From f0de459c587d7d05ae06702189e46bcd7e7ad6fd Mon Sep 17 00:00:00 2001 From: durch Date: Thu, 27 Apr 2023 09:45:25 +0200 Subject: [PATCH] Rebase on develop commit 342883fcbe41276f62fe18a8637978e82b05c945 Author: durch Date: Thu Apr 27 09:17:18 2023 +0200 Put back PacketType 1 commit 61a0ee5a193bd61343ffe86cce2e853321263a4d Author: Tommy Verrall Date: Wed Apr 26 16:37:29 2023 +0100 change output for cpu-cycle management logs commit 3956109c7ef4b5ec6d4b5e47070327a959e201dd Author: Tommy Verrall Date: Wed Apr 26 12:13:22 2023 +0100 change the workflow file to build with cpucycles commit 8d725b13c5cb0fd8456f26d577516e7bfd9d8b94 Author: durch Date: Mon Apr 24 13:14:58 2023 +0200 Outfox client compat commit 4d166c389bf65da6b8d1d360352650061e3a6c30 Author: durch Date: Fri Apr 21 00:30:46 2023 +0200 Address PR comments commit 145c3c1223af68d719a0004a5d81dc3ef0480409 Author: durch Date: Fri Apr 21 00:12:35 2023 +0200 Rename PacketMode commit cbd654d6fdfb05f7b1cb8d66bf81aebda76f7586 Author: Drazen Urch Date: Thu Apr 20 23:59:40 2023 +0200 Outfox rest compat (#3333) * Outfox forwarding compat * Tidy up interface * PacketSize compat commit e7be91a94cac7669471445236ff03165ebdf4fbc Author: durch Date: Wed Apr 19 16:36:48 2023 +0200 Remove serde cruft commit 582e7d566a5b7b94e64ee10d12994f2fef2e6cb1 Author: durch Date: Wed Apr 19 16:24:09 2023 +0200 Outfox framing commit 6464da5f01969d67d8efc8767d830218d8880efd Author: durch Date: Tue Apr 18 22:23:02 2023 +0200 Framing compat commit d5e77e499b197c043c827ad67ca4f02877b479f8 Author: durch Date: Tue Apr 18 18:18:54 2023 +0200 Framed encoding serde POC commit f086f9c35ab8158ca07c3b4a9be126c0a4559d10 Author: durch Date: Tue Apr 18 16:54:21 2023 +0200 Experiment with serde --- .../build-and-upload-binaries-ci.yml | 2 +- Cargo.lock | 1 + clients/native/src/client/mod.rs | 16 ++++-- clients/native/src/websocket/handler.rs | 13 ++++- clients/webassembly/src/client/mod.rs | 15 +++-- .../client-core/src/client/base_client/mod.rs | 10 ++-- .../src/client/cover_traffic_stream.rs | 2 +- .../src/client/inbound_messages.rs | 57 +++++++++++++++++-- common/client-core/src/client/mix_traffic.rs | 6 +- .../input_message_listener.rs | 48 ++++++++++++++-- .../retransmission_request_listener.rs | 6 +- .../real_messages_control/message_handler.rs | 21 +++++-- .../real_traffic_stream.rs | 4 +- .../client/replies/reply_controller/mod.rs | 6 +- .../src/client/transmission_buffer.rs | 2 +- common/node-tester-utils/Cargo.toml | 1 + common/node-tester-utils/src/tester.rs | 10 +++- common/nymsphinx/framing/src/codec.rs | 1 + common/nymsphinx/params/src/packet_types.rs | 3 + common/nymsphinx/src/preparer/mod.rs | 33 ++++++++--- common/nymsphinx/types/src/lib.rs | 2 +- common/socks5-client-core/src/socks/client.rs | 15 ++++- common/socks5-client-core/src/socks/server.rs | 1 + common/topology/src/lib.rs | 7 +++ contracts/Cargo.lock | 4 +- mixnode/src/main.rs | 7 ++- nym-api/src/network_monitor/chunker.rs | 14 ++++- nym-api/src/network_monitor/mod.rs | 2 + nym-api/src/network_monitor/monitor/mod.rs | 14 ++++- .../src/network_monitor/monitor/preparer.rs | 14 ++++- nym-outfox/src/error.rs | 2 +- nym-outfox/src/format.rs | 4 +- nym-outfox/src/packet.rs | 2 +- sdk/rust/nym-sdk/src/mixnet/client.rs | 1 + sdk/rust/nym-sdk/src/mixnet/native_client.rs | 8 ++- 35 files changed, 284 insertions(+), 70 deletions(-) diff --git a/.github/workflows/build-and-upload-binaries-ci.yml b/.github/workflows/build-and-upload-binaries-ci.yml index 537e239753..fd761ff459 100644 --- a/.github/workflows/build-and-upload-binaries-ci.yml +++ b/.github/workflows/build-and-upload-binaries-ci.yml @@ -69,7 +69,7 @@ jobs: uses: actions-rs/cargo@v1 with: command: build - args: --workspace --release --all + args: --workspace --release --all --features cpucycles - name: Install Rust stable uses: actions-rs/toolchain@v1 diff --git a/Cargo.lock b/Cargo.lock index 3254d538f6..4a57486580 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3786,6 +3786,7 @@ dependencies = [ "log", "nym-crypto", "nym-sphinx", + "nym-sphinx-params", "nym-task", "nym-topology", "rand 0.7.3", diff --git a/clients/native/src/client/mod.rs b/clients/native/src/client/mod.rs index 8672745329..ed1be01e30 100644 --- a/clients/native/src/client/mod.rs +++ b/clients/native/src/client/mod.rs @@ -16,6 +16,7 @@ use nym_client_core::client::received_buffer::{ }; use nym_client_core::config::persistence::key_pathfinder::ClientKeyPathfinder; use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag; +use nym_sphinx::params::PacketType; use nym_task::connections::TransmissionLane; use nym_task::TaskManager; use nym_validator_client::nyxd::QueryNyxdClient; @@ -119,6 +120,7 @@ impl SocketClient { self_address, shared_lane_queue_lengths, reply_controller_sender, + None, ); websocket::Listener::new(config.get_listening_ip(), config.get_listening_port()) @@ -178,7 +180,10 @@ impl SocketClient { Ok(started_client.task_manager) } - pub async fn start_direct(self) -> Result { + pub async fn start_direct( + self, + packet_type: Option, + ) -> Result { if self.config.get_socket_type().is_websocket() { return Err(ClientError::InvalidSocketMode); } @@ -224,6 +229,7 @@ impl SocketClient { reconstructed_receiver, address, shutdown_notifier: started_client.task_manager, + packet_type, }) } } @@ -237,6 +243,7 @@ pub struct DirectClient { // we need to keep reference to this guy otherwise things will start dropping shutdown_notifier: TaskManager, + packet_type: Option, } impl DirectClient { @@ -257,7 +264,7 @@ impl DirectClient { /// well enough in local tests) pub async fn send_regular_message(&mut self, recipient: Recipient, message: Vec) { let lane = TransmissionLane::General; - let input_msg = InputMessage::new_regular(recipient, message, lane); + let input_msg = InputMessage::new_regular(recipient, message, lane, self.packet_type); self.client_input .input_sender @@ -276,7 +283,8 @@ impl DirectClient { reply_surbs: u32, ) { let lane = TransmissionLane::General; - let input_msg = InputMessage::new_anonymous(recipient, message, reply_surbs, lane); + let input_msg = + InputMessage::new_anonymous(recipient, message, reply_surbs, lane, self.packet_type); self.client_input .input_sender @@ -290,7 +298,7 @@ impl DirectClient { /// well enough in local tests) pub async fn send_reply(&mut self, recipient_tag: AnonymousSenderTag, message: Vec) { let lane = TransmissionLane::General; - let input_msg = InputMessage::new_reply(recipient_tag, message, lane); + let input_msg = InputMessage::new_reply(recipient_tag, message, lane, self.packet_type); self.client_input .input_sender diff --git a/clients/native/src/websocket/handler.rs b/clients/native/src/websocket/handler.rs index a0eebbf9be..3830a31894 100644 --- a/clients/native/src/websocket/handler.rs +++ b/clients/native/src/websocket/handler.rs @@ -14,6 +14,7 @@ use nym_client_core::client::{ use nym_client_websocket_requests::{requests::ClientRequest, responses::ServerResponse}; use nym_sphinx::addressing::clients::Recipient; use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag; +use nym_sphinx::params::PacketType; use nym_sphinx::receiver::ReconstructedMessage; use nym_task::connections::{ ConnectionCommand, ConnectionCommandSender, ConnectionId, LaneQueueLengths, TransmissionLane, @@ -41,6 +42,7 @@ pub(crate) struct HandlerBuilder { self_full_address: Recipient, lane_queue_lengths: LaneQueueLengths, reply_controller_sender: ReplyControllerSender, + packet_type: Option, } impl HandlerBuilder { @@ -51,6 +53,7 @@ impl HandlerBuilder { self_full_address: &Recipient, lane_queue_lengths: LaneQueueLengths, reply_controller_sender: ReplyControllerSender, + packet_type: Option, ) -> Self { Self { msg_input, @@ -59,6 +62,7 @@ impl HandlerBuilder { self_full_address: *self_full_address, lane_queue_lengths, reply_controller_sender, + packet_type, } } @@ -73,6 +77,7 @@ impl HandlerBuilder { received_response_type: Default::default(), lane_queue_lengths: self.lane_queue_lengths.clone(), reply_controller_sender: self.reply_controller_sender.clone(), + packet_type: self.packet_type, } } } @@ -86,6 +91,7 @@ pub(crate) struct Handler { received_response_type: ReceivedResponseType, lane_queue_lengths: LaneQueueLengths, reply_controller_sender: ReplyControllerSender, + packet_type: Option, } impl Drop for Handler { @@ -160,7 +166,7 @@ impl Handler { }); // the ack control is now responsible for chunking, etc. - let input_msg = InputMessage::new_regular(recipient, message, lane); + let input_msg = InputMessage::new_regular(recipient, message, lane, self.packet_type); self.msg_input .send(input_msg) .await @@ -191,7 +197,8 @@ impl Handler { TransmissionLane::ConnectionId(id) }); - let input_msg = InputMessage::new_anonymous(recipient, message, reply_surbs, lane); + let input_msg = + InputMessage::new_anonymous(recipient, message, reply_surbs, lane, self.packet_type); self.msg_input .send(input_msg) .await @@ -218,7 +225,7 @@ impl Handler { TransmissionLane::ConnectionId(id) }); - let input_msg = InputMessage::new_reply(recipient_tag, message, lane); + let input_msg = InputMessage::new_reply(recipient_tag, message, lane, self.packet_type); self.msg_input .send(input_msg) .await diff --git a/clients/webassembly/src/client/mod.rs b/clients/webassembly/src/client/mod.rs index ae3a814326..02cc7a5057 100644 --- a/clients/webassembly/src/client/mod.rs +++ b/clients/webassembly/src/client/mod.rs @@ -21,6 +21,7 @@ use nym_client_core::config::{ CoverTraffic, DebugConfig, GatewayEndpointConfig, Topology, Traffic, }; use nym_credential_storage::ephemeral_storage::EphemeralStorage; +use nym_sphinx::params::PacketType; use nym_task::connections::TransmissionLane; use nym_task::TaskManager; use nym_topology::provider_trait::{HardcodedTopologyProvider, TopologyProvider}; @@ -49,6 +50,7 @@ pub struct NymClient { // even though we don't use graceful shutdowns, other components rely on existence of this struct // and if it's dropped, everything will start going offline _task_manager: TaskManager, + packet_type: Option, } #[wasm_bindgen] @@ -67,6 +69,7 @@ pub struct NymClientBuilder { bandwidth_controller: Option, EphemeralStorage>>, disabled_credentials: bool, + packet_type: Option, } #[wasm_bindgen] @@ -82,6 +85,7 @@ impl NymClientBuilder { on_message, bandwidth_controller: None, disabled_credentials: true, + packet_type: None, } } @@ -132,6 +136,7 @@ impl NymClientBuilder { on_message, bandwidth_controller: None, disabled_credentials: true, + packet_type: None, } } @@ -189,6 +194,7 @@ impl NymClientBuilder { client_state: Arc::new(started_client.client_state), _full_topology: None, _task_manager: started_client.task_manager, + packet_type: self.packet_type, }) } @@ -255,7 +261,7 @@ impl NymClient { let input_msgs = request .test_msgs .into_iter() - .map(|p| InputMessage::new_regular(recipient, p, lane)) + .map(|p| InputMessage::new_regular(recipient, p, lane, None)) .collect(); self.client_input.send_messages(input_msgs) @@ -275,7 +281,7 @@ impl NymClient { let lane = TransmissionLane::General; - let input_msg = InputMessage::new_regular(recipient, message, lane); + let input_msg = InputMessage::new_regular(recipient, message, lane, self.packet_type); self.client_input.send_message(input_msg) } @@ -302,7 +308,8 @@ impl NymClient { let lane = TransmissionLane::General; - let input_msg = InputMessage::new_anonymous(recipient, message, reply_surbs, lane); + let input_msg = + InputMessage::new_anonymous(recipient, message, reply_surbs, lane, self.packet_type); self.client_input.send_message(input_msg) } @@ -320,7 +327,7 @@ impl NymClient { let lane = TransmissionLane::General; - let input_msg = InputMessage::new_reply(sender_tag, message, lane); + let input_msg = InputMessage::new_reply(sender_tag, message, lane, self.packet_type); self.client_input.send_message(input_msg) } } diff --git a/common/client-core/src/client/base_client/mod.rs b/common/client-core/src/client/base_client/mod.rs index ead3a7a1a0..3708bc122a 100644 --- a/common/client-core/src/client/base_client/mod.rs +++ b/common/client-core/src/client/base_client/mod.rs @@ -409,7 +409,7 @@ where Ok(()) } - // controller for sending sphinx packets to mixnet (either real traffic or cover traffic) + // controller for sending packets to mixnet (either real traffic or cover traffic) // TODO: if we want to send control messages to gateway_client, this CAN'T take the ownership // over it. Perhaps GatewayClient needs to be thread-shareable or have some channel for // requests? @@ -524,11 +524,11 @@ where task_manager.subscribe(), ); - // The sphinx_message_sender is the transmitter for any component generating sphinx packets + // The message_sender is the transmitter for any component generating sphinx packets // that are to be sent to the mixnet. They are used by cover traffic stream and real // traffic stream. // The MixTrafficController then sends the actual traffic - let sphinx_message_sender = + let message_sender = Self::start_mix_traffic_controller(gateway_client, task_manager.subscribe()); // Channels that the websocket listener can use to signal downstream to the real traffic @@ -550,7 +550,7 @@ where shared_topology_accessor.clone(), ack_receiver, input_receiver, - sphinx_message_sender.clone(), + message_sender.clone(), reply_storage, reply_controller_sender.clone(), reply_controller_receiver, @@ -569,7 +569,7 @@ where self.key_manager.ack_key(), self_address, shared_topology_accessor.clone(), - sphinx_message_sender, + message_sender, task_manager.subscribe(), ); } diff --git a/common/client-core/src/client/cover_traffic_stream.rs b/common/client-core/src/client/cover_traffic_stream.rs index 41048a1461..c961e95484 100644 --- a/common/client-core/src/client/cover_traffic_stream.rs +++ b/common/client-core/src/client/cover_traffic_stream.rs @@ -45,7 +45,7 @@ where #[cfg(target_arch = "wasm32")] next_delay: Pin>, - /// Channel used for sending prepared sphinx packets to `MixTrafficController` that sends them + /// Channel used for sending prepared nym packets to `MixTrafficController` that sends them /// out to the network without any further delays. mix_tx: BatchMixMessageSender, diff --git a/common/client-core/src/client/inbound_messages.rs b/common/client-core/src/client/inbound_messages.rs index 0a1e93c435..1530073d3f 100644 --- a/common/client-core/src/client/inbound_messages.rs +++ b/common/client-core/src/client/inbound_messages.rs @@ -4,6 +4,7 @@ use nym_sphinx::addressing::clients::Recipient; use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag; use nym_sphinx::forwarding::packet::MixPacket; +use nym_sphinx::params::PacketType; use nym_task::connections::TransmissionLane; pub type InputMessageSender = tokio::sync::mpsc::Sender; @@ -53,18 +54,49 @@ pub enum InputMessage { data: Vec, lane: TransmissionLane, }, + + MessageWrapper { + message: Box, + packet_type: PacketType, + }, } impl InputMessage { - pub fn new_premade(msgs: Vec, lane: TransmissionLane) -> Self { - InputMessage::Premade { msgs, lane } + pub fn new_premade( + msgs: Vec, + lane: TransmissionLane, + packet_type: PacketType, + ) -> Self { + let message = InputMessage::Premade { msgs, lane }; + if packet_type == PacketType::Mix { + message + } else { + InputMessage::new_wrapper(message, packet_type) + } } - pub fn new_regular(recipient: Recipient, data: Vec, lane: TransmissionLane) -> Self { - InputMessage::Regular { + pub fn new_wrapper(message: InputMessage, packet_type: PacketType) -> Self { + InputMessage::MessageWrapper { + message: Box::new(message), + packet_type, + } + } + + pub fn new_regular( + recipient: Recipient, + data: Vec, + lane: TransmissionLane, + packet_type: Option, + ) -> Self { + let message = InputMessage::Regular { recipient, data, lane, + }; + if let Some(packet_type) = packet_type { + InputMessage::new_wrapper(message, packet_type) + } else { + message } } @@ -73,12 +105,18 @@ impl InputMessage { data: Vec, reply_surbs: u32, lane: TransmissionLane, + packet_type: Option, ) -> Self { - InputMessage::Anonymous { + let message = InputMessage::Anonymous { recipient, data, reply_surbs, lane, + }; + if let Some(packet_type) = packet_type { + InputMessage::new_wrapper(message, packet_type) + } else { + message } } @@ -86,11 +124,17 @@ impl InputMessage { recipient_tag: AnonymousSenderTag, data: Vec, lane: TransmissionLane, + packet_type: Option, ) -> Self { - InputMessage::Reply { + let message = InputMessage::Reply { recipient_tag, data, lane, + }; + if let Some(packet_type) = packet_type { + InputMessage::new_wrapper(message, packet_type) + } else { + message } } @@ -100,6 +144,7 @@ impl InputMessage { | InputMessage::Anonymous { lane, .. } | InputMessage::Reply { lane, .. } | InputMessage::Premade { lane, .. } => lane, + InputMessage::MessageWrapper { message, .. } => message.lane(), } } } diff --git a/common/client-core/src/client/mix_traffic.rs b/common/client-core/src/client/mix_traffic.rs index bb67314e6a..13ef076b0a 100644 --- a/common/client-core/src/client/mix_traffic.rs +++ b/common/client-core/src/client/mix_traffic.rs @@ -39,15 +39,15 @@ where pub fn new( gateway_client: GatewayClient, ) -> (MixTrafficController, BatchMixMessageSender) { - let (sphinx_message_sender, sphinx_message_receiver) = + let (message_sender, message_receiver) = tokio::sync::mpsc::channel(MIX_MESSAGE_RECEIVER_BUFFER_SIZE); ( MixTrafficController { gateway_client, - mix_rx: sphinx_message_receiver, + mix_rx: message_receiver, consecutive_gateway_failure_count: 0, }, - sphinx_message_sender, + message_sender, ) } diff --git a/common/client-core/src/client/real_messages_control/acknowledgement_control/input_message_listener.rs b/common/client-core/src/client/real_messages_control/acknowledgement_control/input_message_listener.rs index 76f8918981..ab2eda1637 100644 --- a/common/client-core/src/client/real_messages_control/acknowledgement_control/input_message_listener.rs +++ b/common/client-core/src/client/real_messages_control/acknowledgement_control/input_message_listener.rs @@ -9,6 +9,7 @@ use log::*; use nym_sphinx::addressing::clients::Recipient; use nym_sphinx::anonymous_replies::requests::AnonymousSenderTag; use nym_sphinx::forwarding::packet::MixPacket; +use nym_sphinx::params::PacketType; use nym_task::connections::TransmissionLane; use rand::{CryptoRng, Rng}; @@ -71,10 +72,11 @@ where recipient: Recipient, content: Vec, lane: TransmissionLane, + packet_type: PacketType, ) { if let Err(err) = self .message_handler - .try_send_plain_message(recipient, content, lane) + .try_send_plain_message(recipient, content, lane, packet_type) .await { warn!("failed to send a plain message - {err}") @@ -87,10 +89,11 @@ where content: Vec, reply_surbs: u32, lane: TransmissionLane, + packet_type: PacketType, ) { if let Err(err) = self .message_handler - .try_send_message_with_reply_surbs(recipient, content, reply_surbs, lane) + .try_send_message_with_reply_surbs(recipient, content, reply_surbs, lane, packet_type) .await { warn!("failed to send a repliable message - {err}") @@ -103,14 +106,17 @@ where recipient, data, lane, - } => self.handle_plain_message(recipient, data, lane).await, + } => { + self.handle_plain_message(recipient, data, lane, PacketType::Mix) + .await + } InputMessage::Anonymous { recipient, data, reply_surbs, lane, } => { - self.handle_repliable_message(recipient, data, reply_surbs, lane) + self.handle_repliable_message(recipient, data, reply_surbs, lane, PacketType::Mix) .await } InputMessage::Reply { @@ -121,6 +127,40 @@ where self.handle_reply(recipient_tag, data, lane).await; } InputMessage::Premade { msgs, lane } => self.handle_premade_packets(msgs, lane).await, + InputMessage::MessageWrapper { + message, + packet_type, + } => match *message { + InputMessage::Regular { + recipient, + data, + lane, + } => { + self.handle_plain_message(recipient, data, lane, packet_type) + .await + } + InputMessage::Anonymous { + recipient, + data, + reply_surbs, + lane, + } => { + self.handle_repliable_message(recipient, data, reply_surbs, lane, packet_type) + .await + } + InputMessage::Reply { + recipient_tag, + data, + lane, + } => { + self.handle_reply(recipient_tag, data, lane).await; + } + InputMessage::Premade { msgs, lane } => { + self.handle_premade_packets(msgs, lane).await + } + // MessageWrappers can't be nested + InputMessage::MessageWrapper { .. } => unimplemented!(), + }, }; } diff --git a/common/client-core/src/client/real_messages_control/acknowledgement_control/retransmission_request_listener.rs b/common/client-core/src/client/real_messages_control/acknowledgement_control/retransmission_request_listener.rs index 966130d1cb..734e03d709 100644 --- a/common/client-core/src/client/real_messages_control/acknowledgement_control/retransmission_request_listener.rs +++ b/common/client-core/src/client/real_messages_control/acknowledgement_control/retransmission_request_listener.rs @@ -11,9 +11,9 @@ use crate::client::real_messages_control::real_traffic_stream::RealMessage; use crate::client::replies::reply_controller::ReplyControllerSender; use futures::StreamExt; use log::*; -use nym_sphinx::addressing::clients::Recipient; use nym_sphinx::chunking::fragment::Fragment; use nym_sphinx::preparer::PreparedFragment; +use nym_sphinx::{addressing::clients::Recipient, params::PacketType}; use nym_task::connections::TransmissionLane; use rand::{CryptoRng, Rng}; use std::sync::{Arc, Weak}; @@ -51,8 +51,10 @@ where ) -> Result { debug!("retransmitting normal packet..."); + // TODO: Figure out retransmission packet type signaling + self.message_handler - .try_prepare_single_chunk_for_sending(packet_recipient, chunk_data) + .try_prepare_single_chunk_for_sending(packet_recipient, chunk_data, PacketType::Mix) .await } diff --git a/common/client-core/src/client/real_messages_control/message_handler.rs b/common/client-core/src/client/real_messages_control/message_handler.rs index 7658016017..c42a9d2279 100644 --- a/common/client-core/src/client/real_messages_control/message_handler.rs +++ b/common/client-core/src/client/real_messages_control/message_handler.rs @@ -15,7 +15,7 @@ use nym_sphinx::anonymous_replies::requests::{AnonymousSenderTag, RepliableMessa use nym_sphinx::anonymous_replies::{ReplySurb, SurbEncryptionKey}; use nym_sphinx::chunking::fragment::{Fragment, FragmentIdentifier}; use nym_sphinx::message::NymMessage; -use nym_sphinx::params::{PacketSize, DEFAULT_NUM_MIX_HOPS}; +use nym_sphinx::params::{PacketSize, PacketType, DEFAULT_NUM_MIX_HOPS}; use nym_sphinx::preparer::{MessagePreparer, PreparedFragment}; use nym_sphinx::Delay; use nym_task::connections::TransmissionLane; @@ -417,9 +417,10 @@ where recipient: Recipient, message: Vec, lane: TransmissionLane, + packet_type: PacketType, ) -> Result<(), PreparationError> { let message = NymMessage::new_plain(message); - self.try_split_and_send_non_reply_message(message, recipient, lane) + self.try_split_and_send_non_reply_message(message, recipient, lane, packet_type) .await } @@ -428,6 +429,7 @@ where message: NymMessage, recipient: Recipient, lane: TransmissionLane, + packet_type: PacketType, ) -> Result<(), PreparationError> { // TODO: I really dislike existence of this assertion, it implies code has to be re-organised debug_assert!(!matches!(message, NymMessage::Reply(_))); @@ -453,6 +455,7 @@ where topology, &self.config.ack_key, &recipient, + &packet_type, )?; let real_message = RealMessage::new( @@ -476,6 +479,7 @@ where &mut self, recipient: Recipient, amount: u32, + packet_type: PacketType, ) -> Result<(), PreparationError> { let sender_tag = self.get_or_create_sender_tag(&recipient); let (reply_surbs, reply_keys) = @@ -490,6 +494,7 @@ where message, recipient, TransmissionLane::AdditionalReplySurbs, + packet_type, ) .await?; @@ -505,6 +510,7 @@ where message: Vec, num_reply_surbs: u32, lane: TransmissionLane, + packet_type: PacketType, ) -> Result<(), SurbWrappedPreparationError> { let sender_tag = self.get_or_create_sender_tag(&recipient); let (reply_surbs, reply_keys) = self @@ -514,7 +520,7 @@ where let message = NymMessage::new_repliable(RepliableMessage::new_data(message, sender_tag, reply_surbs)); - self.try_split_and_send_non_reply_message(message, recipient, lane) + self.try_split_and_send_non_reply_message(message, recipient, lane, packet_type) .await?; log::trace!("storing {} reply keys", reply_keys.len()); @@ -527,13 +533,20 @@ where &mut self, recipient: Recipient, chunk: Fragment, + packet_type: PacketType, ) -> Result { let topology_permit = self.topology_access.get_read_permit().await; let topology = self.get_topology(&topology_permit)?; let prepared_fragment = self .message_preparer - .prepare_chunk_for_sending(chunk, topology, &self.config.ack_key, &recipient) + .prepare_chunk_for_sending( + chunk, + topology, + &self.config.ack_key, + &recipient, + &packet_type, + ) .unwrap(); Ok(prepared_fragment) diff --git a/common/client-core/src/client/real_messages_control/real_traffic_stream.rs b/common/client-core/src/client/real_messages_control/real_traffic_stream.rs index 4ef8ae4539..4c78a6d595 100644 --- a/common/client-core/src/client/real_messages_control/real_traffic_stream.rs +++ b/common/client-core/src/client/real_messages_control/real_traffic_stream.rs @@ -92,7 +92,7 @@ where // messages. sending_delay_controller: SendingDelayController, - /// Channel used for sending prepared sphinx packets to `MixTrafficController` that sends them + /// Channel used for sending prepared packets to `MixTrafficController` that sends them /// out to the network without any further delays. mix_tx: BatchMixMessageSender, @@ -386,7 +386,7 @@ where // On every iteration we get new messages from upstream. Given that these come bunched // in `Vec`, this ensures that on average we will fetch messages faster than we can - // send, which is a condition for being able to multiplex sphinx packets from multiple + // send, which is a condition for being able to multiplex packets from multiple // data streams. match Pin::new(&mut self.real_receiver).poll_recv(cx) { // in the case our real message channel stream was closed, we should also indicate we are closed diff --git a/common/client-core/src/client/replies/reply_controller/mod.rs b/common/client-core/src/client/replies/reply_controller/mod.rs index 21e1f5a9d1..0e5a5a0ae9 100644 --- a/common/client-core/src/client/replies/reply_controller/mod.rs +++ b/common/client-core/src/client/replies/reply_controller/mod.rs @@ -512,7 +512,11 @@ where let to_send = min(remaining, 100); if let Err(err) = self .message_handler - .try_send_additional_reply_surbs(recipient, to_send) + .try_send_additional_reply_surbs( + recipient, + to_send, + nym_sphinx::params::PacketType::Mix, + ) .await { warn!("failed to send additional surbs to {recipient} - {err}"); diff --git a/common/client-core/src/client/transmission_buffer.rs b/common/client-core/src/client/transmission_buffer.rs index 5423cc57a6..65c0e23976 100644 --- a/common/client-core/src/client/transmission_buffer.rs +++ b/common/client-core/src/client/transmission_buffer.rs @@ -28,7 +28,7 @@ impl SizedData for RealMessage { impl SizedData for Fragment { fn data_size(&self) -> usize { - // note that raw `Fragment` is smaller than sphinx packet payload + // note that raw `Fragment` is smaller than packet payload // as it doesn't include surb-ack or the [shared] key materials self.payload_size() } diff --git a/common/node-tester-utils/Cargo.toml b/common/node-tester-utils/Cargo.toml index eea8d1b21b..39a93d4a9f 100644 --- a/common/node-tester-utils/Cargo.toml +++ b/common/node-tester-utils/Cargo.toml @@ -17,6 +17,7 @@ tokio = { workspace = true, features = ["macros"]} nym-crypto = { path = "../crypto", features = ["asymmetric"] } nym-task = { path = "../task" } nym-topology = { path = "../topology" } +nym-sphinx-params = { path = "../nymsphinx/params" } # TODO: do we need the whole nymsphinx? nym-sphinx = { path = "../nymsphinx" } diff --git a/common/node-tester-utils/src/tester.rs b/common/node-tester-utils/src/tester.rs index bb6a376c83..e9e6706cb4 100644 --- a/common/node-tester-utils/src/tester.rs +++ b/common/node-tester-utils/src/tester.rs @@ -10,6 +10,7 @@ use nym_sphinx::addressing::clients::Recipient; use nym_sphinx::message::NymMessage; use nym_sphinx::params::{PacketSize, DEFAULT_NUM_MIX_HOPS}; use nym_sphinx::preparer::{FragmentPreparer, PreparedFragment}; +use nym_sphinx_params::PacketType; use nym_topology::{gateway, mix, NymTopology}; use rand::{CryptoRng, Rng}; use serde::Serialize; @@ -170,7 +171,14 @@ where // TODO: can we avoid this arc clone? let ack_key = Arc::clone(&self.ack_key); - Ok(self.prepare_chunk_for_sending(fragment, topology, &ack_key, &address, &address)?) + Ok(self.prepare_chunk_for_sending( + fragment, + topology, + &ack_key, + &address, + &address, + &PacketType::Mix, + )?) } } diff --git a/common/nymsphinx/framing/src/codec.rs b/common/nymsphinx/framing/src/codec.rs index 07ac62ec44..3c0644f3ee 100644 --- a/common/nymsphinx/framing/src/codec.rs +++ b/common/nymsphinx/framing/src/codec.rs @@ -84,6 +84,7 @@ impl Decoder for NymCodec { match header.packet_type { PacketType::Outfox => NymPacket::outfox_from_bytes(slice)?, PacketType::Mix => NymPacket::sphinx_from_bytes(slice)?, + PacketType::Vpn => NymPacket::sphinx_from_bytes(slice)?, } } else { return Ok(None); diff --git a/common/nymsphinx/params/src/packet_types.rs b/common/nymsphinx/params/src/packet_types.rs index 869173735e..5f96081c46 100644 --- a/common/nymsphinx/params/src/packet_types.rs +++ b/common/nymsphinx/params/src/packet_types.rs @@ -19,6 +19,9 @@ pub enum PacketType { #[default] Mix = 0, + /// Represents a packet that should be sent through the network as fast as possible. + Vpn = 1, + /// Abusing this to add Outfox support Outfox = 2, } diff --git a/common/nymsphinx/src/preparer/mod.rs b/common/nymsphinx/src/preparer/mod.rs index 2c8cf01bc3..b0eff92983 100644 --- a/common/nymsphinx/src/preparer/mod.rs +++ b/common/nymsphinx/src/preparer/mod.rs @@ -5,6 +5,7 @@ use crate::message::{NymMessage, ACK_OVERHEAD}; use crate::NymsphinxPayloadBuilder; use nym_crypto::asymmetric::encryption; use nym_crypto::Digest; +use nym_outfox::packet::OutfoxPacket; use nym_sphinx_acknowledgements::surb_ack::SurbAck; use nym_sphinx_acknowledgements::AckKey; use nym_sphinx_addressing::clients::Recipient; @@ -13,7 +14,7 @@ use nym_sphinx_anonymous_replies::reply_surb::ReplySurb; use nym_sphinx_chunking::fragment::{Fragment, FragmentIdentifier}; use nym_sphinx_forwarding::packet::MixPacket; use nym_sphinx_params::packet_sizes::PacketSize; -use nym_sphinx_params::{ReplySurbKeyDigestAlgorithm, DEFAULT_NUM_MIX_HOPS}; +use nym_sphinx_params::{PacketType, ReplySurbKeyDigestAlgorithm, DEFAULT_NUM_MIX_HOPS}; use nym_sphinx_types::builder::SphinxPacketBuilder; use nym_sphinx_types::{delays, Delay, NymPacket}; use nym_topology::{NymTopology, NymTopologyError}; @@ -170,6 +171,7 @@ pub trait FragmentPreparer { ack_key: &AckKey, packet_sender: &Recipient, packet_recipient: &Recipient, + packet_type: &PacketType, ) -> Result { // each plain or repliable packet (i.e. not a reply) attaches an ephemeral public key so that the recipient // could perform diffie-hellman with its own keys followed by a kdf to re-derive @@ -208,12 +210,25 @@ pub trait FragmentPreparer { // create the actual sphinx packet here. With valid route and correct payload size, // there's absolutely no reason for this call to fail. - let sphinx_packet = NymPacket::Sphinx( - SphinxPacketBuilder::new() - .with_payload_size(packet_size.payload_size()) - .build_packet(packet_payload, &route, &destination, &delays) - .unwrap(), - ); + let packet = match packet_type { + PacketType::Outfox => NymPacket::Outfox(OutfoxPacket::build( + packet_payload, + route.as_slice().try_into()?, + Some(packet_size.payload_size()), + )?), + PacketType::Mix => NymPacket::Sphinx( + SphinxPacketBuilder::new() + .with_payload_size(packet_size.payload_size()) + .build_packet(packet_payload, &route, &destination, &delays) + .unwrap(), + ), + PacketType::Vpn => NymPacket::Sphinx( + SphinxPacketBuilder::new() + .with_payload_size(packet_size.payload_size()) + .build_packet(packet_payload, &route, &destination, &delays) + .unwrap(), + ), + }; // from the previously constructed route extract the first hop let first_hop_address = @@ -224,7 +239,7 @@ pub trait FragmentPreparer { // well as the total delay of the ack packet. // note that the last hop of the packet is a gateway that does not do any delays total_delay: delays.iter().take(delays.len() - 1).sum::() + ack_delay, - mix_packet: MixPacket::new(first_hop_address, sphinx_packet, Default::default()), + mix_packet: MixPacket::new(first_hop_address, packet, Default::default()), fragment_identifier, }) } @@ -335,6 +350,7 @@ where topology: &NymTopology, ack_key: &AckKey, packet_recipient: &Recipient, + packet_type: &PacketType, ) -> Result { let sender = self.sender_address; @@ -345,6 +361,7 @@ where ack_key, &sender, packet_recipient, + packet_type, ) } diff --git a/common/nymsphinx/types/src/lib.rs b/common/nymsphinx/types/src/lib.rs index b9f15693a8..1060030f33 100644 --- a/common/nymsphinx/types/src/lib.rs +++ b/common/nymsphinx/types/src/lib.rs @@ -1,7 +1,7 @@ // Copyright 2021 - Nym Technologies SA // SPDX-License-Identifier: Apache-2.0 -pub use nym_outfox::{format::MIX_PARAMS_LEN, packet::OUTFOX_PACKET_OVERHEAD}; +pub use nym_outfox::{error::OutfoxError, format::MIX_PARAMS_LEN, packet::OUTFOX_PACKET_OVERHEAD}; // re-exporting types and constants available in sphinx use nym_outfox::packet::OutfoxPacket; pub use sphinx_packet::{ diff --git a/common/socks5-client-core/src/socks/client.rs b/common/socks5-client-core/src/socks/client.rs index d1d4b10697..ebd980a0e6 100644 --- a/common/socks5-client-core/src/socks/client.rs +++ b/common/socks5-client-core/src/socks/client.rs @@ -18,6 +18,7 @@ use nym_socks5_requests::{ }; use nym_sphinx::addressing::clients::Recipient; use nym_sphinx::params::PacketSize; +use nym_sphinx::params::PacketType; use nym_task::connections::{LaneQueueLengths, TransmissionLane}; use nym_task::TaskClient; use pin_project::pin_project; @@ -185,6 +186,7 @@ pub(crate) struct SocksClient { started_proxy: bool, lane_queue_lengths: LaneQueueLengths, shutdown_listener: TaskClient, + packet_type: Option, } impl Drop for SocksClient { @@ -213,6 +215,7 @@ impl SocksClient { self_address: &Recipient, lane_queue_lengths: LaneQueueLengths, mut shutdown_listener: TaskClient, + packet_type: Option, ) -> Self { // If this task fails and exits, we don't want to send shutdown signal shutdown_listener.mark_as_success(); @@ -233,6 +236,7 @@ impl SocksClient { started_proxy: false, lane_queue_lengths, shutdown_listener, + packet_type, } } @@ -349,6 +353,7 @@ impl SocksClient { msg.into_bytes(), self.config.connection_start_surbs, TransmissionLane::ConnectionId(self.connection_id), + self.packet_type, ); self.input_sender .send(input_message) @@ -371,6 +376,7 @@ impl SocksClient { self.service_provider, msg.into_bytes(), TransmissionLane::ConnectionId(self.connection_id), + self.packet_type, ); self.input_sender .send(input_message) @@ -408,6 +414,7 @@ impl SocksClient { let request_version = self.config.request_version(); let recipient = self.service_provider; + let packet_type = self.packet_type; let (stream, _) = ProxyRunner::new( stream, local_stream_remote, @@ -439,9 +446,15 @@ impl SocksClient { provider_message.into_bytes(), per_request_surbs, lane, + packet_type, ) } else { - InputMessage::new_regular(recipient, provider_message.into_bytes(), lane) + InputMessage::new_regular( + recipient, + provider_message.into_bytes(), + lane, + packet_type, + ) } }) .await diff --git a/common/socks5-client-core/src/socks/server.rs b/common/socks5-client-core/src/socks/server.rs index 179b78cca5..1b2687dd53 100644 --- a/common/socks5-client-core/src/socks/server.rs +++ b/common/socks5-client-core/src/socks/server.rs @@ -104,6 +104,7 @@ impl SphinxSocksServer { &self.self_address, self.lane_queue_lengths.clone(), self.shutdown.clone(), + None ); tokio::spawn(async move { diff --git a/common/topology/src/lib.rs b/common/topology/src/lib.rs index 859eae7672..891a2f5f18 100644 --- a/common/topology/src/lib.rs +++ b/common/topology/src/lib.rs @@ -8,6 +8,7 @@ use nym_mixnet_contract_common::{GatewayBond, IdentityKeyRef, MixId}; use nym_sphinx_addressing::nodes::NodeIdentity; use nym_sphinx_types::Node as SphinxNode; use rand::{CryptoRng, Rng}; +use std::array::TryFromSliceError; use std::collections::BTreeMap; use std::convert::TryInto; use std::fmt::{self, Display, Formatter}; @@ -55,6 +56,12 @@ pub enum NymTopologyError { // We can't import SurbAckRecoveryError due to cyclic dependency, this is a bit dirty #[error("Could not build payload")] PayloadBuilder, + + #[error("Outfox: {0}")] + Outfox(#[from] nym_sphinx_types::OutfoxError), + + #[error("{0}")] + FromSlice(#[from] TryFromSliceError), } #[derive(Debug, Clone)] diff --git a/contracts/Cargo.lock b/contracts/Cargo.lock index b2c4c63074..f7c4192b43 100644 --- a/contracts/Cargo.lock +++ b/contracts/Cargo.lock @@ -1676,9 +1676,9 @@ dependencies = [ [[package]] name = "rustix" -version = "0.37.14" +version = "0.37.15" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d9b864d3c18a5785a05953adeed93e2dca37ed30f18e69bba9f30079d51f363f" +checksum = "a0661814f891c57c930a610266415528da53c4933e6dea5fb350cbfe048a9ece" dependencies = [ "bitflags", "errno", diff --git a/mixnode/src/main.rs b/mixnode/src/main.rs index 066d4a061e..b0cb340634 100644 --- a/mixnode/src/main.rs +++ b/mixnode/src/main.rs @@ -51,9 +51,14 @@ fn test_function() { async fn main() { cfg_if::cfg_if! { if #[cfg(feature = "cpucycles")] { - setup_tracing!("/tmp/tracing.log"); + let home_dir = dirs::home_dir().expect("Could not get $HOME"); + let logs_dir = home_dir.join(".nym").join("logs"); + let logs_dir_str = logs_dir.to_str().expect("Could not construct logs path"); + setup_tracing!(logs_dir_str); + info!("CPU cycles measurement is ON") } else { setup_logging(); + info!("CPU cycles measurement is OFF") } } diff --git a/nym-api/src/network_monitor/chunker.rs b/nym-api/src/network_monitor/chunker.rs index efce5e92d7..e57855abc4 100644 --- a/nym-api/src/network_monitor/chunker.rs +++ b/nym-api/src/network_monitor/chunker.rs @@ -3,7 +3,7 @@ use nym_sphinx::forwarding::packet::MixPacket; use nym_sphinx::message::NymMessage; -use nym_sphinx::params::PacketSize; +use nym_sphinx::params::{PacketSize, PacketType}; use nym_sphinx::{ acknowledgements::AckKey, addressing::clients::Recipient, preparer::MessagePreparer, }; @@ -43,12 +43,13 @@ impl Chunker { message: Vec, topology: &NymTopology, packet_sender: Recipient, + packet_type: PacketType, ) -> Vec { // I really dislike how we have to overwrite the parameter of the `MessagePreparer` on each run // but without some significant API changes in the `MessagePreparer` this was the easiest // way to being able to have variable sender address. self.message_preparer.set_sender_address(packet_sender); - self.prepare_packets(message, topology, packet_sender) + self.prepare_packets(message, topology, packet_sender, packet_type) } fn prepare_packets( @@ -56,6 +57,7 @@ impl Chunker { message: Vec, topology: &NymTopology, packet_sender: Recipient, + packet_type: PacketType, ) -> Vec { let ack_key: AckKey = AckKey::new(&mut self.rng); @@ -68,7 +70,13 @@ impl Chunker { // don't bother with acks etc. for time being let prepared_fragment = self .message_preparer - .prepare_chunk_for_sending(message_chunk, topology, &ack_key, &packet_sender) + .prepare_chunk_for_sending( + message_chunk, + topology, + &ack_key, + &packet_sender, + &packet_type, + ) .unwrap(); mix_packets.push(prepared_fragment.mix_packet); diff --git a/nym-api/src/network_monitor/mod.rs b/nym-api/src/network_monitor/mod.rs index f19cccc35e..79f3b796ab 100644 --- a/nym-api/src/network_monitor/mod.rs +++ b/nym-api/src/network_monitor/mod.rs @@ -20,6 +20,7 @@ use futures::channel::mpsc; use nym_bandwidth_controller::BandwidthController; use nym_credential_storage::persistent_storage::PersistentStorage; use nym_crypto::asymmetric::{encryption, identity}; +use nym_sphinx::params::PacketType; use nym_sphinx::receiver::MessageReceiver; use nym_task::TaskManager; use std::sync::Arc; @@ -132,6 +133,7 @@ impl<'a> NetworkMonitorBuilder<'a> { received_processor, summary_producer, self.node_status_storage, + PacketType::Mix, ); NetworkMonitorRunnables { diff --git a/nym-api/src/network_monitor/monitor/mod.rs b/nym-api/src/network_monitor/monitor/mod.rs index ebc7174d2a..ba261b485b 100644 --- a/nym-api/src/network_monitor/monitor/mod.rs +++ b/nym-api/src/network_monitor/monitor/mod.rs @@ -10,6 +10,7 @@ use crate::network_monitor::test_route::TestRoute; use crate::storage::NymApiStorage; use crate::support::config::Config; use log::{debug, error, info}; +use nym_sphinx::params::PacketType; use nym_sphinx::receiver::MessageReceiver; use nym_task::TaskClient; use std::collections::{HashMap, HashSet}; @@ -44,6 +45,8 @@ pub(super) struct Monitor { /// The minimum number of test routes that need to be constructed (and working) in order for /// a monitor test run to be valid. minimum_test_routes: usize, + + packet_type: PacketType, } impl Monitor { @@ -54,6 +57,7 @@ impl Monitor { received_processor: ReceivedProcessor, summary_producer: SummaryProducer, node_status_storage: NymApiStorage, + packet_type: PacketType, ) -> Self { Monitor { test_nonce: 1, @@ -68,6 +72,7 @@ impl Monitor { route_test_packets: config.get_route_test_packets(), test_routes: config.get_test_routes(), minimum_test_routes: config.get_minimum_test_routes(), + packet_type, } } @@ -122,8 +127,11 @@ impl Monitor { for route in routes { let mut packet_preparer = self.packet_preparer.clone(); let route = route.clone(); - let gateway_packets = packet_preparer - .prepare_test_route_viability_packets(&route, self.route_test_packets); + let gateway_packets = packet_preparer.prepare_test_route_viability_packets( + &route, + self.route_test_packets, + self.packet_type, + ); packets.push(gateway_packets); } @@ -230,7 +238,7 @@ impl Monitor { info!("Generating test mix packets for all the network nodes..."); let prepared_packets = self .packet_preparer - .prepare_test_packets(self.test_nonce, routes) + .prepare_test_packets(self.test_nonce, routes, self.packet_type) .await; let total_sent = prepared_packets diff --git a/nym-api/src/network_monitor/monitor/preparer.rs b/nym-api/src/network_monitor/monitor/preparer.rs index a0df027e9a..715070938a 100644 --- a/nym-api/src/network_monitor/monitor/preparer.rs +++ b/nym-api/src/network_monitor/monitor/preparer.rs @@ -11,6 +11,7 @@ use nym_crypto::asymmetric::{encryption, identity}; use nym_mixnet_contract_common::{Addr, GatewayBond, Layer, MixId, MixNodeBond}; use nym_sphinx::addressing::clients::Recipient; use nym_sphinx::forwarding::packet::MixPacket; +use nym_sphinx::params::PacketType; use nym_topology::{gateway, mix, NymTopology}; use rand::seq::SliceRandom; use rand::{thread_rng, Rng}; @@ -170,6 +171,7 @@ impl PacketPreparer { packet: &TestPacket, topology: &NymTopology, packet_recipient: Recipient, + packet_type: PacketType, ) -> MixPacket { // this should be done only once. We can't really do it at construction time // as there's no sane Default for Recipient @@ -180,6 +182,7 @@ impl PacketPreparer { packet.to_bytes(), topology, packet_recipient, + packet_type, ); assert_eq!( mix_packets.len(), @@ -368,12 +371,14 @@ impl PacketPreparer { &mut self, route: &TestRoute, num: usize, + packet_type: PacketType, ) -> GatewayPackets { let mut mix_packets = Vec::with_capacity(num); let test_packet = route.self_test_packet(); let recipient = self.create_packet_sender(route.gateway()); for _ in 0..num { - let mix_packet = self.wrap_test_packet(&test_packet, route.topology(), recipient); + let mix_packet = + self.wrap_test_packet(&test_packet, route.topology(), recipient, packet_type); mix_packets.push(mix_packet) } @@ -428,6 +433,7 @@ impl PacketPreparer { &mut self, test_nonce: u64, test_routes: &[TestRoute], + packet_type: PacketType, ) -> PreparedPackets { // only test mixnodes that are rewarded, i.e. that will be rewarded in this interval. // (remember that "idle" nodes are still part of that set) @@ -462,7 +468,8 @@ impl PacketPreparer { let topology = test_route.substitute_mix(mixnode); // produce n mix packets for _ in 0..self.per_node_test_packets { - let mix_packet = self.wrap_test_packet(&test_packet, &topology, recipient); + let mix_packet = + self.wrap_test_packet(&test_packet, &topology, recipient, packet_type); mix_packets.push(mix_packet); } } @@ -482,7 +489,8 @@ impl PacketPreparer { let topology = test_route.substitute_gateway(gateway); // produce n mix packets for _ in 0..self.per_node_test_packets { - let mix_packet = self.wrap_test_packet(&test_packet, &topology, recipient); + let mix_packet = + self.wrap_test_packet(&test_packet, &topology, recipient, packet_type); gateway_mix_packets.push(mix_packet); } diff --git a/nym-outfox/src/error.rs b/nym-outfox/src/error.rs index 36f869bf87..e95bc5f088 100644 --- a/nym-outfox/src/error.rs +++ b/nym-outfox/src/error.rs @@ -5,7 +5,7 @@ use crate::lion::MIN_MESSAGE_LEN; use chacha20::cipher::InvalidLength; use thiserror::Error; -#[derive(Debug, Error)] +#[derive(Debug, Error, Clone)] pub enum OutfoxError { #[error("Lengths mismatch, expected: {expected}, got: {got}")] LenMismatch { expected: usize, got: usize }, diff --git a/nym-outfox/src/format.rs b/nym-outfox/src/format.rs index 4615124de6..eca665fa02 100644 --- a/nym-outfox/src/format.rs +++ b/nym-outfox/src/format.rs @@ -92,7 +92,7 @@ use std::convert::TryFrom; pub struct MixCreationParameters { /// The routing length is inner first, so \[0\] is the innermost routing length, etc (in bytes) /// In our stratified topology this will always be 3 - pub routing_information_length_by_stage: [u8; 3], + pub routing_information_length_by_stage: [u8; 4], /// The payload length (in bytes) pub payload_length_bytes: u16, } @@ -127,7 +127,7 @@ impl MixCreationParameters { /// Create a set of parameters for a mix packet format. pub fn new(payload_length_bytes: u16) -> MixCreationParameters { MixCreationParameters { - routing_information_length_by_stage: [DEFAULT_ROUTING_INFO_SIZE; 3], + routing_information_length_by_stage: [DEFAULT_ROUTING_INFO_SIZE; 4], payload_length_bytes, } } diff --git a/nym-outfox/src/packet.rs b/nym-outfox/src/packet.rs index 5c0c064d7c..d136896c32 100644 --- a/nym-outfox/src/packet.rs +++ b/nym-outfox/src/packet.rs @@ -51,7 +51,7 @@ impl OutfoxPacket { pub fn build>( payload: M, - route: &[Node; 3], + route: &[Node; 4], packet_size: Option, ) -> Result { let mut secret_key = [0; 32]; diff --git a/sdk/rust/nym-sdk/src/mixnet/client.rs b/sdk/rust/nym-sdk/src/mixnet/client.rs index a685e39fbd..be321ca9be 100644 --- a/sdk/rust/nym-sdk/src/mixnet/client.rs +++ b/sdk/rust/nym-sdk/src/mixnet/client.rs @@ -592,6 +592,7 @@ where client_state, reconstructed_receiver, task_manager: started_client.task_manager, + packet_type: None, }) } } diff --git a/sdk/rust/nym-sdk/src/mixnet/native_client.rs b/sdk/rust/nym-sdk/src/mixnet/native_client.rs index 4dab78d34f..f914fdf835 100644 --- a/sdk/rust/nym-sdk/src/mixnet/native_client.rs +++ b/sdk/rust/nym-sdk/src/mixnet/native_client.rs @@ -6,6 +6,7 @@ use nym_client_core::client::{ }; use nym_sphinx::{ addressing::clients::{ClientIdentity, Recipient}, + params::PacketType, receiver::ReconstructedMessage, }; use nym_task::{ @@ -45,6 +46,7 @@ pub struct MixnetClient { /// The task manager that controlls all the spawned tasks that the clients uses to do it's job. pub(crate) task_manager: TaskManager, + pub(crate) packet_type: Option, } impl MixnetClient { @@ -163,9 +165,11 @@ impl MixnetClient { let lane = TransmissionLane::General; let input_msg = match surbs { IncludedSurbs::Amount(surbs) => { - InputMessage::new_anonymous(address, message, surbs, lane) + InputMessage::new_anonymous(address, message, surbs, lane, self.packet_type) + } + IncludedSurbs::ExposeSelfAddress => { + InputMessage::new_regular(address, message, lane, self.packet_type) } - IncludedSurbs::ExposeSelfAddress => InputMessage::new_regular(address, message, lane), }; self.send(input_msg).await }