firewall: register the ForwardingAbility endpoint

Pubkeys in the Peers field are obfuscated. Other data is averaged over
large timespans usually, so that doesn't lead to privacy leaks.

Author: bitromortac

firewall/privacy_mapper.go

@@ -13,6 +13,7 @@ import (
 	"time"
 
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/lightninglabs/faraday/frdrpc"
 	"github.com/lightninglabs/lightning-terminal/firewalldb"
 	mid "github.com/lightninglabs/lightning-terminal/rpcmiddleware"
 	"github.com/lightninglabs/lightning-terminal/session"
@@ -535,6 +536,13 @@ func (p *PrivacyMapper) checkers(db firewalldb.PrivacyMapDB,
 	flags session.PrivacyFlags) map[string]mid.RoundTripChecker {
 
 	return map[string]mid.RoundTripChecker{
+		//nolint:ll
+		"/frdrpc.FaradayServer/ForwardingAbility": mid.NewResponseRewriter(
+			&frdrpc.ForwardingAbilityRequest{},
+			&frdrpc.ForwardingAbilityResponse{},
+			handleForwardingAbilityResponse(db, flags),
+			mid.PassThroughErrorHandler,
+		),
 		"/lnrpc.Lightning/GetInfo": mid.NewResponseRewriter(
 			&lnrpc.GetInfoRequest{}, &lnrpc.GetInfoResponse{},
 			handleGetInfoResponse(db, flags),
@@ -585,7 +593,6 @@ func (p *PrivacyMapper) checkers(db firewalldb.PrivacyMapDB,
 			handlePendingChannelsResponse(db, flags, p.randIntn),
 			mid.PassThroughErrorHandler,
 		),
-
 		"/lnrpc.Lightning/BatchOpenChannel": mid.NewFullRewriter(
 			&lnrpc.BatchOpenChannelRequest{},
 			&lnrpc.BatchOpenChannelResponse{},
@@ -600,7 +607,6 @@ func (p *PrivacyMapper) checkers(db firewalldb.PrivacyMapDB,
 			handleChannelOpenResponse(db, flags),
 			mid.PassThroughErrorHandler,
 		),
-
 		"/lnrpc.Lightning/ConnectPeer": mid.NewRequestRewriter(
 			&lnrpc.ConnectPeerRequest{},
 			&lnrpc.ConnectPeerResponse{},
@@ -609,6 +615,69 @@ func (p *PrivacyMapper) checkers(db firewalldb.PrivacyMapDB,
 	}
 }
 
+func handleForwardingAbilityResponse(db firewalldb.PrivacyMapDB,
+	flags session.PrivacyFlags) func(ctx context.Context,
+	r *frdrpc.ForwardingAbilityResponse) (proto.Message, error) {
+
+	return func(ctx context.Context, r *frdrpc.ForwardingAbilityResponse) (
+		proto.Message, error) {
+
+		// When pubkey hiding is disabled or there are no peers to
+		// obfuscate, pass the response through untouched and avoid
+		// opening a write transaction.
+		if flags.Contains(session.ClearPubkeys) || len(r.Peers) == 0 {
+			return r, nil
+		}
+
+		// The response addresses peers by index from a shared peer
+		// list, so obfuscate each peer in place to keep the entries'
+		// packed indices valid. The list need not stay sorted because
+		// decoding resolves peers purely by index.
+		peers := make([][]byte, len(r.Peers))
+
+		err := db.Update(ctx, func(ctx context.Context,
+			tx firewalldb.PrivacyMapTx) error {
+
+			for i, p := range r.Peers {
+				// Skip empty pubkeys to avoid storing a
+				// degenerate empty-to-empty mapping.
+				if len(p) == 0 {
+					peers[i] = p
+
+					continue
+				}
+
+				// Hide the pubkey so a peer maps to the same
+				// pseudonym across RPCs.
+				pseudoBytes, err := firewalldb.HideBytes(
+					ctx, tx, p,
+				)
+				if err != nil {
+					return err
+				}
+
+				peers[i] = pseudoBytes
+			}
+
+			return nil
+		})
+		if err != nil {
+			return nil, err
+		}
+
+		// Peers are obfuscated in place, so the index-keyed entries and
+		// up-but-idle bitmask stay valid and pass through unchanged.
+		return &frdrpc.ForwardingAbilityResponse{
+			Peers:            peers,
+			Entries:          r.Entries,
+			StartTime:        r.StartTime,
+			EndTime:          r.EndTime,
+			UpButIdleBitmask: r.UpButIdleBitmask,
+			UptimeThreshold:  r.UptimeThreshold,
+		}, nil
+	}
+}
+
 func handleGetInfoResponse(db firewalldb.PrivacyMapDB,
 	flags session.PrivacyFlags) func(ctx context.Context,
 	r *lnrpc.GetInfoResponse) (proto.Message, error) {

firewall/privacy_mapper_test.go

@@ -85,6 +85,7 @@ func TestPrivacyMapper(t *testing.T) {
 		outPoint(clearTxID, 0):  outPoint(obfusTxID0, obfusOut0),
 		outPoint(clearTxID, 1):  outPoint(obfusTxID1, obfusOut1),
 		"01020304":              "c8134495",
+		"05060708":              "a1b2c3d4",
 		"secret-host.com":       "sksiuekalkdoowurekdf",
 	}
 
@@ -151,6 +152,115 @@ func TestPrivacyMapper(t *testing.T) {
 		msg                 proto.Message
 		expectedReplacement proto.Message
 	}{
+		{
+			name:    "ForwardingAbility Response",
+			uri:     "/frdrpc.FaradayServer/ForwardingAbility",
+			msgType: rpcperms.TypeResponse,
+			msg: &frdrpc.ForwardingAbilityResponse{
+				Peers: [][]byte{{0x01, 0x02, 0x03, 0x04}},
+				Entries: []*frdrpc.ForwardingAbilityEntry{{
+					PackedIdx:        0,
+					EffectiveUptimeS: 90,
+					ForwardedSat:     100,
+				}},
+			},
+			expectedReplacement: &frdrpc.ForwardingAbilityResponse{
+				Peers: [][]byte{{0xc8, 0x13, 0x44, 0x95}},
+				Entries: []*frdrpc.ForwardingAbilityEntry{{
+					PackedIdx:        0,
+					EffectiveUptimeS: 90,
+					ForwardedSat:     100,
+				}},
+			},
+		},
+		{
+			// Multiple peers, including a repeated one, must map to
+			// the same pseudonym so the index-keyed entries stay
+			// valid.
+			name:    "ForwardingAbility Response multiple peers",
+			uri:     "/frdrpc.FaradayServer/ForwardingAbility",
+			msgType: rpcperms.TypeResponse,
+			msg: &frdrpc.ForwardingAbilityResponse{
+				Peers: [][]byte{
+					{0x01, 0x02, 0x03, 0x04},
+					{0x05, 0x06, 0x07, 0x08},
+					{0x01, 0x02, 0x03, 0x04},
+				},
+				Entries: []*frdrpc.ForwardingAbilityEntry{
+					{
+						PackedIdx:        0,
+						EffectiveUptimeS: 90,
+						ForwardedSat:     100,
+					},
+					{
+						PackedIdx:        1,
+						EffectiveUptimeS: 80,
+						ForwardedSat:     200,
+					},
+					{
+						PackedIdx:        2,
+						EffectiveUptimeS: 70,
+						ForwardedSat:     300,
+					},
+				},
+			},
+			expectedReplacement: &frdrpc.ForwardingAbilityResponse{
+				Peers: [][]byte{
+					{0xc8, 0x13, 0x44, 0x95},
+					{0xa1, 0xb2, 0xc3, 0xd4},
+					{0xc8, 0x13, 0x44, 0x95},
+				},
+				Entries: []*frdrpc.ForwardingAbilityEntry{
+					{
+						PackedIdx:        0,
+						EffectiveUptimeS: 90,
+						ForwardedSat:     100,
+					},
+					{
+						PackedIdx:        1,
+						EffectiveUptimeS: 80,
+						ForwardedSat:     200,
+					},
+					{
+						PackedIdx:        2,
+						EffectiveUptimeS: 70,
+						ForwardedSat:     300,
+					},
+				},
+			},
+		},
+		{
+			// With ClearPubkeys set the peers must pass through
+			// without obfuscation.
+			name:    "ForwardingAbility Response clear pubkey",
+			uri:     "/frdrpc.FaradayServer/ForwardingAbility",
+			msgType: rpcperms.TypeResponse,
+			privacyFlags: session.PrivacyFlags{
+				session.ClearPubkeys,
+			},
+			msg: &frdrpc.ForwardingAbilityResponse{
+				Peers: [][]byte{
+					{0x01, 0x02, 0x03, 0x04},
+					{0x05, 0x06, 0x07, 0x08},
+				},
+				Entries: []*frdrpc.ForwardingAbilityEntry{{
+					PackedIdx:        0,
+					EffectiveUptimeS: 90,
+					ForwardedSat:     100,
+				}},
+			},
+			expectedReplacement: &frdrpc.ForwardingAbilityResponse{
+				Peers: [][]byte{
+					{0x01, 0x02, 0x03, 0x04},
+					{0x05, 0x06, 0x07, 0x08},
+				},
+				Entries: []*frdrpc.ForwardingAbilityEntry{{
+					PackedIdx:        0,
+					EffectiveUptimeS: 90,
+					ForwardedSat:     100,
+				}},
+			},
+		},
 		{
 			name:    "GetInfo Response",
 			uri:     "/lnrpc.Lightning/GetInfo",