@lifeready/core 1.0.12 → 1.0.15

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

@@ -1,299 +1,299 @@
-import { __awaiter } from "tslib";
-import { Injectable } from '@angular/core';
-import graphlib, { Graph } from '@dagrejs/graphlib';
-import _ from 'lodash';
-import { LrException, LrEncryptionException, LrNotFoundException, LrBadArgumentException, } from '../_common/exceptions';
-import { EdgeType, NodeType, } from './cryptography.types';
-import { asJwk, EncryptionService, isSymmetricKey, } from './encryption.service';
-import { KeyFactoryService, KeyFactoryService as KFS, } from './key-factory.service';
-import { KeyService } from './key.service';
-import * as i0 from "@angular/core";
-import * as i1 from "./encryption.service";
-import * as i2 from "./key.service";
-import * as i3 from "./key-factory.service";
-export class KeyGraphService {
-    // private keyCache: {
-    //   [id: string]: Key;
-    // };
-    constructor(encryptionService, keyService, keyFactory) {
-        this.encryptionService = encryptionService;
-        this.keyService = keyService;
-        this.keyFactory = keyFactory;
-        this.purgeKeys();
-    }
-    purgeKeys() {
-        this.graph = new Graph();
-        // this.keyCache = null;
-    }
-    populateKeys(userKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.keyService.populateKeys({
-                passKey: userKey.passKey,
-                masterKey: yield this.keyService.loadMasterKey(userKey.masterKey.id),
-                rootKey: yield this.unwrapKey(userKey.masterKey.id, userKey.rootKey.id),
-                pxk: yield this.unwrapKey(userKey.masterKey.id, userKey.pxk.id),
-                sigPxk: yield this.unwrapKey(userKey.masterKey.id, userKey.sigPxk.id),
-            });
-        });
-    }
-    hasKey(keyId) {
-        return !!this.graph.node(keyId);
-    }
-    getNode(id, type) {
-        const node = this.graph.node(id);
-        if (!node) {
-            throw new LrNotFoundException(`Key graphs does not contain key id: ${id}`);
-        }
-        if (node.type !== type) {
-            throw new LrException({
-                message: `Key with id ${id} is not of type ${type}`,
-            });
-        }
-        return node.data;
-    }
-    key(id) {
-        return this.getNode(id, NodeType.Key);
-    }
-    passKey(id) {
-        return this.getNode(id, NodeType.PassKey);
-    }
-    addKeys(src) {
-        // Keys
-        if (src.keys) {
-            // What key graph returns can not be customized. So keys are essentially immutable.
-            // Therefore, if a key exists, there's no reason to update it.
-            for (const key of src.keys) {
-                // Note using Relay global id allows us to not worry about clashing node id
-                if (this.graph.hasNode(key.id)) {
-                    continue;
-                }
-                const node = {
-                    type: NodeType.Key,
-                    data: _.cloneDeep(key),
-                };
-                this.graph.setNode(key.id, node);
-            }
-        }
-        // KeyLinks
-        if (src.keyLinks) {
-            for (const keyLink of src.keyLinks) {
-                if (this.graph.hasEdge(keyLink.wrappingKeyId, keyLink.keyId)) {
-                    continue;
-                }
-                const edge = {
-                    type: EdgeType.KeyLink,
-                    data: _.cloneDeep(keyLink),
-                };
-                // Edge goes from wrapping key to wrapped key.
-                this.graph.setEdge(keyLink.wrappingKeyId, keyLink.keyId, edge);
-            }
-        }
-        // PassKeyLinks
-        if (src.passKeyLinks) {
-            for (const passKeyLink of src.passKeyLinks) {
-                if (this.graph.hasEdge(passKeyLink.passKeyId, passKeyLink.keyId)) {
-                    continue;
-                }
-                const edge = {
-                    type: EdgeType.PassKeyLink,
-                    data: _.cloneDeep(passKeyLink),
-                };
-                // Edge goes from wrapping key to wrapped key.
-                this.graph.setEdge(passKeyLink.passKeyId, passKeyLink.keyId, edge);
-            }
-        }
-        // The graph is the single source of truth. These are lazily calculated.
-        // this.keyCache = null;
-    }
-    tracePath(distances, keyId) {
-        // The node label is the same as the id of the key nodes.
-        const ret = [];
-        let node = keyId;
-        if (!distances[node].predecessor) {
-            return null;
-        }
-        while (distances[node].predecessor) {
-            const child = distances[node].predecessor;
-            ret.push(this.graph.edge(child, node));
-            node = child;
-        }
-        // After reverse, the first element is the passkey
-        ret.reverse();
-        return ret;
-    }
-    getPath(knownKeyId, keyId) {
-        if (!knownKeyId || typeof knownKeyId !== 'string') {
-            throw new LrEncryptionException(`Param knownKeyId wrong format: ${knownKeyId}`);
-        }
-        if (!keyId || typeof keyId !== 'string') {
-            throw new LrEncryptionException(`Param keyId wrong format: ${keyId}`);
-        }
-        // => { A: { distance: 0 },
-        //      B: { distance: 6, predecessor: 'C' },
-        //      C: { distance: 4, predecessor: 'A' },
-        //      D: { distance: 2, predecessor: 'A' },
-        //      E: { distance: 8, predecessor: 'F' },
-        //      F: { distance: 4, predecessor: 'D' } }
-        const distances = graphlib.alg.dijkstra(this.graph, knownKeyId);
-        // Trace path from keyId to knownKeyId
-        return this.tracePath(distances, keyId);
-    }
-    getJwkKey(keyOrId, getKeyIdCallback) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return (yield this.getKey(keyOrId, getKeyIdCallback)).jwk;
-        });
-    }
-    // We assume that when a keyId is fetched, the key graph
-    // for the key is also returned and merged into the client-side
-    // key graph. By insisting a keyId is returned instead of the
-    // actual key we ensure key-graph is consistent.
-    getKey(keyOrId, getKeyIdCallback) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let keyId = typeof keyOrId === 'string' ? keyOrId : keyOrId === null || keyOrId === void 0 ? void 0 : keyOrId.id;
-            if (!this.hasKey(keyId) && getKeyIdCallback) {
-                keyId = yield getKeyIdCallback();
-            }
-            // else, continue and let it fail.
-            const key = this.key(keyId);
-            if (key.jwk) {
-                return key;
-            }
-            else {
-                return this.unwrapKey(this.keyService.getCurrentMasterKey().id, keyId);
-            }
-        });
-    }
-    _unwrapLink(wrappingKey, link, dstKey) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // console.log("_unwrapLink:", link.data.keyId);
-            const wrappedKey = JSON.parse(link.data.wrappedKey);
-            // Signatures of keys contain the key itself. This way we only need
-            // to access the KeyLinks to decrypt/verify keys.
-            let nextRawKey;
-            if (wrappedKey.signatures) {
-                nextRawKey = yield this.encryptionService.verify(wrappingKey, wrappedKey);
-            }
-            else {
-                nextRawKey = yield this.encryptionService.decrypt(wrappingKey, wrappedKey);
-            }
-            dstKey.jwk = yield KFS.asKey(nextRawKey);
-            dstKey.task = null;
-        });
-    }
-    _unwrap(key, path) {
-        return __awaiter(this, void 0, void 0, function* () {
-            for (const link of path) {
-                const dstKey = this.key(link.data.keyId);
-                // console.log("key: ", link.data.keyId);
-                if (dstKey.jwk) {
-                    key = dstKey.jwk;
-                    // console.log("Returning cached key: ", link.data.keyId);
-                    continue;
-                }
-                if (!dstKey.task) {
-                    dstKey.task = this._unwrapLink(key, link, dstKey);
-                }
-                yield dstKey.task;
-                key = dstKey.jwk;
-            }
-            return key;
-        });
-    }
-    unwrapWithPassKey(passKeyId, passKey, keyId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Get path of the directory key.
-            const path = this.getPath(passKeyId, keyId);
-            return {
-                id: keyId,
-                jwk: yield this._unwrap(passKey, path),
-            };
-        });
-    }
-    unwrapKey(masterKeyId, keyId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // The first key should be a masterKey
-            const masterKey = yield this.keyService.loadMasterKey(masterKeyId);
-            if (masterKeyId === keyId) {
-                return masterKey;
-            }
-            // Get path of the directory key.
-            const path = this.getPath(masterKey.id, keyId);
-            return {
-                id: keyId,
-                jwk: yield this._unwrap(masterKey.jwk, path),
-            };
-        });
-    }
-    decryptFromString(keyOrId, cipherData, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (cipherData) {
-                const key = yield this.getJwkKey(keyOrId);
-                return (yield this.encryptionService.decrypt(key, JSON.parse(cipherData), options));
-            }
-            return null;
-        });
-    }
-    decryptFile(keyId, file) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const key = yield this.getJwkKey(keyId);
-            return (yield this.encryptionService.decrypt(key, file, {
-                payloadType: 'ArrayBuffer',
-            }));
-        });
-    }
-    // TODO rename this to encrypt() and use as the most common usecase
-    encryptToString(key, content) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // 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) || (yield this.getJwkKey(key));
-            return this.encryptionService.encryptToString(jwk, content);
-        });
-    }
-    // Wraps a symmetric encryption key.
-    // Throws exception if wrapping public keys.
-    wrapKey(wrappingKey, key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            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>();
-    encryptWithNewKey(wrappingKeyId, cipherClearJson) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const key = yield this.keyFactory.createKey();
-            const wrappedKey = yield this.encryptToString(wrappingKeyId, key.toJSON(true));
-            const cipher = yield this.encryptToString(key, cipherClearJson);
-            return {
-                key,
-                wrappingKeyId,
-                wrappedKey,
-                cipher,
-            };
-        });
-    }
-}
-KeyGraphService.ɵprov = i0.ɵɵdefineInjectable({ factory: function KeyGraphService_Factory() { return new KeyGraphService(i0.ɵɵinject(i1.EncryptionService), i0.ɵɵinject(i2.KeyService), i0.ɵɵinject(i3.KeyFactoryService)); }, token: KeyGraphService, providedIn: "root" });
-KeyGraphService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-KeyGraphService.ctorParameters = () => [
-    { type: EncryptionService },
-    { type: KeyService },
-    { type: KeyFactoryService }
-];
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"key-graph.service.js","sourceRoot":"/opt/atlassian/pipelines/agent/build/projects/core/src/","sources":["lib/cryptography/key-graph.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport graphlib, { Graph } from '@dagrejs/graphlib';\nimport _ from 'lodash';\nimport { JWK } from 'node-jose';\nimport { CurrentUserKey } from '../users/profile.types';\nimport {\n  LrException,\n  LrEncryptionException,\n  LrNotFoundException,\n  LrBadArgumentException,\n} from '../_common/exceptions';\nimport {\n  Edge,\n  EdgeType,\n  Key,\n  KeyGraphResponse,\n  Node,\n  NodeType,\n  PassKey,\n} from './cryptography.types';\nimport {\n  asJwk,\n  DecryptOptions,\n  EncryptionService,\n  isSymmetricKey,\n} from './encryption.service';\nimport {\n  KeyFactoryService,\n  KeyFactoryService as KFS,\n} from './key-factory.service';\nimport { KeyService } from './key.service';\n\nexport interface GraphKey extends Key {\n  task?: Promise<any>;\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class KeyGraphService {\n  private graph: Graph;\n  // private keyCache: {\n  //   [id: string]: Key;\n  // };\n\n  constructor(\n    private encryptionService: EncryptionService,\n    private keyService: KeyService,\n    private keyFactory: KeyFactoryService\n  ) {\n    this.purgeKeys();\n  }\n\n  purgeKeys() {\n    this.graph = new Graph();\n    // this.keyCache = null;\n  }\n\n  async populateKeys(userKey: CurrentUserKey) {\n    this.keyService.populateKeys({\n      passKey: userKey.passKey,\n      masterKey: await this.keyService.loadMasterKey(userKey.masterKey.id),\n      rootKey: await this.unwrapKey(userKey.masterKey.id, userKey.rootKey.id),\n      pxk: await this.unwrapKey(userKey.masterKey.id, userKey.pxk.id),\n      sigPxk: await this.unwrapKey(userKey.masterKey.id, userKey.sigPxk.id),\n    });\n  }\n\n  hasKey(keyId: string) {\n    return !!this.graph.node(keyId);\n  }\n\n  private getNode(id, type): GraphKey | PassKey {\n    const node = this.graph.node(id);\n    if (!node) {\n      throw new LrNotFoundException(\n        `Key graphs does not contain key id: ${id}`\n      );\n    }\n    if (node.type !== type) {\n      throw new LrException({\n        message: `Key with id ${id} is not of type ${type}`,\n      });\n    }\n    return node.data;\n  }\n\n  key(id): GraphKey {\n    return this.getNode(id, NodeType.Key);\n  }\n\n  passKey(id): PassKey {\n    return this.getNode(id, NodeType.PassKey);\n  }\n\n  addKeys(src: KeyGraphResponse) {\n    // Keys\n    if (src.keys) {\n      // What key graph returns can not be customized. So keys are essentially immutable.\n      // Therefore, if a key exists, there's no reason to update it.\n      for (const key of src.keys) {\n        // Note using Relay global id allows us to not worry about clashing node id\n        if (this.graph.hasNode(key.id)) {\n          continue;\n        }\n\n        const node: Node = {\n          type: NodeType.Key,\n          data: _.cloneDeep(key),\n        };\n\n        this.graph.setNode(key.id, node);\n      }\n    }\n\n    // KeyLinks\n    if (src.keyLinks) {\n      for (const keyLink of src.keyLinks) {\n        if (this.graph.hasEdge(keyLink.wrappingKeyId, keyLink.keyId)) {\n          continue;\n        }\n\n        const edge: Edge = {\n          type: EdgeType.KeyLink,\n          data: _.cloneDeep(keyLink),\n        };\n        // Edge goes from wrapping key to wrapped key.\n        this.graph.setEdge(keyLink.wrappingKeyId, keyLink.keyId, edge);\n      }\n    }\n\n    // PassKeyLinks\n    if (src.passKeyLinks) {\n      for (const passKeyLink of src.passKeyLinks) {\n        if (this.graph.hasEdge(passKeyLink.passKeyId, passKeyLink.keyId)) {\n          continue;\n        }\n\n        const edge: Edge = {\n          type: EdgeType.PassKeyLink,\n          data: _.cloneDeep(passKeyLink),\n        };\n        // Edge goes from wrapping key to wrapped key.\n        this.graph.setEdge(passKeyLink.passKeyId, passKeyLink.keyId, edge);\n      }\n    }\n\n    // The graph is the single source of truth. These are lazily calculated.\n    // this.keyCache = null;\n  }\n\n  tracePath(distances, keyId: string): Edge[] {\n    // The node label is the same as the id of the key nodes.\n    const ret: Edge[] = [];\n    let node = keyId;\n    if (!distances[node].predecessor) {\n      return null;\n    }\n\n    while (distances[node].predecessor) {\n      const child = distances[node].predecessor;\n      ret.push(this.graph.edge(child, node));\n      node = child;\n    }\n\n    // After reverse, the first element is the passkey\n    ret.reverse();\n\n    return ret;\n  }\n\n  getPath(knownKeyId: string, keyId: string): Edge[] {\n    if (!knownKeyId || typeof knownKeyId !== 'string') {\n      throw new LrEncryptionException(\n        `Param knownKeyId wrong format: ${knownKeyId}`\n      );\n    }\n    if (!keyId || typeof keyId !== 'string') {\n      throw new LrEncryptionException(`Param keyId wrong format: ${keyId}`);\n    }\n\n    // => { A: { distance: 0 },\n    //      B: { distance: 6, predecessor: 'C' },\n    //      C: { distance: 4, predecessor: 'A' },\n    //      D: { distance: 2, predecessor: 'A' },\n    //      E: { distance: 8, predecessor: 'F' },\n    //      F: { distance: 4, predecessor: 'D' } }\n    const distances = graphlib.alg.dijkstra(this.graph, knownKeyId);\n\n    // Trace path from keyId to knownKeyId\n    return this.tracePath(distances, keyId);\n  }\n\n  async getJwkKey(\n    keyOrId: string | Key,\n    getKeyIdCallback?: () => Promise<string> | string\n  ): Promise<JWK.Key> {\n    return (await this.getKey(keyOrId, getKeyIdCallback)).jwk;\n  }\n\n  // We assume that when a keyId is fetched, the key graph\n  // for the key is also returned and merged into the client-side\n  // key graph. By insisting a keyId is returned instead of the\n  // actual key we ensure key-graph is consistent.\n  async getKey(\n    keyOrId: string | Key,\n    getKeyIdCallback?: () => Promise<string> | string\n  ): Promise<Key> {\n    let keyId = typeof keyOrId === 'string' ? keyOrId : keyOrId?.id;\n\n    if (!this.hasKey(keyId) && getKeyIdCallback) {\n      keyId = await getKeyIdCallback();\n    }\n    // else, continue and let it fail.\n\n    const key = this.key(keyId);\n    if (key.jwk) {\n      return key;\n    } else {\n      return this.unwrapKey(this.keyService.getCurrentMasterKey().id, keyId);\n    }\n  }\n\n  private async _unwrapLink(wrappingKey, link, dstKey) {\n    // console.log(\"_unwrapLink:\", link.data.keyId);\n    const wrappedKey = JSON.parse(link.data.wrappedKey);\n    // Signatures of keys contain the key itself. This way we only need\n    // to access the KeyLinks to decrypt/verify keys.\n    let nextRawKey;\n    if (wrappedKey.signatures) {\n      nextRawKey = await this.encryptionService.verify(wrappingKey, wrappedKey);\n    } else {\n      nextRawKey = await this.encryptionService.decrypt(\n        wrappingKey,\n        wrappedKey\n      );\n    }\n    dstKey.jwk = await KFS.asKey(nextRawKey);\n    dstKey.task = null;\n  }\n\n  private async _unwrap(key: JWK.Key, path: Edge[]): Promise<JWK.Key> {\n    for (const link of path) {\n      const dstKey = this.key(link.data.keyId);\n      // console.log(\"key: \", link.data.keyId);\n      if (dstKey.jwk) {\n        key = dstKey.jwk;\n        // console.log(\"Returning cached key: \", link.data.keyId);\n        continue;\n      }\n\n      if (!dstKey.task) {\n        dstKey.task = this._unwrapLink(key, link, dstKey);\n      }\n\n      await dstKey.task;\n      key = dstKey.jwk;\n    }\n\n    return key;\n  }\n\n  public async unwrapWithPassKey(\n    passKeyId: string,\n    passKey: JWK.Key,\n    keyId: string\n  ): Promise<Key> {\n    // Get path of the directory key.\n    const path = this.getPath(passKeyId, keyId);\n\n    return {\n      id: keyId,\n      jwk: await this._unwrap(passKey, path),\n    };\n  }\n\n  async unwrapKey(masterKeyId: string, keyId: string): Promise<Key> {\n    // The first key should be a masterKey\n    const masterKey = await this.keyService.loadMasterKey(masterKeyId);\n\n    if (masterKeyId === keyId) {\n      return masterKey;\n    }\n\n    // Get path of the directory key.\n    const path = this.getPath(masterKey.id, keyId);\n\n    return {\n      id: keyId,\n      jwk: await this._unwrap(masterKey.jwk, path),\n    };\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.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 decryptFile(keyId: string, file: any): Promise<any> {\n    const key = await this.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 = asJwk(key) || (await this.getJwkKey(key as string | Key));\n    return this.encryptionService.encryptToString(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 encryptWithNewKey(wrappingKeyId: string, cipherClearJson: any) {\n    const key = await this.keyFactory.createKey();\n    const wrappedKey = await this.encryptToString(\n      wrappingKeyId,\n      key.toJSON(true)\n    );\n    const cipher = await this.encryptToString(key, cipherClearJson);\n\n    return {\n      key,\n      wrappingKeyId,\n      wrappedKey,\n      cipher,\n    };\n  }\n}\n"]}
+import { __awaiter } from "tslib";
+import { Injectable } from '@angular/core';
+import graphlib, { Graph } from '@dagrejs/graphlib';
+import _ from 'lodash';
+import { LrException, LrEncryptionException, LrNotFoundException, LrBadArgumentException, } from '../_common/exceptions';
+import { EdgeType, NodeType, } from './cryptography.types';
+import { asJwk, EncryptionService, isSymmetricKey, } from './encryption.service';
+import { KeyFactoryService, KeyFactoryService as KFS, } from './key-factory.service';
+import { KeyService } from './key.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./encryption.service";
+import * as i2 from "./key.service";
+import * as i3 from "./key-factory.service";
+export class KeyGraphService {
+    // private keyCache: {
+    //   [id: string]: Key;
+    // };
+    constructor(encryptionService, keyService, keyFactory) {
+        this.encryptionService = encryptionService;
+        this.keyService = keyService;
+        this.keyFactory = keyFactory;
+        this.purgeKeys();
+    }
+    purgeKeys() {
+        this.graph = new Graph();
+        // this.keyCache = null;
+    }
+    populateKeys(userKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.keyService.populateKeys({
+                passKey: userKey.passKey,
+                masterKey: yield this.keyService.loadMasterKey(userKey.masterKey.id),
+                rootKey: yield this.unwrapKey(userKey.masterKey.id, userKey.rootKey.id),
+                pxk: yield this.unwrapKey(userKey.masterKey.id, userKey.pxk.id),
+                sigPxk: yield this.unwrapKey(userKey.masterKey.id, userKey.sigPxk.id),
+            });
+        });
+    }
+    hasKey(keyId) {
+        return !!this.graph.node(keyId);
+    }
+    getNode(id, type) {
+        const node = this.graph.node(id);
+        if (!node) {
+            throw new LrNotFoundException(`Key graphs does not contain key id: ${id}`);
+        }
+        if (node.type !== type) {
+            throw new LrException({
+                message: `Key with id ${id} is not of type ${type}`,
+            });
+        }
+        return node.data;
+    }
+    key(id) {
+        return this.getNode(id, NodeType.Key);
+    }
+    passKey(id) {
+        return this.getNode(id, NodeType.PassKey);
+    }
+    addKeys(src) {
+        // Keys
+        if (src.keys) {
+            // What key graph returns can not be customized. So keys are essentially immutable.
+            // Therefore, if a key exists, there's no reason to update it.
+            for (const key of src.keys) {
+                // Note using Relay global id allows us to not worry about clashing node id
+                if (this.graph.hasNode(key.id)) {
+                    continue;
+                }
+                const node = {
+                    type: NodeType.Key,
+                    data: _.cloneDeep(key),
+                };
+                this.graph.setNode(key.id, node);
+            }
+        }
+        // KeyLinks
+        if (src.keyLinks) {
+            for (const keyLink of src.keyLinks) {
+                if (this.graph.hasEdge(keyLink.wrappingKeyId, keyLink.keyId)) {
+                    continue;
+                }
+                const edge = {
+                    type: EdgeType.KeyLink,
+                    data: _.cloneDeep(keyLink),
+                };
+                // Edge goes from wrapping key to wrapped key.
+                this.graph.setEdge(keyLink.wrappingKeyId, keyLink.keyId, edge);
+            }
+        }
+        // PassKeyLinks
+        if (src.passKeyLinks) {
+            for (const passKeyLink of src.passKeyLinks) {
+                if (this.graph.hasEdge(passKeyLink.passKeyId, passKeyLink.keyId)) {
+                    continue;
+                }
+                const edge = {
+                    type: EdgeType.PassKeyLink,
+                    data: _.cloneDeep(passKeyLink),
+                };
+                // Edge goes from wrapping key to wrapped key.
+                this.graph.setEdge(passKeyLink.passKeyId, passKeyLink.keyId, edge);
+            }
+        }
+        // The graph is the single source of truth. These are lazily calculated.
+        // this.keyCache = null;
+    }
+    tracePath(distances, keyId) {
+        // The node label is the same as the id of the key nodes.
+        const ret = [];
+        let node = keyId;
+        if (!distances[node].predecessor) {
+            return null;
+        }
+        while (distances[node].predecessor) {
+            const child = distances[node].predecessor;
+            ret.push(this.graph.edge(child, node));
+            node = child;
+        }
+        // After reverse, the first element is the passkey
+        ret.reverse();
+        return ret;
+    }
+    getPath(knownKeyId, keyId) {
+        if (!knownKeyId || typeof knownKeyId !== 'string') {
+            throw new LrEncryptionException(`Param knownKeyId wrong format: ${knownKeyId}`);
+        }
+        if (!keyId || typeof keyId !== 'string') {
+            throw new LrEncryptionException(`Param keyId wrong format: ${keyId}`);
+        }
+        // => { A: { distance: 0 },
+        //      B: { distance: 6, predecessor: 'C' },
+        //      C: { distance: 4, predecessor: 'A' },
+        //      D: { distance: 2, predecessor: 'A' },
+        //      E: { distance: 8, predecessor: 'F' },
+        //      F: { distance: 4, predecessor: 'D' } }
+        const distances = graphlib.alg.dijkstra(this.graph, knownKeyId);
+        // Trace path from keyId to knownKeyId
+        return this.tracePath(distances, keyId);
+    }
+    getJwkKey(keyOrId, getKeyIdCallback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.getKey(keyOrId, getKeyIdCallback)).jwk;
+        });
+    }
+    // We assume that when a keyId is fetched, the key graph
+    // for the key is also returned and merged into the client-side
+    // key graph. By insisting a keyId is returned instead of the
+    // actual key we ensure key-graph is consistent.
+    getKey(keyOrId, getKeyIdCallback) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let keyId = typeof keyOrId === 'string' ? keyOrId : keyOrId === null || keyOrId === void 0 ? void 0 : keyOrId.id;
+            if (!this.hasKey(keyId) && getKeyIdCallback) {
+                keyId = yield getKeyIdCallback();
+            }
+            // else, continue and let it fail.
+            const key = this.key(keyId);
+            if (key.jwk) {
+                return key;
+            }
+            else {
+                return this.unwrapKey(this.keyService.getCurrentMasterKey().id, keyId);
+            }
+        });
+    }
+    _unwrapLink(wrappingKey, link, dstKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // console.log("_unwrapLink:", link.data.keyId);
+            const wrappedKey = JSON.parse(link.data.wrappedKey);
+            // Signatures of keys contain the key itself. This way we only need
+            // to access the KeyLinks to decrypt/verify keys.
+            let nextRawKey;
+            if (wrappedKey.signatures) {
+                nextRawKey = yield this.encryptionService.verify(wrappingKey, wrappedKey);
+            }
+            else {
+                nextRawKey = yield this.encryptionService.decrypt(wrappingKey, wrappedKey);
+            }
+            dstKey.jwk = yield KFS.asKey(nextRawKey);
+            dstKey.task = null;
+        });
+    }
+    _unwrap(key, path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const link of path) {
+                const dstKey = this.key(link.data.keyId);
+                // console.log("key: ", link.data.keyId);
+                if (dstKey.jwk) {
+                    key = dstKey.jwk;
+                    // console.log("Returning cached key: ", link.data.keyId);
+                    continue;
+                }
+                if (!dstKey.task) {
+                    dstKey.task = this._unwrapLink(key, link, dstKey);
+                }
+                yield dstKey.task;
+                key = dstKey.jwk;
+            }
+            return key;
+        });
+    }
+    unwrapWithPassKey(passKeyId, passKey, keyId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Get path of the directory key.
+            const path = this.getPath(passKeyId, keyId);
+            return {
+                id: keyId,
+                jwk: yield this._unwrap(passKey, path),
+            };
+        });
+    }
+    unwrapKey(masterKeyId, keyId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // The first key should be a masterKey
+            const masterKey = yield this.keyService.loadMasterKey(masterKeyId);
+            if (masterKeyId === keyId) {
+                return masterKey;
+            }
+            // Get path of the directory key.
+            const path = this.getPath(masterKey.id, keyId);
+            return {
+                id: keyId,
+                jwk: yield this._unwrap(masterKey.jwk, path),
+            };
+        });
+    }
+    decryptFromString(keyOrId, cipherData, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (cipherData) {
+                const key = yield this.getJwkKey(keyOrId);
+                return (yield this.encryptionService.decrypt(key, JSON.parse(cipherData), options));
+            }
+            return null;
+        });
+    }
+    decryptFile(keyId, file) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = yield this.getJwkKey(keyId);
+            return (yield this.encryptionService.decrypt(key, file, {
+                payloadType: 'ArrayBuffer',
+            }));
+        });
+    }
+    // TODO rename this to encrypt() and use as the most common usecase
+    encryptToString(key, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 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) || (yield this.getJwkKey(key));
+            return this.encryptionService.encryptToString(jwk, content);
+        });
+    }
+    // Wraps a symmetric encryption key.
+    // Throws exception if wrapping public keys.
+    wrapKey(wrappingKey, key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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>();
+    encryptWithNewKey(wrappingKeyId, cipherClearJson) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = yield this.keyFactory.createKey();
+            const wrappedKey = yield this.encryptToString(wrappingKeyId, key.toJSON(true));
+            const cipher = yield this.encryptToString(key, cipherClearJson);
+            return {
+                key,
+                wrappingKeyId,
+                wrappedKey,
+                cipher,
+            };
+        });
+    }
+}
+KeyGraphService.ɵprov = i0.ɵɵdefineInjectable({ factory: function KeyGraphService_Factory() { return new KeyGraphService(i0.ɵɵinject(i1.EncryptionService), i0.ɵɵinject(i2.KeyService), i0.ɵɵinject(i3.KeyFactoryService)); }, token: KeyGraphService, providedIn: "root" });
+KeyGraphService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+KeyGraphService.ctorParameters = () => [
+    { type: EncryptionService },
+    { type: KeyService },
+    { type: KeyFactoryService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"key-graph.service.js","sourceRoot":"C:/Projects/kc-client/projects/core/src/","sources":["lib/cryptography/key-graph.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport graphlib, { Graph } from '@dagrejs/graphlib';\r\nimport _ from 'lodash';\r\nimport { JWK } from 'node-jose';\r\nimport { CurrentUserKey } from '../users/profile.types';\r\nimport {\r\n  LrException,\r\n  LrEncryptionException,\r\n  LrNotFoundException,\r\n  LrBadArgumentException,\r\n} from '../_common/exceptions';\r\nimport {\r\n  Edge,\r\n  EdgeType,\r\n  Key,\r\n  KeyGraphResponse,\r\n  Node,\r\n  NodeType,\r\n  PassKey,\r\n} from './cryptography.types';\r\nimport {\r\n  asJwk,\r\n  DecryptOptions,\r\n  EncryptionService,\r\n  isSymmetricKey,\r\n} from './encryption.service';\r\nimport {\r\n  KeyFactoryService,\r\n  KeyFactoryService as KFS,\r\n} from './key-factory.service';\r\nimport { KeyService } from './key.service';\r\n\r\nexport interface GraphKey extends Key {\r\n  task?: Promise<any>;\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class KeyGraphService {\r\n  private graph: Graph;\r\n  // private keyCache: {\r\n  //   [id: string]: Key;\r\n  // };\r\n\r\n  constructor(\r\n    private encryptionService: EncryptionService,\r\n    private keyService: KeyService,\r\n    private keyFactory: KeyFactoryService\r\n  ) {\r\n    this.purgeKeys();\r\n  }\r\n\r\n  purgeKeys() {\r\n    this.graph = new Graph();\r\n    // this.keyCache = null;\r\n  }\r\n\r\n  async populateKeys(userKey: CurrentUserKey) {\r\n    this.keyService.populateKeys({\r\n      passKey: userKey.passKey,\r\n      masterKey: await this.keyService.loadMasterKey(userKey.masterKey.id),\r\n      rootKey: await this.unwrapKey(userKey.masterKey.id, userKey.rootKey.id),\r\n      pxk: await this.unwrapKey(userKey.masterKey.id, userKey.pxk.id),\r\n      sigPxk: await this.unwrapKey(userKey.masterKey.id, userKey.sigPxk.id),\r\n    });\r\n  }\r\n\r\n  hasKey(keyId: string) {\r\n    return !!this.graph.node(keyId);\r\n  }\r\n\r\n  private getNode(id, type): GraphKey | PassKey {\r\n    const node = this.graph.node(id);\r\n    if (!node) {\r\n      throw new LrNotFoundException(\r\n        `Key graphs does not contain key id: ${id}`\r\n      );\r\n    }\r\n    if (node.type !== type) {\r\n      throw new LrException({\r\n        message: `Key with id ${id} is not of type ${type}`,\r\n      });\r\n    }\r\n    return node.data;\r\n  }\r\n\r\n  key(id): GraphKey {\r\n    return this.getNode(id, NodeType.Key);\r\n  }\r\n\r\n  passKey(id): PassKey {\r\n    return this.getNode(id, NodeType.PassKey);\r\n  }\r\n\r\n  addKeys(src: KeyGraphResponse) {\r\n    // Keys\r\n    if (src.keys) {\r\n      // What key graph returns can not be customized. So keys are essentially immutable.\r\n      // Therefore, if a key exists, there's no reason to update it.\r\n      for (const key of src.keys) {\r\n        // Note using Relay global id allows us to not worry about clashing node id\r\n        if (this.graph.hasNode(key.id)) {\r\n          continue;\r\n        }\r\n\r\n        const node: Node = {\r\n          type: NodeType.Key,\r\n          data: _.cloneDeep(key),\r\n        };\r\n\r\n        this.graph.setNode(key.id, node);\r\n      }\r\n    }\r\n\r\n    // KeyLinks\r\n    if (src.keyLinks) {\r\n      for (const keyLink of src.keyLinks) {\r\n        if (this.graph.hasEdge(keyLink.wrappingKeyId, keyLink.keyId)) {\r\n          continue;\r\n        }\r\n\r\n        const edge: Edge = {\r\n          type: EdgeType.KeyLink,\r\n          data: _.cloneDeep(keyLink),\r\n        };\r\n        // Edge goes from wrapping key to wrapped key.\r\n        this.graph.setEdge(keyLink.wrappingKeyId, keyLink.keyId, edge);\r\n      }\r\n    }\r\n\r\n    // PassKeyLinks\r\n    if (src.passKeyLinks) {\r\n      for (const passKeyLink of src.passKeyLinks) {\r\n        if (this.graph.hasEdge(passKeyLink.passKeyId, passKeyLink.keyId)) {\r\n          continue;\r\n        }\r\n\r\n        const edge: Edge = {\r\n          type: EdgeType.PassKeyLink,\r\n          data: _.cloneDeep(passKeyLink),\r\n        };\r\n        // Edge goes from wrapping key to wrapped key.\r\n        this.graph.setEdge(passKeyLink.passKeyId, passKeyLink.keyId, edge);\r\n      }\r\n    }\r\n\r\n    // The graph is the single source of truth. These are lazily calculated.\r\n    // this.keyCache = null;\r\n  }\r\n\r\n  tracePath(distances, keyId: string): Edge[] {\r\n    // The node label is the same as the id of the key nodes.\r\n    const ret: Edge[] = [];\r\n    let node = keyId;\r\n    if (!distances[node].predecessor) {\r\n      return null;\r\n    }\r\n\r\n    while (distances[node].predecessor) {\r\n      const child = distances[node].predecessor;\r\n      ret.push(this.graph.edge(child, node));\r\n      node = child;\r\n    }\r\n\r\n    // After reverse, the first element is the passkey\r\n    ret.reverse();\r\n\r\n    return ret;\r\n  }\r\n\r\n  getPath(knownKeyId: string, keyId: string): Edge[] {\r\n    if (!knownKeyId || typeof knownKeyId !== 'string') {\r\n      throw new LrEncryptionException(\r\n        `Param knownKeyId wrong format: ${knownKeyId}`\r\n      );\r\n    }\r\n    if (!keyId || typeof keyId !== 'string') {\r\n      throw new LrEncryptionException(`Param keyId wrong format: ${keyId}`);\r\n    }\r\n\r\n    // => { A: { distance: 0 },\r\n    //      B: { distance: 6, predecessor: 'C' },\r\n    //      C: { distance: 4, predecessor: 'A' },\r\n    //      D: { distance: 2, predecessor: 'A' },\r\n    //      E: { distance: 8, predecessor: 'F' },\r\n    //      F: { distance: 4, predecessor: 'D' } }\r\n    const distances = graphlib.alg.dijkstra(this.graph, knownKeyId);\r\n\r\n    // Trace path from keyId to knownKeyId\r\n    return this.tracePath(distances, keyId);\r\n  }\r\n\r\n  async getJwkKey(\r\n    keyOrId: string | Key,\r\n    getKeyIdCallback?: () => Promise<string> | string\r\n  ): Promise<JWK.Key> {\r\n    return (await this.getKey(keyOrId, getKeyIdCallback)).jwk;\r\n  }\r\n\r\n  // We assume that when a keyId is fetched, the key graph\r\n  // for the key is also returned and merged into the client-side\r\n  // key graph. By insisting a keyId is returned instead of the\r\n  // actual key we ensure key-graph is consistent.\r\n  async getKey(\r\n    keyOrId: string | Key,\r\n    getKeyIdCallback?: () => Promise<string> | string\r\n  ): Promise<Key> {\r\n    let keyId = typeof keyOrId === 'string' ? keyOrId : keyOrId?.id;\r\n\r\n    if (!this.hasKey(keyId) && getKeyIdCallback) {\r\n      keyId = await getKeyIdCallback();\r\n    }\r\n    // else, continue and let it fail.\r\n\r\n    const key = this.key(keyId);\r\n    if (key.jwk) {\r\n      return key;\r\n    } else {\r\n      return this.unwrapKey(this.keyService.getCurrentMasterKey().id, keyId);\r\n    }\r\n  }\r\n\r\n  private async _unwrapLink(wrappingKey, link, dstKey) {\r\n    // console.log(\"_unwrapLink:\", link.data.keyId);\r\n    const wrappedKey = JSON.parse(link.data.wrappedKey);\r\n    // Signatures of keys contain the key itself. This way we only need\r\n    // to access the KeyLinks to decrypt/verify keys.\r\n    let nextRawKey;\r\n    if (wrappedKey.signatures) {\r\n      nextRawKey = await this.encryptionService.verify(wrappingKey, wrappedKey);\r\n    } else {\r\n      nextRawKey = await this.encryptionService.decrypt(\r\n        wrappingKey,\r\n        wrappedKey\r\n      );\r\n    }\r\n    dstKey.jwk = await KFS.asKey(nextRawKey);\r\n    dstKey.task = null;\r\n  }\r\n\r\n  private async _unwrap(key: JWK.Key, path: Edge[]): Promise<JWK.Key> {\r\n    for (const link of path) {\r\n      const dstKey = this.key(link.data.keyId);\r\n      // console.log(\"key: \", link.data.keyId);\r\n      if (dstKey.jwk) {\r\n        key = dstKey.jwk;\r\n        // console.log(\"Returning cached key: \", link.data.keyId);\r\n        continue;\r\n      }\r\n\r\n      if (!dstKey.task) {\r\n        dstKey.task = this._unwrapLink(key, link, dstKey);\r\n      }\r\n\r\n      await dstKey.task;\r\n      key = dstKey.jwk;\r\n    }\r\n\r\n    return key;\r\n  }\r\n\r\n  public async unwrapWithPassKey(\r\n    passKeyId: string,\r\n    passKey: JWK.Key,\r\n    keyId: string\r\n  ): Promise<Key> {\r\n    // Get path of the directory key.\r\n    const path = this.getPath(passKeyId, keyId);\r\n\r\n    return {\r\n      id: keyId,\r\n      jwk: await this._unwrap(passKey, path),\r\n    };\r\n  }\r\n\r\n  async unwrapKey(masterKeyId: string, keyId: string): Promise<Key> {\r\n    // The first key should be a masterKey\r\n    const masterKey = await this.keyService.loadMasterKey(masterKeyId);\r\n\r\n    if (masterKeyId === keyId) {\r\n      return masterKey;\r\n    }\r\n\r\n    // Get path of the directory key.\r\n    const path = this.getPath(masterKey.id, keyId);\r\n\r\n    return {\r\n      id: keyId,\r\n      jwk: await this._unwrap(masterKey.jwk, path),\r\n    };\r\n  }\r\n\r\n  async decryptFromString<T>(\r\n    keyOrId: string | Key,\r\n    cipherData: string,\r\n    options?: DecryptOptions\r\n  ): Promise<T> {\r\n    if (cipherData) {\r\n      const key = await this.getJwkKey(keyOrId);\r\n      return (await this.encryptionService.decrypt(\r\n        key,\r\n        JSON.parse(cipherData),\r\n        options\r\n      )) as any;\r\n    }\r\n    return null;\r\n  }\r\n\r\n  async decryptFile(keyId: string, file: any): Promise<any> {\r\n    const key = await this.getJwkKey(keyId);\r\n    return (await this.encryptionService.decrypt(key, file, {\r\n      payloadType: 'ArrayBuffer',\r\n    })) as any;\r\n  }\r\n\r\n  // TODO rename this to encrypt() and use as the most common usecase\r\n  async encryptToString(\r\n    key: string | Key | JWK.Key,\r\n    content: any\r\n  ): Promise<string> {\r\n    // Empty string should be encrypted since you want to clear the field.\r\n    // Null is not encrypted because it's not valid JSON in the old JSON spec. Use\r\n    // empty string instead. It'll function as a logic false as well.\r\n    // Note that passing in empty string means it'll be encrypted which verifies\r\n    // it's integrity. But we still want to have a way to set the DB field\r\n    // to NULL, so we explicitly return null when content == null. A null\r\n    // variable in graphql mutation on KC server clears the field to NULL.\r\n    if (content == null) {\r\n      return null;\r\n    }\r\n\r\n    const jwk = asJwk(key) || (await this.getJwkKey(key as string | Key));\r\n    return this.encryptionService.encryptToString(jwk, content);\r\n  }\r\n\r\n  // Wraps a symmetric encryption key.\r\n  // Throws exception if wrapping public keys.\r\n  async wrapKey<T>(\r\n    wrappingKey: string | Key | JWK.Key,\r\n    key: JWK.Key\r\n  ): Promise<string> {\r\n    if (!isSymmetricKey(key)) {\r\n      throw new LrBadArgumentException(\r\n        'Only allowing wrapping of symmetric keys.'\r\n      );\r\n    }\r\n\r\n    return this.encryptToString(wrappingKey, key.toJSON(true));\r\n  }\r\n\r\n  // TODO\r\n  // async wrapPublicKey<T>();\r\n  // async wrapPrivateKey<T>();\r\n\r\n  async encryptWithNewKey(wrappingKeyId: string, cipherClearJson: any) {\r\n    const key = await this.keyFactory.createKey();\r\n    const wrappedKey = await this.encryptToString(\r\n      wrappingKeyId,\r\n      key.toJSON(true)\r\n    );\r\n    const cipher = await this.encryptToString(key, cipherClearJson);\r\n\r\n    return {\r\n      key,\r\n      wrappingKeyId,\r\n      wrappedKey,\r\n      cipher,\r\n    };\r\n  }\r\n}\r\n"]}