TRACE//LABTHE EXECUTION GENOME PLATFORM

Observe · Query · Defend

The first platform that fuses API tracing, memory forensics, behavioral signatures, and ROP gadget analysis into one queryable engine.

View on GitHubSee the architecture
pescan — PE//SCAN · TRACE//LAB
$ pescan exposure target.exe ┌─── EXPOSURE//MAP SCORE ──────────────────────────────── │ ██████████████████████████████████████░░░░░░░░░░░░ 72/100 [HIGH] │ MITIGATIONS 22.0/30.0 (73%) │ MEMORY 15.0/25.0 (60%) │ IMPORTS 8.0/20.0 (40%) │ STRUCTURE 5.0/15.0 (33%) │ SURFACE 3.0/10.0 (30%) └──────────────────────────────────────────────────────── │ [CRITICAL] ASLR disabled — predictable load address │ [CRITICAL] DEP disabled — executable data pages │ [CRITICAL] 1 RWX section — writable AND executable $ pescan gadgets ntdll.dll │ pop; ret 1,847 │ xchg; ret 23 │ jmp/call reg 156 │ mov [r],r; ret 41 $ pescan shield target.exe ┌─── SHIELD//MAP — Defensive Control Assessment ──────── │ EXPOSURE: 72/100SHIELDED: 28/100 [WEAK] │ [CRITICAL] Classic DLL Injection (T1055.001) FULLY ENABLED │ APIs: OpenProcess, VirtualAllocEx, WriteProcessMemory, CreateRemoteThread │ Mitigation: 17% (1/6 controls active) │ ✗ PPL ✗ CIG ✗ DEP ✗ ACG │ [CRITICAL] DEP Bypass via ROP (T1620) FULLY ENABLED │ Mitigation: 0% (0/5 controls active) │ REMEDIATION: │ #1 [IMMEDIATE] Enable DEP │ $ Set-ProcessMitigation -Name app.exe -Enable DEP │ #2 [IMMEDIATE] Enable ASLR │ $ Set-ProcessMitigation -Name app.exe -Enable ForceRelocateImages └────────────────────────────────────────────────────────

Architecture

Eight pillars of execution intelligence

Each pillar is a standalone capability. Together they form the execution genome — a multi-dimensional behavioral fingerprint of every Windows process.

PILLAR 01
PE//SCAN
Zero-dependency PE parser. Import categorization, entropy analysis, security assessment, ROP gadget scanning. Every byte parsed by hand in Rust.
PHASE 0 · LIVE
PILLAR 02
CALL//CHAIN
ETW-based temporal execution graphs. Causal edges, temporal correlation, and 8 built-in behavioral signatures mapped to MITRE ATT&CK.
PHASE 1 · LIVE
PILLAR 03
EXPOSURE//MAP
Quantified attack surface across five dimensions. Runtime CVSS for process instances — not for software vulnerabilities, but for instantaneous exploitability.
STATIC · LIVE
PILLAR 04
SHIELD//MAP
Defensive counterpart to EXPOSURE//MAP. Maps imports to 14 attack chains, identifies missing controls, and generates prioritized remediation with PowerShell commands.
PHASE 1 · LIVE
PILLAR 05
DEBUG//BRIDGE
WinDbg integration via DbgEng API. Memory inspection, PEB/TEB walking, gadget resolution with ASLR-adjusted virtual addresses and bad-char filtering.
PHASE 1 · LIVE
PILLAR 06
LIB//GRAPH + RESOURCE//PULSE
DLL usage profiling fused with CPU/memory/IO telemetry. Burst detection, crypto fingerprinting, hardware performance counter correlation. 7 fused alert rules.
PHASE 2 · LIVE
PILLAR 07
GENOME//DIFF
6-dimension behavioral genome: PE structure, API graph, exposure, shield, DLL usage, and resource telemetry. Multi-dimensional diffing catches supply chain and injection mutations.
PHASE 3 · LIVE
PILLAR 08
ARTIFACT//SWEEP
Forensic collection across 5 categories with TRACE//LAB behavioral correlation. Prefetch, shimcache, registry persistence, VAD entries, network state — evidence with context.
PHASE 3 · LIVE
PILLAR 09
TRACE//QL
Pipeline query language for all TRACE//LAB dimensions. Lexer, recursive descent parser, typed AST, execution engine with 12 pipeline stages. Interactive REPL and single-shot mode.
QUERY · LIVE
PILLAR 10
DETECTION EXPORT
20 detection rules exported to Sigma YAML, Splunk SPL, and Elastic EQL. Bridges behavioral analysis directly into SOC tooling for production deployment.
SOC · LIVE
PILLAR 11
THREAT//INTEL
IoC extraction from PE analysis, trace events, and forensic artifacts. Threat scoring, CTI source enrichment model, STIX 2.1 bundle export for threat sharing.
CTI · LIVE
PILLAR 12
COMPLIANCE
Maps SHIELD//MAP controls to NIST CSF 2.0, CIS Controls v8.1, ISO 27001:2022, CMMC 2.0, and NIST 800-53 Rev 5. Per-framework gap analysis with remediation priorities.
GRC · LIVE

Privilege architecture

Ring 3 / Ring 0 observation map

Click any pillar to see where it observes across the privilege boundary.

RING 0 — KERNEL SSDT ETW providers Callbacks SYSCALL BOUNDARY RING 3 — USER MODE Win32 API ntdll.dll IAT / EAT PEB / TEB TRACE//QL PE//SCAN CALL//CHAIN EXPOSURE//MAP DEBUG//BRIDGE LIB//GRAPH + PULSE GENOME//DIFF ARTIFACT//SWEEP CLICK A PILLAR FOR DETAILS
PE//SCAN — Ring 3 pre-execution. Parses PE headers, imports, exports, sections. Finds ROP gadgets, scores exposure, detects packing — all before the binary runs.

Attack visualization

Execution chain analysis

Watch real attack techniques flow through privilege rings. Each node shows which TRACE//LAB pillar detects it. Yellow edges mark syscall boundary crossings.

Query language

TRACE//QL — one language, all dimensions

Query across live instrumentation, forensic artifacts, PE structure, and behavioral baselines.

-- Detect process injection: temporal API sequence TRACE WHERE api.sequence MATCHES ( "VirtualAllocEx" -> "WriteProcessMemory" -> "CreateRemoteThread" ) WITHIN 5s | GROUP BY process.name -- Compare svchost against known-good behavioral genome GENOME DIFF process.name="svchost.exe" AGAINST BASELINE "svchost_clean" WHERE mutations.count > 0 -- Correlate CPU anomaly with exposure spike TRACE WHERE resource.cpu_delta > 50% AND exposure.score_delta > 20 WITHIN 2s | ALERT severity=CRITICAL

Built for

From exploit dev to SOC triage

DFIR Teams
ARTIFACT//SWEEP + TRACE//QL replaces a stack of collection tools. Behavioral correlation connects the dots — evidence with context.
Malware Analysts
GENOME//DIFF + CALL//CHAIN + PE//SCAN in one platform. TTD integration for replay analysis without re-running the sample.
Red Teams
EXPOSURE//MAP + gadget resolution + DEBUG//BRIDGE. Quantify your target's attack surface. Built for OSEE-level operators.
Detection Engineers
TRACE//QL behavioral signatures become detection content. Write detections as temporal queries, export to SIEM/EDR.

Open source

19,900+ lines of Rust. 65 files. 12 pillars. 54 unit tests. Zero warnings.

Parse PE files at the byte level. Find ROP gadgets. Score attack surfaces. Trace execution graphs. Built for Windows internals mastery.

Clone the repoRead the docs