hacktricks/mobile-pentesting/android-app-pentesting/frida-tutorial/README.md

# Tutorial de Frida

<details>

<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>

* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
* Descubre [**The PEASS Family**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de Telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Comparte tus trucos de hacking enviando PRs al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).

</details>

<img src="../../../.gitbook/assets/i3.png" alt="" data-size="original">

**Consejo para recompensas por errores**: **regístrate** en **Intigriti**, una plataforma premium de **recompensas por errores creada por hackers, para hackers**. ¡Únete a nosotros en [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoy mismo y comienza a ganar recompensas de hasta **$100,000**!

{% embed url="https://go.intigriti.com/hacktricks" %}

## Instalación

Instala las **herramientas de Frida**:
```bash
pip install frida-tools
pip install frida
```
**Descarga e instala** en el dispositivo Android el **servidor de Frida** ([Descarga la última versión](https://github.com/frida/frida/releases)).\
Una línea de comando para reiniciar adb en modo root, conectarse a él, cargar frida-server, otorgar permisos de ejecución y ejecutarlo en segundo plano:

{% code overflow="wrap" %}
```bash
adb root; adb connect localhost:6000; sleep 1; adb push frida-server /data/local/tmp/; adb shell "chmod 755 /data/local/tmp/frida-server"; adb shell "/data/local/tmp/frida-server &"
```
{% endcode %}

**Comprueba** si está **funcionando**:
```bash
frida-ps -U #List packages and processes
frida-ps -U | grep -i <part_of_the_package_name> #Get all the package name
```
## Tutoriales

### [Tutorial 1](frida-tutorial-1.md)

**Desde**: [https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1](https://medium.com/infosec-adventures/introduction-to-frida-5a3f51595ca1)\
**APK**: [https://github.com/t0thkr1s/frida-demo/releases](https://github.com/t0thkr1s/frida-demo/releases)\
**Código fuente**: [https://github.com/t0thkr1s/frida-demo](https://github.com/t0thkr1s/frida-demo)

Sigue el [enlace para leerlo](frida-tutorial-1.md).

### [Tutorial 2](frida-tutorial-2.md)

**Desde**: [https://11x256.github.io/Frida-hooking-android-part-2/](https://11x256.github.io/Frida-hooking-android-part-2/) (Partes 2, 3 y 4)\
**APKs y código fuente**: [https://github.com/11x256/frida-android-examples](https://github.com/11x256/frida-android-examples)

Sigue el [enlace para leerlo](frida-tutorial-2.md).

### [Tutorial 3](owaspuncrackable-1.md)

**Desde**: [https://joshspicer.com/android-frida-1](https://joshspicer.com/android-frida-1)\
**APK**: [https://github.com/OWASP/owasp-mstg/blob/master/Crackmes/Android/Level\_01/UnCrackable-Level1.apk](https://github.com/OWASP/owasp-mstg/blob/master/Crackmes/Android/Level\_01/UnCrackable-Level1.apk)

Sigue el [enlace para leerlo](owaspuncrackable-1.md).\
**Puedes encontrar algunos scripts increíbles de Frida aquí:** [**https://codeshare.frida.re/**](https://codeshare.frida.re)

## Ejemplos rápidos

Aquí puedes encontrar las funcionalidades más básicas e interesantes de Frida para crear un script rápido:

### Llamando a Frida desde la línea de comandos
```bash
frida-ps -U

#Basic frida hooking
frida -l disableRoot.js -f owasp.mstg.uncrackable1

#Hooking before starting the app
frida -U --no-pause -l disableRoot.js -f owasp.mstg.uncrackable1
#The --no-pause and -f options allow the app to be spawned automatically,
#frozen so that the instrumentation can occur, and the automatically
#continue execution with our modified code.
```
### Script básico de Python

```python
import frida

# Attach to the target process
session = frida.attach("com.example.app")

# Define the JavaScript code to be injected
js_code = """
Java.perform(function () {
    // Find the target method
    var targetMethod = Java.use("com.example.app.TargetClass.targetMethod");

    // Hook the target method
    targetMethod.implementation = function () {
        // Print the arguments passed to the method
        console.log("Arguments: " + Array.prototype.slice.call(arguments));

        // Call the original method
        var result = this.targetMethod.apply(this, arguments);

        // Print the result of the method
        console.log("Result: " + result);

        // Modify the result if needed
        // result = "Modified result";

        // Return the result
        return result;
    };
});
"""

# Create the script
script = session.create_script(js_code)

# Load the script into the target process
script.load()

# Detach from the target process
session.detach()
```

### Script básico de Python

```python
import frida

# Adjuntarse al proceso objetivo
session = frida.attach("com.example.app")

# Definir el código JavaScript a inyectar
js_code = """
Java.perform(function () {
    // Encontrar el método objetivo
    var targetMethod = Java.use("com.example.app.TargetClass.targetMethod");

    // Enganchar el método objetivo
    targetMethod.implementation = function () {
        // Imprimir los argumentos pasados al método
        console.log("Argumentos: " + Array.prototype.slice.call(arguments));

        // Llamar al método original
        var result = this.targetMethod.apply(this, arguments);

        // Imprimir el resultado del método
        console.log("Resultado: " + result);

        // Modificar el resultado si es necesario
        // result = "Resultado modificado";

        // Devolver el resultado
        return result;
    };
});
"""

# Crear el script
script = session.create_script(js_code)

# Cargar el script en el proceso objetivo
script.load()

# Desadjuntarse del proceso objetivo
session.detach()
```
```python
import frida, sys

jscode = open(sys.argv[0]).read()
process = frida.get_usb_device().attach('infosecadventures.fridademo')
script = process.create_script(jscode)
print('[ * ] Running Frida Demo application')
script.load()
sys.stdin.read()
```
### Enganchando funciones sin parámetros

Engancha la función `a()` de la clase `sg.vantagepoint.a.c`
```javascript
Java.perform(function () {
;  rootcheck1.a.overload().implementation = function() {
rootcheck1.a.overload().implementation = function() {
send("sg.vantagepoint.a.c.a()Z   Root check 1 HIT!  su.exists()");
return false;
};
});
```
# Hook java `exit()`

## Introduction

In this tutorial, we will learn how to hook the `exit()` method in a Java application using Frida. By hooking this method, we can intercept the application's exit calls and perform additional actions before the application terminates.

## Prerequisites

Before getting started, make sure you have the following:

- A rooted Android device or an emulator
- Frida installed on your machine
- Basic knowledge of JavaScript and Java

## Steps

Follow the steps below to hook the `exit()` method:

1. Launch the target application on your Android device or emulator.

2. Open a terminal and start the Frida server by running the following command:

   ```bash
   frida-server
   ```

3. Create a new JavaScript file, for example, `hook.js`, and add the following code:

   ```javascript
   Java.perform(function () {
       var System = Java.use('java.lang.System');
       var Runtime = Java.use('java.lang.Runtime');

       // Hook the exit() method
       System.exit.overload('int').implementation = function (status) {
           console.log('Exit status: ' + status);

           // Perform additional actions here

           // Call the original exit() method
           this.exit(status);
       };
   });
   ```

4. Save the `hook.js` file.

5. In the terminal, navigate to the directory where the `hook.js` file is located.

6. Run the following command to start the Frida script:

   ```bash
   frida -U -l hook.js -f <package_name>
   ```

   Replace `<package_name>` with the package name of the target application.

7. You should see the output of the `console.log()` statement whenever the `exit()` method is called in the target application.

8. Customize the code inside the `implementation` function to perform your desired actions before the application exits.

## Conclusion

By hooking the `exit()` method using Frida, we can intercept and modify the behavior of an application when it tries to exit. This technique can be useful for various purposes, such as analyzing the application's termination process or preventing it from exiting under certain conditions.
```javascript
var sysexit = Java.use("java.lang.System");
sysexit.exit.overload("int").implementation = function(var_0) {
send("java.lang.System.exit(I)V  // We avoid exiting the application  :)");
};
```
# Tutorial de Frida: Enganchando `.onStart()` y `.onCreate()` de MainActivity

En este tutorial, aprenderemos cómo utilizar Frida para enganchar los métodos `.onStart()` y `.onCreate()` de la clase MainActivity en una aplicación de Android. Esto nos permitirá interceptar y modificar el comportamiento de estos métodos en tiempo de ejecución.

## Requisitos previos

Antes de comenzar, asegúrate de tener instalado lo siguiente:

- Frida Server en el dispositivo Android objetivo.
- Frida CLI en tu máquina local.

## Paso 1: Conectarse al dispositivo

Primero, debemos conectarnos al dispositivo Android objetivo utilizando Frida CLI. Ejecuta el siguiente comando en tu terminal:

```bash
frida-ps -U
```

Esto mostrará una lista de los procesos en ejecución en el dispositivo. Asegúrate de que la aplicación que deseas pentestar esté en la lista.

## Paso 2: Crear el script de Frida

A continuación, crearemos un script de Frida para enganchar los métodos `.onStart()` y `.onCreate()` de la clase MainActivity. Crea un archivo llamado `hook.js` y pega el siguiente código:

```javascript
Java.perform(function() {
  var MainActivity = Java.use('com.example.app.MainActivity');

  MainActivity.onStart.implementation = function() {
    console.log('Método onStart() enganchado');
    // Agrega aquí tu código personalizado
    this.onStart();
  };

  MainActivity.onCreate.implementation = function() {
    console.log('Método onCreate() enganchado');
    // Agrega aquí tu código personalizado
    this.onCreate();
  };
});
```

## Paso 3: Ejecutar el script de Frida

Ahora, ejecutaremos el script de Frida para enganchar los métodos `.onStart()` y `.onCreate()`. Ejecuta el siguiente comando en tu terminal:

```bash
frida -U -l hook.js -f com.example.app
```

Esto iniciará la aplicación de Android objetivo y enganchará los métodos especificados en el script de Frida.

## Paso 4: Verificar la salida

Finalmente, verifica la salida en la terminal para confirmar que los métodos `.onStart()` y `.onCreate()` han sido enganchados con éxito. También puedes agregar tu propio código personalizado dentro de los métodos enganchados para modificar su comportamiento.

¡Felicidades! Ahora sabes cómo utilizar Frida para enganchar los métodos `.onStart()` y `.onCreate()` de la clase MainActivity en una aplicación de Android. Esto te permitirá realizar pruebas de penetración y modificar el comportamiento de la aplicación en tiempo de ejecución.
```javascript
var mainactivity = Java.use("sg.vantagepoint.uncrackable1.MainActivity");
mainactivity.onStart.overload().implementation = function() {
send("MainActivity.onStart() HIT!!!");
var ret = this.onStart.overload().call(this);
};
mainactivity.onCreate.overload("android.os.Bundle").implementation = function(var_0) {
send("MainActivity.onCreate() HIT!!!");
var ret = this.onCreate.overload("android.os.Bundle").call(this,var_0);
};
```
# Hook android `.onCreate()`

En este tutorial, aprenderás cómo realizar un hook en el método `.onCreate()` de una aplicación Android utilizando Frida.

## Requisitos previos

- Dispositivo Android rooteado o emulador con acceso de root.
- Frida Server instalado en el dispositivo objetivo.
- Conocimientos básicos de JavaScript.

## Pasos

1. Abre una terminal y ejecuta el siguiente comando para iniciar el servidor Frida en el dispositivo objetivo:

   ```
   frida-server
   ```

2. Asegúrate de que el dispositivo objetivo y tu máquina estén conectados a la misma red.

3. En tu máquina, crea un nuevo archivo JavaScript llamado `hook.js` y ábrelo en un editor de texto.

4. Agrega el siguiente código al archivo `hook.js`:

   ```javascript
   Java.perform(function() {
       var targetClass = Java.use('com.example.app.MainActivity');
       targetClass.onCreate.implementation = function() {
           console.log('Hook exitoso en el método onCreate()');
           this.onCreate();
       };
   });
   ```

5. Guarda el archivo `hook.js`.

6. Ejecuta el siguiente comando en la terminal para iniciar el script de Frida:

   ```
   frida -U -l hook.js com.example.app
   ```

   Asegúrate de reemplazar `com.example.app` con el nombre del paquete de la aplicación que deseas pentestar.

7. Abre la aplicación en el dispositivo objetivo y verás que se muestra el mensaje "Hook exitoso en el método onCreate()" en la terminal.

¡Felicidades! Has realizado un hook en el método `.onCreate()` de una aplicación Android utilizando Frida. Esto te permitirá interceptar y modificar el comportamiento de la aplicación en este punto específico.
```javascript
var activity = Java.use("android.app.Activity");
activity.onCreate.overload("android.os.Bundle").implementation = function(var_0) {
send("Activity HIT!!!");
var ret = this.onCreate.overload("android.os.Bundle").call(this,var_0);
};
```
### Enganchando funciones con parámetros y recuperando el valor

Enganchando una función de desencriptación. Imprimir la entrada, llamar a la función original para desencriptar la entrada y finalmente, imprimir los datos en texto plano:
```javascript
function getString(data){
var ret = "";
for (var i=0; i < data.length; i++){
ret += data[i].toString();
}
return ret
}
var aes_decrypt = Java.use("sg.vantagepoint.a.a");
aes_decrypt.a.overload("[B","[B").implementation = function(var_0,var_1) {
send("sg.vantagepoint.a.a.a([B[B)[B   doFinal(enc)  // AES/ECB/PKCS7Padding");
send("Key       : " + getString(var_0));
send("Encrypted : " + getString(var_1));
var ret = this.a.overload("[B","[B").call(this,var_0,var_1);
send("Decrypted : " + ret);

var flag = "";
for (var i=0; i < ret.length; i++){
flag += String.fromCharCode(ret[i]);
}
send("Decrypted flag: " + flag);
return ret; //[B
};
```
### Enganchando funciones y llamándolas con nuestra entrada

Engancha una función que recibe una cadena y llámala con otra cadena (desde [aquí](https://11x256.github.io/Frida-hooking-android-part-2/))
```javascript
var string_class = Java.use("java.lang.String"); // get a JS wrapper for java's String class

my_class.fun.overload("java.lang.String").implementation = function(x){ //hooking the new function
var my_string = string_class.$new("My TeSt String#####"); //creating a new String by using `new` operator
console.log("Original arg: " +x );
var ret =  this.fun(my_string); // calling the original function with the new String, and putting its return value in ret variable
console.log("Return value: "+ret);
return ret;
};
```
### Obteniendo un objeto ya creado de una clase

Si deseas extraer algún atributo de un objeto creado, puedes utilizar esto.

En este ejemplo, verás cómo obtener el objeto de la clase my\_activity y cómo llamar a la función .secret() que imprimirá un atributo privado del objeto:
```javascript
Java.choose("com.example.a11x256.frida_test.my_activity" , {
onMatch : function(instance){ //This function will be called for every instance found by frida
console.log("Found instance: "+instance);
console.log("Result of secret func: " + instance.secret());
},
onComplete:function(){}
});
```
<img src="../../../.gitbook/assets/i3.png" alt="" data-size="original">

**Consejo de recompensa por errores**: ¡**regístrate** en **Intigriti**, una plataforma premium de **recompensas por errores creada por hackers, para hackers**! ¡Únete a nosotros en [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoy mismo y comienza a ganar recompensas de hasta **$100,000**!

{% embed url="https://go.intigriti.com/hacktricks" %}

<details>

<summary><a href="https://cloud.hacktricks.xyz/pentesting-cloud/pentesting-cloud-methodology"><strong>☁️ HackTricks Cloud ☁️</strong></a> -<a href="https://twitter.com/hacktricks_live"><strong>🐦 Twitter 🐦</strong></a> - <a href="https://www.twitch.tv/hacktricks_live/schedule"><strong>🎙️ Twitch 🎙️</strong></a> - <a href="https://www.youtube.com/@hacktricks_LIVE"><strong>🎥 Youtube 🎥</strong></a></summary>

* ¿Trabajas en una **empresa de ciberseguridad**? ¿Quieres ver tu **empresa anunciada en HackTricks**? ¿O quieres tener acceso a la **última versión de PEASS o descargar HackTricks en PDF**? ¡Consulta los [**PLANES DE SUSCRIPCIÓN**](https://github.com/sponsors/carlospolop)!
* Descubre [**La Familia PEASS**](https://opensea.io/collection/the-peass-family), nuestra colección exclusiva de [**NFTs**](https://opensea.io/collection/the-peass-family)
* Obtén el [**swag oficial de PEASS y HackTricks**](https://peass.creator-spring.com)
* **Únete al** [**💬**](https://emojipedia.org/speech-balloon/) [**grupo de Discord**](https://discord.gg/hRep4RUj7f) o al [**grupo de Telegram**](https://t.me/peass) o **sígueme** en **Twitter** [**🐦**](https://github.com/carlospolop/hacktricks/tree/7af18b62b3bdc423e11444677a6a73d4043511e9/\[https:/emojipedia.org/bird/README.md)[**@carlospolopm**](https://twitter.com/hacktricks\_live)**.**
* **Comparte tus trucos de hacking enviando PRs al** [**repositorio de hacktricks**](https://github.com/carlospolop/hacktricks) **y al** [**repositorio de hacktricks-cloud**](https://github.com/carlospolop/hacktricks-cloud).

</details>