refactor

src/main.rs

@@ -6,8 +6,8 @@ mod error;
 fn main() {
     match parse_args(std::env::args_os()) {
         Err(e) => eprintln!("{e}"),
-        Ok(op) => {
+        Ok(cmd) => {
-            if let Err(e) = op.perform() {
+            if let Err(e) = cmd.perform() {
                 eprintln!("{e}");
             }
         }
@@ -16,23 +16,19 @@ fn main() {
 
 #[cfg(test)]
 mod tests {
-    use crate::error::DrawerError;
+    use std::path::PathBuf;
-    use crate::parsing::DrawerOperation;
+    use crate::parsing::{CloseOperation, Command, OpenOperation};
-    use crate::parsing::KeyType::*;
-    use crate::parsing::OperationType::*;
     use super::*;
 
     #[test]
     fn test_basic_close() {
         let op = parse_args(vec!["drawer", "close", "blah.drawer", "-i", "foo.key", "blah"]);
         assert_eq!(op, Ok(
-            DrawerOperation {
+            Command::Close(CloseOperation{
-                operation_type: Close,
                 drawer_file: "blah.drawer".into(),
-                key: Path("foo.key".into()),
+                key: Some(PathBuf::from("foo.key")),
                 target_path: Some("blah".into()),
-                force: false,
+            })
-            }
         ))
     }
 
@@ -40,45 +36,52 @@ mod tests {
     fn test_basic_open() {
         let op = parse_args(vec!["drawer", "open", "blah.drawer", "-i", "foo.key", "blah"]);
         assert_eq!(op, Ok(
-            DrawerOperation {
+            Command::Open(OpenOperation {
-                operation_type: Open,
                 drawer_file: "blah.drawer".into(),
-                key: Path("foo.key".into()),
+                key: Some(PathBuf::from("foo.key")),
                 target_path: Some("blah".into()),
                 force: false,
             }
-        ))
+        )))
     }
 
     #[test]
     fn test_inferred_open() {
         let op = parse_args(vec!["drawer", "open", "blah.drawer", "-i", "foo.key"]);
         assert_eq!(op, Ok(
-            DrawerOperation {
+            Command::Open(OpenOperation {
-                operation_type: Open,
                 drawer_file: "blah.drawer".into(),
-                key: Path("foo.key".into()),
+                key: Some(PathBuf::from("foo.key")),
                 target_path: None,
                 force: false,
             }
-        ))
+        )))
     }
 
     #[test]
     fn test_key_env_variable() {
         let op = parse_args(vec!["drawer", "open", "blah.drawer", "blah"]);
-        assert_eq!(op.unwrap().key, EnvVar)
+        if let Ok(Command::Open(open)) = op {
+            assert_eq!(open.key, None);
+        } else {
+            assert!(false, "expected Open command");
+        }
     }
 
-    #[test]
+    // #[test]
-    fn test_drawer_filenames() {
+    // fn test_drawer_filenames() {
-        let op = parse_args(vec!["drawer", "open", "blah.notadrawer", "blah"]);
+    //     let op = parse_args(vec!["drawer", "open", "blah.notadrawer", "blah"]).unwrap();
-        assert_eq!(op.unwrap().validate(), Err(DrawerError::DrawerFileInvalidExtension("blah.notadrawer".into())));
+    //     if let Command::Open(open) = op {
-    }
+    //
-
+    //     } else {
-    #[test]
+    //         assert!(false, "expected Open command");
-    fn test_missing_key() {
+    //     }
-        let op = parse_args(vec!["drawer", "open", "blah.drawer", "-i", "notthere", "blah"]);
+    //     assert_eq!(op.unwrap().validate(), Err(DrawerError::DrawerFileInvalidExtension("blah.notadrawer".into())));
-        assert_eq!(op.unwrap().validate(), Err(DrawerError::KeyInvalid("notthere".into())));
+    // }
-    }
+    //
+    // #[test]
+    // fn test_missing_key() {
+    //     let op = parse_args(vec!["drawer", "open", "blah.drawer", "-i", "notthere", "blah"]);
+    //     assert_eq!(op.unwrap().validate(), Err(DrawerError::KeyInvalid("notthere".into())));
+    // }
 }

src/parsing.rs

@@ -8,29 +8,6 @@ use flate2::write::GzEncoder;
 use clap::{Parser, Subcommand};
 use ssh_key::{Algorithm, LineEnding, PrivateKey};
 use crate::error::DrawerError;
-use crate::parsing::KeyType::*;
-
-#[derive(Debug, Copy, Clone, PartialEq)]
-pub enum OperationType {
-    Open,
-    Close,
-    Key,
-    Info,
-}
-
-#[derive(Debug, PartialEq)]
-pub struct DrawerOperation {
-    pub operation_type: OperationType,
-    pub drawer_file: PathBuf,
-    pub key: KeyType,
-    pub target_path: Option<PathBuf>,
-    pub force: bool,
-}
-
-#[derive(Debug, PartialEq)]
-pub enum KeyType {
-    EnvVar, Path(PathBuf)
-}
 
 #[derive(Parser)]
 #[command(name = "drawer", about = "Encrypt and decrypt project directories as drawer files")]
@@ -39,8 +16,8 @@ struct Cli {
     command: Command,
 }
 
-#[derive(Subcommand)]
+#[derive(Debug, PartialEq, Subcommand)]
-enum Command {
+pub enum Command {
     /// Decrypt and expand a drawer file into a directory
     Open(OpenOperation),
     /// Compress and encrypt a directory into a drawer file
@@ -51,92 +28,133 @@ enum Command {
     Info(InfoOperation),
 }
 
-#[derive(Parser, Debug)]
+impl Command {
-struct OpenOperation {
+    pub fn perform(&self) -> Result<(), DrawerError> {
-    drawer_file: PathBuf,
+        match self {
-    target_path: Option<PathBuf>,
+            Command::Open(op) => op.perform(),
+            Command::Close(op) => op.perform(),
+            Command::Key(op) => op.perform(),
+            Command::Info(op) => op.perform(),
+        }
+    }
+}
+
+#[derive(Parser, Debug, PartialEq)]
+pub struct OpenOperation {
+    pub drawer_file: PathBuf,
+    pub target_path: Option<PathBuf>,
     #[arg(short = 'i')]
-    key: Option<PathBuf>,
+    pub key: Option<PathBuf>,
     #[arg(short = 'f')]
-    force: bool,
+    pub force: bool,
 }
 
-#[derive(Parser, Debug)]
+#[derive(Parser, Debug, PartialEq)]
-struct CloseOperation {
+pub struct CloseOperation {
-    drawer_file: PathBuf,
+    pub drawer_file: PathBuf,
-    target_path: Option<PathBuf>,
+    pub target_path: Option<PathBuf>,
     #[arg(short = 'i')]
-    key: Option<PathBuf>,
+    pub key: Option<PathBuf>,
 }
 
-#[derive(Parser, Debug)]
+#[derive(Parser, Debug, PartialEq)]
-struct KeyOperation {
+pub struct KeyOperation {
-    filename: PathBuf,
+    pub filename: PathBuf,
 }
 
-#[derive(Parser, Debug)]
+#[derive(Parser, Debug, PartialEq)]
-struct InfoOperation {
+pub struct InfoOperation {
-    drawer_file: PathBuf,
+    pub drawer_file: PathBuf,
     #[arg(short = 'i')]
-    key: Option<PathBuf>,
+    pub key: Option<PathBuf>,
 }
 
-pub fn parse_args<I, T>(args: I) -> Result<DrawerOperation, DrawerError>
+pub fn parse_args<I, T>(args: I) -> Result<Command, DrawerError>
 where
     I: IntoIterator<Item = T>,
     T: Into<OsString> + Clone,
 {
     let cli = Cli::try_parse_from(args)
         .map_err(|e| DrawerError::ParseError(e.to_string()))?;
+    Ok(cli.command)
+}
 
-    match cli.command {
+fn key_path(key: &Option<PathBuf>) -> Result<PathBuf, DrawerError> {
-        Command::Open(OpenOperation { drawer_file, target_path, key, force }) => {
+    if let Some(k) = key {
-            let key = resolve_key(key);
+        return Ok(k.clone());
-            Ok(DrawerOperation {
+    }
-                operation_type: OperationType::Open,
+    let val = std::env::var("DRAWER_KEY").map_err(|_| DrawerError::NoKeyPath)?;
-                drawer_file,
+    Ok(PathBuf::from(val))
-                key,
+}
-                target_path,
+
-                force,
+fn identity(key: &Option<PathBuf>, drawer_file: &Path) -> Result<(PathBuf, Identity), DrawerError> {
-            })
+    let kp = key_path(key)?;
-        }
+    let file = std::fs::File::open(&kp)
-        Command::Close(CloseOperation { drawer_file, target_path, key }) => {
+        .map_err(|_| DrawerError::KeyInvalid(kp.clone()))?;
-            let key = resolve_key(key);
+    let reader = std::io::BufReader::new(file);
-            Ok(DrawerOperation {
+    let id = age::ssh::Identity::from_buffer(reader, None)
-                operation_type: OperationType::Close,
+        .map_err(|_| DrawerError::DecryptFailed(drawer_file.to_path_buf(), kp.clone()))?;
-                drawer_file,
+    Ok((kp, id))
-                key,
+}
-                target_path,
+
-                force: false,
+fn decrypt(encrypted: Vec<u8>, key: &Option<PathBuf>, drawer_file: &Path) -> Result<Vec<u8>, DrawerError> {
-            })
+    let (kp, id) = identity(key, drawer_file)?;
-        }
+    let decryptor = age::Decryptor::new(encrypted.as_slice())
-        Command::Key(KeyOperation { filename }) => {
+        .map_err(|_| DrawerError::DecryptFailed(drawer_file.to_path_buf(), kp.clone()))?;
-            Ok(DrawerOperation {
+    let mut decrypted: Vec<u8> = Vec::new();
-                operation_type: OperationType::Key,
+    let mut stream = decryptor.decrypt(std::iter::once(&id as &dyn age::Identity))
-                drawer_file: filename,
+        .map_err(|_| DrawerError::DecryptFailed(drawer_file.to_path_buf(), kp.clone()))?;
-                key: KeyType::EnvVar,
+    std::io::Read::read_to_end(&mut stream, &mut decrypted)
-                target_path: None,
+        .map_err(|_| DrawerError::DecryptFailed(drawer_file.to_path_buf(), kp.clone()))?;
-                force: false,
+    Ok(decrypted)
-            })
+}
-        }
+
-        Command::Info(InfoOperation { drawer_file, key }) => {
+fn encrypt(buf: &[u8], key: &Option<PathBuf>, drawer_file: &Path) -> Result<Vec<u8>, DrawerError> {
-            let key = resolve_key(key);
+    let (_, id) = identity(key, drawer_file)?;
-            Ok(DrawerOperation {
+    let recipient = age::ssh::Recipient::try_from(id)
-                operation_type: OperationType::Info,
+        .map_err(|_| DrawerError::EncryptFailed)?;
-                drawer_file,
+    let mut encrypted: Vec<u8> = Vec::new();
-                key,
+    let encryptor = age::Encryptor::with_recipients(
-                target_path: None,
+        std::iter::once(&recipient as &dyn age::Recipient)
-                force: false,
+    ).map_err(|_| DrawerError::EncryptFailed)?;
-            })
+    let mut writer = encryptor.wrap_output(&mut encrypted)
-        }
+        .map_err(|_| DrawerError::EncryptFailed)?;
+    writer.write_all(buf).map_err(|_| DrawerError::EncryptFailed)?;
+    writer.finish().map_err(|_| DrawerError::EncryptFailed)?;
+    Ok(encrypted)
+}
+
+fn default_target(drawer_file: &Path, single_file: Option<&Path>) -> PathBuf {
+    match single_file {
+        Some(p) => PathBuf::from(p.file_name().unwrap_or_default()),
+        None => PathBuf::from(drawer_file.file_stem().unwrap_or_default()),
     }
 }
 
-fn resolve_key(key: Option<PathBuf>) -> KeyType {
+fn validate_drawer_extension(drawer_file: &Path) -> Result<(), DrawerError> {
-    if let Some(k) = key {
+    if drawer_file.extension().and_then(|e| e.to_str()) != Some("drawer") {
-        return Path(k);
+        return Err(DrawerError::DrawerFileInvalidExtension(drawer_file.to_path_buf()));
     }
-    EnvVar
+    Ok(())
+}
+
+fn validate_drawer_file_exists(drawer_file: &Path) -> Result<(), DrawerError> {
+    if !drawer_file.exists() {
+        return Err(DrawerError::DrawerFileNotFound(drawer_file.to_path_buf()));
+    }
+    Ok(())
+}
+
+fn validate_ssh_key(key: &Option<PathBuf>) -> Result<(), DrawerError> {
+    let kp = key_path(key)?;
+    let file = std::fs::File::open(&kp)
+        .map_err(|_| DrawerError::KeyInvalid(kp.clone()))?;
+    let reader = std::io::BufReader::new(file);
+    let id = age::ssh::Identity::from_buffer(reader, None)
+        .map_err(|_| DrawerError::KeyNotValidSsh)?;
+    age::ssh::Recipient::try_from(id)
+        .map_err(|_| DrawerError::KeyNotValidSsh)?;
+    Ok(())
 }
 
 enum ArchiveInfo {
@@ -187,36 +205,19 @@ fn single_file_entry(data: &[u8]) -> Option<PathBuf> {
     Some(entry.path().ok()?.into_owned())
 }
 
-impl DrawerOperation {
+impl OpenOperation {
-    // Returns the default target when no target_path is specified.
-    // For close and for directory drawers on open: the drawer file stem.
-    // For single-file drawers on open: the filename stored in the archive.
-    fn default_target(&self, single_file: Option<&std::path::Path>) -> PathBuf {
-        match single_file {
-            Some(p) => PathBuf::from(p.file_name().unwrap_or_default()),
-            None => PathBuf::from(self.drawer_file.file_stem().unwrap_or_default()),
-        }
-    }
-
     pub fn perform(&self) -> Result<(), DrawerError> {
-        self.validate()?;
+        validate_drawer_extension(&self.drawer_file)?;
-        match self.operation_type {
+        validate_ssh_key(&self.key)?;
-            OperationType::Open => self.perform_open(),
+        validate_drawer_file_exists(&self.drawer_file)?;
-            OperationType::Close => self.perform_close(),
-            OperationType::Key => self.perform_key(),
-            OperationType::Info => self.perform_info(),
-        }
-    }
 
-    fn perform_open(&self) -> Result<(), DrawerError> {
         let encrypted = std::fs::read(&self.drawer_file)
             .map_err(|_| DrawerError::DrawerFileNotFound(self.drawer_file.clone()))?;
-
+        let decrypted = decrypt(encrypted, &self.key, &self.drawer_file)?;
-        let decrypted = self.decrypt(encrypted)?;
 
         let sf = single_file_entry(&decrypted);
         let target = self.target_path.as_ref().cloned()
-            .unwrap_or_else(|| self.default_target(sf.as_deref()));
+            .unwrap_or_else(|| default_target(&self.drawer_file, sf.as_deref()));
 
         if self.target_path.is_none() {
             println!("(assuming into {})", target.display());
@@ -251,33 +252,16 @@ impl DrawerOperation {
         }
         Ok(())
     }
+}
 
-    fn decrypt(&self, encrypted: Vec<u8>) -> Result<Vec<u8>, DrawerError> {
+impl CloseOperation {
-        let (key_path, identity) = self.identity()?;
+    pub fn perform(&self) -> Result<(), DrawerError> {
+        validate_drawer_extension(&self.drawer_file)?;
+        validate_ssh_key(&self.key)?;
+        self.validate_close()?;
 
-        let decryptor = age::Decryptor::new(encrypted.as_slice())
-            .map_err(|_| DrawerError::DecryptFailed(self.drawer_file.clone(), key_path.clone()))?;
-        let mut decrypted: Vec<u8> = Vec::new();
-        let mut stream = decryptor.decrypt(std::iter::once(&identity as &dyn age::Identity))
-            .map_err(|_| DrawerError::DecryptFailed(self.drawer_file.clone(), key_path.clone()))?;
-        std::io::Read::read_to_end(&mut stream, &mut decrypted)
-            .map_err(|_| DrawerError::DecryptFailed(self.drawer_file.clone(), key_path.clone()))?;
-        Ok(decrypted)
-    }
-
-    fn identity(&self) -> Result<(PathBuf, Identity), DrawerError> {
-        let key_path = self.key_path()?;
-        let file = std::fs::File::open(&key_path)
-            .map_err(|_| DrawerError::KeyInvalid(key_path.clone()))?;
-        let reader = std::io::BufReader::new(file);
-        let identity = age::ssh::Identity::from_buffer(reader, None)
-            .map_err(|_| DrawerError::DecryptFailed(self.drawer_file.clone(), key_path.clone()))?;
-        Ok((key_path, identity))
-    }
-
-    fn perform_close(&self) -> Result<(), DrawerError> {
         let target = self.target_path.as_ref().cloned()
-            .unwrap_or_else(|| self.default_target(None));
+            .unwrap_or_else(|| default_target(&self.drawer_file, None));
 
         let mut buf: Vec<u8> = Vec::new();
         {
@@ -297,116 +281,14 @@ impl DrawerOperation {
                 .map_err(|_| DrawerError::TarFailed)?;
         }
 
-        let encrypted = self.encrypt(&buf)?;
+        let encrypted = encrypt(&buf, &self.key, &self.drawer_file)?;
-
         std::fs::write(&self.drawer_file, &encrypted)
             .map_err(|_| DrawerError::WriteFailed(self.drawer_file.clone()))
     }
 
-    fn encrypt(&self, buf: &[u8]) -> Result<Vec<u8>, DrawerError> {
-        let (_, identity) = self.identity()?;
-        let recipient = age::ssh::Recipient::try_from(identity)
-            .map_err(|_| DrawerError::EncryptFailed)?;
-
-        let mut encrypted: Vec<u8> = Vec::new();
-        let encryptor = age::Encryptor::with_recipients(
-            std::iter::once(&recipient as &dyn age::Recipient)
-        ).map_err(|_| DrawerError::EncryptFailed)?;
-        let mut writer = encryptor.wrap_output(&mut encrypted)
-            .map_err(|_| DrawerError::EncryptFailed)?;
-        writer.write_all(buf).map_err(|_| DrawerError::EncryptFailed)?;
-        writer.finish().map_err(|_| DrawerError::EncryptFailed)?;
-        Ok(encrypted)
-    }
-
-    pub fn validate(&self) -> Result<(), DrawerError> {
-        if self.operation_type != OperationType::Key {
-            if self.drawer_file.extension().and_then(|e| e.to_str()) != Some("drawer") {
-                return Err(DrawerError::DrawerFileInvalidExtension(self.drawer_file.clone()));
-            }
-            self.validate_key()?;
-        }
-        match self.operation_type {
-            OperationType::Open | OperationType::Info => self.validate_drawer_file(),
-            OperationType::Close => self.validate_close(),
-            OperationType::Key => self.validate_key_gen(),
-        }
-    }
-
-    fn validate_key_gen(&self) -> Result<(), DrawerError> {
-        self.validate_drawer_file()?;
-        let parent = match self.drawer_file.parent() {
-            None => Path::new("."),
-            Some(p) => {
-                if p == Path::new("") {
-                    Path::new(".")
-                } else {
-                    p
-                }
-            },
-        };
-        if !parent.exists() {
-            return Err(DrawerError::KeyOutputFailed(self.drawer_file.clone()));
-        }
-        Ok(())
-    }
-
-    fn key_path(&self) -> Result<PathBuf, DrawerError> {
-        match &self.key {
-            EnvVar => {
-                let val = std::env::var("DRAWER_KEY").map_err(|_| DrawerError::NoKeyPath)?;
-                Ok(PathBuf::from(val))
-            }
-            Path(p) => Ok(p.clone()),
-        }
-    }
-
-    fn validate_key(&self) -> Result<(), DrawerError> {
-        let key_path = self.key_path()?;
-        let file = std::fs::File::open(&key_path)
-            .map_err(|_| DrawerError::KeyInvalid(key_path.clone()))?;
-        let reader = std::io::BufReader::new(file);
-        let identity = age::ssh::Identity::from_buffer(reader, None)
-            .map_err(|_| DrawerError::KeyNotValidSsh)?;
-        age::ssh::Recipient::try_from(identity)
-            .map_err(|_| DrawerError::KeyNotValidSsh)?;
-        Ok(())
-    }
-
-    // Ensure the drawer file actually exists
-    fn validate_drawer_file(&self) -> Result<(), DrawerError> {
-        if !self.drawer_file.exists() {
-            return Err(DrawerError::DrawerFileNotFound(self.drawer_file.clone()));
-        }
-        Ok(())
-    }
-
-    fn perform_info(&self) -> Result<(), DrawerError> {
-        let encrypted = std::fs::read(&self.drawer_file)
-            .map_err(|_| DrawerError::DrawerFileNotFound(self.drawer_file.clone()))?;
-        let decrypted = self.decrypt(encrypted)?;
-        let info = archive_info(&decrypted)?;
-        match info {
-            ArchiveInfo::SingleFile { size } =>
-                println!("{} (file, {} bytes)", self.drawer_file.display(), size),
-            ArchiveInfo::Folder { file_count } =>
-                println!("{} (folder, {} files)", self.drawer_file.display(), file_count),
-        }
-        Ok(())
-    }
-
-    fn perform_key(&self) -> Result<(), DrawerError> {
-        let private_key = PrivateKey::random(&mut rand::rngs::OsRng, Algorithm::Ed25519)
-            .map_err(|_| DrawerError::KeyGenerateFailed)?;
-        let pem = private_key.to_openssh(LineEnding::LF)
-            .map_err(|_| DrawerError::KeyGenerateFailed)?;
-        std::fs::write(&self.drawer_file, pem.as_bytes())
-            .map_err(|_| DrawerError::KeyOutputFailed(self.drawer_file.clone()))
-    }
-
     fn validate_close(&self) -> Result<(), DrawerError> {
         let target = self.target_path.as_ref().cloned()
-            .unwrap_or_else(|| self.default_target(None));
+            .unwrap_or_else(|| default_target(&self.drawer_file, None));
         if self.target_path.is_none() {
             println!("(assuming from {})", target.display());
         }
@@ -422,9 +304,7 @@ impl DrawerOperation {
             .unwrap_or_else(|_| target.clone());
         let drawer_parent = match self.drawer_file.parent() {
             None => Path::new("."),
-            Some(p) if p == Path::new("") => {
+            Some(p) if p == Path::new("") => Path::new("."),
-                Path::new(".")
-            },
             Some(p) => p,
         };
         let canon_drawer = drawer_parent.canonicalize()
@@ -436,3 +316,47 @@ impl DrawerOperation {
         Ok(())
     }
 }
+
+impl KeyOperation {
+    pub fn perform(&self) -> Result<(), DrawerError> {
+        self.validate()?;
+        let private_key = PrivateKey::random(&mut rand::rngs::OsRng, Algorithm::Ed25519)
+            .map_err(|_| DrawerError::KeyGenerateFailed)?;
+        let pem = private_key.to_openssh(LineEnding::LF)
+            .map_err(|_| DrawerError::KeyGenerateFailed)?;
+        std::fs::write(&self.filename, pem.as_bytes())
+            .map_err(|_| DrawerError::KeyOutputFailed(self.filename.clone()))
+    }
+
+    fn validate(&self) -> Result<(), DrawerError> {
+        let parent = match self.filename.parent() {
+            None => Path::new("."),
+            Some(p) if p == Path::new("") => Path::new("."),
+            Some(p) => p,
+        };
+        if !parent.exists() {
+            return Err(DrawerError::KeyOutputFailed(self.filename.clone()));
+        }
+        Ok(())
+    }
+}
+
+impl InfoOperation {
+    pub fn perform(&self) -> Result<(), DrawerError> {
+        validate_drawer_extension(&self.drawer_file)?;
+        validate_ssh_key(&self.key)?;
+        validate_drawer_file_exists(&self.drawer_file)?;
+
+        let encrypted = std::fs::read(&self.drawer_file)
+            .map_err(|_| DrawerError::DrawerFileNotFound(self.drawer_file.clone()))?;
+        let decrypted = decrypt(encrypted, &self.key, &self.drawer_file)?;
+        let info = archive_info(&decrypted)?;
+        match info {
+            ArchiveInfo::SingleFile { size } =>
+                println!("{} (file, {} bytes)", self.drawer_file.display(), size),
+            ArchiveInfo::Folder { file_count } =>
+                println!("{} (folder, {} files)", self.drawer_file.display(), file_count),
+        }
+        Ok(())
+    }
+}