_ Git - rust-lightning/blob - fuzz/fuzz_targets/channel_target.rs

   1 extern crate bitcoin;
   2 extern crate lightning;
   3 extern crate secp256k1;
   4
   5 use bitcoin::blockdata::block::BlockHeader;
   6 use bitcoin::blockdata::transaction::{Transaction, TxOut};
   7 use bitcoin::util::hash::Sha256dHash;
   8 use bitcoin::network::serialize::{serialize, BitcoinHash};
   9
  10 use lightning::ln::channel::{Channel, ChannelKeys};
  11 use lightning::ln::channelmanager::{HTLCFailReason, PendingForwardHTLCInfo};
  12 use lightning::ln::msgs;
  13 use lightning::ln::msgs::MsgDecodable;
  14 use lightning::chain::chaininterface::{FeeEstimator, ConfirmationTarget};
  15 use lightning::chain::transaction::OutPoint;
  16 use lightning::util::reset_rng_state;
  17
  18 use secp256k1::key::{PublicKey, SecretKey};
  19 use secp256k1::Secp256k1;
  20
  21 use std::sync::atomic::{AtomicUsize,Ordering};
  22
  23 #[inline]
  24 pub fn slice_to_be16(v: &[u8]) -> u16 {
  25         ((v[0] as u16) << 8*1) |
  26         ((v[1] as u16) << 8*0)
  27 }
  28
  29 #[inline]
  30 pub fn slice_to_be32(v: &[u8]) -> u32 {
  31         ((v[0] as u32) << 8*3) |
  32         ((v[1] as u32) << 8*2) |
  33         ((v[2] as u32) << 8*1) |
  34         ((v[3] as u32) << 8*0)
  35 }
  36
  37 #[inline]
  38 pub fn slice_to_be64(v: &[u8]) -> u64 {
  39         ((v[0] as u64) << 8*7) |
  40         ((v[1] as u64) << 8*6) |
  41         ((v[2] as u64) << 8*5) |
  42         ((v[3] as u64) << 8*4) |
  43         ((v[4] as u64) << 8*3) |
  44         ((v[5] as u64) << 8*2) |
  45         ((v[6] as u64) << 8*1) |
  46         ((v[7] as u64) << 8*0)
  47 }
  48
  49 #[inline]
  50 fn slice_to_be24(v: &[u8]) -> u64 {
  51         //TODO: We should probably be returning a Result for channel creation, not panic!()ing on
  52         //>2**24 values...
  53         ((v[0] as u64) << 8*2) |
  54         ((v[1] as u64) << 8*1) |
  55         ((v[2] as u64) << 8*0)
  56 }
  57
  58 struct InputData<'a> {
  59         data: &'a [u8],
  60         read_pos: AtomicUsize,
  61 }
  62 impl<'a> InputData<'a> {
  63         fn get_slice(&self, len: usize) -> Option<&'a [u8]> {
  64                 let old_pos = self.read_pos.fetch_add(len, Ordering::AcqRel);
  65                 if self.data.len() < old_pos + len {
  66                         return None;
  67                 }
  68                 Some(&self.data[old_pos..old_pos + len])
  69         }
  70         fn get_slice_nonadvancing(&self, len: usize) -> Option<&'a [u8]> {
  71                 let old_pos = self.read_pos.load(Ordering::Acquire);
  72                 if self.data.len() < old_pos + len {
  73                         return None;
  74                 }
  75                 Some(&self.data[old_pos..old_pos + len])
  76         }
  77 }
  78
  79 struct FuzzEstimator<'a> {
  80         input: &'a InputData<'a>,
  81 }
  82 impl<'a> FeeEstimator for FuzzEstimator<'a> {
  83         fn get_est_sat_per_vbyte(&self, _: ConfirmationTarget) -> u64 {
  84                 //TODO: We should actually be testing at least much more than 64k...
  85                 match self.input.get_slice(2) {
  86                         Some(slice) => slice_to_be16(slice) as u64,
  87                         None => 0
  88                 }
  89         }
  90 }
  91
  92 #[inline]
  93 pub fn do_test(data: &[u8]) {
  94         reset_rng_state();
  95
  96         let input = InputData {
  97                 data,
  98                 read_pos: AtomicUsize::new(0),
  99         };
 100         let fee_est = FuzzEstimator {
 101                 input: &input,
 102         };
 103
 104         macro_rules! get_slice {
 105                 ($len: expr) => {
 106                         match input.get_slice($len as usize) {
 107                                 Some(slice) => slice,
 108                                 None => return,
 109                         }
 110                 }
 111         }
 112
 113         macro_rules! decode_msg {
 114                 ($MsgType: path, $len: expr) => {
 115                         match <($MsgType)>::decode(get_slice!($len)) {
 116                                 Ok(msg) => msg,
 117                                 Err(e) => match e {
 118                                         msgs::DecodeError::UnknownRealmByte => return,
 119                                         msgs::DecodeError::BadPublicKey => return,
 120                                         msgs::DecodeError::BadSignature => return,
 121                                         msgs::DecodeError::BadText => return,
 122                                         msgs::DecodeError::ExtraAddressesPerType => return,
 123                                         msgs::DecodeError::WrongLength => panic!("We picked the length..."),
 124                                 }
 125                         }
 126                 }
 127         }
 128
 129         macro_rules! decode_msg_with_len16 {
 130                 ($MsgType: path, $begin_len: expr, $factor: expr) => {
 131                         {
 132                                 let extra_len = slice_to_be16(&match input.get_slice_nonadvancing($begin_len as usize + 2) {
 133                                         Some(slice) => slice,
 134                                         None => return,
 135                                 }[$begin_len..$begin_len + 2]);
 136                                 match <($MsgType)>::decode(get_slice!($begin_len as usize + 2 + (extra_len as usize)*$factor)) {
 137                                         Ok(msg) => msg,
 138                                         Err(e) => match e {
 139                                                 msgs::DecodeError::UnknownRealmByte => return,
 140                                                 msgs::DecodeError::BadPublicKey => return,
 141                                                 msgs::DecodeError::BadSignature => return,
 142                                                 msgs::DecodeError::BadText => return,
 143                                                 msgs::DecodeError::ExtraAddressesPerType => return,
 144                                                 msgs::DecodeError::WrongLength => panic!("We picked the length..."),
 145                                         }
 146                                 }
 147                         }
 148                 }
 149         }
 150
 151         let secp_ctx = Secp256k1::new();
 152         macro_rules! get_pubkey {
 153                 () => {
 154                         match PublicKey::from_slice(&secp_ctx, get_slice!(33)) {
 155                                 Ok(key) => key,
 156                                 Err(_) => return,
 157                         }
 158                 }
 159         }
 160
 161         macro_rules! return_err {
 162                 ($expr: expr) => {
 163                         match $expr {
 164                                 Ok(r) => r,
 165                                 Err(_) => return,
 166                         }
 167                 }
 168         }
 169
 170         macro_rules! chan_keys {
 171                 () => {
 172                         ChannelKeys {
 173                                 funding_key:               SecretKey::from_slice(&secp_ctx, &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]).unwrap(),
 174                                 revocation_base_key:       SecretKey::from_slice(&secp_ctx, &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]).unwrap(),
 175                                 payment_base_key:          SecretKey::from_slice(&secp_ctx, &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]).unwrap(),
 176                                 delayed_payment_base_key:  SecretKey::from_slice(&secp_ctx, &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]).unwrap(),
 177                                 htlc_base_key:             SecretKey::from_slice(&secp_ctx, &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]).unwrap(),
 178                                 channel_close_key:         SecretKey::from_slice(&secp_ctx, &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]).unwrap(),
 179                                 channel_monitor_claim_key: SecretKey::from_slice(&secp_ctx, &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]).unwrap(),
 180                                 commitment_seed: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 181                         }
 182                 }
 183         }
 184
 185         let their_pubkey = get_pubkey!();
 186
 187         let mut tx = Transaction { version: 0, lock_time: 0, input: Vec::new(), output: Vec::new() };
 188
 189         let mut channel = if get_slice!(1)[0] != 0 {
 190                 let chan_value = slice_to_be24(get_slice!(3));
 191
 192                 let mut chan = Channel::new_outbound(&fee_est, chan_keys!(), their_pubkey, chan_value, get_slice!(1)[0] == 0, slice_to_be64(get_slice!(8)));
 193                 chan.get_open_channel(Sha256dHash::from(get_slice!(32)), &fee_est).unwrap();
 194                 let accept_chan = if get_slice!(1)[0] == 0 {
 195                         decode_msg_with_len16!(msgs::AcceptChannel, 270, 1)
 196                 } else {
 197                         decode_msg!(msgs::AcceptChannel, 270)
 198                 };
 199                 return_err!(chan.accept_channel(&accept_chan));
 200
 201                 tx.output.push(TxOut{ value: chan_value, script_pubkey: chan.get_funding_redeemscript().to_v0_p2wsh() });
 202                 let funding_output = OutPoint::new(Sha256dHash::from_data(&serialize(&tx).unwrap()[..]), 0);
 203
 204                 chan.get_outbound_funding_created(funding_output).unwrap();
 205                 let funding_signed = decode_msg!(msgs::FundingSigned, 32+64);
 206                 return_err!(chan.funding_signed(&funding_signed));
 207                 chan
 208         } else {
 209                 let open_chan = if get_slice!(1)[0] == 0 {
 210                         decode_msg_with_len16!(msgs::OpenChannel, 2*32+6*8+4+2*2+6*33+1, 1)
 211                 } else {
 212                         decode_msg!(msgs::OpenChannel, 2*32+6*8+4+2*2+6*33+1)
 213                 };
 214                 let mut chan = match Channel::new_from_req(&fee_est, chan_keys!(), their_pubkey, &open_chan, slice_to_be64(get_slice!(8)), get_slice!(1)[0] == 0) {
 215                         Ok(chan) => chan,
 216                         Err(_) => return,
 217                 };
 218                 chan.get_accept_channel().unwrap();
 219
 220                 tx.output.push(TxOut{ value: open_chan.funding_satoshis, script_pubkey: chan.get_funding_redeemscript().to_v0_p2wsh() });
 221                 let funding_output = OutPoint::new(Sha256dHash::from_data(&serialize(&tx).unwrap()[..]), 0);
 222
 223                 let mut funding_created = decode_msg!(msgs::FundingCreated, 32+32+2+64);
 224                 funding_created.funding_txid = funding_output.txid.clone();
 225                 funding_created.funding_output_index = funding_output.index;
 226                 return_err!(chan.funding_created(&funding_created));
 227                 chan
 228         };
 229
 230         let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
 231         channel.block_connected(&header, 1, &[&tx; 1], &[42; 1]);
 232         for i in 2..100 {
 233                 header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
 234                 channel.block_connected(&header, i, &[&tx; 0], &[0; 0]);
 235         }
 236
 237         let funding_locked = decode_msg!(msgs::FundingLocked, 32+33);
 238         return_err!(channel.funding_locked(&funding_locked));
 239
 240         loop {
 241                 match get_slice!(1)[0] {
 242                         0 => {
 243                                 return_err!(channel.send_htlc(slice_to_be64(get_slice!(8)), [42; 32], slice_to_be32(get_slice!(4)), msgs::OnionPacket {
 244                                         version: get_slice!(1)[0],
 245                                         public_key: get_pubkey!(),
 246                                         hop_data: [0; 20*65],
 247                                         hmac: [0; 32],
 248                                 }));
 249                         },
 250                         1 => {
 251                                 return_err!(channel.send_commitment());
 252                         },
 253                         2 => {
 254                                 let update_add_htlc = decode_msg!(msgs::UpdateAddHTLC, 32+8+8+32+4+4+33+20*65+32);
 255                                 return_err!(channel.update_add_htlc(&update_add_htlc, PendingForwardHTLCInfo::dummy()));
 256                         },
 257                         3 => {
 258                                 let update_fulfill_htlc = decode_msg!(msgs::UpdateFulfillHTLC, 32 + 8 + 32);
 259                                 return_err!(channel.update_fulfill_htlc(&update_fulfill_htlc));
 260                         },
 261                         4 => {
 262                                 let update_fail_htlc = decode_msg_with_len16!(msgs::UpdateFailHTLC, 32 + 8, 1);
 263                                 return_err!(channel.update_fail_htlc(&update_fail_htlc, HTLCFailReason::dummy()));
 264                         },
 265                         5 => {
 266                                 let update_fail_malformed_htlc = decode_msg!(msgs::UpdateFailMalformedHTLC, 32+8+32+2);
 267                                 return_err!(channel.update_fail_malformed_htlc(&update_fail_malformed_htlc, HTLCFailReason::dummy()));
 268                         },
 269                         6 => {
 270                                 let commitment_signed = decode_msg_with_len16!(msgs::CommitmentSigned, 32+64, 64);
 271                                 return_err!(channel.commitment_signed(&commitment_signed));
 272                         },
 273                         7 => {
 274                                 let revoke_and_ack = decode_msg!(msgs::RevokeAndACK, 32+32+33);
 275                                 return_err!(channel.revoke_and_ack(&revoke_and_ack));
 276                         },
 277                         8 => {
 278                                 let update_fee = decode_msg!(msgs::UpdateFee, 32+4);
 279                                 return_err!(channel.update_fee(&fee_est, &update_fee));
 280                         },
 281                         9 => {
 282                                 let shutdown = decode_msg_with_len16!(msgs::Shutdown, 32, 1);
 283                                 return_err!(channel.shutdown(&fee_est, &shutdown));
 284                                 if channel.is_shutdown() { return; }
 285                         },
 286                         10 => {
 287                                 let closing_signed = decode_msg!(msgs::ClosingSigned, 32+8+64);
 288                                 if return_err!(channel.closing_signed(&fee_est, &closing_signed)).1.is_some() {
 289                                         assert!(channel.is_shutdown());
 290                                         return;
 291                                 }
 292                         },
 293                         _ => return,
 294                 }
 295         }
 296 }
 297
 298 #[cfg(feature = "afl")]
 299 extern crate afl;
 300 #[cfg(feature = "afl")]
 301 fn main() {
 302         afl::read_stdio_bytes(|data| {
 303                 do_test(&data);
 304         });
 305 }
 306
 307 #[cfg(feature = "honggfuzz")]
 308 #[macro_use] extern crate honggfuzz;
 309 #[cfg(feature = "honggfuzz")]
 310 fn main() {
 311         loop {
 312                 fuzz!(|data| {
 313                         do_test(data);
 314                 });
 315         }
 316 }
 317
 318 #[cfg(test)]
 319 mod tests {
 320         fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
 321                 let mut b = 0;
 322                 for (idx, c) in hex.as_bytes().iter().enumerate() {
 323                         b <<= 4;
 324                         match *c {
 325                                 b'A'...b'F' => b |= c - b'A' + 10,
 326                                 b'a'...b'f' => b |= c - b'a' + 10,
 327                                 b'0'...b'9' => b |= c - b'0',
 328                                 _ => panic!("Bad hex"),
 329                         }
 330                         if (idx & 1) == 1 {
 331                                 out.push(b);
 332                                 b = 0;
 333                         }
 334                 }
 335         }
 336
 337         #[test]
 338         fn duplicate_crash() {
 339                 let mut a = Vec::new();
 340                 extend_vec_from_hex("00", &mut a);
 341                 super::do_test(&a);
 342         }
 343 }