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

78.18

/lnwire/shutdown.go

package lnwire

import (
        "bytes"
        "io"

        "github.com/lightningnetwork/lnd/tlv"
)

type (
        // ShutdownNonceType is the type of the shutdown nonce TLV record.
        ShutdownNonceType = tlv.TlvType8

        // ShutdownNonceTLV is the TLV record that contains the shutdown nonce.
        ShutdownNonceTLV = tlv.OptionalRecordT[ShutdownNonceType, Musig2Nonce]
)

// SomeShutdownNonce returns a ShutdownNonceTLV with the given nonce.
func SomeShutdownNonce(nonce Musig2Nonce) ShutdownNonceTLV {
        return tlv.SomeRecordT(
                tlv.NewRecordT[ShutdownNonceType, Musig2Nonce](nonce),
        )
}

// Shutdown is sent by either side in order to initiate the cooperative closure
// of a channel. This message is sparse as both sides implicitly have the
// information necessary to construct a transaction that will send the settled
// funds of both parties to the final delivery addresses negotiated during the
// funding workflow.
type Shutdown struct {
        // ChannelID serves to identify which channel is to be closed.
        ChannelID ChannelID

        // Address is the script to which the channel funds will be paid.
        Address DeliveryAddress

        // ShutdownNonce is the nonce the sender will use to sign the first
        // co-op sign offer.
        ShutdownNonce ShutdownNonceTLV

        // CustomRecords maps TLV types to byte slices, storing arbitrary data
        // intended for inclusion in the ExtraData field of the Shutdown
        // message.
        CustomRecords CustomRecords

        // ExtraData is the set of data that was appended to this message to
        // fill out the full maximum transport message size. These fields can
        // be used to specify optional data such as custom TLV fields.
        ExtraData ExtraOpaqueData
}

// NewShutdown creates a new Shutdown message.
func NewShutdown(cid ChannelID, addr DeliveryAddress) *Shutdown {
        return &Shutdown{
                ChannelID: cid,
                Address:   addr,
        }
}

// A compile-time check to ensure Shutdown implements the lnwire.Message
// interface.
var _ Message = (*Shutdown)(nil)

// Decode deserializes a serialized Shutdown from the passed io.Reader,
// observing the specified protocol version.
//
// This is part of the lnwire.Message interface.
func (s *Shutdown) Decode(r io.Reader, pver uint32) error {
        err := ReadElements(r, &s.ChannelID, &s.Address)
        if err != nil {
                return err
        }

        var tlvRecords ExtraOpaqueData
        if err := ReadElements(r, &tlvRecords); err != nil {
                return err
        }

        // Extract TLV records from the extra data field.
        musigNonce := s.ShutdownNonce.Zero()

        customRecords, parsed, extraData, err := ParseAndExtractCustomRecords(
                tlvRecords, &musigNonce,
        )
        if err != nil {
                return err
        }

        // Assign the parsed records back to the message.
        if _, ok := parsed[musigNonce.TlvType()]; ok {
                s.ShutdownNonce = tlv.SomeRecordT(musigNonce)
        }

        s.CustomRecords = customRecords
        s.ExtraData = extraData

        return nil
}

// Encode serializes the target Shutdown into the passed io.Writer observing
// the protocol version specified.
//
// This is part of the lnwire.Message interface.
func (s *Shutdown) Encode(w *bytes.Buffer, pver uint32) error {
        if err := WriteChannelID(w, s.ChannelID); err != nil {
                return err
        }

        if err := WriteDeliveryAddress(w, s.Address); err != nil {
                return err
        }

        // Only include nonce in extra data if present.
        var records []tlv.RecordProducer
        s.ShutdownNonce.WhenSome(
                func(nonce tlv.RecordT[ShutdownNonceType, Musig2Nonce]) {
                        records = append(records, &nonce)
                },
        )

        extraData, err := MergeAndEncode(records, s.ExtraData, s.CustomRecords)
        if err != nil {
                return err
        }

        return WriteBytes(w, extraData)
}

// MsgType returns the integer uniquely identifying this message type on the
// wire.
//
// This is part of the lnwire.Message interface.
func (s *Shutdown) MsgType() MessageType {
        return MsgShutdown
}

1	package lnwire
2
3	import (
4	"bytes"
5	"io"
6
7	"github.com/lightningnetwork/lnd/tlv"
8	)
9
10	type (
11	// ShutdownNonceType is the type of the shutdown nonce TLV record.
12	ShutdownNonceType = tlv.TlvType8
13
14	// ShutdownNonceTLV is the TLV record that contains the shutdown nonce.
15	ShutdownNonceTLV = tlv.OptionalRecordT[ShutdownNonceType, Musig2Nonce]
16	)
17
18	// SomeShutdownNonce returns a ShutdownNonceTLV with the given nonce.
19	func SomeShutdownNonce(nonce Musig2Nonce) ShutdownNonceTLV {	3✔
20	return tlv.SomeRecordT(	3✔
21	tlv.NewRecordT[ShutdownNonceType, Musig2Nonce](nonce),	3✔
22	)	3✔
23	}	3✔
24
25	// Shutdown is sent by either side in order to initiate the cooperative closure
26	// of a channel. This message is sparse as both sides implicitly have the
27	// information necessary to construct a transaction that will send the settled
28	// funds of both parties to the final delivery addresses negotiated during the
29	// funding workflow.
30	type Shutdown struct {
31	// ChannelID serves to identify which channel is to be closed.
32	ChannelID ChannelID
33
34	// Address is the script to which the channel funds will be paid.
35	Address DeliveryAddress
36
37	// ShutdownNonce is the nonce the sender will use to sign the first
38	// co-op sign offer.
39	ShutdownNonce ShutdownNonceTLV
40
41	// CustomRecords maps TLV types to byte slices, storing arbitrary data
42	// intended for inclusion in the ExtraData field of the Shutdown
43	// message.
44	CustomRecords CustomRecords
45
46	// ExtraData is the set of data that was appended to this message to
47	// fill out the full maximum transport message size. These fields can
48	// be used to specify optional data such as custom TLV fields.
49	ExtraData ExtraOpaqueData
50	}
51
52	// NewShutdown creates a new Shutdown message.
53	func NewShutdown(cid ChannelID, addr DeliveryAddress) *Shutdown {	3✔
54	return &Shutdown{	3✔
55	ChannelID: cid,	3✔
56	Address: addr,	3✔
57	}	3✔
58	}	3✔
59
60	// A compile-time check to ensure Shutdown implements the lnwire.Message
61	// interface.
62	var _ Message = (*Shutdown)(nil)
63
64	// Decode deserializes a serialized Shutdown from the passed io.Reader,
65	// observing the specified protocol version.
66	//
67	// This is part of the lnwire.Message interface.
68	func (s *Shutdown) Decode(r io.Reader, pver uint32) error {	3✔
69	err := ReadElements(r, &s.ChannelID, &s.Address)	3✔
70	if err != nil {	3✔
UNCOV 71	return err	×
UNCOV 72	}	×
73
74	var tlvRecords ExtraOpaqueData	3✔
75	if err := ReadElements(r, &tlvRecords); err != nil {	3✔
76	return err	×
77	}	×
78
79	// Extract TLV records from the extra data field.
80	musigNonce := s.ShutdownNonce.Zero()	3✔
81		3✔
82	customRecords, parsed, extraData, err := ParseAndExtractCustomRecords(	3✔
83	tlvRecords, &musigNonce,	3✔
84	)	3✔
85	if err != nil {	3✔
UNCOV 86	return err	×
UNCOV 87	}	×
88
89	// Assign the parsed records back to the message.
90	if _, ok := parsed[musigNonce.TlvType()]; ok {	6✔
91	s.ShutdownNonce = tlv.SomeRecordT(musigNonce)	3✔
92	}	3✔
93
94	s.CustomRecords = customRecords	3✔
95	s.ExtraData = extraData	3✔
96		3✔
97	return nil	3✔
98	}
99
100	// Encode serializes the target Shutdown into the passed io.Writer observing
101	// the protocol version specified.
102	//
103	// This is part of the lnwire.Message interface.
104	func (s Shutdown) Encode(w bytes.Buffer, pver uint32) error {	3✔
105	if err := WriteChannelID(w, s.ChannelID); err != nil {	3✔
106	return err	×
107	}	×
108
109	if err := WriteDeliveryAddress(w, s.Address); err != nil {	3✔
110	return err	×
111	}	×
112
113	// Only include nonce in extra data if present.
114	var records []tlv.RecordProducer	3✔
115	s.ShutdownNonce.WhenSome(	3✔
116	func(nonce tlv.RecordT[ShutdownNonceType, Musig2Nonce]) {	6✔
117	records = append(records, &nonce)	3✔
118	},	3✔
119	)
120
121	extraData, err := MergeAndEncode(records, s.ExtraData, s.CustomRecords)	3✔
122	if err != nil {	3✔
123	return err	×
124	}	×
125
126	return WriteBytes(w, extraData)	3✔
127	}
128
129	// MsgType returns the integer uniquely identifying this message type on the
130	// wire.
131	//
132	// This is part of the lnwire.Message interface.
133	func (s *Shutdown) MsgType() MessageType {	3✔
134	return MsgShutdown	3✔
135	}	3✔

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