@lifeready/core 1.0.1 → 1.0.3

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

@@ -0,0 +1,168 @@
+import { __awaiter } from "tslib";
+import { Inject, Injectable } from '@angular/core';
+import { Idle, DEFAULT_INTERRUPTSOURCES } from '@ng-idle/core';
+import { Keepalive } from '@ng-idle/keepalive';
+import { KeyService } from '../cryptography/key.service';
+import { LrBadArgumentException, LrBadStateException, } from '../_common/exceptions';
+import { LR_CONFIG } from '../life-ready.config';
+import { HttpClient } from '@angular/common/http';
+import { Config } from './idle.types';
+import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
+import * as i0 from "@angular/core";
+import * as i1 from "../life-ready.config";
+import * as i2 from "@angular/common/http";
+import * as i3 from "@ng-idle/core";
+import * as i4 from "@ng-idle/keepalive";
+import * as i5 from "../cryptography/key.service";
+import * as i6 from "@aws-amplify/auth/lib-esm/Auth";
+export class IdleService {
+    constructor(config, http, idle, keepalive, keyService, auth) {
+        this.config = config;
+        this.http = http;
+        this.idle = idle;
+        this.keepalive = keepalive;
+        this.keyService = keyService;
+        this.auth = auth;
+        this.IDLE_EXPIRY_KEY = 'ng2Idle.main.expiry';
+        this.IDLING_KEY = 'ng2Idle.main.idling';
+        this.initCalled = false;
+    }
+    assertInit() {
+        if (!this.initCalled) {
+            throw new LrBadStateException('Call IdleService.init() first.');
+        }
+    }
+    init(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.initCalled) {
+                throw new LrBadStateException('IdleService.init() can only be called once. IdleService.start() calls init() with default values if init() has not been called yet.');
+            }
+            this.initCalled = true;
+            // Defaults
+            params = Object.assign({ onTimeout: null, onKeepalive: null, idleSec: Config.IDLE, timeoutSec: Config.TIMEOUT, keepAliveIntervalSec: Config.KEEP_ALIVE_INTERVAL }, params);
+            // If timeoutSec == 0 then the onTimeout() callback is never called.
+            if (params.timeoutSec < 0.01) {
+                throw new LrBadArgumentException('Minimum value for IdleService.init({ timeoutSec }) is 0.01');
+            }
+            this.onTimeout = params.onTimeout;
+            this.onKeepalive = params.onKeepalive;
+            // ------------------------------------------------------------------------
+            // Setup Idle
+            // ------------------------------------------------------------------------
+            // sets an idle timeout of 5 seconds, for testing purposes.
+            this.idle.setIdle(params.idleSec);
+            // sets a timeout period of 5 seconds. after 10 seconds of inactivity, the user will be considered timed out.
+            this.idle.setTimeout(params.timeoutSec);
+            // sets the default interrupts, in this case, things like clicks, scrolls, touches to the document
+            this.idle.setInterrupts(DEFAULT_INTERRUPTSOURCES);
+            this.idle.onIdleEnd.subscribe(() => console.log('Idle stopped'));
+            this.idle.onIdleStart.subscribe(() => console.log('Idle started'));
+            this.idle.onTimeout.subscribe(() => __awaiter(this, void 0, void 0, function* () {
+                console.log('Idle timed out');
+                this.reset();
+                yield Promise.resolve(this.onTimeout && this.onTimeout());
+            }));
+            this.idle.onTimeoutWarning.subscribe((countdown) => console.log(`Will timeout in ${countdown} seconds!`));
+            // ------------------------------------------------------------------------
+            // Setup Keepalive
+            // ------------------------------------------------------------------------
+            // Ref: https://github.com/moribvndvs/ng2-idle#readme
+            // ng-idle will instruct @ng-idle/keepalive to ping while the user is active, and stop once
+            // they go idle or time out. When the user resumes activity or the idle state is reset, it will
+            // ping immediately and then resume pinging.
+            this.keepalive.interval(params.keepAliveIntervalSec);
+            console.log(`Keep alive interval set at: ${Config.KEEP_ALIVE_INTERVAL} seconds`);
+            this.keepalive.onPing.subscribe(() => this.onPing());
+            // If the browser tab has been closed for a period longer thant the inactivity
+            // period, then we should logout right from the start.
+            const idleExpiry = localStorage.getItem(this.IDLE_EXPIRY_KEY);
+            if (idleExpiry &&
+                parseInt(idleExpiry, 10) + this.idle.getTimeout() * 1000 < Date.now()) {
+                this.reset();
+                yield Promise.resolve(this.onTimeout && this.onTimeout());
+            }
+        });
+    }
+    keepalivePost() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // currentAuthenticatedUser() refreshes the access token if required.
+            const cognitoUser = yield this.auth.currentAuthenticatedUser();
+            const keepaliveResult = yield this.http
+                .post(`${this.config.authUrl}auth/keepalive/`, null, {
+                withCredentials: true,
+                headers: {
+                    Authorization: `Bearer ${cognitoUser
+                        .getSignInUserSession()
+                        .getAccessToken()
+                        .getJwtToken()}`,
+                },
+            })
+                .toPromise();
+            return {
+                keepaliveResult,
+                expiresAfterSeconds: this.idle.getIdle() +
+                    this.idle.getTimeout() +
+                    this.keepalive.interval(),
+            };
+        });
+    }
+    persistMasterKey(masterKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // The keepalive API call extends the server-side session, the session cookie expiry, refresh key cookie
+            // expiry, and returns the session expiry.
+            // NOTE Use time delta rather than absolute time, since client clock and server clock maybe
+            // out of sync. We can't use the serverTime() functionality because the cookie expiry still
+            // run on local clock.
+            const { expiresAfterSeconds } = yield this.keepalivePost();
+            // Persist the derived passKey
+            yield this.keyService.persistMasterKey(masterKey, expiresAfterSeconds);
+            console.log('setMasterKey() done');
+        });
+    }
+    onPing() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log(`Keep alive triggered at time: ${Date.now()}. Interval set at: ${this.keepalive.interval()} seconds`);
+            // Keepalive API will extend the session expiry.
+            const { expiresAfterSeconds } = yield this.keepalivePost();
+            // Extend the expiry of the persisted key
+            yield this.keyService.setMasterKeyExpiresAfterSeconds(expiresAfterSeconds);
+            yield Promise.resolve(this.onKeepalive && this.onKeepalive());
+        });
+    }
+    start() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.initCalled) {
+                yield this.init();
+            }
+            if (this.idle.isRunning()) {
+                return;
+            }
+            // Ping does not seem to happen right at the start. So we call it explicitly
+            yield this.onPing();
+            this.idle.watch();
+        });
+    }
+    stop() {
+        this.idle.stop();
+        this.reset();
+    }
+    reset() {
+        localStorage.removeItem(this.IDLE_EXPIRY_KEY);
+        localStorage.removeItem(this.IDLING_KEY);
+    }
+}
+IdleService.ɵprov = i0.ɵɵdefineInjectable({ factory: function IdleService_Factory() { return new IdleService(i0.ɵɵinject(i1.LR_CONFIG), i0.ɵɵinject(i2.HttpClient), i0.ɵɵinject(i3.Idle), i0.ɵɵinject(i4.Keepalive), i0.ɵɵinject(i5.KeyService), i0.ɵɵinject(i6.AuthClass)); }, token: IdleService, providedIn: "root" });
+IdleService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+IdleService.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [LR_CONFIG,] }] },
+    { type: HttpClient },
+    { type: Idle },
+    { type: Keepalive },
+    { type: KeyService },
+    { type: AuthClass }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"idle.service.js","sourceRoot":"C:/Projects/newrepo/kc-client/projects/core/src/","sources":["lib/auth/idle.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\r\nimport { Idle, DEFAULT_INTERRUPTSOURCES } from '@ng-idle/core';\r\nimport { Keepalive } from '@ng-idle/keepalive';\r\nimport { KeyService } from '../cryptography/key.service';\r\nimport {\r\n  LrBadArgumentException,\r\n  LrBadStateException,\r\n} from '../_common/exceptions';\r\nimport { LifeReadyConfig, LR_CONFIG } from '../life-ready.config';\r\nimport { HttpClient } from '@angular/common/http';\r\nimport { Config, KeepaliveResult } from './idle.types';\r\nimport { Key } from '../cryptography/cryptography.types';\r\nimport { CognitoUser } from '@aws-amplify/auth';\r\nimport { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';\r\n\r\nexport interface IdleServiceInit {\r\n  // TODO: this should be EventEmitter instead of a callback.\r\n  onTimeout?: (() => any) | (() => Promise<any>) | null;\r\n  onKeepalive?: (() => any) | (() => Promise<any>) | null;\r\n  idleSec?: number;\r\n  timeoutSec?: number;\r\n  keepAliveIntervalSec?: number;\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class IdleService {\r\n  private readonly IDLE_EXPIRY_KEY = 'ng2Idle.main.expiry';\r\n  private readonly IDLING_KEY = 'ng2Idle.main.idling';\r\n\r\n  private initCalled = false;\r\n  private onTimeout: (() => any) | (() => Promise<any>) | null;\r\n  private onKeepalive: (() => any) | (() => Promise<any>) | null;\r\n\r\n  constructor(\r\n    @Inject(LR_CONFIG) private config: LifeReadyConfig,\r\n    private http: HttpClient,\r\n    private idle: Idle,\r\n    private keepalive: Keepalive,\r\n    private keyService: KeyService,\r\n    private auth: AuthClass\r\n  ) {}\r\n\r\n  private assertInit(): void {\r\n    if (!this.initCalled) {\r\n      throw new LrBadStateException('Call IdleService.init() first.');\r\n    }\r\n  }\r\n\r\n  public async init(params?: IdleServiceInit): Promise<void> {\r\n    if (this.initCalled) {\r\n      throw new LrBadStateException(\r\n        'IdleService.init() can only be called once. IdleService.start() calls init() with default values if init() has not been called yet.'\r\n      );\r\n    }\r\n\r\n    this.initCalled = true;\r\n\r\n    // Defaults\r\n    params = {\r\n      onTimeout: null,\r\n      onKeepalive: null,\r\n      idleSec: Config.IDLE,\r\n      timeoutSec: Config.TIMEOUT,\r\n      keepAliveIntervalSec: Config.KEEP_ALIVE_INTERVAL,\r\n      ...params,\r\n    };\r\n\r\n    // If timeoutSec == 0 then the onTimeout() callback is never called.\r\n    if (params.timeoutSec < 0.01) {\r\n      throw new LrBadArgumentException(\r\n        'Minimum value for IdleService.init({ timeoutSec }) is 0.01'\r\n      );\r\n    }\r\n\r\n    this.onTimeout = params.onTimeout;\r\n    this.onKeepalive = params.onKeepalive;\r\n\r\n    // ------------------------------------------------------------------------\r\n    // Setup Idle\r\n    // ------------------------------------------------------------------------\r\n    // sets an idle timeout of 5 seconds, for testing purposes.\r\n    this.idle.setIdle(params.idleSec);\r\n    // sets a timeout period of 5 seconds. after 10 seconds of inactivity, the user will be considered timed out.\r\n    this.idle.setTimeout(params.timeoutSec);\r\n    // sets the default interrupts, in this case, things like clicks, scrolls, touches to the document\r\n    this.idle.setInterrupts(DEFAULT_INTERRUPTSOURCES);\r\n\r\n    this.idle.onIdleEnd.subscribe(() => console.log('Idle stopped'));\r\n    this.idle.onIdleStart.subscribe(() => console.log('Idle started'));\r\n\r\n    this.idle.onTimeout.subscribe(async () => {\r\n      console.log('Idle timed out');\r\n      this.reset();\r\n      await Promise.resolve(this.onTimeout && this.onTimeout());\r\n    });\r\n    this.idle.onTimeoutWarning.subscribe((countdown: any) =>\r\n      console.log(`Will timeout in ${countdown} seconds!`)\r\n    );\r\n\r\n    // ------------------------------------------------------------------------\r\n    // Setup Keepalive\r\n    // ------------------------------------------------------------------------\r\n    // Ref: https://github.com/moribvndvs/ng2-idle#readme\r\n    // ng-idle will instruct @ng-idle/keepalive to ping while the user is active, and stop once\r\n    // they go idle or time out. When the user resumes activity or the idle state is reset, it will\r\n    // ping immediately and then resume pinging.\r\n    this.keepalive.interval(params.keepAliveIntervalSec);\r\n    console.log(\r\n      `Keep alive interval set at: ${Config.KEEP_ALIVE_INTERVAL} seconds`\r\n    );\r\n\r\n    this.keepalive.onPing.subscribe(() => this.onPing());\r\n\r\n    // If the browser tab has been closed for a period longer thant the inactivity\r\n    // period, then we should logout right from the start.\r\n    const idleExpiry = localStorage.getItem(this.IDLE_EXPIRY_KEY);\r\n    if (\r\n      idleExpiry &&\r\n      parseInt(idleExpiry, 10) + this.idle.getTimeout() * 1000 < Date.now()\r\n    ) {\r\n      this.reset();\r\n      await Promise.resolve(this.onTimeout && this.onTimeout());\r\n    }\r\n  }\r\n\r\n  public async keepalivePost(): Promise<{\r\n    expiresAfterSeconds: number;\r\n    keepaliveResult: KeepaliveResult;\r\n  }> {\r\n    // currentAuthenticatedUser() refreshes the access token if required.\r\n    const cognitoUser: CognitoUser = await this.auth.currentAuthenticatedUser();\r\n\r\n    const keepaliveResult = await this.http\r\n      .post<KeepaliveResult>(`${this.config.authUrl}auth/keepalive/`, null, {\r\n        withCredentials: true, // /auth/keepalive/ will be extending the sessions cookie.\r\n        headers: {\r\n          Authorization: `Bearer ${cognitoUser\r\n            .getSignInUserSession()\r\n            .getAccessToken()\r\n            .getJwtToken()}`,\r\n        },\r\n      })\r\n      .toPromise();\r\n\r\n    return {\r\n      keepaliveResult,\r\n      expiresAfterSeconds:\r\n        this.idle.getIdle() +\r\n        this.idle.getTimeout() +\r\n        this.keepalive.interval(),\r\n    };\r\n  }\r\n\r\n  public async persistMasterKey(masterKey: Key): Promise<void> {\r\n    // The keepalive API call extends the server-side session, the session cookie expiry, refresh key cookie\r\n    // expiry, and returns the session expiry.\r\n    // NOTE Use time delta rather than absolute time, since client clock and server clock maybe\r\n    // out of sync. We can't use the serverTime() functionality because the cookie expiry still\r\n    // run on local clock.\r\n    const { expiresAfterSeconds } = await this.keepalivePost();\r\n\r\n    // Persist the derived passKey\r\n    await this.keyService.persistMasterKey(masterKey, expiresAfterSeconds);\r\n\r\n    console.log('setMasterKey() done');\r\n  }\r\n\r\n  private async onPing(): Promise<void> {\r\n    console.log(\r\n      `Keep alive triggered at time: ${Date.now()}. Interval set at: ${this.keepalive.interval()} seconds`\r\n    );\r\n\r\n    // Keepalive API will extend the session expiry.\r\n    const { expiresAfterSeconds } = await this.keepalivePost();\r\n\r\n    // Extend the expiry of the persisted key\r\n    await this.keyService.setMasterKeyExpiresAfterSeconds(expiresAfterSeconds);\r\n\r\n    await Promise.resolve(this.onKeepalive && this.onKeepalive());\r\n  }\r\n\r\n  public async start(): Promise<void> {\r\n    if (!this.initCalled) {\r\n      await this.init();\r\n    }\r\n\r\n    if (this.idle.isRunning()) {\r\n      return;\r\n    }\r\n\r\n    // Ping does not seem to happen right at the start. So we call it explicitly\r\n    await this.onPing();\r\n\r\n    this.idle.watch();\r\n  }\r\n\r\n  public stop(): void {\r\n    this.idle.stop();\r\n    this.reset();\r\n  }\r\n\r\n  private reset() {\r\n    localStorage.removeItem(this.IDLE_EXPIRY_KEY);\r\n    localStorage.removeItem(this.IDLING_KEY);\r\n  }\r\n}\r\n"]}

package/esm2015/lib/auth/idle.types.js

@@ -0,0 +1,7 @@
+export var Config;
+(function (Config) {
+    Config[Config["TIMEOUT"] = 0.01] = "TIMEOUT";
+    Config[Config["IDLE"] = 1200] = "IDLE";
+    Config[Config["KEEP_ALIVE_INTERVAL"] = 60] = "KEEP_ALIVE_INTERVAL";
+})(Config || (Config = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaWRsZS50eXBlcy5qcyIsInNvdXJjZVJvb3QiOiJDOi9Qcm9qZWN0cy9uZXdyZXBvL2tjLWNsaWVudC9wcm9qZWN0cy9jb3JlL3NyYy8iLCJzb3VyY2VzIjpbImxpYi9hdXRoL2lkbGUudHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksTUFJWDtBQUpELFdBQVksTUFBTTtJQUNoQiw0Q0FBYyxDQUFBO0lBQ2Qsc0NBQWMsQ0FBQTtJQUNkLGtFQUE0QixDQUFBO0FBQzlCLENBQUMsRUFKVyxNQUFNLEtBQU4sTUFBTSxRQUlqQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBlbnVtIENvbmZpZyB7XHJcbiAgVElNRU9VVCA9IDAuMDEsIC8vIHNlY29uZHMsIG1pbiB2YWx1ZSAwLjAxLCBhZnRlciBzdGF0ZSBpcyBpZGxlLCB3YWl0IGZvciBUSU1FT1VUIHNlY29uZHMgYmVmb3JlIHRha2luZyBhY3Rpb25cclxuICBJRExFID0gNjAgKiAyMCwgLy8gc2Vjb25kcywgcGVyaW9kIG9mIGluYWN0aXZpdHkgdG8gY29uc2lkZXIgc3RhdGUgYXMgaWRsZVxyXG4gIEtFRVBfQUxJVkVfSU5URVJWQUwgPSA2MCAqIDEsIC8vIHNlY29uZHMsIHRyaWdnZXJlZCBvbiBhIHJlZ3VsYXIgYmFzaXMgd2hpbGUgYWN0aXZlIChpLmUuIHdoaWxlIG5vdCBpZGxpbmcpXHJcbn1cclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgS2VlcGFsaXZlUmVzdWx0IHtcclxuICBzZXNzaW9uOiB7XHJcbiAgICBleHBpcmVzX2FmdGVyX3NlY29uZHM6IG51bWJlcjtcclxuICB9O1xyXG59XHJcbiJdfQ==

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

@@ -0,0 +1,355 @@
+import { __awaiter } from "tslib";
+import { LrApolloService } from '../api/lr-apollo.service';
+import { HttpClient } from '@angular/common/http';
+import { Inject, Injectable } from '@angular/core';
+import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
+import gql from 'graphql-tag';
+import { EncryptionService } from '../cryptography/encryption.service';
+import { KeyGraphService } from '../cryptography/key-graph.service';
+import { KeyService } from '../cryptography/key.service';
+import { LR_CONFIG } from '../life-ready.config';
+import { LrException, LrBadLogicException, } from '../_common/exceptions';
+import { LifeReadyAuthService } from './life-ready-auth.service';
+import { PasswordService } from './password.service';
+import { Slip39Helper } from 'slip39';
+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 "./life-ready-auth.service";
+import * as i6 from "../cryptography/key-factory.service";
+import * as i7 from "../cryptography/key.service";
+import * as i8 from "../cryptography/encryption.service";
+import * as i9 from "../cryptography/key-graph.service";
+import * as i10 from "./password.service";
+export const CreateLbopQuery = gql `
+  mutation CreateLbop($input: CreateLbopInput!) {
+    createLbop(input: $input) {
+      lbop {
+        id
+      }
+    }
+  }
+`;
+export const DeleteLbopQuery = gql `
+  mutation DeleteLbop($input: DeleteLbopInput!) {
+    deleteLbop(input: $input) {
+      id
+    }
+  }
+`;
+export const UpdateLbopQuery = gql `
+  mutation UpdateLbop($input: UpdateLbopInput!) {
+    updateLbop(input: $input) {
+      lbop {
+        id
+      }
+    }
+  }
+`;
+export const LbopQuery = gql `
+  query Lbop($id: LrRelayIdInput!) {
+    lbop(id: $id) {
+      id
+      cipherMeta
+    }
+  }
+`;
+export const LbopsQuery = gql `
+  query Lbops {
+    lbops {
+      edges {
+        node {
+          id
+          cipherMeta
+        }
+      }
+    }
+  }
+`;
+export class LbopService {
+    constructor(config, http, lrApollo, auth, authService, keyFactory, keyService, encryptionService, keyGraph, passwordService) {
+        this.config = config;
+        this.http = http;
+        this.lrApollo = lrApollo;
+        this.auth = auth;
+        this.authService = authService;
+        this.keyFactory = keyFactory;
+        this.keyService = keyService;
+        this.encryptionService = encryptionService;
+        this.keyGraph = keyGraph;
+        this.passwordService = passwordService;
+        this.CLIENT_NONCE_LENGTH = 32;
+        // There are 1024 words (10 bits), so 25 words should give ~256 bits of entropy.
+        this.LBOP_WORDS = 25;
+    }
+    getPartial(lbopString) {
+        return lbopString.split(' ')[0];
+    }
+    remove(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.lrApollo.mutate({
+                mutation: DeleteLbopQuery,
+                variables: {
+                    input: {
+                        id,
+                    },
+                },
+            });
+            return res.deleteLbop.id;
+        });
+    }
+    update({ id, name }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lbop = yield this.get(id);
+            lbop.name = name;
+            const masterKey = yield this.keyService.getCurrentMasterKey();
+            const cipherMeta = yield this.encryptionService.encrypt(masterKey.jwk, lbop);
+            const res = yield this.lrApollo.mutate({
+                mutation: UpdateLbopQuery,
+                variables: {
+                    input: {
+                        id,
+                        cipherMeta: JSON.stringify(cipherMeta),
+                    },
+                },
+            });
+            return res.updateLbop;
+        });
+    }
+    get(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.lrApollo.query({
+                query: LbopQuery,
+                variables: {
+                    id,
+                },
+            });
+            const masterKey = yield this.keyService.getCurrentMasterKey();
+            const plainCipherMeta = yield this.encryptionService.decrypt(masterKey.jwk, JSON.parse(res.lbop.cipherMeta));
+            return Object.assign({ id: res.id }, plainCipherMeta);
+        });
+    }
+    list() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.lrApollo.query({
+                query: LbopsQuery,
+            });
+            const masterKey = yield this.keyService.getCurrentMasterKey();
+            return Promise.all(res.lbops.edges.map((edge) => __awaiter(this, void 0, void 0, function* () {
+                const plainCipherMeta = yield this.encryptionService.decrypt(masterKey.jwk, JSON.parse(edge.node.cipherMeta));
+                return Object.assign({ id: edge.node.id }, plainCipherMeta);
+            })));
+        });
+    }
+    create({ name }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (Slip39Helper.WORD_LIST.length !== 1024) {
+                throw new LrBadLogicException('Slip39Helper.WORD_LIST.length != 1024');
+            }
+            // Get existing to make sure there are not duplicate first words
+            const lbops = yield this.list();
+            // Generate new one
+            let lbopString;
+            while (true) {
+                lbopString = this.keyFactory
+                    .randomChoices(Slip39Helper.WORD_LIST, this.LBOP_WORDS)
+                    .join(' ');
+                const partial = this.getPartial(lbopString);
+                if (!lbops.some((lbop) => lbop.partial === partial)) {
+                    break;
+                }
+            }
+            const lbopKeyParams = yield this.keyFactory.createLbopKeyParams();
+            const lbopKey = (yield this.keyFactory.deriveLbopKey(Object.assign({ password: lbopString }, lbopKeyParams))).jwk;
+            const lbopKeyVerifier = yield this.keyFactory.createSignKey();
+            const wrappedLbopKeyVerifier = yield this.encryptionService.encrypt(lbopKey, lbopKeyVerifier.toJSON(true));
+            // Re-encrypt master key with new key
+            const currentUser = yield this.authService.getUser();
+            const masterKey = yield this.keyGraph.getKey(currentUser.currentUserKey.masterKey.id);
+            const wrappedMasterKey = yield this.encryptionService.encrypt(lbopKey, masterKey.jwk.toJSON(true));
+            const meta = Object.assign(Object.assign({}, (name && { name })), { partial: this.getPartial(lbopString) });
+            const cipherMeta = yield this.encryptionService.encrypt(masterKey.jwk, meta);
+            const res = yield this.lrApollo.mutate({
+                mutation: CreateLbopQuery,
+                variables: {
+                    input: {
+                        cipherMeta: JSON.stringify(cipherMeta),
+                        lbopKeyParams: JSON.stringify(lbopKeyParams),
+                        lbopKeyVerifier: JSON.stringify(lbopKeyVerifier.toJSON(true)),
+                        wrappedLbopKeyVerifier: JSON.stringify(wrappedLbopKeyVerifier),
+                        masterKeyId: currentUser.currentUserKey.masterKey.id,
+                        wrappedMasterKey: JSON.stringify(wrappedMasterKey),
+                    },
+                },
+            });
+            return Object.assign(Object.assign({}, res.createLbop.lbop), { lbopString });
+        });
+    }
+    // --------------------------------------------------------------------------------------------------------------------
+    // --------------------------------------------------------------------------------------------------------------------
+    // Flow below are for password reset via LBOP
+    //
+    // --Potential Failure Point xxx--
+    //
+    // Look for the above and you can test by interrupting at these points.
+    //
+    // The LBOP reset process can be restarted at any point before the call to "set-password/". Once "set-password/" has been
+    // called, we assume the client has a short period of time to change the Idp password to the one they've chosen. The "set-password/"
+    // will set the Idp password to a temporary random password. The user can no longer login using their current password. If the Idp
+    // password change process does not complete or takes longer than the lockout period, the account will not be accessible and a new
+    // LBOP password reset must be carried out.
+    // --------------------------------------------------------------------------------------------------------------------
+    // --------------------------------------------------------------------------------------------------------------------
+    verifyLbops(challengeResult, lbopString) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const clientNonce = this.keyFactory.randomString(this.CLIENT_NONCE_LENGTH);
+            for (const lbop of challengeResult.lbops) {
+                const lbopKey = (yield this.keyFactory.deriveLbopKey(Object.assign({ password: lbopString }, lbop.lbopKeyParams))).jwk;
+                // If decoding successful then it's the correct lbop
+                try {
+                    const lbopKeyVerifier = (yield this.encryptionService.decrypt(lbopKey, lbop.wrappedLbopKeyVerifier));
+                    // Force a bad signature.
+                    // const serverNonce = challengeResult.challenge.serverNonce + "1",
+                    const serverNonce = challengeResult.challenge.serverNonce;
+                    const signedChallenge = yield this.encryptionService.sign(lbopKeyVerifier, {
+                        serverNonce,
+                        clientNonce,
+                    });
+                    return {
+                        lbop,
+                        signedChallenge,
+                        lbopKey,
+                    };
+                }
+                catch (error) {
+                    continue;
+                }
+            }
+            throw new LrException({
+                source: 'LBOP',
+                code: 'INVALID_PASSPHRASE',
+                message: 'Invalid passphrase.',
+            });
+        });
+    }
+    verifyContact(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ret = this.http
+                .post(`${this.config.authUrl}users/lbop-reset/verify-contact/`, params)
+                .toPromise();
+            // --Potential Failure Point 1 --
+            // The contact verifications are throttled. But otherwise harmless.
+            return ret;
+        });
+    }
+    confirmContact(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.http
+                .post(`${this.config.authUrl}cove/respond/`, {
+                claim_id: params.claimId,
+                v_code: params.vCode,
+            })
+                .toPromise();
+            // --Potential Failure Point 2 --
+            // A verified claim for a contact does not prevent new ones from being generated. So it should be fine to just start again.
+        });
+    }
+    verify(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const challengeResult = yield this.http
+                .post(`${this.config.authUrl}users/lbop-reset/get-challenge/`, {
+                claimId: params.claimId,
+                claimToken: params.claimToken,
+            })
+                .toPromise();
+            // --Potential Failure Point 3 --
+            // This does not lock anything. A second call to "get-challenge/" will create a new challenge amd invalidate the first one.
+            const { signedChallenge, lbop, lbopKey } = yield this.verifyLbops(challengeResult, params.lbop);
+            const res = yield this.http
+                .post(`${this.config.authUrl}users/lbop-reset/verify-challenge/`, {
+                lbopId: lbop.lbopId,
+                signedChallenge,
+            })
+                .toPromise();
+            // --Potential Failure Point 4 --
+            // This does not lock anything. So ok to restart.
+            return {
+                lbopId: lbop.lbopId,
+                verifiedToken: res.verifiedToken,
+                masterKeyId: res.masterKeyId,
+                masterKey: yield KFS.asKey(yield this.encryptionService.decrypt(lbopKey, res.wrappedMasterKey)),
+            };
+        });
+    }
+    setPassword(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Generate the new password derived keys
+            const passKeyBundle = yield this.passwordService.createPassKeyBundle(params.newPassword);
+            // Re-encrypt master key with new key
+            const newWrappedMasterKey = yield this.encryptionService.encrypt(passKeyBundle.passKey, params.masterKey.toJSON(true));
+            const result = yield this.http
+                .post(`${this.config.authUrl}users/lbop-reset/set-password/`, {
+                lbopId: params.lbopId,
+                verifiedToken: params.verifiedToken,
+                masterKeyId: params.masterKeyId,
+                newWrappedMasterKey,
+                newPassKey: {
+                    passKeyParams: passKeyBundle.passKeyParams,
+                    passIdpParams: passKeyBundle.passIdpParams,
+                    passIdpVerifierPbk: passKeyBundle.passIdpVerifier.toJSON(),
+                    wrappedPassIdpVerifierPrk: passKeyBundle.wrappedPassIdpVerifierPrk,
+                },
+            })
+                .toPromise();
+            // --Potential Failure Point 5 --
+            // A timed mutex is locked. The Idp password change must occur within a period of time.
+            // If interrupted here, the user can not login with their old password again. They must
+            // start the whole LBOP password reset process again.
+            // This call will go through the LR proxy which is OK since the LR server knows
+            // the temporary password anyway.
+            let user = yield this.auth.signIn(result.username, result.idpPassword, {
+                noProxy: 'true',
+            });
+            if (user.challengeName !== 'NEW_PASSWORD_REQUIRED') {
+                throw new LrException({
+                    message: 'Internal error. Expecting Cognito to have done a password reset.',
+                });
+            }
+            // --Potential Failure Point 6 --
+            // Must restart the LBOP password reset process again.
+            // Set new password on Idp
+            user = yield this.auth.completeNewPassword(user, this.passwordService.getPassIdpString(passKeyBundle.passIdp), {});
+            // --Potential Failure Point 7 --
+            // Must restart the LBOP password reset process again.
+            yield this.auth.signOut();
+            return yield this.http
+                .post(`${this.config.authUrl}users/lbop-reset/complete/`, {
+                lbopId: params.lbopId,
+                setPasswordToken: result.setPasswordToken,
+            })
+                .toPromise();
+        });
+    }
+}
+LbopService.ɵprov = i0.ɵɵdefineInjectable({ factory: function LbopService_Factory() { return new LbopService(i0.ɵɵinject(i1.LR_CONFIG), i0.ɵɵinject(i2.HttpClient), i0.ɵɵinject(i3.LrApolloService), i0.ɵɵinject(i4.AuthClass), i0.ɵɵinject(i5.LifeReadyAuthService), i0.ɵɵinject(i6.KeyFactoryService), i0.ɵɵinject(i7.KeyService), i0.ɵɵinject(i8.EncryptionService), i0.ɵɵinject(i9.KeyGraphService), i0.ɵɵinject(i10.PasswordService)); }, token: LbopService, providedIn: "root" });
+LbopService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+LbopService.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [LR_CONFIG,] }] },
+    { type: HttpClient },
+    { type: LrApolloService },
+    { type: AuthClass },
+    { type: LifeReadyAuthService },
+    { type: KFS },
+    { type: KeyService },
+    { type: EncryptionService },
+    { type: KeyGraphService },
+    { type: PasswordService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lbop.service.js","sourceRoot":"C:/Projects/newrepo/kc-client/projects/core/src/","sources":["lib/auth/lbop.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { LrApolloService } from '../api/lr-apollo.service';\r\nimport { HttpClient } from '@angular/common/http';\r\nimport { Inject, Injectable } from '@angular/core';\r\nimport { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';\r\nimport gql from 'graphql-tag';\r\nimport { JWK } from 'node-jose';\r\nimport { EncryptionService } from '../cryptography/encryption.service';\r\nimport { KeyGraphService } from '../cryptography/key-graph.service';\r\nimport { KeyService } from '../cryptography/key.service';\r\nimport { LifeReadyConfig, LR_CONFIG } from '../life-ready.config';\r\nimport {\r\n  LrException,\r\n  LrErrorCode,\r\n  LrBadLogicException,\r\n} from '../_common/exceptions';\r\nimport { LifeReadyAuthService } from './life-ready-auth.service';\r\nimport { PasswordService } from './password.service';\r\nimport { Slip39Helper } from 'slip39';\r\nimport { KeyFactoryService as KFS } from '../cryptography/key-factory.service';\r\n\r\ninterface SetPasswordApiResult {\r\n  username: string;\r\n  idpPassword: string;\r\n  setPasswordToken: string;\r\n}\r\n\r\nexport interface SetPasswordParams {\r\n  lbopId: string;\r\n  newPassword: string;\r\n  verifiedToken: string;\r\n  masterKeyId: string;\r\n  masterKey: JWK.Key;\r\n}\r\n\r\nexport interface VerifyContactParams {\r\n  email?: string;\r\n  phone?: string;\r\n}\r\n\r\nexport interface VerifyContactResult {\r\n  // The claim_id identifies the Email/SMS confirmation\r\n  claimId: string;\r\n}\r\n\r\nexport interface ConfirmContactParams {\r\n  claimId: string;\r\n  vCode: string;\r\n}\r\n\r\nexport interface ConfirmContactResult {\r\n  // The token to prove the client had the correct confirmation code.\r\n  token: string;\r\n}\r\n\r\nexport interface VerifyParams {\r\n  claimId: string;\r\n  claimToken: string;\r\n  lbop: string;\r\n}\r\n\r\nexport interface VerifyResult {\r\n  // userId: string;\r\n  lbopId: string;\r\n  verifiedToken: string;\r\n  masterKeyId: string;\r\n  masterKey: JWK.Key;\r\n}\r\n\r\nexport interface ChallengeResult {\r\n  challenge: any;\r\n  lbops: any;\r\n  // userId: string;\r\n}\r\n\r\nexport interface Lbop {\r\n  id: string;\r\n  partial?: string;\r\n  name?: string;\r\n  lbopString?: string;\r\n}\r\n\r\nexport interface CreateLbopParams {\r\n  name?: string;\r\n}\r\n\r\ninterface CreateLbopQuery {\r\n  createLbop: {\r\n    lbop: Lbop;\r\n  };\r\n}\r\n\r\nexport const CreateLbopQuery = gql`\r\n  mutation CreateLbop($input: CreateLbopInput!) {\r\n    createLbop(input: $input) {\r\n      lbop {\r\n        id\r\n      }\r\n    }\r\n  }\r\n`;\r\n\r\ninterface DeleteLbopQuery {\r\n  deleteLbop: Lbop;\r\n}\r\n\r\nexport const DeleteLbopQuery = gql`\r\n  mutation DeleteLbop($input: DeleteLbopInput!) {\r\n    deleteLbop(input: $input) {\r\n      id\r\n    }\r\n  }\r\n`;\r\n\r\nexport interface UpdateLbopParams {\r\n  id: string;\r\n  name: string;\r\n}\r\n\r\ninterface UpdateLbopQuery {\r\n  updateLbop: Lbop;\r\n}\r\n\r\nexport const UpdateLbopQuery = gql`\r\n  mutation UpdateLbop($input: UpdateLbopInput!) {\r\n    updateLbop(input: $input) {\r\n      lbop {\r\n        id\r\n      }\r\n    }\r\n  }\r\n`;\r\n\r\nexport const LbopQuery = gql`\r\n  query Lbop($id: LrRelayIdInput!) {\r\n    lbop(id: $id) {\r\n      id\r\n      cipherMeta\r\n    }\r\n  }\r\n`;\r\n\r\ninterface LbopsQuery {\r\n  lbops: any;\r\n}\r\n\r\nexport const LbopsQuery = gql`\r\n  query Lbops {\r\n    lbops {\r\n      edges {\r\n        node {\r\n          id\r\n          cipherMeta\r\n        }\r\n      }\r\n    }\r\n  }\r\n`;\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class LbopService {\r\n  private readonly CLIENT_NONCE_LENGTH = 32;\r\n  // There are 1024 words (10 bits), so 25 words should give ~256 bits of entropy.\r\n  private readonly LBOP_WORDS = 25;\r\n\r\n  constructor(\r\n    @Inject(LR_CONFIG) private config: LifeReadyConfig,\r\n    private http: HttpClient,\r\n    private lrApollo: LrApolloService,\r\n    private auth: AuthClass,\r\n    private authService: LifeReadyAuthService,\r\n    private keyFactory: KFS,\r\n    private keyService: KeyService,\r\n    private encryptionService: EncryptionService,\r\n    private keyGraph: KeyGraphService,\r\n    private passwordService: PasswordService\r\n  ) {}\r\n\r\n  private getPartial(lbopString: string): string {\r\n    return lbopString.split(' ')[0];\r\n  }\r\n\r\n  public async remove(id: string): Promise<string> {\r\n    const res = await this.lrApollo.mutate<any>({\r\n      mutation: DeleteLbopQuery,\r\n      variables: {\r\n        input: {\r\n          id,\r\n        },\r\n      },\r\n    });\r\n\r\n    return res.deleteLbop.id;\r\n  }\r\n\r\n  public async update({ id, name }: UpdateLbopParams): Promise<Lbop> {\r\n    const lbop = await this.get(id);\r\n    lbop.name = name;\r\n\r\n    const masterKey = await this.keyService.getCurrentMasterKey();\r\n    const cipherMeta = await this.encryptionService.encrypt(\r\n      masterKey.jwk,\r\n      lbop\r\n    );\r\n\r\n    const res = await this.lrApollo.mutate<UpdateLbopQuery>({\r\n      mutation: UpdateLbopQuery,\r\n      variables: {\r\n        input: {\r\n          id,\r\n          cipherMeta: JSON.stringify(cipherMeta),\r\n        },\r\n      },\r\n    });\r\n\r\n    return res.updateLbop;\r\n  }\r\n\r\n  public async get(id: string): Promise<Lbop> {\r\n    const res = await this.lrApollo.query<any>({\r\n      query: LbopQuery,\r\n      variables: {\r\n        id,\r\n      },\r\n    });\r\n\r\n    const masterKey = await this.keyService.getCurrentMasterKey();\r\n\r\n    const plainCipherMeta = await this.encryptionService.decrypt(\r\n      masterKey.jwk,\r\n      JSON.parse(res.lbop.cipherMeta)\r\n    );\r\n\r\n    return {\r\n      id: res.id,\r\n      ...plainCipherMeta,\r\n    };\r\n  }\r\n\r\n  public async list(): Promise<Lbop[]> {\r\n    const res = await this.lrApollo.query<LbopsQuery>({\r\n      query: LbopsQuery,\r\n    });\r\n\r\n    const masterKey = await this.keyService.getCurrentMasterKey();\r\n\r\n    return Promise.all(\r\n      res.lbops.edges.map(async (edge) => {\r\n        const plainCipherMeta = await this.encryptionService.decrypt(\r\n          masterKey.jwk,\r\n          JSON.parse(edge.node.cipherMeta)\r\n        );\r\n        return {\r\n          id: edge.node.id,\r\n          ...plainCipherMeta,\r\n        };\r\n      })\r\n    );\r\n  }\r\n\r\n  public async create({ name }: CreateLbopParams): Promise<Lbop> {\r\n    if (Slip39Helper.WORD_LIST.length !== 1024) {\r\n      throw new LrBadLogicException('Slip39Helper.WORD_LIST.length != 1024');\r\n    }\r\n\r\n    // Get existing to make sure there are not duplicate first words\r\n    const lbops = await this.list();\r\n\r\n    // Generate new one\r\n    let lbopString;\r\n    while (true) {\r\n      lbopString = this.keyFactory\r\n        .randomChoices(Slip39Helper.WORD_LIST, this.LBOP_WORDS)\r\n        .join(' ');\r\n      const partial = this.getPartial(lbopString);\r\n\r\n      if (!lbops.some((lbop) => lbop.partial === partial)) {\r\n        break;\r\n      }\r\n    }\r\n\r\n    const lbopKeyParams = await this.keyFactory.createLbopKeyParams();\r\n    const lbopKey = (\r\n      await this.keyFactory.deriveLbopKey({\r\n        password: lbopString,\r\n        ...lbopKeyParams,\r\n      })\r\n    ).jwk;\r\n\r\n    const lbopKeyVerifier = await this.keyFactory.createSignKey();\r\n    const wrappedLbopKeyVerifier = await this.encryptionService.encrypt(\r\n      lbopKey,\r\n      lbopKeyVerifier.toJSON(true)\r\n    );\r\n\r\n    // Re-encrypt master key with new key\r\n    const currentUser = await this.authService.getUser();\r\n    const masterKey = await this.keyGraph.getKey(\r\n      currentUser.currentUserKey.masterKey.id\r\n    );\r\n    const wrappedMasterKey = await this.encryptionService.encrypt(\r\n      lbopKey,\r\n      masterKey.jwk.toJSON(true)\r\n    );\r\n\r\n    const meta = {\r\n      ...(name && { name }),\r\n      partial: this.getPartial(lbopString),\r\n    };\r\n    const cipherMeta = await this.encryptionService.encrypt(\r\n      masterKey.jwk,\r\n      meta\r\n    );\r\n\r\n    const res = await this.lrApollo.mutate<CreateLbopQuery>({\r\n      mutation: CreateLbopQuery,\r\n      variables: {\r\n        input: {\r\n          cipherMeta: JSON.stringify(cipherMeta),\r\n          lbopKeyParams: JSON.stringify(lbopKeyParams),\r\n          lbopKeyVerifier: JSON.stringify(lbopKeyVerifier.toJSON(true)),\r\n          wrappedLbopKeyVerifier: JSON.stringify(wrappedLbopKeyVerifier),\r\n          masterKeyId: currentUser.currentUserKey.masterKey.id,\r\n          wrappedMasterKey: JSON.stringify(wrappedMasterKey),\r\n        },\r\n      },\r\n    });\r\n\r\n    return {\r\n      ...res.createLbop.lbop,\r\n      lbopString,\r\n    };\r\n  }\r\n\r\n  // --------------------------------------------------------------------------------------------------------------------\r\n  // --------------------------------------------------------------------------------------------------------------------\r\n  // Flow below are for password reset via LBOP\r\n  //\r\n  // --Potential Failure Point xxx--\r\n  //\r\n  // Look for the above and you can test by interrupting at these points.\r\n  //\r\n  // The LBOP reset process can be restarted at any point before the call to \"set-password/\". Once \"set-password/\" has been\r\n  // called, we assume the client has a short period of time to change the Idp password to the one they've chosen. The \"set-password/\"\r\n  // will set the Idp password to a temporary random password. The user can no longer login using their current password. If the Idp\r\n  // password change process does not complete or takes longer than the lockout period, the account will not be accessible and a new\r\n  // LBOP password reset must be carried out.\r\n  // --------------------------------------------------------------------------------------------------------------------\r\n  // --------------------------------------------------------------------------------------------------------------------\r\n  private async verifyLbops(\r\n    challengeResult: ChallengeResult,\r\n    lbopString: string\r\n  ): Promise<{ lbop: any; signedChallenge: any; lbopKey: JWK.Key }> {\r\n    const clientNonce = this.keyFactory.randomString(this.CLIENT_NONCE_LENGTH);\r\n\r\n    for (const lbop of challengeResult.lbops) {\r\n      const lbopKey = (\r\n        await this.keyFactory.deriveLbopKey({\r\n          password: lbopString,\r\n          ...lbop.lbopKeyParams,\r\n        })\r\n      ).jwk;\r\n\r\n      // If decoding successful then it's the correct lbop\r\n      try {\r\n        const lbopKeyVerifier = (await this.encryptionService.decrypt(\r\n          lbopKey,\r\n          lbop.wrappedLbopKeyVerifier\r\n        )) as any;\r\n\r\n        // Force a bad signature.\r\n        // const serverNonce = challengeResult.challenge.serverNonce + \"1\",\r\n\r\n        const serverNonce = challengeResult.challenge.serverNonce;\r\n\r\n        const signedChallenge = await this.encryptionService.sign(\r\n          lbopKeyVerifier,\r\n          {\r\n            serverNonce,\r\n            clientNonce,\r\n          }\r\n        );\r\n\r\n        return {\r\n          lbop,\r\n          signedChallenge,\r\n          lbopKey,\r\n        };\r\n      } catch (error) {\r\n        continue;\r\n      }\r\n    }\r\n    throw new LrException({\r\n      source: 'LBOP',\r\n      code: 'INVALID_PASSPHRASE',\r\n      message: 'Invalid passphrase.',\r\n    });\r\n  }\r\n\r\n  public async verifyContact(\r\n    params: VerifyContactParams\r\n  ): Promise<VerifyContactResult> {\r\n    const ret = this.http\r\n      .post<VerifyContactResult>(\r\n        `${this.config.authUrl}users/lbop-reset/verify-contact/`,\r\n        params\r\n      )\r\n      .toPromise();\r\n\r\n    // --Potential Failure Point 1 --\r\n    // The contact verifications are throttled. But otherwise harmless.\r\n\r\n    return ret;\r\n  }\r\n\r\n  public async confirmContact(\r\n    params: ConfirmContactParams\r\n  ): Promise<ConfirmContactResult> {\r\n    return this.http\r\n      .post<ConfirmContactResult>(`${this.config.authUrl}cove/respond/`, {\r\n        claim_id: params.claimId,\r\n        v_code: params.vCode,\r\n      })\r\n      .toPromise();\r\n\r\n    // --Potential Failure Point 2 --\r\n    // A verified claim for a contact does not prevent new ones from being generated. So it should be fine to just start again.\r\n  }\r\n\r\n  public async verify(params: VerifyParams): Promise<VerifyResult> {\r\n    const challengeResult = await this.http\r\n      .post<ChallengeResult>(\r\n        `${this.config.authUrl}users/lbop-reset/get-challenge/`,\r\n        {\r\n          claimId: params.claimId,\r\n          claimToken: params.claimToken,\r\n        }\r\n      )\r\n      .toPromise();\r\n\r\n    // --Potential Failure Point 3 --\r\n    // This does not lock anything. A second call to \"get-challenge/\" will create a new challenge amd invalidate the first one.\r\n    const { signedChallenge, lbop, lbopKey } = await this.verifyLbops(\r\n      challengeResult,\r\n      params.lbop\r\n    );\r\n\r\n    const res = await this.http\r\n      .post<any>(`${this.config.authUrl}users/lbop-reset/verify-challenge/`, {\r\n        lbopId: lbop.lbopId,\r\n        signedChallenge,\r\n      })\r\n      .toPromise();\r\n\r\n    // --Potential Failure Point 4 --\r\n    // This does not lock anything. So ok to restart.\r\n\r\n    return {\r\n      lbopId: lbop.lbopId,\r\n      verifiedToken: res.verifiedToken,\r\n      masterKeyId: res.masterKeyId,\r\n      masterKey: await KFS.asKey(\r\n        await this.encryptionService.decrypt(lbopKey, res.wrappedMasterKey)\r\n      ),\r\n    };\r\n  }\r\n\r\n  public async setPassword(params: SetPasswordParams): Promise<any> {\r\n    // Generate the new password derived keys\r\n    const passKeyBundle = await this.passwordService.createPassKeyBundle(\r\n      params.newPassword\r\n    );\r\n\r\n    // Re-encrypt master key with new key\r\n    const newWrappedMasterKey = await this.encryptionService.encrypt(\r\n      passKeyBundle.passKey,\r\n      params.masterKey.toJSON(true)\r\n    );\r\n\r\n    const result = await this.http\r\n      .post<SetPasswordApiResult>(\r\n        `${this.config.authUrl}users/lbop-reset/set-password/`,\r\n        {\r\n          lbopId: params.lbopId,\r\n          verifiedToken: params.verifiedToken,\r\n          masterKeyId: params.masterKeyId,\r\n          newWrappedMasterKey,\r\n          newPassKey: {\r\n            passKeyParams: passKeyBundle.passKeyParams,\r\n            passIdpParams: passKeyBundle.passIdpParams,\r\n            passIdpVerifierPbk: passKeyBundle.passIdpVerifier.toJSON(),\r\n            wrappedPassIdpVerifierPrk: passKeyBundle.wrappedPassIdpVerifierPrk,\r\n          },\r\n        }\r\n      )\r\n      .toPromise();\r\n\r\n    // --Potential Failure Point 5 --\r\n    // A timed mutex is locked. The Idp password change must occur within a period of time.\r\n    // If interrupted here, the user can not login with their old password again. They must\r\n    // start the whole LBOP password reset process again.\r\n\r\n    // This call will go through the LR proxy which is OK since the LR server knows\r\n    // the temporary password anyway.\r\n    let user = await this.auth.signIn(result.username, result.idpPassword, {\r\n      noProxy: 'true',\r\n    });\r\n\r\n    if (user.challengeName !== 'NEW_PASSWORD_REQUIRED') {\r\n      throw new LrException({\r\n        message:\r\n          'Internal error. Expecting Cognito to have done a password reset.',\r\n      });\r\n    }\r\n\r\n    // --Potential Failure Point 6 --\r\n    // Must restart the LBOP password reset process again.\r\n\r\n    // Set new password on Idp\r\n    user = await this.auth.completeNewPassword(\r\n      user,\r\n      this.passwordService.getPassIdpString(passKeyBundle.passIdp),\r\n      {}\r\n    );\r\n\r\n    // --Potential Failure Point 7 --\r\n    // Must restart the LBOP password reset process again.\r\n\r\n    await this.auth.signOut();\r\n\r\n    return await this.http\r\n      .post<any>(`${this.config.authUrl}users/lbop-reset/complete/`, {\r\n        lbopId: params.lbopId,\r\n        setPasswordToken: result.setPasswordToken,\r\n      })\r\n      .toPromise();\r\n  }\r\n}\r\n"]}