significado pelicula language español drama asl app assembly

assembly - pelicula - Reunión de aprendizaje



assembly pelicula (23)

Decidí aprender el lenguaje ensamblador. La razón principal para hacerlo es ser capaz de entender el código desmontado y tal vez poder escribir partes más eficientes del código (por ejemplo, a través de c ++), hacer cosas como cuevas de códigos, etc. Vi que hay un trillón de sabores diferentes de ensamblaje Entonces, para los fines que menciono, ¿cómo debería comenzar? ¿Qué tipo de asamblea debo aprender? Quiero aprender haciendo primero algunos programas fáciles (es decir, una calculadora), pero el objetivo en sí será familiarizarme con él para poder entender el código que se muestra, por ejemplo, por IDA Pro.

Estoy usando Windows (si eso hace alguna diferencia).

editar: Entonces, parece que todos apuntan hacia MASM. Aunque entiendo que tiene capacidades de alto nivel, todas buenas para el programador de código ensamblador, eso no es lo que estoy buscando. Parece tener instrucciones if, invoke, etc. que no se muestran en los desensambladores populares (como IDA). Entonces, lo que me gustaría escuchar si es posible, es la opinión de cualquiera que use ASM para los fines que estoy preguntando (leyendo el código de exe desarmado en IDA), no solo los programadores de ensamblado "generales".

editar: OK. Ya estoy aprendiendo ensamblaje. Estoy aprendiendo MASM, no usando las cosas de alto nivel que no me importan. Lo que estoy haciendo ahora es probar mi código en las directivas __asm ​​en c ++, así que puedo probar las cosas mucho más rápido que si tuviera que hacer todo desde cero con MASM.

¡Esto no necesariamente lo ayudará a escribir un código eficiente!

Los códigos op de i86 son más o menos un formato "heredado" que persiste debido al gran volumen de código y binarios ejecutables para Windows y Linux que existen.

Es un poco como los antiguos eruditos escribiendo en latín, un hablante italiano como Galileo escribiría en latín y su artículo podría ser entendido por un hablante polaco como Copérnico. Esta seguía siendo la forma más efectiva de comunicarse, aunque su hijo era particularmente bueno en latín, y el latín es un lenguaje de desecho para expresar ideas matemáticas.

Así que los compiladores generan código x86 por defecto, y los chips modernos leen los códigos op de anceint y traducen lo que ven en instrucciones de risc paralelas, con ejecución reordenada, ejecución especulativa, canalización, etc. además hacen un uso completo de los 32 o 64 registros del procesador en realidad tiene (a diferencia del patético 8 que ves en las instrucciones x86).

Ahora todos los compiladores de optimización saben que esto es lo que realmente sucede, por lo que codifican secuencias de códigos OP que saben que el chip puede optimizar de manera eficiente, incluso aunque algunas de estas secuencias parezcan ineficaces para un programador de 1990 .asm.

En algún momento debe aceptar que los 10 de miles de años que los escritores de compiladores de esfuerzo han aportado han dado sus frutos y confiar en ellos.

La forma más simple y fácil de obtener un tiempo de ejecución más eficiente es comprar el compilador Intel C / C ++. Tienen un nicho de mercado para los compiladores de efficeint y tienen la ventaja de poder preguntar a los diseñadores de chips qué ocurre dentro.

¿Estás haciendo otro trabajo de desarrollo en Windows? En que IDE? Si es VS, entonces no hay necesidad de un IDE adicional solo para leer el código desensamblado: depurar su aplicación (o adjuntarla a una aplicación externa), luego abra la ventana de desensamblaje (en la configuración predeterminada, eso es Alt + 8). Paso y mira la memoria / registros como lo haría a través del código normal. Es posible que también desee mantener abierta una ventana de registros (Alt + 5 de forma predeterminada).

Intel ofrece Intel gratuitos, que ofrecen tanto una encuesta de arquitectura básica (registros, unidades de procesadores, etc.) como una referencia de instrucción completa. A medida que la arquitectura madura y se vuelve más compleja, los manuales de ''arquitectura básica'' se vuelven cada vez menos legibles. Si puede obtener una versión anterior, probablemente tenga un mejor lugar para comenzar (incluso los manuales P3: explican mejor el mismo entorno de ejecución básico).

Si te interesa invertir en un libro, here hay un bonito texto introductorio. Busque en Amazon por ''x86'' y obtendrá muchos otros. Puede obtener varias otras direcciones de otra pregunta here .

Finalmente, puede beneficiarse bastante reading some blogs de low level . Estos bits de información de tamaño byte funcionan mejor para mí, personalmente.

(No sé ustedes, pero estaba emocionado con el montaje)

Una herramienta simple para experimentar con el ensamblaje ya está instalada en su pc.

Vaya al menú Inicio-> Ejecutar y escriba debug

depurar (comando)

debug es un comando en DOS, MS-DOS, OS / 2 y Microsoft Windows (solo versiones x86, no x64) que ejecuta el programa debug.exe (o DEBUG.COM en versiones anteriores de DOS). Debug puede actuar como un ensamblador, desensamblador o programa de volcado hexadecimal que permite a los usuarios examinar de forma interactiva los contenidos de la memoria (en lenguaje ensamblador, hexadecimal o ASCII), realizar cambios y ejecutar selectivamente COM, EXE y otros tipos de archivos. También tiene varios subcomandos que se utilizan para acceder a sectores de discos específicos, puertos de E / S y direcciones de memoria. La depuración de MS-DOS se ejecuta en un nivel de proceso de 16 bits y, por lo tanto, está limitada a programas de computadora de 16 bits . FreeDOS Debug también tiene una versión "DEBUGX" que admite programas DPMI de 32 bits.

Tutoriales:


Si quiere entender el código que ve en IDA Pro (u ollydbg.de ), tendrá que aprender cómo está estructurado el código compilado. Recomiendo el libro Reversing: Secrets of Reverse Engineering

Experimenté un par de semanas con la debug cuando comencé a aprender ensamblaje (hace 15 años).
Tenga en cuenta que la debug funciona en el nivel de máquina base, no hay comandos de ensamblaje de alto nivel.

Y ahora un simple ejemplo:

Dé a para comenzar a escribir el código de ensamblado - escriba el programa a continuación - y finalmente dele g para ejecutarlo.


( INT 21 muestra en la pantalla el carácter ASCII almacenado en el registro DL si el registro AH está establecido en 2 - INT 20 termina el programa)

Aprendimos ensamblaje con un kit de desarrollo de microcontroladores (Motorola HC12) y una hoja de datos gruesa.

Comencé a aprender MIPS, que es una arquitectura muy compacta de 32 bits. Es un conjunto reducido de instrucciones, pero eso es lo que hace que sea fácil de entender para los principiantes. Aún podrá comprender cómo funciona el ensamblaje sin verse abrumado por la complejidad. Incluso puede descargar un IDE pequeño y agradable, que le permitirá compilar su código MIPS: clicky Una vez que lo domine, creo que sería mucho más fácil pasar a arquitecturas más complejas. Al menos eso es lo que pensé :) En este punto, tendrás el conocimiento esencial de asignación y administración de memoria, flujo lógico, depuración, pruebas, etc.

Comience con MASM32 y desde allí observe FASM . Pero te divertirás con MASM.

Conocer el ensamblaje puede ser útil para la depuración, pero no me entusiasmaría demasiado usarlo para optimizar tu código. Los compiladores modernos suelen ser mucho mejores para optimizar que un humano en estos días.

Creo que Hacking: The Art of Exploitation es una forma interesante y útil de abordar este tema ... no puedo decir que alguna vez haya usado el conocimiento directamente, pero realmente no es el motivo por el que lo leí. Le da una apreciación mucho más rica de las instrucciones compiladas en su código, que ocasionalmente ha sido útil para entender errores más sutiles.

No te dejes desanimar por el título. La mayor parte de la primera parte del libro es "Hackear" en el sentido de la palabra de Eric Raymond: formas creativas, sorprendentes y casi furtivas de resolver problemas difíciles. Yo (y tal vez usted) estaba mucho menos interesado en los aspectos de seguridad.

Creo que quiere aprender los mnemónicos de código de operación ASCII -ized (y sus parámetros), que son producidos por un desensamblador y que son entendidos por (pueden ser utilizados como entrada) para un ensamblador.

Cualquier ensamblador (por ejemplo, MASM) haría.

Y / o podría ser mejor para ti leer un libro sobre él (se han recomendado libros sobre SO, no recuerdo cuál).

Fuera del tema, lo sé, pero dado que usted es un programador de Windows, no puedo evitar pensar que puede ser un uso más apropiado y / o mejor de su tiempo para aprender MSIL. No, no es ensamblado, pero probablemente sea más relevante en esta era .NET.

He hecho esto muchas veces y sigo haciendo esto. En este caso, donde su objetivo principal es leer y no escribir ensamblador, creo que esto se aplica.

Escribe tu propio desensamblador. No con el propósito de hacer el próximo desensamblador más grande, este es estrictamente para ti. El objetivo es aprender el conjunto de instrucciones. Si estoy aprendiendo ensamblador en una plataforma nueva, recordando ensamblador para una plataforma que una vez conocí. Comience con solo unas pocas líneas de código, agregue registros, por ejemplo, y haga ping pong entre desensamblar la salida binaria y agregar más y más instrucciones complicadas en el lado de entrada:

1) aprender el conjunto de instrucciones para el procesador específico

2) aprende los matices de cómo escribir código en el ensamble para dicho procesador de modo que puedas mover cada bit de código de operación en cada instrucción

3) aprendes mejor las instrucciones que la mayoría de los ingenieros que usan ese conjunto de instrucciones para ganarse la vida

En su caso hay un par de problemas, normalmente recomiendo el conjunto de instrucciones ARM para comenzar, hay más productos basados ​​en ARM enviados hoy que cualquier otro (computadoras x86 incluidas). Pero la probabilidad de que esté utilizando ARM ahora y no conozca suficiente ensamblador para escribir el código de inicio u otras rutinas sabiendo que ARM puede ayudar o no a lo que está tratando de hacer. La segunda y más importante razón para ARM primero es porque las longitudes de las instrucciones son de tamaño fijo y están alineadas. Desmontar instrucciones de longitud variable como x86 puede ser una pesadilla como su primer proyecto, y el objetivo aquí es aprender el conjunto de instrucciones para no crear un proyecto de investigación. El tercer ARM es un conjunto de instrucciones bien hecho, los registros se crean iguales y no tienen matices especiales individuales.

Por lo tanto, tendrá que averiguar con qué procesador desea comenzar. Sugiero primero el msp430 o ARM, luego ARM primero o segundo, luego el caos de x86. Independientemente de la plataforma, cualquier plataforma que valga la pena utilizar tiene hojas de datos o manuales de referencia de programadores gratuitos del proveedor que incluyen el conjunto de instrucciones y la codificación de los códigos de operación (los bits y bytes del lenguaje de la máquina). Para aprender lo que hace el compilador y cómo escribir código con el que el compilador no tiene que luchar, es bueno conocer algunos conjuntos de instrucciones y ver cómo se implementa el mismo código de alto nivel en cada conjunto de instrucciones con cada compilador con cada optimización ajuste. No quiere entrar en la optimización de su código solo para descubrir que lo ha mejorado para un compilador / plataforma, pero mucho peor para todos los demás.

Ah para desmontar conjuntos de instrucciones de longitud variable, en lugar de simplemente comenzar desde el principio y desmontar cada palabra de cuatro bytes linealmente a través de la memoria como lo haría con el ARM o cada dos bytes como msp430 (El msp430 tiene instrucciones de longitud variable pero aún puede obtener ir linealmente a través de la memoria si comienza en los puntos de entrada de la tabla de vectores de interrupción). Para la longitud variable, desea encontrar un punto de entrada basado en una tabla vectorial o saber cómo se inicia el procesador y seguir el código en orden de ejecución. Debe decodificar cada instrucción por completo para saber cuántos bytes se utilizan y, si la instrucción no es una rama incondicional, suponga que el siguiente byte después de esa instrucción es otra instrucción. También debe almacenar todas las direcciones de bifurcación posibles y asumir que esas son las direcciones de bytes iniciales para obtener más instrucciones. La única vez que tuve éxito hice varios pases a través del binario. Empezando en el punto de entrada, marqué ese byte como el comienzo de una instrucción y luego lo decodifiqué linealmente a través de la memoria hasta golpear una rama incondicional. Todos los destinos de las ramas se etiquetaron como direcciones de inicio de una instrucción. Hice varios pases a través del binario hasta que no encontré nuevos objetivos de ramificación. Si en algún momento encuentras una instrucción de 3 bytes, pero por algún motivo has etiquetado el segundo byte como el comienzo de una instrucción, tienes un problema. Si el código fue generado por un compilador de alto nivel, esto no debería ocurrir a menos que el compilador esté haciendo algo malo, si el código tiene ensamblador escrito a mano (como decir un viejo juego de arcade) es muy posible que haya ramas condicionales que nunca pueden suceder como r0 = 0 seguido de un salto si no es cero. Es posible que deba editarlos a mano fuera del binario para continuar. Para sus objetivos inmediatos, que supongo que estarán en x86, no creo que tenga un problema.

Recomiendo las herramientas gcc, mingw32 es una manera fácil de usar herramientas gcc en Windows si x86 es su objetivo. Si no, mingw32 plus msys es una excelente plataforma para generar un compilador cruzado a partir de fuentes binutils y gcc (generalmente bastante fácil). mingw32 tiene algunas ventajas sobre cygwin, como programas significativamente más rápidos y evitar el infierno cygwin dll. gcc y binutils le permitirán escribir en C o en ensamblador y desmontar su código, y hay más páginas web de las que puede leer que le muestran cómo hacer una o las tres. Si va a hacer esto con un conjunto de instrucciones de longitud variable, le recomiendo que use un conjunto de herramientas que incluye un desensamblador. Un desensamblador de terceros para x86, por ejemplo, va a ser un desafío de usar, ya que nunca se sabe si se ha desmontado correctamente. Parte de esto también depende del sistema operativo, el objetivo es compilar los módulos en un formato binario que contenga instrucciones de marcado de datos para que el desensamblador pueda realizar un trabajo más preciso. Su otra opción para este objetivo principal es tener una herramienta que pueda compilarse directamente con el ensamblador para su inspección y luego esperar que cuando se compile en un formato binario cree las mismas instrucciones.

La respuesta corta (bueno, un poco más breve) a su pregunta. Escribe un desensamblador para aprender un conjunto de instrucciones. Comenzaría con algo RISCy y fácil de aprender como ARM. Una vez que sepa un conjunto de instrucciones, será mucho más fácil seleccionar otras, a menudo en unas pocas horas, con el tercer conjunto de instrucciones puede comenzar a escribir el código casi de inmediato usando la hoja de datos / el manual de referencia para la sintaxis. Todos los procesadores que vale la pena utilizar tienen una hoja de datos o un manual de referencia que describe las instrucciones hasta los bits y bytes de los códigos de operación. Aprende un procesador RISC como ARM y un CISC como x86 lo suficiente como para tener una idea de las diferencias, cosas como tener que pasar por los registros de todo o poder realizar operaciones directamente en la memoria con menos o sin registros. Tres instrucciones de operando frente a dos, etc. A medida que sintonice su código de alto nivel, compile para más de un procesador y compare la salida. Lo más importante que aprenderá es que no importa cuán bueno esté escrito el código de alto nivel, la calidad del compilador y las elecciones de optimización hechas marcan una gran diferencia en las instrucciones reales. Recomiendo llvm y gcc (con binutils), tampoco producen código excelente , pero son multiplataforma y multidireccionales y ambos tienen optimizadores. Y ambos son gratuitos y puedes construir fácilmente compiladores cruzados a partir de fuentes para varios procesadores de destino.

Iré contra la mayoría de las respuestas y recomendaré la variante MMIX de Knuth de la arquitectura MIPS RISC. No será tan práctico como los lenguajes de ensamblaje x86 o ARM (no es que sean tan cruciales en la mayoría de los trabajos de la vida real en estos días ... ;-), pero desbloqueará para ti la magia de la última versión de Knuth versión de la obra maestra más grandiosa de todos los tiempos sobre comprensión profunda de bajo nivel de algoritmos y estructuras de datos - TAOCP , "El arte de la programación de computadoras". Los enlaces de las dos URL que he citado son una excelente manera de empezar a explorar esta posibilidad.

La sugerencia de usar depuración es divertida, se pueden hacer muchos trucos ingeniosos con eso. Sin embargo, para un sistema operativo moderno, aprender a ensamblar 16 bits puede ser un poco menos útil. Considere, en cambio, usar ntsd.exe. Está integrado en Windows XP (desafortunadamente fue retirado en el Servidor 2003 y superior), lo que lo convierte en una herramienta conveniente de aprender ya que está ampliamente disponible.

Dicho esto, la versión original en XP sufre de una serie de errores. Si realmente desea usarlo (o cdb, o windbg, que son interfaces esencialmente diferentes con la misma sintaxis de comando y el mismo back-end de depuración), debe instalar el paquete gratuito de herramientas de depuración de Windows .

El archivo debugger.chm incluido en ese paquete es especialmente útil al tratar de descubrir la sintaxis inusual.

Lo mejor de ntsd es que puedes mostrarlo en cualquier máquina XP que estés cerca y usarlo para ensamblar o desmontar. Es una herramienta de aprendizaje de ensamblaje / great / X86. Por ejemplo (usando cdb ya que está en línea en el indicador de dos, de lo contrario es idéntico):

(Errores de símbolos omitidos, ya que son irrelevantes; también, espero que este formato funcione, esta es mi primera publicación)

C:/Documents and Settings/User>cdb calc Microsoft (R) Windows Debugger Version 6.10.0003.233 X86 Copyright (c) Microsoft Corporation. All rights reserved. CommandLine: calc Symbol search path is: *** Invalid *** Executable search path is: ModLoad: 01000000 0101f000 calc.exe ModLoad: 7c900000 7c9b2000 ntdll.dll ModLoad: 7c800000 7c8f6000 C:/WINDOWS/system32/kernel32.dll ModLoad: 7c9c0000 7d1d7000 C:/WINDOWS/system32/SHELL32.dll ModLoad: 77dd0000 77e6b000 C:/WINDOWS/system32/ADVAPI32.dll ModLoad: 77e70000 77f02000 C:/WINDOWS/system32/RPCRT4.dll ModLoad: 77fe0000 77ff1000 C:/WINDOWS/system32/Secur32.dll ModLoad: 77f10000 77f59000 C:/WINDOWS/system32/GDI32.dll ModLoad: 7e410000 7e4a1000 C:/WINDOWS/system32/USER32.dll ModLoad: 77c10000 77c68000 C:/WINDOWS/system32/msvcrt.dll ModLoad: 77f60000 77fd6000 C:/WINDOWS/system32/SHLWAPI.dll (f2c.208): Break instruction exception - code 80000003 (first chance) eax=001a1eb4 ebx=7ffd6000 ecx=00000007 edx=00000080 esi=001a1f48 edi=001a1eb4 eip=7c90120e esp=0007fb20 ebp=0007fc94 iopl=0 nv up ei pl nz na po nc cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202 ntdll!DbgBreakPoint: 7c90120e cc int 3 0:000> r eax eax=001a1eb4 0:000> r eax=0 0:000> a eip 7c90120e add eax,0x100 7c901213 0:000> u eip ntdll!DbgBreakPoint: 7c90120e 0500010000 add eax,100h 7c901213 c3 ret 7c901214 8bff mov edi,edi 7c901216 8b442404 mov eax,dword ptr [esp+4] 7c90121a cc int 3 7c90121b c20400 ret 4 ntdll!NtCurrentTeb: 7c90121e 64a118000000 mov eax,dword ptr fs:[00000018h] 7c901224 c3 ret 0:000> t eax=00000100 ebx=7ffd6000 ecx=00000007 edx=00000080 esi=001a1f48 edi=001a1eb4 eip=7c901213 esp=0007fb20 ebp=0007fc94 iopl=0 nv up ei pl nz na pe nc cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206 ntdll!DbgUserBreakPoint+0x1: 7c901213 c3 ret 0:000>`

Además, mientras juegas con IDA, asegúrate de revisar el IDA Pro Book de Chris Eagle (desvinculado porque no quiere dejar que publique más de dos enlaces para mi primera publicación). Es sin duda la mejor referencia que hay.

Mi favorito personal es NASM, principalmente porque es multiplataforma, y ​​compila MMX, SSE, 64 bits ...

Comencé a compilar un archivo fuente en C simple con gcc, y "transcodificar" la instrucción de ensamblador de formato gcc en formato NASM. Luego puede cambiar pequeñas porciones de código y verificar la mejora de rendimiento que trae.

La documentación de NASM está realmente completa, nunca necesité buscar información de libros u otras fuentes.

Muchas buenas respuestas aquí. La programación de bajo nivel, el montaje, etc. son populares en la comunidad de seguridad, por lo que vale la pena buscar sugerencias y consejos una vez que haya comenzado. Incluso tienen algunos buenos tutoriales como este en el ensamblaje x86 .

No me enfocaría en intentar escribir programas en ensamblaje, al menos no al principio. Si estás en x86 (que supongo que eres, ya que estás usando Windows), hay toneladas de casos especiales raros que es inútil aprender. Por ejemplo, muchas instrucciones suponen que está operando en un registro que no menciona explícitamente, y otras instrucciones funcionan en algunos registros pero no en otros.

Aprendería lo suficiente acerca de su arquitectura deseada para que entendiera los conceptos básicos, luego simplemente ingrese directamente e intente comprender la salida de su compilador. Ármate con Intel y simplemente sumérgete en la salida de tu compilador. Aísle el código de interés en una función pequeña, para que pueda estar seguro de entender todo.

Considero que los conceptos básicos son:

  • registros: ¿cuántos hay, cuáles son sus nombres y cuáles son sus tamaños?
  • orden de operando: add eax, ebx significa "Agregar ebx a eax y almacenar el resultado en eax".
  • FPU: aprende los conceptos básicos de la pila de coma flotante y cómo convertir a / desde fp.
  • modos de direccionamiento: [multiplicador base + offset *], pero el multiplicador solo puede ser 1, 2 o 4 (¿o quizás 8?)
  • convenciones de llamada: ¿cómo se pasan los parámetros a una función?

Muchas veces será sorprendente lo que el compilador emite. Conviértalo en un rompecabezas de averiguar por qué diablos el compilador pensó que sería una buena idea. Te enseñará mucho.

Probablemente también te ayude a armarse con los manuales de Agner Fog , especialmente las instrucciones que enumeran uno. Le dirá aproximadamente qué tan costosa es cada instrucción, aunque esto es más difícil de cuantificar directamente en los procesadores modernos. Pero ayudará a explicar por qué, por ejemplo, el compilador se sale de su camino para evitar emitir una instrucción idiv .

Mi único otro consejo es usar siempre la sintaxis Intel en lugar de AT & T cuando se tiene la opción. Solía ​​ser bastante neutral en este punto, hasta el día en que me di cuenta de que algunas instrucciones son totalmente diferentes entre las dos (por ejemplo, movslq en la sintaxis de AT & T es movsxd en la sintaxis de Intel). Como todos los manuales están escritos con la sintaxis de Intel, simplemente apéguese a eso.

¡Buena suerte!

Para alcanzar realmente su objetivo, puede considerar comenzar con el IDE en el que se encuentra. Por lo general, es una ventana de desensamblador, por lo que puede hacer un solo paso a través del código. Por lo general, hay una vista de algún tipo para que pueda ver los registros y examinar las áreas de memoria.

El examen del código c / c ++ no optimizado ayudará a construir un vínculo en el tipo de código que el compilador genera para sus fuentes. Algunos compiladores tienen algún tipo de palabra reservada de ASM que le permite insertar instrucciones de la máquina en su código.

Mi consejo sería jugar con ese tipo de herramientas por un tiempo y mojarse los pies, y luego dar un paso adelante. ¿abajo? al código ensamblador directo en cualquier plataforma en la que se esté ejecutando.

Hay muchas herramientas geniales, pero puede que le resulte más divertido evitar la curva de aprendizaje al principio.

Para hacer lo que quieres hacer, acabo de tomar la referencia del conjunto de instrucciones de Intel (podría no ser la exacta que utilicé, pero parece suficiente) y algunos programas simples que escribí en Visual Studio y comencé a incluirlos en IDAPro / Windbg. . Cuando crecí mis propios programas, el software de crackmes fue útil.

Supongo que tiene una comprensión básica de cómo se ejecutan los programas en Windows. Pero, en realidad, para el montaje de lectura, solo hay unas pocas instrucciones para aprender y algunos sabores de esas instrucciones (por ejemplo, hay una instrucción de salto, el salto tiene algunos sabores como salto-si-igual, salto-si-ecx-es-cero , etc.) Una vez que aprenda las instrucciones básicas, es bastante simple obtener la esencia de la ejecución del programa. La vista gráfica de IDA ayuda, y si está rastreando el programa con Windbg, es bastante simple averiguar qué están haciendo las instrucciones si no está seguro.

Después de tocar un poco así, compré Hacker Disassembly Uncovered . En general, me mantengo alejado de los libros con la palabra "Hacker" en el título, pero realmente me gustó cómo este fue realmente profundo sobre cómo se compiló el código compilado. También entra en optimizaciones de compilador y algunas cosas de eficiencia que fueron interesantes.

Todo depende de cuán profundamente quieras comprender el programa también. Si está realizando ingeniería inversa en un objetivo en busca de vulnerabilidades, si está escribiendo código de explotación o analizando las capacidades del malware empaquetado, necesitará más tiempo de aceleración para realmente poner en marcha las cosas (especialmente para el malware más avanzado). ) Por otro lado, si solo quieres cambiar el nivel de tu personaje en tu videojuego favorito, deberías estar bien en un tiempo relativamente corto.

Puede ver el curso de video de ensamblaje xorpd x86 . (Yo lo escribi). El curso en sí está pagado, pero los ejercicios son de fuente abierta, en github. Si tiene alguna experiencia en programación, creo que debería poder trabajar solo con los ejercicios y comprender todo.

Tenga en cuenta que el código es para la plataforma de Windows y está escrito utilizando el FASM . El curso y los ejercicios no contienen construcciones de alto nivel, sin embargo, puedes utilizar Fasm para crear macros muy complicados, si alguna vez deseas hacerlo.

Recientemente tomé una clase de sistemas informáticos. Uno de los temas era Assembly como una herramienta para comunicarse con el hardware.

Para mí, el conocimiento de ensamblaje no habría sido completo sin entender los detalles de cómo funcionan los sistemas informáticos. Entender eso, trae una nueva comprensión de por qué las instrucciones de ensamblaje en la arquitectura de un procesador son geniales, pero es terrible en otra arquitectura.

Dado esto, me inclino a recomendar mi libro de texto de la clase:

Sistemas informáticos: la perspectiva de un programador .

Sistemas informáticos: la perspectiva de un programador http://csapp.cs.cmu.edu/public/csappcover-medium.jpg

Sí cubre el ensamblaje x86, pero el libro es mucho más amplio que eso. Cubre el revestimiento del tubo del procesador y la memoria como un caché, el sistema de memoria virtual y mucho más. Todo esto puede afectar cómo el ensamblaje podría optimizarse para las características dadas.

Uno de los lenguajes de ensamblaje pedagógico estándar es el MIPS. Puede obtener simuladores MIPS (spim) y varios materiales de enseñanza para ello.

Personalmente, no soy un fan. Me gusta más IA32.

El conjunto que escribiría a mano y el conjunto generado por un compilador a menudo son muy diferentes cuando se ven desde un nivel alto. Por supuesto, las entrañas del programa serán muy similares (después de todo, hay muchas maneras diferentes de codificar a = b + c ), pero no son el problema cuando intentas realizar ingeniería inversa. El compilador agregará una tonelada de código repetitivo a incluso ejecutables simples: la última vez que comparé, "Hello World" compilado por GCC fue de aproximadamente 4kB, mientras que si se lo escribe a mano en el ensamblaje, es de alrededor de 100 bytes. Es peor en Windows: la última vez que comparé (es cierto, esto fue el siglo pasado), el "Hello World" más pequeño que pude obtener de mi compilador de Windows de entonces fue de 52kB. Por lo general, esta repetición solo se ejecuta una vez, si es que no afecta la velocidad del programa, como dije antes, el núcleo del programa, la parte donde se usa la mayor parte del tiempo de ejecución, suele ser bastante similar ya sea compilado o escrito a mano.

Al final del día, esto significa que un experto programador de ensamblaje y un desensamblador experto son dos especialidades diferentes. Comúnmente se encuentran en la misma persona, pero están realmente separados, y aprender cómo ser un excelente programador de ensambles no te ayudará tanto a aprender ingeniería inversa.

Lo que quiere hacer es tomar los manuales de arquitectura IA-32 y AMD64 (ambos están cubiertos) de Intel y AMD , y consulte las secciones anteriores sobre instrucciones y códigos de operación. Tal vez lea un tutorial o dos en lenguaje ensamblador, solo para obtener los conceptos básicos del lenguaje ensamblador. Luego tome un pequeño programa de muestra que le interese y desmóntelo: controle su flujo de control e intente comprender lo que está haciendo. Vea si puede parchear para hacer otra cosa. Luego intente de nuevo con otro programa y repita hasta que esté lo suficientemente cómodo como para tratar de lograr un objetivo más útil. Puede que le interesen cosas como "crackmes", producidos por la comunidad de ingeniería inversa, que son desafíos para las personas interesadas en la ingeniería inversa para probar y, con suerte, aprender algo en el camino. Varían en dificultad desde básico (¡comience aquí!) Hasta imposible.

Sobre todo, solo necesitas practicar . Como en muchas otras disciplinas, con la ingeniería inversa, la práctica hace al maestro ... o al menos mejor .