sábado, 9 de marzo de 2013

How to Exploit: GDB mas a fondo.. -3-

Vamos a retomar con este tercer paper, y analizar lo que hace nuestro humilde programa codeado en C.

Antes que nada, vamos a eliminar nuestro analizaMe compilado anteriormente, y vamos a volverlo a compilar con un parametro nuevo que es la option flag "-g".
Genera mayor informacion de debug para ser utilizada por GDB.
Let's work!.

$> gcc -g analizaMe.c -o analizaMe (compilas con option flag -g)
$> chmod +x analizaMe (le damos permisos de ejecucion)
$> ./analizaMe (ejecutamos el binario para testear que todo haya salido correcto y recordar que hacia)

La variable contar vale: 0
La variable contar vale: 1
La variable contar vale: 2
La variable contar vale: 3
La variable contar vale: 4


Ok, todo funciono bien por fuera, analicemos que hace por dentro, con lo aprendido anteriormente en GDB.

ACLARACION: Puede que las direcciones de memoria de SUS PCS respecto a las mias en estos ejemplos NO SEAN IGUALES. Y seria algo logico..
Asi que no se preocupen, que podran seguir igual los ejemplos...


$> gdb -q ./analizaMe (abrimos el binario creado con nuestro debugger favorito :))

(gdb) b main  (breakpoint en la funcion principal main)
Punto de interrupción 1 at 0x8048415: file analizaMe.c, line 4. (respuesta del gdb).

(gdb) r (corremos el programa con el comando run o r abreviado)
Breakpoint 1, main () at analizaMe.c:4
4      for(contar=0; contar < 5; contar++)


Bien como vemos, para en el punto de interrupcion que nosotros mismos pusimos en main.
Y como vemos nos adjunta '+ informacion' gracias al option flag -g que agregamos.

Bien, vamos a verificar como esta el panorama..

(gdb) i r $eip
eip            0x8048415    0x8048415 <main+9>  (verificamos la informacion del registro $eip y vemos que apunta a esa direccion).

(gdb) x/3i $eip
=> 0x8048415 <main+9>:    mov    DWORD PTR [esp+0x1c],0x0
      0x804841d <main+17>:    jmp    0x8048438 <main+44>
      0x804841f <main+19>:    mov    eax,DWORD PTR [esp+0x1c]



Como anteriormente vimos, la opción 'i' era la de instrucción. Le decimos a GDB que nos muestre solo las próximas 3 instrucciones a ejecutarse para guiarnos de que esta haciendo el programa y que va a hacer.
Si hicieron la tarea y refrescaron un poco assembler, fundamental para explotar cualquier vulnerabilidad... recordamos también cuando explique algunas instrucciones de assembler, como por ejemplo 'mov'.

A simple vista entonces, GDB nos dice que donde ahora mismo esta parado, va a realizar una operacion en la cual 'movera' el valor de la derecha '0x0' hacia la izquierda en donde tenemos como destino una direccion en memoria (esp+0x1c). Nota: Es muy comun ver este tipo de direcciones, porque si recordamos sabemos que EAX, EBX, EDI, ESI, ESP, etc son registros
y es comun leer ESP+4 o EBP-4 y cosas asi, este caso nos dice que lo va a mover a ESP+0x1c.
0x1c en decimal equivale a 28. Por lo que seria $esp+28.

Si recordamos tambien que el programa paro en nuestro breakpoint en main justo cuando comenzaba el for y nos arrojo esta informacion:
"4   for(contar=0; contar < 5; contar++)"
Podríamos deducir que ese valor 0x0 que va a mover, es el que le dimos en el FOR a nuestra variable llamada 'contar'.

Analicemos esa dirección de memoria que valor contiene en este momento con el programa pausado en nuestro breakpoint:

(gdb) i r $esp
esp            0xbffff270  (En el registro ESP encontramos una direccion de memoria 0xbffff270)

Por lo tanto BFFFF270 + 1C  (ESP+28) = BFFFF28C. (tranquilos, todo eso el debugger lo obvia por nosotros y lo sabe, pero para que entendamos, otra aclaracion for dummys, siempre que veamos 0x12345678 esa '0x' del principio nos indica que es una notacion Hexadecimal, la direccion seria 12345678.)

Bien, volviendo a la practica verificamos con GDB, la siguiente linea:
=> 0x8048415 <main+9>:    mov    DWORD PTR [esp+0x1c],0x0

(gdb) x/x $esp+0x1c
0xbffff28c:    0xb7fc1000

Como vemos nos responde lo que anteriormente les aclare, esp contiene una direccion y esa direccion + 28 (1c) es BFFFF28c, y GDB nos dice que esa direccion contiene el siguiente valor: 0xb7fc1000.

Por lo tanto lo que pasaria ahora es que al ejecutar la siguiente instruccion:
"mov    DWORD PTR [esp+0x1c],0x0" ..ese valor dejaria de existir y pasaria a ser 0x0 con la operacion de mov.

Voy a comentarles un nuevo comando el cual nos permite por asi decirlo, crear temporalmente un 'acceso directo' a una determinada direccion, para no tener que escribirla constantemente y verificar si tiene cambios en su contenido:

(gdb) print $esp+0x1c
$1 = (void *) 0xbffff28c

(Le decimos a gdb que nos cree una variable temporal de la direccion de memoria $esp+0x1c, para accederla facilmente cuando querramos, y gdb nos responde diciendo que se creo la variable $1)

Ahora usaremos el comando 'nexti' para ejecutar  la siguiente instruccion, nexti hace que el programa vaya paso a paso, instruccion por instruccion, luego del breakpoint que pusimos.

(gdb) nexti
0x0804841d    4      for(contar=0; contar < 5; contar++)

Ejecutamos nexti. Veamos si la direccion $esp+0x1c (0xbffff28c)    0xb7fc1000 que contenia valores aleatorios.. ha cambiado.

(gdb) x/x $1  
0xbffff28c:    0x00000000

Efectivamente, se cumplio la operacion 'mov' y movio el valor '0x0' a la direccion de esp+0x1c.
Veamos donde esta parado ahora el registro EIP y cuales son sus siguientes operaciones:

(gdb) x/10i $eip  (le decimos a gdb que nos arroje las proximas 10 instrucciones).



Como vemos en la imagen, EIP apunta a una instruccion en donde hay un JMP (JUMP), un salto el cual tiene como destino la direccion 0x8048438. Que es la 7ma linea de las 10 que pedimos que nos muestre. Le damos a nexti.

(gdb) nexti
0x08048438    4      for(contar=0; contar < 5; contar++)

Vemos que seguimos en el FOR.

(gdb) x/3i $eip
=> 0x8048438 <main+44>:    cmp    DWORD PTR [esp+0x1c],0x4
      0x804843d <main+49>:    jle    0x804841f <main+19>
      0x804843f <main+51>:    leave

Ok, confirmamos que salto a la direccion 8048438 como sabiamos.
Y ahora lo que va a hacer es a comparar mediante la instruccion 'cmp'. El valor 0x4 (4) contra el valor que esta guardado en la direccion [esp+0x1c] (nuestra famosa direccion que podemos acceder temporalmente mediante la variable $1 que seteamos anteriormente).
Como sabemos por la ultima vez que vimos la direccion esa contenia el valor '0'. Por lo tanto comparara el valor 4, contra el valor 0. Exactamente en esta parte del FOR estamos: "contar < 5"
Le damos a nexti...

(gdb) nexti
0x0804843d    4      for(contar=0; contar < 5; contar++)

(gdb) x/i $eip
=> 0x804843d <main+49>:    jle    0x804841f <main+19>

Luego de ejecutar 'nexti' nos lleva a la siguiente instruccion, y si la verificamos con examine para ver donde esta parado EIP, nos encontramos con un JLE. Como recordamos, J.. es sinonimo de JUMP, pero en este caso es un salto 'condicional' que significa JUMP LESS EQUAL.
Y quiere decir que SALTA, SI ES MENOR o IGUAL.....

Como evidentemente esto es cierto, ya que 0 es menor que 4.. entonces salta a la direccion 0x804841f.

(gdb) x/i $eip
=> 0x804841f <main+19>:    mov    eax,DWORD PTR [esp+0x1c]

Estábamos en lo correcto, y salto nomas a la direccion previamente dicha.
Si verificamos las siguientes 10 instrucciones:



Observamos que en la 4ta linea de las 10 solicitadas, hay un "CALL 0x80482F0".
Que es el encargado de llamar a la funcion PRINTF. (La que imprime en pantalla el primer mensaje de "La variable contar vale: 0" que observamos al ejecutar el programa).

Para que se entienda, cuando llegamos a una instruccion donde hay un CALL como en este caso el programa se desvia a una subrutina, es como si fuese una porcion de codigo aparte en la cual se realizan otras operaciones y una vez que se concluyen al final de ese codigo de la subrutina hay una instruccion llamada RET (de return/regreso).
Vean la siguiente imagen..















 Por lo tanto, luego de la llamada a esa funcion, el RET deberia dejarnos justito en la siguiente direccion 0x8048433:













 Ok, siguiendo con nuestro analisis, ya estamos por el final, espero no se hayan perdido.

(gdb) x/5i $eip
=> 0x8048433 <main+39>:    add    DWORD PTR [esp+0x1c],0x1
      0x8048438 <main+44>:    cmp    DWORD PTR [esp+0x1c],0x4
      0x804843d <main+49>:    jle    0x804841f <main+19>
      0x804843f <main+51>:    leave
      0x8048440 <main+52>:    ret

EIP apunta a una instruccion conocida llamada 'add' la cual sirve para 'sumar' dos operandos y lo guarda en el lugar destino, en este caso 0x1 en nuestra conocida direccion de memoria ;).

Le damos a 'nexti'.. y luego verificamos despues de esta operacion si el valor de esa direccion de memoria tuvo algun cambio..

(gdb) nexti
0x08048438    4      for(contar=0; contar < 5; contar++)

(gdb) x/x $1
0xbffff28c:    0x00000001

Efectivamente.. ahora contiene el valor de 1.
Si miramos un poco mas las siguientes dos instrucciones:

(gdb) x/2i $eip
=> 0x8048438 <main+44>:    cmp    DWORD PTR [esp+0x1c],0x4
      0x804843d <main+49>:    jle    0x804841f <main+19>

Ya nos resulta conocida, y es que esta nuevamente comparando el valor de 4 con el ahora 1.
Luego viene el ya explicado JLE - va a saltar si es menor o igual que 4.
Como lo és, salta a 0x804841f. Y así seguiría el loop.. hasta que si seguimos analizando el programa paso a paso con nexti y verificando el valor de la direccion en $1.. llegaríamos a:

(gdb) x/x $1
0xbffff28c:    0x00000005

(gdb) x/i $eip
=> 0x8048438 <main+44>:    cmp    DWORD PTR [esp+0x1c],0x4

(gdb) x/5i $eip
=> 0x8048438 <main+44>:    cmp    DWORD PTR [esp+0x1c],0x4
      0x804843d <main+49>:    jle    0x804841f <main+19>
      0x804843f <main+51>:    leave
      0x8048440 <main+52>:    ret


Luego de ir sumándole 1 por cada loop de imprimir en pantalla, nuestra famosa dirección contiene el valor de 5.
Por lo tanto al siguiente 'cmp', de comparar si 5 es menor o igual que 4? y matemáticamente es negativo, NO se cumpliría el JLE condicional por lo que las siguiente dos instrucciones serian:

(gdb) x/2i $eip
=> 0x804843f <main+51>:    leave
      0x8048440 <main+52>:    ret
      0xb7e344d3 <__libc_start_main+243>:    mov    DWORD PTR [esp],eax
      0xb7e344d6 <__libc_start_main+246>:    call   0xb7e4dfb0 <exit>

(gdb) nexti
[Inferior 1 (process 5324) exited with code 034]

De esta manera finaliza el tercer paper.. y uno de los mas largos.
Gracias :).


#c0nfused - allmenage@gmail.com - http://insecuritynotes.blogspot.com


miércoles, 6 de marzo de 2013

#How to exploit: Un poco de Assembler y GNU Debugger. -2-

#How to exploit: Un poco de Assembler y GNU Debugger. 




Retomando con el paper anterior, y nuestro código de ejemplo, vamos a repasar un poco sobre Assembler y GNU Debugger durante esta segunda parte. Veremos por 'encima' el tema de assembler ya que mi interes no es un tutorial de este, sino repasarlo para introducirlo con el Debugger.

Para invocar al GDB
Utilizaremos el crudo y puro gdb desde la linea de comandos con sintaxis INTEL. 
Para configurar GDB con sintaxis INTEL, vamos a hacer lo siguiente:


$> sudo gedit /etc/gdb/gdbint 

Y luego pegamos al final la siguiente linea y guardamos el archivo:

set disassembly-flavor intel

La sintaxis de intel nos mostrara las operaciones de esta manera en gdb:

instrucciones "[destino],[origen]" 
Por ejemplo: "mov ebx, eax"


En este ejemplo el valor del registro 'eax', sera movido al registro 'ebx'. 
Recordar que las operaciones del origen y destino pueden ser un valor, 
una dirección de memoria, o un registro como en este caso.

Operaciones comunes que veremos en assembler para refrescar memoria:

MOV: Mueve contenido
INC: Incrementa de a 1 el valor
DEC: Resta de a 1 el valor
ADD: Suma  
SUB: Resta
CMP: Compara dos registros o un registro y direccion de memoria.
JMP/JNE etc: Todos los que empiecen con J.. son saltos condicionales e inccondicionales. 
Hay mas pero como dije, son los basicos y el paper no esta orientado a un manual de assembler.


 

# GDB

El debugger es una herramienta que nos permite ejecutar programas y analizarlos. Ya sea para localizar errores o entender un poco mas a fondo que es lo que hace una determinada aplicación.

GDB dispone de un comando muy particular y uno de los mas útiles a la hora de verificar la memoria.
Este comando se llama 'examine' y como su nombre indica, nos sirve para examinar la memoria.
GDB puede examinar detenidamente cada aspecto de la ejecución de un programa, ejecutarlo, detenerlo, verificar los registros, direcciones de memoria, lo que se nos ocurra.
(Lo practico de GDB también es que la mayoría de los comandos se pueden 'abreviar', por ejemplo examine se puede acortar a una simple 'x' y este se reconoce como un comando)

El comando examine, tiene varias maneras de arrojar la información que requerimos ver en una determinada direccion de memoria. Podemos especificar el formato en el que se muestra usando alguna de las siguiente abreviaturas:

x = Muestra el resultado en Hexadecimal
u = Muestra el resultado en Decimal.
o = Muestra el resultado en Octal.
t = Muestra el resultado en Binario.


Veamos un ejemplo con nuestro pequeño programa del paper anterior que adjunto nuevamente:

-----------------------------------------------------
#include <stdio.h>
int main() {
  int contar;
  for(contar=0; contar < 5; contar++)
  {
    printf("La variable contar vale: %i \n", contar);
  }
}

-----------------------------------------------------


$> gdb -q ./analizaMe
De esta manera le pasamos a gdb el binario a debugguear.

(gdb) break main
Punto de interrupción 1 at 0x804840f (en mi caso esto nos responde gdb al poner un break)

Le decimos que genere un breakpoint en la funcion principal "main". Un breakpoint no hace otra cosa que poner una barrera una vez que se ejecuta el programa, le dice al gdb que cuando llegue a nuestro breakpoint el programa se parara obligatoriamente ahi en ese break. Podemos poner varios break, de momento solo haremos uno en la funcion main.

(gdb) run
Breakpoint 1, 0x0804840f in main () (esto nos responde el gdb al encontrar el break que seteamos)

Corremos el programa desde el debugger con run o tambien con una simple 'r' y va a parar en el primer breakpoint que seteamos en la funcion "main"

(gdb) info register

eax            0x1    1
ecx            0xbffff344    -1073745084
edx            0xbffff2d4    -1073745196
ebx            0xb7fc1000    -1208217600
esp            0xbffff2a8    0xbffff2a8
ebp            0xbffff2a8    0xbffff2a8
esi            0x0    0
edi            0x0    0
eip            0x804840f    0x804840f <main+3>
eflags         0x246    [ PF ZF IF ]
cs             0x73    115
ss             0x7b    123
ds             0x7b    123
es             0x7b    123
fs             0x0    0
gs             0x33    51


Este comando "info register" nos permite ver el estado actual de los registros.
Como ven obtenemos un status de todos los registros de ese preciso momento.

(gdb) info register eip
eip            0x804840f    0x804840f <main+3> (respuesta del gdb)

Podemos filtrar a algun registro en particular escribiendolo al lado como en el ejemplo 'eip'.
Ademas, como les conte antes podemos 'abreviar' este comando asi: "i r eip"
Vemos como EIP contiene el valor 0x804840f.

(gdb) x/x $eip
0x804840f <main+3>:    0x83f0e483 (ahora examinamos la memoria a la que esta señalando el registro EIP usando la direccion almacenada en EIP). Vemos que donde arriba EIP contenia '0x804840f', examinamos este registro y contiene lo siguiente: 0x83f0e483.

De esa manera usamos el 'examine' abreviado con la primer 'x', luego le decimos que nos arroje la info en hexadecimal con la segunda 'x'. Y el registro 'eip'. Fijense que en este caso hay que poner el registro luego de un $. A diferencia de el info register que no lo anteponiamos.

Tambien se puede anteponer un numero al formato del comando examine, para examinar varias unidades en esas direcciones objetivos que tengamos. Por ejemplo:

(gdb) x/4x $eip
0x804840f <main+3>:    0x83f0e483    0x44c720ec    0x00001c24    0x19eb0000

Las unidades tienen un tamaño predeterminado de 4 bytes. Conocidas como WORD.
De la misma manera que podemos cambiar el formato que nos arroja el resultado con 'examine' ya sea en hexadecimal, octal, binario o decimal, tambien podemos cambiar el tamaño de las unidades que estamos examinando, agregandole una letra de tamaño al final de la de formato y estos son:

b: byte
h: half-word (2 bytes)
w: word (4 bytes)
g: giant o qword (8 bytes)



Veamos un ejemplo practico:

1) (gdb) x/4xb $eip
0x804840f <main+3>:    0x83    0xe4    0xf0    0x83

2) (gdb) x/4xh $eip
0x804840f <main+3>:    0xe483    0x83f0    0x20ec    0x44c7

3) (gdb) x/4xw $eip
0x804840f <main+3>:    0x83f0e483    0x44c720ec    0x00001c24    0x19eb0000

4) (gdb) x/4xg $eip
0x804840f <main+3>:    0x44c720ec83f0e483    0x19eb000000001c24
0x804841f <main+19>:    0x042444891c24448b    0xe8080484e82404c7


1- Como vemos en el ejemplo uno, le decimos a gdb que nos examine el registro $eip, y nos arroje en 4 unidades, en hexadecimal, y en tamaño byte.
2- En el segundo de la misma manera pero ya con 2 bytes.
3- Igual pero con 4 bytes.
4- Por ultimo igual, pero con 8 bytes.

  • Resumen de este paper
  1. Ya sabemos, compilar un codigo fuente, gcc analizaMe.c.
  2. Sabemos invocar el gdb y pasarle un binario para debuggearlo: gdb -q ./analizaMe
  3. Sabemos que para poner un breakpoint y que se detenga el programa invocamos el comando 'break' + nombre de la función, o dirección en memoria donde queremos que pare.
  4. Sabemos que una vez que para en el breakpoint, podemos verificar el status de los registros mediante 'info register' o alguno en particular como en nuestro caso anterior 'info register eip'.
  5. Sabemos que la herramienta 'examine' nos permite verificar todas la memoria, direcciones y valores que se nos ocurra y arrojar el resultado de la manera que mas comoda nos parezca, como en el ejemplo de 'x/x $eip' para ver el valor que contiene el registro EIP en ese momento y que nos arroje el resultado en hexadecimal.
  6. Sabemos como mostrar por unidades como "x/2x"
  7. Sabemos como mostrar examine en tamaño de unidades b,h,w,g (byte, 2bytes,4bytes, 8bytes).

De momento dejamos acá esta segunda parte, y ya pronto escribo la tercera.
c0nfused.

domingo, 3 de marzo de 2013

#How to Exploit. - Comienzo.. -1-


#How to Exploit. - Comienzo..
Estos papers que pienso escribir iran enfocados para aquellos que tengan curiosidad sobre como explotar vulnerabilidades, descubrirlas, realizar ingeniería inversa, etc etc..
Me enfocare desde mi entorno Linux, pero es viable para Windows también, salvo excepciones de algunas herramientas, la esencia es la misma.

¿Requisitos?.
Simplemente tener conocimientos basicos de programación.. compiladores, arquitectura, todo lo que nos rodea y usamos habitualmente, y en otros casos lo usamos pero no tenemos idea que lo hacemos.. Un requisito mas podria ser el saber y querer entender 'el porque de las cosas', no tirar un exploit a lo scriptkiddie. De todas maneras intentare enfocarme y detallar lo maximo que pueda. Para el resto, Google. Usare muchas herramientas como GDB, Objdump, IDA, GCC, Python,etc, etc..

 #Primero, lo aburrido, pero necesario para entender.
Vamos a familiarizarnos un poco con el código fuente, compilar, desensamblar, algunas herramientas que ayudan este proceso y todas esas cosas.
Para empezar tenemos preparado para esta prueba un pequeño codigo fuente  "analizaMe",
esta codeado en C, y es de lo mas básico, pero me ayudara a explicarlo de manera rápida.. asi que deberíamos compilarlo. ¿Compilar?.

Suponiendo que si llegan hasta aca, siguieron al pie los requisitos de tener conocimientos basicos de programacion, assembler, etc..  no sera muy dificil entender lo que refresco por encima a continuacion. Para comprender realmente el significado de Compilar, tenemos que movernos al origen de los procesadores, pero resaltaremos lo importante, el procesador x86.
Intel desarrollo la cpu 8086 que fue el priemr procesador x86.. luego creo otros mas avanzados como el 386, 486.. etc.. El procesador x86 que se refiere a los anteriormente mencionados, posee varios registros que son como las 'variables' internas para dicho procesador. Algunos de estos registros son los conocidos 'EAX,ECX,EDX,EBX', son registros usados para varios fines, entre ellos como contadores o acumuladores.. sirven como variables temporales para el procesador cuando esta ejecutando instrucciones. Hay 4 registros mas a resaltar que son 'EBP, ESP, ESI y EDI'.
Estos registros llevan el nombre de EBP puntero base, ESP puntero de pila, ESI indice de origen y EDI indice destino. El puntero EIP, es el puntero de instruccion, es quien nos ayuda y nos señala a la instruccion que el procesador esta leyendo en ese preciso momento.

Bueno, como sabran con el codigo fuente no vamos a poder hacer nada, hasta el momento en el que lo compilamos y lo convertimos en un archivo ejecutable.
Let's Go!

El programa analizaMe:

#include <stdio.h>
int main() {
  int contar;
  for(contar=0; contar < 5; contar++)
  {
    printf("La variable contar vale: %i \n", contar);
  }
}

Bien, lo primero sera explicar un poco este codigo, y luego compilarlo.
Basicamente y de manera rapida, este programa lo que hace es mostrar en pantalla un mensaje y el valor de la variable 'contar'. Mientras sea la variable menor de 5 el mensaje sera mostrado via la funcion 'printf'. Cuando llega a 5, el programa finaliza. Analicemoslo mas en detalle..
(cada vez que vean $> es la manera de decirles que son comandos a tipear en la shell)

Vamos a compilarlo con GCC (es el GNU Compiler Collection), la funcion de los compiladores basicamente es la de convertir el codigo fuente en lenguaje maquina, la manera en la que entienden los procesadores.

$> gcc analizaMe.c -o analizaMe
$> chmod +x
$> ./analizaMe


Invocamos al compilador y le decimos que nos compile el codigo fuente en c. El resultado es un nuevo archivo llamado analizaMe. Le damos permisos de ejecución. Y luego lo ejecutamos..
El resultado es el siguiente:

La variable contar vale: 0
La variable contar vale: 1
La variable contar vale: 2
La variable contar vale: 3
La variable contar vale: 4

Ok, vemos el resultado del programa, pero veamos que es lo que no esta a simple vista, como es que funciona este programa realmente..

Invocamos en la shell, a ojbdump, es una gran utilidad para desensamblar facilmente binarios compilados.

$> objdump -D analizaMe -M intel |grep -A15 main.:


(Le decimos a objdump que (-D) desensamble el binario 'analizaMe', (-M intel) que nos muestre el resultado con la sintaxis Intel ya que es mas prolija y acostumbrado que la de AT&T (por default objdump nos arroja esta ultima por eso es que forzamos a que nos muestre con la de Intel)).. (grep -A15 main.:) invocamos a 'grep' y aplicamos una expresión regular para que nos muestre solo las primeras 15 lineas de la funciona principal, main.
Podríamos no limitar a 15, pero arrojaria muchas lineas innecesaria para este momento.
Y hasta acá esta primera parte..