Merge pull request #5 from wiseaidev/rnd-src-ip-patch

fix source ip randomization

Author: wiseaidev

src/ip.rs

@@ -1,21 +1,95 @@
+use crate::tcp::TcpHeader;
+use crate::utils::calculate_ip_checksum;
+use std::net::Ipv4Addr;
+use std::str::FromStr;
+
 /// Represents the IP header structure with its fields.
+///
+/// This struct follows the IP header format.
+/// Reference: https://github.com/wiseaidev/dark-web-rust/tree/main/chapter-1#13-the-ip-header-struct
+#[repr(C, packed)]
 #[derive(Debug)]
 pub struct IpHeader {
     /// Version and Internet Header Length (IHL) combined field.
     pub version_ihl: u8,
+    /// Type of Service (TOS) field.
+    pub tos: u8,
+    /// Length field.
+    pub len: u16,
+    /// Identification field.
+    pub id: u16,
+    /// Fragment Offset field.
+    pub offset: u16,
     /// Time To Live (TTL) field.
     pub ttl: u8,
-    /// Source IP address field.
-    pub source_ip: u32,
-    /// Destination IP address field.
-    pub dest_ip: u32,
     /// Protocol field.
     pub protocol: u8,
-    /// Length field.
-    pub len: u16,
+    /// Header Checksum field.
+    pub sum: u16,
+    /// Source IP address field.
+    pub src: u32,
+    /// Destination IP address field.
+    pub dst: u32,
 }
 /// Implements methods for the IpHeader struct.
 impl IpHeader {
+    /// Constructs an IP header with the given source IP and computes the length and checksum.
+    ///
+    /// # Arguments
+    ///
+    /// * `source_ip` - The source IP address.
+    /// * `dest_ip` - The target ip.
+    ///
+    /// # Returns
+    ///
+    /// (`IpHeader`): The IP header with calculated length and checksum.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use rping::utils::{generate_random_ip, calculate_tcp_checksum};
+    /// use rping::ip::IpHeader;
+    ///
+    /// let source_ip = generate_random_ip();
+    /// let ip_header = IpHeader::new(source_ip, "192.168.1.10");
+    /// // Ensure that relevant fields have been initialized properly.
+    /// assert_eq!(ip_header.version_ihl, (4 << 4) | 5);
+    /// assert_eq!(ip_header.protocol, 6);
+    /// ```
+    pub fn new(source_ip: u32, dest_ip: &str) -> Self {
+        let mut ip_header = Self {
+            version_ihl: 69,
+            tos: 0,
+            len: 0,
+            id: 0,
+            offset: 0,
+            ttl: 50,
+            protocol: 6,
+            sum: 0,
+            src: source_ip.to_be(),
+            dst: Ipv4Addr::from_str(dest_ip).unwrap().into(),
+        };
+
+        // Convert destination IP to big-endian
+        ip_header.dst = ip_header.dst.to_be();
+
+        // Calculate the total length (IP header + TCP header)
+        let total_length =
+            (std::mem::size_of::<IpHeader>() + std::mem::size_of::<TcpHeader>()) as u16;
+
+        // Set the total length in the IP header
+        ip_header.len = total_length.to_be();
+
+        // Calculate the checksum without TCP header
+        ip_header.sum = calculate_ip_checksum(&ip_header);
+
+        // Convert length and checksum to network byte order (big-endian)
+        ip_header.len = ip_header.len.to_be();
+        ip_header.sum = ip_header.sum.to_be();
+
+        ip_header
+    }
+
     /// Returns a byte slice representing the binary data of the IpHeader.
     ///
     /// # Examples
@@ -24,14 +98,21 @@ impl IpHeader {
     ///
     /// let ip_header = IpHeader {
     ///     version_ihl: 0x45,
+    ///     tos: 0,
+    ///     len: 20,
+    ///     id: 0,
+    ///     offset: 0,
     ///     ttl: 64,
-    ///     source_ip: 0xC0A80001, // 192.168.0.1
-    ///     dest_ip: 0xC0A80002,   // 192.168.0.2
     ///     protocol: 6,
-    ///     len: 0,
+    ///     sum: 127,
+    ///     src: 0xC0A80001, // 192.168.0.1
+    ///     dst: 0xC0A80002, // 192.168.0.2
     /// };
     ///
-    /// assert_eq!(ip_header.as_bytes(), &[1, 0, 168, 192, 2, 0, 168, 192, 0, 0, 69, 64, 6, 127, 0, 0]);
+    /// assert_eq!(
+    ///     ip_header.as_bytes(),
+    ///     &[69, 0, 20, 0, 0, 0, 0, 0, 64, 6, 127, 0, 1, 0, 168, 192, 2, 0, 168, 192]
+    /// );
     /// ```
     /// Returns a byte slice representing the binary data of the IpHeader.
     pub fn as_bytes(&self) -> &[u8] {
@@ -52,16 +133,20 @@ mod tests {
     fn test_ip_header_as_bytes() {
         let ip_header = IpHeader {
             version_ihl: 0x45,
+            tos: 0,
+            len: 20,
+            id: 0,
+            offset: 0,
             ttl: 64,
-            source_ip: 0xC0A80001, // 192.168.0.1
-            dest_ip: 0xC0A80002,   // 192.168.0.2
             protocol: 6,
-            len: 0,
+            sum: 0,
+            src: 0xC0A80001, // 192.168.0.1
+            dst: 0xC0A80002, // 192.168.0.2
         };
 
         assert_eq!(
             ip_header.as_bytes(),
-            &[1, 0, 168, 192, 2, 0, 168, 192, 0, 0, 69, 64, 6, 0, 0, 0]
+            &[69, 0, 20, 0, 0, 0, 0, 0, 64, 6, 0, 0, 1, 0, 168, 192, 2, 0, 168, 192]
         );
     }
 }

src/tcp.rs

@@ -1,28 +1,63 @@
+use rand::Rng;
+use std::time::SystemTime;
+
 /// Represents the TCP header structure with its fields.
+///
+/// This struct follows the TCP header format.
+/// Reference: https://github.com/wiseaidev/dark-web-rust/tree/main/chapter-1#16-decoding-tcp-packets
+#[repr(C, packed)]
 #[derive(Clone)]
 pub struct TcpHeader {
     /// Source Port field.
     pub sport: u16,
     /// Destination Port field.
     pub dport: u16,
     /// Sequence Number field.
-    pub seq: u32,
+    pub seq: u16,
     /// Acknowledgment Number field.
-    pub ack: u32,
-    /// Data Offset (offset of the data in the TCP header) and Reserved (always zero) combined field.
-    pub offx2: u8,
-    /// Flags field.
-    pub flags: u8,
+    pub ack: u16,
+    /// Data Offset (offset of the data in the TCP header), Reserved (always zero), and flags combined field.
+    pub off_reserved_flags: u16,
     /// Window Size field.
     pub win: u16,
     /// Checksum field.
     pub sum: u16,
     /// Urgent Pointer field.
     pub urp: u16,
+    /// Options field.
+    pub opt: u16,
+    /// Padding field.
+    pub pad: u16,
 }
 
 /// Implements methods for the TcpHeader struct.
 impl TcpHeader {
+    /// Creates a new TCP header with default values.
+    pub fn new(dest_port: u16) -> Self {
+        let mut rng = rand::thread_rng();
+        let data_offset = 20; // 5 words (20 bytes)
+        let reserved = 0;
+        let flags = 2; // 2 is the flag value for SYN
+        let off_reserved_flags = (data_offset << 15) | (reserved << 12) | (flags << 7);
+
+        TcpHeader {
+            sport: (SystemTime::now()
+                .duration_since(SystemTime::UNIX_EPOCH)
+                .unwrap()
+                .as_millis()
+                % u16::MAX as u128) as u16,
+            dport: dest_port.to_be(),
+            seq: rng.gen::<u16>(),
+            ack: rng.gen::<u16>(),
+            off_reserved_flags,
+            win: rng.gen::<u16>(),
+            sum: rng.gen::<u16>(),
+            urp: rng.gen::<u16>(),
+            opt: rng.gen::<u16>(),
+            pad: rng.gen::<u16>(),
+        }
+    }
+
     /// Returns a byte slice representing the binary data of the TcpHeader.
     ///
     /// # Examples
@@ -34,14 +69,15 @@ impl TcpHeader {
     ///     dport: 80,
     ///     seq: 12345,
     ///     ack: 0,
-    ///     offx2: 0x50,
-    ///     flags: 0x02,
+    ///     off_reserved_flags: 0x5000,
     ///     win: 1024,
     ///     sum: 0,
     ///     urp: 0,
+    ///     opt: 0,
+    ///     pad: 0,
     /// };
     ///
-    /// assert_eq!(tcp_header.as_bytes(), &[57, 48, 0, 0, 0, 0, 0, 0, 144, 31, 80, 0, 0, 4, 0, 0, 0, 0, 80, 2]);
+    /// assert_eq!(tcp_header.as_bytes(), &[144, 31, 80, 0, 57, 48, 0, 0, 0, 80, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0]);
     /// ```
     /// Returns a byte slice representing the binary data of the TcpHeader.
     pub fn as_bytes(&self) -> &[u8] {
@@ -65,16 +101,17 @@ mod tests {
             dport: 80,
             seq: 12345,
             ack: 0,
-            offx2: 0x50,
-            flags: 0x02,
+            off_reserved_flags: 0x0202,
             win: 1024,
             sum: 0,
             urp: 0,
+            opt: 0,
+            pad: 0,
         };
 
         assert_eq!(
             tcp_header.as_bytes(),
-            &[57, 48, 0, 0, 0, 0, 0, 0, 144, 31, 80, 0, 0, 4, 0, 0, 0, 0, 80, 2]
+            &[144, 31, 80, 0, 57, 48, 0, 0, 2, 2, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0]
         );
     }
 }