strawberry/tests/test_daemon_runtime.cpp
trvon a6c8ddc612
Read process facts on macOS without procfs
include/strawberry/platform_process.hpp answers what /proc answers on
Linux: running PIDs (proc_listallpids), executable path
(proc_pidpath), parent and start time (sysctl KERN_PROC_PID, readable
for every process), argv (KERN_PROCARGS2) and a boot id
(kern.bootsessionuuid). A process is identified by its start time in
microseconds since the epoch plus the boot id, so node ids survive PID
reuse as on Linux. It is header-only, so the per-test source lists stay
as they are.

Users on macOS: resolve_process_ref (default root), the pipeline's
image hashing and exec-decision actor, and YaraScanner::scan_process
(scans the image by path). A synthetic procfs root still takes the
procfs code, so the existing procfs tests run on macOS too.

The resource governor samples Mach/sysctl on macOS: own CPU from
getrusage, RSS from task_info, load from getloadavg, available memory
from host_statistics64 (free + inactive + purgeable + speculative).

The behavior engine knows macOS debuggers (debugserver, dtrace) and
kext loaders (kernelmanagerd, kmutil), and macOS temp and Downloads
paths count as drop locations. The Linux lists are unchanged.

The KERN_PROCARGS2 parser is portable: a property test (exact argv
recovery, truncation never invents data, total on junk) and the
fuzz_procargs target run on every platform. test_platform_process
checks the live helpers against this process; the daemon test reads
the stopped state through sysctl on macOS.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-25 20:53:02 -06:00

528 lines
21 KiB
C++

#include "strawberry/daemon_app.hpp"
#include "strawberry/database.hpp"
#include "strawberry/hash_utils.hpp"
#include "strawberry/control_server.hpp"
#include "strawberry/policy.hpp"
#include "strawberry/behavior_engine.hpp"
#include <cassert>
#include <chrono>
#include <cstdlib>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <string>
#include <thread>
#include <vector>
#include <csignal>
#include <optional>
#include <sys/wait.h>
#include <unistd.h>
#if defined(__APPLE__)
#include <sys/sysctl.h>
#endif
#if defined(_WIN32)
#include <stdlib.h>
#endif
#ifndef STRAWBERRY_HAVE_YARA
#define STRAWBERRY_HAVE_YARA 0
#endif
namespace fs = std::filesystem;
namespace {
#if STRAWBERRY_HAVE_YARA
fs::path make_test_root() {
const auto root = fs::temp_directory_path() / "strawberry_daemon_runtime_tests";
std::error_code ec;
fs::remove_all(root, ec);
fs::create_directories(root, ec);
assert(!ec);
return root;
}
void write_binary_file(const fs::path& path, const std::string& content) {
if (path.has_parent_path()) {
std::error_code ec;
fs::create_directories(path.parent_path(), ec);
assert(!ec);
}
std::ofstream output(path, std::ios::binary);
assert(output.good());
output.write(content.data(), static_cast<std::streamsize>(content.size()));
output.close();
assert(output.good());
}
void write_cmdline_file(const fs::path& path, const std::vector<std::string>& args) {
if (path.has_parent_path()) {
std::error_code ec;
fs::create_directories(path.parent_path(), ec);
assert(!ec);
}
std::ofstream output(path, std::ios::binary);
assert(output.good());
for (const auto& arg : args) {
output.write(arg.data(), static_cast<std::streamsize>(arg.size()));
output.put('\0');
}
output.close();
assert(output.good());
}
void write_status_file(const fs::path& path, int parent_pid) {
if (path.has_parent_path()) {
std::error_code ec;
fs::create_directories(path.parent_path(), ec);
assert(!ec);
}
std::ofstream output(path);
assert(output.good());
output << "Name:\tsynthetic-daemon\n";
output << "State:\tR (running)\n";
output << "PPid:\t" << parent_pid << "\n";
output.close();
assert(output.good());
}
void write_rule_file(const fs::path& path) {
if (path.has_parent_path()) {
std::error_code ec;
fs::create_directories(path.parent_path(), ec);
assert(!ec);
}
std::ofstream output(path);
assert(output.good());
output << "rule SyntheticDaemonRule {\n"
" strings:\n"
" $marker = \"synthetic-daemon-marker\"\n"
" condition:\n"
" $marker\n"
"}\n";
output.close();
assert(output.good());
}
void write_config_file(const fs::path& path,
const std::string& db_path,
const std::string& rules_dir) {
if (path.has_parent_path()) {
std::error_code ec;
fs::create_directories(path.parent_path(), ec);
assert(!ec);
}
std::ofstream output(path);
assert(output.good());
output << "db_path=" << db_path << "\n";
output << "yara_rules_path=" << rules_dir << "\n";
output << "daemonize=false\n";
output << "enable_bpf_monitoring=true\n";
output.close();
assert(output.good());
}
void set_env_var(const std::string& key, const std::string& value) {
#if defined(_WIN32)
_putenv_s(key.c_str(), value.c_str());
#else
::setenv(key.c_str(), value.c_str(), 1);
#endif
}
void unset_env_var(const std::string& key) {
#if defined(_WIN32)
_putenv_s(key.c_str(), "");
#else
::unsetenv(key.c_str());
#endif
}
bool wait_for_running(strawberry::StrawberryDaemon& daemon, std::chrono::milliseconds timeout) {
const auto deadline = std::chrono::steady_clock::now() + timeout;
while (std::chrono::steady_clock::now() < deadline) {
if (daemon.is_running()) {
return true;
}
std::this_thread::sleep_for(std::chrono::milliseconds(25));
}
return daemon.is_running();
}
void test_daemon_procfs_event_persists_match() {
const auto root = make_test_root();
const auto proc_root = root / "proc";
const auto rules_dir = root / "rules";
const auto executable = root / "bin" / "synthetic_daemon_exec";
const auto database_path = (root / "daemon_runtime.db").string();
const auto config_path = root / "strawberry.conf";
std::error_code ec;
fs::create_directories(proc_root, ec);
assert(!ec);
fs::create_directories(rules_dir, ec);
assert(!ec);
write_binary_file(executable, std::string("\x7f\x45\x4c\x46") + "synthetic-daemon-marker");
write_rule_file(rules_dir / "synthetic_daemon.yar");
write_config_file(config_path, database_path, rules_dir.string());
const auto expected_hash = strawberry::HashUtils::sha256_file(executable.string());
assert(!expected_hash.empty());
set_env_var("STRAWBERRY_PROCFS_ROOT", proc_root.string());
set_env_var("STRAWBERRY_PROCESS_MONITOR_POLL_MS", "25");
strawberry::StrawberryDaemon daemon;
std::cout << "Test daemon_procfs_event_persists_match:" << std::endl;
assert(daemon.initialize(config_path.string()));
assert(daemon.is_initialized());
std::thread daemon_thread([&]() {
daemon.run();
});
assert(wait_for_running(daemon, std::chrono::seconds(2)));
const auto staged_proc_dir = proc_root / "pending-654";
fs::create_directories(staged_proc_dir, ec);
assert(!ec);
fs::create_symlink(executable, staged_proc_dir / "exe", ec);
assert(!ec);
write_cmdline_file(staged_proc_dir / "cmdline", {"synthetic_daemon_exec", "--daemon-test"});
write_status_file(staged_proc_dir / "status", 42);
const auto live_proc_dir = proc_root / "654";
fs::rename(staged_proc_dir, live_proc_dir, ec);
assert(!ec);
std::this_thread::sleep_for(std::chrono::seconds(1));
daemon.request_stop();
daemon_thread.join();
assert(!daemon.is_running());
strawberry::Database database;
assert(database.open(database_path));
auto hits = database.find_indicators_by_hash(expected_hash);
assert(hits.size() == 1);
assert(hits[0].rule_name == "SyntheticDaemonRule");
assert(hits[0].metadata.at("source") == "yara");
assert(hits[0].metadata.at("scan_kind") == "process_executable");
assert(hits[0].metadata.at("pid") == "654");
assert(hits[0].metadata.at("parent_pid") == "42");
assert(hits[0].metadata.at("process_path") == executable.string());
assert(hits[0].metadata.at("cmdline") == "synthetic_daemon_exec --daemon-test");
assert(!hits[0].metadata.at("event_timestamp_ns").empty());
const std::string process_node_id = "process_654";
const std::string file_node_id = "file_" + expected_hash;
auto related = database.find_related_nodes(process_node_id, 1);
assert(related.size() == 2);
bool saw_indicator = false;
bool saw_file = false;
for (const auto& node : related) {
if (node.type == "indicator") {
saw_indicator = true;
assert(node.properties.at("rule_name") == "SyntheticDaemonRule");
assert(node.properties.at("cmdline") == "synthetic_daemon_exec --daemon-test");
assert(node.properties.at("parent_pid") == "42");
} else if (node.id == file_node_id) {
saw_file = true;
assert(node.type == "file");
assert(node.properties.at("path") == executable.string());
assert(node.properties.at("hash") == expected_hash);
assert(node.properties.at("kind") == "executable_image");
}
}
assert(saw_indicator);
assert(saw_file);
auto edges = database.get_node_edges(process_node_id);
assert(edges.size() == 3);
bool saw_spawned = false;
bool saw_executed = false;
bool saw_matched = false;
for (const auto& edge : edges) {
if (edge.relationship_type == "spawned") {
saw_spawned = true;
} else if (edge.relationship_type == "executed") {
saw_executed = true;
assert(edge.to_id == file_node_id);
} else if (edge.relationship_type == "matched") {
saw_matched = true;
}
}
assert(saw_spawned);
assert(saw_executed);
assert(saw_matched);
auto parent_related = database.find_related_nodes("process_42", 1);
assert(parent_related.size() == 1);
assert(parent_related[0].id == process_node_id);
auto file_edges = database.get_node_edges(file_node_id);
assert(file_edges.size() == 2);
bool saw_content_matched = false;
for (const auto& edge : file_edges) {
if (edge.relationship_type == "content_matched") {
saw_content_matched = true;
}
}
assert(saw_content_matched);
database.close();
std::cout << " PASSED" << std::endl;
unset_env_var("STRAWBERRY_PROCFS_ROOT");
unset_env_var("STRAWBERRY_PROCESS_MONITOR_POLL_MS");
fs::remove_all(root, ec);
}
bool contains_text(const std::string& haystack, const std::string& needle) {
return haystack.find(needle) != std::string::npos;
}
void test_daemon_opensnitch_containment() {
const auto root = make_test_root();
const auto proc_root = root / "proc";
const auto rules_dir = root / "rules";
const auto os_rules = root / "opensnitch" / "rules";
const auto executable = root / "bin" / "contain_me";
const auto socket_path = (fs::temp_directory_path() / ("sbd-" + std::to_string(::getpid()) + ".sock")).string();
const auto config_path = root / "strawberry.conf";
std::error_code ec;
fs::create_directories(proc_root, ec);
fs::create_directories(os_rules, ec);
fs::create_directories(rules_dir, ec);
write_binary_file(executable, std::string("\x7f\x45\x4c\x46") + "contain-marker");
{
std::ofstream rule(rules_dir / "high.yar");
rule << "rule High_Severity_Test { meta: severity = \"high\" strings: $m = \"contain-marker\" condition: $m }\n";
}
// OpenSnitch config with checksums on, so rules are hash-pinned.
std::ofstream(root / "opensnitch" / "default-config.json") << R"({"Rules":{"EnableChecksums":true}})";
{
std::ofstream config(config_path);
config << "db_path=" << (root / "daemon.db").string() << "\n"
<< "yara_rules_path=" << rules_dir.string() << "\n"
<< "enable_bpf_monitoring=true\n"
<< "control_socket_path=" << socket_path << "\n"
<< "control_group=\n"
<< "opensnitch_rules_dir=" << os_rules.string() << "\n"
<< "opensnitch_config=" << (root / "opensnitch" / "default-config.json").string() << "\n";
}
const auto hash = strawberry::HashUtils::sha256_file(executable.string());
const auto rule_file = os_rules / ("strawberry-contain-" + hash.substr(0, 12) + ".json");
set_env_var("STRAWBERRY_PROCFS_ROOT", proc_root.string());
set_env_var("STRAWBERRY_PROCESS_MONITOR_POLL_MS", "25");
std::cout << "Test daemon_opensnitch_containment:" << std::endl;
strawberry::StrawberryDaemon daemon;
assert(daemon.initialize(config_path.string()));
std::thread runner([&]() { daemon.run(); });
assert(wait_for_running(daemon, std::chrono::seconds(2)));
const auto staged = proc_root / "pending-777";
fs::create_directories(staged, ec);
fs::create_symlink(executable, staged / "exe", ec);
write_cmdline_file(staged / "cmdline", {"contain_me"});
write_status_file(staged / "status", 1);
fs::rename(staged, proc_root / "777", ec);
// Auto-containment: high severity, not a system path.
for (int i = 0; i < 80 && !fs::exists(rule_file); ++i) {
std::this_thread::sleep_for(std::chrono::milliseconds(25));
}
assert(fs::exists(rule_file));
{
std::ifstream input(rule_file);
const std::string text((std::istreambuf_iterator<char>(input)), std::istreambuf_iterator<char>());
assert(contains_text(text, "process.hash.md5") && contains_text(text, executable.string()));
}
auto status = strawberry::control_request(socket_path, "status", std::chrono::seconds(2));
assert(status && contains_text(*status, "\"containments\":1"));
// Resource governor + timing surfaces.
assert(contains_text(*status, "\"resources\":{\"cgroup\"") || contains_text(*status, "\"resources\":{"));
assert(contains_text(*status, "\"profile\":\"balanced\""));
assert(contains_text(*status, "\"level\":\""));
assert(contains_text(*status, "\"timings\":{"));
assert(contains_text(*status, "\"exec_decision\":{\"count\""));
auto policy = strawberry::control_request(socket_path, "policy", std::chrono::seconds(2));
assert(policy && contains_text(*policy, "\"automatic\":true"));
// Allowlisting the binary releases its containment.
auto reply = strawberry::control_request_with_payload(socket_path, "allowlist-add",
R"({"kind":"sha256","value":")" + hash + R"("})", std::chrono::seconds(2));
assert(reply && contains_text(*reply, "\"ok\":true"));
assert(!fs::exists(rule_file));
// Manual containment works only for binaries in stored evidence, and takes
// path/md5 from that evidence.
reply = strawberry::control_request_with_payload(socket_path, "contain-add",
R"({"sha256":")" + std::string(64, 'e') + R"("})", std::chrono::seconds(2));
assert(reply && contains_text(*reply, "no stored evidence"));
reply = strawberry::control_request_with_payload(socket_path, "contain-add",
R"({"sha256":")" + hash + R"(","path":"/etc/passwd"})", std::chrono::seconds(2));
assert(reply && contains_text(*reply, "payload must be"));
reply = strawberry::control_request_with_payload(socket_path, "contain-add",
R"({"sha256":")" + hash + R"("})", std::chrono::seconds(2));
assert(reply && contains_text(*reply, "\"hash_pinned\":true"));
assert(fs::exists(rule_file));
// Undo by id.
const auto id_at = reply->find("\"id\":\"") + 6;
const auto id = reply->substr(id_at, reply->find('"', id_at) - id_at);
assert(id.starts_with("contain-"));
reply = strawberry::control_request_with_payload(socket_path, "contain-remove", R"({"id":")" + id + R"("})",
std::chrono::seconds(2));
assert(reply && contains_text(*reply, "\"removed\""));
assert(!fs::exists(rule_file));
// Protection settings are validated.
reply = strawberry::control_request_with_payload(socket_path, "protection-set",
R"({"prevention_mode":"yolo"})", std::chrono::seconds(2));
assert(reply && contains_text(*reply, "prevention_mode must be"));
reply = strawberry::control_request_with_payload(socket_path, "protection-set",
R"({"contain_auto":false,"contain_min_severity":"critical"})", std::chrono::seconds(2));
assert(reply && contains_text(*reply, "\"contain_auto\":false"));
// Quarantine: only binaries from stored evidence; undo releases containment.
reply = strawberry::control_request_with_payload(socket_path, "quarantine",
R"({"sha256":")" + std::string(64, 'e') + R"("})", std::chrono::seconds(2));
assert(reply && contains_text(*reply, "no stored evidence"));
reply = strawberry::control_request_with_payload(socket_path, "quarantine",
R"({"sha256":")" + hash + R"("})", std::chrono::seconds(2));
assert(reply && contains_text(*reply, "\"quarantined\""));
assert(fs::exists(rule_file));
policy = strawberry::control_request(socket_path, "policy", std::chrono::seconds(2));
assert(policy && contains_text(*policy, hash));
reply = strawberry::control_request_with_payload(socket_path, "quarantine",
R"({"sha256":")" + hash + R"("})", std::chrono::seconds(2));
assert(reply && contains_text(*reply, "already quarantined"));
reply = strawberry::control_request_with_payload(socket_path, "quarantine-remove",
R"({"sha256":")" + hash + R"("})", std::chrono::seconds(2));
assert(reply && contains_text(*reply, "\"released\""));
assert(!fs::exists(rule_file));
// A containment that existed before the quarantine survives its release.
reply = strawberry::control_request_with_payload(socket_path, "contain-add",
R"({"sha256":")" + hash + R"("})", std::chrono::seconds(2));
assert(reply && fs::exists(rule_file));
reply = strawberry::control_request_with_payload(socket_path, "quarantine",
R"({"sha256":")" + hash + R"("})", std::chrono::seconds(2));
assert(reply && contains_text(*reply, "\"quarantined\""));
reply = strawberry::control_request_with_payload(socket_path, "quarantine-remove",
R"({"sha256":")" + hash + R"("})", std::chrono::seconds(2));
assert(reply && contains_text(*reply, "\"released\"") && fs::exists(rule_file));
// Process actions: stable ids only, re-verified against the live process.
const auto self_id = strawberry::resolve_process_ref(::getpid());
assert(self_id);
reply = strawberry::control_request_with_payload(socket_path, "process-kill",
R"({"node_id":"process_)" + std::to_string(::getpid()) + R"("})", std::chrono::seconds(2));
assert(reply && contains_text(*reply, "stable process id"));
reply = strawberry::control_request_with_payload(socket_path, "process-kill",
R"({"node_id":")" + self_id->node_id + R"("})", std::chrono::seconds(2));
assert(reply && contains_text(*reply, "protected")); // the daemon itself
if (const auto init = strawberry::resolve_process_ref(1)) {
reply = strawberry::control_request_with_payload(socket_path, "process-kill",
R"({"node_id":")" + init->node_id + R"("})", std::chrono::seconds(2));
assert(reply && (contains_text(*reply, "protected") || contains_text(*reply, "no longer running")));
}
const pid_t child = ::fork();
if (child == 0) {
::execl("/bin/sleep", "sleep", "30", static_cast<char*>(nullptr));
::_exit(127);
}
std::optional<strawberry::ProcessRef> child_ref;
for (int i = 0; i < 80; ++i) {
child_ref = strawberry::resolve_process_ref(child);
if (child_ref && child_ref->exe.find("sleep") != std::string::npos) {
break;
}
std::this_thread::sleep_for(std::chrono::milliseconds(25));
}
assert(child_ref);
// Wrong start time (as after PID reuse) is refused.
auto stale = child_ref->node_id;
stale.back() = stale.back() == '1' ? '2' : '1';
reply = strawberry::control_request_with_payload(socket_path, "process-suspend",
R"({"node_id":")" + stale + R"("})", std::chrono::seconds(2));
assert(reply && contains_text(*reply, "no longer running"));
const auto state_of = [&]() {
#if defined(__APPLE__)
int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, child};
kinfo_proc info{};
std::size_t size = sizeof(info);
if (::sysctl(mib, 4, &info, &size, nullptr, 0) != 0 || size != sizeof(info)) {
return '?';
}
return info.kp_proc.p_stat == SSTOP ? 'T' : 'R';
#else
std::ifstream stat("/proc/" + std::to_string(child) + "/stat");
std::string text((std::istreambuf_iterator<char>(stat)), std::istreambuf_iterator<char>());
const auto close = text.rfind(')');
return close == std::string::npos || close + 2 >= text.size() ? '?' : text[close + 2];
#endif
};
reply = strawberry::control_request_with_payload(socket_path, "process-suspend",
R"({"node_id":")" + child_ref->node_id + R"("})", std::chrono::seconds(2));
assert(reply && contains_text(*reply, "\"done\""));
for (int i = 0; i < 40 && state_of() != 'T'; ++i) {
std::this_thread::sleep_for(std::chrono::milliseconds(25));
}
assert(state_of() == 'T');
reply = strawberry::control_request_with_payload(socket_path, "process-resume",
R"({"node_id":")" + child_ref->node_id + R"("})", std::chrono::seconds(2));
assert(reply && contains_text(*reply, "\"done\""));
reply = strawberry::control_request_with_payload(socket_path, "scan-memory",
R"({"node_id":")" + child_ref->node_id + R"("})", std::chrono::seconds(2));
assert(reply && contains_text(*reply, "\"queued\":true"));
reply = strawberry::control_request_with_payload(socket_path, "process-kill",
R"({"node_id":")" + child_ref->node_id + R"("})", std::chrono::seconds(2));
assert(reply && contains_text(*reply, "\"done\""));
int wstatus = 0;
assert(::waitpid(child, &wstatus, 0) == child && WIFSIGNALED(wstatus) && WTERMSIG(wstatus) == SIGKILL);
policy = strawberry::control_request(socket_path, "policy", std::chrono::seconds(2));
assert(policy && contains_text(*policy, "process-kill"));
daemon.request_stop();
runner.join();
unset_env_var("STRAWBERRY_PROCFS_ROOT");
unset_env_var("STRAWBERRY_PROCESS_MONITOR_POLL_MS");
fs::remove_all(root, ec);
std::cout << " PASSED" << std::endl;
}
#endif
} // namespace
int main() {
std::cout << "Running StrawberryDaemon tests..." << std::endl << std::endl;
#if !STRAWBERRY_HAVE_YARA
std::cout << "SKIP: daemon runtime test requires libyara" << std::endl;
return 0;
#else
test_daemon_procfs_event_persists_match();
test_daemon_opensnitch_containment();
std::cout << std::endl << "All tests passed!" << std::endl;
return 0;
#endif
}