Skip to content

Implement and document Channel/ChannelManager (de)serialization #223

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
28 commits
Select commit Hold shift + click to select a range
8c235d9
Generate Events from ChannelMonitor to indicate spendable ouputs
Oct 19, 2018
d33cb3c
Add a KeysInterface which provides keys from user
Oct 26, 2018
6d5dc6c
Implement KeysInterface for KeysManager util
Oct 26, 2018
e361fed
Integrate KeysInterface to ChannelManager with Arc
Oct 26, 2018
32a9378
Integrate shutdown_pubkey from KeysInterface in ChannelManager/Channel
Oct 26, 2018
5180686
Integrate destination_script from KeysInterface in ChannelManager/Cha…
Oct 26, 2018
e397cb9
Split Event, move MessageSendEvent push() inside channel_state lock
TheBlueMatt Oct 19, 2018
608d517
Send AcceptChannel responses out-of-band to ensure ordered delivery
TheBlueMatt Oct 19, 2018
c962a27
Send funding_signed messages out-of-band to ensure ordered delivery
TheBlueMatt Oct 19, 2018
e382a7b
Send announcement_signatures msgs out-of-band for ordered delivery
TheBlueMatt Oct 19, 2018
812f255
Send shutdown/closing_signed msgs out-of-band for ordered delivery
TheBlueMatt Oct 20, 2018
4342114
Send RAA/CS messages out-of-band to ensure ordered delivery
TheBlueMatt Oct 20, 2018
e2de49d
Respond to channel_reestablish out-of-band for ordered delivery
TheBlueMatt Oct 20, 2018
249aa77
Send channel_reestablish out-of-band to ensure ordered deliver
TheBlueMatt Oct 20, 2018
294ad32
Avoid reentrancy of send_data from PeerHandler::read_bytes.
TheBlueMatt Oct 20, 2018
c0c139c
Fix and test update_add_htlc but disconnect pre-commitment_signed
TheBlueMatt Oct 20, 2018
bb43b98
Store [u8; 32]s instead of SharedSecrets (for deserialization)
TheBlueMatt Oct 18, 2018
062a02d
Add a second Readable trait for state args, clean macros slightly
TheBlueMatt Oct 18, 2018
47fe673
Give ChannelMonitor a logger via new ReadableArgs trait
TheBlueMatt Oct 18, 2018
74cec62
Add a BIG lock to ChannelManager
TheBlueMatt Oct 20, 2018
4eafd37
impl Readable/Writable for Route
TheBlueMatt Oct 19, 2018
f049011
impl some additional (de)serializers, including a u48 wrapper type
TheBlueMatt Oct 24, 2018
612e280
Redo ChannelMonitor deserialization to avoid read_to_end()
TheBlueMatt Oct 24, 2018
56513f2
Track last_block_hash in ChannelMonitor and expose it on deser
TheBlueMatt Oct 24, 2018
6f08779
Track ChannelMonitor-watched-outpoints (+ remove now-uesless Mutex)
TheBlueMatt Oct 24, 2018
b2bd64d
Store+expose bits of Channel[Monitor] to figure out local state
TheBlueMatt Oct 25, 2018
a2fb3cc
Implement and document Channel/ChannelManager (de)serialization
TheBlueMatt Oct 26, 2018
7f91572
Add very basic test of ChannelManager serialization round-trip
TheBlueMatt Oct 26, 2018
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
16 changes: 13 additions & 3 deletions fuzz/fuzz_targets/chanmon_deser_target.rs
Original file line number Diff line number Diff line change
@@ -1,13 +1,20 @@
// This file is auto-generated by gen_target.sh based on msg_target_template.txt
// To modify it, modify msg_target_template.txt and run gen_target.sh instead.

extern crate bitcoin;
extern crate lightning;

use bitcoin::util::hash::Sha256dHash;

use lightning::ln::channelmonitor;
use lightning::util::reset_rng_state;
use lightning::util::ser::{Readable, Writer};
use lightning::util::ser::{ReadableArgs, Writer};

mod utils;
use utils::test_logger;

use std::io::Cursor;
use std::sync::Arc;

struct VecWriter(Vec<u8>);
impl Writer for VecWriter {
Expand All @@ -23,10 +30,13 @@ impl Writer for VecWriter {
#[inline]
pub fn do_test(data: &[u8]) {
reset_rng_state();
if let Ok(monitor) = channelmonitor::ChannelMonitor::read(&mut Cursor::new(data)) {
let logger = Arc::new(test_logger::TestLogger{});
if let Ok((latest_block_hash, monitor)) = <(Sha256dHash, channelmonitor::ChannelMonitor)>::read(&mut Cursor::new(data), logger.clone()) {
let mut w = VecWriter(Vec::new());
monitor.write_for_disk(&mut w).unwrap();
assert!(channelmonitor::ChannelMonitor::read(&mut Cursor::new(&w.0)).unwrap() == monitor);
let deserialized_copy = <(Sha256dHash, channelmonitor::ChannelMonitor)>::read(&mut Cursor::new(&w.0), logger.clone()).unwrap();
assert!(latest_block_hash == deserialized_copy.0);
assert!(monitor == deserialized_copy.1);
w.0.clear();
monitor.write_for_watchtower(&mut w).unwrap();
}
Expand Down
68 changes: 57 additions & 11 deletions fuzz/fuzz_targets/full_stack_target.rs

Large diffs are not rendered by default.

202 changes: 202 additions & 0 deletions src/chain/keysinterface.rs
Original file line number Diff line number Diff line change
@@ -0,0 +1,202 @@
//! keysinterface provides keys into rust-lightning and defines some useful enums which describe
//! spendable on-chain outputs which the user owns and is responsible for using just as any other
//! on-chain output which is theirs.

use bitcoin::blockdata::transaction::{OutPoint, TxOut};
use bitcoin::blockdata::script::{Script, Builder};
use bitcoin::blockdata::opcodes;
use bitcoin::network::constants::Network;
use bitcoin::util::hash::Hash160;
use bitcoin::util::bip32::{ExtendedPrivKey, ExtendedPubKey, ChildNumber};

use secp256k1::key::{SecretKey, PublicKey};
use secp256k1::Secp256k1;
use secp256k1;

use crypto::hkdf::{hkdf_extract,hkdf_expand};

use util::sha2::Sha256;
use util::logger::Logger;

use std::sync::Arc;

/// When on-chain outputs are created by rust-lightning an event is generated which informs the
/// user thereof. This enum describes the format of the output and provides the OutPoint.
pub enum SpendableOutputDescriptor {
/// Outpoint with an output to a script which was provided via KeysInterface, thus you should
/// have stored somewhere how to spend script_pubkey!
/// Outputs from a justice tx, claim tx or preimage tx
StaticOutput {
/// The outpoint spendable by user wallet
outpoint: OutPoint,
/// The output which is referenced by the given outpoint
output: TxOut,
},
/// Outpoint commits to a P2WSH, should be spend by the following witness :
/// <local_delayedsig> 0 <witnessScript>
/// With input nSequence set to_self_delay.
/// Outputs from a HTLC-Success/Timeout tx
DynamicOutput {
/// Outpoint spendable by user wallet
outpoint: OutPoint,
/// local_delayedkey = delayed_payment_basepoint_secret + SHA256(per_commitment_point || delayed_payment_basepoint
local_delayedkey: SecretKey,
/// witness redeemScript encumbering output
witness_script: Script,
/// nSequence input must commit to self_delay to satisfy script's OP_CSV
to_self_delay: u16,
}
}

/// A trait to describe an object which can get user secrets and key material.
pub trait KeysInterface: Send + Sync {
/// Get node secret key (aka node_id or network_key)
fn get_node_secret(&self) -> SecretKey;
/// Get destination redeemScript to encumber static protocol exit points.
fn get_destination_script(&self) -> Script;
/// Get shutdown_pubkey to use as PublicKey at channel closure
fn get_shutdown_pubkey(&self) -> PublicKey;
/// Get a new set of ChannelKeys for per-channel secrets. These MUST be unique even if you
/// restarted with some stale data!
fn get_channel_keys(&self, inbound: bool) -> ChannelKeys;
}

/// Set of lightning keys needed to operate a channel as described in BOLT 3
#[derive(Clone)]
pub struct ChannelKeys {
/// Private key of anchor tx
pub funding_key: SecretKey,
/// Local secret key for blinded revocation pubkey
pub revocation_base_key: SecretKey,
/// Local secret key used in commitment tx htlc outputs
pub payment_base_key: SecretKey,
/// Local secret key used in HTLC tx
pub delayed_payment_base_key: SecretKey,
/// Local htlc secret key used in commitment tx htlc outputs
pub htlc_base_key: SecretKey,
/// Commitment seed
pub commitment_seed: [u8; 32],
}

impl_writeable!(ChannelKeys, 0, {
funding_key,
revocation_base_key,
payment_base_key,
delayed_payment_base_key,
htlc_base_key,
commitment_seed
});

impl ChannelKeys {
/// Generate a set of lightning keys needed to operate a channel by HKDF-expanding a given
/// random 32-byte seed
pub fn new_from_seed(seed: &[u8; 32]) -> ChannelKeys {
let mut prk = [0; 32];
hkdf_extract(Sha256::new(), b"rust-lightning key gen salt", seed, &mut prk);
let secp_ctx = Secp256k1::without_caps();

let mut okm = [0; 32];
hkdf_expand(Sha256::new(), &prk, b"rust-lightning funding key info", &mut okm);
let funding_key = SecretKey::from_slice(&secp_ctx, &okm).expect("Sha256 is broken");

hkdf_expand(Sha256::new(), &prk, b"rust-lightning revocation base key info", &mut okm);
let revocation_base_key = SecretKey::from_slice(&secp_ctx, &okm).expect("Sha256 is broken");

hkdf_expand(Sha256::new(), &prk, b"rust-lightning payment base key info", &mut okm);
let payment_base_key = SecretKey::from_slice(&secp_ctx, &okm).expect("Sha256 is broken");

hkdf_expand(Sha256::new(), &prk, b"rust-lightning delayed payment base key info", &mut okm);
let delayed_payment_base_key = SecretKey::from_slice(&secp_ctx, &okm).expect("Sha256 is broken");

hkdf_expand(Sha256::new(), &prk, b"rust-lightning htlc base key info", &mut okm);
let htlc_base_key = SecretKey::from_slice(&secp_ctx, &okm).expect("Sha256 is broken");

hkdf_expand(Sha256::new(), &prk, b"rust-lightning local commitment seed info", &mut okm);

ChannelKeys {
funding_key: funding_key,
revocation_base_key: revocation_base_key,
payment_base_key: payment_base_key,
delayed_payment_base_key: delayed_payment_base_key,
htlc_base_key: htlc_base_key,
commitment_seed: okm
}
}
}

/// Simple KeysInterface implementor that takes a 32-byte seed for use as a BIP 32 extended key
/// and derives keys from that.
///
/// Your node_id is seed/0'
/// ChannelMonitor closes may use seed/1'
/// Cooperative closes may use seed/2'
/// The two close keys may be needed to claim on-chain funds!
pub struct KeysManager {
secp_ctx: Secp256k1<secp256k1::All>,
node_secret: SecretKey,
destination_script: Script,
shutdown_pubkey: PublicKey,
channel_master_key: ExtendedPrivKey,

logger: Arc<Logger>,
}

impl KeysManager {
/// Constructs a KeysManager from a 32-byte seed. If the seed is in some way biased (eg your
/// RNG is busted) this may panic.
pub fn new(seed: &[u8; 32], network: Network, logger: Arc<Logger>) -> KeysManager {
let secp_ctx = Secp256k1::new();
match ExtendedPrivKey::new_master(&secp_ctx, network.clone(), seed) {
Ok(master_key) => {
let node_secret = master_key.ckd_priv(&secp_ctx, ChildNumber::from_hardened_idx(0)).expect("Your RNG is busted").secret_key;
let destination_script = match master_key.ckd_priv(&secp_ctx, ChildNumber::from_hardened_idx(1)) {
Ok(destination_key) => {
let pubkey_hash160 = Hash160::from_data(&ExtendedPubKey::from_private(&secp_ctx, &destination_key).public_key.serialize()[..]);
Builder::new().push_opcode(opcodes::All::OP_PUSHBYTES_0)
.push_slice(pubkey_hash160.as_bytes())
.into_script()
},
Err(_) => panic!("Your RNG is busted"),
};
let shutdown_pubkey = match master_key.ckd_priv(&secp_ctx, ChildNumber::from_hardened_idx(2)) {
Ok(shutdown_key) => ExtendedPubKey::from_private(&secp_ctx, &shutdown_key).public_key,
Err(_) => panic!("Your RNG is busted"),
};
let channel_master_key = master_key.ckd_priv(&secp_ctx, ChildNumber::from_hardened_idx(3)).expect("Your RNG is busted");
KeysManager {
secp_ctx,
node_secret,
destination_script,
shutdown_pubkey,
channel_master_key,

logger,
}
},
Err(_) => panic!("Your rng is busted"),
}
}
}

impl KeysInterface for KeysManager {
fn get_node_secret(&self) -> SecretKey {
self.node_secret.clone()
}

fn get_destination_script(&self) -> Script {
self.destination_script.clone()
}

fn get_shutdown_pubkey(&self) -> PublicKey {
self.shutdown_pubkey.clone()
}

fn get_channel_keys(&self, _inbound: bool) -> ChannelKeys {
let channel_pubkey = ExtendedPubKey::from_private(&self.secp_ctx, &self. channel_master_key);
let mut seed = [0; 32];
for (arr, slice) in seed.iter_mut().zip((&channel_pubkey.public_key.serialize()[0..32]).iter()) {
*arr = *slice;
}
ChannelKeys::new_from_seed(&seed)
}
}
1 change: 1 addition & 0 deletions src/chain/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -2,3 +2,4 @@

pub mod chaininterface;
pub mod transaction;
pub mod keysinterface;
Loading