Puedes descargar el código fuente de PCRE desde el [sitio web de PCRE](http://www.pcre.org/). Consulta también esta [entrada de blog](https://www.cryptobells.com/building-openresty-with-pcre-jit/) para ver una guía paso a paso sobre cómo compilar OpenResty con una librería PCRE con JIT habilitado.

## Rendimiento

lua-resty-waf fue diseñado pensando en la eficiencia y la escalabilidad. Aprovecha el modelo de procesamiento asíncrono de Nginx y un diseño eficiente para procesar cada transacción lo más rápido posible. Las pruebas de carga han demostrado que los despliegues que implementan todos los conjuntos de reglas proporcionados, diseñados para imitar la lógica detrás del ModSecurity CRS, procesan transacciones en aproximadamente 300-500 microsegundos por petición; esto equivale al rendimiento anunciado por el [WAF de Cloudflare](https://www.cloudflare.com/waf). Las pruebas se ejecutaron sobre una pila de hardware razonable (CPU E3-1230, 32 GB de RAM, 2 x 840 EVO en RAID 0), alcanzando un máximo de aproximadamente 15,000 peticiones por segundo. Consulta [esta entrada de blog](http://www.cryptobells.com/freewaf-a-high-performance-scalable-open-web-firewall) para más información.

La carga de trabajo de lua-resty-waf está casi exclusivamente limitada por CPU. La huella de memoria en la máquina virtual de Lua (excluyendo el almacenamiento persistente respaldado por `lua-shared-dict`) es de aproximadamente 2 MB.

## Instalación

Se proporciona un sencillo Makefile:```
# make && sudo make install

lua-resty-waf hace uso del gestor de paquetes [OPM](https://github.com/openresty/opm), disponible en las distribuciones modernas de OpenResty. Las herramientas cliente de OPM requieren que la herramienta de línea de comandos `resty` esté disponible en la variable de entorno `PATH` de tu sistema.

Ten en cuenta que, por defecto, lua-resty-waf se ejecuta en modo SIMULATE, para evitar afectar inmediatamente a una aplicación; los usuarios que deseen habilitar las acciones de las reglas deben establecer explícitamente el modo operativo en ACTIVE.

## Sinopsis```lua
http {
    init_by_lua_block {
        -- use resty.core for performance improvement, see the status note above
        require "resty.core"

        -- require the base module
        local lua_resty_waf = require "resty.waf"

        -- perform some preloading and optimization
        lua_resty_waf.init()
    }

    server {
        location / {
            access_by_lua_block {
                local lua_resty_waf = require "resty.waf"

                local waf = lua_resty_waf:new()

                -- define options that will be inherited across all scopes
                waf:set_option("debug", true)
                waf:set_option("mode", "ACTIVE")

                -- this may be desirable for low-traffic or testing sites
                -- by default, event logs are not written until the buffer is full
                -- for testing, flush the log buffer every 5 seconds
                --
                -- this is only necessary when configuring a remote TCP/UDP
                -- socket server for event logs. otherwise, this is ignored
                waf:set_option("event_log_periodic_flush", 5)

                -- run the firewall
                waf:exec()
            }

            header_filter_by_lua_block {
                local lua_resty_waf = require "resty.waf"

                -- note that options set in previous handlers (in the same scope)
                -- do not need to be set again
                local waf = lua_resty_waf:new()

                waf:exec()
            }

            body_filter_by_lua_block {
                local lua_resty_waf = require "resty.waf"

                local waf = lua_resty_waf:new()

                waf:exec()
            }

            log_by_lua_block {
                local lua_resty_waf = require "resty.waf"

                local waf = lua_resty_waf:new()

                waf:exec()
            }
        }
    }
}

    -- this translates and calculates a ruleset called 'ruleset_name'
    local ok, errs = pcall(function()
        lua_resty_waf.load_secrules("/path/to/secrules/ruleset_name")
    end)

    -- errs is an array-like table
    if errs then
        for i = 1, #errs do
            ngx.log(ngx.ERR, errs[i])
        end
    end
}

server {
    location / {
        access_by_lua_block {
            local lua_resty_waf = require "resty.waf"

            local waf = lua_resty_waf:new()

            -- in order to use the loaded ruleset, it must be added via
            -- the 'add_ruleset' option
            waf:set_option("add_ruleset", "ruleset_name")
        }
    }
}

Además, `load_secrules` puede aceptar un segundo argumento opcional como una tabla de opciones para pasar a varias funciones de traducción. Se reconocen las siguientes opciones:

* *path*: Define una ruta del sistema de archivos para buscar archivos de datos para operadores como @pmFromFile. Si no se define dicha clave, se utiliza el directorio de trabajo actual (`.`)
* *force*: No mostrar error ni abortar al fallar la traducción de una variable de regla
* *loose*: No mostrar error ni abortar al fallar la traducción de una acción de regla
* *quiet*: No mostrar error ni advertencia al fallar la traducción de una acción de regla

Esta función también puede aceptar una tercera opción como tabla para capturar errores de traducción y procesarlos posteriormente. Si esta opción no está presente o no es una tabla, los errores de traducción se registrarán en el registro de errores.

### lua-resty-waf.init()

Realiza algún precálculo de reglas y conjuntos de reglas, basado en lo que se ha puesto a disposición mediante los conjuntos de reglas distribuidos por defecto. Se recomienda, aunque no es obligatorio, llamar a esta función (no hacerlo resultará en una pequeña penalización de rendimiento). Esta función nunca debe llamarse fuera de este ámbito.

*Ejemplo*:```lua
http {
    init_by_lua_block {
        local lua_resty_waf = require "resty.waf"

        lua_resty_waf.init()
    }
}

    local waf = lua_resty_waf:new()
}

### lua-resty-waf:set_option()

Configura una opción a nivel de ámbito.

*Ejemplo*:```lua
location / {
    access_by_lua_block {
        local lua_resty_waf = require "resty.waf"

        local waf = lua_resty_waf:new()

        -- enable debug logging only for this scope
        waf:set_option("debug", true)
    }
}

    local waf = lua_resty_waf:new()

    waf:set_var("FOO", "bar")
}

Tenga en cuenta que, como con cualquier otra regla de ModSecurity, la existencia de una variable no conlleva ningún cambio funcional en el procesamiento del WAF; es responsabilidad del autor de la regla comprender y utilizar las variables `TX`.

### lua-resty-waf:sieve_rule()

Define una exclusión de colección para una regla determinada.

*Ejemplo*:```lua
location / {
    access_by_lua_block {
        local lua_resty_waf = require "resty.waf"

        local waf = lua_resty_waf:new()

        local sieves = {
            {
                type   = "ARGS",
                elts   = "foo",
                action = "ignore",
            }
        }

        waf:sieve_rule("12345", sieves)
    }
}

    local waf = lua_resty_waf:new()

    -- execute according to access phase collections and rules
    waf:exec()
}

content_by_lua_block {
    local lua_resty_waf = require "waf"

    local waf = lua_resty_waf:new()

    -- execute header_filter rules, passing in a table of additional collections
    -- this assumes the 'request_headers' and 'status' Lua variables were
    -- declared and initialized elsewhere
    local opts = {
        phase = 'header_filter',
        collections = {
            REQUEST_HEADERS = request_headers,
            STATUS = status,
        }
    }

    waf:exec(opts)
}

### lua-resty-waf:write_log_events()

Escriba cualquier entrada de registro de auditoría generada por la transacción. Esto es solo opcional cuando se llama a `exec` en un manejador `log_by_lua`.

*Ejemplo*:```lua
location / {
    log_by_lua_block {
        local lua_resty_waf = require "resty.waf"

        local waf = lua_resty_waf:new()

        -- write out any event log entries to the
        -- configured target, if applicable
        waf:write_log_events()
    }
}

server {
    location / {
        access_by_lua_block {
            waf:set_option("add_ruleset", "50000_extra_rules")
        }
    }
}

Se pueden añadir múltiples rulesets pasando una tabla de valores a `set_option`. Tenga en cuenta que los nombres de los rulesets se ordenan antes del procesamiento. Los rulesets se procesan en orden de menor a mayor.

### add_ruleset_string

*Por defecto*: ninguno

Añade un ruleset adicional para usar durante el procesamiento. Esto permite a los usuarios implementar rulesets personalizados sin sobrescribir el directorio de rules incluido. Los rulesets se definen en línea como una cadena Lua, en forma de una estructura JSON de ruleset traducida.

*Ejemplo*:```lua
location / {
    access_by_lua_block {
        waf:set_option("add_ruleset_string", "70000_extra_rules", [=[{"access":[{"action":"DENY","id":73,"operator":"REGEX","opts":{},"pattern":"foo","vars":[{"parse":{"values":1},"type":"REQUEST_ARGS"}]}],"body_filter":[],"header_filter":[]}]=])
    }
}

### allowed_content_types

*Predeterminado*: ninguno

Define uno o más encabezados Content-Type que se permitirán, además de los Content-Type predeterminados `application/x-www-form-urlencoded` y `multipart/form-data`. Una solicitud cuyo tipo de contenido coincida con uno de `allowed_content_types` establecerá la colección `REQUEST_BODY` en una única cadena que contiene (en lugar de una tabla); una solicitud cuyo tipo de contenido no coincida con ninguno de estos valores, ni con `application/x-www-form-urlencoded` ni con `multipart/form-data`, será rechazada.

*Ejemplo*:```lua
location / {
    access_by_lua_block {
        -- define a single allowed Content-Type value
        waf:set_option("allowed_content_types", "text/xml")

        -- defines multiple allowed Content-Type values
        waf:set_option("allowed_content_types", { "text/html", "text/json", "application/json" })
    }
}

### debug_log_level

*Default*: ngx.INFO

Establece la constante de nivel de registro de nginx utilizada para el registro de depuración.

*Ejemplo*:```lua
location / {
    access_by_lua_block {
        waf:set_option("debug_log_level", ngx.DEBUG)
    }
}

### disable_pcre_optimization

*Valor predeterminado*: false

Elimina las banderas `oj` de todas las llamadas a `ngx.re.match`, `ngx.re.find` y `ngx.re.sub`. Esto puede ser útil en algunos casos en los que se utilizan bibliotecas PCRE antiguas, pero causará una degradación severa del rendimiento, por lo que su uso está fuertemente desaconsejado; en su lugar, se recomienda a los usuarios compilar OpenResty con una biblioteca PCRE moderna y compatible con JIT.

*Ejemplo*:```lua
location / {
    access_by_lua_block {
        waf:set_option("disable_pcre_optimization", true)
    }
}

Tenga en cuenta que `mode` no tendrá efecto en determinar si una transacción se considera alterada. Es decir, si se coincide con una regla con una acción `DENY`, pero lua-resty-waf se está ejecutando en modo `SIMULATE`, la transacción aún se considerará alterada y las coincidencias de reglas se registrarán.

### event_log_buffer_size

*Predeterminado*: 4096

Define el tamaño umbral, en bytes, del búfer que se utilizará para contener los registros de eventos. El búfer se vaciará cuando se alcance este umbral.

*Ejemplo*:```lua
location / {
    access_by_lua_block {
        -- 8 KB event log message buffer
        waf:set_option("event_log_buffer_size", 8192)
    }
}

### event_log_ngx_vars

*Predeterminado*: vacío

Define qué variables adicionales de `ngx.var` se incluyen en el evento de registro. Esta es una forma genérica de ampliar la alerta con contexto adicional. El nombre de la variable será la clave de la entrada bajo una clave `ngx` en la entrada de registro. Si la variable no está presente como variable de nginx, no se añade ningún elemento al evento.

*Ejemplo*:```lua
location / {
    access_by_lua_block {
        waf:set_option("event_log_ngx_vars", "host")
        waf:set_option("event_log_ngx_vars", "request_id")
    }
}

### event_log_periodic_flush

*Predeterminado*: ninguno

Define un intervalo, en segundos, en el que el búfer del registro de eventos se vaciará periódicamente. Si no se configura ningún valor, el búfer no se vaciará periódicamente y solo se vaciará cuando se alcance el umbral de `event_log_buffer_size`. Configure esta opción para sitios de tráfico muy bajo que puedan no recibir datos de registro de eventos durante un largo período de tiempo, para evitar que datos obsoletos permanezcan en el búfer.

*Ejemplo*:```lua
location / {
    access_by_lua_block {
        -- flush the event log buffer every 30 seconds
        waf:set_option("event_log_periodic_flush", 30)
    }
}

### event_log_request_body

*Predeterminado*: false

Cuando se establece en true, las entradas de registro contienen el cuerpo de la solicitud bajo la clave `request_body`.

*Ejemplo*:```lua
location / {
    access_by_lua_block {
        waf:set_option("event_log_request_body", true)
    }
}

El evento resultante tiene estos elementos adicionales:```json
{
"request_headers": {
    "accept": "*/*",
    "user-agent": "curl/7.22.0 (x86_64-pc-linux-gnu) libcurl/7.22.0 OpenSSL/1.0.1 zlib/1.2.3.4 libidn/1.23 librtmp/2.3"
}
}

### event_log_ssl_sni_host

*Por defecto*: none

Establece el host SNI para las conexiones de `lua-resty-logger-socket`.

*Ejemplo*:```lua
location / {
    access_by_lua_block {
        waf:set_option("event_log_ssl_sni_host", "loghost.example.com")
    }
}

### event_log_socket_proto

*Predeterminado*: udp

Define qué protocolo IP usar (TCP o UDP) al enviar registros de eventos a través de un socket remoto. Se utilizará la misma lógica de almacenamiento en búfer y vaciado recurrente independientemente del protocolo.

*Ejemplo*:```lua
location / {
    access_by_lua_block {
        -- send logs via TCP
        waf:set_option("event_log_socket_proto", "tcp")
    }
}

    -- send event logs to a local file on disk
    waf:set_option("event_log_target", "file")

    -- send event logs to a remote server
    waf:set_option("event_log_target", "socket")
}

Nota: debido a una limitación en la biblioteca de registro utilizada, solo se puede definir un único socket de destino. Es decir, solo puede configurar un destino `socket` con una combinación específica de host/puerto; si configura una segunda combinación host/puerto, los datos no se registrarán correctamente.

### event_log_target_host

*Predeterminado*: none

Define el servidor de destino para los registros de eventos que apuntan a un servidor remoto.

*Ejemplo*:```lua
location / {
    access_by_lua_block {
        waf:set_option("event_log_target_host", "10.10.10.10")
    }
}

Esta ruta debe estar en una ubicación escribible por el usuario de nginx. Tenga en cuenta que, por naturaleza, el registro en disco puede causar una degradación significativa del rendimiento en entornos de alta concurrencia.

### event_log_target_port

*Por defecto*: ninguno

Define el puerto de destino para los registros de eventos que se dirigen a un servidor remoto.

*Ejemplo*:```lua
location / {
    access_by_lua_block {
        waf:set_option("event_log_target_port", 9001)
    }
}

location / {
    access_by_lua_block {
        local deny_override = function(waf, ctx)
            ngx.log(ngx.INFO, "Overriding DENY action")
            ngx.status = 404
        end

        -- override the DENY action with the function defined above
        waf:set_option("hook_action", "DENY", deny_override)
    }
}

### ignore_rule

*Predeterminado*: ninguno

Indica al módulo que ignore un ID de regla específico. Ten en cuenta que ignorar una regla en una cadena provocará que se ignore toda la cadena, y el procesamiento continuará con la siguiente regla posterior a la cadena.

*Ejemplo*:```lua
location / {
    access_by_lua_block {
        waf:set_option("ignore_rule", 40294)
        waf:set_option("ignore_rule", {40002, 41036})
    }
}

### mode

*Por defecto*: SIMULATE

Establece el modo operativo del módulo. Las opciones son ACTIVE, INACTIVE y SIMULATE. En el modo ACTIVE, las coincidencias de reglas se registran y se ejecutan las acciones. En el modo SIMULATE, lua-resty-waf recorre cada regla habilitada y registra las coincidencias de reglas, pero no completa la acción especificada en una ejecución determinada. El modo INACTIVE evita que el módulo se ejecute.

Por defecto, se selecciona SIMULATE si no se establece un modo explícitamente; esto requiere que los nuevos usuarios implementen activamente el bloqueo estableciendo el modo en ACTIVE.

*Ejemplo*:```lua
location / {
    access_by_lua_block {
        waf:set_option("mode", "ACTIVE")
    }
}

### process_multipart_body

*Por defecto* true

Habilita el procesamiento de cuerpos de solicitud multipart/form-data (cuando estén presentes), utilizando el módulo `lua-resty-upload`. En el futuro, lua-resty-waf puede utilizar este procesamiento para realizar comprobaciones más estrictas de los cuerpos de subida; por ahora, este módulo realiza solo comprobaciones mínimas de cordura en el cuerpo de la solicitud y no registrará un evento si el cuerpo de la solicitud no es válido. Deshabilita esta opción si no necesitas esta comprobación, o si los errores en el módulo upstream están causando problemas con las subidas HTTP.

*Ejemplo*:```lua
location / {
    access_by_lua_block {
        -- disable processing of multipart/form-data requests
        -- note that the request body will still be sent to the upstream
        waf:set_option("process_multipart_body", false)
    }
}

### res_body_max_size

*Predeterminado*: 1048576 (1 MB)

Define el umbral de longitud de contenido a partir del cual los cuerpos de respuesta no se procesarán. Este tamaño del cuerpo de respuesta se determina mediante el encabezado de respuesta Content-Length. Si este encabezado no existe en la respuesta, el cuerpo de respuesta nunca se procesará.

*Ejemplo*:```lua
location / {
    access_by_lua_block {
        -- increase the max response size to 2 MB
        waf:set_option("res_body_max_size", 1024 * 1024 * 2)
    }
}

Se pueden añadir múltiples tipos MIME pasando una tabla de tipos a `set_option`.

### res_tid_header

*Por defecto*: false

Establece una cabecera HTTP `X-Lua-Resty-WAF-ID` en la respuesta descendente, con el valor como ID de transacción. Este ID se correlacionará con el ID de transacción presente en los registros de depuración (si está configurado). Esto puede ser útil para el seguimiento de solicitudes o con fines de depuración.

*Ejemplo*:```lua
location / {
    access_by_lua_block {
        waf:set_option("res_tid_header", true)
    }
}

### storage_backend

*Predeterminado*: dict

Define un motor para el almacenamiento persistente de variables. Las opciones disponibles actualmente son *dict* (zona de memoria compartida de ngx_lua), *memcached* y *redis*.

*Ejemplo*:```lua
location / {
    acccess_by_lua_block {
        waf:set_option("storage_backend", "memcached")
    }
}

### storage_keepalive_timeout

*Por defecto*: 10000

Configura (en milisegundos) el tiempo de espera para el pool de keepalive cosocket de los hosts remotos de almacenamiento persistente.

*Ejemplo*:```lua
location / {
    acccess_by_lua_block {
        waf:set_option("storage_keepalive_timeout", 30000)
    }
}

### storage_memcached_host

*Predeterminado*: 127.0.0.1

Define un host para usar cuando se utiliza memcached como motor de almacenamiento de variables persistentes.

*Ejemplo*:```lua
location / {
    acccess_by_lua_block {
        waf:set_option("storage_memcached_host", "10.10.10.10")
    }
}

### storage_redis_host

*Predeterminado*: 127.0.0.1

Define un host para usar cuando se use redis como motor de almacenamiento de variables persistente.

*Ejemplo*:```lua
location / {
    acccess_by_lua_block {
        waf:set_option("storage_redis_host", "10.10.10.10")
    }
}

### storage_zone

*Default*: none

Define el `lua_shared_dict` que se usará para mantener datos de almacenamiento persistente. Esta zona debe definirse en el bloque `http{}` de la configuración.

*Ejemplo*:_```lua
http {
    -- define a 64M shared memory zone to hold persistent storage data
    lua_shared_dict persistent_storage 64m;
}

location / {
    access_by_lua_block {
        waf:set_option("storage_zone", "persistent_storage")
    }
}