enprot 0.4.2

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

// Integration tests for `enprot inspect` (TODO.finalize/42).

use assert_cmd::Command;
use std::fs;
use tempfile::tempdir;

fn write(path: &std::path::Path, contents: &str) {
    if let Some(parent) = path.parent() {
        fs::create_dir_all(parent).unwrap();
    }
    fs::write(path, contents).unwrap();
}

fn write_lines(path: &std::path::Path, lines: &[&str]) {
    write(path, &lines.join("\n"))
}

#[test]
fn inspect_shows_begin_end_segments() {
    let dir = tempdir().unwrap();
    let input = dir.path().join("a.ept");
    write(
        &input,
        "hello\n// <( BEGIN Secret )>\nhidden line\n// <( END Secret )>\n",
    );

    let out = Command::cargo_bin("enprot")
        .unwrap()
        .current_dir(dir.path())
        .args(["inspect"])
        .arg(&input)
        .assert()
        .success();
    let s = std::str::from_utf8(&out.get_output().stdout).unwrap();
    assert!(s.contains("structure"), "missing structure section: {s}");
    assert!(s.contains("Secret"), "WORD should appear: {s}");
    assert!(s.contains("chain anchors"), "missing chain section: {s}");
    assert!(s.contains("conflicts"), "missing conflict section: {s}");
    assert!(
        s.contains("capabilities"),
        "missing capability section: {s}"
    );
}

#[test]
fn inspect_reports_no_conflicts_when_clean() {
    let dir = tempdir().unwrap();
    let input = dir.path().join("a.ept");
    write(&input, "plain text only\n");

    let out = Command::cargo_bin("enprot")
        .unwrap()
        .current_dir(dir.path())
        .args(["inspect"])
        .arg(&input)
        .assert()
        .success();
    let s = std::str::from_utf8(&out.get_output().stdout).unwrap();
    assert!(s.contains("(none)"), "should show no conflicts: {s}");
}

#[test]
fn inspect_exits_nonzero_when_conflicts_present() {
    let dir = tempdir().unwrap();
    let input = dir.path().join("conflict.ept");
    write_lines(
        &input,
        &[
            "// <( CONFLICT Secret )>",
            "// <( OURS )>",
            "our content",
            "// <( THEIRS )>",
            "their content",
            "// <( END Secret )>",
        ],
    );

    let out = Command::cargo_bin("enprot")
        .unwrap()
        .current_dir(dir.path())
        .args(["inspect"])
        .arg(&input)
        .assert()
        .failure();
    let s = std::str::from_utf8(&out.get_output().stdout).unwrap();
    assert!(
        s.contains("1 unresolved conflict"),
        "should count conflict: {s}"
    );
}

#[test]
fn inspect_shows_encrypted_block_metadata() {
    let dir = tempdir().unwrap();
    let cas = dir.path().join("cas");
    fs::create_dir(&cas).unwrap();
    let input = dir.path().join("a.ept");
    write_lines(
        &input,
        &[
            "// <( ENCRYPTED Secret cipher:$aes-256-siv$iv=MDEyMzQ1Njc4OWFiY2RlZg== )>",
            "// <( DATA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA )>",
            "// <( END Secret )>",
        ],
    );

    let out = Command::cargo_bin("enprot")
        .unwrap()
        .current_dir(dir.path())
        .args(["inspect"])
        .arg(&input)
        .assert()
        .success();
    let s = std::str::from_utf8(&out.get_output().stdout).unwrap();
    assert!(s.contains("ENCRYPTED"), "should show ENCRYPTED kind: {s}");
    assert!(s.contains("Secret"), "WORD should appear: {s}");
}