Merge pull request #1692 from TheBlueMatt/2022-08-time-goes-backwards

[rust-lightning] / lightning / src / onion_message / packet.rs

diff --git a/lightning/src/onion_message/packet.rs b/lightning/src/onion_message/packet.rs
index a3414d844edff9cb96f5d6b15cf36e5807b29d9a..1337bdb14d5d6c3bf83fcadc5beebcea8b6d70d8 100644 (file)
--- a/lightning/src/onion_message/packet.rs
+++ b/lightning/src/onion_message/packet.rs
@@ -14,9 +14,9 @@ use bitcoin::secp256k1::ecdh::SharedSecret;
 
 use ln::msgs::DecodeError;
 use ln::onion_utils;
-use super::blinded_route::{ForwardTlvs, ReceiveTlvs};
+use super::blinded_route::{BlindedRoute, ForwardTlvs, ReceiveTlvs};
 use util::chacha20poly1305rfc::{ChaChaPolyReadAdapter, ChaChaPolyWriteAdapter};
-use util::ser::{FixedLengthReader, LengthRead, LengthReadable, LengthReadableArgs, Readable, ReadableArgs, Writeable, Writer};
+use util::ser::{BigSize, FixedLengthReader, LengthRead, LengthReadable, LengthReadableArgs, Readable, ReadableArgs, Writeable, Writer};
 
 use core::cmp;
 use io::{self, Read};
@@ -69,12 +69,12 @@ impl LengthReadable for Packet {
                let public_key = Readable::read(r)?;
 
                let mut hop_data = Vec::new();
-               let hop_data_len = r.total_bytes() as usize - 66; // 1 (version) + 33 (pubkey) + 32 (HMAC) = 66
+               let hop_data_len = r.total_bytes().saturating_sub(66) as usize; // 1 (version) + 33 (pubkey) + 32 (HMAC) = 66
                let mut read_idx = 0;
                while read_idx < hop_data_len {
                        let mut read_buffer = [0; READ_BUFFER_SIZE];
                        let read_amt = cmp::min(hop_data_len - read_idx, READ_BUFFER_SIZE);
-                       r.read_exact(&mut read_buffer[..read_amt]);
+                       r.read_exact(&mut read_buffer[..read_amt])?;
                        hop_data.extend_from_slice(&read_buffer[..read_amt]);
                        read_idx += read_amt;
                }
@@ -98,8 +98,8 @@ pub(super) enum Payload {
        /// This payload is for the final hop.
        Receive {
                control_tlvs: ReceiveControlTlvs,
+               reply_path: Option<BlindedRoute>,
                // Coming soon:
-               // reply_path: Option<BlindedRoute>,
                // message: Message,
        }
 }
@@ -135,21 +135,31 @@ pub(super) enum ReceiveControlTlvs {
 impl Writeable for (Payload, [u8; 32]) {
        fn write<W: Writer>(&self, w: &mut W) -> Result<(), io::Error> {
                match &self.0 {
-                       Payload::Forward(ForwardControlTlvs::Blinded(encrypted_bytes)) |
-                       Payload::Receive { control_tlvs: ReceiveControlTlvs::Blinded(encrypted_bytes)} => {
+                       Payload::Forward(ForwardControlTlvs::Blinded(encrypted_bytes)) => {
                                encode_varint_length_prefixed_tlv!(w, {
                                        (4, encrypted_bytes, vec_type)
                                })
                        },
+                       Payload::Receive {
+                               control_tlvs: ReceiveControlTlvs::Blinded(encrypted_bytes), reply_path
+                       } => {
+                               encode_varint_length_prefixed_tlv!(w, {
+                                       (2, reply_path, option),
+                                       (4, encrypted_bytes, vec_type)
+                               })
+                       },
                        Payload::Forward(ForwardControlTlvs::Unblinded(control_tlvs)) => {
                                let write_adapter = ChaChaPolyWriteAdapter::new(self.1, &control_tlvs);
                                encode_varint_length_prefixed_tlv!(w, {
                                        (4, write_adapter, required)
                                })
                        },
-                       Payload::Receive { control_tlvs: ReceiveControlTlvs::Unblinded(control_tlvs)} => {
+                       Payload::Receive {
+                               control_tlvs: ReceiveControlTlvs::Unblinded(control_tlvs), reply_path,
+                       } => {
                                let write_adapter = ChaChaPolyWriteAdapter::new(self.1, &control_tlvs);
                                encode_varint_length_prefixed_tlv!(w, {
+                                       (2, reply_path, option),
                                        (4, write_adapter, required)
                                })
                        },
@@ -160,21 +170,14 @@ impl Writeable for (Payload, [u8; 32]) {
 
 // Uses the provided secret to simultaneously decode and decrypt the control TLVs.
 impl ReadableArgs<SharedSecret> for Payload {
-       fn read<R: Read>(mut r: &mut R, encrypted_tlvs_ss: SharedSecret) -> Result<Self, DecodeError> {
-               use bitcoin::consensus::encode::{Decodable, Error, VarInt};
-               let v: VarInt = Decodable::consensus_decode(&mut r)
-                       .map_err(|e| match e {
-                               Error::Io(ioe) => DecodeError::from(ioe),
-                               _ => DecodeError::InvalidValue
-                       })?;
-
+       fn read<R: Read>(r: &mut R, encrypted_tlvs_ss: SharedSecret) -> Result<Self, DecodeError> {
+               let v: BigSize = Readable::read(r)?;
                let mut rd = FixedLengthReader::new(r, v.0);
-               // TODO: support reply paths
-               let mut _reply_path_bytes: Option<Vec<u8>> = Some(Vec::new());
+               let mut reply_path: Option<BlindedRoute> = None;
                let mut read_adapter: Option<ChaChaPolyReadAdapter<ControlTlvs>> = None;
                let rho = onion_utils::gen_rho_from_shared_secret(&encrypted_tlvs_ss.secret_bytes());
                decode_tlv_stream!(&mut rd, {
-                       (2, _reply_path_bytes, vec_type),
+                       (2, reply_path, option),
                        (4, read_adapter, (option: LengthReadableArgs, rho))
                });
                rd.eat_remaining().map_err(|_| DecodeError::ShortRead)?;
@@ -185,7 +188,7 @@ impl ReadableArgs<SharedSecret> for Payload {
                                Ok(Payload::Forward(ForwardControlTlvs::Unblinded(tlvs)))
                        },
                        Some(ChaChaPolyReadAdapter { readable: ControlTlvs::Receive(tlvs)}) => {
-                               Ok(Payload::Receive { control_tlvs: ReceiveControlTlvs::Unblinded(tlvs)})
+                               Ok(Payload::Receive { control_tlvs: ReceiveControlTlvs::Unblinded(tlvs), reply_path })
                        },
                }
        }