v0.0.9

Author: VHSgunzo

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ulexec"
-version = "0.0.8"
+version = "0.0.9"
 edition = "2021"
 license = "MIT"
 readme = "README.md"

PKGBUILD

@@ -1,7 +1,7 @@
 # Maintainer: VHSgunzo <vhsgunzo.github.io>
 pkgname='ulexec-bin'
 binname="${pkgname%-bin}"
-pkgver='0.0.8'
+pkgver='0.0.9'
 pkgrel='1'
 pkgdesc='A tool for loading and executing PE on Windows and ELF on Linux from memory'
 arch=("x86_64")

README.md

@@ -47,28 +47,49 @@ Options:
 ## Examples
 The tool fully supports static and dynamically compiled Linux executables and Windows PE (portable executable). Simply pass the filename of the binary to `ulexec` and any arguments you want to supply to the binary. The environment will be directly copied over from the environment in which you execute `ulexec`
 
+The file path can be passed directly or with `~~f | ~~file` argument or env var `ULEXEC_FILE`
+
 ```
 ulexec /bin/ls -lha
 ```
 
-You can have it read a binary from `stdin` if you specify `~~s | ~~stdin` argument
+You can read a binary from `stdin` if you specify `~~s | ~~stdin` argument or env var `ULEXEC_STDIN=1`
 
 ```
 cat /bin/ls|ulexec ~~s -lha
 # or
 ulexec ~~s</bin/ls -lha
 ```
 
-To download a binary into memory and immediately execute it you can use `~~u | ~~url`
+To download a binary into memory and immediately execute it you can use `~~u | ~~url` argument or env var `ULEXEC_URL` or pass the URL directly
+
+```
+ulexec http://example.com/bin/ls -lha
+```
+
+If the resource (for example https://temp.sh) on which the binary file is located requires using the POST method instead of GET to start downloading, you can specify this with the `~~p | ~~post` argument or env var `ULEXEC_POST=1`
+
+```
+ulexec ~~p http://temp.sh/ABCDEF/ls -lha
+```
+
+For executable files that need to fork themselves, you can use the `~~re | ~~reexec` argument or env var `ULEXEC_REEXEC=1`
+
+```
+ulexec ~~re http://example.com/bin/tun2proxy --unshare --setup --proxy socks5://127.0.0.1:1080 -- /bin/bash
+ulexec ~~re http://example.com/bin/gocryptfs /tmp/cryptfs /tmp/mnt
+```
+
+To self remove `ulexec` at startup, you can use the `~~r | ~~remove` argument or env var `ULEXEC_REMOVE=1`
 
 ```
-ulexec ~~u http://example.com/bin/ls -lha
+ulexec ~~r http://example.com/bin/ls -lha
 ```
 
-If the resource (for example https://temp.sh) on which the binary file is located requires using the POST method instead of GET to start downloading, you can specify this with the `~~p | ~~post` argument
+You can pass `stdin` data to the executed binary
 
 ```
-ulexec ~~p ~~u http://temp.sh/ABCDEF/ls -lha
+ulexec http://example.com/bin/tar -xzvf-</path/to/local.tar.gz
 ```
 
 ## References

src/main.rs

@@ -49,6 +49,15 @@ fn get_env_var(env_var: &str) -> String {
     ret
 }
 
+fn unset_env_vars_with_prefix(prefix: &str) {
+    let current_vars = env::vars();
+    for (key, _value) in current_vars {
+        if key.starts_with(prefix) {
+            env::remove_var(key);
+        }
+    }
+}
+
 fn parse_args() -> Args {
     let env_args: Vec<String> = env::args().skip(1).collect();
     let mut args = Args::default();
@@ -113,7 +122,16 @@ fn parse_args() -> Args {
     }
     if args.url.is_none() {
         let var = get_env_var("ULEXEC_URL");
-        if !var.is_empty() { args.url = Some(var) }
+        if !var.is_empty() {
+            args.url = Some(var)
+        } else {
+            if !args.exec_args.is_empty() {
+                let arg = &args.exec_args[0];
+                if arg.starts_with("http://") || arg.starts_with("https://") {
+                    args.url = Some(args.exec_args.remove(0));
+                }
+            }
+        }
     }
     if args.file.is_none() {
         let var = get_env_var("ULEXEC_FILE");
@@ -184,6 +202,8 @@ fn main() {
         }
     }
 
+    unset_env_vars_with_prefix("ULEXEC_");
+
     let mut exec_file: Vec<u8> = Vec::new();
     let mut file_path = PathBuf::new();
 
@@ -233,15 +253,7 @@ fn main() {
     if !file_path.to_str().unwrap().is_empty() && exec_file.is_empty() {
         match read(&file_path) {
             Ok(data) => {
-                exec_file = data;
-                #[cfg(target_os = "linux")]
-                if args.reexec && is_child {
-                    file_path = PathBuf::new();
-                    env::remove_var("ULEXEC_URL");
-                    env::remove_var("ULEXEC_FILE");
-                    env::remove_var("ULEXEC_CHILD");
-                    env::remove_var("ULEXEC_REEXEC");
-                }
+                exec_file = data
             }
             Err(err) => {
                 eprintln!("Failed to read the binary file: {err}: {:?}", file_path);
@@ -340,14 +352,14 @@ fn main() {
         }
 
         if args.reexec && !is_child && !args.mfdexec {
-            let fifo_path = &env::temp_dir().join(random_string(8));
-            if let Err(err) = mkfifo(fifo_path, Mode::S_IRWXU) {
+            let fifo_path = env::temp_dir().join(random_string(8));
+            if let Err(err) = mkfifo(&fifo_path, Mode::S_IRWXU) {
                 eprintln!("Failed to create fifo: {err}: {:?}", fifo_path);
                 exit(1)
             }
             env::set_var("ULEXEC_CHILD", "1");
             env::set_var("ULEXEC_REEXEC", "1");
-            env::set_var("ULEXEC_FILE", fifo_path);
+            env::set_var("ULEXEC_FILE", &fifo_path);
             let fifo_path = fifo_path.clone();
             let exec_file = exec_file.clone();
             spawn(move || {
@@ -377,10 +389,10 @@ fn main() {
                 .envs(env::vars())
                 .status().unwrap().code().unwrap())
         } else {
-            if file_path.to_str().unwrap().is_empty() && !exec_file.is_empty() {
+            if !file_path.exists() && !exec_file.is_empty() {
                 match &memfd_create(
                     CString::new(memfd_name).unwrap().as_c_str(),
-                    MemFdCreateFlag::MFD_CLOEXEC,
+                    MemFdCreateFlag::MFD_CLOEXEC
                 ) {
                     Ok(memfd) => {
                         let memfd_raw = memfd.as_raw_fd();