diff --git a/common/nym-lp/src/codec.rs b/common/nym-lp/src/codec.rs index 794f7a2b49..b8a6b44cbf 100644 --- a/common/nym-lp/src/codec.rs +++ b/common/nym-lp/src/codec.rs @@ -2,7 +2,7 @@ // SPDX-License-Identifier: Apache-2.0 use crate::LpError; -use crate::packet::{EncryptedLpPacket, InnerHeader, LpHeader, LpMessage, LpPacket}; +use crate::packet::{EncryptedLpPacket, InnerHeader, LpFrame, LpHeader, LpPacket}; use bytes::BytesMut; use libcrux_psq::Channel; @@ -46,9 +46,9 @@ pub(crate) fn encrypt_lp_packet( packet: LpPacket, transport: &mut libcrux_psq::session::Transport, ) -> Result { - let mut plaintext = BytesMut::with_capacity(InnerHeader::SIZE + packet.message().len()); + let mut plaintext = BytesMut::with_capacity(InnerHeader::SIZE + packet.frame().len()); packet.header().inner.encode(&mut plaintext); - packet.message().encode(&mut plaintext); + packet.frame().encode(&mut plaintext); let ciphertext = encrypt_data(plaintext.as_ref(), transport)?; @@ -67,14 +67,14 @@ pub(crate) fn decrypt_lp_packet( let inner_header = InnerHeader::parse(&plaintext)?; let payload = &plaintext[InnerHeader::SIZE..]; - let message = LpMessage::decode(payload)?; + let frame = LpFrame::decode(payload)?; Ok(LpPacket::new( LpHeader { outer: packet.outer_header(), inner: inner_header, }, - message, + frame, )) } @@ -82,7 +82,7 @@ pub(crate) fn decrypt_lp_packet( mod tests { use crate::LpError; use crate::codec::{decrypt_data, decrypt_lp_packet, encrypt_data, encrypt_lp_packet}; - use crate::packet::{EncryptedLpPacket, LpHeader, LpMessage, LpPacket}; + use crate::packet::{EncryptedLpPacket, LpFrame, LpHeader, LpPacket}; use crate::peer::mock_peers; use crate::psq::initiator::{build_psq_ciphersuite, build_psq_principal}; use crate::psq::{PSQ_MSG2_SIZE, psq_msg1_size, responder}; @@ -261,7 +261,7 @@ mod tests { // happy path let packet = LpPacket::new( LpHeader::new(123, 0, 1), - LpMessage::new_opaque(b"foomp".to_vec()), + LpFrame::new_opaque(b"foomp".to_vec()), ); let ciphertext = encrypt_lp_packet(packet.clone(), &mut init_transport).unwrap(); @@ -273,7 +273,7 @@ mod tests { // incomplete ciphertext let packet = LpPacket::new( LpHeader::new(123, 1, 1), - LpMessage::new_opaque(b"foomp".to_vec()), + LpFrame::new_opaque(b"foomp".to_vec()), ); let ciphertext2 = encrypt_lp_packet(packet, &mut init_transport).unwrap(); let l = ciphertext2.ciphertext().len(); @@ -285,7 +285,7 @@ mod tests { // too small buffer let packet = LpPacket::new( LpHeader::new(123, 1, 1), - LpMessage::new_opaque(b"foomp".to_vec()), + LpFrame::new_opaque(b"foomp".to_vec()), ); let ciphertext3 = encrypt_lp_packet(packet, &mut resp_transport).unwrap(); let malformed = EncryptedLpPacket::new(ciphertext3.outer_header(), vec![]); diff --git a/common/nym-lp/src/packet/error.rs b/common/nym-lp/src/packet/error.rs index baf1146cbb..281f766080 100644 --- a/common/nym-lp/src/packet/error.rs +++ b/common/nym-lp/src/packet/error.rs @@ -11,8 +11,8 @@ pub enum MalformedLpPacketError { #[error("provided insufficient data to fully deserialise the struct")] InsufficientData, - #[error("{0} is not a valid LpDataKind")] - InvalidLpDataKind(u16), + #[error("{0} is not a valid LpFrameKind value")] + InvalidLpFrameKind(u16), #[error("invalid payload size: expected {expected}, got {actual}")] InvalidPayloadSize { expected: usize, actual: usize }, @@ -27,7 +27,7 @@ pub enum MalformedLpPacketError { } impl MalformedLpPacketError { - pub fn invalid_data_kind(message_type: u16) -> Self { - MalformedLpPacketError::InvalidLpDataKind(message_type) + pub fn invalid_data_kind(frame_kind: u16) -> Self { + MalformedLpPacketError::InvalidLpFrameKind(frame_kind) } } diff --git a/common/nym-lp/src/packet/message.rs b/common/nym-lp/src/packet/frame.rs similarity index 87% rename from common/nym-lp/src/packet/message.rs rename to common/nym-lp/src/packet/frame.rs index 97a2c94fb9..5472b45d1b 100644 --- a/common/nym-lp/src/packet/message.rs +++ b/common/nym-lp/src/packet/frame.rs @@ -7,32 +7,32 @@ use num_enum::{IntoPrimitive, TryFromPrimitive}; use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr}; #[derive(Debug, Clone, PartialEq)] -pub struct LpMessageHeader { - pub kind: LpMessageType, - pub message_attributes: [u8; 14], +pub struct LpFrameHeader { + pub kind: LpFrameKind, + pub frame_attributes: [u8; 14], } -impl LpMessageHeader { +impl LpFrameHeader { pub const SIZE: usize = 16; // message_kind(2) + message_attributes(14) - pub fn new(kind: LpMessageType, message_attributes: [u8; 14]) -> Self { + pub fn new(kind: LpFrameKind, frame_attributes: [u8; 14]) -> Self { Self { kind, - message_attributes, + frame_attributes, } } - pub fn new_no_attributes(kind: LpMessageType) -> Self { + pub fn new_no_attributes(kind: LpFrameKind) -> Self { Self { kind, - message_attributes: [0; 14], + frame_attributes: [0; 14], } } /// Encode directly into a BytesMut buffer pub fn encode(&self, dst: &mut BytesMut) { dst.put_u16_le(self.kind as u16); - dst.put_slice(&self.message_attributes); + dst.put_slice(&self.frame_attributes); } pub fn parse(src: &[u8]) -> Result { @@ -41,35 +41,35 @@ impl LpMessageHeader { } let raw_kind = u16::from_le_bytes([src[0], src[1]]); - let kind = LpMessageType::try_from(raw_kind) + let kind = LpFrameKind::try_from(raw_kind) .map_err(|_| MalformedLpPacketError::invalid_data_kind(raw_kind))?; #[allow(clippy::unwrap_used)] let message_attributes = src[2..16].try_into().unwrap(); Ok(Self { kind, - message_attributes, + frame_attributes: message_attributes, }) } } /// Represent application data being sent in Transport mode #[derive(Debug, Clone, PartialEq)] -pub struct LpMessage { - pub header: LpMessageHeader, +pub struct LpFrame { + pub header: LpFrameHeader, pub content: Bytes, } -impl AsRef<[u8]> for LpMessage { +impl AsRef<[u8]> for LpFrame { fn as_ref(&self) -> &[u8] { &self.content } } -impl LpMessage { - pub fn new(kind: LpMessageType, content: impl Into) -> Self { +impl LpFrame { + pub fn new(kind: LpFrameKind, content: impl Into) -> Self { Self { - header: LpMessageHeader::new_no_attributes(kind), + header: LpFrameHeader::new_no_attributes(kind), content: content.into(), } } @@ -81,37 +81,37 @@ impl LpMessage { } pub fn decode(src: &[u8]) -> Result { - let header = LpMessageHeader::parse(src)?; - let content = src[LpMessageHeader::SIZE..].to_vec().into(); + let header = LpFrameHeader::parse(src)?; + let content = src[LpFrameHeader::SIZE..].to_vec().into(); Ok(Self { header, content }) } - pub fn kind(&self) -> LpMessageType { + pub fn kind(&self) -> LpFrameKind { self.header.kind } pub fn new_opaque(content: impl Into) -> Self { - Self::new(LpMessageType::Opaque, content) + Self::new(LpFrameKind::Opaque, content) } pub fn new_registration(data: impl Into) -> Self { - Self::new(LpMessageType::Registration, data) + Self::new(LpFrameKind::Registration, data) } pub fn new_forward(data: impl Into) -> Self { - Self::new(LpMessageType::Forward, data) + Self::new(LpFrameKind::Forward, data) } pub(crate) fn len(&self) -> usize { - LpMessageHeader::SIZE + self.content.len() + LpFrameHeader::SIZE + self.content.len() } } /// Represent kind of application data being sent in Transport mode #[derive(Clone, Copy, PartialEq, Eq, Debug, IntoPrimitive, TryFromPrimitive)] #[repr(u16)] -pub enum LpMessageType { +pub enum LpFrameKind { Opaque = 0, Registration = 1, Forward = 2, diff --git a/common/nym-lp/src/packet/mod.rs b/common/nym-lp/src/packet/mod.rs index 6ece484603..34fddb9973 100644 --- a/common/nym-lp/src/packet/mod.rs +++ b/common/nym-lp/src/packet/mod.rs @@ -6,12 +6,12 @@ use bytes::{BufMut, BytesMut}; use std::fmt::{Debug, Formatter}; pub use error::MalformedLpPacketError; +pub use frame::{ForwardPacketData, LpFrame}; pub use header::{InnerHeader, LpHeader, OuterHeader}; -pub use message::{ForwardPacketData, LpMessage}; pub mod error; +pub mod frame; pub mod header; -pub mod message; pub mod replay; pub mod utils; @@ -81,7 +81,7 @@ impl EncryptedLpPacket { #[derive(Clone, PartialEq)] pub struct LpPacket { pub(crate) header: LpHeader, - pub(crate) message: LpMessage, + pub(crate) frame: LpFrame, } impl Debug for LpPacket { @@ -91,16 +91,16 @@ impl Debug for LpPacket { } impl LpPacket { - pub fn new(header: LpHeader, message: LpMessage) -> Self { - Self { header, message } + pub fn new(header: LpHeader, frame: LpFrame) -> Self { + Self { header, frame } } - pub fn message(&self) -> &LpMessage { - &self.message + pub fn frame(&self) -> &LpFrame { + &self.frame } - pub fn into_message(self) -> LpMessage { - self.message + pub fn into_frame(self) -> LpFrame { + self.frame } pub fn header(&self) -> &LpHeader { @@ -115,6 +115,6 @@ impl LpPacket { pub(crate) fn dbg_encode(&self, dst: &mut BytesMut) { self.header.dbg_encode(dst); - self.message.encode(dst) + self.frame.encode(dst) } } diff --git a/common/nym-lp/src/session.rs b/common/nym-lp/src/session.rs index b173057cec..dc122d425a 100644 --- a/common/nym-lp/src/session.rs +++ b/common/nym-lp/src/session.rs @@ -6,7 +6,7 @@ //! This module implements session management functionality, including replay protection use crate::codec::{decrypt_lp_packet, encrypt_lp_packet}; -use crate::packet::{EncryptedLpPacket, LpHeader, LpMessage, LpPacket}; +use crate::packet::{EncryptedLpPacket, LpFrame, LpHeader, LpPacket}; use crate::peer::{LpLocalPeer, LpRemotePeer}; use crate::peer_config::LpReceiverIndex; use crate::psq::initiator::HandshakeMode; @@ -32,7 +32,7 @@ pub enum LpInput { ReceivePacket(EncryptedLpPacket), /// Application wants to send data (only valid in Transport state). - SendData(LpMessage), + SendFrame(LpFrame), } /// Represents actions the state machine requests the environment to perform. @@ -42,7 +42,7 @@ pub enum LpAction { SendPacket(EncryptedLpPacket), /// Deliver decrypted application data received from the peer. - DeliverData(LpMessage), + DeliverFrame(LpFrame), } pub type SessionId = [u8; 32]; @@ -234,10 +234,10 @@ impl LpTransportSession { self.protocol_version } - pub fn next_packet(&mut self, message: LpMessage) -> Result { + pub fn next_packet(&mut self, frame: LpFrame) -> Result { let counter = self.next_counter(); let header = LpHeader::new(self.receiver_index(), counter, self.protocol_version); - let packet = LpPacket::new(header, message); + let packet = LpPacket::new(header, frame); Ok(packet) } @@ -299,22 +299,19 @@ impl LpTransportSession { self.receiving_counter.current_packet_cnt() } - /// Encrypts a produced application using the established transport session - /// and produce an `EncryptedLpPacket` + /// Wrap the provided `LpFrame` into an `LpPacket` and encrypt its content using the established transport session + /// to produce an `EncryptedLpPacket` /// /// # Arguments /// - /// * `data` - plaintext data to encrypt + /// * `frame` - structured `LpFrame` to wrap and encrypt /// /// # Returns /// /// * `Ok(EncryptedLpPacket)` containing the encrypted message ciphertext. /// * `Err(LpError)` if the session is not in transport mode or encryption fails. - pub(crate) fn encrypt_application_data( - &mut self, - data: LpMessage, - ) -> Result { - let packet = self.next_packet(data)?; + pub(crate) fn wrap_lp_frame(&mut self, frame: LpFrame) -> Result { + let packet = self.next_packet(frame)?; encrypt_lp_packet(packet, &mut self.active_transport) } @@ -322,7 +319,7 @@ impl LpTransportSession { /// /// # Arguments /// - /// * `ciphertext` - The encrypted packet + /// * `packet` - The encrypted packet /// /// # Returns /// @@ -358,11 +355,11 @@ impl LpTransportSession { self.receiving_counter_mark(ctr)?; // 4. deliver the message - Ok(LpAction::DeliverData(packet.message)) + Ok(LpAction::DeliverFrame(packet.frame)) } - LpInput::SendData(data) => { + LpInput::SendFrame(data) => { // Encrypt and send application data - match self.encrypt_application_data(data) { + match self.wrap_lp_frame(data) { Ok(packet) => Ok(LpAction::SendPacket(packet)), Err(e) => Err(e), } @@ -476,8 +473,9 @@ mod tests { // --- Transport Phase --- println!("--- Step 1: Initiator sends data ---"); - let data_to_send_1 = LpMessage::new_opaque(b"hello responder".to_vec()); - let init_actions_4 = initiator.process_input(LpInput::SendData(data_to_send_1.clone())); + let data_to_send_1 = LpFrame::new_opaque(b"hello responder".to_vec()); + let init_actions_4 = + initiator.process_input(LpInput::SendFrame(data_to_send_1.clone())); let data_packet_1 = if let Ok(LpAction::SendPacket(packet)) = init_actions_4 { packet.clone() } else { @@ -487,7 +485,7 @@ mod tests { println!("--- Step 2: Responder receives data ---"); let resp_actions_5 = responder.process_input(LpInput::ReceivePacket(data_packet_1)); - let resp_data_1 = if let Ok(LpAction::DeliverData(data)) = resp_actions_5 { + let resp_data_1 = if let Ok(LpAction::DeliverFrame(data)) = resp_actions_5 { data } else { panic!("Responder should deliver data"); @@ -495,8 +493,9 @@ mod tests { assert_eq!(resp_data_1, data_to_send_1); println!("--- Step 3: Responder sends data ---"); - let data_to_send_2 = LpMessage::new_opaque(b"hello initiator".to_vec()); - let resp_actions_6 = responder.process_input(LpInput::SendData(data_to_send_2.clone())); + let data_to_send_2 = LpFrame::new_opaque(b"hello initiator".to_vec()); + let resp_actions_6 = + responder.process_input(LpInput::SendFrame(data_to_send_2.clone())); let data_packet_2 = if let Ok(LpAction::SendPacket(packet)) = resp_actions_6 { packet.clone() } else { @@ -506,7 +505,7 @@ mod tests { println!("--- Step 4: Initiator receives data ---"); let init_actions_5 = initiator.process_input(LpInput::ReceivePacket(data_packet_2)); - if let Ok(LpAction::DeliverData(data)) = init_actions_5 { + if let Ok(LpAction::DeliverFrame(data)) = init_actions_5 { assert_eq!(data, data_to_send_2); } else { panic!("Initiator should deliver data"); diff --git a/common/nym-lp/src/session_integration/mod.rs b/common/nym-lp/src/session_integration/mod.rs index f60f8e5d13..e07538f45b 100644 --- a/common/nym-lp/src/session_integration/mod.rs +++ b/common/nym-lp/src/session_integration/mod.rs @@ -1,6 +1,6 @@ #[cfg(test)] mod tests { - use crate::packet::{EncryptedLpPacket, LpMessage}; + use crate::packet::{EncryptedLpPacket, LpFrame}; use crate::session::{LpAction, LpInput}; use crate::{LpError, SessionManager, SessionsMock}; use nym_kkt_ciphersuite::{IntoEnumIterator, KEM}; @@ -9,7 +9,7 @@ mod tests { trait ActionExtract { fn ciphertext(self) -> EncryptedLpPacket; - fn data(self) -> LpMessage; + fn data(self) -> LpFrame; } impl ActionExtract for LpAction { @@ -21,8 +21,8 @@ mod tests { } } - fn data(self) -> LpMessage { - if let LpAction::DeliverData(data) = self { + fn data(self) -> LpFrame { + if let LpAction::DeliverFrame(data) = self { data } else { panic!("invalid action"); @@ -54,7 +54,7 @@ mod tests { // --- A sends to B --- let plaintext_a = format!("A->B Message {i}").into_bytes(); let ciphertext_a = session_manager_1 - .send_data(peer_a_sm, LpMessage::new_opaque(plaintext_a.clone())) + .send_frame(peer_a_sm, LpFrame::new_opaque(plaintext_a.clone())) .unwrap() .ciphertext(); @@ -68,7 +68,7 @@ mod tests { // --- B sends to A --- let plaintext_b = format!("B->A Message {i}").into_bytes(); let ciphertext_b = session_manager_2 - .send_data(peer_b_sm, LpMessage::new_opaque(plaintext_b.clone())) + .send_frame(peer_b_sm, LpFrame::new_opaque(plaintext_b.clone())) .unwrap() .ciphertext(); @@ -183,15 +183,13 @@ mod tests { // --- 3. Simulate Data Transfer via process_input --- println!("Starting data transfer simulation via process_input..."); - let plaintext_a_to_b = - LpMessage::new_opaque(b"Hello from A via process_input!".to_vec()); - let plaintext_b_to_a = - LpMessage::new_opaque(b"Hello from B via process_input!".to_vec()); + let plaintext_a_to_b = LpFrame::new_opaque(b"Hello from A via process_input!".to_vec()); + let plaintext_b_to_a = LpFrame::new_opaque(b"Hello from B via process_input!".to_vec()); // --- A sends to B --- println!(" A sends to B"); let action_a_send = session_manager_1 - .process_input(session_id, LpInput::SendData(plaintext_a_to_b.clone())) + .process_input(session_id, LpInput::SendFrame(plaintext_a_to_b.clone())) .expect("A SendData failed"); let data_packet_a = action_a_send.ciphertext(); @@ -202,7 +200,7 @@ mod tests { .process_input(session_id, LpInput::ReceivePacket(data_packet_a)) .expect("B ReceivePacket (data) failed"); - if let LpAction::DeliverData(data) = action_b_recv { + if let LpAction::DeliverFrame(data) = action_b_recv { assert_eq!(data, plaintext_a_to_b, "Decrypted data mismatch A->B"); println!( " B successfully decrypted: {:?}", @@ -215,7 +213,7 @@ mod tests { // --- B sends to A --- println!(" B sends to A"); let action_b_send = session_manager_2 - .process_input(session_id, LpInput::SendData(plaintext_b_to_a.clone())) + .process_input(session_id, LpInput::SendFrame(plaintext_b_to_a.clone())) .expect("B SendData failed"); let data_packet_b = action_b_send.ciphertext(); @@ -229,7 +227,7 @@ mod tests { .process_input(session_id, LpInput::ReceivePacket(data_packet_b)) .expect("A ReceivePacket (data) failed"); - if let LpAction::DeliverData(data) = action_a_recv { + if let LpAction::DeliverFrame(data) = action_a_recv { assert_eq!(data, plaintext_b_to_a, "Decrypted data mismatch B->A"); println!( " A successfully decrypted: {:?}", @@ -258,11 +256,11 @@ mod tests { println!("Testing out-of-order reception via process_input..."); // A prepares N+1 then N - let data_n_plus_1 = LpMessage::new_opaque(b"Message N+1".to_vec()); - let data_n = LpMessage::new_opaque(b"Message N".to_vec()); + let data_n_plus_1 = LpFrame::new_opaque(b"Message N+1".to_vec()); + let data_n = LpFrame::new_opaque(b"Message N".to_vec()); let action_send_n1 = session_manager_1 - .process_input(session_id, LpInput::SendData(data_n_plus_1.clone())) + .process_input(session_id, LpInput::SendFrame(data_n_plus_1.clone())) .unwrap(); let packet_n1 = match action_send_n1 { LpAction::SendPacket(p) => p, @@ -270,7 +268,7 @@ mod tests { }; let action_send_n = session_manager_1 - .process_input(session_id, LpInput::SendData(data_n.clone())) + .process_input(session_id, LpInput::SendFrame(data_n.clone())) .unwrap(); let packet_n = match action_send_n { LpAction::SendPacket(p) => p, @@ -284,7 +282,7 @@ mod tests { .process_input(session_id, LpInput::ReceivePacket(packet_n1)) .unwrap(); match action_recv_n1 { - LpAction::DeliverData(d) => assert_eq!(d, data_n_plus_1, "Data N+1 mismatch"), + LpAction::DeliverFrame(d) => assert_eq!(d, data_n_plus_1, "Data N+1 mismatch"), _ => panic!("Expected DeliverData for N+1"), } @@ -294,7 +292,7 @@ mod tests { .process_input(session_id, LpInput::ReceivePacket(packet_n)) .unwrap(); match action_recv_n { - LpAction::DeliverData(d) => assert_eq!(d, data_n, "Data N mismatch"), + LpAction::DeliverFrame(d) => assert_eq!(d, data_n, "Data N mismatch"), _ => panic!("Expected DeliverData for N"), } diff --git a/common/nym-lp/src/session_manager.rs b/common/nym-lp/src/session_manager.rs index 8e5dfd2dec..6c54d67bbf 100644 --- a/common/nym-lp/src/session_manager.rs +++ b/common/nym-lp/src/session_manager.rs @@ -6,7 +6,7 @@ //! This module implements session lifecycle management functionality, handling //! creation, retrieval, and storage of sessions. -use crate::packet::{EncryptedLpPacket, LpMessage}; +use crate::packet::{EncryptedLpPacket, LpFrame}; use crate::peer_config::LpReceiverIndex; use crate::{LpError, LpTransportSession}; use std::collections::HashMap; @@ -39,12 +39,12 @@ impl SessionManager { self.with_session_mut(lp_id, |sm| sm.process_input(input))? } - pub fn send_data( + pub fn send_frame( &mut self, lp_id: LpReceiverIndex, - data: LpMessage, + frame: LpFrame, ) -> Result { - self.process_input(lp_id, LpInput::SendData(data)) + self.process_input(lp_id, LpInput::SendFrame(frame)) } pub fn receive_packet( diff --git a/nym-node/src/node/lp/control/ingress/client_handler.rs b/nym-node/src/node/lp/control/ingress/client_handler.rs index 7a3e9e1bd5..5fc23caf0d 100644 --- a/nym-node/src/node/lp/control/ingress/client_handler.rs +++ b/nym-node/src/node/lp/control/ingress/client_handler.rs @@ -6,13 +6,13 @@ use crate::node::lp::control::{LP_DURATION_BUCKETS, LpConnectionStats}; use crate::node::lp::error::LpHandlerError; use crate::node::lp::state::SharedLpClientControlState; use dashmap::mapref::one::RefMut; -use nym_lp::packet::message::LpMessageType; -use nym_lp::packet::{EncryptedLpPacket, ForwardPacketData, LpMessage}; +use nym_lp::packet::frame::LpFrameKind; +use nym_lp::packet::{EncryptedLpPacket, ForwardPacketData, LpFrame}; use nym_lp::peer_config::LpReceiverIndex; use nym_lp::session::{LpAction, LpInput}; use nym_lp::transport::LpHandshakeChannel; use nym_lp::transport::traits::LpTransportChannel; -use nym_lp::{LpTransportSession, packet::message::ExpectedResponseSize}; +use nym_lp::{LpTransportSession, packet::frame::ExpectedResponseSize}; use nym_metrics::{add_histogram_obs, inc}; use nym_node_metrics::NymNodeMetrics; use nym_registration_common::{LpRegistrationRequest, RegistrationStatus}; @@ -225,7 +225,7 @@ where LpAction::SendPacket(response_packet) => { self.send_serialised_packet(&response_packet).await } - LpAction::DeliverData(data) => { + LpAction::DeliverFrame(data) => { // Decrypted application data - process as registration/forwarding self.handle_decrypted_payload(receiver_index, data).await } @@ -236,14 +236,14 @@ where async fn handle_decrypted_payload( &mut self, receiver_idx: LpReceiverIndex, - decrypted_data: LpMessage, + decrypted_data: LpFrame, ) -> Result<(), LpHandlerError> { let remote = self.remote_addr; let header = decrypted_data.header; let bytes = decrypted_data.content; match header.kind { - LpMessageType::Registration => { + LpFrameKind::Registration => { let request = LpRegistrationRequest::try_deserialise(&bytes) .map_err(|source| LpHandlerError::MalformedRegistrationRequest { source })?; @@ -255,13 +255,13 @@ where self.handle_registration_request(receiver_idx, request) .await } - LpMessageType::Forward => { + LpFrameKind::Forward => { let forward_data = ForwardPacketData::decode(&bytes)?; self.handle_forwarding_request(receiver_idx, forward_data) .await } - typ @ LpMessageType::Opaque => { + typ @ LpFrameKind::Opaque => { // Neither registration nor forwarding - unknown payload type warn!( "Unknown transport payload type from {remote} (receiver_idx={receiver_idx}). dropping {} bytes", @@ -277,17 +277,17 @@ where async fn send_response_packet( &mut self, serialised_response: Vec, - response_kind: LpMessageType, + response_kind: LpFrameKind, ) -> Result<(), LpHandlerError> { let mut state_entry = self.state_entry_mut()?; // Access session via state machine for subsession support let state_machine = &mut state_entry.value_mut().state; - let wrapped_lp_data = LpMessage::new(response_kind, serialised_response); + let wrapped_lp_data = LpFrame::new(response_kind, serialised_response); // Process packet through state machine - let action = state_machine.process_input(LpInput::SendData(wrapped_lp_data))?; + let action = state_machine.process_input(LpInput::SendFrame(wrapped_lp_data))?; let packet = match action { LpAction::SendPacket(packet) => packet, @@ -312,7 +312,7 @@ where .serialise() .map_err(|source| LpHandlerError::MalformedRegistrationRequest { source })?; - self.send_response_packet(response_bytes, LpMessageType::Registration) + self.send_response_packet(response_bytes, LpFrameKind::Registration) .await?; match response.status { @@ -349,7 +349,7 @@ where // Forward the packet to the target gateway and retrieve its response let response_bytes = self.handle_forward_packet(forward_data).await?; - self.send_response_packet(response_bytes, LpMessageType::Forward) + self.send_response_packet(response_bytes, LpFrameKind::Forward) .await?; debug!( @@ -646,7 +646,7 @@ mod tests { let packet = handler.receive_raw_packet().await?; let header = packet.outer_header(); assert_eq!(packet.outer_header().receiver_idx, id); - let LpAction::DeliverData(data) = resp_sm.receive_packet(id, packet)? else { + let LpAction::DeliverFrame(data) = resp_sm.receive_packet(id, packet)? else { panic!("illegal state") }; Ok::<_, LpHandlerError>((header, data)) @@ -657,7 +657,7 @@ mod tests { // Send a valid packet from client side let LpAction::SendPacket(packet) = init_sm - .send_data(id, LpMessage::new_opaque(b"foomp".to_vec())) + .send_frame(id, LpFrame::new_opaque(b"foomp".to_vec())) .unwrap() else { panic!("illegal state") @@ -693,7 +693,7 @@ mod tests { let (mut stream, _) = listener.accept().await.unwrap(); let LpAction::SendPacket(packet) = resp_sm - .send_data(id, LpMessage::new_opaque(b"foomp".to_vec())) + .send_frame(id, LpFrame::new_opaque(b"foomp".to_vec())) .unwrap() else { panic!("illegal state") @@ -716,7 +716,7 @@ mod tests { .await .unwrap(); let header = received.outer_header(); - let LpAction::DeliverData(data) = init_sm.receive_packet(id, received).unwrap() else { + let LpAction::DeliverFrame(data) = init_sm.receive_packet(id, received).unwrap() else { panic!("illegal state") }; diff --git a/nym-node/src/node/lp/error.rs b/nym-node/src/node/lp/error.rs index 865d4ccaab..c86b34b911 100644 --- a/nym-node/src/node/lp/error.rs +++ b/nym-node/src/node/lp/error.rs @@ -1,7 +1,7 @@ // Copyright 2026 - Nym Technologies SA // SPDX-License-Identifier: Apache-2.0 -use nym_lp::packet::message::LpMessageType; +use nym_lp::packet::frame::LpFrameKind; use nym_lp::peer_config::LpReceiverIndex; use nym_lp::session::LpAction; use nym_lp::transport::LpTransportError; @@ -43,7 +43,7 @@ pub enum LpHandlerError { MalformedLpPacket(#[from] MalformedLpPacketError), #[error("received payload type of an unexpected type: {typ:?}")] - UnexpectedLpPayload { typ: LpMessageType }, + UnexpectedLpPayload { typ: LpFrameKind }, #[error("timed out while attempting to send to/receive from the connection")] ConnectionTimeout, diff --git a/nym-registration-client/src/lp_client/client.rs b/nym-registration-client/src/lp_client/client.rs index c1de9db024..ab182154bd 100644 --- a/nym-registration-client/src/lp_client/client.rs +++ b/nym-registration-client/src/lp_client/client.rs @@ -5,7 +5,9 @@ use super::config::LpRegistrationConfig; use super::error::{LpClientError, Result}; -use crate::lp_client::helpers::{LpDataDeliverExt, LpDataSendExt, exponential_backoff_with_jitter}; +use crate::lp_client::helpers::{ + LpFrameDeliverExt, LpFrameSendExt, exponential_backoff_with_jitter, +}; use crate::lp_client::nested_session::connection::NestedConnection; use crate::lp_client::session_helpers::{extract_forwarded_response, prepare_send_packet}; use nym_bandwidth_controller::{BandwidthTicketProvider, DEFAULT_TICKETS_TO_SPEND}; @@ -458,7 +460,7 @@ where tracing::trace!("Built dVPN registration finalisation request"); // 3. Serialize the request - let lp_data = request.to_lp_data()?; + let lp_data = request.to_lp_frame()?; // 4. Encrypt and prepare packet via state machine let state_machine = self.transport_session_mut()?; @@ -477,7 +479,7 @@ where let received_data = extract_forwarded_response(response_packet, state_machine)?; // 7. Extract decrypted data and deserialise the response - let response = LpRegistrationResponse::from_lp_data(received_data)?; + let response = LpRegistrationResponse::from_lp_frame(received_data)?; let Some(dvpn_response) = response.into_dvpn_response() else { return Err(LpClientError::unexpected_response( "did not get a dvpn registration response after sending initial request", @@ -545,7 +547,7 @@ where tracing::trace!("Built dVPN registration request: {request:?}"); // 2. Serialize the request - let lp_data = request.to_lp_data()?; + let lp_data = request.to_lp_frame()?; // 3. Encrypt and prepare packet via state machine let state_machine = self.transport_session_mut()?; @@ -564,7 +566,7 @@ where let received_data = extract_forwarded_response(response_packet, state_machine)?; // 6. Extract decrypted data and deserialise the response - let response = LpRegistrationResponse::from_lp_data(received_data)?; + let response = LpRegistrationResponse::from_lp_frame(received_data)?; let Some(dvpn_response) = response.into_dvpn_response() else { return Err(LpClientError::unexpected_response( "did not get a dvpn registration response after sending initial request", diff --git a/nym-registration-client/src/lp_client/error.rs b/nym-registration-client/src/lp_client/error.rs index 1bf138fabb..168ee3836e 100644 --- a/nym-registration-client/src/lp_client/error.rs +++ b/nym-registration-client/src/lp_client/error.rs @@ -5,7 +5,7 @@ use nym_lp::LpError; use nym_lp::packet::MalformedLpPacketError; -use nym_lp::packet::message::LpMessageType; +use nym_lp::packet::frame::LpFrameKind; use nym_lp::session::LpAction; use nym_lp::transport::LpTransportError; use thiserror::Error; @@ -43,7 +43,7 @@ pub enum LpClientError { MalformedLpPacket(#[from] MalformedLpPacketError), #[error("received payload type of an unexpected type: {typ:?}")] - UnexpectedLpPayload { typ: LpMessageType }, + UnexpectedLpPayload { typ: LpFrameKind }, #[error("timed out while attempting to finish the KKT/PSQ handshake")] HandshakeTimeout, diff --git a/nym-registration-client/src/lp_client/helpers.rs b/nym-registration-client/src/lp_client/helpers.rs index d3a5ab02d6..bda1a67a69 100644 --- a/nym-registration-client/src/lp_client/helpers.rs +++ b/nym-registration-client/src/lp_client/helpers.rs @@ -4,8 +4,8 @@ #![allow(dead_code)] use crate::LpClientError; -use nym_lp::packet::message::LpMessageType; -use nym_lp::packet::{ForwardPacketData, LpMessage}; +use nym_lp::packet::frame::LpFrameKind; +use nym_lp::packet::{ForwardPacketData, LpFrame}; use nym_lp::peer::LpRemotePeer; use nym_lp::session::{LpAction, LpInput}; use nym_registration_common::{ @@ -13,16 +13,16 @@ use nym_registration_common::{ }; use rand09::Rng; -pub(crate) trait LpDataSendExt { - fn to_lp_data(&self) -> Result; +pub(crate) trait LpFrameSendExt { + fn to_lp_frame(&self) -> Result; } -pub(crate) trait LpDataDeliverExt: Sized { - fn from_lp_data(data: LpMessage) -> Result; +pub(crate) trait LpFrameDeliverExt: Sized { + fn from_lp_frame(frame: LpFrame) -> Result; } -impl LpDataSendExt for LpRegistrationRequest { - fn to_lp_data(&self) -> Result { +impl LpFrameSendExt for LpRegistrationRequest { + fn to_lp_frame(&self) -> Result { let request_bytes = self.serialise().map_err(|e| { LpClientError::SendRegistrationRequest(format!("Failed to serialize request: {e}")) })?; @@ -32,25 +32,25 @@ impl LpDataSendExt for LpRegistrationRequest { request_bytes.len() ); - Ok(LpMessage::new_registration(request_bytes)) + Ok(LpFrame::new_registration(request_bytes)) } } -impl LpDataDeliverExt for LpRegistrationResponse { - fn from_lp_data(data: LpMessage) -> Result { - if data.kind() != LpMessageType::Registration { - return Err(LpClientError::UnexpectedLpPayload { typ: data.kind() }); +impl LpFrameDeliverExt for LpRegistrationResponse { + fn from_lp_frame(frame: LpFrame) -> Result { + if frame.kind() != LpFrameKind::Registration { + return Err(LpClientError::UnexpectedLpPayload { typ: frame.kind() }); } - let response = LpRegistrationResponse::try_deserialise(&data.content) + let response = LpRegistrationResponse::try_deserialise(&frame.content) .map_err(|source| LpClientError::MalformedRegistrationData { source })?; Ok(response) } } -impl LpDataSendExt for ForwardPacketData { - fn to_lp_data(&self) -> Result { +impl LpFrameSendExt for ForwardPacketData { + fn to_lp_frame(&self) -> Result { let request_bytes = self.to_bytes(); tracing::trace!( @@ -58,21 +58,21 @@ impl LpDataSendExt for ForwardPacketData { request_bytes.len() ); - Ok(LpMessage::new_forward(request_bytes)) + Ok(LpFrame::new_forward(request_bytes)) } } pub(crate) fn convert_forward_data(request: ForwardPacketData) -> Result { - Ok(LpInput::SendData(request.to_lp_data()?)) + Ok(LpInput::SendFrame(request.to_lp_frame()?)) } pub(crate) fn try_convert_forward_response(action: LpAction) -> Result, LpClientError> { let response_data = match action { - LpAction::DeliverData(data) => data, + LpAction::DeliverFrame(data) => data, action => return Err(LpClientError::UnexpectedStateMachineAction { action }), }; - if response_data.kind() != LpMessageType::Forward { + if response_data.kind() != LpFrameKind::Forward { return Err(LpClientError::UnexpectedLpPayload { typ: response_data.kind(), }); diff --git a/nym-registration-client/src/lp_client/nested_session/connection.rs b/nym-registration-client/src/lp_client/nested_session/connection.rs index c4e54015ac..c446998756 100644 --- a/nym-registration-client/src/lp_client/nested_session/connection.rs +++ b/nym-registration-client/src/lp_client/nested_session/connection.rs @@ -5,7 +5,7 @@ use crate::lp_client::helpers::{convert_forward_data, try_convert_forward_respon use crate::{LpClientError, LpRegistrationClient}; use bytes::{BufMut, BytesMut}; use nym_lp::KEM; -use nym_lp::packet::{EncryptedLpPacket, ForwardPacketData, message::ExpectedResponseSize}; +use nym_lp::packet::{EncryptedLpPacket, ForwardPacketData, frame::ExpectedResponseSize}; use nym_lp::session::{LpAction, LpInput}; use nym_lp::transport::traits::{HandshakeMessage, LpTransportChannel}; use nym_lp::transport::{LpHandshakeChannel, LpTransportError}; diff --git a/nym-registration-client/src/lp_client/nested_session/mod.rs b/nym-registration-client/src/lp_client/nested_session/mod.rs index 5cf8e98434..b6705c9147 100644 --- a/nym-registration-client/src/lp_client/nested_session/mod.rs +++ b/nym-registration-client/src/lp_client/nested_session/mod.rs @@ -20,13 +20,15 @@ use super::client::LpRegistrationClient; use super::error::{LpClientError, Result}; -use crate::lp_client::helpers::{LpDataDeliverExt, LpDataSendExt, exponential_backoff_with_jitter}; +use crate::lp_client::helpers::{ + LpFrameDeliverExt, LpFrameSendExt, exponential_backoff_with_jitter, +}; use crate::lp_client::session_helpers::{extract_forwarded_response, prepare_send_packet}; use nym_bandwidth_controller::{BandwidthTicketProvider, DEFAULT_TICKETS_TO_SPEND}; use nym_credentials_interface::TicketType; use nym_crypto::asymmetric::{ed25519, x25519}; use nym_lp::packet::version; -use nym_lp::packet::{EncryptedLpPacket, LpMessage}; +use nym_lp::packet::{EncryptedLpPacket, LpFrame}; use nym_lp::peer::{DHKeyPair, LpLocalPeer, LpRemotePeer}; use nym_lp::psq::initiator::HandshakeMode; use nym_lp::transport::LpHandshakeChannel; @@ -126,19 +128,19 @@ impl NestedLpSession { .ok_or(LpClientError::IncompleteHandshake) } - /// Attempt to wrap the provided `LpData` into a `EncryptedLpPacket` + /// Attempt to wrap the provided `LpFrame` into a `EncryptedLpPacket` /// using the inner state machine. - fn prepare_transport_packet(&mut self, data: LpMessage) -> Result { + fn prepare_transport_packet(&mut self, frame: LpFrame) -> Result { let state_machine = self.state_machine_mut()?; - prepare_send_packet(data, state_machine) + prepare_send_packet(frame, state_machine) } - /// Attempt to recover received `LpData` from the received `EncryptedLpPacket` + /// Attempt to recover received `LpFrame` from the received `EncryptedLpPacket` /// using the inner state machine. fn extract_forwarded_response( &mut self, response_packet: EncryptedLpPacket, - ) -> Result { + ) -> Result { let state_machine = self.state_machine_mut()?; extract_forwarded_response(response_packet, state_machine) } @@ -255,7 +257,7 @@ impl NestedLpSession { tracing::trace!("Built dVPN registration finalisation request"); // Step 3: Serialize the request - let send_data = request.to_lp_data()?; + let send_data = request.to_lp_frame()?; // Step 4: Encrypt and prepare packet via state machine let forward_packet = self.prepare_transport_packet(send_data)?; @@ -274,7 +276,7 @@ impl NestedLpSession { let response_data = self.extract_forwarded_response(response)?; // Step 8: Extract decrypted data and deserialise the response - let response = LpRegistrationResponse::from_lp_data(response_data)?; + let response = LpRegistrationResponse::from_lp_frame(response_data)?; let Some(dvpn_response) = response.into_dvpn_response() else { return Err(LpClientError::unexpected_response( "did not get a dvpn registration response after sending initial request", @@ -349,7 +351,7 @@ impl NestedLpSession { let request = LpRegistrationRequest::new_initial_dvpn(wg_public_key, psk); // Step 3: Serialize the request - let send_data = request.to_lp_data()?; + let send_data = request.to_lp_frame()?; // Step 4: Encrypt and prepare packet via state machine let forward_packet = self.prepare_transport_packet(send_data)?; @@ -369,7 +371,7 @@ impl NestedLpSession { let response_data = self.extract_forwarded_response(response)?; // Step 8: Extract decrypted data and deserialise the response - let response = LpRegistrationResponse::from_lp_data(response_data)?; + let response = LpRegistrationResponse::from_lp_frame(response_data)?; let Some(dvpn_response) = response.into_dvpn_response() else { return Err(LpClientError::unexpected_response( "did not get a dvpn registration response after sending initial request", diff --git a/nym-registration-client/src/lp_client/session_helpers.rs b/nym-registration-client/src/lp_client/session_helpers.rs index bbb15fd177..fa7d0c9ef6 100644 --- a/nym-registration-client/src/lp_client/session_helpers.rs +++ b/nym-registration-client/src/lp_client/session_helpers.rs @@ -2,17 +2,17 @@ // SPDX-License-Identifier: Apache-2.0 use crate::LpClientError; -use nym_lp::packet::LpMessage; +use nym_lp::packet::LpFrame; use nym_lp::session::{LpAction, LpInput}; use nym_lp::{LpTransportSession, packet::EncryptedLpPacket}; /// Attempt to prepare the provided data for sending by wrapping it in appropriate `LpAction`, /// and attempting to extract `EncryptedLpPacket` from the provided state machine. pub(crate) fn prepare_send_packet( - data: LpMessage, + frame: LpFrame, state_machine: &mut LpTransportSession, ) -> Result { - let action = state_machine.process_input(LpInput::SendData(data))?; + let action = state_machine.process_input(LpInput::SendFrame(frame))?; match action { LpAction::SendPacket(packet) => Ok(packet), @@ -25,11 +25,11 @@ pub(crate) fn prepare_send_packet( pub(crate) fn extract_forwarded_response( response_packet: EncryptedLpPacket, state_machine: &mut LpTransportSession, -) -> Result { +) -> Result { let action = state_machine.process_input(LpInput::ReceivePacket(response_packet))?; match action { - LpAction::DeliverData(data) => Ok(data), + LpAction::DeliverFrame(frame) => Ok(frame), action => Err(LpClientError::UnexpectedStateMachineAction { action }), } }