modality 0.1.6

CLI for Modality, an evolving temporal modal logic
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use anyhow::{Context, Result};
use clap::Parser;
use rpassword::read_password;
use std::env;
use std::fs;
use std::path::PathBuf;

use modality_utils::keypair::Keypair;

#[derive(Debug, Parser)]
#[command(about = "Decrypt Modality passfile file in place")]
#[command(group = clap::ArgGroup::new("source")
    .required(true)
    .args(&["dir", "path"]))]
pub struct Opts {
    /// Dir to search for passfile files.
    #[clap(long, value_parser)]
    dir: Option<PathBuf>,

    /// Direct path to passfile files
    #[clap(long, value_parser)]
    path: Option<PathBuf>,
}

pub async fn run(opts: &Opts) -> Result<()> {
    let password = get_password().context("Failed to get password")?;

    // Find all .mod_passfile files in specified directory
    let entries = if let Some(path) = opts.path.clone() {
        vec![Ok(path)].into_iter()
    } else {
        let root_dir = if let Some(dir) = &opts.dir {
            dir.clone()
        } else {
            env::current_dir().context("Failed to get current directory")?
        };
        println!("\nSearching for passfile files in: {}", root_dir.display());
        // Validate directory
        if !root_dir.exists() {
            return Err(anyhow::anyhow!(
                "Directory does not exist: {}",
                root_dir.display()
            ));
        }
        if !root_dir.is_dir() {
            return Err(anyhow::anyhow!(
                "Path is not a directory: {}",
                root_dir.display()
            ));
        }
        // Map DirEntry to PathBuf to match the single path case
        fs::read_dir(&root_dir)?
            .map(|res| res.map(|entry| entry.path()))
            .collect::<Vec<_>>()
            .into_iter()
    };

    let mut decrypted_count = 0;

    for entry in entries {
        let path = entry?;

        if let Some(ext) = path.extension() {
            if ext == "mod_passfile" {
                // Try to read as json to check if encrypted
                if let Ok(content) = fs::read_to_string(&path) {
                    if content.contains("encrypted_private_key") {
                        // Decrypt keypair from file
                        let keypair = Keypair::from_encrypted_json_file(
                            path.to_str().ok_or_else(|| {
                                anyhow::anyhow!(
                                    "Invalid file path: contains non-Unicode characters"
                                )
                            })?,
                            &password,
                        )
                        .map_err(|e| {
                            eprintln!(
                                "Failed to decrypt keypair from file {}: {}",
                                path.display(),
                                e
                            );
                            e
                        })?;

                        keypair
                            .as_json_file(path.to_str().ok_or_else(|| {
                                anyhow::anyhow!(
                                    "Invalid file path: contains non-Unicode characters"
                                )
                            })?)
                            .map_err(|e| {
                                eprintln!(
                                    "Failed to save decrypted keypair to file {}: {}",
                                    path.display(),
                                    e
                                );
                                e
                            })?;

                        println!("🔓 Decrypted {}", path.display());
                        decrypted_count += 1;
                    }
                }
            }
        }
    }

    if decrypted_count > 0 {
        println!(
            "\n✨ Successfully decrypted {} passfile files!",
            decrypted_count
        );
    } else {
        println!("\nℹī¸ No encrypted passfile files found.");
    }

    Ok(())
}

fn get_password() -> Result<String> {
    eprint!("Enter password to decrypt the passfiles: ");

    let password = read_password()?;
    if password.is_empty() {
        return Err(anyhow::anyhow!("Password cannot be empty"));
    }

    Ok(password)
}