Hack este sitio!

[ Advertise With HackThisSite.org :: Hide These Ads ] [Anúnciate con HackThisSite.org:: Ocultar estos anuncios]

"A war is not won if the defeated enemy has not been turned into a friend." "Una guerra no se gana si el enemigo derrotado no se ha convertido en un amigo". -Erric Hoffer Hoffer-Erric

HTS costs up to $300 a month to operate. HTS gastos de hasta $ 300 al mes para funcionar. We need your help! Necesitamos tu ayuda!

Donors also receive special recognition on our donors page. Los donantes también recibirán un reconocimiento especial a nuestros donantes página.

FR DE ES IT PT FR DE ES IT PT

Link to us! Enlace con nosotros!

phoenix free shells Phoenix libre de los depósitos
hackergames.net hackergames.net
PullThePlug PullThePlug

Shellcode for Beginners Shellcode para principiantes
Published by: apples , on 2008-04-05 22:18:00 Publicado por: manzanas, sobre 2008-04-05 22:18:00
shellcode for beginners código shell para principiantes by apples por manzanas pre-requisites: Pre-requisitos: -basic x86 assembly knowledge x86-montaje básico de conocimientos -buffer overflow techniques (for implementation of the shellcode) -técnicas de desbordamiento de búfer (para la aplicación de la shell) -common sense -el sentido común okay, so you just found a buffer overflow in the latest application. bien, por lo que sólo encontró un desbordamiento de búfer en la última aplicación. you overwrite the EIP, and..suddenly you realize you need code to execute. que las anule la EIP, .. y de repente te das cuenta de que usted necesita para ejecutar código. AND, this code has to be small enough to work in your newfound vulnerability. Y, este código tiene que ser lo suficientemente pequeño como para trabajar en su nueva vulnerabilidad. so, what do you use? Entonces, ¿qué uso? shellcode, of course! código shell, por supuesto! shellcode can be very modular, meaning that it can be used in many different areas, shell puede ser muy modular, lo que significa que puede ser utilizado en muchas diferentes áreas, as long it meets some basic requirements, such as the architecture type and operating system. siempre que cumpla unos requisitos básicos, tales como el tipo de arquitectura y sistema operativo. shellcode is written in assembly, which means that while it's more difficult to create, código shell que está escrito en el montaje, lo que significa que, si bien es más difícil de crear, it's much smaller, due to the lack of abstraction. es mucho menor, debido a la falta de abstracción. so, let's get started, shall wee? así, vamos a empezar, se wee? our first shellcode will perform something very simple. nuestro primer código shell llevará a cabo algo muy simple. it will call the que se llame a la exit() syscall in linux. exit () syscall en linux. first, let's take a look at the syntax of the en primer lugar, echemos un vistazo a la sintaxis de la syscall itself. syscall sí mismo. CODE : CÓDIGO: `int sys_exit(int status)` `int sys_exit (int estado)` `-terminates the current process` `-termina el actual proceso` `-status is the return code` `el estatuto es el código de retorno` here's the code that i wrote to call exit(). aquí está el código que he escrito para llamar a la salida (). (this code is for use in NASM) (este código es para uso en NASM) CODE : CÓDIGO: `section .text` `sección. texto` `.global _start` `. mundial _start` `_start:` `_start:` `mov eax,1` `mov eax, 1` `mov ebx,0` `mov ebx, 0` `int 0x80` `int 0x80` this is equivalent to the following code in C: esto es equivalente a la siguiente código en C: CODE : CÓDIGO: `void main()` `void main ()` `{` `(` `exit(0);` `exit (0);` `}` `)` write those in your favorite text editor, then assemble it and link it. escribir en tu editor de texto favorito y, a continuación, reunirse y vincularlo. here's what i did. esto es lo que hice. CODE : CÓDIGO: `apples@apples-server:~$ nano exit.asm'` `@ manzanas manzanas-server: ~ $ nano exit.asm "` `apples@apples-server:~$ nasm -f elf exit.asm'` `@ manzanas manzanas-server: ~ $ NASM-f exit.asm elfo "` `apples@apples-server:~$ ld exit.o -o exit'` `@ manzanas manzanas-server: ~ $ ld-o exit.o salida '` once this completes, we want to grab the shellcode from the binary. Una vez que este concluya, queremos agarrar el código shell desde el binario. CODE : CÓDIGO: `'apples@apples-server:~$ objdump -d exit'` `'@ manzanas manzanas-server: ~ $ objdump-d salida'` this returned: este respondió: CODE : CÓDIGO: `exit: file format elf32-i386` `salida: formato de archivo elf32-i386` `Disassembly of section .text:` `Desmontaje de la sección. Texto:` `08048080 <_start>:` `08048080 <_start>:` `8048080: b8 01 00 00 00 mov $0x1,%eax` `8048080: B8 01 00 00 00 mov $ 0x1,% eax` `8048085: bb 00 00 00 00 mov $0x0,%ebx` `8048085: bb 00 00 00 00 mov $ 0x0,% ebx` `804808a: cd 80 int $0x80` `804808a: cd $ 80 int 0x80` finally, we start to see some results from our work! finalmente, empezamos a ver algunos resultados de nuestro trabajo! the shellcode is es el código shell "xb8x01x00x00x00xbbx00x00x00x00xcdx80" ! "xb8x01x00x00x00xbbx00x00x00x00xcdx80"! but, there's an pero, hay un obvious problem with this shellcode, and anyone who uses strings in C evidente problema con este código shell, y cualquier persona que utilice cadenas en C will see it instantly. verán al instante. strings cannot contain NULL bytes, because a NULL cadenas no pueden contener NULL bytes, porque una NULL byte is used to signify the end of the string. byte se utiliza para indicar el final de la cadena. which means, the lo que significa, la vulnerable program would stop reading after "xb8x01". vulnerables programa deje de leer después de "xb8x01". this is a very este es un muy bad thing indeed. mala cosa en realidad. let's try writing one again, with this knowledge. vamos a intentar escribir una vez más, con este conocimiento. first, we notice that 'mov eax, 1' generated 3 null bytes. en primer lugar, nos damos cuenta de que "mov eax, 1« nula generado 3 bytes. now, think ahora, creo about why this would happen. acerca de por qué esto suceda. eax is a 32-bit register, and we're only eax es uno de 32-bit registro, y estamos sólo changing 1 byte with our value of 1. cambio de 1 byte con valor de 1. think about it this way: pensar de esta manera: CODE : CÓDIGO: `eax: 00 00 00 00` `eax: 00 00 00 00` `1: 00 00 00 01` `1: 00 00 00 01` now you can see where the problem might arise. ahora puede ver el problema que pudiera surgir. on another note, the Por otra parte, la lower 16 bits of eax can be divided into two 8-bit registers, known as menor de 16 bits eax se puede dividir en dos de 8 bits registros, conocido como ah and al. ah y al. as you might be able to tell, ah is the high 8 bits, and al is como podría ser capaz de decir, ah es la 8 bits de alto, y es al the low 8 bits. la baja 8 bits. since 1 only takes up one byte, then we can simply move desde el 1 º de sólo ocupa un byte, entonces podemos simplemente mover it to al. a al. thus, "mov eax, 1" por lo tanto, "mov eax, 1" becomes "mov al, 1" se convierte en "mov al, 1" now, we still have the second command to worry about. ahora, todavía tenemos el segundo mando de qué preocuparse. how can we set ebx ¿cómo podemos establecer ebx to 0 without moving the value of 0 to it? a 0 sin mover el valor de 0 a ella? the answer lies within the la respuesta se encuentra dentro de la bitwise operator XOR. binaria operador XOR. here's a table on how it works: aquí está una tabla de cómo funciona: a \| b \| c a \| b \| c ----------------------------------- 0 \| 0 = 0 0 \| 0 = 0 1 \| 0 = 1 1 \| 0 = 1 0 \| 1 = 1 0 \| 1 = 1 1 \| 1 = 0 1 \| 1 = 0 when a and b are the same value, then it returns 0. cuando A y B son el mismo valor, entonces se devuelve 0. when they are cuando se different, it returns 1. diferentes, devuelve 1. now, think about how this can be applied to ahora, pensar en cómo esto puede ser aplicado a ebx. if you XOR ebx with itself, it will create 0, since ebx has the si ebx XOR consigo mismo, se creará 0, ya que tiene la ebx same value as ebx (duh?! :P) mismo valor que ebx (duh!: P) thus, "mov ebx, 0" por lo tanto, "mov ebx, 0" becomes "xor ebx, ebx" se convierte en "xor ebx, ebx" make the following changes to your shellcode, and re-assemble and link hacer los siguientes cambios a su código shell, y volver a ensamblar y enlazar it. ello. then run 'objdump -d exit' again, and this should be your shiny new a continuación, ejecute 'objdump salida-d' una vez más, y este debería ser su nuevo y brillante output: salida: CODE : CÓDIGO: `exit: file format elf32-i386` `salida: formato de archivo elf32-i386` `Disassembly of section .text:` `Desmontaje de la sección. Texto:` `08048080 <_start>:` `08048080 <_start>:` `8048080: b0 01 mov $0x1,%al` `8048080: b0 01 mov $ 0x1,% al` `8048082: 31 db xor %ebx,%ebx` `8048082: 31 db xor% ebx,% ebx` `8048084: cd 80 int $0x80` `8048084: cd $ 80 int 0x80` thus, our new shellcode is "xb0x01x31xdbxcdx80" ! por lo tanto, nuestro nuevo código shell es "xb0x01x31xdbxcdx80"! and, it's NULL y, es NULL free! libre! next, try using these techniques to create shellcode that spawns a A continuación, pruebe a utilizar estas técnicas para crear shell que genera una shell. depósito.
Cast your vote on this article Emitir su voto sobre este artículo Note: the order of the votes has been reversed. Nota: el orden de los votos se ha invertido.

Comments: Comentarios:
Published: 11 comments. Publicado: 11 comentarios.

Nines - 03:42 am Sunday April 06th, 2008 Nueves - 03:42 horas del domingo 06 de abril, 2008

The original was better cause it contained slashes :P Well done bud, good article. El original era mejor causa que contenía barras: P Bien hecho Botón, buen artículo.

Karec - 08:52 am Sunday April 06th, 2008 Karec - 08:52 horas del domingo 06 de abril, 2008

Good things: Cosas buenas:
1. I liked the truth table. Me gustó la tabla de verdad. (Digital Sytems class reference) (Digital Sytems clase de referencia)
2. The article flows very well information wise. El artículo muy bien las corrientes de información racional.

Bad Things: Cosas malas:
1. Lack of captialization or capitalisation (depending if you are US or European) at all in the article. La falta de capitalización o captialization (dependiendo de si usted es EE.UU. o Europa) a todos en el artículo.
2. Bad grammar as far as going comma happy. Mala gramática en la medida de lo que coma feliz.

7/10 7 / 10

KSEboom - 12:33 pm Sunday April 06th, 2008 KSEboom - 12:33 pm del domingo 06 de abril, 2008

Not bad! No está mal!

signsoft - 01:38 am Monday April 14th, 2008 signsoft - 01:38 horas Lunes 14 de abril, 2008

Nice article, simple and explaining. Niza artículo, simple y explicar. Really good job. Realmente buen trabajo.
I have one suggestion though: Tengo una sugerencia sin embargo:
MOV EAX,1 and MOV EAX, 1 y
MOV AL,1 aren't equal. MOV AL, 1 no son iguales.
MOV AL,1 only alters 8 lowest bits and leaves the upper 24 unchanged. MOV AL, 1 sólo altera 8 bits más baja y deja la parte superior de 24 sin cambios. Whatever was there will stay there and in effect you can end with something other than 1 in EAX. Sea cual estaba allí permanecerá allí y en efecto que puede terminar con algo distinto de 1 en EAX.
Placing XOR EAX,EAX in front of Colocar XOR EAX, EAX delante de
MOV AL,1 solves the problem. MOV AL, 1 resuelve el problema.

bitchasshoe - 05:22 pm Wednesday April 23rd, 2008 bitchasshoe - 05:22 pm Miércoles 23 de abril, 2008

nice, simple and straight to the point. agradable, sencillo y directo al punto.

sikes - 09:19 am Friday May 02nd, 2008 Sikes - 09:19 horas Viernes 02a mayo, 2008

Nice Agradable

VARUNmca123 - 04:51 am Monday May 12th, 2008 VARUNmca123 - 04:51 horas Lunes 12 de mayo, 2008

not very hard to understand! no es muy difícil de entender!

herotrojanz - 11:28 am Thursday June 05th, 2008 herotrojanz - 11:28 am Jueves 05 de junio, 2008

AmbivalentMercenary - 01:01 am Wednesday October 08th, 2008 AmbivalentMercenary - 01:01 horas Miércoles 08 de octubre, 2008

understood and gud job writing the article entendido y gud trabajo escrito el artículo

rohit_007 - 02:24 am Monday October 13th, 2008 rohit_007 - 02:24 horas Lunes 13 de octubre, 2008

abyss - 02:25 am Saturday November 01st, 2008 abismo - 02:25 horas Sábado 01a noviembre, 2008

WICKED! Impíos! Thanks for that Indeed! Gracias por ese hecho!

This site is the collective work of the HackThisSite staff. Este sitio es el trabajo colectivo de la HackThisSite personal. Please don't reproduce in part or whole without permission. Por favor, no reproducir en parte o su totalidad sin permiso.
Page Generated: Mon, 01 Dec 2008 20:32:09 -0500 Exec: 10 Página de creación: Lunes, 01 diciembre 2008 20:32:09 -0500 Ejec: 10
_{Page loaded in 0.11876 seconds!} _{Page cargado en 0,11876 segundos!}

Donate Donar

Challenges Retos

Get Informed Infórmese

Get Involved ¡Participa!

Communicate Comunicar

About HTS Acerca de HTS

Translate Traducir

Partners Socios