Skip to content
KitploitKITPLOIT
OutilsExploitsBlog
Log in
Soumettre
OutilsExploitsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

FluxContactConfidentialité© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
CVE-2026-20700 — Preuve de concept démontrant dyld comme oracle de signature PAC via des fixups chaînés Mach-O spécialement conçus sur arm64e, permettant des écritures contrôlées de pointeurs valides PAC et l'exécution de callbacks de dispatch sur iOS. | Kitploit
Outils/GitHubGitHub/r3n3r0/cve-2026-20700
Analyse des VulnérabilitésExploitationRétro-ingénierieShellcodeCTFSécurité MatérielleArticles et RechercheApprentissage et ÉducationDéveloppement de Charges UtilesExploitation de BinairesLabs et Pratique
10363il y a 5 moisPas encore vérifié
GitHub
r3n3r0/cve-2026-20700

CVE-2026-20700

Preuve de concept démontrant dyld comme oracle de signature PAC via des fixups chaînés Mach-O spécialement conçus sur arm64e, permettant des écritures contrôlées de pointeurs valides PAC et l'exécution de callbacks de dispatch sur iOS.

Voir le dépôt
Partager

dyld-signing-oracle-poc

Une exploration contrôlée du mécanisme de liaison page-in et de correction chaînée de dyld en tant qu'oracle de signature PAC, dans le contexte de CVE-2026-20700.

Sur arm64e, chaque pointeur de fonction est authentifié par le matériel. L'objectif ici est de montrer que dyld lui-même peut être dirigé — via un Mach-O fabriqué à la main — pour produire des pointeurs valides PAC dans des emplacements choisis par l'attaquant, en utilisant uniquement son propre mécanisme de correction normal.

Testé sur : iPhone 14 (iOS 18.5, arm64e).


Ce que cela démontre

  1. Liaison de correction chaînée contrôlée — dyld accepte un dylib Mach-O fabriqué à la main et écrit des pointeurs de fonction valides PAC dans des emplacements choisis de sa propre section __DATA.
  2. Crash déterministe dans fixupPage64 — des valeurs page_start / next malformées font sortir dyld des limites de la page, prouvant l'atteignabilité des branches.
  3. Exécution de la boucle d'événements dispatch — le pointeur valide PAC écrit par dyld est enregistré comme gestionnaire de timer dispatch_source_t et appelé naturellement via la boucle d'événements, sans invocation directe depuis le code PoC.

Structure du dépôt

dyld-signing-oracle-poc/
├── Makefile                        ← orchestrates the full pipeline
├── src/
│   └── launcher.c                  ← iOS launcher (2 threads + dispatch chain-close)
├── generators/
│   ├── gen_exports.py              ← generates exports.c  (N dummy symbols)
│   ├── gen_client.py               ← generates client.c  (N imports, dyld gate stress)
│   └── gen_malformed_dylib.py      ← generates libmalformed.dylib (hand-crafted Mach-O)
├── tools/
│   ├── scan_pointers.py            ← classifies Mach-O pointer sections as W/R
│   └── inspect_fixups.py           ← parses LC_DYLD_CHAINED_FIXUPS header
└── blog/
    ├── it/
    │   └── dyld-signing-oracle.md  ← write-up completo in italiano
    └── en/
        └── dyld-signing-oracle.md  ← full write-up in English

Sorties de compilation (non commit)

FichierGénéré par
exports.cgenerators/gen_exports.py + symboles sentinelles Makefile
client.cgenerators/gen_client.py
libmalformed.dylibgenerators/gen_malformed_dylib.py
libexports.dylibclang à partir de exports.c
libclient.dylibclang à partir de client.c
PoCAppclang à partir de src/launcher.c
PoCApp.ipaÉtape package du Makefile

Prérequis

  • macOS avec outils en ligne de commande Xcode
  • SDK iOS (xcrun --sdk iphoneos --show-sdk-path)
  • Python 3
  • Pour les tests sur appareil : Sideloadly ou un certificat développeur + profil de provisionnement

Compilation

# Default full build (arm64, 99k symbols)
make

# Fast build for iteration
make SYMBOLS=10000

Préréglages

# Deterministic crash in fixupPage64 (branch reachability proof)
make stress

# Stable intra-image write-what-where
make exploit

# dyld writes PAC-valid pointer → dispatch calls it naturally
make chain_close

Outils d'analyse

# Verify generated chained-fixup blob layout
make verify

# Parse LC_DYLD_CHAINED_FIXUPS header of libmalformed.dylib
make inspect

# Scan pointer sections (GOT/non-lazy) across compiled binaries
make scan

Paramètres ajustables

VariableDéfautDescription
SYMBOLS99000Nombre de cibles de liaison dans libclient (< 100k pour la passerelle pre-26.3, < 64k pour 26.3+)
STACK_KB128Taille de la pile du thread worker en Ko
BURN_KB0Ko de pile à consommer avant dlopen (0 = auto)
MARGIN_KB24Marge auto-burn
ARM64E0Utiliser le format DYLD_CHAINED_PTR_ARM64E_USERLAND24
MALFORM_PAGEIN0Activer la chaîne page-in malformée
MALFORM_TARGET_OFFSET—Décalage cible dans __DATA (ex. 0x10)
CHAIN_CLOSE0Deuxième emplacement → _attacker_hook, activer la démo dispatch

Installation sur l'appareil

# Ad-hoc signed (Sideloadly)
make chain_close
# drag PoCApp.ipa into Sideloadly

# Real certificate
make resign IDENTITY="iPhone Developer: ..." PROFILE=embedded.mobileprovision

# Monitor logs
idevicesyslog | grep "POC"

Comment ça fonctionne

Ordre de chargement à l'exécution dans PoCApp :

  1. libexports.dylib — chargé en premier (RTLD_GLOBAL), fournit write_target_value et attacker_hook à tout dlopen ultérieur.
  2. libclient.dylib — chargé par le Thread B (pile de 128 Ko) ; environ 99k cibles de liaison stressent la passerelle de liaison page-in de dyld.
  3. libmalformed.dylib — chargé par le Thread A ; une chaîne de correction chaînée fabriquée à la main fait que dyld résout et écrit _write_target_value (et optionnellement _attacker_hook) dans __DATA+0x10 / +0x20.
  4. Le Thread A lit les emplacements écrits, valide les canaris, appelle le pointeur de fonction que dyld a écrit.
  5. En mode chain_close, le main enregistre __DATA+0x20 comme gestionnaire de timer dispatch_source_t — la boucle d'événements l'appelle 1 seconde plus tard sans invocation directe depuis le code PoC.

Blog

Article technique complet en italien et en anglais. Couvre : mécanismes matériels PAC, dyld comme producteur de pointeurs, encodage de correction chaînée à partir de zéro, mécanismes de la passerelle de liaison page-in, pièges d'ingénierie Mach-O (sizeofcmds, nombre de sections, stride), disposition des données validées par canari, la passerelle des 99k symboles, preuve de crash d'atteignabilité, primitive intra-image stable, concept d'oracle de signature arm64e, fermeture de chaîne par timer dispatch.

  • 🇮🇹 Italiano — blog/it/dyld-signing-oracle.md
  • 🇬🇧 English — blog/en/dyld-signing-oracle.md
Télécharger l’outil

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 La boîte à outils OSINT ultime : graphe d'enquête, notation de confiance, familles d'alias, carte, chronologie et rapports. 49 modules, plus de 400 sites, aucune clé API requise.

    540
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Application d'exécution en un clic GhostLock (CVE-2026-43499)

    476
  • 3

    ARTEX

    baarai/artex

    Plateforme autonome de tests d'intrusion multi-agents basée sur des LLM, avec agents planificateur/ouvrier, graphes d'actifs et d'exploration, enregistrement du trafic MITM et retest des vulnérabilités.

    373
  • 4

    redforge

    cybersecurity91/redforge

    Boîte à outils red team côté navigateur avec 102 outils hors ligne pour la reconnaissance, la génération de payloads, les attaques par identifiants, la cryptographie, l'encodage et le reporting d'engagement.

    322
  • 5

    estorides

    grisuno/estorides

    Agrège plus de 99 sources OSINT gratuites en parallèle, résout les entités dans un graphe de connaissances et exporte en STIX 2.1, MISP ou GraphML avec une analyse assistée par LLM.

    278
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Le système d'action pour la cybersécurité native IA—où l'intention devient une exécution gouvernée, les preuves deviennent une mémoire opérationnelle, et chaque opération améliore la suivante.

    251

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →