X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning-invoice%2Fsrc%2Fde.rs;h=9e96849a274c24d9ba1a08845b8d69622c75a4ff;hb=996d3d8058f2342b9e23d53f9dd81ae472822120;hp=c06281e4b4db86c00b95812ad4794b57dffe9112;hpb=affefb677e3f9f1a586707484ac82b6c86f4f26b;p=rust-lightning diff --git a/lightning-invoice/src/de.rs b/lightning-invoice/src/de.rs index c06281e4..9e96849a 100644 --- a/lightning-invoice/src/de.rs +++ b/lightning-invoice/src/de.rs @@ -1,17 +1,20 @@ +#[cfg(feature = "std")] use std::error; -use std::fmt; -use std::fmt::{Display, Formatter}; -use std::num::ParseIntError; -use std::str; -use std::str::FromStr; +use core::fmt; +use core::fmt::{Display, Formatter}; +use core::num::ParseIntError; +use core::str; +use core::str::FromStr; use bech32; use bech32::{u5, FromBase32}; use bitcoin_hashes::Hash; use bitcoin_hashes::sha256; +use crate::prelude::*; +use lightning::ln::PaymentSecret; use lightning::routing::network_graph::RoutingFees; -use lightning::routing::router::RouteHintHop; +use lightning::routing::router::{RouteHint, RouteHintHop}; use num_traits::{CheckedAdd, CheckedMul}; @@ -19,13 +22,15 @@ use secp256k1; use secp256k1::recovery::{RecoveryId, RecoverableSignature}; use secp256k1::key::PublicKey; -use super::*; +use super::{Invoice, Sha256, TaggedField, ExpiryTime, MinFinalCltvExpiry, Fallback, PayeePubKey, InvoiceSignature, PositiveTimestamp, + SemanticError, PrivateRoute, Description, RawTaggedField, Currency, RawHrp, SiPrefix, RawInvoice, constants, SignedRawInvoice, + RawDataPart, InvoiceFeatures}; use self::hrp_sm::parse_hrp; /// State machine to parse the hrp mod hrp_sm { - use std::ops::Range; + use core::ops::Range; #[derive(PartialEq, Eq, Debug)] enum States { @@ -74,7 +79,7 @@ mod hrp_sm { } else if ['m', 'u', 'n', 'p'].contains(&read_symbol) { Ok(States::ParseAmountSiPrefix) } else { - Err(super::ParseError::MalformedHRP) + Err(super::ParseError::UnknownSiPrefix) } }, States::ParseAmountSiPrefix => Err(super::ParseError::MalformedHRP), @@ -182,6 +187,7 @@ impl FromStr for super::Currency { "tb" => Ok(Currency::BitcoinTestnet), "bcrt" => Ok(Currency::Regtest), "sb" => Ok(Currency::Simnet), + "tbs" => Ok(Currency::Signet), _ => Err(ParseError::UnknownCurrency) } } @@ -205,10 +211,18 @@ impl FromStr for SiPrefix { /// ``` /// use lightning_invoice::Invoice; /// -/// let invoice = "lnbc1pvjluezpp5qqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqypqdp\ -/// l2pkx2ctnv5sxxmmwwd5kgetjypeh2ursdae8g6twvus8g6rfwvs8qun0dfjkxaq8rkx3yf5tcsyz3d7\ -/// 3gafnh3cax9rn449d9p5uxz9ezhhypd0elx87sjle52x86fux2ypatgddc6k63n7erqz25le42c4u4ec\ -/// ky03ylcqca784w"; +/// +/// let invoice = "lnbc100p1psj9jhxdqud3jxktt5w46x7unfv9kz6mn0v3jsnp4q0d3p2sfluzdx45tqcs\ +/// h2pu5qc7lgq0xs578ngs6s0s68ua4h7cvspp5q6rmq35js88zp5dvwrv9m459tnk2zunwj5jalqtyxqulh0l\ +/// 5gflssp5nf55ny5gcrfl30xuhzj3nphgj27rstekmr9fw3ny5989s300gyus9qyysgqcqpcrzjqw2sxwe993\ +/// h5pcm4dxzpvttgza8zhkqxpgffcrf5v25nwpr3cmfg7z54kuqq8rgqqqqqqqq2qqqqq9qq9qrzjqd0ylaqcl\ +/// j9424x9m8h2vcukcgnm6s56xfgu3j78zyqzhgs4hlpzvznlugqq9vsqqqqqqqlgqqqqqeqq9qrzjqwldmj9d\ +/// ha74df76zhx6l9we0vjdquygcdt3kssupehe64g6yyp5yz5rhuqqwccqqyqqqqlgqqqqjcqq9qrzjqf9e58a\ +/// guqr0rcun0ajlvmzq3ek63cw2w282gv3z5uupmuwvgjtq2z55qsqqg6qqqyqqqrtnqqqzq3cqygrzjqvphms\ +/// ywntrrhqjcraumvc4y6r8v4z5v593trte429v4hredj7ms5z52usqq9ngqqqqqqqlgqqqqqqgq9qrzjq2v0v\ +/// p62g49p7569ev48cmulecsxe59lvaw3wlxm7r982zxa9zzj7z5l0cqqxusqqyqqqqlgqqqqqzsqygarl9fh3\ +/// 8s0gyuxjjgux34w75dnc6xp2l35j7es3jd4ugt3lu0xzre26yg5m7ke54n2d5sym4xcmxtl8238xxvw5h5h5\ +/// j5r6drg6k6zcqj0fcwg"; /// /// assert!(invoice.parse::().is_ok()); /// ``` @@ -224,10 +238,17 @@ impl FromStr for Invoice { /// ``` /// use lightning_invoice::*; /// -/// let invoice = "lnbc1pvjluezpp5qqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqqqsyqcyq5rqwzqfqypqdp\ -/// l2pkx2ctnv5sxxmmwwd5kgetjypeh2ursdae8g6twvus8g6rfwvs8qun0dfjkxaq8rkx3yf5tcsyz3d7\ -/// 3gafnh3cax9rn449d9p5uxz9ezhhypd0elx87sjle52x86fux2ypatgddc6k63n7erqz25le42c4u4ec\ -/// ky03ylcqca784w"; +/// let invoice = "lnbc100p1psj9jhxdqud3jxktt5w46x7unfv9kz6mn0v3jsnp4q0d3p2sfluzdx45tqcs\ +/// h2pu5qc7lgq0xs578ngs6s0s68ua4h7cvspp5q6rmq35js88zp5dvwrv9m459tnk2zunwj5jalqtyxqulh0l\ +/// 5gflssp5nf55ny5gcrfl30xuhzj3nphgj27rstekmr9fw3ny5989s300gyus9qyysgqcqpcrzjqw2sxwe993\ +/// h5pcm4dxzpvttgza8zhkqxpgffcrf5v25nwpr3cmfg7z54kuqq8rgqqqqqqqq2qqqqq9qq9qrzjqd0ylaqcl\ +/// j9424x9m8h2vcukcgnm6s56xfgu3j78zyqzhgs4hlpzvznlugqq9vsqqqqqqqlgqqqqqeqq9qrzjqwldmj9d\ +/// ha74df76zhx6l9we0vjdquygcdt3kssupehe64g6yyp5yz5rhuqqwccqqyqqqqlgqqqqjcqq9qrzjqf9e58a\ +/// guqr0rcun0ajlvmzq3ek63cw2w282gv3z5uupmuwvgjtq2z55qsqqg6qqqyqqqrtnqqqzq3cqygrzjqvphms\ +/// ywntrrhqjcraumvc4y6r8v4z5v593trte429v4hredj7ms5z52usqq9ngqqqqqqqlgqqqqqqgq9qrzjq2v0v\ +/// p62g49p7569ev48cmulecsxe59lvaw3wlxm7r982zxa9zzj7z5l0cqqxusqqyqqqqlgqqqqqzsqygarl9fh3\ +/// 8s0gyuxjjgux34w75dnc6xp2l35j7es3jd4ugt3lu0xzre26yg5m7ke54n2d5sym4xcmxtl8238xxvw5h5h5\ +/// j5r6drg6k6zcqj0fcwg"; /// /// let parsed_1 = invoice.parse::(); /// @@ -246,7 +267,13 @@ impl FromStr for SignedRawInvoice { type Err = ParseError; fn from_str(s: &str) -> Result { - let (hrp, data) = bech32::decode(s)?; + let (hrp, data, var) = bech32::decode(s)?; + + if var == bech32::Variant::Bech32m { + // Consider Bech32m addresses to be "Invalid Checksum", since that is what we'd get if + // we didn't support Bech32m (which lightning does not use). + return Err(ParseError::Bech32Error(bech32::Error::InvalidChecksum)); + } if data.len() < 104 { return Err(ParseError::TooShortDataPart); @@ -264,7 +291,7 @@ impl FromStr for SignedRawInvoice { hrp.as_bytes(), &data[..data.len()-104] ), - signature: Signature::from_base32(&data[data.len()-104..])?, + signature: InvoiceSignature::from_base32(&data[data.len()-104..])?, }) } } @@ -332,23 +359,22 @@ impl FromBase32 for PositiveTimestamp { .expect("7*5bit < 64bit, no overflow possible"); match PositiveTimestamp::from_unix_timestamp(timestamp) { Ok(t) => Ok(t), - Err(CreationError::TimestampOutOfBounds) => Err(ParseError::TimestampOverflow), Err(_) => unreachable!(), } } } -impl FromBase32 for Signature { +impl FromBase32 for InvoiceSignature { type Err = ParseError; fn from_base32(signature: &[u5]) -> Result { if signature.len() != 104 { - return Err(ParseError::InvalidSliceLength("Signature::from_base32()".into())); + return Err(ParseError::InvalidSliceLength("InvoiceSignature::from_base32()".into())); } let recoverable_signature_bytes = Vec::::from_base32(signature)?; let signature = &recoverable_signature_bytes[0..64]; let recovery_id = RecoveryId::from_i32(recoverable_signature_bytes[64] as i32)?; - Ok(Signature(RecoverableSignature::from_compact( + Ok(InvoiceSignature(RecoverableSignature::from_compact( signature, recovery_id )?)) @@ -394,7 +420,7 @@ fn parse_tagged_parts(data: &[u5]) -> Result, ParseError> { Ok(field) => { parts.push(RawTaggedField::KnownSemantics(field)) }, - Err(ParseError::Skip) => { + Err(ParseError::Skip)|Err(ParseError::Bech32Error(bech32::Error::InvalidLength)) => { parts.push(RawTaggedField::UnknownSemantics(field.into())) }, Err(e) => {return Err(e)} @@ -429,8 +455,8 @@ impl FromBase32 for TaggedField { Ok(TaggedField::MinFinalCltvExpiry(MinFinalCltvExpiry::from_base32(field_data)?)), constants::TAG_FALLBACK => Ok(TaggedField::Fallback(Fallback::from_base32(field_data)?)), - constants::TAG_ROUTE => - Ok(TaggedField::Route(RouteHint::from_base32(field_data)?)), + constants::TAG_PRIVATE_ROUTE => + Ok(TaggedField::PrivateRoute(PrivateRoute::from_base32(field_data)?)), constants::TAG_PAYMENT_SECRET => Ok(TaggedField::PaymentSecret(PaymentSecret::from_base32(field_data)?)), constants::TAG_FEATURES => @@ -484,27 +510,12 @@ impl FromBase32 for PayeePubKey { } } -impl FromBase32 for PaymentSecret { - type Err = ParseError; - - fn from_base32(field_data: &[u5]) -> Result { - if field_data.len() != 52 { - Err(ParseError::Skip) - } else { - let data_bytes = Vec::::from_base32(field_data)?; - let mut payment_secret = [0; 32]; - payment_secret.copy_from_slice(&data_bytes); - Ok(PaymentSecret(payment_secret)) - } - } -} - impl FromBase32 for ExpiryTime { type Err = ParseError; fn from_base32(field_data: &[u5]) -> Result { match parse_int_be::(field_data, 32) - .and_then(|t| ExpiryTime::from_seconds(t).ok()) // ok, since the only error is out of bounds + .map(|t| ExpiryTime::from_seconds(t)) { Some(t) => Ok(t), None => Err(ParseError::IntegerOverflowError), @@ -569,10 +580,10 @@ impl FromBase32 for Fallback { } } -impl FromBase32 for RouteHint { +impl FromBase32 for PrivateRoute { type Err = ParseError; - fn from_base32(field_data: &[u5]) -> Result { + fn from_base32(field_data: &[u5]) -> Result { let bytes = Vec::::from_base32(field_data)?; if bytes.len() % 51 != 0 { @@ -604,7 +615,7 @@ impl FromBase32 for RouteHint { route_hops.push(hop); } - Ok(RouteHint(route_hops)) + Ok(PrivateRoute(RouteHint(route_hops))) } } @@ -634,7 +645,6 @@ pub enum ParseError { /// Not an error, but used internally to signal that a part of the invoice should be ignored /// according to BOLT11 Skip, - TimestampOverflow, } /// Indicates that something went wrong while parsing or validating the invoice. Parsing errors @@ -697,9 +707,6 @@ impl Display for ParseError { ParseError::Skip => { f.write_str("the tagged field has to be skipped because of an unexpected, but allowed property") }, - ParseError::TimestampOverflow => { - f.write_str("the invoice's timestamp could not be represented as SystemTime") - }, } } } @@ -713,8 +720,10 @@ impl Display for ParseOrSemanticError { } } +#[cfg(feature = "std")] impl error::Error for ParseError {} +#[cfg(feature = "std")] impl error::Error for ParseOrSemanticError {} macro_rules! from_error { @@ -786,6 +795,7 @@ mod test { assert_eq!("tb".parse::(), Ok(Currency::BitcoinTestnet)); assert_eq!("bcrt".parse::(), Ok(Currency::Regtest)); assert_eq!("sb".parse::(), Ok(Currency::Simnet)); + assert_eq!("tbs".parse::(), Ok(Currency::Signet)); assert_eq!("something_else".parse::(), Err(ParseError::UnknownCurrency)) } @@ -862,7 +872,7 @@ mod test { use bech32::FromBase32; let input = from_bech32("pu".as_bytes()); - let expected = Ok(ExpiryTime::from_seconds(60).unwrap()); + let expected = Ok(ExpiryTime::from_seconds(60)); assert_eq!(ExpiryTime::from_base32(&input), expected); let input_too_large = from_bech32("sqqqqqqqqqqqq".as_bytes()); @@ -940,8 +950,8 @@ mod test { #[test] fn test_parse_route() { use lightning::routing::network_graph::RoutingFees; - use lightning::routing::router::RouteHintHop; - use ::RouteHint; + use lightning::routing::router::{RouteHint, RouteHintHop}; + use ::PrivateRoute; use bech32::FromBase32; use de::parse_int_be; @@ -986,10 +996,10 @@ mod test { htlc_maximum_msat: None }); - assert_eq!(RouteHint::from_base32(&input), Ok(RouteHint(expected))); + assert_eq!(PrivateRoute::from_base32(&input), Ok(PrivateRoute(RouteHint(expected)))); assert_eq!( - RouteHint::from_base32(&[u5::try_from_u8(0).unwrap(); 40][..]), + PrivateRoute::from_base32(&[u5::try_from_u8(0).unwrap(); 40][..]), Err(ParseError::UnexpectedEndOfTaggedFields) ); } @@ -999,7 +1009,7 @@ mod test { use lightning::ln::features::InvoiceFeatures; use secp256k1::recovery::{RecoveryId, RecoverableSignature}; use TaggedField::*; - use {SiPrefix, SignedRawInvoice, Signature, RawInvoice, RawHrp, RawDataPart, + use {SiPrefix, SignedRawInvoice, InvoiceSignature, RawInvoice, RawHrp, RawDataPart, Currency, Sha256, PositiveTimestamp}; // Feature bits 9, 15, and 99 are set. @@ -1025,7 +1035,7 @@ mod test { hash: [0xb1, 0x96, 0x46, 0xc3, 0xbc, 0x56, 0x76, 0x1d, 0x20, 0x65, 0x6e, 0x0e, 0x32, 0xec, 0xd2, 0x69, 0x27, 0xb7, 0x62, 0x6e, 0x2a, 0x8b, 0xe6, 0x97, 0x71, 0x9f, 0xf8, 0x7e, 0x44, 0x54, 0x55, 0xb9], - signature: Signature(RecoverableSignature::from_compact( + signature: InvoiceSignature(RecoverableSignature::from_compact( &[0xd7, 0x90, 0x4c, 0xc4, 0xb7, 0x4a, 0x22, 0x26, 0x9c, 0x68, 0xc1, 0xdf, 0x68, 0xa9, 0x6c, 0x21, 0x4d, 0x65, 0x1b, 0x93, 0x76, 0xe9, 0xf1, 0x64, 0xd3, 0x60, 0x4d, 0xa4, 0xb7, 0xde, 0xcc, 0xce, 0x0e, 0x82, 0xaa, 0xab, 0x4c, 0x85, 0xd3, @@ -1045,7 +1055,7 @@ mod test { fn test_raw_signed_invoice_deserialization() { use TaggedField::*; use secp256k1::recovery::{RecoveryId, RecoverableSignature}; - use {SignedRawInvoice, Signature, RawInvoice, RawHrp, RawDataPart, Currency, Sha256, + use {SignedRawInvoice, InvoiceSignature, RawInvoice, RawHrp, RawDataPart, Currency, Sha256, PositiveTimestamp}; assert_eq!( @@ -1078,7 +1088,7 @@ mod test { 0x7b, 0x1d, 0x85, 0x8d, 0xb1, 0xd1, 0xf7, 0xab, 0x71, 0x37, 0xdc, 0xb7, 0x83, 0x5d, 0xb2, 0xec, 0xd5, 0x18, 0xe1, 0xc9 ], - signature: Signature(RecoverableSignature::from_compact( + signature: InvoiceSignature(RecoverableSignature::from_compact( & [ 0x38u8, 0xec, 0x68, 0x91, 0x34, 0x5e, 0x20, 0x41, 0x45, 0xbe, 0x8a, 0x3a, 0x99, 0xde, 0x38, 0xe9, 0x8a, 0x39, 0xd6, 0xa5, 0x69, 0x43,