Agentic Static Application Security Testing
Code Property Graph data-flow analysis, with an LLM evaluating context at every node and an agent validating every candidate path.
Taint-style data flow and single-line point issues
SQL injection
Unescaped query concatenation
User input reaches a query parameter via unescaped concatenation. Parameterization and escaping are evaluated at each node.
XSS
Reflected, stored, DOM
Reflected or stored input renders in the DOM without contextual encoding. HTML, attribute, JS, and URL contexts are evaluated separately.
SSRF
User-controlled outbound URL
A user-controlled URL parameter reaches an outbound HTTP client. Allowlists, URL parsing, and metadata-endpoint risk are checked per path.
Path traversal
File I/O and command injection
User input reaches file I/O without path normalization. Command injection (input reaching shell execution without sanitization) is traced with the same pipeline.
Hardcoded credentials
API keys, secrets, tokens
Credentials and API keys embedded in source code, verified against the broader codebase to confirm they aren't overridden elsewhere.
Weak cryptography
MD5, ECB, weak RNG
MD5 for passwords, ECB mode, weak RNG in security-sensitive contexts. Flagged only when used in a security-relevant code path.
Insecure cookies and CORS
Missing flags, permissive policies
Missing Secure, HttpOnly, or SameSite flags on session cookies. Permissive CORS policies that expose authenticated endpoints to untrusted origins.
Timing-vulnerable comparisons
Non-constant-time equality
Equality checks that leak timing because they are not constant-time, detected in token, signature, and credential comparison paths.
Static findings are reported as static analysis results, with their traced path or code context. A static finding becomes a pentest finding only after the whitebox pentest proves it against the running app, and each is recorded as one canonical finding.
Not just “is there a sanitizer” but “does this encoding prevent this injection in this context.”
A Code Property Graph combines AST, control flow, and data flow. An LLM evaluates every node. An agent validates every path. Only confirmed findings reach the report.
Data flow analysis on a Code Property Graph
We compile your codebase into a Code Property Graph (AST, control flow, and data flow in one structure), then analyze it in three phases: extract sources and sinks, trace backward from every sink, validate each candidate path.
Only validated, high-confidence paths advance, and each one is handed to the whitebox pentest to exploit before it is reported.
Sources and sinks
Phase 01 · Extract
Sources (user inputs, API parameters, file reads, environment variables) and sinks (SQL queries, shell commands, file writes, response outputs) are extracted using deterministic patterns, plus LLM-identified custom input handlers specific to your framework.
Backward from every sink
Phase 02 · Trace
We trace backward from every sink toward potential sources. At each node, an LLM evaluates whether the specific sanitization actually addresses the specific risk in the specific context.
An agent confirms each path
Phase 03 · Validate
An autonomous agent validates each candidate path for control flow correctness (can this branch actually execute?) and logic correctness (do the types and constraints line up?), producing confidence scores. Anything below that bar never reaches the report.
Source, sink, and every intermediate hop
Path visualization
The UI renders source (green), sink (red), and intermediate hops (blue) with line-by-line code context. Developers see the complete attack chain, not just endpoints.
Beyond data flow: point issues
Some vulnerabilities don't need cross-function data flow. They live at a single line of code. A cost-optimized two-stage LLM pipeline runs on every file in the repository to catch them.
Lightweight triage, fast and cheap
Stage 01 · Fast classification
Quickly classifies each file to determine whether it's production code and whether it likely contains a vulnerability (crypto, auth, misconfiguration, access control). Low-confidence files are filtered out immediately.
Reasoning model, category-specific
Stage 02 · Deep analysis
Category-specific deep analysis of full files. A vulnerability is reported only when confidence is high and exploitability is concrete. Theoretical or speculative issues are discarded.
Concrete exploits only. Hypothetical warnings get dropped.
Ultra-strict stage 2
Stage 2 is intentionally conservative: a finding ships only if the agent can describe how an attacker would actually trigger it.
One pipeline, the whole surface
Agentic SAST is one module on the Keygraph platform. Everything below shares the same findings model, deduplication, and reporting.
Pentesting
Whitebox PentesterCode-aware exploit validation Blackbox PentesterNo source access required Business Logic TestingAbuse of intended behaviour ShannonThe open-source engineSee it read your code
Schedule a demo and watch Agentic SAST map a real codebase, then watch the whitebox pentest exploit what it finds.