firewall: obfuscate BatchOpenChannel

We obfuscate fields from the batch channel open requests and
responses.

Author: bitromortac

firewall/privacy_mapper.go

@@ -12,6 +12,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/lightninglabs/lightning-terminal/firewalldb"
 	mid "github.com/lightninglabs/lightning-terminal/rpcmiddleware"
 	"github.com/lightninglabs/lightning-terminal/session"
@@ -296,6 +297,14 @@ func (p *PrivacyMapper) checkers(db firewalldb.PrivacyMapDB,
 			handlePendingChannelsResponse(db, flags, p.randIntn),
 			mid.PassThroughErrorHandler,
 		),
+
+		"/lnrpc.Lightning/BatchOpenChannel": mid.NewFullRewriter(
+			&lnrpc.BatchOpenChannelRequest{},
+			&lnrpc.BatchOpenChannelResponse{},
+			handleBatchOpenChannelRequest(db, flags),
+			handleBatchOpenChannelResponse(db, flags),
+			mid.PassThroughErrorHandler,
+		),
 	}
 }
 
@@ -1317,6 +1326,134 @@ func handlePendingChannelsResponse(db firewalldb.PrivacyMapDB,
 	}
 }
 
+func handleBatchOpenChannelRequest(db firewalldb.PrivacyMapDB,
+	flags session.PrivacyFlags) func(ctx context.Context,
+	r *lnrpc.BatchOpenChannelRequest) (proto.Message, error) {
+
+	return func(_ context.Context, r *lnrpc.BatchOpenChannelRequest) (
+		proto.Message, error) {
+
+		var reqs = make([]*lnrpc.BatchOpenChannel, len(r.Channels))
+
+		err := db.View(func(tx firewalldb.PrivacyMapTx) error {
+			for i, c := range r.Channels {
+				var err error
+
+				// Note, this only works if the obfuscated
+				// pubkey was already created via other
+				// calls, e.g. via ListChannels or
+				// GetInfo or the like.
+				nodePubkey := c.NodePubkey
+				if !flags.Contains(session.ClearPubkeys) {
+					nodePubkey, err = firewalldb.RevealBytes(
+						tx, c.NodePubkey,
+					)
+					if err != nil {
+						return err
+					}
+				}
+
+				reqs[i] = &lnrpc.BatchOpenChannel{
+					// Obfuscated fields.
+					NodePubkey: nodePubkey,
+
+					// Non-obfuscated fields.
+					LocalFundingAmount:         c.LocalFundingAmount,
+					PushSat:                    c.PushSat,
+					Private:                    c.Private,
+					MinHtlcMsat:                c.MinHtlcMsat,
+					RemoteCsvDelay:             c.RemoteCsvDelay,
+					CloseAddress:               c.CloseAddress,
+					PendingChanId:              c.PendingChanId,
+					CommitmentType:             c.CommitmentType,
+					RemoteMaxValueInFlightMsat: c.RemoteMaxValueInFlightMsat,
+					RemoteMaxHtlcs:             c.RemoteMaxHtlcs,
+					MaxLocalCsv:                c.MaxLocalCsv,
+					ZeroConf:                   c.ZeroConf,
+					ScidAlias:                  c.ScidAlias,
+					BaseFee:                    c.BaseFee,
+					FeeRate:                    c.FeeRate,
+					UseBaseFee:                 c.UseBaseFee,
+					UseFeeRate:                 c.UseFeeRate,
+					RemoteChanReserveSat:       c.RemoteChanReserveSat,
+					Memo:                       c.Memo,
+				}
+			}
+
+			return nil
+		})
+		if err != nil {
+			return nil, err
+		}
+
+		return &lnrpc.BatchOpenChannelRequest{
+			Channels:         reqs,
+			TargetConf:       r.TargetConf,
+			SatPerVbyte:      r.SatPerVbyte,
+			MinConfs:         r.MinConfs,
+			SpendUnconfirmed: r.SpendUnconfirmed,
+			Label:            r.Label,
+		}, nil
+	}
+}
+
+func handleBatchOpenChannelResponse(db firewalldb.PrivacyMapDB,
+	flags session.PrivacyFlags) func(ctx context.Context,
+	r *lnrpc.BatchOpenChannelResponse) (proto.Message, error) {
+
+	return func(_ context.Context, r *lnrpc.BatchOpenChannelResponse) (
+		proto.Message, error) {
+
+		resps := make([]*lnrpc.PendingUpdate, len(r.PendingChannels))
+
+		err := db.Update(func(tx firewalldb.PrivacyMapTx) error {
+			for i, p := range r.PendingChannels {
+				var (
+					txIdBytes   = p.Txid
+					outputIndex = p.OutputIndex
+				)
+
+				if !flags.Contains(session.ClearChanIDs) {
+					txId, err := chainhash.NewHash(p.Txid)
+					if err != nil {
+						return err
+					}
+
+					txID, outIdx, err := firewalldb.HideChanPoint(
+						tx, txId.String(), p.OutputIndex,
+					)
+					if err != nil {
+						return err
+					}
+					outputIndex = outIdx
+
+					txHash, err := chainhash.NewHashFromStr(
+						txID,
+					)
+					if err != nil {
+						return err
+					}
+					txIdBytes = txHash[:]
+				}
+
+				resps[i] = &lnrpc.PendingUpdate{
+					Txid:        txIdBytes,
+					OutputIndex: outputIndex,
+				}
+			}
+
+			return nil
+		})
+		if err != nil {
+			return nil, err
+		}
+
+		return &lnrpc.BatchOpenChannelResponse{
+			PendingChannels: resps,
+		}, nil
+	}
+}
+
 // maybeHideAmount hides an amount if the privacy flag is not set.
 func maybeHideAmount(flags session.PrivacyFlags, randIntn func(int) (int,
 	error), a int64) (int64, error) {

firewall/privacy_mapper_test.go

@@ -27,8 +27,11 @@ func TestPrivacyMapper(t *testing.T) {
 
 	// Define some transaction outpoints used for mapping.
 	clearTxID := "abcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcd"
+	clearTxIDReveresed, err := chainhash.NewHashFromStr(clearTxID)
+	require.NoError(t, err)
 
 	obfusTxID0 := "097ef666a61919ff3413b3b701eae3a5cbac08f70c0ca567806e1fa6acbfe384"
+	require.NoError(t, err)
 	obfusOut0 := uint32(2161781494)
 	obfusTxID0Reversed, err := chainhash.NewHashFromStr(obfusTxID0)
 	require.NoError(t, err)
@@ -672,6 +675,59 @@ func TestPrivacyMapper(t *testing.T) {
 				},
 			},
 		},
+		{
+			name:    "BatchOpenChannel Request",
+			uri:     "/lnrpc.Lightning/BatchOpenChannel",
+			msgType: rpcperms.TypeRequest,
+			msg: &lnrpc.BatchOpenChannelRequest{
+				TargetConf: 6,
+				Channels: []*lnrpc.BatchOpenChannel{
+					{
+						NodePubkey: []byte{
+							200, 19, 68, 149,
+						},
+						LocalFundingAmount: 1_000_000,
+						PushSat:            1_000_000,
+						MinHtlcMsat:        100,
+					},
+				},
+			},
+			expectedReplacement: &lnrpc.BatchOpenChannelRequest{
+				TargetConf: 6,
+				Channels: []*lnrpc.BatchOpenChannel{
+					{
+						NodePubkey: []byte{
+							1, 2, 3, 4,
+						},
+						LocalFundingAmount: 1_000_000,
+						PushSat:            1_000_000,
+						MinHtlcMsat:        100,
+					},
+				},
+			},
+		},
+		{
+			name:    "BatchOpenChannel Response",
+			uri:     "/lnrpc.Lightning/BatchOpenChannel",
+			msgType: rpcperms.TypeResponse,
+			msg: &lnrpc.BatchOpenChannelResponse{
+				PendingChannels: []*lnrpc.PendingUpdate{
+					{
+
+						Txid:        clearTxIDReveresed[:],
+						OutputIndex: 0,
+					},
+				},
+			},
+			expectedReplacement: &lnrpc.BatchOpenChannelResponse{
+				PendingChannels: []*lnrpc.PendingUpdate{
+					{
+						Txid:        obfusTxID0Reversed[:],
+						OutputIndex: obfusOut0,
+					},
+				},
+			},
+		},
 	}
 
 	decodedID := &lnrpc.MacaroonId{