Taint-flow analysis
89 ready-made presets across 12 categories: injection, XSS, SSRF, deserialization, dangerous functions and more. Each preset explains the attack scenario it detects.
Coverage-first code audit platform
Find real vulnerabilities.
Find real vulnerabilities.
Trace every data flow.
SEK is a coverage-first code audit platform. It turns your source code into a queryable Code Property Graph, sweeps every route and parser with deterministic sensors, and lets LLM agents judge what actually matters.
- Managed cloud or air-gapped on-prem
- LLM tokens spent on verdicts, not exploration
- Browser, REST API and MCP interfaces
From source to sink, every hop traced.
89built-in taint-flow presets
6languages + code-quality rules
23MCP tools for LLM assistants
2deployment modes: cloud or air-gapped
Features
Everything between source and sink
One platform to import code, query its graph, trace exploit paths, and manage findings. No black box, no SaaS upload.
Code Property Graph
AST, CFG and PDG fused into one queryable graph. Ask anything in CPGQL through the UI or the authenticated REST API.
Trace view
Every finding comes with its full data-flow path. Step through source, propagation and sink with the code highlighted at each hop, keyboard-driven, graph optional.
Agentic triage
Deterministic sensors propose, LLMs judge. Candidates are scored with CWE IDs and CVSS v3.1 vectors, with evidence packs that keep code fenced off as data.
MCP server
23 tools exposed over the Model Context Protocol. Let Claude Code or Claude Desktop run queries, launch scans and manage findings without leaving the chat.
Findings and SARIF
Track vulnerabilities in a persistent findings store backed by SQLite, then export SARIF 2.1 to feed GitHub Advanced Security or any compatible pipeline.
Analysis engine 89 presets. Six languages.
89 presets. Six languages.
Zero guesswork.
SEK ships with curated taint-flow definitions for the stacks you actually ship, from browser XSS to Spring injection to C memory corruption, organized in 12 categories with per-preset explanations. Need something bespoke? Build custom presets visually in the Builder, or drop to raw CPGQL for anything the graph can express.
- JavaScript / TypeScript
- Java / Spring / Servlet
- Python
- Go
- PHP
- C / C++
Plus language-agnostic code-quality rules. Presets, query cache and findings persist in SQLite across restarts.
# Ask the graph a question
$ curl -H "Authorization: Bearer $SEK_API_TOKEN" \
-d '{"query":"cpg.method.name.l.size"}' \
https://sek.internal/api/query
{"id":"…","stdout":"res0: Int = 2413","stderr":""}
# Run a taint-flow preset over the pool
$ sek run --preset java/spring/sqli \
--project payments-service
✓ 3 flows found: 2 reachable sinks, 1 sanitized Workflow
From repo to report in three steps
- 01
Import
Drop in source archives, clone from a URL, or upload pre-built graph artifacts. SEK builds the Code Property Graph automatically and stores it alongside your project.
- 02
Analyze
Fire a built-in preset, compose one in the Builder, or write CPGQL by hand. Pooled analysis engines with hash-affinity routing and failover keep queries fast.
- 03
Triage
Walk each flow in Trace, save findings with severity and status, optionally let the agentic layer score them, then export SARIF into your pipeline.
Audit philosophy
Coverage first. Judgement second.
An audit that samples is a gamble. SEK maps the whole application before judging anything: every file parsed into the graph, every route, parser and auth gate inventoried, every preset and rule pack swept across it. The model only judges what full coverage produced.
Preset bundles
89 taint-flow presets matched to the project language sweep the graph for the classic classes: SQLi, command injection, XSS, SSRF, path traversal and more.
Structural rule packs
123 structural rules catch the single-location shapes taint cannot see: disabled TLS verification, weak crypto, permissive file modes, secrets written to logs.
Probe and agent lanes
The model studies this specific codebase and proposes hypotheses per family; the engine executes them. What presets cannot know, the probe hunts.
Every scan ships a surface inventory: routes, parsers, auth gates and outbound calls, so you can see what was covered, not just what was found.
Agentic layer Deterministic sensors find candidates.
Deterministic sensors find candidates.
LLMs judge them.
Connect one or more LLM providers and every project gains an Agentic tab: seeded playbooks sweep the source tree or re-triage saved findings, while an autonomous review lane lets a model hunt with sandboxed tools.
- Evidence packs: source snippets around every flow step, with a sanitizer-in-path flag, wrapped in
BEGIN/END UNTRUSTED CODEfences. Code is data, never instructions. - Structured verdicts: CWE identification plus the 8 CVSS v3.1 base metrics, judged per candidate by the model you choose.
- Full provenance: provider, model, token usage and dollar cost are stamped on every run. History is never rewritten by later preference edits.
CWE-915 HIGH · CVSS 8.1
Mass assignment through request JSON
books.py:18 → books.py:34 · 4 steps · no sanitizer in path
AV:NAC:LPR:NUI:N S:UC:HI:HA:N
evidence pack attached judged · 12.4k tokens
Context-aware scans
The hypothesis probe
Presets know what is common; your codebase is specific. Each round, the engine hands the model a surface inventory built from the graph (entry points, routes, parsers, auth logic), plus what presets already covered and what earlier rounds found. The model proposes one hypothesis per probe, tied to this application, and the engine validates and executes it deterministically. The model never runs anything itself.
- Context fed in: graph surface inventory, preset and rule-pack coverage, digest of previous rounds
- Proposals: one hypothesis per probe, tied to a family: input parsing, auth and session, outbound requests, parser robustness
- Guardrails: banned tokens, size caps and language-aware shape checks before anything executes
- Feedback loop: hits and empty rounds are digested into the next round; two dry rounds close a family early
# round 3 · family: input parsing
# context: 14 routes, 3 parsers, presets covered sqli/xss
› hypothesis: parser output reaches a template render
sink without escaping
✓ validated (shape ok, language-aware) → executed
✓ 1 flow → candidate queued for judgement
# digest feeds round 4 · 2 dry rounds close a family Agentic workflow
Sense. Package. Judge. Learn.
Four stages, one loop. Deterministic where it can be, intelligent where it counts, and permanently smarter after every run.
- 01
Sense
Deterministic sensors sweep the Code Property Graph: preset taint bundles, rule packs and hypothesis probes surface candidate flows without spending a single token.
- 02
Package
Every candidate ships with an evidence pack: source snippets around each flow step and a sanitizer-in-path flag, all fenced as untrusted data the model can read but never obey.
- 03
Judge
The LLM scores only what remains: CWE identification, the 8 CVSS v3.1 base metrics and a confidence verdict, deduplicated into clean, trackable findings.
- 04
Learn
Triage feeds back into the engine. SEK writes new detection rules from confirmed scans and from reports you feed it, so every scan makes the next one sharper.
Unit economics Pay for verdicts.
Pay for verdicts.
Not for exploration.
Naive AI review feeds whole repositories to a model and pays for every token, so its cost grows with your codebase. SEK searches deterministically and lets the LLM judge packaged evidence only, so spend tracks the number of real candidates, not the size of your repo.
~0 tokens spent searching, the engine explores deterministically
Automation
Fire it from CI/CD
SEK is an API first. Launch scans on every pull request, gate merges on new critical flows, and keep a durable audit trail of what shipped clean.
- Trigger scans from any pipeline through the authenticated REST API
- Export SARIF 2.1 to feed merge gates and security dashboards
- Scoped personal access tokens keep automation credentials tight
- Self-improving rules mean the gate gets stricter as the engine learns
# Any CI that can curl
$ curl -X POST \
-H "Authorization: Bearer $SEK_API_TOKEN" \
https://sek.internal/api/projects/billing/scans
$ sek findings export --format sarif > results.sarif
✓ quality gate passed: 0 new critical flows MCP integration Your AI assistant,
Your AI assistant,
on the graph.
mcp-sek exposes the whole platform as 23 Model Context Protocol tools
covering projects, scans, queries, dataflow, presets and findings, so Claude Code
or Claude Desktop can drive a full secure code review conversationally.
- Launch scans and run CPGQL or taint-flow analysis straight from chat
- Create, update and export findings without touching the UI
- Authenticated with scoped personal access tokens
# In Claude Code, with the SEK MCP server connected
› Run the Python injection presets on the
billing project and summarize reachable sinks.
✓ 3 flows found: 2 reachable sinks, 1 sanitized
✓ findings saved to the workspace
› Export the confirmed ones as SARIF.
✓ results.sarif written (2 findings) Deployment Cloud simplicity.
Cloud simplicity.
Air-gap ready.
Run SEK as a managed service, or deploy the same engine inside your own walls for regulated and air-gapped environments. Same analysis, same workflow, your call.
SEK Cloud
The managed SaaS. Sign in, import a repository, and run your first scan in minutes. We operate the analysis pool and the infrastructure; you keep the findings.
- Zero infrastructure to run
- Always on the latest engine
- Team workspaces with SSO
On-prem, air-gap ready
The full platform packaged for your own infrastructure: no external calls required, your models or a local provider, built for regulated and disconnected environments.
- Runs fully offline
- Your code never leaves your network
- OIDC SSO and scoped access tokens
Get started
Start tracing your first repository
Tell us about your stack, your languages and your compliance constraints. We will get you a workspace on SEK Cloud, or a package for your air-gapped environment, and your first scan runs in minutes.