fixup! multi: Support custom size onion packets

Author: gijswijs

sphinx_test.go

@@ -45,10 +45,17 @@ var (
 var (
 	// ErrInsufficientHops is returned when there are not enough hops to
 	// create a route.
-	ErrInsufficientHops = errors.New("at least 2 hops are required to " +
+	ErrInsufficientHops = errors.New("at least 1 hop is required to " +
 		"create an onion message route")
 )
 
+// Session keys used in onion message tests.
+var (
+	sessionKeyA = bytes.Repeat([]byte{'A'}, 32)
+	sessionKeyB = bytes.Repeat([]byte{'B'}, 32)
+	sessionKeyC = bytes.Repeat([]byte{'C'}, 32)
+)
+
 // encodeTLVRecord encodes a TLV record with the given type and value.
 func encodeTLVRecord(recordType uint64, value []byte) []byte {
 	var buf bytes.Buffer
@@ -159,7 +166,7 @@ func newTestRoute(numHops int) ([]*Router, *PaymentPath, *[]HopData, *OnionPacke
 func newOnionMessageRoute(numHops int) (*OnionPacket, *PaymentPath, []*Router,
 	error) {
 
-	if numHops < 2 {
+	if numHops < 1 {
 		return nil, nil, nil, ErrInsufficientHops
 	}
 
@@ -178,8 +185,8 @@ func newOnionMessageRoute(numHops int) (*OnionPacket, *PaymentPath, []*Router,
 	secondPathNodes := nodes[mid:]
 
 	// Create the sessions keys for the two blinded paths.
-	firstSessionKey, _ := btcec.NewPrivateKey()
-	secondSessionKey, _ := btcec.NewPrivateKey()
+	firstSessionKey, _ := btcec.PrivKeyFromBytes(sessionKeyA)
+	secondSessionKey, _ := btcec.PrivKeyFromBytes(sessionKeyB)
 
 	// Create the first blinded path, adding a next_path_key_override TLV
 	// at the last node.
@@ -227,7 +234,7 @@ func newOnionMessageRoute(numHops int) (*OnionPacket, *PaymentPath, []*Router,
 	}
 
 	// Generate the onion packet.
-	sessionKey, _ := btcec.NewPrivateKey()
+	sessionKey, _ := btcec.PrivKeyFromBytes(sessionKeyC)
 
 	onionPacket, err := NewOnionPacket(
 		&route, sessionKey, nil, DeterministicPacketFiller,
@@ -267,11 +274,18 @@ func createBlindedPath(firstPathNodes []*Router, secondPathNodes []*Router,
 		}
 	}
 
-	firstBlindedPath, err := BuildBlindedPath(
-		firstSessionKey, firstPathInfos,
-	)
-	if err != nil {
-		return nil, err
+	// The first blinded path may be empty if the sender has a direct
+	// channel with the introduction point.
+	var firstBlindedPath *BlindedPathInfo
+	if len(firstPathNodes) > 0 {
+		var err error
+
+		firstBlindedPath, err = BuildBlindedPath(
+			firstSessionKey, firstPathInfos,
+		)
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	// Create the second blinded path, omitting the next_node_id TLV for the
@@ -308,13 +322,26 @@ func createBlindedPath(firstPathNodes []*Router, secondPathNodes []*Router,
 		return nil, err
 	}
 
-	blindedPath := &BlindedPath{
-		IntroductionPoint: firstBlindedPath.Path.IntroductionPoint,
-		BlindingPoint:     firstBlindedPath.Path.BlindingPoint,
-		BlindedHops: append(
-			firstBlindedPath.Path.BlindedHops,
-			secondBlindedPath.Path.BlindedHops...,
-		),
+	var blindedPath *BlindedPath
+	if len(firstPathNodes) == 0 {
+		// If the sender has a direct channel to the introduction point
+		// of the blinded path the receiver gave us, then the sender
+		// doesn't need to create its own blinded path. We can just use
+		// the receiver's blinded path as is.
+		blindedPath = secondBlindedPath.Path
+	} else {
+		// Otherwise, we use the introduction point of the blinded path
+		// created by the sender and concatenate the hops of both paths.
+		introductionPoint := firstBlindedPath.Path.IntroductionPoint
+		blindingPoint := firstBlindedPath.Path.BlindingPoint
+		blindedPath = &BlindedPath{
+			IntroductionPoint: introductionPoint,
+			BlindingPoint:     blindingPoint,
+			BlindedHops: append(
+				firstBlindedPath.Path.BlindedHops,
+				secondBlindedPath.Path.BlindedHops...,
+			),
+		}
 	}
 
 	return blindedPath, nil
@@ -601,7 +628,7 @@ func TestSphinxSingleHop(t *testing.T) {
 	// The destination node should detect that the packet is destined for
 	// itself.
 	if processedPacket.Action != ExitNode {
-		t.Fatalf("processed action is correct, is %v should be %v",
+		t.Fatalf("processed action is incorrect, is %v should be %v",
 			processedPacket.Action, ExitNode)
 	}
 }
@@ -903,6 +930,49 @@ func TestPaymentPathTotalPayloadSizeExceeds1300(t *testing.T) {
 			"MaxOnionMessagePayloadSize")
 }
 
+// TestSingleHopOnionMessage test that we can create and encode a single-hop
+// onion message packet.
+func TestSingleHopOnionMessage(t *testing.T) {
+	t.Parallel()
+
+	packet, route, nodes, err := newOnionMessageRoute(1)
+	require.NoError(t, err, "newOnionMessageRoute should not return an "+
+		"error")
+
+	require.Equal(t, 1, route.TrueRouteLength())
+
+	// Start the ReplayLog and defer shutdown
+	err = nodes[0].log.Start()
+	require.NoError(t, err, "unable to start ReplayLog")
+
+	defer func() {
+		require.NoError(t, nodes[0].log.Stop())
+	}()
+
+	// In a single-hop onion message the blinding point is the session key
+	// used by the receiver to create its blinded path. The sender didn't
+	// need to create a blinded path since it has a direct channel to the
+	// receiver/introduction point. Knowing this we use the session key that
+	// the receiver used.
+	blindingPoint, _ := btcec.PrivKeyFromBytes(sessionKeyB)
+
+	// Simulating a direct single-hop onion message, send the sphinx packet
+	// to the destination node, making it process the packet fully.
+	processedPacket, err := nodes[0].ProcessOnionPacket(
+		packet, nil, 1, WithBlindingPoint(blindingPoint.PubKey()),
+	)
+	if err != nil {
+		t.Fatalf("unable to process sphinx packet: %v", err)
+	}
+
+	// The destination node should detect that the packet is destined for
+	// itself.
+	if processedPacket.Action != ExitNode {
+		t.Fatalf("processed action is incorrect, is %v should be %v",
+			processedPacket.Action, ExitNode)
+	}
+}
+
 // TestCustomPayloadSize tests that we can create an onion packet with any size
 // of routing info.
 func TestCustomPayloadSize(t *testing.T) {