internxt-crypto 0.0.10-alpha → 0.0.13

package/dist/kyber1024-jeKS8CXf.js

@@ -0,0 +1,173 @@
+const require_chunk = require('./chunk-EbLFQX5m.js');
+let _noble_post_quantum_ml_kem_js = require("@noble/post-quantum/ml-kem.js");
+
+//#region src/post-quantum-crypto/kyber768.ts
+/**
+* Generates public and secret Kyber keys
+*
+* @param seed - The optional seed
+* @returns The generated Kyber key pair.
+*/
+function generateKyberKeys$2(seed) {
+	try {
+		return _noble_post_quantum_ml_kem_js.ml_kem768.keygen(seed);
+	} catch (error) {
+		throw new Error("Failed to generate Kyber keys", { cause: error });
+	}
+}
+/**
+* Generates a shared secret of 256-bits and encapsulates it to the given public key using Kyber algorithms
+*
+* @param publicKey - The public Kyber key
+* @returns The resulting encapsulation and the generated shared secret.
+*/
+function encapsulateKyber$2(publicKey) {
+	try {
+		return _noble_post_quantum_ml_kem_js.ml_kem768.encapsulate(publicKey);
+	} catch (error) {
+		throw new Error("Failed to encapsulate", { cause: error });
+	}
+}
+/**
+* Decapsulates the encapsulated shared secret using Kyber algorithms
+*
+* @param cipherText - The encapsulated key
+* @param secretKey - The private Kyber key
+* @returns The resulting decapsulated shared secret.
+*/
+function decapsulateKyber$2(cipherText, secretKey) {
+	try {
+		return _noble_post_quantum_ml_kem_js.ml_kem768.decapsulate(cipherText, secretKey);
+	} catch (error) {
+		throw new Error("Failed to decapsulate", { cause: error });
+	}
+}
+
+//#endregion
+//#region src/post-quantum-crypto/kyber512.ts
+var kyber512_exports = /* @__PURE__ */ require_chunk.__exportAll({
+	decapsulateKyber: () => decapsulateKyber$1,
+	encapsulateKyber: () => encapsulateKyber$1,
+	generateKyberKeys: () => generateKyberKeys$1
+});
+/**
+* Generates public and secret Kyber keys
+*
+* @param seed - The optional seed
+* @returns The generated Kyber key pair.
+*/
+function generateKyberKeys$1(seed) {
+	try {
+		return _noble_post_quantum_ml_kem_js.ml_kem512.keygen(seed);
+	} catch (error) {
+		throw new Error("Failed to generate Kyber keys", { cause: error });
+	}
+}
+/**
+* Generates a shared secret of 256-bits and encapsulates it to the given public key using Kyber algorithms
+*
+* @param publicKey - The public Kyber key
+* @returns The resulting encapsulation and the generated shared secret.
+*/
+function encapsulateKyber$1(publicKey) {
+	try {
+		return _noble_post_quantum_ml_kem_js.ml_kem512.encapsulate(publicKey);
+	} catch (error) {
+		throw new Error("Failed to encapsulate", { cause: error });
+	}
+}
+/**
+* Decapsulates the encapsulated shared secret using Kyber algorithms
+*
+* @param cipherText - The encapsulated key
+* @param secretKey - The private Kyber key
+* @returns The resulting decapsulated shared secret.
+*/
+function decapsulateKyber$1(cipherText, secretKey) {
+	try {
+		return _noble_post_quantum_ml_kem_js.ml_kem512.decapsulate(cipherText, secretKey);
+	} catch (error) {
+		throw new Error("Failed to decapsulate", { cause: error });
+	}
+}
+
+//#endregion
+//#region src/post-quantum-crypto/kyber1024.ts
+var kyber1024_exports = /* @__PURE__ */ require_chunk.__exportAll({
+	decapsulateKyber: () => decapsulateKyber,
+	encapsulateKyber: () => encapsulateKyber,
+	generateKyberKeys: () => generateKyberKeys
+});
+/**
+* Generates public and secret Kyber keys
+*
+* @param seed - The optional seed
+* @returns The generated Kyber key pair.
+*/
+function generateKyberKeys(seed) {
+	try {
+		return _noble_post_quantum_ml_kem_js.ml_kem1024.keygen(seed);
+	} catch (error) {
+		throw new Error("Failed to generate Kyber keys", { cause: error });
+	}
+}
+/**
+* Generates a shared secret of 256-bits and encapsulates it to the given public key using Kyber algorithms
+*
+* @param publicKey - The public Kyber key
+* @returns The resulting encapsulation and the generated shared secret.
+*/
+function encapsulateKyber(publicKey) {
+	try {
+		return _noble_post_quantum_ml_kem_js.ml_kem1024.encapsulate(publicKey);
+	} catch (error) {
+		throw new Error("Failed to encapsulate", { cause: error });
+	}
+}
+/**
+* Decapsulates the encapsulated shared secret using Kyber algorithms
+*
+* @param cipherText - The encapsulated key
+* @param secretKey - The private Kyber key
+* @returns The resulting decapsulated shared secret.
+*/
+function decapsulateKyber(cipherText, secretKey) {
+	try {
+		return _noble_post_quantum_ml_kem_js.ml_kem1024.decapsulate(cipherText, secretKey);
+	} catch (error) {
+		throw new Error("Failed to decapsulate", { cause: error });
+	}
+}
+
+//#endregion
+Object.defineProperty(exports, 'decapsulateKyber', {
+  enumerable: true,
+  get: function () {
+    return decapsulateKyber$2;
+  }
+});
+Object.defineProperty(exports, 'encapsulateKyber', {
+  enumerable: true,
+  get: function () {
+    return encapsulateKyber$2;
+  }
+});
+Object.defineProperty(exports, 'generateKyberKeys', {
+  enumerable: true,
+  get: function () {
+    return generateKyberKeys$2;
+  }
+});
+Object.defineProperty(exports, 'kyber1024_exports', {
+  enumerable: true,
+  get: function () {
+    return kyber1024_exports;
+  }
+});
+Object.defineProperty(exports, 'kyber512_exports', {
+  enumerable: true,
+  get: function () {
+    return kyber512_exports;
+  }
+});
+//# sourceMappingURL=kyber1024-jeKS8CXf.js.map

package/dist/kyber1024-jeKS8CXf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kyber1024-jeKS8CXf.js","names":["generateKyberKeys","ml_kem768","encapsulateKyber","decapsulateKyber","generateKyberKeys","ml_kem512","encapsulateKyber","decapsulateKyber","ml_kem1024"],"sources":["../src/post-quantum-crypto/kyber768.ts","../src/post-quantum-crypto/kyber512.ts","../src/post-quantum-crypto/kyber1024.ts"],"sourcesContent":["import { ml_kem768 } from '@noble/post-quantum/ml-kem.js';\n\n/**\n * Generates public and secret Kyber keys\n *\n * @param seed - The optional seed\n * @returns The generated Kyber key pair.\n */\nexport function generateKyberKeys(seed?: Uint8Array): {\n  publicKey: Uint8Array;\n  secretKey: Uint8Array;\n} {\n  try {\n    return ml_kem768.keygen(seed);\n  } catch (error) {\n    throw new Error('Failed to generate Kyber keys', { cause: error });\n  }\n}\n\n/**\n * Generates a shared secret of 256-bits and encapsulates it to the given public key using Kyber algorithms\n *\n * @param publicKey - The public Kyber key\n * @returns The resulting encapsulation and the generated shared secret.\n */\nexport function encapsulateKyber(publicKey: Uint8Array): {\n  cipherText: Uint8Array;\n  sharedSecret: Uint8Array;\n} {\n  try {\n    return ml_kem768.encapsulate(publicKey);\n  } catch (error) {\n    throw new Error('Failed to encapsulate', { cause: error });\n  }\n}\n\n/**\n * Decapsulates the encapsulated shared secret using Kyber algorithms\n *\n * @param cipherText - The encapsulated key\n * @param secretKey - The private Kyber key\n * @returns The resulting decapsulated shared secret.\n */\nexport function decapsulateKyber(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array {\n  try {\n    return ml_kem768.decapsulate(cipherText, secretKey);\n  } catch (error) {\n    throw new Error('Failed to decapsulate', { cause: error });\n  }\n}\n","import { ml_kem512 } from '@noble/post-quantum/ml-kem.js';\n\n/**\n * Generates public and secret Kyber keys\n *\n * @param seed - The optional seed\n * @returns The generated Kyber key pair.\n */\nexport function generateKyberKeys(seed?: Uint8Array): {\n  publicKey: Uint8Array;\n  secretKey: Uint8Array;\n} {\n  try {\n    return ml_kem512.keygen(seed);\n  } catch (error) {\n    throw new Error('Failed to generate Kyber keys', { cause: error });\n  }\n}\n\n/**\n * Generates a shared secret of 256-bits and encapsulates it to the given public key using Kyber algorithms\n *\n * @param publicKey - The public Kyber key\n * @returns The resulting encapsulation and the generated shared secret.\n */\nexport function encapsulateKyber(publicKey: Uint8Array): {\n  cipherText: Uint8Array;\n  sharedSecret: Uint8Array;\n} {\n  try {\n    return ml_kem512.encapsulate(publicKey);\n  } catch (error) {\n    throw new Error('Failed to encapsulate', { cause: error });\n  }\n}\n\n/**\n * Decapsulates the encapsulated shared secret using Kyber algorithms\n *\n * @param cipherText - The encapsulated key\n * @param secretKey - The private Kyber key\n * @returns The resulting decapsulated shared secret.\n */\nexport function decapsulateKyber(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array {\n  try {\n    return ml_kem512.decapsulate(cipherText, secretKey);\n  } catch (error) {\n    throw new Error('Failed to decapsulate', { cause: error });\n  }\n}\n","import { ml_kem1024 } from '@noble/post-quantum/ml-kem.js';\n\n/**\n * Generates public and secret Kyber keys\n *\n * @param seed - The optional seed\n * @returns The generated Kyber key pair.\n */\nexport function generateKyberKeys(seed?: Uint8Array): {\n  publicKey: Uint8Array;\n  secretKey: Uint8Array;\n} {\n  try {\n    return ml_kem1024.keygen(seed);\n  } catch (error) {\n    throw new Error('Failed to generate Kyber keys', { cause: error });\n  }\n}\n\n/**\n * Generates a shared secret of 256-bits and encapsulates it to the given public key using Kyber algorithms\n *\n * @param publicKey - The public Kyber key\n * @returns The resulting encapsulation and the generated shared secret.\n */\nexport function encapsulateKyber(publicKey: Uint8Array): {\n  cipherText: Uint8Array;\n  sharedSecret: Uint8Array;\n} {\n  try {\n    return ml_kem1024.encapsulate(publicKey);\n  } catch (error) {\n    throw new Error('Failed to encapsulate', { cause: error });\n  }\n}\n\n/**\n * Decapsulates the encapsulated shared secret using Kyber algorithms\n *\n * @param cipherText - The encapsulated key\n * @param secretKey - The private Kyber key\n * @returns The resulting decapsulated shared secret.\n */\nexport function decapsulateKyber(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array {\n  try {\n    return ml_kem1024.decapsulate(cipherText, secretKey);\n  } catch (error) {\n    throw new Error('Failed to decapsulate', { cause: error });\n  }\n}\n"],"mappings":";;;;;;;;;;AAQA,SAAgBA,oBAAkB,MAGhC;AACA,KAAI;AACF,SAAOC,wCAAU,OAAO,KAAK;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,iCAAiC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAUtE,SAAgBC,mBAAiB,WAG/B;AACA,KAAI;AACF,SAAOD,wCAAU,YAAY,UAAU;UAChC,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW9D,SAAgBE,mBAAiB,YAAwB,WAAmC;AAC1F,KAAI;AACF,SAAOF,wCAAU,YAAY,YAAY,UAAU;UAC5C,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;;;;;;;ACvC9D,SAAgBG,oBAAkB,MAGhC;AACA,KAAI;AACF,SAAOC,wCAAU,OAAO,KAAK;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,iCAAiC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAUtE,SAAgBC,mBAAiB,WAG/B;AACA,KAAI;AACF,SAAOD,wCAAU,YAAY,UAAU;UAChC,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW9D,SAAgBE,mBAAiB,YAAwB,WAAmC;AAC1F,KAAI;AACF,SAAOF,wCAAU,YAAY,YAAY,UAAU;UAC5C,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;;;;;;;ACvC9D,SAAgB,kBAAkB,MAGhC;AACA,KAAI;AACF,SAAOG,yCAAW,OAAO,KAAK;UACvB,OAAO;AACd,QAAM,IAAI,MAAM,iCAAiC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAUtE,SAAgB,iBAAiB,WAG/B;AACA,KAAI;AACF,SAAOA,yCAAW,YAAY,UAAU;UACjC,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW9D,SAAgB,iBAAiB,YAAwB,WAAmC;AAC1F,KAAI;AACF,SAAOA,yCAAW,YAAY,YAAY,UAAU;UAC7C,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC"}

package/dist/{kyber768-B87rMQ7u.d.mts → kyber768-DGBB_RS7.d.ts}

@@ -1,3 +1,4 @@
+//#region src/post-quantum-crypto/kyber768.d.ts
 /**
  * Generates public and secret Kyber keys
  *
@@ -5,8 +6,8 @@
  * @returns The generated Kyber key pair.
  */
 declare function generateKyberKeys(seed?: Uint8Array): {
-    publicKey: Uint8Array;
-    secretKey: Uint8Array;
+  publicKey: Uint8Array;
+  secretKey: Uint8Array;
 };
 /**
  * Generates a shared secret of 256-bits and encapsulates it to the given public key using Kyber algorithms
@@ -15,8 +16,8 @@ declare function generateKyberKeys(seed?: Uint8Array): {
  * @returns The resulting encapsulation and the generated shared secret.
  */
 declare function encapsulateKyber(publicKey: Uint8Array): {
-    cipherText: Uint8Array;
-    sharedSecret: Uint8Array;
+  cipherText: Uint8Array;
+  sharedSecret: Uint8Array;
 };
 /**
  * Decapsulates the encapsulated shared secret using Kyber algorithms
@@ -26,5 +27,6 @@ declare function encapsulateKyber(publicKey: Uint8Array): {
  * @returns The resulting decapsulated shared secret.
  */
 declare function decapsulateKyber(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array;
-
-export { decapsulateKyber as d, encapsulateKyber as e, generateKyberKeys as g };
+//#endregion
+export { encapsulateKyber as n, generateKyberKeys as r, decapsulateKyber as t };
+//# sourceMappingURL=kyber768-DGBB_RS7.d.ts.map

package/dist/kyber768-DGBB_RS7.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kyber768-DGBB_RS7.d.ts","names":[],"sources":["../src/post-quantum-crypto/kyber768.ts"],"mappings":";;AAQA;;;;;iBAAgB,iBAAA,CAAkB,IAAA,GAAO,UAAA;EACvC,SAAA,EAAW,UAAA;EACX,SAAA,EAAW,UAAA;AAAA;;;;;;;iBAeG,gBAAA,CAAiB,SAAA,EAAW,UAAA;EAC1C,UAAA,EAAY,UAAA;EACZ,YAAA,EAAc,UAAA;AAAA;;;;;;;;iBAgBA,gBAAA,CAAiB,UAAA,EAAY,UAAA,EAAY,SAAA,EAAW,UAAA,GAAa,UAAA"}

package/dist/{kyber768-B87rMQ7u.d.ts → kyber768-DzIcGg1i.d.mts}

@@ -1,3 +1,4 @@
+//#region src/post-quantum-crypto/kyber768.d.ts
 /**
  * Generates public and secret Kyber keys
  *
@@ -5,8 +6,8 @@
  * @returns The generated Kyber key pair.
  */
 declare function generateKyberKeys(seed?: Uint8Array): {
-    publicKey: Uint8Array;
-    secretKey: Uint8Array;
+  publicKey: Uint8Array;
+  secretKey: Uint8Array;
 };
 /**
  * Generates a shared secret of 256-bits and encapsulates it to the given public key using Kyber algorithms
@@ -15,8 +16,8 @@ declare function generateKyberKeys(seed?: Uint8Array): {
  * @returns The resulting encapsulation and the generated shared secret.
  */
 declare function encapsulateKyber(publicKey: Uint8Array): {
-    cipherText: Uint8Array;
-    sharedSecret: Uint8Array;
+  cipherText: Uint8Array;
+  sharedSecret: Uint8Array;
 };
 /**
  * Decapsulates the encapsulated shared secret using Kyber algorithms
@@ -26,5 +27,6 @@ declare function encapsulateKyber(publicKey: Uint8Array): {
  * @returns The resulting decapsulated shared secret.
  */
 declare function decapsulateKyber(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array;
-
-export { decapsulateKyber as d, encapsulateKyber as e, generateKyberKeys as g };
+//#endregion
+export { encapsulateKyber as n, generateKyberKeys as r, decapsulateKyber as t };
+//# sourceMappingURL=kyber768-DzIcGg1i.d.mts.map

package/dist/kyber768-DzIcGg1i.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kyber768-DzIcGg1i.d.mts","names":[],"sources":["../src/post-quantum-crypto/kyber768.ts"],"mappings":";;AAQA;;;;;iBAAgB,iBAAA,CAAkB,IAAA,GAAO,UAAA;EACvC,SAAA,EAAW,UAAA;EACX,SAAA,EAAW,UAAA;AAAA;;;;;;;iBAeG,gBAAA,CAAiB,SAAA,EAAW,UAAA;EAC1C,UAAA,EAAY,UAAA;EACZ,YAAA,EAAc,UAAA;AAAA;;;;;;;;iBAgBA,gBAAA,CAAiB,UAAA,EAAY,UAAA,EAAY,SAAA,EAAW,UAAA,GAAa,UAAA"}

package/dist/mac-BMb1F0dN.js

@@ -0,0 +1,170 @@
+const require_chunk = require('./chunk-EbLFQX5m.js');
+const require_constants = require('./constants.js');
+let _noble_hashes_blake3_js = require("@noble/hashes/blake3.js");
+let _noble_hashes_utils_js = require("@noble/hashes/utils.js");
+
+//#region src/hash/blake3.ts
+/**
+* Hashes the given array of data
+*
+* @param data - The data to hash
+* @returns The resulting hash array
+*/
+function hashDataArray(data) {
+	try {
+		const hasher = _noble_hashes_blake3_js.blake3.create();
+		for (const d of data) hasher.update(d);
+		return hasher.digest();
+	} catch (error) {
+		throw new Error("Failed to compute hash", { cause: error });
+	}
+}
+/**
+* Hashes the given array of data
+*
+* @param data - The data to hash
+* @returns The resulting hash hex string
+*/
+function hashDataArrayHex(data) {
+	return (0, _noble_hashes_utils_js.bytesToHex)(hashDataArray(data));
+}
+function hashDataArrayWithKeyHex(hashKey, data) {
+	try {
+		return (0, _noble_hashes_utils_js.bytesToHex)(hashDataArrayWithKey(hashKey, data));
+	} catch (error) {
+		throw new Error("Failed to compute hash hex", { cause: error });
+	}
+}
+function hashDataArrayWithKey(hashKey, data) {
+	try {
+		const hasher = _noble_hashes_blake3_js.blake3.create({ key: hashKey });
+		for (const d of data) hasher.update(d);
+		return hasher.digest();
+	} catch (error) {
+		throw new Error("Failed to compute hash", { cause: error });
+	}
+}
+/**
+* Hashes the given array of data using blake3 algorithm
+*
+* @param bytes - The desired output byte-length
+* @param data - The data to hash
+* @returns The resulting hash value
+*/
+function getBytesFromDataArray(bytes, data) {
+	try {
+		const hasher = _noble_hashes_blake3_js.blake3.create({ dkLen: bytes });
+		for (const chunk of data) hasher.update(chunk);
+		return hasher.digest();
+	} catch (error) {
+		throw new Error("Failed to get bytes from data", { cause: error });
+	}
+}
+/**
+* Hashes the given array of data using blake3 algorithm
+*
+* @param bytes - The desired output byte-length
+* @param data - The data to hash
+* @returns The resulting hash value
+*/
+function getBytesFromDataArrayHex(bytes, data) {
+	try {
+		return (0, _noble_hashes_utils_js.bytesToHex)(getBytesFromDataArray(bytes, data));
+	} catch (error) {
+		throw new Error("Failed to get bytes from data", { cause: error });
+	}
+}
+/**
+* Hashes the given string using blake3 algorithm
+*
+* @param bytes - The desired output byte-length
+* @param data - The data to hash
+* @returns The resulting hash value
+*/
+function getBytesFromData(bytes, data) {
+	return (0, _noble_hashes_blake3_js.blake3)(data, { dkLen: bytes });
+}
+/**
+* Hashes the given data using blake3 algorithm
+*
+* @param bytes - The desired output byte-length
+* @param data - The data to hash
+* @returns The resulting hash value
+*/
+function getBytesFromDataHex(bytes, data) {
+	return (0, _noble_hashes_utils_js.bytesToHex)(getBytesFromData(bytes, data));
+}
+
+//#endregion
+//#region src/hash/mac.ts
+/**
+* Computes mac for the given key material and data
+*
+* @param keyMaterial - The key material
+* @param data - The data to hash
+* @returns The resulting hash hex string
+*/
+function computeMac(keyMaterial, data) {
+	try {
+		return (0, _noble_hashes_utils_js.bytesToHex)(hashDataArrayWithKey(getBytesFromData(require_constants.AES_KEY_BIT_LENGTH / 8, keyMaterial), data));
+	} catch (error) {
+		throw new Error("Failed to compute mac", { cause: error });
+	}
+}
+
+//#endregion
+Object.defineProperty(exports, 'computeMac', {
+  enumerable: true,
+  get: function () {
+    return computeMac;
+  }
+});
+Object.defineProperty(exports, 'getBytesFromData', {
+  enumerable: true,
+  get: function () {
+    return getBytesFromData;
+  }
+});
+Object.defineProperty(exports, 'getBytesFromDataArray', {
+  enumerable: true,
+  get: function () {
+    return getBytesFromDataArray;
+  }
+});
+Object.defineProperty(exports, 'getBytesFromDataArrayHex', {
+  enumerable: true,
+  get: function () {
+    return getBytesFromDataArrayHex;
+  }
+});
+Object.defineProperty(exports, 'getBytesFromDataHex', {
+  enumerable: true,
+  get: function () {
+    return getBytesFromDataHex;
+  }
+});
+Object.defineProperty(exports, 'hashDataArray', {
+  enumerable: true,
+  get: function () {
+    return hashDataArray;
+  }
+});
+Object.defineProperty(exports, 'hashDataArrayHex', {
+  enumerable: true,
+  get: function () {
+    return hashDataArrayHex;
+  }
+});
+Object.defineProperty(exports, 'hashDataArrayWithKey', {
+  enumerable: true,
+  get: function () {
+    return hashDataArrayWithKey;
+  }
+});
+Object.defineProperty(exports, 'hashDataArrayWithKeyHex', {
+  enumerable: true,
+  get: function () {
+    return hashDataArrayWithKeyHex;
+  }
+});
+//# sourceMappingURL=mac-BMb1F0dN.js.map

package/dist/mac-BMb1F0dN.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mac-BMb1F0dN.js","names":["blake3","AES_KEY_BIT_LENGTH"],"sources":["../src/hash/blake3.ts","../src/hash/mac.ts"],"sourcesContent":["import { blake3 } from '@noble/hashes/blake3.js';\nimport { bytesToHex } from '@noble/hashes/utils.js';\n\n/**\n * Hashes the given array of data\n *\n * @param data - The data to hash\n * @returns The resulting hash array\n */\nexport function hashDataArray(data: Uint8Array[]): Uint8Array {\n  try {\n    const hasher = blake3.create();\n    for (const d of data) {\n      hasher.update(d);\n    }\n    return hasher.digest();\n  } catch (error) {\n    throw new Error('Failed to compute hash', { cause: error });\n  }\n}\n\n/**\n * Hashes the given array of data\n *\n * @param data - The data to hash\n * @returns The resulting hash hex string\n */\nexport function hashDataArrayHex(data: Uint8Array[]): string {\n  return bytesToHex(hashDataArray(data));\n}\n\nexport function hashDataArrayWithKeyHex(hashKey: Uint8Array, data: Uint8Array[]): string {\n  try {\n    const hash = hashDataArrayWithKey(hashKey, data);\n    return bytesToHex(hash);\n  } catch (error) {\n    throw new Error('Failed to compute hash hex', { cause: error });\n  }\n}\n\nexport function hashDataArrayWithKey(hashKey: Uint8Array, data: Uint8Array[]): Uint8Array {\n  try {\n    const hasher = blake3.create({ key: hashKey });\n    for (const d of data) {\n      hasher.update(d);\n    }\n    return hasher.digest();\n  } catch (error) {\n    throw new Error('Failed to compute hash', { cause: error });\n  }\n}\n\n/**\n * Hashes the given array of data using blake3 algorithm\n *\n * @param bytes - The desired output byte-length\n * @param data - The data to hash\n * @returns The resulting hash value\n */\nexport function getBytesFromDataArray(bytes: number, data: Uint8Array[]): Uint8Array {\n  try {\n    const hasher = blake3.create({ dkLen: bytes });\n    for (const chunk of data) {\n      hasher.update(chunk);\n    }\n    return hasher.digest();\n  } catch (error) {\n    throw new Error('Failed to get bytes from data', { cause: error });\n  }\n}\n\n/**\n * Hashes the given array of data using blake3 algorithm\n *\n * @param bytes - The desired output byte-length\n * @param data - The data to hash\n * @returns The resulting hash value\n */\nexport function getBytesFromDataArrayHex(bytes: number, data: Uint8Array[]): string {\n  try {\n    const hash = getBytesFromDataArray(bytes, data);\n    return bytesToHex(hash);\n  } catch (error) {\n    throw new Error('Failed to get bytes from data', { cause: error });\n  }\n}\n\n/**\n * Hashes the given string using blake3 algorithm\n *\n * @param bytes - The desired output byte-length\n * @param data - The data to hash\n * @returns The resulting hash value\n */\nexport function getBytesFromData(bytes: number, data: Uint8Array): Uint8Array {\n  return blake3(data, { dkLen: bytes });\n}\n\n/**\n * Hashes the given data using blake3 algorithm\n *\n * @param bytes - The desired output byte-length\n * @param data - The data to hash\n * @returns The resulting hash value\n */\nexport function getBytesFromDataHex(bytes: number, data: Uint8Array): string {\n  return bytesToHex(getBytesFromData(bytes, data));\n}\n","import { bytesToHex } from '@noble/hashes/utils.js';\nimport { AES_KEY_BIT_LENGTH } from '../constants';\nimport { getBytesFromData, hashDataArrayWithKey } from './blake3';\n\n/**\n * Computes mac for the given key material and data\n *\n * @param keyMaterial - The key material\n * @param data - The data to hash\n * @returns The resulting hash hex string\n */\nexport function computeMac(keyMaterial: Uint8Array, data: Uint8Array[]): string {\n  try {\n    const key = getBytesFromData(AES_KEY_BIT_LENGTH / 8, keyMaterial);\n    const hash = hashDataArrayWithKey(key, data);\n    return bytesToHex(hash);\n  } catch (error) {\n    throw new Error('Failed to compute mac', { cause: error });\n  }\n}\n"],"mappings":";;;;;;;;;;;;AASA,SAAgB,cAAc,MAAgC;AAC5D,KAAI;EACF,MAAM,SAASA,+BAAO,QAAQ;AAC9B,OAAK,MAAM,KAAK,KACd,QAAO,OAAO,EAAE;AAElB,SAAO,OAAO,QAAQ;UACf,OAAO;AACd,QAAM,IAAI,MAAM,0BAA0B,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAU/D,SAAgB,iBAAiB,MAA4B;AAC3D,+CAAkB,cAAc,KAAK,CAAC;;AAGxC,SAAgB,wBAAwB,SAAqB,MAA4B;AACvF,KAAI;AAEF,gDADa,qBAAqB,SAAS,KAAK,CACzB;UAChB,OAAO;AACd,QAAM,IAAI,MAAM,8BAA8B,EAAE,OAAO,OAAO,CAAC;;;AAInE,SAAgB,qBAAqB,SAAqB,MAAgC;AACxF,KAAI;EACF,MAAM,SAASA,+BAAO,OAAO,EAAE,KAAK,SAAS,CAAC;AAC9C,OAAK,MAAM,KAAK,KACd,QAAO,OAAO,EAAE;AAElB,SAAO,OAAO,QAAQ;UACf,OAAO;AACd,QAAM,IAAI,MAAM,0BAA0B,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW/D,SAAgB,sBAAsB,OAAe,MAAgC;AACnF,KAAI;EACF,MAAM,SAASA,+BAAO,OAAO,EAAE,OAAO,OAAO,CAAC;AAC9C,OAAK,MAAM,SAAS,KAClB,QAAO,OAAO,MAAM;AAEtB,SAAO,OAAO,QAAQ;UACf,OAAO;AACd,QAAM,IAAI,MAAM,iCAAiC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAWtE,SAAgB,yBAAyB,OAAe,MAA4B;AAClF,KAAI;AAEF,gDADa,sBAAsB,OAAO,KAAK,CACxB;UAChB,OAAO;AACd,QAAM,IAAI,MAAM,iCAAiC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAWtE,SAAgB,iBAAiB,OAAe,MAA8B;AAC5E,4CAAc,MAAM,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAUvC,SAAgB,oBAAoB,OAAe,MAA0B;AAC3E,+CAAkB,iBAAiB,OAAO,KAAK,CAAC;;;;;;;;;;;;AC/FlD,SAAgB,WAAW,aAAyB,MAA4B;AAC9E,KAAI;AAGF,gDADa,qBADD,iBAAiBC,uCAAqB,GAAG,YAAY,EAC1B,KAAK,CACrB;UAChB,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC"}

package/dist/mac-ZpRlx8Fs.mjs

@@ -0,0 +1,116 @@
+import { AES_KEY_BIT_LENGTH } from "./constants.mjs";
+import { blake3 } from "@noble/hashes/blake3.js";
+import { bytesToHex } from "@noble/hashes/utils.js";
+
+//#region src/hash/blake3.ts
+/**
+* Hashes the given array of data
+*
+* @param data - The data to hash
+* @returns The resulting hash array
+*/
+function hashDataArray(data) {
+	try {
+		const hasher = blake3.create();
+		for (const d of data) hasher.update(d);
+		return hasher.digest();
+	} catch (error) {
+		throw new Error("Failed to compute hash", { cause: error });
+	}
+}
+/**
+* Hashes the given array of data
+*
+* @param data - The data to hash
+* @returns The resulting hash hex string
+*/
+function hashDataArrayHex(data) {
+	return bytesToHex(hashDataArray(data));
+}
+function hashDataArrayWithKeyHex(hashKey, data) {
+	try {
+		return bytesToHex(hashDataArrayWithKey(hashKey, data));
+	} catch (error) {
+		throw new Error("Failed to compute hash hex", { cause: error });
+	}
+}
+function hashDataArrayWithKey(hashKey, data) {
+	try {
+		const hasher = blake3.create({ key: hashKey });
+		for (const d of data) hasher.update(d);
+		return hasher.digest();
+	} catch (error) {
+		throw new Error("Failed to compute hash", { cause: error });
+	}
+}
+/**
+* Hashes the given array of data using blake3 algorithm
+*
+* @param bytes - The desired output byte-length
+* @param data - The data to hash
+* @returns The resulting hash value
+*/
+function getBytesFromDataArray(bytes, data) {
+	try {
+		const hasher = blake3.create({ dkLen: bytes });
+		for (const chunk of data) hasher.update(chunk);
+		return hasher.digest();
+	} catch (error) {
+		throw new Error("Failed to get bytes from data", { cause: error });
+	}
+}
+/**
+* Hashes the given array of data using blake3 algorithm
+*
+* @param bytes - The desired output byte-length
+* @param data - The data to hash
+* @returns The resulting hash value
+*/
+function getBytesFromDataArrayHex(bytes, data) {
+	try {
+		return bytesToHex(getBytesFromDataArray(bytes, data));
+	} catch (error) {
+		throw new Error("Failed to get bytes from data", { cause: error });
+	}
+}
+/**
+* Hashes the given string using blake3 algorithm
+*
+* @param bytes - The desired output byte-length
+* @param data - The data to hash
+* @returns The resulting hash value
+*/
+function getBytesFromData(bytes, data) {
+	return blake3(data, { dkLen: bytes });
+}
+/**
+* Hashes the given data using blake3 algorithm
+*
+* @param bytes - The desired output byte-length
+* @param data - The data to hash
+* @returns The resulting hash value
+*/
+function getBytesFromDataHex(bytes, data) {
+	return bytesToHex(getBytesFromData(bytes, data));
+}
+
+//#endregion
+//#region src/hash/mac.ts
+/**
+* Computes mac for the given key material and data
+*
+* @param keyMaterial - The key material
+* @param data - The data to hash
+* @returns The resulting hash hex string
+*/
+function computeMac(keyMaterial, data) {
+	try {
+		return bytesToHex(hashDataArrayWithKey(getBytesFromData(AES_KEY_BIT_LENGTH / 8, keyMaterial), data));
+	} catch (error) {
+		throw new Error("Failed to compute mac", { cause: error });
+	}
+}
+
+//#endregion
+export { getBytesFromDataHex as a, hashDataArrayWithKey as c, getBytesFromDataArrayHex as i, hashDataArrayWithKeyHex as l, getBytesFromData as n, hashDataArray as o, getBytesFromDataArray as r, hashDataArrayHex as s, computeMac as t };
+//# sourceMappingURL=mac-ZpRlx8Fs.mjs.map

package/dist/mac-ZpRlx8Fs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mac-ZpRlx8Fs.mjs","names":[],"sources":["../src/hash/blake3.ts","../src/hash/mac.ts"],"sourcesContent":["import { blake3 } from '@noble/hashes/blake3.js';\nimport { bytesToHex } from '@noble/hashes/utils.js';\n\n/**\n * Hashes the given array of data\n *\n * @param data - The data to hash\n * @returns The resulting hash array\n */\nexport function hashDataArray(data: Uint8Array[]): Uint8Array {\n  try {\n    const hasher = blake3.create();\n    for (const d of data) {\n      hasher.update(d);\n    }\n    return hasher.digest();\n  } catch (error) {\n    throw new Error('Failed to compute hash', { cause: error });\n  }\n}\n\n/**\n * Hashes the given array of data\n *\n * @param data - The data to hash\n * @returns The resulting hash hex string\n */\nexport function hashDataArrayHex(data: Uint8Array[]): string {\n  return bytesToHex(hashDataArray(data));\n}\n\nexport function hashDataArrayWithKeyHex(hashKey: Uint8Array, data: Uint8Array[]): string {\n  try {\n    const hash = hashDataArrayWithKey(hashKey, data);\n    return bytesToHex(hash);\n  } catch (error) {\n    throw new Error('Failed to compute hash hex', { cause: error });\n  }\n}\n\nexport function hashDataArrayWithKey(hashKey: Uint8Array, data: Uint8Array[]): Uint8Array {\n  try {\n    const hasher = blake3.create({ key: hashKey });\n    for (const d of data) {\n      hasher.update(d);\n    }\n    return hasher.digest();\n  } catch (error) {\n    throw new Error('Failed to compute hash', { cause: error });\n  }\n}\n\n/**\n * Hashes the given array of data using blake3 algorithm\n *\n * @param bytes - The desired output byte-length\n * @param data - The data to hash\n * @returns The resulting hash value\n */\nexport function getBytesFromDataArray(bytes: number, data: Uint8Array[]): Uint8Array {\n  try {\n    const hasher = blake3.create({ dkLen: bytes });\n    for (const chunk of data) {\n      hasher.update(chunk);\n    }\n    return hasher.digest();\n  } catch (error) {\n    throw new Error('Failed to get bytes from data', { cause: error });\n  }\n}\n\n/**\n * Hashes the given array of data using blake3 algorithm\n *\n * @param bytes - The desired output byte-length\n * @param data - The data to hash\n * @returns The resulting hash value\n */\nexport function getBytesFromDataArrayHex(bytes: number, data: Uint8Array[]): string {\n  try {\n    const hash = getBytesFromDataArray(bytes, data);\n    return bytesToHex(hash);\n  } catch (error) {\n    throw new Error('Failed to get bytes from data', { cause: error });\n  }\n}\n\n/**\n * Hashes the given string using blake3 algorithm\n *\n * @param bytes - The desired output byte-length\n * @param data - The data to hash\n * @returns The resulting hash value\n */\nexport function getBytesFromData(bytes: number, data: Uint8Array): Uint8Array {\n  return blake3(data, { dkLen: bytes });\n}\n\n/**\n * Hashes the given data using blake3 algorithm\n *\n * @param bytes - The desired output byte-length\n * @param data - The data to hash\n * @returns The resulting hash value\n */\nexport function getBytesFromDataHex(bytes: number, data: Uint8Array): string {\n  return bytesToHex(getBytesFromData(bytes, data));\n}\n","import { bytesToHex } from '@noble/hashes/utils.js';\nimport { AES_KEY_BIT_LENGTH } from '../constants';\nimport { getBytesFromData, hashDataArrayWithKey } from './blake3';\n\n/**\n * Computes mac for the given key material and data\n *\n * @param keyMaterial - The key material\n * @param data - The data to hash\n * @returns The resulting hash hex string\n */\nexport function computeMac(keyMaterial: Uint8Array, data: Uint8Array[]): string {\n  try {\n    const key = getBytesFromData(AES_KEY_BIT_LENGTH / 8, keyMaterial);\n    const hash = hashDataArrayWithKey(key, data);\n    return bytesToHex(hash);\n  } catch (error) {\n    throw new Error('Failed to compute mac', { cause: error });\n  }\n}\n"],"mappings":";;;;;;;;;;;AASA,SAAgB,cAAc,MAAgC;AAC5D,KAAI;EACF,MAAM,SAAS,OAAO,QAAQ;AAC9B,OAAK,MAAM,KAAK,KACd,QAAO,OAAO,EAAE;AAElB,SAAO,OAAO,QAAQ;UACf,OAAO;AACd,QAAM,IAAI,MAAM,0BAA0B,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAU/D,SAAgB,iBAAiB,MAA4B;AAC3D,QAAO,WAAW,cAAc,KAAK,CAAC;;AAGxC,SAAgB,wBAAwB,SAAqB,MAA4B;AACvF,KAAI;AAEF,SAAO,WADM,qBAAqB,SAAS,KAAK,CACzB;UAChB,OAAO;AACd,QAAM,IAAI,MAAM,8BAA8B,EAAE,OAAO,OAAO,CAAC;;;AAInE,SAAgB,qBAAqB,SAAqB,MAAgC;AACxF,KAAI;EACF,MAAM,SAAS,OAAO,OAAO,EAAE,KAAK,SAAS,CAAC;AAC9C,OAAK,MAAM,KAAK,KACd,QAAO,OAAO,EAAE;AAElB,SAAO,OAAO,QAAQ;UACf,OAAO;AACd,QAAM,IAAI,MAAM,0BAA0B,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW/D,SAAgB,sBAAsB,OAAe,MAAgC;AACnF,KAAI;EACF,MAAM,SAAS,OAAO,OAAO,EAAE,OAAO,OAAO,CAAC;AAC9C,OAAK,MAAM,SAAS,KAClB,QAAO,OAAO,MAAM;AAEtB,SAAO,OAAO,QAAQ;UACf,OAAO;AACd,QAAM,IAAI,MAAM,iCAAiC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAWtE,SAAgB,yBAAyB,OAAe,MAA4B;AAClF,KAAI;AAEF,SAAO,WADM,sBAAsB,OAAO,KAAK,CACxB;UAChB,OAAO;AACd,QAAM,IAAI,MAAM,iCAAiC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAWtE,SAAgB,iBAAiB,OAAe,MAA8B;AAC5E,QAAO,OAAO,MAAM,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAUvC,SAAgB,oBAAoB,OAAe,MAA0B;AAC3E,QAAO,WAAW,iBAAiB,OAAO,KAAK,CAAC;;;;;;;;;;;;AC/FlD,SAAgB,WAAW,aAAyB,MAA4B;AAC9E,KAAI;AAGF,SAAO,WADM,qBADD,iBAAiB,qBAAqB,GAAG,YAAY,EAC1B,KAAK,CACrB;UAChB,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC"}

package/dist/post-quantum-crypto.d.mts

@@ -1,14 +1,18 @@
-export { d as decapsulateKyber, e as encapsulateKyber, g as generateKyberKeys } from './kyber768-B87rMQ7u.mjs';
+import { n as encapsulateKyber, r as generateKyberKeys, t as decapsulateKyber } from "./kyber768-DzIcGg1i.mjs";
 
+//#region src/post-quantum-crypto/kyber512.d.ts
+declare namespace kyber512_d_exports {
+  export { decapsulateKyber$2 as decapsulateKyber, encapsulateKyber$2 as encapsulateKyber, generateKyberKeys$2 as generateKyberKeys };
+}
 /**
  * Generates public and secret Kyber keys
  *
  * @param seed - The optional seed
  * @returns The generated Kyber key pair.
  */
-declare function generateKyberKeys$1(seed?: Uint8Array): {
-    publicKey: Uint8Array;
-    secretKey: Uint8Array;
+declare function generateKyberKeys$2(seed?: Uint8Array): {
+  publicKey: Uint8Array;
+  secretKey: Uint8Array;
 };
 /**
  * Generates a shared secret of 256-bits and encapsulates it to the given public key using Kyber algorithms
@@ -16,9 +20,9 @@ declare function generateKyberKeys$1(seed?: Uint8Array): {
  * @param publicKey - The public Kyber key
  * @returns The resulting encapsulation and the generated shared secret.
  */
-declare function encapsulateKyber$1(publicKey: Uint8Array): {
-    cipherText: Uint8Array;
-    sharedSecret: Uint8Array;
+declare function encapsulateKyber$2(publicKey: Uint8Array): {
+  cipherText: Uint8Array;
+  sharedSecret: Uint8Array;
 };
 /**
  * Decapsulates the encapsulated shared secret using Kyber algorithms
@@ -27,21 +31,19 @@ declare function encapsulateKyber$1(publicKey: Uint8Array): {
  * @param secretKey - The private Kyber key
  * @returns The resulting decapsulated shared secret.
  */
-declare function decapsulateKyber$1(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array;
-
-declare namespace kyber512 {
+declare function decapsulateKyber$2(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array;
+declare namespace kyber1024_d_exports {
   export { decapsulateKyber$1 as decapsulateKyber, encapsulateKyber$1 as encapsulateKyber, generateKyberKeys$1 as generateKyberKeys };
 }
-
 /**
  * Generates public and secret Kyber keys
  *
  * @param seed - The optional seed
  * @returns The generated Kyber key pair.
  */
-declare function generateKyberKeys(seed?: Uint8Array): {
-    publicKey: Uint8Array;
-    secretKey: Uint8Array;
+declare function generateKyberKeys$1(seed?: Uint8Array): {
+  publicKey: Uint8Array;
+  secretKey: Uint8Array;
 };
 /**
  * Generates a shared secret of 256-bits and encapsulates it to the given public key using Kyber algorithms
@@ -49,9 +51,9 @@ declare function generateKyberKeys(seed?: Uint8Array): {
  * @param publicKey - The public Kyber key
  * @returns The resulting encapsulation and the generated shared secret.
  */
-declare function encapsulateKyber(publicKey: Uint8Array): {
-    cipherText: Uint8Array;
-    sharedSecret: Uint8Array;
+declare function encapsulateKyber$1(publicKey: Uint8Array): {
+  cipherText: Uint8Array;
+  sharedSecret: Uint8Array;
 };
 /**
  * Decapsulates the encapsulated shared secret using Kyber algorithms
@@ -60,13 +62,7 @@ declare function encapsulateKyber(publicKey: Uint8Array): {
  * @param secretKey - The private Kyber key
  * @returns The resulting decapsulated shared secret.
  */
-declare function decapsulateKyber(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array;
-
-declare const kyber1024_decapsulateKyber: typeof decapsulateKyber;
-declare const kyber1024_encapsulateKyber: typeof encapsulateKyber;
-declare const kyber1024_generateKyberKeys: typeof generateKyberKeys;
-declare namespace kyber1024 {
-  export { kyber1024_decapsulateKyber as decapsulateKyber, kyber1024_encapsulateKyber as encapsulateKyber, kyber1024_generateKyberKeys as generateKyberKeys };
-}
-
-export { kyber1024, kyber512 };
+declare function decapsulateKyber$1(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array;
+//#endregion
+export { decapsulateKyber, encapsulateKyber, generateKyberKeys, kyber1024_d_exports as kyber1024, kyber512_d_exports as kyber512 };
+//# sourceMappingURL=post-quantum-crypto.d.mts.map

package/dist/post-quantum-crypto.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"post-quantum-crypto.d.mts","names":[],"sources":["../src/post-quantum-crypto/kyber512.ts","../src/post-quantum-crypto/kyber1024.ts"],"mappings":";;;;;;;;;;;;iBAQgB,mBAAA,CAAkB,IAAA,GAAO,UAAA;EACvC,SAAA,EAAW,UAAA;EACX,SAAA,EAAW,UAAA;AAAA;;;;;;;iBAeG,kBAAA,CAAiB,SAAA,EAAW,UAAA;EAC1C,UAAA,EAAY,UAAA;EACZ,YAAA,EAAc,UAAA;AAAA;;;;;;AAFhB;;iBAkBgB,kBAAA,CAAiB,UAAA,EAAY,UAAA,EAAY,SAAA,EAAW,UAAA,GAAa,UAAA;AAAA;;;;;;;;;iBCnCjE,mBAAA,CAAkB,IAAA,GAAO,UAAA;EACvC,SAAA,EAAW,UAAA;EACX,SAAA,EAAW,UAAA;AAAA;;;;;;;iBAeG,kBAAA,CAAiB,SAAA,EAAW,UAAA;EAC1C,UAAA,EAAY,UAAA;EACZ,YAAA,EAAc,UAAA;AAAA;;;;;;ADFhB;;iBCkBgB,kBAAA,CAAiB,UAAA,EAAY,UAAA,EAAY,SAAA,EAAW,UAAA,GAAa,UAAA"}