enprot 0.4.1

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
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

// Integration tests for `enprot clean` / `smudge` / `textconv`
// (TODO.roadmap/45). These are git filter protocols: stdin → stdout.

use assert_cmd::Command;
use tempfile::tempdir;

const PLAINTEXT: &str = "hello smudge world\nsecond line\n";

#[test]
fn clean_smudge_round_trip_recovers_original_plaintext() {
    // Clean: plaintext → EPT ciphertext (stdout).
    let cleaned = Command::cargo_bin("enprot")
        .unwrap()
        .args(["clean", "-w", "demo", "-k", "demo=pw"])
        .write_stdin(PLAINTEXT)
        .assert()
        .success()
        .get_output()
        .stdout
        .clone();
    let cleaned_str = String::from_utf8(cleaned).unwrap();
    assert!(
        cleaned_str.contains("ENCRYPTED demo"),
        "clean should emit an ENCRYPTED block: got {cleaned_str}"
    );

    // Smudge: EPT ciphertext → plaintext.
    let smudged = Command::cargo_bin("enprot")
        .unwrap()
        .args(["smudge", "-w", "demo", "-k", "demo=pw"])
        .write_stdin(cleaned_str.as_bytes())
        .assert()
        .success()
        .get_output()
        .stdout
        .clone();
    let smudged_str = String::from_utf8(smudged).unwrap();
    assert_eq!(smudged_str, PLAINTEXT);
}

#[test]
fn textconv_is_alias_for_smudge() {
    let cleaned = Command::cargo_bin("enprot")
        .unwrap()
        .args(["clean", "-w", "demo", "-k", "demo=pw"])
        .write_stdin(PLAINTEXT)
        .assert()
        .success()
        .get_output()
        .stdout
        .clone();

    let smudged = Command::cargo_bin("enprot")
        .unwrap()
        .args(["textconv", "-w", "demo", "-k", "demo=pw"])
        .write_stdin(cleaned.as_slice())
        .assert()
        .success()
        .get_output()
        .stdout
        .clone();

    assert_eq!(String::from_utf8(smudged).unwrap(), PLAINTEXT);
}

#[test]
fn clean_uses_env_var_when_no_k_flag() {
    // Git filters can't pass -k on every invocation; ENPROPT_KEY is
    // the documented workaround.
    let cleaned = Command::cargo_bin("enprot")
        .unwrap()
        .env("ENPROPT_KEY", "demo=pw")
        .args(["clean", "-w", "demo"])
        .write_stdin(PLAINTEXT)
        .assert()
        .success();
    let s = String::from_utf8(cleaned.get_output().stdout.clone()).unwrap();
    assert!(s.contains("ENCRYPTED demo"));
}

#[test]
fn clean_without_password_fails_loudly() {
    Command::cargo_bin("enprot")
        .unwrap()
        .args(["clean", "-w", "demo"])
        .write_stdin(PLAINTEXT)
        .assert()
        .failure();
}

#[test]
fn smudge_with_wrong_password_fails() {
    let cleaned = Command::cargo_bin("enprot")
        .unwrap()
        .args(["clean", "-w", "demo", "-k", "demo=correct"])
        .write_stdin(PLAINTEXT)
        .assert()
        .success()
        .get_output()
        .stdout
        .clone();

    Command::cargo_bin("enprot")
        .unwrap()
        .args(["smudge", "-w", "demo", "-k", "demo=wrong"])
        .write_stdin(cleaned.as_slice())
        .assert()
        .failure();
}

#[test]
fn clean_emits_det_aead_by_default_for_diff_stability() {
    // Deterministic AEAD with a fixed-salt PBKDF means same
    // plaintext+password → identical ciphertext, so git diffs are
    // stable across re-clones. The `clean` filter doesn't auto-pick
    // legacy PBKDF (callers should opt in), so the test pins it
    // explicitly — this is the recipe docs/schemas recommends.
    let run = || {
        Command::cargo_bin("enprot")
            .unwrap()
            .args(["clean", "-w", "demo", "-k", "demo=pw", "--pbkdf", "legacy"])
            .write_stdin(PLAINTEXT)
            .assert()
            .success()
            .get_output()
            .stdout
            .clone()
    };
    let a = String::from_utf8(run()).unwrap();
    let b = String::from_utf8(run()).unwrap();
    assert_eq!(
        a, b,
        "det-AEAD + legacy PBKDF must produce identical output across runs; got:\n{a}\n---\n{b}"
    );
    assert!(a.contains("aes-256-gcm-siv-det"));
}

#[test]
fn init_git_scaffolds_gitattributes() {
    let dir = tempdir().unwrap();
    Command::cargo_bin("enprot")
        .unwrap()
        .current_dir(dir.path())
        .args(["init", "--git"])
        .assert()
        .success();
    let attrs = std::fs::read_to_string(dir.path().join(".gitattributes")).unwrap();
    assert!(attrs.contains("filter=enprot"), "got: {attrs}");
    assert!(attrs.contains("diff=enprot"));
    assert!(attrs.contains("merge=enprot"));
}