> 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/ios/predicate-injection.md). # 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="" %}