Added logic and settings for enabling fingerprint

authentication within distro box

Author: Pyro57000

pentest_tool/src/box_controls.rs

@@ -70,7 +70,7 @@ 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){
+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(){
@@ -91,55 +91,68 @@ pub fn make_box(project: &Project, tools_dir: &PathBuf, boxtemplate: &String, ne
         }
     }
     let mut box_name_path = project.files_folder.clone();
-    let mut box_name = format!("atarchbox_{}", &project.customer);
+    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());
-    println!("distrobox create --root --init --clone {} --volume {} --volume {} --name {}", boxtemplate, toold_volume,  pentest_volume, box_name);
-    let distrobox_result = process::Command::new("distrobox")
-                                                                .arg("create")
-                                                                .arg("--root")
-                                                                .arg("--init")
-                                                                .arg("--unshare-all")
-                                                                .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!");
+    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{
-            println!("ooof did not start successfully try entering it yoruself");
-            println!("distrobox enter --rrot {} -- sudo -s ln -sf /pentest/boxname /etc/boxname", &box_name);
+            first = false;
         }
     }
-    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 --root {} -- sudo -s ln -sf /pentest/boxname /etc/boxname", &box_name);
+    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);
+            }
+        }
     }
 }
 

pentest_tool/src/install.rs

@@ -5,12 +5,15 @@ 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();
@@ -286,18 +289,47 @@ 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!("example distrobox setup command:");
-        println!("distrobox create --root --image archlinux --name template");
-        println!("then enter that distrobox and install all the tools you want and do what ever setup you need");
-        println!("and re-run this tool.");
-        process::Command::new("rm").arg(del_on_fail).spawn().expect("ERROR deleting config folder, please manually clean up");
-        std::process::exit(1);
+        println!("ooof buddy, should have had that already... no worries, we'll make one now.");
+        let new_boxname = get_user_input("name for your template box? (for exmaple I use atarchbox cause its my attacking archbox ;-)");
+        println!("please review the following link to select an image to use for your distrobox");
+        println!("https://distrobox.it/compatibility/#containers-distros");
+        let image_name = get_user_input("which image would you like to use?");
+        let tools_volume =format!("{}:/tools:rw", &tools_response);
+        let distrobox_create_res = Command::new("distrobox")
+                                                        .arg("create")
+                                                        .arg("--root")
+                                                        .arg("--name")
+                                                        .arg(new_boxname)
+                                                        .arg("--init")
+                                                        .arg("--image")
+                                                        .arg(image_name)
+                                                        .arg("--volume")
+                                                        .arg(tools_volume)
+                                                        .arg("--additional-packages")
+                                                        .arg("systemd")
+                                                        .arg("--")
+                                                        .arg("exit")
+                                                        .status();
+        if distrobox_create_res.is_err(){
+            let error = distrobox_create_res.err().unwrap();
+            println!("ooof we ran into a problem creating your distrobox....");
+            println!("{}", 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:{}\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());
+    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:{}: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");

pentest_tool/src/main.rs

@@ -77,6 +77,7 @@ fn main() {
     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();
@@ -95,6 +96,7 @@ fn main() {
                 "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])
             }
         }
@@ -114,5 +116,5 @@ fn main() {
     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, &pass_spray_file);
+    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,11 +1,6 @@
-use core::time;
-use std::clone;
-use std::path;
-use std::path::Path;
 use std::path::PathBuf;
 use std::process::exit;
 use chrono::Datelike;
-use chrono::Duration;
 use clearscreen::clear;
 use clearscreen;
 use chrono::Local;
@@ -36,7 +31,7 @@ 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, cracking_rig: String, rockyou: String, rule: String, upcoming_files: &PathBuf, upcoming_notes: &PathBuf, password_spray_file: &PathBuf){
+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(); 
@@ -154,14 +149,14 @@ Year: {}
             "3" => project_controls::switch_project(&mut projects),
             "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, &upcoming_files, &upcoming_notes)},
+            "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" => project_controls::print_upcoming_projects(&projects),
-            "9" => project_controls::promote_project(&mut projects, &config_path, base_files, base_notes, tools_dir, &boxtemplate),
+            "9" => project_controls::promote_project(&mut projects, &config_path, base_files, base_notes, tools_dir, &boxtemplate, fingerprint),
             "10" => box_controls::project_standalone_terminal(active_project.clone(), terminal.clone()),
             "11" => box_controls::project_inline_terminal(active_project.clone()),
             "12" => {let cs_thread = box_controls::launch_cobalt_strike(active_project.clone()); if cs_thread.is_some(){threads.push(cs_thread.unwrap());}},
-            "13" => box_controls::make_box(&active_project, &tools_dir, &boxtemplate, false),
+            "13" => box_controls::make_box(&active_project, &tools_dir, &boxtemplate, false, fingerprint),
             "14" => info_controls::open_in_dolphin("files", active_project.clone()),
             "15" => info_controls::open_in_dolphin("notes", active_project.clone()),
             "16" => info_controls::generate_userpass(&active_project),

pentest_tool/src/project_controls.rs

@@ -68,7 +68,7 @@ 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, upcoming_files: &PathBuf, upcoming_notes: &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, upcoming_files: &PathBuf, upcoming_notes: &PathBuf, fingerprint: bool){
     let mut new_project_dir = PathBuf::new();
     let mut new_note_dir = PathBuf::new();
     let mut existing_folders = String::new();
@@ -229,7 +229,7 @@ pub fn new_project(projects: &mut Vec<Project>, project_dir: &PathBuf, notes_dir
                                     stage: project_stage.to_owned()
                                       };
     if project_stage.contains("current"){
-        make_box(&new_project, &tools_dir, &boxtemplate, true);
+        make_box(&new_project, &tools_dir, &boxtemplate, true, fingerprint);
     }
     projects.push(new_project);
     save_projects(projects, config_path);
@@ -343,7 +343,7 @@ pub fn print_upcoming_projects(projects: &Vec<Project>){
     }
 }
 
-pub fn promote_project(projects: &mut Vec<Project>, config_path: &PathBuf, project_dir: &PathBuf, notes_dir: &PathBuf, tools_dir: &PathBuf, boxtemplate: &String){
+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"){
@@ -434,7 +434,7 @@ pub fn promote_project(projects: &mut Vec<Project>, config_path: &PathBuf, proje
                 }
             }
             thread::sleep(Duration::from_secs(3));
-            make_box(&promoted_project, tools_dir, boxtemplate, true);
+            make_box(&promoted_project, tools_dir, boxtemplate, true, fingerprint);
             projects_to_save.push(promoted_project);
         }
         else{