_ 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 use secp256k1::Secp256k1;
   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         let mut read_pos = 0;
  18         macro_rules! get_slice {
  19                 ($len: expr) => {
  20                         {
  21                                 let slice_len = $len as usize;
  22                                 if data.len() < read_pos + slice_len {
  23                                         return;
  24                                 }
  25                                 read_pos += slice_len;
  26                                 &data[read_pos - slice_len..read_pos]
  27                         }
  28                 }
  29         }
  30
  31         let secp_ctx = Secp256k1::new();
  32         let our_network_key = match SecretKey::from_slice(&secp_ctx, get_slice!(32)) {
  33                 Ok(key) => key,
  34                 Err(_) => return,
  35         };
  36
  37         let mut crypter = if get_slice!(1)[0] != 0 {
  38                 let their_pubkey = match PublicKey::from_slice(&secp_ctx, get_slice!(33)) {
  39                         Ok(key) => key,
  40                         Err(_) => return,
  41                 };
  42                 let mut crypter = PeerChannelEncryptor::new_outbound(their_pubkey);
  43                 crypter.get_act_one();
  44                 match crypter.process_act_two(get_slice!(50), &our_network_key) {
  45                         Ok(_) => {},
  46                         Err(_) => return,
  47                 }
  48                 assert!(crypter.is_ready_for_encryption());
  49                 crypter
  50         } else {
  51                 let mut crypter = PeerChannelEncryptor::new_inbound(&our_network_key);
  52                 match crypter.process_act_one_with_key(get_slice!(50), &our_network_key) {
  53                         Ok(_) => {},
  54                         Err(_) => return,
  55                 }
  56                 match crypter.process_act_three(get_slice!(66)) {
  57                         Ok(_) => {},
  58                         Err(_) => return,
  59                 }
  60                 assert!(crypter.is_ready_for_encryption());
  61                 crypter
  62         };
  63         loop {
  64                 if get_slice!(1)[0] == 0 {
  65                         crypter.encrypt_message(get_slice!(slice_to_be16(get_slice!(2))));
  66                 } else {
  67                         let len = match crypter.decrypt_length_header(get_slice!(16+2)) {
  68                                 Ok(len) => len,
  69                                 Err(_) => return,
  70                         };
  71                         match crypter.decrypt_message(get_slice!(len as usize + 16)) {
  72                                 Ok(_) => {},
  73                                 Err(_) => return,
  74                         }
  75                 }
  76         }
  77 }
  78
  79 #[cfg(feature = "afl")]
  80 extern crate afl;
  81 #[cfg(feature = "afl")]
  82 fn main() {
  83         afl::read_stdio_bytes(|data| {
  84                 do_test(&data);
  85         });
  86 }
  87
  88 #[cfg(feature = "honggfuzz")]
  89 #[macro_use] extern crate honggfuzz;
  90 #[cfg(feature = "honggfuzz")]
  91 fn main() {
  92         loop {
  93                 fuzz!(|data| {
  94                         do_test(data);
  95                 });
  96         }
  97 }
  98
  99 #[cfg(test)]
 100 mod tests {
 101         fn extend_vec_from_hex(hex: &str, out: &mut Vec<u8>) {
 102                 let mut b = 0;
 103                 for (idx, c) in hex.as_bytes().iter().enumerate() {
 104                         b <<= 4;
 105                         match *c {
 106                                 b'A'...b'F' => b |= c - b'A' + 10,
 107                                 b'a'...b'f' => b |= c - b'a' + 10,
 108                                 b'0'...b'9' => b |= c - b'0',
 109                                 _ => panic!("Bad hex"),
 110                         }
 111                         if (idx & 1) == 1 {
 112                                 out.push(b);
 113                                 b = 0;
 114                         }
 115                 }
 116         }
 117
 118         #[test]
 119         fn duplicate_crash() {
 120                 let mut a = Vec::new();
 121                 extend_vec_from_hex("01", &mut a);
 122                 super::do_test(&a);
 123         }
 124 }