modified the install to avoid the newlines

in folder names

added hash cracking function, though this doesn't
work yet...

.gitignore

@@ -0,0 +1 @@
+/pentest_tool/target

README.md

@@ -3,6 +3,8 @@ A quick little tool to manage which projects you're on and manage distrobox cont
 
 In order to use this tool you'll want to have distrobox set up and have a "template" box you've created that has all yoru tools installed and what not, you'll likely also want to have a folder full of your other custom tools that you get from git hub, this makes it easier.
 
+The distroboxes it sets up will have the prjoect files folder for the project mounted at /pentest and folder you use for custom tools (like the ones you clone from github) at /tools so getting to your files for the project is as easy as `cd /pentest`!
+
 # General Use case and flow
 I'm not very good at organization. In order to keep track of all the things needed for pentest engagements and keep client data separated from other client data I worte this tool to do it for me. Basically I have a distrobox for each engagement, a folder to keep files related to the engagement, and a separate folder full of my markdown notes for the engagement. An example is below
 
@@ -42,6 +44,12 @@ Current engagements: client1 internal pentest, client 2 internal pentest
         - attack_notes.md
   - upcomming
   - writing
+- tools
+  - bloodhound-linux-x86_64_4.3.1
+  - bofhound
+  - burp_extensions
+  - ek45
+  - etc
 
 This tool automatically creates the file structure, and if you use the start_pentest option populates the markdown note files with the templates I use.  
 

pentest_tool/Cargo.toml

@@ -1,9 +1,14 @@
 [package]
-name = "pentest_tool2"
+name = "pentest_tool"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
 
 [dependencies]
+chrono = "0.4.39"
 clearscreen = "3.0.0"
 directories = "5.0.1"
 fs_extra = "1.3.0"
+futures-io = { version = "0.2.0-beta" }
+reqwest = {version = "0.12.12", features = ["blocking", "json"]}
+rodio = "0.20.1"
+walkdir = "2.5.0"

pentest_tool/src/info_controls.rs

@@ -1,8 +1,20 @@
+use core::hash;
 use std::fs;
 use std::fs::read_to_string;
+use std::io::BufReader;
+use std::io::Read;
 use std::io::Write;
 use std::path::PathBuf;
 use std::process;
+use std::result;
+use std::thread;
+use std::thread::spawn;
+use std::time::Duration;
+use std::io::stdin;
+use walkdir::WalkDir;
+use clearscreen::clear;
+use clearscreen;
+use rodio::{Decoder, OutputStream, Sink};
 use crate::Project;
 
 pub fn run_initial_enum(project: &Project){
@@ -143,4 +155,434 @@ pub fn print_report_information(project: Project){
         }
     }
     
+}
+
+
+pub fn build_cs_portscan_cmd(project: &Project){
+    let mut general_note_path = project.notes_folder.clone();
+    general_note_path.push("general.md");
+    println!("Reading from: {}", general_note_path.display());
+    let mut ranges = Vec::new();
+    let general_note_string = read_to_string(general_note_path);
+    let mut _note_string = String::new();
+   match general_note_string{
+        Err(error) => {println!("error reading file to string!! {}", error); return;},
+        _=> _note_string = general_note_string.unwrap()
+    }
+    let lines: Vec<&str> = _note_string.split("\n").collect();
+    for line in lines{
+       if line.contains("|"){
+            if line.contains("."){
+                let ip = line.split("|").collect::<Vec<&str>>()[1];
+                if ip.contains(","){
+                    let ips: Vec<&str> = ip.split(",").collect();
+                    for ip in ips{
+                        ranges.push(ip.trim_end().trim_start());
+                    }
+                } 
+                else{
+                    ranges.push(ip.trim_end().trim_start());
+                }
+            }
+        }
+    }
+    let portscan_cmd = "portscan !!! 1-1024,1433,2222,3306,3389,5000-6000,8000,8080,8443 icmp 512";
+    let mut _range_command = String::new();
+    let combined_ranges = ranges.join(",");
+    let final_command = portscan_cmd.replace("!!!", &combined_ranges);
+    println!("{}", final_command);
+}
+
+fn find_file(dir: &PathBuf, file_name: &str) -> Option<String>{
+    for entry in WalkDir::new(dir){
+        let entry = entry.unwrap();
+        let path = entry.path();
+        if path.is_file() && path.file_name().unwrap() == file_name{
+            return Some(path.to_str().unwrap().to_string());
+        }
+    }
+    return None;
+}
+
+fn nefarious_config(tools_dir: &PathBuf) -> String{
+    let nefarious_spray_path = find_file(tools_dir, "obf-NefariousSpray.exe");
+    let mut outline = String::new();
+    let mut exemethod = String::new();
+    loop {
+        println!("how do you need to run it?");
+        print!("
+        1.) execut-assembly
+        2.) inlineExecute-assembly
+        3.) from disk with cobalt strike
+        4.) from disk without cobalt strike
+        ");
+        let exemethod_result = stdin().read_line(&mut exemethod);
+        if exemethod_result.is_err(){
+            println!("we need input here dummy!");
+        }
+        else{
+            match exemethod.as_str(){
+                "1\n" => outline = format!("execute-assembly {} spray -p ||PASSWORD|| -o C:\\temp\\fr\\||PASSWORD||.txt", nefarious_spray_path.map_or("".to_string(), |s| s)),
+                "2\n" => outline = format!("inlineExecute-Assembly --dotnetassembly {} --assemblyargs spray -p ||PASSWORD|| -o C:\\temp\\fr\\||PASSWORD||.txt --etw --amsi --pipe totallyawesomepipeyo", nefarious_spray_path.map_or("".to_string(), |s| s)),
+                "3\n" => outline = {let mut path = String::new(); println!("path to nefarious spray.exe"); stdin().read_line(&mut path).unwrap(); format!("run {} spray -p ||PASSWORD|| -o C:\\temp\\fr\\||PASSWORD||.txt", path.trim_ascii_end())},
+                "4\n" => outline = {let mut path = String::new(); println!("path to nefarious spray.exe"); stdin().read_line(&mut path).unwrap(); format!("{} spray -p ||PASSWORD|| -o C:\\temp\\fr\\||PASSWORD||.txt", path.trim_ascii_end())},
+                _ => println!("unknown exec method... try again")
+            }
+            return outline;
+        }
+    }
+}
+
+fn msolspray_config(tools_dir: &PathBuf) -> String{
+    let mut msolspray_path = String::new();
+    let mut outline = String::new();
+    let mut userlist = String::new();
+    let mut spray_target = String::new();
+    loop{
+        println!("path to your users list?");
+        let result = stdin().read_line(&mut userlist);
+        if result.is_err(){
+            println!("we need input here dummy!");
+        }
+        else{
+            break;
+        }
+    }
+    loop{
+        println!("target URL (probably a fireprox url)");
+        let result = stdin().read_line(&mut spray_target);
+        if result.is_err(){
+            println!("we need input here dummy!");
+        }
+        else{
+            break;
+        }
+    }
+    loop {
+        let mut response = String::new();
+        println!("is MSOLSpray.py in your path? (for example installed via pipx or pip)");
+        let path_result = stdin().read_line(&mut response);
+        if path_result.is_err(){
+            println!("we need input here dummy!!");
+        }
+        else{
+            response = response.to_lowercase();
+            if response.contains("y"){
+                msolspray_path = "MSOLSpray".to_owned();
+            }
+            else if response.contains("n"){
+                println!("trying to automatically find msolspray.py in your tools folder...");
+                let find_result = find_file(tools_dir, "MSOLSpray.py");
+                if find_result.is_some(){
+                    msolspray_path = find_result.unwrap();
+                    loop {
+                        let mut response = String::new();
+                        println!("Found it! located at {}", msolspray_path);
+                        println!("is that correct?");
+                        let result = stdin().read_line(&mut response);
+                        if result.is_err(){
+                            println!("we need input here bruv, try again...");
+                            continue;
+                        }
+                        response = response.to_lowercase();
+                        if response.contains("n"){
+                            loop{
+                                msolspray_path = "".to_owned();
+                                println!("ok, so where is msolspray.py then?");
+                                let result = stdin().read_line(&mut msolspray_path);
+                                if result.is_err(){
+                                    println!("we need input here burv...");
+                                    continue;
+                                }
+                                else{
+                                    break;
+                                }
+                            }
+                        }
+                        msolspray_path = format!("python {}", msolspray_path);
+                        break;
+                    }
+                }
+                else {
+                    loop {
+                        println!("OOOOF we didn't find it burh... where is MSOLSpray.py located?");
+                        match stdin().read_line(&mut msolspray_path){
+                            Ok(_response) => break,
+                            Err(_e) => println!("we need input here bruv... try again")
+                        }
+                    }
+                }
+            }
+        }
+        break;
+    }
+    outline = format!("{} {} -p ||PASSWORD|| --url {}", msolspray_path.trim_end(), userlist.trim_end(), spray_target.trim_end());
+    return outline;
+}
+
+pub fn password_spray_help(project: &Project, season: String, lseason: String, year: i32, tools_dir: &PathBuf, config_path: &PathBuf){
+    let mut wait_time:u64 = 0;
+    let mut wait_time_response = String::new();
+    let mut bell_path = config_path.clone();
+    bell_path.pop();
+    bell_path.push("bell.mp3");
+    let mut tool_to_use = String::new();
+    loop {
+        println!("which tool?");
+        print!("
+        1.) nefarious spray
+        2.) msolspray.py
+        ");
+        let exemethod_result = stdin().read_line(&mut tool_to_use);
+        if exemethod_result.is_err(){
+            println!("we need input here dummy!");
+        }
+        else{
+            break
+        }
+    }
+    loop {
+        println!("Observation window in minutes?");
+        match stdin().read_line(&mut wait_time_response){
+            Ok(_response) => {{
+                                    let trimmed = wait_time_response.trim_end();
+                                    let time_parse_reslut = trimmed.parse::<u64>();
+                                    if time_parse_reslut.is_err(){
+                                        println!("error parsing wait time into u64!");
+                                        break;
+                                    }
+                                    else{
+                                        wait_time = time_parse_reslut.unwrap();
+                                        break;
+                                    }
+                                    }},
+            Err(_e) => println!("we need you to put in the minutes for the obervation window please!")
+        }
+    }
+    let wait_dur = Duration::from_secs(wait_time);    
+    let mut password_spray_file = project.notes_folder.clone();
+    password_spray_file.push("password_spray.md");
+    println!("{}", password_spray_file.display());
+    let mut password_spray_string = String::new();
+    let password_spray_read_result = fs::read_to_string(&password_spray_file);
+    if password_spray_read_result.is_err(){
+        println!("error reading password spray file!!!");
+        return;
+    }
+    else{
+        password_spray_string = password_spray_read_result.unwrap();
+    }
+    let mut passwords = Vec::new();
+    let mut sprayed_passwords = Vec::new();
+    println!("loading lines to parse...");
+    for line in password_spray_string.split("\n"){
+        if line.len() > 3{
+            if !line.contains("[x]"){
+                println!("parsing {} ...", line);
+                let words: Vec<&str> = line.split_whitespace().collect();
+                let mut password = words.last().unwrap().to_string();
+                if password.contains("year"){
+                    password = password.replace("year", year.to_string().as_str());
+                }
+                if password.contains("Season"){            
+                    let seasonpassword = password.replace("Season", &season);
+                    passwords.push(seasonpassword);
+                    let lseasonpassword = password.replace("Season", &lseason);
+                    passwords.push(lseasonpassword);
+                }
+                if password.contains("season"){
+                    let seasonpassword = password.replace("season", &season.to_lowercase());
+                    passwords.push(seasonpassword);
+                    let lseasonpassword = password.replace("season", &lseason.to_lowercase());
+                    passwords.push(lseasonpassword);
+                }
+                passwords.push(password);
+            }
+            else{
+                let words: Vec<&str> = line.split_whitespace().collect();
+                let password = words.last().unwrap().to_string();
+                println!("{} already sprayed, making note...", &password);
+                sprayed_passwords.push(password);
+            }
+        }
+    }
+    println!("passwords loaded, and parsed!");
+    println!("starting password display and timer operations...");
+    let mut outline = String::new();
+    match tool_to_use.as_str(){
+        "1\n" => outline = nefarious_config(tools_dir),
+        "2\n" => outline = msolspray_config(tools_dir),
+        _ => println!("unkown tool to use, try again...")
+    } 
+    for password in &passwords{
+        let mut _spraycontinue = String::new();
+        let mut printline = outline.replace("||PASSWORD||", password);
+        if password.contains("useraspass"){
+            printline = printline.replace("-p useraspass", "--UserAsPass")
+        }
+        println!("\n{}\n", printline);
+        println!("enter s to save an return to main menu, or just enter to start timer");
+        stdin().read_line(&mut _spraycontinue).unwrap();
+        sprayed_passwords.push(password.to_owned());
+        if _spraycontinue.contains("s"){
+            let new_spray_file = fs::OpenOptions::new().write(true).truncate(true).open(&password_spray_file);
+            if new_spray_file.is_err(){
+                println!("error saving progress, please make note of where you are and update the file accordingly");
+            }
+            else{
+                let mut open_spray_file  = new_spray_file.unwrap();
+                let mut new_file_text = String::new();
+                for sprayed_pass in &sprayed_passwords{
+                    new_file_text = format!("{}\n- [x] {}", new_file_text, sprayed_pass);
+                }
+                for password in &passwords{
+                    if sprayed_passwords.contains(password) == false{
+                        new_file_text = format!("{}\n- [ ] {}", new_file_text, password);
+                    }
+                }
+                let save_result = open_spray_file.write_all(new_file_text.as_bytes());
+                if save_result.is_err(){
+                    println!("saving failed!\nplease copy the below lines into your password spray notes!");
+                    println!("{}", new_file_text);
+                }
+                else{
+                    println!("password saved complete!!!");
+                    println!("returning to main menu...");
+                    return;
+                }
+            }   
+        }
+        println!("waiting for {} minutes...", wait_dur.as_secs());
+        thread::sleep(wait_dur * 60);
+        let (_stream, stream_handle) = OutputStream::try_default().unwrap();
+        let sink = Sink::try_new(&stream_handle).unwrap();
+        let bell_file = fs::File::open(&bell_path).unwrap();
+        let source = Decoder::new(BufReader::new(bell_file)).unwrap();
+        sink.append(source);
+        sink.sleep_until_end();
+        clear().unwrap();
+    }
+}
+
+pub fn crack_hashes(cracking_rig: &String, project: &Project, terminal: &String, rockyou: &String, rule: &String){
+    let mut hash_file = String::new();
+    println!("trying to automatically find hashes.txt file...");
+    let find_result = find_file(&project.files_folder, "hashes.txt");
+    if find_result.is_some(){
+        hash_file = find_result.unwrap();
+        println!("hash file found!");
+        let mut res = String::new();
+        println!("is {} the file you want to crack?", hash_file);
+        match stdin().read_line(&mut res){
+            Ok(_r) => (),
+            Err(_e) => {println!("we need input here dummy! returning..."); return;}
+        }
+        res = res.to_lowercase();
+        if res.contains("n"){
+            println!("ooof ok, where is the file you want then?");
+            loop{
+                match stdin().read_line(&mut hash_file){
+                    Ok(_r) => break,
+                    Err(_e) => println!("we need input here dummy! try again...")
+                }
+            }
+        }
+        if res.contains("y"){
+            println!("nice! checking for cracking directory...");
+            let listing_res = process::Command::new("ssh").arg(&cracking_rig).arg("'ls ~'").output();
+            if listing_res.is_err(){
+                println!("Error checking for cracking directory!");
+                println!("Error: {}", listing_res.unwrap_err());
+            }
+            else{
+                let listing_stdout = listing_res.unwrap().stdout;
+                let listing = String::from_utf8_lossy(&listing_stdout);
+                if listing.contains("hash_cracking") == false{
+                    println!("no folder found, creating it...");
+                    let mkdir = process::Command::new("ssh").arg(&cracking_rig).arg("'mkdir ~/hash_cracking'").status();
+                    if mkdir.is_err(){
+                        println!("error creating directory! try again...");
+                        println!("Error: {}", mkdir.unwrap_err());
+                        return;
+                    }
+                }
+                let scp_arg = format!("'scp {} {}:~/hash_cracking/{}'", &hash_file, cracking_rig, &hash_file);
+                let scp_res = process::Command::new("ssh").arg(&cracking_rig).arg(scp_arg).status();
+                if scp_res.is_err(){
+                    println!("error uploading hashes file!");
+                    println!("Error: {}", scp_res.unwrap_err());
+                    return;
+                }
+                println!("nice, hach file uploaded! determining correct terminal command...");
+                let terminal = terminal.split(" ").collect::<Vec<&str>>()[0];
+                process::Command::new(terminal).arg("-e").arg("ssh").arg(&cracking_rig);
+                let mut hash_type_res = String::new();
+                let mut cracking_arg = String::new();
+                let mut crack_box = String::new();
+                let mut crack_box_res = String::new();
+                println!("do you use a distrobox to crack passwords?");
+                loop{
+                    match stdin().read_line(&mut crack_box_res){
+                        Ok(_r) => break,
+                        Err(_e) => println!("we need input here dummy, try again")
+                    }
+                }
+                crack_box_res = crack_box_res.to_lowercase();
+                if crack_box_res.contains("y"){
+                    println!("What's the distrobox's name?");
+                    loop{
+                        match stdin().read_line(&mut crack_box){
+                            Ok(_r) => break,
+                            Err(_e) => println!("we need input here dummy, try again!")
+                        }
+                    }    
+                }
+                else{
+                    crack_box = "no".to_owned();
+                }
+
+                if crack_box == "no".to_owned(){
+                    cracking_arg = format!("sudo hashcat -m ||MODE|| -a 0 -r {} /home/{}/hash_cracking/{} {}", rule, cracking_rig.split("@").collect::<Vec<&str>>()[1], &hash_file, &rockyou);
+                }
+                else{
+                    cracking_arg = format!("distrobox enter --root {} -- sudo -S hashcat -m ||MODE|| -a 0 -r {} /home/{}/hash_cracking/{} {}", crack_box, rule, cracking_rig.split("@").collect::<Vec<&str>>()[1], &hash_file, &rockyou);
+                }
+                    loop{
+                        println!("Hash type?");
+                            print!("
+                            1.) kerberos
+                            2.) ntlm
+                            3.) other
+                            ");
+                            let _res = stdin().read_line(&mut hash_type_res);
+                            if _res.is_err(){
+                                println!("we need input here dummy! try again...");
+                            }
+                    else{
+                        match hash_type_res.as_str(){
+                            "1\n" => {cracking_arg = cracking_arg.replace("||MODE||", "19700"); break;},
+                            "2\n" => {cracking_arg = cracking_arg.replace("||MODE||", "1000"); break;},
+                            "3\n" => {let mut mode = String::new();
+                                        println!("code for the mode you want to use?");
+                                        loop{
+                                            match stdin().read_line(&mut mode){
+                                                Ok(_r) => break,
+                                                Err(_e) => println!("we need input here dummy, try again...")
+                                            }
+                                        }
+                                      cracking_arg = cracking_arg.replace("||MODE||", &mode);
+                                      break; 
+                                     },
+                            _ => println!("unknown selection... try again...")
+                        }
+                    }
+                }
+                let spaw_res = process::Command::new(terminal).arg("-e").arg("ssh").arg(&cracking_rig).arg(cracking_arg).spawn();
+                if spaw_res.is_err(){
+                    println!("error spawing new terminal to ssh with!");
+                    println!("ERROR: {}", spaw_res.unwrap_err());
+                }
+            }
+        }
+    }
 }

pentest_tool/src/install.rs

@@ -1,8 +1,167 @@
 use std::collections::HashMap;
 use std::fs;
+use std::fs::File;
+use std::io::Read;
 use std::io::Write;
+use std::io::stdin;
+use std::io::copy;
+use reqwest::blocking::get;
 use std::path::PathBuf;
 use std::process;
+use std::process::exit;
+
+
+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();
+            }
+        }
+    }
+    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);
+    let new_notes_path = PathBuf::from(&new_notes_folder);
+    let upcomming_files_path = PathBuf::from(&upcomming_files_folder);
+    let upcomming_notes_path = PathBuf::from(&upcomming_notes_folder);
+    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);
+}
 
 
 
@@ -16,16 +175,21 @@ pub fn install(config_path: &PathBuf){
     let mut config_folder_path: PathBuf = config_path.clone();
     config_folder_path.pop();
     let mut projects_conf_path = config_folder_path.clone();
+    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");
+    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();
+    let response_length = response.content_length().unwrap_or(0);
+    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\n").expect("error writing default project info");
     let mut terminal_response = String::new();
-    let mut notes_response = String::new();
-    let mut files_response = String::new();
-    let mut tools_response = String::new();
     let mut template_name = String::new();
     let mut have_template = String::new();
     println!("terminal you use? (example: konsole, xfce, gnome, etc)");
@@ -46,12 +210,7 @@ pub fn install(config_path: &PathBuf){
     else{
         _terminal_command = _terminal_commands[terminal_response.trim_end()].to_owned();
     }
-    println!("path to save project notes?");
+    let (files_response, notes_response, tools_response, project_folder_path, project_note_path, cracking_rig, cracking_user, rockyou, rule) = setup_folders(&config_path);
-    std::io::stdin().read_line(&mut notes_response).unwrap();
-    println!("path to save project files?");
-    std::io::stdin().read_line(&mut files_response).unwrap();
-    println!("path to folder with your custom tools?");
-    std::io::stdin().read_line(&mut tools_response).unwrap();
     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.
@@ -70,12 +229,18 @@ Do you have a distrobox set up to function as your template for all new projects
     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 config_string = format!("Project_files:{}\nProject_notes:{}\ntools_folder:{}\nterminal:{}", files_response.trim_end(), notes_response.trim_end(), tools_response.trim_end(), _terminal_command.trim_end());
+    let config_string = format!("Project_files:{}\nProject_notes:{}\ntools_folder:{}\nbox_template:{}\nterminal:{}\ncracking_rig:{}@{}\nrockyou_location:{}\nrule_location:{}", files_response.trim_end(), notes_response.trim_end(), tools_response.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());
     config_file.write_all(config_string.as_bytes()).expect("error writing to config file");
     let default_projectline = format!("default:default:{}:{}:yes:{}", &notes_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: {}", &notes_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());
-    println!("please rerun the program");
     
 
     let config_path = &config_folder_path.clone();
@@ -84,16 +249,6 @@ Do you have a distrobox set up to function as your template for all new projects
     install_path.push("new_projects.conf");
     password_spray_template_path.push("passwordspray.md");
     let password_spray_template_path = install_path.clone();
-    let mut conf_file = fs::File::create(install_path).expect("error creating config file");
-    let mut project_folder_path = String::new();
-    let mut porject_note_path = String::new();
-    println!("path to the project folders directory?");
-    std::io::stdin().read_line(&mut project_folder_path).expect("error reading project folder from stdin");
-    println!("path to the project notes directory");
-    std::io::stdin().read_line(&mut porject_note_path).expect("error reading project note folder form stdin");
-    write!(conf_file, "project_folder_path:{}
-project_notes_path:{}
-", project_folder_path.trim_end(), porject_note_path.trim_end()).expect("error writing config file");
     let mut passpray_file =  fs::File::create(password_spray_template_path).expect("error creating passwordspray file");
     write!(passpray_file, "
 - [ ] useraspass

pentest_tool/src/main.rs

@@ -53,6 +53,9 @@ fn main() {
     let mut tools_folder = PathBuf::new();
     let mut terminal_command = String::new();
     let mut box_template = String::new();
+    let mut cracking_rig = String::new();
+    let mut rockyou = String::new();
+    let mut rule = String::new();
     println!("\nconfig already generated\nloading config file...\n");
     let settings_string = fs::read_to_string(&config_path).expect("error reading config file");
     let settings: Vec<&str> = settings_string.split("\n").collect();
@@ -65,6 +68,9 @@ fn main() {
                 "tools_folder" => tools_folder.push(setting_vec[1].trim_end()),
                 "box_template" => box_template = setting_vec[1].trim_end().to_owned(),
                 "terminal" => terminal_command = setting_vec[1].trim_end().to_owned(),
+                "cracking_rig" => cracking_rig = setting_vec[1].trim_end().to_owned(),
+                "rockyou_location" => rockyou = setting_vec[1].trim_ascii_end().to_owned(),
+                "rule_location" => rule = setting_vec[1].trim_end().to_owned(),
                 _ => println!("error unknown setting: {}", setting_vec[0])
             }
         }
@@ -74,12 +80,13 @@ fn main() {
     Note Folders: {}
     Tools Folder: {}
     distrobox template: {}
-    terminal_command: {}\n
+    terminal_command: {}
-", project_base_folder.display(), project_base_notes.display(), tools_folder.display(), box_template, terminal_command);
+    cracking_rig: {}\n
+", project_base_folder.display(), project_base_notes.display(), tools_folder.display(), box_template, terminal_command, cracking_rig);
     println!("loading project configs...");
     let projects = project_controls::get_projects(&config_path);
     println!("Enter to start main menu");
     let mut enter = String::new();
     std::io::stdin().read_line(&mut enter).unwrap();
-    menu::main_menu(projects, config_path, &project_base_folder, &project_base_notes, &tools_folder, box_template, terminal_command);
+    menu::main_menu(projects, config_path, &project_base_folder, &project_base_notes, &tools_folder, box_template, terminal_command, cracking_rig, rockyou, rule);
 }

pentest_tool/src/menu.rs

@@ -1,6 +1,9 @@
 use std::path::PathBuf;
+use std::process::exit;
+use chrono::Datelike;
 use clearscreen::clear;
 use clearscreen;
+use chrono::Local;
 use crate::Project;
 use crate::project_controls;
 use crate::box_controls;
@@ -28,12 +31,24 @@ fn get_active_project(projects: &Vec<Project>) -> &Project{
     return active_project
 }
 
-pub fn main_menu(mut projects: Vec<Project>, config_path: PathBuf, base_files: &PathBuf, base_notes: &PathBuf, tools_dir: &PathBuf, boxtemplate: String, terminal: String){
+pub fn main_menu(mut projects: Vec<Project>, config_path: PathBuf, base_files: &PathBuf, base_notes: &PathBuf, tools_dir: &PathBuf, boxtemplate: String, terminal: String, cracking_rig: String, rockyou: String, rule: String){
     let mut loopize = true;
     let mut new_id = next_project_id(&config_path);
     loop {
         let active_project = get_active_project(&projects);
         let mut response = String::new();
+        let now = Local::now();
+        let month = now.month();
+        let year = now.year();
+        let mut season = String::new();
+        let mut lseason = String::new();
+        match month{
+            12 | 01 | 02 => {season = "Winter".to_owned(); lseason = "Fall".to_owned()},
+            03 | 04 | 05 => {season = "Spring".to_owned(); lseason = "Winter".to_owned()},
+            06 | 07 | 08 => {season = "Summer".to_owned(); lseason = "Spring".to_owned()},
+            09 | 10 | 11 => {season = "Fall".to_owned(); lseason = "Summer".to_owned()},
+            _ => {println!("error getting season! Check code..."); exit(1)}
+        }
         clear().expect("error clearing screen");
         print!("
 ,,,;;::ccccc::;;;::c::;,;::cccccllc::::::;:::;;;;,,;,'',,;,,;;;;;;;:;;;;;,,,,,,,,,,,'''''',,,,,,''''
@@ -82,10 +97,15 @@ pub fn main_menu(mut projects: Vec<Project>, config_path: PathBuf, base_files: &
     
 
 
-NOTE SAVE PROJECT INFO BEFORE STOPPING THE APPLICATION, OR HOUR TRACKIGN WON'T BE ACCURATE
+NOTE OPTION 18 WILL SAVE YOUR PROJECTS BEFORE QUITTING
-NOTE OPTION 10 WILL SAVE YOUR PROJECTS BEFORE QUITTING
 
 Current Project: {} {}
+Working Folder: {}
+Notes Folder: {}
+Box Name: {}
+Terminal Command: {}
+Current Season: {}
+Year: {}
 
         Main Menu:
             1 .) Show Active Project
@@ -103,9 +123,12 @@ Current Project: {} {}
             13.) run pyro's initail enum script on a nessus csv for the current project
             14.) Print Project Info For Report
             15.) Build host discovery cmd command from scope in notes
-            16.) Stop All Distroboxes
+            16.) build portscan command from scope in notes
-            17.) Quit Application
+            17.) Stop All Distroboxes
-\n", active_project.customer, active_project.project_name);
+            18.) Password Spray (will print password to spray, and wait the obervation window time)
+            19.) crack password hashes on your cracking rig
+            20.) Quit Application
+\n", active_project.customer, active_project.project_name, active_project.files_folder.display(), active_project.notes_folder.display(), active_project.boxname, terminal, season, year);
         std::io::stdin().read_line(&mut response).expect("error getting menu input");
         clear().expect("error clearing screen");
         match response.as_str().trim_end(){
@@ -127,8 +150,11 @@ Current Project: {} {}
             "13" => info_controls::run_initial_enum(&active_project),
             "14" =>info_controls::print_report_information(active_project.clone()),
             "15" => info_controls::build_cmd_for_host_discovery(&active_project),
-            "16" => box_controls::stop_all_boxes(&projects),
+            "16" => info_controls::build_cs_portscan_cmd(&active_project),
-            "17" => {project_controls::save_projects(&projects, &config_path);
+            "17" => box_controls::stop_all_boxes(&projects),
+            "18" => info_controls::password_spray_help(&active_project, season, lseason, year, &tools_dir, &config_path),
+            "19" => info_controls::crack_hashes(&cracking_rig, &active_project, &terminal, &rockyou, &rule),
+            "20" => {project_controls::save_projects(&projects, &config_path);
                     let mut stop = String::new(); 
                     println!("stop all boxes?\ny/n");
                     std::io::stdin().read_line(&mut stop).unwrap();

pentest_tool/src/project_controls.rs

@@ -72,8 +72,6 @@ pub fn new_project(projects: &mut Vec<Project>, project_dir: &PathBuf, notes_dir
     let mut project_name = String::new();
     println!("do you have an existing notes and folder structure to copy over?\ny/n");
     std::io::stdin().read_line(&mut existing_folders).unwrap();
-    let mut customer_name = customer_name.trim_end().to_owned();
-    let mut project_name = project_name.trim_end().to_owned();
     if existing_folders.contains("y") || existing_folders.contains("Y"){
         println!("NOTE THIS WILL OVERWRITE CUSTOMER NAME AND PROJECT NAME WITH THE 2nd TO LAST AND LAST FOLDER NAMES IN THE PATH YOU'RE COPYING RESPECTIVELY");
         let mut files_to_copy = String::new();

pentest_tool/src/start_pentest.rs

@@ -266,12 +266,18 @@ pub fn start_pentest(config_path: &PathBuf) {
     }
     println!("Project files path: {}\nProject Notes path: {}", project_files, pentest_notes);
     println!("Comapny Name?");
-    std::io::stdin().read_line(&mut company_name);
+    match std::io::stdin().read_line(&mut company_name){
+        Ok(_result) => (),
+        Err(_e) => {println!("we need input here dummy!"); return;}
+    }
     println!("project Name?");
-    stdin().read_line(&mut project_name);
+    match stdin().read_line(&mut project_name){
+        Ok(_result) => (),
+        Err(_e) => {println!("we need input here dummy!"); return;}
+    }
     //remove new lines from input
-    company_name.trim_end();
+    company_name = company_name.trim_end().to_owned();
-    project_name.trim_end();
+    project_name = project_name.trim_end().to_owned();
     let project_folder_path = format!("{}/{}/{}", pentest_notes, company_name,project_name);
     println!("setting folder creation paths...");
     let project_files_folder_path = format!("{}/{}/{}", project_files, company_name, project_name);

pentest_tool/target/.rustc_info.json

@@ -1 +0,0 @@
-{"rustc_fingerprint":1960306743998270933,"outputs":{"14371922958718593042":{"success":true,"status":"","code":0,"stdout":"___\nlib___.rlib\nlib___.so\nlib___.so\nlib___.a\nlib___.so\n/home/pyro/.rustup/toolchains/stable-x86_64-unknown-linux-gnu\noff\npacked\nunpacked\n___\ndebug_assertions\npanic=\"unwind\"\nproc_macro\ntarget_abi=\"\"\ntarget_arch=\"x86_64\"\ntarget_endian=\"little\"\ntarget_env=\"gnu\"\ntarget_family=\"unix\"\ntarget_feature=\"fxsr\"\ntarget_feature=\"sse\"\ntarget_feature=\"sse2\"\ntarget_has_atomic=\"16\"\ntarget_has_atomic=\"32\"\ntarget_has_atomic=\"64\"\ntarget_has_atomic=\"8\"\ntarget_has_atomic=\"ptr\"\ntarget_os=\"linux\"\ntarget_pointer_width=\"64\"\ntarget_vendor=\"unknown\"\nunix\n","stderr":""},"15729799797837862367":{"success":true,"status":"","code":0,"stdout":"___\nlib___.rlib\nlib___.so\nlib___.so\nlib___.a\nlib___.so\n/home/pyro/.rustup/toolchains/stable-x86_64-unknown-linux-gnu\noff\npacked\nunpacked\n___\ndebug_assertions\nfmt_debug=\"full\"\noverflow_checks\npanic=\"unwind\"\nproc_macro\nrelocation_model=\"pic\"\ntarget_abi=\"\"\ntarget_arch=\"x86_64\"\ntarget_endian=\"little\"\ntarget_env=\"gnu\"\ntarget_family=\"unix\"\ntarget_feature=\"fxsr\"\ntarget_feature=\"sse\"\ntarget_feature=\"sse2\"\ntarget_has_atomic\ntarget_has_atomic=\"16\"\ntarget_has_atomic=\"32\"\ntarget_has_atomic=\"64\"\ntarget_has_atomic=\"8\"\ntarget_has_atomic=\"ptr\"\ntarget_has_atomic_equal_alignment=\"16\"\ntarget_has_atomic_equal_alignment=\"32\"\ntarget_has_atomic_equal_alignment=\"64\"\ntarget_has_atomic_equal_alignment=\"8\"\ntarget_has_atomic_equal_alignment=\"ptr\"\ntarget_has_atomic_load_store\ntarget_has_atomic_load_store=\"16\"\ntarget_has_atomic_load_store=\"32\"\ntarget_has_atomic_load_store=\"64\"\ntarget_has_atomic_load_store=\"8\"\ntarget_has_atomic_load_store=\"ptr\"\ntarget_os=\"linux\"\ntarget_pointer_width=\"64\"\ntarget_thread_local\ntarget_vendor=\"unknown\"\nub_checks\nunix\n","stderr":""},"4614504638168534921":{"success":true,"status":"","code":0,"stdout":"rustc 1.83.0 (90b35a623 2024-11-26)\nbinary: rustc\ncommit-hash: 90b35a6239c3d8bdabc530a6a0816f7ff89a0aaf\ncommit-date: 2024-11-26\nhost: x86_64-unknown-linux-gnu\nrelease: 1.83.0\nLLVM version: 19.1.1\n","stderr":""}},"successes":{}}

pentest_tool/target/CACHEDIR.TAG

@@ -1,3 +0,0 @@
-Signature: 8a477f597d28d172789f06886806bc55
-# This file is a cache directory tag created by cargo.
-# For information about cache directory tags see https://bford.info/cachedir/

pentest_tool/target/debug/.fingerprint/bitflags-579c065d70004b46/invoked.timestamp

@@ -1 +0,0 @@
-This file has an mtime of when this was started.

pentest_tool/target/debug/.fingerprint/bitflags-579c065d70004b46/lib-bitflags

@@ -1 +0,0 @@
-100f34741f77911f

pentest_tool/target/debug/.fingerprint/bitflags-579c065d70004b46/lib-bitflags.json

@@ -1 +0,0 @@
-{"rustc":11594289678289209806,"features":"[\"std\"]","declared_features":"[\"arbitrary\", \"bytemuck\", \"compiler_builtins\", \"core\", \"example_generated\", \"rustc-dep-of-std\", \"serde\", \"std\"]","target":14463131919016566876,"profile":10243973527296709326,"path":16748284277583444831,"deps":[],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/bitflags-579c065d70004b46/dep-lib-bitflags","checksum":false}}],"rustflags":[],"metadata":14564035643000669268,"config":2202906307356721367,"compile_kind":0}

pentest_tool/target/debug/.fingerprint/bitflags-778b466868486432/invoked.timestamp

@@ -1 +0,0 @@
-This file has an mtime of when this was started.

pentest_tool/target/debug/.fingerprint/bitflags-778b466868486432/lib-bitflags

@@ -1 +0,0 @@
-05e6a2536daa107a

pentest_tool/target/debug/.fingerprint/bitflags-778b466868486432/lib-bitflags.json

@@ -1 +0,0 @@
-{"rustc":11594289678289209806,"features":"[\"std\"]","declared_features":"[\"arbitrary\", \"bytemuck\", \"compiler_builtins\", \"core\", \"example_generated\", \"rustc-dep-of-std\", \"serde\", \"std\"]","target":14463131919016566876,"profile":10243973527296709326,"path":9228158316637899548,"deps":[],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/bitflags-778b466868486432/dep-lib-bitflags","checksum":false}}],"rustflags":[],"metadata":14564035643000669268,"config":2202906307356721367,"compile_kind":0}

pentest_tool/target/debug/.fingerprint/bitflags-796ee5e059da5bcc/invoked.timestamp

@@ -1 +0,0 @@
-This file has an mtime of when this was started.

pentest_tool/target/debug/.fingerprint/bitflags-796ee5e059da5bcc/lib-bitflags

@@ -1 +0,0 @@
-388f42111244902a

pentest_tool/target/debug/.fingerprint/bitflags-796ee5e059da5bcc/lib-bitflags.json

@@ -1 +0,0 @@
-{"rustc":11594289678289209806,"features":"[\"default\"]","declared_features":"[\"compiler_builtins\", \"core\", \"default\", \"example_generated\", \"rustc-dep-of-std\"]","target":202096439108023897,"profile":10243973527296709326,"path":3297157276231387091,"deps":[],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/bitflags-796ee5e059da5bcc/dep-lib-bitflags","checksum":false}}],"rustflags":[],"metadata":14564035643000669268,"config":2202906307356721367,"compile_kind":0}

pentest_tool/target/debug/.fingerprint/bitflags-d96cb1cfd8335477/invoked.timestamp

@@ -1 +0,0 @@
-This file has an mtime of when this was started.

pentest_tool/target/debug/.fingerprint/bitflags-d96cb1cfd8335477/lib-bitflags

@@ -1 +0,0 @@
-5fe6a3fa88c3c6bc

pentest_tool/target/debug/.fingerprint/bitflags-d96cb1cfd8335477/lib-bitflags.json

@@ -1 +0,0 @@
-{"rustc":18217185010275080438,"features":"[\"std\"]","declared_features":"","target":14463131919016566876,"profile":10243973527296709326,"path":96659009738692421,"deps":[],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/bitflags-d96cb1cfd8335477/dep-lib-bitflags"}}],"rustflags":[],"metadata":14564035643000669268,"config":2202906307356721367,"compile_kind":0}

pentest_tool/target/debug/.fingerprint/bitflags-f1b2eea508d06d09/invoked.timestamp

@@ -1 +0,0 @@
-This file has an mtime of when this was started.

pentest_tool/target/debug/.fingerprint/bitflags-f1b2eea508d06d09/lib-bitflags

@@ -1 +0,0 @@
-ad00dafc4fb5db47

pentest_tool/target/debug/.fingerprint/bitflags-f1b2eea508d06d09/lib-bitflags.json

@@ -1 +0,0 @@
-{"rustc":18217185010275080438,"features":"[\"default\"]","declared_features":"","target":202096439108023897,"profile":10243973527296709326,"path":4706328860019254468,"deps":[],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/bitflags-f1b2eea508d06d09/dep-lib-bitflags"}}],"rustflags":[],"metadata":14564035643000669268,"config":2202906307356721367,"compile_kind":0}

pentest_tool/target/debug/.fingerprint/cfg-if-c1fbdb19b888f7ea/invoked.timestamp

@@ -1 +0,0 @@
-This file has an mtime of when this was started.

pentest_tool/target/debug/.fingerprint/cfg-if-c1fbdb19b888f7ea/lib-cfg_if

@@ -1 +0,0 @@
-d7b39ead053b56f3

pentest_tool/target/debug/.fingerprint/cfg-if-c1fbdb19b888f7ea/lib-cfg_if.json

@@ -1 +0,0 @@
-{"rustc":18217185010275080438,"features":"[]","declared_features":"","target":11601024444410784892,"profile":10243973527296709326,"path":14751567272659301693,"deps":[],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/cfg-if-c1fbdb19b888f7ea/dep-lib-cfg_if"}}],"rustflags":[],"metadata":8462187951337715540,"config":2202906307356721367,"compile_kind":0}

pentest_tool/target/debug/.fingerprint/cfg-if-f1126d5e99956cbe/invoked.timestamp

@@ -1 +0,0 @@
-This file has an mtime of when this was started.

pentest_tool/target/debug/.fingerprint/cfg-if-f1126d5e99956cbe/lib-cfg_if

@@ -1 +0,0 @@
-4564aaca188960b7

pentest_tool/target/debug/.fingerprint/cfg-if-f1126d5e99956cbe/lib-cfg_if.json

@@ -1 +0,0 @@
-{"rustc":11594289678289209806,"features":"[]","declared_features":"[\"compiler_builtins\", \"core\", \"rustc-dep-of-std\"]","target":11601024444410784892,"profile":10243973527296709326,"path":11251423349894544871,"deps":[],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/cfg-if-f1126d5e99956cbe/dep-lib-cfg_if","checksum":false}}],"rustflags":[],"metadata":8462187951337715540,"config":2202906307356721367,"compile_kind":0}

pentest_tool/target/debug/.fingerprint/cfg_aliases-1f13698e8658435a/invoked.timestamp

@@ -1 +0,0 @@
-This file has an mtime of when this was started.

pentest_tool/target/debug/.fingerprint/cfg_aliases-1f13698e8658435a/lib-cfg_aliases

@@ -1 +0,0 @@
-de07ee73877b76e4

pentest_tool/target/debug/.fingerprint/cfg_aliases-1f13698e8658435a/lib-cfg_aliases.json

@@ -1 +0,0 @@
-{"rustc":11594289678289209806,"features":"[]","declared_features":"[]","target":12544613461349730042,"profile":13232757476167777671,"path":3082952703254974027,"deps":[],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/cfg_aliases-1f13698e8658435a/dep-lib-cfg_aliases","checksum":false}}],"rustflags":[],"metadata":16709548127506949239,"config":2202906307356721367,"compile_kind":0}

pentest_tool/target/debug/.fingerprint/clearscreen-034d850761e9268d/invoked.timestamp

@@ -1 +0,0 @@
-This file has an mtime of when this was started.

pentest_tool/target/debug/.fingerprint/clearscreen-034d850761e9268d/lib-clearscreen

@@ -1 +0,0 @@
-30c685bccae69e0e

pentest_tool/target/debug/.fingerprint/clearscreen-034d850761e9268d/lib-clearscreen.json

@@ -1 +0,0 @@
-{"rustc":11594289678289209806,"features":"[]","declared_features":"[\"windows-console\"]","target":16510214328398099570,"profile":10243973527296709326,"path":8065629026401069409,"deps":[[4171369895214295011,"nix",false,14721634682339001905],[6670304167515094581,"terminfo",false,15574987113318484187],[11266840602298992523,"thiserror",false,7865905133239940446],[15094023649821285592,"which",false,3114378975027364186]],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/clearscreen-034d850761e9268d/dep-lib-clearscreen","checksum":false}}],"rustflags":[],"metadata":3954388147124695588,"config":2202906307356721367,"compile_kind":0}

pentest_tool/target/debug/.fingerprint/clearscreen-1c48c433255f9c28/invoked.timestamp

@@ -1 +0,0 @@
-This file has an mtime of when this was started.

pentest_tool/target/debug/.fingerprint/clearscreen-1c48c433255f9c28/lib-clearscreen

@@ -1 +0,0 @@
-dabc9fe5ca9c63f4

pentest_tool/target/debug/.fingerprint/clearscreen-1c48c433255f9c28/lib-clearscreen.json

@@ -1 +0,0 @@
-{"rustc":11594289678289209806,"features":"[]","declared_features":"[\"windows-console\"]","target":16510214328398099570,"profile":10243973527296709326,"path":14967873048789862483,"deps":[[6165314194305105601,"thiserror",false,14456543346191666976],[6583558668148823975,"which",false,11162537753682719875],[6670304167515094581,"terminfo",false,13222487086128244100],[17995977118843992204,"nix",false,3197397263473614650]],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/clearscreen-1c48c433255f9c28/dep-lib-clearscreen","checksum":false}}],"rustflags":[],"metadata":3954388147124695588,"config":2202906307356721367,"compile_kind":0}

pentest_tool/target/debug/.fingerprint/clearscreen-345b6824d4b33831/invoked.timestamp

@@ -1 +0,0 @@
-This file has an mtime of when this was started.

pentest_tool/target/debug/.fingerprint/clearscreen-345b6824d4b33831/lib-clearscreen

@@ -1 +0,0 @@
-62dadf8571ff6215

pentest_tool/target/debug/.fingerprint/clearscreen-345b6824d4b33831/lib-clearscreen.json

@@ -1 +0,0 @@
-{"rustc":11594289678289209806,"features":"[]","declared_features":"[\"windows-console\"]","target":16510214328398099570,"profile":10243973527296709326,"path":14967873048789862483,"deps":[[6165314194305105601,"thiserror",false,14456543346191666976],[6583558668148823975,"which",false,11162537753682719875],[6670304167515094581,"terminfo",false,2744511574786726040],[17995977118843992204,"nix",false,3197397263473614650]],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/clearscreen-345b6824d4b33831/dep-lib-clearscreen","checksum":false}}],"rustflags":[],"metadata":3954388147124695588,"config":2202906307356721367,"compile_kind":0}

pentest_tool/target/debug/.fingerprint/clearscreen-35ec903f591841be/invoked.timestamp

@@ -1 +0,0 @@
-This file has an mtime of when this was started.

pentest_tool/target/debug/.fingerprint/clearscreen-35ec903f591841be/lib-clearscreen

@@ -1 +0,0 @@
-97ca3e661e0f25e4

pentest_tool/target/debug/.fingerprint/clearscreen-35ec903f591841be/lib-clearscreen.json

@@ -1 +0,0 @@
-{"rustc":18217185010275080438,"features":"[]","declared_features":"","target":16510214328398099570,"profile":10243973527296709326,"path":15789751593529559319,"deps":[[6165314194305105601,"thiserror",false,8920314343114863320],[6583558668148823975,"which",false,13684585653519867350],[6670304167515094581,"terminfo",false,3057214535705540554],[17995977118843992204,"nix",false,7029758982020207529]],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/clearscreen-35ec903f591841be/dep-lib-clearscreen"}}],"rustflags":[],"metadata":3954388147124695588,"config":2202906307356721367,"compile_kind":0}

pentest_tool/target/debug/.fingerprint/clearscreen-79a7f35c54511a30/invoked.timestamp

@@ -1 +0,0 @@
-This file has an mtime of when this was started.

pentest_tool/target/debug/.fingerprint/clearscreen-79a7f35c54511a30/lib-clearscreen

@@ -1 +0,0 @@
-364ab39407412841

pentest_tool/target/debug/.fingerprint/clearscreen-79a7f35c54511a30/lib-clearscreen.json

@@ -1 +0,0 @@
-{"rustc":11594289678289209806,"features":"[]","declared_features":"[\"windows-console\"]","target":16510214328398099570,"profile":10243973527296709326,"path":8065629026401069409,"deps":[[4171369895214295011,"nix",false,14721634682339001905],[6670304167515094581,"terminfo",false,1603648623332424207],[11266840602298992523,"thiserror",false,7865905133239940446],[15094023649821285592,"which",false,3114378975027364186]],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/clearscreen-79a7f35c54511a30/dep-lib-clearscreen","checksum":false}}],"rustflags":[],"metadata":3954388147124695588,"config":2202906307356721367,"compile_kind":0}

pentest_tool/target/debug/.fingerprint/clearscreen-d8bad1fbd518d682/invoked.timestamp

@@ -1 +0,0 @@
-This file has an mtime of when this was started.

pentest_tool/target/debug/.fingerprint/clearscreen-d8bad1fbd518d682/lib-clearscreen

@@ -1 +0,0 @@
-573a50a72f25eac3

pentest_tool/target/debug/.fingerprint/clearscreen-d8bad1fbd518d682/lib-clearscreen.json

@@ -1 +0,0 @@
-{"rustc":11594289678289209806,"features":"[]","declared_features":"[\"windows-console\"]","target":16510214328398099570,"profile":10243973527296709326,"path":14967873048789862483,"deps":[[6583558668148823975,"which",false,12787014422002407715],[6670304167515094581,"terminfo",false,15574987113318484187],[11266840602298992523,"thiserror",false,7865905133239940446],[17995977118843992204,"nix",false,15353782744700607602]],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/clearscreen-d8bad1fbd518d682/dep-lib-clearscreen","checksum":false}}],"rustflags":[],"metadata":3954388147124695588,"config":2202906307356721367,"compile_kind":0}

pentest_tool/target/debug/.fingerprint/directories-318b04d31eec143a/invoked.timestamp

@@ -1 +0,0 @@
-This file has an mtime of when this was started.

pentest_tool/target/debug/.fingerprint/directories-318b04d31eec143a/lib-directories

@@ -1 +0,0 @@
-75369bf07cba1e36

pentest_tool/target/debug/.fingerprint/directories-318b04d31eec143a/lib-directories.json

@@ -1 +0,0 @@
-{"rustc":11594289678289209806,"features":"[]","declared_features":"[]","target":6431201985272143883,"profile":10243973527296709326,"path":14901037407568701745,"deps":[[8374856912967190420,"dirs_sys",false,16724394558162659770]],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/directories-318b04d31eec143a/dep-lib-directories","checksum":false}}],"rustflags":[],"metadata":931290570756584624,"config":2202906307356721367,"compile_kind":0}

pentest_tool/target/debug/.fingerprint/directories-970baa92cda8360a/invoked.timestamp

@@ -1 +0,0 @@
-This file has an mtime of when this was started.

pentest_tool/target/debug/.fingerprint/directories-970baa92cda8360a/lib-directories

@@ -1 +0,0 @@
-b7873dee657c1e4b

pentest_tool/target/debug/.fingerprint/directories-970baa92cda8360a/lib-directories.json

@@ -1 +0,0 @@
-{"rustc":18217185010275080438,"features":"[]","declared_features":"","target":6431201985272143883,"profile":10243973527296709326,"path":15385006301191335814,"deps":[[8374856912967190420,"dirs_sys",false,8803782161123291461]],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/directories-970baa92cda8360a/dep-lib-directories"}}],"rustflags":[],"metadata":931290570756584624,"config":2202906307356721367,"compile_kind":0}

pentest_tool/target/debug/.fingerprint/directories-cedee198e6a671c8/invoked.timestamp

@@ -1 +0,0 @@
-This file has an mtime of when this was started.

pentest_tool/target/debug/.fingerprint/directories-cedee198e6a671c8/lib-directories

@@ -1 +0,0 @@
-67d9407881be5aee

pentest_tool/target/debug/.fingerprint/directories-cedee198e6a671c8/lib-directories.json

@@ -1 +0,0 @@
-{"rustc":11594289678289209806,"features":"[]","declared_features":"[]","target":6431201985272143883,"profile":10243973527296709326,"path":14901037407568701745,"deps":[[8374856912967190420,"dirs_sys",false,467828751267860915]],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/directories-cedee198e6a671c8/dep-lib-directories","checksum":false}}],"rustflags":[],"metadata":931290570756584624,"config":2202906307356721367,"compile_kind":0}

pentest_tool/target/debug/.fingerprint/directories-e9879c9f45d683d4/invoked.timestamp

@@ -1 +0,0 @@
-This file has an mtime of when this was started.

pentest_tool/target/debug/.fingerprint/directories-e9879c9f45d683d4/lib-directories

@@ -1 +0,0 @@
-625cc3cb1db678a9

pentest_tool/target/debug/.fingerprint/directories-e9879c9f45d683d4/lib-directories.json

@@ -1 +0,0 @@
-{"rustc":11594289678289209806,"features":"[]","declared_features":"[]","target":6431201985272143883,"profile":10243973527296709326,"path":14901037407568701745,"deps":[[8374856912967190420,"dirs_sys",false,16407321985629232149]],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/directories-e9879c9f45d683d4/dep-lib-directories","checksum":false}}],"rustflags":[],"metadata":931290570756584624,"config":2202906307356721367,"compile_kind":0}

pentest_tool/target/debug/.fingerprint/dirs-0ed43f970d02ea56/invoked.timestamp

@@ -1 +0,0 @@
-This file has an mtime of when this was started.

pentest_tool/target/debug/.fingerprint/dirs-0ed43f970d02ea56/lib-dirs

@@ -1 +0,0 @@
-bd9e7e9ba848bf6d

pentest_tool/target/debug/.fingerprint/dirs-0ed43f970d02ea56/lib-dirs.json

@@ -1 +0,0 @@
-{"rustc":11594289678289209806,"features":"[]","declared_features":"[]","target":2202548160250307783,"profile":10243973527296709326,"path":5780857034169534110,"deps":[[3220473298903565236,"dirs_sys",false,14246505222629087773]],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/dirs-0ed43f970d02ea56/dep-lib-dirs","checksum":false}}],"rustflags":[],"metadata":2541453624792457215,"config":2202906307356721367,"compile_kind":0}

pentest_tool/target/debug/.fingerprint/dirs-74d33f85a8093a98/invoked.timestamp

@@ -1 +0,0 @@
-This file has an mtime of when this was started.

pentest_tool/target/debug/.fingerprint/dirs-74d33f85a8093a98/lib-dirs

@@ -1 +0,0 @@
-895cbb3523b793a9

pentest_tool/target/debug/.fingerprint/dirs-74d33f85a8093a98/lib-dirs.json

@@ -1 +0,0 @@
-{"rustc":18217185010275080438,"features":"[]","declared_features":"","target":2202548160250307783,"profile":10243973527296709326,"path":1473193461444364558,"deps":[[3220473298903565236,"dirs_sys",false,14504532339575399676]],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/dirs-74d33f85a8093a98/dep-lib-dirs"}}],"rustflags":[],"metadata":2541453624792457215,"config":2202906307356721367,"compile_kind":0}

pentest_tool/target/debug/.fingerprint/dirs-c9fffe1fabc476a4/invoked.timestamp

@@ -1 +0,0 @@
-This file has an mtime of when this was started.

pentest_tool/target/debug/.fingerprint/dirs-c9fffe1fabc476a4/lib-dirs

@@ -1 +0,0 @@
-7e48c0f8fb61d242

pentest_tool/target/debug/.fingerprint/dirs-c9fffe1fabc476a4/lib-dirs.json

@@ -1 +0,0 @@
-{"rustc":11594289678289209806,"features":"[]","declared_features":"[]","target":2202548160250307783,"profile":10243973527296709326,"path":5780857034169534110,"deps":[[3220473298903565236,"dirs_sys",false,17692783231220250451]],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/dirs-c9fffe1fabc476a4/dep-lib-dirs","checksum":false}}],"rustflags":[],"metadata":2541453624792457215,"config":2202906307356721367,"compile_kind":0}

pentest_tool/target/debug/.fingerprint/dirs-sys-15f825f9fb3a7df6/invoked.timestamp

@@ -1 +0,0 @@
-This file has an mtime of when this was started.