For a self-hosted WAF, the first results are bunkerity/bunkerized-nginx, chaitin/safeline (SafeLine is a containerized web application firewall and reverse proxy that inspects HTTP traffic, enforces rules, and provides rate limiting, access control, and bot mitigation — exactly the self-hosted WAF this search targets) and alexazhou/verynginx (VeryNginx is a Lua-based programmable web application firewall that extends Nginx, offering rule-based attack detection, rate limiting, a real-time traffic dashboard, and a management control panel—exactly the self-hosted WAF needed to analyze and block malicious HTTP/S traffic). owasp-modsecurity/modsecurity and nginx/nginx round out the shortlist. Compare the match explanations and check the project documentation against your requirements.
Open-source security tools for filtering and blocking malicious HTTP traffic to protect your web applications.
Bunkerized Nginx is a containerized security automation system that provides a secure reverse proxy and web application firewall. It focuses on protecting web applications by monitoring container labels within cloud-native orchestration systems to automatically update security settings and firewall rules. The system distinguishes itself through automated security operations, including the automatic management of SSL certificates and an automated client banning mechanism that blocks IP addresses based on HTTP status codes. It features bot challenge mechanisms using CAPTCHAs, JavaScript, or coo
Bunkerized Nginx is a containerized web application firewall and reverse proxy that automatically protects web applications with rule-based blocking, rate limiting, TLS/SSL termination, and real-time logging and alerting, making it a full-featured self-hosted WAF fitting this search.
SafeLine is a containerized web application firewall and reverse proxy designed to secure web services by inspecting incoming HTTP traffic. It acts as a security gateway that sits in front of backend infrastructure to filter malicious requests and enforce access policies before they reach the application server. The platform distinguishes itself through advanced bot mitigation and content protection capabilities. It employs challenge-response mechanisms to verify human users and dynamically obfuscates HTML and JavaScript content to prevent unauthorized scraping and code tampering. These featu
SafeLine is a containerized web application firewall and reverse proxy that inspects HTTP traffic, enforces rules, and provides rate limiting, access control, and bot mitigation — exactly the self-hosted WAF this search targets.
VeryNginx is a Lua-based Nginx extension and programmable web application firewall. It provides a management control panel and a traffic monitoring dashboard to configure server settings and analyze request statistics without manual configuration file edits. The project implements a programmable security layer to filter malicious traffic and block common web attacks, such as SQL injection and directory traversal. It includes tools for bot traffic restriction through request rate limiting and browser identity verification. The system covers traffic management via URI routing and redirection,
VeryNginx is a Lua-based programmable web application firewall that extends Nginx, offering rule-based attack detection, rate limiting, a real-time traffic dashboard, and a management control panel—exactly the self-hosted WAF needed to analyze and block malicious HTTP/S traffic.
ModSecurity is an open-source web application firewall and security engine. It functions as an HTTP traffic inspector and intrusion detection system that filters incoming web requests and responses against a set of security rules to block threats and prevent attacks on web servers. The project provides a modular framework for implementing restrictive security policies and custom filtering logic. It identifies and blocks common injection attacks, such as cross-site scripting and SQL injection, while hardening web applications to reduce their overall attack surface. Its broader capabilities in
ModSecurity is a widely-used open-source web application firewall that inspects HTTP traffic against security rules to block attacks, directly matching the core need for self-hosted WAF protection, though you may need to pair it with additional tools for built-in rate limiting.
Nginx is a high-performance HTTP server and reverse proxy designed to handle high-concurrency traffic through an efficient, event-driven architecture. It functions as a versatile traffic management gateway and content delivery accelerator, providing the infrastructure necessary to route client requests, balance loads across backend servers, and serve static assets with minimal resource consumption. The project distinguishes itself through a master-worker process model that separates configuration management from request processing, ensuring stable operations under heavy load. Its modular requ
Nginx is a reverse proxy and web server with rate limiting and TLS support, but it does not itself analyze or block malicious HTTP traffic, so it is not a self-hosted web application firewall.
This project is a comprehensive network traffic orchestrator and server infrastructure manager designed to provide centralized control over secure tunneling, routing, and security policies. It functions as a web-based dashboard that enables administrators to deploy and maintain network services, enforce access restrictions, and manage traffic flow through a private server environment. The platform distinguishes itself by integrating advanced traffic anonymization and routing capabilities, including support for relay networks and secure tunnels to bypass regional restrictions. It provides gran
3x-UI is a web-based dashboard for managing proxy protocols and VPN tunnels, not a web application firewall — it lacks rule-based HTTP/S attack detection and reverse proxy mode needed for WAF functionality.
Echo is a high-performance, lightweight web framework for Go designed for building scalable RESTful APIs and web services. It provides a centralized environment for mapping network requests to handler functions, utilizing a fast radix-tree routing engine to ensure efficient request dispatching. The framework is built around a modular, middleware-centric pipeline that allows developers to execute reusable logic for cross-cutting concerns like authentication, logging, and security across the entire application. What distinguishes Echo is its focus on developer productivity through structured da
Echo is a high-performance Go web framework with middleware for security headers, rate limiting, and logging, but it is not a self-hosted web application firewall—it does not analyze or block malicious traffic with a dedicated rule engine or act as a reverse proxy.
This project is a Kubernetes Ingress Controller that functions as a layer 7 traffic router and NGINX reverse proxy. It serves as a secure network gateway, directing external HTTP and HTTPS traffic to backend services within a cluster based on declarative routing rules. The controller acts as a TLS termination gateway to secure traffic and integrates with Prometheus to expose request metrics and latency data for cluster monitoring. It supports canary deployment workflows by implementing weight-based traffic splitting between different versions of a service. The system manages external access
Kubernetes ingress-nginx is a layer 7 reverse proxy and traffic router for Kubernetes, not a standalone web application firewall — it lacks built-in rule-based attack detection and a dedicated WAF rules engine, though it could potentially integrate with one when extended.
CrowdSec is a collaborative, distributed security engine designed for threat detection and infrastructure protection. It functions as an intrusion detection system that parses logs and network traffic to identify malicious patterns, utilizing a bucket-based threshold detection model to aggregate events and trigger alerts. The platform is built on a modular architecture that includes a centralized local API server for managing security signals and a relational database for persistent storage of remediation decisions. What distinguishes the project is its decoupled enforcement model, which offl
CrowdSec is a collaborative security engine that parses logs and network traffic for threat detection and can be configured to block malicious requests via bouncers, but its core identity is an intrusion detection/prevention system rather than a dedicated web application firewall.
Pingora is a Rust-based framework for building high-performance network services, including HTTP reverse proxies, layer seven load balancers, and TLS termination proxies. It serves as an asynchronous network library designed to intercept and route HTTP, gRPC, and WebSocket traffic between clients and upstream backend servers. The project enables zero-downtime service updates by handing over listening sockets between processes during binary or configuration upgrades. It utilizes a programmable multi-phase pipeline to modify request and response bodies and headers, and it provides a pluggable T
Pingora is a Rust framework for building high‑performance reverse proxies and load balancers, but it does not provide the rule‑based attack detection or web application firewall logic needed to analyze and block malicious traffic out of the box.
HAProxy is a high-performance TCP and HTTP proxy that distributes traffic across multiple backend servers to ensure availability and fault tolerance for critical services. It operates in either TCP or HTTP mode, with an event-driven, single-threaded reactor that handles tens of thousands of connections without context switching, and supports kernel-level data transfer to minimize memory usage and latency. What distinguishes HAProxy is its configuration-file-first design, where all load-balancing rules and runtime behavior are defined in a declarative text file parsed at startup. It embeds a L
HAProxy is a high-performance reverse proxy and load balancer with capabilities like rate limiting and TLS termination, but it lacks built-in rule-based attack detection for web application traffic, so it is not a full web application firewall on its own.
The NGINX Ingress Controller is a Kubernetes-native traffic manager that handles external requests and routes them to internal services. It translates Kubernetes API objects and annotations into proxy configurations to manage incoming HTTP, TCP, and UDP traffic. The controller distinguishes itself through advanced traffic steering and security integration. It supports blue-green and canary traffic splitting, as well as content-based and regex path routing. Security is handled at the edge via a web application firewall, denial-of-service protection, and a variety of authentication methods incl
This is an NGINX Ingress Controller for Kubernetes, not a standalone web application firewall—while it bundles WAF and rate-limiting features, its primary identity is traffic routing and load balancing, not a dedicated self-hosted WAF that you would run independently of Kubernetes.
| Repository | Stars | Language | License | Last push |
|---|---|---|---|---|
| bunkerity/bunkerized-nginx | 10.6K | Python | AGPL-3.0 | |
| chaitin/safeline | 21.5K | Go | GPL-3.0 | |
| 6K |
| Lua |
| LGPL-3.0 |
| owasp-modsecurity/modsecurity | 9.7K | C++ | Apache-2.0 |
| nginx/nginx | 30.9K | C | BSD-2-Clause |
| mhsanaei/3x-ui | 40.8K | Go | GPL-3.0 |
| labstack/echo | 32.5K | Go | MIT |
| kubernetes/ingress-nginx | 19.5K | Go | Apache-2.0 |
| crowdsecurity/crowdsec | 12.6K | Go | mit |
| cloudflare/pingora | 26.8K | Rust | Apache-2.0 |