Android Malware I.
Montando el laboratorio

Esta serie de artículos de nuestro blog viene motivada por la cantidad de noticias que circulan con titulares como «Malware en Android roba tus datos bancarios», «Malware que no se desintalada de tu Android», «Malware que se reinstala sin que te des cuenta»… La pregunta es ¿cómo funciona a nivel del sistema?, ¿cómo consiguen salir de la sandbox que se genera al instarla la App?, ¿solo usan ingeniería social o existen más aspectos técnicos interesantes?. Por esto, decidimos montar un laboratorio para poder analizar en detalle las técnicas utilizadas por estos malware.

Infraestructuras similares a las que describiremos las usamos habitualmente en nuestro laboratorio acreditado para la realización de Evaluaciones de Seguridad de Productos TIC y, cuando aplica, en nuestras actividades de Red Team.

1.Instalación de máquina virtuales en VirtualBox

Como vamos a ejecutar código malicioso será importante poder volver en cualquier momento a una situación del sistema previa a la infección. Aunque esto se puede realizar con dispositivos físicos, es mucho más cómodo realizarlo con dispositivos virtualizados: en cualquier momento podemos tomar un snapshot del sistema, y en cualquier momento podemos devolver el sistema al estado de cualquiera de los snapshots de manera casi inmediata.

Como plataforma de virtualización utilizaremos Virtualbox y para la emulación de android sobre Virtualbox usaremos el proyecto de Open Source Android_x86 que a día de hoy sigue en desarrollo y actualizado. Existen alternativas, por ejemplo Genymotion que tiene mejor rendimiento pero perdemos control porque estas máquinas Genymotion levantan una interfaz Host-Only en tu host, lo cual es un riesgo que preferimos evitar. También está CuckooDroid que es un sandbox para el análisis de malware en Android que quizás probemos en el futuro.

Instalaremos una máquina por donde pasarán todas las peticiones realizadas por Android y donde instalaremos todo el software necesario para el análisis. Utilizaremos un sistema basado en Debian. El esquema a seguir será el siguiente:

1.1. Linux Analysis & Transparent Proxy Virtual Machine

1.1.1. Especificaciones de la máquina

En el centro del esquema anterior tendremos la máquina de análisis que por un interfaz de red en modo bridge tendrá conexión a internet (eth0) y por el otro interfaz (eth1) estará conectado a la red interna de Virtualbox. Debido a que vamos a levantar bastante software a la vez en la máquina de análisis, hay que dedicarle más de 2GB de RAM, en nuestro caso 4GB y así no nos quedamos cortos. Además hay que añadir un interfaz más (eth1) donde se configurará el servidor DHCP y a donde se conectará la máquina Android.

1.1.2. Herramientas

Existen cientos de herramientas para el análisis tanto dinámico como estático de aplicaciones Android. Aquí se muestra la instalación de las herramientas que nos han parecido más relevantes.

  • Proxy/Sistema:

sudo apt install adb docker docker.io docker-compose android-sdk openjdk-8-jre wireshark -y

  • Análisis estático:

wget https://github.com/skylot/jadx/releases/download/v1.2.0/jadx-1.2.0.zip
sudo mv jadx-1.2.0.zip /usr/local/bin/jadx-1.2.0.zip
sudo unzip /usr/local/bin/jadx-1.2.0.zip -d /usr/local/bin/jadx-1.2.0
sudo rm /usr/local/bin/jadx-1.2.0.zip
sudo ln -s /usr/local/bin/jadx-1.2.0/bin/jadx /usr/local/bin/jadx
sudo ln -s /usr/local/bin/jadx-1.2.0/bin/jadx-gui /usr/local/bin/jadx-gui

wget https://raw.githubusercontent.com/iBotPeaches/Apktool/master/scripts/linux/apktool
wget https://bitbucket.org/iBotPeaches/apktool/downloads/apktool_2.5.0.jar
mv apktool_2.5.0.jar apktool.jar
sudo mv apktool.jar /usr/local/bin
sudo mv apktool /usr/local/bin
sudo chmod +x /usr/local/bin/apktool.jar
sudo chmod +x /usr/local/bin/apktool

  • Análisis dinámico:

sudo apt install python3-pip
pip3 install frida-tools

wget https://raw.githubusercontent.com/JakeWharton/pidcat/master/pidcat.py
chmod +x pidcat
mv pidcat /bin/

chmod +x burpsuite_community_linux_v2020_12_1.sh
./burpsuite_community_linux_v2020_12_1.sh

sudo docker pull opensecurity/mobile-security-framework-mobsf
echo «alias mobsf=’sudo docker run -it -p 8000:8000 opensecurity/mobile-security-framework-mobsf:latest'» >> ~/.bashrc

1.1.3. Instalación y configuración del servidor DHCP

Para instalarlo:

sudo apt install isc-dhcp-server

Añadir el interfaz, en el fichero /etc/default/isc-dhcp-server, donde se quiere dejar el dhcp funcionando. Modificar la línea INTERFACESv4="" dejandola como INTERFACESv4="eth1"

Luego en el fichero /etc/dhcp/dhcpd.conf se debe modificar de la siguiente forma:

option domain-name-servers 8.8.8.8, 8.8.4.4;
default-lease-time 600;
max-lease-time 7200;
ddns-update-style none;
authoritative;

subnet 10.0.0.0 netmask 255.255.255.0 {
range 10.0.0.10 10.0.0.20;
option domain-name-servers 8.8.8.8;
option subnet-mask 255.255.255.0;
option routers 10.0.0.1;
option broadcast-address 10.0.0.255;
default-lease-time 600;
max-lease-time 7200;
}

Altamente recomendable deshabilitar el network-manager : service network-manager stopAdemás instalar net-tools y ifupdown para la configuración de los interfaces de red, que en ocasiones no viene con algunas distros.

Para que funcione nuestro interfaz eth1 debe tener una IP. Se la indicamos en /etc/network/interfaces del siguiente modo:

auto eth0
iface eth0 inet dhcp
auto eth1
iface eth1 inet static
address 10.0.0.1
netmask 255.255.255.0

Y ahora reiniciar el servicio: service isc-server-dhcp restart

1.1.4. Proxy transparente con iptables

Primero limpiamos las reglas, para asegurarnos en que empezamos de cero:

iptables -F
iptables -X
iptables -Z
iptables -t nat -F

Establecemos política por defecto:

iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
iptables -t nat -P PREROUTING ACCEPT
iptables -t nat -P POSTROUTING ACCEPT

Primero tenemos que habilitar el reenvio de tráfico a través de la máquina con:

echo 1 > /proc/sys/net/ipv4/ip_forward

Luego pondremos las demás reglas:

## Cadena FORWARD
iptables -A FORWARD -i eth0 -o eth1 -m state --state ESTABLISHED,RELATED -j ACCEPT
iptables -A FORWARD -i eth1 -o eth0 -m state --state NEW -j ACCEPT

## NAT
iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE

## HTTP and HTTPS para Burpsuite
iptables -t nat -A PREROUTING -p tcp --dport 80 -j REDIRECT --to-port 8082
iptables -t nat -A PREROUTING -p tcp --dport 443 -j REDIRECT --to-port 8082

Más adelante configuraremos el Burp para terminar de configurar el proxy, pero ahora vamos a la máquina Android.

 

1.2. Android_x86 Virtual Machine

Descargar la versión de Android-x86 desde la web oficial. Fuertemente recomendable una versión en 64 bits. Los pasos para instalar estos sistemas en Virtualbox están descritos en el siguiente link.

Para hacer un resumen rápido de lo que indica en el link:

  • Crear un máquina virtual de tipo Linux  y Versión Linux 2.6/3.x/4.x (64bits).
  • Dedicarle más de un procesador a la máquina.
  • Importante este paso: Es obligatorio que en las opciones de Display cambiar de VMSVGA a VBoxVGA.

Luego algunas opciones que añadimos nosotros para el lab:

  • Además añadir lo máximo posible de memoria de vídeo (128MB).
  • En las interfaces de red, dejar solo una, en modo internal_network con el mismo nombre que la internal_network del proxy (van a estar en la misma red).

Arrancar la máquina con el disco .iso que se haya descargado. Arrancará el asistente de instalación del sistema operativo. A partir de aquí hay que seguir los siguientes pasos:

  • Pulsar la opción «Instalación –  Install Android-x86 to harddisk»
  • Ante la pregunta del uso de GPT elegir que no
  • Ahora hay que crear una partición. Pulsar New>Primary>Seleccionar todo el disco>Bootable>Write>Confimar y esperar>Quit

  • Seleccionar la nueva partición que acabamos de crear, elegir el formato «ext4», luego confirmar.
  • A la pregunta de instalación del GRUB elegir que sí.
  • Importante este paso: Cuando pregunta sobre si instalar el directorio /system como read-write elegir sí.

Y ya estaría Android instalado en una máquina virtual de virtualbox.

 

2. Burp Suite y la instalación de certificado

Vamos a usar la versión de Burp Suite Community como proxy web para la visualización de las llamadas HTTP/S. Para poder trabajar con Burp Suite como proxy transparente en Android hay que instalar el certificado de Burp como Root CA. Para ello hay que seguir los siguientes pasos:

  • Abrir Burp
  • Importar el certificado en formato .cer desde Burp. Proxy>Options>Import/export CA certificate> Seleccionar la opción «Certificate in DER format»> Guardar en el lugar deseado.
  • Ejecutar en bash para instalar el certificado (sustituir por las variables entre <>):

openssl x509 -inform DER -in <CERTIFICATE_BURP> -out cacert.pem
hash=`openssl x509 -inform PEM -subject_hash_old -in cacert.pem | head -1`
cert_hash=$hash.0
mv cacert.pem $cert_hash
adb connect <IP_ANDROID_MACHINE>
adb root
adb connect <IP_ANDROID_MACHINE>
adb remount
adb push $cert_hash /sdcard/
adb shell "mv /sdcard/$cert_hash /system/etc/security/cacerts/"
adb shell "chmod 644 /system/etc/security/cacerts/$cert_hash"
adb shell "reboot"

Si vamos a Ajustes de la máquina Android y buscamos el apartado «Trusted credentials» vemos como nuestro certificado se ha instalado como CA del sistema:

También hay que configurar el proxy en Burp.

  • En la pestaña Proxy>Intercerpt, apagar el intercerpt por el momento
  • Luego en Proxy>Options>Proxy Listeners>Add
  • En Bind to port: 8082
  • En Bind to address: All interfaces
  • En la pestaña «Request handling» de la misma ventana habilitar la opción «Support invisible proxying (enable only if needed)»

Ya estaría Burp escuchando en el puerto 8082 todas las peticiones HTTP/S que recibirá gracias a las reglas de Iptables que hemos configurado anteriormente:

NOTA: Es posible que se realizen peticiones HTTP/S por puertos que no son los comunes y en nuestro caso solo hemos añadido al Iptables las peticiones que tengan como destino el puerto 80/443. En ese caso, habría que mirar las tramas de Wireshark y detectar que puertos son los usados y posteriormente añadir una regla a Iptables con este puerto.

En los próximos artículos de esta serie iremos viendo ejemplos de malware que usen técnicas específicas, teoría o herramientas que nos parezcan interesantes.

FUENTES:

Internal Networking – Virtualbox [Malware Lab]

Configuring Burp Suite With Android Nougat

Using Burp’s Invisible Proxy Settings to Test a Non-Proxy-Aware Thick Client Application

Iptables incluyendo para proxy transparente

Proxying Android app traffic – Common issues / Checklist