_ Git - rust-lightning/blob - fuzz/src/peer_crypt.rs

   1 use lightning::ln::peer_channel_encryptor::PeerChannelEncryptor;
   2
   3 use secp256k1::key::{PublicKey,SecretKey};
   4
   5 #[inline]
   6 fn slice_to_be16(v: &[u8]) -> u16 {
   7         ((v[0] as u16) << 8*1) |
   8         ((v[1] as u16) << 8*0)
   9 }
  10
  11 #[inline]
  12 pub fn do_test(data: &[u8]) {
  13         let mut read_pos = 0;
  14         macro_rules! get_slice {
  15                 ($len: expr) => {
  16                         {
  17                                 let slice_len = $len as usize;
  18                                 if data.len() < read_pos + slice_len {
  19                                         return;
  20                                 }
  21                                 read_pos += slice_len;
  22                                 &data[read_pos - slice_len..read_pos]
  23                         }
  24                 }
  25         }
  26
  27         let our_network_key = match SecretKey::from_slice(get_slice!(32)) {
  28                 Ok(key) => key,
  29                 Err(_) => return,
  30         };
  31         let ephemeral_key = match SecretKey::from_slice(get_slice!(32)) {
  32                 Ok(key) => key,
  33                 Err(_) => return,
  34         };
  35
  36         let mut crypter = if get_slice!(1)[0] != 0 {
  37                 let their_pubkey = match PublicKey::from_slice(get_slice!(33)) {
  38                         Ok(key) => key,
  39                         Err(_) => return,
  40                 };
  41                 let mut crypter = PeerChannelEncryptor::new_outbound(their_pubkey, ephemeral_key);
  42                 crypter.get_act_one();
  43                 match crypter.process_act_two(get_slice!(50), &our_network_key) {
  44                         Ok(_) => {},
  45                         Err(_) => return,
  46                 }
  47                 assert!(crypter.is_ready_for_encryption());
  48                 crypter
  49         } else {
  50                 let mut crypter = PeerChannelEncryptor::new_inbound(&our_network_key);
  51                 match crypter.process_act_one_with_keys(get_slice!(50), &our_network_key, ephemeral_key) {
  52                         Ok(_) => {},
  53                         Err(_) => return,
  54                 }
  55                 match crypter.process_act_three(get_slice!(66)) {
  56                         Ok(_) => {},
  57                         Err(_) => return,
  58                 }
  59                 assert!(crypter.is_ready_for_encryption());
  60                 crypter
  61         };
  62         loop {
  63                 if get_slice!(1)[0] == 0 {
  64                         crypter.encrypt_message(get_slice!(slice_to_be16(get_slice!(2))));
  65                 } else {
  66                         let len = match crypter.decrypt_length_header(get_slice!(16+2)) {
  67                                 Ok(len) => len,
  68                                 Err(_) => return,
  69                         };
  70                         match crypter.decrypt_message(get_slice!(len as usize + 16)) {
  71                                 Ok(_) => {},
  72                                 Err(_) => return,
  73                         }
  74                 }
  75         }
  76 }
  77
  78 #[no_mangle]
  79 pub extern "C" fn peer_crypt_run(data: *const u8, datalen: usize) {
  80         do_test(unsafe { std::slice::from_raw_parts(data, datalen) });
  81 }