Bueno, gracias a todos por su ayuda. Ya llevo unos días leyendo los PDFs de Intel. (AMD no me agrada mucho. XD.). Pero aún no consigo encontrar algún patrón en las instrucciones que me evite hacer una comparacion directa con una tabla de opcodes.

Pero al menos con lo que me han dicho ya tengo una orientacion. (Eso de que van de 8 en 8 no lo sabía. XD). Bueno, aunque mi desensamblador no tiene porque reconocer todos los opcodes, al menos quiero que reconozca las instrucciones más usadas (Operaciones aritmetica, Saltos condicionales, Manejo de pila, Mover datos, entre otras de uso común).

Bueno, si alguna problema sucede, me imagino que puedo contar con ustedes. ¿o no? XD.

Gracias a todos por sus respuestas.

Gracias a todos por sus respuestas. He estado pensando en crear un motor que haga mutar las instrucciones, pero evitando cifrarlas (para que el antivirus no detecte algun loop extraño ni detecte actividad anormal, porque un codigo que cambia es algo anormal). Pero si implementaré una rutina que cifre/decifre la parte de datos. Estoy trabajando primero en el desensamblador, para luego añadirle el motor metamorfico.

Sé que esto pueda parecer fuera del tema, pero ¿Es posible hacer un virus que tenga su parte de datos y de codigo separadas? Es decir como un programa normal. Para evitar que el antivirus me detecte cambios en la sección de codigo (que no debería ser writable).

Ah, una cosa más: ¿Por qué cuando un busca por internet, hay muy poca informacion respecto a como implementar un motor metamorfico? Mucho del codigo que estoy haciendo lo he hecho de la nada, y otras partes me he basado en codigo que no es precisamente virico. No entiendo por que la informacion sobre los virus (metodos actuales) no se consigue en internet. Solo he encontrado virus de broma (como formatea de unidad de disco haciendo click en este bat...) o cosas por el estilo. Aunque en VXheaven hay algunos virus buenos, parecieran muchos estar desfasados con el tiempo actual.

Pareciera como si uno tuviera que armar en puzzle tomando piezas de varios programas para finalmente conseguir algo decente que se pueda llamar 'malware'.

Ay, disculpen, una pregunta más: ¿No saben en donde puedo conseguir buena documentacion sobre un motor metamorfico? Si es posible, por favor actualizada.

Bueno, gracias a todos por su colaboracion. Y disculpen por hacerlos leer tanto. XD

Oye, ¿tienes acceso al router? Si lo tienes, sería muy sencillo descubrir si tiene algun parametro cambiado.

¿Tienes acceso a las computadoras que crees que están recibiendo mas ancho de banda? Ejemplo, son de la universidad o se conectan por wifi? Si tienes acceso a las computadoras y son de la universidad, me imagino que podrías pedir un permiso para ver las computadoras y usarlas (en el caso que no te permitan acceder al router). De alli haces pruebas con descargas a ver cual computadora tiene mejor tiempo.

Esas son las posibles soluciones que se me ocurren. Creo que es algo dificil saber si una computadora acapara mayor ancho de banda desde otra PC es algo creo que casi imposible.

Espero que encuentres una solución a tu problema. Te ayudaré en cuanto pueda. Deberias dar más datos sobre el router y exactamente por qué piensas que están limitando el ancho de banda a favor de otros.

Muchas gracias por tu respuesta, Vaagish

Bueno, sé que al estar haciendolo por diversión no estoy realmente perdiendo el tiempo, pero si me dices que puedo aprender algo útil de allí seguiré con mi diversión. XD.

Ah, ¿¿entonces si uso un motor metamorfico bien diseñado en mi malware seré capaz de evitar la deteccion por firmas???. ¿¿Será que me puedes dar algunas instrucciones que sean reemplazables por otras???. Porque un motor metamorfico en primera instancia es algo que reemplaza codigo por otro equivalente, o no??

He estado investigando, y según veo un mov se puede reemplazar por un push/pop. ¿Será que conoces algunas otras instrucciones y sus equivalentes?

Gracias por tu 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.

Oye, solo por curiosidad: ¿Eso es capaz de infectar y diseminarse por la red? ¿O son bots que necesitan intervencion directa del usuario? Es solo por curiosidad. ¿Y el codigo está completo, o son solo binarios? Leeré tu codigo en cuanto pueda, a ver que tal está. XD.

Dios me libre de que me llegue a infectar a mi. XD.

Gracias rir3760!! No sabía que había mucha diferencia entre un char con signo o sin signo!! Entonces, ¿Será que si hago el mismo switch pero enteros con signo y otros con signo, puede que algunos valores los interprete mal?

Saludos. Gracias por tu 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.

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

Gracias cpu2. ¿Entonces, no sabes si los prefijos siguen el orden que indica la imagen? (LOCK/REP/REPNE, luego Address size override, luego Operand size y de ultimo Segment Override??

Sé que me diste una idea, pero, ¿no sabes exactamente si los prefijos pueden seguir el orden indicado anteriormente? Porque si lo siguen, creo que serìa capaz de escribir de forma más sencilla la parte de identificacion de prefijos.

Ah, y estuve mirando, y al parecer si hay opcodes que coinciden con los valores de los prefijos, aunque creo que los opcodes que coinciden no deberían tener ese prefijo.

Empezar este desensamblador está algo dificil. XD. Bueno, cuando lo terminé tendré un proyecto más en mi casa.