strawberry/RESEARCH.md
2026-04-26 16:37:36 -04:00

13 KiB

Research Brief

Working research brief for Strawberry's current approach and implementation direction.

Linked Documents

Scope

Strawberry's intended design combines:

  • Linux runtime telemetry
  • eBPF/libbpf-based process observation
  • YARA-based file or process-memory matching
  • graph or provenance-style relationship analysis
  • a local embedded store for indicators and relationships

This is not a formal systematic literature review. It is a focused, implementation-oriented reading list assembled on April 25, 2026 from paperbridge results to guide architecture and sequencing.

The brief was refreshed on April 26, 2026 to sharpen two now-immediate topics:

  • a real correlation engine for detections over Strawberry's stored process/file/indicator graph
  • a real analyst UX, likely a native process-centric desktop app rather than only a minimal local web trace viewer

Core Research Position

The literature supports the overall direction:

  1. Runtime process telemetry is a strong foundation
    • eBPF-based observation is now a practical basis for low-overhead Linux runtime security systems.
  2. Pure signatures are insufficient on their own
    • YARA remains useful for triage and known-pattern matching, but stealthy or fileless behavior requires behavioral context.
  3. Provenance and graph analysis materially improve detection
    • Process/file/network relationships help surface multi-step attacks that point detectors miss.
  4. Online graph systems must be concise and efficient
    • The strongest practical systems prioritize compact graph construction, bounded search, and interpretable attack paths.
  5. Provenance systems can be evaded
    • Mimicry and behavior blending are real risks, so Strawberry should treat graph analysis as one layer, not a complete defense.
  6. Operators need correlated findings, not raw graph exhaust
    • The literature on threat hunting and SOC workflows repeatedly points toward aggregation, explanation, and human-usable pivots rather than standalone low-level events.

Implications for Strawberry

1) eBPF telemetry should come before advanced graph analytics

Without trustworthy runtime events, the graph layer is mostly hypothetical. The literature consistently assumes reliable event capture first, then higher-order reasoning.

2) YARA should be integrated as an enrichment layer

The best fit for Strawberry is:

  • use eBPF or process telemetry to decide what to inspect
  • use YARA to scan files or memory regions when warranted
  • store both the match and the surrounding execution context

3) The embedded database should preserve relationships, not just hits

A local store is most useful when it keeps:

  • indicators
  • process metadata
  • parent/child edges
  • file access or execution links
  • timestamps

This makes later provenance or graph-style analysis possible even before advanced ML is added.

4) The first milestone should be deterministic, local, and inspectable

The literature shows the value of online systems, but Strawberry is earlier than that. The right near-term target is a small, verifiable local pipeline:

  1. capture a process event
  2. resolve an executable path
  3. hash and/or scan it
  4. persist the result and relationship edges
  5. query the stored trail back out

5) The next major subsystem should be correlation

Strawberry now has enough substrate to justify a correlation layer:

  • process execution events
  • process lineage edges
  • executable-image file nodes
  • YARA-backed indicator hits
  • timestamps and partial runtime context

The next literature-aligned step is to convert these into finding candidates or incident summaries rather than leaving them as raw stored graph elements.

6) The long-term operator surface should be process-centric

The current local web GUI is good for evaluation, but the operator workflow implied by the literature is:

  • search for a process, executable, or indicator
  • pivot through lineage and related artifacts
  • inspect a concise correlated explanation
  • expand into supporting evidence only when needed

That argues for a richer analyst surface. A native Qt app is a reasonable fit if Strawberry stays local-first and desktop-oriented.

Literature by Theme

A. Provenance / graph-based detection

GID: Graph-based Intrusion Detection on Massive Process Traces for Enterprise Security Systems

  • Boxiang Dong et al., 2016
  • Link: https://huggingface.co/papers/1608.02639
  • Why it matters:
    • Strong evidence that graph representations of heterogeneous process traces improve detection over single-event views.
    • Relevant to Strawberry's process + relationship model.

You Are What You Do: Hunting Stealthy Malware via Data Provenance Analysis

  • Qi Wang et al., 2020
  • DOI: https://doi.org/10.14722/ndss.2020.24167
  • Why it matters:
    • Strong theoretical and practical support for provenance-centric malware hunting.
    • Reinforces that behavior chains can expose stealthy attacks even when obvious payload artifacts are absent.

Unicorn: Runtime Provenance-Based Detector for Advanced Persistent Threats

  • Xueyuan Han et al., 2020
  • DOI: https://doi.org/10.14722/ndss.2020.24046
  • Why it matters:
    • Demonstrates that long-lived, low-and-slow attacks can be modeled from runtime provenance.
    • Relevant to Strawberry's interest in persistent local graph storage.
  • Shaofei Li et al., 2024
  • DOI: https://doi.org/10.14722/ndss.2024.23204
  • Why it matters:
    • Highlights the importance of concise, interpretable online provenance graphs.
    • Useful design pressure against building an overgrown, low-signal graph store.

POIROT: Aligning Attack Behavior with Kernel Audit Records for Cyber Threat Hunting

  • Sadegh M. Milajerdi et al., 2019
  • Link: https://huggingface.co/papers/1910.00056
  • Why it matters:
    • Shows how graph matching over kernel-audit-derived provenance can support threat hunting.
    • Suggests a future direction for query-driven hunt workflows in Strawberry.

Sometimes, You Aren't What You Do: Mimicry Attacks against Provenance Graph Host Intrusion Detection Systems

  • Akul Goyal et al., 2023
  • DOI: https://doi.org/10.14722/ndss.2023.24207
  • Why it matters:
    • Important cautionary paper.
    • Strawberry should assume provenance graphs are valuable but attackable; YARA, hashing, and policy signals should remain complementary layers.

B. YARA and rule-based enrichment

Scanning memory with Yara

  • Michael Cohen, 2017
  • DOI: https://doi.org/10.1016/j.diin.2017.02.005
  • Why it matters:
    • Directly relevant to Strawberry's proposed process-memory scanning path.
    • Supports treating YARA as more than just a file scanner.

APIARY: An API-based automatic rule generator for YARA to enhance malware detection

  • Antonio Coscia et al., 2025
  • DOI: https://doi.org/10.1016/j.cose.2025.104397
  • Why it matters:
    • Not required for v1, but useful for future rule-authoring workflows.
    • Suggests Strawberry could later support generated or curated rule pipelines instead of only hand-maintained rules.

C. eBPF and Linux runtime security

bpfbox

  • William Findlay, Anil Somayaji, David Barrera, 2020
  • DOI: https://doi.org/10.1145/3411495.3421358
  • Why it matters:
    • Demonstrates practical eBPF-based confinement and security instrumentation on Linux.
    • Useful proof that eBPF can anchor security controls, not just passive observation.

Comparative Analysis of eBPF-Based Runtime Security Monitoring Tools in Monitoring and Threat Detection on Kubernetes

  • Aldien Asy Syairozi and Arizal, 2025
  • DOI: https://doi.org/10.5220/0014272700004928
  • Why it matters:
    • Practical comparative context for modern eBPF-based security tooling.
    • Even though Kubernetes is not Strawberry's immediate scope, the operational tradeoffs are relevant.

DySec: A Machine Learning-based Dynamic Analysis for Detecting Malicious Packages in PyPI Ecosystem

  • Sk Tanzir Mehedi et al., 2025
  • Link: https://huggingface.co/papers/2503.00324
  • Why it matters:
    • Shows eBPF telemetry being used in a practical detection pipeline for malicious install-time behavior.
    • Useful evidence for a staged Strawberry pipeline: observe first, enrich second, classify or score later.

D. Correlation, threat hunting, and analyst workflow

Real-time Analytics for APT Detection and Threat Hunting Using Cyber-threat Intelligence and Provenance Graphs

  • V.N. Venkatakrishnan, 2025
  • DOI: https://doi.org/10.1145/3716815.3729016
  • Why it matters:
    • Direct support for a correlation engine that combines provenance structure with higher-level threat knowledge.
    • Reinforces that Strawberry's graph should feed hunt and triage workflows, not merely archive events.

LogKernel: A Threat Hunting Approach Based on Behaviour Provenance Graph and Graph Kernel Clustering

  • Jiawei Li et al., 2022
  • Link: https://arxiv.org/abs/2208.08820
  • Why it matters:
    • Supports the idea that suspicious behavior should be identified over subgraphs or paths, not isolated events.
    • Useful pressure toward compact scoring over bounded behavior windows.

threaTrace: Detecting and Tracing Host-based Threats in Node Level Through Provenance Graph Learning

  • Su Wang et al., 2021
  • Link: https://arxiv.org/abs/2111.04333
  • Why it matters:
    • Suggests Strawberry should preserve enough per-entity context to support future node-level scoring.
    • Also supports a process-centric analyst UX where an operator starts from one suspicious entity and expands outward.

TDLens: Toward an empirical evaluation of provenance graph-based approach to cyber threat detection

  • Rui Mei et al., 2022
  • DOI: https://doi.org/10.23919/jcc.2022.00.028
  • Why it matters:
    • Useful reminder to validate whether the graph layer actually improves detection quality instead of assuming it does.
    • Good evidence for benchmarking a future Strawberry correlation engine against simpler baselines.

Security Operations Center: A Systematic Study and Open Challenges

  • Manfred Vielberth et al., 2020
  • DOI: https://doi.org/10.1109/access.2020.3045514
  • Why it matters:
    • Reinforces that analyst workflow, process, and explanation matter as much as raw technical detection.
    • Supports building Strawberry around concise pivots, triage views, and explainable outputs.

An Interview Study on Third-Party Cyber Threat Hunting Processes in the U.S. Department of Homeland Security

  • William P. Maxam and James C. Davis, 2024
  • Link: https://arxiv.org/abs/2402.12252
  • Why it matters:
    • Indicates that threat hunting workflows are still variable and tool support remains a practical pain point.
    • Supports building Strawberry's next UX around fast search, pivoting, and repeatable analyst workflows.

Enhancing Cyber Threat Hunting — A Visual Approach with the Forensic Visualization Toolkit

  • Jihane Najar et al., 2025
  • Link: https://arxiv.org/abs/2509.09185
  • Why it matters:
    • More tentative and newer than the other references, but directionally useful for UI thinking.
    • Supports graph-aware visual exploration once Strawberry's underlying search and correlation model is stable.

Research-Grounded Design Guidance

Based on the papers above, Strawberry should prefer:

  • event capture before advanced scoring
  • local persistence before distributed orchestration
  • graph context plus signatures, not either one alone
  • compact, queryable provenance trails over vague “graph database” ambitions
  • layered detection, because provenance-only systems can be evaded
  • correlated findings over raw hits, because operators need explanation and prioritization
  • process-first investigation UX, because that is the most defensible current pivot in Strawberry's data model

Open Questions

  1. Should Strawberry target:
    • a lightweight host detector, or
    • a threat-hunting substrate with replayable provenance?
  2. Is the immediate “make” goal:
    • GNU Make wrapper support, or
    • Make.com automation/integration?
  3. How much provenance is enough for v1?
    • process spawn edges only
    • process + file edges
    • process + file + network edges
  4. Should the first correlation engine be:
    • simple rule/heuristic based
    • subgraph/pattern based
    • anomaly scored over bounded provenance windows
  5. Should the first serious analyst UI remain web-local, or move to a native Qt desktop shell?
  6. When should Strawberry add thread-level pivots?
    • only after true thread/TID telemetry exists
    • or via a process-first UI with deferred thread support

The best literature-aligned v1 is:

  • Linux-only
  • eBPF-backed process execution telemetry
  • YARA-backed file and optionally process-memory scanning
  • local embedded persistence
  • process lineage and file relationship edges
  • simple rule- or heuristic-driven correlation and triage
  • a process-centric operator UX, with thread-level pivots deferred until the telemetry model actually supports them

That scope is ambitious enough to be meaningful and small enough to make real.