@lifeready/core 0.6.0-beta.1

package/esm2015/lib/cryptography/key.service.js

@@ -0,0 +1,124 @@
+import { __awaiter } from "tslib";
+import { Inject, Injectable } from '@angular/core';
+import { LrNotFoundException } from '../_common/exceptions';
+import { PersistService } from '../api/persist.service';
+import { KeyFactoryService as KFS } from './key-factory.service';
+import { LR_CONFIG } from '../life-ready.config';
+import * as i0 from "@angular/core";
+import * as i1 from "../life-ready.config";
+import * as i2 from "../api/persist.service";
+export class UserKeys {
+}
+export class KeyService {
+    constructor(config, persistService) {
+        this.config = config;
+        this.persistService = persistService;
+        this.STORE_MASTER_KEY = 'masterKey';
+        // AZ: This can't be change easily. It's basically a PassK or PassIdp rotation.
+        // todo: we should eventually increase this periodically to match with Moore's law.
+        // The iterations for each key are kept by the server as well but we assume the value
+        // from the server is not trustworthy, so need to have minimum thresholds here.
+        // If creating new keys, these minimum are used.
+        this.MIN_PASS_IDP_PBKDF_ITER = 100000;
+        this.MIN_PASS_KEY_PBKDF_ITER = 100000;
+        this.MIN_LBOP_KEY_PBKDF_ITER = 100000;
+        // These are used as the default values. They must be larger than the minimum values.
+        this.DEFAULT_PASS_IDP_PBKDF_ITER = this.MIN_PASS_IDP_PBKDF_ITER;
+        this.DEFAULT_PASS_KEY_PBKDF_ITER = this.MIN_PASS_KEY_PBKDF_ITER;
+        this.DEFAULT_LBOP_KEY_PBKDF_ITER = this.MIN_LBOP_KEY_PBKDF_ITER;
+        this.resetKeys();
+    }
+    resetKeys() {
+        this.keys = null;
+        this.masterKey = null;
+    }
+    purgeKeys() {
+        this.resetKeys();
+        this.persistService.clear();
+    }
+    populateKeys(keys) {
+        this.keys = keys;
+    }
+    getCurrentPassKey() {
+        return this.keys.passKey;
+    }
+    getCurrentMasterKey() {
+        return this.keys.masterKey;
+    }
+    getCurrentRootKey() {
+        return this.keys.rootKey;
+    }
+    getCurrentPxk() {
+        return this.keys.pxk;
+    }
+    getCurrentSigPxk() {
+        return this.keys.sigPxk;
+    }
+    expiresAfter(seconds) {
+        return new Date(Date.now() + 1000 * seconds);
+    }
+    persistMasterKey(masterKey, expiresAfterSeconds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const storedKey = {
+                id: masterKey.id,
+                jwk: masterKey.jwk.toJSON(true),
+            };
+            this.masterKey = masterKey;
+            // Save in an expirable cookie.
+            yield this.persistService.set({
+                name: this.STORE_MASTER_KEY,
+                value: storedKey,
+                expiry: this.expiresAfter(expiresAfterSeconds),
+                serverSession: !this.config.disableSessionEncryptionKey,
+            });
+        });
+    }
+    setMasterKeyExpiresAfterSeconds(seconds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const storedKey = yield this.persistService.get(this.STORE_MASTER_KEY);
+            if (storedKey == null) {
+                throw new LrNotFoundException(`Can not find masterKey in persisted storage using name: ${this.STORE_MASTER_KEY}`);
+            }
+            yield this.persistService.set({
+                name: this.STORE_MASTER_KEY,
+                value: storedKey,
+                expiry: this.expiresAfter(seconds),
+                serverSession: !this.config.disableSessionEncryptionKey,
+            });
+        });
+    }
+    // There's little benefit in using WebCrypto's none-extractable keys because if there
+    // is an XSS attack, then the attacker has control over the js that downloads the keys. The
+    // attacker can modify the code to import the keys as extractable. So none-extractable keys
+    // are only useful if they are already persisted and the user cannot download any more keys,
+    // which is not feasible.
+    // So storing the PassKey in localstorage for now, at least till we know what the usage
+    // pattern is, i.e. how often do we need to use the RootK, MaterK, and PassK.
+    loadMasterKey(masterKeyId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.masterKey) {
+                const storedKey = yield this.persistService.get(this.STORE_MASTER_KEY);
+                if (!storedKey) {
+                    throw new LrNotFoundException('Could not find masterKey in persisted storage');
+                }
+                if (storedKey.id !== masterKeyId) {
+                    throw new LrNotFoundException(`masterKeyId ${storedKey.id} in persisted storage does not match the one requested ${masterKeyId}`);
+                }
+                storedKey.jwk = yield KFS.asKey(storedKey.jwk);
+                this.masterKey = storedKey;
+            }
+            return this.masterKey;
+        });
+    }
+}
+KeyService.ɵprov = i0.ɵɵdefineInjectable({ factory: function KeyService_Factory() { return new KeyService(i0.ɵɵinject(i1.LR_CONFIG), i0.ɵɵinject(i2.PersistService)); }, token: KeyService, providedIn: "root" });
+KeyService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+KeyService.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [LR_CONFIG,] }] },
+    { type: PersistService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"key.service.js","sourceRoot":"C:/Projects/test/projects/core/src/","sources":["lib/cryptography/key.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\r\nimport { Key, PassKey } from './cryptography.types';\r\nimport { LrNotFoundException } from '../_common/exceptions';\r\nimport { PersistService } from '../api/persist.service';\r\nimport { KeyFactoryService as KFS } from './key-factory.service';\r\nimport { LifeReadyConfig, LR_CONFIG } from '../life-ready.config';\r\n\r\nexport class UserKeys {\r\n  passKey: PassKey;\r\n  masterKey: Key;\r\n  rootKey?: Key;\r\n  pxk?: Key;\r\n  sigPxk?: Key;\r\n}\r\n\r\ninterface StoredPassKey {\r\n  id: string;\r\n  jwk: object;\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class KeyService {\r\n  private readonly STORE_MASTER_KEY = 'masterKey';\r\n  // variables\r\n  private keys: UserKeys;\r\n  private masterKey: Key;\r\n\r\n  // AZ: This can't be change easily. It's basically a PassK or PassIdp rotation.\r\n  // todo: we should eventually increase this periodically to match with Moore's law.\r\n  // The iterations for each key are kept by the server as well but we assume the value\r\n  // from the server is not trustworthy, so need to have minimum thresholds here.\r\n  // If creating new keys, these minimum are used.\r\n  public readonly MIN_PASS_IDP_PBKDF_ITER = 100000;\r\n  public readonly MIN_PASS_KEY_PBKDF_ITER = 100000;\r\n  public readonly MIN_LBOP_KEY_PBKDF_ITER = 100000;\r\n\r\n  // These are used as the default values. They must be larger than the minimum values.\r\n  public readonly DEFAULT_PASS_IDP_PBKDF_ITER = this.MIN_PASS_IDP_PBKDF_ITER;\r\n  public readonly DEFAULT_PASS_KEY_PBKDF_ITER = this.MIN_PASS_KEY_PBKDF_ITER;\r\n  public readonly DEFAULT_LBOP_KEY_PBKDF_ITER = this.MIN_LBOP_KEY_PBKDF_ITER;\r\n\r\n  constructor(\r\n    @Inject(LR_CONFIG) private config: LifeReadyConfig,\r\n    private persistService: PersistService\r\n  ) {\r\n    this.resetKeys();\r\n  }\r\n\r\n  resetKeys() {\r\n    this.keys = null;\r\n    this.masterKey = null;\r\n  }\r\n\r\n  purgeKeys() {\r\n    this.resetKeys();\r\n    this.persistService.clear();\r\n  }\r\n\r\n  populateKeys(keys: UserKeys) {\r\n    this.keys = keys;\r\n  }\r\n\r\n  public getCurrentPassKey(): Key {\r\n    return this.keys.passKey;\r\n  }\r\n\r\n  public getCurrentMasterKey(): Key {\r\n    return this.keys.masterKey;\r\n  }\r\n\r\n  public getCurrentRootKey(): Key {\r\n    return this.keys.rootKey;\r\n  }\r\n\r\n  public getCurrentPxk(): Key {\r\n    return this.keys.pxk;\r\n  }\r\n\r\n  public getCurrentSigPxk(): Key {\r\n    return this.keys.sigPxk;\r\n  }\r\n\r\n  private expiresAfter(seconds: number): Date {\r\n    return new Date(Date.now() + 1000 * seconds);\r\n  }\r\n\r\n  async persistMasterKey(\r\n    masterKey: Key,\r\n    expiresAfterSeconds: number\r\n  ): Promise<void> {\r\n    const storedKey = {\r\n      id: masterKey.id,\r\n      jwk: masterKey.jwk.toJSON(true),\r\n    };\r\n\r\n    this.masterKey = masterKey;\r\n\r\n    // Save in an expirable cookie.\r\n    await this.persistService.set({\r\n      name: this.STORE_MASTER_KEY,\r\n      value: storedKey,\r\n      expiry: this.expiresAfter(expiresAfterSeconds),\r\n      serverSession: !this.config.disableSessionEncryptionKey,\r\n    });\r\n  }\r\n\r\n  async setMasterKeyExpiresAfterSeconds(seconds: number): Promise<void> {\r\n    const storedKey = await this.persistService.get(this.STORE_MASTER_KEY);\r\n    if (storedKey == null) {\r\n      throw new LrNotFoundException(\r\n        `Can not find masterKey in persisted storage using name: ${this.STORE_MASTER_KEY}`\r\n      );\r\n    }\r\n    await this.persistService.set({\r\n      name: this.STORE_MASTER_KEY,\r\n      value: storedKey,\r\n      expiry: this.expiresAfter(seconds),\r\n      serverSession: !this.config.disableSessionEncryptionKey,\r\n    });\r\n  }\r\n\r\n  // There's little benefit in using WebCrypto's none-extractable keys because if there\r\n  // is an XSS attack, then the attacker has control over the js that downloads the keys. The\r\n  // attacker can modify the code to import the keys as extractable. So none-extractable keys\r\n  // are only useful if they are already persisted and the user cannot download any more keys,\r\n  // which is not feasible.\r\n  // So storing the PassKey in localstorage for now, at least till we know what the usage\r\n  // pattern is, i.e. how often do we need to use the RootK, MaterK, and PassK.\r\n  async loadMasterKey(masterKeyId: string): Promise<Key> {\r\n    if (!this.masterKey) {\r\n      const storedKey = await this.persistService.get(this.STORE_MASTER_KEY);\r\n\r\n      if (!storedKey) {\r\n        throw new LrNotFoundException(\r\n          'Could not find masterKey in persisted storage'\r\n        );\r\n      }\r\n\r\n      if (storedKey.id !== masterKeyId) {\r\n        throw new LrNotFoundException(\r\n          `masterKeyId ${storedKey.id} in persisted storage does not match the one requested ${masterKeyId}`\r\n        );\r\n      }\r\n\r\n      storedKey.jwk = await KFS.asKey(storedKey.jwk);\r\n\r\n      this.masterKey = storedKey;\r\n    }\r\n\r\n    return this.masterKey;\r\n  }\r\n}\r\n"]}

package/esm2015/lib/cryptography/slip39.service.js

@@ -0,0 +1,169 @@
+import { __awaiter } from "tslib";
+import { Injectable } from '@angular/core';
+import { Slip39, Slip39Helper } from 'slip39';
+import * as i0 from "@angular/core";
+export class SecretShare {
+    constructor(assembly = 0, subAssembly = 0, mnemonics = '') {
+        this.assembly = assembly;
+        this.subAssembly = subAssembly;
+        this.mnemonics = mnemonics;
+    }
+}
+export class SubAssembly {
+    constructor(index, threshold = 0, size = 0) {
+        this.index = index;
+        this.threshold = threshold;
+        this.size = size;
+        this.clearShares();
+    }
+    clearShares() {
+        this.shares = Array();
+    }
+    addShare(share) {
+        this.shares.push(share);
+    }
+}
+export class Assembly {
+    constructor(threshold = 0) {
+        this.threshold = threshold;
+        this.clearSubAssemblies();
+    }
+    size() {
+        return this.subAssemblies.length;
+    }
+    clearSubAssemblies() {
+        this.subAssemblies = new Array();
+    }
+    addSubAssembly(subAssembly) {
+        this.subAssemblies.push(subAssembly);
+    }
+}
+export class SubQuorum {
+    constructor(subAssemblyIndex) {
+        this.subAssemblyIndex = subAssemblyIndex;
+        this.clearShares();
+    }
+    clearShares() {
+        this.shares = new Array();
+    }
+    addShare(share) {
+        this.shares.push(share);
+    }
+}
+export class Quorum {
+    constructor() {
+        this.clearSubQuora();
+    }
+    clearSubQuora() {
+        this.subQuora = new Array();
+    }
+    addSubQuorum(subQuorum) {
+        this.subQuora.push(subQuorum);
+    }
+    serialiseShares() {
+        let shares = [];
+        this.subQuora.forEach((subQuorum) => {
+            shares = shares.concat(subQuorum.shares);
+        });
+        return shares;
+    }
+}
+export class Slip39Service {
+    constructor() { }
+    generateShares(secret, passphrase, assembly) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Hex-encode secret.
+            let ems = btoa(secret);
+            ems = Slip39Helper.slip39EncodeHex(ems);
+            // Construct group specifications
+            const groups = [];
+            for (const sa of assembly.subAssemblies) {
+                groups.push([sa.threshold, sa.size]);
+            }
+            // Split!
+            const slip = yield Slip39.fromArray(ems, {
+                passphrase,
+                threshold: assembly.threshold,
+                groups,
+                title: '',
+            });
+            // Extract shares
+            assembly.subAssemblies.forEach((sa, isa) => {
+                // Remove any existing shares
+                sa.clearShares();
+                for (let im = 0; im < sa.size; im++) {
+                    // Construct the path to the share, formatted as "r/<subassembly index>/<member index>"
+                    // with <subassembly index> and <member index> being two-digit, zero-padded integers.
+                    const path = 'r/' +
+                        isa.toString().padStart(2, '0') +
+                        '/' +
+                        im.toString().padStart(2, '0');
+                    const mnemonics = slip.fromPath(path).mnemonics[0];
+                    const share = new SecretShare(isa, im, mnemonics);
+                    sa.addShare(share);
+                }
+            });
+        });
+    }
+    // Remove all redundant shares. i.e. keep only enough members and groups to satisfy the thresholds.
+    minimalSet(mnemonics) {
+        // Decode the mnemonics and sort then into groups.
+        let groupThresh = null;
+        const groups = new Map();
+        for (const mnemonic of mnemonics) {
+            const decoded = Slip39Helper.decodeMnemonic(mnemonic);
+            if (groupThresh && groupThresh !== decoded.groupThreshold) {
+                throw new Error('groupThreshold is different in mnemonics');
+            }
+            groupThresh = decoded.groupThreshold;
+            // Note that Slip39.recoverSecret() will do all the error checking again. So it's not critical
+            // that we error check here. So we just optimistically assume it's all good.
+            let g = groups.get(decoded.groupIndex);
+            if (g == null) {
+                g = {
+                    memberThreshold: decoded.memberThreshold,
+                    members: [],
+                };
+                groups.set(decoded.groupIndex, g);
+            }
+            g.members.push({
+                mnemonic,
+                decoded,
+            });
+        }
+        // Keep the minimum set of groups that meet threshold.
+        const mnemonicsMinSet = [];
+        let groupCount = 0;
+        for (const g of groups.values()) {
+            // Keep only groups that meet threshold
+            if (g.members.length < g.memberThreshold) {
+                continue;
+            }
+            // Keep minimum number of approvals needed for group
+            g.members.slice(0, g.memberThreshold).forEach((member) => {
+                mnemonicsMinSet.push(member.mnemonic);
+            });
+            ++groupCount;
+            if (groupCount >= groupThresh) {
+                break;
+            }
+        }
+        return mnemonicsMinSet;
+    }
+    recoverSecret(shares, passphrase) {
+        return __awaiter(this, void 0, void 0, function* () {
+            shares = this.minimalSet(shares);
+            const recovered = yield Slip39.recoverSecret(shares, passphrase);
+            const secret = Slip39Helper.slip39DecodeHex(recovered);
+            return atob(secret);
+        });
+    }
+}
+Slip39Service.ɵprov = i0.ɵɵdefineInjectable({ factory: function Slip39Service_Factory() { return new Slip39Service(); }, token: Slip39Service, providedIn: "root" });
+Slip39Service.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+Slip39Service.ctorParameters = () => [];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slip39.service.js","sourceRoot":"C:/Projects/test/projects/core/src/","sources":["lib/cryptography/slip39.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { Slip39, Slip39Helper } from 'slip39';\r\n\r\nexport class SecretShare {\r\n  constructor(\r\n    public assembly: number = 0,\r\n    public subAssembly: number = 0,\r\n    public mnemonics: string = ''\r\n  ) {}\r\n}\r\n\r\nexport class SubAssembly {\r\n  constructor(\r\n    public index: number,\r\n    public threshold: number = 0,\r\n    public size: number = 0\r\n  ) {\r\n    this.clearShares();\r\n  }\r\n\r\n  shares: SecretShare[];\r\n\r\n  public clearShares() {\r\n    this.shares = Array();\r\n  }\r\n\r\n  public addShare(share: SecretShare) {\r\n    this.shares.push(share);\r\n  }\r\n}\r\n\r\nexport class Assembly {\r\n  constructor(public threshold: number = 0) {\r\n    this.clearSubAssemblies();\r\n  }\r\n\r\n  subAssemblies: SubAssembly[];\r\n\r\n  public size() {\r\n    return this.subAssemblies.length;\r\n  }\r\n\r\n  public clearSubAssemblies() {\r\n    this.subAssemblies = new Array();\r\n  }\r\n\r\n  public addSubAssembly(subAssembly: SubAssembly) {\r\n    this.subAssemblies.push(subAssembly);\r\n  }\r\n}\r\n\r\nexport class SubQuorum {\r\n  shares: string[];\r\n\r\n  constructor(public subAssemblyIndex: number) {\r\n    this.clearShares();\r\n  }\r\n\r\n  public clearShares() {\r\n    this.shares = new Array();\r\n  }\r\n\r\n  public addShare(share: string) {\r\n    this.shares.push(share);\r\n  }\r\n}\r\n\r\nexport class Quorum {\r\n  subQuora: SubQuorum[];\r\n\r\n  constructor() {\r\n    this.clearSubQuora();\r\n  }\r\n\r\n  public clearSubQuora() {\r\n    this.subQuora = new Array();\r\n  }\r\n\r\n  public addSubQuorum(subQuorum: SubQuorum) {\r\n    this.subQuora.push(subQuorum);\r\n  }\r\n\r\n  public serialiseShares() {\r\n    let shares = [];\r\n\r\n    this.subQuora.forEach((subQuorum) => {\r\n      shares = shares.concat(subQuorum.shares);\r\n    });\r\n\r\n    return shares;\r\n  }\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class Slip39Service {\r\n  constructor() {}\r\n\r\n  public async generateShares(secret, passphrase: string, assembly: Assembly) {\r\n    // Hex-encode secret.\r\n    let ems = btoa(secret);\r\n    ems = Slip39Helper.slip39EncodeHex(ems);\r\n\r\n    // Construct group specifications\r\n    const groups = [];\r\n\r\n    for (const sa of assembly.subAssemblies) {\r\n      groups.push([sa.threshold, sa.size]);\r\n    }\r\n\r\n    // Split!\r\n    const slip = await Slip39.fromArray(ems, {\r\n      passphrase,\r\n      threshold: assembly.threshold,\r\n      groups,\r\n      title: '',\r\n    });\r\n\r\n    // Extract shares\r\n    assembly.subAssemblies.forEach((sa, isa) => {\r\n      // Remove any existing shares\r\n      sa.clearShares();\r\n\r\n      for (let im = 0; im < sa.size; im++) {\r\n        // Construct the path to the share, formatted as \"r/<subassembly index>/<member index>\"\r\n        // with <subassembly index> and <member index> being two-digit, zero-padded integers.\r\n        const path =\r\n          'r/' +\r\n          isa.toString().padStart(2, '0') +\r\n          '/' +\r\n          im.toString().padStart(2, '0');\r\n        const mnemonics = slip.fromPath(path).mnemonics[0];\r\n        const share = new SecretShare(isa, im, mnemonics);\r\n\r\n        sa.addShare(share);\r\n      }\r\n    });\r\n  }\r\n\r\n  // Remove all redundant shares. i.e. keep only enough members and groups to satisfy the thresholds.\r\n  private minimalSet(mnemonics: string[]): string[] {\r\n    // Decode the mnemonics and sort then into groups.\r\n    let groupThresh = null;\r\n    const groups = new Map();\r\n    for (const mnemonic of mnemonics) {\r\n      const decoded = Slip39Helper.decodeMnemonic(mnemonic);\r\n\r\n      if (groupThresh && groupThresh !== decoded.groupThreshold) {\r\n        throw new Error('groupThreshold is different in mnemonics');\r\n      }\r\n\r\n      groupThresh = decoded.groupThreshold;\r\n\r\n      // Note that Slip39.recoverSecret() will do all the error checking again. So it's not critical\r\n      // that we error check here. So we just optimistically assume it's all good.\r\n      let g = groups.get(decoded.groupIndex);\r\n      if (g == null) {\r\n        g = {\r\n          memberThreshold: decoded.memberThreshold,\r\n          members: [],\r\n        };\r\n        groups.set(decoded.groupIndex, g);\r\n      }\r\n\r\n      g.members.push({\r\n        mnemonic,\r\n        decoded,\r\n      });\r\n    }\r\n\r\n    // Keep the minimum set of groups that meet threshold.\r\n    const mnemonicsMinSet = [];\r\n    let groupCount = 0;\r\n    for (const g of groups.values()) {\r\n      // Keep only groups that meet threshold\r\n      if (g.members.length < g.memberThreshold) {\r\n        continue;\r\n      }\r\n\r\n      // Keep minimum number of approvals needed for group\r\n      g.members.slice(0, g.memberThreshold).forEach((member) => {\r\n        mnemonicsMinSet.push(member.mnemonic);\r\n      });\r\n\r\n      ++groupCount;\r\n      if (groupCount >= groupThresh) {\r\n        break;\r\n      }\r\n    }\r\n\r\n    return mnemonicsMinSet;\r\n  }\r\n\r\n  public async recoverSecret(shares: string[], passphrase: string) {\r\n    shares = this.minimalSet(shares);\r\n\r\n    const recovered = await Slip39.recoverSecret(shares, passphrase);\r\n\r\n    const secret = Slip39Helper.slip39DecodeHex(recovered);\r\n\r\n    return atob(secret);\r\n  }\r\n}\r\n"]}

package/esm2015/lib/cryptography/web-crypto.service.js

@@ -0,0 +1,29 @@
+import { __awaiter } from "tslib";
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class WebCryptoService {
+    constructor() {
+        this.crypto = window.crypto;
+    }
+    toHex(buffer) {
+        // Ref: https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/digest
+        const array = Array.from(new Uint8Array(buffer)); // convert buffer to byte array
+        const hex = array.map((b) => b.toString(16).padStart(2, '0')).join(''); // convert bytes to hex string
+        return hex;
+    }
+    stringDigest(algorithm, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const encoder = new TextEncoder();
+            const data = encoder.encode(message);
+            const hash = yield this.crypto.subtle.digest(algorithm, data);
+            return this.toHex(hash);
+        });
+    }
+}
+WebCryptoService.ɵprov = i0.ɵɵdefineInjectable({ factory: function WebCryptoService_Factory() { return new WebCryptoService(); }, token: WebCryptoService, providedIn: "root" });
+WebCryptoService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/life-ready.config.js

@@ -0,0 +1,84 @@
+import { __awaiter } from "tslib";
+import { InjectionToken } from '@angular/core';
+import { ApolloLink, createHttpLink, from, InMemoryCache, } from '@apollo/client/core';
+import { setContext } from '@apollo/client/link/context';
+import { RetryLink } from '@apollo/client/link/retry';
+import { LrApiErrorCode } from './_common/exceptions';
+export const LR_CONFIG = new InjectionToken('LR.AUTH');
+const RETRY_ERROR_CODES = [LrApiErrorCode.CONCURRENT_ACCESS];
+export const configureApollo = (config, auth) => {
+    const defaultOptions = {
+        watchQuery: {
+            fetchPolicy: 'no-cache',
+            errorPolicy: 'all',
+        },
+        query: {
+            fetchPolicy: 'no-cache',
+            errorPolicy: 'all',
+        },
+        mutate: {
+            errorPolicy: 'all',
+        },
+    };
+    const authLink = setContext((_, { headers }) => __awaiter(void 0, void 0, void 0, function* () {
+        let accessJwt = null;
+        try {
+            accessJwt = (yield auth.currentSession()).getAccessToken();
+        }
+        catch (_a) {
+            console.log('User not signed in');
+        }
+        return {
+            headers: Object.assign(Object.assign({}, headers), { authorization: accessJwt ? `Bearer ${accessJwt.jwtToken}` : '' }),
+        };
+    }));
+    // We are only retrying on certain errors, like the CONCURRENT_ACCESS gql
+    // error which indicates DB race condition. So can be safely retried.
+    const retryIf = (error, _) => {
+        // The RetryLink is called on network error as well, so we need to filter for GraphQL errors.
+        if (error instanceof GraphQLErrorException) {
+            if (error.errors.some((e) => { var _a; return RETRY_ERROR_CODES.includes((_a = e.extensions) === null || _a === void 0 ? void 0 : _a.code); })) {
+                return true;
+            }
+        }
+        return false;
+    };
+    const retryLink = new RetryLink({
+        delay: {
+            initial: 300,
+            max: Infinity,
+            jitter: true,
+        },
+        attempts: {
+            max: 3,
+            retryIf,
+        },
+    });
+    class GraphQLErrorException extends Error {
+        constructor(errors) {
+            super(errors.map((e) => e.message).join(', '));
+            this.errors = errors;
+        }
+    }
+    // Throw exception on gql errors which effectively promotes it to a network
+    // error, which can then be handled by the RetryLink.
+    const promoteGqlErrors = new ApolloLink((operation, forward) => {
+        return forward(operation).map((data) => {
+            if (data && data.errors) {
+                const errors = data.errors.filter((e) => { var _a; return RETRY_ERROR_CODES.includes((_a = e.extensions) === null || _a === void 0 ? void 0 : _a.code); });
+                if (errors.length > 0) {
+                    throw new GraphQLErrorException(data.errors);
+                }
+            }
+            return data;
+        });
+    });
+    const httpLink = createHttpLink({
+        uri: config.apolloUrl,
+        // Sending the sessionid cookie so that the server can use session data when needed.
+        // eg. setting the session encryption key.
+        credentials: 'include',
+    });
+    return Object.assign({ link: from([retryLink, promoteGqlErrors, authLink, httpLink]), cache: new InMemoryCache(), defaultOptions }, config.apolloConfig);
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"life-ready.config.js","sourceRoot":"C:/Projects/test/projects/core/src/","sources":["lib/life-ready.config.ts"],"names":[],"mappings":"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","sourcesContent":["import { InjectionToken } from '@angular/core';\r\nimport { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';\r\nimport {\r\n  ApolloClientOptions,\r\n  ApolloLink,\r\n  createHttpLink,\r\n  DefaultOptions,\r\n  from,\r\n  InMemoryCache,\r\n} from '@apollo/client/core';\r\nimport { setContext } from '@apollo/client/link/context';\r\nimport { RetryLink } from '@apollo/client/link/retry';\r\nimport { LrApiErrorCode } from './_common/exceptions';\r\nimport { GraphQLError } from 'graphql';\r\n\r\nexport const LR_CONFIG = new InjectionToken<LifeReadyConfig>('LR.AUTH');\r\nconst RETRY_ERROR_CODES = [LrApiErrorCode.CONCURRENT_ACCESS];\r\n\r\nexport interface LifeReadyConfig {\r\n  authUrl: string;\r\n  apiUrl: string;\r\n  apolloUrl: string;\r\n  userPoolId: string;\r\n  userPoolWebClientId: string;\r\n  apolloConfig?: ApolloClientOptions<any>;\r\n  // Mainly to allow localhost to not needing this. Default to falsy\r\n  disableSessionEncryptionKey?: boolean;\r\n}\r\n\r\nexport const configureApollo = (\r\n  config: LifeReadyConfig,\r\n  auth: AuthClass\r\n): ApolloClientOptions<any> => {\r\n  const defaultOptions: DefaultOptions = {\r\n    watchQuery: {\r\n      fetchPolicy: 'no-cache',\r\n      errorPolicy: 'all',\r\n    },\r\n    query: {\r\n      fetchPolicy: 'no-cache',\r\n      errorPolicy: 'all',\r\n    },\r\n    mutate: {\r\n      errorPolicy: 'all',\r\n    },\r\n  };\r\n\r\n  const authLink = setContext(async (_, { headers }) => {\r\n    let accessJwt = null;\r\n    try {\r\n      accessJwt = (await auth.currentSession()).getAccessToken();\r\n    } catch {\r\n      console.log('User not signed in');\r\n    }\r\n\r\n    return {\r\n      headers: {\r\n        ...headers,\r\n        authorization: accessJwt ? `Bearer ${accessJwt.jwtToken}` : '',\r\n      },\r\n    };\r\n  });\r\n\r\n  // We are only retrying on certain errors, like the CONCURRENT_ACCESS gql\r\n  // error which indicates DB race condition. So can be safely retried.\r\n  const retryIf = (error, _) => {\r\n    // The RetryLink is called on network error as well, so we need to filter for GraphQL errors.\r\n    if (error instanceof GraphQLErrorException) {\r\n      if (\r\n        error.errors.some((e) => RETRY_ERROR_CODES.includes(e.extensions?.code))\r\n      ) {\r\n        return true;\r\n      }\r\n    }\r\n\r\n    return false;\r\n  };\r\n\r\n  const retryLink = new RetryLink({\r\n    delay: {\r\n      initial: 300,\r\n      max: Infinity,\r\n      jitter: true,\r\n    },\r\n    attempts: {\r\n      max: 3,\r\n      retryIf,\r\n    },\r\n  });\r\n\r\n  class GraphQLErrorException extends Error {\r\n    constructor(public errors: readonly GraphQLError[]) {\r\n      super(errors.map((e) => e.message).join(', '));\r\n    }\r\n  }\r\n\r\n  // Throw exception on gql errors which effectively promotes it to a network\r\n  // error, which can then be handled by the RetryLink.\r\n  const promoteGqlErrors = new ApolloLink((operation, forward) => {\r\n    return forward(operation).map((data) => {\r\n      if (data && data.errors) {\r\n        const errors = data.errors.filter((e) =>\r\n          RETRY_ERROR_CODES.includes(e.extensions?.code)\r\n        );\r\n\r\n        if (errors.length > 0) {\r\n          throw new GraphQLErrorException(data.errors);\r\n        }\r\n      }\r\n      return data;\r\n    });\r\n  });\r\n\r\n  const httpLink = createHttpLink({\r\n    uri: config.apolloUrl,\r\n    // Sending the sessionid cookie so that the server can use session data when needed.\r\n    // eg. setting the session encryption key.\r\n    credentials: 'include',\r\n  });\r\n\r\n  return {\r\n    link: from([retryLink, promoteGqlErrors, authLink, httpLink]),\r\n    cache: new InMemoryCache(),\r\n    defaultOptions,\r\n    ...config.apolloConfig,\r\n  };\r\n};\r\n"]}

package/esm2015/lib/life-ready.module.js

@@ -0,0 +1,74 @@
+import { HttpClientModule } from '@angular/common/http';
+import { APP_INITIALIZER, NgModule } from '@angular/core';
+import Auth from '@aws-amplify/auth';
+import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
+import { APOLLO_OPTIONS } from 'apollo-angular';
+import { CookieService } from 'ngx-cookie-service';
+import { FileService } from './api/file.service';
+import { ProfileService } from './users/profile.service';
+import { configureAmplifyAuth } from './auth/auth.config';
+import { initialiseAuth, LifeReadyAuthService, } from './auth/life-ready-auth.service';
+import { PasswordService } from './auth/password.service';
+import { RegisterService } from './auth/register.service';
+import { EncryptionService } from './cryptography/encryption.service';
+import { KeyGraphService } from './cryptography/key-graph.service';
+import { KeyService } from './cryptography/key.service';
+import { KeyFactoryService } from './cryptography/key-factory.service';
+import { WebCryptoService } from './cryptography/web-crypto.service';
+import { configureApollo, LR_CONFIG, } from './life-ready.config';
+import { TimeService } from './api/time.service';
+import { NgIdleKeepaliveModule } from '@ng-idle/keepalive';
+export class LifeReadyModule {
+    static forRoot(config) {
+        return {
+            ngModule: LifeReadyModule,
+            providers: [
+                {
+                    provide: LR_CONFIG,
+                    useValue: config,
+                },
+                {
+                    provide: AuthClass,
+                    useValue: Auth,
+                },
+                {
+                    provide: APP_INITIALIZER,
+                    useFactory: configureAmplifyAuth,
+                    deps: [LR_CONFIG, AuthClass],
+                    multi: true,
+                },
+                {
+                    provide: APP_INITIALIZER,
+                    useFactory: initialiseAuth,
+                    deps: [LifeReadyAuthService],
+                    multi: true,
+                },
+                {
+                    provide: APOLLO_OPTIONS,
+                    useFactory: configureApollo,
+                    deps: [LR_CONFIG, AuthClass],
+                },
+            ],
+        };
+    }
+}
+LifeReadyModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [HttpClientModule, NgIdleKeepaliveModule.forRoot()],
+                providers: [
+                    CookieService,
+                    TimeService,
+                    FileService,
+                    ProfileService,
+                    RegisterService,
+                    LifeReadyAuthService,
+                    PasswordService,
+                    WebCryptoService,
+                    EncryptionService,
+                    KeyGraphService,
+                    KeyService,
+                    KeyFactoryService,
+                ],
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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