@lifeready/core 0.6.0-beta.1

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

@@ -0,0 +1,189 @@
+import { __awaiter } from "tslib";
+import { LrException, LrErrorCode, LrBadArgumentException, } from './../_common/exceptions';
+import { Injectable } from '@angular/core';
+import { JWE, JWS } from 'node-jose';
+import { TimeService } from '../api/time.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../api/time.service";
+export var JoseSerialization;
+(function (JoseSerialization) {
+    JoseSerialization["JSON"] = "JSON";
+    JoseSerialization["COMPACT"] = "COMPACT";
+})(JoseSerialization || (JoseSerialization = {}));
+export const VERIFY_OPTIONS_DEFAULT = {
+    payloadType: 'json',
+    returnOnlyPayload: true,
+};
+export const DECRYPT_OPTIONS_DEFAULT = {
+    payloadType: 'json',
+    returnOnlyPayload: true,
+    serializations: [JoseSerialization.JSON],
+};
+export function isSymmetricKey(key) {
+    // TODO: make sure this covers all cases.
+    return key.kty === 'oct';
+}
+export function asJwk(key) {
+    // TODO: make sure this covers all cases.
+    // Excluded:
+    //   key.use - only for public keys, Ref: https://tools.ietf.org/html/rfc7517#section-4.2
+    if (key.id && key.jwk) {
+        return key.jwk;
+    }
+    else if (key.keystore && key.length && key.kty && key.kid && key.alg) {
+        return key;
+    }
+    else {
+        return null;
+    }
+}
+export class EncryptionService {
+    constructor(timeService) {
+        this.timeService = timeService;
+    }
+    decrypt(key, // string is assumed to be key.id, will unwrap key.
+    jwe, // string will be JSON.parsed
+    options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const opt = {
+                algorithms: ['dir', 'A*GCM', 'RSA-OAEP-*'],
+            };
+            options = Object.assign(Object.assign({}, DECRYPT_OPTIONS_DEFAULT), options);
+            if (key.jwk) {
+                key = key.jwk;
+            }
+            if (typeof jwe === 'string') {
+                if (options.serializations.includes(JoseSerialization.JSON)) {
+                    try {
+                        jwe = JSON.parse(jwe);
+                    }
+                    catch (error) {
+                        if (options.serializations.includes(JoseSerialization.COMPACT)) {
+                            console.log('Not a JSON-formatted JWE, it maybe compact serialisation format.');
+                        }
+                        else {
+                            throw error;
+                        }
+                    }
+                }
+            }
+            // {result} is a Object with:
+            // *  header: the combined 'protected' and 'unprotected' header members
+            // *  protected: an array of the member names from the "protected" member
+            // *  key: Key used to decrypt
+            // *  payload: Buffer of the decrypted content
+            // *  plaintext: Buffer of the decrypted content (alternate), just a reference to payload
+            const res = yield JWE.createDecrypt(key, opt).decrypt(jwe);
+            res.payload = this.decodePayload(options.payloadType, res.payload);
+            if (options.returnOnlyPayload) {
+                return res.payload;
+            }
+            else {
+                return res;
+            }
+        });
+    }
+    // TODO rename this to encrypt() and use as the most common usecase
+    encryptToString(key, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return JSON.stringify(yield this.encrypt(key, content));
+        });
+    }
+    // TODO rename this to encryptToJSON() and use this when required.
+    encrypt(key, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!content) {
+                throw new Error('Encrypting empty content.');
+            }
+            if (!(content instanceof ArrayBuffer)) {
+                content = new TextEncoder().encode(JSON.stringify(content));
+            }
+            return JWE.createEncrypt({
+                contentAlg: 'A256GCM',
+                fields: {
+                    timestamp: yield this.timeService.serverNow(),
+                },
+            }, key)
+                .update(content)
+                .final();
+        });
+    }
+    // <AZ> Unlike signContent, the serialised "content" variable is contained inside
+    // the result. So ordering of fields within "content" is not an issue.
+    sign(key, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const signer = JWS.createSign({
+                fields: {
+                    timestamp: yield this.timeService.serverNow(),
+                },
+            }, key);
+            if (content instanceof Buffer) {
+                signer.update(content);
+            }
+            else {
+                signer.update(JSON.stringify(content), 'utf8');
+            }
+            return signer.final();
+        });
+    }
+    signToString(key, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return JSON.stringify(yield this.sign(key, content));
+        });
+    }
+    verify(key, jws, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const opt = {
+                algorithms: ['RS*'],
+            };
+            options = Object.assign(Object.assign({}, VERIFY_OPTIONS_DEFAULT), options);
+            try {
+                const res = yield JWS.createVerify(key, opt).verify(jws);
+                res.payload = this.decodePayload(options.payloadType, res.payload);
+                if (options.returnOnlyPayload) {
+                    return res.payload;
+                }
+                else {
+                    return res;
+                }
+            }
+            catch (error) {
+                throw new LrException({
+                    code: LrErrorCode.BadSignature,
+                    message: `Bad signature: ${error}`,
+                });
+            }
+        });
+    }
+    encryptThenSign({ key, sigPrk, }, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cipher = JSON.stringify(yield this.encrypt(key, content));
+            const sig = yield this.sign(sigPrk, cipher);
+            delete sig.payload;
+            return {
+                cipher,
+                sig: JSON.stringify(sig),
+            };
+        });
+    }
+    decodePayload(payloadType, payload) {
+        switch (payloadType) {
+            case 'json':
+                return JSON.parse(new TextDecoder().decode(payload));
+            case 'ArrayBuffer':
+                return payload;
+            default:
+                throw new LrBadArgumentException(`Unknown payloadType: ${payloadType}`);
+        }
+    }
+}
+EncryptionService.ɵprov = i0.ɵɵdefineInjectable({ factory: function EncryptionService_Factory() { return new EncryptionService(i0.ɵɵinject(i1.TimeService)); }, token: EncryptionService, providedIn: "root" });
+EncryptionService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+EncryptionService.ctorParameters = () => [
+    { type: TimeService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"encryption.service.js","sourceRoot":"C:/Projects/test/projects/core/src/","sources":["lib/cryptography/encryption.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  LrException,\r\n  LrErrorCode,\r\n  LrBadArgumentException,\r\n} from './../_common/exceptions';\r\nimport { ComponentFactoryResolver, Injectable } from '@angular/core';\r\nimport { JWE, JWK, JWS, util } from 'node-jose';\r\nimport { Key, PayloadType } from './cryptography.types';\r\nimport { TimeService } from '../api/time.service';\r\n\r\nexport enum JoseSerialization {\r\n  JSON = 'JSON',\r\n  COMPACT = 'COMPACT',\r\n}\r\n\r\nexport interface VerifyOptions {\r\n  payloadType?: PayloadType;\r\n  returnOnlyPayload?: boolean; // If true, return only the decoded payload.\r\n}\r\n\r\nexport interface DecryptOptions {\r\n  payloadType?: PayloadType;\r\n  returnOnlyPayload?: boolean; // If true, return only the decoded payload.\r\n  serializations?: JoseSerialization[];\r\n}\r\n\r\nexport const VERIFY_OPTIONS_DEFAULT: VerifyOptions = {\r\n  payloadType: 'json',\r\n  returnOnlyPayload: true,\r\n};\r\n\r\nexport const DECRYPT_OPTIONS_DEFAULT: DecryptOptions = {\r\n  payloadType: 'json',\r\n  returnOnlyPayload: true,\r\n  serializations: [JoseSerialization.JSON],\r\n};\r\n\r\nexport function isSymmetricKey(key: JWK.Key) {\r\n  // TODO: make sure this covers all cases.\r\n  return key.kty === 'oct';\r\n}\r\n\r\nexport function asJwk(key: JWK.Key | Key | any): JWK.Key | null {\r\n  // TODO: make sure this covers all cases.\r\n  // Excluded:\r\n  //   key.use - only for public keys, Ref: https://tools.ietf.org/html/rfc7517#section-4.2\r\n\r\n  if (key.id && key.jwk) {\r\n    return key.jwk;\r\n  } else if (key.keystore && key.length && key.kty && key.kid && key.alg) {\r\n    return key;\r\n  } else {\r\n    return null;\r\n  }\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class EncryptionService {\r\n  constructor(private timeService: TimeService) {}\r\n\r\n  async decrypt(\r\n    key: JWK.Key | Key, // string is assumed to be key.id, will unwrap key.\r\n    jwe: object | string, // string will be JSON.parsed\r\n    options?: DecryptOptions\r\n  ): Promise<JWE.DecryptResult | any> {\r\n    const opt = {\r\n      algorithms: ['dir', 'A*GCM', 'RSA-OAEP-*'],\r\n    };\r\n\r\n    options = {\r\n      ...DECRYPT_OPTIONS_DEFAULT,\r\n      ...options,\r\n    };\r\n\r\n    if ((key as Key).jwk) {\r\n      key = (key as Key).jwk;\r\n    }\r\n\r\n    if (typeof jwe === 'string') {\r\n      if (options.serializations.includes(JoseSerialization.JSON)) {\r\n        try {\r\n          jwe = JSON.parse(jwe);\r\n        } catch (error) {\r\n          if (options.serializations.includes(JoseSerialization.COMPACT)) {\r\n            console.log(\r\n              'Not a JSON-formatted JWE, it maybe compact serialisation format.'\r\n            );\r\n          } else {\r\n            throw error;\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    // {result} is a Object with:\r\n    // *  header: the combined 'protected' and 'unprotected' header members\r\n    // *  protected: an array of the member names from the \"protected\" member\r\n    // *  key: Key used to decrypt\r\n    // *  payload: Buffer of the decrypted content\r\n    // *  plaintext: Buffer of the decrypted content (alternate), just a reference to payload\r\n    const res = await JWE.createDecrypt(key as JWK.Key, opt).decrypt(\r\n      jwe as any\r\n    );\r\n\r\n    res.payload = this.decodePayload(options.payloadType, res.payload);\r\n\r\n    if (options.returnOnlyPayload) {\r\n      return res.payload;\r\n    } else {\r\n      return res;\r\n    }\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: JWK.Key,\r\n    content: ArrayBuffer | string | object\r\n  ): Promise<string> {\r\n    return JSON.stringify(await this.encrypt(key, content));\r\n  }\r\n\r\n  // TODO rename this to encryptToJSON() and use this when required.\r\n  async encrypt(\r\n    key: JWK.Key,\r\n    content: ArrayBuffer | string | object\r\n  ): Promise<any> {\r\n    if (!content) {\r\n      throw new Error('Encrypting empty content.');\r\n    }\r\n\r\n    if (!(content instanceof ArrayBuffer)) {\r\n      content = new TextEncoder().encode(JSON.stringify(content));\r\n    }\r\n\r\n    return JWE.createEncrypt(\r\n      {\r\n        contentAlg: 'A256GCM',\r\n        fields: {\r\n          timestamp: await this.timeService.serverNow(),\r\n        },\r\n      } as any,\r\n      key\r\n    )\r\n      .update(content)\r\n      .final() as any;\r\n  }\r\n\r\n  // <AZ> Unlike signContent, the serialised \"content\" variable is contained inside\r\n  // the result. So ordering of fields within \"content\" is not an issue.\r\n  async sign(key: JWK.Key, content: Buffer | string | object): Promise<any> {\r\n    const signer = JWS.createSign(\r\n      {\r\n        fields: {\r\n          timestamp: await this.timeService.serverNow(),\r\n        },\r\n      },\r\n      key\r\n    );\r\n\r\n    if (content instanceof Buffer) {\r\n      signer.update(content);\r\n    } else {\r\n      signer.update(JSON.stringify(content), 'utf8');\r\n    }\r\n\r\n    return signer.final();\r\n  }\r\n\r\n  async signToString(\r\n    key: JWK.Key,\r\n    content: Buffer | string | object\r\n  ): Promise<string> {\r\n    return JSON.stringify(await this.sign(key, content));\r\n  }\r\n\r\n  async verify(\r\n    key: JWK.Key,\r\n    jws: object,\r\n    options?: VerifyOptions\r\n  ): Promise<any> {\r\n    const opt = {\r\n      algorithms: ['RS*'],\r\n    };\r\n\r\n    options = {\r\n      ...VERIFY_OPTIONS_DEFAULT,\r\n      ...options,\r\n    };\r\n\r\n    try {\r\n      const res = await JWS.createVerify(key, opt).verify(jws as any);\r\n\r\n      res.payload = this.decodePayload(options.payloadType, res.payload);\r\n\r\n      if (options.returnOnlyPayload) {\r\n        return res.payload;\r\n      } else {\r\n        return res;\r\n      }\r\n    } catch (error) {\r\n      throw new LrException({\r\n        code: LrErrorCode.BadSignature,\r\n        message: `Bad signature: ${error}`,\r\n      });\r\n    }\r\n  }\r\n\r\n  async encryptThenSign(\r\n    {\r\n      key,\r\n      sigPrk,\r\n    }: {\r\n      key: JWK.Key;\r\n      sigPrk: JWK.Key;\r\n    },\r\n    content: ArrayBuffer | string | object\r\n  ): Promise<{ cipher: string; sig: string }> {\r\n    const cipher = JSON.stringify(await this.encrypt(key, content));\r\n    const sig = await this.sign(sigPrk, cipher);\r\n    delete sig.payload;\r\n\r\n    return {\r\n      cipher,\r\n      sig: JSON.stringify(sig),\r\n    };\r\n  }\r\n\r\n  private decodePayload(\r\n    payloadType: PayloadType,\r\n    payload: ArrayBuffer\r\n  ): ArrayBuffer | any {\r\n    switch (payloadType) {\r\n      case 'json':\r\n        return JSON.parse(new TextDecoder().decode(payload));\r\n      case 'ArrayBuffer':\r\n        return payload;\r\n      default:\r\n        throw new LrBadArgumentException(`Unknown payloadType: ${payloadType}`);\r\n    }\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +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":"C:/Projects/test/projects/core/src/","sources":["lib/cryptography/key-factory.service.ts"],"names":[],"mappings":"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","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"]}