fix: memory zeroing, Schnorr signatures, and 32-byte key derivation

HIGH fixes:
- Zero Uint8Array buffers containing entropy/private key bytes after use
  (.fill(0) on all intermediate key material in 4 files)
- Replace ECDSA secp256k1.sign/verify with schnorr.sign/verify (NIP-01
  requires BIP-340 Schnorr signatures, not ECDSA)
- Hash 16-byte mnemonic entropy to 32 bytes via SHA-256 in core/keys.ts
  (was returning raw entropy as private key — invalid for secp256k1)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: vveerrgg

src/core/crypto.ts

@@ -97,6 +97,7 @@ export async function getSharedSecret(
     const privKeyBytes = hexToBytes(privateKey);
     const pubKeyBytes = hexToBytes(publicKey);
     const sharedPoint = schnorr.getPublicKey(privKeyBytes);
+    privKeyBytes.fill(0); // zero sensitive material
     return sha256(sharedPoint);
   } catch (error) {
     logger.error("Failed to get shared secret:", error?.toString());

src/core/keys.ts

@@ -1,5 +1,6 @@
 import * as secp256k1 from "@noble/secp256k1";
 import { bytesToHex, hexToBytes } from "@noble/hashes/utils";
+import { sha256 } from "@noble/hashes/sha256";
 import { pino } from "pino";
 import { KeyPair } from "../types/keys.js";
 import {
@@ -155,7 +156,9 @@ export function seedPhraseToPrivateKey(seedPhrase: string): string {
     }
 
     const entropy = getEntropyFromSeedPhrase(seedPhrase);
-    return bytesToHex(entropy);
+    const privateKey = bytesToHex(sha256(entropy));
+    entropy.fill(0); // zero sensitive material
+    return privateKey;
   } catch (error) {
     logger.error("Failed to convert seed phrase to private key:", error);
     throw new Error("Failed to convert seed phrase to private key");

src/crypto/keys.ts

@@ -101,9 +101,12 @@ export async function seedPhraseToKeyPair(
 
     const entropy = getEntropyFromSeedPhrase(seedPhrase);
     const privateKey = derivePrivateKey(entropy);
+    entropy.fill(0); // zero sensitive material
+    const privateKeyBytes = hexToBytes(privateKey);
     const publicKey = createPublicKey(
-      bytesToHex(getCompressedPublicKey(hexToBytes(privateKey))),
+      bytesToHex(getCompressedPublicKey(privateKeyBytes)),
     );
+    privateKeyBytes.fill(0); // zero sensitive material
 
     return {
       privateKey,
@@ -127,10 +130,11 @@ export async function seedPhraseToKeyPair(
  */
 export function derivePrivateKey(entropy: Uint8Array): string {
   try {
-    let privateKeyBytes = entropy;
     // Hash the entropy to get a valid private key
-    privateKeyBytes = sha256(privateKeyBytes);
-    return bytesToHex(privateKeyBytes);
+    const privateKeyBytes = sha256(entropy);
+    const hex = bytesToHex(privateKeyBytes);
+    privateKeyBytes.fill(0); // zero sensitive material
+    return hex;
   } catch (error) {
     logger.error("Failed to derive private key:", error?.toString());
     throw new Error("Failed to derive private key");
@@ -156,11 +160,13 @@ export async function fromHex(privateKeyHex: string): Promise<KeyPair> {
   try {
     const privateKeyBytes = hexToBytes(privateKeyHex);
     if (!secp256k1.utils.isValidPrivateKey(privateKeyBytes)) {
+      privateKeyBytes.fill(0); // zero sensitive material
       throw new Error("Invalid private key");
     }
     const publicKey = createPublicKey(
       bytesToHex(getCompressedPublicKey(privateKeyBytes)),
     );
+    privateKeyBytes.fill(0); // zero sensitive material
 
     return {
       privateKey: privateKeyHex,
@@ -187,6 +193,7 @@ export async function validateKeyPair(
   try {
     const privateKeyBytes = hexToBytes(privateKey);
     if (!secp256k1.utils.isValidPrivateKey(privateKeyBytes)) {
+      privateKeyBytes.fill(0); // zero sensitive material
       return {
         isValid: false,
         error: "Invalid private key",
@@ -197,6 +204,7 @@ export async function validateKeyPair(
     const derivedPublicKey = bytesToHex(
       getCompressedPublicKey(privateKeyBytes),
     );
+    privateKeyBytes.fill(0); // zero sensitive material
 
     if (pubKeyHex !== derivedPublicKey) {
       return {

src/index.ts

@@ -1,5 +1,6 @@
 import { generateMnemonic, validateMnemonic, mnemonicToEntropy } from "bip39";
 import * as secp256k1 from "@noble/secp256k1";
+import { schnorr } from "@noble/curves/secp256k1";
 import { bytesToHex, hexToBytes } from "@noble/hashes/utils";
 import { sha256 } from "@noble/hashes/sha256";
 import { hmac } from "@noble/hashes/hmac";
@@ -124,7 +125,9 @@ export function seedPhraseToKeyPair(seedPhrase: string): KeyPair {
     const entropy = getEntropyFromSeedPhrase(seedPhrase);
     // Hash the entropy to generate a proper private key
     const privateKeyBytes = sha256(entropy);
+    entropy.fill(0); // zero sensitive material
     const privateKeyHex = bytesToHex(privateKeyBytes);
+    privateKeyBytes.fill(0); // zero sensitive material
 
     // Derive the public key
     const publicKeyBytes = secp256k1.getPublicKey(privateKeyHex, true); // Force compressed format
@@ -180,11 +183,13 @@ export function fromHex(privateKeyHex: string): KeyPair {
     // Validate the private key
     const privateKeyBytes = hexToBytes(privateKeyHex);
     if (!secp256k1.utils.isValidPrivateKey(privateKeyBytes)) {
+      privateKeyBytes.fill(0); // zero sensitive material
       throw new Error("Invalid private key");
     }
 
     // Derive the public key
     const publicKeyBytes = secp256k1.getPublicKey(privateKeyBytes, true); // Force compressed format
+    privateKeyBytes.fill(0); // zero sensitive material
     const publicKey = bytesToHex(publicKeyBytes);
 
     // Generate the nsec and npub formats
@@ -216,6 +221,7 @@ export function getPublicKey(privateKey: string): string {
   try {
     const privateKeyBytes = hexToBytes(privateKey);
     const publicKeyBytes = secp256k1.getPublicKey(privateKeyBytes, true); // Force compressed format
+    privateKeyBytes.fill(0); // zero sensitive material
     return bytesToHex(publicKeyBytes);
   } catch (error) {
     logger.error("Failed to get public key:", error?.toString());
@@ -358,12 +364,11 @@ export async function signEvent(
 ): Promise<string> {
   try {
     const eventHash = getEventHash(event);
-    const signature = await secp256k1.sign(
-      hexToBytes(eventHash),
-      hexToBytes(privateKey),
-    );
+    const privateKeyBytes = hexToBytes(privateKey);
+    const signature = schnorr.sign(eventHash, privateKeyBytes);
+    privateKeyBytes.fill(0); // zero sensitive material
     logger.log("Event signed successfully");
-    return bytesToHex(signature.toCompactRawBytes());
+    return bytesToHex(signature);
   } catch (error) {
     logger.error("Failed to sign event:", error?.toString());
     throw error;
@@ -392,9 +397,9 @@ export async function verifyEvent(event: NostrEvent): Promise<boolean> {
     }
 
     logger.log("Verifying event signature");
-    return await secp256k1.verify(
+    return schnorr.verify(
       hexToBytes(event.sig),
-      hexToBytes(hash),
+      hash,
       hexToBytes(event.pubkey),
     );
   } catch (error) {
@@ -527,6 +532,7 @@ export function privateKeyToNpub(privateKey: string): string {
   try {
     const privateKeyBytes = hexToBytes(privateKey);
     const publicKey = secp256k1.getPublicKey(privateKeyBytes, true);
+    privateKeyBytes.fill(0); // zero sensitive material
     return nip19.npubEncode(bytesToHex(publicKey));
   } catch (error) {
     logger.error("Failed to encode npub:", error?.toString());
@@ -632,9 +638,12 @@ export async function signMessage(
   try {
     const messageBytes = new TextEncoder().encode(message);
     const messageHash = sha256(messageBytes);
-    const signature = await secp256k1.sign(messageHash, hexToBytes(privateKey));
+    const messageHashHex = bytesToHex(messageHash);
+    const privateKeyBytes = hexToBytes(privateKey);
+    const signature = schnorr.sign(messageHashHex, privateKeyBytes);
+    privateKeyBytes.fill(0); // zero sensitive material
     logger.log("Message signed successfully");
-    return bytesToHex(signature.toCompactRawBytes());
+    return bytesToHex(signature);
   } catch (error) {
     logger.error("Failed to sign message:", error?.toString());
     throw error;
@@ -659,10 +668,11 @@ export async function verifySignature(
   try {
     const messageBytes = new TextEncoder().encode(message);
     const messageHash = sha256(messageBytes);
+    const messageHashHex = bytesToHex(messageHash);
     logger.log("Verifying message signature");
-    return await secp256k1.verify(
+    return schnorr.verify(
       hexToBytes(signature),
-      messageHash,
+      messageHashHex,
       hexToBytes(publicKey),
     );
   } catch (error) {