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

/watchtower/wtdb/migration4/codec.go

package migration4

import (
        "encoding/binary"
        "encoding/hex"
        "fmt"
        "io"
)

// SessionIDSize is 33-bytes; it is a serialized, compressed public key.
const SessionIDSize = 33

// SessionID is created from the remote public key of a client, and serves as a
// unique identifier and authentication for sending state updates.
type SessionID [SessionIDSize]byte

// String returns a hex encoding of the session id.
func (s SessionID) String() string {
        return hex.EncodeToString(s[:])
}

// ChannelID is a series of 32-bytes that uniquely identifies all channels
// within the network. The ChannelID is computed using the outpoint of the
// funding transaction (the txid, and output index). Given a funding output the
// ChannelID can be calculated by XOR'ing the big-endian serialization of the
// txid and the big-endian serialization of the output index, truncated to
// 2 bytes.
type ChannelID [32]byte

// String returns the string representation of the ChannelID. This is just the
// hex string encoding of the ChannelID itself.
func (c ChannelID) String() string {
        return hex.EncodeToString(c[:])
}

// BackupID identifies a particular revoked, remote commitment by channel id and
// commitment height.
type BackupID struct {
        // ChanID is the channel id of the revoked commitment.
        ChanID ChannelID

        // CommitHeight is the commitment height of the revoked commitment.
        CommitHeight uint64
}

// Encode writes the BackupID from the passed io.Writer.
func (b *BackupID) Encode(w io.Writer) error {
        return WriteElements(w,
                b.ChanID,
                b.CommitHeight,
        )
}

// Decode reads a BackupID from the passed io.Reader.
func (b *BackupID) Decode(r io.Reader) error {
        return ReadElements(r,
                &b.ChanID,
                &b.CommitHeight,
        )
}

// String returns a human-readable encoding of a BackupID.
func (b BackupID) String() string {
        return fmt.Sprintf("backup(%v, %d)", b.ChanID, b.CommitHeight)
}

// WriteElements serializes a variadic list of elements into the given
// io.Writer.
func WriteElements(w io.Writer, elements ...interface{}) error {
        for _, element := range elements {
                if err := WriteElement(w, element); err != nil {
                        return err
                }
        }

        return nil
}

// ReadElements deserializes the provided io.Reader into a variadic list of
// target elements.
func ReadElements(r io.Reader, elements ...interface{}) error {
        for _, element := range elements {
                if err := ReadElement(r, element); err != nil {
                        return err
                }
        }

        return nil
}

// WriteElement serializes a single element into the provided io.Writer.
func WriteElement(w io.Writer, element interface{}) error {
        switch e := element.(type) {
        case ChannelID:
                if _, err := w.Write(e[:]); err != nil {
                        return err
                }

        case uint64:
                if err := binary.Write(w, byteOrder, e); err != nil {
                        return err
                }

        default:
                return fmt.Errorf("unexpected type")
        }

        return nil
}

// ReadElement deserializes a single element from the provided io.Reader.
func ReadElement(r io.Reader, element interface{}) error {
        switch e := element.(type) {
        case *ChannelID:
                if _, err := io.ReadFull(r, e[:]); err != nil {
                        return err
                }

        case *uint64:
                if err := binary.Read(r, byteOrder, e); err != nil {
                        return err
                }

        default:
                return fmt.Errorf("unexpected type")
        }

        return nil
}

1	package migration4
2
3	import (
4	"encoding/binary"
5	"encoding/hex"
6	"fmt"
7	"io"
8	)
9
10	// SessionIDSize is 33-bytes; it is a serialized, compressed public key.
11	const SessionIDSize = 33
12
13	// SessionID is created from the remote public key of a client, and serves as a
14	// unique identifier and authentication for sending state updates.
15	type SessionID [SessionIDSize]byte
16
17	// String returns a hex encoding of the session id.
UNCOV 18	func (s SessionID) String() string {	×
UNCOV 19	return hex.EncodeToString(s[:])	×
UNCOV 20	}	×
21
22	// ChannelID is a series of 32-bytes that uniquely identifies all channels
23	// within the network. The ChannelID is computed using the outpoint of the
24	// funding transaction (the txid, and output index). Given a funding output the
25	// ChannelID can be calculated by XOR'ing the big-endian serialization of the
26	// txid and the big-endian serialization of the output index, truncated to
27	// 2 bytes.
28	type ChannelID [32]byte
29
30	// String returns the string representation of the ChannelID. This is just the
31	// hex string encoding of the ChannelID itself.
32	func (c ChannelID) String() string {	×
33	return hex.EncodeToString(c[:])	×
34	}	×
35
36	// BackupID identifies a particular revoked, remote commitment by channel id and
37	// commitment height.
38	type BackupID struct {
39	// ChanID is the channel id of the revoked commitment.
40	ChanID ChannelID
41
42	// CommitHeight is the commitment height of the revoked commitment.
43	CommitHeight uint64
44	}
45
46	// Encode writes the BackupID from the passed io.Writer.
UNCOV 47	func (b *BackupID) Encode(w io.Writer) error {	×
UNCOV 48	return WriteElements(w,	×
UNCOV 49	b.ChanID,	×
UNCOV 50	b.CommitHeight,	×
UNCOV 51	)	×
UNCOV 52	}	×
53
54	// Decode reads a BackupID from the passed io.Reader.
UNCOV 55	func (b *BackupID) Decode(r io.Reader) error {	×
UNCOV 56	return ReadElements(r,	×
UNCOV 57	&b.ChanID,	×
UNCOV 58	&b.CommitHeight,	×
UNCOV 59	)	×
UNCOV 60	}	×
61
62	// String returns a human-readable encoding of a BackupID.
63	func (b BackupID) String() string {	×
64	return fmt.Sprintf("backup(%v, %d)", b.ChanID, b.CommitHeight)	×
65	}	×
66
67	// WriteElements serializes a variadic list of elements into the given
68	// io.Writer.
UNCOV 69	func WriteElements(w io.Writer, elements ...interface{}) error {	×
UNCOV 70	for _, element := range elements {	×
UNCOV 71	if err := WriteElement(w, element); err != nil {	×
72	return err	×
73	}	×
74	}
75
UNCOV 76	return nil	×
77	}
78
79	// ReadElements deserializes the provided io.Reader into a variadic list of
80	// target elements.
UNCOV 81	func ReadElements(r io.Reader, elements ...interface{}) error {	×
UNCOV 82	for _, element := range elements {	×
UNCOV 83	if err := ReadElement(r, element); err != nil {	×
84	return err	×
85	}	×
86	}
87
UNCOV 88	return nil	×
89	}
90
91	// WriteElement serializes a single element into the provided io.Writer.
UNCOV 92	func WriteElement(w io.Writer, element interface{}) error {	×
UNCOV 93	switch e := element.(type) {	×
UNCOV 94	case ChannelID:	×
UNCOV 95	if _, err := w.Write(e[:]); err != nil {	×
96	return err	×
97	}	×
98
UNCOV 99	case uint64:	×
UNCOV 100	if err := binary.Write(w, byteOrder, e); err != nil {	×
101	return err	×
102	}	×
103
104	default:	×
105	return fmt.Errorf("unexpected type")	×
106	}
107
UNCOV 108	return nil	×
109	}
110
111	// ReadElement deserializes a single element from the provided io.Reader.
UNCOV 112	func ReadElement(r io.Reader, element interface{}) error {	×
UNCOV 113	switch e := element.(type) {	×
UNCOV 114	case *ChannelID:	×
UNCOV 115	if _, err := io.ReadFull(r, e[:]); err != nil {	×
116	return err	×
117	}	×
118
UNCOV 119	case *uint64:	×
UNCOV 120	if err := binary.Read(r, byteOrder, e); err != nil {	×
121	return err	×
122	}	×
123
124	default:	×
125	return fmt.Errorf("unexpected type")	×
126	}
127
UNCOV 128	return nil	×
129	}

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