internxt-crypto 0.0.9-alpha → 0.0.11

package/dist/storage-service-BgIK2aYZ.js

@@ -0,0 +1,82 @@
+const require_chunk = require('./chunk-Dt-PWiN7.js');
+
+//#region src/storage-service/localStorageService.ts
+var localStorageService_exports = /* @__PURE__ */ require_chunk.__exportAll({ default: () => localStorageService_default });
+function get$1(key) {
+	return localStorage.getItem(key);
+}
+function set$1(key, value) {
+	return localStorage.setItem(key, value);
+}
+function removeItem$1(key) {
+	localStorage.removeItem(key);
+}
+function exists$1(key) {
+	return !!localStorage.getItem(key);
+}
+function clear$1() {
+	localStorage.clear();
+}
+const localStorageService = {
+	set: set$1,
+	get: get$1,
+	removeItem: removeItem$1,
+	exists: exists$1,
+	clear: clear$1
+};
+var localStorageService_default = localStorageService;
+
+//#endregion
+//#region src/storage-service/sessionStorageService.ts
+var sessionStorageService_exports = /* @__PURE__ */ require_chunk.__exportAll({ default: () => sessionStorageService_default });
+function get(key) {
+	return sessionStorage.getItem(key);
+}
+function set(key, value) {
+	return sessionStorage.setItem(key, value);
+}
+function removeItem(key) {
+	sessionStorage.removeItem(key);
+}
+function exists(key) {
+	return !!sessionStorage.getItem(key);
+}
+function clear() {
+	sessionStorage.clear();
+}
+const sessionStorageService = {
+	set,
+	get,
+	removeItem,
+	exists,
+	clear
+};
+var sessionStorageService_default = sessionStorageService;
+
+//#endregion
+//#region src/storage-service/index.ts
+var storage_service_exports = /* @__PURE__ */ require_chunk.__exportAll({
+	localStorageService: () => localStorageService_exports,
+	sessionStorageService: () => sessionStorageService_exports
+});
+
+//#endregion
+Object.defineProperty(exports, 'localStorageService_exports', {
+  enumerable: true,
+  get: function () {
+    return localStorageService_exports;
+  }
+});
+Object.defineProperty(exports, 'sessionStorageService_exports', {
+  enumerable: true,
+  get: function () {
+    return sessionStorageService_exports;
+  }
+});
+Object.defineProperty(exports, 'storage_service_exports', {
+  enumerable: true,
+  get: function () {
+    return storage_service_exports;
+  }
+});
+//# sourceMappingURL=storage-service-BgIK2aYZ.js.map

package/dist/storage-service-BgIK2aYZ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-service-BgIK2aYZ.js","names":["get","set","removeItem","exists","clear"],"sources":["../src/storage-service/localStorageService.ts","../src/storage-service/sessionStorageService.ts","../src/storage-service/index.ts"],"sourcesContent":["function get(key: string): string | null {\n  return localStorage.getItem(key);\n}\n\nfunction set(key: string, value: string): void {\n  return localStorage.setItem(key, value);\n}\n\nfunction removeItem(key: string): void {\n  localStorage.removeItem(key);\n}\n\nfunction exists(key: string): boolean {\n  return !!localStorage.getItem(key);\n}\n\nfunction clear(): void {\n  localStorage.clear();\n}\n\nconst localStorageService = {\n  set,\n  get,\n  removeItem,\n  exists,\n  clear,\n};\n\nexport default localStorageService;\n\nexport interface LocalStorageService {\n  set: (key: string, value: string) => void;\n  get: (key: string) => string | null;\n  removeItem: (key: string) => void;\n  exists: (key: string) => boolean;\n  clear: () => void;\n}\n","function get(key: string): string | null {\n  return sessionStorage.getItem(key);\n}\n\nfunction set(key: string, value: string): void {\n  return sessionStorage.setItem(key, value);\n}\n\nfunction removeItem(key: string): void {\n  sessionStorage.removeItem(key);\n}\n\nfunction exists(key: string): boolean {\n  return !!sessionStorage.getItem(key);\n}\n\nfunction clear(): void {\n  sessionStorage.clear();\n}\n\nconst sessionStorageService = {\n  set,\n  get,\n  removeItem,\n  exists,\n  clear,\n};\n\nexport default sessionStorageService;\n\nexport interface SessionStorageService {\n  set: (key: string, value: string) => void;\n  get: (key: string) => string | null;\n  removeItem: (key: string) => void;\n  exists: (key: string) => boolean;\n  clear: () => void;\n}\n","export * as localStorageService from './localStorageService';\nexport * as sessionStorageService from './sessionStorageService';\n"],"mappings":";;;;AAAA,SAASA,MAAI,KAA4B;AACvC,QAAO,aAAa,QAAQ,IAAI;;AAGlC,SAASC,MAAI,KAAa,OAAqB;AAC7C,QAAO,aAAa,QAAQ,KAAK,MAAM;;AAGzC,SAASC,aAAW,KAAmB;AACrC,cAAa,WAAW,IAAI;;AAG9B,SAASC,SAAO,KAAsB;AACpC,QAAO,CAAC,CAAC,aAAa,QAAQ,IAAI;;AAGpC,SAASC,UAAc;AACrB,cAAa,OAAO;;AAGtB,MAAM,sBAAsB;CAC1B;CACA;CACA;CACA;CACA;CACD;AAED,kCAAe;;;;;AC5Bf,SAAS,IAAI,KAA4B;AACvC,QAAO,eAAe,QAAQ,IAAI;;AAGpC,SAAS,IAAI,KAAa,OAAqB;AAC7C,QAAO,eAAe,QAAQ,KAAK,MAAM;;AAG3C,SAAS,WAAW,KAAmB;AACrC,gBAAe,WAAW,IAAI;;AAGhC,SAAS,OAAO,KAAsB;AACpC,QAAO,CAAC,CAAC,eAAe,QAAQ,IAAI;;AAGtC,SAAS,QAAc;AACrB,gBAAe,OAAO;;AAGxB,MAAM,wBAAwB;CAC5B;CACA;CACA;CACA;CACA;CACD;AAED,oCAAe"}

package/dist/storage-service-CubCbhY2.mjs

@@ -0,0 +1,65 @@
+import { t as __exportAll } from "./chunk-DWirmd9C.mjs";
+
+//#region src/storage-service/localStorageService.ts
+var localStorageService_exports = /* @__PURE__ */ __exportAll({ default: () => localStorageService_default });
+function get$1(key) {
+	return localStorage.getItem(key);
+}
+function set$1(key, value) {
+	return localStorage.setItem(key, value);
+}
+function removeItem$1(key) {
+	localStorage.removeItem(key);
+}
+function exists$1(key) {
+	return !!localStorage.getItem(key);
+}
+function clear$1() {
+	localStorage.clear();
+}
+const localStorageService = {
+	set: set$1,
+	get: get$1,
+	removeItem: removeItem$1,
+	exists: exists$1,
+	clear: clear$1
+};
+var localStorageService_default = localStorageService;
+
+//#endregion
+//#region src/storage-service/sessionStorageService.ts
+var sessionStorageService_exports = /* @__PURE__ */ __exportAll({ default: () => sessionStorageService_default });
+function get(key) {
+	return sessionStorage.getItem(key);
+}
+function set(key, value) {
+	return sessionStorage.setItem(key, value);
+}
+function removeItem(key) {
+	sessionStorage.removeItem(key);
+}
+function exists(key) {
+	return !!sessionStorage.getItem(key);
+}
+function clear() {
+	sessionStorage.clear();
+}
+const sessionStorageService = {
+	set,
+	get,
+	removeItem,
+	exists,
+	clear
+};
+var sessionStorageService_default = sessionStorageService;
+
+//#endregion
+//#region src/storage-service/index.ts
+var storage_service_exports = /* @__PURE__ */ __exportAll({
+	localStorageService: () => localStorageService_exports,
+	sessionStorageService: () => sessionStorageService_exports
+});
+
+//#endregion
+export { sessionStorageService_exports as n, localStorageService_exports as r, storage_service_exports as t };
+//# sourceMappingURL=storage-service-CubCbhY2.mjs.map

package/dist/storage-service-CubCbhY2.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-service-CubCbhY2.mjs","names":["get","set","removeItem","exists","clear"],"sources":["../src/storage-service/localStorageService.ts","../src/storage-service/sessionStorageService.ts","../src/storage-service/index.ts"],"sourcesContent":["function get(key: string): string | null {\n  return localStorage.getItem(key);\n}\n\nfunction set(key: string, value: string): void {\n  return localStorage.setItem(key, value);\n}\n\nfunction removeItem(key: string): void {\n  localStorage.removeItem(key);\n}\n\nfunction exists(key: string): boolean {\n  return !!localStorage.getItem(key);\n}\n\nfunction clear(): void {\n  localStorage.clear();\n}\n\nconst localStorageService = {\n  set,\n  get,\n  removeItem,\n  exists,\n  clear,\n};\n\nexport default localStorageService;\n\nexport interface LocalStorageService {\n  set: (key: string, value: string) => void;\n  get: (key: string) => string | null;\n  removeItem: (key: string) => void;\n  exists: (key: string) => boolean;\n  clear: () => void;\n}\n","function get(key: string): string | null {\n  return sessionStorage.getItem(key);\n}\n\nfunction set(key: string, value: string): void {\n  return sessionStorage.setItem(key, value);\n}\n\nfunction removeItem(key: string): void {\n  sessionStorage.removeItem(key);\n}\n\nfunction exists(key: string): boolean {\n  return !!sessionStorage.getItem(key);\n}\n\nfunction clear(): void {\n  sessionStorage.clear();\n}\n\nconst sessionStorageService = {\n  set,\n  get,\n  removeItem,\n  exists,\n  clear,\n};\n\nexport default sessionStorageService;\n\nexport interface SessionStorageService {\n  set: (key: string, value: string) => void;\n  get: (key: string) => string | null;\n  removeItem: (key: string) => void;\n  exists: (key: string) => boolean;\n  clear: () => void;\n}\n","export * as localStorageService from './localStorageService';\nexport * as sessionStorageService from './sessionStorageService';\n"],"mappings":";;;;AAAA,SAASA,MAAI,KAA4B;AACvC,QAAO,aAAa,QAAQ,IAAI;;AAGlC,SAASC,MAAI,KAAa,OAAqB;AAC7C,QAAO,aAAa,QAAQ,KAAK,MAAM;;AAGzC,SAASC,aAAW,KAAmB;AACrC,cAAa,WAAW,IAAI;;AAG9B,SAASC,SAAO,KAAsB;AACpC,QAAO,CAAC,CAAC,aAAa,QAAQ,IAAI;;AAGpC,SAASC,UAAc;AACrB,cAAa,OAAO;;AAGtB,MAAM,sBAAsB;CAC1B;CACA;CACA;CACA;CACA;CACD;AAED,kCAAe;;;;;AC5Bf,SAAS,IAAI,KAA4B;AACvC,QAAO,eAAe,QAAQ,IAAI;;AAGpC,SAAS,IAAI,KAAa,OAAqB;AAC7C,QAAO,eAAe,QAAQ,KAAK,MAAM;;AAG3C,SAAS,WAAW,KAAmB;AACrC,gBAAe,WAAW,IAAI;;AAGhC,SAAS,OAAO,KAAsB;AACpC,QAAO,CAAC,CAAC,eAAe,QAAQ,IAAI;;AAGtC,SAAS,QAAc;AACrB,gBAAe,OAAO;;AAGxB,MAAM,wBAAwB;CAC5B;CACA;CACA;CACA;CACA;CACD;AAED,oCAAe"}

package/dist/storage-service.d.mts

@@ -0,0 +1,2 @@
+import { n as sessionStorageService_d_exports, r as localStorageService_d_exports } from "./index-D5pBU_A5.mjs";
+export { localStorageService_d_exports as localStorageService, sessionStorageService_d_exports as sessionStorageService };

package/dist/storage-service.d.ts

@@ -0,0 +1,2 @@
+import { n as sessionStorageService_d_exports, r as localStorageService_d_exports } from "./index-CQqgKsbX.js";
+export { localStorageService_d_exports as localStorageService, sessionStorageService_d_exports as sessionStorageService };

package/dist/storage-service.js

@@ -0,0 +1,14 @@
+const require_storage_service = require('./storage-service-BgIK2aYZ.js');
+
+Object.defineProperty(exports, 'localStorageService', {
+  enumerable: true,
+  get: function () {
+    return require_storage_service.localStorageService_exports;
+  }
+});
+Object.defineProperty(exports, 'sessionStorageService', {
+  enumerable: true,
+  get: function () {
+    return require_storage_service.sessionStorageService_exports;
+  }
+});

package/dist/storage-service.mjs

@@ -0,0 +1,3 @@
+import { n as sessionStorageService_exports, r as localStorageService_exports } from "./storage-service-CubCbhY2.mjs";
+
+export { localStorageService_exports as localStorageService, sessionStorageService_exports as sessionStorageService };

package/dist/symmetric-crypto-CrdS1Che.mjs

@@ -0,0 +1,197 @@
+import { t as __exportAll } from "./chunk-DWirmd9C.mjs";
+import { c as AUX_BYTE_LEN, n as AES_KEY_BIT_LENGTH, t as AES_ALGORITHM, v as IV_LEN_BYTES, y as KEY_FORMAT } from "./constants-kTeX-2T0.mjs";
+import { r as getBytesFromData } from "./hash-CXeGAwai.mjs";
+import { concatBytes } from "@noble/hashes/utils.js";
+import { randomBytes } from "@noble/post-quantum/utils.js";
+
+//#region src/symmetric-crypto/keys.ts
+/**
+* Converts Uint8Array into CryptoKey
+*
+* @param keyData - The Uint8Array representation of the symmetric key
+* @returns The resulting symmetric CryptoKey.
+*/
+async function importSymmetricCryptoKey(keyData) {
+	return crypto.subtle.importKey(KEY_FORMAT, new Uint8Array(keyData), {
+		name: AES_ALGORITHM,
+		length: AES_KEY_BIT_LENGTH
+	}, true, ["encrypt", "decrypt"]);
+}
+/**
+* Converts CryptoKey into Uint8Array
+*
+* @param key - The symmetric CryptoKey
+* @returns The resulting Uint8Array.
+*/
+async function exportSymmetricCryptoKey(key) {
+	try {
+		const rawKey = await crypto.subtle.exportKey(KEY_FORMAT, key);
+		return new Uint8Array(rawKey);
+	} catch (error) {
+		throw new Error("Failed to export symmetric CryptoKey", { cause: error });
+	}
+}
+/**
+* Generates symmetric CryptoKey
+*
+* @returns The generated CryptoKey.
+*/
+async function genSymmetricCryptoKey() {
+	return crypto.subtle.generateKey({
+		name: AES_ALGORITHM,
+		length: AES_KEY_BIT_LENGTH
+	}, true, ["encrypt", "decrypt"]);
+}
+/**
+* Generates symmetric key as Uint8Array
+*
+* @returns The generated Uint8Array.
+*/
+function genSymmetricKey() {
+	try {
+		const key = new Uint8Array(AES_KEY_BIT_LENGTH / 8);
+		crypto.getRandomValues(key);
+		return key;
+	} catch (error) {
+		throw new Error("Failed to generate symmetric key", { cause: error });
+	}
+}
+/**
+* Derives CryptoKey from the given key material
+*
+* @returns The derived CryptoKey.
+*/
+async function deriveSymmetricCryptoKey(keyMaterial) {
+	try {
+		return importSymmetricCryptoKey(getBytesFromData(AES_KEY_BIT_LENGTH / 8, keyMaterial));
+	} catch (error) {
+		throw new Error("Failed to derive CryptoKey from the given key material", { cause: error });
+	}
+}
+
+//#endregion
+//#region src/symmetric-crypto/core.ts
+/**
+* Creates an initialization vector (IV) using RGB-based construction (8.2.2 NIST Special Publication 800-38D)
+* Constructs a 128-bits IV from 2 fileds: the random field (at least 96 bits) and the free field (32 bits).
+* If free filed is empty, then the entier 128-bit IV is sampled randomly.
+*
+* @param freeFiled - The string with an unrestricted content. Can be a device identifier, etc.
+* @returns The resulting 128-bits initialization vector.
+*/
+function createNISTbasedIV(freeField) {
+	try {
+		if (!freeField) return randomBytes(IV_LEN_BYTES);
+		const iv = new Uint8Array(16);
+		const randFiled = randomBytes(12);
+		iv.set(randFiled, 0);
+		const freeFiledFixedLength = getBytesFromData(4, freeField);
+		iv.set(freeFiledFixedLength, 12);
+		return iv;
+	} catch (error) {
+		throw new Error("Failed to create IV", { cause: error });
+	}
+}
+/**
+* Hashes aux string to make it fixed-length
+*
+* @param aux - The auxilay string of arbitrary length
+* @returns The resulting fixed-length auxilary string.
+*/
+async function makeAuxFixedLength(aux) {
+	return getBytesFromData(AUX_BYTE_LEN, aux);
+}
+/**
+* Symmetrically encrypts message
+*
+* @param message - The message to encrypt
+* @param encryptionKey - The encryption key
+* @param iv - The initialization vector
+* @param additionalData - The auxilary data
+* @returns The resulting ciphertext
+*/
+async function encryptMessage(message, encryptionKey, iv, additionalData) {
+	try {
+		const encrypted = await crypto.subtle.encrypt({
+			name: AES_ALGORITHM,
+			iv,
+			additionalData
+		}, encryptionKey, message);
+		return new Uint8Array(encrypted);
+	} catch (error) {
+		throw new Error("Failed to encrypt symmetrically", { cause: error });
+	}
+}
+/**
+* Symmetrically decrypts message
+*
+* @param ciphertext - The encrypted message
+* @param ciphertext - The initialization vector
+* @param encryptionKey - The encryption key
+* @param additionalData - The auxilary data
+* @returns The resulting decrypted message
+*/
+async function decryptMessage(ciphertext, iv, encryptionKey, additionalData) {
+	try {
+		const decrypted = await crypto.subtle.decrypt({
+			name: AES_ALGORITHM,
+			iv,
+			additionalData
+		}, encryptionKey, ciphertext);
+		return new Uint8Array(decrypted);
+	} catch (error) {
+		throw new Error("Failed to decrypt symmetrically", { cause: error });
+	}
+}
+
+//#endregion
+//#region src/symmetric-crypto/aes.ts
+/**
+* Symmetrically encrypts the message
+*
+* @param encryptionKey - The symmetric CryptoKey used for message encryption
+* @param message - The message to encrypt
+* @param freeField - The context of the message (required for IV generation)
+* @param aux - The auxilary string
+* @returns The resulting ciphertext.
+*/
+async function encryptSymmetrically(encryptionKey, message, aux, freeField) {
+	try {
+		const iv = createNISTbasedIV(freeField);
+		return concatBytes(await encryptMessage(message, encryptionKey, iv, await makeAuxFixedLength(aux)), iv);
+	} catch (error) {
+		throw new Error("Failed to encrypt symmetrically", { cause: error });
+	}
+}
+/**
+* Decryps symmetrically encrypted message
+*
+* @param encryptionKey - The symmetric CryptoKey used for message encryption
+* @param encryptedMessage - The ciphertext
+* @param aux - The auxilary string
+* @returns The resulting ciphertext.
+*/
+async function decryptSymmetrically(encryptionKey, encryptedMessage, aux) {
+	try {
+		const additionalData = await makeAuxFixedLength(aux);
+		return await decryptMessage(encryptedMessage.slice(0, encryptedMessage.length - IV_LEN_BYTES), encryptedMessage.slice(encryptedMessage.length - IV_LEN_BYTES), encryptionKey, additionalData);
+	} catch (error) {
+		throw new Error("Failed to decrypt symmetrically", { cause: error });
+	}
+}
+
+//#endregion
+//#region src/symmetric-crypto/index.ts
+var symmetric_crypto_exports = /* @__PURE__ */ __exportAll({
+	decryptSymmetrically: () => decryptSymmetrically,
+	deriveSymmetricCryptoKey: () => deriveSymmetricCryptoKey,
+	encryptSymmetrically: () => encryptSymmetrically,
+	exportSymmetricCryptoKey: () => exportSymmetricCryptoKey,
+	genSymmetricCryptoKey: () => genSymmetricCryptoKey,
+	genSymmetricKey: () => genSymmetricKey,
+	importSymmetricCryptoKey: () => importSymmetricCryptoKey
+});
+
+//#endregion
+export { exportSymmetricCryptoKey as a, importSymmetricCryptoKey as c, deriveSymmetricCryptoKey as i, decryptSymmetrically as n, genSymmetricCryptoKey as o, encryptSymmetrically as r, genSymmetricKey as s, symmetric_crypto_exports as t };
+//# sourceMappingURL=symmetric-crypto-CrdS1Che.mjs.map

package/dist/symmetric-crypto-CrdS1Che.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"symmetric-crypto-CrdS1Che.mjs","names":[],"sources":["../src/symmetric-crypto/keys.ts","../src/symmetric-crypto/core.ts","../src/symmetric-crypto/aes.ts","../src/symmetric-crypto/index.ts"],"sourcesContent":["import { AES_ALGORITHM, AES_KEY_BIT_LENGTH, KEY_FORMAT } from '../constants';\nimport { getBytesFromData } from '../hash';\n\n/**\n * Converts Uint8Array into CryptoKey\n *\n * @param keyData - The Uint8Array representation of the symmetric key\n * @returns The resulting symmetric CryptoKey.\n */\nexport async function importSymmetricCryptoKey(keyData: Uint8Array | ArrayBuffer): Promise<CryptoKey> {\n  return crypto.subtle.importKey(\n    KEY_FORMAT,\n    new Uint8Array(keyData),\n    {\n      name: AES_ALGORITHM,\n      length: AES_KEY_BIT_LENGTH,\n    },\n    true,\n    ['encrypt', 'decrypt'],\n  );\n}\n\n/**\n * Converts CryptoKey into Uint8Array\n *\n * @param key - The symmetric CryptoKey\n * @returns The resulting Uint8Array.\n */\nexport async function exportSymmetricCryptoKey(key: CryptoKey): Promise<Uint8Array> {\n  try {\n    const rawKey = await crypto.subtle.exportKey(KEY_FORMAT, key);\n    return new Uint8Array(rawKey);\n  } catch (error) {\n    throw new Error('Failed to export symmetric CryptoKey', { cause: error });\n  }\n}\n\n/**\n * Generates symmetric CryptoKey\n *\n * @returns The generated CryptoKey.\n */\nexport async function genSymmetricCryptoKey(): Promise<CryptoKey> {\n  return crypto.subtle.generateKey(\n    {\n      name: AES_ALGORITHM,\n      length: AES_KEY_BIT_LENGTH,\n    },\n    true,\n    ['encrypt', 'decrypt'],\n  );\n}\n\n/**\n * Generates symmetric key as Uint8Array\n *\n * @returns The generated Uint8Array.\n */\nexport function genSymmetricKey(): Uint8Array {\n  try {\n    const key = new Uint8Array(AES_KEY_BIT_LENGTH / 8);\n    crypto.getRandomValues(key);\n    return key;\n  } catch (error) {\n    throw new Error('Failed to generate symmetric key', { cause: error });\n  }\n}\n\n/**\n * Derives CryptoKey from the given key material\n *\n * @returns The derived CryptoKey.\n */\nexport async function deriveSymmetricCryptoKey(keyMaterial: Uint8Array): Promise<CryptoKey> {\n  try {\n    const hashBuffer = getBytesFromData(AES_KEY_BIT_LENGTH / 8, keyMaterial);\n    return importSymmetricCryptoKey(hashBuffer);\n  } catch (error) {\n    throw new Error('Failed to derive CryptoKey from the given key material', { cause: error });\n  }\n}\n","import { randomBytes } from '@noble/post-quantum/utils.js';\nimport { getBytesFromData } from '../hash';\nimport { AUX_BYTE_LEN, AES_ALGORITHM, IV_LEN_BYTES } from '../constants';\n\n/**\n * Creates an initialization vector (IV) using RGB-based construction (8.2.2 NIST Special Publication 800-38D)\n * Constructs a 128-bits IV from 2 fileds: the random field (at least 96 bits) and the free field (32 bits).\n * If free filed is empty, then the entier 128-bit IV is sampled randomly.\n *\n * @param freeFiled - The string with an unrestricted content. Can be a device identifier, etc.\n * @returns The resulting 128-bits initialization vector.\n */\nexport function createNISTbasedIV(freeField?: Uint8Array): Uint8Array {\n  try {\n    if (!freeField) {\n      return randomBytes(IV_LEN_BYTES);\n    }\n\n    const iv = new Uint8Array(16);\n\n    const randFiled = randomBytes(12);\n    iv.set(randFiled, 0);\n\n    const freeFiledFixedLength = getBytesFromData(4, freeField);\n    iv.set(freeFiledFixedLength, 12);\n\n    return iv;\n  } catch (error) {\n    throw new Error('Failed to create IV', { cause: error });\n  }\n}\n\n/**\n * Hashes aux string to make it fixed-length\n *\n * @param aux - The auxilay string of arbitrary length\n * @returns The resulting fixed-length auxilary string.\n */\nexport async function makeAuxFixedLength(aux: Uint8Array): Promise<Uint8Array> {\n  return getBytesFromData(AUX_BYTE_LEN, aux);\n}\n\n/**\n * Symmetrically encrypts message\n *\n * @param message - The message to encrypt\n * @param encryptionKey - The encryption key\n * @param iv - The initialization vector\n * @param additionalData - The auxilary data\n * @returns The resulting ciphertext\n */\nexport async function encryptMessage(\n  message: Uint8Array,\n  encryptionKey: CryptoKey,\n  iv: Uint8Array,\n  additionalData: Uint8Array,\n): Promise<Uint8Array> {\n  try {\n    const encrypted = await crypto.subtle.encrypt(\n      { name: AES_ALGORITHM, iv: iv as BufferSource, additionalData: additionalData as BufferSource },\n      encryptionKey,\n      message as BufferSource,\n    );\n    return new Uint8Array(encrypted);\n  } catch (error) {\n    throw new Error('Failed to encrypt symmetrically', { cause: error });\n  }\n}\n\n/**\n * Symmetrically decrypts message\n *\n * @param ciphertext - The encrypted message\n * @param ciphertext - The initialization vector\n * @param encryptionKey - The encryption key\n * @param additionalData - The auxilary data\n * @returns The resulting decrypted message\n */\nexport async function decryptMessage(\n  ciphertext: Uint8Array,\n  iv: Uint8Array,\n  encryptionKey: CryptoKey,\n  additionalData: Uint8Array,\n): Promise<Uint8Array> {\n  try {\n    const decrypted = await crypto.subtle.decrypt(\n      { name: AES_ALGORITHM, iv: iv as BufferSource, additionalData: additionalData as BufferSource },\n      encryptionKey,\n      ciphertext as BufferSource,\n    );\n    return new Uint8Array(decrypted);\n  } catch (error) {\n    throw new Error('Failed to decrypt symmetrically', { cause: error });\n  }\n}\n","import { createNISTbasedIV, makeAuxFixedLength, encryptMessage, decryptMessage } from './core';\nimport { concatBytes } from '@noble/hashes/utils.js';\nimport { IV_LEN_BYTES } from '../constants';\n\n/**\n * Symmetrically encrypts the message\n *\n * @param encryptionKey - The symmetric CryptoKey used for message encryption\n * @param message - The message to encrypt\n * @param freeField - The context of the message (required for IV generation)\n * @param aux - The auxilary string\n * @returns The resulting ciphertext.\n */\nexport async function encryptSymmetrically(\n  encryptionKey: CryptoKey,\n  message: Uint8Array,\n  aux: Uint8Array,\n  freeField?: Uint8Array,\n): Promise<Uint8Array> {\n  try {\n    const iv = createNISTbasedIV(freeField);\n    const additionalData = await makeAuxFixedLength(aux);\n    const ciphertext = await encryptMessage(message, encryptionKey, iv, additionalData);\n    return concatBytes(ciphertext, iv);\n  } catch (error) {\n    throw new Error('Failed to encrypt symmetrically', { cause: error });\n  }\n}\n\n/**\n * Decryps symmetrically encrypted message\n *\n * @param encryptionKey - The symmetric CryptoKey used for message encryption\n * @param encryptedMessage - The ciphertext\n * @param aux - The auxilary string\n * @returns The resulting ciphertext.\n */\nexport async function decryptSymmetrically(\n  encryptionKey: CryptoKey,\n  encryptedMessage: Uint8Array,\n  aux: Uint8Array,\n): Promise<Uint8Array> {\n  try {\n    const additionalData = await makeAuxFixedLength(aux);\n    const ciphertext = encryptedMessage.slice(0, encryptedMessage.length - IV_LEN_BYTES);\n    const iv = encryptedMessage.slice(encryptedMessage.length - IV_LEN_BYTES);\n    const result = await decryptMessage(ciphertext, iv, encryptionKey, additionalData);\n    return result;\n  } catch (error) {\n    throw new Error('Failed to decrypt symmetrically', { cause: error });\n  }\n}\n","export * from './keys';\nexport * from './aes';\n"],"mappings":"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"}

package/dist/symmetric-crypto-D65zB396.js

@@ -0,0 +1,244 @@
+const require_chunk = require('./chunk-Dt-PWiN7.js');
+const require_constants = require('./constants-Ccp21E03.js');
+const require_hash = require('./hash-BoqwNkcd.js');
+let _noble_hashes_utils_js = require("@noble/hashes/utils.js");
+let _noble_post_quantum_utils_js = require("@noble/post-quantum/utils.js");
+
+//#region src/symmetric-crypto/keys.ts
+/**
+* Converts Uint8Array into CryptoKey
+*
+* @param keyData - The Uint8Array representation of the symmetric key
+* @returns The resulting symmetric CryptoKey.
+*/
+async function importSymmetricCryptoKey(keyData) {
+	return crypto.subtle.importKey(require_constants.KEY_FORMAT, new Uint8Array(keyData), {
+		name: require_constants.AES_ALGORITHM,
+		length: require_constants.AES_KEY_BIT_LENGTH
+	}, true, ["encrypt", "decrypt"]);
+}
+/**
+* Converts CryptoKey into Uint8Array
+*
+* @param key - The symmetric CryptoKey
+* @returns The resulting Uint8Array.
+*/
+async function exportSymmetricCryptoKey(key) {
+	try {
+		const rawKey = await crypto.subtle.exportKey(require_constants.KEY_FORMAT, key);
+		return new Uint8Array(rawKey);
+	} catch (error) {
+		throw new Error("Failed to export symmetric CryptoKey", { cause: error });
+	}
+}
+/**
+* Generates symmetric CryptoKey
+*
+* @returns The generated CryptoKey.
+*/
+async function genSymmetricCryptoKey() {
+	return crypto.subtle.generateKey({
+		name: require_constants.AES_ALGORITHM,
+		length: require_constants.AES_KEY_BIT_LENGTH
+	}, true, ["encrypt", "decrypt"]);
+}
+/**
+* Generates symmetric key as Uint8Array
+*
+* @returns The generated Uint8Array.
+*/
+function genSymmetricKey() {
+	try {
+		const key = new Uint8Array(require_constants.AES_KEY_BIT_LENGTH / 8);
+		crypto.getRandomValues(key);
+		return key;
+	} catch (error) {
+		throw new Error("Failed to generate symmetric key", { cause: error });
+	}
+}
+/**
+* Derives CryptoKey from the given key material
+*
+* @returns The derived CryptoKey.
+*/
+async function deriveSymmetricCryptoKey(keyMaterial) {
+	try {
+		return importSymmetricCryptoKey(require_hash.getBytesFromData(require_constants.AES_KEY_BIT_LENGTH / 8, keyMaterial));
+	} catch (error) {
+		throw new Error("Failed to derive CryptoKey from the given key material", { cause: error });
+	}
+}
+
+//#endregion
+//#region src/symmetric-crypto/core.ts
+/**
+* Creates an initialization vector (IV) using RGB-based construction (8.2.2 NIST Special Publication 800-38D)
+* Constructs a 128-bits IV from 2 fileds: the random field (at least 96 bits) and the free field (32 bits).
+* If free filed is empty, then the entier 128-bit IV is sampled randomly.
+*
+* @param freeFiled - The string with an unrestricted content. Can be a device identifier, etc.
+* @returns The resulting 128-bits initialization vector.
+*/
+function createNISTbasedIV(freeField) {
+	try {
+		if (!freeField) return (0, _noble_post_quantum_utils_js.randomBytes)(require_constants.IV_LEN_BYTES);
+		const iv = new Uint8Array(16);
+		const randFiled = (0, _noble_post_quantum_utils_js.randomBytes)(12);
+		iv.set(randFiled, 0);
+		const freeFiledFixedLength = require_hash.getBytesFromData(4, freeField);
+		iv.set(freeFiledFixedLength, 12);
+		return iv;
+	} catch (error) {
+		throw new Error("Failed to create IV", { cause: error });
+	}
+}
+/**
+* Hashes aux string to make it fixed-length
+*
+* @param aux - The auxilay string of arbitrary length
+* @returns The resulting fixed-length auxilary string.
+*/
+async function makeAuxFixedLength(aux) {
+	return require_hash.getBytesFromData(require_constants.AUX_BYTE_LEN, aux);
+}
+/**
+* Symmetrically encrypts message
+*
+* @param message - The message to encrypt
+* @param encryptionKey - The encryption key
+* @param iv - The initialization vector
+* @param additionalData - The auxilary data
+* @returns The resulting ciphertext
+*/
+async function encryptMessage(message, encryptionKey, iv, additionalData) {
+	try {
+		const encrypted = await crypto.subtle.encrypt({
+			name: require_constants.AES_ALGORITHM,
+			iv,
+			additionalData
+		}, encryptionKey, message);
+		return new Uint8Array(encrypted);
+	} catch (error) {
+		throw new Error("Failed to encrypt symmetrically", { cause: error });
+	}
+}
+/**
+* Symmetrically decrypts message
+*
+* @param ciphertext - The encrypted message
+* @param ciphertext - The initialization vector
+* @param encryptionKey - The encryption key
+* @param additionalData - The auxilary data
+* @returns The resulting decrypted message
+*/
+async function decryptMessage(ciphertext, iv, encryptionKey, additionalData) {
+	try {
+		const decrypted = await crypto.subtle.decrypt({
+			name: require_constants.AES_ALGORITHM,
+			iv,
+			additionalData
+		}, encryptionKey, ciphertext);
+		return new Uint8Array(decrypted);
+	} catch (error) {
+		throw new Error("Failed to decrypt symmetrically", { cause: error });
+	}
+}
+
+//#endregion
+//#region src/symmetric-crypto/aes.ts
+/**
+* Symmetrically encrypts the message
+*
+* @param encryptionKey - The symmetric CryptoKey used for message encryption
+* @param message - The message to encrypt
+* @param freeField - The context of the message (required for IV generation)
+* @param aux - The auxilary string
+* @returns The resulting ciphertext.
+*/
+async function encryptSymmetrically(encryptionKey, message, aux, freeField) {
+	try {
+		const iv = createNISTbasedIV(freeField);
+		return (0, _noble_hashes_utils_js.concatBytes)(await encryptMessage(message, encryptionKey, iv, await makeAuxFixedLength(aux)), iv);
+	} catch (error) {
+		throw new Error("Failed to encrypt symmetrically", { cause: error });
+	}
+}
+/**
+* Decryps symmetrically encrypted message
+*
+* @param encryptionKey - The symmetric CryptoKey used for message encryption
+* @param encryptedMessage - The ciphertext
+* @param aux - The auxilary string
+* @returns The resulting ciphertext.
+*/
+async function decryptSymmetrically(encryptionKey, encryptedMessage, aux) {
+	try {
+		const additionalData = await makeAuxFixedLength(aux);
+		return await decryptMessage(encryptedMessage.slice(0, encryptedMessage.length - require_constants.IV_LEN_BYTES), encryptedMessage.slice(encryptedMessage.length - require_constants.IV_LEN_BYTES), encryptionKey, additionalData);
+	} catch (error) {
+		throw new Error("Failed to decrypt symmetrically", { cause: error });
+	}
+}
+
+//#endregion
+//#region src/symmetric-crypto/index.ts
+var symmetric_crypto_exports = /* @__PURE__ */ require_chunk.__exportAll({
+	decryptSymmetrically: () => decryptSymmetrically,
+	deriveSymmetricCryptoKey: () => deriveSymmetricCryptoKey,
+	encryptSymmetrically: () => encryptSymmetrically,
+	exportSymmetricCryptoKey: () => exportSymmetricCryptoKey,
+	genSymmetricCryptoKey: () => genSymmetricCryptoKey,
+	genSymmetricKey: () => genSymmetricKey,
+	importSymmetricCryptoKey: () => importSymmetricCryptoKey
+});
+
+//#endregion
+Object.defineProperty(exports, 'decryptSymmetrically', {
+  enumerable: true,
+  get: function () {
+    return decryptSymmetrically;
+  }
+});
+Object.defineProperty(exports, 'deriveSymmetricCryptoKey', {
+  enumerable: true,
+  get: function () {
+    return deriveSymmetricCryptoKey;
+  }
+});
+Object.defineProperty(exports, 'encryptSymmetrically', {
+  enumerable: true,
+  get: function () {
+    return encryptSymmetrically;
+  }
+});
+Object.defineProperty(exports, 'exportSymmetricCryptoKey', {
+  enumerable: true,
+  get: function () {
+    return exportSymmetricCryptoKey;
+  }
+});
+Object.defineProperty(exports, 'genSymmetricCryptoKey', {
+  enumerable: true,
+  get: function () {
+    return genSymmetricCryptoKey;
+  }
+});
+Object.defineProperty(exports, 'genSymmetricKey', {
+  enumerable: true,
+  get: function () {
+    return genSymmetricKey;
+  }
+});
+Object.defineProperty(exports, 'importSymmetricCryptoKey', {
+  enumerable: true,
+  get: function () {
+    return importSymmetricCryptoKey;
+  }
+});
+Object.defineProperty(exports, 'symmetric_crypto_exports', {
+  enumerable: true,
+  get: function () {
+    return symmetric_crypto_exports;
+  }
+});
+//# sourceMappingURL=symmetric-crypto-D65zB396.js.map

package/dist/symmetric-crypto-D65zB396.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"symmetric-crypto-D65zB396.js","names":["KEY_FORMAT","AES_ALGORITHM","AES_KEY_BIT_LENGTH","getBytesFromData","IV_LEN_BYTES","getBytesFromData","AUX_BYTE_LEN","AES_ALGORITHM","IV_LEN_BYTES"],"sources":["../src/symmetric-crypto/keys.ts","../src/symmetric-crypto/core.ts","../src/symmetric-crypto/aes.ts","../src/symmetric-crypto/index.ts"],"sourcesContent":["import { AES_ALGORITHM, AES_KEY_BIT_LENGTH, KEY_FORMAT } from '../constants';\nimport { getBytesFromData } from '../hash';\n\n/**\n * Converts Uint8Array into CryptoKey\n *\n * @param keyData - The Uint8Array representation of the symmetric key\n * @returns The resulting symmetric CryptoKey.\n */\nexport async function importSymmetricCryptoKey(keyData: Uint8Array | ArrayBuffer): Promise<CryptoKey> {\n  return crypto.subtle.importKey(\n    KEY_FORMAT,\n    new Uint8Array(keyData),\n    {\n      name: AES_ALGORITHM,\n      length: AES_KEY_BIT_LENGTH,\n    },\n    true,\n    ['encrypt', 'decrypt'],\n  );\n}\n\n/**\n * Converts CryptoKey into Uint8Array\n *\n * @param key - The symmetric CryptoKey\n * @returns The resulting Uint8Array.\n */\nexport async function exportSymmetricCryptoKey(key: CryptoKey): Promise<Uint8Array> {\n  try {\n    const rawKey = await crypto.subtle.exportKey(KEY_FORMAT, key);\n    return new Uint8Array(rawKey);\n  } catch (error) {\n    throw new Error('Failed to export symmetric CryptoKey', { cause: error });\n  }\n}\n\n/**\n * Generates symmetric CryptoKey\n *\n * @returns The generated CryptoKey.\n */\nexport async function genSymmetricCryptoKey(): Promise<CryptoKey> {\n  return crypto.subtle.generateKey(\n    {\n      name: AES_ALGORITHM,\n      length: AES_KEY_BIT_LENGTH,\n    },\n    true,\n    ['encrypt', 'decrypt'],\n  );\n}\n\n/**\n * Generates symmetric key as Uint8Array\n *\n * @returns The generated Uint8Array.\n */\nexport function genSymmetricKey(): Uint8Array {\n  try {\n    const key = new Uint8Array(AES_KEY_BIT_LENGTH / 8);\n    crypto.getRandomValues(key);\n    return key;\n  } catch (error) {\n    throw new Error('Failed to generate symmetric key', { cause: error });\n  }\n}\n\n/**\n * Derives CryptoKey from the given key material\n *\n * @returns The derived CryptoKey.\n */\nexport async function deriveSymmetricCryptoKey(keyMaterial: Uint8Array): Promise<CryptoKey> {\n  try {\n    const hashBuffer = getBytesFromData(AES_KEY_BIT_LENGTH / 8, keyMaterial);\n    return importSymmetricCryptoKey(hashBuffer);\n  } catch (error) {\n    throw new Error('Failed to derive CryptoKey from the given key material', { cause: error });\n  }\n}\n","import { randomBytes } from '@noble/post-quantum/utils.js';\nimport { getBytesFromData } from '../hash';\nimport { AUX_BYTE_LEN, AES_ALGORITHM, IV_LEN_BYTES } from '../constants';\n\n/**\n * Creates an initialization vector (IV) using RGB-based construction (8.2.2 NIST Special Publication 800-38D)\n * Constructs a 128-bits IV from 2 fileds: the random field (at least 96 bits) and the free field (32 bits).\n * If free filed is empty, then the entier 128-bit IV is sampled randomly.\n *\n * @param freeFiled - The string with an unrestricted content. Can be a device identifier, etc.\n * @returns The resulting 128-bits initialization vector.\n */\nexport function createNISTbasedIV(freeField?: Uint8Array): Uint8Array {\n  try {\n    if (!freeField) {\n      return randomBytes(IV_LEN_BYTES);\n    }\n\n    const iv = new Uint8Array(16);\n\n    const randFiled = randomBytes(12);\n    iv.set(randFiled, 0);\n\n    const freeFiledFixedLength = getBytesFromData(4, freeField);\n    iv.set(freeFiledFixedLength, 12);\n\n    return iv;\n  } catch (error) {\n    throw new Error('Failed to create IV', { cause: error });\n  }\n}\n\n/**\n * Hashes aux string to make it fixed-length\n *\n * @param aux - The auxilay string of arbitrary length\n * @returns The resulting fixed-length auxilary string.\n */\nexport async function makeAuxFixedLength(aux: Uint8Array): Promise<Uint8Array> {\n  return getBytesFromData(AUX_BYTE_LEN, aux);\n}\n\n/**\n * Symmetrically encrypts message\n *\n * @param message - The message to encrypt\n * @param encryptionKey - The encryption key\n * @param iv - The initialization vector\n * @param additionalData - The auxilary data\n * @returns The resulting ciphertext\n */\nexport async function encryptMessage(\n  message: Uint8Array,\n  encryptionKey: CryptoKey,\n  iv: Uint8Array,\n  additionalData: Uint8Array,\n): Promise<Uint8Array> {\n  try {\n    const encrypted = await crypto.subtle.encrypt(\n      { name: AES_ALGORITHM, iv: iv as BufferSource, additionalData: additionalData as BufferSource },\n      encryptionKey,\n      message as BufferSource,\n    );\n    return new Uint8Array(encrypted);\n  } catch (error) {\n    throw new Error('Failed to encrypt symmetrically', { cause: error });\n  }\n}\n\n/**\n * Symmetrically decrypts message\n *\n * @param ciphertext - The encrypted message\n * @param ciphertext - The initialization vector\n * @param encryptionKey - The encryption key\n * @param additionalData - The auxilary data\n * @returns The resulting decrypted message\n */\nexport async function decryptMessage(\n  ciphertext: Uint8Array,\n  iv: Uint8Array,\n  encryptionKey: CryptoKey,\n  additionalData: Uint8Array,\n): Promise<Uint8Array> {\n  try {\n    const decrypted = await crypto.subtle.decrypt(\n      { name: AES_ALGORITHM, iv: iv as BufferSource, additionalData: additionalData as BufferSource },\n      encryptionKey,\n      ciphertext as BufferSource,\n    );\n    return new Uint8Array(decrypted);\n  } catch (error) {\n    throw new Error('Failed to decrypt symmetrically', { cause: error });\n  }\n}\n","import { createNISTbasedIV, makeAuxFixedLength, encryptMessage, decryptMessage } from './core';\nimport { concatBytes } from '@noble/hashes/utils.js';\nimport { IV_LEN_BYTES } from '../constants';\n\n/**\n * Symmetrically encrypts the message\n *\n * @param encryptionKey - The symmetric CryptoKey used for message encryption\n * @param message - The message to encrypt\n * @param freeField - The context of the message (required for IV generation)\n * @param aux - The auxilary string\n * @returns The resulting ciphertext.\n */\nexport async function encryptSymmetrically(\n  encryptionKey: CryptoKey,\n  message: Uint8Array,\n  aux: Uint8Array,\n  freeField?: Uint8Array,\n): Promise<Uint8Array> {\n  try {\n    const iv = createNISTbasedIV(freeField);\n    const additionalData = await makeAuxFixedLength(aux);\n    const ciphertext = await encryptMessage(message, encryptionKey, iv, additionalData);\n    return concatBytes(ciphertext, iv);\n  } catch (error) {\n    throw new Error('Failed to encrypt symmetrically', { cause: error });\n  }\n}\n\n/**\n * Decryps symmetrically encrypted message\n *\n * @param encryptionKey - The symmetric CryptoKey used for message encryption\n * @param encryptedMessage - The ciphertext\n * @param aux - The auxilary string\n * @returns The resulting ciphertext.\n */\nexport async function decryptSymmetrically(\n  encryptionKey: CryptoKey,\n  encryptedMessage: Uint8Array,\n  aux: Uint8Array,\n): Promise<Uint8Array> {\n  try {\n    const additionalData = await makeAuxFixedLength(aux);\n    const ciphertext = encryptedMessage.slice(0, encryptedMessage.length - IV_LEN_BYTES);\n    const iv = encryptedMessage.slice(encryptedMessage.length - IV_LEN_BYTES);\n    const result = await decryptMessage(ciphertext, iv, encryptionKey, additionalData);\n    return result;\n  } catch (error) {\n    throw new Error('Failed to decrypt symmetrically', { cause: error });\n  }\n}\n","export * from './keys';\nexport * from './aes';\n"],"mappings":"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"}