internxt-crypto 0.0.13 → 1.0.0

package/dist/derive-key.d.mts

@@ -8,15 +8,6 @@
  * @returns The derived secret key
  */
 declare function deriveSymmetricKeyFromContext(context: string, baseKey: Uint8Array): Uint8Array;
-/**
- * Derives a symmetric CryptoKey from the base key and context string
- *
- * @param context - The context string.
- * The context string should be hardcoded, globally unique, and application-specific.
- * @param baseKey - The base key (NOT PASSWORD!)
- * @returns The derived secret CryptoKey
- */
-declare function deriveSymmetricCryptoKeyFromContext(context: string, baseKey: Uint8Array): Promise<CryptoKey>;
 /**
  * Derives a symmetric key from two keys
  *
@@ -25,70 +16,6 @@ declare function deriveSymmetricCryptoKeyFromContext(context: string, baseKey: U
  * @returns The derived secret key
  */
 declare function deriveSymmetricKeyFromTwoKeys(key1: Uint8Array, key2: Uint8Array): Uint8Array;
-/**
- * Derives a symmetric CryptoKey from two keys
- *
- * @param key1 - The 32-bytes key
- * @param key2 - The 32-bytes key
- * @returns The derived secret CryptoKey
- */
-declare function deriveSymmetricCryptoKeyFromTwoKeys(key1: Uint8Array, key2: Uint8Array): Promise<CryptoKey>;
-/**
- * Derives a symmetric key from two keys and context
- *
- * @param key1 - The 32-bytes key
- * @param key2 - The 32-bytes key
- * @param context - The context string
- * @returns The derived symmetric key
- */
-declare function deriveSymmetricKeyFromTwoKeysAndContext(key1: Uint8Array, key2: Uint8Array, context: string): Uint8Array;
-//#endregion
-//#region src/derive-key/deriveKeysFromPassword.d.ts
-/**
- * Derives a symmetric key from a user's password with a randomly sampled salt
- *
- * @param password - The user's password
- * @returns The derived secret key and randomly sampled salt
- */
-declare function getKeyFromPassword(password: string): Promise<{
-  key: Uint8Array;
-  salt: Uint8Array;
-}>;
-/**
- * Derives a symmetric key from a user's password and salt
- *
- * @param password - The user's password
- * @param salt - The given salt
- * @returns The derived secret key
- */
-declare function getKeyFromPasswordAndSalt(password: string, salt: Uint8Array): Promise<Uint8Array>;
-/**
- * Derives a HEX symmetric key from a user's password with a randomly sampled salt
- *
- * @param password - The user's password
- * @returns The derived HEX secret key and randomly sampled HEX salt
- */
-declare function getKeyFromPasswordHex(password: string): Promise<{
-  keyHex: string;
-  saltHex: string;
-}>;
-/**
- * Derives a HEX symmetric key from a user's password and salt
- *
- * @param password - The user's password
- * @param saltHex - The given HEX salt
- * @returns The derived HEX secret key
- */
-declare function getKeyFromPasswordAndSaltHex(password: string, saltHex: string): Promise<string>;
-/**
- * Verifies the derived key
- *
- * @param password - The user's password
- * @param saltHex - The given HEX salt
- * @param keyHex - The derived HEX key
- * @returns The result of the key verification
- */
-declare function verifyKeyFromPasswordHex(password: string, saltHex: string, keyHex: string): Promise<boolean>;
 //#endregion
-export { deriveSymmetricCryptoKeyFromContext, deriveSymmetricCryptoKeyFromTwoKeys, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, deriveSymmetricKeyFromTwoKeysAndContext, getKeyFromPassword, getKeyFromPasswordAndSalt, getKeyFromPasswordAndSaltHex, getKeyFromPasswordHex, verifyKeyFromPasswordHex };
+export { deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys };
 //# sourceMappingURL=derive-key.d.mts.map

package/dist/derive-key.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"derive-key.d.mts","names":[],"sources":["../src/derive-key/deriveKeysFromKey.ts","../src/derive-key/deriveKeysFromPassword.ts"],"mappings":";;AAaA;;;;;;;iBAAgB,6BAAA,CAA8B,OAAA,UAAiB,OAAA,EAAS,UAAA,GAAa,UAAA;;;AAYrF;;;;;;iBAAsB,mCAAA,CAAoC,OAAA,UAAiB,OAAA,EAAS,UAAA,GAAa,OAAA,CAAQ,SAAA;;;;;;;;iBAwBzF,6BAAA,CAA8B,IAAA,EAAM,UAAA,EAAY,IAAA,EAAM,UAAA,GAAa,UAAA;AAAnF;;;;;;;AAAA,iBAWsB,mCAAA,CAAoC,IAAA,EAAM,UAAA,EAAY,IAAA,EAAM,UAAA,GAAa,OAAA,CAAQ,SAAA;;;;;;;;AAAvG;iBAkBgB,uCAAA,CACd,IAAA,EAAM,UAAA,EACN,IAAA,EAAM,UAAA,EACN,OAAA,WACC,UAAA;;;;AArEH;;;;;iBCJsB,kBAAA,CAAmB,QAAA,WAAmB,OAAA;EAAU,GAAA,EAAK,UAAA;EAAY,IAAA,EAAM,UAAA;AAAA;;ADgB7F;;;;;;iBCIsB,yBAAA,CAA0B,QAAA,UAAkB,IAAA,EAAM,UAAA,GAAa,OAAA,CAAQ,UAAA;;;;;;;iBAoBvE,qBAAA,CAAsB,QAAA,WAAmB,OAAA;EAAU,MAAA;EAAgB,OAAA;AAAA;;;;;;;;iBAgBnE,4BAAA,CAA6B,QAAA,UAAkB,OAAA,WAAkB,OAAA;;;;;;ADLvF;;;iBCuBsB,wBAAA,CAAyB,QAAA,UAAkB,OAAA,UAAiB,MAAA,WAAiB,OAAA"}
+{"version":3,"file":"derive-key.d.mts","names":[],"sources":["../src/derive-key/deriveKeysFromKey.ts"],"mappings":";;AAYA;;;;;;;iBAAgB,6BAAA,CAA8B,OAAA,UAAiB,OAAA,EAAS,UAAA,GAAa,UAAA;;;AAWrF;;;;;iBAAgB,6BAAA,CAA8B,IAAA,EAAM,UAAA,EAAY,IAAA,EAAM,UAAA,GAAa,UAAA"}

package/dist/derive-key.d.ts

@@ -8,15 +8,6 @@
  * @returns The derived secret key
  */
 declare function deriveSymmetricKeyFromContext(context: string, baseKey: Uint8Array): Uint8Array;
-/**
- * Derives a symmetric CryptoKey from the base key and context string
- *
- * @param context - The context string.
- * The context string should be hardcoded, globally unique, and application-specific.
- * @param baseKey - The base key (NOT PASSWORD!)
- * @returns The derived secret CryptoKey
- */
-declare function deriveSymmetricCryptoKeyFromContext(context: string, baseKey: Uint8Array): Promise<CryptoKey>;
 /**
  * Derives a symmetric key from two keys
  *
@@ -25,70 +16,6 @@ declare function deriveSymmetricCryptoKeyFromContext(context: string, baseKey: U
  * @returns The derived secret key
  */
 declare function deriveSymmetricKeyFromTwoKeys(key1: Uint8Array, key2: Uint8Array): Uint8Array;
-/**
- * Derives a symmetric CryptoKey from two keys
- *
- * @param key1 - The 32-bytes key
- * @param key2 - The 32-bytes key
- * @returns The derived secret CryptoKey
- */
-declare function deriveSymmetricCryptoKeyFromTwoKeys(key1: Uint8Array, key2: Uint8Array): Promise<CryptoKey>;
-/**
- * Derives a symmetric key from two keys and context
- *
- * @param key1 - The 32-bytes key
- * @param key2 - The 32-bytes key
- * @param context - The context string
- * @returns The derived symmetric key
- */
-declare function deriveSymmetricKeyFromTwoKeysAndContext(key1: Uint8Array, key2: Uint8Array, context: string): Uint8Array;
-//#endregion
-//#region src/derive-key/deriveKeysFromPassword.d.ts
-/**
- * Derives a symmetric key from a user's password with a randomly sampled salt
- *
- * @param password - The user's password
- * @returns The derived secret key and randomly sampled salt
- */
-declare function getKeyFromPassword(password: string): Promise<{
-  key: Uint8Array;
-  salt: Uint8Array;
-}>;
-/**
- * Derives a symmetric key from a user's password and salt
- *
- * @param password - The user's password
- * @param salt - The given salt
- * @returns The derived secret key
- */
-declare function getKeyFromPasswordAndSalt(password: string, salt: Uint8Array): Promise<Uint8Array>;
-/**
- * Derives a HEX symmetric key from a user's password with a randomly sampled salt
- *
- * @param password - The user's password
- * @returns The derived HEX secret key and randomly sampled HEX salt
- */
-declare function getKeyFromPasswordHex(password: string): Promise<{
-  keyHex: string;
-  saltHex: string;
-}>;
-/**
- * Derives a HEX symmetric key from a user's password and salt
- *
- * @param password - The user's password
- * @param saltHex - The given HEX salt
- * @returns The derived HEX secret key
- */
-declare function getKeyFromPasswordAndSaltHex(password: string, saltHex: string): Promise<string>;
-/**
- * Verifies the derived key
- *
- * @param password - The user's password
- * @param saltHex - The given HEX salt
- * @param keyHex - The derived HEX key
- * @returns The result of the key verification
- */
-declare function verifyKeyFromPasswordHex(password: string, saltHex: string, keyHex: string): Promise<boolean>;
 //#endregion
-export { deriveSymmetricCryptoKeyFromContext, deriveSymmetricCryptoKeyFromTwoKeys, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, deriveSymmetricKeyFromTwoKeysAndContext, getKeyFromPassword, getKeyFromPasswordAndSalt, getKeyFromPasswordAndSaltHex, getKeyFromPasswordHex, verifyKeyFromPasswordHex };
+export { deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys };
 //# sourceMappingURL=derive-key.d.ts.map

package/dist/derive-key.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"derive-key.d.ts","names":[],"sources":["../src/derive-key/deriveKeysFromKey.ts","../src/derive-key/deriveKeysFromPassword.ts"],"mappings":";;AAaA;;;;;;;iBAAgB,6BAAA,CAA8B,OAAA,UAAiB,OAAA,EAAS,UAAA,GAAa,UAAA;;;AAYrF;;;;;;iBAAsB,mCAAA,CAAoC,OAAA,UAAiB,OAAA,EAAS,UAAA,GAAa,OAAA,CAAQ,SAAA;;;;;;;;iBAwBzF,6BAAA,CAA8B,IAAA,EAAM,UAAA,EAAY,IAAA,EAAM,UAAA,GAAa,UAAA;AAAnF;;;;;;;AAAA,iBAWsB,mCAAA,CAAoC,IAAA,EAAM,UAAA,EAAY,IAAA,EAAM,UAAA,GAAa,OAAA,CAAQ,SAAA;;;;;;;;AAAvG;iBAkBgB,uCAAA,CACd,IAAA,EAAM,UAAA,EACN,IAAA,EAAM,UAAA,EACN,OAAA,WACC,UAAA;;;;AArEH;;;;;iBCJsB,kBAAA,CAAmB,QAAA,WAAmB,OAAA;EAAU,GAAA,EAAK,UAAA;EAAY,IAAA,EAAM,UAAA;AAAA;;ADgB7F;;;;;;iBCIsB,yBAAA,CAA0B,QAAA,UAAkB,IAAA,EAAM,UAAA,GAAa,OAAA,CAAQ,UAAA;;;;;;;iBAoBvE,qBAAA,CAAsB,QAAA,WAAmB,OAAA;EAAU,MAAA;EAAgB,OAAA;AAAA;;;;;;;;iBAgBnE,4BAAA,CAA6B,QAAA,UAAkB,OAAA,WAAkB,OAAA;;;;;;ADLvF;;;iBCuBsB,wBAAA,CAAyB,QAAA,UAAkB,OAAA,UAAiB,MAAA,WAAiB,OAAA"}
+{"version":3,"file":"derive-key.d.ts","names":[],"sources":["../src/derive-key/deriveKeysFromKey.ts"],"mappings":";;AAYA;;;;;;;iBAAgB,6BAAA,CAA8B,OAAA,UAAiB,OAAA,EAAS,UAAA,GAAa,UAAA;;;AAWrF;;;;;iBAAgB,6BAAA,CAA8B,IAAA,EAAM,UAAA,EAAY,IAAA,EAAM,UAAA,GAAa,UAAA"}

package/dist/derive-key.js

@@ -1,13 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_deriveKeysFromPassword = require('./deriveKeysFromPassword-Ko7NxkHM.js');
+const require_deriveKeysFromKey = require('./deriveKeysFromKey-C4McqO6_.js');
 
-exports.deriveSymmetricCryptoKeyFromContext = require_deriveKeysFromPassword.deriveSymmetricCryptoKeyFromContext;
-exports.deriveSymmetricCryptoKeyFromTwoKeys = require_deriveKeysFromPassword.deriveSymmetricCryptoKeyFromTwoKeys;
-exports.deriveSymmetricKeyFromContext = require_deriveKeysFromPassword.deriveSymmetricKeyFromContext;
-exports.deriveSymmetricKeyFromTwoKeys = require_deriveKeysFromPassword.deriveSymmetricKeyFromTwoKeys;
-exports.deriveSymmetricKeyFromTwoKeysAndContext = require_deriveKeysFromPassword.deriveSymmetricKeyFromTwoKeysAndContext;
-exports.getKeyFromPassword = require_deriveKeysFromPassword.getKeyFromPassword;
-exports.getKeyFromPasswordAndSalt = require_deriveKeysFromPassword.getKeyFromPasswordAndSalt;
-exports.getKeyFromPasswordAndSaltHex = require_deriveKeysFromPassword.getKeyFromPasswordAndSaltHex;
-exports.getKeyFromPasswordHex = require_deriveKeysFromPassword.getKeyFromPasswordHex;
-exports.verifyKeyFromPasswordHex = require_deriveKeysFromPassword.verifyKeyFromPasswordHex;
+exports.deriveSymmetricKeyFromContext = require_deriveKeysFromKey.deriveSymmetricKeyFromContext;
+exports.deriveSymmetricKeyFromTwoKeys = require_deriveKeysFromKey.deriveSymmetricKeyFromTwoKeys;

package/dist/derive-key.mjs

@@ -1,3 +1,3 @@
-import { a as verifyKeyFromPasswordHex, c as deriveSymmetricKeyFromContext, i as getKeyFromPasswordHex, l as deriveSymmetricKeyFromTwoKeys, n as getKeyFromPasswordAndSalt, o as deriveSymmetricCryptoKeyFromContext, r as getKeyFromPasswordAndSaltHex, s as deriveSymmetricCryptoKeyFromTwoKeys, t as getKeyFromPassword, u as deriveSymmetricKeyFromTwoKeysAndContext } from "./deriveKeysFromPassword-DJRWZ8Rw.mjs";
+import { n as deriveSymmetricKeyFromTwoKeys, t as deriveSymmetricKeyFromContext } from "./deriveKeysFromKey-DPU_h7wr.mjs";
 
-export { deriveSymmetricCryptoKeyFromContext, deriveSymmetricCryptoKeyFromTwoKeys, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, deriveSymmetricKeyFromTwoKeysAndContext, getKeyFromPassword, getKeyFromPasswordAndSalt, getKeyFromPasswordAndSaltHex, getKeyFromPasswordHex, verifyKeyFromPasswordHex };
+export { deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys };

package/dist/derive-password.d.mts

@@ -0,0 +1,22 @@
+//#region src/derive-password/deriveKeysFromPassword.d.ts
+/**
+ * Derives a symmetric key from a user's password with a randomly sampled salt
+ *
+ * @param password - The user's password
+ * @returns The derived secret key and randomly sampled salt
+ */
+declare function getKeyFromPassword(password: string): Promise<{
+  key: Uint8Array;
+  salt: Uint8Array;
+}>;
+/**
+ * Derives a symmetric key from a user's password and salt
+ *
+ * @param password - The user's password
+ * @param salt - The given salt
+ * @returns The derived secret key
+ */
+declare function getKeyFromPasswordAndSalt(password: string, salt: Uint8Array): Promise<Uint8Array>;
+//#endregion
+export { getKeyFromPassword, getKeyFromPasswordAndSalt };
+//# sourceMappingURL=derive-password.d.mts.map

package/dist/derive-password.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derive-password.d.mts","names":[],"sources":["../src/derive-password/deriveKeysFromPassword.ts"],"mappings":";;AAQA;;;;;iBAAsB,kBAAA,CAAmB,QAAA,WAAmB,OAAA;EAAU,GAAA,EAAK,UAAA;EAAY,IAAA,EAAM,UAAA;AAAA;;;;;;;;iBAiBvE,yBAAA,CAA0B,QAAA,UAAkB,IAAA,EAAM,UAAA,GAAa,OAAA,CAAQ,UAAA"}

package/dist/derive-password.d.ts

@@ -0,0 +1,22 @@
+//#region src/derive-password/deriveKeysFromPassword.d.ts
+/**
+ * Derives a symmetric key from a user's password with a randomly sampled salt
+ *
+ * @param password - The user's password
+ * @returns The derived secret key and randomly sampled salt
+ */
+declare function getKeyFromPassword(password: string): Promise<{
+  key: Uint8Array;
+  salt: Uint8Array;
+}>;
+/**
+ * Derives a symmetric key from a user's password and salt
+ *
+ * @param password - The user's password
+ * @param salt - The given salt
+ * @returns The derived secret key
+ */
+declare function getKeyFromPasswordAndSalt(password: string, salt: Uint8Array): Promise<Uint8Array>;
+//#endregion
+export { getKeyFromPassword, getKeyFromPasswordAndSalt };
+//# sourceMappingURL=derive-password.d.ts.map

package/dist/derive-password.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derive-password.d.ts","names":[],"sources":["../src/derive-password/deriveKeysFromPassword.ts"],"mappings":";;AAQA;;;;;iBAAsB,kBAAA,CAAmB,QAAA,WAAmB,OAAA;EAAU,GAAA,EAAK,UAAA;EAAY,IAAA,EAAM,UAAA;AAAA;;;;;;;;iBAiBvE,yBAAA,CAA0B,QAAA,UAAkB,IAAA,EAAM,UAAA,GAAa,OAAA,CAAQ,UAAA"}

package/dist/derive-password.js

@@ -0,0 +1,5 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_deriveKeysFromPassword = require('./deriveKeysFromPassword-C7xAGGsh.js');
+
+exports.getKeyFromPassword = require_deriveKeysFromPassword.getKeyFromPassword;
+exports.getKeyFromPasswordAndSalt = require_deriveKeysFromPassword.getKeyFromPasswordAndSalt;

package/dist/derive-password.mjs

@@ -0,0 +1,3 @@
+import { n as getKeyFromPasswordAndSalt, t as getKeyFromPassword } from "./deriveKeysFromPassword-DXgSvTNC.mjs";
+
+export { getKeyFromPassword, getKeyFromPasswordAndSalt };

package/dist/deriveKeysFromKey-C4McqO6_.js

@@ -0,0 +1,47 @@
+const require_chunk = require('./chunk-EbLFQX5m.js');
+const require_constants = require('./constants.js');
+const require_genID = require('./genID-cWOPmspk.js');
+let _noble_hashes_blake3_js = require("@noble/hashes/blake3.js");
+
+//#region src/derive-key/deriveKeysFromKey.ts
+/**
+* Derives a symmetric key from the base key and context string
+*
+* @param context - The context string.
+* The context string should be hardcoded, globally unique, and application-specific.
+* @param baseKey - The base key (NOT PASSWORD!)
+* @returns The derived secret key
+*/
+function deriveSymmetricKeyFromContext(context, baseKey) {
+	return (0, _noble_hashes_blake3_js.blake3)(baseKey, { context: require_genID.UTF8ToUint8(context) });
+}
+/**
+* Derives a symmetric key from two keys
+*
+* @param key1 - The 32-bytes key
+* @param key2 - The 32-bytes key
+* @returns The derived secret key
+*/
+function deriveSymmetricKeyFromTwoKeys(key1, key2) {
+	try {
+		if (key2.length != require_constants.AES_KEY_BYTE_LENGTH || key1.length != require_constants.AES_KEY_BYTE_LENGTH) throw new Error(`Input key length must be exactly ${require_constants.AES_KEY_BYTE_LENGTH} bytes`);
+		return deriveSymmetricKeyFromContext(require_constants.CONTEXT_DERIVE, (0, _noble_hashes_blake3_js.blake3)(key1, { key: key2 }));
+	} catch (error) {
+		throw new Error("Failed to derive symmetric key from two keys and context", { cause: error });
+	}
+}
+
+//#endregion
+Object.defineProperty(exports, 'deriveSymmetricKeyFromContext', {
+  enumerable: true,
+  get: function () {
+    return deriveSymmetricKeyFromContext;
+  }
+});
+Object.defineProperty(exports, 'deriveSymmetricKeyFromTwoKeys', {
+  enumerable: true,
+  get: function () {
+    return deriveSymmetricKeyFromTwoKeys;
+  }
+});
+//# sourceMappingURL=deriveKeysFromKey-C4McqO6_.js.map

package/dist/deriveKeysFromKey-C4McqO6_.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deriveKeysFromKey-C4McqO6_.js","names":["UTF8ToUint8","AES_KEY_BYTE_LENGTH","CONTEXT_DERIVE"],"sources":["../src/derive-key/deriveKeysFromKey.ts"],"sourcesContent":["import { blake3 } from '@noble/hashes/blake3.js';\nimport { AES_KEY_BYTE_LENGTH, CONTEXT_DERIVE } from '../constants';\nimport { UTF8ToUint8 } from '../utils';\n\n/**\n * Derives a symmetric key from the base key and context string\n *\n * @param context - The context string.\n * The context string should be hardcoded, globally unique, and application-specific.\n * @param baseKey - The base key (NOT PASSWORD!)\n * @returns The derived secret key\n */\nexport function deriveSymmetricKeyFromContext(context: string, baseKey: Uint8Array): Uint8Array {\n  return blake3(baseKey, { context: UTF8ToUint8(context) });\n}\n\n/**\n * Derives a symmetric key from two keys\n *\n * @param key1 - The 32-bytes key\n * @param key2 - The 32-bytes key\n * @returns The derived secret key\n */\nexport function deriveSymmetricKeyFromTwoKeys(key1: Uint8Array, key2: Uint8Array): Uint8Array {\n  try {\n    if (key2.length != AES_KEY_BYTE_LENGTH || key1.length != AES_KEY_BYTE_LENGTH) {\n      throw new Error(`Input key length must be exactly ${AES_KEY_BYTE_LENGTH} bytes`);\n    }\n    const key = blake3(key1, { key: key2 });\n    return deriveSymmetricKeyFromContext(CONTEXT_DERIVE, key);\n  } catch (error) {\n    throw new Error('Failed to derive symmetric key from two keys and context', { cause: error });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AAYA,SAAgB,8BAA8B,SAAiB,SAAiC;AAC9F,4CAAc,SAAS,EAAE,SAASA,0BAAY,QAAQ,EAAE,CAAC;;;;;;;;;AAU3D,SAAgB,8BAA8B,MAAkB,MAA8B;AAC5F,KAAI;AACF,MAAI,KAAK,UAAUC,yCAAuB,KAAK,UAAUA,sCACvD,OAAM,IAAI,MAAM,oCAAoCA,sCAAoB,QAAQ;AAGlF,SAAO,8BAA8BC,sEADlB,MAAM,EAAE,KAAK,MAAM,CAAC,CACkB;UAClD,OAAO;AACd,QAAM,IAAI,MAAM,4DAA4D,EAAE,OAAO,OAAO,CAAC"}

package/dist/deriveKeysFromKey-DPU_h7wr.mjs

@@ -0,0 +1,35 @@
+import { AES_KEY_BYTE_LENGTH, CONTEXT_DERIVE } from "./constants.mjs";
+import { s as UTF8ToUint8 } from "./genID-D08K7JPr.mjs";
+import { blake3 } from "@noble/hashes/blake3.js";
+
+//#region src/derive-key/deriveKeysFromKey.ts
+/**
+* Derives a symmetric key from the base key and context string
+*
+* @param context - The context string.
+* The context string should be hardcoded, globally unique, and application-specific.
+* @param baseKey - The base key (NOT PASSWORD!)
+* @returns The derived secret key
+*/
+function deriveSymmetricKeyFromContext(context, baseKey) {
+	return blake3(baseKey, { context: UTF8ToUint8(context) });
+}
+/**
+* Derives a symmetric key from two keys
+*
+* @param key1 - The 32-bytes key
+* @param key2 - The 32-bytes key
+* @returns The derived secret key
+*/
+function deriveSymmetricKeyFromTwoKeys(key1, key2) {
+	try {
+		if (key2.length != AES_KEY_BYTE_LENGTH || key1.length != AES_KEY_BYTE_LENGTH) throw new Error(`Input key length must be exactly ${AES_KEY_BYTE_LENGTH} bytes`);
+		return deriveSymmetricKeyFromContext(CONTEXT_DERIVE, blake3(key1, { key: key2 }));
+	} catch (error) {
+		throw new Error("Failed to derive symmetric key from two keys and context", { cause: error });
+	}
+}
+
+//#endregion
+export { deriveSymmetricKeyFromTwoKeys as n, deriveSymmetricKeyFromContext as t };
+//# sourceMappingURL=deriveKeysFromKey-DPU_h7wr.mjs.map

package/dist/deriveKeysFromKey-DPU_h7wr.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"deriveKeysFromKey-DPU_h7wr.mjs","names":[],"sources":["../src/derive-key/deriveKeysFromKey.ts"],"sourcesContent":["import { blake3 } from '@noble/hashes/blake3.js';\nimport { AES_KEY_BYTE_LENGTH, CONTEXT_DERIVE } from '../constants';\nimport { UTF8ToUint8 } from '../utils';\n\n/**\n * Derives a symmetric key from the base key and context string\n *\n * @param context - The context string.\n * The context string should be hardcoded, globally unique, and application-specific.\n * @param baseKey - The base key (NOT PASSWORD!)\n * @returns The derived secret key\n */\nexport function deriveSymmetricKeyFromContext(context: string, baseKey: Uint8Array): Uint8Array {\n  return blake3(baseKey, { context: UTF8ToUint8(context) });\n}\n\n/**\n * Derives a symmetric key from two keys\n *\n * @param key1 - The 32-bytes key\n * @param key2 - The 32-bytes key\n * @returns The derived secret key\n */\nexport function deriveSymmetricKeyFromTwoKeys(key1: Uint8Array, key2: Uint8Array): Uint8Array {\n  try {\n    if (key2.length != AES_KEY_BYTE_LENGTH || key1.length != AES_KEY_BYTE_LENGTH) {\n      throw new Error(`Input key length must be exactly ${AES_KEY_BYTE_LENGTH} bytes`);\n    }\n    const key = blake3(key1, { key: key2 });\n    return deriveSymmetricKeyFromContext(CONTEXT_DERIVE, key);\n  } catch (error) {\n    throw new Error('Failed to derive symmetric key from two keys and context', { cause: error });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAYA,SAAgB,8BAA8B,SAAiB,SAAiC;AAC9F,QAAO,OAAO,SAAS,EAAE,SAAS,YAAY,QAAQ,EAAE,CAAC;;;;;;;;;AAU3D,SAAgB,8BAA8B,MAAkB,MAA8B;AAC5F,KAAI;AACF,MAAI,KAAK,UAAU,uBAAuB,KAAK,UAAU,oBACvD,OAAM,IAAI,MAAM,oCAAoC,oBAAoB,QAAQ;AAGlF,SAAO,8BAA8B,gBADzB,OAAO,MAAM,EAAE,KAAK,MAAM,CAAC,CACkB;UAClD,OAAO;AACd,QAAM,IAAI,MAAM,4DAA4D,EAAE,OAAO,OAAO,CAAC"}

package/dist/{deriveKeysFromPassword-Ko7NxkHM.js → deriveKeysFromPassword-C7xAGGsh.js}

@@ -1,80 +1,7 @@
 const require_chunk = require('./chunk-EbLFQX5m.js');
 const require_constants = require('./constants.js');
-const require_genID = require('./genID-YJSl3YhL.js');
-const require_aes = require('./aes-bOrKZuUC.js');
-let _noble_hashes_blake3_js = require("@noble/hashes/blake3.js");
+let _noble_hashes_utils_js = require("@noble/hashes/utils.js");
 
-//#region src/derive-key/deriveKeysFromKey.ts
-/**
-* Derives a symmetric key from the base key and context string
-*
-* @param context - The context string.
-* The context string should be hardcoded, globally unique, and application-specific.
-* @param baseKey - The base key (NOT PASSWORD!)
-* @returns The derived secret key
-*/
-function deriveSymmetricKeyFromContext(context, baseKey) {
-	return (0, _noble_hashes_blake3_js.blake3)(baseKey, { context: require_genID.UTF8ToUint8(context) });
-}
-/**
-* Derives a symmetric CryptoKey from the base key and context string
-*
-* @param context - The context string.
-* The context string should be hardcoded, globally unique, and application-specific.
-* @param baseKey - The base key (NOT PASSWORD!)
-* @returns The derived secret CryptoKey
-*/
-async function deriveSymmetricCryptoKeyFromContext(context, baseKey) {
-	try {
-		if (baseKey.length != require_constants.AES_KEY_BIT_LENGTH / 8) throw new Error(`Base key length must be exactly ${require_constants.AES_KEY_BIT_LENGTH / 8} bytes`);
-		if (!context) throw new Error("Context is empry");
-		return await require_aes.importSymmetricCryptoKey(deriveSymmetricKeyFromContext(context, baseKey));
-	} catch (error) {
-		throw new Error("Failed to derive CryptoKey from base key and context", { cause: error });
-	}
-}
-/**
-* Derives a symmetric key from two keys
-*
-* @param key1 - The 32-bytes key
-* @param key2 - The 32-bytes key
-* @returns The derived secret key
-*/
-function deriveSymmetricKeyFromTwoKeys(key1, key2) {
-	return deriveSymmetricKeyFromTwoKeysAndContext(key1, key2, require_constants.CONTEXT_DERIVE);
-}
-/**
-* Derives a symmetric CryptoKey from two keys
-*
-* @param key1 - The 32-bytes key
-* @param key2 - The 32-bytes key
-* @returns The derived secret CryptoKey
-*/
-async function deriveSymmetricCryptoKeyFromTwoKeys(key1, key2) {
-	try {
-		return await require_aes.importSymmetricCryptoKey(deriveSymmetricKeyFromTwoKeys(key1, key2));
-	} catch (error) {
-		throw new Error("Failed to derive symmetric CryptoKey from two keys", { cause: error });
-	}
-}
-/**
-* Derives a symmetric key from two keys and context
-*
-* @param key1 - The 32-bytes key
-* @param key2 - The 32-bytes key
-* @param context - The context string
-* @returns The derived symmetric key
-*/
-function deriveSymmetricKeyFromTwoKeysAndContext(key1, key2, context) {
-	try {
-		if (key2.length != require_constants.AES_KEY_BIT_LENGTH / 8 || key1.length != require_constants.AES_KEY_BIT_LENGTH / 8) throw new Error(`Input key length must be exactly ${require_constants.AES_KEY_BIT_LENGTH / 8} bytes`);
-		return (0, _noble_hashes_blake3_js.blake3)((0, _noble_hashes_blake3_js.blake3)(key1, { key: key2 }), { context: require_genID.UTF8ToUint8(context) });
-	} catch (error) {
-		throw new Error("Failed to derive symmetric key from two keys and context", { cause: error });
-	}
-}
-
-//#endregion
 //#region node_modules/hash-wasm/dist/index.umd.js
 var require_index_umd = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, module) => {
 	/*!
@@ -2310,7 +2237,7 @@ var require_index_umd = /* @__PURE__ */ require_chunk.__commonJSMin(((exports, m
 }));
 
 //#endregion
-//#region src/derive-key/core.ts
+//#region src/derive-password/core.ts
 var import_index_umd = require_index_umd();
 /**
 * Calculates hash using the argon2id password-hashing function
@@ -2340,17 +2267,11 @@ async function argon2(password, salt, parallelism = require_constants.ARGON2ID_P
 * @returns The salt
 */
 function sampleSalt() {
-	try {
-		const salt = new Uint8Array(require_constants.ARGON2ID_SALT_BYTE_LENGTH);
-		crypto.getRandomValues(salt);
-		return salt;
-	} catch (error) {
-		throw new Error("Failed to sample salt", { cause: error });
-	}
+	return (0, _noble_hashes_utils_js.randomBytes)(require_constants.ARGON2ID_SALT_BYTE_LENGTH);
 }
 
 //#endregion
-//#region src/derive-key/deriveKeysFromPassword.ts
+//#region src/derive-password/deriveKeysFromPassword.ts
 /**
 * Derives a symmetric key from a user's password with a randomly sampled salt
 *
@@ -2359,7 +2280,6 @@ function sampleSalt() {
 */
 async function getKeyFromPassword(password) {
 	try {
-		if (!password) throw new Error("No password given");
 		const salt = sampleSalt();
 		return {
 			key: await argon2(password, salt),
@@ -2378,87 +2298,13 @@ async function getKeyFromPassword(password) {
 */
 async function getKeyFromPasswordAndSalt(password, salt) {
 	try {
-		if (!salt.length) throw new Error("No salt given");
-		if (!password) throw new Error("No password given");
 		return await argon2(password, salt);
 	} catch (error) {
 		throw new Error("Failed to derive key from password and salt", { cause: error });
 	}
 }
-/**
-* Derives a HEX symmetric key from a user's password with a randomly sampled salt
-*
-* @param password - The user's password
-* @returns The derived HEX secret key and randomly sampled HEX salt
-*/
-async function getKeyFromPasswordHex(password) {
-	try {
-		const { key, salt } = await getKeyFromPassword(password);
-		return {
-			keyHex: require_genID.uint8ArrayToHex(key),
-			saltHex: require_genID.uint8ArrayToHex(salt)
-		};
-	} catch (error) {
-		throw new Error("Failed to derive key from password", { cause: error });
-	}
-}
-/**
-* Derives a HEX symmetric key from a user's password and salt
-*
-* @param password - The user's password
-* @param saltHex - The given HEX salt
-* @returns The derived HEX secret key
-*/
-async function getKeyFromPasswordAndSaltHex(password, saltHex) {
-	try {
-		return require_genID.uint8ArrayToHex(await getKeyFromPasswordAndSalt(password, require_genID.hexToUint8Array(saltHex)));
-	} catch (error) {
-		throw new Error("Failed to derive key from password and salt", { cause: error });
-	}
-}
-/**
-* Verifies the derived key
-*
-* @param password - The user's password
-* @param saltHex - The given HEX salt
-* @param keyHex - The derived HEX key
-* @returns The result of the key verification
-*/
-async function verifyKeyFromPasswordHex(password, saltHex, keyHex) {
-	return keyHex === await getKeyFromPasswordAndSaltHex(password, saltHex);
-}
 
 //#endregion
-Object.defineProperty(exports, 'deriveSymmetricCryptoKeyFromContext', {
-  enumerable: true,
-  get: function () {
-    return deriveSymmetricCryptoKeyFromContext;
-  }
-});
-Object.defineProperty(exports, 'deriveSymmetricCryptoKeyFromTwoKeys', {
-  enumerable: true,
-  get: function () {
-    return deriveSymmetricCryptoKeyFromTwoKeys;
-  }
-});
-Object.defineProperty(exports, 'deriveSymmetricKeyFromContext', {
-  enumerable: true,
-  get: function () {
-    return deriveSymmetricKeyFromContext;
-  }
-});
-Object.defineProperty(exports, 'deriveSymmetricKeyFromTwoKeys', {
-  enumerable: true,
-  get: function () {
-    return deriveSymmetricKeyFromTwoKeys;
-  }
-});
-Object.defineProperty(exports, 'deriveSymmetricKeyFromTwoKeysAndContext', {
-  enumerable: true,
-  get: function () {
-    return deriveSymmetricKeyFromTwoKeysAndContext;
-  }
-});
 Object.defineProperty(exports, 'getKeyFromPassword', {
   enumerable: true,
   get: function () {
@@ -2471,22 +2317,4 @@ Object.defineProperty(exports, 'getKeyFromPasswordAndSalt', {
     return getKeyFromPasswordAndSalt;
   }
 });
-Object.defineProperty(exports, 'getKeyFromPasswordAndSaltHex', {
-  enumerable: true,
-  get: function () {
-    return getKeyFromPasswordAndSaltHex;
-  }
-});
-Object.defineProperty(exports, 'getKeyFromPasswordHex', {
-  enumerable: true,
-  get: function () {
-    return getKeyFromPasswordHex;
-  }
-});
-Object.defineProperty(exports, 'verifyKeyFromPasswordHex', {
-  enumerable: true,
-  get: function () {
-    return verifyKeyFromPasswordHex;
-  }
-});
-//# sourceMappingURL=deriveKeysFromPassword-Ko7NxkHM.js.map
+//# sourceMappingURL=deriveKeysFromPassword-C7xAGGsh.js.map