sphinx_test: add test for blinded route processing

We add TestOnionMessageRouteBlinding which verifies that the onion
message packet from the test vector can be processed correctly by the
nodes in a blinded route.

Author: gijswijs

path_test.go

@@ -331,6 +331,106 @@ func TestOnionRouteBlinding(t *testing.T) {
 	}
 }
 
+// TestOnionMessageRouteBlinding tests that an onion message packet can
+// correctly be processed by a node in a blinded route.
+func TestOnionMessageRouteBlinding(t *testing.T) {
+	t.Parallel()
+
+	// First, we'll read out the raw Json file at the target location.
+	jsonBytes, err := os.ReadFile(blindedOnionMessageOnionTestFileName)
+	require.NoError(t, err)
+
+	// Once we have the raw file, we'll unpack it into our
+	// blindingJsonTestCase struct defined above.
+	testCase := &onionMessageJsonTestCase{}
+	require.NoError(t, json.Unmarshal(jsonBytes, testCase))
+
+	// Extract the original onion message packet to be processed.
+	onion, err := hex.DecodeString(testCase.OnionMessage.OnionMessagePacket)
+	require.NoError(t, err)
+
+	onionBytes := bytes.NewReader(onion)
+	onionPacket := &OnionPacket{}
+	require.NoError(t, onionPacket.Decode(onionBytes))
+
+	// peelOnion is a helper closure that can be used to set up a Router
+	// and use it to process the given onion packet.
+	peelOnion := func(key *btcec.PrivateKey,
+		blindingPoint *btcec.PublicKey) *ProcessedPacket {
+
+		r := NewRouter(
+			&PrivKeyECDH{PrivKey: key}, NewMemoryReplayLog(),
+		)
+
+		require.NoError(t, r.Start())
+		defer r.Stop()
+
+		res, err := r.ProcessOnionPacket(
+			onionPacket, nil, 10,
+			WithBlindingPoint(blindingPoint),
+		)
+		require.NoError(t, err)
+
+		return res
+	}
+
+	hops := testCase.Generate.Hops
+
+	// There are some things that the processor of the onion packet will
+	// only be able to determine from the actual contents of the encrypted
+	// data it receives. These things include the next_blinding_point for
+	// the introduction point and the next_blinding_override. The decryption
+	// of this data is dependent on the encoding chosen by higher layers.
+	// The test uses TLVs. Since the extraction of this data is dependent
+	// on layers outside the scope of this library, we provide handle these
+	// cases manually for the sake of the test.
+	var (
+		firstBlinding = pubKeyFromString(testCase.Route.FirstPathKey)
+
+		concatIndex      = 1
+		blindingOverride = pubKeyFromString(hops[0].EncodedOnionMessageTLVs.NextPathKeyOverride)
+	)
+
+	var blindingPoint *btcec.PublicKey
+	for i, hop := range testCase.Decrypt.Hops {
+		buff := bytes.NewBuffer(nil)
+		require.NoError(t, onionPacket.Encode(buff))
+
+		// hop.OnionMessage contains the onion_message hex string. This
+		// contains the type 513 (two bytes), the path_key (33 bytes)
+		// and the length of the onion_message_packet (two bytes). We
+		// are only interested in the onion_message_packet so we only
+		// check that part.
+		const onionMessageHexHeaderLen = 74
+
+		require.Equal(
+			t, hop.OnionMessage[onionMessageHexHeaderLen:],
+			hex.EncodeToString(buff.Bytes()),
+		)
+
+		priv := privKeyFromString(hop.PrivKey)
+
+		switch i {
+		case 0:
+			// Onion message routes are always entirely blinded, so
+			// the first hop will always use the first blinding
+			// point.
+			blindingPoint = firstBlinding
+		case concatIndex:
+			blindingPoint = blindingOverride
+		}
+
+		processedPkt := peelOnion(priv, blindingPoint)
+
+		blindingPoint, err = NextEphemeral(
+			&PrivKeyECDH{priv}, blindingPoint,
+		)
+		require.NoError(t, err)
+
+		onionPacket = processedPkt.NextPacket
+	}
+}
+
 type onionBlindingJsonTestCase struct {
 	Generate generateOnionData `json:"generate"`
 	Decrypt  decryptData       `json:"decrypt"`
@@ -369,10 +469,10 @@ type blindingJsonTestCase struct {
 }
 
 type onionMessageJsonTestCase struct {
-	Generate generateOnionMessageData `json:"generate"`
-	Route    routeOnionMessageData    `json:"route"`
-	// OnionMessage onionMessageData        `json:"onionmessage"`
-	Decrypt decryptOnionMessageData `json:"decrypt"`
+	Generate     generateOnionMessageData `json:"generate"`
+	Route        routeOnionMessageData    `json:"route"`
+	OnionMessage onionMessageData         `json:"onionmessage"`
+	Decrypt      decryptOnionMessageData  `json:"decrypt"`
 }
 
 type routeData struct {
@@ -387,6 +487,10 @@ type routeOnionMessageData struct {
 	Hops         []blindedOnionMessageHop `json:"hops"`
 }
 
+type onionMessageData struct {
+	OnionMessagePacket string `json:"onion_message_packet"`
+}
+
 type unblindData struct {
 	Hops []unblindedHop `json:"hops"`
 }