X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Foffers%2Fmerkle.rs;h=11f1d971330c7f1c3f7447aa2f2b7ee5a5f5ddd7;hb=1e580668684d4dbf11d69d75e5d4a5c4f8cc40bf;hp=941bf196716d8b5ee2d2e51d2c4db95716bdf869;hpb=6d5c952556aefa8f61c5a2c74ff72f426f5406ac;p=rust-lightning diff --git a/lightning/src/offers/merkle.rs b/lightning/src/offers/merkle.rs index 941bf196..11f1d971 100644 --- a/lightning/src/offers/merkle.rs +++ b/lightning/src/offers/merkle.rs @@ -12,10 +12,10 @@ use bitcoin::hashes::{Hash, HashEngine, sha256}; use bitcoin::secp256k1::{Message, PublicKey, Secp256k1, self}; use bitcoin::secp256k1::schnorr::Signature; -use core::convert::AsRef; use crate::io; use crate::util::ser::{BigSize, Readable, Writeable, Writer}; +#[allow(unused_imports)] use crate::prelude::*; /// Valid type range for signature TLV records. @@ -38,13 +38,23 @@ pub struct TaggedHash { } impl TaggedHash { + /// Creates a tagged hash with the given parameters. + /// + /// Panics if `bytes` is not a well-formed TLV stream containing at least one TLV record. + pub(super) fn from_valid_tlv_stream_bytes(tag: &'static str, bytes: &[u8]) -> Self { + let tlv_stream = TlvStream::new(bytes); + Self::from_tlv_stream(tag, tlv_stream) + } + /// Creates a tagged hash with the given parameters. /// /// Panics if `tlv_stream` is not a well-formed TLV stream containing at least one TLV record. - pub(super) fn new(tag: &'static str, tlv_stream: &[u8]) -> Self { + pub(super) fn from_tlv_stream<'a, I: core::iter::Iterator>>( + tag: &'static str, tlv_stream: I + ) -> Self { let tag_hash = sha256::Hash::hash(tag.as_bytes()); let merkle_root = root_hash(tlv_stream); - let digest = Message::from_slice(tagged_hash(tag_hash, merkle_root).as_byte_array()).unwrap(); + let digest = Message::from_digest(tagged_hash(tag_hash, merkle_root).to_byte_array()); Self { tag, merkle_root, @@ -66,6 +76,10 @@ impl TaggedHash { pub fn merkle_root(&self) -> sha256::Hash { self.merkle_root } + + pub(super) fn to_bytes(&self) -> [u8; 32] { + *self.digest.as_ref() + } } impl AsRef for TaggedHash { @@ -137,9 +151,10 @@ pub(super) fn verify_signature( /// Computes a merkle root hash for the given data, which must be a well-formed TLV stream /// containing at least one TLV record. -fn root_hash(data: &[u8]) -> sha256::Hash { +fn root_hash<'a, I: core::iter::Iterator>>(tlv_stream: I) -> sha256::Hash { + let mut tlv_stream = tlv_stream.peekable(); let nonce_tag = tagged_hash_engine(sha256::Hash::from_engine({ - let first_tlv_record = TlvStream::new(&data[..]).next().unwrap(); + let first_tlv_record = tlv_stream.peek().unwrap(); let mut engine = sha256::Hash::engine(); engine.input("LnNonce".as_bytes()); engine.input(first_tlv_record.record_bytes); @@ -149,8 +164,7 @@ fn root_hash(data: &[u8]) -> sha256::Hash { let branch_tag = tagged_hash_engine(sha256::Hash::hash("LnBranch".as_bytes())); let mut leaves = Vec::new(); - let tlv_stream = TlvStream::new(&data[..]); - for record in tlv_stream.skip_signatures() { + for record in TlvStream::skip_signatures(tlv_stream) { leaves.push(tagged_hash_from_engine(leaf_tag.clone(), &record.record_bytes)); leaves.push(tagged_hash_from_engine(nonce_tag.clone(), &record.type_bytes)); } @@ -227,8 +241,10 @@ impl<'a> TlvStream<'a> { .take_while(move |record| take_range.contains(&record.r#type)) } - fn skip_signatures(self) -> core::iter::Filter, fn(&TlvRecord) -> bool> { - self.filter(|record| !SIGNATURE_TYPES.contains(&record.r#type)) + fn skip_signatures( + tlv_stream: impl core::iter::Iterator> + ) -> impl core::iter::Iterator> { + tlv_stream.filter(|record| !SIGNATURE_TYPES.contains(&record.r#type)) } } @@ -276,7 +292,7 @@ impl<'a> Writeable for WithoutSignatures<'a> { #[inline] fn write(&self, writer: &mut W) -> Result<(), io::Error> { let tlv_stream = TlvStream::new(self.0); - for record in tlv_stream.skip_signatures() { + for record in TlvStream::skip_signatures(tlv_stream) { writer.write_all(record.record_bytes)?; } Ok(()) @@ -289,7 +305,7 @@ mod tests { use bitcoin::hashes::{Hash, sha256}; use bitcoin::hashes::hex::FromHex; - use bitcoin::secp256k1::{KeyPair, Message, Secp256k1, SecretKey}; + use bitcoin::secp256k1::{Keypair, Message, Secp256k1, SecretKey}; use bitcoin::secp256k1::schnorr::Signature; use crate::offers::offer::{Amount, OfferBuilder}; use crate::offers::invoice_request::{InvoiceRequest, UnsignedInvoiceRequest}; @@ -304,15 +320,15 @@ mod tests { macro_rules! tlv2 { () => { "02080000010000020003" } } macro_rules! tlv3 { () => { "03310266e4598d1d3c415f572a8488830b60f7e744ed9235eb0b1ba93283b315c0351800000000000000010000000000000002" } } assert_eq!( - super::root_hash(&>::from_hex(tlv1!()).unwrap()), + super::root_hash(TlvStream::new(&>::from_hex(tlv1!()).unwrap())), sha256::Hash::from_slice(&>::from_hex("b013756c8fee86503a0b4abdab4cddeb1af5d344ca6fc2fa8b6c08938caa6f93").unwrap()).unwrap(), ); assert_eq!( - super::root_hash(&>::from_hex(concat!(tlv1!(), tlv2!())).unwrap()), + super::root_hash(TlvStream::new(&>::from_hex(concat!(tlv1!(), tlv2!())).unwrap())), sha256::Hash::from_slice(&>::from_hex("c3774abbf4815aa54ccaa026bff6581f01f3be5fe814c620a252534f434bc0d1").unwrap()).unwrap(), ); assert_eq!( - super::root_hash(&>::from_hex(concat!(tlv1!(), tlv2!(), tlv3!())).unwrap()), + super::root_hash(TlvStream::new(&>::from_hex(concat!(tlv1!(), tlv2!(), tlv3!())).unwrap())), sha256::Hash::from_slice(&>::from_hex("ab2e79b1283b0b31e0b035258de23782df6b89a38cfa7237bde69aed1a658c5d").unwrap()).unwrap(), ); } @@ -322,15 +338,16 @@ mod tests { let secp_ctx = Secp256k1::new(); let recipient_pubkey = { let secret_key = SecretKey::from_slice(&>::from_hex("4141414141414141414141414141414141414141414141414141414141414141").unwrap()).unwrap(); - KeyPair::from_secret_key(&secp_ctx, &secret_key).public_key() + Keypair::from_secret_key(&secp_ctx, &secret_key).public_key() }; let payer_keys = { let secret_key = SecretKey::from_slice(&>::from_hex("4242424242424242424242424242424242424242424242424242424242424242").unwrap()).unwrap(); - KeyPair::from_secret_key(&secp_ctx, &secret_key) + Keypair::from_secret_key(&secp_ctx, &secret_key) }; // BOLT 12 test vectors - let invoice_request = OfferBuilder::new("A Mathematical Treatise".into(), recipient_pubkey) + let invoice_request = OfferBuilder::new(recipient_pubkey) + .description("A Mathematical Treatise".into()) .amount(Amount::Currency { iso4217_code: *b"USD", amount: 100 }) .build_unchecked() .request_invoice(vec![0; 8], payer_keys.public_key()).unwrap() @@ -344,7 +361,7 @@ mod tests { "lnr1qqyqqqqqqqqqqqqqqcp4256ypqqkgzshgysy6ct5dpjk6ct5d93kzmpq23ex2ct5d9ek293pqthvwfzadd7jejes8q9lhc4rvjxd022zv5l44g6qah82ru5rdpnpjkppqvjx204vgdzgsqpvcp4mldl3plscny0rt707gvpdh6ndydfacz43euzqhrurageg3n7kafgsek6gz3e9w52parv8gs2hlxzk95tzeswywffxlkeyhml0hh46kndmwf4m6xma3tkq2lu04qz3slje2rfthc89vss", ); assert_eq!( - super::root_hash(&invoice_request.bytes[..]), + super::root_hash(TlvStream::new(&invoice_request.bytes[..])), sha256::Hash::from_slice(&>::from_hex("608407c18ad9a94d9ea2bcdbe170b6c20c462a7833a197621c916f78cf18e624").unwrap()).unwrap(), ); assert_eq!( @@ -355,7 +372,7 @@ mod tests { #[test] fn compute_tagged_hash() { - let unsigned_invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey()) + let unsigned_invoice_request = OfferBuilder::new(recipient_pubkey()) .amount_msats(1000) .build().unwrap() .request_invoice(vec![1; 32], payer_pubkey()).unwrap() @@ -367,8 +384,7 @@ mod tests { let tagged_hash = unsigned_invoice_request.as_ref(); let expected_digest = unsigned_invoice_request.as_ref().as_digest(); let tag = sha256::Hash::hash(tagged_hash.tag().as_bytes()); - let actual_digest = Message::from_slice(super::tagged_hash(tag, tagged_hash.merkle_root()).as_byte_array()) - .unwrap(); + let actual_digest = Message::from_digest(super::tagged_hash(tag, tagged_hash.merkle_root()).to_byte_array()); assert_eq!(*expected_digest, actual_digest); } @@ -377,14 +393,14 @@ mod tests { let secp_ctx = Secp256k1::new(); let recipient_pubkey = { let secret_key = SecretKey::from_slice(&[41; 32]).unwrap(); - KeyPair::from_secret_key(&secp_ctx, &secret_key).public_key() + Keypair::from_secret_key(&secp_ctx, &secret_key).public_key() }; let payer_keys = { let secret_key = SecretKey::from_slice(&[42; 32]).unwrap(); - KeyPair::from_secret_key(&secp_ctx, &secret_key) + Keypair::from_secret_key(&secp_ctx, &secret_key) }; - let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey) + let invoice_request = OfferBuilder::new(recipient_pubkey) .amount_msats(100) .build_unchecked() .request_invoice(vec![0; 8], payer_keys.public_key()).unwrap() @@ -409,14 +425,14 @@ mod tests { let secp_ctx = Secp256k1::new(); let recipient_pubkey = { let secret_key = SecretKey::from_slice(&[41; 32]).unwrap(); - KeyPair::from_secret_key(&secp_ctx, &secret_key).public_key() + Keypair::from_secret_key(&secp_ctx, &secret_key).public_key() }; let payer_keys = { let secret_key = SecretKey::from_slice(&[42; 32]).unwrap(); - KeyPair::from_secret_key(&secp_ctx, &secret_key) + Keypair::from_secret_key(&secp_ctx, &secret_key) }; - let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey) + let invoice_request = OfferBuilder::new(recipient_pubkey) .amount_msats(100) .build_unchecked() .request_invoice(vec![0; 8], payer_keys.public_key()).unwrap()