_ 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         let ephemeral_key = match SecretKey::from_slice(get_slice!(32)) {
  38                 Ok(key) => key,
  39                 Err(_) => return,
  40         };
  41
  42         let mut crypter = if get_slice!(1)[0] != 0 {
  43                 let their_pubkey = match PublicKey::from_slice(get_slice!(33)) {
  44                         Ok(key) => key,
  45                         Err(_) => return,
  46                 };
  47                 let mut crypter = PeerChannelEncryptor::new_outbound(their_pubkey, ephemeral_key);
  48                 crypter.get_act_one();
  49                 match crypter.process_act_two(get_slice!(50), &our_network_key) {
  50                         Ok(_) => {},
  51                         Err(_) => return,
  52                 }
  53                 assert!(crypter.is_ready_for_encryption());
  54                 crypter
  55         } else {
  56                 let mut crypter = PeerChannelEncryptor::new_inbound(&our_network_key);
  57                 match crypter.process_act_one_with_keys(get_slice!(50), &our_network_key, ephemeral_key) {
  58                         Ok(_) => {},
  59                         Err(_) => return,
  60                 }
  61                 match crypter.process_act_three(get_slice!(66)) {
  62                         Ok(_) => {},
  63                         Err(_) => return,
  64                 }
  65                 assert!(crypter.is_ready_for_encryption());
  66                 crypter
  67         };
  68         loop {
  69                 if get_slice!(1)[0] == 0 {
  70                         crypter.encrypt_message(get_slice!(slice_to_be16(get_slice!(2))));
  71                 } else {
  72                         let len = match crypter.decrypt_length_header(get_slice!(16+2)) {
  73                                 Ok(len) => len,
  74                                 Err(_) => return,
  75                         };
  76                         match crypter.decrypt_message(get_slice!(len as usize + 16)) {
  77                                 Ok(_) => {},
  78                                 Err(_) => return,
  79                         }
  80                 }
  81         }
  82 }
  83
  84 #[cfg(feature = "afl")]
  85 #[macro_use] extern crate afl;
  86 #[cfg(feature = "afl")]
  87 fn main() {
  88         fuzz!(|data| {
  89                 do_test(data);
  90         });
  91 }
  92
  93 #[cfg(feature = "honggfuzz")]
  94 #[macro_use] extern crate honggfuzz;
  95 #[cfg(feature = "honggfuzz")]
  96 fn main() {
  97         loop {
  98                 fuzz!(|data| {
  99                         do_test(data);
 100                 });
 101         }
 102 }
 103
 104 extern crate hex;
 105 #[cfg(test)]
 106 mod tests {
 107
 108         #[test]
 109         fn duplicate_crash() {
 110                 super::do_test(&::hex::decode("01").unwrap());
 111         }
 112 }