2 extern crate lightning;
3 extern crate secp256k1;
5 use bitcoin::blockdata::block::BlockHeader;
6 use bitcoin::blockdata::transaction::Transaction;
7 use bitcoin::util::hash::Sha256dHash;
8 use bitcoin::network::serialize::{serialize, BitcoinHash};
10 use lightning::ln::channel::Channel;
11 use lightning::ln::channelmanager::PendingForwardHTLCInfo;
12 use lightning::ln::msgs;
13 use lightning::ln::msgs::MsgDecodable;
14 use lightning::chain::chaininterface::{FeeEstimator, ConfirmationTarget};
16 use secp256k1::key::PublicKey;
17 use secp256k1::Secp256k1;
19 use std::sync::atomic::{AtomicUsize,Ordering};
22 pub fn slice_to_be16(v: &[u8]) -> u16 {
23 ((v[0] as u16) << 8*1) |
24 ((v[1] as u16) << 8*0)
28 pub fn slice_to_be32(v: &[u8]) -> u32 {
29 ((v[0] as u32) << 8*3) |
30 ((v[1] as u32) << 8*2) |
31 ((v[2] as u32) << 8*1) |
32 ((v[3] as u32) << 8*0)
36 pub fn slice_to_be64(v: &[u8]) -> u64 {
37 ((v[0] as u64) << 8*7) |
38 ((v[1] as u64) << 8*6) |
39 ((v[2] as u64) << 8*5) |
40 ((v[3] as u64) << 8*4) |
41 ((v[4] as u64) << 8*3) |
42 ((v[5] as u64) << 8*2) |
43 ((v[6] as u64) << 8*1) |
44 ((v[7] as u64) << 8*0)
48 fn slice_to_be24(v: &[u8]) -> u64 {
49 //TODO: We should probably be returning a Result for channel creation, not panic!()ing on
51 ((v[0] as u64) << 8*2) |
52 ((v[1] as u64) << 8*1) |
53 ((v[2] as u64) << 8*0)
56 struct InputData<'a> {
58 read_pos: AtomicUsize,
60 impl<'a> InputData<'a> {
61 fn get_slice(&self, len: usize) -> Option<&'a [u8]> {
62 let old_pos = self.read_pos.fetch_add(len, Ordering::AcqRel);
63 if self.data.len() < old_pos + len {
66 Some(&self.data[old_pos..old_pos + len])
68 fn get_slice_nonadvancing(&self, len: usize) -> Option<&'a [u8]> {
69 let old_pos = self.read_pos.load(Ordering::Acquire);
70 if self.data.len() < old_pos + len {
73 Some(&self.data[old_pos..old_pos + len])
77 struct FuzzEstimator<'a> {
78 input: &'a InputData<'a>,
80 impl<'a> FeeEstimator for FuzzEstimator<'a> {
81 fn get_est_sat_per_vbyte(&self, _: ConfirmationTarget) -> u64 {
82 //TODO: We should actually be testing at least much more than 64k...
83 match self.input.get_slice(2) {
84 Some(slice) => slice_to_be16(slice) as u64,
91 pub fn do_test(data: &[u8]) {
92 let input = InputData {
94 read_pos: AtomicUsize::new(0),
96 let fee_est = FuzzEstimator {
100 macro_rules! get_slice {
102 match input.get_slice($len as usize) {
103 Some(slice) => slice,
109 macro_rules! decode_msg {
110 ($MsgType: path, $len: expr) => {
111 match <($MsgType)>::decode(get_slice!($len)) {
114 msgs::DecodeError::UnknownRealmByte => return,
115 msgs::DecodeError::BadPublicKey => return,
116 msgs::DecodeError::BadSignature => return,
117 msgs::DecodeError::ExtraAddressesPerType => return,
118 msgs::DecodeError::WrongLength => panic!("We picked the length..."),
124 macro_rules! decode_msg_with_len16 {
125 ($MsgType: path, $begin_len: expr, $factor: expr) => {
127 let extra_len = slice_to_be16(&match input.get_slice_nonadvancing($begin_len as usize + 2) {
128 Some(slice) => slice,
130 }[$begin_len..$begin_len + 2]);
131 match <($MsgType)>::decode(get_slice!($begin_len as usize + 2 + (extra_len as usize)*$factor)) {
134 msgs::DecodeError::UnknownRealmByte => return,
135 msgs::DecodeError::BadPublicKey => return,
136 msgs::DecodeError::BadSignature => return,
137 msgs::DecodeError::ExtraAddressesPerType => return,
138 msgs::DecodeError::WrongLength => panic!("We picked the length..."),
145 let secp_ctx = Secp256k1::new();
146 macro_rules! get_pubkey {
148 match PublicKey::from_slice(&secp_ctx, get_slice!(33)) {
155 macro_rules! return_err {
164 let their_pubkey = get_pubkey!();
166 let tx = Transaction { version: 0, lock_time: 0, input: Vec::new(), output: Vec::new() };
167 let funding_output = (Sha256dHash::from_data(&serialize(&tx).unwrap()[..]), 0);
169 let mut channel = if get_slice!(1)[0] != 0 {
170 let mut chan = Channel::new_outbound(&fee_est, their_pubkey, slice_to_be24(get_slice!(3)), get_slice!(1)[0] == 0, slice_to_be64(get_slice!(8)));
171 chan.get_open_channel(Sha256dHash::from(get_slice!(32)), &fee_est).unwrap();
172 let accept_chan = if get_slice!(1)[0] == 0 {
173 decode_msg_with_len16!(msgs::AcceptChannel, 270, 1)
175 decode_msg!(msgs::AcceptChannel, 270)
177 return_err!(chan.accept_channel(&accept_chan));
178 chan.get_outbound_funding_created(funding_output.0.clone(), funding_output.1).unwrap();
179 let funding_signed = decode_msg!(msgs::FundingSigned, 32+64);
180 return_err!(chan.funding_signed(&funding_signed));
183 let open_chan = if get_slice!(1)[0] == 0 {
184 decode_msg_with_len16!(msgs::OpenChannel, 2*32+6*8+4+2*2+6*33+1, 1)
186 decode_msg!(msgs::OpenChannel, 2*32+6*8+4+2*2+6*33+1)
188 let mut chan = match Channel::new_from_req(&fee_est, their_pubkey, &open_chan, slice_to_be64(get_slice!(8)), get_slice!(1)[0] == 0) {
192 chan.get_accept_channel().unwrap();
193 let mut funding_created = decode_msg!(msgs::FundingCreated, 32+32+2+64);
194 funding_created.funding_txid = funding_output.0.clone();
195 funding_created.funding_output_index = funding_output.1;
196 return_err!(chan.funding_created(&funding_created));
200 let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
201 channel.block_connected(&header, 1, &[&tx; 1], &[42; 1]);
203 header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
204 channel.block_connected(&header, i, &[&tx; 0], &[0; 0]);
207 let funding_locked = decode_msg!(msgs::FundingLocked, 32+33);
208 return_err!(channel.funding_locked(&funding_locked));
211 match get_slice!(1)[0] {
213 return_err!(channel.send_htlc(slice_to_be64(get_slice!(8)), [42; 32], slice_to_be32(get_slice!(4)), msgs::OnionPacket {
214 version: get_slice!(1)[0],
215 public_key: get_pubkey!(),
216 hop_data: [0; 20*65],
221 return_err!(channel.send_commitment());
224 let update_add_htlc = decode_msg!(msgs::UpdateAddHTLC, 32+8+8+32+4+4+33+20*65+32);
225 return_err!(channel.update_add_htlc(&update_add_htlc, PendingForwardHTLCInfo::dummy()));
228 let update_fulfill_htlc = decode_msg!(msgs::UpdateFulfillHTLC, 32 + 8 + 32);
229 return_err!(channel.update_fulfill_htlc(&update_fulfill_htlc));
232 let update_fail_htlc = decode_msg_with_len16!(msgs::UpdateFailHTLC, 32 + 8, 1);
233 return_err!(channel.update_fail_htlc(&update_fail_htlc));
236 let update_fail_malformed_htlc = decode_msg!(msgs::UpdateFailMalformedHTLC, 32+8+32+2);
237 return_err!(channel.update_fail_malformed_htlc(&update_fail_malformed_htlc));
240 let commitment_signed = decode_msg_with_len16!(msgs::CommitmentSigned, 32+64, 64);
241 return_err!(channel.commitment_signed(&commitment_signed));
244 let revoke_and_ack = decode_msg!(msgs::RevokeAndACK, 32+32+33);
245 return_err!(channel.revoke_and_ack(&revoke_and_ack));
248 let update_fee = decode_msg!(msgs::UpdateFee, 32+4);
249 return_err!(channel.update_fee(&fee_est, &update_fee));
252 let shutdown = decode_msg_with_len16!(msgs::Shutdown, 32, 1);
253 return_err!(channel.shutdown(&fee_est, &shutdown));
256 let closing_signed = decode_msg!(msgs::ClosingSigned, 32+8+64);
257 return_err!(channel.closing_signed(&fee_est, &closing_signed));
264 #[cfg(feature = "afl")]
266 #[cfg(feature = "afl")]
268 afl::read_stdio_bytes(|data| {
273 #[cfg(feature = "honggfuzz")]
274 #[macro_use] extern crate honggfuzz;
275 #[cfg(feature = "honggfuzz")]
286 fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
288 for (idx, c) in hex.as_bytes().iter().enumerate() {
291 b'A'...b'F' => b |= c - b'A' + 10,
292 b'a'...b'f' => b |= c - b'a' + 10,
293 b'0'...b'9' => b |= c - b'0',
294 _ => panic!("Bad hex"),
304 fn duplicate_crash() {
305 let mut a = Vec::new();
306 extend_vec_from_hex("00", &mut a);