convez.ai
MCP ServerSegurançaAvançado
Sathvik-1007

SIFT Kernel — Sistema Operacional de Evidência Forense

Sathvik-1007/sift-kernel

Kernel forense que torna spoliation impossível e alucinações indetectáveis

Ver no GitHub
InicialPluginScore · de 0 a 100

Servidor MCP que implementa raciocínio forense com metodologia evidence-grade, impedindo spoliation de evidências e alucinações de LLM por construção arquitetural. Integra 129 operações forenses, fusão de evidências via DSmT/PCR5, correlação temporal automática e relatórios interativos (Markdown, JSON, HTML) para análise digital de incidentes (DFIR) com zero taxa de alucinação.

Instalação

$npx convez-ai Sathvik-1007/sift-kernel

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
2
Forks
0
Acompanhando
0
Saúde
42%
Último commit
há 5 meses
Versão
—
Issues abertas
0
Contribuidores
1

Casos de uso

  • Investigação de incidentes de segurança com rastreamento de evidências determinístico
  • Análise forense de imagens E01 de disco com correlação automática de artefatos
  • Automação de investigações DFIR mantendo conformidade metodológica
  • Geração de relatórios periciais com cadeia de custódia verificável

Veredito

Projeto robusto e altamente especializado que resolve um problema real em forensia digital: evitar alucinações de LLM e garantir metodologia forense. Arquitetura rigorosa com propriedades de segurança formais comprovadas, mas nicho técnico e curva de aprendizado acentuada.

README

A tradução para o português deste README ainda está na fila.

SIFT Kernel

Forensic Evidence Operating System — An MCP server that makes evidence spoliation architecturally impossible, hallucinations structurally unregisterable, and forensic methodology computationally enforced.

Built for the FIND EVIL! Hackathon by SANS Institute.


Results

MetricValue
Forensic operations129 across 14 categories (+ 21 reporting/kernel tools)
Reasoning engine (FARE)DSmT/PCR5 evidence fusion + Active Inference (EFE) tool selection + Rough-set confidence tiers
Knowledge base90 evidence-to-hypothesis rules across 7 artifact categories, 12 attack scenarios
Auto-correlationTemporal proximity + MITRE kill-chain sequencing + shared entity detection
Formal security properties6 (property-tested, 10,000 scenarios each)
Context overload solved32 tools exposed (14 category dispatchers + 18 kernel) — not 128 flat
Hallucination rate0% by construction (findings require evidence links + deterministic verification)
Methodology enforcementSignal-driven reactive FSM (7 states) + capability DAG
Self-correctionExternal-feedback architecture (arXiv:2601.00828) — FARE conflict detection, entropy tracking, bias monitoring
Inference constraintLevel 3-4 per Hilgert et al. 2025 (arXiv:2506.00274) — server handles parsing + anomaly detection
Report formatsMarkdown, JSON, interactive HTML (entropy curve SVG, dark/light toggle, correlation timeline)
Transportsstdio + HTTP/SSE (fail-closed bearer auth)
Tested againstReal 16GB SRL-2018 E01 disk image (APT compromise)

SUBMISSION COMPLIANCE

Judges: Every turn-in requirement maps to a specific file. Nothing is hidden.

#RequirementLocationStatus
1Code repository (public, open source)This repositoryDone
2Open source license (MIT or Apache 2.0)LICENSEDone (MIT)
3README with setup instructionsREADME.md — see "Quick Start" belowDone
4Live deployment URL or local run instructionsREADME.md — see "Quick Start" belowDone (local)
5Text description of features/functionalityREADME.md — see "What It Does" + "How It Works" belowDone
6Demo video (< 5 min, live terminal, audio, self-correction)YouTube + docs/DEMO.mdDone
7Architecture diagramdocs/architecture.mdDone
8Evidence dataset documentationdocs/DATASET.mdDone
9Accuracy reportdocs/ACCURACY-REPORT.mdDone
10Agent execution logsdocs/EXECUTION-LOGS.md + sift-output/ledger.dbDone

Additional Documentation

DocumentDescription
CLAUDE.mdAgent skill file — teaches any LLM the investigation loop
docs/ZERO-TRUST-ALIGNMENT.mdHow architecture maps to Anthropic's Zero Trust for AI Agents (2026)
docs/USER-GUIDE.mdPractitioner guide for forensic analysts
docs/DESIGN-DECISIONS.mdArchitectural choices and rationale
docs/BYPASS-TESTING.mdSecurity bypass attempts and why they fail

What It Does

SIFT Kernel sits between any AI agent (Claude, GPT, Llama, etc.) and the SANS SIFT Workstation's 200+ forensic tools. It provides:

  • 129 forensic operations across 14 categories + 21 reporting tools, exposed via the Model Context Protocol (MCP)
  • Category dispatcher architecture — agent sees 32 tools (14 forensic categories + 18 kernel), each category groups related operations
  • Capability-based security — no shell access exists, read-only evidence mounts
  • Hash-chained evidence ledger — every tool call cryptographically recorded
  • Confidence scoring — findings require evidence links (hallucinations structurally blocked)
  • FARE reasoning engine — Dempster-Shafer evidence fusion (PCR5), Active Inference (EFE) tool selection, Rough-set confidence tiers, convergence detection, cognitive bias monitoring
  • Auto-correlation — deterministic attack chain detection via temporal proximity + MITRE kill-chain sequencing + shared entity linking
  • Self-correction architecture — coverage gap detection, FARE conflict interrupts (K>0.3), entropy-plateau falsification injection, evidence provenance verification
  • Forensic knowledge enrichment — every tool response includes expert caveats, corroboration suggestions, and interpretation guidance at the response level (not system prompt)
  • Determinism tracking — measures how closely the agent follows server methodology recommendations (0.0-1.0 score)

Architecture

┌─────────────────────────────────────────────────────────────┐
│  ANY MCP CLIENT (Claude Code, Cursor, Zed, etc.)            │
└────────────────────────────┬────────────────────────────────┘
                             │ MCP Protocol (stdio)
┌────────────────────────────▼────────────────────────────────┐
│  SIFT KERNEL                                                 │
│  ┌────────────────────────────────────────────────────────┐ │
│  │ Category Dispatchers (14 forensic + 18 kernel = 32)   │ │
│  ├────────────────────────────────────────────────────────┤ │
│  │ Meta-Cognitive Toolkit (self-correction engine)         │ │
│  ├────────────────────────────────────────────────────────┤ │
│  │ Evidence Ledger (hash-chained, append-only)            │ │
│  ├────────────────────────────────────────────────────────┤ │
│  │ Output Intelligence (anomaly detection)                │ │
│  ├────────────────────────────────────────────────────────┤ │
│  │ Capability Kernel (DAG prerequisites, ro mounts)       │ │
│  ├────────────────────────────────────────────────────────┤ │
│  │ Tool Executors (binary allowlist, shell:false)         │ │
│  └────────────────────────────────────────────────────────┘ │
└────────────────────────────┬────────────────────────────────┘
                             │ subprocess (shell:false)
┌────────────────────────────▼────────────────────────────────┐
│  SIFT WORKSTATION (200+ forensic binaries)                   │
└─────────────────────────────────────────────────────────────┘

Quick Start

Prerequisites

  • Node.js 18+
  • SIFT Workstation (for actual forensic tool execution)

Install

git clone https://github.com/Sathvik-1007/sift-kernel.git
cd sift-kernel
npm install

Run

# As MCP server (stdio transport — for Claude Code, OpenCode, etc.)
npx tsx src/index.ts --output ./investigation

# With evidence pre-loaded (optional — can also load dynamically via mount_evidence tool)
npx tsx src/index.ts --evidence /path/to/image.E01 --output ./investigation

# HTTP transport with bearer auth (for remote/multi-client access)
npx tsx src/index.ts --transport http --port 3000 --token YOUR_SECRET

# Fresh investigation (wipes prior state)
npx tsx src/index.ts --fresh --output ./investigation

Connect from MCP Client

Add to your MCP client configuration:

{
  "mcpServers": {
    "sift-kernel": {
      "command": "npx",
      "args": ["tsx", "/path/to/sift-kernel/src/index.ts", "--output", "/tmp/sift-output", "--fresh"],
      "env": {}
    }
  }
}

How It Works

The "Even Dumb LLMs Work" Loop

while (not done):
    result = call("suggest_next_action")
    call(result.tool_name, result.params)

Any model that can parse JSON and call a function produces a valid, methodology-correct, auditable forensic investigation. The intelligence is in the server.

Progressive Disclosure

At session start, the agent sees 32 tools (14 category dispatchers + 18 kernel). Each category groups related operations:

filesystem(operation="list_directory", path="/Users")
registry(operation="get_persistence_keys")
event_logs(operation="parse_event_log", path="/Windows/System32/winevt/Logs/Security.evtx")

The capability kernel still blocks out-of-order calls — methodology is enforced regardless of what the agent tries.

FARE: Forensic Abductive Reasoning Engine

The server doesn't just run tools — it reasons about the investigation state using published mathematical frameworks:

ComponentTheoryWhat it does
DSmT/PCR5 FusionDezert-Smarandache (2006)Combines contradictory tool outputs without Zadeh's paradox
Active Inference (EFE)Friston (2015)Selects the tool that maximally reduces hypothesis uncertainty
Rough-Set ConfidencePawlak (1982)Maps findings to CONFIRMED/SUPPORTED/INFERRED tiers with mathematical grounding
Convergence DetectionShannon (1948)Tracks investigation entropy; detects learning, plateau, and divergence
Cognitive Bias MonitoringKahneman & Tversky (1974)Detects confirmation bias, anchoring, and tunnel vision in the investigation
Auto-CorrelationCarrier (2006) + ATT&CKTemporal + kill-chain + entity linking across findings

Every tool response includes the FARE state: entropy, dominant hypothesis, active signals, conflict coefficient, and bias warnings.

Rich Investigation Directives

suggest_next_action returns a full forensic cognitive frame — not just "run this tool":

{
  "tool": "registry",
  "operation": "get_persistence_keys",
  "directive": {
    "whatEvilLooksLike": "Entries pointing to temp dirs, random names, encoded PowerShell",
    "whatNormalLooksLike": "Chrome Update, Windows Defender, Office updaters",
    "hypothesisTested": "Has the attacker established registry-based persistence?",
    "confirmationCriteria": "Run key value points to a path containing suspicious executables",
    "ifConfirmed": "Register T1547.001 finding, advance to scheduled tasks",
    "ifAbsent": "Persistence is NOT via registry — check scheduled tasks"
  },
  "efe_score": 0.34,
  "information_gain": "EFE=0.34 (risk=0.20, ambiguity=0.14)"
}

The methodology engine drives the investigation — any MCP-capable LLM follows the structured directives without needing forensic domain knowledge.

Confidence Scoring

LevelCriteria
HYPOTHESIZED0 evidence links — investigation marker only
INFERRED1 evidence source
SUPPORTED2+ sources, same category
CONFIRMED2+ sources, different categories

Findings cannot appear in the final report without evidence links. Hallucinations are structurally impossible.

Evidence Ledger

Every tool call produces a hash-chained ledger entry:

  • Tool name + parameters
  • Output hash (SHA-256)
  • Previous entry hash (tamper detection)
  • Capabilities held at time of execution
  • Duration

Run verify_chain to cryptographically validate the entire audit trail.

Workflows (15)

#WorkflowToolsDescription
1Acquisition5Mount, verify, partition discovery
2Filesystem9Directory listing, file extraction, deleted recovery
3Timeline6Super timeline, filtering, anomaly detection
4Registry9Hives, persistence, user activity, USB
5Event Logs8EVTX, logon correlation, PowerShell
6Execution7Prefetch, Amcache, ShimCache, SRUM
7Persistence9YARA, scheduled tasks, WMI, BITS
8Memory11Processes, injection, rootkits, network
9Network8PCAP, beaconing, DNS, HTTP
10Browser6History, downloads, cache, extensions
11User Activity8LNK, jumplists, shellbags, recycle bin
12Anti-Forensics7Timestomping, log clearing, wiping
13Correlation7Attack narrative, lateral movement, MITRE
14Linux8Auth, syslog, bash, cron, systemd
15Reporting21Coverage, confidence, provenance, export

Academic Foundations & Novel Contributions

This project implements the first computational realization of several theoretical frameworks for DFIR:

FrameworkCitationOur novel application
Hypothesis-based forensic investigationCarrier 2006 (Purdue/CERIAS PhD)First computational implementation — his model was purely theoretical
DSmT/PCR5 evidence fusionSmarandache & Dezert 2006Applied to forensic tool outputs (prior: only VBIED/radar)
Active Inference for action selectionFriston 2015 (Free Energy Principle)First application to DFIR tool orchestration
Rough-set decision approximationsPawlak 1982Maps to forensic confidence tiers + stop criterion
External self-correctionHuang et al. 2025 (arXiv:2601.00828)Server provides external correction signals (not LLM self-correcting)
MCP inference constraint levelsHilgert et al. 2025 (arXiv:2506.00274)Implemented Level 3-4 constraint with metadata reporting
Nondeterminism mitigationGruber & Hilgert 2026 (arXiv:2604.05589)Determinism score quantifying methodology adherence
Knowledge-execution gapDFIR-Metric 2025 (arXiv:2505.19973)Rich directives bridge the 70% knowledge → 20% execution gap
Multi-agent forensic specialisationCyberSleuth 2025 (arXiv:2508.20643)Category dispatchers = lightweight specialist decomposition

Security Properties

Formally verified via property-based tests (npm test):

  • P1: No shell execution capability exists (no code path)
  • P2: No finding without evidence links enters the report
  • P3: Capability graph is a valid DAG (no cycles)
  • P4: Hash chain valid for any operation sequence
  • P5: Every tool call produces exactly one ledger entry
  • P6: All file access contained within evidence mount prefix

Development

# Type check
npx tsc --noEmit

# Run tests
npx vitest run

# Watch mode
npx vitest

Tech Stack

| Package | Purpose | |---------|---------|
| @modelcontextprotocol/sdk | MCP server (stdio + HTTP/SSE transport) | | zod | Runtime validation + branded types | | better-sqlite3 | Evidence ledger (WAL mode, hash-chained) | | neverthrow | Type-safe Result<T, E> — no exceptions in domain layer | | nanoid | Unique IDs for ledger entries + findings | | exponential-backoff | Retry transient I/O failures with jitter | | vitest + fast-check | Testing + property-based formal verification |

License

MIT

Ver o original no GitHub

Bom para