security: decrypt and sign dApp approvals in the popup (closes #157)

The password no longer crosses the extension messaging boundary: the popup
decrypts and signs, and sends only the raw signed transaction or the signature.
The background re-derives the signer from the artifact and checks it against
the approval it holds before broadcasting, so it is not a blind relay.

src/popup/views/approval.js

@@ -9,10 +9,19 @@ const {
     attachCopyHandlers,
 } = require("./helpers");
 const { state, saveState, currentNetwork } = require("../../shared/state");
-const { formatEther, formatUnits, Interface, toUtf8String } = require("ethers");
+const {
+    formatEther,
+    formatUnits,
+    getBytes,
+    Interface,
+    toUtf8String,
+} = require("ethers");
 const { getPrice, formatUsd } = require("../../shared/prices");
 const { ERC20_ABI } = require("../../shared/constants");
 const { TOKEN_BY_ADDRESS } = require("../../shared/tokenList");
+const { decryptWithPassword } = require("../../shared/vault");
+const { getSignerForAddress } = require("../../shared/wallet");
+const { getProvider } = require("../../shared/balances");
 const txStatus = require("./txStatus");
 const uniswap = require("../../shared/uniswap");
 const runtime =
@@ -153,6 +162,8 @@ function showTxApproval(details) {
         details.isPhishingDomain,
     );
 
+    pendingTxParams = details.txParams;
+
     const toAddr = details.txParams.to;
     const token = toAddr ? TOKEN_BY_ADDRESS.get(toAddr.toLowerCase()) : null;
     const ethValue = formatEther(details.txParams.value || "0");
@@ -326,6 +337,7 @@ function showSignApproval(details) {
     );
 
     const sp = details.signParams;
+    pendingSignParams = sp;
 
     $("approve-sign-hostname").textContent = details.hostname;
     $("approve-sign-from").innerHTML = approvalAddressHtml(sp.from);
@@ -401,6 +413,36 @@ function show(id) {
 
 let approvalId = null;
 let pendingTxDetails = null;
+// The exact parameters shown to the user, kept so the popup signs what it
+// displayed rather than re-fetching anything at approval time. Both are
+// repopulated by show() when the popup is closed and reopened.
+let pendingTxParams = null;
+let pendingSignParams = null;
+
+// Approve buttons stay disabled and muted while the popup derives the key and
+// signs, which is slow enough (Argon2id) that a double click is likely.
+function setTxButtonBusy(busy) {
+    $("btn-approve-tx").disabled = busy;
+    $("btn-approve-tx").classList.toggle("text-muted", busy);
+}
+
+function setSignButtonBusy(busy) {
+    $("btn-approve-sign").disabled = busy;
+    $("btn-approve-sign").classList.toggle("text-muted", busy);
+}
+
+// Locate the wallet and the address index owning the currently active
+// address. Returns null when no wallet holds it.
+function findActiveWallet() {
+    for (const wallet of state.wallets) {
+        for (let i = 0; i < wallet.addresses.length; i++) {
+            if (wallet.addresses[i].address === state.activeAddress) {
+                return { wallet, addrIndex: i };
+            }
+        }
+    }
+    return null;
+}
 
 function init(ctx) {
     $("approve-remember").addEventListener("change", async () => {
@@ -430,34 +472,86 @@ function init(ctx) {
         window.close();
     });
 
-    $("btn-approve-tx").addEventListener("click", () => {
-        const password = $("approve-tx-password").value;
+    $("btn-approve-tx").addEventListener("click", async () => {
+        let password = $("approve-tx-password").value;
         if (!password) {
             showError("approve-tx-error", "Please enter your password.");
             return;
         }
         hideError("approve-tx-error");
-        $("btn-approve-tx").disabled = true;
-        $("btn-approve-tx").classList.add("text-muted");
+        setTxButtonBusy(true);
 
-        runtime.sendMessage(
-            {
-                type: "AUTISTMASK_TX_RESPONSE",
-                id: approvalId,
-                approved: true,
-                // TODO(security): Move decryption to popup to avoid sending password via runtime.sendMessage
-                password: password,
-            },
-            (response) => {
-                if (response && response.txHash) {
-                    txStatus.showWait(pendingTxDetails, response.txHash);
-                } else {
-                    const msg =
-                        (response && response.error) || "Transaction failed.";
-                    txStatus.showError(pendingTxDetails, null, msg);
-                }
-            },
-        );
+        const active = findActiveWallet();
+        if (!active) {
+            password = null;
+            showError(
+                "approve-tx-error",
+                "No wallet was found for the active address.",
+            );
+            setTxButtonBusy(false);
+            return;
+        }
+
+        // Decrypt here, in the popup. The password must never cross the
+        // extension messaging boundary; only the signed transaction does.
+        let decryptedSecret;
+        try {
+            decryptedSecret = await decryptWithPassword(
+                active.wallet.encryptedSecret,
+                password,
+            );
+        } catch {
+            showError(
+                "approve-tx-error",
+                "That password is incorrect. Please try again.",
+            );
+            setTxButtonBusy(false);
+            return;
+        } finally {
+            // Best-effort: drop the password as soon as the key derivation
+            // is done. Note that JS strings are immutable; this clears the
+            // reference but the original string may persist until GC.
+            password = null;
+        }
+
+        const payload = {
+            type: "AUTISTMASK_TX_RESPONSE",
+            id: approvalId,
+            approved: true,
+        };
+        try {
+            const signer = getSignerForAddress(
+                active.wallet,
+                active.addrIndex,
+                decryptedSecret,
+            );
+            const provider = getProvider(state.rpcUrl);
+            const connected = signer.connect(provider);
+            // This is the sequence ethers' own sendTransaction() runs
+            // internally, so nonce, gas, fee and chain id population are
+            // identical to when the background did the signing.
+            const populated =
+                await connected.populateTransaction(pendingTxParams);
+            delete populated.from;
+            payload.rawSignedTx = await connected.signTransaction(populated);
+        } catch (e) {
+            payload.error =
+                e.shortMessage || e.message || "Transaction signing failed.";
+        } finally {
+            // Best-effort: clear the decrypted secret after use, with the
+            // same immutability caveat as the password above.
+            decryptedSecret = null;
+        }
+
+        runtime.sendMessage(payload, (response) => {
+            if (response && response.txHash) {
+                txStatus.showWait(pendingTxDetails, response.txHash);
+            } else {
+                const msg =
+                    (response && response.error) || "Transaction failed.";
+                txStatus.showError(pendingTxDetails, null, msg);
+            }
+        });
     });
 
     $("btn-reject-tx").addEventListener("click", () => {
@@ -469,36 +563,93 @@ function init(ctx) {
         window.close();
     });
 
-    $("btn-approve-sign").addEventListener("click", () => {
-        const password = $("approve-sign-password").value;
+    $("btn-approve-sign").addEventListener("click", async () => {
+        let password = $("approve-sign-password").value;
         if (!password) {
             showError("approve-sign-error", "Please enter your password.");
             return;
         }
         hideError("approve-sign-error");
-        $("btn-approve-sign").disabled = true;
-        $("btn-approve-sign").classList.add("text-muted");
+        setSignButtonBusy(true);
 
-        runtime.sendMessage(
-            {
-                type: "AUTISTMASK_SIGN_RESPONSE",
-                id: approvalId,
-                approved: true,
-                // TODO(security): Move decryption to popup to avoid sending password via runtime.sendMessage
-                password: password,
-            },
-            (response) => {
-                if (response && response.signature) {
-                    window.close();
-                } else {
-                    const msg =
-                        (response && response.error) || "Signing failed.";
-                    showError("approve-sign-error", msg);
-                    $("btn-approve-sign").disabled = false;
-                    $("btn-approve-sign").classList.remove("text-muted");
-                }
-            },
-        );
+        const active = findActiveWallet();
+        if (!active) {
+            password = null;
+            showError(
+                "approve-sign-error",
+                "No wallet was found for the active address.",
+            );
+            setSignButtonBusy(false);
+            return;
+        }
+
+        // Decrypt here, in the popup. The password must never cross the
+        // extension messaging boundary; only the signature does.
+        let decryptedSecret;
+        try {
+            decryptedSecret = await decryptWithPassword(
+                active.wallet.encryptedSecret,
+                password,
+            );
+        } catch {
+            showError(
+                "approve-sign-error",
+                "That password is incorrect. Please try again.",
+            );
+            setSignButtonBusy(false);
+            return;
+        } finally {
+            // Best-effort: drop the password as soon as the key derivation
+            // is done. Note that JS strings are immutable; this clears the
+            // reference but the original string may persist until GC.
+            password = null;
+        }
+
+        const payload = {
+            type: "AUTISTMASK_SIGN_RESPONSE",
+            id: approvalId,
+            approved: true,
+        };
+        try {
+            const signer = getSignerForAddress(
+                active.wallet,
+                active.addrIndex,
+                decryptedSecret,
+            );
+            const sp = pendingSignParams;
+            if (sp.method === "personal_sign" || sp.method === "eth_sign") {
+                payload.signature = await signer.signMessage(
+                    getBytes(sp.message),
+                );
+            } else {
+                // eth_signTypedData_v4 / eth_signTypedData
+                const typedData = JSON.parse(sp.typedData);
+                const { domain, types, message } = typedData;
+                // ethers handles EIP712Domain internally
+                delete types.EIP712Domain;
+                payload.signature = await signer.signTypedData(
+                    domain,
+                    types,
+                    message,
+                );
+            }
+        } catch (e) {
+            payload.error = e.shortMessage || e.message || "Signing failed.";
+        } finally {
+            // Best-effort: clear the decrypted secret after use, with the
+            // same immutability caveat as the password above.
+            decryptedSecret = null;
+        }
+
+        runtime.sendMessage(payload, (response) => {
+            if (response && response.signature) {
+                window.close();
+            } else {
+                const msg = (response && response.error) || "Signing failed.";
+                showError("approve-sign-error", msg);
+                setSignButtonBusy(false);
+            }
+        });
     });
 
     $("btn-reject-sign").addEventListener("click", () => {