GRIN/nym
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Framing compat

Browse Source
This commit is contained in:
durch
2023-04-18 22:23:02 +02:00
parent d5e77e499b
commit 6464da5f01
25 changed files with 795 additions and 315 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Cargo.lock
Generated
+2
View File
@@ -4092,6 +4092,7 @@ name = "nym-sphinx-params"
version = "0.1.0"
dependencies = [
"nym-crypto",
"nym-outfox",
"nym-sphinx-types",
"serde",
"thiserror",
@@ -4104,6 +4105,7 @@ dependencies = [
"nym-outfox",
"serde",
"sphinx-packet",
"thiserror",
]
[[package]]
common/client-libs/mixnet-client/src/client.rs
+12 -15
View File
@@ -4,10 +4,11 @@
use futures::channel::mpsc;
use futures::StreamExt;
use log::*;
use nym_sphinx::framing::codec::SphinxCodec;
use nym_sphinx::framing::packet::FramedSphinxPacket;
use nym_sphinx::addressing::nodes::NymNodeRoutingAddress;
use nym_sphinx::framing::codec::NymCodec;
use nym_sphinx::framing::packet::FramedNymPacket;
use nym_sphinx::params::PacketMode;
use nym_sphinx::{addressing::nodes::NymNodeRoutingAddress, SphinxPacket};
use nym_sphinx::NymPacket;
use std::collections::HashMap;
use std::io;
use std::net::SocketAddr;
@@ -50,7 +51,7 @@ pub trait SendWithoutResponse {
fn send_without_response(
&mut self,
address: NymNodeRoutingAddress,
packet: SphinxPacket,
packet: NymPacket,
packet_mode: PacketMode,
) -> io::Result<()>;
}
@@ -61,12 +62,12 @@ pub struct Client {
}
struct ConnectionSender {
channel: mpsc::Sender<FramedSphinxPacket>,
channel: mpsc::Sender<FramedNymPacket>,
current_reconnection_attempt: Arc<AtomicU32>,
}
impl ConnectionSender {
fn new(channel: mpsc::Sender<FramedSphinxPacket>) -> Self {
fn new(channel: mpsc::Sender<FramedNymPacket>) -> Self {
ConnectionSender {
channel,
current_reconnection_attempt: Arc::new(AtomicU32::new(0)),
@@ -84,7 +85,7 @@ impl Client {
async fn manage_connection(
address: SocketAddr,
receiver: mpsc::Receiver<FramedSphinxPacket>,
receiver: mpsc::Receiver<FramedNymPacket>,
connection_timeout: Duration,
current_reconnection: &AtomicU32,
) {
@@ -96,7 +97,7 @@ impl Client {
debug!("Managed to establish connection to {}", address);
// if we managed to connect, reset the reconnection count (whatever it might have been)
current_reconnection.store(0, Ordering::Release);
Framed::new(stream, SphinxCodec)
Framed::new(stream, NymCodec)
}
Err(err) => {
debug!(
@@ -148,11 +149,7 @@ impl Client {
}
}
fn make_connection(
&mut self,
address: NymNodeRoutingAddress,
pending_packet: FramedSphinxPacket,
) {
fn make_connection(&mut self, address: NymNodeRoutingAddress, pending_packet: FramedNymPacket) {
let (mut sender, receiver) = mpsc::channel(self.config.maximum_connection_buffer_size);
// this CAN'T fail because we just created the channel which has a non-zero capacity
@@ -200,12 +197,12 @@ impl SendWithoutResponse for Client {
fn send_without_response(
&mut self,
address: NymNodeRoutingAddress,
packet: SphinxPacket,
packet: NymPacket,
packet_mode: PacketMode,
) -> io::Result<()> {
trace!("Sending packet to {:?}", address);
let framed_packet =
FramedSphinxPacket::new(packet, packet_mode, self.config.use_legacy_version);
FramedNymPacket::new(packet, packet_mode, self.config.use_legacy_version);
if let Some(sender) = self.conn_new.get_mut(&address) {
if let Err(err) = sender.channel.try_send(framed_packet) {
common/client-libs/mixnet-client/src/forwarder.rs
+2 -1
View File
@@ -6,6 +6,7 @@ use futures::channel::mpsc;
use futures::StreamExt;
use log::*;
use nym_sphinx::forwarding::packet::MixPacket;
use nym_sphinx::NymPacket;
use std::time::Duration;
pub type MixForwardingSender = mpsc::UnboundedSender<MixPacket>;
@@ -66,7 +67,7 @@ impl PacketForwarder {
if let Err(err) =
self.mixnet_client
.send_without_response(next_hop, sphinx_packet, packet_mode)
.send_without_response(next_hop, NymPacket::Sphinx(sphinx_packet), packet_mode)
{
debug!("failed to forward the packet - {err}")
}
common/mixnode-common/src/packet_processor/error.rs
+4 -1
View File
@@ -3,12 +3,15 @@
use nym_sphinx_acknowledgements::surb_ack::SurbAckRecoveryError;
use nym_sphinx_addressing::nodes::NymNodeRoutingAddressError;
use nym_sphinx_types::Error as SphinxError;
use nym_sphinx_types::{NymPacketError, SphinxError};
use thiserror::Error;
#[derive(Error, Debug)]
pub enum MixProcessingError {
#[error("failed to process received packet: {0}")]
NymPacketProcessingError(#[from] NymPacketError),
#[error("failed to process received sphinx packet: {0}")]
SphinxProcessingError(#[from] SphinxError),
#[error("the forward hop address was malformed: {0}")]
common/mixnode-common/src/packet_processor/processor.rs
+15 -11
View File
@@ -7,11 +7,11 @@ use log::*;
use nym_sphinx_acknowledgements::surb_ack::SurbAck;
use nym_sphinx_addressing::nodes::NymNodeRoutingAddress;
use nym_sphinx_forwarding::packet::MixPacket;
use nym_sphinx_framing::packet::FramedSphinxPacket;
use nym_sphinx_framing::packet::FramedNymPacket;
use nym_sphinx_params::{PacketMode, PacketSize};
use nym_sphinx_types::{
Delay as SphinxDelay, DestinationAddressBytes, NodeAddressBytes, Payload, PrivateKey,
ProcessedPacket, SphinxPacket,
Delay as SphinxDelay, DestinationAddressBytes, NodeAddressBytes, NymPacket, Payload,
PrivateKey, ProcessedPacket, SphinxPacket,
};
use std::convert::TryFrom;
use std::sync::Arc;
@@ -55,12 +55,12 @@ impl SphinxPacketProcessor {
)]
fn perform_initial_sphinx_packet_processing(
&self,
packet: SphinxPacket,
packet: NymPacket,
) -> Result<ProcessedPacket, MixProcessingError> {
measure!({
packet.process(&self.sphinx_key).map_err(|err| {
debug!("Failed to unwrap Sphinx packet: {err}");
MixProcessingError::SphinxProcessingError(err)
MixProcessingError::NymPacketProcessingError(err)
})
})
}
@@ -72,17 +72,17 @@ impl SphinxPacketProcessor {
)]
fn perform_initial_unwrapping(
&self,
received: FramedSphinxPacket,
received: FramedNymPacket,
) -> Result<ProcessedPacket, MixProcessingError> {
measure!({
let packet_mode = received.packet_mode();
let sphinx_packet = received.into_inner();
let packet = received.into_inner();
if packet_mode.is_old_vpn() {
return Err(MixProcessingError::ReceivedOldTypeVpnPacket);
}
self.perform_initial_sphinx_packet_processing(sphinx_packet)
self.perform_initial_sphinx_packet_processing(packet)
})
}
@@ -127,14 +127,18 @@ impl SphinxPacketProcessor {
packet_mode: PacketMode,
) -> Result<(Option<MixPacket>, Vec<u8>), MixProcessingError> {
match packet_size {
PacketSize::AckPacket => {
PacketSize::AckPacket | PacketSize::OutfoxAckPacket => {
trace!("received an ack packet!");
Ok((None, data))
}
PacketSize::RegularPacket
| PacketSize::ExtendedPacket8
| PacketSize::ExtendedPacket16
| PacketSize::ExtendedPacket32 => {
| PacketSize::ExtendedPacket32
| PacketSize::OutfoxRegularPacket
| PacketSize::OutfoxExtendedPacket8
| PacketSize::OutfoxExtendedPacket16
| PacketSize::OutfoxExtendedPacket32 => {
trace!("received a normal packet!");
let (ack_data, message) = self.split_hop_data_into_ack_and_message(data)?;
let (ack_first_hop, ack_packet) = SurbAck::try_recover_first_hop_packet(&ack_data)?;
@@ -192,7 +196,7 @@ impl SphinxPacketProcessor {
)]
pub fn process_received(
&self,
received: FramedSphinxPacket,
received: FramedNymPacket,
) -> Result<MixProcessingResult, MixProcessingError> {
// explicit packet size will help to correctly parse final hop
measure!({
common/nymsphinx/acknowledgements/src/surb_ack.rs
+1 -1
View File
@@ -10,7 +10,7 @@ use nym_sphinx_addressing::nodes::{
use nym_sphinx_params::packet_sizes::PacketSize;
use nym_sphinx_params::DEFAULT_NUM_MIX_HOPS;
use nym_sphinx_types::builder::SphinxPacketBuilder;
use nym_sphinx_types::Error as SphinxError;
use nym_sphinx_types::SphinxError;
use nym_sphinx_types::{
delays::{self, Delay},
SphinxPacket,
common/nymsphinx/anonymous-replies/src/reply_surb.rs
+1 -1
View File
@@ -7,7 +7,7 @@ use nym_sphinx_addressing::clients::Recipient;
use nym_sphinx_addressing::nodes::{NymNodeRoutingAddress, MAX_NODE_ADDRESS_UNPADDED_LEN};
use nym_sphinx_params::packet_sizes::PacketSize;
use nym_sphinx_params::{ReplySurbKeyDigestAlgorithm, DEFAULT_NUM_MIX_HOPS};
use nym_sphinx_types::{delays, Error as SphinxError, SURBMaterial, SphinxPacket, SURB};
use nym_sphinx_types::{delays, SURBMaterial, SphinxError, SphinxPacket, SURB};
use nym_topology::{NymTopology, NymTopologyError};
use rand::{CryptoRng, RngCore};
use serde::de::{Error as SerdeError, Visitor};
common/nymsphinx/cover/src/lib.rs
+1 -1
View File
@@ -14,7 +14,7 @@ use nym_sphinx_params::{
PacketEncryptionAlgorithm, PacketHkdfAlgorithm, PacketMode, DEFAULT_NUM_MIX_HOPS,
};
use nym_sphinx_types::builder::SphinxPacketBuilder;
use nym_sphinx_types::{delays, Error as SphinxError};
use nym_sphinx_types::{delays, SphinxError};
use nym_topology::{NymTopology, NymTopologyError};
use rand::{CryptoRng, RngCore};
use std::convert::TryFrom;
common/nymsphinx/framing/src/codec.rs
+138 -186
View File
@@ -5,14 +5,14 @@ use crate::packet::{FramedNymPacket, Header};
use bytes::{Buf, BufMut, BytesMut};
use nym_sphinx_params::packet_modes::InvalidPacketMode;
use nym_sphinx_params::packet_sizes::{InvalidPacketSize, PacketSize};
use nym_sphinx_types::{Error as SphinxError, NymPacket};
use nym_sphinx_types::{OutfoxError, SphinxPacket};
use nym_sphinx_types::SphinxPacket;
use nym_sphinx_types::{NymPacket, NymPacketError, SphinxError};
use std::io;
use thiserror::Error;
use tokio_util::codec::{Decoder, Encoder};
#[derive(Error, Debug)]
pub enum SphinxCodecError {
pub enum NymCodecError {
#[error("the packet size information was malformed - {0}")]
InvalidPacketSize(#[from] InvalidPacketSize),
@@ -25,6 +25,9 @@ pub enum SphinxCodecError {
#[error("encountered an IO error - {0}")]
IoError(#[from] io::Error),
#[error("encountered a packet error - {0}")]
NymPacket(#[from] NymPacketError),
#[error("could not convert to bytes")]
ToBytes,
@@ -32,68 +35,67 @@ pub enum SphinxCodecError {
FromBytes,
}
#[derive(Error, Debug)]
pub enum OutfoxCodecError {
#[error("the packet size information was malformed - {0}")]
InvalidPacketSize(#[from] InvalidPacketSize),
#[error("the packet mode information was malformed - {0}")]
InvalidPacketMode(#[from] InvalidPacketMode),
#[error("the actual sphinx packet was malformed - {0}")]
MalformedSphinxPacket(#[from] SphinxError),
#[error("encountered an IO error - {0}")]
IoError(#[from] io::Error),
#[error("outfox error - {0}")]
Outfox(#[from] OutfoxError),
}
pub struct OutfoxCodec;
impl Encoder<FramedNymPacket> for OutfoxCodec {
type Error = OutfoxCodecError;
fn encode(&mut self, item: FramedNymPacket, dst: &mut BytesMut) -> Result<(), Self::Error> {
dst.put(
bincode::serialize(&item)
.map_err(|_| OutfoxError::Bincode)?
.as_slice(),
);
Ok(())
}
}
// TODO: in the future it could be extended to have state containing symmetric encryption key
// so that all data could be encrypted easily (alternatively we could just slap TLS)
pub struct SphinxCodec;
pub struct NymCodec;
impl Encoder<FramedNymPacket> for SphinxCodec {
type Error = SphinxCodecError;
impl Encoder<FramedNymPacket> for NymCodec {
type Error = NymCodecError;
// fn encode_serde(&mut self, item: FramedNymPacket, dst: &mut BytesMut) -> Result<(), Self::Error> {
// let encoded_size = bincode::serialized_size(&item).unwrap() as u32;
// dst.put_u32(encoded_size);
// dst.put(
// bincode::serialize(&item)
// .map_err(|_| NymCodecError::ToBytes)?
// .as_slice(),
// );
// Ok(())
// }
fn encode(&mut self, item: FramedNymPacket, dst: &mut BytesMut) -> Result<(), Self::Error> {
let encoded_size = bincode::serialized_size(&item).unwrap() as u32;
dst.put_u32(encoded_size);
dst.put(
bincode::serialize(&item)
.map_err(|_| SphinxCodecError::ToBytes)?
.as_slice(),
);
// item.header().encode(dst);
// dst.put(
// item.packet
// .to_bytes()
// .map_err(|_e| SphinxCodecError::ToBytes)?
// .as_ref(),
// );
item.header.encode(dst);
dst.put(item.packet.to_bytes()?.as_slice());
Ok(())
}
}
impl Decoder for SphinxCodec {
impl Decoder for NymCodec {
type Item = FramedNymPacket;
type Error = SphinxCodecError;
type Error = NymCodecError;
// fn decode_serde(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
// if src.is_empty() {
// // can't do anything if we have no bytes, but let's reserve enough for the most
// // conservative case, i.e. receiving an ack packet
// src.reserve(Header::LEGACY_SIZE + PacketSize::AckPacket.size());
// return Ok(None);
// }
// let next_size = if let Some(size) = src.get(..4) {
// u32::from_be_bytes(size.try_into().unwrap()) as usize
// } else {
// 0
// };
// if next_size == 0 {
// return Ok(None);
// }
// if let Some(next_packet) = src.get(4..next_size + 4) {
// match bincode::deserialize::<Self::Item>(next_packet) {
// Ok(packet) => {
// src.advance(next_size + 4);
// return Ok(Some(packet));
// }
// Err(_) => {
// println!("Could not decode packet");
// return Ok(None);
// }
// }
// }
// Ok(None)
// }
fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
if src.is_empty() {
@@ -103,58 +105,33 @@ impl Decoder for SphinxCodec {
return Ok(None);
}
let next_size = if let Some(size) = src.get(..4) {
u32::from_be_bytes(size.try_into().unwrap()) as usize
} else {
0
// because header is so small and simple it makes no point in trying to cache
// this result. It will be just simpler to re-decode it
let header = match Header::decode(src)? {
Some(header) => header,
None => return Ok(None), // we have some data but not enough to get header back
};
// let next_size = src.get_u64() as usize;
if next_size == 0 {
let packet_size = header.packet_size.size();
let frame_len = header.size() + packet_size;
if src.len() < frame_len {
// we don't have enough bytes to read the rest of frame
src.reserve(packet_size);
return Ok(None);
}
if let Some(next_packet) = src.get(4..next_size + 4) {
match bincode::deserialize::<Self::Item>(next_packet) {
Ok(packet) => {
src.advance(next_size + 4);
return Ok(Some(packet));
}
Err(_) => {
println!("Could not decode packet");
return Ok(None);
}
}
}
Ok(None)
// because header is so small and simple it makes no point in trying to cache
// this result. It will be just simpler to re-decode it
// let header = match Header::decode(src)? {
// Some(header) => header,
// None => return Ok(None), // we have some data but not enough to get header back
// };
// let sphinx_packet_size = framed_packet.header.packet_size.size();
// let frame_len = framed_packet.header.size() + sphinx_packet_size;
// if src.len() < frame_len {
// // we don't have enough bytes to read the rest of frame
// src.reserve(sphinx_packet_size);
// return Ok(None);
// }
// advance buffer past the header - at this point we have enough bytes
// src.advance(header.size());
// let sphinx_packet_bytes = src.split_to(sphinx_packet_size);
src.advance(header.size());
let sphinx_packet_bytes = src.split_to(packet_size);
// here it could be debatable whether stream is corrupt or not,
// but let's go with the safer approach and assume it is.
// let packet = SphinxPacket::from_bytes(&sphinx_packet_bytes)?;
// let nymsphinx_packet = FramedNymPacket {
// header,
// packet: NymPacket::Sphinx(packet),
// };
let packet = SphinxPacket::from_bytes(&sphinx_packet_bytes)?;
let nymsphinx_packet = FramedNymPacket {
header,
packet: NymPacket::Sphinx(packet),
};
// As per docs:
// Before returning from the function, implementations should ensure that the buffer
@@ -166,24 +143,24 @@ impl Decoder for SphinxCodec {
// reserve for that.
// we also assume the next packet coming from the same client will use exactly the same versioning
// as the current packet
// let mut allocate_for_next_packet = framed_packet.header.size() + PacketSize::AckPacket.size();
// if !src.is_empty() {
// match Header::decode(src) {
// Ok(Some(next_header)) => {
// allocate_for_next_packet = next_header.size() + next_header.packet_size.size();
// }
// Ok(None) => {
// // we don't have enough information to know how much to reserve, fallback to the ack case
// }
let mut allocate_for_next_packet = header.size() + PacketSize::AckPacket.size();
if !src.is_empty() {
match Header::decode(src) {
Ok(Some(next_header)) => {
allocate_for_next_packet = next_header.size() + next_header.packet_size.size();
}
Ok(None) => {
// we don't have enough information to know how much to reserve, fallback to the ack case
}
// // the next frame will be malformed but let's leave handling the error to the next
// // call to 'decode', as presumably, the current sphinx packet is still valid
// Err(_) => return Ok(Some(framed_packet)),
// };
// }
// src.reserve(allocate_for_next_packet);
// the next frame will be malformed but let's leave handling the error to the next
// call to 'decode', as presumably, the current sphinx packet is still valid
Err(_) => return Ok(Some(nymsphinx_packet)),
};
}
src.reserve(allocate_for_next_packet);
// Ok(Some(framed_packet))
Ok(Some(nymsphinx_packet))
}
}
@@ -237,15 +214,15 @@ mod packet_encoding {
let packet = FramedNymPacket {
header,
packet: Some(NymPacket::Sphinx(sphinx_packet)),
packet: NymPacket::Sphinx(sphinx_packet),
};
let mut bytes = BytesMut::new();
SphinxCodec.encode(packet, &mut bytes).unwrap();
let decoded = SphinxCodec.decode(&mut bytes).unwrap().unwrap();
NymCodec.encode(packet, &mut bytes).unwrap();
let decoded = NymCodec.decode(&mut bytes).unwrap().unwrap();
assert_eq!(decoded.header, header);
assert_eq!(decoded.packet.unwrap().to_bytes().unwrap(), sphinx_bytes)
assert_eq!(decoded.packet.to_bytes().unwrap(), sphinx_bytes)
}
#[cfg(test)]
@@ -258,7 +235,7 @@ mod packet_encoding {
fn for_empty_bytes() {
// empty bytes should allocate for header + ack packet
let mut empty_bytes = BytesMut::new();
assert!(SphinxCodec.decode(&mut empty_bytes).unwrap().is_none());
assert!(NymCodec.decode(&mut empty_bytes).unwrap().is_none());
assert_eq!(
empty_bytes.capacity(),
Header::LEGACY_SIZE + PacketSize::AckPacket.size()
@@ -279,11 +256,11 @@ mod packet_encoding {
let header = Header {
packet_version: PacketVersion::Legacy,
packet_size,
packet_mode: Default::default(),
..Default::default()
};
let mut bytes = BytesMut::new();
header.encode(&mut bytes);
assert!(SphinxCodec.decode(&mut bytes).unwrap().is_none());
assert!(NymCodec.decode(&mut bytes).unwrap().is_none());
assert_eq!(bytes.capacity(), Header::LEGACY_SIZE + packet_size.size())
}
@@ -303,11 +280,11 @@ mod packet_encoding {
let header = Header {
packet_version: PacketVersion::Versioned(123),
packet_size,
packet_mode: Default::default(),
..Default::default()
};
let mut bytes = BytesMut::new();
header.encode(&mut bytes);
assert!(SphinxCodec.decode(&mut bytes).unwrap().is_none());
assert!(NymCodec.decode(&mut bytes).unwrap().is_none());
assert_eq!(
bytes.capacity(),
@@ -322,21 +299,18 @@ mod packet_encoding {
let packet = FramedNymPacket {
header: Header {
packet_version: PacketVersion::Legacy,
packet_size: Default::default(),
packet_mode: Default::default(),
..Default::default()
},
packet: Some(NymPacket::Sphinx(make_valid_sphinx_packet(
Default::default(),
))),
packet: NymPacket::Sphinx(make_valid_sphinx_packet(Default::default())),
};
let mut bytes = BytesMut::new();
SphinxCodec.encode(packet, &mut bytes).unwrap();
assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());
// assert_eq!(
// bytes.capacity(),
// Header::LEGACY_SIZE + PacketSize::AckPacket.size()
// );
NymCodec.encode(packet, &mut bytes).unwrap();
assert!(NymCodec.decode(&mut bytes).unwrap().is_some());
assert_eq!(
bytes.capacity(),
Header::LEGACY_SIZE + PacketSize::AckPacket.size()
);
}
#[test]
@@ -344,18 +318,16 @@ mod packet_encoding {
// if full frame is used exactly, there should be enough space for header + ack packet
let packet = FramedNymPacket {
header: Header::default(),
packet: Some(NymPacket::Sphinx(make_valid_sphinx_packet(
Default::default(),
))),
packet: NymPacket::Sphinx(make_valid_sphinx_packet(Default::default())),
};
let mut bytes = BytesMut::new();
SphinxCodec.encode(packet, &mut bytes).unwrap();
assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());
// assert_eq!(
// bytes.capacity(),
// Header::VERSIONED_SIZE + PacketSize::AckPacket.size()
// );
NymCodec.encode(packet, &mut bytes).unwrap();
assert!(NymCodec.decode(&mut bytes).unwrap().is_some());
assert_eq!(
bytes.capacity(),
Header::VERSIONED_SIZE + PacketSize::AckPacket.size()
);
}
#[test]
@@ -373,21 +345,18 @@ mod packet_encoding {
let first_packet = FramedNymPacket {
header: Header {
packet_version: PacketVersion::Legacy,
packet_size: Default::default(),
packet_mode: Default::default(),
..Default::default()
},
packet: Some(NymPacket::Sphinx(make_valid_sphinx_packet(
Default::default(),
))),
packet: NymPacket::Sphinx(make_valid_sphinx_packet(Default::default())),
};
let mut bytes = BytesMut::new();
SphinxCodec.encode(first_packet, &mut bytes).unwrap();
NymCodec.encode(first_packet, &mut bytes).unwrap();
bytes.put_u8(packet_size as u8);
bytes.put_u8(PacketMode::default() as u8);
assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());
assert!(NymCodec.decode(&mut bytes).unwrap().is_some());
// assert!(bytes.capacity() >= Header::LEGACY_SIZE + packet_size.size())
assert!(bytes.capacity() >= Header::LEGACY_SIZE + packet_size.size())
}
}
@@ -405,17 +374,15 @@ mod packet_encoding {
for packet_size in packet_sizes {
let first_packet = FramedNymPacket {
header: Header::default(),
packet: Some(NymPacket::Sphinx(make_valid_sphinx_packet(
Default::default(),
))),
packet: NymPacket::Sphinx(make_valid_sphinx_packet(Default::default())),
};
let mut bytes = BytesMut::new();
SphinxCodec.encode(first_packet, &mut bytes).unwrap();
NymCodec.encode(first_packet, &mut bytes).unwrap();
bytes.put_u8(PacketVersion::new_versioned(123).as_u8().unwrap());
bytes.put_u8(packet_size as u8);
bytes.put_u8(PacketMode::default() as u8);
assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());
assert!(NymCodec.decode(&mut bytes).unwrap().is_some());
// assert!(bytes.capacity() >= Header::VERSIONED_SIZE + packet_size.size())
}
@@ -426,65 +393,50 @@ mod packet_encoding {
fn can_decode_two_packets_immediately() {
let packet1 = FramedNymPacket {
header: Header::default(),
packet: Some(NymPacket::Sphinx(make_valid_sphinx_packet(
Default::default(),
))),
packet: NymPacket::Sphinx(make_valid_sphinx_packet(Default::default())),
};
let packet2 = FramedNymPacket {
header: Header::default(),
packet: Some(NymPacket::Sphinx(make_valid_sphinx_packet(
Default::default(),
))),
packet: NymPacket::Sphinx(make_valid_sphinx_packet(Default::default())),
};
let mut bytes = BytesMut::new();
SphinxCodec.encode(packet1, &mut bytes).unwrap();
SphinxCodec.encode(packet2, &mut bytes).unwrap();
NymCodec.encode(packet1, &mut bytes).unwrap();
NymCodec.encode(packet2, &mut bytes).unwrap();
assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());
assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());
assert!(SphinxCodec.decode(&mut bytes).unwrap().is_none());
assert!(NymCodec.decode(&mut bytes).unwrap().is_some());
assert!(NymCodec.decode(&mut bytes).unwrap().is_some());
assert!(NymCodec.decode(&mut bytes).unwrap().is_none());
}
#[test]
fn can_decode_two_packets_in_separate_calls() {
let packet1 = FramedNymPacket {
header: Header::default(),
packet: Some(NymPacket::Sphinx(make_valid_sphinx_packet(
Default::default(),
))),
packet: NymPacket::Sphinx(make_valid_sphinx_packet(Default::default())),
};
let packet2 = FramedNymPacket {
header: Header::default(),
packet: Some(NymPacket::Sphinx(make_valid_sphinx_packet(
Default::default(),
))),
packet: NymPacket::Sphinx(make_valid_sphinx_packet(Default::default())),
};
let mut bytes = BytesMut::new();
let mut bytes_tmp = BytesMut::new();
println!("{}", bytes.len());
SphinxCodec.encode(packet1, &mut bytes).unwrap();
println!("{}", bytes.len());
SphinxCodec.encode(packet2, &mut bytes_tmp).unwrap();
println!("{}", bytes.len());
NymCodec.encode(packet1, &mut bytes).unwrap();
NymCodec.encode(packet2, &mut bytes_tmp).unwrap();
let tmp = bytes_tmp.split_off(100);
bytes.put(bytes_tmp);
println!("{}", bytes.len());
assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());
println!("{}", bytes.len());
assert!(SphinxCodec.decode(&mut bytes).unwrap().is_none());
println!("{}", bytes.len());
assert!(NymCodec.decode(&mut bytes).unwrap().is_some());
assert!(NymCodec.decode(&mut bytes).unwrap().is_none());
bytes.put(tmp);
println!("{}", bytes.len());
assert!(SphinxCodec.decode(&mut bytes).unwrap().is_some());
assert!(SphinxCodec.decode(&mut bytes).unwrap().is_none());
assert!(NymCodec.decode(&mut bytes).unwrap().is_some());
assert!(NymCodec.decode(&mut bytes).unwrap().is_none());
}
}
common/nymsphinx/framing/src/packet.rs
+7 -7
View File
@@ -1,7 +1,7 @@
// Copyright 2021 - Nym Technologies SA <contact@nymtech.net>
// SPDX-License-Identifier: Apache-2.0
use crate::codec::SphinxCodecError;
use crate::codec::NymCodecError;
use bytes::{BufMut, BytesMut};
use nym_sphinx_params::packet_sizes::PacketSize;
use nym_sphinx_params::packet_version::PacketVersion;
@@ -16,7 +16,7 @@ pub struct FramedNymPacket {
pub(crate) header: Header,
/// The actual SphinxPacket being sent.
pub(crate) packet: Option<NymPacket>,
pub(crate) packet: NymPacket,
}
impl FramedNymPacket {
@@ -31,7 +31,7 @@ impl FramedNymPacket {
packet_size,
packet_mode,
},
packet: Some(packet),
packet,
}
}
@@ -48,7 +48,7 @@ impl FramedNymPacket {
}
pub fn into_inner(self) -> NymPacket {
self.packet.unwrap()
self.packet
}
}
@@ -101,7 +101,7 @@ impl Header {
dst.reserve(self.packet_size.size());
}
pub(crate) fn decode(src: &mut BytesMut) -> Result<Option<Self>, SphinxCodecError> {
pub(crate) fn decode(src: &mut BytesMut) -> Result<Option<Self>, NymCodecError> {
if src.len() < Self::LEGACY_SIZE {
// can't do anything if we don't have enough bytes - but reserve enough for the next call
src.reserve(Self::LEGACY_SIZE);
@@ -197,7 +197,7 @@ mod header_encoding {
let header = Header {
packet_version: PacketVersion::Legacy,
packet_size,
packet_mode: Default::default(),
..Default::default()
};
let mut bytes = BytesMut::new();
header.encode(&mut bytes);
@@ -218,7 +218,7 @@ mod header_encoding {
let header = Header {
packet_version: PacketVersion::Versioned(123),
packet_size,
packet_mode: Default::default(),
..Default::default()
};
let mut bytes = BytesMut::new();
header.encode(&mut bytes);
common/nymsphinx/params/Cargo.toml
+1
View File
@@ -13,3 +13,4 @@ serde = { workspace = true, features = ["derive"] }
nym-crypto = { path = "../../crypto", features = ["hashing", "symmetric"] }
nym-sphinx-types = { path = "../types" }
nym-outfox = { "path" = "../../../nym-outfox" }
common/nymsphinx/params/src/packet_sizes.rs
+57 -9
View File
@@ -2,6 +2,7 @@
// SPDX-License-Identifier: Apache-2.0
use crate::FRAG_ID_LEN;
use nym_outfox::packet::OUTFOX_PACKET_OVERHEAD;
use nym_sphinx_types::header::HEADER_SIZE;
use nym_sphinx_types::PAYLOAD_OVERHEAD_SIZE;
use serde::{Deserialize, Serialize};
@@ -12,20 +13,27 @@ use std::str::FromStr;
use thiserror::Error;
// each sphinx packet contains mandatory header and payload padding + markers
const PACKET_OVERHEAD: usize = HEADER_SIZE + PAYLOAD_OVERHEAD_SIZE;
const SPHINX_PACKET_OVERHEAD: usize = HEADER_SIZE + PAYLOAD_OVERHEAD_SIZE;
// it's up to the smart people to figure those values out : )
const REGULAR_PACKET_SIZE: usize = 2 * 1024 + PACKET_OVERHEAD;
// TODO: even though we have 16B IV, is having just 5B (FRAG_ID_LEN) of the ID possibly insecure?
// TODO: I'm not entirely sure if we can easily extract `<AckEncryptionAlgorithm as NewStreamCipher>::NonceSize`
// into a const usize before relevant stuff is stabilised in rust...
const ACK_IV_SIZE: usize = 16;
const ACK_PACKET_SIZE: usize = ACK_IV_SIZE + FRAG_ID_LEN + PACKET_OVERHEAD;
const EXTENDED_PACKET_SIZE_8: usize = 8 * 1024 + PACKET_OVERHEAD;
const EXTENDED_PACKET_SIZE_16: usize = 16 * 1024 + PACKET_OVERHEAD;
const EXTENDED_PACKET_SIZE_32: usize = 32 * 1024 + PACKET_OVERHEAD;
const ACK_PACKET_SIZE: usize = ACK_IV_SIZE + FRAG_ID_LEN + SPHINX_PACKET_OVERHEAD;
const REGULAR_PACKET_SIZE: usize = 2 * 1024 + SPHINX_PACKET_OVERHEAD;
const EXTENDED_PACKET_SIZE_8: usize = 8 * 1024 + SPHINX_PACKET_OVERHEAD;
const EXTENDED_PACKET_SIZE_16: usize = 16 * 1024 + SPHINX_PACKET_OVERHEAD;
const EXTENDED_PACKET_SIZE_32: usize = 32 * 1024 + SPHINX_PACKET_OVERHEAD;
const OUTFOX_ACK_PACKET_SIZE: usize = ACK_IV_SIZE + FRAG_ID_LEN + OUTFOX_PACKET_OVERHEAD;
const OUTFOX_REGULAR_PACKET_SIZE: usize = 2 * 1024 + OUTFOX_PACKET_OVERHEAD;
const OUTFOX_EXTENDED_PACKET_SIZE_8: usize = 8 * 1024 + OUTFOX_PACKET_OVERHEAD;
const OUTFOX_EXTENDED_PACKET_SIZE_16: usize = 16 * 1024 + OUTFOX_PACKET_OVERHEAD;
const OUTFOX_EXTENDED_PACKET_SIZE_32: usize = 32 * 1024 + OUTFOX_PACKET_OVERHEAD;
#[derive(Debug, Error)]
pub enum InvalidPacketSize {
@@ -62,6 +70,25 @@ pub enum PacketSize {
// for example for streaming fast and furious in compressed XviD quality
#[serde(rename = "extended16")]
ExtendedPacket16 = 5,
#[serde(rename = "outfox_regular")]
OutfoxRegularPacket = 6,
// for sending SURB-ACKs
#[serde(rename = "outfox_ack")]
OutfoxAckPacket = 7,
// for example for streaming fast and furious in uncompressed 10bit 4K HDR quality
#[serde(rename = "outfox_extended32")]
OutfoxExtendedPacket32 = 8,
// for example for streaming fast and furious in heavily compressed lossy RealPlayer quality
#[serde(rename = "outfox_extended8")]
OutfoxExtendedPacket8 = 9,
// for example for streaming fast and furious in compressed XviD quality
#[serde(rename = "outfox_extended16")]
OutfoxExtendedPacket16 = 10,
}
impl PartialOrd for PacketSize {
@@ -88,6 +115,11 @@ impl FromStr for PacketSize {
"extended8" => Ok(Self::ExtendedPacket8),
"extended16" => Ok(Self::ExtendedPacket16),
"extended32" => Ok(Self::ExtendedPacket32),
"outfox_regular" => Ok(Self::OutfoxRegularPacket),
"outfox_ack" => Ok(Self::OutfoxAckPacket),
"outfox_extended8" => Ok(Self::OutfoxExtendedPacket8),
"outfox_extended16" => Ok(Self::OutfoxExtendedPacket16),
"outfox_extended32" => Ok(Self::OutfoxExtendedPacket32),
s => Err(InvalidPacketSize::UnknownExtendedPacketVariant {
received: s.to_string(),
}),
@@ -103,6 +135,11 @@ impl Display for PacketSize {
PacketSize::ExtendedPacket32 => write!(f, "extended32"),
PacketSize::ExtendedPacket8 => write!(f, "extended8"),
PacketSize::ExtendedPacket16 => write!(f, "extended16"),
PacketSize::OutfoxRegularPacket => write!(f, "outfox_regular"),
PacketSize::OutfoxAckPacket => write!(f, "outfox_ack"),
PacketSize::OutfoxExtendedPacket32 => write!(f, "outfox_extended32"),
PacketSize::OutfoxExtendedPacket8 => write!(f, "outfox_extended8"),
PacketSize::OutfoxExtendedPacket16 => write!(f, "outfox_extended16"),
}
}
}
@@ -140,6 +177,11 @@ impl PacketSize {
PacketSize::ExtendedPacket8 => EXTENDED_PACKET_SIZE_8,
PacketSize::ExtendedPacket16 => EXTENDED_PACKET_SIZE_16,
PacketSize::ExtendedPacket32 => EXTENDED_PACKET_SIZE_32,
PacketSize::OutfoxRegularPacket => OUTFOX_REGULAR_PACKET_SIZE,
PacketSize::OutfoxAckPacket => OUTFOX_ACK_PACKET_SIZE,
PacketSize::OutfoxExtendedPacket8 => OUTFOX_EXTENDED_PACKET_SIZE_8,
PacketSize::OutfoxExtendedPacket16 => OUTFOX_EXTENDED_PACKET_SIZE_16,
PacketSize::OutfoxExtendedPacket32 => OUTFOX_EXTENDED_PACKET_SIZE_32,
}
}
@@ -169,10 +211,16 @@ impl PacketSize {
pub fn is_extended_size(&self) -> bool {
match self {
PacketSize::RegularPacket | PacketSize::AckPacket => false,
PacketSize::RegularPacket
| PacketSize::AckPacket
| PacketSize::OutfoxAckPacket
| PacketSize::OutfoxRegularPacket => false,
PacketSize::ExtendedPacket8
| PacketSize::ExtendedPacket16
| PacketSize::ExtendedPacket32 => true,
| PacketSize::ExtendedPacket32
| PacketSize::OutfoxExtendedPacket8
| PacketSize::OutfoxExtendedPacket16
| PacketSize::OutfoxExtendedPacket32 => true,
}
}
@@ -185,7 +233,7 @@ impl PacketSize {
}
pub fn get_type_from_plaintext(plaintext_size: usize) -> Result<Self, InvalidPacketSize> {
let packet_size = plaintext_size + PACKET_OVERHEAD;
let packet_size = plaintext_size + SPHINX_PACKET_OVERHEAD;
Self::get_type(packet_size)
}
}
common/nymsphinx/params/src/packet_version.rs
+1 -1
View File
@@ -1,7 +1,7 @@
// Copyright 2022 - Nym Technologies SA <contact@nymtech.net>
// SPDX-License-Identifier: Apache-2.0
use serde::{Serialize, Deserialize};
use serde::{Deserialize, Serialize};
use crate::{PacketSize, CURRENT_PACKET_VERSION_NUMBER};
common/nymsphinx/types/Cargo.toml
+1
View File
@@ -11,6 +11,7 @@ repository = { workspace = true }
sphinx-packet = { version = "0.1.0" }
serde = "1"
nym-outfox = { path = "../../../nym-outfox" }
thiserror = "1"
[patch.crates-io]
sphinx-packet = { path = "../../../../sphinx" }
common/nymsphinx/types/src/lib.rs
+21 -3
View File
@@ -15,9 +15,20 @@ pub use sphinx_packet::{
payload::{Payload, PAYLOAD_OVERHEAD_SIZE},
route::{Destination, DestinationAddressBytes, Node, NodeAddressBytes, SURBIdentifier},
surb::{SURBMaterial, SURB},
Error, ProcessedPacket, SphinxPacket,
Error as SphinxError, ProcessedPacket, SphinxPacket,
};
use thiserror::Error;
#[derive(Error, Debug)]
pub enum NymPacketError {
#[error("Sphinx error: {0}")]
Sphinx(#[from] sphinx_packet::Error),
#[error("Outfox error: {0}")]
Outfox(#[from] nym_outfox::error::OutfoxError),
}
#[allow(clippy::large_enum_variant)]
pub enum NymPacket {
Sphinx(SphinxPacket),
Outfox(OutfoxPacket),
@@ -50,10 +61,17 @@ impl NymPacket {
self.len() == 0
}
pub fn to_bytes(&self) -> Result<Vec<u8>, OutfoxError> {
pub fn to_bytes(&self) -> Result<Vec<u8>, NymPacketError> {
match self {
NymPacket::Sphinx(packet) => Ok(packet.to_bytes()),
NymPacket::Outfox(packet) => packet.to_bytes(),
NymPacket::Outfox(packet) => Ok(packet.to_bytes()?),
}
}
pub fn process(self, node_secret_key: &PrivateKey) -> Result<ProcessedPacket, NymPacketError> {
match self {
NymPacket::Sphinx(packet) => Ok(packet.process(node_secret_key)?),
NymPacket::Outfox(_packet) => todo!(),
}
}
}
contracts/Cargo.lock
Generated
+272 -10
View File
@@ -2,6 +2,16 @@
# It is not intended for manual editing.
version = 3
[[package]]
name = "aead"
version = "0.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0"
dependencies = [
"crypto-common",
"generic-array 0.14.6",
]
[[package]]
name = "aes"
version = "0.7.5"
@@ -9,7 +19,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9e8b47f52ea9bae42228d07ec09eb676433d7c4ed1ebdf0f1d1c29ed446f1ab8"
dependencies = [
"cfg-if",
"cipher",
"cipher 0.3.0",
"cpufeatures",
"ctr",
"opaque-debug 0.3.0",
@@ -38,6 +48,12 @@ version = "0.3.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a4c527152e37cf757a3f78aae5a06fbeefdb07ccc535c980a3208ee3060dd544"
[[package]]
name = "arrayvec"
version = "0.7.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8da52d66c7071e2e3fa2a1e5c6d088fec47b593032b254f5e980de8ea54454d6"
[[package]]
name = "autocfg"
version = "1.1.0"
@@ -68,6 +84,15 @@ version = "1.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
[[package]]
name = "bincode"
version = "1.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
dependencies = [
"serde",
]
[[package]]
name = "bitflags"
version = "1.3.2"
@@ -86,6 +111,20 @@ dependencies = [
"opaque-debug 0.2.3",
]
[[package]]
name = "blake3"
version = "1.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "42ae2468a89544a466886840aa467a25b766499f4f04bf7d9fcd10ecee9fccef"
dependencies = [
"arrayref",
"arrayvec",
"cc",
"cfg-if",
"constant_time_eq",
"digest 0.10.6",
]
[[package]]
name = "block-buffer"
version = "0.9.0"
@@ -95,6 +134,15 @@ dependencies = [
"generic-array 0.14.6",
]
[[package]]
name = "block-buffer"
version = "0.10.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
dependencies = [
"generic-array 0.14.6",
]
[[package]]
name = "bs58"
version = "0.4.0"
@@ -150,6 +198,30 @@ dependencies = [
"keystream",
]
[[package]]
name = "chacha20"
version = "0.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c3613f74bd2eac03dad61bd53dbe620703d4371614fe0bc3b9f04dd36fe4e818"
dependencies = [
"cfg-if",
"cipher 0.4.4",
"cpufeatures",
]
[[package]]
name = "chacha20poly1305"
version = "0.10.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "10cd79432192d1c0f4e1a0fef9527696cc039165d729fb41b3f4f4f354c2dc35"
dependencies = [
"aead",
"chacha20",
"cipher 0.4.4",
"poly1305",
"zeroize",
]
[[package]]
name = "cipher"
version = "0.3.0"
@@ -159,6 +231,17 @@ dependencies = [
"generic-array 0.14.6",
]
[[package]]
name = "cipher"
version = "0.4.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
dependencies = [
"crypto-common",
"inout",
"zeroize",
]
[[package]]
name = "coconut-test"
version = "0.1.0"
@@ -190,6 +273,12 @@ version = "0.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e4c78c047431fee22c1a7bb92e00ad095a02a983affe4d8a72e2a2c62c1b94f3"
[[package]]
name = "constant_time_eq"
version = "0.2.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "13418e745008f7349ec7e449155f419a61b92b58a99cc3616942b926825ec76b"
[[package]]
name = "cosmwasm-crypto"
version = "1.0.0"
@@ -258,6 +347,49 @@ dependencies = [
"libc",
]
[[package]]
name = "crossbeam-channel"
version = "0.5.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a33c2bf77f2df06183c3aa30d1e96c0695a313d4f9c453cc3762a6db39f99200"
dependencies = [
"cfg-if",
"crossbeam-utils",
]
[[package]]
name = "crossbeam-deque"
version = "0.8.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ce6fd6f855243022dcecf8702fef0c297d4338e226845fe067f6341ad9fa0cef"
dependencies = [
"cfg-if",
"crossbeam-epoch",
"crossbeam-utils",
]
[[package]]
name = "crossbeam-epoch"
version = "0.9.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "46bd5f3f85273295a9d14aedfb86f6aadbff6d8f5295c4a9edb08e819dcf5695"
dependencies = [
"autocfg",
"cfg-if",
"crossbeam-utils",
"memoffset",
"scopeguard",
]
[[package]]
name = "crossbeam-utils"
version = "0.8.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3c063cd8cc95f5c377ed0d4b49a4b21f632396ff690e8470c29b3359b346984b"
dependencies = [
"cfg-if",
]
[[package]]
name = "crunchy"
version = "0.2.2"
@@ -276,6 +408,17 @@ dependencies = [
"zeroize",
]
[[package]]
name = "crypto-common"
version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
dependencies = [
"generic-array 0.14.6",
"rand_core 0.6.4",
"typenum",
]
[[package]]
name = "crypto-mac"
version = "0.7.0"
@@ -302,14 +445,14 @@ version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "049bb91fb4aaf0e3c7efa6cd5ef877dbbbd15b39dad06d9948de4ec8a75761ea"
dependencies = [
"cipher",
"cipher 0.3.0",
]
[[package]]
name = "curve25519-dalek"
version = "3.2.1"
version = "3.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "90f9d052967f590a76e62eb387bd0bbb1b000182c3cefe5364db6b7211651bc0"
checksum = "0b9fdf9972b2bd6af2d913799d9ebc165ea4d2e65878e329d9c6b372c4491b61"
dependencies = [
"byteorder",
"digest 0.9.0",
@@ -501,6 +644,17 @@ dependencies = [
"generic-array 0.14.6",
]
[[package]]
name = "digest"
version = "0.10.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8168378f4e5023e7218c89c891c0fd8ecdb5e5e4f18cb78f38cf245dd021e76f"
dependencies = [
"block-buffer 0.10.4",
"crypto-common",
"subtle 2.4.1",
]
[[package]]
name = "dyn-clone"
version = "1.0.11"
@@ -701,8 +855,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
dependencies = [
"cfg-if",
"js-sys",
"libc",
"wasi 0.11.0+wasi-snapshot-preview1",
"wasm-bindgen",
]
[[package]]
@@ -750,6 +906,15 @@ dependencies = [
"ahash",
]
[[package]]
name = "hermit-abi"
version = "0.2.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ee512640fe35acbfb4bb779db6f0d80704c2cacfa2e39b601ef3e3f47d1ae4c7"
dependencies = [
"libc",
]
[[package]]
name = "hermit-abi"
version = "0.3.1"
@@ -808,6 +973,15 @@ dependencies = [
"unicode-normalization",
]
[[package]]
name = "inout"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a0c10553d664a4d0bcff9f4215d0aac67a639cc68ef660840afe309b807bc9f5"
dependencies = [
"generic-array 0.14.6",
]
[[package]]
name = "instant"
version = "0.1.12"
@@ -823,7 +997,7 @@ version = "1.0.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "09270fd4fa1111bc614ed2246c7ef56239a3063d5be0d1ec3b589c505d400aeb"
dependencies = [
"hermit-abi",
"hermit-abi 0.3.1",
"libc",
"windows-sys 0.45.0",
]
@@ -949,6 +1123,15 @@ dependencies = [
"cfg-if",
]
[[package]]
name = "memoffset"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d61c719bcfbcf5d62b3a09efa6088de8c54bc0bfcd3ea7ae39fcc186108b8de1"
dependencies = [
"autocfg",
]
[[package]]
name = "num-traits"
version = "0.2.15"
@@ -959,6 +1142,16 @@ dependencies = [
"libm",
]
[[package]]
name = "num_cpus"
version = "1.15.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0fac9e2da13b5eb447a6ce3d392f23a29d8694bff781bf03a16cd9ac8697593b"
dependencies = [
"hermit-abi 0.2.6",
"libc",
]
[[package]]
name = "nym-coconut-bandwidth"
version = "0.1.0"
@@ -1105,6 +1298,23 @@ dependencies = [
"thiserror",
]
[[package]]
name = "nym-outfox"
version = "0.1.0"
dependencies = [
"bincode",
"blake3",
"chacha20",
"chacha20poly1305",
"curve25519-dalek",
"getrandom 0.2.8",
"rayon",
"serde",
"sphinx-packet",
"thiserror",
"zeroize",
]
[[package]]
name = "nym-pemstore"
version = "0.2.0"
@@ -1143,7 +1353,10 @@ dependencies = [
name = "nym-sphinx-types"
version = "0.2.0"
dependencies = [
"nym-outfox",
"serde",
"sphinx-packet",
"thiserror",
]
[[package]]
@@ -1232,6 +1445,17 @@ version = "0.3.26"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6ac9a59f73473f1b8d852421e59e64809f025994837ef743615c6d0c5b305160"
[[package]]
name = "poly1305"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8159bd90725d2df49889a078b54f4f79e87f1f8a8444194cdca81d38f5393abf"
dependencies = [
"cpufeatures",
"opaque-debug 0.3.0",
"universal-hash",
]
[[package]]
name = "ppv-lite86"
version = "0.2.17"
@@ -1379,6 +1603,28 @@ dependencies = [
"rand_core 0.5.1",
]
[[package]]
name = "rayon"
version = "1.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1d2df5196e37bcc87abebc0053e20787d73847bb33134a69841207dd0a47f03b"
dependencies = [
"either",
"rayon-core",
]
[[package]]
name = "rayon-core"
version = "1.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4b8f95bd6966f5c87776639160a66bd8ab9895d9d4ab01ddba9fc60661aebe8d"
dependencies = [
"crossbeam-channel",
"crossbeam-deque",
"crossbeam-utils",
"num_cpus",
]
[[package]]
name = "redox_syscall"
version = "0.2.16"
@@ -1485,6 +1731,12 @@ dependencies = [
"syn 1.0.109",
]
[[package]]
name = "scopeguard"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
[[package]]
name = "sec1"
version = "0.2.1"
@@ -1572,7 +1824,7 @@ version = "0.9.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4d58a1e1bf39749807d89cf2d98ac2dfa0ff1cb3faa38fbb64dd88ac8013d800"
dependencies = [
"block-buffer",
"block-buffer 0.9.0",
"cfg-if",
"cpufeatures",
"digest 0.9.0",
@@ -1804,6 +2056,16 @@ version = "0.2.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
[[package]]
name = "universal-hash"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7d3160b73c9a19f7e2939a2fdad446c57c1bbbbf4d919d3213ff1267a580d8b5"
dependencies = [
"crypto-common",
"subtle 2.4.1",
]
[[package]]
name = "url"
version = "2.3.1"
@@ -2024,9 +2286,9 @@ checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
[[package]]
name = "x25519-dalek"
version = "1.2.0"
version = "1.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2392b6b94a576b4e2bf3c5b2757d63f10ada8020a2e4d08ac849ebcf6ea8e077"
checksum = "5a0c105152107e3b96f6a00a65e86ce82d9b125230e1c4302940eca58ff71f4f"
dependencies = [
"curve25519-dalek",
"rand_core 0.5.1",
@@ -2035,9 +2297,9 @@ dependencies = [
[[package]]
name = "zeroize"
version = "1.3.0"
version = "1.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4756f7db3f7b5574938c3eb1c117038b8e07f95ee6718c0efad4ac21508f1efd"
checksum = "2a0956f1ba7c7909bfb66c2e9e4124ab6f6482560f6628b5aaeba39207c9aad9"
dependencies = [
"zeroize_derive",
]
gateway/src/node/mixnet_handling/receiver/connection_handler.rs
+4 -4
View File
@@ -11,8 +11,8 @@ use log::*;
use nym_mixnet_client::forwarder::MixForwardingSender;
use nym_mixnode_common::packet_processor::processor::ProcessedFinalHop;
use nym_sphinx::forwarding::packet::MixPacket;
use nym_sphinx::framing::codec::SphinxCodec;
use nym_sphinx::framing::packet::FramedSphinxPacket;
use nym_sphinx::framing::codec::NymCodec;
use nym_sphinx::framing::packet::FramedNymPacket;
use nym_sphinx::DestinationAddressBytes;
use nym_task::TaskClient;
use std::collections::HashMap;
@@ -155,7 +155,7 @@ impl<St: Storage> ConnectionHandler<St> {
self.forward_ack(forward_ack, client_address);
}
async fn handle_received_packet(&mut self, framed_sphinx_packet: FramedSphinxPacket) {
async fn handle_received_packet(&mut self, framed_sphinx_packet: FramedNymPacket) {
//
// TODO: here be replay attack detection - it will require similar key cache to the one in
// packet processor for vpn packets,
@@ -182,7 +182,7 @@ impl<St: Storage> ConnectionHandler<St> {
) {
debug!("Starting connection handler for {:?}", remote);
shutdown.mark_as_success();
let mut framed_conn = Framed::new(conn, SphinxCodec);
let mut framed_conn = Framed::new(conn, NymCodec);
while !shutdown.is_shutdown() {
tokio::select! {
biased;
gateway/src/node/mixnet_handling/receiver/packet_processing.rs
+2 -2
View File
@@ -5,7 +5,7 @@ use nym_crypto::asymmetric::encryption;
use nym_mixnode_common::packet_processor::error::MixProcessingError;
pub use nym_mixnode_common::packet_processor::processor::MixProcessingResult;
use nym_mixnode_common::packet_processor::processor::{ProcessedFinalHop, SphinxPacketProcessor};
use nym_sphinx::framing::packet::FramedSphinxPacket;
use nym_sphinx::framing::packet::FramedNymPacket;
use thiserror::Error;
#[derive(Error, Debug)]
@@ -32,7 +32,7 @@ impl PacketProcessor {
pub(crate) fn process_received(
&self,
received: FramedSphinxPacket,
received: FramedNymPacket,
) -> Result<ProcessedFinalHop, GatewayProcessingError> {
match self.inner_processor.process_received(received)? {
MixProcessingResult::ForwardHop(..) => {
mixnode/src/node/listener/connection_handler/mod.rs
+4 -4
View File
@@ -9,8 +9,8 @@ use crate::node::TaskClient;
use futures::StreamExt;
use nym_mixnode_common::measure;
use nym_sphinx::forwarding::packet::MixPacket;
use nym_sphinx::framing::codec::SphinxCodec;
use nym_sphinx::framing::packet::FramedSphinxPacket;
use nym_sphinx::framing::codec::NymCodec;
use nym_sphinx::framing::packet::FramedNymPacket;
use nym_sphinx::Delay as SphinxDelay;
use std::net::SocketAddr;
use tokio::net::TcpStream;
@@ -54,7 +54,7 @@ impl ConnectionHandler {
feature = "cpucycles",
instrument(skip(self, framed_sphinx_packet), fields(cpucycles))
)]
fn handle_received_packet(&self, framed_sphinx_packet: FramedSphinxPacket) {
fn handle_received_packet(&self, framed_sphinx_packet: FramedNymPacket) {
//
// TODO: here be replay attack detection - it will require similar key cache to the one in
// packet processor for vpn packets,
@@ -86,7 +86,7 @@ impl ConnectionHandler {
) {
debug!("Starting connection handler for {:?}", remote);
shutdown.mark_as_success();
let mut framed_conn = Framed::new(conn, SphinxCodec);
let mut framed_conn = Framed::new(conn, NymCodec);
while !shutdown.is_shutdown() {
tokio::select! {
biased;
mixnode/src/node/listener/connection_handler/packet_processing.rs
+2 -2
View File
@@ -6,7 +6,7 @@ use nym_crypto::asymmetric::encryption;
use nym_mixnode_common::packet_processor::error::MixProcessingError;
pub use nym_mixnode_common::packet_processor::processor::MixProcessingResult;
use nym_mixnode_common::packet_processor::processor::SphinxPacketProcessor;
use nym_sphinx::framing::packet::FramedSphinxPacket;
use nym_sphinx::framing::packet::FramedNymPacket;
// PacketProcessor contains all data required to correctly unwrap and forward sphinx packets
#[derive(Clone)]
@@ -31,7 +31,7 @@ impl PacketProcessor {
pub(crate) fn process_received(
&self,
received: FramedSphinxPacket,
received: FramedNymPacket,
) -> Result<MixProcessingResult, MixProcessingError> {
self.node_stats_update_sender.report_received();
self.inner_processor.process_received(received)
mixnode/src/node/packet_delayforwarder.rs
+8 -7
View File
@@ -5,7 +5,7 @@ use crate::node::node_statistics::UpdateSender;
use futures::channel::mpsc;
use futures::StreamExt;
use nym_nonexhaustive_delayqueue::{Expired, NonExhaustiveDelayQueue};
use nym_sphinx::forwarding::packet::MixPacket;
use nym_sphinx::{forwarding::packet::MixPacket, NymPacket};
use std::io;
use tokio::time::Instant;
@@ -61,10 +61,11 @@ where
let packet_mode = packet.packet_mode();
let sphinx_packet = packet.into_sphinx_packet();
if let Err(err) =
self.mixnet_client
.send_without_response(next_hop, sphinx_packet, packet_mode)
{
if let Err(err) = self.mixnet_client.send_without_response(
next_hop,
NymPacket::Sphinx(sphinx_packet),
packet_mode,
) {
if err.kind() == io::ErrorKind::WouldBlock {
// we only know for sure if we dropped a packet if our sending queue was full
// in any other case the connection might still be re-established (or created for the first time)
@@ -147,14 +148,14 @@ mod tests {
#[derive(Default)]
struct TestClient {
pub packets_sent: Arc<Mutex<Vec<(NymNodeRoutingAddress, SphinxPacket, PacketMode)>>>,
pub packets_sent: Arc<Mutex<Vec<(NymNodeRoutingAddress, NymPacket, PacketMode)>>>,
}
impl nym_mixnet_client::SendWithoutResponse for TestClient {
fn send_without_response(
&mut self,
address: NymNodeRoutingAddress,
packet: SphinxPacket,
packet: NymPacket,
packet_mode: PacketMode,
) -> io::Result<()> {
self.packets_sent
nym-connect/desktop/Cargo.lock
Generated
+22 -28
View File
@@ -217,6 +217,15 @@ version = "1.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
[[package]]
name = "bincode"
version = "1.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
dependencies = [
"serde",
]
[[package]]
name = "bip32"
version = "0.3.0"
@@ -3191,7 +3200,7 @@ dependencies = [
[[package]]
name = "nym-bin-common"
version = "0.4.0"
version = "0.5.0"
dependencies = [
"atty",
"clap",
@@ -3560,13 +3569,15 @@ dependencies = [
name = "nym-outfox"
version = "0.1.0"
dependencies = [
"bincode",
"blake3",
"chacha20",
"chacha20poly1305",
"curve25519-dalek",
"getrandom 0.2.8",
"rayon",
"sphinx-packet 0.1.0 (git+https://github.com/nymtech/sphinx.git)",
"serde",
"sphinx-packet",
"thiserror",
"zeroize",
]
@@ -3747,9 +3758,11 @@ dependencies = [
name = "nym-sphinx-framing"
version = "0.1.0"
dependencies = [
"bincode",
"bytes",
"nym-sphinx-params",
"nym-sphinx-types",
"serde",
"thiserror",
"tokio-util",
]
@@ -3759,6 +3772,7 @@ name = "nym-sphinx-params"
version = "0.1.0"
dependencies = [
"nym-crypto",
"nym-outfox",
"nym-sphinx-types",
"serde",
"thiserror",
@@ -3768,7 +3782,10 @@ dependencies = [
name = "nym-sphinx-types"
version = "0.2.0"
dependencies = [
"sphinx-packet 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
"nym-outfox",
"serde",
"sphinx-packet",
"thiserror",
]
[[package]]
@@ -3841,7 +3858,7 @@ dependencies = [
[[package]]
name = "nym-vesting-contract"
version = "1.3.0"
version = "1.3.1"
dependencies = [
"cosmwasm-derive",
"cosmwasm-std",
@@ -3859,7 +3876,7 @@ dependencies = [
[[package]]
name = "nym-vesting-contract-common"
version = "0.4.0"
version = "0.5.0"
dependencies = [
"cosmwasm-std",
"nym-contracts-common",
@@ -5377,29 +5394,6 @@ dependencies = [
"subtle 2.4.1",
]
[[package]]
name = "sphinx-packet"
version = "0.1.0"
source = "git+https://github.com/nymtech/sphinx.git#ca107d94360cdf8bbfbdb12fe5320ed74f80e40c"
dependencies = [
"aes 0.7.5",
"arrayref",
"blake2",
"bs58",
"byteorder",
"chacha",
"curve25519-dalek",
"digest 0.9.0",
"hkdf 0.11.0",
"hmac 0.11.0",
"lioness",
"log",
"rand 0.7.3",
"rand_distr",
"sha2 0.9.9",
"subtle 2.4.1",
]
[[package]]
name = "spin"
version = "0.5.2"
nym-outfox/src/format.rs
+10 -8
View File
@@ -68,21 +68,23 @@ use sphinx_packet::route::Node;
use std::convert::TryInto;
const GROUPELEMENTBYTES: usize = 32;
const TAGBYTES: usize = 16;
pub const GROUPELEMENTBYTES: usize = 32;
pub const TAGBYTES: usize = 16;
use std::ops::Range;
use std::u8;
use crate::error::OutfoxError;
use crate::lion::*;
use crate::packet::DEFAULT_ROUTING_INFO_SIZE;
/// A structure that holds mix packet construction parameters. These incluse the length
/// of the routing information at each hop, the number of hops, and the payload length.
#[derive(Serialize, Deserialize)]
pub struct MixCreationParameters {
/// The routing length is inner first, so \[0\] is the innermost routing length, etc (in bytes)
pub routing_information_length_by_stage: Vec<usize>,
/// In our stratified topology this will always be 3
pub routing_information_length_by_stage: [usize; 3],
/// The payload length (in bytes)
pub payload_length_bytes: usize,
}
@@ -91,16 +93,16 @@ impl MixCreationParameters {
/// Create a set of parameters for a mix packet format.
pub fn new(payload_length_bytes: usize) -> MixCreationParameters {
MixCreationParameters {
routing_information_length_by_stage: Vec::new(),
routing_information_length_by_stage: [DEFAULT_ROUTING_INFO_SIZE; 3],
payload_length_bytes,
}
}
/// Add another outer layer containing some byte length of routing data.
pub fn add_outer_layer(&mut self, routing_information_length_bytes: usize) {
self.routing_information_length_by_stage
.push(routing_information_length_bytes);
}
// pub fn add_outer_layer(&mut self, routing_information_length_bytes: usize) {
// self.routing_information_length_by_stage
// .push(routing_information_length_bytes);
// }
/// The length of the buffer needed to build a packet.
pub fn total_packet_length(&self) -> usize {
nym-outfox/src/packet.rs
+15 -7
View File
@@ -3,11 +3,14 @@ use std::ops::Range;
use crate::{
error::OutfoxError,
format::{MixCreationParameters, MixStageParameters},
format::{MixCreationParameters, MixStageParameters, GROUPELEMENTBYTES, TAGBYTES},
};
use sphinx_packet::{packet::builder::DEFAULT_PAYLOAD_SIZE, route::Node};
pub const OUTFOX_PACKET_OVERHEAD: usize =
3 * DEFAULT_ROUTING_INFO_SIZE + GROUPELEMENTBYTES + TAGBYTES;
#[derive(Serialize, Deserialize)]
pub struct OutfoxPacket {
mix_params: MixCreationParameters,
@@ -18,15 +21,20 @@ pub const DEFAULT_ROUTING_INFO_SIZE: usize = 32;
impl OutfoxPacket {
pub fn len(&self) -> usize {
self.mix_params().total_packet_length()
self.mix_params().total_packet_length() + self.payload.len()
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
// TODO: Replace with lightweight methods
pub fn to_bytes(&self) -> Result<Vec<u8>, OutfoxError> {
bincode::serialize(self).map_err(|_e| OutfoxError::Bincode)
}
pub fn from_bytes(v: &[u8]) -> Result<Self, OutfoxError> {
Ok(bincode::deserialize(v).map_err(|_| OutfoxError::Bincode)?)
bincode::deserialize(v).map_err(|_| OutfoxError::Bincode)
}
pub fn build(
@@ -34,11 +42,11 @@ impl OutfoxPacket {
route: &[Node; 3],
user_secret_key: &[u8],
) -> Result<OutfoxPacket, OutfoxError> {
let mut mix_params = MixCreationParameters::new(DEFAULT_PAYLOAD_SIZE);
let mix_params = MixCreationParameters::new(DEFAULT_PAYLOAD_SIZE);
for node in route.iter() {
mix_params.add_outer_layer(node.address.as_bytes_ref().len());
}
// for node in route.iter() {
// mix_params.add_outer_layer(node.address.as_bytes_ref().len());
// }
let padding = mix_params.total_packet_length() - payload.len();
let mut buffer = vec![0; padding];
nym-wallet/Cargo.lock
Generated
+192 -6
View File
@@ -23,6 +23,16 @@ dependencies = [
"generic-array 0.14.6",
]
[[package]]
name = "aead"
version = "0.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0"
dependencies = [
"crypto-common",
"generic-array 0.14.6",
]
[[package]]
name = "aes"
version = "0.7.5"
@@ -30,7 +40,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9e8b47f52ea9bae42228d07ec09eb676433d7c4ed1ebdf0f1d1c29ed446f1ab8"
dependencies = [
"cfg-if",
"cipher",
"cipher 0.3.0",
"cpufeatures",
"ctr",
"opaque-debug 0.3.0",
@@ -42,9 +52,9 @@ version = "0.9.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "df5f85a83a7d8b0442b6aa7b504b8212c1733da07b98aae43d4bc21b2cb3cdf6"
dependencies = [
"aead",
"aead 0.4.3",
"aes",
"cipher",
"cipher 0.3.0",
"ctr",
"ghash",
"subtle 2.4.1",
@@ -119,6 +129,12 @@ version = "0.3.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a4c527152e37cf757a3f78aae5a06fbeefdb07ccc535c980a3208ee3060dd544"
[[package]]
name = "arrayvec"
version = "0.7.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8da52d66c7071e2e3fa2a1e5c6d088fec47b593032b254f5e980de8ea54454d6"
[[package]]
name = "async-trait"
version = "0.1.64"
@@ -211,6 +227,15 @@ version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8a32fd6af2b5827bce66c29053ba0e7c42b9dcab01835835058558c10851a46b"
[[package]]
name = "bincode"
version = "1.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
dependencies = [
"serde",
]
[[package]]
name = "bip32"
version = "0.3.0"
@@ -288,6 +313,20 @@ dependencies = [
"digest 0.10.6",
]
[[package]]
name = "blake3"
version = "1.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "42ae2468a89544a466886840aa467a25b766499f4f04bf7d9fcd10ecee9fccef"
dependencies = [
"arrayref",
"arrayvec",
"cc",
"cfg-if",
"constant_time_eq",
"digest 0.10.6",
]
[[package]]
name = "block"
version = "0.1.6"
@@ -496,6 +535,30 @@ dependencies = [
"keystream",
]
[[package]]
name = "chacha20"
version = "0.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c3613f74bd2eac03dad61bd53dbe620703d4371614fe0bc3b9f04dd36fe4e818"
dependencies = [
"cfg-if",
"cipher 0.4.4",
"cpufeatures",
]
[[package]]
name = "chacha20poly1305"
version = "0.10.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "10cd79432192d1c0f4e1a0fef9527696cc039165d729fb41b3f4f4f354c2dc35"
dependencies = [
"aead 0.5.2",
"chacha20",
"cipher 0.4.4",
"poly1305",
"zeroize",
]
[[package]]
name = "cipher"
version = "0.3.0"
@@ -505,6 +568,17 @@ dependencies = [
"generic-array 0.14.6",
]
[[package]]
name = "cipher"
version = "0.4.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
dependencies = [
"crypto-common",
"inout",
"zeroize",
]
[[package]]
name = "clap"
version = "4.1.4"
@@ -636,6 +710,12 @@ version = "0.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e4c78c047431fee22c1a7bb92e00ad095a02a983affe4d8a72e2a2c62c1b94f3"
[[package]]
name = "constant_time_eq"
version = "0.2.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "13418e745008f7349ec7e449155f419a61b92b58a99cc3616942b926825ec76b"
[[package]]
name = "convert_case"
version = "0.4.0"
@@ -782,6 +862,30 @@ dependencies = [
"crossbeam-utils",
]
[[package]]
name = "crossbeam-deque"
version = "0.8.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ce6fd6f855243022dcecf8702fef0c297d4338e226845fe067f6341ad9fa0cef"
dependencies = [
"cfg-if",
"crossbeam-epoch",
"crossbeam-utils",
]
[[package]]
name = "crossbeam-epoch"
version = "0.9.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "46bd5f3f85273295a9d14aedfb86f6aadbff6d8f5295c4a9edb08e819dcf5695"
dependencies = [
"autocfg",
"cfg-if",
"crossbeam-utils",
"memoffset 0.8.0",
"scopeguard",
]
[[package]]
name = "crossbeam-utils"
version = "0.8.14"
@@ -816,6 +920,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
dependencies = [
"generic-array 0.14.6",
"rand_core 0.6.4",
"typenum",
]
@@ -891,7 +996,7 @@ version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "049bb91fb4aaf0e3c7efa6cd5ef877dbbbd15b39dad06d9948de4ec8a75761ea"
dependencies = [
"cipher",
"cipher 0.3.0",
]
[[package]]
@@ -1342,7 +1447,7 @@ version = "0.3.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e1c54951450cbd39f3dbcf1005ac413b49487dabf18a720ad2383eccfeffb92"
dependencies = [
"memoffset",
"memoffset 0.6.5",
"rustc_version 0.3.3",
]
@@ -2239,6 +2344,15 @@ dependencies = [
"cfb",
]
[[package]]
name = "inout"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a0c10553d664a4d0bcff9f4215d0aac67a639cc68ef660840afe309b807bc9f5"
dependencies = [
"generic-array 0.14.6",
]
[[package]]
name = "instant"
version = "0.1.12"
@@ -2573,6 +2687,15 @@ dependencies = [
"autocfg",
]
[[package]]
name = "memoffset"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d61c719bcfbcf5d62b3a09efa6088de8c54bc0bfcd3ea7ae39fcc186108b8de1"
dependencies = [
"autocfg",
]
[[package]]
name = "mime"
version = "0.3.16"
@@ -2959,6 +3082,23 @@ dependencies = [
"url",
]
[[package]]
name = "nym-outfox"
version = "0.1.0"
dependencies = [
"bincode",
"blake3",
"chacha20",
"chacha20poly1305",
"curve25519-dalek",
"getrandom 0.2.8",
"rayon",
"serde",
"sphinx-packet",
"thiserror",
"zeroize",
]
[[package]]
name = "nym-pemstore"
version = "0.2.0"
@@ -2970,7 +3110,10 @@ dependencies = [
name = "nym-sphinx-types"
version = "0.2.0"
dependencies = [
"nym-outfox",
"serde",
"sphinx-packet",
"thiserror",
]
[[package]]
@@ -3642,6 +3785,17 @@ dependencies = [
"miniz_oxide",
]
[[package]]
name = "poly1305"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8159bd90725d2df49889a078b54f4f79e87f1f8a8444194cdca81d38f5393abf"
dependencies = [
"cpufeatures",
"opaque-debug 0.3.0",
"universal-hash 0.5.0",
]
[[package]]
name = "polyval"
version = "0.5.3"
@@ -3651,7 +3805,7 @@ dependencies = [
"cfg-if",
"cpufeatures",
"opaque-debug 0.3.0",
"universal-hash",
"universal-hash 0.4.1",
]
[[package]]
@@ -3894,6 +4048,28 @@ dependencies = [
"cty",
]
[[package]]
name = "rayon"
version = "1.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1d2df5196e37bcc87abebc0053e20787d73847bb33134a69841207dd0a47f03b"
dependencies = [
"either",
"rayon-core",
]
[[package]]
name = "rayon-core"
version = "1.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4b8f95bd6966f5c87776639160a66bd8ab9895d9d4ab01ddba9fc60661aebe8d"
dependencies = [
"crossbeam-channel",
"crossbeam-deque",
"crossbeam-utils",
"num_cpus",
]
[[package]]
name = "redox_syscall"
version = "0.2.16"
@@ -5441,6 +5617,16 @@ dependencies = [
"subtle 2.4.1",
]
[[package]]
name = "universal-hash"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7d3160b73c9a19f7e2939a2fdad446c57c1bbbbf4d919d3213ff1267a580d8b5"
dependencies = [
"crypto-common",
"subtle 2.4.1",
]
[[package]]
name = "untrusted"
version = "0.7.1"