added logic to install the tetanus_update scirpt on the system.

folder.

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 {
@@ -162,22 +163,26 @@ impl AppState {
                             new_project.load_config(display)?;
                             let template_box = self.config.get("template_box").unwrap();
                             let tools = self.config.get("tools").unwrap();
-                            let db = DistroBox {
-                                name: format!(
-                                    "{}-{}-{}",
-                                    template_box,
-                                    new_project.org_name.clone(),
-                                    new_project.name.clone()
-                                ),
-                                volumes: vec![
-                                    new_project.files.display().to_string(),
-                                    new_project.notes.display().to_string(),
-                                    tools.clone(),
-                                ],
-                                created: false,
-                                template: template_box.clone(),
-                            };
-                            new_project.db = Some(db);
+                            if template_box != "NONE" || new_project.distrobox {
+                                let db = DistroBox {
+                                    name: format!(
+                                        "{}-{}-{}",
+                                        template_box,
+                                        new_project.org_name.clone(),
+                                        new_project.name.clone()
+                                    ),
+                                    volumes: vec![
+                                        new_project.files.display().to_string(),
+                                        new_project.notes.display().to_string(),
+                                        tools.clone(),
+                                    ],
+                                    created: false,
+                                    template: template_box.clone(),
+                                };
+                                new_project.db = Some(db);
+                            } else {
+                                new_project.db = None;
+                            }
                             self.projects.push(new_project);
                         }
                     }
@@ -282,6 +287,7 @@ impl AppState {
             "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(());
@@ -579,11 +585,24 @@ impl AppState {
                 let project = self.projects[self.selected_project].clone();
                 if let Some(cmd) = self.config.get("term_cmd") {
                     if let Some(db) = project.db {
-                        db.launch_terminal(cmd.to_string());
+                        let _ = self
+                            .main_tx
+                            .send(ToolMessage::Output((rid, format!("launcing distrobox..."))));
+                        db.launch_terminal(
+                            cmd.to_string(),
+                            self.projects[self.selected_project].files.clone(),
+                        );
                     } else {
                         if let Some((prog, _)) = cmd.split_once(" ") {
                             let mut launch_cmd = Command::new(prog);
-                            match launch_cmd.spawn() {
+                            launch_cmd.current_dir(&project.files);
+                            if let Some(dir) = launch_cmd.get_current_dir() {
+                                let _ = self.main_tx.send(ToolMessage::Output((
+                                    rid,
+                                    format!("launcing terminal in {}", dir.display()),
+                                )));
+                            }
+                            match launch_cmd.current_dir(&project.files).spawn() {
                                 Ok(_) => {}
                                 Err(e) => {
                                     let _ = self.main_tx.send(ToolMessage::Output((
@@ -1716,6 +1735,50 @@ impl AppState {
                 }
             }
 
+            "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);
@@ -1979,6 +2042,7 @@ impl AppState {
             }
         }
         let mut db = None;
+        let mut distrobx = false;
         if template_box != &"NONE".to_string() {
             db = Some(DistroBox {
                 name: format!("{}-{}-{}", template_box, org, name),
@@ -1990,6 +2054,7 @@ impl AppState {
                 created: false,
                 template: template_box.to_string(),
             });
+            distrobx = true;
         };
         let mut new_project = Project {
             org_name: org,
@@ -2000,6 +2065,7 @@ impl AppState {
             config_folder: project_config_file,
             current: false,
             db: db,
+            distrobox: distrobx,
             scope: Vec::new(),
             exclusions: Vec::new(),
         };
@@ -2038,8 +2104,24 @@ impl AppState {
             rid,
             String::from("[success] folders copied!"),
         )))?;
+        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(&new_project.files)?;
         remove_dir_all(&new_project.notes)?;
+        if let Err(_) = remove_dir(old_files) {
+            self.main_tx.send(ToolMessage::Output((
+                rid,
+                String::from("organization files folder is not empty and will not be deleted."),
+            )))?;
+        }
+        if let Err(_) = remove_dir(old_notes) {
+            self.main_tx.send(ToolMessage::Output((
+                rid,
+                String::from("organization notes folder is not empty and will not be deleted."),
+            )))?;
+        }
         new_files_path.push(&new_project.name);
         new_notes_path.push(&new_project.name);
         new_project.files(new_files_path.clone());
@@ -2051,9 +2133,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(),
@@ -2065,6 +2151,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;

src/install.rs

@@ -1,11 +1,12 @@
 use fs_extra::dir::{CopyOptions, copy};
-use std::env;
 use std::error::Error;
-use std::fs::{File, create_dir_all, remove_dir_all};
+use std::fs::{File, OpenOptions, create_dir_all, remove_dir_all};
 use std::io::Write;
+use std::os::unix::fs::PermissionsExt;
 use std::path::PathBuf;
 use std::process::Command;
 use std::process::exit;
+use std::{env, fs};
 use tetanus::funcs::get_user_input;
 
 pub fn install() -> Result<(), Box<dyn Error>> {
@@ -98,6 +99,7 @@ pub fn client_install() -> Result<(), Box<dyn Error>> {
         client_config_file.write(format!("term_cmd: {}\n", term_cmd).as_bytes())?;
         client_config_file.write(format!("tools: {}\n", tools_folder).as_bytes())?;
         client_config_file.write("alternate_configs: \n".as_bytes())?;
+        let mut version_file = File::create(root_config_folder_path.join("version"))?;
         println!("\ndefault config files written!");
         println!("downloading note templates, victim templates, and modules...");
         create_dir_all("./temp")?;
@@ -129,6 +131,81 @@ 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() {
+                            let base_update_string = fs::read_to_string("./tetanus_update.sh")?;
+                            let update_string = base_update_string.replace(
+                                "|||config|||",
+                                &root_config_folder_path.display().to_string(),
+                            );
+                            let update_path = PathBuf::from("./tetanus_update");
+                            let mut update_script = OpenOptions::new()
+                                .create(true)
+                                .truncate(true)
+                                .write(true)
+                                .open(&update_path)?;
+                            update_script.write(update_string.as_bytes())?;
+                            let mut perms = fs::metadata(&update_path)?.permissions();
+                            perms.set_mode(0o755);
+                            fs::set_permissions(update_path, perms)?;
+                            let _ = Command::new("sudo")
+                                .arg("cp")
+                                .arg("./tetanus_update")
+                                .arg("/usr/bin/tetanus_update")
+                                .status();
+                            version_file
+                                .write("version: 0.0.7\npath: /usr/bin/tetanus".as_bytes())?;
+                            println!("copied to path!");
+                            println!("install completed!");
+                        } else {
+                            eprintln!(
+                                "error copying to path. please copy this executable to your path manually."
+                            );
+                            eprintln!("please download the update_script to your path manually");
+                            eprintln!(
+                                "sudo curl https://git.pyro.monster/pyro/tetanus/raw/branch/main/tetanus_update.sh -o /usr/bin/tetanus_update"
+                            );
+                            eprintln!("sudo chmod +x /usr/bin/tetanus_update");
+                        }
+                    }
+                }
+            } else {
+                println!(
+                    "Ok, we will keep the tetanus binary where it is. The tetanus_update bash script will be in the same directory."
+                );
+                let base_update_string = fs::read_to_string("./tetanus_update.sh")?;
+                let update_string = base_update_string.replace(
+                    "|||config|||",
+                    &root_config_folder_path.display().to_string(),
+                );
+                let mut update_path = env::current_exe()?;
+                update_path.pop();
+                update_path.push("tetanus_update");
+                let mut update_script = OpenOptions::new()
+                    .create(true)
+                    .truncate(true)
+                    .write(true)
+                    .open(&update_path)?;
+                update_script.write(update_string.as_bytes())?;
+                let mut perms = fs::metadata(&update_path)?.permissions();
+                perms.set_mode(0o755);
+                fs::set_permissions(update_path, perms)?;
+                version_file.write(
+                    format!("version: 0.0.7\npath: {}", env::current_exe()?.display()).as_bytes(),
+                )?;
+            }
             env::set_current_dir("../")?;
             remove_dir_all("./temp")?;
         }

src/main.rs

@@ -2,6 +2,8 @@ use clap::Parser;
 use keyring::Entry;
 use rand::RngExt;
 use rand::distr::Alphanumeric;
+use std::fs::OpenOptions;
+use std::io::{Write, read_to_string};
 use std::sync::{Arc, Mutex};
 use std::thread::{sleep, spawn};
 use std::time::Duration;
@@ -115,6 +117,30 @@ async fn main() {
             }
         }
     }
+    if let Ok(version_string) = std::fs::read_to_string(config_path.join("version")) {
+        version_string
+            .lines()
+            .into_iter()
+            .filter(|line| line.contains("path:"))
+            .for_each(|line| {
+                if let Some((_, path)) = line.split_once(" ") {
+                    if let Ok(current_exe) = env::current_exe() {
+                        if PathBuf::from(path) != current_exe {
+                            let new_version_string =
+                                version_string.replace(path, &current_exe.display().to_string());
+                            if let Ok(mut version_file) = OpenOptions::new()
+                                .truncate(true)
+                                .write(true)
+                                .open(config_path.join("version"))
+                            {
+                                let _ = version_file.write(new_version_string.as_bytes());
+                            }
+                        }
+                    }
+                }
+            });
+    }
+
     if args.client {
         let banner = "
         XXXXXXXXXXXXXXXXXXXXXXXXXX
@@ -158,6 +184,7 @@ async fn main() {
         banner.lines().for_each(|line| {
             appstate.output.push(line.to_string());
         });
+
         let handles = Arc::new(Mutex::new(Vec::new()));
         let handles_clone = handles.clone();
         let primary_handle = spawn(move || {

src/project.rs

@@ -22,6 +22,7 @@ pub struct Project {
     pub hosts: Vec<Host>,
     pub current: bool,
     pub db: Option<DistroBox>,
+    pub distrobox: bool,
     pub scope: Vec<String>,
     pub exclusions: Vec<String>,
 }
@@ -37,6 +38,7 @@ impl Project {
             hosts: Vec::new(),
             current: false,
             db: None,
+            distrobox: false,
             scope: Vec::new(),
             exclusions: Vec::new(),
         }
@@ -117,6 +119,13 @@ impl Project {
                             self.exclusions.push(ip.to_string());
                         });
                     }
+                    "db" => {
+                        if parts[1].contains("false") {
+                            self.distrobox = false;
+                        } else {
+                            self.distrobox = true;
+                        }
+                    }
                     _ => {}
                 }
             }
@@ -236,13 +245,14 @@ impl Project {
         }
         let mut file = File::create(&self.config_folder)?;
         let mut out_string = format!(
-            "org_name: {}\nname: {}\nnotes: {}\nfiles: {}\nscope: {}\nexclusions: {}\n",
+            "org_name: {}\nname: {}\nnotes: {}\nfiles: {}\nscope: {}\nexclusions: {}\ndb: {}\n",
             self.org_name,
             self.name,
             self.notes.display(),
             self.files.display(),
             self.scope.join(","),
             self.exclusions.join(","),
+            self.distrobox
         );
         if self.current {
             out_string.push_str("stage: current");
@@ -318,7 +328,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());
             }
         }
@@ -458,7 +468,7 @@ impl DistroBox {
         return Ok(());
     }
 
-    pub fn launch_terminal(&self, cmd: String) {
+    pub fn launch_terminal(&self, cmd: String, dir: PathBuf) {
         if let Some((terminal_cmd, args)) = cmd.split_once(" ") {
             let mut term_cmd = Command::new(terminal_cmd);
             args.split(" ").into_iter().for_each(|arg| {
@@ -474,7 +484,7 @@ impl DistroBox {
                     term_cmd.arg(arg);
                 }
             });
-            let _ = term_cmd.spawn();
+            let _ = term_cmd.current_dir(dir).spawn();
         }
     }
 

tetanus_update.sh

@@ -0,0 +1,21 @@
+#!/bin/bash
+config_path="|||CONFIG|||"
+current_version=$(cat $config_path/version | grep version | cut -d " " -f 2)
+path=$(cat $config_path/version | grep path | cut -d " " -f 2)
+version=$(curl https://git.pyro.monster/pyro/tetanus/releases/tag/latest | grep "<title>" | cut -d ">" -f 2 | cut -d " " -f 1)
+
+if [[ "$version" == "$current_version" ]]; then
+    echo "up to date"
+else
+    echo "update needed"
+    curl https://git.pyro.monster/pyro/tetanus/releases/download/latest/tetanus -o $config_path/new_tetanus
+    chmod +x $config_path/new_tetanus
+    if [ "$(stat -c '%u' $path)" -eq 0 ]; then
+        sudo cp $config_path/new_tetanus $path
+    else
+        cp $config_path/new_tetanus $path
+    fi
+    echo "version: $version" > $config_path/version
+    echo "path: $path" >> $config_path/version
+    echo update complete!
+fi