-----BEGIN PGP SIGNED MESSAGE----- Hash: SHA256 NEFARIOUSPLAN-CANONICAL-V1 {"body_md":"## The chain needed three CVEs because two of them stop at PAC\n\nThe two WebKit bugs in this chain are the conventional half of the exploit. CVE-2025-14174 is an out-of-bounds read in JavaScriptCore that leaks adjacent heap structure, enough to defeat ASLR inside the WebContent process. CVE-2025-43529 is a use-after-free in a DOM allocator that, paired with the leaked addresses, gives an arbitrary write primitive. Two bugs, one process, full memory read and write inside WebContent.\n\nOn any platform other than arm64e Apple silicon, that is the end of the chain. Read where you want, write where you want, overwrite a function pointer, return to your shellcode. Game over.\n\nOn arm64e, the write primitive walks into a wall. Every function pointer the runtime stores in writable memory is signed with Pointer Authentication. The signature is computed against the IA key, a 128-bit value held in a CPU system register that no userspace instruction can read. An attacker who controls all of WebContent's memory still cannot mint a valid signed pointer, because the key is not in WebContent's memory. The hardware refuses to authenticate forgeries, and an unsigned pointer that reaches a BLRAA instruction faults.\n\nSo the chain needs a third bug. Not a bug that breaks PAC mathematically. A bug that gets the system to sign a pointer the attacker chose, using the legitimate key, through the legitimate signing path.\n\nThat is what CVE-2026-20700 is.\n\n## dyld signs because dyld must\n\ndyld is the dynamic linker. On macOS, iOS, and the rest of Apple's platforms, dyld is the first piece of code that runs in a new process, and it stays resident inside every process for the lifetime of that process. Its job is to resolve symbols, lay out the shared cache, and write the import slots in the GOT so that when your binary calls `printf`, the call goes to the real `printf` in libSystem.\n\nOn arm64e, every one of those writes is a PAC operation. The GOT slot does not just hold the address of `printf`. It holds the address signed with the IA key, against a discriminator derived from the slot's location. When the calling code later does `BLRAA x16, x17`, the CPU authenticates the loaded pointer against the same discriminator and the same IA key. Match: the call proceeds. Mismatch: fault.\n\nFor this to work, dyld needs the IA key. dyld has the IA key. It must, because it is the component that signs the pointers it writes. The key is not exposed to dyld through some API the attacker could call. It is held by the hardware, and dyld's signing instructions (PACIA, PACIZA) operate on that key without ever materializing it in any register an attacker could read. From any reasoning about confidentiality, the key remains secret.\n\nBut the signing oracle is right there. Every binding dyld resolves, every chained fixup it applies, every entry in the linker's import table is a slot where dyld will, on its own, write a pointer signed with the real key. The address that gets signed is the address that resolves the symbol. Control the resolution, and you control what dyld signs.\n\nThis is the surface CVE-2026-20700 lives on.\n\n## The PoC makes dyld sign at attacker-chosen slots\n\nThe PoC repository for this CVE, R3n3r0/CVE-2026-20700, codename darksword, ships a Makefile, a launcher, and a generator that builds a deliberately malformed dylib. The malformed dylib's job is to feed dyld a chained-fixup stream whose binding entries point at attacker-chosen target addresses, and whose chain-walk metadata pushes dyld into writing the resulting signed pointer at a slot the attacker controls.\n\nThe relevant file format is dyld4's chained-fixup encoding, declared via `LC_DYLD_CHAINED_FIXUPS` in `__LINKEDIT`. The format encodes fixup chains directly into the bytes of the `__DATA` segment, using bit-fields inside what will eventually be 64-bit pointers. Bit 63 marks a bind entry. Bits 62 through 51 encode the offset to the next entry in the chain. Bits 23 through 0 encode the import ordinal that resolves to a symbol in the linker's bind table.\n\nThe malformed dylib in the PoC declares a bind table containing two symbols. The first symbol resolves to a write target address inside the loaded image. The second symbol, in the `chain_close` preset, resolves to a function the attacker wants to call. The chain encoded in `__DATA` is short, two entries, and the next-pointer offsets are tuned so that the write of the signed pointer for the second symbol lands at a slot the attacker has reason to expect will be invoked.\n\nWhen dyld walks this chain inside `fixupPage64`, it computes the write location with the formula `segment_vm_address + page_start + next * stride`, looks up the import target, signs that target with the IA key against the slot's PAC discriminator, and writes the signed pointer to the slot. dyld did exactly what dyld is supposed to do. It signed a pointer it resolved against an import ordinal it was given, and it wrote that signed pointer where the chain metadata told it to.\n\nThe attacker did not break PAC. The attacker did not steal the IA key. The attacker handed dyld a manifest, and dyld signed everything on the manifest, because dyld's purpose is to sign everything on the manifest.\n\n## Page-in linking is the gate, and the gate is a number\n\nThere is a check. dyld does not perform full chained-fixup processing for every loadable image, because doing so eagerly would explode startup latency. For images with a large enough bind table, dyld defers the work into page-in linking, a path that processes fixups one page at a time when the page is faulted in by the kernel. For images below the threshold, dyld walks the chains immediately during image binding.\n\nThe threshold is a number. Pre-26.3, that number was 100,000. The PoC's `gen_malformed_dylib.py` produces a dylib with a configurable symbol count, and the Makefile's default is 99,000. The number is one below the threshold by design, because below the threshold is the path the PoC needs.\n\nThe path the PoC needs is the path where bounds checking on the write location was looser. The bounds check that constrains where `fixupPage64` is allowed to write was, in the pre-26.3 dyld, tight enough for well-formed inputs and loose enough for the malformed inputs this dylib produces. The chain's next-pointer offsets, the segment base, and the page stride combine to produce write locations that pass the existing check while landing in attacker-chosen slots inside `__DATA`.\n\nApple's fix, in the dyld shipped with iOS 26.3 and macOS Tahoe 26.3, tightens that bounds check. The fix also drops the page-in linking threshold from 100,000 to 64,000, which shrinks the population of images that hit the now-tightened immediate path. \"A memory corruption issue was addressed with improved state management\" is, in the code, this pair of edits.\n\n## The dispatch event loop calls the pointer dyld wrote\n\nWriting a signed pointer to a slot is not yet code execution. Something has to call through that slot. The PoC's launcher solves this with a chosen call-site that already exists on every iOS process: the libdispatch event loop.\n\nThe launcher allocates a region, runs the malformed dylib through dyld so the second bound symbol lands at offset `__DATA+0x20`, and then registers that offset as the handler for a `dispatch_source_t` timer. When the timer fires, libdispatch dereferences the handler through its vtable slot and authenticates the pointer with `BLRAA`. The pointer authenticates, because dyld signed it. The call proceeds to `_attacker_hook`, because that is what the bind ordinal resolved to.\n\nThe chosen call-site matters. The author's Italian-language comment in the launcher describes it as the natural call-site that would exist in a real exploitation scenario, where the compromised WebContent process has dispatch sources registered and will invoke the resolved pointers as event handlers in its normal operation. The PoC is staging that scenario in a launcher. The chain in a real attack does not need a launcher. It needs WebContent, which is already running event loops.\n\n## The patch tightens where dyld writes. dyld still has the key.\n\nRead Apple's 26.3 release notes for CVE-2026-20700 and the change is bounds checks and a lower page-in linking threshold. Read the PoC and the change closes the specific malformed-chain shapes the author found that pushed `fixupPage64` into out-of-bounds writes.\n\nWhat the change does not do is remove dyld's IA key. It cannot. dyld must sign because the GOT must be signed, and the GOT must be signed because that is what PAC is for. The signing oracle is the dynamic linker's reason for existing. The bug is a malformed-input crash on the oracle's input parser. The oracle remains.\n\nThe next bug on this surface is a different malformed-chain shape, or a different cached image format, or a different deferred path that elides a check the immediate path now performs. The threshold dropping from 100,000 to 64,000 is itself a tell: the patch shrinks the population that hits the tightened path, because shrinking the population is part of how the patch holds. A bug class that gets patched by reducing exposure to it is a bug class that the platform has not eliminated. It has narrowed.\n\nThis is what the chain shows. Two WebKit bugs land an attacker inside WebContent with read and write. PAC keeps them there, because the IA key is in the silicon and not in the process. The third bug, CVE-2026-20700, is the one that crosses the PAC barrier without breaking PAC, by handing the in-process signer a manifest of signatures to mint. The fix tightens the parser. The signer remains in the process. The key remains, by design, available to the signer.\n\nThe architectural property that produces this class of bug is that the component which signs pointers and the component being exploited share an address space. PAC was introduced to make signed pointers unforgeable from outside the signing key's owner. dyld is the signing key's owner. dyld is inside every process. The two facts cannot both move.\n\nThis is the shape catalogued elsewhere on this site as trust inversion: the issuer of the trust artifact is also the attack surface that produces it, because the issuer must live in the process for the artifact to mean anything at the call site. It is also the shape of an unpatchable primitive. Apple's fix tightens the parser dyld uses on chained-fixup metadata, but the primitive that fix addresses is \"the in-process signer will sign what it is told to sign,\" and that primitive is the dynamic linker's reason for existing. Future bugs on this surface will be different malformed-chain shapes, different image formats, different deferred paths. The signer stays.","closing_line":"PAC keeps the key out of every process. dyld is in every process.","hook_md":"Apple's description for CVE-2026-20700 fits in two sentences. \"A memory corruption issue was addressed with improved state management.\" \"An attacker with memory write capability may be able to execute arbitrary code.\" Neither sentence contains the word dyld. Neither contains PAC. The advisory's third paragraph notes that this CVE, alongside CVE-2025-14174 and CVE-2025-43529, was issued in response to a report of exploitation \"in an extremely sophisticated attack against specific targeted individuals on versions of iOS before iOS 26.\" Apple's reserved phrase for mercenary-spyware targeting. Three CVEs, one chain. The first two are in WebKit. The third is in dyld, the in-process component that on arm64e holds the Pointer Authentication key and signs every function pointer it writes.","post_id":453,"slug":"dyld-cve-2026-20700-holds-the-pac-key","title":"CVE-2026-20700: PAC Keeps the Key Out of Every Process. dyld Is In Every Process.","type":"initial","unreadable_sentence":"PAC keeps the key out of every process. dyld is in every process."} -----BEGIN PGP SIGNATURE----- iHUEARYIAB0WIQRf0htP5+SjynlxywneZjl4jgkQJgUCanOiswAKCRDeZjl4jgkQ JsyUAP4pDZ/dmJS7OBKHowZ4SUNkhcZsQR3xKEtXggR4BUQhjwD+KLoAkUpkPXvN +aHHT8+K/YyfXWz5ZoEi0JegGI6Vogs= =2bi8 -----END PGP SIGNATURE-----