# dyld come oracolo di firma: esplorare il page-in linking e i chained fixups

_Ricercatore: Paolo Russo — Maggio 2026_

---

Su ogni iPhone con chip A12 o superiore, ogni function pointer è firmato crittograficamente dall'hardware. Puoi avere un bug con scrittura arbitraria in memoria e ancora non riuscire a eseguire codice: qualsiasi puntatore che scrivi senza la firma corretta viene rifiutato dal processore prima ancora che parta la prima istruzione dell'attaccante.

Il valore difensivo di Pointer Authentication Code sta tutto qui. La chiave di firma non si può leggere, non si può derivare, non si può bruteforce. Le tecniche classiche — GOT overwrite, vtable hijacking, ROP — non funzionano se non si riesce a produrre un puntatore autenticato.

La domanda che ha guidato questo progetto è diversa: e se invece di forgiare la firma, si facesse firmare al sistema?

Il dynamic linker `dyld` produce puntatori PAC-validi come parte ordinaria del suo lavoro. Ogni volta che risolve un simbolo e lo scrive in una tabella GOT, su arm64e lo autentica con `pacia`. Non è una scelta — è necessario perché il sistema possa chiamare quei puntatori in seguito. Il linker ha la chiave, e la usa milioni di volte al giorno.

La domanda concreta diventa: è possibile costruire una dylib che faccia scrivere a dyld un puntatore PAC-valido in uno slot di memoria scelto dall'attaccante? Con quale meccanismo? Con quali limiti? E cosa succede se la struttura che guida dyld è malformata?

Questo progetto risponde a quelle domande costruendo tutto da zero: un Mach-O generato byte per byte in Python, un launcher che valida il risultato su hardware reale, e una dimostrazione end-to-end che mostra il puntatore scritto da dyld eseguito attraverso il dispatch event loop del processo — senza nessuna chiamata diretta da parte del codice "attaccante".

**Contesto.** CVE-2026-20700 è una vulnerabilità di memory corruption in dyld patchata in iOS 26.3 (febbraio 2026), scoperta da Google TAG e sfruttata in attacchi mirati definiti da Apple "extremely sophisticated". Faceva parte di una catena a tre CVE: CVE-2025-14174 (WebKit OOB read, ASLR defeat) + CVE-2025-43529 (WebKit use-after-free, write primitive) + CVE-2026-20700 (dyld, escalation da write primitive a code execution). I dettagli tecnici precisi di CVE-2026-20700 non sono ancora pubblici in forma verificata: questo progetto esplora il meccanismo di chained fixups e page-in linking come superficie di attacco plausibile in dyld, non è una riproduzione confermata del bug esatto.

---

## Come funziona PAC

Pointer Authentication Code è una funzionalità hardware introdotta con ARMv8.3-A, presente su tutti gli iPhone dall'A12 (2018) in poi.

Quando il codice salva un function pointer, esegue un'istruzione come `PACIA`. Questa prende il puntatore, un valore di contesto, e una chiave hardware a 128 bit chiamata `IA`, e calcola un MAC — un codice di autenticazione — che viene compresso nei bit alti inutilizzati del puntatore. Il risultato sembra un indirizzo normale ma porta una firma incorporata nel suo upper half.

Quando quel puntatore viene chiamato con `BLRAA`, il processore esegue `AUTIA`: ricalcola il MAC con la stessa chiave e lo stesso contesto, e verifica che corrisponda alla firma embedded. Se corrisponde, i bit alti vengono rimossi e l'esecuzione salta all'indirizzo. Se non corrisponde, i bit alti vengono corrotti deliberatamente — e il salto produce un fault immediato.

La chiave `IA` è generata casualmente all'avvio del processo. Vive in un registro hardware non leggibile dall'userspace. È diversa per ogni processo. Non si può derivare da nessun side channel che non sia già kernel code execution.

Questo significa che su arm64e non basta un primitivo di scrittura arbitraria per redirigere l'esecuzione. Bisogna produrre un puntatore autenticato — il che richiede, in qualche forma, accesso alla chiave.

---

## dyld come produttore di puntatori autenticati

Il dynamic linker `dyld` ha un ruolo privilegiato nel processo. All'avvio, prima che inizi l'esecuzione del codice utente, risolve tutti i simboli importati dalle dylib caricate e scrive i loro indirizzi runtime nelle tabelle GOT. Su arm64e, quei puntatori vengono scritti **già autenticati** — perché il sistema deve poterli chiamare normalmente in seguito.

In altre parole: dyld è, per definizione, un componente che produce puntatori PAC-validi come effetto collaterale del suo funzionamento ordinario. Lo fa per ogni libreria caricata in ogni processo.

Il meccanismo specifico che questo progetto esplora è il **page-in linking** e i **chained fixups** — due componenti introdotti con dyld4 che cambiano quando e come quei puntatori vengono prodotti.

---

## Chained fixups: la lista concatenata nei dati

Tradizionalmente, dyld utilizzava una tabella di relocazione separata — un elenco di entry del tipo "all'offset X scrivi l'indirizzo del simbolo Y". Efficace ma costoso: iterare centomila entry all'avvio è misurabilmente lento.

I chained fixups sono una rappresentazione più compatta. Invece di una tabella separata, i puntatori stessi — le locazioni di memoria che alla fine conterranno gli indirizzi runtime — contengono encoding strutturati che istruiscono dyld su cosa fare. Prima che dyld li processi, quegli slot non sono indirizzi: sono istruzioni per il linker.

Nel formato `DYLD_CHAINED_PTR_64_OFFSET` (formato 6, stride 4 byte):

```
bit 63     : 1 = bind (risolvi un simbolo), 0 = rebase (aggiusta per ASLR)
bit 62–51  : next — quante unità-stride avanzare per trovare la prossima entry
bit 23–0   : ordinale dell'import — indice nella tabella degli import
```

Questi encoding formano una lista concatenata attraverso il segmento `__DATA`. dyld trova il primo entry tramite il campo `page_start` nei metadati di fixup, lo processa (risolve il simbolo, scrive l'indirizzo runtime), poi segue `next` per trovare il successivo, fino a `next = 0`. Al termine, ogni slot che conteneva un encoding contiene ora un puntatore runtime — su arm64e, autenticato.

Su arm64e il formato rilevante è `DYLD_CHAINED_PTR_ARM64E_USERLAND24` (formato 12, stride 8 byte). Quando dyld processa un bind entry in questo formato, scrive il puntatore risolto **già firmato con `pacia`**. È il comportamento corretto e intenzionale del loader su hardware autenticato.

---

## Page-in linking: il ramo lazy

Il page-in linking è un'ottimizzazione introdotta con dyld4. Invece di applicare tutti i fixup all'avvio, dyld può deferirli per pagina: i fixup vengono applicati solo quando la pagina viene mappata in memoria per la prima volta. Il codice rilevante è `dyld4::fixupPage64`.

Questo ramo è attivato da un gate:

```c
if (pageInLinkingMode &&
    hasChainedFixups &&
    bindTargets.count() < threshold &&
    !hasFuncVarFixups) {
    setUpPageInLinking(...);
}
```

La condizione più interessante è `bindTargets.count() < threshold`. Prima di iOS 26.3 la soglia era 100.000. Da iOS 26.3 in poi Apple l'ha abbassata a 64.000.

L'area vulnerabile nei loader pre-patch era nel calcolo della write location all'interno di `fixupPage64`:

```
write_location = segment_vm_address + page_start + next * stride
```

Con `page_start` e `next` ben formati, questa formula finisce sempre dentro il segmento in fase di fixup. Con valori malformati, può atterrare altrove nell'address space del processo. Sui loader pre-patch, i bound check erano insufficienti a fermare questo.

---

## Costruire la dylib da zero

La parte più impegnativa del progetto non è l'exploit — è convincere dyld ad accettare un binario costruito manualmente. dyld esegue una validazione strutturale estesa e rifiuta qualsiasi anomalia prima di raggiungere il codice di fixup processing.

Le prime versioni del generatore (`generators/gen_malformed_dylib.py`) venivano rifiutate con errori classici:

```
dlopen: incompatible platform (have 'unknown', need 'iOS')
dlopen: missing LC_UUID
dyld: __TEXT segment fileoffset is not zero
dyld: symbol not found (flat namespace lookup)
```

Ogni errore ha insegnato qualcosa. Il layout finale che dyld accetta:

| Load Command | Valore |
|---|---|
| `LC_BUILD_VERSION` | platform=iOS, minos=16.0, sdk=16.0 |
| `LC_UUID` | 16 byte deterministici |
| `LC_SEGMENT_64 __TEXT` | fileoff=0, vmaddr=0x0, `__text` a 0x4000 |
| `LC_SEGMENT_64 __DATA` | fileoff=0x8000, vmaddr=0x8000, 2 sezioni |
| `LC_SEGMENT_64 __LINKEDIT` | fileoff=0xC000, blob fixup + exports trie |
| `LC_DYLD_CHAINED_FIXUPS` | offset/size nel LINKEDIT |
| `LC_DYLD_EXPORTS_TRIE` | exports trie minima |
| `LC_LOAD_DYLIB` | `@executable_path/libexports.dylib` (ordinal 1) |
| `LC_ID_DYLIB` | identity della dylib |

Il bug più sottile trovato durante lo sviluppo: `sizeofcmds` nell'header Mach-O deve includere la dimensione corretta del segmento `__DATA`. Il segmento ha due sezioni (`__data` e `__poc_ptrs`), quindi la sua dimensione è `sizeof(segment_command_64) + 2 * sizeof(section_64)`. Usare `1 * sizeof(section_64)` rendeva `sizeofcmds` troppo piccolo. dyld smetteva di iterare i load command prima di raggiungere `LC_BUILD_VERSION`, che appare per ultimo nel layout, e riportava platform `'unknown'`. Lo stesso errore causava il fallimento di `codesign`.

La risoluzione dei simboli richiede `LC_LOAD_DYLIB` esplicito e `lib_ordinal=1` in ogni import entry — senza di esso, il flat namespace lookup produceva ambiguità.

---

## Il layout del __DATA: canary e slot controllati

Il segmento `__DATA` della dylib generata è progettato per essere osservabile:

```
__DATA,__poc_ptrs:
  +0x00  canary_before   0xAAAAAAAAAAAAAAAA  ← sentinel
  +0x08  dummy           0x0000000000000000
  +0x10  write_target    [encoded bind entry]  ← dyld scriverà qui
  +0x18  canary_after    0xBBBBBBBBBBBBBBBB  ← sentinel
  +0x20  write_target2   [encoded bind entry]  ← secondo slot
```

I valori a `+0x10` e `+0x20` non sono indirizzi: prima del processing di dyld sono encoded bind entry. La chain entry a `+0x10` ha `next=4` (4 × stride 4 byte = 16 byte) per raggiungere `+0x20`, e `next=0` a `+0x20` per terminare.

Il blob `LC_DYLD_CHAINED_FIXUPS` nel LINKEDIT dichiara che la catena inizia a `page_start=0x10`. Quando dyld processa la pagina `__DATA`:

1. Salta a `__DATA+0x10`
2. Decodifica la bind entry: risolvi `_write_target_value` da `libexports.dylib`
3. Scrive l'indirizzo runtime nello slot — su arm64e, firmato con `pacia`
4. Segue `next=4` → salta a `+0x20`
5. Risolve e scrive il secondo simbolo
6. `next=0` → fine catena

I canary a `+0x00` e `+0x18` verificano che dyld abbia scritto solo negli slot previsti. Se cambiano, qualcosa è andato storto nel processing.

---

## Il gate: 99.000 simboli

Per entrare nel ramo di page-in linking, la condizione `bindTargets.count() < 100.000` deve essere soddisfatta. `libmalformed.dylib` ha solo due bind target — troppo pochi da soli. Il progetto usa `libclient.dylib`, generata con ~99.000 simboli importati, caricata da Thread B in parallelo, per creare le condizioni che attivano il ramo per le immagini nel range corretto.

Su iOS 26.3+: `make SYMBOLS=63000`.

---

## Il crash deterministico: prova di raggiungibilità

`make stress` costruisce una chain con `page_start=0x3FF8` e `next=0x800`:

```
write location = 0x8000 + 0x3FF8 + (0x800 × 8) = 0xBFF8  ← fuori dalla pagina
```

Su iOS 18.5 (pre-patch), dyld tenta di scrivere a `0xBFF8` e va in fault. Il crash report:

```
Exception Subtype: KERN_PROTECTION_FAILURE at 0x000000010408BFF8

Thread 1 Crashed:
  0  dyld   dyld4::fixupPage64(...)
  1  dyld   dyld4::dyld_map_with_linking_np(...)
  2  dyld   dyld4::setUpPageInLinkingRegions(...)
  3  dyld   dyld4::Loader::setUpPageInLinking(...)
```

Il crash dimostra che la chain malformata ha superato il gate ed è entrata nel codice vulnerabile. Che produca un fault invece di una scrittura silenziosa è l'effetto dei bound check presenti in questa versione — su loader pre-patch, la stessa input produceva una scrittura senza protezione.

---

## Il primitivo stabile: write-what-where intra-image

`make exploit` imposta `page_start=0x10`, puntando direttamente allo slot `write_target`. dyld processa il bind, risolve il simbolo, scrive il puntatore runtime. Il launcher lo legge e lo chiama.

```c
// Dopo dlopen di libmalformed:
uint64_t written = *(uint64_t*)((uint8_t*)data_base + 0x10);

// Un encoded bind entry ha bit 63 = 1.
// Un puntatore userspace risolto non ha mai bit 63 = 1.
if (written != 0 && (written >> 63) == 0) {
    void (*fn)(void) = (void(*)(void))written;
    fn();
}
```

Output su iPhone 14, iOS 18.5:

```
POC [ThreadA] write_target_value @ 0x000000010608CAE0
POC [ThreadA] write_target:  0x000000010608CAE0  SCRITTO DA DYLD
POC [ThreadA] canary_before: 0xAAAAAAAAAAAAAAAA  OK
POC [ThreadA] canary_after:  0xBBBBBBBBBBBBBBBB  OK
POC [ThreadA] hook_fn() eseguita
```

Entrambi i canary intatti. L'indirizzo che dyld ha scritto coincide con quello di `dlsym`. Il function pointer è chiamabile. Su arm64e, è autenticato dall'hardware.

---

## arm64e: dyld come signing oracle

Su arm64e, dopo il bind, lo slot contiene un puntatore firmato con `pacia` — verificabile con `AUTIA`, chiamabile con `BLRAA` senza fault. Questo è il concetto di "signing oracle": invece di forgiare un PAC tag, si fa firmare al sistema il puntatore desiderato.

La distinzione pratica: in uno scenario in cui si dispone di un primitivo di lettura arbitraria, si può leggere il puntatore che dyld ha scritto dopo `dlopen`. In uno scenario con scrittura arbitraria, si può usarlo per sovrascrivere una callback esistente nel processo. Il puntatore deve essere compatibile con il calling context del target — `AUTIA` usa anche il contesto per verificare, quindi non tutti i puntatori firmati da dyld sono usabili in qualsiasi call site. Ma per callback che usano lo stesso schema di firma (chiave IA, discriminatore compatibile), il puntatore prodotto da dyld è direttamente utilizzabile.

Questo è ciò che rende questa tecnica interessante come primitivo: non richiede accesso diretto alle chiavi hardware, richiede solo di far raggiungere il ramo di page-in linking a dyld.

---

## Dispatch timer: esecuzione naturale attraverso l'event loop

`make chain_close` completa la dimostrazione. Il secondo slot `+0x20` viene risolto su `_attacker_hook`. Dopo che Thread A valida il primitivo, main registra quello slot come handler di un `dispatch_source_t` timer che scatta dopo 1 secondo.

```c
void** cap_slot = (void**)((uint8_t*)data_base + 0x20);

dispatch_source_t src = dispatch_source_create(
    DISPATCH_SOURCE_TYPE_TIMER, 0, 0,
    dispatch_queue_create("com.poc.chain", NULL)
);
dispatch_source_set_timer(src,
    dispatch_time(DISPATCH_TIME_NOW, 1 * NSEC_PER_SEC),
    DISPATCH_TIME_FOREVER, 0);

dispatch_source_set_event_handler(src, ^{
    void (*fn)(void) = (void(*)(void))*cap_slot;
    fn();   // dispatch chiama il puntatore scritto da dyld
    dispatch_source_cancel(src);
});
dispatch_resume(src);
```

Il launcher non chiama mai `attacker_hook` direttamente. Registra lo slot come callback e aspetta. Il dispatch event loop lo chiama dopo 1 secondo.

Log completo su iPhone 14, iOS 18.5, arm64e:

```
POC [ThreadA] write_target:   0x000000010608CAE0  SCRITTO DA DYLD
POC [ThreadA] write_target2:  0x000000010608CB20
POC [ThreadA] hook_fn() eseguita
POC [ThreadA] hook2() eseguita
POC [ThreadA] === PRIMITIVO CONFERMATO ===
POC [poc] vtable slot @+0x20 = 0x10608cb20 — registro dispatch timer...
  ← 1 secondo →
POC [poc] === EVENTO DISPATCH (naturale) ===
POC [poc] chiamata via slot @+0x20 — non invocata dal launcher
[hook] attacker_hook: in esecuzione via dispatch naturale
[hook] CFI bypass confermato: dyld ha fornito PAC-valid ptr
POC [poc] === CHAIN CLOSE: esecuzione via event loop confermata ===
```

Il puntatore scritto da dyld viene eseguito dal dispatch runtime — non dal codice che lo ha prodotto.

---

## Cosa dimostra e cosa non dimostra

Il primitivo dimostrato è **intra-image**: dyld scrive il puntatore dentro `__DATA` della stessa immagine che sta fixando. Su sistemi patchati, uscire da quel perimetro è bloccato da tre protezioni indipendenti:

**Bound check post-patch**: `fixupPage64` verifica che ogni write location cada dentro la pagina e il segmento in fase di fixup. Catene OOB producono `KERN_PROTECTION_FAILURE`.

**__DATA_CONST**: le GOT e le vtable delle system library vivono in segmenti read-only dopo il binding iniziale. Non scrivibili al momento del `dlopen`.

**Consistenza del contesto PAC**: il tag firmato da dyld per la dylib corrente usa un contesto legato a quella immagine. Copiare quel puntatore in un call site di un'altra immagine può non superare `AUTIA` se il contesto atteso è diverso.

Il PoC non dimostra scrittura cross-image su sistemi patchati, né una catena exploit completa. Dimostra che è possibile costruire una dylib che dyld accetta e che, attraverso il suo normale meccanismo di fixup, produce puntatori autenticati in slot controllati — e che quei puntatori possono essere eseguiti naturalmente attraverso l'event loop del processo.

Vale la pena sottolineare che le protezioni di Apple al di fuori di dyld limitano significativamente la superficie di attacco pratica di questa vulnerabilità. Code signing impone che ogni dylib caricata sia firmata con un certificato Apple-trusted: su un device in produzione non è possibile caricare una dylib arbitraria senza una firma valida. Il sandbox del processo — in particolare WebContent su Safari — restringe ulteriormente quali percorsi sono raggiungibili da `dlopen`. Questi meccanismi di difesa in profondità fanno sì che la vulnerabilità, pur essendo reale, richieda prerequisiti significativi per essere sfruttabile in un contesto reale — non è un primitivo utilizzabile in isolamento.

---

## Struttura del repository

```
darksword-dyld-poc/
├── Makefile
├── src/
│   └── launcher.c              ← launcher iOS due-thread + dispatch chain-close
├── generators/
│   ├── gen_exports.py          ← genera exports.c (N simboli + sentinelle)
│   ├── gen_client.py           ← genera client.c (N import, stress gate)
│   └── gen_malformed_dylib.py  ← genera libmalformed.dylib byte per byte
├── tools/
│   ├── scan_pointers.py        ← classifica sezioni pointer Mach-O W/R
│   └── inspect_fixups.py       ← parser LC_DYLD_CHAINED_FIXUPS
└── blog/
    ├── it/
    └── en/
```

Nessun file generato viene committato. Tutto è riproducibile dai sorgenti.

---

## Build e utilizzo

```sh
# Build completo — arm64, 99k simboli
make

# Crash deterministico in fixupPage64 (prova di raggiungibilità)
make stress

# Write-what-where intra-image stabile
make exploit

# Dispatch chain: dyld produce il puntatore, event loop lo chiama
make chain_close

# Verifica struttura chained-fixup generata
make verify && make inspect

# Scan sezioni pointer
make scan

# iOS 26.3+ (soglia patchata a 64k)
make chain_close SYMBOLS=63000

# Log su device
idevicesyslog | grep "POC"
```

---

## Chiusura

La domanda di partenza era se fosse possibile fare in modo che dyld scrivesse un puntatore PAC-valido in uno slot scelto dall'esterno. La risposta è sì — ed è riproducibile su hardware reale in modo pulito e verificabile.

Il valore del progetto non sta nel produrre un exploit. Sta nel capire esattamente come funziona il meccanismo di fixup di dyld quando viene guidato da strutture Mach-O costruite a mano: cosa accetta, cosa rifiuta, come calcola le write location, e dove si fermano i bound check nelle versioni pre-patch.

Il fatto che Apple abbia patchato questo con bound check più stretti — e non rimuovendo la firma dei puntatori — conferma la natura del problema: il signing è necessario, non opzionale. La patch può solo limitare dove quella firma può atterrare, non impedire che avvenga. È il confine tra feature e superficie di attacco, e vale la pena esplorarlo con precisione.
