# Predicate Injection

## Description

Lorsque des données non fiables (*untrusted input*) sont intégrées dans la chaîne de *predicate*, le *parser* les interprète comme de la syntaxe de *predicate*. Un attaquant peut alors injecter n’importe quel mot-clé de *predicate* afin de construire une requête arbitraire, ainsi que des expressions `FUNCTION` et `CAST` pour invoquer des méthodes Objective-C arbitraires dans le processus cible.

## Reconnaissance

\
Pour détecter des *predicate injections*, recherchez les symboles et chaînes de caractères liés aux *predicates*.

Les *predicates* sont construits via des appels de méthodes Objective-C. Commencez donc par analyser la table des symboles pour trouver des références de *selectors* (exemple avec radare2):

```bash
r2 -q -A -c 'is~Predicate' TargetApp
```

Dans les binaires Swift, les symboles sont *mangled (obfusqués)*. Ce qui donne par exemple :

```
sym._$sSo11NSPredicateC10FoundationE6format_ABSSh_s7CVarArg_pdtcfC
```

Qui correspond à `NSPredicate.init(format:)`.

Le flag `U` indique que ce symbole est importé depuis *Foundation*, confirmant que l’application l’utilise.

Ensuite, analysez les chaînes de caractères du binaire pour identifier des fragments de *predicate* :

```bash
strings TargetApp | grep -iE '== |AND |OR |CONTAINS|MATCHES|BEGINSWITH|FUNCTION|CAST'
```

A partir de là, des fragments séparés comme :

```
username == ' 
AND password == '
```

Indique l'usage de *predicate* pour construire dynamiquement des requêtes via **concaténation** ou **interpolation** de données utilisateurs.

À l’inverse, une chaîne statique unique comme :

```
username == %@ AND password == %@
```

Indique que les requêtes sont probablement paramétrées (Sécurisé)

Ainsi, si l'application semble utiliser des requêtes non paramétrées, il faut ensuite identifier les classes et méthodes responsables de la construction du *predicate* (pour cela, on peut également utiliser radatre2):

```bash
r2 -q -A -c 'is~ViewController' TargetApp
```

Lors de l’analyse, recherchez :

* Les références de chaînes correspondant aux fragments de *predicate* identifiés
* Les appels à `NSPredicate.init(format:)` ou `predicateWithFormat:`
* Le flux de données (*data flow*) entre les sources utilisateur (champs texte, paramètres URL, réponses réseau) et la chaîne de *predicate*

Si des données contrôlées par l’utilisateur atteignent la chaîne de *predicate* via concaténation ou interpolation avant d’être traitées par le *parser*, cela indique une *predicate injection*.

Enfin, si le *predicate* est utilisé avec :

* `evaluateWithObject:`
* `filteredArrayUsingPredicate:`

alors il est exécuté contre un objet dans le processus cible, ce qui peut entraîner un impact direct en cas d’injection réussie.

## Ressources

{% embed url="<https://codecolor.ist/posts/2021-01-16-see-no-eval-runtime-code-execution-objc/>" %}


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://blog.s1rn3tz.ovh/pentest-mobile/ios/predicate-injection.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.