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

/lnwire/pong.go

package lnwire

import (
        "bytes"
        "fmt"
        "io"
)

// MaxPongBytes is the maximum number of extra bytes a pong can be requested to
// send. The type of the message (19) takes 2 bytes, the length field takes up
// 2 bytes, leaving 65531 bytes.
const MaxPongBytes = 65531

// ErrMaxPongBytesExceeded indicates that the NumPongBytes field from the ping
// message has exceeded MaxPongBytes.
var ErrMaxPongBytesExceeded = fmt.Errorf("pong bytes exceeded")

// PongPayload is a set of opaque bytes sent in response to a ping message.
type PongPayload []byte

// Pong defines a message which is the direct response to a received Ping
// message. A Pong reply indicates that a connection is still active. The Pong
// reply to a Ping message should contain the nonce carried in the original
// Pong message.
type Pong struct {
        // PongBytes is a set of opaque bytes that corresponds to the
        // NumPongBytes defined in the ping message that this pong is
        // replying to.
        PongBytes PongPayload
}

// NewPong returns a new Pong message.
func NewPong(pongBytes []byte) *Pong {
        return &Pong{
                PongBytes: pongBytes,
        }
}

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

// Decode deserializes a serialized Pong message stored in the passed io.Reader
// observing the specified protocol version.
//
// This is part of the lnwire.Message interface.
func (p *Pong) Decode(r io.Reader, pver uint32) error {
        return ReadElements(r,
                &p.PongBytes,
        )
}

// Encode serializes the target Pong into the passed io.Writer observing the
// protocol version specified.
//
// This is part of the lnwire.Message interface.
func (p *Pong) Encode(w *bytes.Buffer, pver uint32) error {
        return WritePongPayload(w, p.PongBytes)
}

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

1	package lnwire
2
3	import (
4	"bytes"
5	"fmt"
6	"io"
7	)
8
9	// MaxPongBytes is the maximum number of extra bytes a pong can be requested to
10	// send. The type of the message (19) takes 2 bytes, the length field takes up
11	// 2 bytes, leaving 65531 bytes.
12	const MaxPongBytes = 65531
13
14	// ErrMaxPongBytesExceeded indicates that the NumPongBytes field from the ping
15	// message has exceeded MaxPongBytes.
16	var ErrMaxPongBytesExceeded = fmt.Errorf("pong bytes exceeded")
17
18	// PongPayload is a set of opaque bytes sent in response to a ping message.
19	type PongPayload []byte
20
21	// Pong defines a message which is the direct response to a received Ping
22	// message. A Pong reply indicates that a connection is still active. The Pong
23	// reply to a Ping message should contain the nonce carried in the original
24	// Pong message.
25	type Pong struct {
26	// PongBytes is a set of opaque bytes that corresponds to the
27	// NumPongBytes defined in the ping message that this pong is
28	// replying to.
29	PongBytes PongPayload
30	}
31
32	// NewPong returns a new Pong message.
33	func NewPong(pongBytes []byte) *Pong {	×
34	return &Pong{	×
35	PongBytes: pongBytes,	×
36	}	×
37	}	×
38
39	// A compile time check to ensure Pong implements the lnwire.Message interface.
40	var _ Message = (*Pong)(nil)
41
42	// Decode deserializes a serialized Pong message stored in the passed io.Reader
43	// observing the specified protocol version.
44	//
45	// This is part of the lnwire.Message interface.
UNCOV 46	func (p *Pong) Decode(r io.Reader, pver uint32) error {	×
UNCOV 47	return ReadElements(r,	×
UNCOV 48	&p.PongBytes,	×
UNCOV 49	)	×
UNCOV 50	}	×
51
52	// Encode serializes the target Pong into the passed io.Writer observing the
53	// protocol version specified.
54	//
55	// This is part of the lnwire.Message interface.
UNCOV 56	func (p Pong) Encode(w bytes.Buffer, pver uint32) error {	×
UNCOV 57	return WritePongPayload(w, p.PongBytes)	×
UNCOV 58	}	×
59
60	// MsgType returns the integer uniquely identifying this message type on the
61	// wire.
62	//
63	// This is part of the lnwire.Message interface.
UNCOV 64	func (p *Pong) MsgType() MessageType {	×
UNCOV 65	return MsgPong	×
UNCOV 66	}	×

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