Add a method to get session secret for onion packet to KeysInterface

[rust-lightning] / fuzz / fuzz_targets / full_stack_target.rs

diff --git a/fuzz/fuzz_targets/full_stack_target.rs b/fuzz/fuzz_targets/full_stack_target.rs
index ecadd212d5aa99a69d950ae2673f5188e857a17e..354625604c1e13cc5eacd6dc7cda286de635057a 100644 (file)
--- a/fuzz/fuzz_targets/full_stack_target.rs
+++ b/fuzz/fuzz_targets/full_stack_target.rs
@@ -7,9 +7,9 @@ use bitcoin::blockdata::block::BlockHeader;
 use bitcoin::blockdata::transaction::{Transaction, TxOut};
 use bitcoin::blockdata::script::{Builder, Script};
 use bitcoin::blockdata::opcodes;
+use bitcoin::consensus::encode::{deserialize, serialize};
 use bitcoin::network::constants::Network;
-use bitcoin::network::serialize::{deserialize, serialize, BitcoinHash};
-use bitcoin::util::hash::{Sha256dHash, Hash160};
+use bitcoin::util::hash::{BitcoinHash, Sha256dHash, Hash160};
 
 use crypto::digest::Digest;
 
@@ -21,9 +21,10 @@ use lightning::ln::channelmanager::{ChannelManager, PaymentFailReason};
 use lightning::ln::peer_handler::{MessageHandler,PeerManager,SocketDescriptor};
 use lightning::ln::router::Router;
 use lightning::util::events::{EventsProvider,Event};
-use lightning::util::reset_rng_state;
+use lightning::util::{reset_rng_state, fill_bytes};
 use lightning::util::logger::Logger;
 use lightning::util::sha2::Sha256;
+use lightning::util::config::UserConfig;
 
 mod utils;
 
@@ -167,7 +168,7 @@ impl<'a> MoneyLossDetector<'a> {
                let mut txn = Vec::with_capacity(all_txn.len());
                let mut txn_idxs = Vec::with_capacity(all_txn.len());
                for (idx, tx) in all_txn.iter().enumerate() {
-                       let txid = Sha256dHash::from_data(&serialize(tx).unwrap()[..]);
+                       let txid = tx.txid();
                        match self.txids_confirmed.entry(txid) {
                                hash_map::Entry::Vacant(e) => {
                                        e.insert(self.height);
@@ -208,15 +209,17 @@ impl<'a> MoneyLossDetector<'a> {
 
 impl<'a> Drop for MoneyLossDetector<'a> {
        fn drop(&mut self) {
-               // Disconnect all peers
-               for (idx, peer) in self.peers.borrow().iter().enumerate() {
-                       if *peer {
-                               self.handler.disconnect_event(&Peer{id: idx as u8, peers_connected: &self.peers});
+               if !::std::thread::panicking() {
+                       // Disconnect all peers
+                       for (idx, peer) in self.peers.borrow().iter().enumerate() {
+                               if *peer {
+                                       self.handler.disconnect_event(&Peer{id: idx as u8, peers_connected: &self.peers});
+                               }
                        }
-               }
 
-               // Force all channels onto the chain (and time out claim txn)
-               self.manager.force_close_all_channels();
+                       // Force all channels onto the chain (and time out claim txn)
+                       self.manager.force_close_all_channels();
+               }
        }
 }
 
@@ -262,6 +265,12 @@ impl KeysInterface for KeyProvider {
                        }
                }
        }
+
+       fn get_session_key(&self) -> SecretKey {
+               let mut session_key = [0; 32];
+               fill_bytes(&mut session_key);
+               SecretKey::from_slice(&Secp256k1::without_caps(), &session_key).unwrap()
+       }
 }
 
 #[inline]
@@ -305,7 +314,11 @@ pub fn do_test(data: &[u8], logger: &Arc<Logger>) {
        let monitor = channelmonitor::SimpleManyChannelMonitor::new(watch.clone(), broadcast.clone(), Arc::clone(&logger));
 
        let keys_manager = Arc::new(KeyProvider { node_secret: our_network_key.clone() });
-       let channelmanager = ChannelManager::new(slice_to_be32(get_slice!(4)), get_slice!(1)[0] != 0, Network::Bitcoin, fee_est.clone(), monitor.clone(), watch.clone(), broadcast.clone(), Arc::clone(&logger), keys_manager.clone()).unwrap();
+       let mut config = UserConfig::new();
+       config.channel_options.fee_proportional_millionths =  slice_to_be32(get_slice!(4));
+       config.channel_options.announced_channel = get_slice!(1)[0] != 0;
+       config.channel_limits.min_dust_limit_satoshis = 0;
+       let channelmanager = ChannelManager::new(Network::Bitcoin, fee_est.clone(), monitor.clone(), watch.clone(), broadcast.clone(), Arc::clone(&logger), keys_manager.clone(), config).unwrap();
        let router = Arc::new(Router::new(PublicKey::from_secret_key(&secp_ctx, &keys_manager.get_node_secret()), watch.clone(), Arc::clone(&logger)));
 
        let peers = RefCell::new([false; 256]);
@@ -425,7 +438,7 @@ pub fn do_test(data: &[u8], logger: &Arc<Logger>) {
                                                        value: funding_generation.1, script_pubkey: funding_generation.2,
                                                }] };
                                        let funding_output = 'search_loop: loop {
-                                               let funding_txid = Sha256dHash::from_data(&serialize(&tx).unwrap()[..]);
+                                               let funding_txid = tx.txid();
                                                if let None = loss_detector.txids_confirmed.get(&funding_txid) {
                                                        let outpoint = OutPoint::new(funding_txid, 0);
                                                        for chan in channelmanager.list_channels() {