From fc316c2a71da53343babc1f747b8e7ec1e7ae5d8 Mon Sep 17 00:00:00 2001 From: pyro57000 Date: Fri, 4 Apr 2025 20:17:35 -0500 Subject: [PATCH] Completely re-wrote the install function. Trying to get this working on default kali. --- pentest_tool/src/install.rs | 544 +++++++++++++++--------------------- pentest_tool/src/main.rs | 22 +- 2 files changed, 243 insertions(+), 323 deletions(-) diff --git a/pentest_tool/src/install.rs b/pentest_tool/src/install.rs index 2898341..57ce53c 100644 --- a/pentest_tool/src/install.rs +++ b/pentest_tool/src/install.rs @@ -1,13 +1,13 @@ use std::collections::HashMap; -use std::fs; -use std::fs::File; +use std::env::home_dir; +use std::fs::{File, create_dir_all, remove_dir_all}; use std::io::Read; use std::io::Write; use std::io::stdin; use std::io::copy; use std::process::Command; use reqwest::blocking::get; -use std::path::PathBuf; +use std::{path::Path, path::PathBuf}; use std::process; use std::process::exit; use directories::UserDirs; @@ -15,217 +15,31 @@ use directories::UserDirs; use crate::get_user_input; -fn setup_folders(config_path: &PathBuf) -> (String, String, String, String, String, String, String, String, String){ - let mut delete_for_cleanup = config_path.clone(); - delete_for_cleanup.pop(); - let mut failed = false; - let mut new_files_folder = String::new(); - let mut new_notes_folder = String::new(); - let mut upcomming_files_folder = String::new(); - let mut upcomming_notes_folder = String::new(); - let mut tools_folder = String::new(); - let mut cracking_rig = String::new(); - let mut cracking_user = String::new(); - let mut rockyou = String::new(); - let mut rule = String::new(); - while new_files_folder.is_empty() || new_notes_folder.is_empty() || tools_folder.is_empty(){ - if new_files_folder.is_empty(){ - println!("path to save active project files?"); - match stdin().read_line(&mut new_files_folder){ - Ok(_r) => (), - Err(_e) => println!("we need input here dummy... We will reprompt on the next loop...") - } - } - if new_notes_folder.is_empty(){ - println!("path to save active project notes?"); - match stdin().read_line(&mut new_notes_folder){ - Ok(_r) => (), - Err(_e) => println!("we need input here dummy... We will reprompt on the next loop...") - } - } - if tools_folder.is_empty(){ - println!("path to custom tools (like github tools and what not)"); - match stdin().read_line(&mut tools_folder){ - Ok(_r) => (), - Err(_e) => println!("we need input here dummy... We will reprompt on the next loop...") - } - } - if upcomming_files_folder.is_empty(){ - println!("path to save upcomming project files?"); - match stdin().read_line(&mut upcomming_files_folder){ - Ok(_r) => (), - Err(_e) => println!("we need input here dummy... We will reprompt on the next loop...") - } - } - if upcomming_notes_folder.is_empty(){ - println!("path to save upcomming project notes?"); - match stdin().read_line(&mut upcomming_notes_folder){ - Ok(_r) => (), - Err(_e) => println!("we need input here dummy... We will reprompt on the next loop...") - } - } - if cracking_rig.is_empty(){ - let mut have_rig = String::new(); - println!("do you have a separate computer that you can ssh into to crack passwords on?"); - match stdin().read_line(&mut have_rig){ - Ok(_r) => (), - Err(_e) => println!("we need input here dummy, try again...") - } - have_rig = have_rig.to_lowercase(); - if have_rig.contains("y"){ - println!("excellent! Whats the IP or hostname?"); - loop{ - match stdin().read_line(&mut cracking_rig){ - Ok(_r) => break, - Err(_e) => println!("we need input here dummy, try again...") - } - } - println!("user to ssh as for the cracking rig?"); - loop{ - match stdin().read_line(&mut cracking_user){ - Ok(_r) => break, - Err(_e) => println!("we need input here dummy, try again...") - } - } - println!("Path to rockyou.txt on the cracking rig?"); - loop{ - match stdin().read_line(&mut rockyou){ - Ok(_r) => break, - Err(_e) => println!("we need input here dummyu try again...") - } - } - println!("Path to one rule to rule them all on the cracking rig?"); - loop{ - match stdin().read_line(&mut rule){ - Ok(_r) => break, - Err(_e) => println!("we need input here dummyu try again...") - } - } - } - else if have_rig.contains("n"){ - println!("ooof ok freeloader"); - cracking_rig = "n".to_owned(); - rule = "n".to_owned(); - rockyou = "n".to_owned(); - } - } - } - new_files_folder = new_files_folder.trim_end().to_owned(); - new_notes_folder = new_notes_folder.trim_end().to_owned(); - upcomming_files_folder = upcomming_files_folder.trim_end().to_owned(); - upcomming_notes_folder = upcomming_notes_folder.trim_end().to_owned(); - tools_folder = tools_folder.trim_end().to_owned(); - cracking_rig = cracking_rig.trim_end().to_owned(); - cracking_user = cracking_user.trim_end().to_owned(); - let new_files_path = PathBuf::from(&new_files_folder.trim_end()); - let new_notes_path = PathBuf::from(&new_notes_folder.trim_end()); - let upcomming_files_path = PathBuf::from(&upcomming_files_folder.trim_end()); - let upcomming_notes_path = PathBuf::from(&upcomming_notes_folder.trim_end()); - let tools_path = PathBuf::from(&tools_folder.trim_end()); - if new_files_path.exists() == false{ - println!("active project file folder does not exist, creating..."); - match fs::create_dir_all(&new_files_folder){ - Ok(_r) => (), - Err(e) => {println!("Error creating active project files Folder!: {}", e);failed = true;} - } - } - if new_notes_path.exists() == false{ - println!("active project notes folder does not exist creating..."); - match fs::create_dir_all(new_notes_path){ - Ok(_r) => (), - Err(e) => {println!("Error creating active project notes Folder!: {}", e);failed = true;} - } - } - if tools_path.exists() == false{ - println!("tools folder does not exist creating..."); - match fs::create_dir_all(tools_path){ - Ok(_r) => (), - Err(e) => {println!("Error creating tools Folder!: {}", e);failed = true;} - } - } - if upcomming_files_path.exists() == false{ - println!("upcomming project files folder does not exist creating..."); - match fs::create_dir_all(upcomming_files_path){ - Ok(_r) => (), - Err(e) => {println!("Error creating upcomming project files Folder!: {}", e);failed = true;} - } - } - if upcomming_notes_path.exists() == false{ - println!("upcomming project notes folder does not exist creating..."); - match fs::create_dir_all(upcomming_notes_path){ - Ok(_r) => (), - Err(e) => {println!("Error creating upcomming project notes Folder!: {}", e);failed = true;} - } - } - - if failed{ - println!("install failed, cleaning up files..."); - match fs::remove_dir_all(&delete_for_cleanup){ - Ok(_r) => println!("cleanup successfull, please correct previously reported errors and rerun"), - Err(e) => println!("cleanup failed!: {}\nManually delete the following folder and retry\n{}", e, delete_for_cleanup.display()) - } - exit(1); - } - return (new_files_folder, new_notes_folder, tools_folder, upcomming_files_folder, upcomming_notes_folder, cracking_rig, cracking_user, rockyou, rule); -} - - -fn configure_distrobox(){ - let user_dirs_result = UserDirs::new(); - let mut success = false; - let mut dbrcpath = PathBuf::new(); - if user_dirs_result.is_some(){ - let home = user_dirs_result.unwrap().home_dir().to_path_buf(); - dbrcpath.push(home); - dbrcpath.push(".distroboxrc"); - let box_config_string = String::from("container_always_pull=\"0\"\ncontainer_generate_entry=1\ncontainer_manager=\"podman\"\ncontainer_name_default=\"ubuntu\"\ncontainer_image_default=\"ghcr.io/ublue-os/ubuntu-toolbox:latest\"\nnon_interactive=\"1\"\nxhost +si:localuser:$USER >/dev/null\nexport PIPEWIRE_RUNTIME_DIR=/dev/null\nexport PATH=$PATH:$HOME/.local/bin\n"); - let dbrc_file_res = fs::OpenOptions::new().write(true).create(true).open(dbrcpath); - if dbrc_file_res.is_err(){ - let error = dbrc_file_res.err().unwrap(); - println!("error opening distroboxrc file!"); - println!("{}", error); - } - else{ - let mut dibrc_file = dbrc_file_res.unwrap(); - let dbrc_write_res = write!(dibrc_file, "{}",box_config_string); - if dbrc_write_res.is_err(){ - println!("error writing config to distroboxrc file!"); - println!("{}", dbrc_write_res.err().unwrap()); - } - else{ - let _dbrc_write = dbrc_write_res.unwrap(); - success = true; - } - } - } - if success == false{ - println!("Error getting user dirs!"); - println!("distrobox config failed, please follow the following instructions..."); - print!(" -copy the distrobox config file to your home folder with the name .distroboxrc -cp /usr/etc/distrobox/distrobox.conf ~/.distroboxrc - -Then edit the file to change the line container_always_pull=\"1\" to container_always_pull=\"0\" - "); - } -} - - - pub fn install(config_path: &PathBuf){ let mut _terminal_commands = HashMap::from([ - ("konsole", "konsole -e !!!"), + ("kde", "konsole -e !!!"), + ("plasma", "konsole -e !!!"), ("gnome", "gnome-terminal -- bash !!!"), ("xfce", "xfce4-terminal --execute '!!!'"), ("alacritty", "alacritty -e !!!"), ]); + let mut folder_creation = true; + let current_projects = PathBuf::from(get_user_input("path to store your active projects?")); + let current_notes = PathBuf::from(get_user_input("path to store your active project notes?")); + let upcoming_projects = PathBuf::from(get_user_input("path to store your upcomming projects?")); + let upcoming_notes = PathBuf::from(get_user_input("path to store your upcomming project notes?")); + let tools = PathBuf::from(get_user_input("path where you store your custom tools (like from github and places)?")); + let folders = vec![¤t_projects, ¤t_notes, &upcoming_projects, &upcoming_notes, &tools]; let mut config_folder_path: PathBuf = config_path.clone(); config_folder_path.pop(); + let mut password_path = config_folder_path.clone(); + password_path.push("password_spray.md"); let mut projects_conf_path = config_folder_path.clone(); + projects_conf_path.push("projects."); let mut bell_file_path = config_folder_path.clone(); let del_on_fail = config_folder_path.clone(); projects_conf_path.push("projects.conf"); - fs::create_dir_all(&config_folder_path).expect("error creating config dir"); + create_dir_all(&config_folder_path).expect("error creating config dir"); bell_file_path.push("bell.mp3"); let bell_sound_url = "https://github.com/Pyro57000/pentest_tool/raw/refs/heads/main/resources/bell.mp3"; let response = get(bell_sound_url).unwrap(); @@ -233,131 +47,221 @@ pub fn install(config_path: &PathBuf){ let mut bell_file = File::create(bell_file_path).unwrap(); copy(&mut response.take(response_length), &mut bell_file).unwrap(); println!("bell notification tone sucessfully downloaded!"); - let mut config_file = fs::File::create(config_path).expect("error creating file"); - let mut projects_conf_file = fs::File::create(projects_conf_path).expect("error creating projects config file"); - projects_conf_file.write_all(b"customer:name:notes:files:active:box_name:stage\n").expect("error writing default project info"); - let mut terminal_response = String::new(); - let mut template_name = String::new(); - let mut have_template = String::new(); - println!("terminal you use? (example: konsole, xfce, gnome, etc)"); - std::io::stdin().read_line(&mut terminal_response).unwrap(); - let mut _terminal_command = String::new(); - if terminal_response.contains("konsole"){ - let mut response_buffer = String::new(); - println!("do you already have a custom profile setup?"); - println!("this is pretty specific to pyro's setup, I do some special sauce for my konsole stuff"); - std::io::stdin().read_line(&mut response_buffer).unwrap(); - if response_buffer.to_lowercase().contains("y"){ - let mut profile = String::new(); - println!("konsole profile name?"); - std::io::stdin().read_line(&mut profile).unwrap(); - _terminal_command = format!("konsole --profile {}", profile); + println!("creating new folders if needed..."); + for folder in &folders{ + if !Path::exists(folder){ + let create_res = create_dir_all(folder); + if create_res.is_err(){ + let error = create_res.err().unwrap(); + println!("error creating folder {}", folder.display()); + println!("{}", error); + println!("you'll need to create this manually after the install is done!"); + folder_creation = false; + } + } } + let tool_volume = format!("{}:/tools:rw", &tools.display()); + println!("sweet, now let's get some distrobox stuff out of the way!"); + let distrobox_run_res = Command::new("distrobox").arg("list").arg("--root").output(); + if distrobox_run_res.is_err(){ + let error = distrobox_run_res.err().unwrap(); + println!("Distrobox file was not found!"); + println!("This usually means that distrobox is not installed."); + println!("please install distrobox, if you're on kali run `sudo apt install distrobox`"); + println!("{}", error); + println!("this project heavily relies on distrobox, as its primarily a distrobox mangement tool."); + println!("cleaning up up configuration folders, please install distrobox and re-run this program."); + let cleanup = remove_dir_all(&del_on_fail); + if cleanup.is_err(){ + println!("error cleaning up configuration folder!"); + println!("please manually delete {} before re-running this install.", &del_on_fail.display()); + exit(1); + } + cleanup.unwrap(); + exit(1); + } + let distrobox_output = distrobox_run_res.unwrap().stdout; + let distrobox_string = String::from_utf8_lossy(&distrobox_output); + let mut distrobox_names = Vec::new(); + let distrobox_output_lines: Vec<&str> = distrobox_string.split("\n").collect(); + for line in distrobox_output_lines{ + if line.len() > 1{ + let name = line.split(" | ").collect::>()[1]; + distrobox_names.push(name.to_owned()); + } + } + let mut have_box = false; + for name in distrobox_names{ + if !name.contains("NAME"){ + have_box = true; + println!("name") + } + } + let mut template_box_name = String::new(); + if have_box{ + template_box_name = get_user_input("Name of the distrobox you want to use as a template?"); } else{ - _terminal_command = _terminal_commands[terminal_response.trim_end()].to_owned(); - } - let (files_response, notes_response, tools_response, project_folder_path, project_note_path, cracking_rig, cracking_user, rockyou, rule) = setup_folders(&config_path); - print!(" -This tool is mainly to handle distrobox creation and usage. -It's expecting you to have a distrobox that you will use as a template. -Do you have a distrobox set up to function as your template for all new projects? -"); - std::io::stdin().read_line(&mut have_template).unwrap(); - if have_template.contains("n"){ - println!("ooof buddy, should have had that already... no worries, we'll make one now."); - let new_boxname = get_user_input("name for your template box? (for exmaple I use atarchbox cause its my attacking archbox ;-)"); - println!("please review the following link to select an image to use for your distrobox"); - println!("https://distrobox.it/compatibility/#containers-distros"); - let image_name = get_user_input("which image would you like to use?"); - let tools_volume =format!("{}:/tools:rw", &tools_response); - let distrobox_create_res = Command::new("distrobox") - .arg("create") - .arg("--root") - .arg("--name") - .arg(new_boxname) - .arg("--init") - .arg("--image") - .arg(image_name) - .arg("--volume") - .arg(tools_volume) - .arg("--additional-packages") - .arg("systemd") - .arg("--") - .arg("exit") - .status(); - if distrobox_create_res.is_err(){ - let error = distrobox_create_res.err().unwrap(); - println!("ooof we ran into a problem creating your distrobox...."); + println!("no exiting distroboxes created!"); + println!("let's make one!"); + template_box_name = get_user_input("name of the distrobox you want to create?"); + println!("review images listed here: https://distrobox.it/compatibility/#containers-distros"); + let box_image = get_user_input("image you want to base the template box on?"); + let template_box_create_res = Command::new("distrobox") + .arg("create") + .arg("--root") + .arg("--image") + .arg(&box_image) + .arg("--name") + .arg(&template_box_name) + .arg("--init") + .arg("--volume") + .arg(&tool_volume) + .status(); + if template_box_create_res.is_err(){ + let error = template_box_create_res.err().unwrap(); + println!("error creating template box!"); println!("{}", error); - println!("you'll have to make it manually, but remember the name you want to use for the next step."); + println!("\n\n\nplese create it yourself with the following command."); + println!("\n\ndistrobox create --root --image {}, --name {}, --init --volume {}", &box_image, &template_box_name, &tool_volume); } else{ - distrobox_create_res.unwrap(); - println!("nice, we created a distrobox, remeber the name of your box for the next step!"); + template_box_create_res.unwrap(); } } - let _list = process::Command::new("distrobox").arg("list").arg("--root").status(); - println!("distrobox template name?"); - std::io::stdin().read_line(&mut template_name).unwrap(); - let mut set_fprint = String::from("no"); - let fprint_answer = get_user_input("do you want to use fingerprint authentication inside the distroboxes?").to_lowercase(); - if fprint_answer.contains("y"){ - set_fprint = "yes".to_owned(); + let mut cracking_rig = String::from("nobody@nothing"); + let mut rockyou = String::from("n/a"); + let mut rule = String::from("n/a"); + let cracking_rig_response = get_user_input("do you have a separate machine to crack passwords on? (not the ambush cracking rig)"); + if cracking_rig_response.to_lowercase().contains("y"){ + let rig_ip = get_user_input("ip address or hostname of your cracking rig?"); + let rig_user = get_user_input("username to log into your cracking rig with?"); + rockyou = get_user_input("location of rockyou.txt on the cracking rig?"); + rule = get_user_input("location of one rule to rule them all on the cracking rig?"); + cracking_rig = format!("{}@{}", rig_user, rig_ip); } - let config_string = format!("Project_files:{}\nProject_notes:{}\ntools_folder:{}\nupcoming_files:{}\nupcoming_notes:{}\nbox_template:{}\nterminal:{}\ncracking_rig:{}@{}\nrockyou_location:{}\nrule_location:{}\nfingerprint:{}", files_response.trim_end(), notes_response.trim_end(), tools_response.trim_end(), &project_folder_path.trim_end(), &project_note_path.trim_end(), template_name.trim_end(), _terminal_command.trim_end(), cracking_user.trim_ascii_end(), cracking_rig.trim_end(), rockyou.trim_end(), rule.trim_end(), set_fprint); - config_file.write_all(config_string.as_bytes()).expect("error writing to config file"); - let default_projectline = format!("default:default:{}:{}:yes:{}:current", ¬es_response.trim_end(), &files_response.trim_end(), &template_name.trim_end()); - projects_conf_file.write_all(default_projectline.as_bytes()).expect("error writing default project line"); - println!("active project folders: {}", &files_response); - println!("upcomming project folders: {}", &project_folder_path); - println!("active project notes: {}", ¬es_response); - println!("upcomming prjoect notes: {}", &project_note_path); - println!("tools folder: {}", &tools_response); - println!("distrobox template: {}", &template_name); - println!("terminal command: {}", &_terminal_command); - println!("config file generated and saved to {}\n", config_path.display()); - - - let config_path = &config_folder_path.clone(); - let mut install_path = config_path.clone(); - let mut password_spray_template_path = install_path.clone(); - install_path.push("new_projects.conf"); - password_spray_template_path.push("passwordspray.md"); - let pass_file_config_line = format!("\npass_file:{}", password_spray_template_path.display()); - config_file.write_all(pass_file_config_line.as_bytes()).expect("error writing password spray setting to config file"); - let mut passpray_file = fs::File::create(password_spray_template_path).expect("error creating passwordspray file"); - write!(passpray_file, " -- [ ] useraspass -- [ ] Seasonyear! -- [ ] Service123! -- [ ] admin -- [ ] Admin -- [ ] Admin123! -- [ ] admin123 -- [ ] admin1 -- [ ] 1234567 -- [ ] Seasonyear -- [ ] seasonyear! -- [ ] seasonyear -- [ ] COMPANYYEAR! -- [ ] COMPANYYEAR -- [ ] November2024! -- [ ] September2024! -- [ ] October2024! -- [ ] COMPANYfoundingyear! -- [ ] COMPANYfoundingyear -- [ ] COMPANYstreetnumber! -- [ ] COMPANYstreetnumber -- [ ] Password -- [ ] P@ssw0rd -- [ ] Password1! -- [ ] Password123! -- [ ] Passwordyear! -- [ ] P@55w0rd -- [ ] Service -- [ ] Service! -- [ ] Serviceyear!").expect("error writing password spray template"); - configure_distrobox(); - std::process::exit(0); + else{ + println!("ok free loader"); + } + let fingerprint = get_user_input("will you be using fingerprint authentication for your distroboxes?").to_lowercase(); + let terminal = String::new(); + for desktop in _terminal_commands.keys(){ + println!("{}", desktop); + let desktop_response = get_user_input("do you use any of these desktops?").to_lowercase(); + if desktop_response.contains("y"){ + let default_response = get_user_input("do you use the default terminal for your desktop?").to_lowercase(); + if default_response.contains("y"){ + let de = get_user_input("which desktop do you use?"); + terminal = _terminal_commands[&de]; + } + } + else{ + println!("OK, then please enter the command you'd use to launch a new terminal and run a command inside of it, replacing the command with three !s"); + println!("for example for konsole you'd enter"); + println!("konsole -e !!!"); + terminal = get_user_input(""); + } + } + if terminal.contains("konsole"){ + println!("do you use a specific profile for your attack boxes?"); + println!("this is pretty specific to Pyro's setup, so you probably don't"); + if get_user_input("").to_lowercase().contains("y"){ + let profile_name = get_user_input("what is the name of your profile?"); + terminal = format!("konsole --profile {}", profile_name); + } + } + let configuration_string = format!(" +Project_files:{} +Project_notes:{} +tools_folder:{} +upcoming_files:{} +upcoming_notes:{} +box_template:{} +terminal:{} +cracking_rig:{} +rockyou_location:{} +rule_location:{} +pass_file:{} +fingerprint:{}" +, ¤t_projects.display(), ¤t_notes.display(), &tools.display(), &upcoming_projects.display(), &upcoming_notes.display(), &template_box_name, &terminal, cracking_rig, rockyou, rule, &password_path.display(), fingerprint); + println!("cool everything, all folders and settings have been entered, now let's save this to a config file..."); + let mut config_file_res = File::create_new(config_path); + if config_file_res.is_err(){ + println!("ooof error creating configuration file..."); + println!("try creating it manually."); + println!("copy the following configuration and save it to {}", config_path.display()); + print!("{}\n", configuration_string); + exit(1); + } + let mut config_file = config_file_res.unwrap(); + let config_write_res =write!(config_file, "{}", &configuration_string); + if config_write_res.is_err(){ + println!("error writing configuration string to the configuration file!"); + println!(" try creating it manually."); + println!("copy the following configuration and save it to {}", &configuration_string); + exit(1); + } + config_write_res.unwrap(); + println!("nice the configuration file was written correctly!"); + println!("creating project configuration file, and poplulating it with the default project..."); + let project_conf_res = File::create_new(&projects_conf_path); + if project_conf_res.is_err(){ + println!("ooof error creating the projects configuration file."); + println!("try creating it manually!"); + println!("copy the following configuration and save it to {}", &projects_conf_path.display()); + println!("customer:name:notes:files:active:time:box_name:stage"); + println!("default:default:{}:{}:yes:{}:current", ¤t_notes.display(), ¤t_projects.display(), &template_box_name); + exit(1); + } + let mut project_conf_file = project_conf_res.unwrap(); + let project_write_res = write!(project_conf_file, "customer:name:notes:files:active:time:box_name:stage\ndefault:default:{}:{}:yes:{}:current", ¤t_notes.display(), ¤t_projects.display(), &template_box_name); + if project_write_res.is_err(){ + println!("error writing project config file."); + exit(1); + } + project_write_res.unwrap(); + let password_file_res = File::create_new(password_path); + if password_file_res.is_err(){ + println!("error creating password spray file"); + exit(1); + } + let password_file = password_file_res.unwrap(); + let password_write_res = write!(password_file, " + - [ ] useraspass + - [ ] Seasonyear! + - [ ] Service123! + - [ ] admin + - [ ] Admin + - [ ] Admin123! + - [ ] admin123 + - [ ] admin1 + - [ ] 1234567 + - [ ] Seasonyear + - [ ] seasonyear! + - [ ] seasonyear + - [ ] COMPANYYEAR! + - [ ] COMPANYYEAR + - [ ] November2024! + - [ ] September2024! + - [ ] October2024! + - [ ] COMPANYfoundingyear! + - [ ] COMPANYfoundingyear + - [ ] COMPANYstreetnumber! + - [ ] COMPANYstreetnumber + - [ ] Password + - [ ] P@ssw0rd + - [ ] Password1! + - [ ] Password123! + - [ ] Passwordyear! + - [ ] P@55w0rd + - [ ] Service + - [ ] Service! + - [ ] Serviceyear! + "); + if password_file_res.is_err(){ + println!("error writing password file"); + exit(1); + } + println!("install completed successfully!"); + println!("re-run this to launch!"); } \ No newline at end of file diff --git a/pentest_tool/src/main.rs b/pentest_tool/src/main.rs index 28d8de1..5664c3d 100644 --- a/pentest_tool/src/main.rs +++ b/pentest_tool/src/main.rs @@ -1,6 +1,7 @@ -use std::{io::stdin, path::PathBuf}; +use std::{io::stdin, path::PathBuf, process::Command}; use directories::UserDirs; use reqwest::Response; +use std::process::exit; use std::fs; #[derive(Clone)] @@ -60,8 +61,23 @@ fn main() { ⠀⠀⠀⠀⢿⡉⠳⡟⣸⠃⠀⠀⠀⠘⢷⣌⠉⠀⣿⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ ⠀⠀⠀⠀⠀⠙⢦⣴⠏⠀⠀⠀⠀⠀⠀⠉⠳⠶⠏⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ "); - let user_dirs = UserDirs::new().expect("error getting user directories"); - let mut config_path = user_dirs.home_dir().to_path_buf(); + let mut config_path = PathBuf::new(); + let user_dirs_res = UserDirs::new(); + if user_dirs_res.is_none(){ + println!("oof couldn't get the config directory the right way, falling back to the stpuid way..."); + let get_home_res = Command::new("echo").arg("$HOME").output(); + if get_home_res.is_err(){ + println!("ooof the stupid way didn't work... this is a bruh moment, gotta fix your environment variabls!!!"); + exit(1); + } + let get_home_output = get_home_res.unwrap().stdout; + let home_string = String::from_utf8_lossy(&get_home_output); + config_path.push(home_string.trim()); + } + else{ + let user_dirs = user_dirs_res.unwrap(); + config_path.push(user_dirs.home_dir()); + } config_path.push(".config/pyro_pentest_tool/conf"); if config_path.as_path().exists() == false{ install::install(&config_path);