sphinx_test: test jumbo size onion message packets

This commit adds a helper function to create onion messages of a
specified length. This helper is then used to test the handling of
packets larger than 1300 bytes specifically for onion messages.

Author: gijswijs

sphinx_test.go

@@ -2,6 +2,7 @@ package sphinx
 
 import (
 	"bytes"
+	"crypto/rand"
 	"encoding/hex"
 	"encoding/json"
 	"fmt"
@@ -105,6 +106,184 @@ func newTestRoute(numHops int) ([]*Router, *PaymentPath, *[]HopData, *OnionPacke
 	return nodes, &route, &hopsData, fwdMsg, nil
 }
 
+func newOnionMessageRoute(numHops int) (*OnionPacket, *PaymentPath, []*Router,
+	error) {
+
+	if numHops < 2 {
+		return nil, nil, nil, fmt.Errorf("at least 2 hops are " +
+			"required to create an onion message route")
+	}
+
+	// Create routers for each hop.
+	nodes := make([]*Router, numHops)
+	for i := 0; i < numHops; i++ {
+		privKey, err := btcec.NewPrivateKey()
+		if err != nil {
+			return nil, nil, nil, fmt.Errorf("unable to generate "+
+				"random key for sphinx node: %v", err)
+		}
+		nodes[i] = NewRouter(
+			&PrivKeyECDH{PrivKey: privKey}, NewMemoryReplayLog(),
+		)
+	}
+
+	// Split the nodes into two parts for creating two blinded paths.
+	mid := numHops / 2
+	firstPathNodes := nodes[:mid]
+	secondPathNodes := nodes[mid:]
+
+	// Create the sessions keys for the two blinded paths.
+	firstSessionKey, _ := btcec.NewPrivateKey()
+	secondSessionKey, _ := btcec.NewPrivateKey()
+
+	// Create the first blinded path, adding a next_path_key_override TLV
+	// at the last node.
+	firstPathInfos := make([]*HopInfo, len(firstPathNodes))
+	for i, node := range firstPathNodes {
+		nextNodeID := node.onionKey.PubKey().SerializeCompressed()
+		var b bytes.Buffer
+		var tlvStream *tlv.Stream
+		var err error
+		if i == len(firstPathNodes)-1 {
+			secondsSessPub := secondSessionKey.PubKey()
+			pathKeyOverride := secondsSessPub.SerializeCompressed()
+			tlvStream, err = tlv.NewStream(
+				tlv.MakePrimitiveRecord(4, &nextNodeID),
+				tlv.MakePrimitiveRecord(8, &pathKeyOverride),
+			)
+		} else {
+			tlvStream, err = tlv.NewStream(
+				tlv.MakePrimitiveRecord(4, &nextNodeID),
+			)
+		}
+		if err != nil {
+			return nil, nil, nil, fmt.Errorf("unable to create "+
+				"TLV stream: %v", err)
+		}
+		if err := tlvStream.Encode(&b); err != nil {
+			return nil, nil, nil, fmt.Errorf("unable to encode "+
+				"TLV stream: %v", err)
+		}
+		firstPathInfos[i] = &HopInfo{
+			NodePub:   node.onionKey.PubKey(),
+			PlainText: b.Bytes(),
+		}
+	}
+	firstBlindedPath, err := BuildBlindedPath(
+		firstSessionKey, firstPathInfos,
+	)
+	if err != nil {
+		return nil, nil, nil, fmt.Errorf("error generating first "+
+			"blinded path: %v", err)
+	}
+
+	// Create the second blinded path, omitting the next_node_id TLV for the
+	// last node.
+	secondPathInfos := make([]*HopInfo, len(secondPathNodes))
+	for i, node := range secondPathNodes {
+		nextNodeID := node.onionKey.PubKey().SerializeCompressed()
+		var tlvStream *tlv.Stream
+		var err error
+		if i == len(secondPathNodes)-1 {
+			pathID := make([]byte, 20)
+			if _, err := rand.Read(pathID); err != nil {
+				return nil, nil, nil, fmt.Errorf("unable to "+
+					"generate random path ID: %v", err)
+			}
+			tlvStream, err = tlv.NewStream(
+				tlv.MakePrimitiveRecord(6, &pathID),
+			)
+		} else {
+			tlvStream, err = tlv.NewStream(
+				tlv.MakePrimitiveRecord(4, &nextNodeID),
+			)
+		}
+		if err != nil {
+			return nil, nil, nil, fmt.Errorf("unable to create "+
+				"TLV stream: %v", err)
+		}
+		var b bytes.Buffer
+		if err := tlvStream.Encode(&b); err != nil {
+			return nil, nil, nil, fmt.Errorf("unable to encode "+
+				"TLV stream: %v", err)
+		}
+
+		secondPathInfos[i] = &HopInfo{
+			NodePub:   node.onionKey.PubKey(),
+			PlainText: b.Bytes(),
+		}
+	}
+	secondBlindedPath, err := BuildBlindedPath(
+		secondSessionKey, secondPathInfos,
+	)
+	if err != nil {
+		return nil, nil, nil, fmt.Errorf("error generating second "+
+			"blinded path: %v", err)
+	}
+
+	blindedPath := &BlindedPath{
+		IntroductionPoint: firstBlindedPath.Path.IntroductionPoint,
+		BlindingPoint:     firstBlindedPath.Path.BlindingPoint,
+		BlindedHops: append(
+			firstBlindedPath.Path.BlindedHops,
+			secondBlindedPath.Path.BlindedHops...,
+		),
+	}
+
+	// Create the route from the blinded path, always adding the
+	// hop.CipherText as a TLV field type 4.
+	var route PaymentPath
+	for i, hop := range blindedPath.BlindedHops {
+		var payload []byte
+		var b bytes.Buffer
+		var tlvStream *tlv.Stream
+		var err error
+
+		if i == len(blindedPath.BlindedHops)-1 {
+			hello := []byte("hello")
+			tlvStream, err = tlv.NewStream(
+				tlv.MakePrimitiveRecord(4, &hop.CipherText),
+				tlv.MakePrimitiveRecord(65, &hello),
+			)
+		} else {
+			tlvStream, err = tlv.NewStream(
+				tlv.MakePrimitiveRecord(4, &hop.CipherText),
+			)
+		}
+
+		if err != nil {
+			return nil, nil, nil, fmt.Errorf("unable to create "+
+				"TLV stream: %v", err)
+		}
+
+		if err := tlvStream.Encode(&b); err != nil {
+			return nil, nil, nil, fmt.Errorf("unable to encode "+
+				"TLV stream: %v", err)
+		}
+		payload = b.Bytes()
+		route[i] = OnionHop{
+			NodePub: *hop.BlindedNodePub,
+			HopPayload: HopPayload{
+				Type:    PayloadTLV,
+				Payload: payload,
+			},
+		}
+	}
+
+	// Generate the onion packet.
+	sessionKey, _ := btcec.NewPrivateKey()
+	onionPacket, err := NewOnionPacket(
+		&route, sessionKey, nil, DeterministicPacketFiller,
+		WithOnionMessage(),
+	)
+	if err != nil {
+		return nil, nil, nil, fmt.Errorf("unable to create onion "+
+			"packet: %v", err)
+	}
+
+	return onionPacket, &route, nodes, nil
+}
+
 func TestBolt4Packet(t *testing.T) {
 	var (
 		route PaymentPath
@@ -669,6 +848,18 @@ func mustNewLegacyHopPayload(hopData *HopData) HopPayload {
 	return payload
 }
 
+// TestPaymentPathTotalPayloadSizeExceeds1300 tests that a PaymentPath can have
+// a TotalPayloadSize greater than 1300 bytes.
+func TestPaymentPathTotalPayloadSizeExceeds1300(t *testing.T) {
+	_, route, _, err := newOnionMessageRoute(15)
+	require.NoError(t, err, "newOnionMessageRoute should not return an "+
+		"error")
+
+	totalSize := route.TotalPayloadSize()
+	require.Greater(t, totalSize, 1300, "TotalPayloadSize should be "+
+		"greater than 1300")
+}
+
 // TestSphinxHopVariableSizedPayloads tests that we're able to fully decode an
 // EOB payload that was targeted at the final hop in a route, and also when
 // intermediate nodes have EOB data encoded as well. Additionally, we test that