--- title: "OWASP Top 10 Through an Agentic Lens" description: "See how Paladin's specialist agents test for each OWASP Top 10 vulnerability category - comparing traditional scanner approaches to agentic techniques." canonical: https://turbopentest.com/learn/foundations/owasp-agentic source: "TurboPentest Learn" --- # OWASP Top 10 Through an Agentic Lens ## OWASP Top 10 and Agentic Testing The OWASP Top 10 is the most widely recognized catalog of critical web application security risks. Understanding how agentic pentesting addresses each category - and where it exceeds traditional scanning - is essential for interpreting pentest results effectively. This lesson uses the **OWASP Top 10 2025** taxonomy. Two notable changes from the 2021 list: Server-Side Request Forgery (SSRF) is now consolidated into A01 Broken Access Control, and a new A10 category, Mishandling of Exceptional Conditions, replaces the old standalone SSRF entry. Software Supply Chain Failures (A03) has also broadened beyond "vulnerable and outdated components." For each OWASP category, we examine: what the vulnerability is, how a traditional scanner tests for it, and how Paladin's agentic approach goes deeper. ## A01: Broken Access Control (including SSRF) **The risk:** Users can act outside their intended permissions - accessing other users' data, modifying unauthorized records, or escalating privileges. In the 2025 Top 10, Server-Side Request Forgery (SSRF) is consolidated into this category, because it lets an attacker coerce the server into accessing resources it was never authorized to reach. **Scanner approach:** Automated scanners check for common misconfigurations: directory listing enabled, missing access controls on known admin paths, default CORS configurations. For SSRF, they inject internal IP addresses and check for response differences. **Agentic approach:** Paladin's Auth/Access Agent creates multiple test sessions with different roles and systematically tests whether low-privilege accounts can access high-privilege endpoints. It tests IDOR by manipulating resource IDs in API calls. It checks for horizontal privilege escalation (accessing another user's data) and vertical privilege escalation (performing admin actions as a regular user). When source code is available, the Code Agent reviews authorization middleware for gaps. For SSRF, Paladin's Web App Agent uses sophisticated payloads - DNS rebinding, URL parser confusion, protocol smuggling, and cloud metadata endpoint access (169.254.169.254). When it finds an SSRF, the Exploit Chain Agent evaluates what internal services can be reached and what data can be exfiltrated, potentially chaining SSRF with cloud credential theft for critical impact. ## A02: Security Misconfiguration **The risk:** Insecure default configurations, incomplete configurations, open cloud storage, unnecessary features enabled, verbose error messages. **Scanner approach:** Vuln Scanner and Enumerator test for common misconfigurations: default credentials, exposed admin interfaces, directory listing, debug endpoints, verbose error pages. **Agentic approach:** Paladin's Infrastructure Agent combines Phase 1 tool output (Port Scanner ports, Enumerator directories, Vuln Scanner template matches) to build a comprehensive configuration analysis. It does not just find individual misconfigurations - it evaluates whether the combination of configurations creates exploitable conditions. An individually low-risk debug endpoint becomes critical when combined with an exposed internal API that leaks authentication tokens. ## A03: Software Supply Chain Failures **The risk:** Vulnerabilities and integrity risks introduced through third-party components and the software supply chain - not only outdated libraries with known CVEs, but compromised or typosquatted packages, missing lockfiles, and insecure build and distribution pipelines. **Scanner approach:** Dep Scanner scans dependencies for known CVEs. Vuln Scanner matches version fingerprints against vulnerability databases. **Agentic approach:** Paladin's Supply Chain Agent reviews Dep Scanner and Vuln Scanner output but goes further by assessing whether known vulnerabilities are actually exploitable in context. A library with a known RCE vulnerability might not be exploitable if the vulnerable function is never called. It also evaluates supply-chain integrity - whether lockfiles are present and pinned, and whether dependencies could be typosquatted. When source code is available, the Code Agent checks whether the vulnerable code paths are reachable. ## A04: Cryptographic Failures **The risk:** Sensitive data exposed due to weak encryption, missing encryption, or poor key management. **Scanner approach:** Tools like TLS Analyzer check TLS configurations, cipher suites, and certificate validity. They match against known weak configurations. **Agentic approach:** Paladin's Crypto/TLS Agent goes beyond configuration checks. It analyzes whether sensitive data is actually encrypted in transit (not just whether TLS is configured). It checks for mixed content, evaluates HSTS headers and preload status, tests certificate pinning, and examines whether cookies have appropriate Secure and HttpOnly flags. When combined with findings from the Web Agent about login forms or the API Agent about sensitive endpoints, it can determine whether cryptographic protections are adequate end-to-end. ## A05: Injection (including XSS) **The risk:** Untrusted data sent to an interpreter as part of a command or query - SQL injection, NoSQL injection, OS command injection, LDAP injection. In the 2025 Top 10, Cross-Site Scripting (XSS) is treated as a form of injection within this category. **Scanner approach:** Scanners like Web Scanner and Vuln Scanner send common injection payloads and check for error messages or behavior changes that indicate vulnerability. **Agentic approach:** Paladin's Web App Agent crafts context-specific injection payloads based on the technology stack detected in Phase 1. If the target uses PostgreSQL (inferred from error messages or response patterns), the agent uses PostgreSQL-specific injection techniques. It tests for blind injection using time-based and boolean-based techniques, tests reflected and stored XSS in a real browser context, and attempts second-order injection where the payload is stored and executed later. The agent validates every finding with a proof-of-concept that demonstrates actual data extraction or script execution. ## A06: Insecure Design **The risk:** Fundamental design flaws that cannot be fixed by implementation alone - missing security controls at the architecture level. **Scanner approach:** Traditional scanners have very limited ability to detect design flaws. They test implementations, not architectures. **Agentic approach:** Paladin's Business Logic Agent specifically targets design-level flaws: race conditions in payment flows, workflow bypass (skipping required steps), price manipulation, and insufficient rate limiting on sensitive operations. This is one of the areas where agentic pentesting most dramatically exceeds scanning - an AI agent can reason about how an application should work and test whether that logic can be subverted. ## A07: Identification and Authentication Failures **The risk:** Weaknesses in authentication mechanisms: weak passwords, credential stuffing, missing MFA, session fixation. **Scanner approach:** Scanners test for default credentials, check password policy enforcement, and detect missing security headers. **Agentic approach:** Paladin's Auth/Access Agent conducts thorough authentication testing: credential stuffing with common password lists, password reset flow analysis (IDOR in reset tokens, email enumeration), session management testing (session fixation, session ID randomness), JWT validation bypass attempts (algorithm confusion, signature stripping), and OAuth misconfiguration testing. It chains findings - if it discovers an email enumeration vulnerability, it combines that with any weak password policy findings to demonstrate a complete account takeover path. ## A08: Software and Data Integrity Failures **The risk:** Code and infrastructure that does not protect against integrity violations - insecure CI/CD pipelines, auto-update without verification, deserialization vulnerabilities. **Scanner approach:** Limited scanner coverage. Some tools detect insecure deserialization in specific frameworks. **Agentic approach:** Paladin's Code Agent (when source code is available) checks for insecure deserialization patterns, missing subresource integrity on CDN-loaded scripts, and unsigned software update mechanisms. The Supply Chain Agent evaluates dependency integrity - whether lockfiles are present, whether dependencies could be typosquatted. ## A09: Security Logging and Monitoring Failures **The risk:** Insufficient logging, unclear logs, inability to detect active attacks. **Scanner approach:** Scanners generally do not test logging and monitoring. This is traditionally a manual review item. **Agentic approach:** While Paladin cannot directly inspect server-side logging, it can test whether security-relevant events trigger observable responses: Do failed login attempts cause lockout? Do suspicious requests trigger rate limiting? Do obviously malicious payloads get blocked by WAF? The absence of these defensive responses indicates monitoring gaps. ## A10: Mishandling of Exceptional Conditions **The risk:** The application handles errors and unexpected conditions improperly - fail-open logic that grants access when a check errors, verbose error messages that leak internal details, unhandled exceptions that expose stack traces, and inconsistent error handling that reveals system behavior. This is a new category in the 2025 Top 10. **Scanner approach:** Scanners flag verbose error pages and stack traces but cannot reason about whether logic fails open or fails closed. **Agentic approach:** Paladin's agents deliberately send malformed, boundary, and unexpected inputs to observe how the application behaves under exceptional conditions - whether errors fail open (granting access or skipping validation on failure), leak stack traces or internal file paths, or produce differences that aid enumeration. The Business Logic Agent evaluates whether error-handling paths can be abused to bypass controls, and correlates them with access-control findings for chained impact. ## The Agentic Advantage Across all OWASP categories, the agentic approach offers three consistent advantages over traditional scanning: 1. **Validation** - Findings are confirmed with actual exploit attempts, not just pattern matching 2. **Context** - Agents reason about how findings combine and what they mean for the specific application 3. **Depth** - Specialist agents go far deeper on their domain than a generalist scanner ever could