output: TxOut,
},
/// An output to a P2WSH script which can be spent with a single signature after a CSV delay.
- /// The private key which should be used to sign the transaction is provided, as well as the
- /// full witness redeemScript which is hashed in the output script_pubkey.
+ ///
/// The witness in the spending input should be:
- /// <BIP 143 signature generated with the given key> <empty vector> (MINIMALIF standard rule)
- /// <witness_script as provided>
- /// Note that the nSequence field in the input must be set to_self_delay (which corresponds to
- /// the transaction not being broadcastable until at least to_self_delay blocks after the input
- /// confirms).
+ /// <BIP 143 signature> <empty vector> (MINIMALIF standard rule) <provided witnessScript>
+ ///
+ /// Note that the nSequence field in the spending input must be set to to_self_delay
+ /// (which means the transaction is not broadcastable until at least to_self_delay
+ /// blocks after the outpoint confirms).
+ ///
/// These are generally the result of a "revocable" output to us, spendable only by us unless
- /// it is an output from us having broadcast an old state (which should never happen).
+ /// it is an output from an old state which we broadcast (which should never happen).
+ ///
+ /// To derive the delayed_payment key which is used to sign for this input, you must pass the
+ /// local delayed_payment_base_key (ie the private key which corresponds to the pubkey in
+ /// ChannelKeys::pubkeys().delayed_payment_basepoint) and the provided per_commitment_point to
+ /// chan_utils::derive_private_key. The public key can be generated without the secret key
+ /// using chan_utils::derive_public_key and only the delayed_payment_basepoint which appears in
+ /// ChannelKeys::pubkeys().
+ ///
+ /// To derive the remote_revocation_pubkey provided here (which is used in the witness
+ /// script generation), you must pass the remote revocation_basepoint (which appears in the
+ /// call to ChannelKeys::set_remote_channel_pubkeys) and the provided per_commitment point
+ /// to chan_utils::derive_public_revocation_key.
+ ///
+ /// The witness script which is hashed and included in the output script_pubkey may be
+ /// regenerated by passing the revocation_pubkey (derived as above), our delayed_payment pubkey
+ /// (derived as above), and the to_self_delay contained here to
+ /// chan_utils::get_revokeable_redeemscript.
+ //
+ // TODO: we need to expose utility methods in KeyManager to do all the relevant derivation.
DynamicOutputP2WSH {
/// The outpoint which is spendable
outpoint: OutPoint,
- /// The secret key which must be used to sign the spending transaction
- key: SecretKey,
- /// The witness redeemScript which is hashed to create the script_pubkey in the given output
- witness_script: Script,
+ /// Per commitment point to derive delayed_payment_key by key holder
+ per_commitment_point: PublicKey,
/// The nSequence value which must be set in the spending input to satisfy the OP_CSV in
/// the witness_script.
to_self_delay: u16,
/// The output which is referenced by the given outpoint
output: TxOut,
+ /// The channel keys state used to proceed to derivation of signing key. Must
+ /// be pass to KeysInterface::derive_channel_keys.
+ key_derivation_params: (u64, u64),
+ /// The remote_revocation_pubkey used to derive witnessScript
+ remote_revocation_pubkey: PublicKey
},
- // TODO: Note that because key is now static and exactly what is provided by us, we should drop
- // this in favor of StaticOutput:
- /// An output to a P2WPKH, spendable exclusively by the given private key.
+ /// An output to a P2WPKH, spendable exclusively by our payment key (ie the private key which
+ /// corresponds to the public key in ChannelKeys::pubkeys().payment_point).
/// The witness in the spending input, is, thus, simply:
- /// <BIP 143 signature generated with the given key> <public key derived from the given key>
+ /// <BIP 143 signature> <payment key>
+ ///
/// These are generally the result of our counterparty having broadcast the current state,
/// allowing us to claim the non-HTLC-encumbered outputs immediately.
- DynamicOutputP2WPKH {
+ StaticOutputRemotePayment {
/// The outpoint which is spendable
outpoint: OutPoint,
- /// The secret key which must be used to sign the spending transaction
- key: SecretKey,
/// The output which is reference by the given outpoint
output: TxOut,
+ /// The channel keys state used to proceed to derivation of signing key. Must
+ /// be pass to KeysInterface::derive_channel_keys.
+ key_derivation_params: (u64, u64),
}
}
outpoint.write(writer)?;
output.write(writer)?;
},
- &SpendableOutputDescriptor::DynamicOutputP2WSH { ref outpoint, ref key, ref witness_script, ref to_self_delay, ref output } => {
+ &SpendableOutputDescriptor::DynamicOutputP2WSH { ref outpoint, ref per_commitment_point, ref to_self_delay, ref output, ref key_derivation_params, ref remote_revocation_pubkey } => {
1u8.write(writer)?;
outpoint.write(writer)?;
- key.write(writer)?;
- witness_script.write(writer)?;
+ per_commitment_point.write(writer)?;
to_self_delay.write(writer)?;
output.write(writer)?;
+ key_derivation_params.0.write(writer)?;
+ key_derivation_params.1.write(writer)?;
+ remote_revocation_pubkey.write(writer)?;
},
- &SpendableOutputDescriptor::DynamicOutputP2WPKH { ref outpoint, ref key, ref output } => {
+ &SpendableOutputDescriptor::StaticOutputRemotePayment { ref outpoint, ref output, ref key_derivation_params } => {
2u8.write(writer)?;
outpoint.write(writer)?;
- key.write(writer)?;
output.write(writer)?;
+ key_derivation_params.0.write(writer)?;
+ key_derivation_params.1.write(writer)?;
},
}
Ok(())
}),
1u8 => Ok(SpendableOutputDescriptor::DynamicOutputP2WSH {
outpoint: Readable::read(reader)?,
- key: Readable::read(reader)?,
- witness_script: Readable::read(reader)?,
+ per_commitment_point: Readable::read(reader)?,
to_self_delay: Readable::read(reader)?,
output: Readable::read(reader)?,
+ key_derivation_params: (Readable::read(reader)?, Readable::read(reader)?),
+ remote_revocation_pubkey: Readable::read(reader)?,
}),
- 2u8 => Ok(SpendableOutputDescriptor::DynamicOutputP2WPKH {
+ 2u8 => Ok(SpendableOutputDescriptor::StaticOutputRemotePayment {
outpoint: Readable::read(reader)?,
- key: Readable::read(reader)?,
output: Readable::read(reader)?,
+ key_derivation_params: (Readable::read(reader)?, Readable::read(reader)?),
}),
_ => Err(DecodeError::InvalidValue),
}
fn commitment_seed<'a>(&'a self) -> &'a [u8; 32];
/// Gets the local channel public keys and basepoints
fn pubkeys<'a>(&'a self) -> &'a ChannelPublicKeys;
+ /// Gets arbitrary identifiers describing the set of keys which are provided back to you in
+ /// some SpendableOutputDescriptor types. These should be sufficient to identify this
+ /// ChannelKeys object uniquely and lookup or re-derive its keys.
+ fn key_derivation_params(&self) -> (u64, u64);
/// Create a signature for a remote commitment transaction and associated HTLC transactions.
///
/// return value must contain a signature.
fn sign_local_commitment_htlc_transactions<T: secp256k1::Signing + secp256k1::Verification>(&self, local_commitment_tx: &LocalCommitmentTransaction, local_csv: u16, secp_ctx: &Secp256k1<T>) -> Result<Vec<Option<Signature>>, ()>;
+ /// Create a signature for the given input in a transaction spending an HTLC or commitment
+ /// transaction output when our counterparty broadcasts an old state.
+ ///
+ /// A justice transaction may claim multiples outputs at the same time if timelocks are
+ /// similar, but only a signature for the input at index `input` should be signed for here.
+ /// It may be called multiples time for same output(s) if a fee-bump is needed with regards
+ /// to an upcoming timelock expiration.
+ ///
+ /// Amount is value of the output spent by this input, committed to in the BIP 143 signature.
+ ///
+ /// per_commitment_key is revocation secret which was provided by our counterparty when they
+ /// revoked the state which they eventually broadcast. It's not a _local_ secret key and does
+ /// not allow the spending of any funds by itself (you need our local revocation_secret to do
+ /// so).
+ ///
+ /// htlc holds HTLC elements (hash, timelock) if the output being spent is a HTLC output, thus
+ /// changing the format of the witness script (which is committed to in the BIP 143
+ /// signatures).
+ ///
+ /// on_remote_tx_csv is the relative lock-time that that our counterparty would have to set on
+ /// their transaction were they to spend the same output. It is included in the witness script
+ /// and thus committed to in the BIP 143 signature.
+ fn sign_justice_transaction<T: secp256k1::Signing + secp256k1::Verification>(&self, justice_tx: &Transaction, input: usize, amount: u64, per_commitment_key: &SecretKey, htlc: &Option<HTLCOutputInCommitment>, on_remote_tx_csv: u16, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()>;
+
+ /// Create a signature for a claiming transaction for a HTLC output on a remote commitment
+ /// transaction, either offered or received.
+ ///
+ /// Such a transaction may claim multiples offered outputs at same time if we know the
+ /// preimage for each when we create it, but only the input at index `input` should be
+ /// signed for here. It may be called multiple times for same output(s) if a fee-bump is
+ /// needed with regards to an upcoming timelock expiration.
+ ///
+ /// Witness_script is either a offered or received script as defined in BOLT3 for HTLC
+ /// outputs.
+ ///
+ /// Amount is value of the output spent by this input, committed to in the BIP 143 signature.
+ ///
+ /// Per_commitment_point is the dynamic point corresponding to the channel state
+ /// detected onchain. It has been generated by our counterparty and is used to derive
+ /// channel state keys, which are then included in the witness script and committed to in the
+ /// BIP 143 signature.
+ fn sign_remote_htlc_transaction<T: secp256k1::Signing + secp256k1::Verification>(&self, htlc_tx: &Transaction, input: usize, amount: u64, per_commitment_point: &PublicKey, htlc: &HTLCOutputInCommitment, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()>;
+
/// Create a signature for a (proposed) closing transaction.
///
/// Note that, due to rounding, there may be one "missing" satoshi, and either party may have
pub(crate) remote_channel_pubkeys: Option<ChannelPublicKeys>,
/// The total value of this channel
channel_value_satoshis: u64,
+ /// Key derivation parameters
+ key_derivation_params: (u64, u64),
}
impl InMemoryChannelKeys {
delayed_payment_base_key: SecretKey,
htlc_base_key: SecretKey,
commitment_seed: [u8; 32],
- channel_value_satoshis: u64) -> InMemoryChannelKeys {
+ channel_value_satoshis: u64,
+ key_derivation_params: (u64, u64)) -> InMemoryChannelKeys {
let local_channel_pubkeys =
InMemoryChannelKeys::make_local_keys(secp_ctx, &funding_key, &revocation_base_key,
&payment_key, &delayed_payment_base_key,
channel_value_satoshis,
local_channel_pubkeys,
remote_channel_pubkeys: None,
+ key_derivation_params,
}
}
htlc_basepoint: from_secret(&htlc_base_key),
}
}
+
+ fn remote_pubkeys<'a>(&'a self) -> &'a ChannelPublicKeys { self.remote_channel_pubkeys.as_ref().unwrap() }
}
impl ChannelKeys for InMemoryChannelKeys {
fn htlc_base_key(&self) -> &SecretKey { &self.htlc_base_key }
fn commitment_seed(&self) -> &[u8; 32] { &self.commitment_seed }
fn pubkeys<'a>(&'a self) -> &'a ChannelPublicKeys { &self.local_channel_pubkeys }
+ fn key_derivation_params(&self) -> (u64, u64) { self.key_derivation_params }
fn sign_remote_commitment<T: secp256k1::Signing + secp256k1::Verification>(&self, feerate_per_kw: u64, commitment_tx: &Transaction, keys: &TxCreationKeys, htlcs: &[&HTLCOutputInCommitment], to_self_delay: u16, secp_ctx: &Secp256k1<T>) -> Result<(Signature, Vec<Signature>), ()> {
if commitment_tx.input.len() != 1 { return Err(()); }
local_commitment_tx.get_htlc_sigs(&self.htlc_base_key, local_csv, secp_ctx)
}
+ fn sign_justice_transaction<T: secp256k1::Signing + secp256k1::Verification>(&self, justice_tx: &Transaction, input: usize, amount: u64, per_commitment_key: &SecretKey, htlc: &Option<HTLCOutputInCommitment>, on_remote_tx_csv: u16, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()> {
+ let revocation_key = match chan_utils::derive_private_revocation_key(&secp_ctx, &per_commitment_key, &self.revocation_base_key) {
+ Ok(revocation_key) => revocation_key,
+ Err(_) => return Err(())
+ };
+ let per_commitment_point = PublicKey::from_secret_key(secp_ctx, &per_commitment_key);
+ let revocation_pubkey = match chan_utils::derive_public_revocation_key(&secp_ctx, &per_commitment_point, &self.pubkeys().revocation_basepoint) {
+ Ok(revocation_pubkey) => revocation_pubkey,
+ Err(_) => return Err(())
+ };
+ let witness_script = if let &Some(ref htlc) = htlc {
+ let remote_htlcpubkey = match chan_utils::derive_public_key(&secp_ctx, &per_commitment_point, &self.remote_pubkeys().htlc_basepoint) {
+ Ok(remote_htlcpubkey) => remote_htlcpubkey,
+ Err(_) => return Err(())
+ };
+ let local_htlcpubkey = match chan_utils::derive_public_key(&secp_ctx, &per_commitment_point, &self.pubkeys().htlc_basepoint) {
+ Ok(local_htlcpubkey) => local_htlcpubkey,
+ Err(_) => return Err(())
+ };
+ chan_utils::get_htlc_redeemscript_with_explicit_keys(&htlc, &remote_htlcpubkey, &local_htlcpubkey, &revocation_pubkey)
+ } else {
+ let remote_delayedpubkey = match chan_utils::derive_public_key(&secp_ctx, &per_commitment_point, &self.remote_pubkeys().delayed_payment_basepoint) {
+ Ok(remote_delayedpubkey) => remote_delayedpubkey,
+ Err(_) => return Err(())
+ };
+ chan_utils::get_revokeable_redeemscript(&revocation_pubkey, on_remote_tx_csv, &remote_delayedpubkey)
+ };
+ let sighash_parts = bip143::SighashComponents::new(&justice_tx);
+ let sighash = hash_to_message!(&sighash_parts.sighash_all(&justice_tx.input[input], &witness_script, amount)[..]);
+ return Ok(secp_ctx.sign(&sighash, &revocation_key))
+ }
+
+ fn sign_remote_htlc_transaction<T: secp256k1::Signing + secp256k1::Verification>(&self, htlc_tx: &Transaction, input: usize, amount: u64, per_commitment_point: &PublicKey, htlc: &HTLCOutputInCommitment, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()> {
+ if let Ok(htlc_key) = chan_utils::derive_private_key(&secp_ctx, &per_commitment_point, &self.htlc_base_key) {
+ let witness_script = if let Ok(revocation_pubkey) = chan_utils::derive_public_revocation_key(&secp_ctx, &per_commitment_point, &self.pubkeys().revocation_basepoint) {
+ if let Ok(remote_htlcpubkey) = chan_utils::derive_public_key(&secp_ctx, &per_commitment_point, &self.remote_pubkeys().htlc_basepoint) {
+ if let Ok(local_htlcpubkey) = chan_utils::derive_public_key(&secp_ctx, &per_commitment_point, &self.pubkeys().htlc_basepoint) {
+ chan_utils::get_htlc_redeemscript_with_explicit_keys(&htlc, &remote_htlcpubkey, &local_htlcpubkey, &revocation_pubkey)
+ } else { return Err(()) }
+ } else { return Err(()) }
+ } else { return Err(()) };
+ let sighash_parts = bip143::SighashComponents::new(&htlc_tx);
+ let sighash = hash_to_message!(&sighash_parts.sighash_all(&htlc_tx.input[input], &witness_script, amount)[..]);
+ return Ok(secp_ctx.sign(&sighash, &htlc_key))
+ }
+ Err(())
+ }
+
fn sign_closing_transaction<T: secp256k1::Signing>(&self, closing_tx: &Transaction, secp_ctx: &Secp256k1<T>) -> Result<Signature, ()> {
if closing_tx.input.len() != 1 { return Err(()); }
if closing_tx.input[0].witness.len() != 0 { return Err(()); }
self.commitment_seed.write(writer)?;
self.remote_channel_pubkeys.write(writer)?;
self.channel_value_satoshis.write(writer)?;
+ self.key_derivation_params.0.write(writer)?;
+ self.key_derivation_params.1.write(writer)?;
Ok(())
}
InMemoryChannelKeys::make_local_keys(&secp_ctx, &funding_key, &revocation_base_key,
&payment_key, &delayed_payment_base_key,
&htlc_base_key);
+ let params_1 = Readable::read(reader)?;
+ let params_2 = Readable::read(reader)?;
Ok(InMemoryChannelKeys {
funding_key,
commitment_seed,
channel_value_satoshis,
local_channel_pubkeys,
- remote_channel_pubkeys
+ remote_channel_pubkeys,
+ key_derivation_params: (params_1, params_2),
})
}
}
channel_id_master_key: ExtendedPrivKey,
channel_id_child_index: AtomicUsize,
- unique_start: Sha256State,
+ seed: [u8; 32],
+ starting_time_secs: u64,
+ starting_time_nanos: u32,
}
impl KeysManager {
let session_master_key = master_key.ckd_priv(&secp_ctx, ChildNumber::from_hardened_idx(4).unwrap()).expect("Your RNG is busted");
let channel_id_master_key = master_key.ckd_priv(&secp_ctx, ChildNumber::from_hardened_idx(5).unwrap()).expect("Your RNG is busted");
- let mut unique_start = Sha256::engine();
- unique_start.input(&byte_utils::be64_to_array(starting_time_secs));
- unique_start.input(&byte_utils::be32_to_array(starting_time_nanos));
- unique_start.input(seed);
-
KeysManager {
secp_ctx,
node_secret,
channel_id_master_key,
channel_id_child_index: AtomicUsize::new(0),
- unique_start,
+ seed: *seed,
+ starting_time_secs,
+ starting_time_nanos,
}
},
Err(_) => panic!("Your rng is busted"),
}
}
-}
-
-impl KeysInterface for KeysManager {
- type ChanKeySigner = InMemoryChannelKeys;
-
- 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 derive_unique_start(&self) -> Sha256State {
+ let mut unique_start = Sha256::engine();
+ unique_start.input(&byte_utils::be64_to_array(self.starting_time_secs));
+ unique_start.input(&byte_utils::be32_to_array(self.starting_time_nanos));
+ unique_start.input(&self.seed);
+ unique_start
}
+ /// Derive an old set of ChannelKeys for per-channel secrets based on a key derivation
+ /// parameters.
+ /// Key derivation parameters are accessible through a per-channel secrets
+ /// ChannelKeys::key_derivation_params and is provided inside DynamicOuputP2WSH in case of
+ /// onchain output detection for which a corresponding delayed_payment_key must be derived.
+ pub fn derive_channel_keys(&self, channel_value_satoshis: u64, params_1: u64, params_2: u64) -> InMemoryChannelKeys {
+ let chan_id = ((params_1 & 0xFFFF_FFFF_0000_0000) >> 32) as u32;
+ let mut unique_start = Sha256::engine();
+ unique_start.input(&byte_utils::be64_to_array(params_2));
+ unique_start.input(&byte_utils::be32_to_array(params_1 as u32));
+ unique_start.input(&self.seed);
- fn get_channel_keys(&self, _inbound: bool, channel_value_satoshis: u64) -> InMemoryChannelKeys {
// We only seriously intend to rely on the channel_master_key for true secure
// entropy, everything else just ensures uniqueness. We rely on the unique_start (ie
// starting_time provided in the constructor) to be unique.
- let mut sha = self.unique_start.clone();
-
- let child_ix = self.channel_child_index.fetch_add(1, Ordering::AcqRel);
- let child_privkey = self.channel_master_key.ckd_priv(&self.secp_ctx, ChildNumber::from_hardened_idx(child_ix as u32).expect("key space exhausted")).expect("Your RNG is busted");
- sha.input(&child_privkey.private_key.key[..]);
+ let child_privkey = self.channel_master_key.ckd_priv(&self.secp_ctx, ChildNumber::from_hardened_idx(chan_id).expect("key space exhausted")).expect("Your RNG is busted");
+ unique_start.input(&child_privkey.private_key.key[..]);
- let seed = Sha256::from_engine(sha).into_inner();
+ let seed = Sha256::from_engine(unique_start).into_inner();
let commitment_seed = {
let mut sha = Sha256::engine();
delayed_payment_base_key,
htlc_base_key,
commitment_seed,
- channel_value_satoshis
+ channel_value_satoshis,
+ (params_1, params_2),
)
}
+}
+
+impl KeysInterface for KeysManager {
+ type ChanKeySigner = InMemoryChannelKeys;
+
+ 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, channel_value_satoshis: u64) -> InMemoryChannelKeys {
+ let child_ix = self.channel_child_index.fetch_add(1, Ordering::AcqRel);
+ let ix_and_nanos: u64 = (child_ix as u64) << 32 | (self.starting_time_nanos as u64);
+ self.derive_channel_keys(channel_value_satoshis, ix_and_nanos, self.starting_time_secs)
+ }
fn get_onion_rand(&self) -> (SecretKey, [u8; 32]) {
- let mut sha = self.unique_start.clone();
+ let mut sha = self.derive_unique_start();
let child_ix = self.session_child_index.fetch_add(1, Ordering::AcqRel);
let child_privkey = self.session_master_key.ckd_priv(&self.secp_ctx, ChildNumber::from_hardened_idx(child_ix as u32).expect("key space exhausted")).expect("Your RNG is busted");
}
fn get_channel_id(&self) -> [u8; 32] {
- let mut sha = self.unique_start.clone();
+ let mut sha = self.derive_unique_start();
let child_ix = self.channel_id_child_index.fetch_add(1, Ordering::AcqRel);
let child_privkey = self.channel_id_master_key.ckd_priv(&self.secp_ctx, ChildNumber::from_hardened_idx(child_ix as u32).expect("key space exhausted")).expect("Your RNG is busted");
projects / rust-lightning / blobdiff