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