Cómo detectar si nuestra aplicación en Android se está ejecutando en un emulador

La mayoría del malware moderno trata de escapar de ser analizado y uno de las primeras cosas que hace es comprobar si se está ejecutando en un entorno controlado. En el mundo del malware para Android el ambiente controlado se refiere a un emulador. Si el malware se ejecuta en un emulador, eso significa que lo más probable es que esté siendo analizado por un investigador. Hay varios métodos que los desarrolladores de malware utilizan para detectar el entorno emulado.

1.) Comprobar el Nombre del producto:


En el emulador de Android, el nombre de producto del dispositivo contiene la cadena "sdk" por lo que es un indicio útil para detectar si la aplicación se está ejecutando en un emulador. Con el fin de comprobar el nombre del producto, puedes utilizar el siguiente fragmento de código:

if (Build.PRODUCT.contains ("sdk"))
    #do something

2.) Comprobar el Nombre del modelo:
 
El nombre del producto por defecto del emulador de Android contiene la cadena "sdk". Por lo tanto, vale la pena comprobar también el nombre del modelo con el fin de detectar el uso emulador.
if (Build.MODEL.contains ("sdk"))
    #do something

3.) Comprobar el Nombre del operador de la SIM:

 
En los emuladores de Android, el nombre del operador SIM viene con el valor por defecto "Android". Esto no ocurre en los dispositivos físicos normales aún cuando no hay una tarjeta SIM instalada en el dispositivo.
TelephonyManager localTelephonyManager = (TelephonyManager)getApplicationContext().getSystemService("phone"):
if (localTelephonyManager.getSimOperatorName().equeals ("Android"))
    #do something

4.) Comprobar el Nombre del operador de Red:


Al igual que la anterior, el nombre del operador de red también viene con la opción predeterminada "Android". Es una buena idea comprobar el nombre del operador de red con el fin de decidir si la aplicación se está ejecutando en un emulador.

TelephonyManager localTelephonyManager = (TelephonyManager)getApplicationContext().getSystemService("phone"):
if (localTelephonyManager.getNetworkOperatorName().equeals ("Android"))
    #do something

Al combinar estas 4 técnicas mencionadas anteriormente, se puede escribir una aplicación básica para Android que muestra estos valores. Con el fin de comparar si realmente funcionan, puede instalar la aplicación, tanto en el emulador como en un dispositivo real.

5.) Comprobar las Propiedades ro.kernel.qemu y ro.secure

 
adicionalmente se puede comprobar las propiedades del sistema Android para detectar un entorno emulado. Hay varios archivos de propiedades en el sistema de archivos de Android:

     /default.prop
     /system/build.prop     /data/local.prop

Las propiedades se almacenan en un formato par de valores clave en estos archivos de propiedades. Puedes ver los valores de las propiedades escribiendo

     GetProp adb shell <key>

Si el valor de ro.secure es "0", o el valor de ro.kernel.qemu es 1, el shell ADB se ejecuta como root y eso significa que el entorno en el que se ejecuta la aplicación es un emulador. En un dispositivo físico el shell ADB se ejecuta con los permisos del usuario normal, no el root. Para comprobar estas propiedades se pueden utilizar los fragmentos de código a continuación.

Class SystemProperties = Class.forName("android.os.SystemProperties");
TelephonyManager localTelephonyManager = (TelephonyManager)paramContext.getSystemService("phone");
if (getProperty(SystemProperties, "ro.secure").equalsIgnoreCase("0"))
isEmulator = Boolean.valueOf(true);
else if (getProperty(SystemProperties, "ro.kernel.qemu").equalsIgnoreCase("1"))
isEmulator = Boolean.valueOf(true);

6.) Comprobar el Proceso "qemud" (qemu daemon)

 
este método lo utiliza APKProtect y recorre todos los procesos listados en /proc y comprueba si está qemud comparando el hash de la ruta del binario:
 find_qemud_process() { 
 for(int i = 0; i < 0x65; i++) 
    if( hash(read(“/proc/%d/cmdline”, i)) == hash(“/system/bin/qemud”)) 
        return true; 
    return false;
    } ...

Podéis encontrar todo el código junto en https://github.com/oguzhantopgul/Android-Emulator-Detection
Fuente: http://www.oguzhantopgul.com/2014/12/android-malware-evasion-techniques.html
Otros proyectos para la detección de emuladores en Android:
https://github.com/strazzere/anti-emulator
https://github.com/Fuzion24/AndroidEmulatorDetection

1 comentarios :

  1. Buenisimo, con esto se podría aplicar reversing a las apps y ver si tienen los métodos para la detección de emulador.

    ResponderEliminar