On the host, 586 of 303k records arrived more than 30 s late: exec records
of large images are written after their paced, deferrable scan. Replay is
offline, so holding 2 minutes of records costs nothing that matters.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
From the first replay of real host data (3.5 h, 266k records):
- A never-seen event scored higher the more the model had seen, so the
ranking favoured whatever happened last (the reinstall's systemctl
and generator runs). Each event is now capped at 16 bits (never
seen), and a window scores the sum of its three most surprising
distinct events.
- Warm-up: on a fresh history nearly everything is new. Windows in the
first 12 h are learned from but not ranked (--warmup H); detections
are always listed. The CLI says so when nothing is ranked yet.
- Windows with the same root program and top pattern are one line with
a count ("x40 similar").
- Counts: file writes split by persistence; events from processes
started before recording are reported as such, not as an error;
records more than 30 s out of order are counted as late.
tests/test_replay.cpp R7: warm-up, equal scores for a novel event early
and late, grouping, late-record counting.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Replay (src/learn/replay.cpp, strawberry --replay [dir] [--top N] [--json]):
reads the telemetry stream read-only, orders events by time (a 30 s
reorder buffer absorbs the writer's batching), joins behavior events to
the latest exec of their pid at that time (keeps PID reuse apart), builds
60 s windows (a root exec, its descendants and their behavior, at most 64
events), scores each exec, connection and persistence write with the
rarity model before observing it, and marks windows whose processes had
detections. Prints the most unusual windows with the tuples that made
them unusual. Deterministic. tests/test_replay.cpp: chain windows, PID
reuse, order insensitivity within the horizon, determinism, ranking,
detection marking, a real store round trip. fuzz_replay feeds arbitrary
record streams.
UTF-8: file names are bytes, and the fuzzer showed nlohmann's dump()
throwing on a path that is not UTF-8. The same applied to the daemon's
control replies (kill/suspend/quarantine name the exe path) and to the
OpenSnitch containment rule, so a binary with such a name could not be
contained, and json_escape wrote the raw bytes into status JSON. Now:
- every .dump() in src/ uses error_handler_t::replace (U+FFFD), enforced
by source invariant R9;
- json_escape writes invalid sequences as � (valid_utf8 and
utf8_sequence_length in json_util.hpp);
- containment refuses such a path with a clear error (a rule could never
match the real bytes); quarantine still blocks execution by hash.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
src/learn/ (pure libraries; nothing in the daemon calls them yet, Stage 3
uses them in replay):
- tokenize: path templates (user homes, per-uid dirs, pids, digit and hex
runs, UUIDs, mktemp-style names abstracted) and command-line shapes
(flags kept, values, paths, URLs, IPs, numbers and encoded blobs
classed; the first plain word kept as a subcommand; long argument lists
summarized). Bounded and noexcept.
- rarity: decayed count-min sketches over parent>child, grandparent>
parent>child, exe+command-line shape, exe+connection class and
exe+persistence location, scored as surprisal in bits; a bounded
first-seen table; deterministic hashing for replay. About 1.3 MiB.
tests/test_learn.cpp: tokenizer cases and idempotence; count-min never
underestimates (also after decay); determinism; rare scores above common;
half-life decay; bounded first-seen. fuzz_tokenizer found two
idempotence bugs (truncation before templating, and a cut that left a
" (deleted)" suffix), fixed here.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Their ids included the member pids (and rules or hashes), so every new
process joining a group created a new finding and left the previous one
behind as a duplicate. The id is now the group key alone: the hash, the
rule name, or the parent process. The finding is updated in place as the
group grows; the pids stay in its metadata and summary.
Findings stored under the old ids stay as they are (one last duplicate
per group after upgrading). The incremental property test now also checks
that add-only runs leave exactly one finding per group.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Every finding is a function of one group of indicators (a process, a
parent, a hash or a rule). IncrementalCorrelator keeps group membership
(ids and keys, not indicator contents) and rebuilds only the groups that
new or changed indicators touch. Each pass used to copy every indicator
and rebuild every finding; it now costs about the size of what changed.
- correlation_engine.cpp: the four group loops become per-group
functions (re-indented; logic unchanged), shared by the full pass and
the incremental one.
- EvidenceView keeps a bounded change log of written indicator ids
(resets after clear(), at first use, or past 65536 entries);
Database::take_indicator_changes / find_indicators expose it, with
rolled-back writes reported as removed.
- DetectionPipeline holds its lock only to read changes and members and
to store findings, as before.
Fix found by the oracle test: an indicator naming a process node but no
pid formed a second group for the same process with the same finding id,
and the two findings overwrote each other. The group pid now comes from
the node id when the pid is missing (finding ids are unchanged).
tests/test_correlation_incremental.cpp: random batches of new and updated
indicators give exactly the findings the full pass after every batch
stored (I1, I2); a batch touching one process rebuilds only its groups
(I3); the store's change log, including a rolled-back write.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
File node ids: include/strawberry/node_ids.hpp is now the only place
they are built (file_<sha256> or file_path_<sha256 of path>). The three
modules disagreed: correlation used a 16-digit path hash and behavior
detections the raw path, so path-keyed evidence never met the rest. An
exec detection with a known hash also writes a same_path edge from the
path id to the content id. Source invariant R8 rejects hand-built file
ids in src/ and include/.
Processes carry the real uid and kernel comm: from the eBPF exec event
(which now includes the uid) or /proc. Stored on process nodes and in
process_exec telemetry (fields 14, 15).
Command lines are redacted before any storage (capture_redact_cmdline,
default on): sensitive flags and KEY=value pairs, Authorization/Bearer
credentials, URL passwords, tokens used as URL user names, well-known
token shapes (GitHub, GitLab, Slack, AWS key ids, sk-, JWTs) and mysql
-p<password>. The rules repeat to a fixed point, so redaction is
idempotent by construction. tests/test_redact.cpp covers the rules plus
idempotence, size and planted-secret properties; fuzz_cmdline_redactor
found two idempotence bugs and a leak (--password --token X) that are
fixed here.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Teacher signals and context for the learning stages, written to the
evidence stream (retention never removes it):
- label: operator actions from the control socket (quarantine, contain,
kill, suspend: positive; allowlist-add: negative; allowlist-remove and
quarantine-remove: retracted) and allowlist suppressions (negative,
once per entry, subject and rule). Never from the MCP.
- rules_generation: every rules load attempt, with sources, counts and
the error of a failed reload.
- policy_generation: each policy change, with a sha256 of the policy.
- lifecycle: daemon start and stop.
governor_sample (pressure level, CPU/IO/memory, per-class admissions) goes
to the telemetry stream once a minute.
Database::append_evidence writes records the evidence view ignores.
Tests: record round-trips; suppression labels and dedupe and rules
generations in the pipeline test; operator labels, policy generations and
lifecycle in the daemon test; the record fuzzer covers the new decoders.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Each rule match from a fresh scan now writes a rule_match record: the
rule, namespace, severity, rules generation and its matched strings
(identifier, offset, length, 64-bit FNV-1a digest of the captured bytes).
The matched bytes themselves are never stored. Cache hits write no
rule_match, since their scan_result already names the rules.
Hits are collected in the libyara callback (libyara 4+) and capped at
16 strings per rule, 4 hits per string and 256 per scan. The callback
also tolerates a null user_data now.
Tests: caps, offsets and digests against a real scan; record round-trip
with the encode cap; the telemetry record fuzzer covers rule_match.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Stage 2 increment 2.
- Connect, ptrace and module-load events go to telemetry raw, before the
behavior engine filters them (pid, uid, comm, address/port or target);
the join to processes happens when the data is read.
- Persistence and drop-location writes go to telemetry before any rule
decides on them.
- The exec guard reports every verdict through a new on_observation hook
(allow verdicts and cache hits included; ExecDecision still reports
only non-allow): verdict, answered, scanned, cache hit, degraded, top
rule/severity and latency, as guard_decision records.
Tests: record round-trips; the live exec-guard test checks one
observation per checked exec, including allows and cache hits;
fuzz_telemetry_records covers the new decoders.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Stage 2 increment 1. Until now only detections were stored, so the
learning stages would never see a normal example.
- TelemetrySink: bounded lock-free multi-producer queue (8192); try_emit
never blocks, allocates or throws; a full queue drops and counts.
- A guarded writer thread drains it every 2 s (or at a quarter full)
into the store's root-only telemetry stream through the pipeline,
writing a gap record whenever events were dropped.
- The pipeline emits one process_exec (pid, parent, node ids, exe,
capped cmdline, sha256, deleted/memfd, live/inventory) and one
scan_result (outcome: scanned, cache_hit, too_large, unavailable,
read_error, no_rules, yara_error, pid_scan; bytes, scan time, rules
generation, matched rules) for every handled exec, detection or not.
- Config telemetry=true (default); status gains a telemetry block
(emitted, dropped, queued, written, gaps).
Tests: C1 (never blocks; exactly once and in order under concurrency,
clean under ThreadSanitizer), record round-trips, C2 (one process_exec
and one scan_result per handled exec, stored in the telemetry stream);
fuzz_telemetry_records.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The KPI detect phase still dropped events after the correlation fix.
Cause: every detection kept ~12 KB of evidence in memory, 20k detections
pushed RSS past the 512 MB budget, the governor went to emergency, and in
emergency every live exec scan waited 5 s, so the queue overflowed and
stayed full (memory that is evidence never comes back by waiting).
- The governor holds live exec scans for at most 5 s per emergency
episode, then lets them run (counted as forced); background work still
waits.
- Repeated detections of the same image and rules: the first 20 per
10-minute window are stored in full, then one summary indicator per
key keeps the count and first/last pid and time (rewritten at most
every 30 s). All detections are counted; alerts repeat at most once a
minute per key. Status reports pipeline.repeats_aggregated.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The KPI detect phase dropped 1-2.6k events in 2 of 3 runs: each
correlation pass computed findings over every indicator (300+ ms with
~20k indicators) while holding the pipeline lock, so the exec worker
stalled until its queue (4096) overflowed. Correlation now snapshots the
indicators under the lock, computes findings without it
(CorrelationEngine::build_findings), and takes the lock again only to
store them in one transaction.
"Scanning process" and "New process detected" were logged for every exec
on the host; they now need STRAWBERRY_TRACE_EXECS=1. Detections, errors
and state changes are still logged.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Found by the KPI detect phase (2-3 persist failures per run):
- a finding for one rule across thousands of processes listed every
related id and outgrew the 256 KiB block limit, so the correlation
commit was refused; related lists are now capped at 200 (the most
recent indicators) with the totals in metadata
- a single record up to the 1 MiB record limit may now form a block on
its own (the decoder bound only loosens)
- a refused append records its reason ("rejected: ...") instead of
logging an empty error
- the Database no longer logs every indicator, node, edge and finding it
stores (175k lines in a 4-minute run); failures are still logged
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Stage 1 increment 7.
- Disk floor: below max(store_min_free_mb, store_min_free_pct) free,
telemetry is refused and counted (a gap record with the count and
time range is written once space returns) or, with
store_floor_action=evict_oldest_telemetry, the oldest sealed
telemetry is deleted; evidence continues until store_hard_min_free_mb.
- Retention (telemetry only, off by default): store_retention_days and
store_max_mb, applied when a segment is sealed. Evidence is never
deleted by retention.
- Status gains a store block (floor, free space, per-stream sizes,
compression ratio, drops, deletions); health reports a low disk,
a failed evidence store and unsaved detections.
- strawberry --store-verify checks the manifest and every segment
(read-only, safe while the daemon runs; root-only telemetry is noted,
not flagged). strawberry --store-compact rewrites sealed segments at
zstd level 19 with the daemon stopped, never touching a damaged one.
- The manifest records each sealed segment's uncompressed size.
Tests L7-L11 cover the floor, gaps, retention by age and size,
eviction, compaction and verify.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
--list-findings, --show-finding, --search-process and the trace report
opened config.db_path, which is empty by default, so as a user they read
~/.local/share/strawberry/database.db and showed nothing. They now use
an explicit db_path, else the path the running daemon reports over the
control socket (as the app and MCP do), else /var/lib/strawberry if it
exists, else the per-user default.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Per the triage decisions:
- DeletedExecutable when a new file exists at the executable's path (an
update or reinstall) is stored as evidence only. A binary with nothing
left at its path still raises a low finding.
- scripts/install.sh writes /var/lib/strawberry/installed-files.sha256
(hashes of the units it installs, root-owned, written first). A
PersistenceWrite whose file matches its listed hash is evidence only;
other content at those paths, or a suspicious writer, is reported as
before. The daemon ignores a manifest that is not root-owned or is
group/world-writable.
Evidence-only indicators make no finding, alert or containment on their
own; correlation counts them when the same process has another signal.
Status reports pipeline.evidence_only. Tests cover the manifest, the
behavior hook, correlation and the pipeline (replaced vs deleted).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
sched_process_fork's comm fields became 4-byte __data_loc offsets in
newer kernels, moving child_pid from offset 44 to 20. The hand-written
tracepoint struct read past the event, so the kernel refused to attach
the program and parent-PID enrichment was always off ("Fork tracepoint
✘" in the app). The struct is now CO-RE (preserve_access_index), so
parent_pid/child_pid relocate against the running kernel's BTF. Checked
in a privileged container on kernel 7.2: attaches now, did not before.
The exec smoke test reports whether the tracepoint attached and, when it
did, requires a parent pid on the exec event. The eBPF smokes still
miss the test's own exec inside the container (an older problem, noted
in the live-test runner and tracked separately).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Triage of all 26 findings on a developer workstation (none malicious)
is in docs/false-positives.md: binaries replaced while running
(auto-updates, reinstalls), Strawberry's own installer writing its
systemd units, sanitizer/self-debugging ptrace, deliberate tests, and
the test marker matching process memory.
Fixes:
- behavior detections now honor path and rule allowlist entries (they
only checked sha256, which is computed for high severity only)
- finding summaries include what happened (file written, ptrace
target) and metadata.details
- Strawberry_Test_Marker only matches files that start with the marker
(EICAR-style); it no longer fires on processes holding the text
- ptrace between a parent and child running the same binary
(LeakSanitizer StopTheWorld) is low instead of medium; ProcessRef
carries the parent pid
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Every catch now handles the exception or records it with
STRAWBERRY_NOTE_SWALLOWED() (strawberry/swallowed.hpp): an atomic count,
exported in status as resources.swallowed_exceptions, plus a file:line
log line written with write(2), so it is safe out of memory and in
destructors. The 16 empty catches (store error fallbacks, destructors,
YARA compiler callback, thread entry logging) now use it. Status also
reports thread_errors, which was counted but never exported.
Enforced by source invariant R7 (with a self-test fixture) and by
clang-tidy bugprone-empty-catch in a new .clang-tidy (errors; inherits
parent config). AGENTS.md and CLAUDE.md state the rule.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Nothing shipped used the library after the event store landed. A small
reader/writer for its file format (src/store/legacy_kv) replaces it for
the legacy code, and the submodule, subproject and library test are
removed.
A writer open now imports a legacy database.db file into the event
store: indicators are replayed in an order consistent with the old
hash/rule indexes, the result is verified against the old file, the
old file is kept as database.db.migrated-<ts>, and an import
interrupted between its final renames is finished on the next open.
Read-only handles read a legacy file directly and switch to the store
once it is imported. Ids re-stored under another hash are reported
(their old index entries cannot be carried over).
Tests: legacy import properties I1-I6 (locked and corrupt files are
left untouched), the differential test now shares its comparisons, and
fuzz_legacy_kv covers the file parser. A copy of a real 137 KB legacy
database imported cleanly into 7 KB.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Wire the policy, feeds, containment, exec guard, behavior, governor,
crash safety and event store into the daemon, detection pipeline, CLI
and meson build (zstd now required); Dockerfile, conan, systemd unit
(LimitCORE=0, resource limits) and installer updates; existing tests
adapted (store paths are directories now). Detections are counted and
notified even when evidence cannot be persisted (persist_failures in
status). prevention_timeout_ms is clamped and behavior dedupe handles
out-of-order events. Docs: API contract, developer guide, plan, UX,
agent rules.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
zstd block codec (CRC32C, varint tagged records), segment files with
sealed footers and block index, crash-atomic MANIFEST, LogStore
(lock, recovery, rolls, orphaning, heal with backoff), the evidence
view, and the legacy unqlite store kept for import. Property tests
under injected faults and crashes, a differential test against the old
store, and fuzz targets for every decoder.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Fix for the 2026-10-25 host freeze (an uncaught iostream exception on a
/proc read aborted the daemon; its core dump deadlocked with the exec
guard): non-throwing /proc reads, crash handlers that release fanotify
permission fds, guarded thread entries, from_chars parsing.
Adds the io fault-injection seam with property tests, source invariant
checks (R1-R6) with self-test fixtures, libFuzzer targets and seeds
(including I/O-fault fuzzing), the fold changed-files scan scripts and
the agent workflow docs (CLAUDE.md, prompts).
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
PSI/cgroup-aware governor with efficient/balanced/aggressive profiles,
background pacing and thread priorities; timing histograms and optional
Tracy zones; a capped Docker KPI harness with report/compare tooling.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
fanotify exec-permission guard (audit/enforce, fail-open deadline),
eBPF behavior engine (IOC connections, ptrace, module loads,
download-then-execute) and fanotify persistence watch, with unit tests
and privileged Docker live tests.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
PolicyStore (allowlist, protection settings, operator actions), the
rule/feed updater with HTTPS-only fetches and a systemd timer, IOC
hash/domain/network sets, OpenSnitch blocklist containment, the root
control socket (SCM_RIGHTS credentials, verb allowlist) and scanner
health snapshots.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Remove the browser UI, its Python server and the web API contract test.
Add the Qt6 tray app (status, findings, process search, policy
controls, notifications) and EvidenceStore, the read-only view of the
daemon's evidence that the app and MCP server share. The GUI demo
config becomes strawberry.demo.conf.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>