enprot 0.5.13

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

const test = require("node:test");
const assert = require("node:assert");
const enprot = require("../index");

test("version() returns a semver-shaped string", () => {
  const v = enprot.version();
  assert.match(v, /^\d+\.\d+\.\d+/u, `unexpected version: ${v}`);
});

test("process() rejects missing keys with EnprotError", () => {
  assert.throws(
    () => enprot.process({ foo: "bar" }),
    (err) => {
      assert.ok(err instanceof enprot.EnprotError);
      assert.strictEqual(err.code, enprot.ENPROT_ERR_INVALID);
      return true;
    }
  );
});

test("process() accepts null/missing optional fields", () => {
  // Valid config shape — FFI currently returns OK after JSON shape
  // validation. When the FFI grows real processing, this will flip
  // to IO error (the file doesn't exist).
  try {
    enprot.process({ operation: "encrypt", file: "/tmp/does-not-exist.txt" });
  } catch (err) {
    assert.ok(err instanceof enprot.EnprotError);
    assert.ok(
      [enprot.ENPROT_ERR_IO, enprot.ENPROT_ERR_INVALID, enprot.ENPROT_ERR_PARSE].includes(err.code),
      `unexpected error code: ${err.code}`
    );
  }
});

test("encrypt() builds a well-formed config", () => {
  // Monkeypatch process() to capture the config.
  const original = enprot.process;
  let captured;
  enprot.process = (cfg) => {
    captured = cfg;
  };
  try {
    enprot.encrypt("/some/file.txt", {
      words: { SECRET: "pw" },
      cipher: "aes-256-siv",
      casdir: ".cas",
      policy: "nist",
    });
  } finally {
    enprot.process = original;
  }
  assert.strictEqual(captured.operation, "encrypt");
  assert.strictEqual(captured.file, "/some/file.txt");
  assert.deepStrictEqual(captured.words, { SECRET: "pw" });
  assert.strictEqual(captured.cipher, "aes-256-siv");
  assert.strictEqual(captured.policy, "nist");
});

test("store() and fetch() dispatch correctly", () => {
  const original = enprot.process;
  const calls = [];
  enprot.process = (cfg) => {
    calls.push(cfg.operation);
  };
  try {
    enprot.store("/file", { words: { X: "y" }, casdir: ".cas" });
    enprot.fetch("/file", { words: { X: "y" }, casdir: ".cas" });
  } finally {
    enprot.process = original;
  }
  assert.deepStrictEqual(calls, ["store", "fetch"]);
});

test("process() throws TypeError on non-object config", () => {
  assert.throws(() => enprot.process(null), TypeError);
  assert.throws(() => enprot.process("not an object"), TypeError);
  assert.throws(() => enprot.process([1, 2, 3]), TypeError);
});