feat: add password authentication and SSH key passphrase support

- Add --password flag for password-based authentication
- Automatically detect and prompt for passphrases on encrypted SSH keys
- Support passphrase entry for both explicit and default key paths
- Check multiple default key types (ed25519, rsa, ecdsa, dsa)
- Update all commands (exec, upload, download, ping) to support new auth methods
- Add secure password/passphrase prompting using rpassword crate

Author: inureyes

README.md

@@ -7,7 +7,7 @@ A high-performance parallel SSH command execution tool for cluster management, b
 - **Parallel Execution**: Execute commands across multiple nodes simultaneously
 - **Cluster Management**: Define and manage node clusters via configuration files
 - **Progress Tracking**: Real-time progress indicators for each node
-- **Flexible Authentication**: Support for SSH keys and SSH agent
+- **Flexible Authentication**: Support for SSH keys, SSH agent, password authentication, and encrypted key passphrases
 - **Host Key Verification**: Secure host key checking with known_hosts support
 - **Cross-Platform**: Works on Linux and macOS
 - **Output Management**: Save command outputs to files per node with detailed logging
@@ -35,6 +35,12 @@ bssh -c staging -i ~/.ssh/custom_key "systemctl status nginx"
 # Use SSH agent for authentication
 bssh --use-agent -c production "systemctl status nginx"
 
+# Use password authentication (will prompt for password)
+bssh --password -H "user@host.com" "uptime"
+
+# Use encrypted SSH key (will prompt for passphrase)
+bssh -i ~/.ssh/encrypted_key -c production "df -h"
+
 # Limit parallel connections
 bssh -c production --parallel 5 "apt update"
 ```

src/cli.rs

@@ -57,6 +57,13 @@ pub struct Cli {
     )]
     pub use_agent: bool,
 
+    #[arg(
+        short = 'P',
+        long,
+        help = "Use password authentication (will prompt for password)"
+    )]
+    pub password: bool,
+
     #[arg(
         short = 'p',
         long,

src/executor.rs

@@ -28,6 +28,7 @@ pub struct ParallelExecutor {
     key_path: Option<String>,
     strict_mode: StrictHostKeyChecking,
     use_agent: bool,
+    use_password: bool,
 }
 
 impl ParallelExecutor {
@@ -52,6 +53,7 @@ impl ParallelExecutor {
             key_path,
             strict_mode,
             use_agent: false,
+            use_password: false,
         }
     }
 
@@ -68,6 +70,25 @@ impl ParallelExecutor {
             key_path,
             strict_mode,
             use_agent,
+            use_password: false,
+        }
+    }
+
+    pub fn new_with_all_options(
+        nodes: Vec<Node>,
+        max_parallel: usize,
+        key_path: Option<String>,
+        strict_mode: StrictHostKeyChecking,
+        use_agent: bool,
+        use_password: bool,
+    ) -> Self {
+        Self {
+            nodes,
+            max_parallel,
+            key_path,
+            strict_mode,
+            use_agent,
+            use_password,
         }
     }
 
@@ -89,6 +110,7 @@ impl ParallelExecutor {
                 let key_path = self.key_path.clone();
                 let strict_mode = self.strict_mode;
                 let use_agent = self.use_agent;
+                let use_password = self.use_password;
                 let semaphore = Arc::clone(&semaphore);
                 let pb = multi_progress.add(ProgressBar::new_spinner());
                 pb.set_style(style.clone());
@@ -107,6 +129,7 @@ impl ParallelExecutor {
                         key_path.as_deref(),
                         strict_mode,
                         use_agent,
+                        use_password,
                     )
                     .await;
 
@@ -170,6 +193,7 @@ impl ParallelExecutor {
                 let key_path = self.key_path.clone();
                 let strict_mode = self.strict_mode;
                 let use_agent = self.use_agent;
+                let use_password = self.use_password;
                 let semaphore = Arc::clone(&semaphore);
                 let pb = multi_progress.add(ProgressBar::new_spinner());
                 pb.set_style(style.clone());
@@ -189,6 +213,7 @@ impl ParallelExecutor {
                         key_path.as_deref(),
                         strict_mode,
                         use_agent,
+                        use_password,
                     )
                     .await;
 
@@ -245,6 +270,7 @@ impl ParallelExecutor {
                 let key_path = self.key_path.clone();
                 let strict_mode = self.strict_mode;
                 let use_agent = self.use_agent;
+                let use_password = self.use_password;
                 let semaphore = Arc::clone(&semaphore);
                 let pb = multi_progress.add(ProgressBar::new_spinner());
                 pb.set_style(style.clone());
@@ -276,6 +302,7 @@ impl ParallelExecutor {
                         key_path.as_deref(),
                         strict_mode,
                         use_agent,
+                        use_password,
                     )
                     .await;
 
@@ -338,6 +365,7 @@ impl ParallelExecutor {
                     let key_path = self.key_path.clone();
                     let strict_mode = self.strict_mode;
                     let use_agent = self.use_agent;
+                    let use_password = self.use_password;
                     let semaphore = Arc::clone(&semaphore);
                     let pb = multi_progress.add(ProgressBar::new_spinner());
                     pb.set_style(style.clone());
@@ -368,6 +396,7 @@ impl ParallelExecutor {
                             key_path.as_deref(),
                             strict_mode,
                             use_agent,
+                            use_password,
                         )
                         .await;
 
@@ -411,13 +440,20 @@ async fn execute_on_node(
     key_path: Option<&str>,
     strict_mode: StrictHostKeyChecking,
     use_agent: bool,
+    use_password: bool,
 ) -> Result<CommandResult> {
     let mut client = SshClient::new(node.host.clone(), node.port, node.username.clone());
 
     let key_path = key_path.map(Path::new);
 
     client
-        .connect_and_execute_with_host_check(command, key_path, Some(strict_mode), use_agent)
+        .connect_and_execute_with_host_check(
+            command,
+            key_path,
+            Some(strict_mode),
+            use_agent,
+            use_password,
+        )
         .await
 }
 
@@ -428,6 +464,7 @@ async fn upload_to_node(
     key_path: Option<&str>,
     strict_mode: StrictHostKeyChecking,
     use_agent: bool,
+    use_password: bool,
 ) -> Result<()> {
     let mut client = SshClient::new(node.host.clone(), node.port, node.username.clone());
 
@@ -442,6 +479,7 @@ async fn upload_to_node(
                 key_path,
                 Some(strict_mode),
                 use_agent,
+                use_password,
             )
             .await
     } else {
@@ -452,6 +490,7 @@ async fn upload_to_node(
                 key_path,
                 Some(strict_mode),
                 use_agent,
+                use_password,
             )
             .await
     }
@@ -464,6 +503,7 @@ async fn download_from_node(
     key_path: Option<&str>,
     strict_mode: StrictHostKeyChecking,
     use_agent: bool,
+    use_password: bool,
 ) -> Result<std::path::PathBuf> {
     let mut client = SshClient::new(node.host.clone(), node.port, node.username.clone());
 
@@ -478,6 +518,7 @@ async fn download_from_node(
             key_path,
             Some(strict_mode),
             use_agent,
+            use_password,
         )
         .await?;
 
@@ -491,6 +532,7 @@ pub async fn download_dir_from_node(
     key_path: Option<&str>,
     strict_mode: StrictHostKeyChecking,
     use_agent: bool,
+    use_password: bool,
 ) -> Result<std::path::PathBuf> {
     let mut client = SshClient::new(node.host.clone(), node.port, node.username.clone());
 
@@ -503,6 +545,7 @@ pub async fn download_dir_from_node(
             key_path,
             Some(strict_mode),
             use_agent,
+            use_password,
         )
         .await?;
 

src/main.rs

@@ -36,6 +36,7 @@ struct ExecuteCommandParams<'a> {
     verbose: bool,
     strict_mode: StrictHostKeyChecking,
     use_agent: bool,
+    use_password: bool,
     output_dir: Option<&'a Path>,
 }
 
@@ -45,6 +46,7 @@ struct FileTransferParams<'a> {
     key_path: Option<&'a Path>,
     strict_mode: StrictHostKeyChecking,
     use_agent: bool,
+    use_password: bool,
     recursive: bool,
 }
 
@@ -96,6 +98,7 @@ async fn main() -> Result<()> {
                 cli.identity.as_deref(),
                 strict_mode,
                 cli.use_agent,
+                cli.password,
             )
             .await?;
         }
@@ -110,6 +113,7 @@ async fn main() -> Result<()> {
                 key_path: cli.identity.as_deref(),
                 strict_mode,
                 use_agent: cli.use_agent,
+                use_password: cli.password,
                 recursive,
             };
             upload_file(params, &source, &destination).await?;
@@ -125,6 +129,7 @@ async fn main() -> Result<()> {
                 key_path: cli.identity.as_deref(),
                 strict_mode,
                 use_agent: cli.use_agent,
+                use_password: cli.password,
                 recursive,
             };
             download_file(params, &source, &destination).await?;
@@ -139,6 +144,7 @@ async fn main() -> Result<()> {
                 verbose: cli.verbose > 0,
                 strict_mode,
                 use_agent: cli.use_agent,
+                use_password: cli.password,
                 output_dir: cli.output_dir.as_deref(),
             };
             execute_command(params).await?;
@@ -207,16 +213,18 @@ async fn ping_nodes(
     key_path: Option<&Path>,
     strict_mode: StrictHostKeyChecking,
     use_agent: bool,
+    use_password: bool,
 ) -> Result<()> {
     println!("Pinging {} nodes...\n", nodes.len());
 
     let key_path = key_path.map(|p| p.to_string_lossy().to_string());
-    let executor = ParallelExecutor::new_with_strict_mode_and_agent(
+    let executor = ParallelExecutor::new_with_all_options(
         nodes.clone(),
         max_parallel,
         key_path,
         strict_mode,
         use_agent,
+        use_password,
     );
 
     let results = executor.execute("echo 'pong'").await?;
@@ -250,12 +258,13 @@ async fn execute_command(params: ExecuteCommandParams<'_>) -> Result<()> {
     );
 
     let key_path = params.key_path.map(|p| p.to_string_lossy().to_string());
-    let executor = ParallelExecutor::new_with_strict_mode_and_agent(
+    let executor = ParallelExecutor::new_with_all_options(
         params.nodes,
         params.max_parallel,
         key_path,
         params.strict_mode,
         params.use_agent,
+        params.use_password,
     );
 
     let results = executor.execute(params.command).await?;
@@ -475,12 +484,13 @@ async fn upload_file(
     println!("Destination: {destination}\n");
 
     let key_path_str = params.key_path.map(|p| p.to_string_lossy().to_string());
-    let executor = ParallelExecutor::new_with_strict_mode_and_agent(
+    let executor = ParallelExecutor::new_with_all_options(
         params.nodes.clone(),
         params.max_parallel,
         key_path_str.clone(),
         params.strict_mode,
         params.use_agent,
+        params.use_password,
     );
 
     let mut total_success = 0;
@@ -686,12 +696,13 @@ async fn download_file(
     }
 
     let key_path_str = params.key_path.map(|p| p.to_string_lossy().to_string());
-    let executor = ParallelExecutor::new_with_strict_mode_and_agent(
+    let executor = ParallelExecutor::new_with_all_options(
         params.nodes.clone(),
         params.max_parallel,
         key_path_str.clone(),
         params.strict_mode,
         params.use_agent,
+        params.use_password,
     );
 
     // Check if source contains glob pattern
@@ -735,6 +746,7 @@ async fn download_file(
                 key_path_str.as_deref(),
                 params.strict_mode,
                 params.use_agent,
+                params.use_password,
             )
             .await;
 
@@ -783,6 +795,7 @@ async fn download_file(
                 params.key_path,
                 Some(params.strict_mode),
                 params.use_agent,
+                params.use_password,
             )
             .await?;