Changelog

June 26th, 2026 New Feature

Praetorian Guard now procedurally generates fully operational decoy cloud environments — realistic infrastructure designed to make attackers waste their time against a fake environment instead of investing it in your real one. Unlike static honeypots or manually configured decoys, Knossos generates complete Terraform plans with authentic attack paths, breadcrumb trails, and live alert wiring — all from a single style profile.

The core idea is simple: every hour an attacker spends navigating a decoy environment is an hour they’re not spending on production. Much of the engineering has been spent making these environments indistinguishable from the real thing. Every resource has realistic names, tags, security groups, IAM policies, and cross-references. Attackers who discover one resource find breadcrumbs leading them deeper into the labyrinth — burning their time and operational budget while every step triggers real-time alerts back to the defender.

What’s new

Knossos introduces a full deception generation pipeline — from environment design through Terraform plan output to active threat intelligence — directly inside Guard.

• Style profile inference — Point Knossos at your real infrastructure data and it reverse-engineers a style profile: naming conventions, tag patterns, region preferences, resource distributions, and security posture. Your deception environment mirrors what attackers expect to find

• Environment generation — One API call produces a complete Terraform plan with VPCs, subnets, EC2 instances, RDS databases, Lambda functions, S3 buckets, IAM roles, secrets, and security groups — all wired together with realistic dependencies

• Breadcrumb trails — Automated attack-path injection plants discoverable cross-references between resources: secrets that reference database endpoints, S3 objects containing SSH configs, Lambda environment variables pointing to the next hop. Each breadcrumb is a trap

• Live alert wiring — Every deception resource is instrumented with CloudWatch alarms, EventBridge rules, and API destination callbacks that fire the moment an attacker touches anything — ingest events flow directly into Guard for triage and response

• Camouflage layer — Beyond the resources that serve the attack paths, Knossos pads the environment with camouflage resources — extra VPCs, instances, buckets, and roles — distributed to match the cardinality ratios of your real infrastructure. Operators control the camouflage density through a single scale parameter so the deception environment never looks suspiciously sparse or bloated

• Defense in depth — Every generated environment ships with three isolation layers: a dedicated VPC with deny-all NACLs that prevents any network path to production, an IAM permission boundary that blocks privilege escalation while appearing fully permissive to the attacker, and a ready-to-apply Service Control Policy (SCP) that operators attach at the account or OU level to enforce the boundary from outside the environment

• Cost estimation — Before deploying, Knossos estimates the monthly cost of the deception environment using live pricing data, so operators can tune resource caps and stay within budget

• Activity simulation — Optional simulator roles generate background API activity against deception resources, making the environment appear actively used and increasing attacker dwell time

• Multi-provider roadmap — The emitter architecture is provider-pluggable. AWS ships first with full coverage; GCP and Azure emitters follow the same registry pattern and are in development

Why Knossos?

In Greek mythology, Daedalus built the Labyrinth beneath the palace of Knossos on Crete — an inescapable maze designed to contain the Minotaur. Those who entered could not find their way out. The labyrinth was not a prison for the monster alone; it was a trap for anyone who dared enter uninvited. King Minos used it as the ultimate defensive architecture: a structure so complex that the threat eliminated itself. Knossos brings the same principle to cloud security — deception environments so realistic that attackers walk in willingly, and every step they take becomes intelligence for the defender.

Praetorian Guard now supports AI-enabled, fully autonomous, persistent attacks. Users can now define directives that continuously task the compute fleet to investigate specific targets or attack hypotheses. Unlike unsophisticated vulnerability scans or human-in-the-loop AI penetration testing, Hannibal runs autonomously and iteratively, accumulates cross-iteration learning, and files risks based on demonstrated compromise, linked back to the operational directive. Much of the engineering time has been spent on implementing enterprise-grade controls for efficacy, safety, and token efficiency.

Key features include:

• Asset risk scores — When all tenant infrastructure is in scope, Hannibal leverages pre-computed asset risk scores for target selection

• Guardrails — Safety and prevention controls to restrict scope, targeting, and actions through code enforcement and policy

• Iterative memory — Rather than each run starting cold, working state persists across iterations so signal and compromises from earlier runs inform subsequent investigations

• Judge agents — Adversarial review agents to help control hallucinations and false positives

• Operation directives — Operators define a scoped hunt with a target, goal, and allowed tool set; the platform enqueues and manages execution across the compute fleet

• Orchestration — Orchestrator/subagent architecture to coordinate delegation and execution

• Subagents — Subagent delegation for specialized attack vectors across attack surfaces

• Skills — A collection of offensive security agent skills benchmarked against 15 models

• Risk linkage — Compromises from an operation are filed as Guard risks tagged with the originating hunt, enabling tracking and attribution

• Authentication support — Works across various attack surfaces, including authenticated web applications, with compatibility for local authentication, single sign-on (SSO), two-factor authentication (2FA), and more

• Watermarks — Hannibal uses watermarks to prevent retargeting recently targeted assets and risks

• Workflows — Reusable, multi-step playbooks that chain skills and subagents into repeatable attack sequences, letting operators codify proven methodologies and apply them consistently across operations

Why Hannibal?

After Hannibal's invasion of Italy during the Second Punic War and following his devastating victory at the Battle of Cannae, Romans viewed the Carthaginian general as the greatest threat of their time. Roman children were taught that Hannibal grew up with a blood oath of eternal hatred toward Rome, and Roman parents would terrify their misbehaving children with the warning, “Hannibal ad portas!” …Hannibal is at the gates.

We're fired up to announce that Praetorian Guard now integrates with JupiterOne — bringing your entire cyber asset inventory into Guard's adversary-driven attack surface engine.

What's new

Guard pulls cyber assets and security findings directly from your JupiterOne tenant — across US and EU regions — and overlays them with Guard's attacker-perspective intelligence. Every asset, identity, and finding JupiterOne knows about gets the Praetorian treatment: scope-validated, attacker-prioritized, and materiality-tested.

Why this matters

JupiterOne is incredible at telling you what you have. Guard tells you what an attacker would do with what you have. Together, they answer the question security leaders actually lose sleep over: "Of all these assets and findings, which ones would a real adversary chain into a breach?"

With this integration, you get:

• Attacker's-eye context on your asset graph — Guard correlates JupiterOne's cyber asset inventory against live attack paths, exposed services, and exploitable conditions. Your CAASM data becomes adversarial intelligence, not just a system of record.
• Scope validation across cloud, identity, and beyond — Confirm whether assets surfaced by JupiterOne are actually in your attack surface, owned by you, and worth defending. Cut the noise, focus on what's real.
• Materiality scoring on findings — Guard's offensive intelligence weighs every JupiterOne finding against what a skilled attacker could actually achieve — not theoretical CVSS, but real exploitability against your real environment.
• Unified visibility — Your JupiterOne asset graph and Guard's adversarial validation live side-by-side. No more pivoting between tools to figure out if a finding matters.

The bottom line

JupiterOne gives you the map. Guard shows you which routes the attacker actually takes. With JupiterOne + Guard, your asset inventory stops being a list — it becomes a battleground you've already scouted. Spend your team's time on the assets and findings that move the needle, and let Guard rule out the rest.

We're thrilled to announce that Praetorian Guard now integrates with SecurityScorecard — and it's a game-changer for how security teams cut through the noise.

What's new

Guard now connects directly to your SecurityScorecard tenant, ingesting findings and overlaying them with Guard's adversary-driven attack surface intelligence. Every SecurityScorecard issue gets the Praetorian treatment: scope-validated, attacker-prioritized, and materiality-tested.

Why this matters

SecurityScorecard tells you what it sees. Guard tells you what an attacker would do with it. Together, they answer the question every security leader is really asking: "Is this finding actually exploitable, and does it matter to my business?"

With this integration, you get:

• Attacker's-eye context — Guard correlates SecurityScorecard findings against live attack paths, exposed services, and exploitable conditions on your real attack surface. No more guessing whether an issue is theoretical or reachable.
• Scope validation — Confirm whether SecurityScorecard's identified assets are actually yours, in scope, and worth chasing. Stop wasting cycles on findings tied to assets you don't own or care about.
• Materiality scoring — Guard's offensive intelligence weighs every finding against what a skilled adversary could actually achieve. Surface the issues that would make a real attack succeed — and deprioritize the ones that wouldn't.
• One pane of glass — SecurityScorecard's posture data and Guard's adversarial validation live side-by-side in the platform you already use for attack surface management.

The bottom line

Stop triaging finding-by-finding. Start defending against the attack paths that matter. SecurityScorecard + Guard turns posture data into prioritized, validated, attacker-ready intelligence — so your team spends time on the risks that move the needle.

Map Any API Attack Surface — No Documentation Required

Penetration testers know the problem: the client says "test our APIs" but hands you a login and nothing else. No OpenAPI spec. No Postman collection. No documentation. Vespasian — now open source — solves this. It captures live traffic from web applications, classifies API calls, and generates structured specifications for REST (OpenAPI 3.0), GraphQL (SDL), and SOAP (WSDL) — giving you a complete map of the API attack surface from nothing but a URL.

How It Works

Vespasian uses a two-stage pipeline that separates traffic capture from specification generation:

1. Capture — Drive a headless browser through the target application with full JavaScript execution and authentication injection. Every HTTP request the frontend makes is recorded. Alternatively, import existing traffic from Burp Suite XML, HAR archives, or mitmproxy captures.

2. Generate — Classify captured requests as API calls using content-type, path heuristics, HTTP methods, and response structure. Auto-detect the API type — or specify it explicitly. Probe discovered endpoints for enrichment. Output structured specifications in the native format for each type.

This separation means you capture once, generate many. Run different generators against the same capture without re-scanning. The capture file is inspectable JSON you can review and debug.

Three Output Formats

• OpenAPI 3.0 for REST — Path normalization (/users/42 becomes /users/{id}), schema inference from response bodies, parameter extraction from query strings.

• GraphQL SDL — Tiered introspection with 3 query levels to bypass WAF-protected servers. Falls back to traffic-based schema inference when introspection is disabled entirely.

• WSDL for SOAP — Identifies SOAP services via SOAPAction headers and envelope detection, fetches and parses WSDL documents.

Key Capabilities

• API Type Auto-Detection — Automatically determines REST, GraphQL, or SOAP from captured traffic. No manual selection needed.

• Multi-Source Import — Reuse traffic from Burp Suite XML, HAR 1.2, and mitmproxy. No re-scanning needed.

• Active Probing — OPTIONS discovery, JSON schema inference, WSDL document fetching, and GraphQL introspection enrich discovered endpoints.

• SSRF Protection — Blocks probing of private and loopback addresses by default. Use --dangerous-allow-private for internal targets.

• Confidence Scoring — Configurable classification confidence thresholds filter noise from legitimate API calls.

Vespasian + Hadrian = Complete API Security

Vespasian discovers the attack surface. Hadrian tests it for vulnerabilities. Together they form a pipeline that takes you from "no documentation" to "proven authorization vulnerabilities" — without asking the client for anything beyond a login.

Open Source

Vespasian is fully open source at github.com/praetorian-inc/vespasian. Install with a single command:

go install github.com/praetorian-inc/vespasian/cmd/vespasian@latest

Or scan an application end-to-end:

vespasian scan https://app.example.com -o api.yaml

How It Fits Into Guard

Vespasian runs as a Guard Platform capability, feeding discovered API endpoints and generated specifications directly into your attack surface inventory. When paired with Hadrian, the complete API discovery-to-testing pipeline operates within Guard — endpoints discovered, specs generated, authorization tested, findings triaged — all in one platform.

Documentation

https://docs.praetorian.com/en/articles/2168486-vespasian-api-discovery-and-specification-generation

The Cloud Has a Visibility Problem — Aurelian Fixes It

We are thrilled to announce Aurelian, our open-source multi-cloud security reconnaissance framework — now powering cloud assessments directly inside the Praetorian Guard Platform.

Cloud environments are sprawling, fragmented, and full of hidden risk. Secrets buried in Lambda environment variables. S3 buckets that look private but aren't. IAM policies that silently grant privilege escalation paths nobody mapped. Until now, finding all of this required stitching together a patchwork of single-cloud, compliance-focused tools that weren't built for offensive security.

Aurelian changes that — completely.

One Framework. Three Clouds. Zero Blind Spots.

Aurelian delivers a unified command-line interface for security reconnaissance across AWS, Azure, and GCP — with 25+ purpose-built modules designed by Praetorian's offensive security team. Whether you're hunting secrets, mapping IAM attack paths, or identifying publicly exposed resources, Aurelian gives you a single, consistent workflow across every major cloud provider.

What Makes Aurelian Different

• Real Policy Evaluation, Not Checkbox Compliance — Aurelian doesn't just check config flags. It evaluates actual IAM policies including condition keys, SCPs, and resource ARN patterns to determine true exposure. This is how penetration testers think — and now it's automated.
• Secrets Discovery Across 30+ Sources — EC2 user data, Lambda code, CloudFormation templates, CloudWatch logs, Azure Key Vaults, GCP storage blobs — Aurelian extracts and scans them all using the Titus secrets detection engine, with optional live validation to confirm active credentials.
• IAM Privilege Escalation Graphing — Export IAM relationships to Neo4j and run Cypher queries to visualize multi-hop escalation paths. See exactly how an attacker moves from a low-privilege role to domain dominance.
• Public Resource Detection That Actually Works — Combines resource enumeration, property enrichment, and access evaluation to find resources that are genuinely accessible — even when configuration appears private but resource-based policies tell a different story.
• Subdomain Takeover Detection — Identify dangling CNAMEs across CloudFront, S3, Elastic Beanstalk, CDK staging buckets, and managed DNS services before attackers do.
• OPSEC-Aware Reconnaissance — Built-in awareness of CloudTrail logging with configurable OPSEC levels. The whoami module identifies your caller identity without generating a single audit log entry.

Already Inside the Guard Platform

Aurelian isn't a standalone tool you bolt on — it's already integrated into the Praetorian Guard Platform. That means its reconnaissance capabilities feed directly into your attack surface management workflows. Discovered secrets, public resources, and IAM risks surface as actionable findings alongside everything else Guard already tracks.

Combined with Titus for secrets scanning and Trajan for CI/CD pipeline testing, Aurelian completes a powerful trifecta of cloud security capabilities that give your team comprehensive visibility across your entire cloud footprint.

Open Source and Extensible

Aurelian is fully open source under the Apache 2.0 license. Its plugin architecture makes adding new modules straightforward — implement the plugin.Module interface, call plugin.Register(), and the CLI wiring happens automatically. The streaming pipeline architecture handles backpressure and concurrency out of the box.

Whether you're a Praetorian Guard customer benefiting from Aurelian's capabilities automatically, or a security researcher extending the framework with custom modules — Aurelian is built for you.

Check out the project on GitHub: github.com/praetorian-inc/aurelian

Read the full deep dive: Aurelian: Open-Source Cloud Security Tool

Autonomous Source Code Vulnerability Discovery — From Clone to Confirmed Finding to Tested Patch

What if you could point an AI at a source code repository and get back confirmed, exploitable vulnerabilities — with patches that have been verified to actually fix the bugs? Constantine does exactly that. Inspired by the strategies that won the DARPA AIxCC competition, Constantine runs a six-stage autonomous pipeline that finds vulnerabilities, proves they're real, and generates validated fixes.

The Pipeline

Constantine mirrors how an expert security researcher works — but runs end-to-end with no human intervention:

• Ingest — Clone the repo, score every file for security relevance using LLM-based semantic analysis, and prioritize the code that matters most. Supports 18 languages and handles repositories of any size.

• Detect — Five detection modules run in parallel. The primary two-pass scanner uses Haiku for fast triage across all code, then Opus/Sonnet for deep CWE-specific validation on flagged areas. An adversarial actor-skeptic scanner adds a second perspective — one model proposes findings, another challenges them.

• Review — An agentic LLM verifier with code exploration tools autonomously reads files, searches code, and traces data flows to confirm each finding. Taint-aware verification uses tree-sitter AST parsing to pre-compute call graphs, reducing false positives further.

• Exploit — For every verified finding, an agentic LLM generates proof-of-vulnerability code and executes it in a sandboxed environment. An internal write-test-retry loop iterates until the bug is demonstrably triggered — up to 250 tool calls per finding.

• Patch — Generates fixes using a tiered strategy: dependency bumps, targeted fixes, then structural refactors. Every patch is validated by re-running the exploit. Only patches that provably fix the bug get reported.

• Report — Complete evidence chains from detection through exploitation through patching, with CVSS scores, CWE classifications, and cost breakdowns.

Benchmarked Against 28 Real CVEs

Constantine is validated against vulnerabilities including Log4Shell, Heartbleed, Dirty Pipe, Baron Samedit, regreSSHion, Psychic Signatures, Looney Tunables, and runc Container Escape — spanning memory safety, auth bypass, path traversal, cryptographic flaws, and web vulnerabilities across C, Java, Python, Go, Rust, and JavaScript.

Two Operating Modes

• Customer engagement — Connect to a client's private repository. Findings flow into Guard as Risks with full evidence chains.

• Zero-day hunting — Point at any public repository. Constantine finds vulnerabilities. A human reviews and coordinates disclosure.

Cost Control

Three pipeline tiers — Premium (250 findings reviewed), Medium (150), Basic (75) — with real-time budget tracking and configurable spend caps. Per-module, per-stage cost breakdowns in every report.

How It Fits Into Guard

Constantine runs natively inside the Praetorian Guard Platform. Findings flow directly into your Guard dashboard as Risks — complete with severity ratings, evidence chains, and validated patches. Source code security joins your attack surface management, vulnerability scanning, and penetration testing in one unified view.

Documentation

https://docs.praetorian.com/articles/1856234-constantine-locates-fatal-security-bugs-in-software

API Security Testing That Proves Authorization Is Broken — Not Just Suspects It

Your APIs are your largest attack surface, and authorization flaws are the hardest bugs to find with traditional scanners. Hadrian is now open source and available in the Praetorian Guard Platform. It tests your REST, GraphQL, and gRPC APIs for OWASP API Top 10 vulnerabilities using role-based authorization testing and a mutation testing pattern that proves exploitability — not just flags suspicion.

In its first run against OWASP crAPI, Hadrian found 3 critical BOLA vulnerabilities in under 60 seconds.

What Makes Hadrian Different

Most API security tools send malformed requests and check for error codes. Hadrian does something fundamentally harder: it tests whether one user can access another user's resources. It logs in as each role you define, executes every endpoint, and detects when authorization boundaries fail.

The mutation testing pattern is where Hadrian truly separates from other tools. It uses a three-phase approach: create a resource as a privileged user, attempt to modify or delete it as an unprivileged user, then verify whether the attack actually succeeded. This eliminates false positives from APIs that return 200 OK but silently ignore unauthorized requests. When Hadrian reports a finding, it has proof.

30 Built-In Templates Across Three Protocols

Hadrian ships with 30 security test templates — 8 for REST, 13 for GraphQL, and 9 for gRPC — covering the most critical API security risks:

• BOLA (API1) — Broken Object Level Authorization across all three protocols

• Broken Authentication (API2) — Token handling, session management, and auth bypass

• BOPLA (API3) — Broken Object Property Level Authorization — mass assignment and field-level access

• Unrestricted Resource Consumption (API4) — GraphQL query depth and complexity attacks

• BFLA (API5) — Broken Function Level Authorization with mutation testing proof

• Security Misconfiguration (API8) — CORS, verbose errors, introspection exposure

• Improper Inventory Management (API9) — Undocumented and deprecated endpoints

Every template is a YAML file you can customize, extend, or replace for your organization's specific API patterns.

Works With Vespasian

Don't have API documentation? Vespasian discovers the API surface from live traffic, generates OpenAPI specs, and hands them directly to Hadrian for security testing. Together they form a complete API security pipeline: discover endpoints → generate specs → test for authorization vulnerabilities. No documentation required from the client.

Claude Code Integration

Hadrian includes a Claude Code skill that auto-generates auth.yaml and roles.yaml from your API specification — no manual config writing needed. Point it at an OpenAPI spec, GraphQL SDL schema, or gRPC proto file, and it produces the configuration Hadrian needs to start testing immediately.

CI/CD Ready

Hadrian outputs JSON and Markdown reports and returns a non-zero exit code when vulnerabilities are found, making it suitable for CI/CD security gates. Adaptive rate limiting with reactive backoff on 429/503 responses keeps your pipelines reliable.

Open Source

Hadrian is fully open source at github.com/praetorian-inc/hadrian. Install with a single command:

go install github.com/praetorian-inc/hadrian/cmd/hadrian@latest

How It Fits Into Guard

Hadrian runs as a Guard Platform capability. Findings flow into your Guard dashboard as Risks alongside your other security data — complete with proof of exploitability from the mutation testing pattern. API authorization testing joins your attack surface management, vulnerability scanning, and penetration testing in a single unified view.

Documentation

https://docs.praetorian.com/en/articles/2293307-hadrian-api-security-testing