Red Zone

The Red Zone (/graph) is the primary interface of RedAmon. This is where you visualize your attack surface, launch scans, interact with the AI agent, and explore findings. This page gives you a complete tour of every element on screen.

Accessing the Red Zone

1. Select a project from the Project Selector dropdown in the top navigation bar (or navigate from the Projects page)
2. Click "Red Zone" in the top navigation bar (the crosshair icon)
3. You'll land on the Graph page with your selected project loaded

Page Layout

The Graph page is organized into several sections:

Global Header

The top navigation bar is present on every page.

Graph Toolbar

The toolbar is organized into two rows with action groups. The Render, 2D / 3D and Labels toggles are not here: they sit on the right of the View Tabs strip, and only while the Graph Map view is active.

Row 1 — Context & Emergency Pause

When to use PAUSE ALL: If you notice the recon, GVM scanner, or AI agent are targeting something unintended, click this button immediately. It freezes containers via Docker cgroups (no data loss) and cancels all running agent tasks. You can resume individual pipelines afterwards using their respective Resume buttons.

Row 2 — Action Groups

The second row contains four color-coded action groups:

Recon Actions (Green)

GVM Vulnerability Scan (Yellow, Shield icon)

Other Scans (Blue, GitHub icon)

The Other Scans modal provides three standalone scan modules, each independent of the recon pipeline:

GitHub Secret Hunt and the Supply Chain Scanner each hold their own github.com token in Global Settings, and Supply Chain needs its one only for a private GitHub repository (uploads and public repos need no token). The Secret Multiscanner holds a third: one key per source, in its own Secret Multiscanner drawer under Global Settings > API Keys. All three run independently (GitHub Secret Hunt and Supply Chain add Pause and Resume to Start / Stop / Logs / Download; the Secret Multiscanner has no pause, and its Start / Stop / Logs are per source), and all three write the live graph, so none of them can be started while a saved (past) scan version is being viewed.

Agent Status (Right side)

View Tabs

Just below the toolbar, five tabs let you switch views:

When in Data Table mode, a header chevron opens the preset picker. Each preset renders its own header row with per-table search, refresh, and three export buttons — XLSX, JSON, and MD (Markdown). See Data Export & Import for format details.

Scan Timeline tabs. Next to Graph Map you will also find two tabs with a green NEW badge, Recon Delta and Scans, plus a version switcher in the header (Scan N — <date> UTC). These belong to the Scan Timeline feature: keep each scan as a version, view or activate past versions, diff two scans, schedule future scans, and follow the live scan queue and run history of every scan type.

View toggles (right of the tabs strip)

While the Graph Map view is active, three switches sit on the right of the tabs strip:

All three are saved per user, per project.

RedAmon Terminal

The RedAmon Terminal tab provides full interactive shell access to the kali-sandbox Docker container directly from the browser. It uses xterm.js with a WebSocket-based PTY connection, giving you a real Kali Linux terminal with all pre-installed pentesting tools.

Architecture

Browser (xterm.js) → WebSocket → Agent proxy (/ws/kali-terminal) → kali-sandbox terminal server (port 8016) → PTY /bin/bash

Features

Use Cases

• Manual tool execution — run Metasploit, Nmap, Hydra, sqlmap, or any Kali tool directly
• Debugging — inspect the sandbox environment, check processes, review logs
• Scripting — write and execute custom scripts inside the container
• Supplementing the agent — perform manual steps the AI agent cannot or should not automate

Note: This tab provides direct sandbox access. For managing remote sessions opened by the AI agent (meterpreter, reverse shells, etc.), use the Reverse Shell tab instead.

redagraph CLI (in-terminal graph queries)

redagraph is a small command-line tool installed on the kali-sandbox image and reachable from the RedAmon Terminal tab. It lets you query the project's Neo4j attack-surface graph from inside the shell, with the active user_id and project_id automatically injected into every query so cross-tenant data is never returned.

The point of redagraph is to close the loop between what the recon pipeline already discovered and what you want to throw a Kali tool at next. Instead of opening the Graph view, copying URLs or IPs by hand, and pasting them into a tool, you run a one-liner:

redagraph ls Subdomain | httpx -title -status-code
redagraph ls IP -a address | naabu -p 1-65535
redagraph ls Endpoint -a baseurl > urls.txt && nuclei -l urls.txt -t cves/
redagraph cypher 'MATCH (s:Subdomain)-[:RESOLVES_TO]->(i:IP) RETURN i.address' | sort -u | masscan -iL - -p 80,443

Every Kali tool that reads targets from stdin or a file becomes a first-class consumer of the graph.

Why this matters for manual testing

The recon pipeline produces a rich graph (Subdomain, IP, Port, Service, Technology, Endpoint, BaseURL, Header, DNSRecord, CVE, Vulnerability, Secret, ...) with all the relationships between them. When you want to manually test a single Kali tool against a real subset of that graph, redagraph is the bridge:

Concretely, this is what manual workflows look like:

# Run httpx only against subdomains the recon pipeline marked as live (status_code is set)
redagraph cypher \
  'MATCH (s:Subdomain) WHERE s.status_codes IS NOT NULL RETURN s.name' \
  | httpx -silent -tech-detect

# Run sqlmap against every endpoint that recon flagged with query parameters
redagraph cypher \
  'MATCH (e:Endpoint) WHERE e.query_string <> "" RETURN e.url' \
  | xargs -I{} sqlmap -u {} --batch --level 2

# Pre-filter ffuf wordlist pass to only subdomains that resolve to the same /24 as a known IP
redagraph cypher \
  'MATCH (s:Subdomain)-[:RESOLVES_TO]->(i:IP) WHERE i.address STARTS WITH "203.0.113." RETURN s.name' \
  | xargs -I{} ffuf -u https://{}/FUZZ -w common.txt

# Feed nuclei a hand-crafted target list from BaseURLs that have a specific technology
redagraph cypher \
  'MATCH (b:BaseURL)-[:USES]->(t:Technology {name: "WordPress"}) RETURN b.url' \
  > wp-targets.txt
nuclei -l wp-targets.txt -tags wordpress

Because tenant scoping is silent, you can move between projects (top-right project switcher) and the same exact one-liner now points at a different scope without any code change. That is the primary value over running raw cypher-shell against Neo4j: you stop carrying tenant state in your head.

Invocation

redagraph [global options] <subcommand> [subcommand options]

The shell only reads REDAMON_USER_ID and REDAMON_PROJECT_ID from the environment. These are injected automatically when you open the terminal via the webapp Graph -> Terminal tab (the browser sends them as the first WebSocket frame, and the sandbox PTY forks the shell with them set). A docker exec-spawned shell does not have them, so redagraph exits with a hint.

Global options

Subcommands

Tenant scoping (what happens under the hood)

For every Cypher query, redagraph:

1. Rejects writes via a static regex check (read-only enforcement, local).
2. Rewrites every labelled node pattern (d:Domain {...}) into (d:Domain {..., user_id: $tenant_user_id, project_id: $tenant_project_id}) so the query can only match nodes owned by the current (user_id, project_id).
3. Refuses queries that have no labelled node patterns (e.g. MATCH (n) RETURN n), because the inline rewrite cannot reach them and the query would otherwise leak cross-tenant data. redagraph types is the documented exception, since it filters explicitly with WHERE.
4. Passes tenant_user_id and tenant_project_id as parameters to Neo4j.

You never type the tenant filter, and you cannot accidentally query a different project from the terminal. To target a different project, switch projects in the top-right project switcher; the terminal reconnects with the new tenant context.

Output formats

plain (default) is designed to compose with the rest of the shell:

json always emits NDJSON (one JSON object per row). Nodes and relationships are converted to {"_kind":"node","labels":[...],"properties":{...}} so they survive the trip to text.

tsv adds a header row to stdout and uses tab separators.

Examples

Listing things you want to feed into Kali tools

# All subdomains, one per line
redagraph ls Subdomain

# All Endpoint baseurls into a file, then nuclei them
redagraph ls Endpoint -a baseurl > urls.txt
nuclei -l urls.txt -t exposures/ -t misconfiguration/

# Just the IPs that have at least one open port
redagraph cypher 'MATCH (i:IP)-[:HAS_PORT]->(p:Port) RETURN DISTINCT i.address' \
  | naabu -p 80,443,8080,8443

# Endpoints with query strings, ready for parameter fuzzing
redagraph cypher 'MATCH (e:Endpoint) WHERE e.query_string <> "" RETURN e.url' \
  | head -50 \
  | xargs -I{} ffuf -u "{}&FUZZ=test" -w params.txt

Counting and aggregating

# How many subdomains have we discovered
redagraph ls Subdomain | wc -l

# How many distinct Technology names show up across all BaseURLs
redagraph ls Technology | sort -u | wc -l

# Open-port distribution
redagraph cypher 'MATCH (p:Port) RETURN p.number AS port, count(*) AS n ORDER BY n DESC'

Joining graph data with Kali tool output

# Diff: which discovered subdomains do NOT respond to httpx?
redagraph ls Subdomain > all-subs.txt
httpx -l all-subs.txt -silent | sed 's|https\?://||;s|/.*||' | sort -u > live-subs.txt
comm -23 <(sort -u all-subs.txt) live-subs.txt > dead-subs.txt
echo "$(wc -l < dead-subs.txt) subdomains in the graph but not responding"

# Filter nuclei runs to only versions of nginx the graph claims are vulnerable
redagraph cypher 'MATCH (t:Technology {name: "nginx"})-[:HAS_CVE]->(c:CVE) RETURN c.cve_id' \
  | sort -u > our-nginx-cves.txt
nuclei -l urls.txt -tags cve | grep -F -f our-nginx-cves.txt

Natural-language exploration

# Whatever the LLM thinks "list all the CVEs we know" means
redagraph ask list all CVEs

# Show the generated Cypher (good for prompt debugging or learning the schema)
redagraph ask --show subdomains with status 200

# Pipe NL output into a tool. JSON keeps the structure if the LLM picked nodes.
redagraph -f json ask all endpoints with a query string \
  | jq -r '.e.properties.url'

Output formats side by side

redagraph ls Subdomain --limit 3                           # plain
# a.example.com
# b.example.com
# c.example.com

redagraph -f json ls Subdomain --limit 3                   # NDJSON
# {"name": "a.example.com"}
# {"name": "b.example.com"}
# {"name": "c.example.com"}

redagraph -f tsv cypher 'MATCH (s:Subdomain) RETURN s.name AS name, s.status AS status LIMIT 2'
# name  status
# a.example.com  200
# b.example.com  no_http

Exit codes

Troubleshooting

Graph Canvas

The graph canvas is the main visualization area where your attack surface is displayed as an interactive node-link diagram.

2D Mode

• Pan: Click and drag the background
• Zoom: Mouse scroll wheel
• Select node: Click on any node to open the Node Drawer
• Nodes are color-coded by type (see Bottom Bar)
• Nodes are positioned by a force-directed layout algorithm

3D Mode

• Rotate: Click and drag
• Pan: Right-click and drag
• Zoom: Mouse scroll wheel
• Select node: Click on any node
• Provides a more immersive view for large graphs

Auto-Refresh

During active reconnaissance, the graph auto-refreshes every 5 seconds to show new nodes as they're discovered. The refresh stops when the scan completes.

Data Table

The Data Table tab opens a dropdown with 20 presets: 3 base views plus 17 Red Zone finding tables. Every preset shares the same shell: per-table search, refresh, and three export buttons (XLSX, JSON, MD) in the header; paginated scroll body. The active search filter applies to exports - only matching rows are written.

Default preset: Node Inspector is selected the first time you open the Data Table tab — it's the most common entry point for one-type-at-a-time exploration. You can switch to any other preset from the dropdown; your last-selected preset is not yet persisted across reloads.

Base views

Node Inspector — in detail

Why it exists. "All Nodes" is great for a flat overview but every property is buried inside an expandable row. Node Inspector flips that: pick one type, get a wide table where every attribute is a first-class column you can sort, copy, and export. It's the fastest way to answer questions like "show me all Vulnerability rows with their cwe_id, severity, and description side-by-side" or "list every Domain with its WHOIS registrar and country".

Toolbar (top of the panel).

Column model.

Auto-linkified cells. Property values that match known patterns are rendered as external links automatically — URLs (pass-through), IPs (→ http://<ip>), hostnames (→ https://<host>), CVE IDs (→ NVD detail), CWE IDs (→ MITRE), CAPEC IDs (→ MITRE), emails (→ mailto:), GitHub owner/repo slugs (→ github.com), host:port (→ http://host:port). Plain words (e.g. registrar names like GoDaddy) and file names (e.g. config.xml) stay as text — there's a deny-list for common file extensions to avoid false positives.

Persistence. Hidden-column selections are stored on the User row in Postgres under uiPreferences.nodeDetailsTable.<NodeType>.hiddenColumns (only the HIDDEN keys are stored, so a newly discovered property defaults to visible without any DB write). Selections are per-user AND per-node-type — hiding country on Domain doesn't affect IP. All three Show all / Hide all / single-toggle actions persist via the same debounced PATCH so a rapid burst of clicks produces one network write.

Behavior with empty/missing data.

• A type with zero rows after filtering shows the empty pagination state — the type selector and Columns menu remain operative.
• A property that exists on only ONE node of the type still appears as a column (rows lacking it show empty).
• A previously-hidden column that no longer appears in the current data is silently kept in the saved hidden list — preserves intent if the property returns later.

Red Zone finding tables

Every table below is a graph-native aggregation driven by a single Cypher query. Rows represent actionable pentesting findings, not raw nodes.

4. Kill-Chain Explorer _{(Target icon)}

Row = one attack path. Walks Subdomain -> IP -> Port -> Service -> Technology -> CVE -> MitreData -> Capec, flags a KEV badge when an ExploitGvm node links the CVE. Sorted CISA-KEV first, then max CVSS. Empty until nmap + nuclei vuln_scan + CVE enrichment have run.

5. Technology Blast Radius _{(Zap icon)}

Per-Technology aggregate: CVE count, max CVSS, KEV count, number of BaseURLs / IPs / subdomains transitively affected by that version. Converts scattered CVE nodes into a patch-priority queue. Empty until Technology nodes have linked CVE nodes.

6. Subdomain Takeover _{(Flag icon)}

Every Vulnerability{source='takeover_scan'} with verdict (confirmed / likely / manual_review), provider (github-pages, heroku, aws-s3, fastly, ...), CNAME target, confidence score, evidence snippet, and the tool sources that detected it (subjack, nuclei, baddns). Sorted confirmed -> likely -> manual_review. Empty until Subdomain Takeover Detection has run.

7. Secrets & Credentials _{(Key icon)}

Every :Secret node whether attached via BaseURL-[:HAS_SECRET]-> (resource_enum) or JsReconFinding{js_file}-[:HAS_SECRET]-> (js_recon). Columns: secret type, key category, redacted sample, entropy, validation status (validated / format_validated / unvalidated), detection method, source URL, subdomain. Sorted validated > format_validated > unvalidated, then by type priority. Empty until js_recon or resource_enum has discovered credentials.

8. Net Initial-Access _{(Server icon)}

Merges (a) open sensitive ports (SSH, RDP, SMB, SMTP, MySQL, Postgres, MSSQL, Mongo, Redis, Elasticsearch, K8s API, VNC, etc.) with (b) network-layer security_check vulnerabilities (direct_ip_http, direct_ip_https, waf_bypass, redis_no_auth, database_exposed, kubernetes_api_exposed, smtp_open_relay). Joins each (IP, Port) to its subdomains and ASN/country/CDN metadata. Empty until port_scan + security_checks have run.

9. GraphQL Risk Ledger _{(Boxes icon)}

Every Endpoint{is_graphql=true} with its graphql-scan flags (introspection, graphiql_exposed, field_suggestions_enabled, GET-allowed, batching, tracing), operation counts (queries / mutations / subscriptions), schema hash, sensitive-field sample, and linked graphql_scan / graphql_cop vulnerabilities. Sorted introspection-enabled first. Empty until graphql_scan has run.

10. Web Initial-Access _{(LockKeyhole icon)}

Per-BaseURL view of auth / admin endpoints (/login, /admin/*, category = auth / admin / login), with a present/missing grid for six security headers (CSP, HSTS, X-Frame-Options, X-Content-Type-Options, Referrer-Policy, Permissions-Policy), linked web-layer vulnerabilities (login_no_https, basic_auth_no_tls, session_no_secure, session_no_httponly, cache_control_missing, csp_unsafe_inline, insecure_form_action, no_rate_limiting), and an A-to-F grade. Empty until http_probe + resource_enum + security_checks have run.

11. Parameter Matrix _{(Bug icon)}

Every :Parameter{is_injectable=true} or any Parameter reached by a Nuclei DAST finding via AFFECTS_PARAMETER. Columns: parameter name, position (query / body / header / cookie / path / form), endpoint path, method, linked vulnerability, template_id, matcher_name, fuzzing_method/position, CVSS, matched_at URL. Empty until vuln_scan fuzzing has produced DAST findings.

12. Shared Infrastructure _{(Network icon)}

Three cluster kinds unified into one table: Certificate SAN overlap (same cert serves multiple hostnames), ASN grouping (multiple IPs under the same autonomous system), origin-IP sharing (multiple subdomains on the same IP). Surfaces cross-tenant attack pivots and scope-creep during external engagements. Empty until http_probe has collected Certificate nodes and port_scan has enriched IP ASN.

13. DNS & Email Posture _{(Mail icon)}

One row per Domain: SPF presence + strictness (-all vs ~all vs +all), DMARC presence + policy (reject / quarantine / none), DNSSEC enablement, zone-transfer open flag, MX and NS records, WHOIS registrar + contact emails, days-to-expiry, VT / OTX reputation. Missing-flags derived from TXT-record absence AND spf_missing / dmarc_missing / dnssec_missing / zone_transfer security-check vulns. Empty until domain_recon + WHOIS + security_checks have run.

14. Threat Intel Overlay _{(ShieldAlert icon)}

Unified Domain and IP view with any threat-intel signal: VT malicious / suspicious / reputation / JARM / tags, OTX pulse count + adversaries + malware families + ATT&CK IDs + TLP, CriminalIP risk grade (domain) or score + Tor/VPN/proxy/darkweb/hosting/scanner flags (IP), plus ThreatPulse and Malware linkage counts. Sorted by pulse count desc, VT malicious desc. Empty until OSINT enrichers (otx_enrich, virustotal_enrich, criminalip_enrich) have run.

Since 6.10.0 the table has a third kind of row. Alongside Domain and IP rows (where the asset itself is the indicator) it lists BaseURL rows, where your target was observed contacting a third-party host that a published supply-chain incident names. Those rows fill the Contacted host column and carry the incident id, status, summary and attack vectors; the VT / OTX / CriminalIP columns are empty on them because they are a different kind of claim. The two are kept apart in the graph by the edge type - APPEARS_IN_PULSE versus CONTACTS_MALICIOUS_HOST - so a supply-chain incident can never masquerade as "your host is a known threat indicator". Populate the catalog with ./redamon.sh sca-intel-sync; see Supply-Chain Scanning.

15. JS Dep Signals _{(Package icon)}

Called Supply-Chain before the package/OSV feature took that name. Same table, same data, same supplyChain API slug. If you have a bookmark to /graph?table=supplyChain, it still resolves here.

JsReconFinding nodes with supply-chain impact, all of them about the build and the artifacts it ships, not about the packages themselves: dependency_confusion (a bare import specifier that does not exist on public npm, so an attacker can register it), source_map_exposure + source_map_reference (reachable .map files leaking original sources), framework (React / Vue / Angular version disclosure), dev_comment (leaked internal comments and TODOs), cloud_asset (S3 / GCS / Azure blob URLs leaked in client code). Columns preserve package name, version, cloud provider/type, evidence, and parent JS file URL. Empty until js_recon has run with these scanners enabled.

Package and Version were blank on every row until 2026-08. They read name / version, which the js_recon writer never set. It now stores package_name / package_version (deliberately not name, which is what the graph viewer displays as the node label, and writing it there would relabel every framework node from "React 18.2.0" to "React"). The query coalesces, so rows written before the fix still render. Re-run js_recon to populate the columns on existing findings.

For malicious or vulnerable packages (MAL- verdicts, CVE/GHSA advisories, GuardDog behaviour) see Supply-Chain SCA below.

16. Historic DNS Drift _{(History icon)}

Per-Domain temporal view combining OTX passive-DNS history (HISTORICALLY_RESOLVED_TO edges with first_seen, last_seen, record_type), :ExternalDomain sightings from redirect chains (sources, times_seen, countries_seen, redirect_from_urls), and dangling :Subdomain nodes (has_dns_records=false or status='no_http'). Derives ASN drift and country drift by diffing historic vs current resolutions. Empty until OSINT enrichment and domain_recon have both run.

17. AI / LLM Attack Surface _{(Bot icon)}

In the dropdown this preset sits directly after JS Recon, grouped with the discovery views.

Multi-sheet inventory of every AI / LLM / MCP / vector-DB surface, aggregating AI enrichment from all modules (http_probe AI header/title/favicon, port_scan AI port catalogue, resource_enum AI classifier, js_recon AI SDK, and the central ai_surface_recon module). Sub-sheets:

• LLM Endpoints — every Endpoint with ai_interface_type set or is_ai_framework_detected: interface type (llm-chat / llm-completion / sse-stream / mcp), streaming / tools / vision support, model family, p50 latency, RAG-ingest flag, framework name, and detection source.
• MCP Servers — Endpoint{ai_interface_type='mcp'}: server name/version, protocol version, tool / resource / prompt counts, capabilities, auth-required, and the rug-pull tools_hash.
• AI Technologies — Technology{category starts ai-}: name, category (ai-runtime / ai-frontend / ai-proxy / ai-sdk-client / ai-framework / ai-vector-db), version, detected_by (httpx-ai-header / httpx-ai-title / naabu-ai-port / ai-surface-recon-julius / ai-surface-recon-probe), and attach count.
• Vector DBs — confirmed ai-vector-db Technologies with host, port, and detection source (Chroma / Qdrant / Weaviate / Milvus).
• Model Inventory — flattened ai_model_ids (model id, family, source endpoint) discovered from /v1/models + /api/tags.

Empty until a scan with AI awareness enabled (or the AI / LLM Surface Recon preset) has run.

18. AI Risk (OWASP-LLM / ATLAS) _{(Radiation icon)}

In the dropdown this preset sits directly after AI / LLM Attack Surface.

Multi-sheet offensive view of the attackable AI findings, mapped to OWASP LLM Top-10 / MITRE ATLAS. Sub-sheets:

• MCP Tool Poisoning — Vulnerability{source='ai_surface_recon'}: type (mcp_tool_poisoning / mcp_data_exfiltration / mcp_annotation_mismatch / ...), severity, ai_owasp_llm_id, ai_atlas_technique, payload class, the MCP endpoint, and evidence.
• Injectable Params — Parameter{is_ai_prompt_injectable=true} with endpoint, base URL, and resolved ai_tool_arg_path (the prompt-injection entry points).
• RAG Ingestion — Endpoint{is_ai_rag_ingest=true}: the indirect-prompt-injection sink endpoints.
• Exposed Runtimes — ai-runtime / ai-proxy Technologies reachable on host:port (Ollama / vLLM / TGI / LiteLLM / gateway exposure).
• Unauthenticated MCP — MCP servers with ai_mcp_auth_required=false.
• AI Gauntlet Vulnerabilities — Vulnerability{source IN ['garak','pyrit','giskard','promptfoo']} written by the AI Gauntlet offensive scan: tool, severity, ai_owasp_llm_id, attack chip, target endpoint, ASR, trials, payload class (e.g. garak-dan, pyrit-crescendo), and the transcript reference. These are the confirmed, payload-tested AI weaknesses, as opposed to the statically inferred MCP findings in the rows above.

The first five sub-sheets are empty until the AI Surface Recon module has run; the AI Gauntlet Vulnerabilities sheet fills in after an AI Gauntlet scan.

19. Web Cache Poisoning _{(Droplets icon)}

Every Vulnerability{source='cache_poisoning'} written by the Web Cache Poisoning module, linked to the affected Endpoint / BaseURL. One row per confirmed poisoning, sorted by CVSS then confidence. Columns:

• Endpoint — the poisonable URL.
• Unkeyed input — the request component the cache ignores but the origin trusts: a header (X-Forwarded-Host, X-Forwarded-Proto, X-Forwarded-Port, X-Host, Forwarded, client-IP headers, …) or a ?param (parameter cloaking, e.g. utm_source).
• Impact — stored_xss (critical), open_redirect, dos (CPDoS), reflected, or deception.
• Sev / CVSS — severity badge + score.
• Tier — confidence tier (Confirmed / Strong / Tentative); only findings at or above the project's min-confidence are persisted.
• Mode — how it was proven: reflected (benign canary echoed), differential (a persisted status / Location / body change with no echoed marker), or both.
• Conf — the 0–1 confidence score.
• PoC — a clickable link to the poisoned cache-buster slot, with the ready-to-run curl (canary header + busted URL) in the tooltip.

The header summary shows N Confirmed · N critical · N total. Empty until Web Cache Poisoning is enabled in project settings and a scan has run.

20. Supply-Chain SCA _{(PackageSearch icon)}

In the dropdown this preset sits directly after JS Dep Signals, and is flagged NEW.

The malicious- and vulnerable-package view: Package, MalPackageFinding and Vulnerability{source='osv'}, the model that all three layers of the supply-chain feature MERGE into. An uploaded SBOM, a cloned GitHub repo and a live-target recon harvest dedup onto the same purl, so one row can carry evidence from several scans at once. Three sheets:

• Verdicts - one row per MalPackageFinding. Verdict, severity, advisory or rule (plus OSV aliases), package, version, ecosystem, tool, origin, anchor, title, evidence, and an Incident column that expands into the catalog write-up (summary, status, blast radius, remediation steps, feed revision, link) when the incident catalog matched the package. An empty Incident column means "not in the catalog or never synced", not "safe".
• Packages - the inventory, one row per Package, with rolled-up malicious / suspicious / unchecked / advisory counts and a derived status.
• Advisories - one row per CVE / GHSA the offline OSV pass matched. Filtered to source='osv' because Vulnerability is a shared label that GVM, nuclei and the GraphQL scanner also write into.

Three things the table derives rather than reads, all of them about not mistaking absence of evidence for evidence of safety:

Sheets are capped (1000 verdicts, 2000 packages/advisories) while the header counts are computed over the whole graph, so a capped sheet is labelled SHEET CAPPED rather than quietly presenting a partial list as the total.

Deep-linkable per sheet: /graph?table=supplyChainSca&sheet=advisories. Exports are named supply-chain-sca-<sheet>-<ts>.{xlsx|json|md} (per-sheet, like the AI tables).

Empty until either a Supply-Chain scan has run from Other Scans (SBOM / lockfile upload or a GitHub repo) or a recon scan has run with Supply-Chain Recon enabled. Both need the offline OSV database populated first: ./redamon.sh supply-chain-sync npm.

Bottom Bar (Node Legend & Filter)

The bottom bar displays a scrollable row of color-coded chips, one for each node type present in the graph.

This is especially useful for large graphs where you want to focus on specific node types (e.g., only Vulnerabilities and CVEs).

Persistence. Your selection (which chips are hidden) is saved to your user account, scoped per-project. Hide Vulnerability here and it stays hidden when you reload the page; switch to a different project and that project has its own independent selection. Newly discovered node types (e.g. AttackChain appearing after a scan) are auto-shown the first time. The bar itself auto-hides on table modes other than "All Nodes" — Node Inspector and the Red Zone tables don't need it because they have their own type controls.

Other persistent UI state. The Render, 2D / 3D and Labels toggles in the View Tabs are also persisted per-user per-project. The Theme (dark / light) is persisted per-user globally — flipping it on one device follows your account to others.

Node Drawer

When you click on a node in the graph (or a row in the data table), the Node Drawer slides in from the left.

Internal fields like project_id and user_id are hidden automatically.

Logs Drawer

During any active scan (Recon, GVM, GitHub Hunt, or Secret Multiscanner), a Logs Drawer slides in from the right showing real-time output.

Each scan type (Recon, GVM, GitHub Hunt, Secret Multiscanner) has its own independent logs drawer, toggled by the respective "Logs" button in the toolbar or modal. The Secret Multiscanner goes one level finer: its logs are per source, so the drawer is titled with the source being streamed, and its Logs button is enabled only while that source is running. Its phases are Preparing, Scanning and Complete, and credentials are redacted before the output leaves the orchestrator.

AI Agent Drawer

The AI Agent drawer is the most feature-rich panel. It provides a full chat interface for interacting with the autonomous AI agent. See the dedicated AI Agent Guide for a complete walkthrough.

The drawer header also has a folder icon that opens the FileSystem Drawer on the left side of the screen — same drawer as the toolbar folder icon, convenient for dropping files mid-conversation. See Agent Workspace.

FileSystem Drawer

The FileSystem Drawer slides in from the left side of the screen and gives you direct access to the per-project workspace the AI agent is reading and writing — drag-and-drop uploads, breadcrumb file navigation, inline previews with SHA-256 / mode / mtime properties, per-folder tar.gz downloads, and a Jobs tab tracking every background scan the agent has spawned (status badges, log viewing, cancel).

Two entry points open the same drawer:

• The folder icon in the Graph Toolbar Agent Status group.
• The folder icon in the AI Agent Drawer header.

See the dedicated Agent Workspace page for the full operator walkthrough, the four protected default folders (notes/, tool-outputs/, jobs/, uploads/), the 24 fs_* and 5 job_* tools the agent can call, and the auto-offload behavior for huge tool outputs.

Next Steps

Now that you're familiar with the Red Zone, learn how to:

• Run your first reconnaissance to populate the graph
• Use the AI Agent to analyze findings and perform automated pentesting
• Drop files into the Agent Workspace so the agent can read them on its next think step