OWASP Top 10 and WAF: Which Risks Does It Close, and Which Does It Leave Open?
Nanda Teknoloji Engineering Team · · 8 min read
In brief
A WAF substantially reduces signature-detectable risks in the OWASP Top 10, such as injection and exploitation of known components, but it cannot close broken access control, insecure design, or business logic flaws. Those risks must be addressed with code, design, and process controls.
The OWASP Top 10 is a community-built awareness document that ranks the most critical security risk categories for web applications and is updated at regular intervals. A WAF (Web Application Firewall) does not close the risks on this list equally. It is strong against attacks that can be recognized by signature, such as injection, XSS, and exploitation of known components. It has little or no effect on broken access control, insecure design, and business logic flaws. The reason is that the first group is visible in the content of the request, while the second hides in what the request means in the application’s context. This article sorts the list’s categories by WAF effectiveness and shows which controls you need to close the gaps.
Note: The category names below follow the 2021 edition of the OWASP Top 10. The list is updated over time, so check the project page for the current edition. The logic holds across editions: the distinction between signature-detectable risks and context-dependent risks.
Why is the “WAF solves OWASP” misconception so common?
WAF vendors’ rule sets often reference OWASP categories. That does not mean the WAF closes the whole list; it only means the rule set includes signatures related to some categories. When the security team or management concludes “we bought a WAF, the Top 10 is done,” the riskiest categories are left out of scope. It helps to first review how a WAF works in our article What is a WAF.
Category-by-category assessment
| OWASP category (2021) | WAF effect | Why |
|---|---|---|
| A01 Broken access control | Weak | The request is syntactically legitimate; the authorization logic lives in the application |
| A02 Cryptographic failures | Partial | TLS settings can be checked, but storage and key management are out of scope |
| A03 Injection (including SQL, command, XSS) | Strong | Patterns can be signed, but because of evasion techniques it should not be the only defense |
| A04 Insecure design | None | This is an architecture and process problem |
| A05 Security misconfiguration | Partial | Some information-leaking responses and directory access are blocked; server settings are out of scope |
| A06 Vulnerable and outdated components | Medium | Provides virtual patching for known vulnerabilities; the permanent fix is updating |
| A07 Authentication failures | Partial | Password-guessing attacks are reduced by rate limiting and bot management; weak session design is out of scope |
| A08 Software and data integrity failures | Weak | The supply chain and build pipeline are invisible in network traffic |
| A09 Logging and monitoring failures | Contributes | WAF logs strengthen monitoring but do not replace application logs |
| A10 Server-side request forgery (SSRF) | Partial | Some patterns are caught; egress traffic control is the real solution |
Where a WAF is strong: injection
SQL injection and XSS attempts contain recognizable character sequences and structural anomalies. When a WAF normalizes these inputs and compares them against rules, it cuts off most of them early. Two caveats still apply. First, evasion techniques such as encoding and fragmentation challenge every signature-based solution. Second, the real fix must be made in the application: parameterized queries, output encoding, and input validation. A WAF is not an excuse to postpone these fixes; it is an extra layer that buys time.
Where a WAF partly helps: components and authentication
When a vulnerability is announced in a library, updating the application requires a testing and release process. In the meantime, adding a temporary rule to the WAF that targets that vulnerability reduces risk. Similarly, credential stuffing attacks against the login page are slowed down with rate limiting and bot challenges. Still, multi-factor authentication, password policy, and session management remain on the application side.
Where a WAF is blind: access control and design
Imagine a user viewing an address record: GET /api/adresler/1042. If the user changes the number to 1043 and the application does not check ownership, they see someone else’s data. From the WAF’s perspective, both requests are identical: valid path, valid method, valid session. No signature can declare this “bad.” This class is solved with code review, authorization testing, and ownership verification on every request.
Controls that close the gaps a WAF leaves
- Secure development lifecycle. Threat modeling at the design stage, code review, and static/dynamic analysis.
- Authorization checks on every request. Object ownership and role checks must be performed server-side; identifiers coming from the client must not be trusted.
- Dependency management. An inventory of the libraries in use and an update process; a patch calendar for vulnerabilities.
- Strict configuration. Shutting down unnecessary services, removing default accounts, and not revealing details in error messages.
- Egress traffic control. Limiting the destinations a server can reach to reduce SSRF risk.
- Logging and alerting. Application logs for failed logins, authorization violations, and abnormal access patterns.
- Regular penetration testing. Test behind the WAF as well; scenarios both with and without the WAF should be tried.
How do you evaluate a WAF rule set?
Before asking how well a WAF covers the OWASP categories, decide on a method to verify that coverage.
- Ask for a coverage matrix. Which rule groups exist for which categories, which are enabled by default, and which require tuning?
- Test with your own application. Run controlled attack attempts against known vulnerable test applications and your own staging environment.
- Try evasion scenarios. Observe how signatures behave with encoding, fragmentation, and upper/lower case variations.
- Look at the false positive rate. An overly strict rule set breaks workflows; the criterion is balance, not just detection.
- Ask about update frequency. How long does it take for a rule update to arrive for new vulnerabilities, and does it require your approval?
Keep the results in a table: category, WAF coverage, additional control, responsible team. This table can be reused both in security audits and in architecture decisions.
Sharing responsibility between developers and the security team
Leaving WAF operations solely to the network or security team creates a common divide: the security team says “it’s blocked at the WAF,” and the developer concludes “that’s not our problem.” The healthy model looks like this. The development team owns the permanent fix in the application for every finding. The security team manages WAF rules and incident monitoring, and feeds recurring attack patterns detected at the WAF back to the developers. In a shared findings list, “temporary WAF mitigation” and “permanent code fix” are tracked as separate fields for each record. That way virtual patches are not forgotten, and WAF rule clutter does not grow over time.
Scenario: The WAF is on, but data is leaking
An organization’s customer portal sits behind a WAF, and injection attempts are regularly blocked in the logs. The team feels safe. In a penetration test, however, the tester shows that by changing the number in the invoice endpoint they can access other customers’ invoices. None of the WAF’s rules fired, because the requests look completely normal. The fix is to add an ownership filter based on the customer ID in the session to the invoice query and to write automated authorization tests for all endpoints. The WAF’s value has not diminished, but its area of responsibility is now clear.
Common mistakes
- Using the WAF to tick a compliance box. A rule set mentioning OWASP by name is not proof of coverage.
- Testing only the WAF. The application itself must also be tested without the WAF; you need to know what happens when the WAF is disabled or bypassed.
- Solving false positives by turning off the rule. Instead of defining a narrow exception, the protection is switched off wholesale.
- Mistaking a virtual patch for a permanent fix. A temporary rule is a bridge until the real update is made.
- Forgetting LLM and API risks. AI-powered applications carry an additional set of risks; the OWASP Top 10 for LLM Applications is a separate resource on this topic.
Decision summary
| Risk type | Primary control | The WAF’s role |
|---|---|---|
| Signature-detectable attacks (injection, XSS) | Secure coding | Second line of defense |
| Known component vulnerabilities | Updates and patching | Temporary virtual patch |
| Password guessing and bot traffic | MFA, account lockout | Rate limiting, bot challenge |
| Access control and business logic | Design, authorization testing | Limited contribution |
| Configuration and supply chain | Hardening, process | Indirect |
In short: position the WAF as “a filter for known bad requests coming from outside,” and do not substitute it for secure software development.
Moving forward with Nanda Teknoloji
On projects like this, Nanda Teknoloji carries out the discovery, design, migration, and operations steps: mapping the application surface, tuning WAF rules to the application, and transparently documenting which risk categories the rule coverage closes. You can find how WAF and volumetric attack protection are designed together on the WAF and DDoS protection page.