13211764208

Committed 08 Feb 2025 03:08AM UTC coverage: 49.288% (-9.5%) from 58.815%

Build # 13211764208

Build Type

Pull #9489

github

Committed by

calvinrzachman

Commit Message

itest: verify switchrpc server enforces send then track

We prevent the rpc server from allowing onion dispatches for
attempt IDs which have already been tracked by rpc clients.

This helps protect the client from leaking a duplicate onion
attempt. NOTE: This is not the only method for solving this
issue! The issue could be addressed via careful client side
programming which accounts for the uncertainty and async
nature of dispatching onions to a remote process via RPC.
This would require some lnd ChannelRouter changes for how
we intend to use these RPCs though.

Pull Request Pull Request #9489: multi: add BuildOnion, SendOnion, and TrackOnion RPCs

Run Details

474 of 990 new or added lines in 11 files covered. (47.88%)

27321 existing lines in 435 files now uncovered.

101192 of 205306 relevant lines covered (49.29%)

1.54 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/channeldb/migration27/migration.go

package migration27

import (
        "bytes"
        "fmt"

        mig26 "github.com/lightningnetwork/lnd/channeldb/migration26"
        mig "github.com/lightningnetwork/lnd/channeldb/migration_01_to_11"
        "github.com/lightningnetwork/lnd/kvdb"
)

var (
        // historicalChannelBucket stores all channels that have seen their
        // commitment tx confirm. All information from their previous open state
        // is retained.
        historicalChannelBucket = []byte("historical-chan-bucket")
)

// MigrateHistoricalBalances patches the two new fields, `InitialLocalBalance`
// and `InitialRemoteBalance`, for all the open channels saved in historical
// channel bucket. Unlike migration 25, it will only read the old channel info
// first and then patch the new tlv records with empty values. For historical
// channels, we previously didn't save the initial balances anywhere and since
// it's corresponding open channel bucket is deleted after closure, we have
// lost that balance info.
func MigrateHistoricalBalances(tx kvdb.RwTx) error {
        log.Infof("Migrating historical local and remote balances...")

        // First fetch the top level bucket which stores all data related to
        // historically stored channels.
        rootBucket := tx.ReadWriteBucket(historicalChannelBucket)

        // If no bucket is found, we can exit early.
        if rootBucket == nil {
                return nil
        }

        // Read a list of historical channels.
        channels, err := findHistoricalChannels(rootBucket)
        if err != nil {
                return err
        }

        // Migrate the balances.
        for _, c := range channels {
                if err := migrateBalances(rootBucket, c); err != nil {
                        return err
                }
        }

        return err
}

// findHistoricalChannels finds all historical channels.
func findHistoricalChannels(historicalBucket kvdb.RBucket) ([]*OpenChannel,
        error) {

        channels := []*OpenChannel{}

        // readChannel is a helper closure that reads the channel info from the
        // historical sub-bucket.
        readChannel := func(rootBucket kvdb.RBucket, cp []byte) error {
                c := &OpenChannel{}

                chanPointBuf := bytes.NewBuffer(cp)
                err := mig.ReadOutpoint(chanPointBuf, &c.FundingOutpoint)
                if err != nil {
                        return fmt.Errorf("read funding outpoint got: %w", err)
                }

                // Read the sub-bucket.
                chanBucket := rootBucket.NestedReadBucket(cp)
                if chanBucket == nil {
                        log.Errorf("unable to read bucket for chanPoint=%s",
                                c.FundingOutpoint)
                        return nil
                }

                // Try to fetch channel info in old format.
                err = fetchChanInfoCompatible(chanBucket, c, true)
                if err != nil {
                        return fmt.Errorf("%s: fetch chan info got: %w",
                                c.FundingOutpoint, err)
                }

                channels = append(channels, c)

                return nil
        }

        // Iterate the root bucket.
        err := historicalBucket.ForEach(func(cp, _ []byte) error {
                return readChannel(historicalBucket, cp)
        })

        if err != nil {
                return nil, err
        }

        return channels, nil
}

// fetchChanInfoCompatible tries to fetch the channel info for a historical
// channel. It will first fetch the info assuming `InitialLocalBalance` and
// `InitialRemoteBalance` are not serialized. Upon receiving an error, it will
// then fetch it again assuming the two fields are present in db.
func fetchChanInfoCompatible(chanBucket kvdb.RBucket, c *OpenChannel,
        legacy bool) error {

        // Try to fetch the channel info assuming the historical channel in in
        // the old format, where the two fields, `InitialLocalBalance` and
        // `InitialRemoteBalance` are not saved to db.
        err := FetchChanInfo(chanBucket, c, legacy)
        if err == nil {
                return err
        }

        // If we got an error above, the historical channel may already have
        // the new fields saved. This could happen when a channel is closed
        // after applying migration 25. In this case, we'll borrow the
        // `FetchChanInfo` info method from migration 26 where we assume the
        // two fields are saved.
        return mig26.FetchChanInfo(chanBucket, &c.OpenChannel, legacy)
}

// migrateBalances serializes the channel info using the new tlv format where
// the two fields, `InitialLocalBalance` and `InitialRemoteBalance` are patched
// with empty values.
func migrateBalances(rootBucket kvdb.RwBucket, c *OpenChannel) error {
        var chanPointBuf bytes.Buffer
        err := mig.WriteOutpoint(&chanPointBuf, &c.FundingOutpoint)
        if err != nil {
                return err
        }

        // Get the channel bucket.
        chanBucket := rootBucket.NestedReadWriteBucket(chanPointBuf.Bytes())
        if chanBucket == nil {
                return fmt.Errorf("empty historical chan bucket")
        }

        // Update the channel info.
        if err := PutChanInfo(chanBucket, c, false); err != nil {
                return fmt.Errorf("unable to put chan info: %w", err)
        }

        return nil
}

1	package migration27
2
3	import (
4	"bytes"
5	"fmt"
6
7	mig26 "github.com/lightningnetwork/lnd/channeldb/migration26"
8	mig "github.com/lightningnetwork/lnd/channeldb/migration_01_to_11"
9	"github.com/lightningnetwork/lnd/kvdb"
10	)
11
12	var (
13	// historicalChannelBucket stores all channels that have seen their
14	// commitment tx confirm. All information from their previous open state
15	// is retained.
16	historicalChannelBucket = []byte("historical-chan-bucket")
17	)
18
19	// MigrateHistoricalBalances patches the two new fields, `InitialLocalBalance`
20	// and `InitialRemoteBalance`, for all the open channels saved in historical
21	// channel bucket. Unlike migration 25, it will only read the old channel info
22	// first and then patch the new tlv records with empty values. For historical
23	// channels, we previously didn't save the initial balances anywhere and since
24	// it's corresponding open channel bucket is deleted after closure, we have
25	// lost that balance info.
UNCOV 26	func MigrateHistoricalBalances(tx kvdb.RwTx) error {	×
UNCOV 27	log.Infof("Migrating historical local and remote balances...")	×
UNCOV 28		×
UNCOV 29	// First fetch the top level bucket which stores all data related to	×
UNCOV 30	// historically stored channels.	×
UNCOV 31	rootBucket := tx.ReadWriteBucket(historicalChannelBucket)	×
UNCOV 32		×
UNCOV 33	// If no bucket is found, we can exit early.	×
UNCOV 34	if rootBucket == nil {	×
35	return nil	×
36	}	×
37
38	// Read a list of historical channels.
UNCOV 39	channels, err := findHistoricalChannels(rootBucket)	×
UNCOV 40	if err != nil {	×
41	return err	×
42	}	×
43
44	// Migrate the balances.
UNCOV 45	for _, c := range channels {	×
UNCOV 46	if err := migrateBalances(rootBucket, c); err != nil {	×
47	return err	×
48	}	×
49	}
50
UNCOV 51	return err	×
52	}
53
54	// findHistoricalChannels finds all historical channels.
55	func findHistoricalChannels(historicalBucket kvdb.RBucket) ([]*OpenChannel,
UNCOV 56	error) {	×
UNCOV 57		×
UNCOV 58	channels := []*OpenChannel{}	×
UNCOV 59		×
UNCOV 60	// readChannel is a helper closure that reads the channel info from the	×
UNCOV 61	// historical sub-bucket.	×
UNCOV 62	readChannel := func(rootBucket kvdb.RBucket, cp []byte) error {	×
UNCOV 63	c := &OpenChannel{}	×
UNCOV 64		×
UNCOV 65	chanPointBuf := bytes.NewBuffer(cp)	×
UNCOV 66	err := mig.ReadOutpoint(chanPointBuf, &c.FundingOutpoint)	×
UNCOV 67	if err != nil {	×
68	return fmt.Errorf("read funding outpoint got: %w", err)	×
69	}	×
70
71	// Read the sub-bucket.
UNCOV 72	chanBucket := rootBucket.NestedReadBucket(cp)	×
UNCOV 73	if chanBucket == nil {	×
74	log.Errorf("unable to read bucket for chanPoint=%s",	×
75	c.FundingOutpoint)	×
76	return nil	×
77	}	×
78
79	// Try to fetch channel info in old format.
UNCOV 80	err = fetchChanInfoCompatible(chanBucket, c, true)	×
UNCOV 81	if err != nil {	×
82	return fmt.Errorf("%s: fetch chan info got: %w",	×
83	c.FundingOutpoint, err)	×
84	}	×
85
UNCOV 86	channels = append(channels, c)	×
UNCOV 87		×
UNCOV 88	return nil	×
89	}
90
91	// Iterate the root bucket.
UNCOV 92	err := historicalBucket.ForEach(func(cp, _ []byte) error {	×
UNCOV 93	return readChannel(historicalBucket, cp)	×
UNCOV 94	})	×
95
UNCOV 96	if err != nil {	×
97	return nil, err	×
98	}	×
99
UNCOV 100	return channels, nil	×
101	}
102
103	// fetchChanInfoCompatible tries to fetch the channel info for a historical
104	// channel. It will first fetch the info assuming `InitialLocalBalance` and
105	// `InitialRemoteBalance` are not serialized. Upon receiving an error, it will
106	// then fetch it again assuming the two fields are present in db.
107	func fetchChanInfoCompatible(chanBucket kvdb.RBucket, c *OpenChannel,
UNCOV 108	legacy bool) error {	×
UNCOV 109		×
UNCOV 110	// Try to fetch the channel info assuming the historical channel in in	×
UNCOV 111	// the old format, where the two fields, `InitialLocalBalance` and	×
UNCOV 112	// `InitialRemoteBalance` are not saved to db.	×
UNCOV 113	err := FetchChanInfo(chanBucket, c, legacy)	×
UNCOV 114	if err == nil {	×
UNCOV 115	return err	×
UNCOV 116	}	×
117
118	// If we got an error above, the historical channel may already have
119	// the new fields saved. This could happen when a channel is closed
120	// after applying migration 25. In this case, we'll borrow the
121	// `FetchChanInfo` info method from migration 26 where we assume the
122	// two fields are saved.
UNCOV 123	return mig26.FetchChanInfo(chanBucket, &c.OpenChannel, legacy)	×
124	}
125
126	// migrateBalances serializes the channel info using the new tlv format where
127	// the two fields, `InitialLocalBalance` and `InitialRemoteBalance` are patched
128	// with empty values.
UNCOV 129	func migrateBalances(rootBucket kvdb.RwBucket, c *OpenChannel) error {	×
UNCOV 130	var chanPointBuf bytes.Buffer	×
UNCOV 131	err := mig.WriteOutpoint(&chanPointBuf, &c.FundingOutpoint)	×
UNCOV 132	if err != nil {	×
133	return err	×
134	}	×
135
136	// Get the channel bucket.
UNCOV 137	chanBucket := rootBucket.NestedReadWriteBucket(chanPointBuf.Bytes())	×
UNCOV 138	if chanBucket == nil {	×
139	return fmt.Errorf("empty historical chan bucket")	×
140	}	×
141
142	// Update the channel info.
UNCOV 143	if err := PutChanInfo(chanBucket, c, false); err != nil {	×
144	return fmt.Errorf("unable to put chan info: %w", err)	×
145	}	×
146
UNCOV 147	return nil	×
148	}

lightningnetwork / lnd / 13211764208

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous