Feat/generate traces

Cargo.toml

@@ -42,6 +42,8 @@ base64 = { version = "0.22.1" }
 clap = { version = "4.5.20", features = ["derive"] }
 rand = "0.8.5"
 regex_generate = "0.2.3"
+toml = "0.8.19"
+serde = { version = "1.0.214", features = ["derive"] }
 
 [build-dependencies]
 embed-resource = "2.5.0"

src/commands.rs

@@ -0,0 +1,38 @@
+// SPDX-FileCopyrightText: 2023 The MalwareTracesGenerator development team
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+pub mod generate;
+pub mod traces;
+
+use crate::commands::{generate::Generate, traces::Traces};
+use clap::{Parser, Subcommand};
+use std::error::Error;
+
+#[derive(Parser)]
+#[clap(author, version)]
+#[clap(arg_required_else_help = true)]
+pub struct Arguments {
+    #[clap(subcommand)]
+    pub command: Command,
+}
+
+#[derive(Subcommand)]
+pub enum Command {
+    Traces(Traces),
+    Generate(Generate),
+}
+
+pub trait Runnable {
+    fn run(&self) -> Result<(), Box<dyn Error>>;
+}
+
+impl Runnable for Arguments {
+    fn run(&self) -> Result<(), Box<dyn Error>> {
+        match &self.command {
+            Command::Traces(traces) => traces as &dyn Runnable,
+            Command::Generate(generate) => generate,
+        }
+        .run()
+    }
+}

src/commands/generate.rs

@@ -0,0 +1,51 @@
+// SPDX-FileCopyrightText: 2023 The MalwareTracesGenerator development team
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+use crate::commands::{traces::Traces, Runnable};
+use clap::Parser;
+use serde::Deserialize;
+use std::{error::Error, fs::read_to_string, path::PathBuf};
+use toml::from_str;
+
+#[derive(Deserialize)]
+struct Configuration {
+    metadata: Metadata,
+    traces: Vec<Traces>,
+}
+
+#[derive(Deserialize)]
+struct Metadata {
+    name: String,
+    version: String,
+    references: Vec<String>,
+    authors: Option<Vec<Author>>,
+}
+
+#[derive(Deserialize)]
+struct Author {
+    name: String,
+    email: Option<String>,
+}
+
+#[derive(Parser)]
+pub struct Generate {
+    #[clap(required = true, help = "Path to the configuration file")]
+    path: PathBuf,
+}
+
+impl Runnable for Generate {
+    fn run(&self) -> Result<(), Box<dyn Error>> {
+        if !self.path.try_exists()? || !self.path.is_file() {
+            return Ok(());
+        }
+
+        let configuration: Configuration = from_str(read_to_string(self.path.clone())?.as_str())?;
+
+        for trace in configuration.traces {
+            trace.run()?;
+        }
+
+        Ok(())
+    }
+}

src/traces.rs → src/commands/traces.rs

@@ -2,34 +2,36 @@
 //
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-use crate::traces::{drivers::Drivers, processes::Processes};
+use crate::commands::{
+    traces::{drivers::Drivers, processes::Processes},
+    Runnable,
+};
 use clap::{Args, Subcommand};
+use serde::Deserialize;
 use std::error::Error;
 
 pub mod drivers;
 pub mod processes;
 
-#[derive(Debug, Args)]
+#[derive(Args, Deserialize)]
 pub struct Traces {
     #[clap(subcommand)]
-    pub command: Commands,
+    #[serde(flatten)]
+    pub command: Command,
 }
 
-#[derive(Debug, Subcommand)]
-pub enum Commands {
+#[derive(Subcommand, Deserialize)]
+#[serde(rename_all = "snake_case", untagged)]
+pub enum Command {
     Drivers(Drivers),
     Processes(Processes),
 }
 
-pub trait Runnable {
-    fn run(&self) -> Result<(), Box<dyn Error>>;
-}
-
 impl Runnable for Traces {
     fn run(&self) -> Result<(), Box<dyn Error>> {
         match &self.command {
-            Commands::Drivers(drivers) => drivers as &dyn Runnable,
-            Commands::Processes(processes) => processes,
+            Command::Drivers(drivers) => drivers as &dyn Runnable,
+            Command::Processes(processes) => processes,
         }
         .run()
     }

src/traces/drivers.rs → src/commands/traces/drivers.rs

@@ -2,27 +2,30 @@
 //
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-use crate::traces::{drivers::byovd::Byovd, Runnable};
+use crate::commands::{traces::drivers::byovd::Byovd, Runnable};
 use clap::{Args, Subcommand};
+use serde::Deserialize;
 use std::error::Error;
 
 pub mod byovd;
 
-#[derive(Debug, Args)]
+#[derive(Args, Deserialize)]
 pub struct Drivers {
     #[clap(subcommand)]
-    pub command: Commands,
+    #[serde(flatten)]
+    pub command: Command,
 }
 
-#[derive(Debug, Subcommand)]
-pub enum Commands {
+#[derive(Subcommand, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum Command {
     Byovd(Byovd),
 }
 
 impl Runnable for Drivers {
     fn run(&self) -> Result<(), Box<dyn Error>> {
         match &self.command {
-            Commands::Byovd(byovd) => byovd as &dyn Runnable,
+            Command::Byovd(byovd) => byovd as &dyn Runnable,
         }
         .run()
     }

src/traces/drivers/byovd.rs → src/commands/traces/drivers/byovd.rs

@@ -2,8 +2,9 @@
 //
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-use crate::{traces::Runnable, windows::users::is_administrator};
+use crate::{commands::Runnable, windows::users::is_administrator};
 use clap::Parser;
+use serde::Deserialize;
 use std::{error::Error, path::PathBuf};
 use windows::{
     core::{Owned, HSTRING, PCWSTR},
@@ -17,7 +18,7 @@ use windows::{
     },
 };
 
-#[derive(Debug, Parser)]
+#[derive(Parser, Deserialize)]
 pub struct Byovd {
     #[clap(required = true, help = "Name of the service")]
     service_name: String,

src/traces/processes.rs → src/commands/traces/processes.rs

@@ -2,27 +2,30 @@
 //
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-use crate::traces::{processes::spoofing::Spoofing, Runnable};
+use crate::commands::{traces::processes::spoofing::Spoofing, Runnable};
 use clap::{Args, Subcommand};
+use serde::Deserialize;
 use std::error::Error;
 
 pub mod spoofing;
 
-#[derive(Debug, Args)]
+#[derive(Args, Deserialize)]
 pub struct Processes {
     #[clap(subcommand)]
-    pub command: Commands,
+    #[serde(flatten)]
+    pub command: Command,
 }
 
-#[derive(Debug, Subcommand)]
-pub enum Commands {
+#[derive(Subcommand, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum Command {
     Spoofing(Spoofing),
 }
 
 impl Runnable for Processes {
     fn run(&self) -> Result<(), Box<dyn Error>> {
         match &self.command {
-            Commands::Spoofing(spoofing) => spoofing as &dyn Runnable,
+            Command::Spoofing(spoofing) => spoofing as &dyn Runnable,
         }
         .run()
     }

src/traces/processes/spoofing.rs → src/commands/traces/processes/spoofing.rs

@@ -2,8 +2,9 @@
 //
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-use crate::{traces::Runnable, windows::processes::get_pid};
+use crate::{commands::Runnable, windows::processes::get_pid};
 use clap::Parser;
+use serde::Deserialize;
 use std::{
     error::Error, ffi::OsString, iter::once, mem::size_of, os::windows::ffi::OsStrExt,
     path::PathBuf,
@@ -21,7 +22,7 @@ use windows::{
     },
 };
 
-#[derive(Debug, Parser)]
+#[derive(Parser, Deserialize)]
 pub struct Spoofing {
     #[clap(required = true, help = "Path to the executable")]
     executable: PathBuf,

src/main.rs

@@ -2,19 +2,13 @@
 //
 // SPDX-License-Identifier: GPL-3.0-or-later
 
-mod cli;
-mod traces;
+mod commands;
 mod windows;
 
 use clap::Parser;
-use cli::{Arguments, Commands};
+use commands::{Arguments, Runnable};
 use std::error::Error;
-use traces::Runnable;
 
 fn main() -> Result<(), Box<dyn Error>> {
-    match Arguments::parse().command {
-        Commands::Traces(action) => action.run()?,
-    };
-
-    Ok(())
+    Arguments::parse().run()
 }