The tree now compiles on macOS. Each Linux-only call gets a Darwin branch, and the Linux branch stays as it was: - io::fdatasync uses fcntl(F_FULLFSYNC): fsync alone only reaches the drive cache on APFS, and the store's crash atomicity relies on it. - Control socket: FD_CLOEXEC set after socket/accept/recvmsg (no SOCK_CLOEXEC, accept4 or MSG_CMSG_CLOEXEC), SO_NOSIGPIPE, peer credentials from LOCAL_PEERCRED + LOCAL_PEERPID, getgrouplist with int groups and a growing buffer. launchd has no RuntimeDirectory, so the socket directory is created (0750, access group) when missing. Default socket path is /var/run/strawberry/control.sock. - CRC32C detects ARMv8 CRC with hw.optional.armv8_crc32 (no auxv). - stat mtime via st_mtimespec; the BPF shared header uses stdint typedefs off Linux. - Background threads join the PRIO_DARWIN_BG band (lower CPU and I/O); crash safety zeroes RLIMIT_CORE in place of PR_SET_DUMPABLE. - The desktop app drops Qt DBus off Linux and shows notifications as tray messages (app/notifier_tray.cpp). - make setup passes Homebrew's keg-only libarchive to meson. Tests: behavior_live (Linux ptrace API) builds on Linux only, the control-server fd count reads /dev/fd, the crash test checks the core limit on macOS, and the runtime pipeline test no longer references a YARA-only helper when YARA is absent (that also broke Linux builds without libyara). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
931 lines
34 KiB
C++
931 lines
34 KiB
C++
#include "strawberry/database.hpp"
|
|
#include "strawberry/detection_pipeline.hpp"
|
|
#include "strawberry/resource_governor.hpp"
|
|
#include "strawberry/hash_utils.hpp"
|
|
#include "strawberry/policy.hpp"
|
|
#include "strawberry/process_monitor.hpp"
|
|
|
|
#include <cassert>
|
|
#include <chrono>
|
|
#include <condition_variable>
|
|
#include <cstdlib>
|
|
#include <filesystem>
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <mutex>
|
|
#include <string>
|
|
#include <thread>
|
|
#include <vector>
|
|
|
|
#include <fcntl.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
|
|
#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_runtime_pipeline_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-runtime\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 SyntheticRuntimeRule {\n"
|
|
" meta:\n"
|
|
" severity = \"High\"\n"
|
|
" strings:\n"
|
|
" $marker = \"synthetic-payload-marker\"\n"
|
|
" condition:\n"
|
|
" $marker\n"
|
|
"}\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
|
|
}
|
|
|
|
void test_procfs_event_scans_and_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_exec";
|
|
const auto database_path = (root / "runtime_pipeline.db").string();
|
|
|
|
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-payload-marker");
|
|
write_rule_file(rules_dir / "synthetic_runtime.yar");
|
|
|
|
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::Config config;
|
|
config.db_path = database_path;
|
|
config.yara_rules_path = rules_dir.string();
|
|
|
|
strawberry::DetectionPipeline pipeline;
|
|
assert(pipeline.initialize(config));
|
|
|
|
strawberry::ProcessMonitor monitor;
|
|
assert(monitor.initialize());
|
|
|
|
std::mutex mutex;
|
|
std::condition_variable cv;
|
|
std::vector<strawberry::ProcessInfo> observed_events;
|
|
|
|
std::cout << "Test procfs_event_scans_and_persists_match:" << std::endl;
|
|
assert(monitor.start([&](const strawberry::ProcessInfo& info) {
|
|
pipeline.handle_process(info);
|
|
{
|
|
std::lock_guard<std::mutex> lock(mutex);
|
|
observed_events.push_back(info);
|
|
}
|
|
cv.notify_all();
|
|
}));
|
|
|
|
const auto staged_proc_dir = proc_root / "pending-321";
|
|
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_exec", "--runtime-test"});
|
|
write_status_file(staged_proc_dir / "status", 77);
|
|
|
|
const auto live_proc_dir = proc_root / "321";
|
|
fs::rename(staged_proc_dir, live_proc_dir, ec);
|
|
assert(!ec);
|
|
|
|
{
|
|
std::unique_lock<std::mutex> lock(mutex);
|
|
const bool observed = cv.wait_for(lock, std::chrono::seconds(2), [&]() {
|
|
return !observed_events.empty();
|
|
});
|
|
assert(observed);
|
|
}
|
|
|
|
monitor.stop();
|
|
pipeline.shutdown();
|
|
|
|
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 == "SyntheticRuntimeRule");
|
|
assert(hits[0].severity == "high");
|
|
assert(hits[0].metadata.at("source") == "yara");
|
|
assert(hits[0].metadata.at("scan_kind") == "process_executable");
|
|
assert(hits[0].metadata.at("pid") == "321");
|
|
assert(hits[0].metadata.at("parent_pid") == "77");
|
|
assert(hits[0].metadata.at("process_path") == executable.string());
|
|
assert(hits[0].metadata.at("cmdline") == "synthetic_exec --runtime-test");
|
|
assert(!hits[0].metadata.at("event_timestamp_ns").empty());
|
|
|
|
auto findings = database.list_findings();
|
|
assert(findings.size() == 1);
|
|
assert(findings[0].title == "YARA match on executed process image");
|
|
assert(findings[0].severity == "high");
|
|
assert(findings[0].metadata.at("rule") == "process_executable_yara_match");
|
|
assert(findings[0].metadata.at("pid") == "321");
|
|
assert(findings[0].summary.find("SyntheticRuntimeRule") != std::string::npos);
|
|
|
|
const std::string file_node_id = "file_" + expected_hash;
|
|
|
|
auto related = database.find_related_nodes("process_321", 1);
|
|
assert(related.size() == 2);
|
|
bool saw_file = false;
|
|
bool saw_indicator = false;
|
|
for (const auto& node : related) {
|
|
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");
|
|
} else if (node.type == "indicator") {
|
|
saw_indicator = true;
|
|
assert(node.properties.at("rule_name") == "SyntheticRuntimeRule");
|
|
assert(node.properties.at("cmdline") == "synthetic_exec --runtime-test");
|
|
assert(node.properties.at("parent_pid") == "77");
|
|
}
|
|
}
|
|
assert(saw_file);
|
|
assert(saw_indicator);
|
|
|
|
auto edges = database.get_node_edges("process_321");
|
|
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_77", 1);
|
|
assert(parent_related.size() == 1);
|
|
assert(parent_related[0].id == "process_321");
|
|
|
|
auto file_related = database.find_related_nodes(file_node_id, 1);
|
|
assert(file_related.size() == 1);
|
|
assert(file_related[0].type == "indicator");
|
|
assert(file_related[0].properties.at("rule_name") == "SyntheticRuntimeRule");
|
|
|
|
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);
|
|
}
|
|
|
|
void write_text_file(const fs::path& path, const std::string& content) {
|
|
write_binary_file(path, content);
|
|
}
|
|
|
|
void test_fails_closed_without_rules() {
|
|
const auto root = make_test_root();
|
|
const auto empty_rules = root / "empty_rules";
|
|
std::error_code ec;
|
|
fs::create_directories(empty_rules, ec);
|
|
|
|
std::cout << "Test fails_closed_without_rules:" << std::endl;
|
|
strawberry::Config config;
|
|
config.db_path = (root / "no_rules.db").string();
|
|
config.yara_rules_path = empty_rules.string();
|
|
|
|
strawberry::DetectionPipeline strict;
|
|
assert(!strict.initialize(config));
|
|
|
|
config.require_rules = false;
|
|
strawberry::DetectionPipeline permissive;
|
|
assert(permissive.initialize(config));
|
|
permissive.shutdown();
|
|
|
|
std::cout << " PASSED" << std::endl;
|
|
fs::remove_all(root, ec);
|
|
}
|
|
|
|
void test_single_writer_lock_and_read_only_queries() {
|
|
const auto root = make_test_root();
|
|
const auto rules_dir = root / "rules";
|
|
write_rule_file(rules_dir / "synthetic_runtime.yar");
|
|
const auto db_path = (root / "locked.db").string();
|
|
|
|
std::cout << "Test single_writer_lock_and_read_only_queries:" << std::endl;
|
|
strawberry::Config config;
|
|
config.db_path = db_path;
|
|
config.yara_rules_path = rules_dir.string();
|
|
|
|
strawberry::DetectionPipeline pipeline;
|
|
assert(pipeline.initialize(config));
|
|
|
|
// A second writer must be refused while the pipeline owns the store.
|
|
strawberry::Database second_writer;
|
|
assert(!second_writer.open(db_path));
|
|
|
|
strawberry::DetectionPipeline second_pipeline;
|
|
assert(!second_pipeline.initialize(config));
|
|
|
|
// Readers are allowed and never write back.
|
|
strawberry::Database reader;
|
|
assert(reader.open_read_only(db_path));
|
|
assert(reader.is_read_only());
|
|
reader.close();
|
|
|
|
pipeline.shutdown();
|
|
assert(second_writer.open(db_path));
|
|
second_writer.close();
|
|
|
|
std::cout << " PASSED" << std::endl;
|
|
std::error_code ec;
|
|
fs::remove_all(root, ec);
|
|
}
|
|
|
|
void test_stable_ids_severity_default_and_heuristics() {
|
|
const auto root = make_test_root();
|
|
const auto rules_dir = root / "rules";
|
|
const auto executable = root / "bin" / "reused_pid_exec";
|
|
const auto db_path = (root / "identity.db").string();
|
|
|
|
write_binary_file(executable, std::string("\x7f\x45\x4c\x46") + "no-severity-marker");
|
|
write_text_file(rules_dir / "no_severity.yar",
|
|
"rule NoSeverityRule {\n"
|
|
" strings:\n"
|
|
" $m = \"no-severity-marker\"\n"
|
|
" condition:\n"
|
|
" $m\n"
|
|
"}\n");
|
|
const auto hash = strawberry::HashUtils::sha256_file(executable.string());
|
|
|
|
std::cout << "Test stable_ids_severity_default_and_heuristics:" << std::endl;
|
|
strawberry::Config config;
|
|
config.db_path = db_path;
|
|
config.yara_rules_path = rules_dir.string();
|
|
|
|
strawberry::DetectionPipeline pipeline;
|
|
assert(pipeline.initialize(config));
|
|
|
|
// Two different process instances that happen to share PID 500.
|
|
strawberry::ProcessInfo first;
|
|
first.pid = 500;
|
|
first.parent_pid = 1;
|
|
first.executable_path = executable.string();
|
|
first.image_path = executable.string();
|
|
first.hash = hash;
|
|
first.cmdline = "reused_pid_exec --first";
|
|
first.start_time_ticks = 1000;
|
|
first.parent_start_time_ticks = 1;
|
|
first.boot_id = "feedfacecafebeef";
|
|
first.event_timestamp_ns = 1'000;
|
|
|
|
auto second = first;
|
|
second.cmdline = "reused_pid_exec --second";
|
|
second.start_time_ticks = 9000;
|
|
second.event_timestamp_ns = 2'000;
|
|
second.executable_deleted = true;
|
|
|
|
pipeline.handle_process(first);
|
|
pipeline.handle_process(second);
|
|
assert(pipeline.run_pending_correlation());
|
|
assert(!pipeline.run_pending_correlation());
|
|
pipeline.shutdown();
|
|
|
|
strawberry::Database database;
|
|
assert(database.open_read_only(db_path));
|
|
|
|
const auto first_id = strawberry::process_node_id(first);
|
|
const auto second_id = strawberry::process_node_id(second);
|
|
assert(first_id == "process_500_feedface_1000");
|
|
assert(second_id == "process_500_feedface_9000");
|
|
|
|
auto first_node = database.find_graph_node(first_id);
|
|
auto second_node = database.find_graph_node(second_id);
|
|
assert(first_node && second_node);
|
|
assert(first_node->properties.at("cmdline") == "reused_pid_exec --first");
|
|
assert(second_node->properties.at("cmdline") == "reused_pid_exec --second");
|
|
assert(second_node->properties.at("exe_deleted") == "true");
|
|
assert(second_node->properties.at("parent_node_id") == "process_1_feedface_1");
|
|
|
|
bool saw_yara = false;
|
|
bool saw_deleted = false;
|
|
for (const auto& hit : database.find_indicators_by_hash(hash)) {
|
|
if (hit.rule_name == "NoSeverityRule") {
|
|
saw_yara = true;
|
|
assert(hit.severity == "medium");
|
|
} else if (hit.rule_name == "DeletedExecutable") {
|
|
saw_deleted = true;
|
|
assert(hit.severity == "low");
|
|
assert(hit.metadata.at("source") == "heuristic");
|
|
assert(hit.metadata.at("process_node_id") == second_id);
|
|
}
|
|
}
|
|
assert(saw_yara);
|
|
assert(saw_deleted);
|
|
|
|
// Same hash in two process instances (same PID) is still two processes.
|
|
bool saw_same_hash = false;
|
|
std::size_t per_process_findings = 0;
|
|
for (const auto& finding : database.list_findings()) {
|
|
if (finding.metadata.at("rule") == "same_hash_multiple_process_matches") {
|
|
saw_same_hash = true;
|
|
}
|
|
if (finding.metadata.at("rule") == "process_executable_yara_match") {
|
|
++per_process_findings;
|
|
}
|
|
}
|
|
assert(saw_same_hash);
|
|
assert(per_process_findings == 2);
|
|
|
|
database.close();
|
|
std::cout << " PASSED" << std::endl;
|
|
std::error_code ec;
|
|
fs::remove_all(root, ec);
|
|
}
|
|
|
|
std::string identity_of(const fs::path& path) {
|
|
struct stat st{};
|
|
assert(::stat(path.c_str(), &st) == 0);
|
|
return std::to_string(st.st_dev) + ":" + std::to_string(st.st_ino);
|
|
}
|
|
|
|
void test_scans_only_the_verified_image() {
|
|
const auto root = make_test_root();
|
|
const auto rules_dir = root / "rules";
|
|
const auto malicious = root / "bin" / "malicious";
|
|
const auto clean = root / "bin" / "clean";
|
|
const auto db_path = (root / "verified.db").string();
|
|
|
|
write_rule_file(rules_dir / "synthetic_runtime.yar");
|
|
write_binary_file(malicious, std::string("\x7f\x45\x4c\x46") + "synthetic-payload-marker");
|
|
write_binary_file(clean, std::string("\x7f\x45\x4c\x46") + "nothing to see");
|
|
|
|
std::cout << "Test scans_only_the_verified_image:" << std::endl;
|
|
strawberry::Config config;
|
|
config.db_path = db_path;
|
|
config.yara_rules_path = rules_dir.string();
|
|
|
|
strawberry::DetectionPipeline pipeline;
|
|
assert(pipeline.initialize(config));
|
|
|
|
// Event resolved to the clean image, but by scan time the pinned path
|
|
// points at a different inode (process re-exec'd): must not be scanned.
|
|
strawberry::ProcessInfo swapped;
|
|
swapped.pid = 700;
|
|
swapped.executable_path = clean.string();
|
|
swapped.image_path = malicious.string();
|
|
swapped.image_identity = identity_of(clean);
|
|
pipeline.handle_process(swapped);
|
|
|
|
// Process already exited (pinned link gone): fall back to the on-disk
|
|
// path because it is still the same inode.
|
|
strawberry::ProcessInfo exited;
|
|
exited.pid = 701;
|
|
exited.executable_path = malicious.string();
|
|
exited.image_path = (root / "proc" / "701" / "exe").string();
|
|
exited.image_identity = identity_of(malicious);
|
|
pipeline.handle_process(exited);
|
|
|
|
// Duplicate event for the same process instance and image is ignored.
|
|
pipeline.handle_process(exited);
|
|
pipeline.shutdown();
|
|
|
|
strawberry::Database database;
|
|
assert(database.open_read_only(db_path));
|
|
const auto indicators = database.list_indicators();
|
|
assert(indicators.size() == 1);
|
|
assert(indicators[0].metadata.at("pid") == "701");
|
|
assert(indicators[0].rule_name == "SyntheticRuntimeRule");
|
|
assert(indicators[0].hash == strawberry::HashUtils::sha256_file(malicious.string()));
|
|
database.close();
|
|
|
|
std::cout << " PASSED" << std::endl;
|
|
std::error_code ec;
|
|
fs::remove_all(root, ec);
|
|
}
|
|
|
|
void test_stats_and_rescan_after_rule_reload() {
|
|
const auto root = make_test_root();
|
|
const auto rules_dir = root / "rules";
|
|
const auto executable = root / "bin" / "late_detected";
|
|
const auto db_path = (root / "stats.db").string();
|
|
|
|
// Start with a rule that does not match the binary.
|
|
write_text_file(rules_dir / "active.yar",
|
|
"rule Unrelated { strings: $a = \"nothing-matches-this\" condition: $a }\n");
|
|
write_binary_file(executable, std::string("\x7f\x45\x4c\x46") + "synthetic-payload-marker");
|
|
|
|
std::cout << "Test stats_and_rescan_after_rule_reload:" << std::endl;
|
|
strawberry::Config config;
|
|
config.db_path = db_path;
|
|
config.yara_rules_path = rules_dir.string();
|
|
|
|
strawberry::DetectionPipeline pipeline;
|
|
assert(pipeline.initialize(config));
|
|
auto stats = pipeline.stats();
|
|
assert(stats.rules_loaded && stats.rules_generation == 1 && stats.rule_files == 1);
|
|
assert(pipeline.database_path() == db_path);
|
|
|
|
strawberry::ProcessInfo info;
|
|
info.pid = 800;
|
|
info.executable_path = executable.string();
|
|
info.image_path = executable.string();
|
|
info.image_identity = identity_of(executable);
|
|
info.start_time_ticks = 42;
|
|
|
|
pipeline.handle_process(info);
|
|
pipeline.handle_process(info); // rescan with same rules: deduped
|
|
stats = pipeline.stats();
|
|
assert(stats.events_handled == 2);
|
|
assert(stats.images_scanned == 1);
|
|
assert(stats.detections == 0);
|
|
|
|
// A broken rule file: reload fails, previous rules stay active, error is reported.
|
|
write_text_file(rules_dir / "active.yar", "rule Broken { condition: }\n");
|
|
assert(!pipeline.reload_rules());
|
|
stats = pipeline.stats();
|
|
assert(stats.rules_loaded && stats.rules_generation == 1);
|
|
assert(!stats.last_rules_error.empty());
|
|
|
|
// Fixed rule that matches: rescan of the same process now records it once.
|
|
write_rule_file(rules_dir / "active.yar");
|
|
assert(pipeline.reload_rules());
|
|
stats = pipeline.stats();
|
|
assert(stats.rules_generation == 2 && stats.last_rules_error.empty());
|
|
|
|
pipeline.handle_process(info);
|
|
pipeline.handle_process(info);
|
|
stats = pipeline.stats();
|
|
assert(stats.detections == 1);
|
|
assert(stats.last_detection_ns > 0);
|
|
pipeline.shutdown();
|
|
|
|
strawberry::Database database;
|
|
assert(database.open_read_only(db_path));
|
|
assert(database.list_indicators().size() == 1);
|
|
database.close();
|
|
|
|
std::cout << " PASSED" << std::endl;
|
|
std::error_code ec;
|
|
fs::remove_all(root, ec);
|
|
}
|
|
|
|
void test_scan_on_demand_is_read_only_and_bounded() {
|
|
const auto root = make_test_root();
|
|
const auto rules_dir = root / "rules";
|
|
const auto sample = root / "sample.bin";
|
|
const auto db_path = (root / "ondemand.db").string();
|
|
write_rule_file(rules_dir / "synthetic_runtime.yar");
|
|
write_binary_file(sample, std::string("prefix synthetic-payload-marker suffix"));
|
|
|
|
std::cout << "Test scan_on_demand_is_read_only_and_bounded:" << std::endl;
|
|
strawberry::Config config;
|
|
config.db_path = db_path;
|
|
config.yara_rules_path = rules_dir.string();
|
|
strawberry::DetectionPipeline pipeline;
|
|
assert(pipeline.initialize(config));
|
|
|
|
int fd = ::open(sample.c_str(), O_RDONLY | O_CLOEXEC);
|
|
assert(fd >= 0);
|
|
auto result = pipeline.scan_on_demand(fd, 1024);
|
|
assert(result.ok);
|
|
assert(result.size == fs::file_size(sample));
|
|
assert(result.sha256 == strawberry::HashUtils::sha256_file(sample.string()));
|
|
assert(result.matches.size() == 1);
|
|
assert(result.matches[0].rule == "SyntheticRuntimeRule");
|
|
assert(result.matches[0].severity == "high");
|
|
|
|
// Size cap.
|
|
result = pipeline.scan_on_demand(fd, 8);
|
|
assert(!result.ok && result.error.find("too large") != std::string::npos);
|
|
::close(fd);
|
|
|
|
// Non-regular file.
|
|
fd = ::open(root.c_str(), O_RDONLY | O_DIRECTORY | O_CLOEXEC);
|
|
assert(fd >= 0);
|
|
result = pipeline.scan_on_demand(fd, 1024);
|
|
assert(!result.ok && result.error == "not a regular file");
|
|
::close(fd);
|
|
|
|
assert(pipeline.stats().detections == 0);
|
|
pipeline.shutdown();
|
|
|
|
strawberry::Database database;
|
|
assert(database.open_read_only(db_path));
|
|
assert(database.list_indicators().empty());
|
|
database.close();
|
|
|
|
std::cout << " PASSED" << std::endl;
|
|
std::error_code ec;
|
|
fs::remove_all(root, ec);
|
|
}
|
|
|
|
void test_feed_sources_allowlist_and_size_cap() {
|
|
const auto root = make_test_root();
|
|
const auto rules_dir = root / "rules";
|
|
const auto feeds_dir = root / "feeds";
|
|
const auto executable = root / "bin" / "dual_match";
|
|
const auto db_path = (root / "policy_pipeline.db").string();
|
|
write_rule_file(rules_dir / "synthetic_runtime.yar");
|
|
write_binary_file(executable, std::string("\x7f\x45\x4c\x46") + "synthetic-payload-marker feed-marker");
|
|
|
|
// One installed feed (feeds/f1/current -> v1) with its own rule.
|
|
fs::create_directories(feeds_dir / "f1" / "v1");
|
|
write_text_file(feeds_dir / "f1" / "v1" / "feed.yar",
|
|
"rule FeedRule { meta: severity = \"medium\" strings: $f = \"feed-marker\" condition: $f }\n");
|
|
fs::create_directory_symlink("v1", feeds_dir / "f1" / "current");
|
|
|
|
std::cout << "Test feed_sources_allowlist_and_size_cap:" << std::endl;
|
|
strawberry::Config config;
|
|
config.db_path = db_path;
|
|
config.yara_rules_path = rules_dir.string();
|
|
config.policy_path = (root / "policy.json").string();
|
|
config.feeds_dir = feeds_dir.string();
|
|
|
|
strawberry::PolicyStore policy(config.policy_path);
|
|
assert(policy.load());
|
|
std::string error;
|
|
assert(policy.apply("feed-remove", R"({"id":"yara-forge-core"})", 0, &error));
|
|
assert(policy.apply("feed-add", R"({"id":"f1","type":"url","url":"https://example.com/feed.yar"})", 0, &error));
|
|
|
|
strawberry::DetectionPipeline pipeline;
|
|
assert(pipeline.initialize(config, &policy));
|
|
assert(pipeline.stats().rule_count == 2); // local + feed, separate namespaces
|
|
|
|
const auto hash = strawberry::HashUtils::sha256_file(executable.string());
|
|
uint64_t start = 100;
|
|
const auto event = [&]() {
|
|
strawberry::ProcessInfo info;
|
|
info.pid = 900;
|
|
info.executable_path = executable.string();
|
|
info.image_path = executable.string();
|
|
info.image_identity = identity_of(executable);
|
|
info.start_time_ticks = start++;
|
|
return info;
|
|
};
|
|
|
|
pipeline.handle_process(event());
|
|
assert(pipeline.stats().detections == 2);
|
|
|
|
// Suppress the feed rule everywhere: only the local rule is stored.
|
|
assert(policy.apply("allowlist-add", R"({"kind":"rule","value":"FeedRule"})", 1000, &error));
|
|
pipeline.handle_process(event());
|
|
assert(pipeline.stats().detections == 3);
|
|
assert(pipeline.stats().suppressed == 1);
|
|
|
|
// Allowlist the exact binary: nothing stored.
|
|
assert(policy.apply("allowlist-add", R"({"kind":"sha256","value":")" + hash + R"("})", 1000, &error));
|
|
pipeline.handle_process(event());
|
|
assert(pipeline.stats().detections == 3);
|
|
assert(pipeline.stats().suppressed == 3);
|
|
|
|
// Disabling the feed drops its rules on reload.
|
|
assert(policy.apply("feed-set-enabled", R"({"id":"f1","enabled":false})", 1000, &error));
|
|
assert(pipeline.reload_rules());
|
|
assert(pipeline.stats().rule_count == 1);
|
|
pipeline.shutdown();
|
|
|
|
strawberry::Database database;
|
|
assert(database.open_read_only(db_path));
|
|
std::size_t feed_hits = 0;
|
|
for (const auto& indicator : database.list_indicators()) {
|
|
feed_hits += indicator.rule_name == "FeedRule" ? 1 : 0;
|
|
if (indicator.rule_name == "FeedRule") {
|
|
assert(indicator.metadata.at("namespace") == "f1");
|
|
}
|
|
}
|
|
assert(feed_hits == 1);
|
|
database.close();
|
|
|
|
// Size cap: images over process_scan_max_bytes are counted, not scanned.
|
|
config.process_scan_max_bytes = 8;
|
|
config.db_path = (root / "size_cap.db").string();
|
|
strawberry::DetectionPipeline capped;
|
|
assert(capped.initialize(config));
|
|
capped.handle_process(event());
|
|
assert(capped.stats().images_too_large == 1);
|
|
assert(capped.stats().images_scanned == 0);
|
|
assert(capped.stats().detections == 0);
|
|
capped.shutdown();
|
|
|
|
std::cout << " PASSED" << std::endl;
|
|
std::error_code ec;
|
|
fs::remove_all(root, ec);
|
|
}
|
|
|
|
void test_ioc_hash_detection_and_score_severity() {
|
|
const auto root = make_test_root();
|
|
const auto rules_dir = root / "rules";
|
|
const auto feeds_dir = root / "feeds";
|
|
const auto known_bad = root / "bin" / "known_bad";
|
|
const auto scored = root / "bin" / "scored";
|
|
write_text_file(rules_dir / "scored.yar",
|
|
"rule Scored_Rule { meta: score = 75 strings: $s = \"scored-marker\" condition: $s }\n");
|
|
write_binary_file(known_bad, std::string("\x7f\x45\x4c\x46") + "no rule matches this");
|
|
write_binary_file(scored, std::string("\x7f\x45\x4c\x46") + "scored-marker");
|
|
const auto bad_hash = strawberry::HashUtils::sha256_file(known_bad.string());
|
|
|
|
fs::create_directories(feeds_dir / "hash-feed" / "v1");
|
|
write_text_file(feeds_dir / "hash-feed" / "v1" / "list.txt", std::string(64, '0') + "\n" + bad_hash + "\n");
|
|
fs::create_directory_symlink("v1", feeds_dir / "hash-feed" / "current");
|
|
|
|
std::cout << "Test ioc_hash_detection_and_score_severity:" << std::endl;
|
|
strawberry::Config config;
|
|
config.db_path = (root / "ioc.db").string();
|
|
config.yara_rules_path = rules_dir.string();
|
|
config.policy_path = (root / "policy.json").string();
|
|
config.feeds_dir = feeds_dir.string();
|
|
|
|
strawberry::PolicyStore policy(config.policy_path);
|
|
assert(policy.load());
|
|
std::string error;
|
|
assert(policy.apply("feed-add", R"({"id":"hash-feed","kind":"hashes","type":"url","url":"https://example.com/h.txt"})", 0, &error));
|
|
|
|
strawberry::DetectionPipeline pipeline;
|
|
assert(pipeline.initialize(config, &policy));
|
|
assert(pipeline.stats().ioc_hashes == 2);
|
|
|
|
const auto event = [&](const fs::path& exe, uint64_t start) {
|
|
strawberry::ProcessInfo info;
|
|
info.pid = 950;
|
|
info.executable_path = exe.string();
|
|
info.image_path = exe.string();
|
|
info.image_identity = identity_of(exe);
|
|
info.start_time_ticks = start;
|
|
return info;
|
|
};
|
|
pipeline.handle_process(event(known_bad, 1));
|
|
pipeline.handle_process(event(scored, 2));
|
|
|
|
// On-demand scans report IOC hits too.
|
|
const int fd = ::open(known_bad.c_str(), O_RDONLY | O_CLOEXEC);
|
|
const auto on_demand = pipeline.scan_on_demand(fd, 1 << 20);
|
|
::close(fd);
|
|
assert(on_demand.ok && on_demand.matches.size() == 1);
|
|
assert(on_demand.matches[0].rule == "IOC_KnownMalwareHash" && on_demand.matches[0].severity == "critical");
|
|
assert(on_demand.matches[0].namespace_name == "hash-feed");
|
|
pipeline.shutdown();
|
|
|
|
strawberry::Database database;
|
|
assert(database.open_read_only(config.db_path));
|
|
bool saw_ioc = false;
|
|
bool saw_scored = false;
|
|
for (const auto& indicator : database.list_indicators()) {
|
|
if (indicator.rule_name == "IOC_KnownMalwareHash") {
|
|
saw_ioc = true;
|
|
assert(indicator.severity == "critical");
|
|
assert(indicator.metadata.at("source") == "ioc");
|
|
assert(indicator.hash == bad_hash);
|
|
} else if (indicator.rule_name == "Scored_Rule") {
|
|
saw_scored = true;
|
|
assert(indicator.severity == "high"); // score 75 -> high
|
|
}
|
|
}
|
|
assert(saw_ioc && saw_scored);
|
|
bool saw_title = false;
|
|
for (const auto& finding : database.list_findings()) {
|
|
saw_title |= finding.title.find("Known malware executed") != std::string::npos && finding.severity == "critical";
|
|
}
|
|
assert(saw_title);
|
|
database.close();
|
|
|
|
std::cout << " PASSED" << std::endl;
|
|
std::error_code ec;
|
|
fs::remove_all(root, ec);
|
|
}
|
|
void test_governed_shared_cache_degrade_and_caps() {
|
|
const auto root = make_test_root();
|
|
const auto rules_dir = root / "rules";
|
|
const auto executable = root / "bin" / "guarded";
|
|
const auto other = root / "bin" / "guarded_later";
|
|
write_rule_file(rules_dir / "synthetic_runtime.yar");
|
|
write_binary_file(executable, std::string("\x7f\x45\x4c\x46") + "synthetic-payload-marker");
|
|
write_binary_file(other, std::string("\x7f\x45\x4c\x46") + "synthetic-payload-marker-2");
|
|
|
|
std::cout << "Test governed_shared_cache_degrade_and_caps:" << std::endl;
|
|
strawberry::ResourceSample sample;
|
|
sample.host_source = "psi";
|
|
sample.cpu_some_pct = 1;
|
|
sample.own_cpu_pct = 1;
|
|
sample.rss_bytes = 10ull << 20;
|
|
strawberry::GovernorOptions options;
|
|
options.profile = *strawberry::scan_profile_named("balanced");
|
|
options.sampler = [&sample]() { return sample; };
|
|
options.sleeper = [](std::chrono::milliseconds) {};
|
|
strawberry::ResourceGovernor governor(options);
|
|
governor.tick();
|
|
|
|
strawberry::Config config;
|
|
config.db_path = (root / "governed.db").string();
|
|
config.yara_rules_path = rules_dir.string();
|
|
strawberry::DetectionPipeline pipeline;
|
|
pipeline.set_governor(&governor);
|
|
assert(pipeline.initialize(config));
|
|
|
|
// The exec guard scans first; its result serves the pipeline too.
|
|
int fd = ::open(executable.c_str(), O_RDONLY | O_CLOEXEC);
|
|
assert(fd >= 0);
|
|
auto assessment = pipeline.assess_exec(fd, executable.string());
|
|
::close(fd);
|
|
assert(assessment.scanned && !assessment.degraded);
|
|
assert(assessment.top_rule == "SyntheticRuntimeRule");
|
|
assert(pipeline.perf().yara_scan_us.summary().count == 1);
|
|
|
|
strawberry::ProcessInfo info;
|
|
info.pid = 900;
|
|
info.executable_path = executable.string();
|
|
info.image_path = executable.string();
|
|
info.image_identity = identity_of(executable);
|
|
info.start_time_ticks = 7;
|
|
// Small, already cached image: cheap, handled on the live path.
|
|
assert(pipeline.slow_scan_key(info, 0).empty());
|
|
pipeline.handle_process(info);
|
|
auto stats = pipeline.stats();
|
|
assert(stats.detections == 1);
|
|
assert(stats.scan_cache_hits == 1 && stats.images_scanned == 0);
|
|
assert(pipeline.perf().yara_scan_us.summary().count == 1); // no second YARA pass
|
|
|
|
// Severe host pressure: the guard decides on hash/IOC/quarantine only, and
|
|
// a degraded result is not cached (the pipeline still scans it).
|
|
sample.cpu_some_pct = 95;
|
|
governor.tick();
|
|
fd = ::open(other.c_str(), O_RDONLY | O_CLOEXEC);
|
|
assert(fd >= 0);
|
|
assessment = pipeline.assess_exec(fd, other.string());
|
|
::close(fd);
|
|
assert(assessment.scanned && assessment.degraded && assessment.top_rule.empty());
|
|
assert(!assessment.sha256.empty() && !assessment.md5.empty());
|
|
assert(pipeline.perf().yara_scan_us.summary().count == 1);
|
|
info.pid = 901;
|
|
info.executable_path = other.string();
|
|
info.image_path = other.string();
|
|
info.image_identity = identity_of(other);
|
|
// Uncached: needs a full scan (key returned) unless below the size floor.
|
|
assert(!pipeline.slow_scan_key(info, 0).empty());
|
|
assert(pipeline.slow_scan_key(info, 1 << 20).empty());
|
|
pipeline.handle_process(info);
|
|
assert(pipeline.slow_scan_key(info, 0).empty()); // cached now
|
|
stats = pipeline.stats();
|
|
assert(stats.images_scanned == 1 && stats.detections == 2);
|
|
pipeline.shutdown();
|
|
|
|
// The profile's image cap applies even when the config allows more.
|
|
auto small = *strawberry::scan_profile_named("balanced");
|
|
small.pipeline_max_image_bytes = 8;
|
|
options.profile = small;
|
|
strawberry::ResourceGovernor capped(options);
|
|
capped.tick();
|
|
strawberry::DetectionPipeline limited;
|
|
limited.set_governor(&capped);
|
|
config.db_path = (root / "capped.db").string();
|
|
assert(limited.initialize(config));
|
|
info.pid = 902;
|
|
info.executable_path = executable.string();
|
|
info.image_path = executable.string();
|
|
info.image_identity = identity_of(executable);
|
|
limited.handle_process(info);
|
|
assert(limited.stats().images_too_large == 1 && limited.stats().images_scanned == 0);
|
|
// Repeated execs of a too-large image are cache hits, not re-reads.
|
|
info.pid = 903;
|
|
limited.handle_process(info);
|
|
assert(limited.stats().images_too_large == 1 && limited.stats().scan_cache_hits == 1);
|
|
limited.shutdown();
|
|
|
|
std::cout << " PASSED" << std::endl;
|
|
std::error_code ec;
|
|
fs::remove_all(root, ec);
|
|
}
|
|
#endif
|
|
|
|
} // namespace
|
|
|
|
int main() {
|
|
std::cout << "Running DetectionPipeline tests..." << std::endl << std::endl;
|
|
|
|
#if !STRAWBERRY_HAVE_YARA
|
|
std::cout << "SKIP: runtime pipeline end-to-end test requires libyara" << std::endl;
|
|
return 0;
|
|
#else
|
|
test_procfs_event_scans_and_persists_match();
|
|
test_fails_closed_without_rules();
|
|
test_single_writer_lock_and_read_only_queries();
|
|
test_stable_ids_severity_default_and_heuristics();
|
|
test_scans_only_the_verified_image();
|
|
test_stats_and_rescan_after_rule_reload();
|
|
test_scan_on_demand_is_read_only_and_bounded();
|
|
test_feed_sources_allowlist_and_size_cap();
|
|
test_ioc_hash_detection_and_score_severity();
|
|
test_governed_shared_cache_degrade_and_caps();
|
|
std::cout << std::endl << "All tests passed!" << std::endl;
|
|
return 0;
|
|
#endif
|
|
}
|