enprot 0.5.39

Engyon Protected Text (EPT) — confidentiality processor and capability ledger
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

use crate::Fixture;
use assert_cmd::prelude::*;
use std::fs;
use std::process::Command;
use tempfile::tempdir;

#[test]
fn compress_encrypt_decrypt_round_trip() {
    let casdir = tempdir().unwrap();
    let ept = Fixture::copy("sample/test.ept");

    // Encrypt with --compress
    Command::cargo_bin("enprot")
        .unwrap()
        .arg("-c")
        .arg(casdir.path())
        .arg("-k")
        .arg("Agent_007=password123")
        .arg("encrypt")
        .arg("--compress")
        .arg("-w")
        .arg("Agent_007")
        .arg("--pbkdf")
        .arg("pbkdf2-sha256")
        .arg("--pbkdf-msec")
        .arg("10")
        .arg(&ept.path)
        .assert()
        .success();

    // Verify the encrypt produced output
    let content = fs::read_to_string(&ept.path).unwrap();
    assert!(
        content.contains("ENCRYPTED"),
        "file should have ENCRYPTED block after encrypt"
    );

    // Decrypt — should recover the original plaintext
    Command::cargo_bin("enprot")
        .unwrap()
        .arg("-c")
        .arg(casdir.path())
        .arg("-k")
        .arg("Agent_007=password123")
        .arg("decrypt")
        .arg("-w")
        .arg("Agent_007")
        .arg(&ept.path)
        .assert()
        .success();

    // The decrypted content should match the original sample file
    let decrypted = fs::read_to_string(&ept.path).unwrap();
    let original = fs::read_to_string(&ept.source).unwrap();
    assert_eq!(
        decrypted, original,
        "decrypt(compress(encrypt(pt))) == pt — round-trip must recover original"
    );
}

#[test]
fn compress_without_compress_flag_still_round_trips() {
    let casdir = tempdir().unwrap();
    let ept = Fixture::copy("sample/test.ept");

    // Encrypt WITHOUT --compress
    Command::cargo_bin("enprot")
        .unwrap()
        .arg("-c")
        .arg(casdir.path())
        .arg("-k")
        .arg("Agent_007=password123")
        .arg("encrypt")
        .arg("-w")
        .arg("Agent_007")
        .arg("--pbkdf")
        .arg("pbkdf2-sha256")
        .arg("--pbkdf-msec")
        .arg("10")
        .arg(&ept.path)
        .assert()
        .success();

    // Decrypt — should recover original
    Command::cargo_bin("enprot")
        .unwrap()
        .arg("-c")
        .arg(casdir.path())
        .arg("-k")
        .arg("Agent_007=password123")
        .arg("decrypt")
        .arg("-w")
        .arg("Agent_007")
        .arg(&ept.path)
        .assert()
        .success();

    let decrypted = fs::read_to_string(&ept.path).unwrap();
    let original = fs::read_to_string(&ept.source).unwrap();
    assert_eq!(
        decrypted, original,
        "round-trip without compression must work"
    );
}