exposesecret: Add support for mnemonic-based HSM secrets

Update the exposesecret plugin to work with the new unified HSM secret
format that supports BIP39 mnemonics.

Author: sangbida

external/libbacktrace

@@ -507,7 +507,7 @@ static struct io_plan *init_hsm(struct io_conn *conn,
 				const u8 *msg_in)
 {
 	struct secret *hsm_encryption_key;
-	const char *hsm_passphrase;
+	const char *hsm_passphrase = NULL;  /* Initialize to NULL */
 	struct bip32_key_version bip32_key_version;
 	u32 minversion, maxversion;
 	const u32 our_minversion = 4, our_maxversion = 6;

hsmd/hsmd.c

@@ -237,7 +237,7 @@ plugins/topology: common/route.o common/dijkstra.o common/gossmap.o common/scidd
 
 plugins/txprepare: $(PLUGIN_TXPREPARE_OBJS) $(PLUGIN_LIB_OBJS) $(PLUGIN_COMMON_OBJS) $(JSMN_OBJS)
 
-plugins/exposesecret: $(PLUGIN_EXPOSESECRET_OBJS) $(PLUGIN_LIB_OBJS) $(PLUGIN_COMMON_OBJS) $(JSMN_OBJS) common/hsm_encryption.o common/codex32.o
+plugins/exposesecret: $(PLUGIN_EXPOSESECRET_OBJS) $(PLUGIN_LIB_OBJS) $(PLUGIN_COMMON_OBJS) $(JSMN_OBJS) common/hsm_secret.o common/codex32.o
 
 plugins/bcli: $(PLUGIN_BCLI_OBJS) $(PLUGIN_LIB_OBJS) $(PLUGIN_COMMON_OBJS) $(JSMN_OBJS)
 

plugins/Makefile

@@ -2,13 +2,17 @@
 #include <bitcoin/privkey.h>
 #include <ccan/array_size/array_size.h>
 #include <ccan/crypto/hkdf_sha256/hkdf_sha256.h>
+#include <common/setup.h>
+#include <common/utils.h>
 #include <ccan/crypto/sha256/sha256.h>
 #include <ccan/tal/grab_file/grab_file.h>
 #include <ccan/tal/str/str.h>
 #include <common/bech32.h>
 #include <common/codex32.h>
+#include <common/hsm_secret.h>
 #include <common/json_param.h>
 #include <common/json_stream.h>
+#include <common/setup.h>
 #include <errno.h>
 #include <plugins/libplugin.h>
 
@@ -46,8 +50,9 @@ static struct command_result *json_exposesecret(struct command *cmd,
 	const struct exposesecret *exposesecret = exposesecret_data(cmd->plugin);
 	struct json_stream *js;
 	u8 *contents;
-	const char *id, *passphrase, *err;
-	struct secret hsm_secret;
+	const char *id, *passphrase;
+	enum hsm_secret_error err;
+	struct hsm_secret *hsms;
 	struct privkey node_privkey;
 	struct pubkey node_id;
 	char *bip93;
@@ -71,17 +76,30 @@ static struct command_result *json_exposesecret(struct command *cmd,
 		return command_fail(cmd, LIGHTNINGD, "Could not open hsm_secret: %s", strerror(errno));
 
 	/* grab_file adds a \0 byte at the end for convenience */
-	if (tal_bytelen(contents) == sizeof(hsm_secret) + 1) {
-		memcpy(&hsm_secret, contents, sizeof(hsm_secret));
-	} else {
-		return command_fail(cmd, LIGHTNINGD, "Not a valid hsm_secret file?  Bad length (maybe encrypted?)");
+	if (tal_bytelen(contents) > 0)
+		tal_resize(&contents, tal_bytelen(contents) - 1);
+	
+	/* Check if the HSM secret needs a passphrase */
+	if (hsm_secret_needs_passphrase(contents, tal_bytelen(contents))) {
+		plugin_log(cmd->plugin, LOG_INFORM, "Secret with passphrase is not supported");
+		return command_fail(cmd, LIGHTNINGD, "Secret with passphrase is not supported");
 	}
+	
+	/* Extract the HSM secret without passphrase */
+	tal_wally_start();
+	hsms = extract_hsm_secret(tmpctx, contents, tal_bytelen(contents), NULL, &err);
+	tal_wally_end(tmpctx);
+
+	if (!hsms)
+		return command_fail(cmd, LIGHTNINGD, "Could not parse hsm_secret: %s", hsm_secret_error_str(err));
+
+	plugin_log(cmd->plugin, LOG_INFORM, "hsms->type: %d", hsms->type);
 
 	/* Before we expose it, check it's correct! */
 	hkdf_sha256(&node_privkey, sizeof(node_privkey),
 		    &salt, sizeof(salt),
-		    &hsm_secret,
-		    sizeof(hsm_secret),
+		    &hsms->secret,
+		    sizeof(hsms->secret),
 		    "nodeid", 6);
 
 	/* Should not happen! */
@@ -115,9 +133,9 @@ static struct command_result *json_exposesecret(struct command *cmd,
 	}
 
 	/* This also cannot fail! */
-	err = codex32_secret_encode(tmpctx, "cl", id, 0, hsm_secret.data, 32, &bip93);
-	if (err)
-		return command_fail(cmd, LIGHTNINGD, "Unexpected failure encoding hsm_secret: %s", err);
+	const char *encode_err = codex32_secret_encode(tmpctx, "cl", id, 0, hsms->secret.data, 32, &bip93);
+	if (encode_err)
+		return command_fail(cmd, LIGHTNINGD, "Unexpected failure encoding hsm_secret: %s", encode_err);
 
 	/* If we're just checking, stop */
 	if (command_check_only(cmd))
@@ -126,6 +144,8 @@ static struct command_result *json_exposesecret(struct command *cmd,
 	js = jsonrpc_stream_success(cmd);
 	json_add_string(js, "identifier", id);
 	json_add_string(js, "codex32", bip93);
+	if (hsms->mnemonic)
+		json_add_string(js, "mnemonic", hsms->mnemonic);
 	return command_finished(cmd, js);
 }
 

plugins/exposesecret.c

@@ -12,6 +12,7 @@
     check_coin_moves, first_channel_id, EXPERIMENTAL_DUAL_FUND,
     mine_funding_to_announce, VALGRIND
 )
+from tests.test_wallet import HsmTool, write_all, WAIT_TIMEOUT
 
 import ast
 import json
@@ -4141,7 +4142,6 @@ def test_important_plugin_shutdown(node_factory):
     l1.rpc.plugin_start(os.path.join(os.getcwd(), 'plugins/pay'))
 
 
-@pytest.mark.skip(reason="Temporarily disabled expose secrets test")
 @unittest.skipIf(VALGRIND, "It does not play well with prompt and key derivation.")
 def test_exposesecret(node_factory):
     l1, l2 = node_factory.get_nodes(2, opts=[{'exposesecret-passphrase': "test_exposesecret"}, {}])
@@ -4196,30 +4196,96 @@ def test_exposesecret(node_factory):
     l1.start()
 
     assert l1.rpc.exposesecret(passphrase='test_exposesecret') == {'codex32': 'cl10junxsd35kw6r5de5kueedxyqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq6mdtn5lql6p8m',
-                                                                   'identifier': 'junx'}
+                                                                       'identifier': 'junx'}
 
-    # Test with encrypted-hsm (fails!)
-    password = 'test_exposesecret'
-    l1.stop()
-    # We need to simulate a terminal to use termios in `lightningd`.
-    master_fd, slave_fd = os.openpty()
 
-    def write_all(fd, bytestr):
-        """Wrapper, since os.write can do partial writes"""
-        off = 0
-        while off < len(bytestr):
-            off += os.write(fd, bytestr[off:])
-
-    l1.daemon.opts.update({"encrypted-hsm": None})
-    l1.daemon.start(stdin=slave_fd, wait_for_initialized=False)
-    l1.daemon.wait_for_log(r'Enter hsm_secret password')
-    write_all(master_fd, (password + '\n').encode("utf-8"))
-    l1.daemon.wait_for_log(r'Confirm hsm_secret password')
-    write_all(master_fd, (password + '\n').encode("utf-8"))
+@unittest.skipIf(VALGRIND, "It does not play well with prompt and key derivation.")
+def test_exposesecret_with_hsm_passphrase(node_factory):
+    """Test that exposesecret plugin correctly handles hsm-passphrase option"""
+    # Create a node with exposesecret-passphrase option 
+    l1 = node_factory.get_node(options={
+        'exposesecret-passphrase': "test_exposesecret",
+    }, start=False)
+    
+    hsm_path = os.path.join(l1.daemon.lightning_dir, TEST_NETWORK, "hsm_secret")
+    if os.path.exists(hsm_path):
+        os.remove(hsm_path)
+
+    # Generate hsm_secret with mnemonic and passphrase using hsmtool
+    mnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about"
+    hsm_passphrase = "test_hsm_passphrase"  # Any passphrase, since we expect exposesecret to fail
+    expected_format = "mnemonic with passphrase"
+
+    hsmtool = HsmTool(node_factory.directory, "generatehsm", hsm_path)
+    master_fd, slave_fd = os.openpty()
+    hsmtool.start(stdin=slave_fd)
+    hsmtool.wait_for_log(r"Introduce your BIP39 word list")
+    write_all(master_fd, f"{mnemonic}\n".encode("utf-8"))
+    hsmtool.wait_for_log(r"Enter your passphrase:")
+    write_all(master_fd, f"{hsm_passphrase}\n".encode("utf-8"))
+    assert hsmtool.proc.wait(WAIT_TIMEOUT) == 0
+    hsmtool.is_in_log(r"New hsm_secret file created")
+    hsmtool.is_in_log(f"Format: {expected_format}")
+    os.close(master_fd)
+    os.close(slave_fd)
+    
+    # Add --hsm-passphrase option to trigger interactive prompting
+    l1.daemon.opts["hsm-passphrase"] = None
+    
+    # Create a pty to handle the interactive passphrase prompt
+    master_fd2, slave_fd2 = os.openpty()
+    l1.daemon.start(stdin=slave_fd2, wait_for_initialized=False)
+    
+    # Wait for the passphrase prompt and provide it
+    l1.daemon.wait_for_log("Enter hsm_secret passphrase:")
+    print(f"DEBUG: About to send passphrase: '{hsm_passphrase}'")
+    passphrase_bytes = f"{hsm_passphrase}\n".encode("utf-8")
+    print(f"DEBUG: Passphrase bytes: {passphrase_bytes}")
+    write_all(master_fd2, passphrase_bytes)
+    print("DEBUG: Passphrase sent!")
+    
+    # Wait for the node to be ready
     l1.daemon.wait_for_log("Server started with public key")
+    
+    os.close(master_fd2)
+    os.close(slave_fd2)
+    
+    # Test that exposesecret fails with mnemonic+passphrase format since it needs a passphrase
+    with pytest.raises(RpcError, match="Secret with passphrase is not supported"):
+        l1.rpc.exposesecret(passphrase="test_exposesecret")
+
+
+@unittest.skipIf(VALGRIND, "It does not play well with prompt and key derivation.")
+def test_exposesecret_with_mnemonic_no_passphrase(node_factory):
+    """Test that exposesecret plugin works correctly with mnemonic-based hsm_secret without passphrase"""
+    # Create a node with exposesecret-passphrase option
+    l1 = node_factory.get_node(options={
+        'exposesecret-passphrase': "test_exposesecret",
+    }, start=False)
+    hsm_path = os.path.join(l1.daemon.lightning_dir, TEST_NETWORK, "hsm_secret")
+    if os.path.exists(hsm_path):
+        os.remove(hsm_path)
+
+    # Generate hsm_secret with mnemonic and no passphrase using hsmtool
+    mnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about"
+    hsmtool = HsmTool(node_factory.directory, "generatehsm", hsm_path)
+    master_fd, slave_fd = os.openpty()
+    hsmtool.start(stdin=slave_fd)
+    hsmtool.wait_for_log(r"Introduce your BIP39 word list")
+    write_all(master_fd, f"{mnemonic}\n".encode("utf-8"))
+    hsmtool.wait_for_log(r"Enter your passphrase:")
+    write_all(master_fd, "\n".encode("utf-8"))
+    assert hsmtool.proc.wait(WAIT_TIMEOUT) == 0
+    
+    # Start the daemon normally (no hsm-passphrase option needed for mnemonic without passphrase)
+    l1.start()
+    
+    # Test that exposesecret works correctly with mnemonic-based hsm_secret without passphrase
+    result = l1.rpc.exposesecret(passphrase="test_exposesecret")
+    assert 'codex32' in result
+    assert 'identifier' in result
+    assert 'mnemonic' in result
 
-    with pytest.raises(RpcError, match="maybe encrypted"):
-        l1.rpc.exposesecret(passphrase=password)
 
 
 def test_peer_storage(node_factory, bitcoind):