Dumper d'IPA iOS moderne

Un outil moderne de décryptage mémoire d'applications iOS conçu pour Frida 17.5.2+ avec une prise en charge complète d'iOS 14-16 et de multiples jailbreaks.

Statut : ✅ Fonctionnel et testé - Extrait et décrypte avec succès des applications iOS à l'aide de Frida 17.5.2 sur :

iOS 14.7.1 + jailbreak Taurine (iPad mini 5)
iOS 16.7.12 + jailbreak palera1n (iPhone 8)

Fonctionnalités

✅ Compatible avec Frida 17.5.2+ (utilise NativePointer.readByteArray)
✅ Fonctionne avec le jailbreak Taurine (iOS 14.7.1)
✅ Fonctionne avec le jailbreak palera1n (iOS 16.7.12)
✅ Gère les chemins de jailbreak /cores/binpack/ de palera1n
✅ Décryptage rapide via dump mémoire + patch manuel de cryptid
✅ Aucun appel API obsolète
✅ Code propre et maintenable
✅ Empaquetage IPA automatique
✅ Utilise Python paramiko (aucun outil externe requis)
✅ Rapport d'avancement détaillé

Pourquoi cet outil ?

L'outil original frida-ios-dump (dernière mise à jour en 2020) utilise des API Frida obsolètes qui ne fonctionnent pas avec Frida 17.5.2. Cet outil est développé à partir de zéro avec les API Frida modernes et a été spécifiquement testé avec les correctifs Frida compatibles Taurine.

Prérequis

Prérequis macOS/Hôte

Python 3.8+
Frida 17.5.2+
paramiko (bibliothèque SSH Python - installée automatiquement)
iproxy (pour la connexion USB via libimobiledevice)

Prérequis pour l'appareil iOS

Appareil iOS jailbreaké (testé sur iOS 14.7.1 + Taurine)
Serveur frida patché en cours d'exécution (voir les correctifs Frida dans will add my patch repo)
Accès SSH activé

Installation

cd /Users/username/git/frida-ios-dump-modern

# Create virtual environment with uv:
uv venv
source .venv/bin/activate

# Install dependencies
uv pip install -r requirements.txt

# Make script executable
chmod +x dump.py

Configuration de la connexion USB

# Install libimobiledevice if needed
brew install libimobiledevice

# Start USB tunnel (in a separate terminal)
iproxy 2222 22

Utilisation

1. Lister les applications installées

python dump.py -l

2. Extraire une application

Important : L'application doit être en cours d'exécution avant l'extraction en raison des restrictions du jailbreak Taurine.

# 1. Launch the app on your device manually
# 2. Run the dumper:

python dump.py com.example.app

# With custom SSH password:
python dump.py com.example.app -P your_password

# With custom output directory:
python dump.py com.example.app -o /path/to/output

3. Exemple : extraire Ventusky

# 1. Open Ventusky on your iOS device
# 2. Run:
python dump.py com.in-meteo.ventusky -P mypassword

Comment ça fonctionne

Approche compatible iOS 16 (méthode hybride)

Attacher : Se connecte au processus de l'application en cours d'exécution via Frida
Énumérer : Liste tous les modules (binaires) chargés dans l'application
Lire le binaire disque : Lit le binaire chiffré d'origine depuis le système de fichiers de l'appareil
- Critique pour iOS 16 : Préserve les données LC_DYLD_CHAINED_FIXUPS
- Conserve les segments DATA d'origine avec les chaînes de fixups intactes
Lire le segment déchiffré : Lit UNIQUEMENT le segment TEXT chiffré depuis la mémoire
- iOS déchiffre le code à l'exécution
- Nous lisons uniquement la partie déchiffrée, pas tout le binaire
Remplacer et patcher :
- Remplace le segment TEXT chiffré du binaire disque par la mémoire déchiffrée
- Définit cryptid=0 dans LC_ENCRYPTION_INFO
- Tous les segments DATA restent intacts (préserve les fixups)
Extraire : Écrit le binaire hybride dans /tmp sur l'appareil
Télécharger : Transfère les fichiers de l'appareil via SCP via paramiko
Packager : Crée un fichier IPA déchiffré prêt pour l'analyse

Pourquoi cela fonctionne sur iOS 16 :

iOS 16 utilise des fixups chaînés - les pointeurs sont stockés sous forme de « chaînes » que dyld résout à l'exécution
Extraire depuis la mémoire nous donne des pointeurs résolus, mais les outils attendent des chaînes de fixups
En lisant le binaire disque et en remplaçant uniquement le TEXT chiffré, nous préservons les fixups d'origine
C'est l'approche qu'utilisent bagbak et les autres dumpers modernes

Sortie

L'outil crée :

Binaires déchiffrés individuels
Bundle d'application complet avec les binaires déchiffrés
Fichier IPA empaqueté prêt pour l'analyse

Exemple de structure de sortie :

/tmp/Ventusky_decrypted/
├── Payload/
│   └── Ventusky.app/
│       ├── Ventusky (decrypted main binary)
│       ├── Frameworks/
│       │   └── *.framework (decrypted frameworks)
│       └── ... (other app resources)
└── Ventusky_decrypted.ipa

Compatibilité avec le jailbreak Taurine

Cet outil est conçu pour fonctionner avec le serveur Frida patché pour Taurine, qui inclut :

Pas de suspension de thread sur iOS 14 : Empêche les paniques du noyau
Pas d'injection launchd : Respecte les restrictions de Taurine
Lancement manuel des applications requis : Les applications doivent être lancées manuellement avant l'extraction

Dépannage

« Aucun périphérique USB trouvé »

# Check frida-server is running on device:
ssh -p 2222 root@localhost "ps aux | grep frida-server"

# Restart frida-server if needed:
ssh -p 2222 root@localhost "killall frida-server; frida-server &"

« Application introuvable »

# List apps to find correct bundle ID:
python dump.py -l

« Application non lancée »

# Launch the app manually on your device first
# This is required due to Taurine jailbreak restrictions

Échec de l'authentification SSH

# Test SSH connection:
ssh -p 2222 root@localhost

# If password prompt works, use -P flag:
python dump.py com.example.app -P your_password

iOS 16 : « Les métadonnées Objective-C semblent corrompues » dans Hopper

Si vous obtenez des erreurs de métadonnées sur iOS 16 après le patch :

Diagnostiquer le problème :

# Run diagnostic on dumped binary
./diagnose_ios16.sh /tmp/AppName_decrypted/Payload/AppName.app/AppName

# Compare with working iOS 14 binary
./diagnose_ios16.sh /path/to/working/ios14/binary

Points clés à vérifier :

La taille du fichier correspond au binaire original sur le disque
Cherchez LC_DYLD_CHAINED_FIXUPS (spécifique à iOS 16)
Vérifiez que cryptid est 0 après le patch

L'outil lit désormais la taille du fichier original depuis le disque pour éviter d'extraire des régions mémoire étendues à l'exécution.

Après l'extraction : Vérification

Bonne nouvelle : L'outil définit désormais automatiquement cryptid=0 lors de l'extraction, donc le patch manuel n'est plus nécessaire !

Compatibilité iOS 16 : L'outil utilise une approche hybride :

Lit le binaire original depuis le disque (préserve les fixups chaînés)
Remplace uniquement le segment TEXT chiffré par la mémoire déchiffrée
Définit cryptid=0 automatiquement
Préserve tous les segments DATA avec les chaînes de fixups d'origine intactes

Cela empêche les erreurs « Is this a file manually extracted from the DYLD shared cache? » et « Objective-C Metadata looks mangled » sur iOS 16.

Vérifier l'extraction :

# Check that cryptid is 0 (should be automatic now)
otool -l Payload/App.app/App | grep cryptid
# Should show: cryptid 0

# Check file has all segments
otool -l Payload/App.app/App | grep "segname __"
# Should show: __TEXT, __DATA_CONST, __DATA, __LINKEDIT

# Open in Hopper - should work without warnings!

Patch manuel (hérité - plus nécessaire) :

Si pour une raison quelconque le patch automatique de cryptid n'a pas fonctionné :

# Check if patching needed
otool -l Payload/App.app/App | grep cryptid
# If shows cryptid 1, run:

python patch_cryptid.py Payload/App.app/App
mv Payload/App.app/App.patched Payload/App.app/App

Résultat attendu :

✅ Hopper s'ouvre sans avertissements « ciphered » ni « mangled metadata »
✅ Toutes les classes et méthodes Objective-C sont visibles
✅ Noms de procédures correctement résolus (pas sub_XXXXX)
✅ Fonctionne à la fois sur iOS 14 (Taurine) et iOS 16 (palera1n)

Détails techniques - Fixups chaînés iOS 16 :

Problème : iOS 16 utilise LC_DYLD_CHAINED_FIXUPS pour l'authentification des pointeurs
Difficulté : Extraire depuis la mémoire donne des pointeurs résolus, pas des chaînes de fixups
Solution : Approche hybride
1. Lire le binaire chiffré original depuis le disque (contient les chaînes de fixups)
2. Lire UNIQUEMENT le segment TEXT déchiffré depuis la mémoire
3. Remplacer le TEXT chiffré du binaire disque par la mémoire déchiffrée
4. Préserver les segments DATA du disque (chaînes de fixups intactes)
5. Définir cryptid=0 automatiquement
Résultat : Le binaire contient le code déchiffré + les chaînes de fixups d'origine = Hopper est content !

Différences d'API par rapport à l'ancien frida-ios-dump

Cet outil utilise les API modernes de Frida 17.5.2 :

Support

Si vous trouvez cet outil utile ou souhaitez des mises à jour, envisagez de soutenir le projet. Boba en a besoin :

☕ Offrez-moi un Boba

Licence

Licence MIT - Gratuit pour la recherche en sécurité et à des fins éducatives.

Crédits

Conçu pour une utilisation avec Frida patché Taurine (étude de cas à venir)
Inspiré du frida-ios-dump original par AloneMonkey
Implémentation d'API moderne pour Frida 17.5.2+

Note de sécurité

Cet outil est destiné à :

La recherche en sécurité
Les défis CTF
Des fins éducatives
???
Profit

`Module.ensureInitialized()`	Non nécessaire	ObjC auto-initialisé
`Module.findExportByName(null, 'name')`	`Module.findGlobalExportByName('name')`	Exports globaux
`Process.getModuleByName()`	`Process.findModuleByName()`	Renvoie null si introuvable
E/S de fichiers POSIX manuelles	`new File(path, 'wb')`	API File intégrée
`Memory.writeByteArray()`	`file.write(arrayBuffer)`	Écriture binaire directe

frida-ios-dump-modern

Populaires