@lifeready/core 1.0.12 → 1.0.15

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

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