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

/chainntnfs/btcdnotify/btcd_dev.go

//go:build dev
// +build dev

package btcdnotify

import (
        "fmt"
        "time"

        "github.com/btcsuite/btcd/chaincfg/chainhash"
        "github.com/lightningnetwork/lnd/chainntnfs"
)

// UnsafeStart starts the notifier with a specified best height and optional
// best hash. Its bestBlock and txNotifier are initialized with bestHeight and
// optionally bestHash. The parameter generateBlocks is necessary for the
// bitcoind notifier to ensure we drain all notifications up to syncHeight,
// since if they are generated ahead of UnsafeStart the chainConn may start up
// with an outdated best block and miss sending ntfns. Used for testing.
func (b *BtcdNotifier) UnsafeStart(bestHeight int32, bestHash *chainhash.Hash,
        syncHeight int32, generateBlocks func() error) error {

        // Connect to btcd, and register for notifications on connected, and
        // disconnected blocks.
        if err := b.chainConn.Connect(20); err != nil {
                return err
        }
        if err := b.chainConn.NotifyBlocks(); err != nil {
                return err
        }

        b.txNotifier = chainntnfs.NewTxNotifier(
                uint32(bestHeight), chainntnfs.ReorgSafetyLimit,
                b.confirmHintCache, b.spendHintCache,
        )

        b.chainUpdates.Start()
        b.txUpdates.Start()

        if generateBlocks != nil {
                // Ensure no block notifications are pending when we start the
                // notification dispatcher goroutine.

                // First generate the blocks, then drain the notifications
                // for the generated blocks.
                if err := generateBlocks(); err != nil {
                        return err
                }

                timeout := time.After(60 * time.Second)
        loop:
                for {
                        select {
                        case ntfn := <-b.chainUpdates.ChanOut():
                                lastReceivedNtfn := ntfn.(*chainUpdate)
                                if lastReceivedNtfn.blockHeight >= syncHeight {
                                        break loop
                                }
                        case <-timeout:
                                return fmt.Errorf("unable to catch up to height %d",
                                        syncHeight)
                        }
                }
        }

        // Run notificationDispatcher after setting the notifier's best block
        // to avoid a race condition.
        b.bestBlock = chainntnfs.BlockEpoch{Height: bestHeight, Hash: bestHash}
        if bestHash == nil {
                hash, err := b.chainConn.GetBlockHash(int64(bestHeight))
                if err != nil {
                        return err
                }
                b.bestBlock.Hash = hash
        }

        b.wg.Add(1)
        go b.notificationDispatcher()

        return nil
}

1	//go:build dev
2	// +build dev
3
4	package btcdnotify
5
6	import (
7	"fmt"
8	"time"
9
10	"github.com/btcsuite/btcd/chaincfg/chainhash"
11	"github.com/lightningnetwork/lnd/chainntnfs"
12	)
13
14	// UnsafeStart starts the notifier with a specified best height and optional
15	// best hash. Its bestBlock and txNotifier are initialized with bestHeight and
16	// optionally bestHash. The parameter generateBlocks is necessary for the
17	// bitcoind notifier to ensure we drain all notifications up to syncHeight,
18	// since if they are generated ahead of UnsafeStart the chainConn may start up
19	// with an outdated best block and miss sending ntfns. Used for testing.
20	func (b BtcdNotifier) UnsafeStart(bestHeight int32, bestHash chainhash.Hash,
UNCOV 21	syncHeight int32, generateBlocks func() error) error {	×
UNCOV 22		×
UNCOV 23	// Connect to btcd, and register for notifications on connected, and	×
UNCOV 24	// disconnected blocks.	×
UNCOV 25	if err := b.chainConn.Connect(20); err != nil {	×
26	return err	×
27	}	×
UNCOV 28	if err := b.chainConn.NotifyBlocks(); err != nil {	×
29	return err	×
30	}	×
31
UNCOV 32	b.txNotifier = chainntnfs.NewTxNotifier(	×
UNCOV 33	uint32(bestHeight), chainntnfs.ReorgSafetyLimit,	×
UNCOV 34	b.confirmHintCache, b.spendHintCache,	×
UNCOV 35	)	×
UNCOV 36		×
UNCOV 37	b.chainUpdates.Start()	×
UNCOV 38	b.txUpdates.Start()	×
UNCOV 39		×
UNCOV 40	if generateBlocks != nil {	×
UNCOV 41	// Ensure no block notifications are pending when we start the	×
UNCOV 42	// notification dispatcher goroutine.	×
UNCOV 43		×
UNCOV 44	// First generate the blocks, then drain the notifications	×
UNCOV 45	// for the generated blocks.	×
UNCOV 46	if err := generateBlocks(); err != nil {	×
47	return err	×
48	}	×
49
UNCOV 50	timeout := time.After(60 * time.Second)	×
UNCOV 51	loop:	×
UNCOV 52	for {	×
UNCOV 53	select {	×
UNCOV 54	case ntfn := <-b.chainUpdates.ChanOut():	×
UNCOV 55	lastReceivedNtfn := ntfn.(*chainUpdate)	×
UNCOV 56	if lastReceivedNtfn.blockHeight >= syncHeight {	×
UNCOV 57	break loop	×
58	}
59	case <-timeout:	×
60	return fmt.Errorf("unable to catch up to height %d",	×
61	syncHeight)	×
62	}
63	}
64	}
65
66	// Run notificationDispatcher after setting the notifier's best block
67	// to avoid a race condition.
UNCOV 68	b.bestBlock = chainntnfs.BlockEpoch{Height: bestHeight, Hash: bestHash}	×
UNCOV 69	if bestHash == nil {	×
UNCOV 70	hash, err := b.chainConn.GetBlockHash(int64(bestHeight))	×
UNCOV 71	if err != nil {	×
72	return err	×
73	}	×
UNCOV 74	b.bestBlock.Hash = hash	×
75	}
76
UNCOV 77	b.wg.Add(1)	×
UNCOV 78	go b.notificationDispatcher()	×
UNCOV 79		×
UNCOV 80	return nil	×
81	}

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