Ataque ao banco de dados do controlador de domínio (NTDS.DIT)

Assim, conforme prometido, iniciamos o processo de análise das etapas separadas da Cyber Kill Chain do ataque descrito anteriormente. Hoje, vamos revisar um dos vetores de ataque na infraestrutura da Empresa, que podemos contar como duas etapas: «Ações sobre Objetivos» e «Reconhecimento». Nossos objetivos são:

• Estabelecer uma posição utilizando contas obtidas;
• Obter o máximo de informações sobre a Empresa (e-mail, nomes de departamentos, números de telefone, títulos funcionais, etc.) para futuros ataques ou até mesmo vender acesso à sua infraestrutura.

SYSTEM e NTDS.DIT

Os adversários, uma vez na rede corporativa, vão se intrometer em uma das partes “mais saborosas” das informações do ActiveDirectory, que são os arquivos SYSTEM e NTDS.DIT. Esses arquivos são bancos de dados, que contêm todos os dados do ActiveDirectory. O NTDS.DIT contém informações sobre todos os usuários no domínio, incluindo hashes de senhas. O arquivo SYSTEM é necessário para descriptografar dados do NTDS.DIT.

Não descreverei métodos de recuperação de hashes neste artigo, porque já foram escritos muitos artigos sobre esse assunto. Vou me concentrar no método que mostra a vulnerabilidade da infraestrutura pela exposição de senhas (se hashes LM estiverem disponíveis), e na automação do processo de busca que o torna extremamente rápido.

Então, precisamos apenas de hashes LM e NTLM:Após receber os hashes, começamos com hash LM.

Sobre o hash LM

Algumas informações sobre o hash LM.

Ele é baseado no DES cifra de bloco e pode ser facilmente atacado para quebra de senha devido a duas vulnerabilidades em sua realização. Primeiro, senhas com mais de 7 caracteres são divididas em duas partes e cada parte é hash separadamente, permitindo atacar cada parte separadamente. Em segundo lugar, todos os caracteres minúsculos são convertidos para maiúsculos.

Então, temos:

Hash LM, que, como mencionamos antes, possui duas partes.9196B21FEF3C8906AAD3B435B51404EE

AAD3B435B51404EE – este hash é de uma senha vazia (tal sequência de números significa que metade do hash é uma senha vazia).

Concluímos que a senha é composta por menos de sete caracteres, porque a segunda parte do hash corresponde ao conjunto de caracteres vazios.

Agora para força bruta na primeira parte.

Para esse fim, usamos hashcat, que permite forte força bruta paralelizada por GPU. Usando as seguintes chaves:

Recebemos a senha em 24 segundos.Agora é a vez do NTLM1BC10704ED604747D7D827FC7A43D555É muito mais fácil fazer força bruta nele, porque sabemos as seguintes informações:

1. Quais caracteres são usados na senha;
2. Ordem desses caracteres.

Só precisamos verificar se um caractere é maiúsculo ou minúsculo.

Assim, porque temos um hash LM, todo o trabalho nos levou pouco mais de 32 segundos.

Vamos complicar ainda mais a tarefa:

Suponha que temos uma senha de 14 caracteres com o terceiro nível de dificuldade (senha corporativa clássica):29355BC0D45C341B51ACD8D3923F7C21Usamos o mesmo truque:A força bruta nos deu a primeira aproximação (senha em caracteres maiúsculos) em 31 segundos.29355BC0D45C341B51ACD8D3923F7C21

Agora tudo o que precisamos fazer é

NTLM:E06E777CD11F495E9B9098B5576A4343

Aumentar a complexidade da senha até 14 caracteres não dificulta nossa tarefa – se tivermos o hash LM, a quebra leva apenas 40 segundos!Processamos um hash. Se precisássemos processar uma grande quantidade de hashes, construir máscaras para cada senha seria muito trabalhoso. É por isso que desenvolvi uma ferramenta que faria o próximo trabalho para nós – ntlm_mask_gen.exe  (você pode baixá-lo aqui aqui, MD5: c2a9dac79c51e14c84f35febd72d05ba ou pegar o código em Python no Anexo 1) :

1. Forma listas de palavras para cada senha individual;
2. Forma máscara para cada senha individual incluindo listas de palavras formadas;
3. Forma um único arquivo com strings para cada hash separado, máscara e lista de palavras.

Tudo o que você precisa fazer então é executar este arquivo e assistir hashcat as senhas sendo quebradas em segundos.

Demonstração da metodologia descrita

Vamos realizar mais um experimento para demonstrar a técnica descrita:

Usaremos 10 senhas com 10 caracteres, quarto nível de dificuldade com as seguintes configurações (requisitos tradicionais para conta tecnológica/administrativa/sistema da política de senha corporativa):

1. Criamos um arquivo com hashes csv:
   

2. Então criamos um arquivo para quebrar cmd:

3. E agora recebemos os resultados (divididos em duas partes):

4. Então combinamos as senhas das duas metades usando a chave –show:
   test_lm_full.result:

5. Então criamos um arquivo para nossa ferramenta, que gerará listas de palavras e máscaras para nós. Pegamos o hash NTLM e a senha para invadir o LM, por exemplo test_ntlm_input.txt:
   

6. Executamos nossa ferramenta:
   Imediatamente recebemos um arquivo que está pronto para busca de senha por máscaras e listas de palavras automaticamente formadas:

   

7. Executamos este arquivo e obtemos nossas senhas em 14 segundos:

Isso é tudo.

Esclarecimento

Como você sabe, a partir da versão 2008, o armazenamento de hashes LM é desativado por padrão, mas no caso de migração a partir da versão 2003 (ou inferior), contas que não alteraram suas senhas após a migração permanecem com hash LM no banco de dados. Geralmente, estas são contas tecnológicas com senhas que não são alteradas por vários motivos, por exemplo, podem causar a falha de alguns serviços críticos, etc. Tais contas são uma ameaça séria porque suas senhas são frequentemente «Nunca Expiram», seu acesso não é monitorado e frequentemente possuem altos privilégios até acesso administrativo. Como resultado, usar tais contas para invasão será o mais discreto.

Conclusão

É extremamente importante abandonar os domínios baseados em 2003 ou inferior e usar versões mais novas. No caso de migração, você deve garantir que todas as contas tenham alterado suas senhas e não há hashes LM no banco de dados. E mais um conselho para administradores de domínios e especialistas em segurança da informação, vocês devem trabalhar de forma proativa e quebrar suas senhas pelo menos uma vez por trimestre! Vocês devem controlar o acesso ao AD, especialmente monitorando operações com arquivos SYSTEM e NTDS.DIT.

Espero que este artigo seja útil para especialistas em segurança da informação, que possam usar as técnicas descritas como argumentos ao se comunicar com especialistas em TI. Ou será útil para administradores com o propósito de compreender melhor os riscos relacionados a ataques ao ActiveDirectory.

Anexo 1

importar math

alfabeto = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'exceção = ' &%{}<>^|"'nome_do_arquivo = abrir('D:hashcatkd_input.new','r')main_len = len(nome_do_arquivo.lerlinhas())nome_do_arquivo.fechar()nome_do_arquivo = abrir('D:hashcatkd_input.new','r')nome_do_arquivo_out = abrir('D:hashcatkd_input.cmd','w')hashes = []senhas = []máscaras = [[] for i in intervalo(main_len)]dicionários = []contagem_conjuntos_carac = 0conj_carac = [[] for i in intervalo(main_len)]ind_main = 0
ch1 = []
ch2 = []
ch3 = []
ch4 = []conjuntos_carac = [ch1, ch2, ch3, ch4]


def novo_ini(letra_senha):
    for ind_0 in intervalo(4):conjuntos_carac[ind_0] = []
    retorno prever(letra_senha)


def prever(nova_senha):letra_senha = ''
    for let in nova_senha:
        if let in alfabeto and not (let in letra_senha):letra_senha += let
    retorno gerador_dict(letra_senha)


def gerador_dict(letra_senha):
    global contagem_conjuntos_carac

    dict_novo = ''tam_senha = len(letra_senha)
    if tam_senha < 4:
        for ind1 in intervalo(tam_senha):conjuntos_carac[ind1].acrescentar(letra_senha[ind1])conjuntos_carac[ind1].acrescentar(letra_senha[ind1].minúsculo())
    senão:preenchedor(letra_senha, espalhador(tam_senha))
    for ind2 in intervalo(4):
        if len(conjuntos_carac[ind2]) > 0:dict_novo += '-' + str(ind2+1) + ' ' + ''.juntar(conjuntos_carac[ind2]) + ' 'conj_carac[contagem_conjuntos_carac] = [conjuntos_carac[0], conjuntos_carac[1], conjuntos_carac[2], conjuntos_carac[3]]contagem_conjuntos_carac += 1
    retorno dict_novodef espalhador(num_letra):contador_espalhar = [0, 0, 0, 0]
    for ind3 in intervalo(4):contador_espalhar[ind3] = int(matemática.teto(num_letra/flutuante(4-ind3)))num_letra -= contador_espalhar[ind3]
    retorno contador_espalhardef preenchedor(letra_senha, letra_contador):cont_l = 0
    for ind_carac in intervalo(4):
        for ind_conj in intervalo(letra_contador[ind_carac]):conjuntos_carac[ind_carac].acrescentar(letra_senha[cont_l])conjuntos_carac[ind_carac].acrescentar(letra_senha[cont_l].minúsculo())cont_l += 1


def gerador_máscara(senha,indice_senha):nova_máscara = ''
    for let_senha in senha:
        if let_senha in alfabeto:
            for ind_array in intervalo(4):
                if let_senha in conj_carac[indice_senha][ind_array]:nova_máscara += '?'+str(ind_array+1)
        senão let_senha in exceção:nova_máscara += '?s'
        senão:nova_máscara += let_senha

    máscaras[indice_senha] = nova_máscara# ---------------------- Principal --------------------------------

for linha in nome_do_arquivo:hashes.acrescentar(linha[:32])senhas.acrescentar(linha[33:len(linha)-1])dicionários.acrescentar(novo_ini(senhas[ind_main]))ind_main += 1

for indice_senha in intervalo(len(senhas)):gerador_máscara(senhas[indice_senha],indice_senha)


for índice in intervalo(len(hashes)):texto = 'cudaHashcat64.exe -m 1000 -a 3 -o ntlm_tesult.hash ' + str(hashes[índice]) + ' ' + str(dicionários[índice]) + ' ' + str(máscaras[índice]) + 'n'nome_do_arquivo_out.escrever(texto)nome_do_arquivo.fechar()nome_do_arquivo_out.fechar()