13197586737

Committed 07 Feb 2025 10:06AM UTC coverage: 58.818% (+9.5%) from 49.279%

Build # 13197586737

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #9474 from ellemouton/nodeAnnConversion

graph/db: correctly handle de(ser)ialisation of `models.LightningNode` opaque addresses

Run Details

37 of 45 new or added lines in 3 files covered. (82.22%)

19 existing lines in 5 files now uncovered.

136212 of 231583 relevant lines covered (58.82%)

19326.37 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

72.73

/graph/db/addr.go

package graphdb

import (
        "encoding/binary"
        "errors"
        "fmt"
        "io"
        "net"

        "github.com/lightningnetwork/lnd/lnwire"
        "github.com/lightningnetwork/lnd/tor"
)

// addressType specifies the network protocol and version that should be used
// when connecting to a node at a particular address.
type addressType uint8

const (
        // tcp4Addr denotes an IPv4 TCP address.
        tcp4Addr addressType = 0

        // tcp6Addr denotes an IPv6 TCP address.
        tcp6Addr addressType = 1

        // v2OnionAddr denotes a version 2 Tor onion service address.
        v2OnionAddr addressType = 2

        // v3OnionAddr denotes a version 3 Tor (prop224) onion service address.
        v3OnionAddr addressType = 3

        // opaqueAddrs denotes an address (or a set of addresses) that LND was
        // not able to parse since LND is not yet aware of the address type.
        opaqueAddrs addressType = 4
)

// encodeTCPAddr serializes a TCP address into its compact raw bytes
// representation.
func encodeTCPAddr(w io.Writer, addr *net.TCPAddr) error {
        var (
                addrType byte
                ip       []byte
        )

        if addr.IP.To4() != nil {
                addrType = byte(tcp4Addr)
                ip = addr.IP.To4()
        } else {
                addrType = byte(tcp6Addr)
                ip = addr.IP.To16()
        }

        if ip == nil {
                return fmt.Errorf("unable to encode IP %v", addr.IP)
        }

        if _, err := w.Write([]byte{addrType}); err != nil {
                return err
        }

        if _, err := w.Write(ip); err != nil {
                return err
        }

        var port [2]byte
        byteOrder.PutUint16(port[:], uint16(addr.Port))
        if _, err := w.Write(port[:]); err != nil {
                return err
        }

        return nil
}

// encodeOnionAddr serializes an onion address into its compact raw bytes
// representation.
func encodeOnionAddr(w io.Writer, addr *tor.OnionAddr) error {
        var suffixIndex int
        hostLen := len(addr.OnionService)
        switch hostLen {
        case tor.V2Len:
                if _, err := w.Write([]byte{byte(v2OnionAddr)}); err != nil {
                        return err
                }
                suffixIndex = tor.V2Len - tor.OnionSuffixLen
        case tor.V3Len:
                if _, err := w.Write([]byte{byte(v3OnionAddr)}); err != nil {
                        return err
                }
                suffixIndex = tor.V3Len - tor.OnionSuffixLen
        default:
                return errors.New("unknown onion service length")
        }

        suffix := addr.OnionService[suffixIndex:]
        if suffix != tor.OnionSuffix {
                return fmt.Errorf("invalid suffix \"%v\"", suffix)
        }

        host, err := tor.Base32Encoding.DecodeString(
                addr.OnionService[:suffixIndex],
        )
        if err != nil {
                return err
        }

        // Sanity check the decoded length.
        switch {
        case hostLen == tor.V2Len && len(host) != tor.V2DecodedLen:
                return fmt.Errorf("onion service %v decoded to invalid host %x",
                        addr.OnionService, host)

        case hostLen == tor.V3Len && len(host) != tor.V3DecodedLen:
                return fmt.Errorf("onion service %v decoded to invalid host %x",
                        addr.OnionService, host)
        }

        if _, err := w.Write(host); err != nil {
                return err
        }

        var port [2]byte
        byteOrder.PutUint16(port[:], uint16(addr.Port))
        if _, err := w.Write(port[:]); err != nil {
                return err
        }

        return nil
}

// encodeOpaqueAddrs serializes the lnwire.OpaqueAddrs type to a raw set of
// bytes that we will persist.
func encodeOpaqueAddrs(w io.Writer, addr *lnwire.OpaqueAddrs) error {
        // Write the type byte.
        if _, err := w.Write([]byte{byte(opaqueAddrs)}); err != nil {
                return err
        }

        // Write the length of the payload.
        var l [2]byte
        binary.BigEndian.PutUint16(l[:], uint16(len(addr.Payload)))
        if _, err := w.Write(l[:]); err != nil {
                return err
        }

        // Write the payload.
        _, err := w.Write(addr.Payload)

        return err
}

// DeserializeAddr reads the serialized raw representation of an address and
// deserializes it into the actual address. This allows us to avoid address
// resolution within the channeldb package.
func DeserializeAddr(r io.Reader) (net.Addr, error) {
        var addrType [1]byte
        if _, err := r.Read(addrType[:]); err != nil {
                return nil, err
        }

        var address net.Addr
        switch addressType(addrType[0]) {
        case tcp4Addr:
                var ip [4]byte
                if _, err := r.Read(ip[:]); err != nil {
                        return nil, err
                }

                var port [2]byte
                if _, err := r.Read(port[:]); err != nil {
                        return nil, err
                }

                address = &net.TCPAddr{
                        IP:   net.IP(ip[:]),
                        Port: int(binary.BigEndian.Uint16(port[:])),
                }

        case tcp6Addr:
                var ip [16]byte
                if _, err := r.Read(ip[:]); err != nil {
                        return nil, err
                }

                var port [2]byte
                if _, err := r.Read(port[:]); err != nil {
                        return nil, err
                }

                address = &net.TCPAddr{
                        IP:   net.IP(ip[:]),
                        Port: int(binary.BigEndian.Uint16(port[:])),
                }

        case v2OnionAddr:
                var h [tor.V2DecodedLen]byte
                if _, err := r.Read(h[:]); err != nil {
                        return nil, err
                }

                var p [2]byte
                if _, err := r.Read(p[:]); err != nil {
                        return nil, err
                }

                onionService := tor.Base32Encoding.EncodeToString(h[:])
                onionService += tor.OnionSuffix
                port := int(binary.BigEndian.Uint16(p[:]))

                address = &tor.OnionAddr{
                        OnionService: onionService,
                        Port:         port,
                }

        case v3OnionAddr:
                var h [tor.V3DecodedLen]byte
                if _, err := r.Read(h[:]); err != nil {
                        return nil, err
                }

                var p [2]byte
                if _, err := r.Read(p[:]); err != nil {
                        return nil, err
                }

                onionService := tor.Base32Encoding.EncodeToString(h[:])
                onionService += tor.OnionSuffix
                port := int(binary.BigEndian.Uint16(p[:]))

                address = &tor.OnionAddr{
                        OnionService: onionService,
                        Port:         port,
                }

        case opaqueAddrs:
                // Read the length of the payload.
                var l [2]byte
                if _, err := r.Read(l[:]); err != nil {
                        return nil, err
                }

                // Read the payload.
                payload := make([]byte, binary.BigEndian.Uint16(l[:]))
                if _, err := r.Read(payload); err != nil {
                        return nil, err
                }

                address = &lnwire.OpaqueAddrs{
                        Payload: payload,
                }

        default:
                return nil, ErrUnknownAddressType
        }

        return address, nil
}

// SerializeAddr serializes an address into its raw bytes representation so that
// it can be deserialized without requiring address resolution.
func SerializeAddr(w io.Writer, address net.Addr) error {
        switch addr := address.(type) {
        case *net.TCPAddr:
                return encodeTCPAddr(w, addr)
        case *tor.OnionAddr:
                return encodeOnionAddr(w, addr)
        case *lnwire.OpaqueAddrs:
                return encodeOpaqueAddrs(w, addr)
        default:
                return ErrUnknownAddressType
        }
}

1	package graphdb
2
3	import (
4	"encoding/binary"
5	"errors"
6	"fmt"
7	"io"
8	"net"
9
10	"github.com/lightningnetwork/lnd/lnwire"
11	"github.com/lightningnetwork/lnd/tor"
12	)
13
14	// addressType specifies the network protocol and version that should be used
15	// when connecting to a node at a particular address.
16	type addressType uint8
17
18	const (
19	// tcp4Addr denotes an IPv4 TCP address.
20	tcp4Addr addressType = 0
21
22	// tcp6Addr denotes an IPv6 TCP address.
23	tcp6Addr addressType = 1
24
25	// v2OnionAddr denotes a version 2 Tor onion service address.
26	v2OnionAddr addressType = 2
27
28	// v3OnionAddr denotes a version 3 Tor (prop224) onion service address.
29	v3OnionAddr addressType = 3
30
31	// opaqueAddrs denotes an address (or a set of addresses) that LND was
32	// not able to parse since LND is not yet aware of the address type.
33	opaqueAddrs addressType = 4
34	)
35
36	// encodeTCPAddr serializes a TCP address into its compact raw bytes
37	// representation.
38	func encodeTCPAddr(w io.Writer, addr *net.TCPAddr) error {	2,207✔
39	var (	2,207✔
40	addrType byte	2,207✔
41	ip []byte	2,207✔
42	)	2,207✔
43		2,207✔
44	if addr.IP.To4() != nil {	4,028✔
45	addrType = byte(tcp4Addr)	1,821✔
46	ip = addr.IP.To4()	1,821✔
47	} else {	2,210✔
48	addrType = byte(tcp6Addr)	389✔
49	ip = addr.IP.To16()	389✔
50	}	389✔
51
52	if ip == nil {	2,211✔
53	return fmt.Errorf("unable to encode IP %v", addr.IP)	4✔
54	}	4✔
55
56	if _, err := w.Write([]byte{addrType}); err != nil {	2,203✔
57	return err	×
58	}	×
59
60	if _, err := w.Write(ip); err != nil {	2,203✔
61	return err	×
62	}	×
63
64	var port [2]byte	2,203✔
65	byteOrder.PutUint16(port[:], uint16(addr.Port))	2,203✔
66	if _, err := w.Write(port[:]); err != nil {	2,203✔
67	return err	×
68	}	×
69
70	return nil	2,203✔
71	}
72
73	// encodeOnionAddr serializes an onion address into its compact raw bytes
74	// representation.
75	func encodeOnionAddr(w io.Writer, addr *tor.OnionAddr) error {	208✔
76	var suffixIndex int	208✔
77	hostLen := len(addr.OnionService)	208✔
78	switch hostLen {	208✔
79	case tor.V2Len:	104✔
80	if _, err := w.Write([]byte{byte(v2OnionAddr)}); err != nil {	104✔
81	return err	×
82	}	×
83	suffixIndex = tor.V2Len - tor.OnionSuffixLen	104✔
84	case tor.V3Len:	106✔
85	if _, err := w.Write([]byte{byte(v3OnionAddr)}); err != nil {	106✔
86	return err	×
87	}	×
88	suffixIndex = tor.V3Len - tor.OnionSuffixLen	106✔
89	default:	1✔
90	return errors.New("unknown onion service length")	1✔
91	}
92
93	suffix := addr.OnionService[suffixIndex:]	207✔
94	if suffix != tor.OnionSuffix {	208✔
95	return fmt.Errorf("invalid suffix \"%v\"", suffix)	1✔
96	}	1✔
97
98	host, err := tor.Base32Encoding.DecodeString(	206✔
99	addr.OnionService[:suffixIndex],	206✔
100	)	206✔
101	if err != nil {	207✔
102	return err	1✔
103	}	1✔
104
105	// Sanity check the decoded length.
106	switch {	205✔
107	case hostLen == tor.V2Len && len(host) != tor.V2DecodedLen:	×
108	return fmt.Errorf("onion service %v decoded to invalid host %x",	×
109	addr.OnionService, host)	×
110
111	case hostLen == tor.V3Len && len(host) != tor.V3DecodedLen:	×
112	return fmt.Errorf("onion service %v decoded to invalid host %x",	×
113	addr.OnionService, host)	×
114	}
115
116	if _, err := w.Write(host); err != nil {	205✔
117	return err	×
118	}	×
119
120	var port [2]byte	205✔
121	byteOrder.PutUint16(port[:], uint16(addr.Port))	205✔
122	if _, err := w.Write(port[:]); err != nil {	205✔
123	return err	×
124	}	×
125
126	return nil	205✔
127	}
128
129	// encodeOpaqueAddrs serializes the lnwire.OpaqueAddrs type to a raw set of
130	// bytes that we will persist.
131	func encodeOpaqueAddrs(w io.Writer, addr *lnwire.OpaqueAddrs) error {	1✔
132	// Write the type byte.	1✔
133	if _, err := w.Write([]byte{byte(opaqueAddrs)}); err != nil {	1✔
NEW 134	return err	×
NEW 135	}	×
136
137	// Write the length of the payload.
138	var l [2]byte	1✔
139	binary.BigEndian.PutUint16(l[:], uint16(len(addr.Payload)))	1✔
140	if _, err := w.Write(l[:]); err != nil {	1✔
NEW 141	return err	×
NEW 142	}	×
143
144	// Write the payload.
145	_, err := w.Write(addr.Payload)	1✔
146		1✔
147	return err	1✔
148	}
149
150	// DeserializeAddr reads the serialized raw representation of an address and
151	// deserializes it into the actual address. This allows us to avoid address
152	// resolution within the channeldb package.
153	func DeserializeAddr(r io.Reader) (net.Addr, error) {	11,261✔
154	var addrType [1]byte	11,261✔
155	if _, err := r.Read(addrType[:]); err != nil {	11,261✔
156	return nil, err	×
157	}	×
158
159	var address net.Addr	11,261✔
160	switch addressType(addrType[0]) {	11,261✔
161	case tcp4Addr:	4,510✔
162	var ip [4]byte	4,510✔
163	if _, err := r.Read(ip[:]); err != nil {	4,510✔
164	return nil, err	×
165	}	×
166
167	var port [2]byte	4,510✔
168	if _, err := r.Read(port[:]); err != nil {	4,510✔
169	return nil, err	×
170	}	×
171
172	address = &net.TCPAddr{	4,510✔
173	IP: net.IP(ip[:]),	4,510✔
174	Port: int(binary.BigEndian.Uint16(port[:])),	4,510✔
175	}	4,510✔
176
177	case tcp6Addr:	6,551✔
178	var ip [16]byte	6,551✔
179	if _, err := r.Read(ip[:]); err != nil {	6,551✔
180	return nil, err	×
181	}	×
182
183	var port [2]byte	6,551✔
184	if _, err := r.Read(port[:]); err != nil {	6,551✔
185	return nil, err	×
186	}	×
187
188	address = &net.TCPAddr{	6,551✔
189	IP: net.IP(ip[:]),	6,551✔
190	Port: int(binary.BigEndian.Uint16(port[:])),	6,551✔
191	}	6,551✔
192
193	case v2OnionAddr:	104✔
194	var h [tor.V2DecodedLen]byte	104✔
195	if _, err := r.Read(h[:]); err != nil {	104✔
196	return nil, err	×
197	}	×
198
199	var p [2]byte	104✔
200	if _, err := r.Read(p[:]); err != nil {	104✔
201	return nil, err	×
202	}	×
203
204	onionService := tor.Base32Encoding.EncodeToString(h[:])	104✔
205	onionService += tor.OnionSuffix	104✔
206	port := int(binary.BigEndian.Uint16(p[:]))	104✔
207		104✔
208	address = &tor.OnionAddr{	104✔
209	OnionService: onionService,	104✔
210	Port: port,	104✔
211	}	104✔
212
213	case v3OnionAddr:	104✔
214	var h [tor.V3DecodedLen]byte	104✔
215	if _, err := r.Read(h[:]); err != nil {	104✔
216	return nil, err	×
217	}	×
218
219	var p [2]byte	104✔
220	if _, err := r.Read(p[:]); err != nil {	104✔
221	return nil, err	×
222	}	×
223
224	onionService := tor.Base32Encoding.EncodeToString(h[:])	104✔
225	onionService += tor.OnionSuffix	104✔
226	port := int(binary.BigEndian.Uint16(p[:]))	104✔
227		104✔
228	address = &tor.OnionAddr{	104✔
229	OnionService: onionService,	104✔
230	Port: port,	104✔
231	}	104✔
232
233	case opaqueAddrs:	1✔
234	// Read the length of the payload.	1✔
235	var l [2]byte	1✔
236	if _, err := r.Read(l[:]); err != nil {	1✔
NEW 237	return nil, err	×
NEW 238	}	×
239
240	// Read the payload.
241	payload := make([]byte, binary.BigEndian.Uint16(l[:]))	1✔
242	if _, err := r.Read(payload); err != nil {	1✔
NEW 243	return nil, err	×
NEW 244	}	×
245
246	address = &lnwire.OpaqueAddrs{	1✔
247	Payload: payload,	1✔
248	}	1✔
249
250	default:	×
251	return nil, ErrUnknownAddressType	×
252	}
253
254	return address, nil	11,261✔
255	}
256
257	// SerializeAddr serializes an address into its raw bytes representation so that
258	// it can be deserialized without requiring address resolution.
259	func SerializeAddr(w io.Writer, address net.Addr) error {	2,414✔
260	switch addr := address.(type) {	2,414✔
261	case *net.TCPAddr:	2,207✔
262	return encodeTCPAddr(w, addr)	2,207✔
263	case *tor.OnionAddr:	208✔
264	return encodeOnionAddr(w, addr)	208✔
265	case *lnwire.OpaqueAddrs:	1✔
266	return encodeOpaqueAddrs(w, addr)	1✔
267	default:	1✔
268	return ErrUnknownAddressType	1✔
269	}
270	}

lightningnetwork / lnd / 13197586737

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