fixed a bug in the promotion where the folder for the client was not

cleaned out of the upcoming folders.

src/appstate.rs

@@ -32,6 +32,7 @@ use std::sync::{Arc, Mutex, mpsc::Sender, mpsc::channel};
 use std::thread;
 use std::time::Duration;
 use std::time::{self, Instant};
+use trust_dns_resolver::proto::rr::rdata::svcb::SvcParamKey::Port;
 use walkdir::WalkDir;
 
 pub struct AppState {
@@ -130,6 +131,7 @@ impl AppState {
                                     password: String::new(),
                                     name: name.to_string(),
                                     cert_text: String::new(),
+                                    hostnames: Vec::new(),
                                 };
                                 self.servers.push(Arc::new(Mutex::new(new_server)));
                             }
@@ -218,6 +220,7 @@ impl AppState {
                             password: String::new(),
                             name,
                             cert_text: cert,
+                            hostnames: Vec::new(),
                         };
                         self.servers.push(Arc::new(Mutex::new(new_server)));
                     }
@@ -279,6 +282,8 @@ impl AppState {
         self.help.push(
             "Shortcuts:\nCTRL+P = new_project\nCTRL+s = save\nCTRL_+h = select_host\n".to_string(),
         );
+        self.help.push("exclude\nexcludes an IP or a cidr network from the scope and all future tool calls.\nexport 192.168.1.1 192.168.2.0/24\n".to_string());
+        self.help.push("start_odysseus\nstarts the odyssues server in the distrobox of the project.\nUSAGE:\nstart_odysseus port_number\n".to_string());
         self.help.push("exit\nquit the tool\n".to_string());
         self.initialize_modules();
         return Ok(());
@@ -354,24 +359,24 @@ impl AppState {
             }
             "generate_victim" => {
                 let mut success = false;
+                let mut addresses = Vec::new();
                 if let Some(args) = command_args {
-                    if args.split(" ").into_iter().count() == 1 {
-                        let mut address = String::new();
+                    if let Some((target, address)) = args.split_once(" ") {
                         let mut password = String::new();
                         let config_file = self.config_file.clone();
                         let files = self.projects[self.selected_project].files.clone();
                         let mut cert_text = String::new();
                         if let Ok(lock) = self.servers[self.selected_server].lock() {
-                            address = lock.address.clone();
                             password = lock.password.clone();
                             cert_text = lock.cert_text.clone();
+                            addresses = lock.hostnames.clone();
                         }
                         match victim::generate_code(
-                            address,
+                            address.to_string(),
                             password,
                             config_file,
                             files,
-                            args,
+                            target.to_string(),
                             self.main_tx.clone(),
                             cert_text,
                         ) {
@@ -393,6 +398,14 @@ impl AppState {
                     }
                 }
                 if !success {
+                    let _ = self
+                        .main_tx
+                        .send(ToolMessage::Output((0, format!("available addresses:"))));
+                    addresses.iter().for_each(|a| {
+                        let _ = self
+                            .main_tx
+                            .send(ToolMessage::Output((0, format!("{}", a))));
+                    });
                     let _ = self.main_tx.send(ToolMessage::Output((
                         0,
                         format!("Usage: generate_victim (windows/linux)"),
@@ -572,6 +585,19 @@ impl AppState {
                     } else {
                         if let Some((prog, _)) = cmd.split_once(" ") {
                             let mut launch_cmd = Command::new(prog);
+                            match prog {
+                                "konsole" => {
+                                    launch_cmd
+                                        .arg(format!("--workdir {}", project.files.display()));
+                                }
+                                "xfce4-terminal" => {
+                                    launch_cmd.arg(format!(
+                                        "--working-directory={}",
+                                        project.files.display()
+                                    ));
+                                }
+                                _ => {}
+                            }
                             match launch_cmd.spawn() {
                                 Ok(_) => {}
                                 Err(e) => {
@@ -625,6 +651,7 @@ impl AppState {
                     password: String::new(),
                     name: String::new(),
                     cert_text: String::new(),
+                    hostnames: Vec::new(),
                 };
                 self.servers.push(Arc::new(Mutex::new(new_server)));
                 self.save_all()?;
@@ -853,23 +880,52 @@ impl AppState {
             }
             "parse_scope" => {
                 let mut general_path = self.projects[self.selected_project].notes.clone();
+                let mut scope_path = self.projects[self.selected_project].notes.clone();
+                scope_path.push("scope.md");
                 general_path.push("general.md");
                 let general_string = read_to_string(general_path)?;
-                if let Some((_, scope_section)) = general_string.split_once("# Scope") {
-                    if let Some((scope_section, _)) = scope_section.split_once("#") {
-                        scope_section.lines().into_iter().for_each(|line| {
-                            if line.contains("|") {
-                                if !line.contains("Subnet") {
-                                    if !line.contains("--") {
-                                        let host =
-                                            line.split("|").collect::<Vec<&str>>()[1].to_string();
-                                        self.projects[self.selected_project].add_scope(host);
+                let mut scope_file = OpenOptions::new()
+                    .create(true)
+                    .truncate(true)
+                    .write(true)
+                    .open(scope_path)?;
+                general_string
+                    .split_whitespace()
+                    .into_iter()
+                    .for_each(|word| {
+                        if let Ok(_) = word.trim().parse::<IpNet>() {
+                            if let Err(e) = write!(scope_file, "{}\n", word) {
+                                let _ = self.main_tx.send(ToolMessage::Output((
+                                    rid,
+                                    format!("Error writing scope file! {e}"),
+                                )));
                             }
+                        } else if let Ok(_) = word.trim().parse::<IpAddr>() {
+                            if let Err(e) = write!(scope_file, "{}\n", word) {
+                                let _ = self.main_tx.send(ToolMessage::Output((
+                                    rid,
+                                    format!("Error writing scope file! {e}"),
+                                )));
+                            }
+                        } else if word.contains(".com")
+                            || word.contains(".org")
+                            || word.contains(".gov")
+                            || word.contains(".site")
+                            || word.contains(".local")
+                            || word.contains(".ad")
+                        {
+                            if let Err(e) = write!(scope_file, "{}\n", word) {
+                                let _ = self.main_tx.send(ToolMessage::Output((
+                                    rid,
+                                    format!("Error writing scope file! {e}"),
+                                )));
                             }
                         }
                     });
-                    }
-                }
+                let _ = self.main_tx.send(ToolMessage::Output((
+                    rid,
+                    "[success] scope parsed and scope.md written!".to_string(),
+                )));
             }
             "show_config" | "sc" => {
                 let _ = self
@@ -1140,6 +1196,7 @@ impl AppState {
                             }
                             2 => {
                                 args_vec[0].split(",").into_iter().for_each(|ip| {
+                                    if !project.exclusions.contains(&ip.to_string()) {
                                         if let Ok(ip) = ip.parse::<IpAddr>() {
                                             let mut new_host = Host::new();
                                             new_host.ip = ip.to_string();
@@ -1151,6 +1208,7 @@ impl AppState {
                                                 hosts.push(new_host);
                                             }
                                         }
+                                    }
                                 });
                                 args_vec[1].split(",").into_iter().for_each(|p| {
                                     if p.contains("-") {
@@ -1649,6 +1707,74 @@ impl AppState {
                 }
             }
 
+            "exclude" => {
+                if let Some(args) = command_args {
+                    let project = self.projects[self.selected_project].clone();
+                    if args.contains(" ") {
+                        args.split(" ")
+                            .into_iter()
+                            .filter(|ex| !project.exclusions.contains(&ex.to_string()))
+                            .for_each(|ex| {
+                                if let Ok(_) = ex.parse::<IpAddr>() {
+                                    self.projects[self.selected_project]
+                                        .exclusions
+                                        .push(ex.to_string());
+                                } else if let Ok(net) = ex.parse::<IpNet>() {
+                                    net.hosts().into_iter().for_each(|ip| {
+                                        self.projects[self.selected_project]
+                                            .exclusions
+                                            .push(ip.to_string());
+                                    });
+                                }
+                            });
+                    }
+                }
+            }
+
+            "start_odysseus" => {
+                if let Some(args) = command_args {
+                    let working_db = self.projects[self.selected_project].db.clone();
+                    if let Some(db) = working_db {
+                        if let Some(tools_dir) = self.config.get("TOOLS") {
+                            let mut odysseus_path = None;
+                            let entries = WalkDir::new(tools_dir);
+                            entries.into_iter().for_each(|entry| {
+                                if let Ok(entry) = entry {
+                                    if entry.file_name().to_string_lossy().contains("odysseus") {
+                                        if entry.path().is_dir() {
+                                            odysseus_path = Some(entry.into_path());
+                                        }
+                                    }
+                                }
+                            });
+                            if let Some(path) = odysseus_path {
+                                let tx_clone = self.main_tx.clone();
+                                self.workers.spawn(move||{
+                                    let output = db.run_command(format!("cd {}; source venv/bin/activate; python -m uvicorn app:app --host 127.0.0.1 --port {}", path.display(), args.trim()).as_str());
+                                    let _ = tx_clone.send(ToolMessage::Output((rid, format!("{}", output))));
+                                });
+                                let _ = self.main_tx.send(ToolMessage::Output((
+                                    rid,
+                                    "[success] odysseus command ran!".to_string(),
+                                )));
+                            }
+                        }
+                    }
+                } else {
+                    let _ = self.main_tx.send(ToolMessage::Output((
+                        rid,
+                        "[error] malformed command".to_string(),
+                    )));
+                    let _ = self
+                        .main_tx
+                        .send(ToolMessage::Output((rid, "[error] USAGE:".to_string())));
+                    let _ = self.main_tx.send(ToolMessage::Output((
+                        rid,
+                        "[error] start_odysseus {port number}".to_string(),
+                    )));
+                }
+            }
+
             "exit" => {
                 self.save_all()?;
                 let _ = self.main_tx.send(ToolMessage::AppStateExit);
@@ -1934,6 +2060,7 @@ impl AppState {
             current: false,
             db: db,
             scope: Vec::new(),
+            exclusions: Vec::new(),
         };
         match new_project.save_config() {
             Ok(_) => {}
@@ -1970,8 +2097,12 @@ impl AppState {
             rid,
             String::from("[success] folders copied!"),
         )))?;
-        remove_dir_all(&new_project.files)?;
-        remove_dir_all(&new_project.notes)?;
+        let mut old_files = new_project.files.clone();
+        let mut old_notes = new_project.notes.clone();
+        old_files.pop();
+        old_notes.pop();
+        remove_dir_all(&old_files)?;
+        remove_dir_all(&old_notes)?;
         new_files_path.push(&new_project.name);
         new_notes_path.push(&new_project.name);
         new_project.files(new_files_path.clone());
@@ -1983,9 +2114,13 @@ impl AppState {
         )))?;
         self.main_tx.send(ToolMessage::Output((
             rid,
-            String::from("creating distrobox..."),
+            String::from("checking if distrobox should be used..."),
         )))?;
         if let Some(mut db) = new_project.db {
+            self.main_tx.send(ToolMessage::Output((
+                rid,
+                String::from("creating distrobox..."),
+            )))?;
             db.volumes = vec![
                 new_files_path.display().to_string(),
                 new_notes_path.display().to_string(),
@@ -1997,6 +2132,11 @@ impl AppState {
                 rid,
                 String::from("distrobox sent to rebuild function..."),
             )))?;
+        } else {
+            self.main_tx.send(ToolMessage::Output((
+                rid,
+                String::from("Distrobox was not configured at the creation of this project, so no distrobox will be created."),
+            )))?;
         }
         new_project.save_config()?;
         self.projects[self.selected_project] = new_project;
@@ -2055,6 +2195,7 @@ impl AppState {
             password: String::new(),
             name: String::new(),
             cert_text: String::new(),
+            hostnames: Vec::new(),
         };
         self.servers.push(Arc::new(Mutex::new(new_server)));
         self.prompt.reset();

src/client.rs

@@ -24,6 +24,7 @@ pub struct Server {
     pub password: String,
     pub name: String,
     pub cert_text: String,
+    pub hostnames: Vec<String>,
 }
 
 impl Server {
@@ -56,7 +57,9 @@ impl Server {
         self.last_check = Instant::now();
         let entry = Entry::new("tetanus", &self.address)?;
         if let Ok(password) = entry.get_password() {
-            self.login(password)?;
+            if let Err(e) = self.login(password) {
+                entry.delete_credential()?;
+            }
         }
         return Ok(self.client_id);
     }
@@ -72,6 +75,7 @@ impl Server {
             self.last_check = Instant::now();
             self.logged_in = true;
             self.message_que.push(format!("SET_NAME|{}", self.name));
+            self.message_que.push(format!("REQ_HOSTNAMES"));
             return Ok(());
         } else {
             return Err("[error] logging in!".into());
@@ -82,6 +86,9 @@ impl Server {
         if self.logged_in {
             if let Ok(mut stream) = self.tls_connect() {
                 self.last_check = Instant::now();
+                if self.hostnames.is_empty() {
+                    self.message_que.push("REQ_HOSTNAMES".to_string());
+                }
                 let payload = format!(
                     "{}**{}|||{}\n",
                     self.password.clone(),

src/funcs.rs

@@ -595,6 +595,30 @@ pub fn run_tui(
                                                             let (action, data) =
                                                                 action.split_once("|").unwrap();
                                                             match action.trim() {
+                                                                "HOSTNAMES" => {
+                                                                    let _ = tx_clone.send(
+                                                                        ToolMessage::Output((
+                                                                            0,
+                                                                            "Hostnames recieved:"
+                                                                                .to_string(),
+                                                                        )),
+                                                                    );
+                                                                    data.split(",")
+                                                                        .into_iter()
+                                                                        .for_each(|h| {
+                                                                            let _ = tx_clone.send(
+                                                                            ToolMessage::Output((
+                                                                                0,
+                                                                                h.to_string(),
+                                                                            )),
+                                                                        );
+                                                                            locked_server
+                                                                                .hostnames
+                                                                                .push(
+                                                                                    h.to_string(),
+                                                                                );
+                                                                        });
+                                                                }
                                                                 "OUTPUT" => {
                                                                     let _ = tx_clone.send(
                                                                         ToolMessage::Output((
@@ -1062,6 +1086,9 @@ pub fn run_tui(
             server_lock.action_que.push("disconnect".to_string());
         }
     });
+    println!("saving state information");
+    let _ = state.save_all();
+    println!("SAVED!");
     for handle in handles {
         handle.join().unwrap();
     }

src/install.rs

@@ -129,6 +129,30 @@ pub fn client_install() -> Result<(), Box<dyn Error>> {
                 root_config_folder_path.join("victim"),
                 &options,
             )?;
+            if get_user_input(
+                "do you want to copy tetanus to your path so you can run it anywhere?",
+            )?
+            .contains("y")
+            {
+                println!("this will require sudo. Please complete the following sudo prompt.");
+                if let Ok(exe_path) = env::current_exe() {
+                    if let Ok(res) = Command::new("sudo")
+                        .arg("cp")
+                        .arg(exe_path.display().to_string())
+                        .arg("/usr/bin/tetanus")
+                        .status()
+                    {
+                        if res.success() {
+                            println!("copied to path!");
+                            println!("install completed!");
+                        } else {
+                            eprintln!(
+                                "error copying to path. please copy this executable to your path manually."
+                            );
+                        }
+                    }
+                }
+            }
             env::set_current_dir("../")?;
             remove_dir_all("./temp")?;
         }

src/main.rs

@@ -60,6 +60,13 @@ struct Args {
         help = "The name to set this instance, on servers it will name the server so clients know who it is, on clients it names the clinet for server communications. This defaults to the hostname of the machine, or if the hostname can't be determined it falls back to the username of who runs it."
     )]
     name: Option<String>,
+
+    #[arg(
+        short,
+        long,
+        help = "additional hostnames or ip addresses to add to the tls certificate to allow it to connect via portforwarding or proxies. Comma separate the values."
+    )]
+    addresses: Option<String>,
 }
 
 #[tokio::main]
@@ -201,6 +208,13 @@ async fn main() {
                 }
             }
         }
+        let mut addresses = Vec::new();
+        if let Some(adds) = args.addresses {
+            adds.split(",").into_iter().for_each(|a| {
+                addresses.push(a.to_string());
+            });
+        }
+        addresses.push(server_hostname);
         let new_server = server::Server {
             address,
             clients: Vec::new(),
@@ -208,7 +222,7 @@ async fn main() {
             key_path,
             password: server_pass,
             name,
-            hostname: server_hostname,
+            hostnames: addresses,
         };
         let res = start_server(Arc::new(Mutex::new(new_server))).await;
         match res {

src/project.rs

@@ -10,6 +10,7 @@ use std::net::IpAddr;
 use std::path::PathBuf;
 use std::process::{Command, Stdio};
 use std::sync::mpsc::Sender;
+use walkdir::WalkDir;
 
 #[derive(Clone, Debug)]
 pub struct Project {
@@ -22,6 +23,7 @@ pub struct Project {
     pub current: bool,
     pub db: Option<DistroBox>,
     pub scope: Vec<String>,
+    pub exclusions: Vec<String>,
 }
 
 impl Project {
@@ -36,6 +38,7 @@ impl Project {
             current: false,
             db: None,
             scope: Vec::new(),
+            exclusions: Vec::new(),
         }
     }
 
@@ -56,6 +59,7 @@ impl Project {
     }
 
     pub fn add_host(&mut self, mut host: Host) {
+        if !self.exclusions.contains(&host.ip) {
             let mut new_id = 0;
             self.hosts.iter().for_each(|h| {
                 if h.id > new_id {
@@ -68,6 +72,7 @@ impl Project {
                 self.hosts.push(host);
             }
         }
+    }
 
     pub fn config_folder(&mut self, path: PathBuf) {
         self.config_folder = path;
@@ -106,6 +111,12 @@ impl Project {
                             self.add_scope(ip.trim().to_string());
                         });
                     }
+                    "exclusions" => {
+                        let ips: Vec<&str> = parts[1].split(",").collect();
+                        ips.iter().for_each(|ip| {
+                            self.exclusions.push(ip.to_string());
+                        });
+                    }
                     _ => {}
                 }
             }
@@ -225,12 +236,13 @@ impl Project {
         }
         let mut file = File::create(&self.config_folder)?;
         let mut out_string = format!(
-            "org_name: {}\nname: {}\nnotes: {}\nfiles: {}\nscope: {}\n",
+            "org_name: {}\nname: {}\nnotes: {}\nfiles: {}\nscope: {}\nexclusions: {}\n",
             self.org_name,
             self.name,
             self.notes.display(),
             self.files.display(),
             self.scope.join(","),
+            self.exclusions.join(","),
         );
         if self.current {
             out_string.push_str("stage: current");
@@ -306,7 +318,7 @@ impl DistroBox {
             if !added_volumes.contains(&String::from(folder_name)) {
                 create_command
                     .arg("--volume")
-                    .arg(format!("{}:/{}:rw", volume, folder_name));
+                    .arg(format!("{}:/project:rw", volume));
                 added_volumes.push(folder_name.to_string());
             }
         }

src/server.rs

@@ -23,6 +23,7 @@ enum ClientAction {
     Output(String),
     Cmd(String),
     Collab(String),
+    Hostnames(String),
 }
 
 pub struct Client {
@@ -49,7 +50,7 @@ pub struct Server {
     pub key_path: PathBuf,
     pub password: String,
     pub name: String,
-    pub hostname: String,
+    pub hostnames: Vec<String>,
 }
 
 pub async fn start_server(server: Arc<Mutex<Server>>) -> Result<(), Box<dyn Error>> {
@@ -58,13 +59,15 @@ pub async fn start_server(server: Arc<Mutex<Server>>) -> Result<(), Box<dyn Erro
     name_path.pop();
     name_path.push("names.txt");
     let (server_ip, _) = lock.address.split_once(':').unwrap();
-    let server_hostname = lock.hostname.clone();
-    let current_config_names = vec![
-        server_hostname,
+    let server_hostnames = lock.hostnames.clone();
+    let mut current_config_names = vec![
         server_ip.trim().to_string(),
         "127.0.0.1".to_string(),
         "localhost".to_string(),
     ];
+    server_hostnames.iter().for_each(|n| {
+        current_config_names.push(n.clone());
+    });
     let mut regen = true;
     if let Ok(saved_names_string) = read_to_string(&name_path).await {
         let mut saved_names = Vec::new();
@@ -103,7 +106,10 @@ pub async fn start_server(server: Arc<Mutex<Server>>) -> Result<(), Box<dyn Erro
 
     println!("Listening on {}", lock.address);
     println!("password: {}", lock.password);
-
+    println!("Hostnames:");
+    lock.hostnames.iter().for_each(|h| {
+        println!("{}", h);
+    });
     drop(lock);
 
     loop {
@@ -479,6 +485,15 @@ where
                                     _ => {}
                                 }
                             }
+                            else{
+                                if action.contains("REQ_HOSTNAMES") {
+                                    let hostnames = lock.hostnames.clone().join(",");
+                                    lock.clients.iter_mut().filter(|c| c.id == source_id).for_each(|c|{
+                                        c.actions.push(ClientAction::Hostnames(hostnames.clone()));
+                                    });
+                                    println!("hostnames sent!");
+                                }
+                            }
                         });
                     }
                     if responses.len() > 0 {
@@ -495,6 +510,9 @@ where
                                 ClientAction::Collab(text) => {
                                     println!("todo, {}", text);
                                 }
+                                ClientAction::Hostnames(hostnames) => {
+                                    messages.push(format!("HOSTNAMES|{}", hostnames));
+                                }
                             }
                         }
                         let full_message = messages.join("||");
@@ -566,6 +584,9 @@ where
                                 ClientAction::Collab(text) => {
                                     println!("todo, {}", text);
                                 }
+                                ClientAction::Hostnames(_) => {
+                                    messages.push("OUTPUT|Not authenticated".to_string());
+                                }
                             }
                         }
                         let full_message = messages.join("||");

victim_templates/rust_victim/Cargo.toml

@@ -10,3 +10,24 @@ rayon = "1.12.0"
 rustls = "0.23.43"
 rustls-pemfile = "2.2.0"
 sysinfo = "0.39.6"
+
+[package]
+name = "tetanus_victim"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+ipnet = "2.12.1"
+obfstr = "0.4.6"
+rayon = "1.12.0"
+rustls = "0.23.43"
+rustls-pemfile = "2.2.0"
+sysinfo = "0.39.6"
+
+[profile.release]
+opt-level = "s"
+lto = true
+codegen-units = 1
+panic = "abort"
+strip = "symbols"
+debug = false

victim_templates/rust_victim/src/main.rs

@@ -54,6 +54,7 @@ impl Server {
         }
         self.connected = true;
         self.last_check = Instant::now();
+        self.login(self.password.clone())?;
         return Ok(self.client_id);
     }