1 // This file is Copyright its original authors, visible in version control
4 // This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
5 // or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
6 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
7 // You may not use this file except in accordance with one or both of these
10 //! Tagged hashes for use in signature calculation and verification.
12 use bitcoin::hashes::{Hash, HashEngine, sha256};
13 use bitcoin::secp256k1::{Message, PublicKey, Secp256k1, self};
14 use bitcoin::secp256k1::schnorr::Signature;
16 use crate::util::ser::{BigSize, Readable, Writeable, Writer};
18 #[allow(unused_imports)]
19 use crate::prelude::*;
21 /// Valid type range for signature TLV records.
22 const SIGNATURE_TYPES: core::ops::RangeInclusive<u64> = 240..=1000;
24 tlv_stream!(SignatureTlvStream, SignatureTlvStreamRef, SIGNATURE_TYPES, {
25 (240, signature: Signature),
28 /// A hash for use in a specific context by tweaking with a context-dependent tag as per [BIP 340]
29 /// and computed over the merkle root of a TLV stream to sign as defined in [BOLT 12].
31 /// [BIP 340]: https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki
32 /// [BOLT 12]: https://github.com/rustyrussell/lightning-rfc/blob/guilt/offers/12-offer-encoding.md#signature-calculation
33 #[derive(Clone, Debug, PartialEq)]
34 pub struct TaggedHash {
36 merkle_root: sha256::Hash,
41 /// Creates a tagged hash with the given parameters.
43 /// Panics if `bytes` is not a well-formed TLV stream containing at least one TLV record.
44 pub(super) fn from_valid_tlv_stream_bytes(tag: &'static str, bytes: &[u8]) -> Self {
45 let tlv_stream = TlvStream::new(bytes);
46 Self::from_tlv_stream(tag, tlv_stream)
49 /// Creates a tagged hash with the given parameters.
51 /// Panics if `tlv_stream` is not a well-formed TLV stream containing at least one TLV record.
52 pub(super) fn from_tlv_stream<'a, I: core::iter::Iterator<Item = TlvRecord<'a>>>(
53 tag: &'static str, tlv_stream: I
55 let tag_hash = sha256::Hash::hash(tag.as_bytes());
56 let merkle_root = root_hash(tlv_stream);
57 let digest = Message::from_slice(tagged_hash(tag_hash, merkle_root).as_byte_array()).unwrap();
65 /// Returns the digest to sign.
66 pub fn as_digest(&self) -> &Message {
70 /// Returns the tag used in the tagged hash.
71 pub fn tag(&self) -> &str {
75 /// Returns the merkle root used in the tagged hash.
76 pub fn merkle_root(&self) -> sha256::Hash {
80 pub(super) fn to_bytes(&self) -> [u8; 32] {
85 impl AsRef<TaggedHash> for TaggedHash {
86 fn as_ref(&self) -> &TaggedHash {
91 /// Error when signing messages.
92 #[derive(Debug, PartialEq)]
94 /// User-defined error when signing the message.
96 /// Error when verifying the produced signature using the given pubkey.
97 Verification(secp256k1::Error),
100 /// A function for signing a [`TaggedHash`].
101 pub(super) trait SignFn<T: AsRef<TaggedHash>> {
102 /// Signs a [`TaggedHash`] computed over the merkle root of `message`'s TLV stream.
103 fn sign(&self, message: &T) -> Result<Signature, ()>;
106 impl<F> SignFn<TaggedHash> for F
108 F: Fn(&TaggedHash) -> Result<Signature, ()>,
110 fn sign(&self, message: &TaggedHash) -> Result<Signature, ()> {
115 /// Signs a [`TaggedHash`] computed over the merkle root of `message`'s TLV stream, checking if it
116 /// can be verified with the supplied `pubkey`.
118 /// Since `message` is any type that implements [`AsRef<TaggedHash>`], `sign` may be a closure that
119 /// takes a message such as [`Bolt12Invoice`] or [`InvoiceRequest`]. This allows further message
120 /// verification before signing its [`TaggedHash`].
122 /// [`Bolt12Invoice`]: crate::offers::invoice::Bolt12Invoice
123 /// [`InvoiceRequest`]: crate::offers::invoice_request::InvoiceRequest
124 pub(super) fn sign_message<F, T>(
125 f: F, message: &T, pubkey: PublicKey,
126 ) -> Result<Signature, SignError>
129 T: AsRef<TaggedHash>,
131 let signature = f.sign(message).map_err(|()| SignError::Signing)?;
133 let digest = message.as_ref().as_digest();
134 let pubkey = pubkey.into();
135 let secp_ctx = Secp256k1::verification_only();
136 secp_ctx.verify_schnorr(&signature, digest, &pubkey).map_err(|e| SignError::Verification(e))?;
141 /// Verifies the signature with a pubkey over the given message using a tagged hash as the message
143 pub(super) fn verify_signature(
144 signature: &Signature, message: &TaggedHash, pubkey: PublicKey,
145 ) -> Result<(), secp256k1::Error> {
146 let digest = message.as_digest();
147 let pubkey = pubkey.into();
148 let secp_ctx = Secp256k1::verification_only();
149 secp_ctx.verify_schnorr(signature, digest, &pubkey)
152 /// Computes a merkle root hash for the given data, which must be a well-formed TLV stream
153 /// containing at least one TLV record.
154 fn root_hash<'a, I: core::iter::Iterator<Item = TlvRecord<'a>>>(tlv_stream: I) -> sha256::Hash {
155 let mut tlv_stream = tlv_stream.peekable();
156 let nonce_tag = tagged_hash_engine(sha256::Hash::from_engine({
157 let first_tlv_record = tlv_stream.peek().unwrap();
158 let mut engine = sha256::Hash::engine();
159 engine.input("LnNonce".as_bytes());
160 engine.input(first_tlv_record.record_bytes);
163 let leaf_tag = tagged_hash_engine(sha256::Hash::hash("LnLeaf".as_bytes()));
164 let branch_tag = tagged_hash_engine(sha256::Hash::hash("LnBranch".as_bytes()));
166 let mut leaves = Vec::new();
167 for record in TlvStream::skip_signatures(tlv_stream) {
168 leaves.push(tagged_hash_from_engine(leaf_tag.clone(), &record.record_bytes));
169 leaves.push(tagged_hash_from_engine(nonce_tag.clone(), &record.type_bytes));
172 // Calculate the merkle root hash in place.
173 let num_leaves = leaves.len();
175 let step = 2 << level;
176 let offset = step / 2;
177 if offset >= num_leaves {
181 let left_branches = (0..num_leaves).step_by(step);
182 let right_branches = (offset..num_leaves).step_by(step);
183 for (i, j) in left_branches.zip(right_branches) {
184 leaves[i] = tagged_branch_hash_from_engine(branch_tag.clone(), leaves[i], leaves[j]);
188 *leaves.first().unwrap()
191 fn tagged_hash<T: AsRef<[u8]>>(tag: sha256::Hash, msg: T) -> sha256::Hash {
192 let engine = tagged_hash_engine(tag);
193 tagged_hash_from_engine(engine, msg)
196 fn tagged_hash_engine(tag: sha256::Hash) -> sha256::HashEngine {
197 let mut engine = sha256::Hash::engine();
198 engine.input(tag.as_ref());
199 engine.input(tag.as_ref());
203 fn tagged_hash_from_engine<T: AsRef<[u8]>>(mut engine: sha256::HashEngine, msg: T) -> sha256::Hash {
204 engine.input(msg.as_ref());
205 sha256::Hash::from_engine(engine)
208 fn tagged_branch_hash_from_engine(
209 mut engine: sha256::HashEngine, leaf1: sha256::Hash, leaf2: sha256::Hash,
212 engine.input(leaf1.as_ref());
213 engine.input(leaf2.as_ref());
215 engine.input(leaf2.as_ref());
216 engine.input(leaf1.as_ref());
218 sha256::Hash::from_engine(engine)
221 /// [`Iterator`] over a sequence of bytes yielding [`TlvRecord`]s. The input is assumed to be a
222 /// well-formed TLV stream.
224 pub(super) struct TlvStream<'a> {
225 data: io::Cursor<&'a [u8]>,
228 impl<'a> TlvStream<'a> {
229 pub fn new(data: &'a [u8]) -> Self {
231 data: io::Cursor::new(data),
235 pub fn range<T>(self, types: T) -> impl core::iter::Iterator<Item = TlvRecord<'a>>
237 T: core::ops::RangeBounds<u64> + Clone,
239 let take_range = types.clone();
240 self.skip_while(move |record| !types.contains(&record.r#type))
241 .take_while(move |record| take_range.contains(&record.r#type))
245 tlv_stream: impl core::iter::Iterator<Item = TlvRecord<'a>>
246 ) -> impl core::iter::Iterator<Item = TlvRecord<'a>> {
247 tlv_stream.filter(|record| !SIGNATURE_TYPES.contains(&record.r#type))
251 /// A slice into a [`TlvStream`] for a record.
252 pub(super) struct TlvRecord<'a> {
253 pub(super) r#type: u64,
254 type_bytes: &'a [u8],
255 // The entire TLV record.
256 pub(super) record_bytes: &'a [u8],
259 impl<'a> Iterator for TlvStream<'a> {
260 type Item = TlvRecord<'a>;
262 fn next(&mut self) -> Option<Self::Item> {
263 if self.data.position() < self.data.get_ref().len() as u64 {
264 let start = self.data.position();
266 let r#type = <BigSize as Readable>::read(&mut self.data).unwrap().0;
267 let offset = self.data.position();
268 let type_bytes = &self.data.get_ref()[start as usize..offset as usize];
270 let length = <BigSize as Readable>::read(&mut self.data).unwrap().0;
271 let offset = self.data.position();
272 let end = offset + length;
274 let _value = &self.data.get_ref()[offset as usize..end as usize];
275 let record_bytes = &self.data.get_ref()[start as usize..end as usize];
277 self.data.set_position(end);
279 Some(TlvRecord { r#type, type_bytes, record_bytes })
286 /// Encoding for a pre-serialized TLV stream that excludes any signature TLV records.
288 /// Panics if the wrapped bytes are not a well-formed TLV stream.
289 pub(super) struct WithoutSignatures<'a>(pub &'a [u8]);
291 impl<'a> Writeable for WithoutSignatures<'a> {
293 fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
294 let tlv_stream = TlvStream::new(self.0);
295 for record in TlvStream::skip_signatures(tlv_stream) {
296 writer.write_all(record.record_bytes)?;
304 use super::{SIGNATURE_TYPES, TlvStream, WithoutSignatures};
306 use bitcoin::hashes::{Hash, sha256};
307 use bitcoin::hashes::hex::FromHex;
308 use bitcoin::secp256k1::{KeyPair, Message, Secp256k1, SecretKey};
309 use bitcoin::secp256k1::schnorr::Signature;
310 use crate::offers::offer::{Amount, OfferBuilder};
311 use crate::offers::invoice_request::{InvoiceRequest, UnsignedInvoiceRequest};
312 use crate::offers::parse::Bech32Encode;
313 use crate::offers::test_utils::{payer_pubkey, recipient_pubkey};
314 use crate::util::ser::Writeable;
317 fn calculates_merkle_root_hash() {
318 // BOLT 12 test vectors
319 macro_rules! tlv1 { () => { "010203e8" } }
320 macro_rules! tlv2 { () => { "02080000010000020003" } }
321 macro_rules! tlv3 { () => { "03310266e4598d1d3c415f572a8488830b60f7e744ed9235eb0b1ba93283b315c0351800000000000000010000000000000002" } }
323 super::root_hash(TlvStream::new(&<Vec<u8>>::from_hex(tlv1!()).unwrap())),
324 sha256::Hash::from_slice(&<Vec<u8>>::from_hex("b013756c8fee86503a0b4abdab4cddeb1af5d344ca6fc2fa8b6c08938caa6f93").unwrap()).unwrap(),
327 super::root_hash(TlvStream::new(&<Vec<u8>>::from_hex(concat!(tlv1!(), tlv2!())).unwrap())),
328 sha256::Hash::from_slice(&<Vec<u8>>::from_hex("c3774abbf4815aa54ccaa026bff6581f01f3be5fe814c620a252534f434bc0d1").unwrap()).unwrap(),
331 super::root_hash(TlvStream::new(&<Vec<u8>>::from_hex(concat!(tlv1!(), tlv2!(), tlv3!())).unwrap())),
332 sha256::Hash::from_slice(&<Vec<u8>>::from_hex("ab2e79b1283b0b31e0b035258de23782df6b89a38cfa7237bde69aed1a658c5d").unwrap()).unwrap(),
337 fn calculates_merkle_root_hash_from_invoice_request() {
338 let secp_ctx = Secp256k1::new();
339 let recipient_pubkey = {
340 let secret_key = SecretKey::from_slice(&<Vec<u8>>::from_hex("4141414141414141414141414141414141414141414141414141414141414141").unwrap()).unwrap();
341 KeyPair::from_secret_key(&secp_ctx, &secret_key).public_key()
344 let secret_key = SecretKey::from_slice(&<Vec<u8>>::from_hex("4242424242424242424242424242424242424242424242424242424242424242").unwrap()).unwrap();
345 KeyPair::from_secret_key(&secp_ctx, &secret_key)
348 // BOLT 12 test vectors
349 let invoice_request = OfferBuilder::new("A Mathematical Treatise".into(), recipient_pubkey)
350 .amount(Amount::Currency { iso4217_code: *b"USD", amount: 100 })
352 .request_invoice(vec![0; 8], payer_keys.public_key()).unwrap()
354 .sign(|message: &UnsignedInvoiceRequest|
355 Ok(secp_ctx.sign_schnorr_no_aux_rand(message.as_ref().as_digest(), &payer_keys))
359 invoice_request.to_string(),
360 "lnr1qqyqqqqqqqqqqqqqqcp4256ypqqkgzshgysy6ct5dpjk6ct5d93kzmpq23ex2ct5d9ek293pqthvwfzadd7jejes8q9lhc4rvjxd022zv5l44g6qah82ru5rdpnpjkppqvjx204vgdzgsqpvcp4mldl3plscny0rt707gvpdh6ndydfacz43euzqhrurageg3n7kafgsek6gz3e9w52parv8gs2hlxzk95tzeswywffxlkeyhml0hh46kndmwf4m6xma3tkq2lu04qz3slje2rfthc89vss",
363 super::root_hash(TlvStream::new(&invoice_request.bytes[..])),
364 sha256::Hash::from_slice(&<Vec<u8>>::from_hex("608407c18ad9a94d9ea2bcdbe170b6c20c462a7833a197621c916f78cf18e624").unwrap()).unwrap(),
367 invoice_request.signature(),
368 Signature::from_slice(&<Vec<u8>>::from_hex("b8f83ea3288cfd6ea510cdb481472575141e8d8744157f98562d162cc1c472526fdb24befefbdebab4dbb726bbd1b7d8aec057f8fa805187e5950d2bbe0e5642").unwrap()).unwrap(),
373 fn compute_tagged_hash() {
374 let unsigned_invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey())
377 .request_invoice(vec![1; 32], payer_pubkey()).unwrap()
378 .payer_note("bar".into())
381 // Simply test that we can grab the tag and merkle root exposed by the accessor
382 // functions, then use them to succesfully compute a tagged hash.
383 let tagged_hash = unsigned_invoice_request.as_ref();
384 let expected_digest = unsigned_invoice_request.as_ref().as_digest();
385 let tag = sha256::Hash::hash(tagged_hash.tag().as_bytes());
386 let actual_digest = Message::from_slice(super::tagged_hash(tag, tagged_hash.merkle_root()).as_byte_array())
388 assert_eq!(*expected_digest, actual_digest);
392 fn skips_encoding_signature_tlv_records() {
393 let secp_ctx = Secp256k1::new();
394 let recipient_pubkey = {
395 let secret_key = SecretKey::from_slice(&[41; 32]).unwrap();
396 KeyPair::from_secret_key(&secp_ctx, &secret_key).public_key()
399 let secret_key = SecretKey::from_slice(&[42; 32]).unwrap();
400 KeyPair::from_secret_key(&secp_ctx, &secret_key)
403 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey)
406 .request_invoice(vec![0; 8], payer_keys.public_key()).unwrap()
408 .sign(|message: &UnsignedInvoiceRequest|
409 Ok(secp_ctx.sign_schnorr_no_aux_rand(message.as_ref().as_digest(), &payer_keys))
413 let mut bytes_without_signature = Vec::new();
414 WithoutSignatures(&invoice_request.bytes).write(&mut bytes_without_signature).unwrap();
416 assert_ne!(bytes_without_signature, invoice_request.bytes);
418 TlvStream::new(&bytes_without_signature).count(),
419 TlvStream::new(&invoice_request.bytes).count() - 1,
424 fn iterates_over_tlv_stream_range() {
425 let secp_ctx = Secp256k1::new();
426 let recipient_pubkey = {
427 let secret_key = SecretKey::from_slice(&[41; 32]).unwrap();
428 KeyPair::from_secret_key(&secp_ctx, &secret_key).public_key()
431 let secret_key = SecretKey::from_slice(&[42; 32]).unwrap();
432 KeyPair::from_secret_key(&secp_ctx, &secret_key)
435 let invoice_request = OfferBuilder::new("foo".into(), recipient_pubkey)
438 .request_invoice(vec![0; 8], payer_keys.public_key()).unwrap()
440 .sign(|message: &UnsignedInvoiceRequest|
441 Ok(secp_ctx.sign_schnorr_no_aux_rand(message.as_ref().as_digest(), &payer_keys))
445 let tlv_stream = TlvStream::new(&invoice_request.bytes).range(0..1)
446 .chain(TlvStream::new(&invoice_request.bytes).range(1..80))
447 .chain(TlvStream::new(&invoice_request.bytes).range(80..160))
448 .chain(TlvStream::new(&invoice_request.bytes).range(160..240))
449 .chain(TlvStream::new(&invoice_request.bytes).range(SIGNATURE_TYPES))
450 .map(|r| r.record_bytes.to_vec())
452 .collect::<Vec<u8>>();
454 assert_eq!(tlv_stream, invoice_request.bytes);
457 impl AsRef<[u8]> for InvoiceRequest {
458 fn as_ref(&self) -> &[u8] {
463 impl Bech32Encode for InvoiceRequest {
464 const BECH32_HRP: &'static str = "lnr";
467 impl core::fmt::Display for InvoiceRequest {
468 fn fmt(&self, f: &mut core::fmt::Formatter) -> Result<(), core::fmt::Error> {
469 self.fmt_bech32_str(f)