ns-auth-sdk 1.12.2 → 1.12.4

package/dist/index.mjs

@@ -1,5 +1,9 @@
 import { finalizeEvent, getPublicKey } from "applesauce-core/helpers";
 import * as secp256k1 from "@noble/secp256k1";
+import { sha256 } from "@noble/hashes/sha2";
+import { pbkdf2 } from "@noble/hashes/pbkdf2";
+import { aesGcm } from "@noble/ciphers/aes";
+import { randomBytes } from "@noble/secp256k1/utils";
 
 export * from "applesauce-core"
 
@@ -171,8 +175,6 @@ const PRF_EVAL_INPUT = new TextEncoder().encode("nostr-pwk");
 */
 async function isPrfSupported() {
 	try {
-		const cryptoObj = typeof window !== "undefined" && window.crypto || globalThis.crypto;
-		if (!cryptoObj || !cryptoObj.subtle) return false;
 		const response = await navigator.credentials.get({ publicKey: {
 			challenge: crypto.getRandomValues(new Uint8Array(32)),
 			allowCredentials: [],
@@ -256,32 +258,29 @@ async function getPrfSecret(credentialId, options) {
 * password-protected private key. The private key is wrapped with a password-
 * derived AES-GCM key and stored alongside the public key (SPKI).
 *
-* This is a minimal, browser-oriented implementation designed to provide a
-* practical alternative while keeping crypto surface area focused and safe.
+* This implementation uses @noble libraries for cryptographic operations,
+* ensuring functionality even when Web Crypto API is unavailable.
 */
 function toBase64(bytes) {
-	const arr = new Uint8Array(bytes);
 	let binary = "";
-	for (let i = 0; i < arr.byteLength; i++) binary += String.fromCharCode(arr[i]);
+	for (let i = 0; i < bytes.byteLength; i++) binary += String.fromCharCode(bytes[i]);
 	if (typeof window !== "undefined" && window.btoa) return window.btoa(binary);
-	return Buffer.from(binary, "binary").toString("base64");
+	return btoa(binary);
 }
 function fromBase64(b64) {
 	if (typeof window !== "undefined" && window.atob) {
-		const bin = window.atob(b64);
-		const bytes = new Uint8Array(bin.length);
-		for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
-		return bytes;
-	}
-	return new Uint8Array(Buffer.from(b64, "base64"));
+		const bin$1 = window.atob(b64);
+		const bytes$1 = new Uint8Array(bin$1.length);
+		for (let i = 0; i < bin$1.length; i++) bytes$1[i] = bin$1.charCodeAt(i);
+		return bytes$1;
+	}
+	const bin = atob(b64);
+	const bytes = new Uint8Array(bin.length);
+	for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
+	return bytes;
 }
 async function checkPRFSupport() {
 	try {
-		const cryptoObj = typeof window !== "undefined" && window.crypto || globalThis.crypto;
-		if (!cryptoObj || !cryptoObj.subtle) {
-			console.log("Web Crypto API not available, falling back to password-protected key");
-			return false;
-		}
 		const supported = (typeof PublicKeyCredential !== "undefined" ? await PublicKeyCredential.getClientCapabilities() : null)?.["extension:prf"] === true;
 		if (supported) console.log("PRF extension is supported.");
 		else console.log("PRF extension is not supported.");
@@ -292,107 +291,43 @@ async function checkPRFSupport() {
 	}
 }
 async function generatePasswordProtectedKey(password) {
-	const cryptoObj = typeof window !== "undefined" && window.crypto || globalThis.crypto;
-	if (!cryptoObj || !cryptoObj.subtle) throw new Error("Web Crypto API not available");
-	const kp = await cryptoObj.subtle.generateKey({
-		name: "ECDSA",
-		namedCurve: "P-256"
-	}, true, ["sign"]);
-	const publicKey = kp.publicKey;
-	const privateKey = kp.privateKey;
-	const publicKeySpkiBase64 = toBase64(await cryptoObj.subtle.exportKey("spki", publicKey));
-	const privateKeyJwk = await cryptoObj.subtle.exportKey("jwk", privateKey);
-	const jwkStr = JSON.stringify(privateKeyJwk);
-	const salt = cryptoObj.getRandomValues(new Uint8Array(16));
-	const pbKey = await cryptoObj.subtle.importKey("raw", new TextEncoder().encode(password), "PBKDF2", false, ["deriveKey"]);
-	const aesKey = await cryptoObj.subtle.deriveKey({
-		name: "PBKDF2",
-		salt: salt.slice().buffer,
-		iterations: 1e5,
-		hash: "SHA-256"
-	}, pbKey, {
-		name: "AES-GCM",
-		length: 256
-	}, false, ["encrypt"]);
-	const iv = cryptoObj.getRandomValues(new Uint8Array(12));
-	const enc = new TextEncoder().encode(jwkStr);
+	const privateKey = secp256k1.utils.randomPrivateKey();
+	const publicKeySpkiBase64 = toBase64(secp256k1.getPublicKey(privateKey, true));
+	const salt = randomBytes(16);
+	const derivedKey = pbkdf2(sha256, new TextEncoder().encode(password), salt, {
+		c: 1e5,
+		dkLen: 32
+	});
+	const iv = randomBytes(12);
 	return {
 		publicKeySpkiBase64,
-		wrappedPrivateKeyBase64: toBase64(await cryptoObj.subtle.encrypt({
-			name: "AES-GCM",
-			iv
-		}, aesKey, enc)),
-		saltBase64: toBase64(salt.buffer),
-		ivBase64: toBase64(iv.buffer)
+		wrappedPrivateKeyBase64: toBase64(aesGcm(derivedKey, iv).encrypt(privateKey)),
+		saltBase64: toBase64(salt),
+		ivBase64: toBase64(iv)
 	};
 }
 async function unwrapPasswordProtectedPrivateKey(bundle, password) {
-	const cryptoObj = typeof window !== "undefined" && window.crypto || globalThis.crypto;
-	if (!cryptoObj || !cryptoObj.subtle) throw new Error("Web Crypto API not available");
 	const salt = fromBase64(bundle.saltBase64);
-	const pbKey = await cryptoObj.subtle.importKey("raw", new TextEncoder().encode(password), "PBKDF2", false, ["deriveKey"]);
-	const aesKey = await cryptoObj.subtle.deriveKey({
-		name: "PBKDF2",
-		salt: salt.slice().buffer,
-		iterations: 1e5,
-		hash: "SHA-256"
-	}, pbKey, {
-		name: "AES-GCM",
-		length: 256
-	}, false, ["decrypt"]);
+	const derivedKey = pbkdf2(sha256, new TextEncoder().encode(password), salt, {
+		c: 1e5,
+		dkLen: 32
+	});
 	const iv = fromBase64(bundle.ivBase64);
 	const ct = fromBase64(bundle.wrappedPrivateKeyBase64);
-	const jwkBytes = await cryptoObj.subtle.decrypt({
-		name: "AES-GCM",
-		iv: iv.slice()
-	}, aesKey, ct.slice());
-	const jwkStr = new TextDecoder().decode(jwkBytes);
-	const privateKeyJwk = JSON.parse(jwkStr);
-	await cryptoObj.subtle.importKey("jwk", privateKeyJwk, {
-		name: "ECDSA",
-		namedCurve: "P-256"
-	}, true, ["sign"]);
-	const d = privateKeyJwk.d;
-	if (!d) throw new Error("Missing private scalar in JWK");
-	return base64UrlToBytes(d);
-}
-function base64UrlToBytes(base64url) {
-	let base64 = base64url.replace(/-/g, "+").replace(/_/g, "/");
-	const pad = base64.length % 4;
-	if (pad) base64 += "=".repeat(4 - pad);
-	if (typeof window !== "undefined" && window.atob) {
-		const binary = window.atob(base64);
-		const bytes = new Uint8Array(binary.length);
-		for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
-		return bytes;
-	}
-	return new Uint8Array(Buffer.from(base64, "base64"));
+	return aesGcm(derivedKey, iv).decrypt(ct);
 }
-async function importPublicKeyFromBundle(bundle) {
-	const cryptoObj = typeof window !== "undefined" && window.crypto || globalThis.crypto;
-	if (!cryptoObj || !cryptoObj.subtle) throw new Error("Web Crypto API not available");
-	const spki = fromBase64(bundle.publicKeySpkiBase64);
-	return await cryptoObj.subtle.importKey("spki", spki, {
-		name: "ECDSA",
-		namedCurve: "P-256"
-	}, true, ["verify"]);
+function importPublicKeyFromBundle(bundle) {
+	return fromBase64(bundle.publicKeySpkiBase64);
 }
 const DEFAULT_SALT = "nostr-key-derivation";
-async function deriveNostrPrivateKey(password, salt = DEFAULT_SALT) {
-	const cryptoObj = typeof window !== "undefined" && window.crypto || globalThis.crypto;
-	if (!cryptoObj || !cryptoObj.subtle) throw new Error("Web Crypto API not available");
-	const encoder = new TextEncoder();
-	const passwordKey = await cryptoObj.subtle.importKey("raw", encoder.encode(password), "PBKDF2", false, ["deriveBits"]);
-	const derivedBits = await cryptoObj.subtle.deriveBits({
-		name: "PBKDF2",
-		salt: encoder.encode(salt),
-		iterations: 1e5,
-		hash: "SHA-256"
-	}, passwordKey, 256);
-	return new Uint8Array(derivedBits);
+function deriveNostrPrivateKey(password, salt = DEFAULT_SALT) {
+	return pbkdf2(sha256, new TextEncoder().encode(password), new TextEncoder().encode(salt), {
+		c: 1e5,
+		dkLen: 32
+	});
 }
-async function getPublicKeyFromPassword(password, salt = DEFAULT_SALT) {
-	return getPublicKey(await deriveNostrPrivateKey(password, salt));
+function getPublicKeyFromPassword(password, salt = DEFAULT_SALT) {
+	return getPublicKey(deriveNostrPrivateKey(password, salt));
 }
 
 //#endregion
@@ -439,7 +374,7 @@ async function verifyRecoverySignature(kind0) {
 		if (!parseRecoveryTag(kind0.tags || [])) return false;
 		const signature = getRecoverySignature(kind0);
 		if (!signature || !kind0.pubkey) return false;
-		const messageHash = await sha256(kind0.pubkey);
+		const messageHash = await sha256$1(kind0.pubkey);
 		const signatureBytes = hexToBytes(signature);
 		const pubkeyBytes = hexToBytes(kind0.pubkey);
 		return secp256k1.verify(signatureBytes, messageHash, pubkeyBytes);
@@ -447,7 +382,7 @@ async function verifyRecoverySignature(kind0) {
 		return false;
 	}
 }
-async function sha256(message) {
+async function sha256$1(message) {
 	const msgBuffer = new TextEncoder().encode(message);
 	const subtle = globalThis.crypto?.subtle;
 	if (!subtle) throw new Error("Web Crypto API not available");
@@ -675,7 +610,7 @@ var NosskeyManager = class {
 	*/
 	async createPasswordProtectedNostrKey(password, options = {}) {
 		const salt = await deriveSaltFromUsername(options.username);
-		const pubkey = await getPublicKeyFromPassword(password, salt);
+		const pubkey = getPublicKeyFromPassword(password, salt);
 		return {
 			credentialId: bytesToHex((typeof window !== "undefined" ? window.crypto : globalThis.crypto).getRandomValues(new Uint8Array(16))),
 			pubkey,
@@ -696,7 +631,7 @@ var NosskeyManager = class {
 		if (isPasswordDerived) {
 			if (shouldUseCache) sk = this.#keyCache.getKey(keyInfo.credentialId);
 			if (!sk && password) {
-				sk = await deriveNostrPrivateKey(password, keyInfo.salt);
+				sk = deriveNostrPrivateKey(password, keyInfo.salt);
 				if (shouldUseCache) this.#keyCache.setKey(keyInfo.credentialId, sk);
 			}
 			if (!sk) throw new Error("Password required - key not in cache. Provide password to sign.");
@@ -737,7 +672,7 @@ var NosskeyManager = class {
 		}
 		if (!keyInfo.passwordProtectedBundle && keyInfo.salt) {
 			if (!options.password) throw new Error("Password is required for password-derived keys");
-			return bytesToHex(await deriveNostrPrivateKey(options.password, keyInfo.salt));
+			return bytesToHex(deriveNostrPrivateKey(options.password, keyInfo.salt));
 		}
 		let usedCredentialId = credentialId;
 		if (!usedCredentialId && keyInfo.credentialId) usedCredentialId = hexToBytes(keyInfo.credentialId);
@@ -762,8 +697,8 @@ var NosskeyManager = class {
 		if (keyInfo.recovery) throw new Error("Recovery already configured");
 		if (!(currentCredentialId || (keyInfo.credentialId ? hexToBytes(keyInfo.credentialId) : void 0))) throw new Error("Credential ID required");
 		const recoverySalt = bytesToHex((typeof window !== "undefined" ? window.crypto : globalThis.crypto).getRandomValues(new Uint8Array(16)));
-		const recoveryPubkey = await getPublicKeyFromPassword(password, recoverySalt);
-		const recoverySk = await deriveNostrPrivateKey(password, recoverySalt);
+		const recoveryPubkey = getPublicKeyFromPassword(password, recoverySalt);
+		const recoverySk = deriveNostrPrivateKey(password, recoverySalt);
 		const signature = this.#signWithKey(recoverySk, keyInfo.pubkey);
 		this.#clearKey(recoverySk);
 		const updatedKeyInfo = {
@@ -798,13 +733,13 @@ var NosskeyManager = class {
 		if (!keyInfo.recovery) throw new Error("No recovery key configured");
 		if (!newCredentialId) throw new Error("New credential ID is required for recovery");
 		const { recoveryPubkey, recoverySalt } = keyInfo.recovery;
-		if (await getPublicKeyFromPassword(password, recoverySalt) !== recoveryPubkey) throw new Error("Invalid recovery password");
+		if (getPublicKeyFromPassword(password, recoverySalt) !== recoveryPubkey) throw new Error("Invalid recovery password");
 		const { secret: newSk } = await getPrfSecret(newCredentialId, this.#prfOptions);
 		const newPubkey = getPublicKey(newSk);
 		this.#clearKey(newSk);
 		const newRecoverySalt = bytesToHex((typeof window !== "undefined" ? window.crypto : globalThis.crypto).getRandomValues(new Uint8Array(16)));
-		const newRecoveryPubkey = await getPublicKeyFromPassword(password, newRecoverySalt);
-		const recoverySk = await deriveNostrPrivateKey(password, recoverySalt);
+		const newRecoveryPubkey = getPublicKeyFromPassword(password, newRecoverySalt);
+		const recoverySk = deriveNostrPrivateKey(password, recoverySalt);
 		const signature = this.#signWithKey(recoverySk, newPubkey);
 		this.#clearKey(recoverySk);
 		const updatedKeyInfo = {