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