internxt-crypto 0.0.14 → 1.0.1

package/dist/xwing-iRWVRtNE.js

@@ -0,0 +1,34 @@
+const require_chunk = require('./chunk-EbLFQX5m.js');
+let _noble_post_quantum_hybrid_js = require("@noble/post-quantum/hybrid.js");
+
+//#region src/hybrid-crypto/xwing.ts
+function genHybridKeys(seed) {
+	return _noble_post_quantum_hybrid_js.ml_kem768_x25519.keygen(seed);
+}
+function encapsulateHybrid(publicKey) {
+	return _noble_post_quantum_hybrid_js.ml_kem768_x25519.encapsulate(publicKey);
+}
+function decapsulateHybrid(cipherText, secretKey) {
+	return _noble_post_quantum_hybrid_js.ml_kem768_x25519.decapsulate(cipherText, secretKey);
+}
+
+//#endregion
+Object.defineProperty(exports, 'decapsulateHybrid', {
+  enumerable: true,
+  get: function () {
+    return decapsulateHybrid;
+  }
+});
+Object.defineProperty(exports, 'encapsulateHybrid', {
+  enumerable: true,
+  get: function () {
+    return encapsulateHybrid;
+  }
+});
+Object.defineProperty(exports, 'genHybridKeys', {
+  enumerable: true,
+  get: function () {
+    return genHybridKeys;
+  }
+});
+//# sourceMappingURL=xwing-iRWVRtNE.js.map

package/dist/xwing-iRWVRtNE.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"xwing-iRWVRtNE.js","names":["hybridCipher"],"sources":["../src/hybrid-crypto/xwing.ts"],"sourcesContent":["import { ml_kem768_x25519 as hybridCipher } from '@noble/post-quantum/hybrid.js';\nimport { HybridKeyPair } from '../types';\n\nexport function genHybridKeys(seed?: Uint8Array): HybridKeyPair {\n  return hybridCipher.keygen(seed);\n}\n\nexport function encapsulateHybrid(publicKey: Uint8Array): { cipherText: Uint8Array; sharedSecret: Uint8Array } {\n  return hybridCipher.encapsulate(publicKey);\n}\n\nexport function decapsulateHybrid(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array {\n  return hybridCipher.decapsulate(cipherText, secretKey);\n}\n"],"mappings":";;;;AAGA,SAAgB,cAAc,MAAkC;AAC9D,QAAOA,+CAAa,OAAO,KAAK;;AAGlC,SAAgB,kBAAkB,WAA6E;AAC7G,QAAOA,+CAAa,YAAY,UAAU;;AAG5C,SAAgB,kBAAkB,YAAwB,WAAmC;AAC3F,QAAOA,+CAAa,YAAY,YAAY,UAAU"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "internxt-crypto",
-  "version": "0.0.14",
+  "version": "1.0.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "module": "dist/index.js",
@@ -26,7 +26,7 @@
     "@vitest/browser-playwright": "^4.0.10",
     "@vitest/coverage-istanbul": "^4.0.10",
     "@vitest/coverage-v8": "^4.0.18",
-    "eslint": "^10.0.0",
+    "eslint": "^10.0.2",
     "knip": "^5.84.0",
     "lint-staged": "^16.1.4",
     "playwright": "^1.54.1",
@@ -37,6 +37,7 @@
   },
   "dependencies": {
     "@noble/ciphers": "^2.1.1",
+    "@noble/curves": "^2.0.1",
     "@noble/hashes": "^2.0.1",
     "@noble/post-quantum": "^0.5.2",
     "@scure/bip39": "^2.0.1",
@@ -53,7 +54,7 @@
       "require": "./dist/index.js"
     },
     "./*": {
-      "types": "./dist/*.d.ts",
+     "types": "./dist/*.d.mts", 
       "import": "./dist/*.mjs",
       "require": "./dist/*.js"
     }

package/dist/aes-DCb9dJqb.mjs

@@ -1,161 +0,0 @@
-import { AES_ALGORITHM, AES_KEY_BIT_LENGTH, AUX_BYTE_LEN, IV_LEN_BYTES, KEY_FORMAT } from "./constants.mjs";
-import { n as getBytesFromData } from "./mac-ZpRlx8Fs.mjs";
-import { concatBytes } from "@noble/hashes/utils.js";
-import { randomBytes } from "@noble/post-quantum/utils.js";
-import { gcm } from "@noble/ciphers/webcrypto.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() {
-	return randomBytes(AES_KEY_BIT_LENGTH / 8);
-}
-/**
-* 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) {
-	return gcm(encryptionKey, iv, additionalData).encrypt(message);
-}
-/**
-* 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) {
-	return gcm(encryptionKey, iv, additionalData).decrypt(ciphertext);
-}
-
-//#endregion
-//#region src/symmetric-crypto/aes.ts
-/**
-* Symmetrically encrypts the message
-*
-* @param encryptionKey - The symmetric key 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 key 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
-export { genSymmetricCryptoKey as a, exportSymmetricCryptoKey as i, encryptSymmetrically as n, genSymmetricKey as o, deriveSymmetricCryptoKey as r, importSymmetricCryptoKey as s, decryptSymmetrically as t };
-//# sourceMappingURL=aes-DCb9dJqb.mjs.map

package/dist/aes-DCb9dJqb.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"aes-DCb9dJqb.mjs","names":["aeadCipher"],"sources":["../src/symmetric-crypto/keys.ts","../src/symmetric-crypto/core.ts","../src/symmetric-crypto/aes.ts"],"sourcesContent":["import { AES_ALGORITHM, AES_KEY_BIT_LENGTH, KEY_FORMAT } from '../constants';\nimport { randomBytes } from '@noble/post-quantum/utils.js';\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  return randomBytes(AES_KEY_BIT_LENGTH / 8);\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 { gcm as aeadCipher } from '@noble/ciphers/webcrypto.js';\nimport { randomBytes } from '@noble/post-quantum/utils.js';\nimport { getBytesFromData } from '../hash';\nimport { AUX_BYTE_LEN, 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: Uint8Array,\n  iv: Uint8Array,\n  additionalData: Uint8Array,\n): Promise<Uint8Array> {\n  return aeadCipher(encryptionKey, iv, additionalData).encrypt(message);\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: Uint8Array,\n  additionalData: Uint8Array,\n): Promise<Uint8Array> {\n  return aeadCipher(encryptionKey, iv, additionalData).decrypt(ciphertext);\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 key 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: Uint8Array,\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 key 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: Uint8Array,\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"],"mappings":";;;;;;;;;;;;;AAUA,eAAsB,yBAAyB,SAAuD;AACpG,QAAO,OAAO,OAAO,UACnB,YACA,IAAI,WAAW,QAAQ,EACvB;EACE,MAAM;EACN,QAAQ;EACT,EACD,MACA,CAAC,WAAW,UAAU,CACvB;;;;;;;;AASH,eAAsB,yBAAyB,KAAqC;AAClF,KAAI;EACF,MAAM,SAAS,MAAM,OAAO,OAAO,UAAU,YAAY,IAAI;AAC7D,SAAO,IAAI,WAAW,OAAO;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,wCAAwC,EAAE,OAAO,OAAO,CAAC;;;;;;;;AAS7E,eAAsB,wBAA4C;AAChE,QAAO,OAAO,OAAO,YACnB;EACE,MAAM;EACN,QAAQ;EACT,EACD,MACA,CAAC,WAAW,UAAU,CACvB;;;;;;;AAQH,SAAgB,kBAA8B;AAC5C,QAAO,YAAY,qBAAqB,EAAE;;;;;;;AAQ5C,eAAsB,yBAAyB,aAA6C;AAC1F,KAAI;AAEF,SAAO,yBADY,iBAAiB,qBAAqB,GAAG,YAAY,CAC7B;UACpC,OAAO;AACd,QAAM,IAAI,MAAM,0DAA0D,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;;;;AC5D/F,SAAgB,kBAAkB,WAAoC;AACpE,KAAI;AACF,MAAI,CAAC,UACH,QAAO,YAAY,aAAa;EAGlC,MAAM,KAAK,IAAI,WAAW,GAAG;EAE7B,MAAM,YAAY,YAAY,GAAG;AACjC,KAAG,IAAI,WAAW,EAAE;EAEpB,MAAM,uBAAuB,iBAAiB,GAAG,UAAU;AAC3D,KAAG,IAAI,sBAAsB,GAAG;AAEhC,SAAO;UACA,OAAO;AACd,QAAM,IAAI,MAAM,uBAAuB,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAU5D,eAAsB,mBAAmB,KAAsC;AAC7E,QAAO,iBAAiB,cAAc,IAAI;;;;;;;;;;;AAY5C,eAAsB,eACpB,SACA,eACA,IACA,gBACqB;AACrB,QAAOA,IAAW,eAAe,IAAI,eAAe,CAAC,QAAQ,QAAQ;;;;;;;;;;;AAYvE,eAAsB,eACpB,YACA,IACA,eACA,gBACqB;AACrB,QAAOA,IAAW,eAAe,IAAI,eAAe,CAAC,QAAQ,WAAW;;;;;;;;;;;;;;AC/D1E,eAAsB,qBACpB,eACA,SACA,KACA,WACqB;AACrB,KAAI;EACF,MAAM,KAAK,kBAAkB,UAAU;AAGvC,SAAO,YADY,MAAM,eAAe,SAAS,eAAe,IADzC,MAAM,mBAAmB,IAAI,CAC+B,EACpD,GAAG;UAC3B,OAAO;AACd,QAAM,IAAI,MAAM,mCAAmC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAYxE,eAAsB,qBACpB,eACA,kBACA,KACqB;AACrB,KAAI;EACF,MAAM,iBAAiB,MAAM,mBAAmB,IAAI;AAIpD,SADe,MAAM,eAFF,iBAAiB,MAAM,GAAG,iBAAiB,SAAS,aAAa,EACzE,iBAAiB,MAAM,iBAAiB,SAAS,aAAa,EACrB,eAAe,eAAe;UAE3E,OAAO;AACd,QAAM,IAAI,MAAM,mCAAmC,EAAE,OAAO,OAAO,CAAC"}

package/dist/aes-DQo1MyCz.js

@@ -1,203 +0,0 @@
-const require_chunk = require('./chunk-EbLFQX5m.js');
-const require_constants = require('./constants.js');
-const require_mac = require('./mac-BMb1F0dN.js');
-let _noble_hashes_utils_js = require("@noble/hashes/utils.js");
-let _noble_post_quantum_utils_js = require("@noble/post-quantum/utils.js");
-let _noble_ciphers_webcrypto_js = require("@noble/ciphers/webcrypto.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() {
-	return (0, _noble_post_quantum_utils_js.randomBytes)(require_constants.AES_KEY_BIT_LENGTH / 8);
-}
-/**
-* Derives CryptoKey from the given key material
-*
-* @returns The derived CryptoKey.
-*/
-async function deriveSymmetricCryptoKey(keyMaterial) {
-	try {
-		return importSymmetricCryptoKey(require_mac.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_mac.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_mac.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) {
-	return (0, _noble_ciphers_webcrypto_js.gcm)(encryptionKey, iv, additionalData).encrypt(message);
-}
-/**
-* 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) {
-	return (0, _noble_ciphers_webcrypto_js.gcm)(encryptionKey, iv, additionalData).decrypt(ciphertext);
-}
-
-//#endregion
-//#region src/symmetric-crypto/aes.ts
-/**
-* Symmetrically encrypts the message
-*
-* @param encryptionKey - The symmetric key 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 key 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
-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;
-  }
-});
-//# sourceMappingURL=aes-DQo1MyCz.js.map

package/dist/aes-DQo1MyCz.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"aes-DQo1MyCz.js","names":["KEY_FORMAT","AES_ALGORITHM","AES_KEY_BIT_LENGTH","getBytesFromData","IV_LEN_BYTES","getBytesFromData","AUX_BYTE_LEN","IV_LEN_BYTES"],"sources":["../src/symmetric-crypto/keys.ts","../src/symmetric-crypto/core.ts","../src/symmetric-crypto/aes.ts"],"sourcesContent":["import { AES_ALGORITHM, AES_KEY_BIT_LENGTH, KEY_FORMAT } from '../constants';\nimport { randomBytes } from '@noble/post-quantum/utils.js';\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  return randomBytes(AES_KEY_BIT_LENGTH / 8);\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 { gcm as aeadCipher } from '@noble/ciphers/webcrypto.js';\nimport { randomBytes } from '@noble/post-quantum/utils.js';\nimport { getBytesFromData } from '../hash';\nimport { AUX_BYTE_LEN, 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: Uint8Array,\n  iv: Uint8Array,\n  additionalData: Uint8Array,\n): Promise<Uint8Array> {\n  return aeadCipher(encryptionKey, iv, additionalData).encrypt(message);\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: Uint8Array,\n  additionalData: Uint8Array,\n): Promise<Uint8Array> {\n  return aeadCipher(encryptionKey, iv, additionalData).decrypt(ciphertext);\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 key 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: Uint8Array,\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 key 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: Uint8Array,\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"],"mappings":";;;;;;;;;;;;;;AAUA,eAAsB,yBAAyB,SAAuD;AACpG,QAAO,OAAO,OAAO,UACnBA,8BACA,IAAI,WAAW,QAAQ,EACvB;EACE,MAAMC;EACN,QAAQC;EACT,EACD,MACA,CAAC,WAAW,UAAU,CACvB;;;;;;;;AASH,eAAsB,yBAAyB,KAAqC;AAClF,KAAI;EACF,MAAM,SAAS,MAAM,OAAO,OAAO,UAAUF,8BAAY,IAAI;AAC7D,SAAO,IAAI,WAAW,OAAO;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,wCAAwC,EAAE,OAAO,OAAO,CAAC;;;;;;;;AAS7E,eAAsB,wBAA4C;AAChE,QAAO,OAAO,OAAO,YACnB;EACE,MAAMC;EACN,QAAQC;EACT,EACD,MACA,CAAC,WAAW,UAAU,CACvB;;;;;;;AAQH,SAAgB,kBAA8B;AAC5C,sDAAmBA,uCAAqB,EAAE;;;;;;;AAQ5C,eAAsB,yBAAyB,aAA6C;AAC1F,KAAI;AAEF,SAAO,yBADYC,6BAAiBD,uCAAqB,GAAG,YAAY,CAC7B;UACpC,OAAO;AACd,QAAM,IAAI,MAAM,0DAA0D,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;;;;AC5D/F,SAAgB,kBAAkB,WAAoC;AACpE,KAAI;AACF,MAAI,CAAC,UACH,sDAAmBE,+BAAa;EAGlC,MAAM,KAAK,IAAI,WAAW,GAAG;EAE7B,MAAM,0DAAwB,GAAG;AACjC,KAAG,IAAI,WAAW,EAAE;EAEpB,MAAM,uBAAuBC,6BAAiB,GAAG,UAAU;AAC3D,KAAG,IAAI,sBAAsB,GAAG;AAEhC,SAAO;UACA,OAAO;AACd,QAAM,IAAI,MAAM,uBAAuB,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAU5D,eAAsB,mBAAmB,KAAsC;AAC7E,QAAOA,6BAAiBC,gCAAc,IAAI;;;;;;;;;;;AAY5C,eAAsB,eACpB,SACA,eACA,IACA,gBACqB;AACrB,6CAAkB,eAAe,IAAI,eAAe,CAAC,QAAQ,QAAQ;;;;;;;;;;;AAYvE,eAAsB,eACpB,YACA,IACA,eACA,gBACqB;AACrB,6CAAkB,eAAe,IAAI,eAAe,CAAC,QAAQ,WAAW;;;;;;;;;;;;;;AC/D1E,eAAsB,qBACpB,eACA,SACA,KACA,WACqB;AACrB,KAAI;EACF,MAAM,KAAK,kBAAkB,UAAU;AAGvC,iDADmB,MAAM,eAAe,SAAS,eAAe,IADzC,MAAM,mBAAmB,IAAI,CAC+B,EACpD,GAAG;UAC3B,OAAO;AACd,QAAM,IAAI,MAAM,mCAAmC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAYxE,eAAsB,qBACpB,eACA,kBACA,KACqB;AACrB,KAAI;EACF,MAAM,iBAAiB,MAAM,mBAAmB,IAAI;AAIpD,SADe,MAAM,eAFF,iBAAiB,MAAM,GAAG,iBAAiB,SAASC,+BAAa,EACzE,iBAAiB,MAAM,iBAAiB,SAASA,+BAAa,EACrB,eAAe,eAAe;UAE3E,OAAO;AACd,QAAM,IAAI,MAAM,mCAAmC,EAAE,OAAO,OAAO,CAAC"}