@lifeready/core 1.0.21 → 1.0.23

package/esm2015/lib/key/key-meta.service.js

@@ -0,0 +1,201 @@
+import { __awaiter } from "tslib";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Injectable } from '@angular/core';
+import { LrApolloService } from '../api/lr-apollo.service';
+import { GetCategoryKeyIdQuery } from '../category/category.gql';
+import { EncryptionService } from '../encryption/encryption.service';
+import { KeyFactoryService } from './key-factory.service';
+import { KeyGraphService } from './key-graph.service';
+import { KeyService } from './key.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../encryption/encryption.service";
+import * as i2 from "./key-graph.service";
+import * as i3 from "../api/lr-apollo.service";
+import * as i4 from "./key.service";
+import * as i5 from "./key-factory.service";
+export class WrappedContent {
+}
+export class WrappingKey {
+}
+export class KeyMetaService {
+    constructor(encryptionService, keyGraph, lrApollo, keyService, keyFactory) {
+        this.encryptionService = encryptionService;
+        this.keyGraph = keyGraph;
+        this.lrApollo = lrApollo;
+        this.keyService = keyService;
+        this.keyFactory = keyFactory;
+    }
+    // async decryptFromString<T>(
+    //   keyOrId: string | Key,
+    //   cipherData: string,
+    //   options?: DecryptOptions
+    // ): Promise<T> {
+    //   if (cipherData) {
+    //     const key = await this.keyGraphService.getJwkKey(keyOrId);
+    //     return (await this.encryptionService.decrypt(
+    //       key,
+    //       JSON.parse(cipherData),
+    //       options
+    //     )) as any;
+    //   }
+    //   return null;
+    // }
+    decryptMeta(metaHaver) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (metaHaver.cipherMeta) {
+                const key = yield this.keyGraph.getJwkKey(metaHaver.keyId);
+                return (yield this.encryptionService.decrypt(key, JSON.parse(metaHaver.cipherMeta)));
+            }
+            return null;
+        });
+    }
+    // async decryptFile(keyId: string, file: any): Promise<any> {
+    //   const key = await this.keyGraphService.getJwkKey(keyId);
+    //   return (await this.encryptionService.decrypt(key, file, {
+    //     payloadType: 'ArrayBuffer',
+    //   })) as any;
+    // }
+    // // TODO rename this to encrypt() and use as the most common usecase
+    // async encryptToString(
+    //   key: string | Key | JWK.Key,
+    //   content: any
+    // ): Promise<string> {
+    //   // Empty string should be encrypted since you want to clear the field.
+    //   // Null is not encrypted because it's not valid JSON in the old JSON spec. Use
+    //   // empty string instead. It'll function as a logic false as well.
+    //   // Note that passing in empty string means it'll be encrypted which verifies
+    //   // it's integrity. But we still want to have a way to set the DB field
+    //   // to NULL, so we explicitly return null when content == null. A null
+    //   // variable in graphql mutation on KC server clears the field to NULL.
+    //   if (content == null) {
+    //     return null;
+    //   }
+    //   const jwk =
+    //     asJwk(key) || (await this.keyGraphService.getJwkKey(key as string | Key));
+    //   return JSON.stringify(await this.encryptionService.encrypt(jwk, content));
+    // }
+    // // Wraps a symmetric encryption key.
+    // // Throws exception if wrapping public keys.
+    // async wrapKey<T>(
+    //   wrappingKey: string | Key | JWK.Key,
+    //   key: JWK.Key
+    // ): Promise<string> {
+    //   if (!isSymmetricKey(key)) {
+    //     throw new LrBadArgumentException(
+    //       'Only allowing wrapping of symmetric keys.'
+    //     );
+    //   }
+    //   return this.encryptToString(wrappingKey, key.toJSON(true));
+    // }
+    // // TODO
+    // // async wrapPublicKey<T>();
+    // // async wrapPrivateKey<T>();
+    doubleWrapContent(secureContent, categoryIds, fileContent) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = yield this.keyFactory.createKey();
+            const wrappedContent = yield this.wrapContent(key.toJSON(true), categoryIds);
+            return {
+                rootKey: wrappedContent.rootKey,
+                wrappedKeys: wrappedContent.wrappedKeys,
+                doubleWrappedKey: wrappedContent.cipherMeta,
+                cipherMeta: secureContent
+                    ? JSON.stringify(yield this.encryptionService.encrypt(key, secureContent))
+                    : null,
+                cipherFileContent: fileContent
+                    ? JSON.stringify(yield this.encryptionService.encrypt(key, fileContent))
+                    : null,
+            };
+        });
+    }
+    reWrapContent(keyId, secureContent) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = yield this.keyGraph.getJwkKey(keyId);
+            const newKey = yield this.keyFactory.createKey();
+            return {
+                doubleWrappedKey: JSON.stringify(yield this.encryptionService.encrypt(key, newKey.toJSON(true))),
+                cipherMeta: secureContent
+                    ? JSON.stringify(yield this.encryptionService.encrypt(newKey, secureContent))
+                    : null,
+            };
+        });
+    }
+    wrapContent(secureContent, categoryIds) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = yield this.keyFactory.createKey();
+            let wrappedKeys;
+            let rootWrappingKey;
+            if (categoryIds && categoryIds.length) {
+                wrappedKeys = yield Promise.all(categoryIds.map((categoryId) => __awaiter(this, void 0, void 0, function* () {
+                    const parentKey = yield this.getCategoryKeyId(categoryId);
+                    const wrappedKey = JSON.stringify(yield this.encryptionService.encrypt(parentKey.key, key.toJSON(true)));
+                    return {
+                        directoryId: categoryId,
+                        wrappingKeyId: parentKey.keyId,
+                        wrappedKey,
+                    };
+                })));
+            }
+            else {
+                // Adding to root directory
+                const rootKey = this.keyService.getCurrentRootKey();
+                const wrappedKey = JSON.stringify(yield this.encryptionService.encrypt(rootKey.jwk, key.toJSON(true)));
+                rootWrappingKey = {
+                    wrappingKeyId: rootKey.id,
+                    wrappedKey,
+                };
+            }
+            return {
+                key,
+                rootKey: rootWrappingKey,
+                wrappedKeys,
+                cipherMeta: secureContent
+                    ? JSON.stringify(yield this.encryptionService.encrypt(key, secureContent))
+                    : null,
+            };
+        });
+    }
+    wrapContentWithKey(secureContent, keyId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = yield this.keyFactory.createKey();
+            const wrappedKey = yield this.keyGraph.encryptToString(keyId, key.toJSON(true));
+            return {
+                key,
+                rootKey: {
+                    wrappingKeyId: keyId,
+                    wrappedKey,
+                },
+                cipherMeta: secureContent
+                    ? JSON.stringify(yield this.encryptionService.encrypt(key, secureContent))
+                    : null,
+            };
+        });
+    }
+    getCategoryKeyId(categoryId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { category } = yield this.lrApollo.query({
+                query: GetCategoryKeyIdQuery,
+                variables: {
+                    id: categoryId,
+                },
+            });
+            return {
+                keyId: category.keyId,
+                key: yield this.keyGraph.getJwkKey(category.keyId),
+            };
+        });
+    }
+}
+KeyMetaService.ɵprov = i0.ɵɵdefineInjectable({ factory: function KeyMetaService_Factory() { return new KeyMetaService(i0.ɵɵinject(i1.EncryptionService), i0.ɵɵinject(i2.KeyGraphService), i0.ɵɵinject(i3.LrApolloService), i0.ɵɵinject(i4.KeyService), i0.ɵɵinject(i5.KeyFactoryService)); }, token: KeyMetaService, providedIn: "root" });
+KeyMetaService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+KeyMetaService.ctorParameters = () => [
+    { type: EncryptionService },
+    { type: KeyGraphService },
+    { type: LrApolloService },
+    { type: KeyService },
+    { type: KeyFactoryService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"key-meta.service.js","sourceRoot":"","sources":["../../../../../../projects/core/src/lib/key/key-meta.service.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Injectable } from '@angular/core';\nimport { JWK } from 'node-jose';\nimport { LrApolloService } from '../api/lr-apollo.service';\nimport { GetCategoryKeyIdQuery } from '../category/category.gql';\nimport { EncryptionService } from '../encryption/encryption.service';\nimport { KeyFactoryService } from './key-factory.service';\nimport { KeyGraphService } from './key-graph.service';\nimport { KeyService } from './key.service';\n\nexport interface HasCipherMeta {\n  keyId: string;\n  cipherMeta: string;\n}\n\nexport class WrappedContent {\n  key: JWK.Key;\n  cipherMeta: string;\n  wrappedKeys?: WrappingKey[];\n  rootKey?: WrappingKey;\n}\n\nexport class WrappingKey {\n  directoryId?: string;\n  wrappingKeyId: string;\n  wrappedKey: string;\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class KeyMetaService {\n  constructor(\n    private encryptionService: EncryptionService,\n    private keyGraph: KeyGraphService,\n    private lrApollo: LrApolloService,\n    private keyService: KeyService,\n    private keyFactory: KeyFactoryService\n  ) {}\n\n  // async decryptFromString<T>(\n  //   keyOrId: string | Key,\n  //   cipherData: string,\n  //   options?: DecryptOptions\n  // ): Promise<T> {\n  //   if (cipherData) {\n  //     const key = await this.keyGraphService.getJwkKey(keyOrId);\n  //     return (await this.encryptionService.decrypt(\n  //       key,\n  //       JSON.parse(cipherData),\n  //       options\n  //     )) as any;\n  //   }\n  //   return null;\n  // }\n\n  async decryptMeta<T>(metaHaver: HasCipherMeta): Promise<T> {\n    if (metaHaver.cipherMeta) {\n      const key = await this.keyGraph.getJwkKey(metaHaver.keyId);\n      return (await this.encryptionService.decrypt(\n        key,\n        JSON.parse(metaHaver.cipherMeta)\n      )) as any;\n    }\n    return null;\n  }\n\n  // async decryptFile(keyId: string, file: any): Promise<any> {\n  //   const key = await this.keyGraphService.getJwkKey(keyId);\n  //   return (await this.encryptionService.decrypt(key, file, {\n  //     payloadType: 'ArrayBuffer',\n  //   })) as any;\n  // }\n\n  // // TODO rename this to encrypt() and use as the most common usecase\n  // async encryptToString(\n  //   key: string | Key | JWK.Key,\n  //   content: any\n  // ): Promise<string> {\n  //   // Empty string should be encrypted since you want to clear the field.\n  //   // Null is not encrypted because it's not valid JSON in the old JSON spec. Use\n  //   // empty string instead. It'll function as a logic false as well.\n  //   // Note that passing in empty string means it'll be encrypted which verifies\n  //   // it's integrity. But we still want to have a way to set the DB field\n  //   // to NULL, so we explicitly return null when content == null. A null\n  //   // variable in graphql mutation on KC server clears the field to NULL.\n  //   if (content == null) {\n  //     return null;\n  //   }\n\n  //   const jwk =\n  //     asJwk(key) || (await this.keyGraphService.getJwkKey(key as string | Key));\n  //   return JSON.stringify(await this.encryptionService.encrypt(jwk, content));\n  // }\n\n  // // Wraps a symmetric encryption key.\n  // // Throws exception if wrapping public keys.\n  // async wrapKey<T>(\n  //   wrappingKey: string | Key | JWK.Key,\n  //   key: JWK.Key\n  // ): Promise<string> {\n  //   if (!isSymmetricKey(key)) {\n  //     throw new LrBadArgumentException(\n  //       'Only allowing wrapping of symmetric keys.'\n  //     );\n  //   }\n\n  //   return this.encryptToString(wrappingKey, key.toJSON(true));\n  // }\n\n  // // TODO\n  // // async wrapPublicKey<T>();\n  // // async wrapPrivateKey<T>();\n\n  async doubleWrapContent(\n    secureContent: any,\n    categoryIds: string[],\n    fileContent?: ArrayBuffer\n  ) {\n    const key = await this.keyFactory.createKey();\n\n    const wrappedContent = await this.wrapContent(\n      key.toJSON(true),\n      categoryIds\n    );\n\n    return {\n      rootKey: wrappedContent.rootKey,\n      wrappedKeys: wrappedContent.wrappedKeys,\n      doubleWrappedKey: wrappedContent.cipherMeta,\n      cipherMeta: secureContent\n        ? JSON.stringify(\n            await this.encryptionService.encrypt(key, secureContent)\n          )\n        : null,\n      cipherFileContent: fileContent\n        ? JSON.stringify(await this.encryptionService.encrypt(key, fileContent))\n        : null,\n    };\n  }\n\n  async reWrapContent(keyId: string, secureContent: any) {\n    const key = await this.keyGraph.getJwkKey(keyId);\n    const newKey = await this.keyFactory.createKey();\n\n    return {\n      doubleWrappedKey: JSON.stringify(\n        await this.encryptionService.encrypt(key, newKey.toJSON(true))\n      ),\n      cipherMeta: secureContent\n        ? JSON.stringify(\n            await this.encryptionService.encrypt(newKey, secureContent)\n          )\n        : null,\n    };\n  }\n\n  async wrapContent(\n    secureContent: any,\n    categoryIds?: string[]\n  ): Promise<WrappedContent> {\n    const key = await this.keyFactory.createKey();\n\n    let wrappedKeys: WrappingKey[];\n    let rootWrappingKey: WrappingKey;\n\n    if (categoryIds && categoryIds.length) {\n      wrappedKeys = await Promise.all(\n        categoryIds.map(async (categoryId) => {\n          const parentKey = await this.getCategoryKeyId(categoryId);\n          const wrappedKey = JSON.stringify(\n            await this.encryptionService.encrypt(\n              parentKey.key,\n              key.toJSON(true)\n            )\n          );\n          return {\n            directoryId: categoryId,\n            wrappingKeyId: parentKey.keyId,\n            wrappedKey,\n          };\n        })\n      );\n    } else {\n      // Adding to root directory\n      const rootKey = this.keyService.getCurrentRootKey();\n      const wrappedKey = JSON.stringify(\n        await this.encryptionService.encrypt(rootKey.jwk, key.toJSON(true))\n      );\n      rootWrappingKey = {\n        wrappingKeyId: rootKey.id,\n        wrappedKey,\n      };\n    }\n\n    return {\n      key,\n      rootKey: rootWrappingKey,\n      wrappedKeys,\n      cipherMeta: secureContent\n        ? JSON.stringify(\n            await this.encryptionService.encrypt(key, secureContent)\n          )\n        : null,\n    };\n  }\n\n  async wrapContentWithKey(\n    secureContent: any,\n    keyId: string\n  ): Promise<WrappedContent> {\n    const key = await this.keyFactory.createKey();\n\n    const wrappedKey = await this.keyGraph.encryptToString(\n      keyId,\n      key.toJSON(true)\n    );\n\n    return {\n      key,\n      rootKey: {\n        wrappingKeyId: keyId,\n        wrappedKey,\n      },\n      cipherMeta: secureContent\n        ? JSON.stringify(\n            await this.encryptionService.encrypt(key, secureContent)\n          )\n        : null,\n    };\n  }\n\n  private async getCategoryKeyId(\n    categoryId: string\n  ): Promise<{ keyId: string; key: any }> {\n    const { category } = await this.lrApollo.query<any>({\n      query: GetCategoryKeyIdQuery,\n      variables: {\n        id: categoryId,\n      },\n    });\n\n    return {\n      keyId: category.keyId,\n      key: await this.keyGraph.getJwkKey(category.keyId),\n    };\n  }\n}\n"]}

package/esm2015/lib/{cryptography → key}/key.service.js

@@ -1,12 +1,12 @@
 import { __awaiter } from "tslib";
 import { Inject, Injectable } from '@angular/core';
+import { LR_CONFIG } from '../life-ready.config';
+import { PersistService } from '../persist/persist.service';
 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";
+import * as i2 from "../persist/persist.service";
 export class UserKeys {
 }
 export class KeyService {
@@ -121,4 +121,4 @@ 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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"key.service.js","sourceRoot":"","sources":["../../../../../../projects/core/src/lib/key/key.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { LifeReadyConfig, LR_CONFIG } from '../life-ready.config';\nimport { PersistService } from '../persist/persist.service';\nimport { LrNotFoundException } from '../_common/exceptions';\nimport { KeyFactoryService as KFS } from './key-factory.service';\nimport { Key, PassKey } from './key.types';\n\nexport class UserKeys {\n  passKey: PassKey;\n  masterKey: Key;\n  rootKey?: Key;\n  pxk?: Key;\n  sigPxk?: Key;\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"]}

package/esm2015/lib/key/key.types.js

@@ -0,0 +1,11 @@
+export var KeyGraphNodeType;
+(function (KeyGraphNodeType) {
+    KeyGraphNodeType["Key"] = "key";
+    KeyGraphNodeType["PassKey"] = "passKey";
+})(KeyGraphNodeType || (KeyGraphNodeType = {}));
+export var KeyGraphEdgeType;
+(function (KeyGraphEdgeType) {
+    KeyGraphEdgeType["KeyLink"] = "keyLink";
+    KeyGraphEdgeType["PassKeyLink"] = "passKeyLink";
+})(KeyGraphEdgeType || (KeyGraphEdgeType = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/key-exchange/key-exchange.gql.js

@@ -0,0 +1,188 @@
+import gql from 'graphql-tag';
+import { FetchKeyGraphField, KeyGraphFragment } from '../_common/queries.gql';
+export const KeyExchangeFields = `
+  id
+  token
+  state
+  mode
+  isInitiator
+  initiator {
+    id
+    username
+  }
+  responder {
+    id
+    username
+  }
+  created
+  modified
+  tokenExpiryTime
+  isExpired
+  initiatorRootKeyCipher
+  initiatorActionRequired
+  responderActionRequired
+  responderEmailAddress
+  otk {
+    state
+    otKeyParams
+    otKeyCipher
+    sharedKey {
+      id
+    }
+    mkSharedKey {
+      id
+    }
+    initiatorSigPxk {
+      id
+    }
+    responderSigPxk {
+      id
+    }
+    initiatorOneTimePbkCipher
+    responderPbkCipher
+}`;
+export const UserSharedKeyFields = `
+  userSigPrk {
+    id
+  }
+  otherSigPbk {
+    id
+  }
+  sharedKey {
+    id
+  }
+  mkSharedKey {
+    id
+  }
+  mkPxk {
+    id
+    pbk
+  }
+  mkReshareRequestCipher
+  mkReshareResponseCipher
+  mkReshareRequestSent
+  mkReshareResponseSent
+`;
+export const CurrentUserSharedKeyQuery = gql `
+query CurrentUserSharedKeyQuery(
+  $username: String
+  $userId: LrRelayIdInput
+  $cachedKeyIds: [LrRelayIdInput!]
+) {
+  currentUserSharedKey(
+    username: $username
+    userId: $userId
+  ) {
+    userSharedKey {
+      ${UserSharedKeyFields}
+    }
+  }
+  keyGraph(cachedKeyIds: $cachedKeyIds) {
+    ...KeyGraphFragment
+  }
+}
+${KeyGraphFragment}`;
+export const KeyExchangesQuery = gql `
+query KeyExchangeQuery(
+$orderBy: String
+$isExpired: Boolean
+$initiatorActionRequired: Boolean
+$responderActionRequired: Boolean
+$initiator: ID
+$responder: ID
+$state: String
+) {
+keyExchanges(
+  orderBy: $orderBy
+  isExpired: $isExpired
+  initiatorActionRequired: $initiatorActionRequired
+  responderActionRequired: $responderActionRequired
+  initiator: $initiator
+  responder: $responder
+  state: $state
+) {
+  edges {
+    node {
+      ${KeyExchangeFields}
+    }
+  }
+}
+keyGraph {
+  ...KeyGraphFragment
+}
+}
+${KeyGraphFragment}
+`;
+export const KeyExchangeQuery = gql `
+query KeyExchangeQuery(
+  $id: LrRelayIdInput!
+) {
+  keyExchange(
+    id: $id
+  ) {
+    ${KeyExchangeFields}
+  }
+  keyGraph {
+    ...KeyGraphFragment
+  }
+}
+${KeyGraphFragment}
+`;
+// Key graph is only available for authenticated users. This query
+// is for unauthenticated users.
+export const KeyExchangeTokenQuery = gql `
+query KeyExchangeQuery(
+  $id: LrRelayIdInput!
+  $token: String
+) {
+  keyExchange(
+    id: $id
+    token: $token
+  ) {
+    ${KeyExchangeFields}
+  }
+}`;
+export const InitiateOtkMutation = gql `
+mutation InitiateKeyExchangeOtk(
+$input: InitiateKeyExchangeOtkInput!
+) {
+initiateKeyExchangeOtk(input: $input) {
+  keyExchange {
+    ${KeyExchangeFields}
+  }
+}
+${FetchKeyGraphField}
+}`;
+export const RespondOtkMutation = gql `
+mutation RespondKeyExchangeOtk(
+  $input: RespondKeyExchangeOtkInput!
+) {
+  respondKeyExchangeOtk(input: $input) {
+    keyExchange {
+      ${KeyExchangeFields}
+    }
+    userSharedKey {
+      ${UserSharedKeyFields}
+    }
+    tp {
+      id
+    }
+  }
+}`;
+export const CompleteOtkMutation = gql `
+mutation CompleteKeyExchangeOtk(
+  $input: CompleteKeyExchangeOtkInput!
+) {
+  completeKeyExchangeOtk(input: $input) {
+    keyExchange {
+      ${KeyExchangeFields}
+    }
+    userSharedKey {
+      ${UserSharedKeyFields}
+    }
+    tp {
+      id
+    }
+  }
+}`;
+//# sourceMappingURL=data:application/json;base64,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