evan/protomask
1
Fork 0
Code

Merge branch 'master' of https://github.com/ewpratten/protomask

Browse Source
This commit is contained in:
Evan Pratten 2023-07-22 11:27:13 -04:00
commit 33a2dd685f
19 changed files with 165 additions and 208 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

63
src/cli/logging.rs
View File

@ -6,39 +6,36 @@ pub fn enable_logger(verbose: bool) {
fern::Dispatch::new()
.format(move |out, message, record| {
out.finish(format_args!(
"{}: {}",
format!(
"{}{}",
// Level messages are padded to keep the output looking somewhat sane
match record.level() {
log::Level::Error => "ERROR"
.if_supports_color(Stdout, |text| text.red())
.if_supports_color(Stdout, |text| text.bold())
.to_string(),
log::Level::Warn => "WARN "
.if_supports_color(Stdout, |text| text.yellow())
.if_supports_color(Stdout, |text| text.bold())
.to_string(),
log::Level::Info => "INFO "
.if_supports_color(Stdout, |text| text.green())
.if_supports_color(Stdout, |text| text.bold())
.to_string(),
log::Level::Debug => "DEBUG"
.if_supports_color(Stdout, |text| text.bright_blue())
.if_supports_color(Stdout, |text| text.bold())
.to_string(),
log::Level::Trace => "TRACE"
.if_supports_color(Stdout, |text| text.bright_white())
.if_supports_color(Stdout, |text| text.bold())
.to_string(),
},
// Only show the outer package name if verbose logging is enabled (otherwise nothing)
match verbose {
true => format!(" [{}]", record.target().split("::").nth(0).unwrap()),
false => String::new(),
}
.if_supports_color(Stdout, |text| text.bright_black())
),
"{}{}: {}",
// Level messages are padded to keep the output looking somewhat sane
match record.level() {
log::Level::Error => "ERROR"
.if_supports_color(Stdout, |text| text.red())
.if_supports_color(Stdout, |text| text.bold())
.to_string(),
log::Level::Warn => "WARN "
.if_supports_color(Stdout, |text| text.yellow())
.if_supports_color(Stdout, |text| text.bold())
.to_string(),
log::Level::Info => "INFO "
.if_supports_color(Stdout, |text| text.green())
.if_supports_color(Stdout, |text| text.bold())
.to_string(),
log::Level::Debug => "DEBUG"
.if_supports_color(Stdout, |text| text.bright_blue())
.if_supports_color(Stdout, |text| text.bold())
.to_string(),
log::Level::Trace => "TRACE"
.if_supports_color(Stdout, |text| text.bright_white())
.if_supports_color(Stdout, |text| text.bold())
.to_string(),
},
// Only show the outer package name if verbose logging is enabled (otherwise nothing)
match verbose {
true => format!(" [{}]", record.target().split("::").next().unwrap()),
false => String::new(),
}
.if_supports_color(Stdout, |text| text.bright_black()),
message
))
})

7
src/lib.rs
View File

@ -2,6 +2,11 @@
//!
//! *Note: There is a fair chance you are looking for `src/cli/main.rs` instead of this file.*
#![deny(clippy::pedantic)]
#![allow(clippy::module_name_repetitions)]
#![allow(clippy::missing_errors_doc)]
#![allow(clippy::missing_panics_doc)]
pub mod metrics;
pub mod nat;
mod packet;
pub mod metrics;

3
src/metrics/http.rs
View File

@ -7,6 +7,7 @@ use hyper::{
use prometheus::{Encoder, TextEncoder};
/// Handle an HTTP request
#[allow(clippy::unused_async)]
async fn handle_request(request: Request<Body>) -> Result<Response<Body>, Infallible> {
// If the request is targeting the metrics endpoint
if request.method() == Method::GET && request.uri().path() == "/metrics" {
@ -39,6 +40,6 @@ pub async fn serve_metrics(bind_addr: SocketAddr) {
// Run the server
if let Err(e) = server.await {
eprintln!("Metrics server error: {}", e);
eprintln!("Metrics server error: {e}");
}
}

3
src/metrics/mod.rs
View File

@ -1,5 +1,6 @@
mod http;
#[allow(clippy::module_inception)]
mod metrics;
pub use http::serve_metrics;
pub(crate) use metrics::*;
pub use http::serve_metrics;

12
src/nat/error.rs
View File

@ -1,15 +1,15 @@
#[derive(Debug, thiserror::Error)]
pub enum Nat64Error {
#[error(transparent)]
TableError(#[from] super::table::TableError),
Table(#[from] super::table::TableError),
#[error(transparent)]
TunError(#[from] protomask_tun::Error),
Tun(#[from] protomask_tun::Error),
#[error(transparent)]
IoError(#[from] std::io::Error),
Io(#[from] std::io::Error),
#[error(transparent)]
PacketHandlingError(#[from] crate::packet::error::PacketError),
PacketHandling(#[from] crate::packet::error::PacketError),
#[error(transparent)]
PacketReceiveError(#[from] tokio::sync::broadcast::error::RecvError),
PacketReceive(#[from] tokio::sync::broadcast::error::RecvError),
#[error(transparent)]
PacketSendError(#[from] tokio::sync::mpsc::error::SendError<Vec<u8>>),
PacketSend(#[from] tokio::sync::mpsc::error::SendError<Vec<u8>>),
}

6
src/nat/mod.rs
View File

@ -44,7 +44,7 @@ impl Nat64 {
interface.add_route(ipv6_nat_prefix.into()).await?;
// Add the IPv4 pool prefixes as routes
for ipv4_prefix in ipv4_pool.iter() {
for ipv4_prefix in &ipv4_pool {
interface.add_route((*ipv4_prefix).into()).await?;
}
@ -149,7 +149,7 @@ impl Nat64 {
// Spawn a task to process the packet
tokio::spawn(async move {
if let Some(output) = unwrap_log(translate_ipv6_to_ipv4(
packet,
&packet,
new_source,
new_destination,
)) {
@ -169,7 +169,7 @@ impl Nat64 {
log::warn!("Translator running behind! Dropping {} packets", count);
Ok(())
}
error => Err(error),
error @ broadcast::error::RecvError::Closed => Err(error),
},
}?;
}

75
src/nat/table.rs
View File

@ -5,7 +5,7 @@ use std::{
};
use bimap::BiHashMap;
use ipnet::{Ipv4Net, Ipv6Net};
use ipnet::Ipv4Net;
use crate::metrics::{IPV4_POOL_RESERVED, IPV4_POOL_SIZE};
@ -136,61 +136,6 @@ impl Nat64Table {
// Otherwise, there is no matching reservation
Err(TableError::NoIpv6Mapping(ipv4))
}
/// Check if an address is within the IPv4 pool
pub fn is_address_within_pool(&self, address: &Ipv4Addr) -> bool {
self.ipv4_pool.iter().any(|net| net.contains(address))
}
/// Calculate the translated version of any address
pub fn calculate_xlat_addr(
&mut self,
input: &IpAddr,
ipv6_nat64_prefix: &Ipv6Net,
) -> Result<IpAddr, TableError> {
// Handle the incoming address type
match input {
// Handle IPv4
IpAddr::V4(ipv4_addr) => {
// If the address is in the IPv4 pool, it is a regular IPv4 address
if self.is_address_within_pool(ipv4_addr) {
// This means we need to pass through to `get_reverse`
return Ok(IpAddr::V6(self.get_reverse(*ipv4_addr)?));
}
// Otherwise, it shall be embedded inside the ipv6 prefix
let prefix_octets = ipv6_nat64_prefix.addr().octets();
let address_octets = ipv4_addr.octets();
return Ok(IpAddr::V6(Ipv6Addr::new(
u16::from_be_bytes([prefix_octets[0], prefix_octets[1]]),
u16::from_be_bytes([prefix_octets[2], prefix_octets[3]]),
u16::from_be_bytes([prefix_octets[4], prefix_octets[5]]),
u16::from_be_bytes([prefix_octets[6], prefix_octets[7]]),
u16::from_be_bytes([prefix_octets[8], prefix_octets[9]]),
u16::from_be_bytes([prefix_octets[10], prefix_octets[11]]),
u16::from_be_bytes([address_octets[0], address_octets[1]]),
u16::from_be_bytes([address_octets[2], address_octets[3]]),
)));
}
// Handle IPv6
IpAddr::V6(ipv6_addr) => {
// If the address is in the IPv6 prefix, it is an embedded IPv4 address
if ipv6_nat64_prefix.contains(ipv6_addr) {
let address_bytes = ipv6_addr.octets();
return Ok(IpAddr::V4(Ipv4Addr::new(
address_bytes[12],
address_bytes[13],
address_bytes[14],
address_bytes[15],
)));
}
// Otherwise, it is a regular IPv6 address and we can pass through to `get_or_assign_ipv4`
return Ok(IpAddr::V4(self.get_or_assign_ipv4(*ipv6_addr)?));
}
}
}
}
impl Nat64Table {
@ -200,16 +145,12 @@ impl Nat64Table {
// Prune from the reservation map
self.reservations.retain(|v6, v4| {
if let Some(time) = self.reservation_times.get(&(*v6, *v4)) {
if let Some(time) = time {
let keep = now - *time < self.reservation_timeout;
if !keep {
log::info!("Pruned reservation: {} -> {}", v6, v4);
}
keep
} else {
true
if let Some(Some(time)) = self.reservation_times.get(&(*v6, *v4)) {
let keep = now - *time < self.reservation_timeout;
if !keep {
log::info!("Pruned reservation: {} -> {}", v6, v4);
}
keep
} else {
true
}
@ -235,10 +176,10 @@ impl Nat64Table {
// Track the values
IPV4_POOL_RESERVED
.with_label_values(&["dynamic"])
.set(total_dynamic_reservations as i64);
.set(i64::from(total_dynamic_reservations));
IPV4_POOL_RESERVED
.with_label_values(&["static"])
.set(total_static_reservations as i64);
.set(i64::from(total_static_reservations));
}
}

14
src/packet/protocols/icmp.rs
View File

@ -13,7 +13,7 @@ pub struct IcmpPacket<T> {
}
impl<T> IcmpPacket<T> {
/// Construct a new ICMPv6 packet
/// Construct a new `ICMP` packet
pub fn new(icmp_type: IcmpType, icmp_code: IcmpCode, payload: T) -> Self {
Self {
icmp_type,
@ -32,7 +32,7 @@ where
fn try_from(bytes: Vec<u8>) -> Result<Self, Self::Error> {
// Parse the packet
let packet = pnet_packet::icmp::IcmpPacket::new(&bytes)
.ok_or(PacketError::TooShort(bytes.len(), bytes.to_vec()))?;
.ok_or(PacketError::TooShort(bytes.len(), bytes.clone()))?;
// Return the packet
Ok(Self {
@ -43,13 +43,13 @@ where
}
}
impl<T> Into<Vec<u8>> for IcmpPacket<T>
impl<T> From<IcmpPacket<T>> for Vec<u8>
where
T: Into<Vec<u8>>,
{
fn into(self) -> Vec<u8> {
fn from(packet: IcmpPacket<T>) -> Self {
// Convert the payload into raw bytes
let payload: Vec<u8> = self.payload.into();
let payload: Vec<u8> = packet.payload.into();
// Allocate a mutable packet to write into
let total_length =
@ -58,8 +58,8 @@ where
pnet_packet::icmp::MutableIcmpPacket::owned(vec![0u8; total_length]).unwrap();
// Write the type and code
output.set_icmp_type(self.icmp_type);
output.set_icmp_code(self.icmp_code);
output.set_icmp_type(packet.icmp_type);
output.set_icmp_code(packet.icmp_code);
// Write the payload
output.set_payload(&payload);

20
src/packet/protocols/icmpv6.rs
View File

@ -19,7 +19,7 @@ pub struct Icmpv6Packet<T> {
}
impl<T> Icmpv6Packet<T> {
/// Construct a new ICMPv6 packet
/// Construct a new `ICMPv6` packet
pub fn new(
source_address: Ipv6Addr,
destination_address: Ipv6Addr,
@ -41,7 +41,7 @@ impl<T> Icmpv6Packet<T>
where
T: From<Vec<u8>>,
{
/// Construct a new ICMPv6 packet from raw bytes
/// Construct a new `ICMPv6` packet from raw bytes
#[allow(dead_code)]
pub fn new_from_bytes(
bytes: &[u8],
@ -64,7 +64,7 @@ where
}
impl Icmpv6Packet<RawBytes> {
/// Construct a new ICMPv6 packet with a raw payload from raw bytes
/// Construct a new `ICMPv6` packet with a raw payload from raw bytes
pub fn new_from_bytes_raw_payload(
bytes: &[u8],
source_address: Ipv6Addr,
@ -85,13 +85,13 @@ impl Icmpv6Packet<RawBytes> {
}
}
impl<T> Into<Vec<u8>> for Icmpv6Packet<T>
impl<T> From<Icmpv6Packet<T>> for Vec<u8>
where
T: Into<Vec<u8>>,
{
fn into(self) -> Vec<u8> {
fn from(packet: Icmpv6Packet<T>) -> Self {
// Convert the payload into raw bytes
let payload: Vec<u8> = self.payload.into();
let payload: Vec<u8> = packet.payload.into();
// Allocate a mutable packet to write into
let total_length =
@ -100,8 +100,8 @@ where
pnet_packet::icmpv6::MutableIcmpv6Packet::owned(vec![0u8; total_length]).unwrap();
// Write the type and code
output.set_icmpv6_type(self.icmp_type);
output.set_icmpv6_code(self.icmp_code);
output.set_icmpv6_type(packet.icmp_type);
output.set_icmpv6_code(packet.icmp_code);
// Write the payload
output.set_payload(&payload);
@ -110,8 +110,8 @@ where
output.set_checksum(0);
output.set_checksum(pnet_packet::icmpv6::checksum(
&output.to_immutable(),
&self.source_address,
&self.destination_address,
&packet.source_address,
&packet.destination_address,
));
// Return the raw bytes

50
src/packet/protocols/ipv4.rs
View File

@ -25,6 +25,7 @@ pub struct Ipv4Packet<T> {
impl<T> Ipv4Packet<T> {
/// Construct a new IPv4 packet
#[allow(clippy::too_many_arguments)]
pub fn new(
dscp: u8,
ecn: u8,
@ -53,6 +54,7 @@ impl<T> Ipv4Packet<T> {
}
}
#[allow(clippy::cast_possible_truncation)]
fn options_length_words(&self) -> u8 {
self.options
.iter()
@ -70,8 +72,8 @@ where
fn try_from(bytes: Vec<u8>) -> Result<Self, Self::Error> {
// Parse the packet
let packet =
pnet_packet::ipv4::Ipv4Packet::new(&bytes).ok_or(PacketError::TooShort(bytes.len(), bytes.to_vec()))?;
let packet = pnet_packet::ipv4::Ipv4Packet::new(&bytes)
.ok_or(PacketError::TooShort(bytes.len(), bytes.clone()))?;
// Return the packet
Ok(Self {
@ -90,42 +92,42 @@ where
}
}
impl<T> Into<Vec<u8>> for Ipv4Packet<T>
impl<T> From<Ipv4Packet<T>> for Vec<u8>
where
T: Into<Vec<u8>> + Clone,
{
fn into(self) -> Vec<u8> {
fn from(packet: Ipv4Packet<T>) -> Self {
// Convert the payload into raw bytes
let payload: Vec<u8> = self.payload.clone().into();
let payload: Vec<u8> = packet.payload.clone().into();
// Build the packet
let total_length = 20 + (self.options_length_words() as usize * 4) + payload.len();
let mut packet =
let total_length = 20 + (packet.options_length_words() as usize * 4) + payload.len();
let mut output =
pnet_packet::ipv4::MutableIpv4Packet::owned(vec![0u8; total_length]).unwrap();
// Set the fields
packet.set_version(4);
packet.set_header_length(5 + self.options_length_words());
packet.set_dscp(self.dscp);
packet.set_ecn(self.ecn);
packet.set_total_length(total_length.try_into().unwrap());
packet.set_identification(self.identification);
packet.set_flags(self.flags);
packet.set_fragment_offset(self.fragment_offset);
packet.set_ttl(self.ttl);
packet.set_next_level_protocol(self.protocol);
packet.set_source(self.source_address);
packet.set_destination(self.destination_address);
packet.set_options(&self.options);
output.set_version(4);
output.set_header_length(5 + packet.options_length_words());
output.set_dscp(packet.dscp);
output.set_ecn(packet.ecn);
output.set_total_length(total_length.try_into().unwrap());
output.set_identification(packet.identification);
output.set_flags(packet.flags);
output.set_fragment_offset(packet.fragment_offset);
output.set_ttl(packet.ttl);
output.set_next_level_protocol(packet.protocol);
output.set_source(packet.source_address);
output.set_destination(packet.destination_address);
output.set_options(&packet.options);
// Set the payload
packet.set_payload(&payload);
output.set_payload(&payload);
// Calculate the checksum
packet.set_checksum(0);
packet.set_checksum(pnet_packet::ipv4::checksum(&packet.to_immutable()));
output.set_checksum(0);
output.set_checksum(pnet_packet::ipv4::checksum(&output.to_immutable()));
// Return the packet
packet.to_immutable().packet().to_vec()
output.to_immutable().packet().to_vec()
}
}

24
src/packet/protocols/ipv6.rs
View File

@ -46,8 +46,8 @@ where
fn try_from(bytes: Vec<u8>) -> Result<Self, Self::Error> {
// Parse the packet
let packet =
pnet_packet::ipv6::Ipv6Packet::new(&bytes).ok_or(PacketError::TooShort(bytes.len(), bytes.to_vec()))?;
let packet = pnet_packet::ipv6::Ipv6Packet::new(&bytes)
.ok_or(PacketError::TooShort(bytes.len(), bytes.clone()))?;
// Return the packet
Ok(Self {
@ -62,13 +62,13 @@ where
}
}
impl<T> Into<Vec<u8>> for Ipv6Packet<T>
impl<T> From<Ipv6Packet<T>> for Vec<u8>
where
T: Into<Vec<u8>>,
{
fn into(self) -> Vec<u8> {
fn from(packet: Ipv6Packet<T>) -> Self {
// Convert the payload into raw bytes
let payload: Vec<u8> = self.payload.into();
let payload: Vec<u8> = packet.payload.into();
// Allocate a mutable packet to write into
let total_length =
@ -78,13 +78,13 @@ where
// Write the header
output.set_version(6);
output.set_traffic_class(self.traffic_class);
output.set_flow_label(self.flow_label);
output.set_payload_length(payload.len() as u16);
output.set_next_header(self.next_header);
output.set_hop_limit(self.hop_limit);
output.set_source(self.source_address);
output.set_destination(self.destination_address);
output.set_traffic_class(packet.traffic_class);
output.set_flow_label(packet.flow_label);
output.set_payload_length(u16::try_from(payload.len()).unwrap());
output.set_next_header(packet.next_header);
output.set_hop_limit(packet.hop_limit);
output.set_source(packet.source_address);
output.set_destination(packet.destination_address);
// Write the payload
output.set_payload(&payload);

6
src/packet/protocols/raw.rs
View File

@ -11,8 +11,8 @@ impl TryFrom<Vec<u8>> for RawBytes {
}
}
impl Into<Vec<u8>> for RawBytes {
fn into(self) -> Vec<u8> {
self.0
impl From<RawBytes> for Vec<u8> {
fn from(val: RawBytes) -> Self {
val.0
}
}

46
src/packet/protocols/tcp.rs
View File

@ -24,6 +24,7 @@ pub struct TcpPacket<T> {
impl<T> TcpPacket<T> {
/// Construct a new TCP packet
#[allow(clippy::too_many_arguments)]
pub fn new(
source: SocketAddr,
destination: SocketAddr,
@ -102,11 +103,12 @@ impl<T> TcpPacket<T> {
}
/// Get the length of the options in words
fn options_length(&self) -> usize {
#[allow(clippy::cast_possible_truncation)]
fn options_length(&self) -> u8 {
self.options
.iter()
.map(|option| TcpOptionPacket::packet_size(option))
.sum::<usize>()
.map(|option| TcpOptionPacket::packet_size(option) as u8)
.sum::<u8>()
}
}
@ -139,10 +141,10 @@ where
destination: SocketAddr::new(destination_address, parsed.get_destination()),
sequence: parsed.get_sequence(),
ack_number: parsed.get_acknowledgement(),
flags: parsed.get_flags() as u8,
flags: parsed.get_flags(),
window_size: parsed.get_window(),
urgent_pointer: parsed.get_urgent_ptr(),
options: parsed.get_options().to_vec(),
options: parsed.get_options().clone(),
payload: parsed.payload().to_vec().into(),
})
}
@ -173,62 +175,62 @@ impl TcpPacket<RawBytes> {
destination: SocketAddr::new(destination_address, parsed.get_destination()),
sequence: parsed.get_sequence(),
ack_number: parsed.get_acknowledgement(),
flags: parsed.get_flags() as u8,
flags: parsed.get_flags(),
window_size: parsed.get_window(),
urgent_pointer: parsed.get_urgent_ptr(),
options: parsed.get_options().to_vec(),
options: parsed.get_options().clone(),
payload: RawBytes(parsed.payload().to_vec()),
})
}
}
impl<T> Into<Vec<u8>> for TcpPacket<T>
impl<T> From<TcpPacket<T>> for Vec<u8>
where
T: Into<Vec<u8>>,
{
fn into(self) -> Vec<u8> {
fn from(packet: TcpPacket<T>) -> Self {
// Get the options length in words
let options_length = self.options_length();
let options_length = packet.options_length();
// Convert the payload into raw bytes
let payload: Vec<u8> = self.payload.into();
let payload: Vec<u8> = packet.payload.into();
// Allocate a mutable packet to write into
let total_length = pnet_packet::tcp::MutableTcpPacket::minimum_packet_size()
+ options_length
+ options_length as usize
+ payload.len();
let mut output =
pnet_packet::tcp::MutableTcpPacket::owned(vec![0u8; total_length]).unwrap();
// Write the source and dest ports
output.set_source(self.source.port());
output.set_destination(self.destination.port());
output.set_source(packet.source.port());
output.set_destination(packet.destination.port());
// Write the sequence and ack numbers
output.set_sequence(self.sequence);
output.set_acknowledgement(self.ack_number);
output.set_sequence(packet.sequence);
output.set_acknowledgement(packet.ack_number);
// Write the offset
output.set_data_offset(5 + (options_length / 4) as u8);
output.set_data_offset(5 + (options_length / 4));
// Write the options
output.set_options(&self.options);
output.set_options(&packet.options);
// Write the flags
output.set_flags(self.flags.into());
output.set_flags(packet.flags);
// Write the window size
output.set_window(self.window_size);
output.set_window(packet.window_size);
// Write the urgent pointer
output.set_urgent_ptr(self.urgent_pointer);
output.set_urgent_ptr(packet.urgent_pointer);
// Write the payload
output.set_payload(&payload);
// Calculate the checksum
output.set_checksum(0);
output.set_checksum(match (self.source.ip(), self.destination.ip()) {
output.set_checksum(match (packet.source.ip(), packet.destination.ip()) {
(IpAddr::V4(source_ip), IpAddr::V4(destination_ip)) => {
pnet_packet::tcp::ipv4_checksum(&output.to_immutable(), &source_ip, &destination_ip)
}

14
src/packet/protocols/udp.rs
View File

@ -141,13 +141,13 @@ impl UdpPacket<RawBytes> {
}
}
impl<T> Into<Vec<u8>> for UdpPacket<T>
impl<T> From<UdpPacket<T>> for Vec<u8>
where
T: Into<Vec<u8>>,
{
fn into(self) -> Vec<u8> {
fn from(packet: UdpPacket<T>) -> Self {
// Convert the payload into raw bytes
let payload: Vec<u8> = self.payload.into();
let payload: Vec<u8> = packet.payload.into();
// Allocate a mutable packet to write into
let total_length =
@ -156,18 +156,18 @@ where
pnet_packet::udp::MutableUdpPacket::owned(vec![0u8; total_length]).unwrap();
// Write the source and dest ports
output.set_source(self.source.port());
output.set_destination(self.destination.port());
output.set_source(packet.source.port());
output.set_destination(packet.destination.port());
// Write the length
output.set_length(total_length as u16);
output.set_length(u16::try_from(total_length).unwrap());
// Write the payload
output.set_payload(&payload);
// Calculate the checksum
output.set_checksum(0);
output.set_checksum(match (self.source.ip(), self.destination.ip()) {
output.set_checksum(match (packet.source.ip(), packet.destination.ip()) {
(IpAddr::V4(source_ip), IpAddr::V4(destination_ip)) => {
pnet_packet::udp::ipv4_checksum(&output.to_immutable(), &source_ip, &destination_ip)
}

4
src/packet/xlat/icmp/mod.rs
View File

@ -1,3 +1,5 @@
#![allow(clippy::doc_markdown)]
use std::net::{Ipv4Addr, Ipv6Addr};
use pnet_packet::{icmp::IcmpTypes, icmpv6::Icmpv6Types};
@ -92,7 +94,7 @@ pub fn translate_icmpv6_to_icmp(
// Translate
let inner_payload =
translate_ipv6_to_ipv4(inner_payload.try_into()?, new_source, new_destination)?;
translate_ipv6_to_ipv4(&inner_payload.try_into()?, new_source, new_destination)?;
let inner_payload: Vec<u8> = inner_payload.into();
// Build the new payload

6
src/packet/xlat/icmp/type_code.rs
View File

@ -1,5 +1,7 @@
//! Functions to map between ICMP and ICMPv6 types/codes
#![allow(clippy::doc_markdown)]
use pnet_packet::{
icmp::{destination_unreachable, IcmpCode, IcmpType, IcmpTypes},
icmpv6::{Icmpv6Code, Icmpv6Type, Icmpv6Types},
@ -8,6 +10,7 @@ use pnet_packet::{
use crate::packet::error::PacketError;
/// Best effort translation from an ICMP type and code to an ICMPv6 type and code
#[allow(clippy::deprecated_cfg_attr)]
pub fn translate_type_and_code_4_to_6(
icmp_type: IcmpType,
icmp_code: IcmpCode,
@ -29,6 +32,7 @@ pub fn translate_type_and_code_4_to_6(
(IcmpTypes::DestinationUnreachable, icmp_code) => Ok((
Icmpv6Types::DestinationUnreachable,
#[cfg_attr(rustfmt, rustfmt_skip)]
#[allow(clippy::match_same_arms)]
Icmpv6Code(match icmp_code {
destination_unreachable::IcmpCodes::DestinationHostUnreachable => 3,
destination_unreachable::IcmpCodes::DestinationProtocolUnreachable => 4,
@ -55,6 +59,7 @@ pub fn translate_type_and_code_4_to_6(
}
/// Best effort translation from an ICMPv6 type and code to an ICMP type and code
#[allow(clippy::deprecated_cfg_attr)]
pub fn translate_type_and_code_6_to_4(
icmp_type: Icmpv6Type,
icmp_code: Icmpv6Code,
@ -76,6 +81,7 @@ pub fn translate_type_and_code_6_to_4(
(Icmpv6Types::DestinationUnreachable, icmp_code) => Ok((
IcmpTypes::DestinationUnreachable,
#[cfg_attr(rustfmt, rustfmt_skip)]
#[allow(clippy::match_same_arms)]
match icmp_code.0 {
1 => destination_unreachable::IcmpCodes::CommunicationAdministrativelyProhibited,
2 => destination_unreachable::IcmpCodes::SourceHostIsolated,

4
src/packet/xlat/ip.rs
View File

@ -70,7 +70,7 @@ pub fn translate_ipv4_to_ipv6(
/// Translates an IPv6 packet to an IPv4 packet
pub fn translate_ipv6_to_ipv4(
input: Ipv6Packet<Vec<u8>>,
input: &Ipv6Packet<Vec<u8>>,
new_source: Ipv4Addr,
new_destination: Ipv4Addr,
) -> Result<Ipv4Packet<Vec<u8>>, PacketError> {
@ -121,7 +121,7 @@ pub fn translate_ipv6_to_ipv4(
new_source,
new_destination,
vec![],
new_payload.unwrap_or_else(Vec::new),
new_payload.unwrap_or_default(),
);
// Return the output

8
src/packet/xlat/tcp.rs
View File

@ -12,7 +12,7 @@ pub fn translate_tcp4_to_tcp6(
new_destination_addr: Ipv6Addr,
) -> Result<TcpPacket<RawBytes>, PacketError> {
// Build the packet
Ok(TcpPacket::new(
TcpPacket::new(
SocketAddr::new(IpAddr::V6(new_source_addr), input.source().port()),
SocketAddr::new(IpAddr::V6(new_destination_addr), input.destination().port()),
input.sequence,
@ -22,7 +22,7 @@ pub fn translate_tcp4_to_tcp6(
input.urgent_pointer,
input.options,
input.payload,
)?)
)
}
/// Translates an IPv6 TCP packet to an IPv4 TCP packet
@ -32,7 +32,7 @@ pub fn translate_tcp6_to_tcp4(
new_destination_addr: Ipv4Addr,
) -> Result<TcpPacket<RawBytes>, PacketError> {
// Build the packet
Ok(TcpPacket::new(
TcpPacket::new(
SocketAddr::new(IpAddr::V4(new_source_addr), input.source().port()),
SocketAddr::new(IpAddr::V4(new_destination_addr), input.destination().port()),
input.sequence,
@ -42,7 +42,7 @@ pub fn translate_tcp6_to_tcp4(
input.urgent_pointer,
input.options,
input.payload,
)?)
)
}
#[cfg(test)]

8
src/packet/xlat/udp.rs
View File

@ -12,11 +12,11 @@ pub fn translate_udp4_to_udp6(
new_destination_addr: Ipv6Addr,
) -> Result<UdpPacket<RawBytes>, PacketError> {
// Build the packet
Ok(UdpPacket::new(
UdpPacket::new(
SocketAddr::new(IpAddr::V6(new_source_addr), input.source().port()),
SocketAddr::new(IpAddr::V6(new_destination_addr), input.destination().port()),
input.payload,
)?)
)
}
/// Translates an IPv6 UDP packet to an IPv4 UDP packet
@ -26,11 +26,11 @@ pub fn translate_udp6_to_udp4(
new_destination_addr: Ipv4Addr,
) -> Result<UdpPacket<RawBytes>, PacketError> {
// Build the packet
Ok(UdpPacket::new(
UdpPacket::new(
SocketAddr::new(IpAddr::V4(new_source_addr), input.source().port()),
SocketAddr::new(IpAddr::V4(new_destination_addr), input.destination().port()),
input.payload,
)?)
)
}
#[cfg(test)]