Cómo encontrar errores de seguridad en aplicaciones Android por el camino difícil
Ostorlab es un esfuerzo comunitario para construir un escáner de vulnerabilidades de aplicaciones móviles que ayude a los desarrolladores a crear aplicaciones móviles seguras. Uno de los nuevos componentes clave de las capacidades de detección del escáner es un flamante motor de taint estático para el bytecode Dalvik de Android, muy optimizado para lograr rendimiento y pocos falsos positivos.
Ostorlab es un esfuerzo comunitario para construir un escáner de vulnerabilidades de aplicaciones móviles que ayude a los desarrolladores a crear aplicaciones móviles seguras. Uno de los nuevos componentes clave de las capacidades de detección del escáner es un flamante motor de taint estático para el bytecode Dalvik de Android, muy optimizado para lograr rendimiento y pocos falsos positivos.
Una versión sencilla de un motor de taint estático calcula cómo se propaga por una aplicación la entrada controlada por el usuario. El seguimiento del flujo se basa en marcar (taint) variables y atributos, de ahí el nombre «motor de taint estático». Esta información de taint sirve para detectar vulnerabilidades en la aplicación.
Unos meses después de lanzar la versión inicial del motor y de escanear más de 10.000 aplicaciones móviles subidas por los usuarios, estos son algunos de los resultados clave que hemos recopilado hasta ahora.
El motor de taint estático ha detectado más de 600 vulnerabilidades de alto riesgo, que van desde inyección SQL en content providers, validación insegura de certificados de servidor SSL/TLS (detectada de forma estática), inyección de comandos, preferencias compartidas inseguras, criptografía débil, claves codificadas en el código y muchas otras clases de vulnerabilidades.
Estos son algunos ejemplos de las vulnerabilidades encontradas con el motor de taint estático; he tenido la precaución de compartir únicamente ejemplos de aplicaciones deliberadamente inseguras:
Inyección SQL en content providers:
El segundo parámetro (el 1, si se cuenta desde 0) del método android.database.sqlite.SQLiteDatabase.delete()
provocará una inyección SQL si lo controla el usuario.
El parámetro queda expuesto por el método jakhar.aseem.diva.NotesProvider.delete() del content provider exportado, lo que
hace que la aplicación sea vulnerable a una inyección SQL:
[TAINT] Parameter '1' ==*==*==*==*==>>> Sink '[u'Landroid/database/sqlite/SQLiteDatabase;', u'delete', u'(Ljava/lang/String; Ljava/lang/String; [Ljava/lang/String;)I', u'1', u'SQL_SINK']'
===========
|__Ljakhar/aseem/diva/NotesProvider;->delete(Landroid/net/Uri; Ljava/lang/String; [Ljava/lang/String;)I / 0
|__Landroid/content/ContentResolver;->notifyChange(Landroid/net/Uri; Landroid/database/ContentObserver;)V (no childs) / 1
|__Landroid/content/Context;->getContentResolver()Landroid/content/ContentResolver; (no childs) / 1
|__Landroid/content/UriMatcher;->match(Landroid/net/Uri;)I (no childs) / 1
|__Landroid/database/sqlite/SQLiteDatabase;->delete(Ljava/lang/String; Ljava/lang/String; [Ljava/lang/String;)I (no childs) / 1
|__Landroid/net/Uri;->getLastPathSegment()Ljava/lang/String; (no childs) / 1
|__Landroid/text/TextUtils;->isEmpty(Ljava/lang/CharSequence;)Z (no childs) / 1
|__Ljakhar/aseem/diva/NotesProvider;->getContext()Landroid/content/Context; (no childs) / 1
|__Ljava/lang/IllegalArgumentException;->(Ljava/lang/String;)V (no childs) / 1
|__Ljava/lang/StringBuilder;->()V (no childs) / 1
|__Ljava/lang/StringBuilder;->append(C)Ljava/lang/StringBuilder; (no childs) / 1
|__Ljava/lang/StringBuilder;->append(Ljava/lang/Object;)Ljava/lang/StringBuilder; (no childs) / 1
|__Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder; (no childs) / 1
|__Ljava/lang/StringBuilder;->toString()Ljava/lang/String; (no childs) / 1
===========
Un parámetro controlado por el usuario se utiliza para construir un parámetro SQL vulnerable a la inyección SQL
Método jakhar.aseem.diva.NotesProvider.delete():
public int delete(android.net.Uri p8, String p9, String[] p10)
{
int v0;
switch (jakhar.aseem.diva.NotesProvider.urimatcher.match(p8)) {
case 1:
v0 = this.mDB.delete("notes", p9, p10);
break;
case 2:
String v2_6;
int v3_0 = this.mDB;
StringBuilder v5_1 = new StringBuilder().append("_id = ").append(p8.getLastPathSegment());
if (android.text.TextUtils.isEmpty(p9)) {
v2_6 = "";
} else {
v2_6 = new StringBuilder().append(" AND (").append(p9).append(41).toString();
}
v0 = v3_0.delete("notes", v5_1.append(v2_6).toString(), p10);
break;
default:
throw new IllegalArgumentException(new StringBuilder().append("Divanotes(delete): Unsupported URI ").append(p8).toString());
}
this.getContext().getContentResolver().notifyChange(p8, 0);
return v0;
}
Inyección de comandos:
Este es un ejemplo del uso de un comando peligroso que establece permisos inseguros y excesivamente permisivos mediante el modo '777', lectura, escritura y ejecución para el usuario, el grupo y los demás; no se puede ser más permisivo que eso :/ :
[TAINT] String '/system/bin/chmod -R 0777 F1.txt file12.txt' ==*==*==*==*==>>> Sink '[u'Ljava/lang/Runtime;', u'exec', u'([Ljava/lang/String; [Ljava/lang/String; Ljava/io/File;)Ljava/lang/Process;', u'Object', u'COMMAND_SINK']'
===========
|__Lcom/ibm/android/analyzer/test/cmdinjection/CommandInjection6;->onCreate(Landroid/os/Bundle;)V / 0
|__Landroid/app/Activity;->onCreate(Landroid/os/Bundle;)V (no childs) / 1
|__Landroid/content/Intent;->getStringExtra(Ljava/lang/String;)Ljava/lang/String; (no childs) / 1
|__Lcom/ibm/android/analyzer/test/cmdinjection/CommandInjection6;->cmdRuntime(Ljava/lang/String; I)V / 1
|__Landroid/content/Context;->getFilesDir()Ljava/io/File; (no childs) / 2
|__Landroid/util/Log;->i(Ljava/lang/String; Ljava/lang/String;)I (no childs) / 2
|__Ljava/io/File;->getAbsolutePath()Ljava/lang/String; (no childs) / 2
|__Ljava/lang/Exception;->printStackTrace()V (no childs) / 2
|__Ljava/lang/Runtime;->exec(Ljava/lang/String; [Ljava/lang/String; Ljava/io/File;)Ljava/lang/Process; (no childs) / 2
|__Ljava/lang/Runtime;->exec(Ljava/lang/String; [Ljava/lang/String;)Ljava/lang/Process; (no childs) / 2
|__Ljava/lang/Runtime;->exec(Ljava/lang/String;)Ljava/lang/Process; (no childs) / 2
|__Ljava/lang/Runtime;->exec([Ljava/lang/String; [Ljava/lang/String; Ljava/io/File;)Ljava/lang/Process; (no childs) / 2
|__Ljava/lang/Runtime;->exec([Ljava/lang/String; [Ljava/lang/String;)Ljava/lang/Process; (no childs) / 2
|__Ljava/lang/Runtime;->exec([Ljava/lang/String;)Ljava/lang/Process; (no childs) / 2
|__Ljava/lang/Runtime;->getRuntime()Ljava/lang/Runtime; (no childs) / 2
|__Ljava/lang/StringBuilder;->()V (no childs) / 2
|__Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder; (no childs) / 2
|__Ljava/lang/StringBuilder;->toString()Ljava/lang/String; (no childs) / 2
|__Lcom/ibm/android/analyzer/test/cmdinjection/CommandInjection6;->getIntent()Landroid/content/Intent; (no childs) / 1
|__Ljava/lang/StringBuilder;->()V (no childs) / 1
|__Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder; (no childs) / 1
|__Ljava/lang/StringBuilder;->toString()Ljava/lang/String; (no childs) / 1
===========
La aplicación ejecuta un comando peligroso
Método com.ibm.android.analyzer.test.cmdinjection.CommandInjection6.onCreate():
protected void onCreate(android.os.Bundle p7)
{
super.onCreate(p7);
android.content.Intent v2 = this.getIntent();
String v0 = v2.getStringExtra("exec");
if (v0 == null) {
String v1 = v2.getStringExtra("execR");
if (v1 == null) {
this.cmdRuntime("/system/bin/chmod 0777 /data/data/com.ibm.android.analyzer.test/1.txt", 5);
this.cmdRuntime("/system/bin/chmod -R 0777 F1.txt file12.txt", 5);
} else {
this.cmdRuntime(new StringBuilder().append("/system/bin/sh ").append(v1).toString(), 5);
}
} else {
this.cmdRuntime(v0, 5);
}
return;
}
Claves de cifrado codificadas en el código:
El uso de claves de cifrado codificadas en el código es otro ejemplo de las vulnerabilidades comunes que vemos en las aplicaciones móviles; en el ejemplo, la cadena 'superSecurePassword' se utiliza para llamar a un método de cifrado:
[TAINT] String 'superSecurePassword' ==*==*==*==*==>>> Sink '[u'Ljavax/crypto/spec/SecretKeySpec;', u'', u'([B Ljava/lang/String;)V', u'0', u'CIPHER_SINK']'
===========
|__Lcom/android/insecurebankv2/MyBroadCastReceiver;->onReceive(Landroid/content/Context; Landroid/content/Intent;)V / 0
|__Landroid/content/Context;->getSharedPreferences(Ljava/lang/String; I)Landroid/content/SharedPreferences; (no childs) / 1
|__Landroid/content/Intent;->getStringExtra(Ljava/lang/String;)Ljava/lang/String; (no childs) / 1
|__Landroid/content/SharedPreferences;->getString(Ljava/lang/String; Ljava/lang/String;)Ljava/lang/String; (no childs) / 1
|__Landroid/telephony/SmsManager;->getDefault()Landroid/telephony/SmsManager; (no childs) / 1
|__Landroid/telephony/SmsManager;->sendTextMessage(Ljava/lang/String; Ljava/lang/String; Ljava/lang/String; Landroid/app/PendingIntent; Landroid/app/PendingIntent;)V (no childs) / 1
|__Landroid/util/Base64;->decode(Ljava/lang/String; I)[B (no childs) / 1
|__Lcom/android/insecurebankv2/CryptoClass;->()V / 1
|__Ljava/lang/Object;->()V (no childs) / 2
|__Lcom/android/insecurebankv2/CryptoClass;->aesDeccryptedString(Ljava/lang/String;)Ljava/lang/String; / 1
|__Landroid/util/Base64;->decode([B I)[B (no childs) / 2
|__Lcom/android/insecurebankv2/CryptoClass;->aes256decrypt([B [B [B)[B / 2
|__Ljavax/crypto/Cipher;->doFinal([B)[B (no childs) / 3
|__Ljavax/crypto/Cipher;->getInstance(Ljava/lang/String;)Ljavax/crypto/Cipher; (no childs) / 3
|__Ljavax/crypto/Cipher;->init(I Ljava/security/Key; Ljava/security/spec/AlgorithmParameterSpec;)V (no childs) / 3
|__Ljavax/crypto/spec/IvParameterSpec;->([B)V (no childs) / 3
|__Ljavax/crypto/spec/SecretKeySpec;->([B Ljava/lang/String;)V (no childs) / 3
|__Ljava/lang/String;->([B Ljava/lang/String;)V (no childs) / 2
|__Ljava/lang/String;->getBytes(Ljava/lang/String;)[B (no childs) / 2
|__Ljava/io/PrintStream;->println(Ljava/lang/String;)V (no childs) / 1
|__Ljava/lang/Exception;->printStackTrace()V (no childs) / 1
|__Ljava/lang/String;->([B Ljava/lang/String;)V (no childs) / 1
|__Ljava/lang/String;->toString()Ljava/lang/String; (no childs) / 1
|__Ljava/lang/StringBuilder;->()V (no childs) / 1
|__Ljava/lang/StringBuilder;->append(Ljava/lang/String;)Ljava/lang/StringBuilder; (no childs) / 1
|__Ljava/lang/StringBuilder;->toString()Ljava/lang/String; (no childs) / 1
===========
La aplicación utiliza una clave codificada en el código para cifrar los datos
Método com.android.insecurebankv2.MyBroadCastReceiver.onReceive():
public void onReceive(android.content.Context p17, android.content.Intent p18)
{
String v12 = p18.getStringExtra("phonenumber");
String v10 = p18.getStringExtra("newpass");
if (v12 == null) {
System.out.println("Phone number is null");
} else {
try {
android.content.SharedPreferences v13 = p17.getSharedPreferences("mySharedPreferences", 1);
this.usernameBase64ByteString = new String(android.util.Base64.decode(v13.getString("EncryptedUsername", 0), 0), "UTF-8");
String v8 = new com.android.insecurebankv2.CryptoClass().aesDeccryptedString(v13.getString("superSecurePassword", 0));
String v2 = v12.toString();
String v4 = new StringBuilder().append("Updated Password from: ").append(v8).append(" to: ").append(v10).toString();
android.telephony.SmsManager v1 = android.telephony.SmsManager.getDefault();
System.out.println(new StringBuilder().append("For the changepassword - phonenumber: ").append(v2).append(" password is: ").append(v4).toString());
v1.sendTextMessage(v2, 0, v4, 0, 0);
} catch (Exception v9) {
v9.printStackTrace();
}
}
return;
}
Validación insegura de certificados de servicio SSL/TLS:
Este es un ejemplo de un método que utiliza el inseguro ALLOW_ALL_HOSTNAME_VERIFIER para construir un esquema de validación de certificados SSL/TLS:
[TAINT] Class 'Lorg/apache/http/conn/ssl/SSLSocketFactory;' ==*==*==*==*==>>> Sink '[u'Lorg/apache/http/conn/ssl/SSLSocketFactory;', u'setHostnameVerifier', u'(Lorg/apache/http/conn/ssl/X509HostnameVerifier;)V', u'Object', u'SSLTLS_SINK']'
===========
|__Lcom/ibm/android/analyzer/test/domainvalidation/InsecureApacheSSFAllowAllHostnameVerifier$1;->call()Ljava/lang/Void; / 0
|__Landroid/util/Log;->i(Ljava/lang/String; Ljava/lang/String;)I (no childs) / 1
|__Ljava/lang/Exception;->printStackTrace()V (no childs) / 1
|__Ljava/net/URL;->(Ljava/lang/String;)V (no childs) / 1
|__Ljava/net/URL;->openConnection()Ljava/net/URLConnection; (no childs) / 1
|__Ljava/security/KeyStore;->getDefaultType()Ljava/lang/String; (no childs) / 1
|__Ljava/security/KeyStore;->getInstance(Ljava/lang/String;)Ljava/security/KeyStore; (no childs) / 1
|__Ljava/security/KeyStore;->load(Ljava/io/InputStream; [C)V (no childs) / 1
|__Ljavax/net/ssl/HttpsURLConnection;->connect()V (no childs) / 1
|__Ljavax/net/ssl/SSLContext;->getInstance(Ljava/lang/String;)Ljavax/net/ssl/SSLContext; (no childs) / 1
|__Ljavax/net/ssl/SSLContext;->init([Ljavax/net/ssl/KeyManager; [Ljavax/net/ssl/TrustManager; Ljava/security/SecureRandom;)V (no childs) / 1
|__Lorg/apache/http/conn/ssl/SSLSocketFactory;->(Ljava/security/KeyStore;)V (no childs) / 1
|__Lorg/apache/http/conn/ssl/SSLSocketFactory;->setHostnameVerifier(Lorg/apache/http/conn/ssl/X509HostnameVerifier;)V (no childs) / 1
===========
Uso del atributo inseguro ALLOW_ALL_HOSTNAME_VERIFIER para validar el certificado TLS
Método com.ibm.android.analyzer.test.domainvalidation.InsecureApacheSSFAllowAllHostnameVerifier$1.call():
public Void call()
{
try {
android.util.Log.i(this.this$0.TAG, "1");
javax.net.ssl.SSLContext.getInstance("TLS").init(0, 0, 0);
java.net.URL v4_1 = new java.net.URL("https://1.www.s81c.com/i/v17/t/ibm_logo_print.png?dv1");
android.util.Log.i(this.this$0.TAG, "2");
javax.net.ssl.HttpsURLConnection v5_1 = ((javax.net.ssl.HttpsURLConnection) v4_1.openConnection());
java.security.KeyStore v3 = java.security.KeyStore.getInstance(java.security.KeyStore.getDefaultType());
v3.load(0, 0);
android.util.Log.i(this.this$0.TAG, "3");
new org.apache.http.conn.ssl.SSLSocketFactory(v3).setHostnameVerifier(org.apache.http.conn.ssl.SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
android.util.Log.i(this.this$0.TAG, "4");
v5_1.connect();
android.util.Log.i(this.this$0.TAG, "5");
} catch (Exception v0) {
android.util.Log.i(this.this$0.TAG, "exception 1!");
v0.printStackTrace();
}
return 0;
}
Conceptos clave:
El motor es un esfuerzo de casi un año completo que empezó como una PoC en Python. Python permitió crear prototipos rápidamente, centrándose en los algoritmos y las estructuras de datos. La implementación actual utiliza una representación en forma de grafo de la propagación del taint dentro de una sola función (véase el grafo)
El grafo se utiliza para evaluar el taint de otras funciones, lo que ofrece un motor de taint estático muy rápido y utilizable en el mundo real, y al mismo tiempo tiene en cuenta el aspecto orientado a objetos del bytecode Dalvik para garantizar una propagación precisa del taint.
Para generar un grafo de taint se compilan y evalúan individualmente una lista de rutas de ejecución, y luego se fusionan con un taint global de la función.
Este enfoque tiene, sin embargo, limitaciones si la función presenta una estructura de rutas de ejecución exponencial (véase el ejemplo de grafo); este problema se conoce comúnmente como explosión de rutas y es una fuerte limitación de los métodos de análisis estático, como la ejecución simbólica.
Para paliar esta limitación, transformamos el problema en un «problema de búsqueda» en lugar de un «problema de fuerza bruta». Un algoritmo de selección de rutas elige las rutas con mayor probabilidad de presentar una vulnerabilidad; por ejemplo, si una ruta concreta no atraviesa ninguna función sink (las funciones sink pueden causar una vulnerabilidad si se las llama con parámetros controlados por el usuario), entonces no hay ninguna vulnerabilidad que buscar y las rutas de ejecución se excluyen.
La implementación actual se reescribió en C++14 tras investigar varios otros lenguajes de programación (Rust, Go y C), lo que ofreció una ganancia de más de 200x en la velocidad de ejecución.
Todavía hay margen para aumentar el rendimiento y la cobertura de código, pero también para corregir varios falsos positivos debidos al uso de un grafo sobrecontaminado (over-tainted) por defecto para los métodos nativos de bajo nivel.
Estas capacidades ya forman parte de Ostorlab Scanner y se mejoran continuamente, y en silencio :), cada día.
Le animamos a probarlo y a compartir sus comentarios. Si hay alguna vulnerabilidad que cree que se nos escapa o algún falso positivo que informa el escáner, nos encantaría saberlo e intentar trabajar en una forma de corregirlo o detectarlo.