fixed logic for configuring distrobox during

install, and fixing some functions in info_controls
They may not be quite ready 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,14 +44,20 @@ 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.  
 
-For example if I get a new internal pentest engagement for client 3 but it hasn't started yet I'll start by creating the folder and note structure using option 4 in the menu system. This would create the folder structure and notes templates in the /home/pyro/pentests/upcomming/client3/internal_pentest and /home/pyro/notes/upcomming/client3/internal_pentest folders respectively. It does not create the distrobox or add it to the tracked project list yet.
+For example if I get a new internal pentest engagement for client 3 but it hasn't started yet I'll start by creating the folder and note structure using option 4 in the menu system. This would create the folder structure and notes templates in the /home/pyro/pentests/upcomming/client3/internal_pentest and /home/pyro/notes/upcomming/client3/internal_pentest folders respectively. It does not create the distrobox, but it does add it to the list of tracked projects, with a status of upcomming.
 
-Once the engagement starts I'd run option 6 "import new project - and set up new distrobox" from the menu system. It will ask if you have an existing folder structure to copy over, since I created that structure before with option 4 I would answer y, yes, or anything with the letter y in it. Then it prompts you to past the path to the folders to copy over. Here I browse to /home/pyro/pentests/upcomming in dolphin. I right click on the client3 folder and select "copy path" and then paste that into the terminal. I repeat this process for the notes folder.
+Once the engagement starts I'd run option 9 to promote a project from upcomming status to current status. This will automatically copy the needed files over, and will clean up the empty directory in the upcomming files directory, but the empty folder in the upcomming notes folder is still not cleaning correctly, I'm working on that.
 
-It then attempts to guess the client name and project name based on the folder structure, and asks you to confirm. If its correct the project object will be created, the folders will be copied, and a new distrobox will be set up. If it is not correct it will prompt you to correct it, then copy the files, create a new project object, and setup a new distrobox.  At the moment it is not very fault tollerant and will fail if there is an existing folder with the same name. I plan to fix that later, but haven't gotten around to it yet. Once the distro box is set up (this takes a while) it will return you to the main menu.
+It then will create a new distrobox and ask you if you need to set up cobalt strike for the project. if so it'll ask you for the path to your cobalt strike, it'll copy that into the project files folder so that you can run it if needed.
 
 During the test I use the menu system to spawn new terminals in the distrobox created for the engagement, use the various file generation options to get data in easily usable format for attack operations, etc.
 
@@ -67,7 +75,8 @@ Once the project is done and I'm ready to clean up the distrobox I use option 7
 1. clone this repository `git clone https://github.com/Pyro57000/pentest_tool.git`
 2. cd into the nested "pentest_tool" folder `cd pentest_tool/pentest_tool`
 3. use cargo to build the release binary `cargo build --release`
-4. follow the same installation instructions, skipping the step where you download the release binary.
+4. copy the compiled binary to a folder on your path `sudo cp ./target/release/pentest_tool /usr/bin/`
+5. follow the same installation instructions, skipping the step where you download the release binary.
 
 
 

ToDo.md

@@ -0,0 +1,29 @@
+# planned features
+1.) finish hash cracking with a dedictated cracking rig code.
+
+2.) cracte hash cracking with current computer code.
+
+
+4.) create code that moves projects to a "writing" state and folder.
+
+5.) create code that tracks "current, upcomming, and writing" states, maybe automatic zipping of folders after writing is done?
+    upcoming and current are done, but need to add writing yet...
+
+# Unplanned, but would be cool
+1.) create a "server" and "Client" infrastructure that can help manage the distrobox clients and the main server
+
+2.) maybe expand this server client model to interact with cracking rigs and what not.
+
+3.) implment a function to searchsploit and copy wanted exploits to the project folder.
+
+4.) implement a function to execute those copied exploits.
+
+5.) add a "client" model for compromised internal hosts, this would likely need to be a server from a networking perspective that listens on 127.0.0.1 and then have the main interface connect to that over a proxy to run jobs. a good starting point would be to run some of our enumeration commands and scripts and save the output to the notes directly.
+
+6.) add the ability to interact with the cobalt strike beacons... would need to learn agressor script... what a pain...
+
+
+# NOTE
+if you wish to contribute, please do! just fix a bug or implement any of the above features and make a pull request!! 
+
+I'll keep plugging away as I have time throughout my days as well.

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/box_controls.rs

@@ -1,5 +1,11 @@
-use std::process;
+use std::process::Command;
-use crate::Project;
+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();
@@ -63,3 +69,214 @@ pub fn project_standalone_terminal(project: Project, mut terminal: String){
 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);
+}

pentest_tool/src/info_controls.rs

@@ -1,20 +1,163 @@
+use std::collections::HashMap;
 use std::fs;
 use std::fs::read_to_string;
+use std::io::BufReader;
 use std::io::Write;
 use std::path::PathBuf;
 use std::process;
+use std::process::Command;
+use std::thread;
+use std::time::Duration;
+use std::io::stdin;
+use std::thread::JoinHandle;
+use walkdir::WalkDir;
+use clearscreen::clear;
+use clearscreen;
+use rodio::{Decoder, OutputStream, Sink};
+use crate::get_user_input;
 use crate::Project;
 
 pub fn run_initial_enum(project: &Project){
-    let mut csv = String::new();
+    #[derive(Clone)]
-    println!("path to the csv?");
+    struct Target {
-    std::io::stdin().read_line(&mut csv).unwrap();
+        address: String,
-    let status = process::Command::new("initial_recon").arg(&csv).arg(&project.customer).arg(&project.project_name).status().expect("error running initial_recon program");
+        ports: Vec<String>
-    if status.success(){
-        println!("execllent! hosts should be imported to {}/host_notes.md", &project.notes_folder.display());
     }
-    else{
+
-        println!("ooof something went wrong, host notes may not have saved correctly!");
+    let mut targets:Vec<Target> = Vec::new();
+    println!("log into nessus and export a report, only checking the host, protocol, and port boxes");
+    let mut host_notes_path = project.notes_folder.clone();
+    let mut attack_notes_path = project.notes_folder.clone();
+    host_notes_path.push("host_notes.md");
+    attack_notes_path.push("attacks");
+    let csv_path = get_user_input("path to nessus report CSV?");
+    let csv_read_res = fs::read_to_string(&csv_path);
+    if csv_read_res.is_err(){
+        let error = csv_read_res.err().unwrap();
+        println!("error reading csv!");
+        println!("{}", error);
+        return;
+    }
+    let csv_data = csv_read_res.unwrap();
+    for line in csv_data.split("\n").collect::<Vec<&str>>(){
+        if line.len() > 1{
+            let data: Vec<&str> = line.split(",").collect();
+            let address = data[0].replace("\"", "").trim().to_owned();
+            let port = data[2].replace("\"", "").trim().to_owned();
+            let protocol = data[1].replace("\"", "").trim().to_owned();
+            if &address == &"Host"{
+                continue;
+            }
+            else if &port == &"0"{
+                continue;
+            }
+            let port_entry = format!("{}:{}", &protocol, &port);
+            let mut is_new = true;
+            for target in &mut targets{
+                if target.address == address{
+                    if !target.ports.contains(&port_entry){
+                        target.ports.push(port_entry.clone());
+                    }
+                    is_new = false;
+                }
+            }
+            if is_new{
+                let new_target = Target{address: address.to_owned(), ports: vec![port_entry.clone()]};
+                targets.push(new_target);
+            }
+        }
+    }
+    for target in &targets{
+        let host_notes_open_res = fs::OpenOptions::new().append(true).create(true).open(&host_notes_path);
+        if host_notes_open_res.is_err(){
+            let error = host_notes_open_res.err().unwrap();
+            println!("error opening host notes file!");
+            println!("{}", error);
+            return;
+        }
+        let host_notes = host_notes_open_res.unwrap();
+        let attack_notes_open_res = fs::OpenOptions::new().append(true).create(true).open(&attack_notes_path);
+        if attack_notes_open_res.is_err(){
+            let error = attack_notes_open_res.err().unwrap();
+            println!("error opening attack notes!");
+            println!("{}", error);
+            return;
+        }
+        for target in targets.clone(){
+            let mut output = format!("# {}\n## Ports\n| port | service | attack notes |\n| ----- | ------- | ------------ |\n", target.address);
+            for port in target.ports{
+                output.push_str(format!("| {} | | [[attacks]]\n", port).as_str());
+            }
+            output.push_str("\n");
+            write!(&host_notes, "{}", output).expect("error writing host_notes");
+            println!("{} notes written!", target.address);
+        }
+    }
+}
+
+pub fn build_external_attack_notes(project: &Project){
+
+    #[derive(Clone)]
+    struct Port{
+        number: String,
+        hosts: Vec<String>,
+    }
+
+    let mut ports: Vec<Port> = Vec::new();
+    let mut host_notes_path = project.notes_folder.clone();
+    let mut attack_notes_path = host_notes_path.clone();
+    host_notes_path.push("host_notes.md");
+    attack_notes_path.push("attacks.md");
+    let host_notes_read_res = fs::read_to_string(host_notes_path);
+    if host_notes_read_res.is_err(){
+        let error = host_notes_read_res.err().unwrap();
+        println!("error reading host notes!");
+        println!("{}", error);
+        return;
+    }
+    let host_notes = host_notes_read_res.unwrap();
+    let attack_open_res = fs::OpenOptions::new().append(true).create(true).open(attack_notes_path);
+    if attack_open_res.is_err(){
+        let error = attack_open_res.err().unwrap();
+        println!("error opening attack notes!");
+        println!("{}", error);
+        return;
+    }
+    let attack_notes = attack_open_res.unwrap();
+    for line in host_notes.split("\n").collect::<Vec<&str>>(){
+        let mut current_host = String::new();
+        if line.len() > 1{
+            if line.contains("#"){
+                if !line.contains("##"){
+                    current_host = line.split_whitespace().collect::<Vec<&str>>()[1].trim().to_owned();
+                }
+            }
+            if line.contains("|"){
+                let table_data:Vec <&str> = line.split("|").collect();
+                for item in table_data{
+                    let mut is_new = true;
+                    if item.contains(":"){
+                        for port in &mut ports{
+                            if port.number == item.trim(){
+                                if port.hosts.contains(&current_host){
+                                    port.hosts.push(current_host.clone());
+                                }
+                                is_new = false;
+                            }
+                        }
+                        if is_new{
+                            let new_port = Port{number: line.trim().to_owned(), hosts:vec![current_host.clone()]};
+                        }
+                    }
+                }
+            }
+        }
+    }
+    for port in ports{
+        let output = format!("# {}\nHOSTS:\n", port.number);
+        for host in port.hosts{
+           // output.push_str("## {}");
+        }
     }
 }
 
@@ -144,3 +287,492 @@ 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());
+                }
+            }
+        }
+    }
+}
+
+
+pub fn get_mssql_column_names(project: &Project) -> Option<JoinHandle<()>>{
+    let mut notes_file = project.notes_folder.clone();
+    notes_file.push("l00t/db_stuff");
+    println!("NOTE: this funtion relies on netexec, make sure its installed properly!");
+    let mut servers = Vec::new();
+    let username = get_user_input("username for the databases?");
+    let password = get_user_input("password for the databases?");
+    let local_auth = get_user_input("Will you be using Windows Authentication for this?").to_lowercase();
+    loop{
+        for server in &servers{
+            println!("{}", server);
+        }
+        let new_server = get_user_input("server to add? (enter DONE when you're finished)");
+        if new_server == "DONE".to_owned(){
+            break;
+        }
+        servers.push(new_server);
+    }
+    let db_handle = thread::spawn(move ||{
+        for server in servers{
+            let mut db_notes_path = notes_file.clone();
+            let mut dbs = Vec::new();
+            if local_auth.contains("n"){
+                let netexec_cmd_res = Command::new("proxychains")
+                                                            .arg("netexec")
+                                                            .arg("mssql")
+                                                            .arg(&server)
+                                                            .arg("-u")
+                                                            .arg(&username)
+                                                            .arg("-p")
+                                                            .arg(&password)
+                                                            .arg("--local-auth")
+                                                            .arg("-q")
+                                                            .arg("\"SELECT name FROM master.sys.databases\"")
+                                                            .output();
+                if netexec_cmd_res.is_err(){
+                    let error = netexec_cmd_res.err().unwrap();
+                    println!("error running netexec command!");
+                    println!("{}", error);
+                }
+                else{
+                    let output_string = String::from_utf8(netexec_cmd_res.unwrap().stdout).unwrap();
+                    let words: Vec<&str> = output_string.split_whitespace().collect();
+                    for word in words {
+                        if word.contains("name:"){
+                            let db = word.split(":").collect::<Vec<&str>>()[1].to_owned();
+                            db_notes_path.push(&db);
+                            dbs.push(db);
+                            fs::create_dir_all(&db_notes_path).unwrap();
+                        }
+                    }
+                }
+            }                                                 
+        }
+    });
+    return Some(db_handle);
+}

pentest_tool/src/install.rs

@@ -1,8 +1,214 @@
 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 std::process::Command;
+use reqwest::blocking::get;
 use std::path::PathBuf;
 use std::process;
+use std::process::exit;
+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\"
+        ");
+    }
+}
 
 
 
@@ -16,16 +222,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");
+    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 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 +257,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.
@@ -59,23 +265,58 @@ 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!("please set up a distrobox with root as a template and re-run this tool");
+        println!("ooof buddy, should have had that already... no worries, we'll make one now.");
-        println!("example distrobox setup command:");
+        let new_boxname = get_user_input("name for your template box? (for exmaple I use atarchbox cause its my attacking archbox ;-)");
-        println!("distrobox create --root --image archlinux --name template");
+        println!("please review the following link to select an image to use for your distrobox");
-        println!("then enter that distrobox and install all the tools you want and do what ever setup you need");
+        println!("https://distrobox.it/compatibility/#containers-distros");
-        println!("and re-run this tool.");
+        let image_name = get_user_input("which image would you like to use?");
-        process::Command::new("rm").arg(del_on_fail).spawn().expect("ERROR deleting config folder, please manually clean up");
+        let tools_volume =format!("{}:/tools:rw", &tools_response);
-        std::process::exit(1);
+        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!("{}", error);
+            println!("you'll have to make it manually, but remember the name you want to use for the next step.");
+        }
+        else{
+            distrobox_create_res.unwrap();
+            println!("nice, we created a distrobox, remeber the name of your box for the next step!");
+        }
     }
     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 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 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:{}", &notes_response.trim_end(), &files_response.trim_end(), &template_name.trim_end());
+    let default_projectline = format!("default:default:{}:{}:yes:{}:current", &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();
@@ -83,17 +324,8 @@ Do you have a distrobox set up to function as your template for all new projects
     let mut password_spray_template_path = install_path.clone();
     install_path.push("new_projects.conf");
     password_spray_template_path.push("passwordspray.md");
-    let password_spray_template_path = install_path.clone();
+    let pass_file_config_line = format!("\npass_file:{}", password_spray_template_path.display());
-    let mut conf_file = fs::File::create(install_path).expect("error creating config file");
+    config_file.write_all(pass_file_config_line.as_bytes()).expect("error writing password spray setting to 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
@@ -126,5 +358,6 @@ project_notes_path:{}
 - [ ] Service
 - [ ] Service!
 - [ ] Serviceyear!").expect("error writing password spray template");
+    configure_distrobox();
     std::process::exit(0);
 }

pentest_tool/src/main.rs

@@ -1,5 +1,6 @@
-use std::path::PathBuf;
+use std::{io::stdin, path::PathBuf};
 use directories::UserDirs;
+use reqwest::Response;
 use std::fs;
 
 #[derive(Clone)]
@@ -10,6 +11,7 @@ pub struct Project{
     pub files_folder: PathBuf,
     pub active: bool,
     pub boxname: String,
+    pub stage: String,
     pub id: i32,
 }
 
@@ -20,6 +22,22 @@ mod box_controls;
 mod info_controls;
 mod start_pentest;
 
+pub fn get_user_input(prompt: &str) -> String{
+    let mut response = String::new();
+    loop{
+        println!("{}", prompt);
+        let result = stdin().read_line(&mut response);
+        if result.is_err(){
+            println!("we need input here dummy! try again...");
+        }
+        else{
+            result.unwrap();
+            break;
+        }
+    }
+    return response.trim_end().to_owned();
+}
+
 
 fn main() {
     print!("
@@ -53,6 +71,13 @@ 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();
+    let mut upcoming_files = PathBuf::new();
+    let mut upcoming_notes = PathBuf::new();
+    let mut pass_spray_file = PathBuf::new();
+    let mut fingerprint = false;
     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();
@@ -63,8 +88,15 @@ fn main() {
                 "Project_files" => project_base_folder.push(setting_vec[1].trim_end()),
                 "Project_notes" => project_base_notes.push(setting_vec[1].trim_end()),
                 "tools_folder" => tools_folder.push(setting_vec[1].trim_end()),
+                "upcoming_files" => upcoming_files.push(setting_vec[1].trim_end()),
+                "upcoming_notes" => upcoming_notes.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_end().to_owned(),
+                "rule_location" => rule = setting_vec[1].trim_end().to_owned(),
+                "pass_file"=> pass_spray_file.push(setting_vec[1]),
+                "fingerprint" => {if setting_vec[1].contains("y"){fingerprint = true}},
                 _ => println!("error unknown setting: {}", setting_vec[0])
             }
         }
@@ -74,12 +106,15 @@ 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
+    upcoming project folders: {}
+    upcoming project notes: {}
+", &project_base_folder.display(), &project_base_notes.display(), &tools_folder.display(), box_template, terminal_command, cracking_rig, &upcoming_files.display(), &upcoming_notes.display());
     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, &upcoming_files, &upcoming_notes, &pass_spray_file, fingerprint);
 }

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,25 @@ 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, upcoming_files: &PathBuf, upcoming_notes: &PathBuf, password_spray_file: &PathBuf, fingerprint: bool){
     let mut loopize = true;
     let mut new_id = next_project_id(&config_path);
+    let mut threads = Vec::new(); 
     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 +98,17 @@ 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
 
+base prject folder: {}
+upcoming project folder: {}
 Current Project: {} {}
+Working Folder: {}
+Notes Folder: {}
+Box Name: {}
+Terminal Command: {}
+Current Season: {}
+Year: {}
 
         Main Menu:
             1 .) Show Active Project
@@ -95,40 +118,58 @@ Current Project: {} {}
             5 .) Save Project Information
             6 .) Import New Project - and setup new Distrobox
             7 .) Remove Project
-            8 .) Open A New Terminal in Current Active Project
+            8 .) Print upcoming projects
-            9 .) Open A Terminal In this windows for the current active project
+            9. ) promote project from upcoming to current
-            10.) Open Project Files Folder In Dolphin
+            10.) Open A New Terminal in Current Active Project
-            11.) Open Project Notes Folder In Dolphin
+            11.) Open A Terminal In this windows for the current active project
-            12.) generate userpass file from your obsidian notes
+            12.) open current project's cobalt strike
-            13.) run pyro's initail enum script on a nessus csv for the current project
+            13.) re-create the distrobox for the current active project
-            14.) Print Project Info For Report
+            14.) Open Project Files Folder In Dolphin
-            15.) Build host discovery cmd command from scope in notes
+            15.) Open Project Notes Folder In Dolphin
-            16.) Stop All Distroboxes
+            16.) generate userpass file from your obsidian notes
-            17.) Quit Application
+            17.) run pyro's initail enum script on a nessus csv for the current project
-\n", active_project.customer, active_project.project_name);
+            18.) Print Project Info For Report
+            19.) Build host discovery cmd command from scope in notes
+            20.) build portscan command from scope in notes
+            21.) Stop All Distroboxes
+            22.) Password Spray (will print password to spray, and wait the obervation window time)
+            23.) crack password hashes on your cracking rig
+            24.) Launch bloodhound with the current project's distrobox
+            25.) prune unused distroboxes (free up system storage)
+            26.) Quit Application
+\n",&base_files.display(), &upcoming_files.display(), 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(){
             "1" => println!("\nclient: {}\n\nproject: {}\n\nbox: {}\n\nproject files: {}\n\nproject notes: {}\n", active_project.customer ,active_project.project_name, active_project.boxname, active_project.files_folder.display(), active_project.notes_folder.display()),
             "2" => {println!("+++++++++++++++++++++"); 
                     for project in &projects{
-                        println!("++{}|{}++",project.customer ,project.project_name)}
+                        println!("++Customer: {}|Project name: {}|Stage: {}++",project.customer ,project.project_name, project.stage)}
                     println!("++++++++++++++++++++")},
             "3" => project_controls::switch_project(&mut projects),
-            "4" => start_pentest::start_pentest(&config_path),
+            "4" => {new_id = new_id + 1; start_pentest::start_pentest(&config_path, &mut projects, new_id, upcoming_files, upcoming_notes, &boxtemplate, password_spray_file)},
             "5" => project_controls::save_projects(&projects, &config_path),
-            "6" => {new_id = new_id + 1; project_controls::new_project(&mut projects, &base_files, &base_notes, &tools_dir, &boxtemplate, &config_path, new_id)},
+            "6" => {new_id = new_id + 1; project_controls::new_project(&mut projects, &base_files, &base_notes, &tools_dir, &boxtemplate, &config_path, new_id, &upcoming_files, &upcoming_notes, fingerprint)},
             "7" => project_controls::remove_project(&mut projects, &config_path),
-            "8" => box_controls::project_standalone_terminal(active_project.clone(), terminal.clone()),
+            "8" => project_controls::print_upcoming_projects(&projects),
-            "9" => box_controls::project_inline_terminal(active_project.clone()),
+            "9" => project_controls::promote_project(&mut projects, &config_path, base_files, base_notes, tools_dir, &boxtemplate, fingerprint),
-            "10" => info_controls::open_in_dolphin("files", active_project.clone()),
+            "10" => box_controls::project_standalone_terminal(active_project.clone(), terminal.clone()),
-            "11" => info_controls::open_in_dolphin("notes", active_project.clone()),
+            "11" => box_controls::project_inline_terminal(active_project.clone()),
-            "12" => info_controls::generate_userpass(&active_project),
+            "12" => {let cs_thread = box_controls::launch_cobalt_strike(active_project.clone()); if cs_thread.is_some(){threads.push(cs_thread.unwrap());}},
-            "13" => info_controls::run_initial_enum(&active_project),
+            "13" => box_controls::make_box(&active_project, &tools_dir, &boxtemplate, false, fingerprint),
-            "14" =>info_controls::print_report_information(active_project.clone()),
+            "14" => info_controls::open_in_dolphin("files", active_project.clone()),
-            "15" => info_controls::build_cmd_for_host_discovery(&active_project),
+            "15" => info_controls::open_in_dolphin("notes", active_project.clone()),
-            "16" => box_controls::stop_all_boxes(&projects),
+            "16" => info_controls::generate_userpass(&active_project),
-            "17" => {project_controls::save_projects(&projects, &config_path);
+            "17" => info_controls::run_initial_enum(&active_project),
+            "18" => info_controls::print_report_information(active_project.clone()),
+            "19" => info_controls::build_cmd_for_host_discovery(&active_project),
+            "20" => info_controls::build_cs_portscan_cmd(&active_project),
+            "21" => box_controls::stop_all_boxes(&projects),
+            "22" => info_controls::password_spray_help(&active_project, season, lseason, year, &tools_dir, &config_path),
+            "23" => info_controls::crack_hashes(&cracking_rig, &active_project, &terminal, &rockyou, &rule),
+            "24" => {let bloodhound_handle = box_controls::launch_bloodhound_gui(active_project.clone()).unwrap(); threads.push(bloodhound_handle);},
+            "25" => {let prune_thread = box_controls::clean_unused_boxes(&projects, &boxtemplate); if prune_thread.is_some(){threads.push(prune_thread.unwrap());}},
+            "26" => {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();
@@ -145,4 +186,9 @@ Current Project: {} {}
         let mut enter = String::new();
         std::io::stdin().read_line(&mut enter).unwrap();
     }
+    println!("this will hang until all threads are finished.");
+    println!("make sure to close all programs opened with this menu, like cobalt strike or bloodhound.");
+    for thread in threads{
+        thread.join().unwrap();
+    }
 }

pentest_tool/src/project_controls.rs

@@ -4,10 +4,14 @@ use std::io::stdin;
 use std::io::Write;
 use std::path::PathBuf;
 use std::process;
+use std::process::Command;
 use std::thread;
 use std::time::Duration;
 use std::str::FromStr;
+use crate::get_user_input;
+use fs_extra::file;
 use crate::Project;
+use crate::box_controls::make_box;
 
 pub fn switch_project(projects: &mut Vec<Project>){
     for project in projects.clone(){
@@ -46,34 +50,64 @@ pub fn save_projects(projects: &Vec<Project>, config_path: &PathBuf){
     save_file_path.pop();
     save_file_path.push("projects.conf");
     let mut save_file = fs::File::create(save_file_path).expect("error creating save_file");
-    save_file.write_all(b"customer:name:notes:files:active:time:box_name\n").expect("error writing first line to file");
+    save_file.write_all(b"customer:name:notes:files:active:time:box_name:stage\n").expect("error writing first line to file");
     for project in projects{
         let default = format!{"{}:{}:{}:{}:", project.customer, project.project_name, project.notes_folder.display(), project.files_folder.display()};
         let mut _outline = String::new();
         if project.active{
             if active_set == false{
-                _outline = format!("{}yes:{}\n", default, project.boxname);
+                _outline = format!("{}yes:{}:{}\n", default, project.boxname, project.stage);
                 active_set = true;
             }
 
         }
         else{
-            _outline = format!("{}no:{}\n", default, project.boxname);
+            _outline = format!("{}no:{}:{}\n", default, project.boxname, project.stage);
         }
         save_file.write_all(_outline.as_bytes()).expect("error writing outline");
     }
 }
 
-pub fn new_project(projects: &mut Vec<Project>, project_dir: &PathBuf, notes_dir: &PathBuf, tools_dir: &PathBuf, boxtemplate: &String, config_path: &PathBuf, new_id: i32){
+pub fn new_project(projects: &mut Vec<Project>, project_dir: &PathBuf, notes_dir: &PathBuf, tools_dir: &PathBuf, boxtemplate: &String, config_path: &PathBuf, new_id: i32, upcoming_files: &PathBuf, upcoming_notes: &PathBuf, fingerprint: bool){
-    let mut new_project_dir = project_dir.clone();
+    let mut new_project_dir = PathBuf::new();
-    let mut new_note_dir = notes_dir.clone();
+    let mut new_note_dir = PathBuf::new();
     let mut existing_folders = String::new();
     let mut customer_name = String::new();
     let mut project_name = String::new();
+    let mut project_stage = String::new();
+    loop{
+        let mut stage_response = String::new();
+        println!("what stage is this project in?");
+        print!("
+1.) current
+2.) upcoming
+");
+        let stage_result = stdin().read_line(&mut stage_response);
+        if stage_result.is_err(){
+            println!("we need input here dummy, try again...");
+        }
+        else{
+            match &stage_response.trim_end(){
+                &"1" => {project_stage = "current".to_owned(); break;},
+                &"2" => {project_stage = "upcoming".to_owned(); break;},
+                _ => println!("unknown option, try again...")
+            }
+        }
+    }
+    if project_stage.contains("current"){
+        new_project_dir = project_dir.clone();
+        new_note_dir = notes_dir.clone();
+    }
+    else if project_stage.contains("upcoming"){
+        new_project_dir = upcoming_files.clone();
+        new_note_dir = upcoming_notes.clone();
+    }
+    else{
+        println!("unknown stage!!")
+    }
+    println!("{}", new_project_dir.display());
     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();
@@ -185,54 +219,6 @@ pub fn new_project(projects: &mut Vec<Project>, project_dir: &PathBuf, notes_dir
     }
     thread::sleep(Duration::from_secs(2));
     let box_name = format!("atarchbox_{}", customer_name);
-    let mut box_name_path = new_project_dir.clone();
-    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", new_project_dir.display());
-    let toold_volume = format!("{}:/tools:rw", tools_dir.display());
-    println!("distrobox create --root --clone {} --volume {} --volume {} --name {}", boxtemplate, toold_volume,  pentest_volume, box_name);
-    let distrobox_result = process::Command::new("distrobox")
-                                                                .arg("create")
-                                                                .arg("--root")
-                                                                .arg("--clone")
-                                                                .arg(boxtemplate)
-                                                                .arg("--volume")
-                                                                .arg(&toold_volume)
-                                                                .arg("--volume")
-                                                                .arg(&pentest_volume)
-                                                                .arg("--name")
-                                                                .arg(&box_name)
-                                                                .status()
-                                                                .expect("error getting distrobox status");
-    if distrobox_result.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()
-                                                                        .expect("error getting response from distrobox start");
-        if distrobox_start_result.success(){
-            println!("distrobox was started as well!!!! good job me!");
-        }
-        else{
-            println!("ooof did not start successfully try entering it yoruself");
-            println!("distrobox enter --rrot {} -- sudo -s ln -sf /pentest/boxname /etc/boxname", &box_name);
-        }
-    }
-    else{
-        println!("ooof distrobox did not work.... try creating it yourself");
-        println!("distrobox create --root --clone {} --volume {} --volume {} --name {}", boxtemplate, &toold_volume, &pentest_volume, &box_name);
-        println!("distrobox enter --rrot {} -- sudo -s ln -sf /pentest/boxname /etc/boxname", &box_name);
-    }
     let new_project = Project{customer: customer_name.trim_end().to_owned(), 
                                     project_name: project_name.trim_end().to_owned(), 
                                     notes_folder: new_note_dir, 
@@ -240,7 +226,11 @@ pub fn new_project(projects: &mut Vec<Project>, project_dir: &PathBuf, notes_dir
                                     active: false,
                                     id: new_id,
                                     boxname: box_name,
+                                    stage: project_stage.to_owned()
                                       };
+    if project_stage.contains("current"){
+        make_box(&new_project, &tools_dir, &boxtemplate, true, fingerprint);
+    }
     projects.push(new_project);
     save_projects(projects, config_path);
 
@@ -314,6 +304,12 @@ pub fn get_projects(config_path: &PathBuf) -> Vec<Project>{
         if first != 1{
             if line.len() > 1{
                 let settings: Vec<&str> = line.split(":").collect();
+                //debug config file...
+                /*let mut count = 0;
+                for settin in &settings{
+                    println!("{}: {}", count, settin);
+                    count = count + 1;
+                }*/
                 let customer = settings[0].to_owned();
                 let project = settings[1].to_owned();
                 let notes_string = settings[2].to_owned();
@@ -329,7 +325,8 @@ pub fn get_projects(config_path: &PathBuf) -> Vec<Project>{
                         active = true;
                     }
                 }
-                let new_project = Project{customer: customer, project_name: project, files_folder: project_folder, notes_folder: notes_folder, active: active, id: first, boxname: boxname};
+                let project_stage = settings[6].to_owned();
+                let new_project = Project{customer: customer, project_name: project, files_folder: project_folder, notes_folder: notes_folder, active: active, id: first, boxname: boxname, stage: project_stage};
                 println!("{} {} LOADED!", &new_project.customer, &new_project.project_name);
                 projects.push(new_project);
             }
@@ -337,3 +334,114 @@ pub fn get_projects(config_path: &PathBuf) -> Vec<Project>{
     }
     return projects
 }
+
+pub fn print_upcoming_projects(projects: &Vec<Project>){
+    for project in projects{
+        if project.stage.contains("upcoming"){
+            println!("{}:{}", project.customer, project.project_name);
+        }
+    }
+}
+
+pub fn promote_project(projects: &mut Vec<Project>, config_path: &PathBuf, project_dir: &PathBuf, notes_dir: &PathBuf, tools_dir: &PathBuf, boxtemplate: &String, fingerprint: bool){
+    let working_projects = projects.clone();
+    for project in &working_projects{
+        if project.stage.contains("upcoming"){
+            println!("{}.) {}:{}", project.id, project.customer, project.project_name);
+        }
+    }
+    println!("which project to promote?");
+    let mut selection = String::new();
+    let result = stdin().read_line(&mut selection);
+    if result.is_err(){
+        println!("we need input here dummy try again....");
+    } 
+    result.unwrap();
+    println!("{}", project_dir.display());
+    let promote_id: i32 = selection.trim_end().parse().unwrap(); 
+    let mut projects_to_save = Vec::new();
+    for project in &working_projects{
+        if project.id == promote_id{
+            let mut promoted_project = project.clone();
+            let mut new_files_dir = project_dir.clone();
+            let mut new_notes_dir = notes_dir.clone();
+            new_files_dir.push(&promoted_project.customer);
+            new_notes_dir.push(&promoted_project.customer);
+            fs::create_dir_all(&new_files_dir).unwrap();
+            fs::create_dir_all(&new_notes_dir).unwrap();
+            let folder_move_success = process::Command::new("mv")
+                                                .arg("-i")
+                                                .arg(&project.files_folder)
+                                                .arg(&new_files_dir.display().to_string())
+                                                .status().expect("unable to call the system mv command");
+            let note_move_success = process::Command::new("mv")
+                                                .arg("-i")
+                                                .arg(&project.notes_folder)
+                                                .arg(&new_notes_dir.display().to_string())
+                                                .status().expect("unable to call the system mv command");
+            if folder_move_success.success(){
+                println!("we copied the project folder correctly!!");
+                let mut remove_folder = PathBuf::new();
+                remove_folder.push(&project.files_folder);
+                remove_folder.pop();
+                let remove_files_res = fs::remove_dir_all(remove_folder);
+                if remove_files_res.is_err(){
+                    println!("error removing the original files folder form the upcomming folder, manual cleanup required");
+                }
+                else{
+                    remove_files_res.unwrap();
+                    println!("upcoming files folder cleanup successful!");
+                }
+            }
+            else{
+                println!("failed to copy the project folder, try to move it manually!");
+            }
+            if note_move_success.success(){
+                println!("we copied the notes folder correctly!!");
+                let mut remove_folder = PathBuf::new();
+                remove_folder.push(&project.files_folder);
+                remove_folder.pop();
+                let remove_notes_res = fs::remove_dir_all(remove_folder);
+                if remove_notes_res.is_err(){
+                    println!("error removing the original notes folder form the upcomming folder, manual cleanup required");
+                }
+                else{
+                    remove_notes_res.unwrap();
+                    println!("upcoming notes folder cleanup successful!");
+                }
+            }
+            else{
+                println!("failed to copy the notes folder, try to move it manually!");
+            }
+            new_files_dir.push(&promoted_project.project_name);
+            new_notes_dir.push(&promoted_project.project_name);
+            promoted_project.files_folder = new_files_dir;
+            promoted_project.notes_folder = new_notes_dir;
+            promoted_project.stage = "current".to_owned();
+            let cs_response = get_user_input("will you need to be using cobalt strike for this project?");
+            if cs_response.to_lowercase().contains("y"){
+                let cs_path = get_user_input("path to your current cobalt strike directory?");
+                let copy_result = Command::new("cp").arg("-R").arg(&cs_path).arg(&promoted_project.files_folder).status();
+                if copy_result.is_err(){
+                    println!("oof we had an error copying... you'll have to copy this manually");
+                }
+                else{
+                    let copy_exit = copy_result.unwrap();
+                    if copy_exit.success() == false{
+                        println!("oof we had an error copying... you'll have to copy this manually");
+                        println!("run cp -R {} {}", &cs_path, &promoted_project.files_folder.display());
+                    }
+                }
+            }
+            thread::sleep(Duration::from_secs(3));
+            make_box(&promoted_project, tools_dir, boxtemplate, true, fingerprint);
+            projects_to_save.push(promoted_project);
+        }
+        else{
+            projects_to_save.push(project.clone());
+        }
+    }
+    projects.clear();
+    projects.append(&mut projects_to_save);
+    save_projects(&projects_to_save, config_path);
+}

pentest_tool/src/start_pentest.rs

@@ -1,25 +1,59 @@
 use std::fs;
-use std::io::stdin;
+use std::fs::File;
 use std::io::Write;
 use std::path::PathBuf;
+use crate::Project;
+use crate::project_controls;
+use crate::get_user_input;
 
-fn external(project_folder_path: String,comapny_name: &String, project_name: &String, passtemp: PathBuf){
+
-    let mut general_notes = fs::File::create(format!("{}/general.md", &project_folder_path)).expect("error creating general notes file");
+fn create_project_folder(path: &mut PathBuf, folder: &str){
-    let mut attack_notes = fs::File::create(format!("{}/attacks.md", &project_folder_path)).expect("error creating attack notes file");
+    path.push(folder);
-    let mut host_notes = fs::File::create(format!("{}/host_notes.md", &project_folder_path)).expect("error creating host notes file");
+    let result = fs::create_dir_all(&path);
-    let mut finding_notes = fs::File::create(format!("{}/findings.md", &project_folder_path)).expect("error creating findings notes file");
+    if result.is_err(){
-    // for tagging
+        println!("error creating {} directory!", folder);
-    let year = project_name.split("_").collect::<Vec<&str>>()[1];
+    }
-    let project_type = "External";
+    else{
-    writeln!(&mut general_notes, "#{} #{} #{} #general", comapny_name, project_type, year).expect("error writing to general notes file");
+        result.unwrap();
-    writeln!(&mut attack_notes, "#{} #{} #{} #attack", comapny_name, project_type, year).expect("error writing tags on attack notes");
+    }
-    writeln!(&mut host_notes, "##{} #{} #{} #host_notes", comapny_name, project_type, year).expect("error writing tag lin in host notes");
+    path.pop();
-    writeln!(&mut finding_notes, "#{} #{} #{} #findings", comapny_name, project_type, year).expect("error writing tag line on findings");
+}
-    writeln!(&mut general_notes, "# Scope").expect("error writing to general notes file");
+
-    writeln!(&mut general_notes, "\n| IP | Third Party | Approval |").expect("error writing to general notes file");
+fn create_note_file(path: &PathBuf) -> Option<File>{
-    writeln!(&mut general_notes, "| -- | ----------- | -------- |").expect("error writing to general notes file");
+    let result = fs::File::create(path);
-writeln!(&mut general_notes, "# PPC").expect("failed to write general notes");
+    if result.is_err(){
-write!(&mut general_notes, "
+        println!("error creating {} try manually!", path.display());
+        return None;
+    }
+    else{
+        let file = result.unwrap();
+        return Some(file);
+    } 
+}
+
+fn external(passtemp: &PathBuf, project: &Project){
+    // using a pathbuf to create files.
+    let mut notes_path = project.notes_folder.clone();
+    let file_creation_res = fs::create_dir_all(&notes_path);
+    if file_creation_res.is_err(){
+        let error = file_creation_res.err().unwrap();
+        println!("error creating notes folder! {}", error);
+    }
+    else{
+        file_creation_res.unwrap();
+    }
+    notes_path.push("general.md");
+    let general_notes_result = create_note_file(&notes_path);
+    if general_notes_result.is_some(){
+        let mut general_notes = general_notes_result.unwrap();
+        // for tagging
+        let project_type = "External";
+        writeln!(&mut general_notes, "#{} #{} #general", project.customer, project_type).expect("error writing to general notes file");
+        writeln!(&mut general_notes, "# Scope").expect("error writing to general notes file");
+        writeln!(&mut general_notes, "\n| IP | Third Party | Approval |").expect("error writing to general notes file");
+        writeln!(&mut general_notes, "| -- | ----------- | -------- |").expect("error writing to general notes file");
+        writeln!(&mut general_notes, "# PPC").expect("failed to write general notes");
+        write!(&mut general_notes, "
 Planning call notes:
 * methodolgy
 * whole month testing window
@@ -54,8 +88,14 @@ Planning call notes:
 | IP | host notes | needs? |
 | -- | ---------- | ------ |\n").expect("faile to write pentest notes");
 
-// set up the basics for our attack notes
+    }
-write!(&mut attack_notes,"
+    notes_path.pop();
+    notes_path.push("attacks.md");
+    let attack_notes_result = create_note_file(&notes_path);
+    if attack_notes_result.is_some(){
+        let mut attack_notes = attack_notes_result.unwrap();
+        writeln!(&mut attack_notes, "#{} #{} #attack", project.customer, "external").expect("error writing tags on attack notes");
+        write!(&mut attack_notes,"
 # Directory Bruteforcing
 - [ ] example.com
 
@@ -74,59 +114,79 @@ write!(&mut attack_notes,"
 passwords tried:
 * password\n
 " ).expect("failed to write attack notes template");
-let new_spray_path = format!("{}/passwordspray.md", &project_folder_path);
+    }
-fs::copy(passtemp,new_spray_path).unwrap();
+    notes_path.pop();
+    notes_path.push("password_spray.md");
+    let pass_result = fs::copy(&passtemp, &notes_path);
+    if pass_result.is_err(){
+        println!("error copying password spray file! try manually");
+    }
+    else{
+        pass_result.unwrap();
+    }
+    notes_path.pop();
+    notes_path.push("host_notes.md");
+    let host_notes_result = create_note_file(&notes_path);
+    if host_notes_result.is_some(){
+        let mut host_notes = host_notes_result.unwrap();
+        writeln!(&mut host_notes, "##{} #{} #host_notes", project.customer, "external").expect("error writing tag lin in host notes");
+    }
+    notes_path.pop();
+    notes_path.push("findings.md");
+    let findings_notes_result = create_note_file(&notes_path);
+    if findings_notes_result.is_some(){
+        let mut finding_notes = findings_notes_result.unwrap();
+        writeln!(&mut finding_notes, "#{} #{} #findings", project.customer, "external").expect("error writing tag line on findings");
+    }
+
 }
 
-fn internal(project_folder_path: String, comapny_name: &String, project_name: &String, passtemp: PathBuf){
+fn internal(passtemp: &PathBuf, project: &Project){
-    let loot_folder = format!("{}/l00t", project_folder_path);
+    let mut notes_path = project.notes_folder.clone();
-    fs::create_dir_all(&loot_folder).expect("error creating loot directory");
+    let file_creation_res = fs::create_dir_all(&notes_path);
-    let mut general_notes = fs::File::create(format!("{}/general.md", &project_folder_path)).expect("error creating general notes file");
+    if file_creation_res.is_err(){
-    let mut attack_notes = fs::File::create(format!("{}/attacks.md", &project_folder_path)).expect("error creating attack notes file");
+        let error = file_creation_res.err().unwrap();
-    let mut finding_notes = fs::File::create(format!("{}/findings.md", &project_folder_path)).expect("error creating findings notes file");
+        println!("error creating notes folder! {}", error);
-    let mut systeminfo = fs::File::create(format!("{}/systeminfo", &project_folder_path)).expect("error creating systeminfo note file");
+    }
-    let mut netsta = fs::File::create(format!("{}/netstat", &project_folder_path)).expect("error creating netstat file");
+    else{
-    let mut creds_notes = fs::File::create(format!("{}/creds.md", &loot_folder)).expect("error creating creds note");
+        file_creation_res.unwrap();
-    let mut todo_notes = fs::File::create(format!("{}/todo.md", &project_folder_path)).expect("error creating todo notes");
+    }
-    let mut cleanup_notes = fs::File::create(format!("{}/cleanup.md", &project_folder_path)).expect("error creating cleanup notes");
+    notes_path.push("password_spray.md");
-    let mut dump_notes = fs::File::create(format!("{}/dumps.md", &loot_folder)).expect("error creating password spray notes");
+    println!("copying from {} to {}", passtemp.display(), &notes_path.display());
-    let mut enum_notes = fs::File::create(format!("{}/initial_enum.md", &project_folder_path)).expect("error creating password spray notes");
+    let pass_result = fs::copy(&passtemp, &notes_path);
-    let enum_obsidian_path = format!("Hack_Notes/pentest_notes/upcomming/{customer}//initial_enum.md", customer = comapny_name);
+    if pass_result.is_err(){
-    // for tagging notes
+        let error = pass_result.err().unwrap();
-    let oyear = project_name.split("_").collect::<Vec<&str>>()[0];
+        println!("error copying password spray file, try again manually! {}", error);
-    let year = format!("year-{}", oyear);
+    }
-    let project_type = "Internal";
+    else{
-    writeln!(&mut creds_notes, "#{} #{} #{} #l00t #creds", comapny_name, project_type, year).expect("error writing creds notes"); 
+        pass_result.unwrap();
-    writeln!(&mut dump_notes, "#{} #{} #{} #l00t #dumps", comapny_name, project_type, year).expect("error writing creds notes");
+    }
-    writeln!(&mut cleanup_notes, "#{} #{} #{} #cleanup", comapny_name, project_type, year).expect("error writing to cleanup notes");
+    notes_path.pop();
-    writeln!(&mut general_notes, "#{} #{} #{} #general", comapny_name, project_type, year).expect("error writing to general notes file");
+    notes_path.push("l00t");
-    writeln!(&mut attack_notes, "#{} #{} #{} #attack", comapny_name, project_type, year).expect("error writing attack note tags");
+    fs::create_dir_all(&notes_path).expect("error creating loot directory");
-    writeln!(&mut todo_notes,  "#{} #{} #{} #todo", comapny_name, project_type, year).expect("error writing tag line on todo");
+    notes_path.push("creds.md");
-    writeln!(&mut finding_notes, "#{} #{} #{} #findings", comapny_name, project_type, year).expect("error writing tags line on findings");
+    let creds_notes_result = create_note_file(&notes_path);
-    writeln!(&mut systeminfo, "#{} #{} #{} #general", comapny_name, project_type, year).expect("error writing tag line for system info");
+    if creds_notes_result.is_some(){
-    writeln!(&mut systeminfo, "#{} #{} #{} #Password_sprays", comapny_name, project_type, year).expect("error writing tag line for password spraying");
+        let mut creds_notes = creds_notes_result.unwrap();
-    writeln!(&mut netsta, "#{} #{} #{} #general", comapny_name, project_type, year).expect("error writing tagline in the netstat file");
+        writeln!(&mut creds_notes, "#{} #{} #l00t #creds", project.customer, "internal").expect("error writing creds notes"); 
-    writeln!(&mut enum_notes, "#{} #{} #{} #enum", comapny_name, project_type, year).expect("error writing tagline in the netstat file");
+        writeln!(&mut creds_notes, "# CREDS").expect("error writing creds notes");
-    writeln!(&mut creds_notes, "# CREDS").expect("error writing creds notes");
+        writeln!(&mut creds_notes, "\n| System | username | password |").expect("error writing creds notes");
-    writeln!(&mut creds_notes, "\n| System | username | password |").expect("error writing creds notes");
+        writeln!(&mut creds_notes, "| ------ | -------- | -------- |").expect("error writing creds notes");
-    writeln!(&mut creds_notes, "| ------ | -------- | -------- |").expect("error writing creds notes");
+        writeln!(&mut creds_notes, "\n\n").expect("error writing creds notes");
-    writeln!(&mut creds_notes, "\n\n").expect("error writing creds notes");
+        writeln!(&mut creds_notes, "# HASHES\n\n").expect("error writing creds notes");
-    writeln!(&mut creds_notes, "# HASHES\n\n").expect("error writing creds notes");
+        writeln!(&mut creds_notes, "| TYPE | USER | HASH |").expect("error writing creds notes");
-    writeln!(&mut creds_notes, "| TYPE | USER | HASH |").expect("error writing creds notes");
+        writeln!(&mut creds_notes, "| ---- | ---- | ---- |").expect("error writing creds notes");
-    writeln!(&mut creds_notes, "| ---- | ---- | ---- |").expect("error writing creds notes");
+    } 
-    writeln!(&mut cleanup_notes, "- [ ] Breach machine C-temp-fr").expect("error writing to cleanup notes");
+    notes_path.pop();
-    writeln!(&mut cleanup_notes, "- [ ] (continue to add as needed").expect("error writing ot cleanup notes");
+    notes_path.pop();
-    writeln!(&mut general_notes, "# Scope\n").expect("error writing to general notes file");
+    notes_path.push("general.md");
-    writeln!(&mut general_notes, "PASTE SCOPE FROM EXCELL HERE (THE EXCEL TO MARKDOWN TABLE PLUGIN WILL FORMAT FOR YOU").expect("shouldn't ever fail");
+    let general_result = create_note_file(&notes_path);
-    writeln!(&mut dump_notes, "# SAM\n\n").expect("shouldn't ever fail");
+    if general_result.is_some(){
-    writeln!(&mut dump_notes, "## system name\n").expect("shouldn't ever fail");
+        let mut general_notes = general_result.unwrap();
-    writeln!(&mut dump_notes, "```").expect("shouldn't ever fail");
+        writeln!(&mut general_notes, "#{} #{} #general", project.customer, "internal").expect("error writing to general notes file");
-    writeln!(&mut dump_notes, "```\n\n").expect("shouldn't ever fail");
+        writeln!(&mut general_notes, "# Scope\n").expect("error writing to general notes file");
-    writeln!(&mut dump_notes, "# LSASS\n\n").expect("shouldn't ever fail");
+        writeln!(&mut general_notes, "PASTE SCOPE FROM EXCELL HERE (THE EXCEL TO MARKDOWN TABLE PLUGIN WILL FORMAT FOR YOU").expect("shouldn't ever fail");
-    writeln!(&mut dump_notes, "## system name\n").expect("shouldn't ever fail");
+        write!(&mut general_notes, "
-    writeln!(&mut dump_notes, "```").expect("shouldn't ever fail");
-    writeln!(&mut dump_notes, "```").expect("shouldn't ever fail");
-    write!(&mut general_notes, "
 On the call: 
 
 Introductions 
@@ -151,7 +211,15 @@ Do they have a specific contact
 
 Email any follow-up items from the call to the PM 
 ").expect("error writing PPC text");
-    write!(&mut attack_notes,"
+    }
+    notes_path.pop();
+    let enum_path = format!("{}/initial_enum.md", notes_path.display());
+    notes_path.push("attacks.md");
+    let attack_result = create_note_file(&notes_path);
+    if attack_result.is_some(){
+        let mut attack_notes = attack_result.unwrap();
+        writeln!(&mut attack_notes, "#{} #{} #attack", project.customer, "internal").expect("error writing attack note tags");
+        write!(&mut attack_notes,"
 # current dat (ex: 7/5)
 Got Persistence via (schtasks, bat schtasks, startup folder)
 
@@ -206,15 +274,29 @@ powerup.ps1/sharpup.exe notes.
 
 
 
-    ", enum = enum_obsidian_path).expect("error writing to attack notes for internal tests");
+    ", enum = enum_path).expect("error writing to attack notes for internal tests");
-    write!(&mut finding_notes, "
+    }
-# normal findings
+    notes_path.pop();
+    notes_path.push("findings.md");
+    let findings_result = create_note_file(&notes_path);
+    if findings_result.is_some(){
+       let mut finding_notes = findings_result.unwrap();
+       writeln!(&mut finding_notes, "#{} #{} #findings", project.customer, "internal").expect("error writing tags line on findings");
+       write!(&mut finding_notes, "
+       # normal findings
        
-# data exfil
+       # data exfil
-## [Sarting Username]
+       ## [Sarting Username]
        
-    ").expect("error writing to findings notes on internal");
+           ").expect("error writing to findings notes on internal");
-    write!(&mut todo_notes, "
+    }
+    notes_path.pop();
+    notes_path.push("todo.md");
+    let todo_result = create_note_file(&notes_path);
+    if todo_result.is_some(){
+        let mut todo_notes = todo_result.unwrap();
+        writeln!(&mut todo_notes,  "#{} #{} #todo", project.customer, "internal").expect("error writing tag line on todo");
+        write!(&mut todo_notes, "
 
 - [ ] local checks
 - [ ] find shares
@@ -227,87 +309,47 @@ powerup.ps1/sharpup.exe notes.
 - [ ] passwords in AD Descriptions?
 - [ ] password spray
 ").expect("error writing todo list");
-write!(&mut netsta,"
+    }
-```
+    notes_path.pop();
-
+    notes_path.push("cleanup.md");
-```").expect("error writing code block to system info");
+    let cleanup_result = create_note_file(&notes_path);
-write!(&mut systeminfo,"
+    if cleanup_result.is_some(){
-```
+        let mut cleanup_notes = cleanup_result.unwrap();
-
+        writeln!(&mut cleanup_notes, "#{} #{} #cleanup", project.customer, "internal").expect("error writing to cleanup notes");
-```").expect("error writing code block to system info");
+        writeln!(&mut cleanup_notes, "- [ ] Breach machine C-temp-fr").expect("error writing to cleanup notes");
-let new_pass_path =  format!("{}/passwordspray.md", &project_folder_path);
+        writeln!(&mut cleanup_notes, "- [ ] (continue to add as needed").expect("error writing ot cleanup notes");
-println!("{}  |  {}", passtemp.display(), new_pass_path);
+    }
-fs::copy(passtemp, new_pass_path).unwrap();
 }
 
 
-pub fn start_pentest(config_path: &PathBuf) {
+pub fn start_pentest(config_path: &PathBuf, projects: &mut Vec<Project>, id: i32, upcoming_files: &PathBuf, upcoming_notes: &PathBuf, boxtemplate: &String, password_spray_file: &PathBuf) {
-    let mut pentest_notes = String::new();
+    let mut project_files = upcoming_files.clone();
-    let mut project_files = String::new();
+    let mut project_notes = upcoming_notes.clone();
-    let mut company_name = String::new();
+    let customer_name = get_user_input("Customer name?");
-    let mut project_name = String::new();
+    let project_name = get_user_input("Project Name?");
-    let mut config_file_path_buf = config_path.clone();
+    project_files.push(&customer_name);
-    let mut passpray_path = config_file_path_buf.clone();
+    project_files.push(&project_name);
-    passpray_path.push("passwordspray.md");
+    project_notes.push(&customer_name);
-    config_file_path_buf.push("new_projects.conf");
+    project_notes.push(&project_name);
-    let config_string = fs::read_to_string(config_file_path_buf).expect("error reading ");
+    println!("Files: {}\nNotes: {}\n\n", project_files.display(), project_notes.display());
-    if config_string.contains("folder_path") && config_string.contains("notes_path"){
+    let confirm_response = get_user_input("does this look ok?");
-        let config_string_vec: Vec<&str> = config_string.split("\n").collect();
+    if confirm_response.to_lowercase().contains("n"){
-        for line in config_string_vec{
+        println!("oof sorry");
-            if line.contains("project_folder_path"){
+        return;
-                let line_vec: Vec<&str> = line.split(":").collect();
-                project_files = line_vec[1].to_owned();
-            }
-            else if line.contains("project_notes_path"){
-                let line_vec: Vec<&str> = line.split(":").collect();
-                pentest_notes = line_vec[1].to_owned();
-            }
-        }
     }
-    println!("Project files path: {}\nProject Notes path: {}", project_files, pentest_notes);
+    let mut working = project_files.clone();
-    println!("Comapny Name?");
+    create_project_folder(&mut working, "working");
-    std::io::stdin().read_line(&mut company_name);
+    create_project_folder(&mut working, "writing");
-    println!("project Name?");
+    create_project_folder(&mut working, "delivery");
-    stdin().read_line(&mut project_name);
+    let project_boxname = format!("{}_{}", boxtemplate, customer_name);
-    //remove new lines from input
+    let new_prject = Project{customer:customer_name.clone(), project_name:project_name.clone(), notes_folder:project_notes.clone(), files_folder:project_files.clone(),active:false, boxname:project_boxname.clone(),stage:"upcoming".to_owned(), id};
-    company_name.trim_end();
+    if project_name.contains("external"){
-    project_name.trim_end();
+        external(password_spray_file, &new_prject);
-    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);
-    let working_folder = format!("{}/working", &project_files_folder_path);
-    let writing_folder = format!("{}/writing", &project_files_folder_path);
-    let screeenshot_folder = format!("{}/screenshots",&writing_folder);
-    let delivery_folder = format!("{}/delivery", &project_files_folder_path);
-    // make the folders for this project's notes and files
-    println!("creating directory structure for notes and file folders...");
-    fs::create_dir_all(&project_folder_path).expect("Error creating project folder");
-    fs::create_dir_all(&project_files_folder_path).expect("Error creating project file folder");
-    fs::create_dir_all(&working_folder).expect("error creating working directory");
-    fs::create_dir_all(&writing_folder).expect("Error creating writing direcotry");
-    fs::create_dir(&screeenshot_folder).expect("error creating screenshots folder");
-    fs::create_dir_all(&delivery_folder).expect("Error creating delivery direcotry");
-    if project_name.contains("internal"){
-        println!("internal pentest type detected, auto populating notes with internal layout...");
-        internal(project_folder_path,&company_name, &project_name, passpray_path);
     }
-    else if project_name.contains("external") {
+    else if project_name.contains("internal"){
-        println!("external pentest type detected, auto populating notes with external layout...");
+        internal(password_spray_file, &new_prject);
-        external(project_folder_path, &company_name, &project_name, passpray_path);
     }
-    else if project_name.contains("webapp") {
+    projects.push(new_prject);
-        println!("not implemented yet sorry");
+    project_controls::save_projects(projects, config_path);
-        println!("default file folder structure used, and empty notes folder created...")
+    println!("project created and saved to the projects config file!");
-    }
-    else{
-        println!("unknown project type detected, default folder strucutre and empty note folder created...");
-        print!("
-Known project types:
-Internal Penetration Test
-External Penetartion Test
-
-If this test is actually one of these types please include the type in the project name parameter, example: 2023_internal_pentest.
-If this test is a common test and you would like a default note structure implemented in this script let Kevin \"Kage\" Gunter know and supply an example markdown note sheet.");
-        }
-    
 }

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}