@lifeready/core 1.0.2 → 1.0.4

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

@@ -1,237 +1,237 @@
-import { __awaiter } from "tslib";
-import { Injectable } from '@angular/core';
-import { JWK } from 'node-jose';
-import { WebCryptoService } from './web-crypto.service';
-import { LrBadArgumentException, LrSuspiciousException, } from '../_common/exceptions';
-import * as i0 from "@angular/core";
-import * as i1 from "./web-crypto.service";
-export function sha256(message) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // encode as UTF-8
-        const msgBuffer = new TextEncoder().encode(message);
-        // hash the message
-        const hashBuffer = yield crypto.subtle.digest('SHA-256', msgBuffer);
-        // convert ArrayBuffer to Array
-        const hashArray = Array.from(new Uint8Array(hashBuffer));
-        // convert bytes to hex string
-        const hashHex = hashArray
-            .map((b) => ('00' + b.toString(16)).slice(-2))
-            .join('');
-        return hashHex;
-    });
-}
-export class KeyFactoryService {
-    constructor(webCryptoService) {
-        this.webCryptoService = webCryptoService;
-        // Global keys store. Otherwise, each call to asKey creates a new keyStore.
-        // <AZ> Did not seem to improve speed.
-        // public static keyStore = JWK.createKeyStore();
-        // 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.crypto = this.webCryptoService.crypto;
-    }
-    static asKey(key, form, extras) {
-        // <AZ> Using a single global key store did not seem to improve speed.
-        // return KeyFactoryService.keyStore.add(key, form, extras);
-        return JWK.asKey(key, form, extras);
-    }
-    randomString(digits) {
-        if (digits <= 0) {
-            throw new LrBadArgumentException('digits <= 0');
-        }
-        const validChars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-        let array = new Uint32Array(digits);
-        this.crypto.getRandomValues(array);
-        array = array.map((x) => validChars.charCodeAt(x % validChars.length));
-        return String.fromCharCode.apply(null, array);
-    }
-    randomDigitsNoZeros(digits) {
-        return this.randomChoices([1, 2, 3, 4, 5, 6, 7, 8, 9], digits).join('');
-    }
-    randomChoices(array, chooseN) {
-        if (array.length <= 1) {
-            throw new LrBadArgumentException('array.length <= 0');
-        }
-        if (chooseN <= 0) {
-            throw new LrBadArgumentException('chooseN <= 0');
-        }
-        const values = new Uint32Array(chooseN);
-        this.crypto.getRandomValues(values);
-        const ret = [];
-        values.forEach((v) => ret.push(array[v % array.length]));
-        return ret;
-    }
-    createSalt() {
-        return this.randomString(16);
-    }
-    createKey() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const key = yield this.crypto.subtle.generateKey({
-                name: 'AES-GCM',
-                length: 256,
-            }, true, // whether the key is extractable (i.e. can be used in exportKey)
-            ['encrypt', 'decrypt'] // must be ["encrypt", "decrypt"] or ["wrapKey", "unwrapKey"]
-            );
-            const jwk = yield this.crypto.subtle.exportKey('jwk', key);
-            // Removing the fields not needed by node-jose
-            delete jwk.ext;
-            delete jwk.key_ops;
-            return KeyFactoryService.asKey(jwk);
-        });
-    }
-    createSignKey() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const key = yield this.crypto.subtle.generateKey({
-                name: 'HMAC',
-                hash: { name: 'SHA-512' },
-            }, true, ['sign', 'verify']);
-            const jwk = yield this.crypto.subtle.exportKey('jwk', key);
-            // Removing the fields not needed by node-jose
-            delete jwk.key_ops;
-            delete jwk.ext;
-            return KeyFactoryService.asKey(jwk);
-        });
-    }
-    createPkcKey() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // node-jose is not using Forge properly. It should be calling the async version of
-            // pki.rsa.generateKeyPair() with a callback. Instead it calls the sync version. Webcrypto
-            // does not support sync version, so it uses the javascript implementation, which is way too slow.
-            // So we generate using webcrypto and import the key.
-            // Unfortunately Elliptical Curve is not supported by Webcrypto. So we have to settle for RSA.
-            const key = yield this.crypto.subtle.generateKey({
-                name: 'RSA-OAEP',
-                modulusLength: 2048,
-                // As per suggestion: https://developer.mozilla.org/en-US/docs/Web/API/RsaHashedKeyGenParams
-                publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
-                hash: { name: 'SHA-256' },
-            }, true, // whether the key is extractable (i.e. can be used in exportKey)
-            ['encrypt', 'decrypt'] // must be ["encrypt", "decrypt"] or ["wrapKey", "unwrapKey"]
-            );
-            const jwk = yield this.crypto.subtle.exportKey('jwk', key.privateKey);
-            // Removing the fields not needed by node-jose
-            delete jwk.key_ops;
-            delete jwk.ext;
-            return KeyFactoryService.asKey(jwk);
-        });
-    }
-    createPkcSignKey() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const key = yield this.crypto.subtle.generateKey({
-                name: 'RSASSA-PKCS1-v1_5',
-                modulusLength: 2048,
-                // As per suggestion: https://developer.mozilla.org/en-US/docs/Web/API/RsaHashedKeyGenParams
-                publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
-                hash: { name: 'SHA-256' },
-            }, true, // whether the key is extractable (i.e. can be used in exportKey)
-            ['sign', 'verify'] // can be any combination of "sign" and "verify"
-            );
-            const jwk = yield this.crypto.subtle.exportKey('jwk', key.privateKey);
-            // Removing the fields not needed by node-jose
-            delete jwk.key_ops;
-            delete jwk.ext;
-            return KeyFactoryService.asKey(jwk);
-        });
-    }
-    deriveKey({ password, salt, iterations, kid, }) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const enc = new TextEncoder();
-            const rawKey = yield this.crypto.subtle.importKey('raw', enc.encode(password), 'PBKDF2', false, ['deriveBits', 'deriveKey']);
-            const passKey = yield crypto.subtle.deriveKey({
-                name: 'PBKDF2',
-                salt: new TextEncoder().encode(salt),
-                iterations,
-                hash: 'SHA-256',
-            }, rawKey, { name: 'AES-GCM', length: 256 }, true, ['encrypt', 'decrypt']);
-            const passKeyJson = yield crypto.subtle.exportKey('jwk', passKey);
-            if (kid) {
-                passKeyJson.kid = kid;
-            }
-            const jwk = yield KeyFactoryService.asKey(passKeyJson);
-            return { jwk };
-        });
-    }
-    derivePassIdp(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (params.iterations < this.MIN_PASS_IDP_PBKDF_ITER) {
-                throw new LrSuspiciousException(`The number of PassIdp key derivation iterations sent from the server (${params.iterations}) is lower than the minimum (${this.MIN_PASS_IDP_PBKDF_ITER})`);
-            }
-            return this.deriveKey(params);
-        });
-    }
-    derivePassKey(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (params.iterations < this.MIN_PASS_KEY_PBKDF_ITER) {
-                throw new LrSuspiciousException(`The number of PassKey key derivation iterations sent from the server(${params.iterations}) is lower than the minimum(${this.MIN_PASS_KEY_PBKDF_ITER})`);
-            }
-            return this.deriveKey(params);
-        });
-    }
-    deriveLbopKey(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (params.iterations < this.MIN_LBOP_KEY_PBKDF_ITER) {
-                throw new LrSuspiciousException(`The number of LbopKey key derivation iterations sent from the server(${params.iterations}) is lower than the minimum(${this.MIN_LBOP_KEY_PBKDF_ITER})`);
-            }
-            return this.deriveKey(params);
-        });
-    }
-    createKid() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // todo: AZ: node-jose source uses node's default UUID() function for kid, so just change to use that.
-            // for now, we are just creating a new key to use it's kid.
-            // The kid is a part of the JWK system. LR backend maintains the key hierarchy separately with it's own
-            // key id. But we just use it here as a double check.
-            return (yield this.createKey()).kid;
-        });
-    }
-    createPassIdpParams() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return {
-                salt: this.createSalt(),
-                iterations: this.DEFAULT_PASS_IDP_PBKDF_ITER,
-            };
-        });
-    }
-    createPassKeyParams() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return {
-                salt: this.createSalt(),
-                kid: yield this.createKid(),
-                iterations: this.DEFAULT_PASS_KEY_PBKDF_ITER,
-            };
-        });
-    }
-    createLbopKeyParams() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return {
-                salt: this.createSalt(),
-                // todo: AZ: node-jose source uses node's default UUID() function for kid, so just change to use that.
-                // for now, we are just creating a new key to use it's kid.
-                // The kid is a part of the JWK system. LR backend maintains the key hierarchy separately with it's own
-                // key id. But we just use it here as a double check.
-                kid: yield this.createKid(),
-                iterations: this.DEFAULT_PASS_KEY_PBKDF_ITER,
-            };
-        });
-    }
-}
-KeyFactoryService.ɵprov = i0.ɵɵdefineInjectable({ factory: function KeyFactoryService_Factory() { return new KeyFactoryService(i0.ɵɵinject(i1.WebCryptoService)); }, token: KeyFactoryService, providedIn: "root" });
-KeyFactoryService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-KeyFactoryService.ctorParameters = () => [
-    { type: WebCryptoService }
-];
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"key-factory.service.js","sourceRoot":"/opt/atlassian/pipelines/agent/build/projects/core/src/","sources":["lib/cryptography/key-factory.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { JWK } from 'node-jose';\nimport {\n  LbopKeyParams,\n  PassIdpParams,\n  PassKeyParams,\n  DeriveKeyResult,\n  DerivePassIdpParams,\n  DerivePassKeyParams,\n  DeriveLbopKeyParams,\n} from './cryptography.types';\nimport { WebCryptoService } from './web-crypto.service';\nimport {\n  LrBadArgumentException,\n  LrSuspiciousException,\n} from '../_common/exceptions';\n\nexport async function sha256(message) {\n  // encode as UTF-8\n  const msgBuffer = new TextEncoder().encode(message);\n\n  // hash the message\n  const hashBuffer = await crypto.subtle.digest('SHA-256', msgBuffer);\n\n  // convert ArrayBuffer to Array\n  const hashArray = Array.from(new Uint8Array(hashBuffer));\n\n  // convert bytes to hex string\n  const hashHex = hashArray\n    .map((b) => ('00' + b.toString(16)).slice(-2))\n    .join('');\n  return hashHex;\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class KeyFactoryService {\n  constructor(private webCryptoService: WebCryptoService) {\n    this.crypto = this.webCryptoService.crypto;\n  }\n  private readonly crypto;\n  // Global keys store. Otherwise, each call to asKey creates a new keyStore.\n  // <AZ> Did not seem to improve speed.\n  // public static keyStore = JWK.createKeyStore();\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  static asKey(\n    key: string | Buffer | object | JWK.RawKey,\n    form?:\n      | 'json'\n      | 'private'\n      | 'pkcs8'\n      | 'public'\n      | 'spki'\n      | 'pkix'\n      | 'x509'\n      | 'pem',\n    extras?: Record<string, unknown>\n  ): Promise<JWK.Key> {\n    // <AZ> Using a single global key store did not seem to improve speed.\n    // return KeyFactoryService.keyStore.add(key, form, extras);\n    return JWK.asKey(key, form, extras);\n  }\n\n  randomString(digits: number): string {\n    if (digits <= 0) {\n      throw new LrBadArgumentException('digits <= 0');\n    }\n    const validChars =\n      'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';\n    let array = new Uint32Array(digits);\n    this.crypto.getRandomValues(array);\n    array = array.map((x) => validChars.charCodeAt(x % validChars.length));\n    return String.fromCharCode.apply(null, array);\n  }\n\n  randomDigitsNoZeros(digits: number): string {\n    return this.randomChoices([1, 2, 3, 4, 5, 6, 7, 8, 9], digits).join('');\n  }\n\n  randomChoices<T>(array: T[], chooseN: number): T[] {\n    if (array.length <= 1) {\n      throw new LrBadArgumentException('array.length <= 0');\n    }\n    if (chooseN <= 0) {\n      throw new LrBadArgumentException('chooseN <= 0');\n    }\n    const values = new Uint32Array(chooseN);\n    this.crypto.getRandomValues(values);\n    const ret: T[] = [];\n    values.forEach((v) => ret.push(array[v % array.length]));\n    return ret;\n  }\n\n  createSalt(): string {\n    return this.randomString(16);\n  }\n\n  async createKey(): Promise<JWK.Key> {\n    const key = await this.crypto.subtle.generateKey(\n      {\n        name: 'AES-GCM',\n        length: 256, // can be  128, 192, or 256\n      },\n      true, // whether the key is extractable (i.e. can be used in exportKey)\n      ['encrypt', 'decrypt'] // must be [\"encrypt\", \"decrypt\"] or [\"wrapKey\", \"unwrapKey\"]\n    );\n\n    const jwk = await this.crypto.subtle.exportKey('jwk', key);\n\n    // Removing the fields not needed by node-jose\n    delete jwk.ext;\n    delete jwk.key_ops;\n\n    return KeyFactoryService.asKey(jwk);\n  }\n\n  async createSignKey(): Promise<JWK.Key> {\n    const key = await this.crypto.subtle.generateKey(\n      {\n        name: 'HMAC',\n        hash: { name: 'SHA-512' },\n      },\n      true,\n      ['sign', 'verify']\n    );\n\n    const jwk = await this.crypto.subtle.exportKey('jwk', key);\n\n    // Removing the fields not needed by node-jose\n    delete jwk.key_ops;\n    delete jwk.ext;\n\n    return KeyFactoryService.asKey(jwk);\n  }\n\n  async createPkcKey(): Promise<JWK.Key> {\n    // node-jose is not using Forge properly. It should be calling the async version of\n    // pki.rsa.generateKeyPair() with a callback. Instead it calls the sync version. Webcrypto\n    // does not support sync version, so it uses the javascript implementation, which is way too slow.\n    // So we generate using webcrypto and import the key.\n    // Unfortunately Elliptical Curve is not supported by Webcrypto. So we have to settle for RSA.\n    const key = await this.crypto.subtle.generateKey(\n      {\n        name: 'RSA-OAEP',\n        modulusLength: 2048, // can be 1024, 2048, 3072, 4096 ... 16384\n        // As per suggestion: https://developer.mozilla.org/en-US/docs/Web/API/RsaHashedKeyGenParams\n        publicExponent: new Uint8Array([0x01, 0x00, 0x01]),\n        hash: { name: 'SHA-256' }, // can be \"SHA-1\", \"SHA-256\", \"SHA-384\", or \"SHA-512\"\n      },\n      true, // whether the key is extractable (i.e. can be used in exportKey)\n      ['encrypt', 'decrypt'] // must be [\"encrypt\", \"decrypt\"] or [\"wrapKey\", \"unwrapKey\"]\n    );\n\n    const jwk = await this.crypto.subtle.exportKey('jwk', key.privateKey);\n    // Removing the fields not needed by node-jose\n    delete jwk.key_ops;\n    delete jwk.ext;\n\n    return KeyFactoryService.asKey(jwk);\n  }\n\n  async createPkcSignKey(): Promise<JWK.Key> {\n    const key = await this.crypto.subtle.generateKey(\n      {\n        name: 'RSASSA-PKCS1-v1_5',\n        modulusLength: 2048, // can be 1024, 2048, or 4096\n        // As per suggestion: https://developer.mozilla.org/en-US/docs/Web/API/RsaHashedKeyGenParams\n        publicExponent: new Uint8Array([0x01, 0x00, 0x01]),\n        hash: { name: 'SHA-256' }, // can be \"SHA-1\", \"SHA-256\", \"SHA-384\", or \"SHA-512\"\n      },\n      true, // whether the key is extractable (i.e. can be used in exportKey)\n      ['sign', 'verify'] // can be any combination of \"sign\" and \"verify\"\n    );\n\n    const jwk = await this.crypto.subtle.exportKey('jwk', key.privateKey);\n\n    // Removing the fields not needed by node-jose\n    delete jwk.key_ops;\n    delete jwk.ext;\n\n    return KeyFactoryService.asKey(jwk);\n  }\n\n  async deriveKey({\n    password,\n    salt,\n    iterations,\n    kid,\n  }: {\n    password: string;\n    salt: string;\n    iterations: number;\n    kid?: string;\n  }): Promise<DeriveKeyResult> {\n    const enc = new TextEncoder();\n    const rawKey = await this.crypto.subtle.importKey(\n      'raw',\n      enc.encode(password),\n      'PBKDF2',\n      false,\n      ['deriveBits', 'deriveKey']\n    );\n\n    const passKey = await crypto.subtle.deriveKey(\n      {\n        name: 'PBKDF2',\n        salt: new TextEncoder().encode(salt),\n        iterations,\n        hash: 'SHA-256',\n      },\n      rawKey,\n      { name: 'AES-GCM', length: 256 },\n      true,\n      ['encrypt', 'decrypt']\n    );\n\n    const passKeyJson: any = await crypto.subtle.exportKey('jwk', passKey);\n    if (kid) {\n      passKeyJson.kid = kid;\n    }\n\n    const jwk = await KeyFactoryService.asKey(passKeyJson);\n\n    return { jwk };\n  }\n\n  async derivePassIdp(params: DerivePassIdpParams): Promise<DeriveKeyResult> {\n    if (params.iterations < this.MIN_PASS_IDP_PBKDF_ITER) {\n      throw new LrSuspiciousException(\n        `The number of PassIdp key derivation iterations sent from the server (${params.iterations}) is lower than the minimum (${this.MIN_PASS_IDP_PBKDF_ITER})`\n      );\n    }\n    return this.deriveKey(params);\n  }\n\n  async derivePassKey(params: DerivePassKeyParams): Promise<DeriveKeyResult> {\n    if (params.iterations < this.MIN_PASS_KEY_PBKDF_ITER) {\n      throw new LrSuspiciousException(\n        `The number of PassKey key derivation iterations sent from the server(${params.iterations}) is lower than the minimum(${this.MIN_PASS_KEY_PBKDF_ITER})`\n      );\n    }\n    return this.deriveKey(params);\n  }\n\n  async deriveLbopKey(params: DeriveLbopKeyParams): Promise<DeriveKeyResult> {\n    if (params.iterations < this.MIN_LBOP_KEY_PBKDF_ITER) {\n      throw new LrSuspiciousException(\n        `The number of LbopKey key derivation iterations sent from the server(${params.iterations}) is lower than the minimum(${this.MIN_LBOP_KEY_PBKDF_ITER})`\n      );\n    }\n    return this.deriveKey(params);\n  }\n\n  async createKid(): Promise<string> {\n    // todo: AZ: node-jose source uses node's default UUID() function for kid, so just change to use that.\n    // for now, we are just creating a new key to use it's kid.\n    // The kid is a part of the JWK system. LR backend maintains the key hierarchy separately with it's own\n    // key id. But we just use it here as a double check.\n    return (await this.createKey()).kid;\n  }\n\n  async createPassIdpParams(): Promise<PassIdpParams> {\n    return {\n      salt: this.createSalt(),\n      iterations: this.DEFAULT_PASS_IDP_PBKDF_ITER,\n    };\n  }\n\n  async createPassKeyParams(): Promise<PassKeyParams> {\n    return {\n      salt: this.createSalt(),\n      kid: await this.createKid(),\n      iterations: this.DEFAULT_PASS_KEY_PBKDF_ITER,\n    };\n  }\n\n  async createLbopKeyParams(): Promise<LbopKeyParams> {\n    return {\n      salt: this.createSalt(),\n      // todo: AZ: node-jose source uses node's default UUID() function for kid, so just change to use that.\n      // for now, we are just creating a new key to use it's kid.\n      // The kid is a part of the JWK system. LR backend maintains the key hierarchy separately with it's own\n      // key id. But we just use it here as a double check.\n      kid: await this.createKid(),\n      iterations: this.DEFAULT_PASS_KEY_PBKDF_ITER,\n    };\n  }\n}\n"]}
+import { __awaiter } from "tslib";
+import { Injectable } from '@angular/core';
+import { JWK } from 'node-jose';
+import { WebCryptoService } from './web-crypto.service';
+import { LrBadArgumentException, LrSuspiciousException, } from '../_common/exceptions';
+import * as i0 from "@angular/core";
+import * as i1 from "./web-crypto.service";
+export function sha256(message) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // encode as UTF-8
+        const msgBuffer = new TextEncoder().encode(message);
+        // hash the message
+        const hashBuffer = yield crypto.subtle.digest('SHA-256', msgBuffer);
+        // convert ArrayBuffer to Array
+        const hashArray = Array.from(new Uint8Array(hashBuffer));
+        // convert bytes to hex string
+        const hashHex = hashArray
+            .map((b) => ('00' + b.toString(16)).slice(-2))
+            .join('');
+        return hashHex;
+    });
+}
+export class KeyFactoryService {
+    constructor(webCryptoService) {
+        this.webCryptoService = webCryptoService;
+        // Global keys store. Otherwise, each call to asKey creates a new keyStore.
+        // <AZ> Did not seem to improve speed.
+        // public static keyStore = JWK.createKeyStore();
+        // 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.crypto = this.webCryptoService.crypto;
+    }
+    static asKey(key, form, extras) {
+        // <AZ> Using a single global key store did not seem to improve speed.
+        // return KeyFactoryService.keyStore.add(key, form, extras);
+        return JWK.asKey(key, form, extras);
+    }
+    randomString(digits) {
+        if (digits <= 0) {
+            throw new LrBadArgumentException('digits <= 0');
+        }
+        const validChars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        let array = new Uint32Array(digits);
+        this.crypto.getRandomValues(array);
+        array = array.map((x) => validChars.charCodeAt(x % validChars.length));
+        return String.fromCharCode.apply(null, array);
+    }
+    randomDigitsNoZeros(digits) {
+        return this.randomChoices([1, 2, 3, 4, 5, 6, 7, 8, 9], digits).join('');
+    }
+    randomChoices(array, chooseN) {
+        if (array.length <= 1) {
+            throw new LrBadArgumentException('array.length <= 0');
+        }
+        if (chooseN <= 0) {
+            throw new LrBadArgumentException('chooseN <= 0');
+        }
+        const values = new Uint32Array(chooseN);
+        this.crypto.getRandomValues(values);
+        const ret = [];
+        values.forEach((v) => ret.push(array[v % array.length]));
+        return ret;
+    }
+    createSalt() {
+        return this.randomString(16);
+    }
+    createKey() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = yield this.crypto.subtle.generateKey({
+                name: 'AES-GCM',
+                length: 256,
+            }, true, // whether the key is extractable (i.e. can be used in exportKey)
+            ['encrypt', 'decrypt'] // must be ["encrypt", "decrypt"] or ["wrapKey", "unwrapKey"]
+            );
+            const jwk = yield this.crypto.subtle.exportKey('jwk', key);
+            // Removing the fields not needed by node-jose
+            delete jwk.ext;
+            delete jwk.key_ops;
+            return KeyFactoryService.asKey(jwk);
+        });
+    }
+    createSignKey() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = yield this.crypto.subtle.generateKey({
+                name: 'HMAC',
+                hash: { name: 'SHA-512' },
+            }, true, ['sign', 'verify']);
+            const jwk = yield this.crypto.subtle.exportKey('jwk', key);
+            // Removing the fields not needed by node-jose
+            delete jwk.key_ops;
+            delete jwk.ext;
+            return KeyFactoryService.asKey(jwk);
+        });
+    }
+    createPkcKey() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // node-jose is not using Forge properly. It should be calling the async version of
+            // pki.rsa.generateKeyPair() with a callback. Instead it calls the sync version. Webcrypto
+            // does not support sync version, so it uses the javascript implementation, which is way too slow.
+            // So we generate using webcrypto and import the key.
+            // Unfortunately Elliptical Curve is not supported by Webcrypto. So we have to settle for RSA.
+            const key = yield this.crypto.subtle.generateKey({
+                name: 'RSA-OAEP',
+                modulusLength: 2048,
+                // As per suggestion: https://developer.mozilla.org/en-US/docs/Web/API/RsaHashedKeyGenParams
+                publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
+                hash: { name: 'SHA-256' },
+            }, true, // whether the key is extractable (i.e. can be used in exportKey)
+            ['encrypt', 'decrypt'] // must be ["encrypt", "decrypt"] or ["wrapKey", "unwrapKey"]
+            );
+            const jwk = yield this.crypto.subtle.exportKey('jwk', key.privateKey);
+            // Removing the fields not needed by node-jose
+            delete jwk.key_ops;
+            delete jwk.ext;
+            return KeyFactoryService.asKey(jwk);
+        });
+    }
+    createPkcSignKey() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = yield this.crypto.subtle.generateKey({
+                name: 'RSASSA-PKCS1-v1_5',
+                modulusLength: 2048,
+                // As per suggestion: https://developer.mozilla.org/en-US/docs/Web/API/RsaHashedKeyGenParams
+                publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
+                hash: { name: 'SHA-256' },
+            }, true, // whether the key is extractable (i.e. can be used in exportKey)
+            ['sign', 'verify'] // can be any combination of "sign" and "verify"
+            );
+            const jwk = yield this.crypto.subtle.exportKey('jwk', key.privateKey);
+            // Removing the fields not needed by node-jose
+            delete jwk.key_ops;
+            delete jwk.ext;
+            return KeyFactoryService.asKey(jwk);
+        });
+    }
+    deriveKey({ password, salt, iterations, kid, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const enc = new TextEncoder();
+            const rawKey = yield this.crypto.subtle.importKey('raw', enc.encode(password), 'PBKDF2', false, ['deriveBits', 'deriveKey']);
+            const passKey = yield crypto.subtle.deriveKey({
+                name: 'PBKDF2',
+                salt: new TextEncoder().encode(salt),
+                iterations,
+                hash: 'SHA-256',
+            }, rawKey, { name: 'AES-GCM', length: 256 }, true, ['encrypt', 'decrypt']);
+            const passKeyJson = yield crypto.subtle.exportKey('jwk', passKey);
+            if (kid) {
+                passKeyJson.kid = kid;
+            }
+            const jwk = yield KeyFactoryService.asKey(passKeyJson);
+            return { jwk };
+        });
+    }
+    derivePassIdp(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (params.iterations < this.MIN_PASS_IDP_PBKDF_ITER) {
+                throw new LrSuspiciousException(`The number of PassIdp key derivation iterations sent from the server (${params.iterations}) is lower than the minimum (${this.MIN_PASS_IDP_PBKDF_ITER})`);
+            }
+            return this.deriveKey(params);
+        });
+    }
+    derivePassKey(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (params.iterations < this.MIN_PASS_KEY_PBKDF_ITER) {
+                throw new LrSuspiciousException(`The number of PassKey key derivation iterations sent from the server(${params.iterations}) is lower than the minimum(${this.MIN_PASS_KEY_PBKDF_ITER})`);
+            }
+            return this.deriveKey(params);
+        });
+    }
+    deriveLbopKey(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (params.iterations < this.MIN_LBOP_KEY_PBKDF_ITER) {
+                throw new LrSuspiciousException(`The number of LbopKey key derivation iterations sent from the server(${params.iterations}) is lower than the minimum(${this.MIN_LBOP_KEY_PBKDF_ITER})`);
+            }
+            return this.deriveKey(params);
+        });
+    }
+    createKid() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // todo: AZ: node-jose source uses node's default UUID() function for kid, so just change to use that.
+            // for now, we are just creating a new key to use it's kid.
+            // The kid is a part of the JWK system. LR backend maintains the key hierarchy separately with it's own
+            // key id. But we just use it here as a double check.
+            return (yield this.createKey()).kid;
+        });
+    }
+    createPassIdpParams() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return {
+                salt: this.createSalt(),
+                iterations: this.DEFAULT_PASS_IDP_PBKDF_ITER,
+            };
+        });
+    }
+    createPassKeyParams() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return {
+                salt: this.createSalt(),
+                kid: yield this.createKid(),
+                iterations: this.DEFAULT_PASS_KEY_PBKDF_ITER,
+            };
+        });
+    }
+    createLbopKeyParams() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return {
+                salt: this.createSalt(),
+                // todo: AZ: node-jose source uses node's default UUID() function for kid, so just change to use that.
+                // for now, we are just creating a new key to use it's kid.
+                // The kid is a part of the JWK system. LR backend maintains the key hierarchy separately with it's own
+                // key id. But we just use it here as a double check.
+                kid: yield this.createKid(),
+                iterations: this.DEFAULT_PASS_KEY_PBKDF_ITER,
+            };
+        });
+    }
+}
+KeyFactoryService.ɵprov = i0.ɵɵdefineInjectable({ factory: function KeyFactoryService_Factory() { return new KeyFactoryService(i0.ɵɵinject(i1.WebCryptoService)); }, token: KeyFactoryService, providedIn: "root" });
+KeyFactoryService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+KeyFactoryService.ctorParameters = () => [
+    { type: WebCryptoService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"key-factory.service.js","sourceRoot":"C:/Projects/newrepo/kc-client/projects/core/src/","sources":["lib/cryptography/key-factory.service.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAUhC,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EACL,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,uBAAuB,CAAC;;;AAE/B,MAAM,UAAgB,MAAM,CAAC,OAAO;;QAClC,kBAAkB;QAClB,MAAM,SAAS,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAEpD,mBAAmB;QACnB,MAAM,UAAU,GAAG,MAAM,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;QAEpE,+BAA+B;QAC/B,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC;QAEzD,8BAA8B;QAC9B,MAAM,OAAO,GAAG,SAAS;aACtB,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;aAC7C,IAAI,CAAC,EAAE,CAAC,CAAC;QACZ,OAAO,OAAO,CAAC;IACjB,CAAC;CAAA;AAKD,MAAM,OAAO,iBAAiB;IAC5B,YAAoB,gBAAkC;QAAlC,qBAAgB,GAAhB,gBAAgB,CAAkB;QAItD,2EAA2E;QAC3E,sCAAsC;QACtC,iDAAiD;QAEjD,+EAA+E;QAC/E,mFAAmF;QACnF,qFAAqF;QACrF,+EAA+E;QAC/E,gDAAgD;QAChC,4BAAuB,GAAG,MAAM,CAAC;QACjC,4BAAuB,GAAG,MAAM,CAAC;QACjC,4BAAuB,GAAG,MAAM,CAAC;QAEjD,qFAAqF;QACrE,gCAA2B,GAAG,IAAI,CAAC,uBAAuB,CAAC;QAC3D,gCAA2B,GAAG,IAAI,CAAC,uBAAuB,CAAC;QAC3D,gCAA2B,GAAG,IAAI,CAAC,uBAAuB,CAAC;QAnBzE,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC;IAC7C,CAAC;IAoBD,MAAM,CAAC,KAAK,CACV,GAA0C,EAC1C,IAQS,EACT,MAAgC;QAEhC,sEAAsE;QACtE,4DAA4D;QAC5D,OAAO,GAAG,CAAC,KAAK,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;IACtC,CAAC;IAED,YAAY,CAAC,MAAc;QACzB,IAAI,MAAM,IAAI,CAAC,EAAE;YACf,MAAM,IAAI,sBAAsB,CAAC,aAAa,CAAC,CAAC;SACjD;QACD,MAAM,UAAU,GACd,gEAAgE,CAAC;QACnE,IAAI,KAAK,GAAG,IAAI,WAAW,CAAC,MAAM,CAAC,CAAC;QACpC,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;QACnC,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC;QACvE,OAAO,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAChD,CAAC;IAED,mBAAmB,CAAC,MAAc;QAChC,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC1E,CAAC;IAED,aAAa,CAAI,KAAU,EAAE,OAAe;QAC1C,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC,EAAE;YACrB,MAAM,IAAI,sBAAsB,CAAC,mBAAmB,CAAC,CAAC;SACvD;QACD,IAAI,OAAO,IAAI,CAAC,EAAE;YAChB,MAAM,IAAI,sBAAsB,CAAC,cAAc,CAAC,CAAC;SAClD;QACD,MAAM,MAAM,GAAG,IAAI,WAAW,CAAC,OAAO,CAAC,CAAC;QACxC,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;QACpC,MAAM,GAAG,GAAQ,EAAE,CAAC;QACpB,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QACzD,OAAO,GAAG,CAAC;IACb,CAAC;IAED,UAAU;QACR,OAAO,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC;IAC/B,CAAC;IAEK,SAAS;;YACb,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,WAAW,CAC9C;gBACE,IAAI,EAAE,SAAS;gBACf,MAAM,EAAE,GAAG;aACZ,EACD,IAAI,EAAE,iEAAiE;YACvE,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,6DAA6D;aACrF,CAAC;YAEF,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;YAE3D,8CAA8C;YAC9C,OAAO,GAAG,CAAC,GAAG,CAAC;YACf,OAAO,GAAG,CAAC,OAAO,CAAC;YAEnB,OAAO,iBAAiB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACtC,CAAC;KAAA;IAEK,aAAa;;YACjB,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,WAAW,CAC9C;gBACE,IAAI,EAAE,MAAM;gBACZ,IAAI,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE;aAC1B,EACD,IAAI,EACJ,CAAC,MAAM,EAAE,QAAQ,CAAC,CACnB,CAAC;YAEF,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;YAE3D,8CAA8C;YAC9C,OAAO,GAAG,CAAC,OAAO,CAAC;YACnB,OAAO,GAAG,CAAC,GAAG,CAAC;YAEf,OAAO,iBAAiB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACtC,CAAC;KAAA;IAEK,YAAY;;YAChB,mFAAmF;YACnF,0FAA0F;YAC1F,kGAAkG;YAClG,qDAAqD;YACrD,8FAA8F;YAC9F,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,WAAW,CAC9C;gBACE,IAAI,EAAE,UAAU;gBAChB,aAAa,EAAE,IAAI;gBACnB,4FAA4F;gBAC5F,cAAc,EAAE,IAAI,UAAU,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;gBAClD,IAAI,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE;aAC1B,EACD,IAAI,EAAE,iEAAiE;YACvE,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC,6DAA6D;aACrF,CAAC;YAEF,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC,UAAU,CAAC,CAAC;YACtE,8CAA8C;YAC9C,OAAO,GAAG,CAAC,OAAO,CAAC;YACnB,OAAO,GAAG,CAAC,GAAG,CAAC;YAEf,OAAO,iBAAiB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACtC,CAAC;KAAA;IAEK,gBAAgB;;YACpB,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,WAAW,CAC9C;gBACE,IAAI,EAAE,mBAAmB;gBACzB,aAAa,EAAE,IAAI;gBACnB,4FAA4F;gBAC5F,cAAc,EAAE,IAAI,UAAU,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;gBAClD,IAAI,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE;aAC1B,EACD,IAAI,EAAE,iEAAiE;YACvE,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,gDAAgD;aACpE,CAAC;YAEF,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,GAAG,CAAC,UAAU,CAAC,CAAC;YAEtE,8CAA8C;YAC9C,OAAO,GAAG,CAAC,OAAO,CAAC;YACnB,OAAO,GAAG,CAAC,GAAG,CAAC;YAEf,OAAO,iBAAiB,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACtC,CAAC;KAAA;IAEK,SAAS,CAAC,EACd,QAAQ,EACR,IAAI,EACJ,UAAU,EACV,GAAG,GAMJ;;YACC,MAAM,GAAG,GAAG,IAAI,WAAW,EAAE,CAAC;YAC9B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,SAAS,CAC/C,KAAK,EACL,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC,EACpB,QAAQ,EACR,KAAK,EACL,CAAC,YAAY,EAAE,WAAW,CAAC,CAC5B,CAAC;YAEF,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,MAAM,CAAC,SAAS,CAC3C;gBACE,IAAI,EAAE,QAAQ;gBACd,IAAI,EAAE,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC;gBACpC,UAAU;gBACV,IAAI,EAAE,SAAS;aAChB,EACD,MAAM,EACN,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,EAChC,IAAI,EACJ,CAAC,SAAS,EAAE,SAAS,CAAC,CACvB,CAAC;YAEF,MAAM,WAAW,GAAQ,MAAM,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;YACvE,IAAI,GAAG,EAAE;gBACP,WAAW,CAAC,GAAG,GAAG,GAAG,CAAC;aACvB;YAED,MAAM,GAAG,GAAG,MAAM,iBAAiB,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;YAEvD,OAAO,EAAE,GAAG,EAAE,CAAC;QACjB,CAAC;KAAA;IAEK,aAAa,CAAC,MAA2B;;YAC7C,IAAI,MAAM,CAAC,UAAU,GAAG,IAAI,CAAC,uBAAuB,EAAE;gBACpD,MAAM,IAAI,qBAAqB,CAC7B,yEAAyE,MAAM,CAAC,UAAU,gCAAgC,IAAI,CAAC,uBAAuB,GAAG,CAC1J,CAAC;aACH;YACD,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QAChC,CAAC;KAAA;IAEK,aAAa,CAAC,MAA2B;;YAC7C,IAAI,MAAM,CAAC,UAAU,GAAG,IAAI,CAAC,uBAAuB,EAAE;gBACpD,MAAM,IAAI,qBAAqB,CAC7B,wEAAwE,MAAM,CAAC,UAAU,+BAA+B,IAAI,CAAC,uBAAuB,GAAG,CACxJ,CAAC;aACH;YACD,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QAChC,CAAC;KAAA;IAEK,aAAa,CAAC,MAA2B;;YAC7C,IAAI,MAAM,CAAC,UAAU,GAAG,IAAI,CAAC,uBAAuB,EAAE;gBACpD,MAAM,IAAI,qBAAqB,CAC7B,wEAAwE,MAAM,CAAC,UAAU,+BAA+B,IAAI,CAAC,uBAAuB,GAAG,CACxJ,CAAC;aACH;YACD,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;QAChC,CAAC;KAAA;IAEK,SAAS;;YACb,sGAAsG;YACtG,2DAA2D;YAC3D,uGAAuG;YACvG,qDAAqD;YACrD,OAAO,CAAC,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC,CAAC,GAAG,CAAC;QACtC,CAAC;KAAA;IAEK,mBAAmB;;YACvB,OAAO;gBACL,IAAI,EAAE,IAAI,CAAC,UAAU,EAAE;gBACvB,UAAU,EAAE,IAAI,CAAC,2BAA2B;aAC7C,CAAC;QACJ,CAAC;KAAA;IAEK,mBAAmB;;YACvB,OAAO;gBACL,IAAI,EAAE,IAAI,CAAC,UAAU,EAAE;gBACvB,GAAG,EAAE,MAAM,IAAI,CAAC,SAAS,EAAE;gBAC3B,UAAU,EAAE,IAAI,CAAC,2BAA2B;aAC7C,CAAC;QACJ,CAAC;KAAA;IAEK,mBAAmB;;YACvB,OAAO;gBACL,IAAI,EAAE,IAAI,CAAC,UAAU,EAAE;gBACvB,sGAAsG;gBACtG,2DAA2D;gBAC3D,uGAAuG;gBACvG,qDAAqD;gBACrD,GAAG,EAAE,MAAM,IAAI,CAAC,SAAS,EAAE;gBAC3B,UAAU,EAAE,IAAI,CAAC,2BAA2B;aAC7C,CAAC;QACJ,CAAC;KAAA;;;;YA3QF,UAAU,SAAC;gBACV,UAAU,EAAE,MAAM;aACnB;;;YAzBQ,gBAAgB","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { JWK } from 'node-jose';\r\nimport {\r\n  LbopKeyParams,\r\n  PassIdpParams,\r\n  PassKeyParams,\r\n  DeriveKeyResult,\r\n  DerivePassIdpParams,\r\n  DerivePassKeyParams,\r\n  DeriveLbopKeyParams,\r\n} from './cryptography.types';\r\nimport { WebCryptoService } from './web-crypto.service';\r\nimport {\r\n  LrBadArgumentException,\r\n  LrSuspiciousException,\r\n} from '../_common/exceptions';\r\n\r\nexport async function sha256(message) {\r\n  // encode as UTF-8\r\n  const msgBuffer = new TextEncoder().encode(message);\r\n\r\n  // hash the message\r\n  const hashBuffer = await crypto.subtle.digest('SHA-256', msgBuffer);\r\n\r\n  // convert ArrayBuffer to Array\r\n  const hashArray = Array.from(new Uint8Array(hashBuffer));\r\n\r\n  // convert bytes to hex string\r\n  const hashHex = hashArray\r\n    .map((b) => ('00' + b.toString(16)).slice(-2))\r\n    .join('');\r\n  return hashHex;\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class KeyFactoryService {\r\n  constructor(private webCryptoService: WebCryptoService) {\r\n    this.crypto = this.webCryptoService.crypto;\r\n  }\r\n  private readonly crypto;\r\n  // Global keys store. Otherwise, each call to asKey creates a new keyStore.\r\n  // <AZ> Did not seem to improve speed.\r\n  // public static keyStore = JWK.createKeyStore();\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  static asKey(\r\n    key: string | Buffer | object | JWK.RawKey,\r\n    form?:\r\n      | 'json'\r\n      | 'private'\r\n      | 'pkcs8'\r\n      | 'public'\r\n      | 'spki'\r\n      | 'pkix'\r\n      | 'x509'\r\n      | 'pem',\r\n    extras?: Record<string, unknown>\r\n  ): Promise<JWK.Key> {\r\n    // <AZ> Using a single global key store did not seem to improve speed.\r\n    // return KeyFactoryService.keyStore.add(key, form, extras);\r\n    return JWK.asKey(key, form, extras);\r\n  }\r\n\r\n  randomString(digits: number): string {\r\n    if (digits <= 0) {\r\n      throw new LrBadArgumentException('digits <= 0');\r\n    }\r\n    const validChars =\r\n      'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';\r\n    let array = new Uint32Array(digits);\r\n    this.crypto.getRandomValues(array);\r\n    array = array.map((x) => validChars.charCodeAt(x % validChars.length));\r\n    return String.fromCharCode.apply(null, array);\r\n  }\r\n\r\n  randomDigitsNoZeros(digits: number): string {\r\n    return this.randomChoices([1, 2, 3, 4, 5, 6, 7, 8, 9], digits).join('');\r\n  }\r\n\r\n  randomChoices<T>(array: T[], chooseN: number): T[] {\r\n    if (array.length <= 1) {\r\n      throw new LrBadArgumentException('array.length <= 0');\r\n    }\r\n    if (chooseN <= 0) {\r\n      throw new LrBadArgumentException('chooseN <= 0');\r\n    }\r\n    const values = new Uint32Array(chooseN);\r\n    this.crypto.getRandomValues(values);\r\n    const ret: T[] = [];\r\n    values.forEach((v) => ret.push(array[v % array.length]));\r\n    return ret;\r\n  }\r\n\r\n  createSalt(): string {\r\n    return this.randomString(16);\r\n  }\r\n\r\n  async createKey(): Promise<JWK.Key> {\r\n    const key = await this.crypto.subtle.generateKey(\r\n      {\r\n        name: 'AES-GCM',\r\n        length: 256, // can be  128, 192, or 256\r\n      },\r\n      true, // whether the key is extractable (i.e. can be used in exportKey)\r\n      ['encrypt', 'decrypt'] // must be [\"encrypt\", \"decrypt\"] or [\"wrapKey\", \"unwrapKey\"]\r\n    );\r\n\r\n    const jwk = await this.crypto.subtle.exportKey('jwk', key);\r\n\r\n    // Removing the fields not needed by node-jose\r\n    delete jwk.ext;\r\n    delete jwk.key_ops;\r\n\r\n    return KeyFactoryService.asKey(jwk);\r\n  }\r\n\r\n  async createSignKey(): Promise<JWK.Key> {\r\n    const key = await this.crypto.subtle.generateKey(\r\n      {\r\n        name: 'HMAC',\r\n        hash: { name: 'SHA-512' },\r\n      },\r\n      true,\r\n      ['sign', 'verify']\r\n    );\r\n\r\n    const jwk = await this.crypto.subtle.exportKey('jwk', key);\r\n\r\n    // Removing the fields not needed by node-jose\r\n    delete jwk.key_ops;\r\n    delete jwk.ext;\r\n\r\n    return KeyFactoryService.asKey(jwk);\r\n  }\r\n\r\n  async createPkcKey(): Promise<JWK.Key> {\r\n    // node-jose is not using Forge properly. It should be calling the async version of\r\n    // pki.rsa.generateKeyPair() with a callback. Instead it calls the sync version. Webcrypto\r\n    // does not support sync version, so it uses the javascript implementation, which is way too slow.\r\n    // So we generate using webcrypto and import the key.\r\n    // Unfortunately Elliptical Curve is not supported by Webcrypto. So we have to settle for RSA.\r\n    const key = await this.crypto.subtle.generateKey(\r\n      {\r\n        name: 'RSA-OAEP',\r\n        modulusLength: 2048, // can be 1024, 2048, 3072, 4096 ... 16384\r\n        // As per suggestion: https://developer.mozilla.org/en-US/docs/Web/API/RsaHashedKeyGenParams\r\n        publicExponent: new Uint8Array([0x01, 0x00, 0x01]),\r\n        hash: { name: 'SHA-256' }, // can be \"SHA-1\", \"SHA-256\", \"SHA-384\", or \"SHA-512\"\r\n      },\r\n      true, // whether the key is extractable (i.e. can be used in exportKey)\r\n      ['encrypt', 'decrypt'] // must be [\"encrypt\", \"decrypt\"] or [\"wrapKey\", \"unwrapKey\"]\r\n    );\r\n\r\n    const jwk = await this.crypto.subtle.exportKey('jwk', key.privateKey);\r\n    // Removing the fields not needed by node-jose\r\n    delete jwk.key_ops;\r\n    delete jwk.ext;\r\n\r\n    return KeyFactoryService.asKey(jwk);\r\n  }\r\n\r\n  async createPkcSignKey(): Promise<JWK.Key> {\r\n    const key = await this.crypto.subtle.generateKey(\r\n      {\r\n        name: 'RSASSA-PKCS1-v1_5',\r\n        modulusLength: 2048, // can be 1024, 2048, or 4096\r\n        // As per suggestion: https://developer.mozilla.org/en-US/docs/Web/API/RsaHashedKeyGenParams\r\n        publicExponent: new Uint8Array([0x01, 0x00, 0x01]),\r\n        hash: { name: 'SHA-256' }, // can be \"SHA-1\", \"SHA-256\", \"SHA-384\", or \"SHA-512\"\r\n      },\r\n      true, // whether the key is extractable (i.e. can be used in exportKey)\r\n      ['sign', 'verify'] // can be any combination of \"sign\" and \"verify\"\r\n    );\r\n\r\n    const jwk = await this.crypto.subtle.exportKey('jwk', key.privateKey);\r\n\r\n    // Removing the fields not needed by node-jose\r\n    delete jwk.key_ops;\r\n    delete jwk.ext;\r\n\r\n    return KeyFactoryService.asKey(jwk);\r\n  }\r\n\r\n  async deriveKey({\r\n    password,\r\n    salt,\r\n    iterations,\r\n    kid,\r\n  }: {\r\n    password: string;\r\n    salt: string;\r\n    iterations: number;\r\n    kid?: string;\r\n  }): Promise<DeriveKeyResult> {\r\n    const enc = new TextEncoder();\r\n    const rawKey = await this.crypto.subtle.importKey(\r\n      'raw',\r\n      enc.encode(password),\r\n      'PBKDF2',\r\n      false,\r\n      ['deriveBits', 'deriveKey']\r\n    );\r\n\r\n    const passKey = await crypto.subtle.deriveKey(\r\n      {\r\n        name: 'PBKDF2',\r\n        salt: new TextEncoder().encode(salt),\r\n        iterations,\r\n        hash: 'SHA-256',\r\n      },\r\n      rawKey,\r\n      { name: 'AES-GCM', length: 256 },\r\n      true,\r\n      ['encrypt', 'decrypt']\r\n    );\r\n\r\n    const passKeyJson: any = await crypto.subtle.exportKey('jwk', passKey);\r\n    if (kid) {\r\n      passKeyJson.kid = kid;\r\n    }\r\n\r\n    const jwk = await KeyFactoryService.asKey(passKeyJson);\r\n\r\n    return { jwk };\r\n  }\r\n\r\n  async derivePassIdp(params: DerivePassIdpParams): Promise<DeriveKeyResult> {\r\n    if (params.iterations < this.MIN_PASS_IDP_PBKDF_ITER) {\r\n      throw new LrSuspiciousException(\r\n        `The number of PassIdp key derivation iterations sent from the server (${params.iterations}) is lower than the minimum (${this.MIN_PASS_IDP_PBKDF_ITER})`\r\n      );\r\n    }\r\n    return this.deriveKey(params);\r\n  }\r\n\r\n  async derivePassKey(params: DerivePassKeyParams): Promise<DeriveKeyResult> {\r\n    if (params.iterations < this.MIN_PASS_KEY_PBKDF_ITER) {\r\n      throw new LrSuspiciousException(\r\n        `The number of PassKey key derivation iterations sent from the server(${params.iterations}) is lower than the minimum(${this.MIN_PASS_KEY_PBKDF_ITER})`\r\n      );\r\n    }\r\n    return this.deriveKey(params);\r\n  }\r\n\r\n  async deriveLbopKey(params: DeriveLbopKeyParams): Promise<DeriveKeyResult> {\r\n    if (params.iterations < this.MIN_LBOP_KEY_PBKDF_ITER) {\r\n      throw new LrSuspiciousException(\r\n        `The number of LbopKey key derivation iterations sent from the server(${params.iterations}) is lower than the minimum(${this.MIN_LBOP_KEY_PBKDF_ITER})`\r\n      );\r\n    }\r\n    return this.deriveKey(params);\r\n  }\r\n\r\n  async createKid(): Promise<string> {\r\n    // todo: AZ: node-jose source uses node's default UUID() function for kid, so just change to use that.\r\n    // for now, we are just creating a new key to use it's kid.\r\n    // The kid is a part of the JWK system. LR backend maintains the key hierarchy separately with it's own\r\n    // key id. But we just use it here as a double check.\r\n    return (await this.createKey()).kid;\r\n  }\r\n\r\n  async createPassIdpParams(): Promise<PassIdpParams> {\r\n    return {\r\n      salt: this.createSalt(),\r\n      iterations: this.DEFAULT_PASS_IDP_PBKDF_ITER,\r\n    };\r\n  }\r\n\r\n  async createPassKeyParams(): Promise<PassKeyParams> {\r\n    return {\r\n      salt: this.createSalt(),\r\n      kid: await this.createKid(),\r\n      iterations: this.DEFAULT_PASS_KEY_PBKDF_ITER,\r\n    };\r\n  }\r\n\r\n  async createLbopKeyParams(): Promise<LbopKeyParams> {\r\n    return {\r\n      salt: this.createSalt(),\r\n      // todo: AZ: node-jose source uses node's default UUID() function for kid, so just change to use that.\r\n      // for now, we are just creating a new key to use it's kid.\r\n      // The kid is a part of the JWK system. LR backend maintains the key hierarchy separately with it's own\r\n      // key id. But we just use it here as a double check.\r\n      kid: await this.createKid(),\r\n      iterations: this.DEFAULT_PASS_KEY_PBKDF_ITER,\r\n    };\r\n  }\r\n}\r\n"]}