i6-pack 0.1.16

A tool to compress and optionally encrypt files
Documentation 
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

use std::io::Write;

use crate::compression;
use crate::encryption;
use crate::utils;

pub fn run(action: &str, target: &str, encrypt: bool) -> std::io::Result<()> {
  let password = &if encrypt {
    print!("Enter password: ");
    std::io::stdout().flush().expect("Failed to flush stdout");
    let password1 =
      rpassword::read_password().expect("Failed to read password");

    if (action == "pack") {
      print!("Confirm password: ");
      std::io::stdout().flush().expect("Failed to flush stdout");
      let password2 =
        rpassword::read_password().expect("Failed to read password");

      if password1 != password2 {
        eprintln!("Passwords do not match.");
        std::process::exit(1);
      }
    }

    password1
  } else {
    "".to_owned()
  };

  // Validate and sanitize the target path
  let target_path = utils::validate_path(target)
    .or_else(|_| utils::sanitize_output_path(target))
    .expect("Invalid target path");

  let tar_file =
    &format!(".{}_{}.tar", target_path.display(), uuid::Uuid::new_v4());
  let compressed_file =
    &format!(".{}_{}.tar.zst", target_path.display(), uuid::Uuid::new_v4());
  let encrypted_file = &format!("{}.i6p", target_path.display());

  match action {
    "pack" => {
      compression::create_tar_archive(target_path.to_str().unwrap(), tar_file)?;

      if (encrypt) {
        compression::compress_tar_file(tar_file, compressed_file)?;
        encryption::encrypt_file(compressed_file, encrypted_file, password)?;
      } else {
        compression::compress_tar_file(tar_file, encrypted_file)?;
      }
    }
    "unpack" => {
      if (encrypt) {
        encryption::decrypt_file(
          target_path.to_str().unwrap(),
          compressed_file,
          password,
        )?;
        compression::decompress_file(compressed_file, tar_file)?;
      } else {
        compression::decompress_file(target_path.to_str().unwrap(), tar_file)?;
      }

      compression::extract_tar_archive(
        tar_file,
        &utils::remove_extension(target_path.to_str().unwrap(), ".i6p"),
      )?;
    }
    _ => {
      eprintln!("Invalid action. Use 'pack' or 'unpack'.");
      std::process::exit(1);
    }
  }

  // Clean up temporary files
  std::fs::remove_file(tar_file)?;

  if (encrypt) {
    std::fs::remove_file(compressed_file)?;
  }

  Ok(())
}