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

   1 extern crate lightning;
   2 extern crate secp256k1;
   3
   4 use lightning::ln::peer_channel_encryptor::PeerChannelEncryptor;
   5 use lightning::util::reset_rng_state;
   6
   7 use secp256k1::key::{PublicKey,SecretKey};
   8
   9 #[inline]
  10 fn slice_to_be16(v: &[u8]) -> u16 {
  11         ((v[0] as u16) << 8*1) |
  12         ((v[1] as u16) << 8*0)
  13 }
  14
  15 #[inline]
  16 pub fn do_test(data: &[u8]) {
  17         reset_rng_state();
  18
  19         let mut read_pos = 0;
  20         macro_rules! get_slice {
  21                 ($len: expr) => {
  22                         {
  23                                 let slice_len = $len as usize;
  24                                 if data.len() < read_pos + slice_len {
  25                                         return;
  26                                 }
  27                                 read_pos += slice_len;
  28                                 &data[read_pos - slice_len..read_pos]
  29                         }
  30                 }
  31         }
  32
  33         let our_network_key = match SecretKey::from_slice(get_slice!(32)) {
  34                 Ok(key) => key,
  35                 Err(_) => return,
  36         };
  37
  38         let mut crypter = if get_slice!(1)[0] != 0 {
  39                 let their_pubkey = match PublicKey::from_slice(get_slice!(33)) {
  40                         Ok(key) => key,
  41                         Err(_) => return,
  42                 };
  43                 let mut crypter = PeerChannelEncryptor::new_outbound(their_pubkey);
  44                 crypter.get_act_one();
  45                 match crypter.process_act_two(get_slice!(50), &our_network_key) {
  46                         Ok(_) => {},
  47                         Err(_) => return,
  48                 }
  49                 assert!(crypter.is_ready_for_encryption());
  50                 crypter
  51         } else {
  52                 let mut crypter = PeerChannelEncryptor::new_inbound(&our_network_key);
  53                 match crypter.process_act_one_with_key(get_slice!(50), &our_network_key) {
  54                         Ok(_) => {},
  55                         Err(_) => return,
  56                 }
  57                 match crypter.process_act_three(get_slice!(66)) {
  58                         Ok(_) => {},
  59                         Err(_) => return,
  60                 }
  61                 assert!(crypter.is_ready_for_encryption());
  62                 crypter
  63         };
  64         loop {
  65                 if get_slice!(1)[0] == 0 {
  66                         crypter.encrypt_message(get_slice!(slice_to_be16(get_slice!(2))));
  67                 } else {
  68                         let len = match crypter.decrypt_length_header(get_slice!(16+2)) {
  69                                 Ok(len) => len,
  70                                 Err(_) => return,
  71                         };
  72                         match crypter.decrypt_message(get_slice!(len as usize + 16)) {
  73                                 Ok(_) => {},
  74                                 Err(_) => return,
  75                         }
  76                 }
  77         }
  78 }
  79
  80 #[cfg(feature = "afl")]
  81 #[macro_use] extern crate afl;
  82 #[cfg(feature = "afl")]
  83 fn main() {
  84         fuzz!(|data| {
  85                 do_test(data);
  86         });
  87 }
  88
  89 #[cfg(feature = "honggfuzz")]
  90 #[macro_use] extern crate honggfuzz;
  91 #[cfg(feature = "honggfuzz")]
  92 fn main() {
  93         loop {
  94                 fuzz!(|data| {
  95                         do_test(data);
  96                 });
  97         }
  98 }
  99
 100 extern crate hex;
 101 #[cfg(test)]
 102 mod tests {
 103
 104         #[test]
 105         fn duplicate_crash() {
 106                 super::do_test(&::hex::decode("01").unwrap());
 107         }
 108 }