@decaf-ts/for-fabric 0.0.2

package/lib/shared/crypto.cjs

@@ -0,0 +1,369 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoUtils = exports.BaseEncoder = exports.CRYPTO = exports.BASE_ALPHABET = void 0;
+const x509 = __importStar(require("@peculiar/x509"));
+const webcrypto_1 = require("@peculiar/webcrypto");
+const decorator_validation_1 = require("@decaf-ts/decorator-validation");
+const logging_1 = require("@decaf-ts/logging");
+const utils_1 = require("@decaf-ts/utils");
+const crypto = new webcrypto_1.Crypto();
+x509.cryptoProvider.set(crypto);
+var BASE_ALPHABET;
+(function (BASE_ALPHABET) {
+    BASE_ALPHABET["BASE2"] = "01";
+    BASE_ALPHABET["BASE8"] = "01234567";
+    BASE_ALPHABET["BASE11"] = "0123456789a";
+    BASE_ALPHABET["BASE16"] = "0123456789abcdef";
+    BASE_ALPHABET["BASE32"] = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+    BASE_ALPHABET["BASE32_Z"] = "ybndrfg8ejkmcpqxot1uwisza345h769";
+    BASE_ALPHABET["BASE36"] = "0123456789abcdefghijklmnopqrstuvwxyz";
+    BASE_ALPHABET["BASE58"] = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+    BASE_ALPHABET["BASE62"] = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    BASE_ALPHABET["BASE64"] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    BASE_ALPHABET["BASE67"] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.!~";
+})(BASE_ALPHABET || (exports.BASE_ALPHABET = BASE_ALPHABET = {}));
+var CRYPTO;
+(function (CRYPTO) {
+    CRYPTO["HASH"] = "SHA-256";
+    CRYPTO[CRYPTO["ITERATIONS"] = 1000] = "ITERATIONS";
+    CRYPTO[CRYPTO["KEYLENGTH"] = 48] = "KEYLENGTH";
+    CRYPTO[CRYPTO["DERIVED_IV_LENGTH"] = 16] = "DERIVED_IV_LENGTH";
+    CRYPTO[CRYPTO["DERIVED_KEY_LENGTH"] = 32] = "DERIVED_KEY_LENGTH";
+    CRYPTO["ALGORYTHM"] = "AES-GCM";
+    CRYPTO["KEY_ALGORYTHM"] = "PBKDF2";
+})(CRYPTO || (exports.CRYPTO = CRYPTO = {}));
+class BaseEncoder {
+    constructor(alphabet) {
+        this.alphabet = alphabet;
+        this.baseMap = new Uint8Array(256);
+        if (this.alphabet.length >= 255)
+            throw new Error("Alphabet too long");
+        for (let j = 0; j < this.baseMap.length; j++)
+            this.baseMap[j] = 255;
+        for (let i = 0; i < alphabet.length; i++) {
+            const x = alphabet.charAt(i);
+            const xc = x.charCodeAt(0);
+            if (this.baseMap[xc] !== 255)
+                throw new Error(x + " is ambiguous");
+            this.baseMap[xc] = i;
+        }
+        this.base = this.alphabet.length;
+        this.leader = this.alphabet.charAt(0);
+        this.factor = Math.log(this.base) / Math.log(256); // log(BASE) / log(256), rounded up
+        this.iFactor = Math.log(256) / Math.log(this.base); // log(256) / log(BASE), rounded up
+    }
+    encode(source) {
+        if (typeof source === "string") {
+            source = Buffer.from(source);
+        }
+        else if (ArrayBuffer.isView(source)) {
+            source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+        }
+        else if (Array.isArray(source)) {
+            source = Uint8Array.from(source);
+        }
+        if (source.length === 0)
+            return "";
+        // Skip & count leading zeroes.
+        let zeroes = 0;
+        let length = 0;
+        let pbegin = 0;
+        const pend = source.length;
+        while (pbegin !== pend && source[pbegin] === 0) {
+            pbegin++;
+            zeroes++;
+        }
+        // Allocate enough space in big-endian base58 representation.
+        const size = ((pend - pbegin) * this.iFactor + 1) >>> 0;
+        const b58 = new Uint8Array(size);
+        // Process the bytes.
+        while (pbegin !== pend) {
+            let carry = source[pbegin];
+            // Apply "b58 = b58 * 256 + ch".
+            let i = 0;
+            for (let it1 = size - 1; (carry !== 0 || i < length) && it1 !== -1; it1--, i++) {
+                carry += (256 * b58[it1]) >>> 0;
+                b58[it1] = carry % this.base >>> 0;
+                carry = (carry / this.base) >>> 0;
+            }
+            if (carry !== 0)
+                throw new Error("Non-zero carry");
+            length = i;
+            pbegin++;
+        }
+        // Skip leading zeroes in base58 result.
+        let it2 = size - length;
+        while (it2 !== size && b58[it2] === 0)
+            it2++;
+        // Translate the result into a string.
+        let str = this.leader.repeat(zeroes);
+        for (; it2 < size; ++it2) {
+            str += this.alphabet.charAt(b58[it2]);
+        }
+        return str;
+    }
+    decodeUnsafe(source) {
+        if (source.length === 0)
+            return new Uint8Array(0);
+        let psz = 0;
+        // Skip and count leading '1's.
+        let zeroes = 0;
+        let length = 0;
+        while (source[psz] === this.leader) {
+            zeroes++;
+            psz++;
+        }
+        // Allocate enough space in big-endian base256 representation.
+        const size = ((source.length - psz) * this.factor + 1) >>> 0; // log(58) / log(256), rounded up.
+        const b256 = new Uint8Array(size);
+        // Process the characters.
+        while (source[psz]) {
+            // Decode character
+            let carry = this.baseMap[source.charCodeAt(psz)];
+            // Invalid character
+            if (carry === 255)
+                return;
+            let i = 0;
+            for (let it3 = size - 1; (carry !== 0 || i < length) && it3 !== -1; it3--, i++) {
+                carry += (this.base * b256[it3]) >>> 0;
+                b256[it3] = carry % 256 >>> 0;
+                carry = (carry / 256) >>> 0;
+            }
+            if (carry !== 0)
+                throw new Error("Non-zero carry");
+            length = i;
+            psz++;
+        }
+        // Skip leading zeroes in b256.
+        let it4 = size - length;
+        while (it4 !== size && b256[it4] === 0)
+            it4++;
+        const vch = new Uint8Array(zeroes + (size - it4));
+        let j = zeroes;
+        while (it4 !== size)
+            vch[j++] = b256[it4++];
+        return vch;
+    }
+    decode(source) {
+        const buffer = this.decodeUnsafe(source);
+        if (buffer)
+            return buffer;
+        throw new Error("Non-base" + this.base + " character");
+    }
+}
+exports.BaseEncoder = BaseEncoder;
+class CryptoUtils {
+    static { this.b58encoder = new BaseEncoder(BASE_ALPHABET.BASE58); }
+    static { this.logger = logging_1.Logging.for(CryptoUtils.name); }
+    constructor() { }
+    static fabricIdFromCertificate(certificate) {
+        this.logger.debug((0, decorator_validation_1.stringFormat)("Parsing certificate: {0}", certificate));
+        const cert = new x509.X509Certificate(certificate);
+        const { subject, issuer } = cert;
+        this.logger.debug((0, decorator_validation_1.stringFormat)("Certificate parsed with subject {0} and issuer {1}", subject, issuer));
+        return `x509::/${subject.replaceAll(", ", "/")}::/${issuer.replaceAll(", ", "/")}`;
+    }
+    static encode(str) {
+        return this.b58encoder.encode(str);
+    }
+    static decode(str) {
+        const decoded = this.b58encoder.decode(str);
+        const result = new TextDecoder().decode(decoded);
+        return result;
+    }
+    static stringToArrayBuffer(str) {
+        const buf = new ArrayBuffer(str.length);
+        const bufView = new Uint8Array(buf);
+        for (let i = 0, strLen = str.length; i < strLen; i++) {
+            bufView[i] = str.charCodeAt(i);
+        }
+        return buf;
+    }
+    static async extractKey(type, pem, usages) {
+        const subtle = crypto.subtle;
+        const str = pem
+            .toString("utf8")
+            .replace(new RegExp(`-----BEGIN (${type.toUpperCase()} KEY|CERTIFICATE)-----`), "")
+            .replaceAll("\n", "")
+            .replace(new RegExp(`-----END (${type.toUpperCase()} KEY|CERTIFICATE)-----`), "");
+        const decoded = Buffer.from(str, "base64").toString("binary");
+        const binaryDer = this.stringToArrayBuffer(decoded);
+        const key = await subtle.importKey("pkcs8", binaryDer, {
+            name: "ECDSA",
+            namedCurve: "P-256",
+        }, true, usages ? usages : ["sign"]);
+        return key;
+    }
+    static async extractPrivateKey(pem, usages) {
+        return this.extractKey("private", pem, usages);
+    }
+    static async extractPublicKey(pem, usages) {
+        return this.extractKey("public", pem, usages);
+    }
+    static async sign(privateKey, data) {
+        const key = await this.extractPrivateKey(privateKey);
+        const buff = (await crypto.subtle.sign({
+            name: "ECDSA",
+            hash: "SHA-256",
+        }, key, data));
+        return Array.from(new Uint8Array(buff))
+            .map((b) => b.toString(16).padStart(2, "0"))
+            .join("");
+    }
+    static async verify(certificate, signature, data) {
+        const cert = new x509.X509Certificate(certificate);
+        const key = await cert.publicKey.export();
+        signature = (typeof signature === "string" ? Buffer.from(signature, "hex") : signature);
+        data = (typeof data === "string" ? Buffer.from(data) : data);
+        return crypto.subtle.verify({
+            name: "ECDSA",
+            hash: "SHA-256",
+        }, key, signature, data);
+    }
+    static async encrypt(certificate, data) {
+        const cert = new x509.X509Certificate(certificate);
+        const key = await cert.publicKey.export();
+        data = (typeof data === "string" ? Buffer.from(data) : data);
+        const buff = await this.getSubtleCrypto().encrypt({
+            name: "ECDSA",
+        }, key, data);
+        return Array.from(new Uint8Array(buff))
+            .map((b) => b.toString(16).padStart(2, "0"))
+            .join("");
+    }
+    static getSubtleCrypto() {
+        return (0, utils_1.isBrowser)()
+            ? globalThis.window.crypto.subtle
+            : crypto.subtle;
+    }
+    static async decrypt(privateKey, data) {
+        const key = await this.extractPrivateKey(privateKey);
+        data = (typeof data === "string" ? Buffer.from(data, "hex") : data);
+        return this.getSubtleCrypto().decrypt({
+            name: "ECDSA",
+        }, key, data);
+    }
+    /**
+     * @summary Util function to get a random master key
+     *
+     * @description If data is not passed, a random ArrayBuffer will be generated
+     *
+     * @param {ArrayBuffer} data encrytion data
+     *
+     * @function getMaster
+     */
+    static async getMaster(data) {
+        const textEncoder = new TextEncoder();
+        if (data === undefined) {
+            const genGenesis = crypto.randomUUID();
+            data = textEncoder.encode(genGenesis);
+        }
+        const importedKey = await this.getSubtleCrypto().importKey("raw", data, CRYPTO.KEY_ALGORYTHM, false, ["deriveBits"]);
+        return {
+            key: importedKey,
+            iv: data,
+        };
+    }
+    /**
+     * @summary Util function to derive a key from another key
+     *
+     * @param {string} salt
+     * @param {CryptoKey} key Original key
+     *
+     * @function getDerivationKey
+     */
+    static async getDerivationKey(salt, key) {
+        const textEncoder = new TextEncoder();
+        const saltBuffer = textEncoder.encode(salt);
+        const saltHashed = await this.getSubtleCrypto().digest("SHA-256", saltBuffer);
+        const params = {
+            name: CRYPTO.KEY_ALGORYTHM,
+            hash: CRYPTO.HASH,
+            salt: saltHashed,
+            iterations: CRYPTO.ITERATIONS,
+        };
+        const derivation = await this.getSubtleCrypto().deriveBits(params, key, CRYPTO.KEYLENGTH * 8);
+        return this.getKey(derivation);
+    }
+    /**
+     * @summary Util function to get the key and IV from the CrytoKey array
+     *
+     * @param {ArrayBuffer} derivation
+     *
+     * @function getKey
+     */
+    static async getKey(derivation) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const ivlen = 16;
+        const keylen = 32;
+        const derivedKey = derivation.slice(0, keylen);
+        const iv = derivation.slice(keylen);
+        const importedEncryptionKey = await this.getSubtleCrypto().importKey("raw", derivedKey, { name: CRYPTO.ALGORYTHM }, false, ["encrypt", "decrypt"]);
+        return {
+            key: importedEncryptionKey,
+            iv: iv,
+        };
+    }
+    /**
+     * @summary Util function to decrypt data
+     *
+     * @param {string} text
+     * @param {keyObject} keyObject
+     *
+     * @function encrypt
+     */
+    static async encryptPin(text, keyObject) {
+        const textEncoder = new TextEncoder();
+        const textBuffer = textEncoder.encode(text);
+        const encryptedText = await this.getSubtleCrypto().encrypt({ name: CRYPTO.ALGORYTHM, iv: keyObject.iv }, keyObject.key, textBuffer);
+        return encryptedText;
+    }
+    /**
+     * @summary Util function to decrypt data
+     *
+     * @param {BufferSource} encryptedText
+     * @param {keyObject} keyObject
+     *
+     * @function decrypt
+     */
+    static async decryptPin(encryptedText, keyObject) {
+        const textDecoder = new TextDecoder();
+        const decryptedText = await this.getSubtleCrypto().decrypt({ name: CRYPTO.ALGORYTHM, iv: keyObject.iv }, keyObject.key, encryptedText);
+        return textDecoder.decode(decryptedText);
+    }
+}
+exports.CryptoUtils = CryptoUtils;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"crypto.js","sourceRoot":"","sources":["../../src/shared/crypto.ts"],"names":[],"mappings":"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","sourcesContent":["import * as x509 from \"@peculiar/x509\";\nimport { Crypto, CryptoKey } from \"@peculiar/webcrypto\";\nimport { stringFormat } from \"@decaf-ts/decorator-validation\";\nimport { Logging } from \"@decaf-ts/logging\";\nimport { isBrowser } from \"@decaf-ts/utils\";\n\nconst crypto = new Crypto();\nx509.cryptoProvider.set(crypto);\n\nexport enum BASE_ALPHABET {\n  BASE2 = \"01\",\n  BASE8 = \"01234567\",\n  BASE11 = \"0123456789a\",\n  BASE16 = \"0123456789abcdef\",\n  BASE32 = \"0123456789ABCDEFGHJKMNPQRSTVWXYZ\",\n  BASE32_Z = \"ybndrfg8ejkmcpqxot1uwisza345h769\",\n  BASE36 = \"0123456789abcdefghijklmnopqrstuvwxyz\",\n  BASE58 = \"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz\",\n  BASE62 = \"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\",\n  BASE64 = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\",\n  BASE67 = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.!~\",\n}\n\nexport type keyObject = {\n  iv: ArrayBuffer;\n  key: CryptoKey;\n};\n\nexport enum CRYPTO {\n  HASH = \"SHA-256\",\n  ITERATIONS = 1000,\n  KEYLENGTH = 48,\n  DERIVED_IV_LENGTH = 16,\n  DERIVED_KEY_LENGTH = 32, // Because SHA-256 used has a native size of 32 bytes\n  ALGORYTHM = \"AES-GCM\",\n  KEY_ALGORYTHM = \"PBKDF2\",\n}\n\nexport class BaseEncoder {\n  private readonly baseMap: Uint8Array = new Uint8Array(256);\n  private readonly base: number;\n  private readonly leader: string;\n  private readonly factor: number;\n  private readonly iFactor: number;\n\n  constructor(private alphabet: BASE_ALPHABET) {\n    if (this.alphabet.length >= 255) throw new Error(\"Alphabet too long\");\n\n    for (let j = 0; j < this.baseMap.length; j++) this.baseMap[j] = 255;\n\n    for (let i = 0; i < alphabet.length; i++) {\n      const x = alphabet.charAt(i);\n      const xc = x.charCodeAt(0);\n      if (this.baseMap[xc] !== 255) throw new Error(x + \" is ambiguous\");\n\n      this.baseMap[xc] = i;\n    }\n\n    this.base = this.alphabet.length;\n    this.leader = this.alphabet.charAt(0);\n    this.factor = Math.log(this.base) / Math.log(256); // log(BASE) / log(256), rounded up\n    this.iFactor = Math.log(256) / Math.log(this.base); // log(256) / log(BASE), rounded up\n  }\n\n  encode(source: Uint8Array | DataView | any[] | string) {\n    if (typeof source === \"string\") {\n      source = Buffer.from(source);\n    } else if (ArrayBuffer.isView(source)) {\n      source = new Uint8Array(\n        source.buffer,\n        source.byteOffset,\n        source.byteLength\n      );\n    } else if (Array.isArray(source)) {\n      source = Uint8Array.from(source);\n    }\n\n    if (source.length === 0) return \"\";\n\n    // Skip & count leading zeroes.\n    let zeroes = 0;\n    let length = 0;\n    let pbegin = 0;\n    const pend = source.length;\n    while (pbegin !== pend && source[pbegin] === 0) {\n      pbegin++;\n      zeroes++;\n    }\n    // Allocate enough space in big-endian base58 representation.\n    const size = ((pend - pbegin) * this.iFactor + 1) >>> 0;\n    const b58 = new Uint8Array(size);\n    // Process the bytes.\n    while (pbegin !== pend) {\n      let carry = source[pbegin];\n      // Apply \"b58 = b58 * 256 + ch\".\n      let i = 0;\n      for (\n        let it1 = size - 1;\n        (carry !== 0 || i < length) && it1 !== -1;\n        it1--, i++\n      ) {\n        carry += (256 * b58[it1]) >>> 0;\n        b58[it1] = carry % this.base >>> 0;\n        carry = (carry / this.base) >>> 0;\n      }\n      if (carry !== 0) throw new Error(\"Non-zero carry\");\n\n      length = i;\n      pbegin++;\n    }\n    // Skip leading zeroes in base58 result.\n    let it2 = size - length;\n    while (it2 !== size && b58[it2] === 0) it2++;\n\n    // Translate the result into a string.\n    let str = this.leader.repeat(zeroes);\n    for (; it2 < size; ++it2) {\n      str += this.alphabet.charAt(b58[it2]);\n    }\n    return str;\n  }\n\n  private decodeUnsafe(source: string): Uint8Array | undefined {\n    if (source.length === 0) return new Uint8Array(0);\n\n    let psz = 0;\n    // Skip and count leading '1's.\n    let zeroes = 0;\n    let length = 0;\n    while (source[psz] === this.leader) {\n      zeroes++;\n      psz++;\n    }\n    // Allocate enough space in big-endian base256 representation.\n    const size = ((source.length - psz) * this.factor + 1) >>> 0; // log(58) / log(256), rounded up.\n    const b256 = new Uint8Array(size);\n    // Process the characters.\n    while (source[psz]) {\n      // Decode character\n      let carry = this.baseMap[source.charCodeAt(psz)];\n      // Invalid character\n      if (carry === 255) return;\n\n      let i = 0;\n      for (\n        let it3 = size - 1;\n        (carry !== 0 || i < length) && it3 !== -1;\n        it3--, i++\n      ) {\n        carry += (this.base * b256[it3]) >>> 0;\n        b256[it3] = carry % 256 >>> 0;\n        carry = (carry / 256) >>> 0;\n      }\n      if (carry !== 0) throw new Error(\"Non-zero carry\");\n\n      length = i;\n      psz++;\n    }\n    // Skip leading zeroes in b256.\n    let it4 = size - length;\n    while (it4 !== size && b256[it4] === 0) it4++;\n\n    const vch = new Uint8Array(zeroes + (size - it4));\n    let j = zeroes;\n    while (it4 !== size) vch[j++] = b256[it4++];\n\n    return vch;\n  }\n\n  decode(source: string) {\n    const buffer = this.decodeUnsafe(source);\n    if (buffer) return buffer;\n    throw new Error(\"Non-base\" + this.base + \" character\");\n  }\n}\n\nexport class CryptoUtils {\n  private static readonly b58encoder = new BaseEncoder(BASE_ALPHABET.BASE58);\n  private static readonly logger = Logging.for(CryptoUtils.name);\n  private constructor() {}\n\n  static fabricIdFromCertificate(certificate: string) {\n    this.logger.debug(stringFormat(\"Parsing certificate: {0}\", certificate));\n    const cert = new x509.X509Certificate(certificate);\n    const { subject, issuer } = cert;\n    this.logger.debug(\n      stringFormat(\n        \"Certificate parsed with subject {0} and issuer {1}\",\n        subject,\n        issuer\n      )\n    );\n    return `x509::/${subject.replaceAll(\", \", \"/\")}::/${issuer.replaceAll(\", \", \"/\")}`;\n  }\n\n  static encode(str: string): string {\n    return this.b58encoder.encode(str);\n  }\n  static decode(str: string): string {\n    const decoded = this.b58encoder.decode(str);\n    const result = new TextDecoder().decode(decoded);\n    return result;\n  }\n\n  static stringToArrayBuffer(str: string) {\n    const buf = new ArrayBuffer(str.length);\n    const bufView = new Uint8Array(buf);\n    for (let i = 0, strLen = str.length; i < strLen; i++) {\n      bufView[i] = str.charCodeAt(i);\n    }\n    return buf;\n  }\n\n  private static async extractKey(\n    type: \"private\" | \"public\",\n    pem: Buffer | string,\n    usages?: any[]\n  ) {\n    const subtle = crypto.subtle;\n\n    const str = pem\n      .toString(\"utf8\")\n      .replace(\n        new RegExp(`-----BEGIN (${type.toUpperCase()} KEY|CERTIFICATE)-----`),\n        \"\"\n      )\n      .replaceAll(\"\\n\", \"\")\n      .replace(\n        new RegExp(`-----END (${type.toUpperCase()} KEY|CERTIFICATE)-----`),\n        \"\"\n      );\n    const decoded = Buffer.from(str, \"base64\").toString(\"binary\");\n    const binaryDer = this.stringToArrayBuffer(decoded);\n    const key = await subtle.importKey(\n      \"pkcs8\",\n      binaryDer,\n      {\n        name: \"ECDSA\",\n        namedCurve: \"P-256\",\n      },\n      true,\n      usages ? usages : [\"sign\"]\n    );\n\n    return key;\n  }\n\n  static async extractPrivateKey(pem: Buffer | string, usages?: any[]) {\n    return this.extractKey(\"private\", pem, usages);\n  }\n\n  static async extractPublicKey(pem: Buffer | string, usages?: any[]) {\n    return this.extractKey(\"public\", pem, usages);\n  }\n\n  static async sign(privateKey: string, data: Buffer): Promise<string> {\n    const key = await this.extractPrivateKey(privateKey);\n    const buff = (await crypto.subtle.sign(\n      {\n        name: \"ECDSA\",\n        hash: \"SHA-256\",\n      },\n      key,\n      data\n    )) as ArrayBuffer;\n\n    return Array.from(new Uint8Array(buff))\n      .map((b) => b.toString(16).padStart(2, \"0\"))\n      .join(\"\");\n  }\n\n  static async verify(\n    certificate: string,\n    signature: Buffer | string,\n    data: Buffer | string\n  ): Promise<boolean> {\n    const cert = new x509.X509Certificate(certificate);\n    const key = await cert.publicKey.export();\n    signature = (\n      typeof signature === \"string\" ? Buffer.from(signature, \"hex\") : signature\n    ) as Buffer;\n    data = (typeof data === \"string\" ? Buffer.from(data) : data) as Buffer;\n    return crypto.subtle.verify(\n      {\n        name: \"ECDSA\",\n        hash: \"SHA-256\",\n      },\n      key,\n      signature,\n      data\n    );\n  }\n\n  static async encrypt(certificate: string, data: string | Buffer) {\n    const cert = new x509.X509Certificate(certificate);\n    const key = await cert.publicKey.export();\n    data = (typeof data === \"string\" ? Buffer.from(data) : data) as Buffer;\n    const buff = await this.getSubtleCrypto().encrypt(\n      {\n        name: \"ECDSA\",\n      },\n      key,\n      data\n    );\n\n    return Array.from(new Uint8Array(buff))\n      .map((b) => b.toString(16).padStart(2, \"0\"))\n      .join(\"\");\n  }\n\n  private static getSubtleCrypto() {\n    return isBrowser()\n      ? (globalThis as any).window.crypto.subtle\n      : crypto.subtle;\n  }\n\n  static async decrypt(privateKey: string, data: string | Buffer) {\n    const key = await this.extractPrivateKey(privateKey);\n    data = (\n      typeof data === \"string\" ? Buffer.from(data, \"hex\") : data\n    ) as Buffer;\n    return this.getSubtleCrypto().decrypt(\n      {\n        name: \"ECDSA\",\n      },\n      key,\n      data\n    );\n  }\n\n  /**\n   * @summary Util function to get a random master key\n   *\n   * @description If data is not passed, a random ArrayBuffer will be generated\n   *\n   * @param {ArrayBuffer} data encrytion data\n   *\n   * @function getMaster\n   */\n  static async getMaster(data?: ArrayBuffer): Promise<keyObject> {\n    const textEncoder = new TextEncoder();\n    if (data === undefined) {\n      const genGenesis = crypto.randomUUID();\n      data = textEncoder.encode(genGenesis);\n    }\n\n    const importedKey = await this.getSubtleCrypto().importKey(\n      \"raw\",\n      data,\n      CRYPTO.KEY_ALGORYTHM as string,\n      false,\n      [\"deriveBits\"]\n    );\n\n    return {\n      key: importedKey,\n      iv: data,\n    };\n  }\n\n  /**\n   * @summary Util function to derive a key from another key\n   *\n   * @param {string} salt\n   * @param {CryptoKey} key Original key\n   *\n   * @function getDerivationKey\n   */\n  static async getDerivationKey(salt: string, key: CryptoKey) {\n    const textEncoder = new TextEncoder();\n    const saltBuffer = textEncoder.encode(salt);\n    const saltHashed = await this.getSubtleCrypto().digest(\n      \"SHA-256\",\n      saltBuffer\n    );\n    const params = {\n      name: CRYPTO.KEY_ALGORYTHM as string,\n      hash: CRYPTO.HASH,\n      salt: saltHashed,\n      iterations: CRYPTO.ITERATIONS,\n    };\n    const derivation = await this.getSubtleCrypto().deriveBits(\n      params,\n      key,\n      CRYPTO.KEYLENGTH * 8\n    );\n    return this.getKey(derivation);\n  }\n\n  /**\n   * @summary Util function to get the key and IV from the CrytoKey array\n   *\n   * @param {ArrayBuffer} derivation\n   *\n   * @function getKey\n   */\n  static async getKey(derivation: ArrayBuffer) {\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    const ivlen = 16;\n    const keylen = 32;\n    const derivedKey = derivation.slice(0, keylen);\n    const iv = derivation.slice(keylen);\n    const importedEncryptionKey = await this.getSubtleCrypto().importKey(\n      \"raw\",\n      derivedKey,\n      { name: CRYPTO.ALGORYTHM as string },\n      false,\n      [\"encrypt\", \"decrypt\"]\n    );\n    return {\n      key: importedEncryptionKey,\n      iv: iv,\n    };\n  }\n\n  /**\n   * @summary Util function to decrypt data\n   *\n   * @param {string} text\n   * @param {keyObject} keyObject\n   *\n   * @function encrypt\n   */\n  static async encryptPin(\n    text: string,\n    keyObject: keyObject\n  ): Promise<ArrayBuffer> {\n    const textEncoder = new TextEncoder();\n    const textBuffer = textEncoder.encode(text);\n    const encryptedText = await this.getSubtleCrypto().encrypt(\n      { name: CRYPTO.ALGORYTHM as string, iv: keyObject.iv },\n      keyObject.key,\n      textBuffer\n    );\n    return encryptedText;\n  }\n\n  /**\n   * @summary Util function to decrypt data\n   *\n   * @param {BufferSource} encryptedText\n   * @param {keyObject} keyObject\n   *\n   * @function decrypt\n   */\n  static async decryptPin(\n    encryptedText: ArrayBuffer,\n    keyObject: keyObject\n  ): Promise<string> {\n    const textDecoder = new TextDecoder();\n    const decryptedText = await this.getSubtleCrypto().decrypt(\n      { name: CRYPTO.ALGORYTHM as string, iv: keyObject.iv },\n      keyObject.key,\n      encryptedText\n    );\n    return textDecoder.decode(decryptedText);\n  }\n}\n"]}

package/lib/shared/crypto.d.ts

@@ -0,0 +1,107 @@
+import { CryptoKey } from "@peculiar/webcrypto";
+export declare enum BASE_ALPHABET {
+    BASE2 = "01",
+    BASE8 = "01234567",
+    BASE11 = "0123456789a",
+    BASE16 = "0123456789abcdef",
+    BASE32 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ",
+    BASE32_Z = "ybndrfg8ejkmcpqxot1uwisza345h769",
+    BASE36 = "0123456789abcdefghijklmnopqrstuvwxyz",
+    BASE58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz",
+    BASE62 = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
+    BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
+    BASE67 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.!~"
+}
+export type keyObject = {
+    iv: ArrayBuffer;
+    key: CryptoKey;
+};
+export declare enum CRYPTO {
+    HASH = "SHA-256",
+    ITERATIONS = 1000,
+    KEYLENGTH = 48,
+    DERIVED_IV_LENGTH = 16,
+    DERIVED_KEY_LENGTH = 32,// Because SHA-256 used has a native size of 32 bytes
+    ALGORYTHM = "AES-GCM",
+    KEY_ALGORYTHM = "PBKDF2"
+}
+export declare class BaseEncoder {
+    private alphabet;
+    private readonly baseMap;
+    private readonly base;
+    private readonly leader;
+    private readonly factor;
+    private readonly iFactor;
+    constructor(alphabet: BASE_ALPHABET);
+    encode(source: Uint8Array | DataView | any[] | string): string;
+    private decodeUnsafe;
+    decode(source: string): Uint8Array<ArrayBufferLike>;
+}
+export declare class CryptoUtils {
+    private static readonly b58encoder;
+    private static readonly logger;
+    private constructor();
+    static fabricIdFromCertificate(certificate: string): string;
+    static encode(str: string): string;
+    static decode(str: string): string;
+    static stringToArrayBuffer(str: string): ArrayBuffer;
+    private static extractKey;
+    static extractPrivateKey(pem: Buffer | string, usages?: any[]): Promise<any>;
+    static extractPublicKey(pem: Buffer | string, usages?: any[]): Promise<any>;
+    static sign(privateKey: string, data: Buffer): Promise<string>;
+    static verify(certificate: string, signature: Buffer | string, data: Buffer | string): Promise<boolean>;
+    static encrypt(certificate: string, data: string | Buffer): Promise<string>;
+    private static getSubtleCrypto;
+    static decrypt(privateKey: string, data: string | Buffer): Promise<any>;
+    /**
+     * @summary Util function to get a random master key
+     *
+     * @description If data is not passed, a random ArrayBuffer will be generated
+     *
+     * @param {ArrayBuffer} data encrytion data
+     *
+     * @function getMaster
+     */
+    static getMaster(data?: ArrayBuffer): Promise<keyObject>;
+    /**
+     * @summary Util function to derive a key from another key
+     *
+     * @param {string} salt
+     * @param {CryptoKey} key Original key
+     *
+     * @function getDerivationKey
+     */
+    static getDerivationKey(salt: string, key: CryptoKey): Promise<{
+        key: any;
+        iv: ArrayBuffer;
+    }>;
+    /**
+     * @summary Util function to get the key and IV from the CrytoKey array
+     *
+     * @param {ArrayBuffer} derivation
+     *
+     * @function getKey
+     */
+    static getKey(derivation: ArrayBuffer): Promise<{
+        key: any;
+        iv: ArrayBuffer;
+    }>;
+    /**
+     * @summary Util function to decrypt data
+     *
+     * @param {string} text
+     * @param {keyObject} keyObject
+     *
+     * @function encrypt
+     */
+    static encryptPin(text: string, keyObject: keyObject): Promise<ArrayBuffer>;
+    /**
+     * @summary Util function to decrypt data
+     *
+     * @param {BufferSource} encryptedText
+     * @param {keyObject} keyObject
+     *
+     * @function decrypt
+     */
+    static decryptPin(encryptedText: ArrayBuffer, keyObject: keyObject): Promise<string>;
+}

package/lib/shared/decorators.cjs

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Owner = Owner;
+exports.ownedByOnCreate = ownedByOnCreate;
+exports.OwnedBy = OwnedBy;
+exports.getFabricModelKey = getFabricModelKey;
+exports.privateData = privateData;
+const core_1 = require("@decaf-ts/core");
+const db_decorators_1 = require("@decaf-ts/db-decorators");
+const decorator_validation_1 = require("@decaf-ts/decorator-validation");
+const constants_1 = require("./constants.cjs");
+const reflection_1 = require("@decaf-ts/reflection");
+/**
+ * Decorator for marking methods that require ownership authorization.
+ * Checks the owner of the token before allowing the method to be executed.
+ *
+ * @example
+ * ```typescript
+ * class TokenContract extends Contract {
+ *   @Owner()
+ *   async Mint(ctx: Context, amount: number) {
+ *     // Mint token logic
+ *   }
+ * }
+ * ```
+ *
+ * @returns {MethodDecorator} A method decorator that checks ownership authorization.
+ */
+function Owner() {
+    return function (target, propertyKey, descriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = async function (...args) {
+            const ctx = args[0];
+            const acountId = ctx.clientIdentity.getID();
+            const select = await this["tokenRepository"].selectWithContext(undefined, ctx);
+            const tokens = await select.execute();
+            if (tokens.length == 0) {
+                throw new db_decorators_1.NotFoundError("No tokens avaialble");
+            }
+            if (tokens.length > 1) {
+                throw new db_decorators_1.NotFoundError(`To many token available : ${tokens.length}`);
+            }
+            if (tokens[0].owner != acountId) {
+                throw new core_1.AuthorizationError(`User not authorized to run ${propertyKey} on the token`);
+            }
+            return await originalMethod.apply(this, args);
+        };
+        return descriptor;
+    };
+}
+async function ownedByOnCreate(context, data, key, model) {
+    const { stub } = context;
+    const creator = await stub.getCreator();
+    const owner = creator.mspid;
+    const setOwnedByKeyValue = function (target, propertyKey, value) {
+        Object.defineProperty(target, propertyKey, {
+            enumerable: true,
+            writable: false,
+            configurable: true,
+            value: value,
+        });
+    };
+    setOwnedByKeyValue(model, key, owner);
+}
+function OwnedBy() {
+    const key = getFabricModelKey(constants_1.FabricModelKeys.OWNEDBY);
+    function ownedBy() {
+        return function (obj, attribute) {
+            return (0, reflection_1.apply)((0, decorator_validation_1.required)(), (0, db_decorators_1.readonly)(), (0, db_decorators_1.onCreate)(ownedByOnCreate), (0, decorator_validation_1.propMetadata)(getFabricModelKey(constants_1.FabricModelKeys.OWNEDBY), attribute))(obj, attribute);
+        };
+    }
+    return decorator_validation_1.Decoration.for(key)
+        .define({
+        decorator: ownedBy,
+        args: [],
+    })
+        .apply();
+}
+function getFabricModelKey(key) {
+    return decorator_validation_1.Model.key(constants_1.FabricModelKeys.FABRIC + key);
+}
+function privateData(collection) {
+    if (!collection) {
+        throw new Error("Collection name is required");
+    }
+    const key = getFabricModelKey(constants_1.FabricModelKeys.PRIVATE);
+    return function privateData(model, attribute) {
+        const propertyKey = attribute || undefined;
+        const meta = Reflect.getMetadata(key, model[decorator_validation_1.ModelKeys.ANCHOR] || model, propertyKey);
+        const data = meta?.collections || [];
+        (0, decorator_validation_1.propMetadata)(getFabricModelKey(constants_1.FabricModelKeys.PRIVATE), {
+            ...(!attribute && {
+                collections: data ? [...new Set([...data, collection])] : [collection],
+            }),
+            isPrivate: !attribute,
+        })(attribute ? model.constructor : model[decorator_validation_1.ModelKeys.ANCHOR] || model);
+        if (attribute) {
+            (0, decorator_validation_1.propMetadata)(getFabricModelKey(constants_1.FabricModelKeys.PRIVATE), {
+                collections: data ? [...new Set([...data, collection])] : [collection],
+            })(model, attribute);
+            (0, db_decorators_1.transient)()(model, attribute);
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorators.js","sourceRoot":"","sources":["../../src/shared/decorators.ts"],"names":[],"mappings":"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","sourcesContent":["import { AuthorizationError, Repo } from \"@decaf-ts/core\";\nimport { FabricERC20Contract } from \"../contracts\";\nimport {\n  Context,\n  NotFoundError,\n  onCreate,\n  readonly,\n  RepositoryFlags,\n  transient,\n} from \"@decaf-ts/db-decorators\";\nimport {\n  Decoration,\n  Model,\n  ModelKeys,\n  propMetadata,\n  required,\n} from \"@decaf-ts/decorator-validation\";\nimport { FabricModelKeys } from \"./constants\";\nimport { Context as HLContext } from \"fabric-contract-api\";\nimport { apply } from \"@decaf-ts/reflection\";\n\n/**\n * Decorator for marking methods that require ownership authorization.\n * Checks the owner of the token before allowing the method to be executed.\n *\n * @example\n * ```typescript\n * class TokenContract extends Contract {\n *   @Owner()\n *   async Mint(ctx: Context, amount: number) {\n *     // Mint token logic\n *   }\n * }\n * ```\n *\n * @returns {MethodDecorator} A method decorator that checks ownership authorization.\n */\nexport function Owner() {\n  return function (\n    target: any,\n    propertyKey: string,\n    descriptor: PropertyDescriptor\n  ) {\n    const originalMethod = descriptor.value;\n\n    descriptor.value = async function (\n      this: FabricERC20Contract,\n      ...args: any[]\n    ) {\n      const ctx: HLContext = args[0];\n      const acountId = ctx.clientIdentity.getID();\n\n      const select = await (this as FabricERC20Contract)[\n        \"tokenRepository\"\n      ].selectWithContext(undefined, ctx);\n\n      const tokens = await select.execute();\n\n      if (tokens.length == 0) {\n        throw new NotFoundError(\"No tokens avaialble\");\n      }\n\n      if (tokens.length > 1) {\n        throw new NotFoundError(`To many token available : ${tokens.length}`);\n      }\n\n      if (tokens[0].owner != acountId) {\n        throw new AuthorizationError(\n          `User not authorized to run ${propertyKey} on the token`\n        );\n      }\n\n      return await originalMethod.apply(this, args);\n    };\n\n    return descriptor;\n  };\n}\n\nexport async function ownedByOnCreate<\n  M extends Model,\n  R extends Repo<M, F, C>,\n  V,\n  F extends RepositoryFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  context: Context<F>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  const { stub } = context as any;\n\n  const creator = await stub.getCreator();\n  const owner = creator.mspid;\n\n  const setOwnedByKeyValue = function <M extends Model>(\n    target: M,\n    propertyKey: string,\n    value: string | number | bigint\n  ) {\n    Object.defineProperty(target, propertyKey, {\n      enumerable: true,\n      writable: false,\n      configurable: true,\n      value: value,\n    });\n  };\n\n  setOwnedByKeyValue(model, key as string, owner);\n}\n\nexport function OwnedBy() {\n  const key = getFabricModelKey(FabricModelKeys.OWNEDBY);\n\n  function ownedBy() {\n    return function (obj: any, attribute?: any) {\n      return apply(\n        required(),\n        readonly(),\n        onCreate(ownedByOnCreate),\n        propMetadata(getFabricModelKey(FabricModelKeys.OWNEDBY), attribute)\n      )(obj, attribute);\n    };\n  }\n\n  return Decoration.for(key)\n    .define({\n      decorator: ownedBy,\n      args: [],\n    })\n    .apply();\n}\n\nexport function getFabricModelKey(key: string) {\n  return Model.key(FabricModelKeys.FABRIC + key);\n}\n\nexport function privateData(collection?: string) {\n  if (!collection) {\n    throw new Error(\"Collection name is required\");\n  }\n\n  const key: string = getFabricModelKey(FabricModelKeys.PRIVATE);\n\n  return function privateData(model: any, attribute?: any) {\n    const propertyKey = attribute || undefined;\n\n    const meta = Reflect.getMetadata(\n      key,\n      model[ModelKeys.ANCHOR] || model,\n      propertyKey as string\n    );\n    const data = meta?.collections || [];\n\n    propMetadata(getFabricModelKey(FabricModelKeys.PRIVATE), {\n      ...(!attribute && {\n        collections: data ? [...new Set([...data, collection])] : [collection],\n      }),\n      isPrivate: !attribute,\n    })(attribute ? model.constructor : model[ModelKeys.ANCHOR] || model);\n\n    if (attribute) {\n      propMetadata(getFabricModelKey(FabricModelKeys.PRIVATE), {\n        collections: data ? [...new Set([...data, collection])] : [collection],\n      })(model, attribute);\n      transient()(model, attribute);\n    }\n  };\n}\n"]}