From: Matt Corallo Date: Mon, 20 Aug 2018 21:13:07 +0000 (-0400) Subject: Update to rust-secp256k1 v0.11 and rust-bitcoin v0.14 X-Git-Tag: v0.0.12~343^2 X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=commitdiff_plain;h=refs%2Fheads%2F2018-08-secp-0.10;p=rust-lightning Update to rust-secp256k1 v0.11 and rust-bitcoin v0.14 --- diff --git a/Cargo.toml b/Cargo.toml index 088763ccb..c0f13bde7 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -23,16 +23,16 @@ max_level_info = [] max_level_debug = [] [dependencies] -bitcoin = "0.13" +bitcoin = "0.14" rust-crypto = "0.2" rand = "0.4" -secp256k1 = "0.9" +secp256k1 = "0.11" [build-dependencies] cc = "1.0" [dev-dependencies.bitcoin] -version = "0.13" +version = "0.14" features = ["bitcoinconsensus"] [dev-dependencies] diff --git a/fuzz/Cargo.toml b/fuzz/Cargo.toml index 7455076df..4394fd796 100644 --- a/fuzz/Cargo.toml +++ b/fuzz/Cargo.toml @@ -18,11 +18,11 @@ honggfuzz_fuzz = ["honggfuzz"] [dependencies] afl = { version = "0.4", optional = true } lightning = { path = "..", features = ["fuzztarget"] } -bitcoin = { version = "0.13", features = ["fuzztarget"] } +bitcoin = { version = "0.14", features = ["fuzztarget"] } hex = "0.3" honggfuzz = { version = "0.5", optional = true } rust-crypto = "0.2" -secp256k1 = { version = "0.9", features=["fuzztarget"] } +secp256k1 = { version = "0.11", features=["fuzztarget"] } [build-dependencies] cc = "1.0" diff --git a/fuzz/fuzz_targets/full_stack_target.rs b/fuzz/fuzz_targets/full_stack_target.rs index 283d64422..cbc9df23e 100644 --- a/fuzz/fuzz_targets/full_stack_target.rs +++ b/fuzz/fuzz_targets/full_stack_target.rs @@ -237,7 +237,7 @@ pub fn do_test(data: &[u8], logger: &Arc) { let monitor = channelmonitor::SimpleManyChannelMonitor::new(watch.clone(), broadcast.clone()); let channelmanager = ChannelManager::new(our_network_key, 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)).unwrap(); - let router = Arc::new(Router::new(PublicKey::from_secret_key(&secp_ctx, &our_network_key).unwrap(), Arc::clone(&logger))); + let router = Arc::new(Router::new(PublicKey::from_secret_key(&secp_ctx, &our_network_key), Arc::clone(&logger))); let peers = RefCell::new([false; 256]); let mut loss_detector = MoneyLossDetector::new(&peers, channelmanager.clone(), monitor.clone(), PeerManager::new(MessageHandler { diff --git a/src/chain/chaininterface.rs b/src/chain/chaininterface.rs index e08c8cdbd..bda99b2d8 100644 --- a/src/chain/chaininterface.rs +++ b/src/chain/chaininterface.rs @@ -181,7 +181,7 @@ impl ChainWatchInterfaceUtil { for input in tx.input.iter() { for outpoint in watched.1.iter() { let &(outpoint_hash, outpoint_index) = outpoint; - if outpoint_hash == input.prev_hash && outpoint_index == input.prev_index { + if outpoint_hash == input.previous_output.txid && outpoint_index == input.previous_output.vout { return true; } } diff --git a/src/chain/transaction.rs b/src/chain/transaction.rs index 615c970f0..f89b60806 100644 --- a/src/chain/transaction.rs +++ b/src/chain/transaction.rs @@ -1,7 +1,8 @@ use bitcoin::util::hash::Sha256dHash; +use bitcoin::blockdata::transaction::OutPoint as BitcoinOutPoint; /// A reference to a transaction output. -/// Differs from bitcoin::blockdata::transaction::TxOutRef as the index is a u16 instead of usize +/// Differs from bitcoin::blockdata::transaction::OutPoint as the index is a u16 instead of u32 /// due to LN's restrictions on index values. Should reduce (possibly) unsafe conversions this way. #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)] pub struct OutPoint { @@ -25,6 +26,13 @@ impl OutPoint { res[31] ^= ((self.index >> 0) & 0xff) as u8; res } + + pub fn into_bitcoin_outpoint(self) -> BitcoinOutPoint { + BitcoinOutPoint { + txid: self.txid, + vout: self.index as u32, + } + } } #[cfg(test)] diff --git a/src/ln/chan_utils.rs b/src/ln/chan_utils.rs index 0cace11c1..7f259d981 100644 --- a/src/ln/chan_utils.rs +++ b/src/ln/chan_utils.rs @@ -1,6 +1,6 @@ use bitcoin::blockdata::script::{Script,Builder}; use bitcoin::blockdata::opcodes; -use bitcoin::blockdata::transaction::{TxIn,TxOut,Transaction}; +use bitcoin::blockdata::transaction::{TxIn,TxOut,OutPoint,Transaction}; use bitcoin::util::hash::{Hash160,Sha256dHash}; use secp256k1::key::{PublicKey,SecretKey}; @@ -32,10 +32,10 @@ pub fn build_commitment_secret(commitment_seed: [u8; 32], idx: u64) -> [u8; 32] res } -pub fn derive_private_key(secp_ctx: &Secp256k1, per_commitment_point: &PublicKey, base_secret: &SecretKey) -> Result { +pub fn derive_private_key(secp_ctx: &Secp256k1, per_commitment_point: &PublicKey, base_secret: &SecretKey) -> Result { let mut sha = Sha256::new(); sha.input(&per_commitment_point.serialize()); - sha.input(&PublicKey::from_secret_key(&secp_ctx, &base_secret).unwrap().serialize()); + sha.input(&PublicKey::from_secret_key(&secp_ctx, &base_secret).serialize()); let mut res = [0; 32]; sha.result(&mut res); @@ -44,21 +44,21 @@ pub fn derive_private_key(secp_ctx: &Secp256k1, per_commitment_point: &PublicKey Ok(key) } -pub fn derive_public_key(secp_ctx: &Secp256k1, per_commitment_point: &PublicKey, base_point: &PublicKey) -> Result { +pub fn derive_public_key(secp_ctx: &Secp256k1, per_commitment_point: &PublicKey, base_point: &PublicKey) -> Result { let mut sha = Sha256::new(); sha.input(&per_commitment_point.serialize()); sha.input(&base_point.serialize()); let mut res = [0; 32]; sha.result(&mut res); - let hashkey = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &res)?).unwrap(); + let hashkey = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &res)?); base_point.combine(&secp_ctx, &hashkey) } /// Derives a revocation key from its constituent parts -pub fn derive_private_revocation_key(secp_ctx: &Secp256k1, per_commitment_secret: &SecretKey, revocation_base_secret: &SecretKey) -> Result { - let revocation_base_point = PublicKey::from_secret_key(&secp_ctx, &revocation_base_secret).unwrap(); - let per_commitment_point = PublicKey::from_secret_key(&secp_ctx, &per_commitment_secret).unwrap(); +pub fn derive_private_revocation_key(secp_ctx: &Secp256k1, per_commitment_secret: &SecretKey, revocation_base_secret: &SecretKey) -> Result { + let revocation_base_point = PublicKey::from_secret_key(&secp_ctx, &revocation_base_secret); + let per_commitment_point = PublicKey::from_secret_key(&secp_ctx, &per_commitment_secret); let rev_append_commit_hash_key = { let mut sha = Sha256::new(); @@ -87,7 +87,7 @@ pub fn derive_private_revocation_key(secp_ctx: &Secp256k1, per_commitment_secret Ok(part_a) } -pub fn derive_public_revocation_key(secp_ctx: &Secp256k1, per_commitment_point: &PublicKey, revocation_base_point: &PublicKey) -> Result { +pub fn derive_public_revocation_key(secp_ctx: &Secp256k1, per_commitment_point: &PublicKey, revocation_base_point: &PublicKey) -> Result { let rev_append_commit_hash_key = { let mut sha = Sha256::new(); sha.input(&revocation_base_point.serialize()); @@ -124,7 +124,7 @@ pub struct TxCreationKeys { } impl TxCreationKeys { - pub fn new(secp_ctx: &Secp256k1, per_commitment_point: &PublicKey, a_delayed_payment_base: &PublicKey, a_htlc_base: &PublicKey, b_revocation_base: &PublicKey, b_payment_base: &PublicKey, b_htlc_base: &PublicKey) -> Result { + pub fn new(secp_ctx: &Secp256k1, per_commitment_point: &PublicKey, a_delayed_payment_base: &PublicKey, a_htlc_base: &PublicKey, b_revocation_base: &PublicKey, b_payment_base: &PublicKey, b_htlc_base: &PublicKey) -> Result { Ok(TxCreationKeys { per_commitment_point: per_commitment_point.clone(), revocation_key: derive_public_revocation_key(&secp_ctx, &per_commitment_point, &b_revocation_base)?, @@ -241,8 +241,10 @@ pub fn get_htlc_redeemscript(htlc: &HTLCOutputInCommitment, keys: &TxCreationKey pub fn build_htlc_transaction(prev_hash: &Sha256dHash, feerate_per_kw: u64, to_self_delay: u16, htlc: &HTLCOutputInCommitment, a_delayed_payment_key: &PublicKey, revocation_key: &PublicKey) -> Transaction { let mut txins: Vec = Vec::new(); txins.push(TxIn { - prev_hash: prev_hash.clone(), - prev_index: htlc.transaction_output_index, + previous_output: OutPoint { + txid: prev_hash.clone(), + vout: htlc.transaction_output_index, + }, script_sig: Script::new(), sequence: 0, witness: Vec::new(), diff --git a/src/ln/channel.rs b/src/ln/channel.rs index 76d45dd71..a54be7722 100644 --- a/src/ln/channel.rs +++ b/src/ln/channel.rs @@ -251,7 +251,7 @@ pub struct Channel { channel_id: [u8; 32], channel_state: u32, channel_outbound: bool, - secp_ctx: Secp256k1, + secp_ctx: Secp256k1, announce_publicly: bool, channel_value_satoshis: u64, @@ -302,12 +302,12 @@ pub struct Channel { their_max_accepted_htlcs: u16, //implied by OUR_MAX_HTLCS: our_max_accepted_htlcs: u16, - their_funding_pubkey: PublicKey, - their_revocation_basepoint: PublicKey, - their_payment_basepoint: PublicKey, - their_delayed_payment_basepoint: PublicKey, - their_htlc_basepoint: PublicKey, - their_cur_commitment_point: PublicKey, + their_funding_pubkey: Option, + their_revocation_basepoint: Option, + their_payment_basepoint: Option, + their_delayed_payment_basepoint: Option, + their_htlc_basepoint: Option, + their_cur_commitment_point: Option, their_prev_commitment_point: Option, their_node_id: PublicKey, @@ -401,10 +401,10 @@ impl Channel { let feerate = fee_estimator.get_est_sat_per_1000_weight(ConfirmationTarget::Normal); let secp_ctx = Secp256k1::new(); - let our_channel_monitor_claim_key_hash = Hash160::from_data(&PublicKey::from_secret_key(&secp_ctx, &chan_keys.channel_monitor_claim_key).unwrap().serialize()); + let our_channel_monitor_claim_key_hash = Hash160::from_data(&PublicKey::from_secret_key(&secp_ctx, &chan_keys.channel_monitor_claim_key).serialize()); let our_channel_monitor_claim_script = Builder::new().push_opcode(opcodes::All::OP_PUSHBYTES_0).push_slice(&our_channel_monitor_claim_key_hash[..]).into_script(); let channel_monitor = ChannelMonitor::new(&chan_keys.revocation_base_key, - &PublicKey::from_secret_key(&secp_ctx, &chan_keys.delayed_payment_base_key).unwrap(), + &PublicKey::from_secret_key(&secp_ctx, &chan_keys.delayed_payment_base_key), &chan_keys.htlc_base_key, BREAKDOWN_TIMEOUT, our_channel_monitor_claim_script); @@ -447,12 +447,12 @@ impl Channel { their_to_self_delay: 0, their_max_accepted_htlcs: 0, - their_funding_pubkey: PublicKey::new(), - their_revocation_basepoint: PublicKey::new(), - their_payment_basepoint: PublicKey::new(), - their_delayed_payment_basepoint: PublicKey::new(), - their_htlc_basepoint: PublicKey::new(), - their_cur_commitment_point: PublicKey::new(), + their_funding_pubkey: None, + their_revocation_basepoint: None, + their_payment_basepoint: None, + their_delayed_payment_basepoint: None, + their_htlc_basepoint: None, + their_cur_commitment_point: None, their_prev_commitment_point: None, their_node_id: their_node_id, @@ -557,10 +557,10 @@ impl Channel { } let secp_ctx = Secp256k1::new(); - let our_channel_monitor_claim_key_hash = Hash160::from_data(&PublicKey::from_secret_key(&secp_ctx, &chan_keys.channel_monitor_claim_key).unwrap().serialize()); + let our_channel_monitor_claim_key_hash = Hash160::from_data(&PublicKey::from_secret_key(&secp_ctx, &chan_keys.channel_monitor_claim_key).serialize()); let our_channel_monitor_claim_script = Builder::new().push_opcode(opcodes::All::OP_PUSHBYTES_0).push_slice(&our_channel_monitor_claim_key_hash[..]).into_script(); let mut channel_monitor = ChannelMonitor::new(&chan_keys.revocation_base_key, - &PublicKey::from_secret_key(&secp_ctx, &chan_keys.delayed_payment_base_key).unwrap(), + &PublicKey::from_secret_key(&secp_ctx, &chan_keys.delayed_payment_base_key), &chan_keys.htlc_base_key, BREAKDOWN_TIMEOUT, our_channel_monitor_claim_script); channel_monitor.set_their_htlc_base_key(&msg.htlc_basepoint); @@ -605,12 +605,12 @@ impl Channel { their_to_self_delay: msg.to_self_delay, their_max_accepted_htlcs: msg.max_accepted_htlcs, - their_funding_pubkey: msg.funding_pubkey, - their_revocation_basepoint: msg.revocation_basepoint, - their_payment_basepoint: msg.payment_basepoint, - their_delayed_payment_basepoint: msg.delayed_payment_basepoint, - their_htlc_basepoint: msg.htlc_basepoint, - their_cur_commitment_point: msg.first_per_commitment_point, + their_funding_pubkey: Some(msg.funding_pubkey), + their_revocation_basepoint: Some(msg.revocation_basepoint), + their_payment_basepoint: Some(msg.payment_basepoint), + their_delayed_payment_basepoint: Some(msg.delayed_payment_basepoint), + their_htlc_basepoint: Some(msg.htlc_basepoint), + their_cur_commitment_point: Some(msg.first_per_commitment_point), their_prev_commitment_point: None, their_node_id: their_node_id, @@ -639,13 +639,13 @@ impl Channel { fn get_commitment_transaction_number_obscure_factor(&self) -> u64 { let mut sha = Sha256::new(); - let our_payment_basepoint = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.payment_base_key).unwrap(); + let our_payment_basepoint = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.payment_base_key); if self.channel_outbound { sha.input(&our_payment_basepoint.serialize()); - sha.input(&self.their_payment_basepoint.serialize()); + sha.input(&self.their_payment_basepoint.unwrap().serialize()); } else { - sha.input(&self.their_payment_basepoint.serialize()); + sha.input(&self.their_payment_basepoint.unwrap().serialize()); sha.input(&our_payment_basepoint.serialize()); } let mut res = [0; 32]; @@ -679,8 +679,7 @@ impl Channel { let txins = { let mut ins: Vec = Vec::new(); ins.push(TxIn { - prev_hash: self.channel_monitor.get_funding_txo().unwrap().txid, - prev_index: self.channel_monitor.get_funding_txo().unwrap().index as u32, + previous_output: self.channel_monitor.get_funding_txo().unwrap().into_bitcoin_outpoint(), script_sig: Script::new(), sequence: ((0x80 as u32) << 8*3) | ((obscured_commitment_transaction_number >> 3*8) as u32), witness: Vec::new(), @@ -805,7 +804,7 @@ impl Channel { #[inline] fn get_closing_scriptpubkey(&self) -> Script { - let our_channel_close_key_hash = Hash160::from_data(&PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.channel_close_key).unwrap().serialize()); + let our_channel_close_key_hash = Hash160::from_data(&PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.channel_close_key).serialize()); Builder::new().push_opcode(opcodes::All::OP_PUSHBYTES_0).push_slice(&our_channel_close_key_hash[..]).into_script() } @@ -819,8 +818,7 @@ impl Channel { let txins = { let mut ins: Vec = Vec::new(); ins.push(TxIn { - prev_hash: self.channel_monitor.get_funding_txo().unwrap().txid, - prev_index: self.channel_monitor.get_funding_txo().unwrap().index as u32, + previous_output: self.channel_monitor.get_funding_txo().unwrap().into_bitcoin_outpoint(), script_sig: Script::new(), sequence: 0xffffffff, witness: Vec::new(), @@ -879,11 +877,11 @@ impl Channel { /// The result is a transaction which we can revoke ownership of (ie a "local" transaction) /// TODO Some magic rust shit to compile-time check this? fn build_local_transaction_keys(&self, commitment_number: u64) -> Result { - let per_commitment_point = PublicKey::from_secret_key(&self.secp_ctx, &self.build_local_commitment_secret(commitment_number)).unwrap(); - let delayed_payment_base = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.delayed_payment_base_key).unwrap(); - let htlc_basepoint = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.htlc_base_key).unwrap(); + let per_commitment_point = PublicKey::from_secret_key(&self.secp_ctx, &self.build_local_commitment_secret(commitment_number)); + let delayed_payment_base = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.delayed_payment_base_key); + let htlc_basepoint = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.htlc_base_key); - Ok(secp_derived_key!(TxCreationKeys::new(&self.secp_ctx, &per_commitment_point, &delayed_payment_base, &htlc_basepoint, &self.their_revocation_basepoint, &self.their_payment_basepoint, &self.their_htlc_basepoint))) + Ok(secp_derived_key!(TxCreationKeys::new(&self.secp_ctx, &per_commitment_point, &delayed_payment_base, &htlc_basepoint, &self.their_revocation_basepoint.unwrap(), &self.their_payment_basepoint.unwrap(), &self.their_htlc_basepoint.unwrap()))) } #[inline] @@ -892,19 +890,19 @@ impl Channel { fn build_remote_transaction_keys(&self) -> Result { //TODO: Ensure that the payment_key derived here ends up in the library users' wallet as we //may see payments to it! - let payment_basepoint = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.payment_base_key).unwrap(); - let revocation_basepoint = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.revocation_base_key).unwrap(); - let htlc_basepoint = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.htlc_base_key).unwrap(); + let payment_basepoint = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.payment_base_key); + let revocation_basepoint = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.revocation_base_key); + let htlc_basepoint = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.htlc_base_key); - Ok(secp_derived_key!(TxCreationKeys::new(&self.secp_ctx, &self.their_cur_commitment_point, &self.their_delayed_payment_basepoint, &self.their_htlc_basepoint, &revocation_basepoint, &payment_basepoint, &htlc_basepoint))) + Ok(secp_derived_key!(TxCreationKeys::new(&self.secp_ctx, &self.their_cur_commitment_point.unwrap(), &self.their_delayed_payment_basepoint.unwrap(), &self.their_htlc_basepoint.unwrap(), &revocation_basepoint, &payment_basepoint, &htlc_basepoint))) } /// Gets the redeemscript for the funding transaction output (ie the funding transaction output /// pays to get_funding_redeemscript().to_v0_p2wsh()). pub fn get_funding_redeemscript(&self) -> Script { let builder = Builder::new().push_opcode(opcodes::All::OP_PUSHNUM_2); - let our_funding_key = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.funding_key).unwrap().serialize(); - let their_funding_key = self.their_funding_pubkey.serialize(); + let our_funding_key = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.funding_key).serialize(); + let their_funding_key = self.their_funding_pubkey.unwrap().serialize(); if our_funding_key[..] < their_funding_key[..] { builder.push_slice(&our_funding_key) .push_slice(&their_funding_key) @@ -925,12 +923,12 @@ impl Channel { let funding_redeemscript = self.get_funding_redeemscript(); let sighash = Message::from_slice(&bip143::SighashComponents::new(&tx).sighash_all(&tx.input[0], &funding_redeemscript, self.channel_value_satoshis)[..]).unwrap(); - let our_sig = self.secp_ctx.sign(&sighash, &self.local_keys.funding_key).unwrap(); + let our_sig = self.secp_ctx.sign(&sighash, &self.local_keys.funding_key); tx.input[0].witness.push(Vec::new()); // First is the multisig dummy - let our_funding_key = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.funding_key).unwrap().serialize(); - let their_funding_key = self.their_funding_pubkey.serialize(); + let our_funding_key = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.funding_key).serialize(); + let their_funding_key = self.their_funding_pubkey.unwrap().serialize(); if our_funding_key[..] < their_funding_key[..] { tx.input[0].witness.push(our_sig.serialize_der(&self.secp_ctx).to_vec()); tx.input[0].witness.push(their_sig.serialize_der(&self.secp_ctx).to_vec()); @@ -941,7 +939,7 @@ impl Channel { tx.input[0].witness[1].push(SigHashType::All as u8); tx.input[0].witness[2].push(SigHashType::All as u8); - tx.input[0].witness.push(funding_redeemscript.into_vec()); + tx.input[0].witness.push(funding_redeemscript.into_bytes()); our_sig } @@ -962,8 +960,8 @@ impl Channel { let our_htlc_key = secp_derived_key!(chan_utils::derive_private_key(&self.secp_ctx, &keys.per_commitment_point, &self.local_keys.htlc_base_key)); let sighash = Message::from_slice(&bip143::SighashComponents::new(&tx).sighash_all(&tx.input[0], &htlc_redeemscript, htlc.amount_msat / 1000)[..]).unwrap(); - let is_local_tx = PublicKey::from_secret_key(&self.secp_ctx, &our_htlc_key).unwrap() == keys.a_htlc_key; - Ok((htlc_redeemscript, self.secp_ctx.sign(&sighash, &our_htlc_key).unwrap(), is_local_tx)) + let is_local_tx = PublicKey::from_secret_key(&self.secp_ctx, &our_htlc_key) == keys.a_htlc_key; + Ok((htlc_redeemscript, self.secp_ctx.sign(&sighash, &our_htlc_key), is_local_tx)) } /// Signs a transaction created by build_htlc_transaction. If the transaction is an @@ -996,7 +994,7 @@ impl Channel { tx.input[0].witness.push(preimage.unwrap().to_vec()); } - tx.input[0].witness.push(htlc_redeemscript.into_vec()); + tx.input[0].witness.push(htlc_redeemscript.into_bytes()); Ok(our_sig) } @@ -1230,12 +1228,12 @@ impl Channel { self.their_htlc_minimum_msat = msg.htlc_minimum_msat; self.their_to_self_delay = msg.to_self_delay; self.their_max_accepted_htlcs = msg.max_accepted_htlcs; - self.their_funding_pubkey = msg.funding_pubkey; - self.their_revocation_basepoint = msg.revocation_basepoint; - self.their_payment_basepoint = msg.payment_basepoint; - self.their_delayed_payment_basepoint = msg.delayed_payment_basepoint; - self.their_htlc_basepoint = msg.htlc_basepoint; - self.their_cur_commitment_point = msg.first_per_commitment_point; + self.their_funding_pubkey = Some(msg.funding_pubkey); + self.their_revocation_basepoint = Some(msg.revocation_basepoint); + self.their_payment_basepoint = Some(msg.payment_basepoint); + self.their_delayed_payment_basepoint = Some(msg.delayed_payment_basepoint); + self.their_htlc_basepoint = Some(msg.htlc_basepoint); + self.their_cur_commitment_point = Some(msg.first_per_commitment_point); let obscure_factor = self.get_commitment_transaction_number_obscure_factor(); self.channel_monitor.set_commitment_obscure_factor(obscure_factor); @@ -1258,10 +1256,10 @@ impl Channel { let local_sighash = Message::from_slice(&bip143::SighashComponents::new(&local_initial_commitment_tx).sighash_all(&local_initial_commitment_tx.input[0], &funding_script, self.channel_value_satoshis)[..]).unwrap(); // They sign the "local" commitment transaction, allowing us to broadcast the tx if we wish. - secp_call!(self.secp_ctx.verify(&local_sighash, &sig, &self.their_funding_pubkey), "Invalid funding_created signature from peer"); + secp_call!(self.secp_ctx.verify(&local_sighash, &sig, &self.their_funding_pubkey.unwrap()), "Invalid funding_created signature from peer"); // We sign the "remote" commitment transaction, allowing them to broadcast the tx if they wish. - Ok((remote_initial_commitment_tx, self.secp_ctx.sign(&remote_sighash, &self.local_keys.funding_key).unwrap())) + Ok((remote_initial_commitment_tx, self.secp_ctx.sign(&remote_sighash, &self.local_keys.funding_key))) } pub fn funding_created(&mut self, msg: &msgs::FundingCreated) -> Result<(msgs::FundingSigned, ChannelMonitor), HandleError> { @@ -1321,7 +1319,7 @@ impl Channel { let local_sighash = Message::from_slice(&bip143::SighashComponents::new(&local_initial_commitment_tx).sighash_all(&local_initial_commitment_tx.input[0], &funding_script, self.channel_value_satoshis)[..]).unwrap(); // They sign the "local" commitment transaction, allowing us to broadcast the tx if we wish. - secp_call!(self.secp_ctx.verify(&local_sighash, &msg.signature, &self.their_funding_pubkey), "Invalid funding_signed signature from peer"); + secp_call!(self.secp_ctx.verify(&local_sighash, &msg.signature, &self.their_funding_pubkey.unwrap()), "Invalid funding_signed signature from peer"); self.sign_commitment_transaction(&mut local_initial_commitment_tx, &msg.signature); self.channel_monitor.provide_latest_local_commitment_tx_info(local_initial_commitment_tx.clone(), local_keys, self.feerate_per_kw, Vec::new()); @@ -1343,8 +1341,8 @@ impl Channel { return Err(HandleError{err: "Peer sent a funding_locked at a strange time", action: None}); } - self.their_prev_commitment_point = Some(self.their_cur_commitment_point); - self.their_cur_commitment_point = msg.next_per_commitment_point; + self.their_prev_commitment_point = self.their_cur_commitment_point; + self.their_cur_commitment_point = Some(msg.next_per_commitment_point); Ok(()) } @@ -1505,7 +1503,7 @@ impl Channel { let mut local_commitment_tx = self.build_commitment_transaction(self.cur_local_commitment_transaction_number, &local_keys, true, false); let local_commitment_txid = local_commitment_tx.0.txid(); let local_sighash = Message::from_slice(&bip143::SighashComponents::new(&local_commitment_tx.0).sighash_all(&local_commitment_tx.0.input[0], &funding_script, self.channel_value_satoshis)[..]).unwrap(); - secp_call!(self.secp_ctx.verify(&local_sighash, &msg.signature, &self.their_funding_pubkey), "Invalid commitment tx signature from peer"); + secp_call!(self.secp_ctx.verify(&local_sighash, &msg.signature, &self.their_funding_pubkey.unwrap()), "Invalid commitment tx signature from peer"); if msg.htlc_signatures.len() != local_commitment_tx.1.len() { return Err(HandleError{err: "Got wrong number of HTLC signatures from remote", action: None}); @@ -1531,7 +1529,7 @@ impl Channel { htlcs_and_sigs.push(((*htlc).clone(), msg.htlc_signatures[idx], htlc_sig)); } - let next_per_commitment_point = PublicKey::from_secret_key(&self.secp_ctx, &self.build_local_commitment_secret(self.cur_local_commitment_transaction_number - 1)).unwrap(); + let next_per_commitment_point = PublicKey::from_secret_key(&self.secp_ctx, &self.build_local_commitment_secret(self.cur_local_commitment_transaction_number - 1)); let per_commitment_secret = chan_utils::build_commitment_secret(self.local_keys.commitment_seed, self.cur_local_commitment_transaction_number + 1); // Update state now that we've passed all the can-fail calls... @@ -1655,7 +1653,7 @@ impl Channel { return Err(HandleError{err: "Got revoke/ACK message when channel was not in an operational state", action: None}); } if let Some(their_prev_commitment_point) = self.their_prev_commitment_point { - if PublicKey::from_secret_key(&self.secp_ctx, &secp_call!(SecretKey::from_slice(&self.secp_ctx, &msg.per_commitment_secret), "Peer provided an invalid per_commitment_secret")).unwrap() != their_prev_commitment_point { + if PublicKey::from_secret_key(&self.secp_ctx, &secp_call!(SecretKey::from_slice(&self.secp_ctx, &msg.per_commitment_secret), "Peer provided an invalid per_commitment_secret")) != their_prev_commitment_point { return Err(HandleError{err: "Got a revoke commitment secret which didn't correspond to their current pubkey", action: None}); } } @@ -1666,8 +1664,8 @@ impl Channel { // OK, we step the channel here and *then* if the new generation fails we can fail the // channel based on that, but stepping stuff here should be safe either way. self.channel_state &= !(ChannelState::AwaitingRemoteRevoke as u32); - self.their_prev_commitment_point = Some(self.their_cur_commitment_point); - self.their_cur_commitment_point = msg.next_per_commitment_point; + self.their_prev_commitment_point = self.their_cur_commitment_point; + self.their_cur_commitment_point = Some(msg.next_per_commitment_point); self.cur_remote_commitment_transaction_number -= 1; let mut to_forward_infos = Vec::new(); @@ -1782,7 +1780,7 @@ impl Channel { let funding_redeemscript = self.get_funding_redeemscript(); let sighash = Message::from_slice(&bip143::SighashComponents::new(&closing_tx).sighash_all(&closing_tx.input[0], &funding_redeemscript, self.channel_value_satoshis)[..]).unwrap(); - (Some(proposed_feerate), Some(total_fee_satoshis), Some(self.secp_ctx.sign(&sighash, &self.local_keys.funding_key).unwrap())) + (Some(proposed_feerate), Some(total_fee_satoshis), Some(self.secp_ctx.sign(&sighash, &self.local_keys.funding_key))) } else { (None, None, None) }; // From here on out, we may not fail! @@ -1852,14 +1850,14 @@ impl Channel { } let mut sighash = Message::from_slice(&bip143::SighashComponents::new(&closing_tx).sighash_all(&closing_tx.input[0], &funding_redeemscript, self.channel_value_satoshis)[..]).unwrap(); - match self.secp_ctx.verify(&sighash, &msg.signature, &self.their_funding_pubkey) { + match self.secp_ctx.verify(&sighash, &msg.signature, &self.their_funding_pubkey.unwrap()) { Ok(_) => {}, Err(_e) => { // The remote end may have decided to revoke their output due to inconsistent dust // limits, so check for that case by re-checking the signature here. closing_tx = self.build_closing_transaction(msg.fee_satoshis, true).0; sighash = Message::from_slice(&bip143::SighashComponents::new(&closing_tx).sighash_all(&closing_tx.input[0], &funding_redeemscript, self.channel_value_satoshis)[..]).unwrap(); - secp_call!(self.secp_ctx.verify(&sighash, &msg.signature, &self.their_funding_pubkey), "Invalid closing tx signature from peer"); + secp_call!(self.secp_ctx.verify(&sighash, &msg.signature, &self.their_funding_pubkey.unwrap()), "Invalid closing tx signature from peer"); }, }; @@ -1877,7 +1875,7 @@ impl Channel { let closing_tx_max_weight = Self::get_closing_transaction_weight(&self.get_closing_scriptpubkey(), self.their_shutdown_scriptpubkey.as_ref().unwrap()); let (closing_tx, used_total_fee) = self.build_closing_transaction($new_feerate * closing_tx_max_weight / 1000, false); sighash = Message::from_slice(&bip143::SighashComponents::new(&closing_tx).sighash_all(&closing_tx.input[0], &funding_redeemscript, self.channel_value_satoshis)[..]).unwrap(); - let our_sig = self.secp_ctx.sign(&sighash, &self.local_keys.funding_key).unwrap(); + let our_sig = self.secp_ctx.sign(&sighash, &self.local_keys.funding_key); self.last_sent_closing_fee = Some(($new_feerate, used_total_fee)); return Ok((Some(msgs::ClosingSigned { channel_id: self.channel_id, @@ -2065,7 +2063,7 @@ impl Channel { //a protocol oversight, but I assume I'm just missing something. if need_commitment_update { let next_per_commitment_secret = self.build_local_commitment_secret(self.cur_local_commitment_transaction_number); - let next_per_commitment_point = PublicKey::from_secret_key(&self.secp_ctx, &next_per_commitment_secret).unwrap(); + let next_per_commitment_point = PublicKey::from_secret_key(&self.secp_ctx, &next_per_commitment_secret); return Ok(Some(msgs::FundingLocked { channel_id: self.channel_id, next_per_commitment_point: next_per_commitment_point, @@ -2140,12 +2138,12 @@ impl Channel { feerate_per_kw: fee_estimator.get_est_sat_per_1000_weight(ConfirmationTarget::Background) as u32, to_self_delay: BREAKDOWN_TIMEOUT, max_accepted_htlcs: OUR_MAX_HTLCS, - funding_pubkey: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.funding_key).unwrap(), - revocation_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.revocation_base_key).unwrap(), - payment_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.payment_base_key).unwrap(), - delayed_payment_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.delayed_payment_base_key).unwrap(), - htlc_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.htlc_base_key).unwrap(), - first_per_commitment_point: PublicKey::from_secret_key(&self.secp_ctx, &local_commitment_secret).unwrap(), + funding_pubkey: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.funding_key), + revocation_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.revocation_base_key), + payment_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.payment_base_key), + delayed_payment_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.delayed_payment_base_key), + htlc_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.htlc_base_key), + first_per_commitment_point: PublicKey::from_secret_key(&self.secp_ctx, &local_commitment_secret), channel_flags: if self.announce_publicly {1} else {0}, shutdown_scriptpubkey: None, }) @@ -2173,12 +2171,12 @@ impl Channel { minimum_depth: Channel::derive_minimum_depth(self.channel_value_satoshis*1000, self.value_to_self_msat), to_self_delay: BREAKDOWN_TIMEOUT, max_accepted_htlcs: OUR_MAX_HTLCS, - funding_pubkey: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.funding_key).unwrap(), - revocation_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.revocation_base_key).unwrap(), - payment_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.payment_base_key).unwrap(), - delayed_payment_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.delayed_payment_base_key).unwrap(), - htlc_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.htlc_base_key).unwrap(), - first_per_commitment_point: PublicKey::from_secret_key(&self.secp_ctx, &local_commitment_secret).unwrap(), + funding_pubkey: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.funding_key), + revocation_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.revocation_base_key), + payment_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.payment_base_key), + delayed_payment_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.delayed_payment_base_key), + htlc_basepoint: PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.htlc_base_key), + first_per_commitment_point: PublicKey::from_secret_key(&self.secp_ctx, &local_commitment_secret), shutdown_scriptpubkey: None, }) } @@ -2191,7 +2189,7 @@ impl Channel { let remote_sighash = Message::from_slice(&bip143::SighashComponents::new(&remote_initial_commitment_tx).sighash_all(&remote_initial_commitment_tx.input[0], &funding_script, self.channel_value_satoshis)[..]).unwrap(); // We sign the "remote" commitment transaction, allowing them to broadcast the tx if they wish. - Ok((self.secp_ctx.sign(&remote_sighash, &self.local_keys.funding_key).unwrap(), remote_initial_commitment_tx)) + Ok((self.secp_ctx.sign(&remote_sighash, &self.local_keys.funding_key), remote_initial_commitment_tx)) } /// Updates channel state with knowledge of the funding transaction's txid/index, and generates @@ -2255,7 +2253,7 @@ impl Channel { } let were_node_one = our_node_id.serialize()[..] < self.their_node_id.serialize()[..]; - let our_bitcoin_key = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.funding_key).unwrap(); + let our_bitcoin_key = PublicKey::from_secret_key(&self.secp_ctx, &self.local_keys.funding_key); let msg = msgs::UnsignedChannelAnnouncement { features: msgs::GlobalFeatures::new(), @@ -2263,12 +2261,12 @@ impl Channel { short_channel_id: self.get_short_channel_id().unwrap(), node_id_1: if were_node_one { our_node_id } else { self.get_their_node_id() }, node_id_2: if were_node_one { self.get_their_node_id() } else { our_node_id }, - bitcoin_key_1: if were_node_one { our_bitcoin_key } else { self.their_funding_pubkey }, - bitcoin_key_2: if were_node_one { self.their_funding_pubkey } else { our_bitcoin_key }, + bitcoin_key_1: if were_node_one { our_bitcoin_key } else { self.their_funding_pubkey.unwrap() }, + bitcoin_key_2: if were_node_one { self.their_funding_pubkey.unwrap() } else { our_bitcoin_key }, }; let msghash = Message::from_slice(&Sha256dHash::from_data(&msg.encode()[..])[..]).unwrap(); - let sig = self.secp_ctx.sign(&msghash, &self.local_keys.funding_key).unwrap(); + let sig = self.secp_ctx.sign(&msghash, &self.local_keys.funding_key); Ok((msg, sig)) } @@ -2386,7 +2384,7 @@ impl Channel { let remote_commitment_tx = self.build_commitment_transaction(self.cur_remote_commitment_transaction_number, &remote_keys, false, true); let remote_commitment_txid = remote_commitment_tx.0.txid(); let remote_sighash = Message::from_slice(&bip143::SighashComponents::new(&remote_commitment_tx.0).sighash_all(&remote_commitment_tx.0.input[0], &funding_script, self.channel_value_satoshis)[..]).unwrap(); - let our_sig = self.secp_ctx.sign(&remote_sighash, &self.local_keys.funding_key).unwrap(); + let our_sig = self.secp_ctx.sign(&remote_sighash, &self.local_keys.funding_key); let mut htlc_sigs = Vec::new(); @@ -2395,7 +2393,7 @@ impl Channel { let htlc_redeemscript = chan_utils::get_htlc_redeemscript(&htlc, &remote_keys); let htlc_sighash = Message::from_slice(&bip143::SighashComponents::new(&htlc_tx).sighash_all(&htlc_tx.input[0], &htlc_redeemscript, htlc.amount_msat / 1000)[..]).unwrap(); let our_htlc_key = secp_derived_key!(chan_utils::derive_private_key(&self.secp_ctx, &remote_keys.per_commitment_point, &self.local_keys.htlc_base_key)); - htlc_sigs.push(self.secp_ctx.sign(&htlc_sighash, &our_htlc_key).unwrap()); + htlc_sigs.push(self.secp_ctx.sign(&htlc_sighash, &our_htlc_key)); } // Update state now that we've passed all the can-fail calls... @@ -2558,38 +2556,39 @@ mod tests { channel_monitor_claim_key: SecretKey::from_slice(&secp_ctx, &hex::decode("0fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap()[..]).unwrap(), commitment_seed: [0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff], }; - assert_eq!(PublicKey::from_secret_key(&secp_ctx, &chan_keys.funding_key).unwrap().serialize()[..], + assert_eq!(PublicKey::from_secret_key(&secp_ctx, &chan_keys.funding_key).serialize()[..], hex::decode("023da092f6980e58d2c037173180e9a465476026ee50f96695963e8efe436f54eb").unwrap()[..]); - let mut chan = Channel::new_outbound(&feeest, chan_keys, PublicKey::new(), 10000000, 100000, false, 42, Arc::clone(&logger)).unwrap(); // Nothing uses their network key in this test + let their_node_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap()); + let mut chan = Channel::new_outbound(&feeest, chan_keys, their_node_id, 10000000, 100000, false, 42, Arc::clone(&logger)).unwrap(); // Nothing uses their network key in this test chan.their_to_self_delay = 144; chan.our_dust_limit_satoshis = 546; let funding_info = OutPoint::new(Sha256dHash::from_hex("8984484a580b825b9972d7adb15050b3ab624ccd731946b3eeddb92f4e7ef6be").unwrap(), 0); chan.channel_monitor.set_funding_info((funding_info, Script::new())); - chan.their_payment_basepoint = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("4444444444444444444444444444444444444444444444444444444444444444").unwrap()[..]).unwrap()).unwrap(); - assert_eq!(chan.their_payment_basepoint.serialize()[..], + chan.their_payment_basepoint = Some(PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("4444444444444444444444444444444444444444444444444444444444444444").unwrap()[..]).unwrap())); + assert_eq!(chan.their_payment_basepoint.unwrap().serialize()[..], hex::decode("032c0b7cf95324a07d05398b240174dc0c2be444d96b159aa6c7f7b1e668680991").unwrap()[..]); - chan.their_funding_pubkey = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("1552dfba4f6cf29a62a0af13c8d6981d36d0ef8d61ba10fb0fe90da7634d7e13").unwrap()[..]).unwrap()).unwrap(); - assert_eq!(chan.their_funding_pubkey.serialize()[..], + chan.their_funding_pubkey = Some(PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("1552dfba4f6cf29a62a0af13c8d6981d36d0ef8d61ba10fb0fe90da7634d7e13").unwrap()[..]).unwrap())); + assert_eq!(chan.their_funding_pubkey.unwrap().serialize()[..], hex::decode("030e9f7b623d2ccc7c9bd44d66d5ce21ce504c0acf6385a132cec6d3c39fa711c1").unwrap()[..]); - chan.their_htlc_basepoint = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("4444444444444444444444444444444444444444444444444444444444444444").unwrap()[..]).unwrap()).unwrap(); - assert_eq!(chan.their_htlc_basepoint.serialize()[..], + chan.their_htlc_basepoint = Some(PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("4444444444444444444444444444444444444444444444444444444444444444").unwrap()[..]).unwrap())); + assert_eq!(chan.their_htlc_basepoint.unwrap().serialize()[..], hex::decode("032c0b7cf95324a07d05398b240174dc0c2be444d96b159aa6c7f7b1e668680991").unwrap()[..]); - chan.their_revocation_basepoint = PublicKey::from_slice(&secp_ctx, &hex::decode("02466d7fcae563e5cb09a0d1870bb580344804617879a14949cf22285f1bae3f27").unwrap()[..]).unwrap(); + chan.their_revocation_basepoint = Some(PublicKey::from_slice(&secp_ctx, &hex::decode("02466d7fcae563e5cb09a0d1870bb580344804617879a14949cf22285f1bae3f27").unwrap()[..]).unwrap()); // We can't just use build_local_transaction_keys here as the per_commitment_secret is not // derived from a commitment_seed, so instead we copy it here and call // build_commitment_transaction. - let delayed_payment_base = PublicKey::from_secret_key(&secp_ctx, &chan.local_keys.delayed_payment_base_key).unwrap(); + let delayed_payment_base = PublicKey::from_secret_key(&secp_ctx, &chan.local_keys.delayed_payment_base_key); let per_commitment_secret = SecretKey::from_slice(&secp_ctx, &hex::decode("1f1e1d1c1b1a191817161514131211100f0e0d0c0b0a09080706050403020100").unwrap()[..]).unwrap(); - let per_commitment_point = PublicKey::from_secret_key(&secp_ctx, &per_commitment_secret).unwrap(); - let htlc_basepoint = PublicKey::from_secret_key(&secp_ctx, &chan.local_keys.htlc_base_key).unwrap(); - let keys = TxCreationKeys::new(&secp_ctx, &per_commitment_point, &delayed_payment_base, &htlc_basepoint, &chan.their_revocation_basepoint, &chan.their_payment_basepoint, &chan.their_htlc_basepoint).unwrap(); + let per_commitment_point = PublicKey::from_secret_key(&secp_ctx, &per_commitment_secret); + let htlc_basepoint = PublicKey::from_secret_key(&secp_ctx, &chan.local_keys.htlc_base_key); + let keys = TxCreationKeys::new(&secp_ctx, &per_commitment_point, &delayed_payment_base, &htlc_basepoint, &chan.their_revocation_basepoint.unwrap(), &chan.their_payment_basepoint.unwrap(), &chan.their_htlc_basepoint.unwrap()).unwrap(); let mut unsigned_tx: (Transaction, Vec); @@ -2598,7 +2597,7 @@ mod tests { unsigned_tx = chan.build_commitment_transaction(0xffffffffffff - 42, &keys, true, false); let their_signature = Signature::from_der(&secp_ctx, &hex::decode($their_sig_hex).unwrap()[..]).unwrap(); let sighash = Message::from_slice(&bip143::SighashComponents::new(&unsigned_tx.0).sighash_all(&unsigned_tx.0.input[0], &chan.get_funding_redeemscript(), chan.channel_value_satoshis)[..]).unwrap(); - secp_ctx.verify(&sighash, &their_signature, &chan.their_funding_pubkey).unwrap(); + secp_ctx.verify(&sighash, &their_signature, &chan.their_funding_pubkey.unwrap()).unwrap(); chan.sign_commitment_transaction(&mut unsigned_tx.0, &their_signature); @@ -3086,10 +3085,10 @@ mod tests { let base_secret = SecretKey::from_slice(&secp_ctx, &hex::decode("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f").unwrap()[..]).unwrap(); let per_commitment_secret = SecretKey::from_slice(&secp_ctx, &hex::decode("1f1e1d1c1b1a191817161514131211100f0e0d0c0b0a09080706050403020100").unwrap()[..]).unwrap(); - let base_point = PublicKey::from_secret_key(&secp_ctx, &base_secret).unwrap(); + let base_point = PublicKey::from_secret_key(&secp_ctx, &base_secret); assert_eq!(base_point.serialize()[..], hex::decode("036d6caac248af96f6afa7f904f550253a0f3ef3f5aa2fe6838a95b216691468e2").unwrap()[..]); - let per_commitment_point = PublicKey::from_secret_key(&secp_ctx, &per_commitment_secret).unwrap(); + let per_commitment_point = PublicKey::from_secret_key(&secp_ctx, &per_commitment_secret); assert_eq!(per_commitment_point.serialize()[..], hex::decode("025f7117a78150fe2ef97db7cfc83bd57b2e2c0d0dd25eaf467a4a1c2a45ce1486").unwrap()[..]); assert_eq!(chan_utils::derive_public_key(&secp_ctx, &per_commitment_point, &base_point).unwrap().serialize()[..], diff --git a/src/ln/channelmanager.rs b/src/ln/channelmanager.rs index 27f470d40..76c7bb18f 100644 --- a/src/ln/channelmanager.rs +++ b/src/ln/channelmanager.rs @@ -162,7 +162,7 @@ pub struct ChannelManager { announce_channels_publicly: bool, fee_proportional_millionths: u32, latest_block_height: AtomicUsize, - secp_ctx: Secp256k1, + secp_ctx: Secp256k1, channel_state: Mutex, our_network_key: SecretKey, @@ -461,9 +461,9 @@ impl ChannelManager { // can only fail if an intermediary hop has an invalid public key or session_priv is invalid #[inline] - fn construct_onion_keys_callback (secp_ctx: &Secp256k1, route: &Route, session_priv: &SecretKey, mut callback: FType) -> Result<(), HandleError> { + fn construct_onion_keys_callback (secp_ctx: &Secp256k1, route: &Route, session_priv: &SecretKey, mut callback: FType) -> Result<(), HandleError> { let mut blinded_priv = session_priv.clone(); - let mut blinded_pub = secp_call!(PublicKey::from_secret_key(secp_ctx, &blinded_priv)); + let mut blinded_pub = PublicKey::from_secret_key(secp_ctx, &blinded_priv); let mut first_iteration = true; for hop in route.hops.iter() { @@ -476,13 +476,13 @@ impl ChannelManager { sha.result(&mut blinding_factor); if first_iteration { - blinded_pub = secp_call!(PublicKey::from_secret_key(secp_ctx, &blinded_priv)); + blinded_pub = PublicKey::from_secret_key(secp_ctx, &blinded_priv); first_iteration = false; } let ephemeral_pubkey = blinded_pub; secp_call!(blinded_priv.mul_assign(secp_ctx, &secp_call!(SecretKey::from_slice(secp_ctx, &blinding_factor)))); - blinded_pub = secp_call!(PublicKey::from_secret_key(secp_ctx, &blinded_priv)); + blinded_pub = PublicKey::from_secret_key(secp_ctx, &blinded_priv); callback(shared_secret, blinding_factor, ephemeral_pubkey, hop); } @@ -491,7 +491,7 @@ impl ChannelManager { } // can only fail if an intermediary hop has an invalid public key or session_priv is invalid - fn construct_onion_keys(secp_ctx: &Secp256k1, route: &Route, session_priv: &SecretKey) -> Result, HandleError> { + fn construct_onion_keys(secp_ctx: &Secp256k1, route: &Route, session_priv: &SecretKey) -> Result, HandleError> { let mut res = Vec::with_capacity(route.hops.len()); Self::construct_onion_keys_callback(secp_ctx, route, session_priv, |shared_secret, _blinding_factor, ephemeral_pubkey, _| { @@ -674,7 +674,7 @@ impl ChannelManager { Some(id) => id, }; - let were_node_one = PublicKey::from_secret_key(&self.secp_ctx, &self.our_network_key).unwrap().serialize()[..] < chan.get_their_node_id().serialize()[..]; + let were_node_one = PublicKey::from_secret_key(&self.secp_ctx, &self.our_network_key).serialize()[..] < chan.get_their_node_id().serialize()[..]; let unsigned = msgs::UnsignedChannelUpdate { chain_hash: self.genesis_hash, @@ -688,7 +688,7 @@ impl ChannelManager { }; let msg_hash = Sha256dHash::from_data(&unsigned.encode()[..]); - let sig = self.secp_ctx.sign(&Message::from_slice(&msg_hash[..]).unwrap(), &self.our_network_key).unwrap(); //TODO Can we unwrap here? + let sig = self.secp_ctx.sign(&Message::from_slice(&msg_hash[..]).unwrap(), &self.our_network_key); //TODO Can we unwrap here? Ok(msgs::ChannelUpdate { signature: sig, @@ -839,7 +839,7 @@ impl ChannelManager { let (announcement, our_bitcoin_sig) = chan.get_channel_announcement(self.get_our_node_id(), self.genesis_hash.clone())?; let msghash = Message::from_slice(&Sha256dHash::from_data(&announcement.encode()[..])[..]).unwrap(); - let our_node_sig = secp_call!(self.secp_ctx.sign(&msghash, &self.our_network_key)); + let our_node_sig = self.secp_ctx.sign(&msghash, &self.our_network_key); Ok(Some(msgs::AnnouncementSignatures { channel_id: chan.channel_id(), @@ -1138,7 +1138,7 @@ impl ChannelManager { /// Gets the node_id held by this ChannelManager pub fn get_our_node_id(&self) -> PublicKey { - PublicKey::from_secret_key(&self.secp_ctx, &self.our_network_key).unwrap() + PublicKey::from_secret_key(&self.secp_ctx, &self.our_network_key) } /// Used to restore channels to normal operation after a @@ -1195,7 +1195,7 @@ impl ChainListener for ChannelManager { if let Some(funding_txo) = channel.get_funding_txo() { for tx in txn_matched { for inp in tx.input.iter() { - if inp.prev_hash == funding_txo.txid && inp.prev_index == funding_txo.index as u32 { + if inp.previous_output == funding_txo.into_bitcoin_outpoint() { if let Some(short_id) = channel.get_short_channel_id() { short_to_id.remove(&short_id); } @@ -1939,7 +1939,7 @@ impl ChannelMessageHandler for ChannelManager { secp_call!(self.secp_ctx.verify(&msghash, &msg.node_signature, if were_node_one { &announcement.node_id_2 } else { &announcement.node_id_1 })); secp_call!(self.secp_ctx.verify(&msghash, &msg.bitcoin_signature, if were_node_one { &announcement.bitcoin_key_2 } else { &announcement.bitcoin_key_1 })); - let our_node_sig = secp_call!(self.secp_ctx.sign(&msghash, &self.our_network_key)); + let our_node_sig = self.secp_ctx.sign(&msghash, &self.our_network_key); (msgs::ChannelAnnouncement { node_signature_1: if were_node_one { our_node_sig } else { msg.node_signature }, @@ -2742,7 +2742,7 @@ mod tests { SecretKey::from_slice(&secp_ctx, &key_slice).unwrap() }; let node = ChannelManager::new(node_id.clone(), 0, true, Network::Testnet, feeest.clone(), chan_monitor.clone(), chain_monitor.clone(), tx_broadcaster.clone(), Arc::clone(&logger)).unwrap(); - let router = Router::new(PublicKey::from_secret_key(&secp_ctx, &node_id).unwrap(), Arc::clone(&logger)); + let router = Router::new(PublicKey::from_secret_key(&secp_ctx, &node_id), Arc::clone(&logger)); nodes.push(Node { feeest, chain_monitor, tx_broadcaster, chan_monitor, node_id, node, router }); } @@ -2879,7 +2879,7 @@ mod tests { res.push(explicit_tx.clone()); } else { for tx in node_txn.iter() { - if tx.input.len() == 1 && tx.input[0].prev_hash == chan.3.txid() { + if tx.input.len() == 1 && tx.input[0].previous_output.txid == chan.3.txid() { let mut funding_tx_map = HashMap::new(); funding_tx_map.insert(chan.3.txid(), chan.3.clone()); tx.verify(&funding_tx_map).unwrap(); @@ -2891,7 +2891,7 @@ mod tests { if has_htlc_tx != HTLCType::NONE { for tx in node_txn.iter() { - if tx.input.len() == 1 && tx.input[0].prev_hash == res[0].txid() { + if tx.input.len() == 1 && tx.input[0].previous_output.txid == res[0].txid() { let mut funding_tx_map = HashMap::new(); funding_tx_map.insert(res[0].txid(), res[0].clone()); tx.verify(&funding_tx_map).unwrap(); @@ -2918,7 +2918,7 @@ mod tests { let mut found_prev = false; for tx in prev_txn { - if node_txn[0].input[0].prev_hash == tx.txid() { + if node_txn[0].input[0].previous_output.txid == tx.txid() { let mut funding_tx_map = HashMap::new(); funding_tx_map.insert(tx.txid(), tx.clone()); node_txn[0].verify(&funding_tx_map).unwrap(); diff --git a/src/ln/channelmonitor.rs b/src/ln/channelmonitor.rs index ffc9ed26f..52bb6d65c 100644 --- a/src/ln/channelmonitor.rs +++ b/src/ln/channelmonitor.rs @@ -1,5 +1,6 @@ use bitcoin::blockdata::block::BlockHeader; use bitcoin::blockdata::transaction::{TxIn,TxOut,SigHashType,Transaction}; +use bitcoin::blockdata::transaction::OutPoint as BitcoinOutPoint; use bitcoin::blockdata::script::Script; use bitcoin::network::serialize; use bitcoin::util::hash::Sha256dHash; @@ -9,6 +10,7 @@ use crypto::digest::Digest; use secp256k1::{Secp256k1,Message,Signature}; use secp256k1::key::{SecretKey,PublicKey}; +use secp256k1; use ln::msgs::HandleError; use ln::chan_utils; @@ -186,7 +188,7 @@ pub struct ChannelMonitor { payment_preimages: HashMap<[u8; 32], [u8; 32]>, destination_script: Script, - secp_ctx: Secp256k1, //TODO: dedup this a bit... + secp_ctx: Secp256k1, //TODO: dedup this a bit... } impl Clone for ChannelMonitor { fn clone(&self) -> Self { @@ -928,20 +930,20 @@ impl ChannelMonitor { let per_commitment_key = ignore_error!(SecretKey::from_slice(&self.secp_ctx, &secret)); let (revocation_pubkey, b_htlc_key) = match self.key_storage { KeyStorage::PrivMode { ref revocation_base_key, ref htlc_base_key } => { - let per_commitment_point = ignore_error!(PublicKey::from_secret_key(&self.secp_ctx, &per_commitment_key)); - (ignore_error!(chan_utils::derive_public_revocation_key(&self.secp_ctx, &per_commitment_point, &ignore_error!(PublicKey::from_secret_key(&self.secp_ctx, &revocation_base_key)))), - ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, &per_commitment_point, &ignore_error!(PublicKey::from_secret_key(&self.secp_ctx, &htlc_base_key))))) + let per_commitment_point = PublicKey::from_secret_key(&self.secp_ctx, &per_commitment_key); + (ignore_error!(chan_utils::derive_public_revocation_key(&self.secp_ctx, &per_commitment_point, &PublicKey::from_secret_key(&self.secp_ctx, &revocation_base_key))), + ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, &per_commitment_point, &PublicKey::from_secret_key(&self.secp_ctx, &htlc_base_key)))) }, KeyStorage::SigsMode { ref revocation_base_key, ref htlc_base_key, .. } => { - let per_commitment_point = ignore_error!(PublicKey::from_secret_key(&self.secp_ctx, &per_commitment_key)); + let per_commitment_point = PublicKey::from_secret_key(&self.secp_ctx, &per_commitment_key); (ignore_error!(chan_utils::derive_public_revocation_key(&self.secp_ctx, &per_commitment_point, &revocation_base_key)), ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, &per_commitment_point, &htlc_base_key))) }, }; - let delayed_key = ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, &ignore_error!(PublicKey::from_secret_key(&self.secp_ctx, &per_commitment_key)), &self.delayed_payment_base_key)); + let delayed_key = ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, &PublicKey::from_secret_key(&self.secp_ctx, &per_commitment_key), &self.delayed_payment_base_key)); let a_htlc_key = match self.their_htlc_base_key { None => return txn_to_broadcast, - Some(their_htlc_base_key) => ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, &ignore_error!(PublicKey::from_secret_key(&self.secp_ctx, &per_commitment_key)), &their_htlc_base_key)), + Some(their_htlc_base_key) => ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, &PublicKey::from_secret_key(&self.secp_ctx, &per_commitment_key), &their_htlc_base_key)), }; let revokeable_redeemscript = chan_utils::get_revokeable_redeemscript(&revocation_pubkey, self.our_to_self_delay, &delayed_key); @@ -955,8 +957,10 @@ impl ChannelMonitor { for (idx, outp) in tx.output.iter().enumerate() { if outp.script_pubkey == revokeable_p2wsh { inputs.push(TxIn { - prev_hash: commitment_txid, - prev_index: idx as u32, + previous_output: BitcoinOutPoint { + txid: commitment_txid, + vout: idx as u32, + }, script_sig: Script::new(), sequence: 0xfffffffd, witness: Vec::new(), @@ -979,7 +983,7 @@ impl ChannelMonitor { }; let sighash = ignore_error!(Message::from_slice(&$sighash_parts.sighash_all(&$input, &redeemscript, $amount)[..])); let revocation_key = ignore_error!(chan_utils::derive_private_revocation_key(&self.secp_ctx, &per_commitment_key, &revocation_base_key)); - (ignore_error!(self.secp_ctx.sign(&sighash, &revocation_key)), redeemscript) + (self.secp_ctx.sign(&sighash, &revocation_key), redeemscript) }, KeyStorage::SigsMode { .. } => { unimplemented!(); @@ -992,7 +996,7 @@ impl ChannelMonitor { } else { $input.witness.push(revocation_pubkey.serialize().to_vec()); } - $input.witness.push(redeemscript.into_vec()); + $input.witness.push(redeemscript.into_bytes()); } } } @@ -1008,8 +1012,10 @@ impl ChannelMonitor { return txn_to_broadcast; // Corrupted per_commitment_data, fuck this user } let input = TxIn { - prev_hash: commitment_txid, - prev_index: htlc.transaction_output_index, + previous_output: BitcoinOutPoint { + txid: commitment_txid, + vout: htlc.transaction_output_index, + }, script_sig: Script::new(), sequence: 0xfffffffd, witness: Vec::new(), @@ -1083,8 +1089,8 @@ impl ChannelMonitor { if let Some(revocation_point) = revocation_point_option { let (revocation_pubkey, b_htlc_key) = match self.key_storage { KeyStorage::PrivMode { ref revocation_base_key, ref htlc_base_key } => { - (ignore_error!(chan_utils::derive_public_revocation_key(&self.secp_ctx, revocation_point, &ignore_error!(PublicKey::from_secret_key(&self.secp_ctx, &revocation_base_key)))), - ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, revocation_point, &ignore_error!(PublicKey::from_secret_key(&self.secp_ctx, &htlc_base_key))))) + (ignore_error!(chan_utils::derive_public_revocation_key(&self.secp_ctx, revocation_point, &PublicKey::from_secret_key(&self.secp_ctx, &revocation_base_key))), + ignore_error!(chan_utils::derive_public_key(&self.secp_ctx, revocation_point, &PublicKey::from_secret_key(&self.secp_ctx, &htlc_base_key)))) }, KeyStorage::SigsMode { ref revocation_base_key, ref htlc_base_key, .. } => { (ignore_error!(chan_utils::derive_public_revocation_key(&self.secp_ctx, revocation_point, &revocation_base_key)), @@ -1109,7 +1115,7 @@ impl ChannelMonitor { let redeemscript = chan_utils::get_htlc_redeemscript_with_explicit_keys(htlc, &a_htlc_key, &b_htlc_key, &revocation_pubkey); let sighash = ignore_error!(Message::from_slice(&$sighash_parts.sighash_all(&$input, &redeemscript, $amount)[..])); let htlc_key = ignore_error!(chan_utils::derive_private_key(&self.secp_ctx, revocation_point, &htlc_base_key)); - (ignore_error!(self.secp_ctx.sign(&sighash, &htlc_key)), redeemscript) + (self.secp_ctx.sign(&sighash, &htlc_key), redeemscript) }, KeyStorage::SigsMode { .. } => { unimplemented!(); @@ -1118,7 +1124,7 @@ impl ChannelMonitor { $input.witness.push(sig.serialize_der(&self.secp_ctx).to_vec()); $input.witness[0].push(SigHashType::All as u8); $input.witness.push($preimage); - $input.witness.push(redeemscript.into_vec()); + $input.witness.push(redeemscript.into_bytes()); } } } @@ -1126,8 +1132,10 @@ impl ChannelMonitor { for (idx, htlc) in per_commitment_data.iter().enumerate() { if let Some(payment_preimage) = self.payment_preimages.get(&htlc.payment_hash) { let input = TxIn { - prev_hash: commitment_txid, - prev_index: htlc.transaction_output_index, + previous_output: BitcoinOutPoint { + txid: commitment_txid, + vout: htlc.transaction_output_index, + }, script_sig: Script::new(), sequence: idx as u32, // reset to 0xfffffffd in sign_input witness: Vec::new(), @@ -1199,7 +1207,7 @@ impl ChannelMonitor { htlc_timeout_tx.input[0].witness[2].push(SigHashType::All as u8); htlc_timeout_tx.input[0].witness.push(Vec::new()); - htlc_timeout_tx.input[0].witness.push(chan_utils::get_htlc_redeemscript_with_explicit_keys(htlc, &local_tx.a_htlc_key, &local_tx.b_htlc_key, &local_tx.revocation_key).into_vec()); + htlc_timeout_tx.input[0].witness.push(chan_utils::get_htlc_redeemscript_with_explicit_keys(htlc, &local_tx.a_htlc_key, &local_tx.b_htlc_key, &local_tx.revocation_key).into_bytes()); res.push(htlc_timeout_tx); } else { @@ -1214,7 +1222,7 @@ impl ChannelMonitor { htlc_success_tx.input[0].witness[2].push(SigHashType::All as u8); htlc_success_tx.input[0].witness.push(payment_preimage.to_vec()); - htlc_success_tx.input[0].witness.push(chan_utils::get_htlc_redeemscript_with_explicit_keys(htlc, &local_tx.a_htlc_key, &local_tx.b_htlc_key, &local_tx.revocation_key).into_vec()); + htlc_success_tx.input[0].witness.push(chan_utils::get_htlc_redeemscript_with_explicit_keys(htlc, &local_tx.a_htlc_key, &local_tx.b_htlc_key, &local_tx.revocation_key).into_bytes()); res.push(htlc_success_tx); } @@ -1245,7 +1253,7 @@ impl ChannelMonitor { fn block_connected(&self, txn_matched: &[&Transaction], height: u32, broadcaster: &BroadcasterInterface) { for tx in txn_matched { for txin in tx.input.iter() { - if self.funding_txo.is_none() || (txin.prev_hash == self.funding_txo.as_ref().unwrap().0.txid && txin.prev_index == self.funding_txo.as_ref().unwrap().0.index as u32) { + if self.funding_txo.is_none() || (txin.previous_output.txid == self.funding_txo.as_ref().unwrap().0.txid && txin.previous_output.vout == self.funding_txo.as_ref().unwrap().0.index as u32) { let mut txn = self.check_spend_remote_transaction(tx, height); if txn.is_empty() { txn = self.check_spend_local_transaction(tx, height); @@ -1321,9 +1329,11 @@ mod tests { }; } + let delayed_payment_base_key = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap()); + { // insert_secret correct sequence - monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &PublicKey::new(), &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new()); + monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &delayed_payment_base_key, &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new()); secrets.clear(); secrets.push([0; 32]); @@ -1369,7 +1379,7 @@ mod tests { { // insert_secret #1 incorrect - monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &PublicKey::new(), &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new()); + monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &delayed_payment_base_key, &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new()); secrets.clear(); secrets.push([0; 32]); @@ -1385,7 +1395,7 @@ mod tests { { // insert_secret #2 incorrect (#1 derived from incorrect) - monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &PublicKey::new(), &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new()); + monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &delayed_payment_base_key, &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new()); secrets.clear(); secrets.push([0; 32]); @@ -1411,7 +1421,7 @@ mod tests { { // insert_secret #3 incorrect - monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &PublicKey::new(), &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new()); + monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &delayed_payment_base_key, &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new()); secrets.clear(); secrets.push([0; 32]); @@ -1437,7 +1447,7 @@ mod tests { { // insert_secret #4 incorrect (1,2,3 derived from incorrect) - monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &PublicKey::new(), &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new()); + monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &delayed_payment_base_key, &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new()); secrets.clear(); secrets.push([0; 32]); @@ -1483,7 +1493,7 @@ mod tests { { // insert_secret #5 incorrect - monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &PublicKey::new(), &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new()); + monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &delayed_payment_base_key, &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new()); secrets.clear(); secrets.push([0; 32]); @@ -1519,7 +1529,7 @@ mod tests { { // insert_secret #6 incorrect (5 derived from incorrect) - monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &PublicKey::new(), &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new()); + monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &delayed_payment_base_key, &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new()); secrets.clear(); secrets.push([0; 32]); @@ -1565,7 +1575,7 @@ mod tests { { // insert_secret #7 incorrect - monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &PublicKey::new(), &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new()); + monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &delayed_payment_base_key, &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new()); secrets.clear(); secrets.push([0; 32]); @@ -1611,7 +1621,7 @@ mod tests { { // insert_secret #8 incorrect - monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &PublicKey::new(), &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new()); + monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &delayed_payment_base_key, &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new()); secrets.clear(); secrets.push([0; 32]); @@ -1663,13 +1673,16 @@ mod tests { macro_rules! dummy_keys { () => { - TxCreationKeys { - per_commitment_point: PublicKey::new(), - revocation_key: PublicKey::new(), - a_htlc_key: PublicKey::new(), - b_htlc_key: PublicKey::new(), - a_delayed_payment_key: PublicKey::new(), - b_payment_key: PublicKey::new(), + { + let dummy_key = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap()); + TxCreationKeys { + per_commitment_point: dummy_key.clone(), + revocation_key: dummy_key.clone(), + a_htlc_key: dummy_key.clone(), + b_htlc_key: dummy_key.clone(), + a_delayed_payment_key: dummy_key.clone(), + b_payment_key: dummy_key.clone(), + } } } } @@ -1726,7 +1739,8 @@ mod tests { // Prune with one old state and a local commitment tx holding a few overlaps with the // old state. - let mut monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &PublicKey::new(), &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new()); + let delayed_payment_base_key = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap()); + let mut monitor = ChannelMonitor::new(&SecretKey::from_slice(&secp_ctx, &[42; 32]).unwrap(), &delayed_payment_base_key, &SecretKey::from_slice(&secp_ctx, &[43; 32]).unwrap(), 0, Script::new()); monitor.set_their_to_self_delay(10); monitor.provide_latest_local_commitment_tx_info(dummy_tx.clone(), dummy_keys!(), 0, preimages_to_local_htlcs!(preimages[0..10])); diff --git a/src/ln/msgs.rs b/src/ln/msgs.rs index 14c16e94b..5d4767721 100644 --- a/src/ln/msgs.rs +++ b/src/ln/msgs.rs @@ -1658,7 +1658,7 @@ mod tests { fn encoding_channel_reestablish_no_secret() { let public_key = { let secp_ctx = Secp256k1::new(); - PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap()).unwrap() + PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap()) }; let cr = msgs::ChannelReestablish { @@ -1680,7 +1680,7 @@ mod tests { fn encoding_channel_reestablish_with_secret() { let public_key = { let secp_ctx = Secp256k1::new(); - PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap()).unwrap() + PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap()) }; let cr = msgs::ChannelReestablish { diff --git a/src/ln/peer_channel_encryptor.rs b/src/ln/peer_channel_encryptor.rs index d0faeabee..6a2033e45 100644 --- a/src/ln/peer_channel_encryptor.rs +++ b/src/ln/peer_channel_encryptor.rs @@ -4,6 +4,7 @@ use ln::msgs; use secp256k1::Secp256k1; use secp256k1::key::{PublicKey,SecretKey}; use secp256k1::ecdh::SharedSecret; +use secp256k1; use crypto::digest::Digest; use crypto::hkdf::{hkdf_extract,hkdf_expand}; @@ -65,7 +66,7 @@ enum NoiseState { } pub struct PeerChannelEncryptor { - secp_ctx: Secp256k1, + secp_ctx: Secp256k1, their_node_id: Option, // filled in for outbound, or inbound after noise_state is Finished noise_state: NoiseState, @@ -76,7 +77,7 @@ impl PeerChannelEncryptor { let mut key = [0u8; 32]; rng::fill_bytes(&mut key); - let secp_ctx = Secp256k1::new(); + let secp_ctx = Secp256k1::signing_only(); let sec_key = SecretKey::from_slice(&secp_ctx, &key).unwrap(); //TODO: nicer rng-is-bad error message let mut sha = Sha256::new(); @@ -102,11 +103,11 @@ impl PeerChannelEncryptor { } pub fn new_inbound(our_node_secret: &SecretKey) -> PeerChannelEncryptor { - let secp_ctx = Secp256k1::new(); + let secp_ctx = Secp256k1::signing_only(); let mut sha = Sha256::new(); sha.input(&NOISE_H); - let our_node_id = PublicKey::from_secret_key(&secp_ctx, our_node_secret).unwrap(); //TODO: nicer bad-node_secret error message + let our_node_id = PublicKey::from_secret_key(&secp_ctx, our_node_secret); sha.input(&our_node_id.serialize()[..]); let mut h = [0; 32]; sha.result(&mut h); @@ -167,8 +168,8 @@ impl PeerChannelEncryptor { } #[inline] - fn outbound_noise_act(secp_ctx: &Secp256k1, state: &mut BidirectionalNoiseState, our_key: &SecretKey, their_key: &PublicKey) -> ([u8; 50], [u8; 32]) { - let our_pub = PublicKey::from_secret_key(secp_ctx, &our_key).unwrap(); //TODO: nicer rng-is-bad error message + fn outbound_noise_act(secp_ctx: &Secp256k1, state: &mut BidirectionalNoiseState, our_key: &SecretKey, their_key: &PublicKey) -> ([u8; 50], [u8; 32]) { + let our_pub = PublicKey::from_secret_key(secp_ctx, &our_key); let mut sha = Sha256::new(); sha.input(&state.h); @@ -191,7 +192,7 @@ impl PeerChannelEncryptor { } #[inline] - fn inbound_noise_act(secp_ctx: &Secp256k1, state: &mut BidirectionalNoiseState, act: &[u8], our_key: &SecretKey) -> Result<(PublicKey, [u8; 32]), HandleError> { + fn inbound_noise_act(secp_ctx: &Secp256k1, state: &mut BidirectionalNoiseState, act: &[u8], our_key: &SecretKey) -> Result<(PublicKey, [u8; 32]), HandleError> { assert_eq!(act.len(), 50); if act[0] != 0 { @@ -294,7 +295,7 @@ impl PeerChannelEncryptor { let (re, temp_k2) = PeerChannelEncryptor::inbound_noise_act(&self.secp_ctx, bidirectional_state, act_two, &ie)?; let mut res = [0; 66]; - let our_node_id = PublicKey::from_secret_key(&self.secp_ctx, &our_node_secret).unwrap(); //TODO: nicer rng-is-bad error message + let our_node_id = PublicKey::from_secret_key(&self.secp_ctx, &our_node_secret); PeerChannelEncryptor::encrypt_with_ad(&mut res[1..50], 1, &temp_k2, &bidirectional_state.h, &our_node_id.serialize()[..]); diff --git a/src/ln/peer_handler.rs b/src/ln/peer_handler.rs index 11064bf98..5e9424243 100644 --- a/src/ln/peer_handler.rs +++ b/src/ln/peer_handler.rs @@ -920,7 +920,7 @@ mod tests { fn establish_connection(peer_a: &PeerManager, peer_b: &PeerManager) { let secp_ctx = Secp256k1::new(); - let their_id = PublicKey::from_secret_key(&secp_ctx, &peer_b.our_node_secret).unwrap(); + let their_id = PublicKey::from_secret_key(&secp_ctx, &peer_b.our_node_secret); let fd = FileDescriptor { fd: 1}; peer_a.new_inbound_connection(fd.clone()).unwrap(); peer_a.peers.lock().unwrap().node_id_to_descriptor.insert(their_id, fd.clone()); @@ -935,7 +935,7 @@ mod tests { assert_eq!(peers[0].peers.lock().unwrap().peers.len(), 1); let secp_ctx = Secp256k1::new(); - let their_id = PublicKey::from_secret_key(&secp_ctx, &peers[1].our_node_secret).unwrap(); + let their_id = PublicKey::from_secret_key(&secp_ctx, &peers[1].our_node_secret); let chan_handler = test_utils::TestChannelMessageHandler::new(); chan_handler.pending_events.lock().unwrap().push(events::Event::HandleError { diff --git a/src/ln/router.rs b/src/ln/router.rs index 0e6194c35..1ca55fa26 100644 --- a/src/ln/router.rs +++ b/src/ln/router.rs @@ -1,5 +1,6 @@ use secp256k1::key::PublicKey; use secp256k1::{Secp256k1,Message}; +use secp256k1; use bitcoin::util::hash::Sha256dHash; @@ -152,7 +153,7 @@ pub struct RouteHint { /// Tracks a view of the network, receiving updates from peers and generating Routes to /// payment destinations. pub struct Router { - secp_ctx: Secp256k1, + secp_ctx: Secp256k1, network_map: RwLock, logger: Arc, } @@ -396,7 +397,7 @@ impl Router { addresses: Vec::new(), }); Router { - secp_ctx: Secp256k1::new(), + secp_ctx: Secp256k1::verification_only(), network_map: RwLock::new(NetworkMap { channels: HashMap::new(), our_node_id: our_pubkey, @@ -645,7 +646,7 @@ mod tests { #[test] fn route_test() { let secp_ctx = Secp256k1::new(); - let our_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap()).unwrap(); + let our_id = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0101010101010101010101010101010101010101010101010101010101010101").unwrap()[..]).unwrap()); let logger: Arc = Arc::new(test_utils::TestLogger::new()); let router = Router::new(our_id, Arc::clone(&logger)); @@ -706,14 +707,14 @@ mod tests { // chan11 1-to-2: enabled, 0 fee // chan11 2-to-1: enabled, 0 fee - let node1 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap()[..]).unwrap()).unwrap(); - let node2 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0303030303030303030303030303030303030303030303030303030303030303").unwrap()[..]).unwrap()).unwrap(); - let node3 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0404040404040404040404040404040404040404040404040404040404040404").unwrap()[..]).unwrap()).unwrap(); - let node4 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0505050505050505050505050505050505050505050505050505050505050505").unwrap()[..]).unwrap()).unwrap(); - let node5 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0606060606060606060606060606060606060606060606060606060606060606").unwrap()[..]).unwrap()).unwrap(); - let node6 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0707070707070707070707070707070707070707070707070707070707070707").unwrap()[..]).unwrap()).unwrap(); - let node7 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0808080808080808080808080808080808080808080808080808080808080808").unwrap()[..]).unwrap()).unwrap(); - let node8 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0909090909090909090909090909090909090909090909090909090909090909").unwrap()[..]).unwrap()).unwrap(); + let node1 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0202020202020202020202020202020202020202020202020202020202020202").unwrap()[..]).unwrap()); + let node2 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0303030303030303030303030303030303030303030303030303030303030303").unwrap()[..]).unwrap()); + let node3 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0404040404040404040404040404040404040404040404040404040404040404").unwrap()[..]).unwrap()); + let node4 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0505050505050505050505050505050505050505050505050505050505050505").unwrap()[..]).unwrap()); + let node5 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0606060606060606060606060606060606060606060606060606060606060606").unwrap()[..]).unwrap()); + let node6 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0707070707070707070707070707070707070707070707070707070707070707").unwrap()[..]).unwrap()); + let node7 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0808080808080808080808080808080808080808080808080808080808080808").unwrap()[..]).unwrap()); + let node8 = PublicKey::from_secret_key(&secp_ctx, &SecretKey::from_slice(&secp_ctx, &hex::decode("0909090909090909090909090909090909090909090909090909090909090909").unwrap()[..]).unwrap()); let zero_hash = Sha256dHash::from_data(&[0; 32]); diff --git a/src/util/transaction_utils.rs b/src/util/transaction_utils.rs index 92bc209ab..33072f605 100644 --- a/src/util/transaction_utils.rs +++ b/src/util/transaction_utils.rs @@ -20,13 +20,13 @@ pub fn sort_outputs(outputs: &mut Vec<(TxOut, T)>) { pub fn sort_inputs(inputs: &mut Vec<(TxIn, T)>) { inputs.sort_unstable_by(|a, b| { - if a.0.prev_hash.into_le() < b.0.prev_hash.into_le() { - Ordering::Less - } else if b.0.prev_hash.into_le() < a.0.prev_hash.into_le() { + if a.0.previous_output.txid.into_le() < b.0.previous_output.txid.into_le() { + Ordering::Less + } else if b.0.previous_output.txid.into_le() < a.0.previous_output.txid.into_le() { Ordering::Greater - } else if a.0.prev_index < b.0.prev_index { + } else if a.0.previous_output.vout < b.0.previous_output.vout { Ordering::Less - } else if b.0.prev_index < a.0.prev_index { + } else if b.0.previous_output.vout < a.0.previous_output.vout { Ordering::Greater } else { Ordering::Equal @@ -39,7 +39,7 @@ mod tests { use super::*; use bitcoin::blockdata::script::{Script, Builder}; - use bitcoin::blockdata::transaction::TxOut; + use bitcoin::blockdata::transaction::{TxOut, OutPoint}; use bitcoin::util::hash::Sha256dHash; use hex::decode; @@ -161,8 +161,10 @@ mod tests { let expected_raw: Vec<(&str, u32)> = $value; let expected: Vec<(TxIn, &str)> = expected_raw.iter().map( |txin_raw| TxIn { - prev_hash: Sha256dHash::from_hex(txin_raw.0).unwrap(), - prev_index: txin_raw.1, + previous_output: OutPoint { + txid: Sha256dHash::from_hex(txin_raw.0).unwrap(), + vout: txin_raw.1, + }, script_sig: Script::new(), sequence: 0, witness: vec![]