diff --git a/pentest_tool/src/install.rs b/pentest_tool/src/install.rs index a3d3988..58eff4e 100644 --- a/pentest_tool/src/install.rs +++ b/pentest_tool/src/install.rs @@ -101,6 +101,8 @@ fn setup_folders(config_path: &PathBuf) -> (String, String, String, String, Stri else if have_rig.contains("n"){ println!("ooof ok freeloader"); cracking_rig = "n".to_owned(); + rule = "n".to_owned(); + rockyou = "n".to_owned(); } } } @@ -111,10 +113,10 @@ fn setup_folders(config_path: &PathBuf) -> (String, String, String, String, Stri tools_folder = tools_folder.trim_end().to_owned(); cracking_rig = cracking_rig.trim_end().to_owned(); cracking_user = cracking_user.trim_end().to_owned(); - let new_files_path = PathBuf::from(&new_files_folder); - let new_notes_path = PathBuf::from(&new_notes_folder); - let upcomming_files_path = PathBuf::from(&upcomming_files_folder); - let upcomming_notes_path = PathBuf::from(&upcomming_notes_folder); + let 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..."); @@ -188,7 +190,7 @@ pub fn install(config_path: &PathBuf){ 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 template_name = String::new(); let mut have_template = String::new(); @@ -229,9 +231,9 @@ Do you have a distrobox set up to function as your template for all new projects let _list = process::Command::new("distrobox").arg("list").arg("--root").status(); println!("distrobox template name?"); std::io::stdin().read_line(&mut template_name).unwrap(); - let config_string = format!("Project_files:{}\nProject_notes:{}\ntools_folder:{}\nbox_template:{}\nterminal:{}\ncracking_rig:{}@{}\nrockyou_location:{}\nrule_location:{}", files_response.trim_end(), notes_response.trim_end(), tools_response.trim_end(),template_name.trim_end(), _terminal_command.trim_end(), cracking_user.trim_ascii_end(), cracking_rig.trim_end(), rockyou.trim_end(), rule.trim_end()); + let config_string = format!("Project_files:{}\nProject_notes:{}\ntools_folder:{}\nupcoming_files:{}\nupcoming_notes:{}\nbox_template:{}\nterminal:{}\ncracking_rig:{}@{}\nrockyou_location:{}\nrule_location:{}", 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()); config_file.write_all(config_string.as_bytes()).expect("error writing to config file"); - let default_projectline = format!("default:default:{}:{}:yes:{}", ¬es_response.trim_end(), &files_response.trim_end(), &template_name.trim_end()); + let default_projectline = format!("default:default:{}:{}:yes:{}:current", ¬es_response.trim_end(), &files_response.trim_end(), &template_name.trim_end()); projects_conf_file.write_all(default_projectline.as_bytes()).expect("error writing default project line"); println!("active project folders: {}", &files_response); println!("upcomming project folders: {}", &project_folder_path); @@ -248,7 +250,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()); + config_file.write_all(pass_file_config_line.as_bytes()).expect("error writing password spray setting to config file"); let mut passpray_file = fs::File::create(password_spray_template_path).expect("error creating passwordspray file"); write!(passpray_file, " - [ ] useraspass diff --git a/pentest_tool/src/main.rs b/pentest_tool/src/main.rs index 45d6ced..dfc2668 100644 --- a/pentest_tool/src/main.rs +++ b/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)] @@ -21,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!(" @@ -57,8 +74,9 @@ fn main() { let mut cracking_rig = String::new(); let mut rockyou = String::new(); let mut rule = String::new(); - let mut upcoming_files = String::new(); - let mut upcoming_notes = String::new(); + let mut upcoming_files = PathBuf::new(); + let mut upcoming_notes = PathBuf::new(); + let mut pass_spray_file = PathBuf::new(); println!("\nconfig already generated\nloading config file...\n"); let settings_string = fs::read_to_string(&config_path).expect("error reading config file"); let settings: Vec<&str> = settings_string.split("\n").collect(); @@ -69,13 +87,14 @@ 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(), - "upcoming_files" => upcoming_files = setting_vec[1].trim_end().to_owned(), - "upcoming_notes" => upcoming_notes = setting_vec[1].trim_end().to_owned(), + "pass_file"=> pass_spray_file.push(setting_vec[1]), _ => println!("error unknown setting: {}", setting_vec[0]) } } @@ -87,11 +106,13 @@ fn main() { distrobox template: {} terminal_command: {} cracking_rig: {}\n -", project_base_folder.display(), project_base_notes.display(), tools_folder.display(), box_template, terminal_command, cracking_rig); + 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, cracking_rig, rockyou, rule, upcoming_files, upcoming_notes); + 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); } diff --git a/pentest_tool/src/menu.rs b/pentest_tool/src/menu.rs index 95240ba..07c595b 100644 --- a/pentest_tool/src/menu.rs +++ b/pentest_tool/src/menu.rs @@ -1,4 +1,6 @@ use std::clone; +use std::path; +use std::path::Path; use std::path::PathBuf; use std::process::exit; use chrono::Datelike; @@ -32,7 +34,7 @@ fn get_active_project(projects: &Vec) -> &Project{ return active_project } -pub fn main_menu(mut projects: Vec, 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: String, upcoming_notes: String){ +pub fn main_menu(mut projects: Vec, 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){ let mut loopize = true; let mut new_id = next_project_id(&config_path); loop { @@ -100,6 +102,8 @@ pub fn main_menu(mut projects: Vec, config_path: PathBuf, base_files: & NOTE OPTION 18 WILL SAVE YOUR PROJECTS BEFORE QUITTING +base prject folder: {} +upcoming project folder: {} Current Project: {} {} Working Folder: {} Notes Folder: {} @@ -132,22 +136,22 @@ Year: {} 21.) Password Spray (will print password to spray, and wait the obervation window time) 22.) crack password hashes on your cracking rig 23.) Quit Application -\n", active_project.customer, active_project.project_name, active_project.files_folder.display(), active_project.notes_folder.display(), active_project.boxname, terminal, season, year); +\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)}, "7" => project_controls::remove_project(&mut projects, &config_path), "8" => project_controls::print_upcoming_projects(&projects), - "9" => project_controls::promote_project(&mut projects, &config_path), + "9" => project_controls::promote_project(&mut projects, &config_path, base_files, base_notes, tools_dir, &boxtemplate), "10" => box_controls::project_standalone_terminal(active_project.clone(), terminal.clone()), "11" => box_controls::project_inline_terminal(active_project.clone()), "12" => box_controls::make_box(&active_project, &tools_dir, &boxtemplate, false), @@ -155,7 +159,7 @@ Year: {} "14" => info_controls::open_in_dolphin("notes", active_project.clone()), "15" => info_controls::generate_userpass(&active_project), "16" => info_controls::run_initial_enum(&active_project), - "17" =>info_controls::print_report_information(active_project.clone()), + "17" => info_controls::print_report_information(active_project.clone()), "18" => info_controls::build_cmd_for_host_discovery(&active_project), "19" => info_controls::build_cs_portscan_cmd(&active_project), "20" => box_controls::stop_all_boxes(&projects), diff --git a/pentest_tool/src/project_controls.rs b/pentest_tool/src/project_controls.rs index 83927c2..614b254 100644 --- a/pentest_tool/src/project_controls.rs +++ b/pentest_tool/src/project_controls.rs @@ -7,7 +7,7 @@ use std::process; use std::thread; use std::time::Duration; use std::str::FromStr; -use crate::project_controls; + use crate::Project; use crate::box_controls::make_box; @@ -48,7 +48,7 @@ pub fn save_projects(projects: &Vec, 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(); @@ -66,13 +66,44 @@ pub fn save_projects(projects: &Vec, config_path: &PathBuf){ } } -pub fn new_project(projects: &mut Vec, project_dir: &PathBuf, notes_dir: &PathBuf, tools_dir: &PathBuf, boxtemplate: &String, config_path: &PathBuf, new_id: i32){ - let mut new_project_dir = project_dir.clone(); - let mut new_note_dir = notes_dir.clone(); +pub fn new_project(projects: &mut Vec, project_dir: &PathBuf, notes_dir: &PathBuf, tools_dir: &PathBuf, boxtemplate: &String, config_path: &PathBuf, new_id: i32, upcoming_files: &PathBuf, upcoming_notes: &PathBuf){ + let mut new_project_dir = PathBuf::new(); + 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(); if existing_folders.contains("y") || existing_folders.contains("Y"){ @@ -184,25 +215,6 @@ pub fn new_project(projects: &mut Vec, project_dir: &PathBuf, notes_dir fs::create_dir_all(&new_project_dir).expect("error creating new files folder"); fs::create_dir_all(&new_note_dir).expect("error creating new notes folder"); } - 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...") - } - } - } thread::sleep(Duration::from_secs(2)); let box_name = format!("atarchbox_{}", customer_name); let new_project = Project{customer: customer_name.trim_end().to_owned(), @@ -214,7 +226,9 @@ pub fn new_project(projects: &mut Vec, project_dir: &PathBuf, notes_dir boxname: box_name, stage: project_stage.to_owned() }; - make_box(&new_project, &tools_dir, &boxtemplate, true); + if project_stage.contains("current"){ + make_box(&new_project, &tools_dir, &boxtemplate, true); + } projects.push(new_project); save_projects(projects, config_path); @@ -288,6 +302,12 @@ pub fn get_projects(config_path: &PathBuf) -> Vec{ 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(); @@ -321,7 +341,7 @@ pub fn print_upcoming_projects(projects: &Vec){ } } -pub fn promote_project(projects: &mut Vec, config_path: &PathBuf){ +pub fn promote_project(projects: &mut Vec, config_path: &PathBuf, project_dir: &PathBuf, notes_dir: &PathBuf, tools_dir: &PathBuf, boxtemplate: &String){ let working_projects = projects.clone(); for project in &working_projects{ if project.stage.contains("upcoming"){ @@ -335,12 +355,43 @@ pub fn promote_project(projects: &mut Vec, config_path: &PathBuf){ 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); + 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!!"); + } + 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!!"); + } + else{ + println!("failed to copy the notes folder, try to move it manually!"); + } + promoted_project.files_folder = new_files_dir; + promoted_project.notes_folder = new_notes_dir; promoted_project.stage = "current".to_owned(); + thread::sleep(Duration::from_secs(3)); + make_box(&promoted_project, tools_dir, boxtemplate, true); projects_to_save.push(promoted_project); } else{ diff --git a/pentest_tool/src/start_pentest.rs b/pentest_tool/src/start_pentest.rs index 5678e54..a0408f5 100644 --- a/pentest_tool/src/start_pentest.rs +++ b/pentest_tool/src/start_pentest.rs @@ -1,25 +1,54 @@ 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"); - let mut attack_notes = fs::File::create(format!("{}/attacks.md", &project_folder_path)).expect("error creating attack notes file"); - let mut host_notes = fs::File::create(format!("{}/host_notes.md", &project_folder_path)).expect("error creating host notes file"); - let mut finding_notes = fs::File::create(format!("{}/findings.md", &project_folder_path)).expect("error creating findings notes file"); - // for tagging - let year = project_name.split("_").collect::>()[1]; - let project_type = "External"; - writeln!(&mut general_notes, "#{} #{} #{} #general", comapny_name, project_type, year).expect("error writing to general notes file"); - 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"); - 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"); - 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, " + +fn create_project_folder(path: &mut PathBuf, folder: &str){ + path.push(folder); + let result = fs::create_dir_all(&path); + if result.is_err(){ + println!("error creating {} directory!", folder); + } + else{ + result.unwrap(); + } + path.pop(); +} + +fn create_note_file(path: &PathBuf) -> Option{ + let result = fs::File::create(path); + if result.is_err(){ + 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(); + notes_path.push("general.md"); + let general_notes_result = fs::File::create(¬es_path); + if general_notes_result.is_err(){ + println!("oof we ran into issues making the general notes! try to creat manually!"); + } + else { + 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 +83,17 @@ 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 = fs::File::create(¬es_path); + if attack_notes_result.is_err(){ + println!("oof we ran into issues making the general notes! try to creat manually!"); + } + else { + 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 +112,85 @@ 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, ¬es_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 = fs::File::create(¬es_path); + if host_notes_result.is_err(){ + println!("error creating host notes, try manually!"); + } + else{ + 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 = fs::File::create(notes_path); + if findings_notes_result.is_err(){ + println!("error creating host findings file, try manually!"); + } + else{ + 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){ - let loot_folder = format!("{}/l00t", project_folder_path); - fs::create_dir_all(&loot_folder).expect("error creating loot directory"); - let mut general_notes = fs::File::create(format!("{}/general.md", &project_folder_path)).expect("error creating general notes file"); - let mut attack_notes = fs::File::create(format!("{}/attacks.md", &project_folder_path)).expect("error creating attack notes file"); - let mut finding_notes = fs::File::create(format!("{}/findings.md", &project_folder_path)).expect("error creating findings notes file"); - 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"); - let mut creds_notes = fs::File::create(format!("{}/creds.md", &loot_folder)).expect("error creating creds note"); - 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"); - let mut dump_notes = fs::File::create(format!("{}/dumps.md", &loot_folder)).expect("error creating password spray notes"); - let mut enum_notes = fs::File::create(format!("{}/initial_enum.md", &project_folder_path)).expect("error creating password spray notes"); - let enum_obsidian_path = format!("Hack_Notes/pentest_notes/upcomming/{customer}//initial_enum.md", customer = comapny_name); - // for tagging notes - let oyear = project_name.split("_").collect::>()[0]; - let year = format!("year-{}", oyear); - let project_type = "Internal"; - writeln!(&mut creds_notes, "#{} #{} #{} #l00t #creds", comapny_name, project_type, year).expect("error writing creds notes"); - 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"); - writeln!(&mut general_notes, "#{} #{} #{} #general", comapny_name, project_type, year).expect("error writing to general notes file"); - writeln!(&mut attack_notes, "#{} #{} #{} #attack", comapny_name, project_type, year).expect("error writing attack note tags"); - writeln!(&mut todo_notes, "#{} #{} #{} #todo", comapny_name, project_type, year).expect("error writing tag line on todo"); - writeln!(&mut finding_notes, "#{} #{} #{} #findings", comapny_name, project_type, year).expect("error writing tags line on findings"); - writeln!(&mut systeminfo, "#{} #{} #{} #general", comapny_name, project_type, year).expect("error writing tag line for system info"); - writeln!(&mut systeminfo, "#{} #{} #{} #Password_sprays", comapny_name, project_type, year).expect("error writing tag line for password spraying"); - writeln!(&mut netsta, "#{} #{} #{} #general", comapny_name, project_type, year).expect("error writing tagline in the netstat file"); - 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, "\n| System | username | password |").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, "# HASHES\n\n").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 cleanup_notes, "- [ ] Breach machine C-temp-fr").expect("error writing to cleanup notes"); - writeln!(&mut cleanup_notes, "- [ ] (continue to add as needed").expect("error writing ot cleanup notes"); - writeln!(&mut general_notes, "# Scope\n").expect("error writing to general notes file"); - 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, "# SAM\n\n").expect("shouldn't ever fail"); - writeln!(&mut dump_notes, "## system name\n").expect("shouldn't ever fail"); - writeln!(&mut dump_notes, "```").expect("shouldn't ever fail"); - writeln!(&mut dump_notes, "```\n\n").expect("shouldn't ever fail"); - writeln!(&mut dump_notes, "# LSASS\n\n").expect("shouldn't ever fail"); - writeln!(&mut dump_notes, "## system name\n").expect("shouldn't ever fail"); - writeln!(&mut dump_notes, "```").expect("shouldn't ever fail"); - writeln!(&mut dump_notes, "```").expect("shouldn't ever fail"); - write!(&mut general_notes, " +fn internal(passtemp: &PathBuf, project: &Project){ + let mut notes_path = project.notes_folder.clone(); + let file_creation_res = fs::create_dir_all(¬es_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("password_spray.md"); + println!("copying from {} to {}", passtemp.display(), ¬es_path.display()); + let pass_result = fs::copy(&passtemp, ¬es_path); + if pass_result.is_err(){ + let error = pass_result.err().unwrap(); + println!("error copying password spray file, try again manually! {}", error); + } + else{ + pass_result.unwrap(); + } + notes_path.pop(); + notes_path.push("l00t"); + fs::create_dir_all(¬es_path).expect("error creating loot directory"); + notes_path.push("creds.md"); + let creds_notes_result = create_note_file(¬es_path); + if creds_notes_result.is_some(){ + let mut creds_notes = creds_notes_result.unwrap(); + writeln!(&mut creds_notes, "#{} #{} #l00t #creds", project.customer, "internal").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, "| ------ | -------- | -------- |").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, "| TYPE | USER | HASH |").expect("error writing creds notes"); + writeln!(&mut creds_notes, "| ---- | ---- | ---- |").expect("error writing creds notes"); + } + notes_path.pop(); + notes_path.pop(); + notes_path.push("general.md"); + let general_result = create_note_file(¬es_path); + if general_result.is_some(){ + let mut general_notes = general_result.unwrap(); + writeln!(&mut general_notes, "#{} #{} #general", project.customer, "internal").expect("error writing to general notes file"); + writeln!(&mut general_notes, "# Scope\n").expect("error writing to general notes file"); + writeln!(&mut general_notes, "PASTE SCOPE FROM EXCELL HERE (THE EXCEL TO MARKDOWN TABLE PLUGIN WILL FORMAT FOR YOU").expect("shouldn't ever fail"); + write!(&mut general_notes, " On the call: Introductions @@ -151,7 +215,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(¬es_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 +278,29 @@ powerup.ps1/sharpup.exe notes. - ", enum = enum_obsidian_path).expect("error writing to attack notes for internal tests"); - write!(&mut finding_notes, " -# normal findings - -# data exfil -## [Sarting Username] - - ").expect("error writing to findings notes on internal"); - write!(&mut todo_notes, " + ", enum = enum_path).expect("error writing to attack notes for internal tests"); + } + notes_path.pop(); + notes_path.push("findings.md"); + let findings_result = create_note_file(¬es_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 + ## [Sarting Username] + + ").expect("error writing to findings notes on internal"); + } + notes_path.pop(); + notes_path.push("todo.md"); + let todo_result = create_note_file(¬es_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,94 +313,41 @@ powerup.ps1/sharpup.exe notes. - [ ] passwords in AD Descriptions? - [ ] password spray ").expect("error writing todo list"); -write!(&mut netsta," -``` - -```").expect("error writing code block to system info"); -write!(&mut systeminfo," -``` - -```").expect("error writing code block to system info"); -let new_pass_path = format!("{}/passwordspray.md", &project_folder_path); -println!("{} | {}", passtemp.display(), new_pass_path); -fs::copy(passtemp, new_pass_path).unwrap(); + } + notes_path.pop(); + notes_path.push("cleanup.md"); + let cleanup_result = create_note_file(¬es_path); + 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"); + writeln!(&mut cleanup_notes, "- [ ] Breach machine C-temp-fr").expect("error writing to cleanup notes"); + writeln!(&mut cleanup_notes, "- [ ] (continue to add as needed").expect("error writing ot cleanup notes"); + } } -pub fn start_pentest(config_path: &PathBuf) { - let mut pentest_notes = String::new(); - let mut project_files = String::new(); - let mut company_name = String::new(); - let mut project_name = String::new(); - let mut config_file_path_buf = config_path.clone(); - config_file_path_buf.pop(); - let mut passpray_path = config_file_path_buf.clone(); - passpray_path.push("passwordspray.md"); - config_file_path_buf.push("new_projects.conf"); - let config_string = fs::read_to_string(config_file_path_buf).expect("error reading "); - if config_string.contains("folder_path") && config_string.contains("notes_path"){ - let config_string_vec: Vec<&str> = config_string.split("\n").collect(); - for line in config_string_vec{ - if line.contains("project_folder_path"){ - 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(); - } - } +pub fn start_pentest(config_path: &PathBuf, projects: &mut Vec, id: i32, upcoming_files: &PathBuf, upcoming_notes: &PathBuf, boxtemplate: &String, password_spray_file: &PathBuf) { + let mut project_files = upcoming_files.clone(); + let mut project_notes = upcoming_notes.clone(); + let customer_name = get_user_input("Customer name?"); + let project_name = get_user_input("Project Name?"); + project_files.push(&customer_name); + project_files.push(&project_name); + project_notes.push(&customer_name); + project_notes.push(&project_name); + let mut working = project_files.clone(); + create_project_folder(&mut working, "working"); + create_project_folder(&mut working, "writing"); + create_project_folder(&mut working, "delivery"); + let project_boxname = format!("{}_{}", boxtemplate, customer_name); + 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}; + if project_name.contains("external"){ + external(password_spray_file, &new_prject); } - println!("Project files path: {}\nProject Notes path: {}", project_files, pentest_notes); - println!("Comapny Name?"); - match std::io::stdin().read_line(&mut company_name){ - Ok(_result) => (), - Err(_e) => {println!("we need input here dummy!"); return;} + else if project_name.contains("internal"){ + internal(password_spray_file, &new_prject); } - println!("project Name?"); - match stdin().read_line(&mut project_name){ - Ok(_result) => (), - Err(_e) => {println!("we need input here dummy!"); return;} - } - //remove new lines from input - company_name = company_name.trim_end().to_owned(); - project_name = project_name.trim_end().to_owned(); - let project_folder_path = format!("{}/{}/{}", pentest_notes, company_name,project_name); - println!("setting folder creation paths..."); - let project_files_folder_path = format!("{}/{}/{}", project_files, company_name, project_name); - 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") { - println!("external pentest type detected, auto populating notes with external layout..."); - external(project_folder_path, &company_name, &project_name, passpray_path); - } - else if project_name.contains("webapp") { - println!("not implemented yet sorry"); - println!("default file folder structure used, and empty notes folder created...") - } - 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."); - } - + projects.push(new_prject); + project_controls::save_projects(projects, config_path); + println!("project created and saved to the projects config file!"); } \ No newline at end of file