2016/11/13

Ekoparty 2016

Por motivos logísticos tanto laborales como familiares, en esta edición sólo pude asistir al training y casi nada a la conferencia.

El training, ingenieria inversa aplicada al analisis de malware [1][2],
dictado por Luciano Martins y Gabriela Nicolao, me encantó, me hizo sentir que me he equivocado en la vida por el camino que tomé. Recién el sábado recordé los dos hechos que me desviaron de ese camino:

El libro de assembler del 8086 [3] que salia 100. No sé que eran esos 100, pero era mucho. Mi familia me dijo "te lo compramos, pero es muy caro, ¿estás seguro?" y yo, un tanto tímido ante tamaña responsabilidad, juiciosamente dije que no, grave error.

El segundo fué que yo usaba el debug de D.O.S. para escribir programitas muy chiquitos en assembler e intentar comprender lo que hacían los ejecutables ajenos, no sabía nada de disassemblers, compiladores, estructuras internas de ejecutables y no me crucé con nadie que me diera una guía, era un camino muy difícil y desistí.


El curso estuvo muy, muy bueno, muy atrapante, con una única crítica que ya repetiré cuando me llegue el mail de encuesta. No soy muy partidario de la nivelación curricular sino de la on-demand, o sea, vamos explicando el tema y si hace falta nivelamos. Es método elegido fué nivelamos primero y vemos el tema despues.

No ha sido el caso, pero he asistido a cursos que han fallado por esto.

El otro inconveniente, ajeno al curso es que en el trabajo necesitaría dedicar el 80% de mi tiempo durante tres meses para poder adquirir y fijar los conocimientos para poder análisis rudimentarios y esto nunca va a ocurrir.



Tan mal quedé, que como no quería reescribir en minúscula en título para ponerlo acá y repudiando mi php, escribí en C un programa para convertirlo:


#include <ctype.h>
#include <stdio.h>

unsigned char buffer[] = "INGENIERIA INVERSA APLICADA AL ANALISIS DE MALWARE";

int main(int argc, char* argv[]) {
   for (int i=0; i < sizeof(buffer); i++) {
      buffer[i]=tolower(buffer[i]);

   }

   printf("%s\n", buffer);
   return 0;
}


Por supuesto, me equivoqué en un tipo, char * buffer en lugar de char buffer[] y aproveché para practicar con ddd (frontend gdb)

Pero esto es de blandengue y no tiene mucho que ver con el curso y de algún modo tengo que justificar estar escribiendo esto, así que lo volví a escribir pero en assembler:

[mainAS.c]

#include <stdio.h>

unsigned char buffer[] = "INGENIERIA INVERSA APLICADA AL ANALISIS DE MALWARE";

void tolowerAs(unsigned char * buffer, int size);

int main(int argc, char* argv[]) {
   printf("%s\n", buffer);
   tolowerAs(buffer,sizeof(buffer));
   printf("%s\n", buffer);
   return 0;
}


Yo soy un eterno principiante de assembler pues no lo puedo practicar y terminar de asimilarlo, así que a lo script kiddie me busqué un ejemplo de algo parecido y por supuesto no funcionó. Estaba sacando los parámetros del stack, pero con gdb ví que estaban en dos registros.




 Quise comprobarlo con objdump:


mainAS.o:     file format elf64-x86-64
Disassembly of section .text:

0000000000000000 <main>:
   0:    55                       push   %rbp
   1:    48 89 e5                 mov    %rsp,%rbp
   4:    48 83 ec 10              sub    $0x10,%rsp
   8:    89 7d fc                 mov    %edi,-0x4(%rbp)
   b:    48 89 75 f0              mov    %rsi,-0x10(%rbp)
   f:    be 33 00 00 00           mov    $0x33,%esi
  14:    bf 00 00 00 00           mov    $0x0,%edi

  19:    e8 00 00 00 00           callq  1e <main+0x1e>
  1e:    bf 00 00 00 00           mov    $0x0,%edi
  23:    e8 00 00 00 00           callq  28 <main+0x28>
  28:    b8 00 00 00 00           mov    $0x0,%eax
  2d:    c9                       leaveq
  2e:    c3                       retq 


Me imagino que donde dice mov $0x0, %edi al hacer el linkeo se pone el valor de donde realmente está el buffer. Lo mismo con los callq.

Entonces escribí esto:


[tolower.s]
.globl tolowerAs

# esi has the size
# edi has a pointer to the buffer

.text
tolowerAs:
   push %rax           # we will use %rax
   xor %rax,%rax

start_loop:            # start loop
  dec %esi               # point to last unprocessed position in buffer
  mov (%rsi,%rdi),%rax   # load that position
  cmp $32,%al            # skip if it is an space
  jz continue
  add $32,%rax           # convert to lower case
  movb %al,(%esi,%edi)   # put it in the buffer
continue:
  cmp $0,%esi            # finished?
  jz loop_exit
  jmp start_loop         # keep going

loop_exit:
  pop %rax
  ret



$  gcc -ggdb -std=c99 mainAS.c tolower.s -o tolower && ./tolower
INGENIERIA INVERSA APLICADA AL ANALISIS DE MALWARE
ingenieria inversa aplicada al analisis de malware


Magia, funciona. Ya sé que tendría que controlar que estuviera en el rango de las mayúsculas más que solamente el espacio, pero es una POC.


A la conferencia asistí una hora, una hora y tres horas. Sólo vi las charlas "Multiple vulnerabilities in Schneider Electric PLC", que sirve para mejorar mis conocimientos básicos para el proyecto CIAA y "Look Mom, I don't use  Shellcode: Browser Exploitation Case Study for IE 11" que sirve para apreciar cuanto hay por aprender.

Nos vemos la próxima, espero poder asistir a toda la conferencia.




[1] https://www.ekoparty.org/ingenieria-inv-malware.php
[2] cuando sigas leyendo verás por qué está sin acentos
[3] http://compusaurios.blogspot.com.ar/2012/10/libro-disco-para-pc-ensamblador-8088.html

No hay comentarios:

Publicar un comentario