multi: add unit tests

Author: guggero

btc/bip39.go

@@ -6,28 +6,42 @@ import (
 	"encoding/hex"
 	"errors"
 	"fmt"
-	"os"
-	"strings"
-	"syscall"
-
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/btcsuite/btcutil/hdkeychain"
 	"github.com/guggero/chantools/bip39"
 	"golang.org/x/crypto/pbkdf2"
 	"golang.org/x/crypto/ssh/terminal"
+	"os"
+	"strings"
+	"syscall"
+)
+
+const (
+	BIP39MnemonicEnvName   = "SEED_MNEMONIC"
+	BIP39PassphraseEnvName = "SEED_PASSPHRASE"
 )
 
 func ReadMnemonicFromTerminal(params *chaincfg.Params) (*hdkeychain.ExtendedKey,
 	error) {
 
-	// We'll now prompt the user to enter in their 12 to 24 word mnemonic.
-	fmt.Printf("Input your 12 to 24 word mnemonic separated by spaces: ")
+	var err error
 	reader := bufio.NewReader(os.Stdin)
-	mnemonicStr, err := reader.ReadString('\n')
-	if err != nil {
-		return nil, err
+
+	// To automate things with chantools, we also offer reading the seed
+	// from environment variables.
+	mnemonicStr := strings.TrimSpace(os.Getenv(BIP39MnemonicEnvName))
+
+	if mnemonicStr == "" {
+		// If there's no value in the environment, we'll now prompt the
+		//user to enter in their 12 to 24 word mnemonic.
+		fmt.Printf("Input your 12 to 24 word mnemonic separated by " +
+			"spaces: ")
+		mnemonicStr, err = reader.ReadString('\n')
+		if err != nil {
+			return nil, err
+		}
+		fmt.Println()
 	}
-	fmt.Println()
 
 	// We'll trim off extra spaces, and ensure the mnemonic is all
 	// lower case.
@@ -40,62 +54,87 @@ func ReadMnemonicFromTerminal(params *chaincfg.Params) (*hdkeychain.ExtendedKey,
 			"must be between 12 and 24 words")
 	}
 
-	// Additionally, the user may have a passphrase, that will also
-	// need to be provided so the daemon can properly decipher the
-	// cipher seed.
-	fmt.Printf("Input your cipher seed passphrase (press enter if " +
-		"your seed doesn't have a passphrase): ")
-	passphrase, err := terminal.ReadPassword(int(syscall.Stdin)) // nolint
-	if err != nil {
-		return nil, err
-	}
-	fmt.Println()
+	// Additionally, the user may have a passphrase, that will also need to
+	// be provided so the daemon can properly decipher the cipher seed.
+	// Try the environment variable first.
+	passphrase := strings.TrimSpace(os.Getenv(BIP39PassphraseEnvName))
 
-	// Check that the mnemonic is valid.
-	_, err = bip39.EntropyFromMnemonic(mnemonicStr)
-	if err != nil {
-		return nil, err
-	}
+	// Because we cannot differentiate between an empty and a non-existent
+	// environment variable, we need a special character that indicates that
+	// no passphrase should be used. We use a single dash (-) for that as
+	// that would be too short for a passphrase anyway.
+	var (
+		passphraseBytes []byte
+		seed            []byte
+		choice          string
+	)
+	switch {
+	// The user indicated in the environment variable that no passphrase
+	// should be used. We don't set any value.
+	case passphrase == "-":
 
-	var seed []byte
-	fmt.Printf("Please choose passphrase mode:\n" +
-		"  0 - Default BIP39\n" +
-		"  1 - Passphrase to hex\n" +
-		"  2 - Digital Bitbox (extra round of PBKDF2)\n" +
-		"\n" +
-		"Choice [default 0]: ")
-	choice, err := reader.ReadString('\n')
-	if err != nil {
-		return nil, err
+	// The environment variable didn't contain anything, we'll read the
+	// passphrase from the terminal.
+	case passphrase == "":
+		// Additionally, the user may have a passphrase, that will also
+		// need to be provided so the daemon can properly decipher the
+		// cipher seed.
+		fmt.Printf("Input your cipher seed passphrase (press enter " +
+			"if your seed doesn't have a passphrase): ")
+		passphraseBytes, err = terminal.ReadPassword(
+			int(syscall.Stdin), // nolint
+		)
+		if err != nil {
+			return nil, err
+		}
+		fmt.Println()
+
+		// Check that the mnemonic is valid.
+		_, err = bip39.EntropyFromMnemonic(mnemonicStr)
+		if err != nil {
+			return nil, err
+		}
+
+		fmt.Printf("Please choose passphrase mode:\n" +
+			"  0 - Default BIP39\n" +
+			"  1 - Passphrase to hex\n" +
+			"  2 - Digital Bitbox (extra round of PBKDF2)\n" +
+			"\n" +
+			"Choice [default 0]: ")
+		choice, err = reader.ReadString('\n')
+		if err != nil {
+			return nil, err
+		}
+		fmt.Println()
+
+	// There was a password in the environment, just convert it to bytes.
+	default:
+		passphraseBytes = []byte(passphrase)
 	}
-	fmt.Println()
 
 	switch strings.TrimSpace(choice) {
 	case "", "0":
 		seed = pbkdf2.Key(
 			[]byte(mnemonicStr), append(
-				[]byte("mnemonic"), passphrase...,
+				[]byte("mnemonic"), passphraseBytes...,
 			), 2048, 64, sha512.New,
 		)
 
 	case "1":
-		passphrase = []byte(hex.EncodeToString(passphrase))
+		p := []byte(hex.EncodeToString(passphraseBytes))
 		seed = pbkdf2.Key(
-			[]byte(mnemonicStr), append(
-				[]byte("mnemonic"), passphrase...,
-			), 2048, 64, sha512.New,
+			[]byte(mnemonicStr), append([]byte("mnemonic"), p...),
+			2048, 64, sha512.New,
 		)
 
 	case "2":
-		passphrase = pbkdf2.Key(
-			passphrase, []byte("Digital Bitbox"), 20480, 64,
+		p := hex.EncodeToString(pbkdf2.Key(
+			passphraseBytes, []byte("Digital Bitbox"), 20480, 64,
 			sha512.New,
-		)
-		passphrase = []byte(hex.EncodeToString(passphrase))
+		))
 		seed = pbkdf2.Key(
-			[]byte(mnemonicStr), append(
-				[]byte("mnemonic"), passphrase...,
-			), 2048, 64, sha512.New,
+			[]byte(mnemonicStr), append([]byte("mnemonic"), p...),
+			2048, 64, sha512.New,
 		)
 
 	default:

cmd/chantools/chanbackup_test.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+const (
+	backupContent = "FundingOutpoint: (string) (len=66) \"10279f626196340" +
+		"58b6133cb7ac6c1693a8e6df7caa91c6263ca3d0bf704ad4d:0\""
+)
+
+func TestChanBackupAndDumpBackup(t *testing.T) {
+	h := newHarness(t)
+
+	// Create a channel backup from a channel DB file.
+	makeBackup := &chanBackupCommand{
+		ChannelDB: h.testdataFile("channel.db"),
+		MultiFile: h.tempFile("extracted.backup"),
+		rootKey:   &rootKey{RootKey: rootKeyAezeed},
+	}
+
+	err := makeBackup.Execute(nil, nil)
+	require.NoError(t, err)
+
+	// Decrypt and dump the channel backup file.
+	dumpBackup := &dumpBackupCommand{
+		MultiFile: makeBackup.MultiFile,
+		rootKey:   &rootKey{RootKey: rootKeyAezeed},
+	}
+
+	err = dumpBackup.Execute(nil, nil)
+	require.NoError(t, err)
+
+	h.assertLogContains(backupContent)
+}

cmd/chantools/compactdb.go

@@ -64,10 +64,14 @@ func (c *compactDBCommand) Execute(_ *cobra.Command, _ []string) error {
 	if err != nil {
 		return fmt.Errorf("error opening source DB: %v", err)
 	}
+	defer func() { _ = src.Close() }()
+
 	dst, err := c.openDB(c.DestDB, false)
 	if err != nil {
 		return fmt.Errorf("error opening destination DB: %v", err)
 	}
+	defer func() { _ = dst.Close() }()
+
 	err = c.compact(dst, src)
 	if err != nil {
 		return fmt.Errorf("error compacting DB: %v", err)

cmd/chantools/compactdb_test.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestCompactDBAndDumpChannels(t *testing.T) {
+	h := newHarness(t)
+
+	// Compact the test DB.
+	compact := &compactDBCommand{
+		SourceDB: h.testdataFile("channel.db"),
+		DestDB:   h.tempFile("compacted.db"),
+	}
+
+	err := compact.Execute(nil, nil)
+	require.NoError(t, err)
+
+	require.FileExists(t, compact.DestDB)
+
+	// Compacting small DBs actually increases the size slightly. But we
+	// just want to make sure the contents match.
+	require.GreaterOrEqual(
+		t, h.fileSize(compact.DestDB), h.fileSize(compact.SourceDB),
+	)
+
+	// Compare the content of the source and destination DB by looking at
+	// the logged dump.
+	dump := &dumpChannelsCommand{
+		ChannelDB: compact.SourceDB,
+	}
+	h.clearLog()
+	err = dump.Execute(nil, nil)
+	require.NoError(t, err)
+	sourceDump := h.getLog()
+
+	h.clearLog()
+	dump.ChannelDB = compact.DestDB
+	err = dump.Execute(nil, nil)
+	require.NoError(t, err)
+	destDump := h.getLog()
+
+	h.assertLogEqual(sourceDump, destDump)
+}

cmd/chantools/derivekey.go

@@ -2,15 +2,24 @@ package main
 
 import (
 	"fmt"
-
 	"github.com/btcsuite/btcutil"
 	"github.com/btcsuite/btcutil/hdkeychain"
 	"github.com/guggero/chantools/lnd"
 	"github.com/spf13/cobra"
 )
 
+const deriveKeyFormat = `
+Path:				%s
+Network: 			%s
+Public key: 			%x
+Extended public key (xpub): 	%v
+Address: 			%v
+Legacy address: 		%v
+Private key (WIF): 		%s
+Extended private key (xprv):	%s
+`
+
 type deriveKeyCommand struct {
-	BIP39  bool
 	Path   string
 	Neuter bool
 
@@ -29,11 +38,6 @@ derivation path from the root key and prints it to the console.`,
 	--path "m/1017'/0'/5'/0/0'" --neuter`,
 		RunE: cc.Execute,
 	}
-	cc.cmd.Flags().BoolVar(
-		&cc.BIP39, "bip39", false, "read a classic BIP39 seed and "+
-			"passphrase from the terminal instead of asking for "+
-			"lnd seed format or providing the --rootkey flag",
-	)
 	cc.cmd.Flags().StringVar(
 		&cc.Path, "path", "", "BIP32 derivation path to derive; must "+
 			"start with \"m/\"",
@@ -60,7 +64,6 @@ func (c *deriveKeyCommand) Execute(_ *cobra.Command, _ []string) error {
 func deriveKey(extendedKey *hdkeychain.ExtendedKey, path string,
 	neuter bool) error {
 
-	fmt.Printf("Deriving path %s for network %s.\n", path, chainParams.Name)
 	child, pubKey, wif, err := lnd.DeriveKey(extendedKey, path, chainParams)
 	if err != nil {
 		return fmt.Errorf("could not derive keys: %v", err)
@@ -69,8 +72,6 @@ func deriveKey(extendedKey *hdkeychain.ExtendedKey, path string,
 	if err != nil {
 		return fmt.Errorf("could not neuter child key: %v", err)
 	}
-	fmt.Printf("\nPublic key: %x\n", pubKey.SerializeCompressed())
-	fmt.Printf("Extended public key (xpub): %s\n", neutered.String())
 
 	// Print the address too.
 	hash160 := btcutil.Hash160(pubKey.SerializeCompressed())
@@ -84,13 +85,21 @@ func deriveKey(extendedKey *hdkeychain.ExtendedKey, path string,
 	if err != nil {
 		return fmt.Errorf("could not create address: %v", err)
 	}
-	fmt.Printf("Address: %s\n", addrP2WKH)
-	fmt.Printf("Legacy address: %s\n", addrP2PKH)
 
+	privKey, xPriv := "n/a", "n/a"
 	if !neuter {
-		fmt.Printf("\nPrivate key (WIF): %s\n", wif.String())
-		fmt.Printf("Extended private key (xprv): %s\n", child.String())
+		privKey, xPriv = wif.String(), child.String()
 	}
 
+	result := fmt.Sprintf(
+		deriveKeyFormat, path, chainParams.Name,
+		pubKey.SerializeCompressed(), neutered, addrP2WKH, addrP2PKH,
+		privKey, xPriv,
+	)
+	fmt.Printf(result)
+
+	// For the tests, also log as trace level which is disabled by default.
+	log.Tracef(result)
+
 	return nil
 }