286 lines
14 KiB
Rust
286 lines
14 KiB
Rust
use std::process::Command;
|
|
use std::{path::PathBuf, process};
|
|
use std::env;
|
|
use std::fs;
|
|
use std::io::Write;
|
|
use std::thread::{self, JoinHandle};
|
|
use std::time::Duration;
|
|
use crate::{get_user_input, Project};
|
|
|
|
pub fn stop_all_boxes(projects: &Vec<Project>){
|
|
let mut problem_childs: Vec<Project> = Vec::new();
|
|
let mut all_done = true;
|
|
for project in projects{
|
|
let stopped = process::Command::new("distrobox")
|
|
.arg("stop")
|
|
.arg("--root")
|
|
.arg(&project.boxname)
|
|
.status().expect("error spawing distrobox");
|
|
if stopped.success(){
|
|
println!("{} sucessfully stopped!", &project.boxname);
|
|
}
|
|
else{
|
|
println!("{} not stopped!!!!!!!", &project.boxname);
|
|
all_done = false;
|
|
problem_childs.push(project.clone());
|
|
}
|
|
}
|
|
if all_done{
|
|
println!("All boxes stopped GO US YAAAAA WE DID IT");
|
|
}
|
|
else{
|
|
println!("OOOOOOOF some boxes didn't stop yo, that's cringe");
|
|
println!("here are the problem childs, you may need to stop them manually");
|
|
for child in problem_childs{
|
|
println!("{}",child.boxname);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn project_standalone_terminal(project: Project, mut terminal: String){
|
|
terminal = terminal.trim_end().to_owned();
|
|
let mut profile = false;
|
|
if terminal.contains("profile"){
|
|
profile = true;
|
|
}
|
|
if terminal.contains("!!!"){
|
|
let terminal_launch_cmd = format!("distrobox enter --root {}", &project.boxname);
|
|
terminal = terminal.replace("!!!", &terminal_launch_cmd);
|
|
}
|
|
let terminal_vec:Vec<&str> = terminal.split(" ").collect();
|
|
let mut terminal_start = process::Command::new(terminal_vec[0]);
|
|
let mut first = true;
|
|
for arg in terminal_vec{
|
|
if first == true{
|
|
first = false;
|
|
}
|
|
else{
|
|
terminal_start.arg(arg);
|
|
}
|
|
}
|
|
if profile == false {
|
|
terminal_start.arg(&project.boxname);
|
|
}
|
|
print!("{}", terminal);
|
|
let start = terminal_start.spawn();
|
|
match start{
|
|
Ok(_child) => println!("New Terminal Started, you can retun to the menu now!"),
|
|
Err(_error) => println!("error starting new terminanl, something may be wrong with the terminal part of your config!\nCheck ~/.conf/pyro_pentest_tool/conf for errors")
|
|
}
|
|
//process::Command::new("konsole").arg("--profile").arg("attack").arg(project.boxname).spawn().expect("error opeing konsole");
|
|
}
|
|
|
|
pub fn project_inline_terminal(project: Project){
|
|
process::Command::new("distrobox").arg("enter").arg("--root").arg(project.boxname).arg("--").arg("script").arg("-a").arg("-B").arg("/pentest/working/terminal.log").status().expect("error opeing konsole");
|
|
}
|
|
|
|
pub fn make_box(project: &Project, tools_dir: &PathBuf, boxtemplate: &String, new: bool, fingerprint: bool){
|
|
println!("stopping template box to ensure we can clone it!");
|
|
let stop_result = Command::new("distrobox").arg("stop").arg("--root").arg(boxtemplate).status();
|
|
if stop_result.is_err(){
|
|
println!("error stopping template!");
|
|
}
|
|
if !new{
|
|
let _distrobox_stop_status = process::Command::new("distrobox").arg("stop").arg("--root").arg(&project.boxname).status().expect("error stopping distrobox");
|
|
let distrobox_rm_status = process::Command::new("distrobox-rm")
|
|
.arg("--root")
|
|
.arg("-f")
|
|
.arg(&project.boxname)
|
|
.status().expect("error calling distrobox");
|
|
if distrobox_rm_status.success(){
|
|
println!("Distrobox Removal Successful!!!");
|
|
}
|
|
else{
|
|
println!("Distrobox Removal Failed, manual removal required!");
|
|
}
|
|
}
|
|
let mut box_name_path = project.files_folder.clone();
|
|
let box_name = format!("{}_{}", &boxtemplate, &project.customer);
|
|
box_name_path.push("boxname");
|
|
let mut box_name_file = fs::File::create(box_name_path).expect("Error creating box name file");
|
|
box_name_file.write_all(&box_name.as_bytes()).expect("error writing boxname to box file");
|
|
let pentest_volume = format!("{}:/pentest:rw", &project.files_folder.display());
|
|
let toold_volume = format!("{}:/tools:rw", tools_dir.display());
|
|
let mut distrobox_cmd = String::new();
|
|
if fingerprint{
|
|
println!("creating box with shared volume for fingerprints... note you will still need to set up fingerprint authentication in your distrobox");
|
|
println!("\nfor example, you may need to install fprintd and imagemegick on your template box, and set up the pam files to utilize finger print auth");
|
|
println!("\nsee https://wiki.archlinux.org/title/Fprint for more information and instructions");
|
|
distrobox_cmd = format!("distrobox create --root --init --clone {} --volume {} --volume {} --volume /var/lib/fprint:/var/lib/fprint:rw --name {}", boxtemplate, toold_volume, pentest_volume, box_name);
|
|
}
|
|
else {
|
|
distrobox_cmd = format!("distrobox create --root --init --clone {} --volume {} --volume {} --name {}", boxtemplate, toold_volume, pentest_volume, box_name);
|
|
}
|
|
println!("{}", distrobox_cmd);
|
|
let distrobox_cmd_vec: Vec<&str> = distrobox_cmd.split_whitespace().collect();
|
|
let mut distrobox_cmd_build = process::Command::new("distrobox");
|
|
let mut first = true;
|
|
for word in &distrobox_cmd_vec{
|
|
if first == false{
|
|
println!("adding {} as an argument for the creation command...", word);
|
|
distrobox_cmd_build.arg(word);
|
|
}
|
|
else{
|
|
first = false;
|
|
}
|
|
}
|
|
let distrobox_result = distrobox_cmd_build.status();
|
|
if distrobox_result.is_err(){
|
|
println!("oooof we ran into trouble creating your distrobox!!");
|
|
println!("try creating it manually!");
|
|
println!("{}", distrobox_cmd);
|
|
}
|
|
else{
|
|
if distrobox_result.unwrap().success(){
|
|
println!("we made a distrobox oh boy!");
|
|
let distrobox_start_result = process::Command::new("distrobox")
|
|
.arg("enter")
|
|
.arg("--root")
|
|
.arg(&box_name)
|
|
.arg("--")
|
|
.arg("sudo")
|
|
.arg("-s")
|
|
.arg("ln")
|
|
.arg("-sf")
|
|
.arg("/pentest/boxname")
|
|
.arg("/etc/boxname")
|
|
.status();
|
|
if distrobox_start_result.is_err(){
|
|
println!("ooof did not start successfully try entering it yoruself");
|
|
println!("distrobox enter --root {} -- sudo -s ln -sf /pentest/boxname /etc/boxname", &box_name);
|
|
}
|
|
else if distrobox_start_result.unwrap().success(){
|
|
println!("distrobox was started as well!!!! good job me!");
|
|
}
|
|
else {
|
|
println!("ooof did not start successfully try entering it yoruself");
|
|
println!("distrobox enter --root {} -- sudo -s ln -sf /pentest/boxname /etc/boxname", &box_name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
pub fn clean_unused_boxes(projects: &Vec<Project>, boxtemplate: &String) -> Option<JoinHandle<()>>{
|
|
println!("starting template box: {}", boxtemplate);
|
|
let template_status = process::Command::new("distrobox").arg("enter").arg("--root").arg(boxtemplate).arg("--").arg("exit").status();
|
|
if template_status.is_err(){
|
|
let start_error = template_status.err().unwrap();
|
|
println!("OOOF issue starting template box, cancelling...");
|
|
println!("ERROR: {}", start_error);
|
|
return None;
|
|
}
|
|
println!("starting project boxes...");
|
|
for project in projects{
|
|
if project.stage.contains("current"){
|
|
let start_status = process::Command::new("distrobox").arg("enter").arg("--root").arg(&project.boxname).arg("--").arg("exit").status();
|
|
if start_status.is_err(){
|
|
let start_error = start_status.err().unwrap();
|
|
println!("OOOF issue starting {}, cancelling...", project.boxname);
|
|
println!("ERROR: {}", start_error);
|
|
return None;
|
|
}
|
|
}
|
|
}
|
|
println!("pruning unused containers...");
|
|
let handle = thread::spawn(move ||{
|
|
let spawn_result = process::Command::new("sudo").arg("podman").arg("system").arg("prune").arg("-a").arg("-f").output();
|
|
if spawn_result.is_err(){
|
|
let spawn_error = spawn_result.err().unwrap();
|
|
println!("oof trouble spawing prune command!, try manually");
|
|
println!("ERROR: {}", spawn_error);
|
|
}
|
|
println!("PRUNING COMPLETE!");
|
|
});
|
|
thread::sleep(Duration::from_secs(3));
|
|
println!("this will take some time, but its running on a different thread so you can continue working!");
|
|
return Some(handle);
|
|
}
|
|
|
|
pub fn launch_cobalt_strike(project: Project) -> Option<JoinHandle<()>>{
|
|
let mut check_path = PathBuf::new();
|
|
check_path.push(&project.files_folder);
|
|
check_path.push("cobaltstrike/client");
|
|
if check_path.as_path().exists() == false{
|
|
println!("looks like you don't have cobalt strike set up on this beacon... try copying your cobalt strike folder to the following path!");
|
|
println!("{}", &check_path.display());
|
|
return None;
|
|
}
|
|
println!("you will need to enter your sudo password shortly, when you've done that successfully please type END and hit enter");
|
|
let handle = thread::spawn(move ||{
|
|
let mut cs_dir = PathBuf::new();
|
|
cs_dir.push(project.files_folder);
|
|
cs_dir.push("cobaltstrike/client");
|
|
let cd_res = env::set_current_dir(&cs_dir);
|
|
if cd_res.is_ok(){
|
|
let cobalt_strike_launch_result = Command::new("distrobox")
|
|
.arg("enter")
|
|
.arg("--root").arg(project.boxname)
|
|
.arg("--")
|
|
.arg("./cobaltstrike")
|
|
.output();
|
|
if cobalt_strike_launch_result.is_err(){
|
|
let error = cobalt_strike_launch_result.err().unwrap();
|
|
println!("error launching cobalt strike!");
|
|
println!("{}", error);
|
|
}
|
|
}
|
|
});
|
|
thread::sleep(Duration::from_secs(5));
|
|
loop{
|
|
let end = get_user_input("please enter END if the sudo password was enter correctly!");
|
|
if end == "END".to_string(){
|
|
break;
|
|
}
|
|
}
|
|
return Some(handle);
|
|
}
|
|
|
|
pub fn launch_bloodhound_gui(project: Project) -> Option<JoinHandle<()>>{
|
|
let mut bloodhound_command = String::new();
|
|
let version_response = get_user_input("do you want to use a specific bloodhound version?");
|
|
if version_response.to_lowercase().contains("y"){
|
|
bloodhound_command = get_user_input("path to the bloodhound binary you want to use?");
|
|
}
|
|
else{
|
|
bloodhound_command = "bloodhound".to_owned();
|
|
}
|
|
let mut neo4j_started = false;
|
|
let neo4jstart_res = Command::new("distrobox")
|
|
.arg("enter")
|
|
.arg("--root")
|
|
.arg(&project.boxname)
|
|
.arg("--")
|
|
.arg("sudo")
|
|
.arg("neo4j")
|
|
.arg("start")
|
|
.status();
|
|
if neo4jstart_res.is_err(){
|
|
let error = neo4jstart_res.err().unwrap();
|
|
println!("errror starting neo4j...");
|
|
println!("{}", error);
|
|
}
|
|
else{
|
|
neo4j_started = true;
|
|
thread::sleep(Duration::from_secs(3));
|
|
}
|
|
if neo4j_started == false{
|
|
println!("review previous errors, not spawning bloodhound thread...");
|
|
return None;
|
|
}
|
|
let handle = thread::spawn(move ||{
|
|
let bloodhound_res = Command::new("distrobox")
|
|
.arg("enter")
|
|
.arg("--root")
|
|
.arg(&project.boxname)
|
|
.arg("--")
|
|
.arg(bloodhound_command)
|
|
.output();
|
|
if bloodhound_res.is_err(){
|
|
let error = bloodhound_res.err().unwrap();
|
|
println!("error starting bloodhound!");
|
|
println!("{}", error);
|
|
}
|
|
});
|
|
return Some(handle);
|
|
} |