From 4f82f072361efb946b93b379a1926ec4b2646f51 Mon Sep 17 00:00:00 2001 From: Evan Pratten Date: Tue, 18 Jul 2023 14:28:20 -0400 Subject: [PATCH] Add ipv4 --- src/packet/protocols/icmp.rs | 29 ++------ src/packet/protocols/ipv4.rs | 131 +++++++++++++++++++++++++++++++++++ src/packet/protocols/ipv6.rs | 95 +++++++++++++++++++++++++ src/packet/protocols/mod.rs | 2 + src/packet/protocols/tcp.rs | 5 +- 5 files changed, 238 insertions(+), 24 deletions(-) create mode 100644 src/packet/protocols/ipv4.rs create mode 100644 src/packet/protocols/ipv6.rs diff --git a/src/packet/protocols/icmp.rs b/src/packet/protocols/icmp.rs index e4f35b5..dd1ce40 100644 --- a/src/packet/protocols/icmp.rs +++ b/src/packet/protocols/icmp.rs @@ -23,37 +23,22 @@ impl IcmpPacket { } } -impl IcmpPacket +impl TryFrom> for IcmpPacket where - T: From>, + T: TryFrom, Error = PacketError>, { - /// Construct a new ICMPv6 packet from raw bytes - pub fn new_from_bytes(bytes: &[u8]) -> Result { + type Error = PacketError; + + fn try_from(bytes: Vec) -> Result { // Parse the packet let packet = - pnet_packet::icmp::IcmpPacket::new(bytes).ok_or(PacketError::TooShort(bytes.len()))?; + pnet_packet::icmp::IcmpPacket::new(&bytes).ok_or(PacketError::TooShort(bytes.len()))?; // Return the packet Ok(Self { icmp_type: packet.get_icmp_type(), icmp_code: packet.get_icmp_code(), - payload: packet.payload().to_vec().into(), - }) - } -} - -impl IcmpPacket> { - /// Construct a new ICMPv6 packet with a raw payload from raw bytes - pub fn new_from_bytes_raw_payload(bytes: &[u8]) -> Result { - // Parse the packet - let packet = - pnet_packet::icmp::IcmpPacket::new(bytes).ok_or(PacketError::TooShort(bytes.len()))?; - - // Return the packet - Ok(Self { - icmp_type: packet.get_icmp_type(), - icmp_code: packet.get_icmp_code(), - payload: packet.payload().to_vec(), + payload: packet.payload().to_vec().try_into()?, }) } } diff --git a/src/packet/protocols/ipv4.rs b/src/packet/protocols/ipv4.rs new file mode 100644 index 0000000..9728084 --- /dev/null +++ b/src/packet/protocols/ipv4.rs @@ -0,0 +1,131 @@ +use std::net::Ipv4Addr; + +use pnet_packet::{ + ip::IpNextHeaderProtocol, + ipv4::{Ipv4Option, Ipv4OptionPacket}, + Packet, +}; + +use crate::packet::error::PacketError; + +#[derive(Debug, Clone)] +pub struct Ipv4Packet { + pub dscp: u8, + pub ecn: u8, + pub identification: u16, + pub flags: u8, + pub fragment_offset: u16, + pub ttl: u8, + pub protocol: IpNextHeaderProtocol, + pub source_address: Ipv4Addr, + pub destination_address: Ipv4Addr, + pub options: Vec, + pub payload: T, +} + +impl Ipv4Packet { + /// Construct a new IPv4 packet + pub fn new( + dscp: u8, + ecn: u8, + identification: u16, + flags: u8, + fragment_offset: u16, + ttl: u8, + protocol: IpNextHeaderProtocol, + source_address: Ipv4Addr, + destination_address: Ipv4Addr, + options: Vec, + payload: T, + ) -> Self { + Self { + dscp, + ecn, + identification, + flags, + fragment_offset, + ttl, + protocol, + source_address, + destination_address, + options, + payload, + } + } + + fn options_length_words(&self) -> u8 { + self.options + .iter() + .map(|option| Ipv4OptionPacket::packet_size(option) as u8) + .sum::() + / 4 + } +} + +impl TryFrom> for Ipv4Packet +where + T: From>, +{ + type Error = PacketError; + + fn try_from(bytes: Vec) -> Result { + // Parse the packet + let packet = + pnet_packet::ipv4::Ipv4Packet::new(&bytes).ok_or(PacketError::TooShort(bytes.len()))?; + + // Return the packet + Ok(Self { + dscp: packet.get_dscp(), + ecn: packet.get_ecn(), + identification: packet.get_identification(), + flags: packet.get_flags(), + fragment_offset: packet.get_fragment_offset(), + ttl: packet.get_ttl(), + protocol: packet.get_next_level_protocol(), + source_address: packet.get_source(), + destination_address: packet.get_destination(), + options: packet.get_options(), + payload: packet.payload().to_vec().into(), + }) + } +} + +impl Into> for Ipv4Packet +where + T: Into> + Clone, +{ + fn into(self) -> Vec { + // Convert the payload into raw bytes + let payload: Vec = self.payload.clone().into(); + + // Build the packet + let total_length = 20 + (self.options_length_words() as usize * 4) + payload.len(); + let mut packet = + 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); + + // Set the payload + packet.set_payload(&payload); + + // Calculate the checksum + packet.set_checksum(0); + packet.set_checksum(pnet_packet::ipv4::checksum(&packet.to_immutable())); + + // Return the packet + packet.to_immutable().packet().to_vec() + } +} diff --git a/src/packet/protocols/ipv6.rs b/src/packet/protocols/ipv6.rs new file mode 100644 index 0000000..8d28375 --- /dev/null +++ b/src/packet/protocols/ipv6.rs @@ -0,0 +1,95 @@ +use std::net::Ipv6Addr; + +use pnet_packet::{ip::IpNextHeaderProtocol, Packet}; + +use crate::packet::error::PacketError; + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Ipv6Packet { + pub traffic_class: u8, + pub flow_label: u32, + pub next_header: IpNextHeaderProtocol, + pub hop_limit: u8, + pub source_address: Ipv6Addr, + pub destination_address: Ipv6Addr, + pub payload: T, +} + +impl Ipv6Packet { + /// Construct a new IPv6 packet + pub fn new( + traffic_class: u8, + flow_label: u32, + next_header: IpNextHeaderProtocol, + hop_limit: u8, + source_address: Ipv6Addr, + destination_address: Ipv6Addr, + payload: T, + ) -> Self { + Self { + traffic_class, + flow_label, + next_header, + hop_limit, + source_address, + destination_address, + payload, + } + } +} + +impl TryFrom> for Ipv6Packet +where + T: From>, +{ + type Error = PacketError; + + fn try_from(bytes: Vec) -> Result { + // Parse the packet + let packet = + pnet_packet::ipv6::Ipv6Packet::new(&bytes).ok_or(PacketError::TooShort(bytes.len()))?; + + // Return the packet + Ok(Self { + traffic_class: packet.get_traffic_class(), + flow_label: packet.get_flow_label(), + next_header: packet.get_next_header(), + hop_limit: packet.get_hop_limit(), + source_address: packet.get_source(), + destination_address: packet.get_destination(), + payload: packet.payload().to_vec().into(), + }) + } +} + +impl Into> for Ipv6Packet +where + T: Into>, +{ + fn into(self) -> Vec { + // Convert the payload into raw bytes + let payload: Vec = self.payload.into(); + + // Allocate a mutable packet to write into + let total_length = + pnet_packet::ipv6::MutableIpv6Packet::minimum_packet_size() + payload.len(); + let mut output = + pnet_packet::ipv6::MutableIpv6Packet::owned(vec![0u8; total_length]).unwrap(); + + // 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); + + // Write the payload + output.set_payload(&payload); + + // Return the packet + output.to_immutable().packet().to_vec() + } +} diff --git a/src/packet/protocols/mod.rs b/src/packet/protocols/mod.rs index 75bdf42..f02f380 100644 --- a/src/packet/protocols/mod.rs +++ b/src/packet/protocols/mod.rs @@ -1,4 +1,6 @@ pub mod icmp; pub mod icmpv6; +pub mod ipv4; +pub mod ipv6; pub mod tcp; pub mod udp; diff --git a/src/packet/protocols/tcp.rs b/src/packet/protocols/tcp.rs index bb77ea3..087f237 100644 --- a/src/packet/protocols/tcp.rs +++ b/src/packet/protocols/tcp.rs @@ -188,8 +188,9 @@ where let payload: Vec = self.payload.into(); // Allocate a mutable packet to write into - let total_length = - pnet_packet::tcp::MutableTcpPacket::minimum_packet_size() + payload.len(); + let total_length = pnet_packet::tcp::MutableTcpPacket::minimum_packet_size() + + (self.options_length_words() as usize * 4) + + payload.len(); let mut output = pnet_packet::tcp::MutableTcpPacket::owned(vec![0u8; total_length]).unwrap();