clightning-dumpkeys.c

#include "short_types.h"
#include "hkdf.h"
#include "compiler.h"
#include "secp256k1.h"
#include "bip32.h"
#include "hash.h"
#include "base58.h"
#include "descriptor.h"

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <fcntl.h>
#include <errno.h>
#include <assert.h>

#define BIP32_ENTROPY_LEN_256 32

#define fatal(fmt, ...) do { fprintf(stderr, fmt "\n", __VA_ARGS__); exit(1); } while (0)
#define fatal1(...) do { fprintf(stderr, __VA_ARGS__); exit(1); } while (0)

enum networks {
	mainnet,
	testnet
};

/* General 256-bit secret, which must be private.  Used in various places. */
struct secret {
	u8 data[32];
};

static struct {
	struct secret hsm_secret;
	struct ext_key master;
	struct ext_key parent_ext;
	struct ext_key child_ext;
} secretstuff;


struct bip32_key_version {
	u32 bip32_pubkey_version;
	u32 bip32_privkey_version;
};



/* Version codes for BIP32 extended keys in libwally-core.
 * It's not suitable to add this struct into client struct,
 * so set it static.*/
static struct  bip32_key_version  bip32_key_version;

bool read_all(int fd, void *data, size_t size)
{
	while (size) {
		ssize_t done;

		done = read(fd, data, size);
		if (done < 0 && errno == EINTR)
			continue;
		if (done <= 0)
			return false;
		data = (char *)data + done;
		size -= done;
	}

	return true;
}



static void populate_secretstuff(enum networks network)
{
	u8 bip32_seed[BIP32_ENTROPY_LEN_256];
	u32 salt = 0;
	/* struct ext_key master_extkey, child_extkey; */
	const u32 flags = SECP256K1_CONTEXT_VERIFY | SECP256K1_CONTEXT_SIGN;
	secp256k1_context *ctx = secp256k1_context_create(flags);

	if (network == mainnet) {
		bip32_key_version = (struct bip32_key_version) {
			.bip32_pubkey_version = BIP32_VER_MAIN_PUBLIC,
			.bip32_privkey_version = BIP32_VER_MAIN_PRIVATE
		};
	} else {
		bip32_key_version = (struct bip32_key_version) {
			.bip32_pubkey_version = BIP32_VER_TEST_PUBLIC,
			.bip32_privkey_version = BIP32_VER_TEST_PRIVATE
		};
	}

	assert(bip32_key_version.bip32_pubkey_version == BIP32_VER_MAIN_PUBLIC
			|| bip32_key_version.bip32_pubkey_version == BIP32_VER_TEST_PUBLIC);

	assert(bip32_key_version.bip32_privkey_version == BIP32_VER_MAIN_PRIVATE
			|| bip32_key_version.bip32_privkey_version == BIP32_VER_TEST_PRIVATE);

	/* Fill in the BIP32 tree for bitcoin addresses. */
	/* In libwally-core, the version BIP32_VER_TEST_PRIVATE is for testnet/regtest,
	 * and BIP32_VER_MAIN_PRIVATE is for mainnet. For litecoin, we also set it like
	 * bitcoin else.*/
	do {
		hkdf_sha256(bip32_seed, sizeof(bip32_seed),
			    &salt, sizeof(salt),
			    &secretstuff.hsm_secret,
			    sizeof(secretstuff.hsm_secret),
			    "bip32 seed", strlen("bip32 seed"));
		salt++;
	} while (bip32_key_from_seed(ctx, bip32_seed, sizeof(bip32_seed),
				     bip32_key_version.bip32_privkey_version,
				     0, &secretstuff.master) != WALLY_OK);

	/* BIP 32:
	 *
	 * The default wallet layout
	 *
	 * An HDW is organized as several 'accounts'. Accounts are numbered,
	 * the default account ("") being number 0. Clients are not required
	 * to support more than one account - if not, they only use the
	 * default account.
	 *
	 * Each account is composed of two keypair chains: an internal and an
	 * external one. The external keychain is used to generate new public
	 * addresses, while the internal keychain is used for all other
	 * operations (change addresses, generation addresses, ..., anything
	 * that doesn't need to be communicated). Clients that do not support
	 * separate keychains for these should use the external one for
	 * everything.
	 *
	 *  - m/iH/0/k corresponds to the k'th keypair of the external chain of
	 * account number i of the HDW derived from master m.
	 */
	/* Hence child 0, then child 0 again to get extkey to derive from. */
	if (bip32_key_from_parent(ctx, &secretstuff.master, 0,
				  BIP32_FLAG_KEY_PRIVATE,
				  &secretstuff.child_ext) != WALLY_OK)
		/*~ status_failed() is a helper which exits and sends lightningd
		 * a message about what happened.  For hsmd, that's fatal to
		 * lightningd. */
		fatal1("Can't derive child bip32 key");

	if (bip32_key_from_parent(ctx, &secretstuff.child_ext, 0,
				  BIP32_FLAG_KEY_PRIVATE,
				  &secretstuff.parent_ext) != WALLY_OK)
		fatal1("Can't derive private bip32 key");
}

static void load_hsm(const char *secretfile, enum networks network)
{
	int fd = open(secretfile ? secretfile : "hsm_secret", O_RDONLY);
	if (fd < 0)
		fatal("opening: %s", strerror(errno));
	if (!read_all(fd, &secretstuff.hsm_secret, sizeof(secretstuff.hsm_secret)))
		fatal("reading: %s", strerror(errno));
	close(fd);

	populate_secretstuff(network);
}

static int wally_free_string(char *str)
{
	if (!str)
		return WALLY_EINVAL;
	wally_clear(str, strlen(str));
	free(str);
	return WALLY_OK;
}

static inline size_t hex_str_size(size_t bytes)
{
	return 2 * bytes + 1;
}


static char hexchar(unsigned int val)
{
	if (val < 10)
		return '0' + val;
	if (val < 16)
		return 'a' + val - 10;
	abort();
}

UNUSED static bool hex_encode(const void *buf, size_t bufsize, char *dest,
		       size_t destsize)
{
	size_t i;

	if (destsize < hex_str_size(bufsize))
		return false;

	for (i = 0; i < bufsize; i++) {
		unsigned int c = ((const unsigned char *)buf)[i];
		*(dest++) = hexchar(c >> 4);
		*(dest++) = hexchar(c & 0xF);
	}
	*dest = '\0';

	return true;
}

static void print_key(struct ext_key *key, const char *name, int key_type,
		      const char *key_type_name) {
	static u8 buf[128];
	static char cbuf[512];
	static char cbuf2[512];
	char *out;

	int ret = bip32_key_serialize(key, key_type, buf, BIP32_SERIALIZED_LEN);

	assert(ret == WALLY_OK);

	wally_base58_from_bytes(buf, BIP32_SERIALIZED_LEN,
				BASE58_FLAG_CHECKSUM, &out);

	printf("%s\t%s %s\n", out, name, key_type_name);

	if (!streq(name, "root")) {
		snprintf(cbuf, sizeof(cbuf), "combo(%s/*)", out);
		descriptor_checksum(cbuf, strlen(cbuf), cbuf2, sizeof(cbuf2));

		printf("%s#%s\t%s %s descriptor\n", cbuf, cbuf2, name, key_type_name);
	}
	wally_free_string(out);

}

static void dump_bip32(struct ext_key *key, const char *name) {
	print_key(key, name, BIP32_FLAG_KEY_PRIVATE, "private");
	print_key(key, name, BIP32_FLAG_KEY_PUBLIC, "public");
}

static int dump_xpriv(const char *secretfile, enum networks network) {

	if (network == mainnet) {
		bip32_key_version = (struct bip32_key_version)
			{   .bip32_pubkey_version  = BIP32_VER_MAIN_PUBLIC
			  , .bip32_privkey_version = BIP32_VER_MAIN_PRIVATE
			};
	} else {
		bip32_key_version = (struct bip32_key_version)
			{   .bip32_pubkey_version  = BIP32_VER_TEST_PUBLIC
			  , .bip32_privkey_version = BIP32_VER_TEST_PRIVATE
			};
	}

	load_hsm(secretfile, network);

	dump_bip32(&secretstuff.master, "root");
	printf("\n");
	dump_bip32(&secretstuff.parent_ext, "extended");
	/* printf("\n"); */
	/* dump_bip32(&secretstuff.child_ext, "extended internal"); */


	return 0;
}

void usage()
{
	fprintf(stderr, "usage: clightning-dumpkeys <hsmd_secretfile> [--testnet]\n");
	exit(42);
}

int main(int argc, char *argv[])
{
	if (argc != 2 && argc != 3)
		usage();

	enum networks network = mainnet;
	if (argc == 3) {
		if (strcmp(argv[2], "--testnet") == 0) {
			network = testnet;
		} else {
			usage();
		}
	}

	const char *secretfile = argv[1];

	dump_xpriv(secretfile, network);

	return 0;
}