htlcswitch/circuit_test: use circuit map config and test rextraction

htlcswitch/circuit_test.go

@@ -6,9 +6,12 @@ import (
 	"reflect"
 	"testing"
 
+	"github.com/lightningnetwork/lightning-onion"
 	"github.com/lightningnetwork/lnd/channeldb"
 	"github.com/lightningnetwork/lnd/htlcswitch"
 	"github.com/lightningnetwork/lnd/lnwire"
+	"github.com/roasbeef/btcd/btcec"
+	bitcoinCfg "github.com/roasbeef/btcd/chaincfg"
 	"github.com/roasbeef/btcutil"
 )
 
@@ -16,19 +19,114 @@ var (
 	hash1 = [32]byte{0x01}
 	hash2 = [32]byte{0x02}
 	hash3 = [32]byte{0x03}
+
+	// sphinxPrivKey is the private key given to freshly created sphinx
+	// routers.
+	sphinxPrivKey *btcec.PrivateKey
+
+	// testEphemeralKey is the ephemeral key that will be extracted to
+	// create onion obfuscators.
+	testEphemeralKey *btcec.PublicKey
+
+	// testExtracter is a precomputed extraction of testEphemeralKey, using
+	// the sphinxPrivKey.
+	testExtracter *htlcswitch.SphinxErrorEncrypter
 )
 
-func TestCircuitMapInit(t *testing.T) {
+func init() {
-	t.Parallel()
+	// Generate a fresh key for our sphinx router.
+	var err error
+	sphinxPrivKey, err = btcec.NewPrivateKey(btcec.S256())
+	if err != nil {
+		panic(err)
+	}
 
-	// Initialize new database for circuit map.
+	// And another, whose public key will serve as the test ephemeral key.
-	cdb := makeCircuitDB(t, "")
+	testEphemeralPriv, err := btcec.NewPrivateKey(btcec.S256())
-	_, err := htlcswitch.NewCircuitMap(cdb)
+	if err != nil {
+		panic(err)
+	}
+	testEphemeralKey = testEphemeralPriv.PubKey()
+
+	// Finally, properly initialize the test extracter
+	initTestExtracter()
+}
+
+// initTestExtracter spins up a new onion processor specifically for the purpose
+// of generating our testExtracter, which should be derived from the
+// testEphemeralKey, and which randomly-generated key is used to init the sphinx
+// router.
+//
+// NOTE: This should be called in init(), after testEphemeralKey has been
+// properly initialized.
+func initTestExtracter() {
+	onionProcessor := newOnionProcessor(nil)
+	defer onionProcessor.Stop()
+
+	obfuscator, _ := onionProcessor.ExtractErrorEncrypter(
+		testEphemeralKey,
+	)
+
+	sphinxExtracter, ok := obfuscator.(*htlcswitch.SphinxErrorEncrypter)
+	if !ok {
+		panic("did not extract sphinx error encrypter")
+	}
+
+	testExtracter = sphinxExtracter
+
+	// We also set this error extracter on startup, otherwise it will be nil
+	// at compile-time.
+	halfCircuitTests[2].encrypter = testExtracter
+}
+
+// newOnionProcessor creates starts a new htlcswitch.OnionProcessor using a temp
+// db and no garbage collection.
+func newOnionProcessor(t *testing.T) *htlcswitch.OnionProcessor {
+	sharedSecretFile, err := ioutil.TempFile("", "sphinxreplay.db")
+	if err != nil {
+		t.Fatalf("unable to create temp path: %v", err)
+	}
+
+	sharedSecretPath := sharedSecretFile.Name()
+
+	sphinxRouter := sphinx.NewRouter(
+		sharedSecretPath, sphinxPrivKey, &bitcoinCfg.SimNetParams, nil,
+	)
+
+	if err := sphinxRouter.Start(); err != nil {
+		t.Fatalf("unable to start sphinx router: %v", err)
+	}
+
+	return htlcswitch.NewOnionProcessor(sphinxRouter)
+}
+
+// newCircuitMap creates a new htlcswitch.CircuitMap using a temp db and a
+// fresh sphinx router.
+func newCircuitMap(t *testing.T) (*htlcswitch.CircuitMapConfig,
+	htlcswitch.CircuitMap) {
+
+	onionProcessor := newOnionProcessor(t)
+
+	circuitMapCfg := &htlcswitch.CircuitMapConfig{
+		DB: makeCircuitDB(t, ""),
+		ExtractErrorEncrypter: onionProcessor.ExtractErrorEncrypter,
+	}
+
+	circuitMap, err := htlcswitch.NewCircuitMap(circuitMapCfg)
 	if err != nil {
 		t.Fatalf("unable to create persistent circuit map: %v", err)
 	}
 
-	restartCircuitMap(t, cdb)
+	return circuitMapCfg, circuitMap
+}
+
+// TestCircuitMapInit is a quick check to ensure that we can start and restore
+// the circuit map, as this will be used extensively in this suite.
+func TestCircuitMapInit(t *testing.T) {
+	t.Parallel()
+
+	cfg, _ := newCircuitMap(t)
+	restartCircuitMap(t, cfg)
 }
 
 var halfCircuitTests = []struct {
@@ -56,12 +154,15 @@ var halfCircuitTests = []struct {
 		encrypter: htlcswitch.NewMockObfuscator(),
 	},
 	{
-		hash:      hash3,
+		hash:     hash3,
-		inValue:   10000,
+		inValue:  10000,
-		outValue:  9000,
+		outValue: 9000,
-		chanID:    lnwire.NewShortChanIDFromInt(3),
+		chanID:   lnwire.NewShortChanIDFromInt(3),
-		htlcID:    3,
+		htlcID:   3,
-		encrypter: htlcswitch.NewSphinxErrorEncrypter(),
+		// NOTE: The value of testExtracter is nil at compile-time, it
+		// is fully-initialized in initTestExtracter, which should
+		// repopulate this encrypter.
+		encrypter: testExtracter,
 	},
 }
 
@@ -72,6 +173,8 @@ var halfCircuitTests = []struct {
 func TestHalfCircuitSerialization(t *testing.T) {
 	t.Parallel()
 
+	onionProcessor := newOnionProcessor(t)
+
 	for i, test := range halfCircuitTests {
 		circuit := &htlcswitch.PaymentCircuit{
 			PaymentHash:    test.hash,
@@ -97,6 +200,20 @@ func TestHalfCircuitSerialization(t *testing.T) {
 			t.Fatalf("unable to decode half payment circuit test=%d: %v", i, err)
 		}
 
+		// If the error encrypter is initialized, we will need to
+		// reextract it from it's decoded state, as this requires an
+		// ECDH with the onion processor's private key. For mock error
+		// encrypters, this will be a NOP.
+		if circuit2.ErrorEncrypter != nil {
+			err := circuit2.ErrorEncrypter.Reextract(
+				onionProcessor.ExtractErrorEncrypter,
+			)
+			if err != nil {
+				t.Fatalf("unable to reextract sphinx error "+
+					"encrypter: %v", err)
+			}
+		}
+
 		// Reconstructed half circuit should match the original.
 		if !equalIgnoreLFD(circuit, &circuit2) {
 			t.Fatalf("unexpected half circuit test=%d, want %v, got %v",
@@ -115,11 +232,7 @@ func TestCircuitMapPersistence(t *testing.T) {
 		err        error
 	)
 
-	cdb := makeCircuitDB(t, "")
+	cfg, circuitMap := newCircuitMap(t)
-	circuitMap, err = htlcswitch.NewCircuitMap(cdb)
-	if err != nil {
-		t.Fatalf("unable to create persistent circuit map: %v", err)
-	}
 
 	circuit := circuitMap.LookupCircuit(htlcswitch.CircuitKey{chan1, 0})
 	if circuit != nil {
@@ -143,7 +256,7 @@ func TestCircuitMapPersistence(t *testing.T) {
 	assertNumCircuitsWithHash(t, circuitMap, hash1, 0)
 	assertHasCircuit(t, circuitMap, circuit1)
 
-	cdb, circuitMap = restartCircuitMap(t, cdb)
+	cfg, circuitMap = restartCircuitMap(t, cfg)
 
 	assertNumCircuitsWithHash(t, circuitMap, hash1, 0)
 	assertHasCircuit(t, circuitMap, circuit1)
@@ -168,7 +281,7 @@ func TestCircuitMapPersistence(t *testing.T) {
 	assertHasCircuit(t, circuitMap, circuit1)
 	assertHasKeystone(t, circuitMap, keystone1.OutKey, circuit1)
 
-	cdb, circuitMap = restartCircuitMap(t, cdb)
+	cfg, circuitMap = restartCircuitMap(t, cfg)
 
 	assertNumCircuitsWithHash(t, circuitMap, hash1, 1)
 	assertHasCircuit(t, circuitMap, circuit1)
@@ -213,7 +326,7 @@ func TestCircuitMapPersistence(t *testing.T) {
 
 	assertNumCircuitsWithHash(t, circuitMap, hash3, 0)
 
-	cdb, circuitMap = restartCircuitMap(t, cdb)
+	cfg, circuitMap = restartCircuitMap(t, cfg)
 
 	assertNumCircuitsWithHash(t, circuitMap, hash1, 1)
 	assertHasCircuit(t, circuitMap, circuit1)
@@ -238,7 +351,7 @@ func TestCircuitMapPersistence(t *testing.T) {
 	}
 
 	assertHasCircuit(t, circuitMap, circuit3)
-	cdb, circuitMap = restartCircuitMap(t, cdb)
+	cfg, circuitMap = restartCircuitMap(t, cfg)
 	assertHasCircuit(t, circuitMap, circuit3)
 
 	// Add another circuit with an already-used HTLC ID but different
@@ -260,7 +373,7 @@ func TestCircuitMapPersistence(t *testing.T) {
 	assertHasKeystone(t, circuitMap, keystone1.OutKey, circuit1)
 	assertHasKeystone(t, circuitMap, keystone2.OutKey, circuit2)
 	assertHasKeystone(t, circuitMap, keystone3.OutKey, circuit3)
-	cdb, circuitMap = restartCircuitMap(t, cdb)
+	cfg, circuitMap = restartCircuitMap(t, cfg)
 	assertHasKeystone(t, circuitMap, keystone1.OutKey, circuit1)
 	assertHasKeystone(t, circuitMap, keystone2.OutKey, circuit2)
 	assertHasKeystone(t, circuitMap, keystone3.OutKey, circuit3)
@@ -294,7 +407,7 @@ func TestCircuitMapPersistence(t *testing.T) {
 	assertNumCircuitsWithHash(t, circuitMap, hash1, 1)
 	assertHasCircuit(t, circuitMap, circuit4)
 
-	cdb, circuitMap = restartCircuitMap(t, cdb)
+	cfg, circuitMap = restartCircuitMap(t, cfg)
 
 	assertNumCircuitsWithHash(t, circuitMap, hash1, 1)
 	assertHasCircuit(t, circuitMap, circuit4)
@@ -335,7 +448,7 @@ func TestCircuitMapPersistence(t *testing.T) {
 	assertHasCircuitForHash(t, circuitMap, hash3, circuit3)
 
 	// Restart, then run checks again.
-	cdb, circuitMap = restartCircuitMap(t, cdb)
+	cfg, circuitMap = restartCircuitMap(t, cfg)
 
 	// Verify that all circuits have been fully added.
 	assertHasCircuit(t, circuitMap, circuit1)
@@ -368,7 +481,7 @@ func TestCircuitMapPersistence(t *testing.T) {
 	// should be circuit4.
 	assertNumCircuitsWithHash(t, circuitMap, hash1, 1)
 	assertHasCircuitForHash(t, circuitMap, hash1, circuit4)
-	cdb, circuitMap = restartCircuitMap(t, cdb)
+	cfg, circuitMap = restartCircuitMap(t, cfg)
 	assertNumCircuitsWithHash(t, circuitMap, hash1, 1)
 	assertHasCircuitForHash(t, circuitMap, hash1, circuit4)
 
@@ -391,7 +504,7 @@ func TestCircuitMapPersistence(t *testing.T) {
 	assertNumCircuitsWithHash(t, circuitMap, hash1, 0)
 	assertNumCircuitsWithHash(t, circuitMap, hash2, 1)
 	assertNumCircuitsWithHash(t, circuitMap, hash3, 1)
-	cdb, circuitMap = restartCircuitMap(t, cdb)
+	cfg, circuitMap = restartCircuitMap(t, cfg)
 	assertNumCircuitsWithHash(t, circuitMap, hash1, 0)
 	assertNumCircuitsWithHash(t, circuitMap, hash2, 1)
 	assertNumCircuitsWithHash(t, circuitMap, hash3, 1)
@@ -405,7 +518,7 @@ func TestCircuitMapPersistence(t *testing.T) {
 	// There should now only be one remaining circuit, with hash3.
 	assertNumCircuitsWithHash(t, circuitMap, hash2, 0)
 	assertNumCircuitsWithHash(t, circuitMap, hash3, 1)
-	cdb, circuitMap = restartCircuitMap(t, cdb)
+	cfg, circuitMap = restartCircuitMap(t, cfg)
 	assertNumCircuitsWithHash(t, circuitMap, hash2, 0)
 	assertNumCircuitsWithHash(t, circuitMap, hash3, 1)
 
@@ -417,7 +530,7 @@ func TestCircuitMapPersistence(t *testing.T) {
 
 	// Check that the circuit map is empty, even after restarting.
 	assertNumCircuitsWithHash(t, circuitMap, hash3, 0)
-	cdb, circuitMap = restartCircuitMap(t, cdb)
+	cfg, circuitMap = restartCircuitMap(t, cfg)
 	assertNumCircuitsWithHash(t, circuitMap, hash3, 0)
 }
 
@@ -534,21 +647,24 @@ func makeCircuitDB(t *testing.T, path string) *channeldb.DB {
 
 // Creates a new circuit map, backed by a freshly opened channeldb. The existing
 // channeldb is closed in order to simulate a complete restart.
-func restartCircuitMap(t *testing.T, cdb *channeldb.DB) (*channeldb.DB,
+func restartCircuitMap(t *testing.T, cfg *htlcswitch.CircuitMapConfig) (
-	htlcswitch.CircuitMap) {
+	*htlcswitch.CircuitMapConfig, htlcswitch.CircuitMap) {
 
 	// Record the current temp path and close current db.
-	dbPath := cdb.Path()
+	dbPath := cfg.DB.Path()
-	cdb.Close()
+	cfg.DB.Close()
 
 	// Reinitialize circuit map with same db path.
-	cdb2 := makeCircuitDB(t, dbPath)
+	cfg2 := &htlcswitch.CircuitMapConfig{
-	cm2, err := htlcswitch.NewCircuitMap(cdb2)
+		DB: makeCircuitDB(t, dbPath),
+		ExtractErrorEncrypter: cfg.ExtractErrorEncrypter,
+	}
+	cm2, err := htlcswitch.NewCircuitMap(cfg2)
 	if err != nil {
 		t.Fatalf("unable to recreate persistent circuit map: %v", err)
 	}
 
-	return cdb2, cm2
+	return cfg2, cm2
 }
 
 // TestCircuitMapCommitCircuits tests the following behavior of CommitCircuits:
@@ -564,18 +680,14 @@ func TestCircuitMapCommitCircuits(t *testing.T) {
 		err        error
 	)
 
-	cdb := makeCircuitDB(t, "")
+	cfg, circuitMap := newCircuitMap(t)
-	circuitMap, err = htlcswitch.NewCircuitMap(cdb)
-	if err != nil {
-		t.Fatalf("unable to create persistent circuit map: %v", err)
-	}
 
 	circuit := &htlcswitch.PaymentCircuit{
 		Incoming: htlcswitch.CircuitKey{
 			ChanID: chan1,
 			HtlcID: 3,
 		},
-		ErrorEncrypter: htlcswitch.NewSphinxErrorEncrypter(),
+		ErrorEncrypter: testExtracter,
 	}
 
 	// First we will try to add an new circuit to the circuit map, this
@@ -623,7 +735,7 @@ func TestCircuitMapCommitCircuits(t *testing.T) {
 	// to be loaded from disk. Since the keystone was never set, subsequent
 	// attempts to commit the circuit should cause the circuit map to
 	// indicate that that the HTLC should be failed back.
-	cdb, circuitMap = restartCircuitMap(t, cdb)
+	cfg, circuitMap = restartCircuitMap(t, cfg)
 
 	actions, err = circuitMap.CommitCircuits(circuit)
 	if err != nil {
@@ -664,18 +776,14 @@ func TestCircuitMapOpenCircuits(t *testing.T) {
 		err        error
 	)
 
-	cdb := makeCircuitDB(t, "")
+	cfg, circuitMap := newCircuitMap(t)
-	circuitMap, err = htlcswitch.NewCircuitMap(cdb)
-	if err != nil {
-		t.Fatalf("unable to create persistent circuit map: %v", err)
-	}
 
 	circuit := &htlcswitch.PaymentCircuit{
 		Incoming: htlcswitch.CircuitKey{
 			ChanID: chan1,
 			HtlcID: 3,
 		},
-		ErrorEncrypter: htlcswitch.NewSphinxErrorEncrypter(),
+		ErrorEncrypter: testExtracter,
 	}
 
 	// First we will try to add an new circuit to the circuit map, this
@@ -747,7 +855,7 @@ func TestCircuitMapOpenCircuits(t *testing.T) {
 	//
 	// NOTE: The channel db doesn't have any channel data, so no keystones
 	// will be trimmed.
-	cdb, circuitMap = restartCircuitMap(t, cdb)
+	cfg, circuitMap = restartCircuitMap(t, cfg)
 
 	// Check that we can still query for the open circuit.
 	circuit2 = circuitMap.LookupOpenCircuit(keystone.OutKey)
@@ -874,11 +982,7 @@ func TestCircuitMapTrimOpenCircuits(t *testing.T) {
 		err        error
 	)
 
-	cdb := makeCircuitDB(t, "")
+	cfg, circuitMap := newCircuitMap(t)
-	circuitMap, err = htlcswitch.NewCircuitMap(cdb)
-	if err != nil {
-		t.Fatalf("unable to create persistent circuit map: %v", err)
-	}
 
 	const nCircuits = 10
 	const firstTrimIndex = 7
@@ -895,7 +999,7 @@ func TestCircuitMapTrimOpenCircuits(t *testing.T) {
 				ChanID: chan1,
 				HtlcID: uint64(i + 3),
 			},
-			ErrorEncrypter: htlcswitch.NewSphinxErrorEncrypter(),
+			ErrorEncrypter: htlcswitch.NewMockObfuscator(),
 		}
 	}
 
@@ -953,7 +1057,7 @@ func TestCircuitMapTrimOpenCircuits(t *testing.T) {
 
 	// Restart the circuit map, verify that that the trim is reflected on
 	// startup.
-	cdb, circuitMap = restartCircuitMap(t, cdb)
+	cfg, circuitMap = restartCircuitMap(t, cfg)
 
 	assertCircuitsOpenedPostRestart(
 		t,
@@ -995,7 +1099,7 @@ func TestCircuitMapTrimOpenCircuits(t *testing.T) {
 
 	// Restart the circuit map one last time to make sure the changes are
 	// persisted.
-	cdb, circuitMap = restartCircuitMap(t, cdb)
+	cfg, circuitMap = restartCircuitMap(t, cfg)
 
 	assertCircuitsOpenedPostRestart(
 		t,
@@ -1027,18 +1131,16 @@ func TestCircuitMapCloseOpenCircuits(t *testing.T) {
 		err        error
 	)
 
-	cdb := makeCircuitDB(t, "")
+	cfg, circuitMap := newCircuitMap(t)
-	circuitMap, err = htlcswitch.NewCircuitMap(cdb)
-	if err != nil {
-		t.Fatalf("unable to create persistent circuit map: %v", err)
-	}
 
 	circuit := &htlcswitch.PaymentCircuit{
 		Incoming: htlcswitch.CircuitKey{
 			ChanID: chan1,
 			HtlcID: 3,
 		},
-		ErrorEncrypter: htlcswitch.NewSphinxErrorEncrypter(),
+		ErrorEncrypter: &htlcswitch.SphinxErrorEncrypter{
+			EphemeralKey: testEphemeralKey,
+		},
 	}
 
 	// First we will try to add an new circuit to the circuit map, this
@@ -1095,7 +1197,7 @@ func TestCircuitMapCloseOpenCircuits(t *testing.T) {
 	//
 	// NOTE: The channel db doesn't have any channel data, so no keystones
 	// will be trimmed.
-	cdb, circuitMap = restartCircuitMap(t, cdb)
+	cfg, circuitMap = restartCircuitMap(t, cfg)
 
 	// Close the open circuit for the first time, which should succeed.
 	_, err = circuitMap.FailCircuit(circuit.Incoming)
@@ -1122,18 +1224,14 @@ func TestCircuitMapCloseUnopenedCircuit(t *testing.T) {
 		err        error
 	)
 
-	cdb := makeCircuitDB(t, "")
+	cfg, circuitMap := newCircuitMap(t)
-	circuitMap, err = htlcswitch.NewCircuitMap(cdb)
-	if err != nil {
-		t.Fatalf("unable to create persistent circuit map: %v", err)
-	}
 
 	circuit := &htlcswitch.PaymentCircuit{
 		Incoming: htlcswitch.CircuitKey{
 			ChanID: chan1,
 			HtlcID: 3,
 		},
-		ErrorEncrypter: htlcswitch.NewSphinxErrorEncrypter(),
+		ErrorEncrypter: testExtracter,
 	}
 
 	// First we will try to add an new circuit to the circuit map, this
@@ -1157,7 +1255,7 @@ func TestCircuitMapCloseUnopenedCircuit(t *testing.T) {
 
 	// Now, restart the circuit map, which will result in the circuit being
 	// reopened, since no attempt to delete the circuit was made.
-	cdb, circuitMap = restartCircuitMap(t, cdb)
+	cfg, circuitMap = restartCircuitMap(t, cfg)
 
 	// Close the open circuit for the first time, which should succeed.
 	_, err = circuitMap.FailCircuit(circuit.Incoming)
@@ -1183,18 +1281,14 @@ func TestCircuitMapDeleteUnopenedCircuit(t *testing.T) {
 		err        error
 	)
 
-	cdb := makeCircuitDB(t, "")
+	cfg, circuitMap := newCircuitMap(t)
-	circuitMap, err = htlcswitch.NewCircuitMap(cdb)
-	if err != nil {
-		t.Fatalf("unable to create persistent circuit map: %v", err)
-	}
 
 	circuit := &htlcswitch.PaymentCircuit{
 		Incoming: htlcswitch.CircuitKey{
 			ChanID: chan1,
 			HtlcID: 3,
 		},
-		ErrorEncrypter: htlcswitch.NewSphinxErrorEncrypter(),
+		ErrorEncrypter: testExtracter,
 	}
 
 	// First we will try to add an new circuit to the circuit map, this
@@ -1225,7 +1319,7 @@ func TestCircuitMapDeleteUnopenedCircuit(t *testing.T) {
 
 	// Now, restart the circuit map, and check that the deletion survived
 	// the restart.
-	cdb, circuitMap = restartCircuitMap(t, cdb)
+	cfg, circuitMap = restartCircuitMap(t, cfg)
 
 	circuit2 = circuitMap.LookupCircuit(circuit.Incoming)
 	if circuit2 != nil {
@@ -1246,18 +1340,14 @@ func TestCircuitMapDeleteOpenCircuit(t *testing.T) {
 		err        error
 	)
 
-	cdb := makeCircuitDB(t, "")
+	cfg, circuitMap := newCircuitMap(t)
-	circuitMap, err = htlcswitch.NewCircuitMap(cdb)
-	if err != nil {
-		t.Fatalf("unable to create persistent circuit map: %v", err)
-	}
 
 	circuit := &htlcswitch.PaymentCircuit{
 		Incoming: htlcswitch.CircuitKey{
 			ChanID: chan1,
 			HtlcID: 3,
 		},
-		ErrorEncrypter: htlcswitch.NewSphinxErrorEncrypter(),
+		ErrorEncrypter: testExtracter,
 	}
 
 	// First we will try to add an new circuit to the circuit map, this
@@ -1302,7 +1392,7 @@ func TestCircuitMapDeleteOpenCircuit(t *testing.T) {
 
 	// Now, restart the circuit map, and check that the deletion survived
 	// the restart.
-	cdb, circuitMap = restartCircuitMap(t, cdb)
+	cfg, circuitMap = restartCircuitMap(t, cfg)
 
 	circuit2 = circuitMap.LookupOpenCircuit(keystone.OutKey)
 	if circuit2 != nil {