#1 Assembly x86: Introducción

Después de un largo tiempo regresamos a los blogs, el team R3gularWeb del Laboratorio ha revivido.

Y damos inicio a un nueva serie de post, donde vamos a revisar el terror de muchos programadores el lenguaje Assembly !!

 

Índice

• ¿Vale la pena aprender Assembly en 2021? 

• IDE

• Hola mundo
  

¿Vale la pena aprender Assembly en 2021?

Lo primero que tenemos que preguntarnos, es ¿Qué es Assembly?

Assembly es un lenguaje de programación de bajo nivel, solo por encima del lenguaje maquina.

Esto quiere decir, que con este tipo de lenguajes estamos muy cerca de hablar con la PC a puro 1 y 0. Lo que hace que a primera vista no sea tan intuitivo como otras opciones en el mercado.
Un ejemplo de esto, podría ser python donde mostrar un texto en consola se reduce a una linea print('Mensaje'), en cambio con Assembly esta tarea nos puede llevar hasta 13 lineas de código !

 

Entonces, si solo nos complica la vida ¿Por qué deberíamos de aprenderlo?

Esto se debe a la gran eficiencia que logramos obtener, sin ese relleno que nos trae de manera inherente los compiladores de otros lenguajes.

 

 

Un ejemplo es el buen C/C++ al ser un lenguaje compilado, este nos crea un ejecutable con todas las instrucciones necesarias para que el programa pueda correr de forma correcta.
Dicho ejecutable esta escrito en el Assembly correspondiente a la arquitectura del sistema operativo anfitrión.
Y si logramos entender ensamblador, podemos analizar el código de este ejecutable logrando saber todo lo que nos agrega de más el compilador y por ende alentando el programa.

 

 

Pero, ¿realmente necesitamos tanta velocidad? Todo depende del objetivo, por ejemplo tenemos a los procesadores donde la eficiencia de la ejecución en las tareas es lo más importante.
Y aquí el rey es Assembly, sin importar la arquitectura del procesador (x86 o x64) incluso los procesadores del sector mobile usan esto en sus arquitecturas ARM.

 

El último punto a tocar, es sobre ciberseguridad o hacking. "Todos" los lenguajes de programación pasan sus instrucciones a algún "interprete" que terminan convirtiendo las sentencias a Assembly y de ello al lenguaje maquina, eso quiere decir que incluso si es un ejecutable nosotros podemos leer la lógica la app y con ello intentar explotar ciertas vulnerabilidades o aplicar ingeniería inversa.

En R3gularWeb tenemos dos blogs hablando sobre este tema, por si gustan revisarlo.

URL: 1# Ingeniería inversa usando Ghidra

Hay muchas mas aplicaciones de Assembly en el mundo real que han faltado comentar como en robótica, pero con esto podemos darnos una idea de que Assembly si bien puede parecer viejo y obsoleto, esta muy vivo !

IDE

Para no tener ningún problema con el sistema operativo que estemos usando vamos a utilizar un IDE Online que debería de funcionar independiente de la plataforma.

Si a lo largo del curso, nos vemos con la necesidad de tener un ambiente de desarrollo local, vamos a actualizar este artículo mostrando la instalación.

Assembly x86
https://www.tutorialspoint.com/compile_assembly_online.php

Assembly x64
https://www.mycompiler.io/new/asm-x86_64

Hola mundo 

Ahora vamos a pasar ya al código, donde realizaremos el ejercicio más fácil que se puede hacer en cualquier lenguaje de programación. Nuestro primer hola mundo.

Aquí tenemos el código completo, que iremos explicando paso a paso

 

section	.text
        global _start
_start:
	mov	edx, len
	mov	ecx, msg
	mov	ebx, 1
	mov	eax, 4
	int	0x80
	mov	eax, 1
	int	0x80
section	.data
	msg	db	'Hello, world!', 0xa
	len	equ	$ - msg 

___________________________________________

En la primera línea podemos ver que tenemos un  section .text, como todo lenguaje de programación Assembly igual tiene sus propias palabras reservadas, y las sections son una de ellas.

section	.text
        global _start

Las secciones no son más que secuencias de memoria independientes. Cada nuevo byte de datos se coloca en la "sección de programa" actualmente abierta.

Ahora tenemos que tener un punto de entrada al programa, entonces podemos inicializar el punto de inicio (_start), que se encuentra en la segunda línea de nuestro programa.

Como hemos mencionado, el punto de entrada del programa es _start y a continuación toda nuestra lógica del código, que al principio esto nos parecerá todo un caos para entender.

_start: 

Ahora, seguimos con el resto de sentencias en nuestro programa, le tenemos que pasar ciertos valores en registros específicos. Para que algo sea asignado a una posición de memoria se utiliza la palabra reservada mov seguido del registro donde se almacenará.

	mov	edx, len
	mov	ecx, msg

Esto se podría ver como en cualquier lenguaje de programación común de la siguiente forma edx = len, una simple declaración de variables.

Pero, no todos los registros los podemos usar a nuestro gusto, normalmente ya hay espacios de memoria que nos permiten realizar ciertas acciones.

        mov	ebx, 1
	mov	eax, 4

Si nosotros queremos escribir datos, esto se hace mediante el registro eax, y lo queremos escribir dentro de ebx, pesándole el valor de 1 para indicar que queremos imprimir algo en pantalla.

Y por último, tenemos la sentencia 0x80 donde solamente hacemos llamada al kernel, indicando al sistema que queremos comunicarnos con el.

        int	0x80
	mov	eax, 1
	int	0x80

Para que nosotros le digamos a la PC donde se encuentran nuestras variables tenemos que hacer uso nuevamente de las sections, en este caso nosotros le decimos al compilador que se encuentra en una función llamada .data

section	.data

Para la declaración de una variable, se pone el nombre de la etiqueta, y al no tener tipo de datos como en el resto de lenguajes de programación vamos a hacer uso de algo conocido como directivas de definición de datos.
Para este caso la letra d de data tiene como segundo indicador la directiva del "tipo de dato" si nosotros ponemos la letra b vamos a indicar que serán bytes

	msg	db	'Hello, world!', 0xa
	len	equ	$ - msg 

Solo le pasamos nuestro string que vamos a imprimir, y al final un 0xa para dar un salto de linea.

Pero podemos observar que tenemos otra variable, y esta vez con una mayor cantidad de símbolos, en resumen le estamos pasando nuestra variable mensaje para almacenar su longitud, ya que le tenemos que decir al sistema hasta donde tiene que imprimir, de lo contrario podría seguir ejecutando nuestro script hasta acabar el espacio libre de memoria RAM.

Si ejecutamos nuestro programa, deberíamos de ver en consola nuestro Hello, world!

Ya con esto hemos terminado el primer post, poco a poco estaremos viendo cosas más profundas de este hermoso lenguaje.