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

   1 extern crate bitcoin;
   2 extern crate lightning;
   3 extern crate secp256k1;
   4
   5 use bitcoin::network::constants::Network;
   6 use bitcoin::util::hash::Sha256dHash;
   7
   8 use lightning::chain::chaininterface::{ConfirmationTarget,FeeEstimator,ChainWatchInterfaceUtil};
   9 use lightning::ln::{channelmonitor,msgs};
  10 use lightning::ln::channelmanager::ChannelManager;
  11 use lightning::ln::peer_handler::{MessageHandler,PeerManager,SocketDescriptor};
  12 use lightning::ln::router::Router;
  13
  14 use secp256k1::key::{PublicKey,SecretKey};
  15 use secp256k1::Secp256k1;
  16
  17 use std::sync::Arc;
  18 use std::sync::atomic::{AtomicUsize,Ordering};
  19
  20 #[inline]
  21 pub fn slice_to_be16(v: &[u8]) -> u16 {
  22         ((v[0] as u16) << 8*1) |
  23         ((v[1] as u16) << 8*0)
  24 }
  25
  26 #[inline]
  27 pub fn slice_to_be32(v: &[u8]) -> u32 {
  28         ((v[0] as u32) << 8*3) |
  29         ((v[1] as u32) << 8*2) |
  30         ((v[2] as u32) << 8*1) |
  31         ((v[3] as u32) << 8*0)
  32 }
  33
  34 struct InputData {
  35         data: Vec<u8>,
  36         read_pos: AtomicUsize,
  37 }
  38 impl InputData {
  39         fn get_slice(&self, len: usize) -> Option<&[u8]> {
  40                 let old_pos = self.read_pos.fetch_add(len, Ordering::AcqRel);
  41                 if self.data.len() < old_pos + len {
  42                         return None;
  43                 }
  44                 Some(&self.data[old_pos..old_pos + len])
  45         }
  46         fn get_slice_nonadvancing(&self, len: usize) -> Option<&[u8]> {
  47                 let old_pos = self.read_pos.load(Ordering::Acquire);
  48                 if self.data.len() < old_pos + len {
  49                         return None;
  50                 }
  51                 Some(&self.data[old_pos..old_pos + len])
  52         }
  53 }
  54
  55 struct FuzzEstimator {
  56         input: Arc<InputData>,
  57 }
  58 impl FeeEstimator for FuzzEstimator {
  59         fn get_est_sat_per_vbyte(&self, _: ConfirmationTarget) -> u64 {
  60                 //TODO: We should actually be testing at least much more than 64k...
  61                 match self.input.get_slice(2) {
  62                         Some(slice) => slice_to_be16(slice) as u64,
  63                         None => 0
  64                 }
  65         }
  66 }
  67
  68 struct TestChannelMonitor {}
  69 impl channelmonitor::ManyChannelMonitor for TestChannelMonitor {
  70         fn add_update_monitor(&self, _funding_txo: (Sha256dHash, u16), _monitor: channelmonitor::ChannelMonitor) -> Result<(), msgs::HandleError> {
  71                 //TODO!
  72                 Ok(())
  73         }
  74 }
  75
  76 #[derive(Clone, PartialEq, Eq, Hash)]
  77 struct Peer {
  78         id: u8,
  79 }
  80 impl SocketDescriptor for Peer {
  81         fn send_data(&mut self, data: &Vec<u8>, write_offset: usize, _resume_read: bool) -> usize {
  82                 assert!(write_offset < data.len());
  83                 data.len() - write_offset
  84         }
  85 }
  86
  87 #[inline]
  88 pub fn do_test(data: &[u8]) {
  89         let input = Arc::new(InputData {
  90                 data: data.to_vec(),
  91                 read_pos: AtomicUsize::new(0),
  92         });
  93         let fee_est = Arc::new(FuzzEstimator {
  94                 input: input.clone(),
  95         });
  96
  97         macro_rules! get_slice {
  98                 ($len: expr) => {
  99                         match input.get_slice($len as usize) {
 100                                 Some(slice) => slice,
 101                                 None => return,
 102                         }
 103                 }
 104         }
 105
 106         let secp_ctx = Secp256k1::new();
 107         macro_rules! get_pubkey {
 108                 () => {
 109                         match PublicKey::from_slice(&secp_ctx, get_slice!(33)) {
 110                                 Ok(key) => key,
 111                                 Err(_) => return,
 112                         }
 113                 }
 114         }
 115
 116         let our_network_key = match SecretKey::from_slice(&secp_ctx, get_slice!(32)) {
 117                 Ok(key) => key,
 118                 Err(_) => return,
 119         };
 120
 121         let monitor = Arc::new(TestChannelMonitor{});
 122         let watch = Arc::new(ChainWatchInterfaceUtil::new());
 123
 124         let channelmanager = ChannelManager::new(our_network_key, slice_to_be32(get_slice!(4)), get_slice!(1)[0] != 0, Network::Bitcoin, fee_est.clone(), monitor.clone(), watch.clone()).unwrap();
 125         let router = Arc::new(Router::new(PublicKey::from_secret_key(&secp_ctx, &our_network_key).unwrap()));
 126
 127         let handler = PeerManager::new(MessageHandler {
 128                 chan_handler: channelmanager.clone(),
 129                 route_handler: router.clone(),
 130         }, our_network_key);
 131
 132         let mut peers = [false; 256];
 133
 134         loop {
 135                 match get_slice!(1)[0] {
 136                         0 => {
 137                                 let mut new_id = 0;
 138                                 for i in 1..256 {
 139                                         if !peers[i-1] {
 140                                                 new_id = i;
 141                                                 break;
 142                                         }
 143                                 }
 144                                 if new_id == 0 { return; }
 145                                 peers[new_id - 1] = true;
 146                                 handler.new_outbound_connection(get_pubkey!(), Peer{id: (new_id - 1) as u8}).unwrap();
 147                         },
 148                         1 => {
 149                                 let mut new_id = 0;
 150                                 for i in 1..256 {
 151                                         if !peers[i-1] {
 152                                                 new_id = i;
 153                                                 break;
 154                                         }
 155                                 }
 156                                 if new_id == 0 { return; }
 157                                 peers[new_id - 1] = true;
 158                                 handler.new_inbound_connection(Peer{id: (new_id - 1) as u8}).unwrap();
 159                         },
 160                         2 => {
 161                                 let peer_id = get_slice!(1)[0];
 162                                 if !peers[peer_id as usize] { return; }
 163                                 peers[peer_id as usize] = false;
 164                                 handler.disconnect_event(&Peer{id: peer_id});
 165                         },
 166                         3 => {
 167                                 let peer_id = get_slice!(1)[0];
 168                                 if !peers[peer_id as usize] { return; }
 169                                 match handler.read_event(&mut Peer{id: peer_id}, get_slice!(get_slice!(1)[0]).to_vec()) {
 170                                         Ok(res) => assert!(!res),
 171                                         Err(_) => { peers[peer_id as usize] = false; }
 172                                 }
 173                         },
 174                         _ => return,
 175                 }
 176         }
 177 }
 178
 179 #[cfg(feature = "afl")]
 180 extern crate afl;
 181 #[cfg(feature = "afl")]
 182 fn main() {
 183         afl::read_stdio_bytes(|data| {
 184                 do_test(&data);
 185         });
 186 }
 187
 188 #[cfg(feature = "honggfuzz")]
 189 #[macro_use] extern crate honggfuzz;
 190 #[cfg(feature = "honggfuzz")]
 191 fn main() {
 192         loop {
 193                 fuzz!(|data| {
 194                         do_test(data);
 195                 });
 196         }
 197 }
 198
 199 #[cfg(test)]
 200 mod tests {
 201         fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
 202                 let mut b = 0;
 203                 for (idx, c) in hex.as_bytes().iter().enumerate() {
 204                         b <<= 4;
 205                         match *c {
 206                                 b'A'...b'F' => b |= c - b'A' + 10,
 207                                 b'a'...b'f' => b |= c - b'a' + 10,
 208                                 b'0'...b'9' => b |= c - b'0',
 209                                 _ => panic!("Bad hex"),
 210                         }
 211                         if (idx & 1) == 1 {
 212                                 out.push(b);
 213                                 b = 0;
 214                         }
 215                 }
 216         }
 217
 218         #[test]
 219         fn duplicate_crash() {
 220                 let mut a = Vec::new();
 221                 extend_vec_from_hex("00", &mut a);
 222                 super::do_test(&a);
 223         }
 224 }