integrate with the server

src/main.rs

@@ -1,11 +1,17 @@
+use sequence::PortSequenceDetector;
 use server::Server;
 
 mod config;
 mod sequence;
 mod server;
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let server = Server::new("enp3s0".to_string());
+    // Load the configuration
+    let config = config::load_config("config.yaml")?;
+    // Create the sequence detector
+    let detector = PortSequenceDetector::new(config);
+
+    let mut server = Server::new("enp3s0".to_string(), Box::new(detector));
     server.start();
 
     Ok(())

src/sequence/mod.rs

@@ -1,3 +1,5 @@
+pub use port_sequence::PortSequenceDetector;
+
 mod port_sequence;
 
 pub trait SequenceDetector {

src/sequence/port_sequence.rs

@@ -41,8 +41,17 @@ impl SequenceDetector for PortSequenceDetector {
             return;
         }
 
-        let client_sequence = self.client_sequences.entry(client_ip).or_insert(Vec::new());
+        println!(
+            "SYN packet detected from: {} to target port: {}",
+            client_ip, sequence
+        );
+
+        let client_sequence = self
+            .client_sequences
+            .entry(client_ip.clone())
+            .or_insert(Vec::new());
         client_sequence.push(sequence);
+        self.match_sequence(&client_ip);
     }
 
     fn match_sequence(&mut self, client_ip: &str) -> bool {
@@ -51,7 +60,7 @@ impl SequenceDetector for PortSequenceDetector {
         if let Some(sequence) = client_sequence {
             for rule in &self.sequence_rules {
                 if sequence.ends_with(rule) {
-                    println!("Matched sequence: {:?}", rule);
+                    println!("Matched knock sequence: {:?} from: {}", rule, client_ip);
                     // clear the sequence
                     sequence.clear();
                     return true;

src/server/server.rs

@@ -7,18 +7,22 @@ use pnet::packet::ip::IpNextHeaderProtocols;
 use pnet::packet::tcp::TcpPacket;
 use pnet::packet::Packet;
 
+use crate::sequence::SequenceDetector;
+
 pub struct Server {
     interface_name: String,
+    detector: Box<dyn SequenceDetector>,
 }
 
 impl Server {
-    pub fn new(interface: String) -> Server {
-        Server {
+    pub fn new(interface: String, detector: Box<dyn SequenceDetector>) -> Box<Server> {
+        Box::new(Server {
             interface_name: interface,
-        }
+            detector,
+        })
     }
 
-    pub fn start(&self) {
+    pub fn start(&mut self) {
         let interface = datalink::interfaces()
             .into_iter()
             .find(|iface: &NetworkInterface| iface.name == self.interface_name)
@@ -29,7 +33,7 @@ impl Server {
             Ok(Ethernet(tx, rx)) => (tx, rx),
             Ok(_) => panic!("Unhandled channel type"),
             Err(e) => panic!(
-                "An error occurred when creating the datalink channel: {}",
+                "An error occurred when creating the data link channel: {}",
                 e
             ),
         };
@@ -50,10 +54,9 @@ impl Server {
                                             && tcp.get_flags() & pnet::packet::tcp::TcpFlags::ACK
                                                 == 0
                                         {
-                                            println!(
-                                                "SYN packet detected from: {} to target port: {:?}",
+                                            self.detector.add_sequence(
                                                 header.get_source().to_string(),
-                                                tcp.get_destination()
+                                                tcp.get_destination() as i32,
                                             );
                                         }
                                     }