Charla sobre Desarrollo seguro de aplicaciones C/C++ en Android con NDK, vemos ejemplos de JNI y de posibles vectores de ataque

1. Desarrollo seguro de aplicaciones
C/C++ en Android con NDK
IES Gran Capitán - 26 Enero 2016
Nacho Álvarez
@neonigmacdb
✉ neonigma@gmail.com
http://www.nacho-alvarez.es

2. Acerca de mí
● Ingeniero en Informática por la UCO
● Trayectoria profesional:
○ Soporte Servicio Informática UCO
○ Desarrollo Web
○ Desarrollo / Integración distribuciones GNU/Linux
○ Android mobile + backend developer (WUL4)
○ Actualmente: Área de Innovación (Redsys)
2/36

3. Acerca de mí
● Involucrado en la Innovación de soluciones
de medios de pago
3/36

4. Eventos
● GDG Córdoba
https://www.facebook.com/GDGCordobaESP/
● Hack&Beers Córdoba
https://twitter.com/hackandbeers
● BetaBeers Córdoba
https://twitter.com/betabeersODB
● Codemotion Madrid
https://www.facebook.com/Codemotion-Madrid-505998872792272/
● FOSDEM (Free and Open Source Software Developers’ European Meeting)
https://fosdem.org 4/36

5. Índice
1) Estructura de una app Android
2) Introducción al NDK
3) Nuestro primer programa con NDK
4) Seguridad en aplicaciones móviles
a) Hacking app Android
b) Hacking app nativa
5/36

6. Estructura de app Android
6/36

7. Tutoriales Android
● http://www.sgoliver.net/blog/curso-de-programacion-and
roid/indice-de-contenidos/
● https://github.com/sgolivernet/curso-android-src
● https://github.com/sgolivernet/curso-android-src-as
7/36

8. Introducción al NDK
● Conjunto de herramientas que permiten incorporar
código nativo (C/C++) en aplicaciones Android.
● Con NDK generas librerías binarias para cada
arquitectura de procesador (arm, armv7, x86, etc)
● Las librerías binarias se pueden invocar desde Java por
medio de JNI (Java Native Interface).
8/36

9. ¿Por qué usar NDK?
9/36

10. Estructura de app NDK
10/36

11. Nuestra primera app NDK
public class AndroidActivity extends Activity {
static {
System.loadLibrary("mixed_sample");
}
private Context context;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
context = this;
String greeting = SayHello("neonigma");
Saludo saludo = new Saludo(greeting);
Saludar.enviarSaludo(context, saludo);
}
public native String SayHello(String name);
}
src/main/java/blog/neonigma/AndroidActivity.java
11/36

12. Nuestra primera app NDK
public class Saludo {
private String mensajeSaludo;
public Saludo(String mensajeSaludo) {
this.mensajeSaludo = mensajeSaludo;
}
public String getMensajeSaludo() {
return mensajeSaludo;
}
}
src/main/java/blog/neonigma/Saludo.java
12/36

13. Nuestra primera app NDK
public class Saludar {
public static void enviarSaludo(Context context, Saludo saludo) {
Toast.makeText(context, saludo.getMensajeSaludo(), Toast.LENGTH_LONG).show();
}
}
src/main/java/blog/neonigma/Saludar.java
13/36

14. Nuestra primera app NDK
#include <jni.h>
#include <iostream>
#include <string>
#include <stdexcept>
using namespace std;
extern "C"
{
JNIEXPORT jstring JNICALL Java_blog_neonigma_AndroidActivity_SayHello(JNIEnv *env, jobject thiz, jstring name)
{
src/main/jni/code.cpp
14/36

15. Nuestra primera app NDK
std::string variableImportante = "3.14";
try
{
const char *myName = env->GetStringUTFChars(name, 0);
std::string nameCPP(myName);
nameCPP = "Hello: " + nameCPP;
return env->NewStringUTF(nameCPP.c_str());
}
catch (exception &ex)
{
const char *error = "Failed";
return env->NewStringUTF(error);
}
}
}
src/main/jni/code.cpp
15/36

16. Nuestra primera app NDK
apply plugin: 'com.android.model.application'
model {
android {
compileSdkVersion = 19
buildToolsVersion = "23.0.2"
defaultConfig.with {
applicationId = "src.blog.neonigma"
minSdkVersion.apiLevel = 17
targetSdkVersion.apiLevel = 19
versionCode = 1
versionName = "1.0"
}
}
build.gradle
16/36

17. Nuestra primera app NDK
android.ndk {
moduleName = "mixed_sample"
stl = "stlport_static"
CFlags.addAll("-fexceptions")
cppFlags.addAll("-fexceptions")
}
android.buildTypes {
release {
minifyEnabled = false
proguardFiles.add(file("proguard-rules.pro"))
}
}
}
build.gradle
17/36

18. Demo time!
18/36

19. Hacking app Android
● Una app Android se empaqueta dentro de un fichero APK
● Estos ficheros son solamente ficheros ZIP conteniendo
recursos y un archivo Dalvik Executable (.dex)
● Con las herramientas adecuadas, podemos extraer el código
Java incluido dentro del fichero .dex
● Elementos como los recursos gráficos y el fichero
AndroidManifest.xml no van ofuscados 19/36

20. Hacking app Android
Para extraer el código de la parte Java (no nativa)
● Paso 1: extraer .dex del APK
$ unzip program.apk classes.dex
Archive: program.apk
inflating: classes.dex
● Paso 2: utilizar dex2jar para convertir classes.dex a ficheros .class de Java
$ d2j-dex2jar.sh./classes.dex
dex2jar classes.dex -> ./classes-dex2jar.jar
● Paso 3: utilizamos el decompiler JD-GUI para extraer el código fuente
$ ./jd-gui classes.dex.dex2jar.jar
20/36

21. Hacking app Android
21/36

22. Hacking app Android
● Necesitamos ofuscación defensiva: Proguard /
Dexguard
● ProGuard optimiza, reduce y ofusca el código de
aplicaciones Android
● Solo funcionará cuando hagamos la exportación a APK
● Las reglas se escriben en fichero proguard-rules.pro 22/36

23. Hacking app Android
● Ejemplo proguard (identificar lo que se excluye):
-optimizations !code/simplification/arithmetic
-keep public class * extends android.app.Activity
-keep public class * extends android.app.Fragment
-keep public class * extends android.support.v4.app.Fragment
-keepclasseswithmembernames,includedescriptorclasses class * {
native <methods>;
}
23/36

24. Hacking app Android
No obstante, hay que ir
probando reglas de
ofuscación....
24/36

25. Desarrollo apps NDK
25/36

26. Hacking app nativa
● El código nativo se incluye dentro del apk como ficheros .so
● Este código está compilado y ensamblado contra una
arquitectura específica (ARM, x86, …)
● En teoría es difícil leer un fichero ensamblado, pero… hay
herramientas que ayudan: IDA como disassembler, apktool
para desempaquetado y reempaquetado, etc.
26/36

27. Hacking app nativa
27/36

28. Hacking app nativa
● Cosas que podemos hacer:
○ Ocultar nuestras funciones y variables de la tabla de
símbolos
○ Ofuscar el código, por ej. con O-LLVM
LOCAL_CFLAGS += -ffunction-sections -fdata-sections -fvisibility=hidden
Instructions Substitution: -mllvm -sub
Bogus Control Flow: -mllvm -bcf
Control Flow Flattening: -mllvm -fla
Functions annotations
28/36

29. Hacking app nativa
Sin ofuscación Con ofuscación 29/36

30. Caso práctico
Charlemos sobre un caso real...
30/36

31. Ejemplo
31/36

32. 32/36

33. 33/36

34. Ejemplo práctico
34/36

35. Ejemplo práctico
¡Nada de ser malvadou!
35/36

36. Referencias
● Curso de programación Android sgoliver
● Introducción al Desarrollo de NDK apps
http://es.slideshare.net/RevistaSG/introduccion-al-desarroll
o-de-ndk-apps-dev-day-4-woman-condesasama
● Conectar programas C/C++ con apps Android
http://www.nacho-alvarez.es/index.php/blog/2012/05/02/co
nectar-programas-cc-con-aplicaciones-android/
36/36