Skip to content

Commit f838ce4

Browse files
ellemoutonellemouton
committed
temp
1 parent 6657739 commit f838ce4

File tree

3 files changed

+1356
-0
lines changed

3 files changed

+1356
-0
lines changed

‎lnwire/channel_announcement_2_test.go

Lines changed: 338 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,338 @@
1+
package lnwire
2+
3+
import (
4+
"bytes"
5+
"io"
6+
"testing"
7+
8+
"github.com/btcsuite/btcd/btcec/v2"
9+
"github.com/lightningnetwork/lnd/keychain"
10+
"github.com/lightningnetwork/lnd/tlv"
11+
"github.com/stretchr/testify/require"
12+
)
13+
14+
type GossipMsg1 struct {
15+
// Two known fields in the signed range.
16+
NodeKey tlv.RecordT[tlv.TlvType0, *btcec.PublicKey]
17+
Capacity tlv.OptionalRecordT[tlv.TlvType1, MilliSatoshi]
18+
19+
// Signature in the unsigned range.
20+
Signature tlv.RecordT[tlv.TlvType160, Sig]
21+
}
22+
23+
func newGossipMsg1(nodeKey *btcec.PublicKey, cap *MilliSatoshi) *GossipMsg1 {
24+
newMsg := &GossipMsg1{
25+
NodeKey: tlv.NewPrimitiveRecord[tlv.TlvType0](nodeKey),
26+
}
27+
28+
if cap != nil {
29+
newMsg.Capacity = tlv.SomeRecordT(
30+
tlv.NewPrimitiveRecord[tlv.TlvType1](*cap),
31+
)
32+
}
33+
34+
return newMsg
35+
}
36+
37+
func (g *GossipMsg1) SetSignature(s Sig) {
38+
g.Signature.Val = s
39+
}
40+
41+
func (g *GossipMsg1) SerialiseFieldsToSign() ([]byte, error) {
42+
return nil, nil
43+
}
44+
45+
func (g *GossipMsg1) Decode(r io.Reader, _ uint32) error {
46+
var capacity = tlv.ZeroRecordT[tlv.TlvType1, MilliSatoshi]()
47+
stream, err := tlv.NewStream(
48+
ProduceRecordsSorted(
49+
&g.NodeKey,
50+
&capacity,
51+
&g.Signature,
52+
)...,
53+
)
54+
if err != nil {
55+
return err
56+
}
57+
g.Signature.Val.ForceSchnorr()
58+
59+
typeMap, err := stream.DecodeWithParsedTypesP2P(r)
60+
if err != nil {
61+
return err
62+
}
63+
64+
if _, ok := typeMap[g.Capacity.TlvType()]; ok {
65+
g.Capacity = tlv.SomeRecordT(capacity)
66+
}
67+
68+
return nil
69+
}
70+
71+
func (g *GossipMsg1) Encode(buf *bytes.Buffer, u uint32) error {
72+
recordProducers := []tlv.RecordProducer{
73+
&g.NodeKey,
74+
}
75+
76+
g.Capacity.WhenSome(func(cap tlv.RecordT[tlv.TlvType1, MilliSatoshi]) {
77+
recordProducers = append(recordProducers, &cap)
78+
})
79+
80+
recordProducers = append(recordProducers, &g.Signature)
81+
82+
return EncodeRecordsTo(buf, ProduceRecordsSorted(recordProducers...))
83+
}
84+
85+
func (g *GossipMsg1) MsgType() MessageType {
86+
return 7777
87+
}
88+
89+
var _ Message = (*GossipMsg1)(nil)
90+
var _ PureTLVMessage = (*GossipMsg1)(nil)
91+
92+
type GossipMsg2 struct {
93+
NodeKey tlv.RecordT[tlv.TlvType0, *btcec.PublicKey]
94+
Capacity tlv.OptionalRecordT[tlv.TlvType1, MilliSatoshi]
95+
96+
// An additional fields (optional) in the signed range.
97+
BitcoinKey tlv.OptionalRecordT[tlv.TlvType3, *btcec.PublicKey]
98+
99+
// A zero length TLV in the signed range.
100+
SecondPeer tlv.OptionalRecordT[tlv.TlvType5, TrueBoolean]
101+
102+
// Signature in the unsigned range.
103+
Signature tlv.RecordT[tlv.TlvType160, Sig]
104+
105+
// Another field in the unsigned range. An older node can throw this
106+
// away.
107+
SPVProof tlv.RecordT[tlv.TlvType161, []byte]
108+
109+
// A new field in the second signed range. An older node should keep
110+
// this since it is part of the serialised message that is signed.
111+
Num tlv.RecordT[tlv.TlvType1000000000, uint8]
112+
}
113+
114+
func newGossipMsg2(nodeKey *btcec.PublicKey, cap *MilliSatoshi,
115+
btcKey *btcec.PublicKey, spvProof []byte, num uint8,
116+
secondPeer bool) *GossipMsg2 {
117+
118+
newMsg := &GossipMsg2{
119+
NodeKey: tlv.NewPrimitiveRecord[tlv.TlvType0](nodeKey),
120+
SPVProof: tlv.NewPrimitiveRecord[tlv.TlvType161](spvProof),
121+
Num: tlv.NewPrimitiveRecord[tlv.TlvType1000000000](num),
122+
}
123+
124+
if secondPeer {
125+
newMsg.SecondPeer = tlv.SomeRecordT(
126+
tlv.NewRecordT[tlv.TlvType5](TrueBoolean{}),
127+
)
128+
}
129+
130+
if cap != nil {
131+
newMsg.Capacity = tlv.SomeRecordT(
132+
tlv.NewPrimitiveRecord[tlv.TlvType1](*cap),
133+
)
134+
}
135+
136+
if btcKey != nil {
137+
newMsg.BitcoinKey = tlv.SomeRecordT(
138+
tlv.NewPrimitiveRecord[tlv.TlvType3](btcKey),
139+
)
140+
}
141+
142+
return newMsg
143+
}
144+
145+
func (g *GossipMsg2) SerialiseFieldsToSign() ([]byte, error) {
146+
return nil, nil
147+
}
148+
149+
func (g *GossipMsg2) SetSignature(s Sig) {
150+
g.Signature.Val = s
151+
}
152+
153+
func (g *GossipMsg2) Decode(r io.Reader, _ uint32) error {
154+
var (
155+
capacity = tlv.ZeroRecordT[tlv.TlvType1, MilliSatoshi]()
156+
btcKey = tlv.ZeroRecordT[tlv.TlvType3, *btcec.PublicKey]()
157+
secondPeer = tlv.ZeroRecordT[tlv.TlvType5, TrueBoolean]()
158+
)
159+
160+
stream, err := tlv.NewStream(
161+
ProduceRecordsSorted(
162+
&g.NodeKey,
163+
&capacity,
164+
&btcKey,
165+
&secondPeer,
166+
&g.Signature,
167+
&g.SPVProof,
168+
&g.Num,
169+
)...,
170+
)
171+
if err != nil {
172+
return err
173+
}
174+
g.Signature.Val.ForceSchnorr()
175+
176+
typeMap, err := stream.DecodeWithParsedTypesP2P(r)
177+
if err != nil {
178+
return err
179+
}
180+
181+
if _, ok := typeMap[g.Capacity.TlvType()]; ok {
182+
g.Capacity = tlv.SomeRecordT(capacity)
183+
}
184+
185+
if _, ok := typeMap[g.SecondPeer.TlvType()]; ok {
186+
g.SecondPeer = tlv.SomeRecordT(secondPeer)
187+
}
188+
189+
if _, ok := typeMap[g.BitcoinKey.TlvType()]; ok {
190+
g.BitcoinKey = tlv.SomeRecordT(btcKey)
191+
}
192+
193+
return nil
194+
}
195+
196+
func (g *GossipMsg2) Encode(buf *bytes.Buffer, _ uint32) error {
197+
recordProducers := []tlv.RecordProducer{
198+
&g.NodeKey,
199+
&g.Signature,
200+
&g.SPVProof,
201+
&g.Num,
202+
}
203+
204+
g.Capacity.WhenSome(func(cap tlv.RecordT[tlv.TlvType1, MilliSatoshi]) {
205+
recordProducers = append(recordProducers, &cap)
206+
})
207+
g.BitcoinKey.WhenSome(func(key tlv.RecordT[tlv.TlvType3, *btcec.PublicKey]) {
208+
recordProducers = append(recordProducers, &key)
209+
})
210+
g.SecondPeer.WhenSome(func(second tlv.RecordT[tlv.TlvType5, TrueBoolean]) {
211+
recordProducers = append(recordProducers, &second)
212+
})
213+
214+
return EncodeRecordsTo(buf, ProduceRecordsSorted(recordProducers...))
215+
}
216+
217+
func (g *GossipMsg2) MsgType() MessageType {
218+
return 7779
219+
}
220+
221+
var _ Message = (*GossipMsg2)(nil)
222+
var _ PureTLVMessage = (*GossipMsg2)(nil)
223+
224+
type PureTLVMessage interface {
225+
SerialiseFieldsToSign() ([]byte, error)
226+
227+
SetSignature(Sig)
228+
}
229+
230+
func Sign(msg PureTLVMessage, signer keychain.MessageSignerRing,
231+
keyLoc keychain.KeyLocator) error {
232+
233+
data, err := msg.SerialiseFieldsToSign()
234+
if err != nil {
235+
return err
236+
}
237+
238+
signature, err := signer.SignMessageSchnorr(
239+
keyLoc, data, false, nil, []byte{1, 1, 1, 1, 1},
240+
)
241+
if err != nil {
242+
return err
243+
}
244+
245+
sig, err = NewSigFromSignature(signature)
246+
if err != nil {
247+
return err
248+
}
249+
250+
msg.SetSignature(sig)
251+
252+
return nil
253+
}
254+
255+
func TestMessage(t *testing.T) {
256+
t.Parallel()
257+
// Want to test that an older node that knows the state defined by
258+
// GossipMsg1 is able to validate the signature of GossipMsg2 correctly.
259+
260+
// Node B will:
261+
// 1) Create GossipMsg2 message with all fields & sign it and encode it.
262+
// Node A will:
263+
// 2) decode via GossipMsg1 definition & should be able to:
264+
// 1) successfully validate sig.
265+
// 2) re-encode with all fields.
266+
267+
// Quickly check that the Encode & Decode of both the old and new
268+
// messages work as expected.
269+
var (
270+
privKey, _ = btcec.NewPrivateKey()
271+
272+
_, pkB = btcec.PrivKeyFromBytes([]byte{2})
273+
capacity = MilliSatoshi(100)
274+
275+
testSig = Sig{bytes: [64]byte{1}, sigType: sigTypeSchnorr}
276+
)
277+
278+
t.Run("Encode and Decode of GossipMsg2", func(t *testing.T) {
279+
t.Parallel()
280+
281+
// Test Encode and Decode of GossipMsg2.
282+
msgNew := newGossipMsg2(
283+
privKey.PubKey(), &capacity, pkB, []byte{1, 2, 3, 4},
284+
90, true,
285+
)
286+
msgNew.SetSignature(testSig)
287+
288+
buf := bytes.NewBuffer(nil)
289+
require.NoError(t, msgNew.Encode(buf, 0))
290+
291+
var msgNew2 GossipMsg2
292+
require.NoError(t, msgNew2.Decode(buf, 0))
293+
294+
require.Equal(t, msgNew, &msgNew2)
295+
})
296+
297+
t.Run("Encode and Decode of GossipMsg1", func(t *testing.T) {
298+
t.Parallel()
299+
300+
// Test Encode and Decode of GossipMsg1.
301+
msgOld := newGossipMsg1(privKey.PubKey(), &capacity)
302+
msgOld.SetSignature(testSig)
303+
304+
buf := bytes.NewBuffer(nil)
305+
require.NoError(t, msgOld.Encode(buf, 0))
306+
307+
var msgOld2 GossipMsg1
308+
require.NoError(t, msgOld2.Decode(buf, 0))
309+
310+
require.Equal(t, msgOld, &msgOld2)
311+
})
312+
313+
t.Run("Encode Msg2 and decode via Msg1", func(t *testing.T) {
314+
t.Parallel()
315+
316+
// Ok cool, now try see if we can parse the new message with the
317+
// old decoder.
318+
var (
319+
buf = bytes.NewBuffer(nil)
320+
expectedMsgOld = newGossipMsg1(privKey.PubKey(), &capacity)
321+
msgNew = newGossipMsg2(
322+
privKey.PubKey(), &capacity, pkB,
323+
[]byte{1, 2, 3, 4}, 90, true,
324+
)
325+
)
326+
msgNew.SetSignature(testSig)
327+
expectedMsgOld.SetSignature(testSig)
328+
329+
var msgOld GossipMsg1
330+
require.NoError(t, msgNew.Encode(buf, 0))
331+
require.NoError(t, msgOld.Decode(buf, 0))
332+
require.Equal(t, expectedMsgOld, &msgOld)
333+
})
334+
335+
t.Run("Serialise signed fields", func(t *testing.T) {
336+
337+
})
338+
}

‎tlv/internal/gen/gen_tlv_types.go

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -18,6 +18,8 @@ const (
1818
// gossipUnsignedTypeStart defines the beginning of TLV range used in
1919
// Gossip 1.75 messages that will not be covered by signatures.
2020
gossipUnsignedTypeStart uint32 = 160
21+
22+
gossipSecondSignedRangeTypeStart uint32 = 1000000000
2123
)
2224

2325
const typeCodeTemplate = `// Code generated by tlv/internal/gen; DO NOT EDIT.
@@ -54,6 +56,12 @@ func main() {
5456
items[i] = struct{}{}
5557
}
5658

59+
// We will also generate a few of the types in the second signed range
60+
// for gossip 1.75 messages.
61+
for i := gossipSecondSignedRangeTypeStart; i <= gossipSecondSignedRangeTypeStart+numberOfTypes; i++ { //nolint:lll
62+
items[i] = struct{}{}
63+
}
64+
5765
// With the lower end generated, we'll now generate 100 records in the
5866
// upper end of the range.
5967
for i := customTypeStart; i <= customTypeStart+numberOfTypes; i++ {

0 commit comments

Comments
 (0)