pyro/pentest_tool
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor for upcomming project management

Browse Source
This commit is contained in:
pyro57000
2025-03-05 14:56:17 -06:00
parent 7765640e0e
commit 4dba68cdcf
5 changed files with 326 additions and 214 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
pentest_tool/src/install.rs
View File

@@ -101,6 +101,8 @@ fn setup_folders(config_path: &PathBuf) -> (String, String, String, String, Stri
else if have_rig.contains("n"){ else if have_rig.contains("n"){
println!("ooof ok freeloader"); println!("ooof ok freeloader");
cracking_rig = "n".to_owned(); 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(); tools_folder = tools_folder.trim_end().to_owned();
cracking_rig = cracking_rig.trim_end().to_owned(); cracking_rig = cracking_rig.trim_end().to_owned();
cracking_user = cracking_user.trim_end().to_owned(); cracking_user = cracking_user.trim_end().to_owned();
let new_files_path = PathBuf::from(&new_files_folder); let new_files_path = PathBuf::from(&new_files_folder.trim_end());
let new_notes_path = PathBuf::from(&new_notes_folder); let new_notes_path = PathBuf::from(&new_notes_folder.trim_end());
let upcomming_files_path = PathBuf::from(&upcomming_files_folder); let upcomming_files_path = PathBuf::from(&upcomming_files_folder.trim_end());
let upcomming_notes_path = PathBuf::from(&upcomming_notes_folder); let upcomming_notes_path = PathBuf::from(&upcomming_notes_folder.trim_end());
let tools_path = PathBuf::from(&tools_folder.trim_end()); let tools_path = PathBuf::from(&tools_folder.trim_end());
if new_files_path.exists() == false{ if new_files_path.exists() == false{
println!("active project file folder does not exist, creating..."); 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!"); println!("bell notification tone sucessfully downloaded!");
let mut config_file = fs::File::create(config_path).expect("error creating file"); 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"); 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 terminal_response = String::new();
let mut template_name = String::new(); let mut template_name = String::new();
let mut have_template = 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(); let _list = process::Command::new("distrobox").arg("list").arg("--root").status();
println!("distrobox template name?"); println!("distrobox template name?");
std::io::stdin().read_line(&mut template_name).unwrap(); 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"); 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"); projects_conf_file.write_all(default_projectline.as_bytes()).expect("error writing default project line");
println!("active project folders: {}", &files_response); println!("active project folders: {}", &files_response);
println!("upcomming project folders: {}", &project_folder_path); 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(); let mut password_spray_template_path = install_path.clone();
install_path.push("new_projects.conf"); install_path.push("new_projects.conf");
password_spray_template_path.push("passwordspray.md"); 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"); let mut passpray_file = fs::File::create(password_spray_template_path).expect("error creating passwordspray file");
write!(passpray_file, " write!(passpray_file, "
- [ ] useraspass - [ ] useraspass

35
pentest_tool/src/main.rs
View File

@@ -1,5 +1,6 @@
use std::path::PathBuf; use std::{io::stdin, path::PathBuf};
use directories::UserDirs; use directories::UserDirs;
use reqwest::Response;
use std::fs; use std::fs;
#[derive(Clone)] #[derive(Clone)]
@@ -21,6 +22,22 @@ mod box_controls;
mod info_controls; mod info_controls;
mod start_pentest; 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() { fn main() {
print!(" print!("
@@ -57,8 +74,9 @@ fn main() {
let mut cracking_rig = String::new(); let mut cracking_rig = String::new();
let mut rockyou = String::new(); let mut rockyou = String::new();
let mut rule = String::new(); let mut rule = String::new();
let mut upcoming_files = String::new(); let mut upcoming_files = PathBuf::new();
let mut upcoming_notes = String::new(); let mut upcoming_notes = PathBuf::new();
let mut pass_spray_file = PathBuf::new();
println!("\nconfig already generated\nloading config file...\n"); println!("\nconfig already generated\nloading config file...\n");
let settings_string = fs::read_to_string(&config_path).expect("error reading config file"); let settings_string = fs::read_to_string(&config_path).expect("error reading config file");
let settings: Vec<&str> = settings_string.split("\n").collect(); 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_files" => project_base_folder.push(setting_vec[1].trim_end()),
"Project_notes" => project_base_notes.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()), "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(), "box_template" => box_template = setting_vec[1].trim_end().to_owned(),
"terminal" => terminal_command = 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(), "cracking_rig" => cracking_rig = setting_vec[1].trim_end().to_owned(),
"rockyou_location" => rockyou = 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(), "rule_location" => rule = setting_vec[1].trim_end().to_owned(),
"upcoming_files" => upcoming_files = setting_vec[1].trim_end().to_owned(), "pass_file"=> pass_spray_file.push(setting_vec[1]),
"upcoming_notes" => upcoming_notes = setting_vec[1].trim_end().to_owned(),
_ => println!("error unknown setting: {}", setting_vec[0]) _ => println!("error unknown setting: {}", setting_vec[0])
} }
} }
@@ -87,11 +106,13 @@ fn main() {
distrobox template: {} distrobox template: {}
terminal_command: {} terminal_command: {}
cracking_rig: {}\n 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..."); println!("loading project configs...");
let projects = project_controls::get_projects(&config_path); let projects = project_controls::get_projects(&config_path);
println!("Enter to start main menu"); println!("Enter to start main menu");
let mut enter = String::new(); let mut enter = String::new();
std::io::stdin().read_line(&mut enter).unwrap(); 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);
} }

18
pentest_tool/src/menu.rs
View File

@@ -1,4 +1,6 @@
use std::clone; use std::clone;
use std::path;
use std::path::Path;
use std::path::PathBuf; use std::path::PathBuf;
use std::process::exit; use std::process::exit;
use chrono::Datelike; use chrono::Datelike;
@@ -32,7 +34,7 @@ fn get_active_project(projects: &Vec<Project>) -> &Project{
return active_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, cracking_rig: String, rockyou: String, rule: String, upcoming_files: String, upcoming_notes: 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){
let mut loopize = true; let mut loopize = true;
let mut new_id = next_project_id(&config_path); let mut new_id = next_project_id(&config_path);
loop { loop {
@@ -100,6 +102,8 @@ pub fn main_menu(mut projects: Vec<Project>, config_path: PathBuf, base_files: &
NOTE OPTION 18 WILL SAVE YOUR PROJECTS BEFORE QUITTING NOTE OPTION 18 WILL SAVE YOUR PROJECTS BEFORE QUITTING
base prject folder: {}
upcoming project folder: {}
Current Project: {} {} Current Project: {} {}
Working Folder: {} Working Folder: {}
Notes Folder: {} Notes Folder: {}
@@ -132,22 +136,22 @@ Year: {}
21.) Password Spray (will print password to spray, and wait the obervation window time) 21.) Password Spray (will print password to spray, and wait the obervation window time)
22.) crack password hashes on your cracking rig 22.) crack password hashes on your cracking rig
23.) Quit Application 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"); std::io::stdin().read_line(&mut response).expect("error getting menu input");
clear().expect("error clearing screen"); clear().expect("error clearing screen");
match response.as_str().trim_end(){ 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()), "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!("+++++++++++++++++++++"); "2" => {println!("+++++++++++++++++++++");
for project in &projects{ for project in &projects{
println!("++{}|{}++",project.customer ,project.project_name)} println!("++Customer: {}|Project name: {}|Stage: {}++",project.customer ,project.project_name, project.stage)}
println!("++++++++++++++++++++")}, println!("++++++++++++++++++++")},
"3" => project_controls::switch_project(&mut projects), "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), "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), "7" => project_controls::remove_project(&mut projects, &config_path),
"8" => project_controls::print_upcoming_projects(&projects), "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()), "10" => box_controls::project_standalone_terminal(active_project.clone(), terminal.clone()),
"11" => box_controls::project_inline_terminal(active_project.clone()), "11" => box_controls::project_inline_terminal(active_project.clone()),
"12" => box_controls::make_box(&active_project, &tools_dir, &boxtemplate, false), "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()), "14" => info_controls::open_in_dolphin("notes", active_project.clone()),
"15" => info_controls::generate_userpass(&active_project), "15" => info_controls::generate_userpass(&active_project),
"16" => info_controls::run_initial_enum(&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), "18" => info_controls::build_cmd_for_host_discovery(&active_project),
"19" => info_controls::build_cs_portscan_cmd(&active_project), "19" => info_controls::build_cs_portscan_cmd(&active_project),
"20" => box_controls::stop_all_boxes(&projects), "20" => box_controls::stop_all_boxes(&projects),

103
pentest_tool/src/project_controls.rs
View File

@@ -7,7 +7,7 @@ use std::process;
use std::thread; use std::thread;
use std::time::Duration; use std::time::Duration;
use std::str::FromStr; use std::str::FromStr;
use crate::project_controls;
use crate::Project; use crate::Project;
use crate::box_controls::make_box; use crate::box_controls::make_box;
@@ -48,7 +48,7 @@ pub fn save_projects(projects: &Vec<Project>, config_path: &PathBuf){
save_file_path.pop(); save_file_path.pop();
save_file_path.push("projects.conf"); save_file_path.push("projects.conf");
let mut save_file = fs::File::create(save_file_path).expect("error creating save_file"); 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{ for project in projects{
let default = format!{"{}:{}:{}:{}:", project.customer, project.project_name, project.notes_folder.display(), project.files_folder.display()}; let default = format!{"{}:{}:{}:{}:", project.customer, project.project_name, project.notes_folder.display(), project.files_folder.display()};
let mut _outline = String::new(); let mut _outline = String::new();
@@ -66,13 +66,44 @@ pub fn save_projects(projects: &Vec<Project>, config_path: &PathBuf){
} }
} }
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){
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 existing_folders = String::new();
let mut customer_name = String::new(); let mut customer_name = String::new();
let mut project_name = String::new(); let mut project_name = String::new();
let mut project_stage = 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"); println!("do you have an existing notes and folder structure to copy over?\ny/n");
std::io::stdin().read_line(&mut existing_folders).unwrap(); std::io::stdin().read_line(&mut existing_folders).unwrap();
if existing_folders.contains("y") || existing_folders.contains("Y"){ if existing_folders.contains("y") || existing_folders.contains("Y"){
@@ -184,25 +215,6 @@ pub fn new_project(projects: &mut Vec<Project>, project_dir: &PathBuf, notes_dir
fs::create_dir_all(&new_project_dir).expect("error creating new files folder"); 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"); 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)); thread::sleep(Duration::from_secs(2));
let box_name = format!("atarchbox_{}", customer_name); let box_name = format!("atarchbox_{}", customer_name);
let new_project = Project{customer: customer_name.trim_end().to_owned(), let new_project = Project{customer: customer_name.trim_end().to_owned(),
@@ -214,7 +226,9 @@ pub fn new_project(projects: &mut Vec<Project>, project_dir: &PathBuf, notes_dir
boxname: box_name, boxname: box_name,
stage: project_stage.to_owned() 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); projects.push(new_project);
save_projects(projects, config_path); save_projects(projects, config_path);
@@ -288,6 +302,12 @@ pub fn get_projects(config_path: &PathBuf) -> Vec<Project>{
if first != 1{ if first != 1{
if line.len() > 1{ if line.len() > 1{
let settings: Vec<&str> = line.split(":").collect(); 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 customer = settings[0].to_owned();
let project = settings[1].to_owned(); let project = settings[1].to_owned();
let notes_string = settings[2].to_owned(); let notes_string = settings[2].to_owned();
@@ -321,7 +341,7 @@ pub fn print_upcoming_projects(projects: &Vec<Project>){
} }
} }
pub fn promote_project(projects: &mut Vec<Project>, config_path: &PathBuf){ pub fn promote_project(projects: &mut Vec<Project>, config_path: &PathBuf, project_dir: &PathBuf, notes_dir: &PathBuf, tools_dir: &PathBuf, boxtemplate: &String){
let working_projects = projects.clone(); let working_projects = projects.clone();
for project in &working_projects{ for project in &working_projects{
if project.stage.contains("upcoming"){ if project.stage.contains("upcoming"){
@@ -335,12 +355,43 @@ pub fn promote_project(projects: &mut Vec<Project>, config_path: &PathBuf){
println!("we need input here dummy try again...."); println!("we need input here dummy try again....");
} }
result.unwrap(); result.unwrap();
println!("{}", project_dir.display());
let promote_id: i32 = selection.trim_end().parse().unwrap(); let promote_id: i32 = selection.trim_end().parse().unwrap();
let mut projects_to_save = Vec::new(); let mut projects_to_save = Vec::new();
for project in &working_projects{ for project in &working_projects{
if project.id == promote_id{ if project.id == promote_id{
let mut promoted_project = project.clone(); 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(); 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); projects_to_save.push(promoted_project);
} }
else{ else{

361
pentest_tool/src/start_pentest.rs
View File

@@ -1,25 +1,54 @@
use std::fs; use std::fs;
use std::io::stdin; use std::fs::File;
use std::io::Write; use std::io::Write;
use std::path::PathBuf; 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();
notes_path.push("general.md");
let general_notes_result = fs::File::create(&notes_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: Planning call notes:
* methodolgy * methodolgy
* whole month testing window * whole month testing window
@@ -54,8 +83,17 @@ Planning call notes:
| IP | host notes | needs? | | IP | host notes | needs? |
| -- | ---------- | ------ |\n").expect("faile to write pentest notes"); | -- | ---------- | ------ |\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(&notes_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 # Directory Bruteforcing
- [ ] example.com - [ ] example.com
@@ -74,59 +112,85 @@ write!(&mut attack_notes,"
passwords tried: passwords tried:
* password\n * password\n
" ).expect("failed to write attack notes template"); " ).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 = fs::File::create(&notes_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){ 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: On the call:
Introductions Introductions
@@ -151,7 +215,15 @@ Do they have a specific contact
Email any follow-up items from the call to the PM Email any follow-up items from the call to the PM
").expect("error writing PPC text"); ").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) # current dat (ex: 7/5)
Got Persistence via (schtasks, bat schtasks, startup folder) 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"); ", 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 - [ ] local checks
- [ ] find shares - [ ] find shares
@@ -227,94 +313,41 @@ powerup.ps1/sharpup.exe notes.
- [ ] passwords in AD Descriptions? - [ ] passwords in AD Descriptions?
- [ ] password spray - [ ] password spray
").expect("error writing todo list"); ").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);
config_file_path_buf.pop(); project_files.push(&project_name);
let mut passpray_path = config_file_path_buf.clone(); project_notes.push(&customer_name);
passpray_path.push("passwordspray.md"); project_notes.push(&project_name);
config_file_path_buf.push("new_projects.conf"); let mut working = project_files.clone();
let config_string = fs::read_to_string(config_file_path_buf).expect("error reading "); create_project_folder(&mut working, "working");
if config_string.contains("folder_path") && config_string.contains("notes_path"){ create_project_folder(&mut working, "writing");
let config_string_vec: Vec<&str> = config_string.split("\n").collect(); create_project_folder(&mut working, "delivery");
for line in config_string_vec{ let project_boxname = format!("{}_{}", boxtemplate, customer_name);
if line.contains("project_folder_path"){ 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};
let line_vec: Vec<&str> = line.split(":").collect(); if project_name.contains("external"){
project_files = line_vec[1].to_owned(); external(password_spray_file, &new_prject);
}
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); else if project_name.contains("internal"){
println!("Comapny Name?"); internal(password_spray_file, &new_prject);
match std::io::stdin().read_line(&mut company_name){
Ok(_result) => (),
Err(_e) => {println!("we need input here dummy!"); return;}
} }
println!("project Name?"); projects.push(new_prject);
match stdin().read_line(&mut project_name){ project_controls::save_projects(projects, config_path);
Ok(_result) => (), println!("project created and saved to the projects config file!");
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.");
}
} }