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

25.93

/graph/db/models/channel_edge_policy.go

package models

import (
        "fmt"
        "time"

        "github.com/btcsuite/btcd/btcec/v2/ecdsa"
        "github.com/lightningnetwork/lnd/lnwire"
)

// ChannelEdgePolicy represents a *directed* edge within the channel graph. For
// each channel in the database, there are two distinct edges: one for each
// possible direction of travel along the channel. The edges themselves hold
// information concerning fees, and minimum time-lock information which is
// utilized during path finding.
type ChannelEdgePolicy struct {
        // SigBytes is the raw bytes of the signature of the channel edge
        // policy. We'll only parse these if the caller needs to access the
        // signature for validation purposes. Do not set SigBytes directly, but
        // use SetSigBytes instead to make sure that the cache is invalidated.
        SigBytes []byte

        // sig is a cached fully parsed signature.
        sig *ecdsa.Signature

        // ChannelID is the unique channel ID for the channel. The first 3
        // bytes are the block height, the next 3 the index within the block,
        // and the last 2 bytes are the output index for the channel.
        ChannelID uint64

        // LastUpdate is the last time an authenticated edge for this channel
        // was received.
        LastUpdate time.Time

        // MessageFlags is a bitfield which indicates the presence of optional
        // fields (like max_htlc) in the policy.
        MessageFlags lnwire.ChanUpdateMsgFlags

        // ChannelFlags is a bitfield which signals the capabilities of the
        // channel as well as the directed edge this update applies to.
        ChannelFlags lnwire.ChanUpdateChanFlags

        // TimeLockDelta is the number of blocks this node will subtract from
        // the expiry of an incoming HTLC. This value expresses the time buffer
        // the node would like to HTLC exchanges.
        TimeLockDelta uint16

        // MinHTLC is the smallest value HTLC this node will forward, expressed
        // in millisatoshi.
        MinHTLC lnwire.MilliSatoshi

        // MaxHTLC is the largest value HTLC this node will forward, expressed
        // in millisatoshi.
        MaxHTLC lnwire.MilliSatoshi

        // FeeBaseMSat is the base HTLC fee that will be charged for forwarding
        // ANY HTLC, expressed in mSAT's.
        FeeBaseMSat lnwire.MilliSatoshi

        // FeeProportionalMillionths is the rate that the node will charge for
        // HTLCs for each millionth of a satoshi forwarded.
        FeeProportionalMillionths lnwire.MilliSatoshi

        // ToNode is the public key of the node that this directed edge leads
        // to. Using this pub key, the channel graph can further be traversed.
        ToNode [33]byte

        // ExtraOpaqueData is the set of data that was appended to this
        // message, some of which we may not actually know how to iterate or
        // parse. By holding onto this data, we ensure that we're able to
        // properly validate the set of signatures that cover these new fields,
        // and ensure we're able to make upgrades to the network in a forwards
        // compatible manner.
        ExtraOpaqueData lnwire.ExtraOpaqueData
}

// Signature is a channel announcement signature, which is needed for proper
// edge policy announcement.
//
// NOTE: By having this method to access an attribute, we ensure we only need
// to fully deserialize the signature if absolutely necessary.
func (c *ChannelEdgePolicy) Signature() (*ecdsa.Signature, error) {
        if c.sig != nil {
                return c.sig, nil
        }

        sig, err := ecdsa.ParseSignature(c.SigBytes)
        if err != nil {
                return nil, err
        }

        c.sig = sig

        return sig, nil
}

// SetSigBytes updates the signature and invalidates the cached parsed
// signature.
func (c *ChannelEdgePolicy) SetSigBytes(sig []byte) {
        c.SigBytes = sig
        c.sig = nil
}

// IsDisabled determines whether the edge has the disabled bit set.
func (c *ChannelEdgePolicy) IsDisabled() bool {
        return c.ChannelFlags.IsDisabled()
}

// ComputeFee computes the fee to forward an HTLC of `amt` milli-satoshis over
// the passed active payment channel. This value is currently computed as
// specified in BOLT07, but will likely change in the near future.
func (c *ChannelEdgePolicy) ComputeFee(
        amt lnwire.MilliSatoshi) lnwire.MilliSatoshi {

        return c.FeeBaseMSat + (amt*c.FeeProportionalMillionths)/feeRateParts
}

// String returns a human-readable version of the channel edge policy.
func (c *ChannelEdgePolicy) String() string {
        return fmt.Sprintf("ChannelID=%v, MessageFlags=%v, ChannelFlags=%v, "+
                "LastUpdate=%v", c.ChannelID, c.MessageFlags, c.ChannelFlags,
                c.LastUpdate)
}

1	package models
2
3	import (
4	"fmt"
5	"time"
6
7	"github.com/btcsuite/btcd/btcec/v2/ecdsa"
8	"github.com/lightningnetwork/lnd/lnwire"
9	)
10
11	// ChannelEdgePolicy represents a directed edge within the channel graph. For
12	// each channel in the database, there are two distinct edges: one for each
13	// possible direction of travel along the channel. The edges themselves hold
14	// information concerning fees, and minimum time-lock information which is
15	// utilized during path finding.
16	type ChannelEdgePolicy struct {
17	// SigBytes is the raw bytes of the signature of the channel edge
18	// policy. We'll only parse these if the caller needs to access the
19	// signature for validation purposes. Do not set SigBytes directly, but
20	// use SetSigBytes instead to make sure that the cache is invalidated.
21	SigBytes []byte
22
23	// sig is a cached fully parsed signature.
24	sig *ecdsa.Signature
25
26	// ChannelID is the unique channel ID for the channel. The first 3
27	// bytes are the block height, the next 3 the index within the block,
28	// and the last 2 bytes are the output index for the channel.
29	ChannelID uint64
30
31	// LastUpdate is the last time an authenticated edge for this channel
32	// was received.
33	LastUpdate time.Time
34
35	// MessageFlags is a bitfield which indicates the presence of optional
36	// fields (like max_htlc) in the policy.
37	MessageFlags lnwire.ChanUpdateMsgFlags
38
39	// ChannelFlags is a bitfield which signals the capabilities of the
40	// channel as well as the directed edge this update applies to.
41	ChannelFlags lnwire.ChanUpdateChanFlags
42
43	// TimeLockDelta is the number of blocks this node will subtract from
44	// the expiry of an incoming HTLC. This value expresses the time buffer
45	// the node would like to HTLC exchanges.
46	TimeLockDelta uint16
47
48	// MinHTLC is the smallest value HTLC this node will forward, expressed
49	// in millisatoshi.
50	MinHTLC lnwire.MilliSatoshi
51
52	// MaxHTLC is the largest value HTLC this node will forward, expressed
53	// in millisatoshi.
54	MaxHTLC lnwire.MilliSatoshi
55
56	// FeeBaseMSat is the base HTLC fee that will be charged for forwarding
57	// ANY HTLC, expressed in mSAT's.
58	FeeBaseMSat lnwire.MilliSatoshi
59
60	// FeeProportionalMillionths is the rate that the node will charge for
61	// HTLCs for each millionth of a satoshi forwarded.
62	FeeProportionalMillionths lnwire.MilliSatoshi
63
64	// ToNode is the public key of the node that this directed edge leads
65	// to. Using this pub key, the channel graph can further be traversed.
66	ToNode [33]byte
67
68	// ExtraOpaqueData is the set of data that was appended to this
69	// message, some of which we may not actually know how to iterate or
70	// parse. By holding onto this data, we ensure that we're able to
71	// properly validate the set of signatures that cover these new fields,
72	// and ensure we're able to make upgrades to the network in a forwards
73	// compatible manner.
74	ExtraOpaqueData lnwire.ExtraOpaqueData
75	}
76
77	// Signature is a channel announcement signature, which is needed for proper
78	// edge policy announcement.
79	//
80	// NOTE: By having this method to access an attribute, we ensure we only need
81	// to fully deserialize the signature if absolutely necessary.
82	func (c ChannelEdgePolicy) Signature() (ecdsa.Signature, error) {	×
83	if c.sig != nil {	×
84	return c.sig, nil	×
85	}	×
86
87	sig, err := ecdsa.ParseSignature(c.SigBytes)	×
88	if err != nil {	×
89	return nil, err	×
90	}	×
91
92	c.sig = sig	×
93		×
94	return sig, nil	×
95	}
96
97	// SetSigBytes updates the signature and invalidates the cached parsed
98	// signature.
99	func (c *ChannelEdgePolicy) SetSigBytes(sig []byte) {	3✔
100	c.SigBytes = sig	3✔
101	c.sig = nil	3✔
102	}	3✔
103
104	// IsDisabled determines whether the edge has the disabled bit set.
105	func (c *ChannelEdgePolicy) IsDisabled() bool {	3✔
106	return c.ChannelFlags.IsDisabled()	3✔
107	}	3✔
108
109	// ComputeFee computes the fee to forward an HTLC of `amt` milli-satoshis over
110	// the passed active payment channel. This value is currently computed as
111	// specified in BOLT07, but will likely change in the near future.
112	func (c *ChannelEdgePolicy) ComputeFee(
UNCOV 113	amt lnwire.MilliSatoshi) lnwire.MilliSatoshi {	×
UNCOV 114		×
UNCOV 115	return c.FeeBaseMSat + (amt*c.FeeProportionalMillionths)/feeRateParts	×
UNCOV 116	}	×
117
118	// String returns a human-readable version of the channel edge policy.
119	func (c *ChannelEdgePolicy) String() string {	×
120	return fmt.Sprintf("ChannelID=%v, MessageFlags=%v, ChannelFlags=%v, "+	×
121	"LastUpdate=%v", c.ChannelID, c.MessageFlags, c.ChannelFlags,	×
122	c.LastUpdate)	×
123	}	×

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