From 87a0018e3ebf7d47086032d817a9e671c359214e Mon Sep 17 00:00:00 2001 From: Matt Corallo Date: Fri, 27 Dec 2019 17:29:51 -0500 Subject: [PATCH] Better document msg fuzz target behavior and be slightly more strict --- fuzz/src/msg_targets/utils.rs | 21 ++++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-) diff --git a/fuzz/src/msg_targets/utils.rs b/fuzz/src/msg_targets/utils.rs index a5257ba0f..2a7731ccd 100644 --- a/fuzz/src/msg_targets/utils.rs +++ b/fuzz/src/msg_targets/utils.rs @@ -13,6 +13,15 @@ impl Writer for VecWriter { } } +// We attempt to test the strictest behavior we can for a given message, however, some messages +// have different expected behavior. You can see which messages have which behavior in +// gen_target.sh, but, in general, the *_announcement messages have to round-trip exactly (as +// otherwise we'd invalidate the signatures), most messages just need to round-trip up to the +// amount of data we know how to interpret, and some messages we may throw out invalid stuff (eg +// if an error message isn't valid UTF-8 we cant String-ize it), so they wont roundtrip correctly. + +// Tests a message that must survive roundtrip exactly, though may not empty the read buffer +// entirely #[macro_export] macro_rules! test_msg { ($MsgType: path, $data: ident) => { @@ -31,6 +40,8 @@ macro_rules! test_msg { } } +// Tests a message that may lose data on roundtrip, but shoulnd't lose data compared to our +// re-serialization. #[macro_export] macro_rules! test_msg_simple { ($MsgType: path, $data: ident) => { @@ -40,11 +51,18 @@ macro_rules! test_msg_simple { if let Ok(msg) = <$MsgType as Readable<::std::io::Cursor<&[u8]>>>::read(&mut r) { let mut w = VecWriter(Vec::new()); msg.write(&mut w).unwrap(); + + let msg = <$MsgType as Readable<::std::io::Cursor<&[u8]>>>::read(&mut ::std::io::Cursor::new(&w.0)).unwrap(); + let mut w_two = VecWriter(Vec::new()); + msg.write(&mut w_two).unwrap(); + assert_eq!(&w.0[..], &w_two.0[..]); } } } } +// Tests a message that must survive roundtrip exactly, and must exactly empty the read buffer and +// split it back out on re-serialization. #[macro_export] macro_rules! test_msg_exact { ($MsgType: path, $data: ident) => { @@ -54,13 +72,14 @@ macro_rules! test_msg_exact { if let Ok(msg) = <$MsgType as Readable<::std::io::Cursor<&[u8]>>>::read(&mut r) { let mut w = VecWriter(Vec::new()); msg.write(&mut w).unwrap(); - assert_eq!(&r.into_inner()[..], &w.0[..]); } } } } +// Tests a message that must survive roundtrip exactly, modulo one "hole" which may be set to 0s on +// re-serialization. #[macro_export] macro_rules! test_msg_hole { ($MsgType: path, $data: ident, $hole: expr, $hole_len: expr) => { -- 2.39.5