LORDPEI:

Oye, he estado tanteando y encontré que el programa reserva 280 bytes de stack, aparentemente (tomando tal cual el valor que me dio Olly, que no sé realmente si es decimal o hexadecimal). Pienso yo que está bien, aunque me costóp un poco seguir la subrutina.

Bueno, pareciera ser el alignment: ¿Puedes ayudarme a lograr que mis shellcodes no fallen por culpa de esto?? Reemplaze las 'A' de relleno por NOPs, pero igual.

Hice un cambio en la shellcode, agregando unas cuantas instrucciones, y funciona. Pero pareciera depender del tamaño de la shellcode: Hice una de 26 bytes, y funciona. Hice otra como de 15 bytes, y funciona.

Pero una de 21 bytes, y no funciono, saltando a una direccion rara que no tengo ni idea de donde salió.

Es como si el "tamaño" la afectara. ¿Como puedo lograr que la shellcode se ejecute bien a pesar del tamaño??? No puedo andar modificando el programa vulnerable, porque si fuera uno real no puedo.

He mirado lo que he hecho, y pareciera estar bien: Rellene con basura hasta alcanzar el limite, hay espacio suficiente, cargue bien la shellcode y la envié...Pero nada.

Importante:
Estoy usando FASM como ensamblador, y Tiny C Compiler. No sé si eso puede afectar, aunque lo compile con GCC e igual falla.

Gracias por tu ayuda, perdona por el mensaje extenso.

LORdP3I:
Si tienes razón en decir que solo se desborda con strcpy(...). Y lo hice así porque pensé que sería más fácil de depurar con Olly si usaba un TCP.

Encontré algo curioso: He intentado variar un poco la shellcode, y depende de lo que sea funciona o no. No sé si esto tendrá que ver con el alignment. Solo le agregue una instruccion más, y dejo de funcionar. Estoy rellenando con basura hasta sobreescribir EBP, y poner EIP con mi valor deseado.

(Hecho con Flat Assembler)

Shellcode que NO funciona. (21 bytes)

use32
 
mov eax, 0xDEADBEEF
mov ebx, 0xDEADBEEF
mov ecx, 0xDEADBEEF
mov edx, 0xDEADBEEF
int3
 
 

Shellcode que si funciona: (15 bytes)

use32
 
mov eax, 0xDEADBEEF
mov ebx, 0xDEADBEEF
mov ecx, 0xDEADBEEF
int3
 
 

He hecho todo lo posible para hacer funcionar la que es un poco más larga, pero no deja de falla. No sé si tendrá que ver con los bytes que contiene la shellcode 2, pero la revisé no hay ningún nulo por ahí. En teoría debería funcionar.

Será que habrá otros caracteres que puedan detener strcpy??? Revisé y no hay nulos allí, no sé si habrá otro que interfiera.

Estoy en proceso de entender la parte en donde reserva espacio en stack, pero el codigo es un poco largo y no lo encuentro. Supongo que sería un sub esp, x bytes, o no???

Bueno, espero su respuesta. Seguiré leyendo sobre como sacarle provecho a Olly en encontrar subrutinas.

Hola amigos, disculpen por ser tan impreciso, (editare ahora la pregunta).

Digamos que tengo un buffer de 20 bytes. Ahi pongo la shellcode + los bytes basura.
Y tengo exito.

Pero si tengo un buffer de 60 bytes, y lo lleno con shellcode + los bytes basura necesarios para desbordarlo y todo eso, se desborda pero no con el dato que le quise cargar.

Es como si el buffer tuviera bytes "de más" o algo asi. No sé como explicarlo, pero así me parece que es. Adjuntaré los sources en un sitio de parecido a pastebin, para que lo vean (no uso pastebin porque en mi pais pareciera estar bloqueado...)

Gracias por su atencion, y ahora editare la pregunta.

Puede estar una cosa llamada "aligment" interfiriendo aqui?? Estoy leyendo sobre eso, pero no estoy seguro y no soy muy ducho en estos temas.

Mi pregunta es: ¿Estará el compilador cambiando algo que afecte la posicion de las variables??? en la pila??

Estoy usando Tiny C Compiler sin proteccion alguna, en Windows XP.

Es como si ebp y eip hubiesen sido movidos. Sera que el alineamiento de las variables hara algun efecto??

Es un small buffer de 60 bytes, y luego uno de 120 bytes. El mas peque declarado primero, y luego el otro.

Editare el post si es necesario.

Hola. Edito mi pregunta para ser más preciso: Mi duda es: Puede el compilador agregar algo "de más" entre variables de la stack???

Tengo un Tiny C Compiler, sin protecciones ni a nivel de compilador ni a nivel de Windows XP.

Puede ser que algo llamado "alignment" esté haciendo fallar mi exploit?? He enviado la cantidad de bytes necesarios para desbordar mi propio TCP server. Cuando el buffer destino es de 20 bytes, funciona. Pero si es de 60, no lo hace.

Y estoy enviando la cantidad de bytes necesarios para desbordarlos + la shellcode, así, que en teoría debería hacer lo que quiero, pero en la práctica salta hacia un ret addr extraño.

Adjunto links a un sitio de tipo pastebin, para no abrumar aqui en el foro.
Aqui les dejo mis codigos fuente:

Todos ellos funcionan si el buffer small es de 20 y el big de 30. Cambiando el valor de ambos por 60 y 120, no funcionan. Ahi están mis sources, por si alguien los quiere ver.

(Uso winsock2.h, si alguna cosa lo renombran sin el 2)

Mi TCP server (source escrito por mi)
http://tny.cz/2dc66ee0

Mi TCP exploit
http://tny.cz/dc9295ba

Mi shellcode
http://tny.cz/c4426347

Aqui está el programa objetivo, ya compilado, a peticion de un usuario. Para que no digan que es que uno quiero que resuelvan por mi.
https://drive.google.com/file/d/0Bxshgu4STp1aUXpsYmMySWhqS3c/view?usp=sharing

Gracias de antemano por su atencion.

Hola, estoy tratando de aprender sobre los stack-based buffer overflows, y para ello he construido mi propio programa vulnerable. Estoy teniendo problemas. Estoy tratando de jugar con la direccion de retorno para hacer ejecutar funciones que nunca son llamadas. Pero no puedo conseguirlo bien.

El programa vulnerable, recibe una cadena desde el usuario de 16 bytes, y luego la copia en un buffer de 8 bytes usando strcpy. He escrito un exploit sencillo, al cual le indicas cuantos bytes inutiles deseas, y luego la direccion de retorno en hexadecimal.

Pero cuando sobreescribo la funcion de retorno, solo una funcion se ejecuta, las demas (sabiendo su direccion) no lo hacen. ¿Por que sucederá eso? ¿Puede alguien explicarme como sobreescribir bien la direccion de retorno?

Exploit.c

/*Simple Exploit loader
 
    usage: exploit.exe <trash_bytes> <ret addr>
 
    Recibe la cantidad de bytes inutiles necesario para desbordar el buffer
    y usa la direccion de retorno en hexadecimal, convertida a un binario
    plano en un int de 4 bytes, y enviado al revés (por ser little endian, o
   al menos eso pensé cuando lo cree)
 
*/
 
#include <stdio.h>
#include <stdlib.h>
 
union ret_addr{
    char bytes[4];
    unsigned int raw;
};
 
int load_file_on_buffer(char filename[], void **ptr_buffer_destiny){
    FILE *file_loaded;
    void *buffer_destiny;
    unsigned int file_size;
 
    file_loaded = fopen(filename, "rb");
    if(file_loaded == NULL)
        return 0;
 
    fseek(file_loaded, 0, SEEK_END);
    file_size = ftell(file_loaded);
    fseek(file_loaded, 0, SEEK_SET);
 
    buffer_destiny = (void *) malloc(file_size+1);
    *ptr_buffer_destiny = buffer_destiny;
 
    fread((char *) buffer_destiny, file_size, 1, file_loaded);
    buffer_destiny[file_size] = '\0';
 
    //printf("BEGIN DEBUG FILE\n");
    //printf("%s", buffer_destiny);
    //printf("\n\nEND DEBUG FILE\n");
 
    fclose(file_loaded);
 
    return file_size;
 
}
 
int main(int argc, char *argv[]){
 
    FILE *shellcode_file;
    char *shellcode;
    int file_size;
 
    int trash_bytes = atoi(argv[1]);
    union ret_addr ret_addr;
    ret_addr.raw = (unsigned int) strtol(argv[2], NULL, 16);
 
    int i = 0;
    for(i; i < trash_bytes; i++){
         printf("a");
    }
 
    if(argc == 3){
    printf("%c", ret_addr.bytes[3]);
printf("%c", ret_addr.bytes[2]);
printf("%c", ret_addr.bytes[1]);
printf("%c", ret_addr.bytes[0]);
}
 
    file_size = load_file_on_buffer("shellcode.bin", &shellcode);
 
    for(i = 0; i < file_size; i++){
         printf("%c", shellcode[i]);
    }
 
}
 

Gracias de antemano. No sé si habrá algo mal con mi exploit. Ya me he estado leyendo la stack y como funciona. Seguire buscando en internet....

EDIT 1:

Estoy jugando con un programa tipo TCP servidor hecho por mi mismo, y en vez de sobreescribir EIP, sobreescribo EDX. ¿Puede alguien decirme por qué? Gracias de antemano.

Gracias ivancea96. He implementado una solucion que va contando cada paquete de bytes y los concatena hasta encontrar un CR. Gracias por tu ayuda.

Hola. Estoy desarrollando algo que podría llamarse "shell remota" porque recibe comandos desde una máquina externa. En realidad es una computadora que está a la escucha de comandos, los interpreta y devuelve un resultado.

El problema está en que yo quiero recibir los carácteres recibidos como un bloque, es decir, como un comando completo. Pero cuando lo intento, pareciera ser que voy recibiendo byte a byte, en vez de toda la informacion transmitida.

Por favor, si pueden ayudarme estaría muy agradecido. Adjunto el código para que vean que el receptor no puede interpretar el comando "ATTACK".

/* Enlazar Ws2_32 */
#define _WIN32_WINNT 0x0501
#include <stdio.h>
#include <winsock2.h>
#define PUERTO 8080
 
WSADATA wsa_data;
SOCKET listen_socket, cliente;
struct sockaddr_in clientinfo, servicio;
int rtn;
char buffer[256];
 
void print_buffer(char *buffer, unsigned int bytes) {
    while(bytes--)
        putchar(*buffer++);
 
}
 
int main() {
    if ((rtn = WSAStartup(MAKEWORD(2,2), &wsa_data)) != 0) {
        fprintf(stderr, "Error WSAStartup: %d\n", rtn);
        return 1;
    }
 
    if((listen_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET) {
        fprintf(stderr, "Error en socket: %d\n", WSAGetLastError());
        WSACleanup();
        return 1;
    }
 
    servicio.sin_family = AF_INET;
    servicio.sin_addr.S_un.S_addr = INADDR_ANY;
    servicio.sin_port = htons(PUERTO);
 
    if((rtn = bind(listen_socket, (struct sockaddr*) &servicio, (int) sizeof(servicio))) == SOCKET_ERROR) {
        fprintf(stderr, "Error en bind: %d\n", WSAGetLastError());
        WSACleanup();
        return 1;
    }
 
    if (listen(listen_socket, SOMAXCONN) == SOCKET_ERROR) {
        fprintf(stderr, "Error en listen: %d\n", WSAGetLastError());
        closesocket(listen_socket);
        WSACleanup();
        return 1;
    }
 
    if((cliente = accept(listen_socket, (struct sockaddr*)&clientinfo, NULL)) == INVALID_SOCKET) {
        fprintf(stderr, "Error en accept: %d\n", WSAGetLastError());
        closesocket(listen_socket);
        WSACleanup();
        return 1;
    }
 
    closesocket(listen_socket);
 
    printf("Cliente IP: %s\n", inet_ntoa(clientinfo.sin_addr));
 
    do {
        rtn = recv(cliente, buffer, sizeof(buffer), 0);
 
        if(rtn > 0) {
            print_buffer(buffer, rtn);
            if(strcmp(buffer, "ATTACK") == 0){
                printf("ATTACK COMMAND ISSUED!!\n");
            }
        } else if(rtn == 0)
            printf("Cerrando la conexión...\n");
        else {
            fprintf(stderr, "Error en recv: %d\n", WSAGetLastError());
            closesocket(cliente);
            WSACleanup();
            return 1;
        }
    } while(rtn > 0);
 
    closesocket(cliente);
    WSACleanup();
 
    return 0;
}
 
 

Hola. Estoy aprendiendo algo sobre los Arboles B, una estructura de datos. No sé si este sea el sitio adecuado, pero tengo varias interrogantes acerca de ese Arbol:

No entiendo como cuál es la lógica que sigue el arból. Entiendo bien los términos de nodos hijos y nodos padres, pero no entiendo como funciona. ¿Puede alguien darme una explicacion un poco más sencilla que las que aparecen en internet? Por si acaso, seguiré buscando...

¿Los nodos de izquiera a derecha, van de menor valor a mayor?



Gracias por su ayuda.

Hola, estoy desarrollando una aplicacion sencilla que usa bases de datos SQLite en C/C++. Al hacer la consulta que crea una TABLA si no existe, la aplicacion hace una VIOLACION DE MEMORIA. He estado revisando con el depurador, pero no lo he podido conseguir.

No encontre un subforo adecuado para este tema, así que lo posteé aquí. Disculpen si aquí no iba. XD. El código es el siguiente:

#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <sqlite3.h>
 
///Global variables
sqlite3 *db;
char *zErrMsg = 0;
int rc;
char sql[128];
 
   ///Used to extract interesting data from callbacks.
int number_of_rows_fetched;
int money;
int money2;
const char *data = "Callback function called!!\n";
 
///This function is called each time that a row if found.
///The only way to keep tracking how many rows has the table,
///it's increasing the counter.
static int callback(void *data, int argc, char **argv, char **azColName){
   printf("Callback is running!!\n");
 
   return 0;
}
 
 
int init(){
 
    ///Open database
   rc = sqlite3_open("bank.db", &db);
   if(rc != SQLITE_OK){
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      exit(0);
   }else{
      fprintf(stderr, "Opened database successfully\n");
   }
 
 
 
   ///Create Table if it doesn't exist
   memset(sql, 0, sizeof(sql));
   strcat(sql, "CREATE TABLE accounts("  \
         "id INT            NOT NULL," \
         "username           TEXT    NOT NULL," \
         "password           TEXT    NOT NULL," \
         "cash               INT);");
 
   ///Run query
   rc = sqlite3_exec(db, sql, callback, 0, &zErrMsg);
   printf("After the crash, i still alive\n");
   if( rc != SQLITE_OK ){
   fprintf(stderr, "SQL error: %s\n", zErrMsg);
      sqlite3_free(zErrMsg);
   }else{
      fprintf(stdout, "Table created successfully\n");
   }
 
}
 
int main(int argc, char* argv[])
{
 
   init();
 
   return 0;
}
 
 

Realmente he tenido dudas sobre si este tópico iría en este subforo, pero como no encuentro algo relacionado con Bases de Datos directamente, quise postearlo aqui.

Gracias de antemano.