sphinx: update NewOnionPacket to use the new PaymentPath type

Roasbeef · Roasbeef · commit 4a64e471dbc8 · 2019-04-29T16:45:55.000-07:00
In this commit, we update the NewOnionPacket function to use the new
PaymentPath type. We also update all the tests as they need to reference
this new type themselves.
diff --git a/bench_test.go b/bench_test.go
@@ -14,37 +14,40 @@ var (
 
 func BenchmarkPathPacketConstruction(b *testing.B) {
 	b.StopTimer()
-	route := make([]*btcec.PublicKey, NumMaxHops)
-	for i := 0; i < NumMaxHops; i++ {
-		privKey, err := btcec.NewPrivateKey(btcec.S256())
-		if err != nil {
-			b.Fatalf("unable to generate key: %v", privKey)
-		}
-
-		route[i] = privKey.PubKey()
-	}
 
 	var (
 		err          error
 		sphinxPacket *OnionPacket
+		route        PaymentPath
 	)
 
-	var hopsData []HopData
-	for i := 0; i < len(route); i++ {
-		hopsData = append(hopsData, HopData{
-			Realm:         [RealmByteSize]byte{0x00},
+	for i := 0; i < NumMaxHops; i++ {
+		privKey, err := btcec.NewPrivateKey(btcec.S256())
+		if err != nil {
+			b.Fatalf("unable to generate key: %v", privKey)
+		}
+
+		hopData := HopData{
+			Realm:         [1]byte{0x00},
 			ForwardAmount: uint64(i),
 			OutgoingCltv:  uint32(i),
-		})
-		copy(hopsData[i].NextAddress[:], bytes.Repeat([]byte{byte(i)}, 8))
+		}
+		copy(hopData.NextAddress[:], bytes.Repeat([]byte{byte(i)}, 8))
+
+		route[i] = OnionHop{
+			NodePub: *privKey.PubKey(),
+			HopData: hopData,
+		}
 	}
 
 	d, _ := btcec.PrivKeyFromBytes(btcec.S256(), bytes.Repeat([]byte{'A'}, 32))
+
 	b.ReportAllocs()
+
 	b.StartTimer()
 
 	for i := 0; i < b.N; i++ {
-		sphinxPacket, err = NewOnionPacket(route, d, hopsData, nil)
+		sphinxPacket, err = NewOnionPacket(&route, d, nil)
 		if err != nil {
 			b.Fatalf("unable to create packet: %v", err)
 		}
@@ -55,7 +58,7 @@ func BenchmarkPathPacketConstruction(b *testing.B) {
 
 func BenchmarkProcessPacket(b *testing.B) {
 	b.StopTimer()
-	path, _, sphinxPacket, err := newTestRoute(1)
+	path, _, _, sphinxPacket, err := newTestRoute(1)
 	if err != nil {
 		b.Fatalf("unable to create test route: %v", err)
 	}
diff --git a/sphinx.go b/sphinx.go
@@ -289,14 +289,16 @@ func generateSharedSecrets(paymentPath []*btcec.PublicKey,
 	return hopSharedSecrets
 }
 
-// NewOnionPacket creates a new onion packet which is capable of
-// obliviously routing a message through the mix-net path outline by
-// 'paymentPath'.
-func NewOnionPacket(paymentPath []*btcec.PublicKey, sessionKey *btcec.PrivateKey,
-	hopsData []HopData, assocData []byte) (*OnionPacket, error) {
+// NewOnionPacket creates a new onion packet which is capable of obliviously
+// routing a message through the mix-net path outline by 'paymentPath'.
+func NewOnionPacket(paymentPath *PaymentPath, sessionKey *btcec.PrivateKey,
+	assocData []byte) (*OnionPacket, error) {
 
-	numHops := len(paymentPath)
-	hopSharedSecrets := generateSharedSecrets(paymentPath, sessionKey)
+	numHops := paymentPath.TrueRouteLength()
+
+	hopSharedSecrets := generateSharedSecrets(
+		paymentPath.NodeKeys(), sessionKey,
+	)
 
 	// Generate the padding, called "filler strings" in the paper.
 	filler := generateHeaderPadding(
@@ -323,7 +325,7 @@ func NewOnionPacket(paymentPath []*btcec.PublicKey, sessionKey *btcec.PrivateKey
 		// The HMAC for the final hop is simply zeroes. This allows the
 		// last hop to recognize that it is the destination for a
 		// particular payment.
-		hopsData[i].HMAC = nextHmac
+		paymentPath[i].HopData.HMAC = nextHmac
 
 		// Next, using the key dedicated for our stream cipher, we'll
 		// generate enough bytes to obfuscate this layer of the onion
@@ -338,7 +340,8 @@ func NewOnionPacket(paymentPath []*btcec.PublicKey, sessionKey *btcec.PrivateKey
 		// With the mix header right-shifted, we'll encode the current
 		// hop data into a buffer we'll re-use during the packet
 		// construction.
-		if err := hopsData[i].Encode(&hopDataBuf); err != nil {
+		err := paymentPath[i].HopData.Encode(&hopDataBuf)
+		if err != nil {
 			return nil, err
 		}
 		copy(mixHeader[:], hopDataBuf.Bytes())
diff --git a/sphinx_test.go b/sphinx_test.go
@@ -86,63 +86,91 @@ var (
 		"baaa7d63ad64199f4664813b955cff954949076dcf"
 )
 
-func newTestRoute(numHops int) ([]*Router, *[]HopData, *OnionPacket, error) {
+func newTestRoute(numHops int) ([]*Router, *PaymentPath, *[]HopData, *OnionPacket, error) {
 	nodes := make([]*Router, numHops)
 
 	// Create numHops random sphinx nodes.
 	for i := 0; i < len(nodes); i++ {
 		privKey, err := btcec.NewPrivateKey(btcec.S256())
 		if err != nil {
-			return nil, nil, nil, fmt.Errorf("Unable to generate"+
-				" random key for sphinx node: %v", err)
+			return nil, nil, nil, nil, fmt.Errorf("Unable to "+
+				"generate random key for sphinx node: %v", err)
 		}
 
-		nodes[i] = NewRouter(privKey, &chaincfg.MainNetParams,
-			NewMemoryReplayLog())
+		nodes[i] = NewRouter(
+			privKey, &chaincfg.MainNetParams, NewMemoryReplayLog(),
+		)
 	}
 
 	// Gather all the pub keys in the path.
-	route := make([]*btcec.PublicKey, len(nodes))
+	var (
+		route PaymentPath
+	)
 	for i := 0; i < len(nodes); i++ {
-		route[i] = nodes[i].onionKey.PubKey()
-	}
-
-	var hopsData []HopData
-	for i := 0; i < numHops; i++ {
-		hopsData = append(hopsData, HopData{
-			Realm:         0x00,
+		hopData := HopData{
+			Realm:         [1]byte{0x00},
 			ForwardAmount: uint64(i),
 			OutgoingCltv:  uint32(i),
-		})
-		copy(hopsData[i].NextAddress[:], bytes.Repeat([]byte{byte(i)}, 8))
-		copy(hopsData[i].ExtraBytes[:], bytes.Repeat([]byte{byte(i)}, padSize))
+		}
+
+		copy(hopData.NextAddress[:], bytes.Repeat([]byte{byte(i)}, 8))
+
+		route[i] = OnionHop{
+			NodePub: *nodes[i].onionKey.PubKey(),
+			HopData: hopData,
+		}
 	}
 
 	// Generate a forwarding message to route to the final node via the
 	// generated intermdiates nodes above.  Destination should be Hash160,
 	// adding padding so parsing still works.
-	sessionKey, _ := btcec.PrivKeyFromBytes(btcec.S256(), bytes.Repeat([]byte{'A'}, 32))
-	fwdMsg, err := NewOnionPacket(route, sessionKey, hopsData, nil)
+	sessionKey, _ := btcec.PrivKeyFromBytes(
+		btcec.S256(), bytes.Repeat([]byte{'A'}, 32),
+	)
+	fwdMsg, err := NewOnionPacket(&route, sessionKey, nil)
 	if err != nil {
-		return nil, nil, nil, fmt.Errorf("Unable to create forwarding "+
-			"message: %#v", err)
+		return nil, nil, nil, nil, fmt.Errorf("unable to create "+
+			"forwarding message: %#v", err)
+	}
+
+	var hopsData []HopData
+	for i := 0; i < len(nodes); i++ {
+		hopsData = append(hopsData, route[i].HopData)
 	}
 
-	return nodes, &hopsData, fwdMsg, nil
+	return nodes, &route, &hopsData, fwdMsg, nil
 }
 
 func TestBolt4Packet(t *testing.T) {
-	var route = make([]*btcec.PublicKey, len(bolt4PubKeys))
+	var (
+		route    PaymentPath
+		hopsData []HopData
+	)
 	for i, pubKeyHex := range bolt4PubKeys {
 		pubKeyBytes, err := hex.DecodeString(pubKeyHex)
 		if err != nil {
 			t.Fatalf("unable to decode BOLT 4 hex pubkey #%d: %v", i, err)
 		}
 
-		route[i], err = btcec.ParsePubKey(pubKeyBytes, btcec.S256())
+		pubKey, err := btcec.ParsePubKey(pubKeyBytes, btcec.S256())
 		if err != nil {
 			t.Fatalf("unable to parse BOLT 4 pubkey #%d: %v", i, err)
 		}
+
+		hopData := HopData{
+			Realm:         [1]byte{0x00},
+			ForwardAmount: uint64(i),
+			OutgoingCltv:  uint32(i),
+		}
+		copy(hopData.NextAddress[:], bytes.Repeat([]byte{byte(i)}, 8))
+		hopsData = append(hopsData, hopData)
+
+		pubKey.Curve = nil
+
+		route[i] = OnionHop{
+			NodePub: *pubKey,
+			HopData: hopData,
+		}
 	}
 
 	finalPacket, err := hex.DecodeString(bolt4FinalPacketHex)
@@ -151,18 +179,8 @@ func TestBolt4Packet(t *testing.T) {
 			"%v", err)
 	}
 
-	var hopsData []HopData
-	for i := range route {
-		hopsData = append(hopsData, HopData{
-			Realm:         0x00,
-			ForwardAmount: uint64(i),
-			OutgoingCltv:  uint32(i),
-		})
-		copy(hopsData[i].NextAddress[:], bytes.Repeat([]byte{byte(i)}, 8))
-	}
-
 	sessionKey, _ := btcec.PrivKeyFromBytes(btcec.S256(), bolt4SessionKey)
-	pkt, err := NewOnionPacket(route, sessionKey, hopsData, bolt4AssocData)
+	pkt, err := NewOnionPacket(&route, sessionKey, bolt4AssocData)
 	if err != nil {
 		t.Fatalf("unable to construct onion packet: %v", err)
 	}
@@ -180,7 +198,7 @@ func TestBolt4Packet(t *testing.T) {
 }
 
 func TestSphinxCorrectness(t *testing.T) {
-	nodes, hopDatas, fwdMsg, err := newTestRoute(NumMaxHops)
+	nodes, _, hopDatas, fwdMsg, err := newTestRoute(NumMaxHops)
 	if err != nil {
 		t.Fatalf("unable to create random onion packet: %v", err)
 	}
@@ -229,7 +247,7 @@ func TestSphinxCorrectness(t *testing.T) {
 
 			// The next hop should have been parsed as node[i+1].
 			parsedNextHop := onionPacket.ForwardingInstructions.NextAddress[:]
-			expected := bytes.Repeat([]byte{byte(i)}, addressSize)
+			expected := bytes.Repeat([]byte{byte(i)}, AddressSize)
 			if !bytes.Equal(parsedNextHop, expected) {
 				t.Fatalf("Processing error, next hop parsed incorrectly."+
 					" next hop should be %v, was instead parsed as %v",
@@ -246,8 +264,7 @@ func TestSphinxSingleHop(t *testing.T) {
 	// We'd like to test the proper behavior of the correctness of onion
 	// packet processing for "single-hop" payments which bare a full onion
 	// packet.
-
-	nodes, _, fwdMsg, err := newTestRoute(1)
+	nodes, _, _, fwdMsg, err := newTestRoute(1)
 	if err != nil {
 		t.Fatalf("unable to create test route: %v", err)
 	}
@@ -274,7 +291,7 @@ func TestSphinxSingleHop(t *testing.T) {
 func TestSphinxNodeRelpay(t *testing.T) {
 	// We'd like to ensure that the sphinx node itself rejects all replayed
 	// packets which share the same shared secret.
-	nodes, _, fwdMsg, err := newTestRoute(NumMaxHops)
+	nodes, _, _, fwdMsg, err := newTestRoute(NumMaxHops)
 	if err != nil {
 		t.Fatalf("unable to create test route: %v", err)
 	}
@@ -299,7 +316,7 @@ func TestSphinxNodeRelpay(t *testing.T) {
 func TestSphinxNodeRelpaySameBatch(t *testing.T) {
 	// We'd like to ensure that the sphinx node itself rejects all replayed
 	// packets which share the same shared secret.
-	nodes, _, fwdMsg, err := newTestRoute(NumMaxHops)
+	nodes, _, _, fwdMsg, err := newTestRoute(NumMaxHops)
 	if err != nil {
 		t.Fatalf("unable to create test route: %v", err)
 	}
@@ -345,7 +362,7 @@ func TestSphinxNodeRelpaySameBatch(t *testing.T) {
 func TestSphinxNodeRelpayLaterBatch(t *testing.T) {
 	// We'd like to ensure that the sphinx node itself rejects all replayed
 	// packets which share the same shared secret.
-	nodes, _, fwdMsg, err := newTestRoute(NumMaxHops)
+	nodes, _, _, fwdMsg, err := newTestRoute(NumMaxHops)
 	if err != nil {
 		t.Fatalf("unable to create test route: %v", err)
 	}
@@ -390,7 +407,7 @@ func TestSphinxNodeRelpayLaterBatch(t *testing.T) {
 func TestSphinxNodeReplayBatchIdempotency(t *testing.T) {
 	// We'd like to ensure that the sphinx node itself rejects all replayed
 	// packets which share the same shared secret.
-	nodes, _, fwdMsg, err := newTestRoute(NumMaxHops)
+	nodes, _, _, fwdMsg, err := newTestRoute(NumMaxHops)
 	if err != nil {
 		t.Fatalf("unable to create test route: %v", err)
 	}
@@ -441,7 +458,7 @@ func TestSphinxNodeReplayBatchIdempotency(t *testing.T) {
 func TestSphinxAssocData(t *testing.T) {
 	// We want to make sure that the associated data is considered in the
 	// HMAC creation
-	nodes, _, fwdMsg, err := newTestRoute(5)
+	nodes, _, _, fwdMsg, err := newTestRoute(5)
 	if err != nil {
 		t.Fatalf("unable to create random onion packet: %v", err)
 	}
@@ -460,7 +477,7 @@ func TestSphinxAssocData(t *testing.T) {
 func TestSphinxEncodeDecode(t *testing.T) {
 	// Create some test data with a randomly populated, yet valid onion
 	// forwarding message.
-	_, _, fwdMsg, err := newTestRoute(5)
+	_, _, _, fwdMsg, err := newTestRoute(5)
 	if err != nil {
 		t.Fatalf("unable to create random onion packet: %v", err)
 	}
