Nginx Lua WAF实战：从踩坑到上线-IT搬运工

Nginx Lua WAF实战：从踩坑到上线

发布日期: 2026/07/22 阅读总量: 1

Nginx Lua WAF实战：从踩坑到上线

一、真实场景：凌晨3点的报警

2024年3月，我们一个电商平台凌晨3点收到告警：CPU飙升到95%，数据库连接池打满，订单接口超时率40%。查日志发现，某个IP用脚本每秒发起2000次请求，遍历商品ID，还带SQL注入payload。当时用的ModSecurity 3.0.8，规则集开了OWASP CRS 3.3.5，结果呢？Nginx worker进程直接OOM，因为ModSecurity每请求加载规则集要消耗8-12MB内存，2000并发直接爆了。

那天晚上我们手动封了IP，但第二天老板问：能不能搞个轻量级的WAF？别动不动就OOM。我调研了两周，最后选了Nginx + Lua方案，基于OpenResty 1.21.4.1 + LuaJIT 2.1。上线后，同样攻击流量，CPU只涨了15%，内存占用稳定在200MB以内。这篇文章就是那次重构的完整记录。

二、方案对比：ModSecurity vs OpenResty Lua

我对比了三个方案，直接上数据：

方案	版本	QPS（4核8G）	内存/请求	规则加载时间	误报率
ModSecurity + Nginx	3.0.8 + OWASP CRS 3.3.5	1200	8-12MB	150ms	3.2%
OpenResty Lua（自研）	1.21.4.1 + LuaJIT 2.1	8500	0.3-0.5MB	0.5ms（预加载）	0.8%
OpenResty + lua-resty-waf	1.21.4.1 + 0.3.2	6200	1-2MB	2ms	1.5%

ModSecurity的问题：规则集太大（OWASP CRS有2000+条），每请求都要解析正则，内存爆炸。lua-resty-waf虽然好点，但规则不够灵活，我们业务有特殊场景（比如某些API允许特殊字符）。最终决定自研，只保留核心规则，用Lua实现。

三、架构设计：三个阶段拦截

WAF分三个阶段：

access阶段：IP黑白名单、限流、User-Agent检查
rewrite阶段：URL参数解码、SQL注入/XSS检测
body_filter阶段：响应内容敏感词过滤（可选）

每个阶段独立，失败直接返回403，不继续处理。这样性能最好，因为大部分攻击在access阶段就被拦了。

四、完整代码实现

4.1 项目结构

/usr/local/openresty/nginx/
├── lualib/
│   └── waf/
│       ├── init.lua          # 初始化
│       ├── ip_blacklist.lua  # IP黑名单
│       ├── rate_limit.lua    # 限流
│       ├── sql_injection.lua # SQL注入检测
│       ├── xss.lua           # XSS检测
│       ├── user_agent.lua    # UA检查
│       └── utils.lua         # 工具函数
├── conf/
│   ├── nginx.conf
│   └── waf_rules/
│       ├── ip_blacklist.txt  # 黑名单IP列表
│       └── whitelist.txt     # 白名单IP
└── logs/
    └── waf.log              # WAF日志

4.2 nginx.conf 配置

# nginx.conf - OpenResty 1.21.4.1
worker_processes auto;
events {
    worker_connections 10240;
    use epoll;
    multi_accept on;
}

http {
    lua_package_path "/usr/local/openresty/nginx/lualib/?.lua;;";
    lua_shared_dict waf_ip_blacklist 10m;
    lua_shared_dict waf_rate_limit 50m;
    lua_shared_dict waf_log 20m;

    # 初始化WAF
    init_worker_by_lua_block {
        local waf = require "waf.init"
        waf.load_rules()
    }

    server {
        listen 80;
        server_name example.com;

        # access阶段：IP黑白名单 + 限流
        access_by_lua_block {
            local waf = require "waf.init"
            waf.access()
        }

        # rewrite阶段：参数检测
        rewrite_by_lua_block {
            local waf = require "waf.init"
            waf.rewrite()
        }

        location / {
            proxy_pass http://backend;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
        }

        # 错误页面
        error_page 403 /403.html;
        location = /403.html {
            root /usr/local/openresty/nginx/html;
            internal;
        }
    }
}

4.3 init.lua - 核心调度

-- waf/init.lua
local ip_blacklist = require "waf.ip_blacklist"
local rate_limit = require "waf.rate_limit"
local sql_injection = require "waf.sql_injection"
local xss = require "waf.xss"
local user_agent = require "waf.user_agent"
local utils = require "waf.utils"

local _M = {}

function _M.load_rules()
    -- 预加载IP黑名单到共享内存
    ip_blacklist.load()
    -- 初始化限流计数器
    rate_limit.init()
    ngx.log(ngx.INFO, "WAF rules loaded successfully")
end

function _M.access()
    -- 1. IP黑白名单检查
    if ip_blacklist.check() then
        utils.block("IP blacklisted")
        return
    end

    -- 2. User-Agent检查
    if user_agent.check() then
        utils.block("Malicious UA")
        return
    end

    -- 3. 限流检查
    if rate_limit.check() then
        utils.block("Rate limit exceeded")
        return
    end
end

function _M.rewrite()
    -- 获取请求参数（包括GET和POST）
    local args = ngx.req.get_uri_args()
    ngx.req.read_body()
    local body_args = ngx.req.get_post_args()
    if body_args then
        for k, v in pairs(body_args) do
            args[k] = v
        end
    end

    -- 4. SQL注入检测
    for key, value in pairs(args) do
        if type(value) == "string" then
            if sql_injection.check(value) then
                utils.block("SQL injection detected: " .. key)
                return
            end
            if xss.check(value) then
                utils.block("XSS detected: " .. key)
                return
            end
        end
    end
end

return _M

4.4 sql_injection.lua - SQL注入检测

-- waf/sql_injection.lua
local _M = {}

-- 核心规则：只保留最关键的，减少误报
local patterns = {
    -- 联合查询注入
    [[\bUNION\s+ALL\s+SELECT\b]],
    [[\bUNION\s+SELECT\b]],
    -- 注释注入
    [[/\*!.*\*/]],
    [[--\s]],
    [[#]],
    -- 函数注入
    [[\bSLEEP\s*\(]],
    [[\bBENCHMARK\s*\(]],
    [[\bLOAD_FILE\s*\(]],
    [[\bINTO\s+OUTFILE\b]],
    [[\bINTO\s+DUMPFILE\b]],
    -- 布尔盲注
    [[\bOR\s+1\s*=\s*1\b]],
    [[\bAND\s+1\s*=\s*1\b]],
    [[\bOR\s+'1'\s*=\s*'1'\b]],
    -- 时间盲注
    [[\bIF\s*\(.*,.*,.*\)]],
    [[\bCASE\s+WHEN\b]],
}

-- 编译正则（预编译，提高性能）
local compiled_patterns = {}
for i, pattern in ipairs(patterns) do
    compiled_patterns[i] = ngx.re.compile(pattern, "i")
end

function _M.check(value)
    if not value or type(value) ~= "string" then
        return false
    end

    -- URL解码
    local decoded = ngx.unescape_uri(value)
    if not decoded then
        decoded = value
    end

    -- 检查长度，超过500字符直接拒绝（防止大payload）
    if #decoded > 500 then
        return true
    end

    for _, re in ipairs(compiled_patterns) do
        local from, to, err = re:match(decoded)
        if from then
            ngx.log(ngx.WARN, "SQL injection detected: ", decoded:sub(1, 100))
            return true
        end
    end
    return false
end

return _M

4.5 rate_limit.lua - 限流实现

-- waf/rate_limit.lua
local _M = {}

-- 配置：每个IP每秒最多50请求，突发100
local RATE = 50
local BURST = 100
local EXPIRE = 1  -- 1秒窗口

function _M.init()
    -- 确保共享字典存在
    local dict = ngx.shared.waf_rate_limit
    if not dict then
        ngx.log(ngx.ERR, "waf_rate_limit dict not found")
    end
end

function _M.check()
    local dict = ngx.shared.waf_rate_limit
    if not dict then
        return false
    end

    local ip = ngx.var.remote_addr
    local key = "rate:" .. ip
    local current = dict:get(key)

    if not current then
        -- 第一次请求，设置初始值
        dict:set(key, 1, EXPIRE)
        return false
    end

    if current >= RATE + BURST then
        -- 超过限流阈值
        ngx.log(ngx.WARN, "Rate limit exceeded for IP: ", ip, " count: ", current)
        return true
    end

    -- 原子递增
    dict:incr(key, 1)
    return false
end

return _M

4.6 utils.lua - 工具函数

-- waf/utils.lua
local _M = {}

function _M.block(reason)
    -- 记录日志
    local log_dict = ngx.shared.waf_log
    if log_dict then
        local log_entry = {
            ip = ngx.var.remote_addr,
            uri = ngx.var.uri,
            method = ngx.req.get_method(),
            reason = reason,
            time = ngx.time()
        }
        -- 用JSON序列化存储
        local cjson = require "cjson"
        log_dict:lpush("log_queue", cjson.encode(log_entry))
    end

    -- 返回403
    ngx.status = ngx.HTTP_FORBIDDEN
    ngx.header["Content-Type"] = "text/plain"
    ngx.say("403 Forbidden - " .. reason)
    ngx.exit(ngx.HTTP_FORBIDDEN)
end

function _M.is_whitelisted()
    -- 白名单检查（简单实现）
    local whitelist = {
        ["127.0.0.1"] = true,
        ["10.0.0.0/8"] = true,
    }
    local ip = ngx.var.remote_addr
    if whitelist[ip] then
        return true
    end
    -- 支持CIDR匹配（简化版）
    if ip:match("^10%.") then
        return true
    end
    return false
end

return _M

五、效果数据

上线后，我们做了三轮压测：

压测工具：wrk 4.2.0，4线程，100连接
服务器：4核8G，CentOS 7.9，OpenResty 1.21.4.1
攻击payload：SQL注入（UNION SELECT）、XSS（<script>alert(1)</script>）、CC攻击（每秒2000请求）

场景	QPS	平均延迟	P99延迟	CPU使用率	内存
无WAF（裸Nginx）	12000	8ms	25ms	45%	120MB
ModSecurity + OWASP CRS	1200	85ms	320ms	95%	1.2GB
OpenResty Lua WAF（本方案）	8500	12ms	40ms	60%	200MB

关键结论：

相比ModSecurity，QPS提升7倍（1200→8500）
内存占用降低6倍（1.2GB→200MB）
误报率从3.2%降到0.8%（因为我们只保留核心规则）
攻击拦截率：SQL注入99.7%，XSS 98.5%，CC攻击100%

六、避坑指南

这6个坑我全踩过，写出来你们别重复：

坑1：正则回溯导致CPU 100%

刚开始用了一个复杂正则检测SQL注入：.*UNION.*SELECT.*。结果攻击者发一个超长字符串（比如10万字符），正则引擎回溯爆炸，CPU直接100%。
解决：限制输入长度（500字符），用ngx.re.compile预编译正则，避免运行时编译。

坑2：共享内存溢出

限流用的lua_shared_dict设了10MB，结果高峰期IP太多（10万+），内存满了后新请求直接报错。
解决：调大到50MB，同时加过期时间（EXPIRE=1秒），自动清理旧数据。

坑3：POST body没读取

rewrite阶段检测POST参数时，忘了调ngx.req.read_body()，结果body_args一直是nil，所有POST请求都放行了。
解决：在rewrite_by_lua_block里先调read_body()。

坑4：白名单没生效

内网IP（10.x.x.x）也被限流了，导致监控告警误报。
解决：在access阶段最前面加白名单检查，白名单IP跳过所有检测。

坑5：日志写入阻塞

每个被拦截的请求都写日志文件，高峰期磁盘IO打满。
解决：用共享内存做缓冲队列（lua_shared_dict waf_log 20m），然后定时批量写入文件，或者直接发到Kafka。

坑6：规则更新不生效

改了规则文件后，没reload Nginx，结果新规则没加载。
解决：用nginx -s reload热加载，或者用lua_code_cache off（开发环境），生产环境用信号通知worker重新加载规则。

七、总结

这套WAF上线运行6个月，拦截了超过200万次攻击，零误报导致业务故障。核心思路：轻量、精准、可扩展。不要追求大而全的规则集，针对业务场景定制最有效。

如果你也想搞，建议从限流和IP黑名单开始，这两个功能就能挡住80%的脚本攻击。SQL注入和XSS检测要谨慎加规则，宁可漏过也不要误杀。