#include "strawberry/inspection_executor.hpp" #include #include #include #include #include #include #include #include using namespace strawberry; using namespace strawberry::learn; namespace { const uint64_t seed = [] { const char* value = std::getenv("STRAWBERRY_PROPERTY_SEED"); return value ? std::strtoull(value, nullptr, 10) : uint64_t(std::random_device{}()); }(); #define CHECK(x) do { if (!(x)) { std::cerr << "failed: " #x << " line " << __LINE__ << " seed " << seed << '\n'; std::abort(); } } while (false) void safety_properties() { ProcessRef current{42, "process_42_abcd1234_123", "/tmp/test-image"}; CHECK(pid_from_node_id(current.node_id) == 42); for (const auto* invalid : {"process_42", "process_42_boot_123", "process_1_abcd1234_123", "process_42_abcd1234_0", "process_42_abcd1234_123_extra"}) { CHECK(pid_from_node_id(invalid) == -1); } int scans = 0; bool protected_process = false, admitted = true; InspectionHooks hooks; hooks.resolve = [&](int) { return std::optional(current); }; hooks.is_protected = [&](const ProcessRef&) { return protected_process; }; hooks.admit = [&] { return admitted; }; bool authorized = true; hooks.authorized = [&](const InspectionDecision&) { return authorized; }; hooks.queue_memory_scan = [&](const ProcessRef& process, const InspectionDecision& decision) { CHECK(process.node_id == decision.root_node); ++scans; return true; }; hooks.deep_rescan = [&](const ProcessRef&, const InspectionDecision&, std::string&) { ++scans; return std::optional(2); }; InspectionDecision d; d.shadow = false; d.root_node = current.node_id; d.root_exe = current.exe; d.action = InspectAction::deep_rescan; InspectionExecutor executor(hooks); CHECK(executor.execute(d).status == "scanned" && scans == 1); d.shadow = true; CHECK(executor.execute(d).status == "unsupported" && scans == 1); d.shadow = false; authorized = false; CHECK(executor.execute(d).status == "revoked" && scans == 1); authorized = true; protected_process = true; CHECK(executor.execute(d).status == "skipped_protected" && scans == 1); protected_process = false; admitted = false; CHECK(executor.execute(d).status == "deferred" && scans == 1); admitted = true; current.node_id = "process_42_abcd1234_124"; CHECK(executor.execute(d).status == "skipped_exited" && scans == 1); current.node_id = d.root_node; current.exe = "/tmp/replaced-image"; CHECK(executor.execute(d).status == "skipped_exited" && scans == 1); current.exe = d.root_exe; // Missing safety checks must fail closed, not silently scan. auto incomplete = hooks; incomplete.is_protected = {}; CHECK(InspectionExecutor(incomplete).execute(d).status == "failed" && scans == 1); incomplete = hooks; incomplete.admit = {}; CHECK(InspectionExecutor(incomplete).execute(d).status == "failed" && scans == 1); std::mt19937_64 rng(seed); for (int i = 0; i < 1000; ++i) { d.action = static_cast(5 + rng() % 251); CHECK(executor.execute(d).status == "unsupported" && scans == 1); } d.action = InspectAction::memory_scan; CHECK(executor.execute(d).status == "queued" && scans == 2); hooks.resolve = [](int) -> std::optional { throw std::runtime_error("injected"); }; CHECK(InspectionExecutor(hooks).execute(d).status == "failed" && scans == 2); hooks.resolve = [&](int) { return std::optional(current); }; hooks.deep_rescan = [](const ProcessRef&, const InspectionDecision&, std::string&) -> std::optional { throw 42; }; d.action = InspectAction::deep_rescan; CHECK(InspectionExecutor(hooks).execute(d).status == "failed" && scans == 2); } void queue_properties() { std::mutex mutex; std::condition_variable cv; bool entered = false, release = false; std::vector outcomes; InspectionHooks hooks; hooks.resolve = [&](int) -> std::optional { std::unique_lock lock(mutex); entered = true; cv.notify_all(); CHECK(cv.wait_for(lock, std::chrono::seconds(5), [&] { return release; })); return ProcessRef{42, "process_42_abcd1234_123", "/tmp/image"}; }; hooks.is_protected = [](const ProcessRef&) { return false; }; hooks.admit = [] { return true; }; hooks.authorized = [](const InspectionDecision&) { return true; }; hooks.deep_rescan = [](const ProcessRef&, const InspectionDecision&, std::string&) { return std::optional(0); }; hooks.emit = [&](const InspectionOutcome& o) { std::lock_guard lock(mutex); outcomes.push_back(o.status); cv.notify_all(); }; InspectionDecision d; d.shadow = false; d.action = InspectAction::deep_rescan; d.root_node = "process_42_abcd1234_123"; d.root_exe = "/tmp/image"; InspectionExecutor executor(hooks, 1); executor.start(); executor.submit(d); { std::unique_lock lock(mutex); CHECK(cv.wait_for(lock, std::chrono::seconds(5), [&] { return entered; })); } executor.submit(d); executor.submit(d); { std::lock_guard lock(mutex); CHECK(outcomes.size() == 1 && outcomes[0] == "queue_full"); release = true; cv.notify_all(); } { std::unique_lock lock(mutex); CHECK(cv.wait_for(lock, std::chrono::seconds(5), [&] { return outcomes.size() == 3; })); } executor.stop(); executor.submit(d); CHECK(outcomes.size() == 4 && outcomes.back() == "stopped"); CHECK(executor.stats().deep_rescans == 2); } void codec_properties() { std::mt19937_64 rng(seed); for (int i = 0; i < 1000; ++i) { InspectionOutcome in; in.timestamp_ns = static_cast(rng() & 0x7fffffffffffffffULL); in.root_node = "process_42_abcd1234_123"; in.action = static_cast(rng() % kActions); in.status = "scanned"; in.detail = std::string("host\0\xff", 6); in.matches = static_cast(rng()); in.duration_us = rng(); in.model_generation = rng(); InspectionOutcome out; const auto encoded = encode_inspection_outcome(in); CHECK(decode_inspection_outcome(encoded, out)); CHECK(encode_inspection_outcome(out) == encoded); } InspectionOutcome sentinel; sentinel.status = "unchanged"; CHECK(!decode_inspection_outcome(std::string("\x18\xff\x01", 3), sentinel)); CHECK(sentinel.status == "unchanged"); CHECK(!decode_inspection_outcome(std::string("\x22\x05x", 3), sentinel)); CHECK(sentinel.status == "unchanged"); } } // namespace int main() { safety_properties(); codec_properties(); queue_properties(); std::cout << "inspection executor properties passed, seed " << seed << '\n'; }