highperfocused/lnd
1
0
Fork 0
mirror of https://github.com/lightningnetwork/lnd.git synced 2025-06-24 15:52:22 +02:00
Code Issues Packages Projects Releases Wiki Activity

brontide,lnwire,wtwire,zpay32: appease linter

Browse Source 
Address all linter complaints for the newly migrated fuzz tests.
This commit is contained in:
Matt Morehouse 2022-11-07 16:38:16 -06:00
parent 5a48568806
commit e15d3e898e
No known key found for this signature in database
GPG Key ID: CC8ECA224831C982
4 changed files with 140 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

126
brontide/fuzz_test.go
View File

@ -36,6 +36,7 @@ var (
} }
priv, _ := btcec.PrivKeyFromBytes(eBytes) priv, _ := btcec.PrivKeyFromBytes(eBytes)
return priv, nil return priv, nil
}) })
@ -49,6 +50,7 @@ var (
} }
priv, _ := btcec.PrivKeyFromBytes(eBytes) priv, _ := btcec.PrivKeyFromBytes(eBytes)
return priv, nil return priv, nil
}) })
) )
@ -56,9 +58,11 @@ var (
// completeHandshake takes two brontide machines (initiator, responder) // completeHandshake takes two brontide machines (initiator, responder)
// and completes the brontide handshake between them. If any part of the // and completes the brontide handshake between them. If any part of the
// handshake fails, this function will panic. // handshake fails, this function will panic.
func completeHandshake(initiator, responder *Machine, t *testing.T) { func completeHandshake(t *testing.T, initiator, responder *Machine) {
t.Helper()
if err := handshake(initiator, responder); err != nil { if err := handshake(initiator, responder); err != nil {
nilAndPanic(initiator, responder, err, t) nilAndPanic(t, initiator, responder, err)
} }
} }
@ -96,7 +100,9 @@ func handshake(initiator, responder *Machine) error {
// nilAndPanic first nils the initiator and responder's Curve fields and then // nilAndPanic first nils the initiator and responder's Curve fields and then
// panics. // panics.
func nilAndPanic(initiator, responder *Machine, err error, t *testing.T) { func nilAndPanic(t *testing.T, initiator, responder *Machine, err error) {
t.Helper()
t.Fatalf("error: %v, initiator: %v, responder: %v", err, t.Fatalf("error: %v, initiator: %v, responder: %v", err,
spew.Sdump(initiator), spew.Sdump(responder)) spew.Sdump(initiator), spew.Sdump(responder))
} }
@ -153,7 +159,7 @@ func FuzzRandomActOne(f *testing.F) {
// Responder receives ActOne, should fail on the MAC check. // Responder receives ActOne, should fail on the MAC check.
if err := responder.RecvActOne(actOne); err == nil { if err := responder.RecvActOne(actOne); err == nil {
nilAndPanic(nil, responder, nil, t) nilAndPanic(t, nil, responder, nil)
} }
}) })
} }
@ -172,12 +178,12 @@ func FuzzRandomActThree(f *testing.F) {
// Generate ActOne and send to the responder. // Generate ActOne and send to the responder.
actOne, err := initiator.GenActOne() actOne, err := initiator.GenActOne()
if err != nil { if err != nil {
nilAndPanic(initiator, responder, err, t) nilAndPanic(t, initiator, responder, err)
} }
// Receiving ActOne should succeed, so we panic on error. // Receiving ActOne should succeed, so we panic on error.
if err := responder.RecvActOne(actOne); err != nil { if err := responder.RecvActOne(actOne); err != nil {
nilAndPanic(initiator, responder, err, t) nilAndPanic(t, initiator, responder, err)
} }
// Generate ActTwo - this is not sent to the initiator because // Generate ActTwo - this is not sent to the initiator because
@ -186,7 +192,7 @@ func FuzzRandomActThree(f *testing.F) {
// the appropriate state in the responder machine. // the appropriate state in the responder machine.
_, err = responder.GenActTwo() _, err = responder.GenActTwo()
if err != nil { if err != nil {
nilAndPanic(initiator, responder, err, t) nilAndPanic(t, initiator, responder, err)
} }
// Copy data into [ActThreeSize]byte. // Copy data into [ActThreeSize]byte.
@ -195,7 +201,7 @@ func FuzzRandomActThree(f *testing.F) {
// Responder receives ActThree, should fail on the MAC check. // Responder receives ActThree, should fail on the MAC check.
if err := responder.RecvActThree(actThree); err == nil { if err := responder.RecvActThree(actThree); err == nil {
nilAndPanic(initiator, responder, nil, t) nilAndPanic(t, initiator, responder, nil)
} }
}) })
} }
@ -217,7 +223,7 @@ func FuzzRandomActTwo(f *testing.F) {
// appropriate state in the initiator machine. // appropriate state in the initiator machine.
_, err := initiator.GenActOne() _, err := initiator.GenActOne()
if err != nil { if err != nil {
nilAndPanic(initiator, nil, err, t) nilAndPanic(t, initiator, nil, err)
} }
// Copy data into [ActTwoSize]byte. // Copy data into [ActTwoSize]byte.
@ -226,7 +232,7 @@ func FuzzRandomActTwo(f *testing.F) {
// Initiator receives ActTwo, should fail. // Initiator receives ActTwo, should fail.
if err := initiator.RecvActTwo(actTwo); err == nil { if err := initiator.RecvActTwo(actTwo); err == nil {
nilAndPanic(initiator, nil, nil, t) nilAndPanic(t, initiator, nil, nil)
} }
}) })
} }
@ -239,7 +245,7 @@ func FuzzRandomInitDecrypt(f *testing.F) {
initiator, responder := getBrontideMachines() initiator, responder := getBrontideMachines()
// Complete the brontide handshake. // Complete the brontide handshake.
completeHandshake(initiator, responder, t) completeHandshake(t, initiator, responder)
// Create a reader with the byte array. // Create a reader with the byte array.
r := bytes.NewReader(data) r := bytes.NewReader(data)
@ -247,7 +253,7 @@ func FuzzRandomInitDecrypt(f *testing.F) {
// Decrypt the encrypted message using ReadMessage w/ initiator // Decrypt the encrypted message using ReadMessage w/ initiator
// machine. // machine.
if _, err := initiator.ReadMessage(r); err == nil { if _, err := initiator.ReadMessage(r); err == nil {
nilAndPanic(initiator, responder, nil, t) nilAndPanic(t, initiator, responder, nil)
} }
}) })
} }
@ -266,30 +272,31 @@ func FuzzRandomInitEncDec(f *testing.F) {
initiator, responder := getBrontideMachines() initiator, responder := getBrontideMachines()
// Complete the brontide handshake. // Complete the brontide handshake.
completeHandshake(initiator, responder, t) completeHandshake(t, initiator, responder)
var b bytes.Buffer var b bytes.Buffer
// Encrypt the message using WriteMessage w/ initiator machine. // Encrypt the message using WriteMessage w/ initiator machine.
if err := initiator.WriteMessage(data); err != nil { if err := initiator.WriteMessage(data); err != nil {
nilAndPanic(initiator, responder, err, t) nilAndPanic(t, initiator, responder, err)
} }
// Flush the encrypted message w/ initiator machine. // Flush the encrypted message w/ initiator machine.
if _, err := initiator.Flush(&b); err != nil { if _, err := initiator.Flush(&b); err != nil {
nilAndPanic(initiator, responder, err, t) nilAndPanic(t, initiator, responder, err)
} }
// Decrypt the ciphertext using ReadMessage w/ responder machine. // Decrypt the ciphertext using ReadMessage w/ responder
// machine.
plaintext, err := responder.ReadMessage(&b) plaintext, err := responder.ReadMessage(&b)
if err != nil { if err != nil {
nilAndPanic(initiator, responder, err, t) nilAndPanic(t, initiator, responder, err)
} }
// Check that the decrypted message and the original message are // Check that the decrypted message and the original message are
// equal. // equal.
if !bytes.Equal(data, plaintext) { if !bytes.Equal(data, plaintext) {
nilAndPanic(initiator, responder, nil, t) nilAndPanic(t, initiator, responder, nil)
} }
}) })
} }
@ -308,18 +315,18 @@ func FuzzRandomInitEncrypt(f *testing.F) {
initiator, responder := getBrontideMachines() initiator, responder := getBrontideMachines()
// Complete the brontide handshake. // Complete the brontide handshake.
completeHandshake(initiator, responder, t) completeHandshake(t, initiator, responder)
var b bytes.Buffer var b bytes.Buffer
// Encrypt the message using WriteMessage w/ initiator machine. // Encrypt the message using WriteMessage w/ initiator machine.
if err := initiator.WriteMessage(data); err != nil { if err := initiator.WriteMessage(data); err != nil {
nilAndPanic(initiator, responder, err, t) nilAndPanic(t, initiator, responder, err)
} }
// Flush the encrypted message w/ initiator machine. // Flush the encrypted message w/ initiator machine.
if _, err := initiator.Flush(&b); err != nil { if _, err := initiator.Flush(&b); err != nil {
nilAndPanic(initiator, responder, err, t) nilAndPanic(t, initiator, responder, err)
} }
}) })
} }
@ -332,7 +339,7 @@ func FuzzRandomRespDecrypt(f *testing.F) {
initiator, responder := getBrontideMachines() initiator, responder := getBrontideMachines()
// Complete the brontide handshake. // Complete the brontide handshake.
completeHandshake(initiator, responder, t) completeHandshake(t, initiator, responder)
// Create a reader with the byte array. // Create a reader with the byte array.
r := bytes.NewReader(data) r := bytes.NewReader(data)
@ -340,7 +347,7 @@ func FuzzRandomRespDecrypt(f *testing.F) {
// Decrypt the encrypted message using ReadMessage w/ responder // Decrypt the encrypted message using ReadMessage w/ responder
// machine. // machine.
if _, err := responder.ReadMessage(r); err == nil { if _, err := responder.ReadMessage(r); err == nil {
nilAndPanic(initiator, responder, nil, t) nilAndPanic(t, initiator, responder, nil)
} }
}) })
} }
@ -359,30 +366,31 @@ func FuzzRandomRespEncDec(f *testing.F) {
initiator, responder := getBrontideMachines() initiator, responder := getBrontideMachines()
// Complete the brontide handshake. // Complete the brontide handshake.
completeHandshake(initiator, responder, t) completeHandshake(t, initiator, responder)
var b bytes.Buffer var b bytes.Buffer
// Encrypt the message using WriteMessage w/ responder machine. // Encrypt the message using WriteMessage w/ responder machine.
if err := responder.WriteMessage(data); err != nil { if err := responder.WriteMessage(data); err != nil {
nilAndPanic(initiator, responder, err, t) nilAndPanic(t, initiator, responder, err)
} }
// Flush the encrypted message w/ responder machine. // Flush the encrypted message w/ responder machine.
if _, err := responder.Flush(&b); err != nil { if _, err := responder.Flush(&b); err != nil {
nilAndPanic(initiator, responder, err, t) nilAndPanic(t, initiator, responder, err)
} }
// Decrypt the ciphertext using ReadMessage w/ initiator machine. // Decrypt the ciphertext using ReadMessage w/ initiator
// machine.
plaintext, err := initiator.ReadMessage(&b) plaintext, err := initiator.ReadMessage(&b)
if err != nil { if err != nil {
nilAndPanic(initiator, responder, err, t) nilAndPanic(t, initiator, responder, err)
} }
// Check that the decrypted message and the original message are // Check that the decrypted message and the original message are
// equal. // equal.
if !bytes.Equal(data, plaintext) { if !bytes.Equal(data, plaintext) {
nilAndPanic(initiator, responder, nil, t) nilAndPanic(t, initiator, responder, nil)
} }
}) })
} }
@ -401,18 +409,18 @@ func FuzzRandomRespEncrypt(f *testing.F) {
initiator, responder := getBrontideMachines() initiator, responder := getBrontideMachines()
// Complete the brontide handshake. // Complete the brontide handshake.
completeHandshake(initiator, responder, t) completeHandshake(t, initiator, responder)
var b bytes.Buffer var b bytes.Buffer
// Encrypt the message using WriteMessage w/ responder machine. // Encrypt the message using WriteMessage w/ responder machine.
if err := responder.WriteMessage(data); err != nil { if err := responder.WriteMessage(data); err != nil {
nilAndPanic(initiator, responder, err, t) nilAndPanic(t, initiator, responder, err)
} }
// Flush the encrypted message w/ responder machine. // Flush the encrypted message w/ responder machine.
if _, err := responder.Flush(&b); err != nil { if _, err := responder.Flush(&b); err != nil {
nilAndPanic(initiator, responder, err, t) nilAndPanic(t, initiator, responder, err)
} }
}) })
} }
@ -434,7 +442,7 @@ func FuzzStaticActOne(f *testing.F) {
// Responder receives ActOne, should fail. // Responder receives ActOne, should fail.
if err := responder.RecvActOne(actOne); err == nil { if err := responder.RecvActOne(actOne); err == nil {
nilAndPanic(nil, responder, nil, t) nilAndPanic(t, nil, responder, nil)
} }
}) })
} }
@ -453,12 +461,12 @@ func FuzzStaticActThree(f *testing.F) {
// Generate ActOne and send to the responder. // Generate ActOne and send to the responder.
actOne, err := initiator.GenActOne() actOne, err := initiator.GenActOne()
if err != nil { if err != nil {
nilAndPanic(initiator, responder, err, t) nilAndPanic(t, initiator, responder, err)
} }
// Receiving ActOne should succeed, so we panic on error. // Receiving ActOne should succeed, so we panic on error.
if err := responder.RecvActOne(actOne); err != nil { if err := responder.RecvActOne(actOne); err != nil {
nilAndPanic(initiator, responder, err, t) nilAndPanic(t, initiator, responder, err)
} }
// Generate ActTwo - this is not sent to the initiator because // Generate ActTwo - this is not sent to the initiator because
@ -467,7 +475,7 @@ func FuzzStaticActThree(f *testing.F) {
// the appropriate state in the responder machine. // the appropriate state in the responder machine.
_, err = responder.GenActTwo() _, err = responder.GenActTwo()
if err != nil { if err != nil {
nilAndPanic(initiator, responder, err, t) nilAndPanic(t, initiator, responder, err)
} }
// Copy data into [ActThreeSize]byte. // Copy data into [ActThreeSize]byte.
@ -476,7 +484,7 @@ func FuzzStaticActThree(f *testing.F) {
// Responder receives ActThree, should fail. // Responder receives ActThree, should fail.
if err := responder.RecvActThree(actThree); err == nil { if err := responder.RecvActThree(actThree); err == nil {
nilAndPanic(initiator, responder, nil, t) nilAndPanic(t, initiator, responder, nil)
} }
}) })
} }
@ -498,7 +506,7 @@ func FuzzStaticActTwo(f *testing.F) {
// appropriate state in the initiator machine. // appropriate state in the initiator machine.
_, err := initiator.GenActOne() _, err := initiator.GenActOne()
if err != nil { if err != nil {
nilAndPanic(initiator, nil, err, t) nilAndPanic(t, initiator, nil, err)
} }
// Copy data into [ActTwoSize]byte. // Copy data into [ActTwoSize]byte.
@ -507,7 +515,7 @@ func FuzzStaticActTwo(f *testing.F) {
// Initiator receives ActTwo, should fail. // Initiator receives ActTwo, should fail.
if err := initiator.RecvActTwo(actTwo); err == nil { if err := initiator.RecvActTwo(actTwo); err == nil {
nilAndPanic(initiator, nil, nil, t) nilAndPanic(t, initiator, nil, nil)
} }
}) })
} }
@ -520,7 +528,7 @@ func FuzzStaticInitDecrypt(f *testing.F) {
initiator, responder := getStaticBrontideMachines() initiator, responder := getStaticBrontideMachines()
// Complete the brontide handshake. // Complete the brontide handshake.
completeHandshake(initiator, responder, t) completeHandshake(t, initiator, responder)
// Create a reader with the byte array. // Create a reader with the byte array.
r := bytes.NewReader(data) r := bytes.NewReader(data)
@ -528,7 +536,7 @@ func FuzzStaticInitDecrypt(f *testing.F) {
// Decrypt the encrypted message using ReadMessage w/ initiator // Decrypt the encrypted message using ReadMessage w/ initiator
// machine. // machine.
if _, err := initiator.ReadMessage(r); err == nil { if _, err := initiator.ReadMessage(r); err == nil {
nilAndPanic(initiator, responder, nil, t) nilAndPanic(t, initiator, responder, nil)
} }
}) })
} }
@ -547,31 +555,31 @@ func FuzzStaticInitEncDec(f *testing.F) {
initiator, responder := getStaticBrontideMachines() initiator, responder := getStaticBrontideMachines()
// Complete the brontide handshake. // Complete the brontide handshake.
completeHandshake(initiator, responder, t) completeHandshake(t, initiator, responder)
var b bytes.Buffer var b bytes.Buffer
// Encrypt the message using WriteMessage w/ initiator machine. // Encrypt the message using WriteMessage w/ initiator machine.
if err := initiator.WriteMessage(data); err != nil { if err := initiator.WriteMessage(data); err != nil {
nilAndPanic(initiator, responder, err, t) nilAndPanic(t, initiator, responder, err)
} }
// Flush the encrypted message w/ initiator machine. // Flush the encrypted message w/ initiator machine.
if _, err := initiator.Flush(&b); err != nil { if _, err := initiator.Flush(&b); err != nil {
nilAndPanic(initiator, responder, err, t) nilAndPanic(t, initiator, responder, err)
} }
// Decrypt the ciphertext using ReadMessage w/ responder // Decrypt the ciphertext using ReadMessage w/ responder
// machine. // machine.
plaintext, err := responder.ReadMessage(&b) plaintext, err := responder.ReadMessage(&b)
if err != nil { if err != nil {
nilAndPanic(initiator, responder, err, t) nilAndPanic(t, initiator, responder, err)
} }
// Check that the decrypted message and the original message are // Check that the decrypted message and the original message are
// equal. // equal.
if !bytes.Equal(data, plaintext) { if !bytes.Equal(data, plaintext) {
nilAndPanic(initiator, responder, nil, t) nilAndPanic(t, initiator, responder, nil)
} }
}) })
} }
@ -590,18 +598,18 @@ func FuzzStaticInitEncrypt(f *testing.F) {
initiator, responder := getStaticBrontideMachines() initiator, responder := getStaticBrontideMachines()
// Complete the brontide handshake. // Complete the brontide handshake.
completeHandshake(initiator, responder, t) completeHandshake(t, initiator, responder)
var b bytes.Buffer var b bytes.Buffer
// Encrypt the message using WriteMessage w/ initiator machine. // Encrypt the message using WriteMessage w/ initiator machine.
if err := initiator.WriteMessage(data); err != nil { if err := initiator.WriteMessage(data); err != nil {
nilAndPanic(initiator, responder, err, t) nilAndPanic(t, initiator, responder, err)
} }
// Flush the encrypted message w/ initiator machine. // Flush the encrypted message w/ initiator machine.
if _, err := initiator.Flush(&b); err != nil { if _, err := initiator.Flush(&b); err != nil {
nilAndPanic(initiator, responder, err, t) nilAndPanic(t, initiator, responder, err)
} }
}) })
} }
@ -614,7 +622,7 @@ func FuzzStaticRespDecrypt(f *testing.F) {
initiator, responder := getStaticBrontideMachines() initiator, responder := getStaticBrontideMachines()
// Complete the brontide handshake. // Complete the brontide handshake.
completeHandshake(initiator, responder, t) completeHandshake(t, initiator, responder)
// Create a reader with the byte array. // Create a reader with the byte array.
r := bytes.NewReader(data) r := bytes.NewReader(data)
@ -622,7 +630,7 @@ func FuzzStaticRespDecrypt(f *testing.F) {
// Decrypt the encrypted message using ReadMessage w/ responder // Decrypt the encrypted message using ReadMessage w/ responder
// machine. // machine.
if _, err := responder.ReadMessage(r); err == nil { if _, err := responder.ReadMessage(r); err == nil {
nilAndPanic(initiator, responder, nil, t) nilAndPanic(t, initiator, responder, nil)
} }
}) })
} }
@ -641,31 +649,31 @@ func FuzzStaticRespEncDec(f *testing.F) {
initiator, responder := getStaticBrontideMachines() initiator, responder := getStaticBrontideMachines()
// Complete the brontide handshake. // Complete the brontide handshake.
completeHandshake(initiator, responder, t) completeHandshake(t, initiator, responder)
var b bytes.Buffer var b bytes.Buffer
// Encrypt the message using WriteMessage w/ responder machine. // Encrypt the message using WriteMessage w/ responder machine.
if err := responder.WriteMessage(data); err != nil { if err := responder.WriteMessage(data); err != nil {
nilAndPanic(initiator, responder, err, t) nilAndPanic(t, initiator, responder, err)
} }
// Flush the encrypted message w/ responder machine. // Flush the encrypted message w/ responder machine.
if _, err := responder.Flush(&b); err != nil { if _, err := responder.Flush(&b); err != nil {
nilAndPanic(initiator, responder, err, t) nilAndPanic(t, initiator, responder, err)
} }
// Decrypt the ciphertext using ReadMessage w/ initiator // Decrypt the ciphertext using ReadMessage w/ initiator
// machine. // machine.
plaintext, err := initiator.ReadMessage(&b) plaintext, err := initiator.ReadMessage(&b)
if err != nil { if err != nil {
nilAndPanic(initiator, responder, err, t) nilAndPanic(t, initiator, responder, err)
} }
// Check that the decrypted message and the original message are // Check that the decrypted message and the original message are
// equal. // equal.
if !bytes.Equal(data, plaintext) { if !bytes.Equal(data, plaintext) {
nilAndPanic(initiator, responder, nil, t) nilAndPanic(t, initiator, responder, nil)
} }
}) })
} }
@ -684,18 +692,18 @@ func FuzzStaticRespEncrypt(f *testing.F) {
initiator, responder := getStaticBrontideMachines() initiator, responder := getStaticBrontideMachines()
// Complete the brontide handshake. // Complete the brontide handshake.
completeHandshake(initiator, responder, t) completeHandshake(t, initiator, responder)
var b bytes.Buffer var b bytes.Buffer
// Encrypt the message using WriteMessage w/ responder machine. // Encrypt the message using WriteMessage w/ responder machine.
if err := responder.WriteMessage(data); err != nil { if err := responder.WriteMessage(data); err != nil {
nilAndPanic(initiator, responder, err, t) nilAndPanic(t, initiator, responder, err)
} }
// Flush the encrypted message w/ responder machine. // Flush the encrypted message w/ responder machine.
if _, err := responder.Flush(&b); err != nil { if _, err := responder.Flush(&b); err != nil {
nilAndPanic(initiator, responder, err, t) nilAndPanic(t, initiator, responder, err)
} }
}) })
} }

86
lnwire/fuzz_test.go
View File

@ -14,6 +14,7 @@ func prefixWithMsgType(data []byte, prefix MessageType) []byte {
var prefixBytes [2]byte var prefixBytes [2]byte
binary.BigEndian.PutUint16(prefixBytes[:], uint16(prefix)) binary.BigEndian.PutUint16(prefixBytes[:], uint16(prefix))
data = append(prefixBytes[:], data...) data = append(prefixBytes[:], data...)
return data return data
} }
@ -22,6 +23,8 @@ func prefixWithMsgType(data []byte, prefix MessageType) []byte {
// checks, is a valid message once deserialized, and passes a sequence of // checks, is a valid message once deserialized, and passes a sequence of
// serialization and deserialization checks. // serialization and deserialization checks.
func harness(t *testing.T, data []byte) { func harness(t *testing.T, data []byte) {
t.Helper()
// Create a reader with the byte array. // Create a reader with the byte array.
r := bytes.NewReader(data) r := bytes.NewReader(data)
@ -55,7 +58,8 @@ func harness(t *testing.T, data []byte) {
if !reflect.DeepEqual(msg, newMsg) { if !reflect.DeepEqual(msg, newMsg) {
// Deserialized message and original message are not deeply // Deserialized message and original message are not deeply
// equal. // equal.
t.Fatal("original message and deserialized message are not deeply equal") t.Fatal("original message and deserialized message are not " +
"deeply equal")
} }
} }
@ -99,10 +103,18 @@ func FuzzAcceptChannel(f *testing.F) {
// probably takes up more branches than necessary, but that's // probably takes up more branches than necessary, but that's
// fine for now. // fine for now.
var shouldPanic bool var shouldPanic bool
first := msg.(*AcceptChannel) first, ok := msg.(*AcceptChannel)
second := newMsg.(*AcceptChannel) if !ok {
t.Fatal("message was not AcceptChannel")
}
second, ok := newMsg.(*AcceptChannel)
if !ok {
t.Fatal("new message was not AcceptChannel")
}
if !bytes.Equal(first.PendingChannelID[:],
second.PendingChannelID[:]) {
if !bytes.Equal(first.PendingChannelID[:], second.PendingChannelID[:]) {
shouldPanic = true shouldPanic = true
} }
@ -146,7 +158,9 @@ func FuzzAcceptChannel(f *testing.F) {
shouldPanic = true shouldPanic = true
} }
if !first.DelayedPaymentPoint.IsEqual(second.DelayedPaymentPoint) { if !first.DelayedPaymentPoint.IsEqual(
second.DelayedPaymentPoint) {
shouldPanic = true shouldPanic = true
} }
@ -154,16 +168,21 @@ func FuzzAcceptChannel(f *testing.F) {
shouldPanic = true shouldPanic = true
} }
if !first.FirstCommitmentPoint.IsEqual(second.FirstCommitmentPoint) { if !first.FirstCommitmentPoint.IsEqual(
second.FirstCommitmentPoint) {
shouldPanic = true shouldPanic = true
} }
if !bytes.Equal(first.UpfrontShutdownScript, second.UpfrontShutdownScript) { if !bytes.Equal(first.UpfrontShutdownScript,
second.UpfrontShutdownScript) {
shouldPanic = true shouldPanic = true
} }
if shouldPanic { if shouldPanic {
t.Fatalf("original message and deseralized message are not equal") t.Fatal("original message and deseralized message " +
"are not equal")
} }
}) })
} }
@ -344,8 +363,15 @@ func FuzzNodeAnnouncement(f *testing.F) {
// Now compare every field instead of using reflect.DeepEqual // Now compare every field instead of using reflect.DeepEqual
// for the Addresses field. // for the Addresses field.
var shouldPanic bool var shouldPanic bool
first := msg.(*NodeAnnouncement) first, ok := msg.(*NodeAnnouncement)
second := newMsg.(*NodeAnnouncement) if !ok {
t.Fatal("message was not NodeAnnouncement")
}
second, ok := newMsg.(*NodeAnnouncement)
if !ok {
t.Fatal("new message was not NodeAnnouncement")
}
if !bytes.Equal(first.Signature[:], second.Signature[:]) { if !bytes.Equal(first.Signature[:], second.Signature[:]) {
shouldPanic = true shouldPanic = true
} }
@ -375,18 +401,23 @@ func FuzzNodeAnnouncement(f *testing.F) {
} }
for i := range first.Addresses { for i := range first.Addresses {
if first.Addresses[i].String() != second.Addresses[i].String() { if first.Addresses[i].String() !=
second.Addresses[i].String() {
shouldPanic = true shouldPanic = true
break break
} }
} }
if !reflect.DeepEqual(first.ExtraOpaqueData, second.ExtraOpaqueData) { if !reflect.DeepEqual(first.ExtraOpaqueData,
second.ExtraOpaqueData) {
shouldPanic = true shouldPanic = true
} }
if shouldPanic { if shouldPanic {
t.Fatal("original message and deserialized message are not equal") t.Fatal("original message and deserialized message " +
"are not equal")
} }
}) })
} }
@ -439,14 +470,22 @@ func FuzzOpenChannel(f *testing.F) {
// probably takes up more branches than necessary, but that's // probably takes up more branches than necessary, but that's
// fine for now. // fine for now.
var shouldPanic bool var shouldPanic bool
first := msg.(*OpenChannel) first, ok := msg.(*OpenChannel)
second := newMsg.(*OpenChannel) if !ok {
t.Fatal("message was not OpenChannel")
}
second, ok := newMsg.(*OpenChannel)
if !ok {
t.Fatal("new message was not OpenChannel")
}
if !first.ChainHash.IsEqual(&second.ChainHash) { if !first.ChainHash.IsEqual(&second.ChainHash) {
shouldPanic = true shouldPanic = true
} }
if !bytes.Equal(first.PendingChannelID[:], second.PendingChannelID[:]) { if !bytes.Equal(first.PendingChannelID[:],
second.PendingChannelID[:]) {
shouldPanic = true shouldPanic = true
} }
@ -498,7 +537,9 @@ func FuzzOpenChannel(f *testing.F) {
shouldPanic = true shouldPanic = true
} }
if !first.DelayedPaymentPoint.IsEqual(second.DelayedPaymentPoint) { if !first.DelayedPaymentPoint.IsEqual(
second.DelayedPaymentPoint) {
shouldPanic = true shouldPanic = true
} }
@ -506,7 +547,9 @@ func FuzzOpenChannel(f *testing.F) {
shouldPanic = true shouldPanic = true
} }
if !first.FirstCommitmentPoint.IsEqual(second.FirstCommitmentPoint) { if !first.FirstCommitmentPoint.IsEqual(
second.FirstCommitmentPoint) {
shouldPanic = true shouldPanic = true
} }
@ -514,12 +557,15 @@ func FuzzOpenChannel(f *testing.F) {
shouldPanic = true shouldPanic = true
} }
if !bytes.Equal(first.UpfrontShutdownScript, second.UpfrontShutdownScript) { if !bytes.Equal(first.UpfrontShutdownScript,
second.UpfrontShutdownScript) {
shouldPanic = true shouldPanic = true
} }
if shouldPanic { if shouldPanic {
t.Fatal("original message and deserialized message are not equal") t.Fatal("original message and deserialized message " +
"are not equal")
} }
}) })
} }

3
watchtower/wtwire/fuzz_test.go
View File

@ -13,6 +13,7 @@ func prefixWithMsgType(data []byte, prefix MessageType) []byte {
var prefixBytes [2]byte var prefixBytes [2]byte
binary.BigEndian.PutUint16(prefixBytes[:], uint16(prefix)) binary.BigEndian.PutUint16(prefixBytes[:], uint16(prefix))
data = append(prefixBytes[:], data...) data = append(prefixBytes[:], data...)
return data return data
} }
@ -22,6 +23,8 @@ func prefixWithMsgType(data []byte, prefix MessageType) []byte {
// serialization and deserialization checks. Returns an int that determines // serialization and deserialization checks. Returns an int that determines
// whether the input is unique or not. // whether the input is unique or not.
func harness(t *testing.T, data []byte, emptyMsg Message) { func harness(t *testing.T, data []byte, emptyMsg Message) {
t.Helper()
// Create a reader with the byte array. // Create a reader with the byte array.
r := bytes.NewReader(data) r := bytes.NewReader(data)

6
zpay32/fuzz_test.go
View File

@ -39,7 +39,7 @@ func FuzzEncode(f *testing.F) {
// Initialize the static key we will be using for this fuzz // Initialize the static key we will be using for this fuzz
// test. // test.
testPrivKeyBytes, _ := hex.DecodeString("e126f68f7eafcc8b74f54d269fe206be715000f94dac067d1c04a8ca3b2db734") testPrivKeyBytes, _ := hex.DecodeString("e126f68f7eafcc8b74f54d269fe206be715000f94dac067d1c04a8ca3b2db734") // nolint:lll
testPrivKey, _ := btcec.PrivKeyFromBytes(testPrivKeyBytes) testPrivKey, _ := btcec.PrivKeyFromBytes(testPrivKeyBytes)
// Then, initialize the testMessageSigner so we can encode out // Then, initialize the testMessageSigner so we can encode out
@ -47,12 +47,14 @@ func FuzzEncode(f *testing.F) {
testMessageSigner := MessageSigner{ testMessageSigner := MessageSigner{
SignCompact: func(msg []byte) ([]byte, error) { SignCompact: func(msg []byte) ([]byte, error) {
hash := chainhash.HashB(msg) hash := chainhash.HashB(msg)
sig, err := ecdsa.SignCompact(testPrivKey, hash, true) sig, err := ecdsa.SignCompact(testPrivKey, hash,
true)
if err != nil { if err != nil {
return nil, return nil,
fmt.Errorf("can't sign the "+ fmt.Errorf("can't sign the "+
"message: %v", err) "message: %v", err)
} }
return sig, nil return sig, nil
}, },
} }