Crear un laboratorio para analizar malware

0. Introducción

Cuckoo Sandbox es un software de código abierto para la automatización de análisis de archivos sospechosos, como actualmente son los Malware y Crimeware que afectan mucho a los sistemas Financieros.

Para ello Cuckoo hace uso de componentes personalizados que monitorean el comportamiento de los procesos maliciosos mientras se ejecuta en un entorno aislado.

0.1 Material

En esta práctica vamos a necesitar: 

·Ubuntu 16.04 (Como sistema base) 
    ·Cuckoo +Requisitos   
·Windows XP SP3 (En máquina virtual) 
    ·Python 2.7

1. Requisitos (En Ubuntu)

$ sudo apt-get install python
$ sudo apt-get install python-pip
$ sudo apt-get install python-sqlalchemy
$ sudo apt-get install python-dpkt python-jinja2 python-magic python-pymongo python-libvirt python-bottle python-pefile ssdeep
$ sudo pip install dpkt jinja2 pymongo bottle pefile
$ sudo apt-get install build-essential git libpcre3 libpcre3-dev libpcre++-dev
$ sudo pip install Django==1.8.4
$ sudo pip install requests
$ sudo pip install python-dateutil

pydeep:
$ cd /opt
$ git clone https://github.com/kbandla/pydeep.git pydeep
$ cd /opt/pydeep/
$ sudo python setup.py build
$ sudo python setup.py install

yara:
$ sudo apt-get install automake -y
$ cd /opt
$ svn checkout http://yara-project.googlecode.com/svn/trunk/yara
$ cd /opt/yara
$ sudo ln -s /usr/bin/aclocal-1.11 /usr/bin/aclocal-1.12
$ ./configure
$ make
$ sudo make install
$ cd yara-python
$ python setup.py build
$ sudo python setup.py install

tcdump:
$ sudo apt-get install tcpdump
$ sudo setcap cap_net_raw,cap_net_admin=eip /usr/sbin/tcpdump
$ sudo apt-get install libcap2-bin
$ sudo chmod +s /usr/sbin/tcpdump

$ sudo apt-get install mongodb
 
Cuckoo:
$ git clone git://github.com/cuckoobox/cuckoo.git
$ sudo pip install -r cuckoo/distributed/requirements.txt
$ sudo pip install -r cuckoo/requirements.txt
$ sudo cucko/utils/community.py --all --force

Virtual Box (Solo si usas Kernel 3.5) - Para saber el kernel introduce el comando "uname -a" en la terminal.
$ sudo apt-get install linux-headers-3.5.0.17-generic

2. Configuración de Windows XP

2.1 Configuración Virtual box

INICIAR VIRTUALBOX COMO SUDO ("sudo virtualbox") ya que sino alfinal cuckoo no encontrará la máquina virtual.

Especificaciones de la máquina virtual:

1GB RAM memory
10 GB of hard disk space
VDI format for the virtual disk
Dynamically allocated storage
Windows XP SP3

     ·Deberemos ir a Preferencias - Red - Redes Solo-anfitrion y añadir un nuevo adaptador de red. (El nombre por defecto es vboxnet0) La IP es por defecto 192.168.56.1

·Luego iremos a nuestra máquina virtual de xp y le cambiaremos la tarjeta de red por Adaptador solo-anfitrion.

    2.2 Configuracion de XP

·Deshabilitar el firewall y las actualizaciones
·Instalar python 2.7
·Instalar PIL (Python Imaging Library)
·Instalar Guest Additions
·(OPCIONAL) Intalar aplicaciones estándar como Firefox, Word, Adobe Reader... (oldapps)
·Deberemos configurar una IP estática:

IP: 192.168.56.101
Mascara: 255.255.255.0
Puerta de Enlace: 192.168.56.1
DNS: 8.8.8.8

2.3 Instalar agente cuckoo Windows XP

1º Copiamos el agente.py que vendrá en el repositorio cuckoo:  “cucko/agent/agent.py” al Windows XP en la carpeta C:\Python27.
2º Ponemos para que se ejecute al inicio (C:\Document and settings\username\Start Menu\Programs\Startup)
3º Le cambiamos la terminación por *.pyw (Así no invocará la consola).
4º Después de ejecutar el ajente se quedará un servicio abierto en el puerto :8000 (Podemos comprobar que es así con el comando netstat -aon).

3. Instalación de cuckoo

Antes deberemos configurar las reglas de forwarding y filtering usando IPTABLES (Más informacion).
$ iptables -A FORWARD -o [Interfaz de red con salida a internet] -i vboxnet0 -s 192.168.56.0/24 -m conntrack --ctstate NEW -j ACCEPT
$ iptables -A FORWARD -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
$ iptables -A POSTROUTING -t nat -j MASQUERADE
$ sysctl -w net.ipv4.ip_forward=1 

3.1 Creación de Usuario

$ sudo adduser cuckoo
$ sudo usermod -G vboxusers cuckoo
$ sudo usermod -G libvirtd cuckoo

3.2 Configuración de Cuckoo

Vamos a configurar cuckoo, para ello nos vamos a la carpeta conf/
Empezamos:
1ºArchivo auxiliary.conf
[sniffer]
enabled = yes
tcpdump = [ruta tcpdump (Podemos comprobarlo con el comando "locate tcpdump"]

2º Archivo cuckoo.conf
[cuckoo]
version_check = off

[resultserver]
ip = [IP del adaptador VBOXNET0]

3º Archivo kvm.conf
[kvm]
machines = [Nombre de la maquina virtual]

[cuckoo1] ---Cambiar por ---> [Nombre de la maquina]
label = [Nombre de la maquina]
ip = [IP de VBOXNET0] (La IP debe estar en la red de VBOXNET0)

4ºArchivo processing.conf
[memory]
enabled = yes

 5º Archivo virtualbox.conf
Comprobamos que el path está bien (Hacemos "locate vboxmanage" para saber la ruta)
machines = [Nombre de la maquina virtual]
[cuckoo1] ---Cambiar por ---> [Nombre de la maquina]
label = [Nombre de la maquina]
ip = [IP de WindowsXP]

6º Archivo reporting.conf
[mongodb]
enabled = yes

7º Archivo /web/web/local_settings.conf
DEBUG = False

Y ya tendremos todos los archivos configurados. Ahora tendremos que hacer una snapshot de la máquina, para ello usaremos los siguientes comandos:
$ sudo vboxmanage snapshot "windows-cuckoo" take "windows-cuckooSnap01" --pause
$ sudo vboxmanage controlvm "windows-cuckoo " poweroff
$ sudo vboxheadless --startvm "windows-cuckoo"

4. Funcionamiento

La máquina de Windows XP deberá estar apagada, sino saltará un error.
Iniciamos cuckoo en Ubuntu.

$ sudo ./cuckoo.py

Cuckoo estará a la espera de que hagamos submit de una muestra:

Para subir una muestra, primero la descargamos, una vez descargada la subimos con el comando:

$ cd utils/
$ sudo ./submit.py [Ruta archivo malicioso]

Cuckoo empezará el análisis en la máquina virtual
Una vez acabado podremos ver el resultado en la parte web de Cuckoo, arrancamos la parte web (Más información):

$ cd web/
$ sudo ./manage.py runserver [IP:Puerto] --insecure

5. +Documentación:

Para más documentacion acerca de cuckoo os dejo un enlace de un libro que recomiendo (Explica todo desde lo más básico) y el github del proyecto.

Libro
Github

6. Vídeo DEMO:

 

Construir Qubes-Os desde cero

Definición:

Qubes OS es una distribución de linux cuya característica principal radica en que separa la ejecución de sus componentes, servicios y también las aplicaciones en máquinas virtuales.

Ofrece seguridad a sus usuarios pasando por un mecanismo que separa y mantiene aislados a varios dominios o “zonas de seguridad” (es decir, uno para el visor de imágenes y otro para el navegador web, etc.).

Con Qubes OS, si llegas a ser blanco de un ataque malicioso, el atacante no podrá apoderarse de tu ordenador. Este proyecto se encuentra ya en su versión 3.0, que está basado en la capa Hypervisor Abstraction Layer y utiliza la tecnología de virtualización Xen 4.4.

Qubes OS equivale a un hipervisor del tipo 1, también denominado nativo, unhosted o bare metal (sobre el metal desnudo), es software que se ejecuta directamente sobre el hardware, para ofrecer la funcionalidad descrita.

Creando Qubes-Os

Existe un sistema de construcción totalmente automatizado para Qubes, que descarga, construye  y empaqueta todos los componentes de Qubes, y finalmente crea un .ISO de instalación lista para su uso.

Para usarlo es necesario utilizar una distribución basada en paquetes rpm (En este caso se usará Fedora 24 Workstation), y también es necesario instalar los siguientes paquetes:

     git
     createrepo
     rpm-build
     make
     wget
     rpmdevtools
     python-sh
     dilog
     rpm-sign

■ sudo dnf update
■ sudo yum install git createrepo rpm-build make wget rpmdevtools python-sh dialog rpm-sign

El sistema de construcción crea ambientes de construcción en entornos enjaulados y por lo tanto no se necesitan otros paquetes en el host. Todos los archivos creados por el sistema de construcción se encuentran dentro del directorio qubes-constructor. La construcción completa requiere 25 GB aproximadamente de espacio libre, así que tenlo en cuenta a la hora de decidir dónde colocar este directorio. 

El sistema de construcción se configura a través del archivo builder.conf - se debe copiar el builder.conf.default adjunto, y modificarlo según sea necesario, por ejemplo:

■ cp example-configs/qubes-os-master.conf builder.conf
# Editar el archivo builder.conf y seleccionar las siguientes variables:
NO_SIGN=1

Un requisito adicional útil es que 'sudo root' trabaje sin ningún tipo de símbolo, que es por defecto en la mayoría de distribuciones (por ejemplo, 'sudo bash' le trae el intérprete de comandos sin pedir ninguna contraseña). Esto es importante ya que el constructor tiene que cambiar a root y luego de vuelta al usuario varias veces durante el proceso de construcción.

Además, si la construcción con la firma habilitada (por lo NO_SIGN no se ha establecido), se debe ajustar en el archivo ~ /.rpmmacro para que apunte a la clave GPG utiliza para firmar el paquete, por ejemplo:

%_signature gpg
%_gpg_path /home/user/.gnupg
%_gpg_name AC1BF9B3  # <-- Key ID used for signing

También se recomienda utilizar una contraseña vacía para la clave privada utilizada para firmar. Contrariamente a la creencia popular, esto no afecta a su clave de seguridad o las fuentes - si alguien ve comprometido su sistema, entonces el juego ha terminado, si se utiliza la frase de contraseña adicional para la clave o no.

Por lo tanto, para construir Qubes se podría hacer:

# Import the Qubes master key
gpg --recv-keys 0xDDFA1A3E36879494

# Verify its fingerprint, set as 'trusted'.
# This is described here:
# https://www.qubes-os.org/doc/VerifyingSignatures

wget https://keys.qubes-os.org/keys/qubes-developers-keys.asc
gpg --import qubes-developers-keys.asc

git clone git://github.com/QubesOS/qubes-builder.git qubes-builder
cd qubes-builder

# Verify its integrity:
git tag -v `git describe`

cp example-configs/qubes-os-master.conf builder.conf
# edit the builder.conf file and set the following variables:
# NO_SIGN="1"

# Download all components:

make get-sources

# And now to build all Qubes rpms (this will take a few hours):

make install-deps

make qubes

# ... and then to build the ISO

make iso

Y esto debe producir una nueva ISO.
También es posible construir componente seleccionado por separado. P.ej. para compilar única interfaz gráfica de usuario agente de virtualización / daemon: 

■ make gui-daemon

QubesOs-Builder

Github

Fortificando un FreeBSD

1. Definición:

FreeBSD es un avanzado sistema operativo para arquitecturas x86 compatibles (como Pentium® y Athlon™), amd64 compatibles (como Opteron™, Athlon™64 EM64T), UltraSPARC®, IA-64, PC-98 y ARM. 
FreeBSD es un derivado de BSD, la versión de UNIX® desarrollada en la Universidad de California, Berkeley. FreeBSD es desarrollado y mantenido por un numeroso equipo de personas. El soporte para otras arquitecturas está en diferentes fases de desarrollo.

En este post se verá como installar freeBSD, instalar un escritorio y una parte de seguridad.
Este es un buen post si quieres empezar con freeBSD. 

DOCS

http://ftp.freebsd.org/pub/FreeBSD/doc/es/books/handbook/ https://www.freebsd.org/doc/handbook/ 

2. Instalación freeBSD:

Descarga FreeBSD (Yo he utilizado FreeBSD-11.0-RC3-amd64-dvd1.iso): ftp://ftp.freebsd.org/pub/FreeBSD/releases/ISO-IMAGES/

Instalamos el freeBSD (No me pararé en explicar como se instala ya que es muy sencillo, dejo un enlace de la documentación oficial en la que explica la instalación muy detallada)
https://www.freebsd.org/doc/es/books/handbook/install-start.html

Una vez instalado debemos configurarlo para ello iniciamos como root.
Explicaré como instalar los paquetes de dos formas: Con conexión a internet y sin conexión a internet.

2.1 Instalación de paquetes con conexión a internet

¡Atención!

Cada "■" es un comando en la terminal.

Empezaremos a configurar la red:
■ ee /etc/resolv.conf

En el archivo descomentaremos la variable nameserver y añadimos otro nameserver quedando así:

nameserver [IP LOCAL]
nameserver 8.8.8.8
nameserver 127.0.0.1

Para salir del editor presionamos la tecla ESC.
 
Una vez lista la red descargamos los ports:
■ portsnap fetch

Y los extraemos:
■ portsnap extract

Instalamos el gestor de paquetes:
■ pkg

Ahora tocará instalar xorg (Xorg es una aplicación pública, una implementación en código abierto del sistema X window versión 11.)
■ pkg install xorg

Lo configuraremos adaptándolo así a nuestra pantalla con:
■ Xorg -configure

Instalamos el escritorio que queramos (En mi caso instalaré gnome3):
■ pkg install gnome3

2.2 Instalación de paquetes sin internet (Probado en freeBSD 10.1)

1º Empezaremos creando un directorio llamado /dist para montar el DVD.

■ mkdir -p /dist
■ mount -t cd9660 /dev/cd0 /dist
 
2º Asegurate de que REPOS_DIR está apuntando a tu repositorio local
■ export REPOS_DIR=/dist/packages/repos

o al csh
■ setenv REPOS_DIR /dist/packages/repos

3º Bootstrap pkg e instala los paquetes:
■ pkg bootstrap   
■ pkg install xorg-server xorg gnome2 [...]

Para más información consultar: https://www.freebsd.org/releases/10.1R/errata.html

3. Configuración del escritorio

En el siguiente archivo tenemos que añadir algunos parámetros, asique editamos el archivo (En FreeBSD el archivo de configuración inicial primaria es /etc/defaults/rc.conf.  Ahí se encuentran los scripts de inicio del sistema):
■ ee /etc/rc.conf

Y añadimos:
gdm_enable="YES"
gnome_enable="YES" 
dbus_enable="YES" 
hald_enable="YES"

Editamos otro archivo fstab: (En este fichero aparece la lista de discos y particiones disponibles. En ella se indica como montar cada dispositivo y qué configuración utilizar. Su uso es el siguiente: <dispositivo> <punto_de_montaje> <sistema_de_archivos> <opciones> <dump-freq> <pass-num>):
■ ee /etc/fstab

Y abajo de todo añadimos (Con tabulaciones):
proc    /proc    procfs    rw    0    0

Y reiniciaremos el sistema:
■ reboot 

Error habitual
Si has escrito mal algun parametro del archivo /etc/rc.conf al iniciar dará error y no te dejará modificar el archivo porque el file system se monta solo en lectura, para corregir esto y que te deje modificar el archivo deberás poner:
■  mount -u -o rw /

4. Añadir nuestro usuario a sudoers

Instalamos los paquetes sudo y nano con:
■ pkg install sudo nano

Editamos el archivo sudoers con el comando:
­■ visudo

Y añadimos en la parte de User privilege specification debajo de root:
[Usuario] ALL=(ALL) ALL  

Cambiamos la shell de nuestro usuario con el comando:
■ nano /etc/passwd

Y en el archivo en la parte de nuestro usuario cambiamos la shell sh por bash  

5. Seguridad

Cuenta root:
- Nunca usar la cuenta root
- Cuando sea necesario usar sudo
- Cuando inicie el tty que pregunte por la contraseña de root:
■ nano /etc/ttys
y cambiar secure por insecure
Que siempre haya que escribir la contraseña de root cuando se use sudo
■ sudo visudo
Añadir en la parte Defaults:

Defaults timestamp_timeout=0

Criptografía para el login:
■ echo "crypt_default=blf " > /etc/auth.conf
■ nano /etc/login.conf:
:passwd_format=blf:\
:minpasswordlen=8:\
:mixpasswordcase=true:\
:idletime=30:\
:umask=022:
■ cap_mkdb /etc/login.conf
 
Restringir acceso a archivos (Solo entrar como root):
■ echo "root" > /var/cron/allow
■ echo "root" > /var/at/at.allow
■ chmod o= {/etc/crontab, /usr/bin/crontab,
/usr/bin/at, /usr/bin/atq, /usr/bin/atrm,
/usr/bin/batch}

Restringir más accesos:
■ chmod o= {/etc/fstab, /etc/ftpusers,   /etc/group,
/etc/hosts, /etc/hosts.allow, /etc/hosts.equiv,
/etc/hosts.lpd, /etc/inetd.conf, /etc/login.conf,
/etc/login.access, /etc/newsyslog.cong, /etc/rc.conf,
/etc/ssh/sshd_config, /etc/sysctl.conf, /etc/syslog.conf,
/etc/ttys} 

Restringir accesos nivel paranoia:
■ chmod o= {/usr/bin/users, /usr/bin/w,
/usr/bin/who, /usr/bin/lastcomm,
/usr/sbin/jls, /usr/bin/last,
/usr/sbin/lastlogin}
■ chmod ugo= {/usr/bin/rlogin,
/usr/bin/rsh}

SSH:
■  nano /etc/ssh/sshd_config
- Cambiar puerto por defecto.
- Protocolo 2
- PermiteRootLogin=no
- X11Forwarding=no

Protección de procesos:
Una configuración de seguridad que ayuda a proteger procesos, consiste en evitar que sus PID (Process ID) sean predecibles (como lo es por ejemplo en Linux). En FreeBSD esta característica se encuentra deshabilitada por defecto. Para habilitar el uso de PID aleatorios, se debe configurar correctamente la variable del kernel kern.randompid, indicando un módulo numérico (cuanto más grande el módulo, mayor aleatoriedad, por ende mayor seguridad). Por ejemplo, se puede utilizar el valor 1000:
■ sysctl kern.randompid=1000

Evitar que los usuarios sean capaces de ver procesos y sockets de otros usuarios a través de la variable del kernel 
 ■ sysctl security.bsd.see_other_uids=0

Daemons:
■ echo 'kern_securelevel_enable="YES"' >> /etc/rc.conf
■ echo 'kern_securelevel_enable="1"' >> /etc/rc.conf
■ echo 'portmap_enable="NO"' >> /etc/rc.conf
■ echo 'inetd_enable="NO"' >> /etc/rc.conf
■ echo 'sendmail_enable="NONE"' >> /etc/rc.conf
■ echo 'sendmail_submit_enable="NO"' >> /etc/rc.conf
■ echo 'sendmail_outbound_enable="NO"' >> /etc/rc.conf
■ echo 'sendmail_msp_queue_enable="NO"' >> /etc/rc.conf 

Daemons paranoia:
■ echo 'clear_tmp_enable="YES"' >> /etc/rc.conf
■ echo 'icmp_log_redirect="YES"' >> /etc/rc.conf
■ echo 'log_in_vain="YES"' >> /etc/rc.conf
■ echo 'icmp_drop_redirect="YES"' >> /etc/rc.conf

Crear una JAIL:
https://www.freebsd.org/doc/es_ES.ISO8859-1/books/handbook/jails.html 
- Virtualizacion nativa de freeBSD 
- Archivos y procesos enjaulados 
- Permite compartir entre las VM 
- Puede limitar el espacio de disco para ínodos 
- Sistema de archivos montado como solo de lectura, no permite rootkits. 

Firewalls:
https://www.freebsd.org/doc/handbook/firewalls-pf.html
 
Nivel del kernel:
■ kern_securelevel_enable="3"
-1 (default): Sin seguridad en el kernel.
1: Sin módulos de carga, a menos
recompilar. No hay memoria del sistema de escritura directa.
Sin directa escribe en el disco sin formatear
2: modo 1 + sin cambiar la estructura del sistema sin
escribir directamente en el disco
3: modo 2 + sin alteraciones en las reglas del firewall, sin alteraciones en el enrutamiento de la red.