Microarchitectural Attacks and Defenses in JavaScript

Transcription

1 Microarchitectural Attacks and Defenses in JavaScript Michael Schwarz, Daniel Gruss, Moritz Lipp Michael Schwarz, Daniel Gruss, Moritz Lipp

2 Microarchitecture Microarchitecture... is not defined on the architectural state 2 Michael Schwarz, Daniel Gruss, Moritz Lipp

3 Microarchitecture Microarchitecture... is not defined on the architectural state should not be visible to software 2 Michael Schwarz, Daniel Gruss, Moritz Lipp

4 Microarchitecture Microarchitecture... is not defined on the architectural state should not be visible to software is hardware specific and not fully documented 2 Michael Schwarz, Daniel Gruss, Moritz Lipp

5 Microarchitecture Microarchitecture... is not defined on the architectural state should not be visible to software is hardware specific and not fully documented changes to some extend with new processor generations 2 Michael Schwarz, Daniel Gruss, Moritz Lipp

6 Microarchitectural Attacks Microarchitectural states can be used for attacks Cache state data access 3 Michael Schwarz, Daniel Gruss, Moritz Lipp

7 Microarchitectural Attacks Microarchitectural states can be used for attacks Cache state data access DRAM buffers data access 3 Michael Schwarz, Daniel Gruss, Moritz Lipp

8 Microarchitectural Attacks Microarchitectural states can be used for attacks Cache state data access DRAM buffers data access Interrupts keystrokes 3 Michael Schwarz, Daniel Gruss, Moritz Lipp

9 Microarchitectural Attacks Microarchitectural states can be used for attacks Cache state data access DRAM buffers data access Interrupts keystrokes Branch predictors program flow 3 Michael Schwarz, Daniel Gruss, Moritz Lipp

10 Microarchitectural Attacks Microarchitectural states can be used for attacks Cache state data access DRAM buffers data access Interrupts keystrokes Branch predictors program flow Timings data values 3 Michael Schwarz, Daniel Gruss, Moritz Lipp

11 Side-Channel Attacks Side-channel attacks exploit side effects of operations Microarchitectural attacks are usually side-channel attacks 4 Michael Schwarz, Daniel Gruss, Moritz Lipp

12 Side-Channel Attacks Side-channel attacks exploit side effects of operations Microarchitectural attacks are usually side-channel attacks Sensors user activity 4 Michael Schwarz, Daniel Gruss, Moritz Lipp

13 Side-Channel Attacks Side-channel attacks exploit side effects of operations Microarchitectural attacks are usually side-channel attacks Sensors user activity Timings data values, activity 4 Michael Schwarz, Daniel Gruss, Moritz Lipp

14 One Important Component A core component of many such attacks: Timers 5 Michael Schwarz, Daniel Gruss, Moritz Lipp

15 One Important Component A core component of many such attacks: Timers Side-channel attacks often require high-resolution timers 5 Michael Schwarz, Daniel Gruss, Moritz Lipp

16 One Important Component A core component of many such attacks: Timers Side-channel attacks often require high-resolution timers Differences to measure are often in the range of nanoseconds or microseconds 5 Michael Schwarz, Daniel Gruss, Moritz Lipp

17 One Important Component A core component of many such attacks: Timers Side-channel attacks often require high-resolution timers Differences to measure are often in the range of nanoseconds or microseconds Microarchitectural attacks usually require highest precision 5 Michael Schwarz, Daniel Gruss, Moritz Lipp

18 Attacks in JavaScript

19 First Side-Channel Attack First side-channel attack in JavaScript Stone et al. (2013): Pixel perfect timing attacks with HTML5 6 Michael Schwarz, Daniel Gruss, Moritz Lipp

20 First Side-Channel Attack First side-channel attack in JavaScript Stone et al. (2013): Pixel perfect timing attacks with HTML5 Timing of various redraw events (e.g., visited state of links) 6 Michael Schwarz, Daniel Gruss, Moritz Lipp

21 First Side-Channel Attack First side-channel attack in JavaScript Stone et al. (2013): Pixel perfect timing attacks with HTML5 Timing of various redraw events (e.g., visited state of links) SVG filter timing to extract individual pixels (already 2011) 6 Michael Schwarz, Daniel Gruss, Moritz Lipp

22 First Side-Channel Attack First side-channel attack in JavaScript Stone et al. (2013): Pixel perfect timing attacks with HTML5 Timing of various redraw events (e.g., visited state of links) SVG filter timing to extract individual pixels (already 2011) High-resolution timer was available in browser 6 Michael Schwarz, Daniel Gruss, Moritz Lipp

23 First Microarchitectural Attack First microarchitectural attack in JavaScript Oren et al. (2015): The Spy in the Sandbox 7 Michael Schwarz, Daniel Gruss, Moritz Lipp

24 First Microarchitectural Attack First microarchitectural attack in JavaScript Oren et al. (2015): The Spy in the Sandbox Timing of memory accesses 7 Michael Schwarz, Daniel Gruss, Moritz Lipp

25 First Microarchitectural Attack First microarchitectural attack in JavaScript Oren et al. (2015): The Spy in the Sandbox Timing of memory accesses Allows to determine whether data is cached or uncached 7 Michael Schwarz, Daniel Gruss, Moritz Lipp

26 First Microarchitectural Attack First microarchitectural attack in JavaScript Oren et al. (2015): The Spy in the Sandbox Timing of memory accesses Allows to determine whether data is cached or uncached Possibility to infer info about other programs from browser 7 Michael Schwarz, Daniel Gruss, Moritz Lipp

27 8 Michael Schwarz, Daniel Gruss, Moritz Lipp

28 Timers in JavaScript We need a high-resolution timer to measure such small differences 9 Michael Schwarz, Daniel Gruss, Moritz Lipp

29 Timers in JavaScript We need a high-resolution timer to measure such small differences Native: rdtsc - timestamp in CPU cycles 9 Michael Schwarz, Daniel Gruss, Moritz Lipp

30 Timers in JavaScript We need a high-resolution timer to measure such small differences Native: rdtsc - timestamp in CPU cycles JavaScript: performance.now() has the highest resolution 9 Michael Schwarz, Daniel Gruss, Moritz Lipp

31 Timers in JavaScript We need a high-resolution timer to measure such small differences Native: rdtsc - timestamp in CPU cycles JavaScript: performance.now() has the highest resolution performance.now() [...] represent times as floating-point numbers with up to microsecond precision. Mozilla Developer Network 9 Michael Schwarz, Daniel Gruss, Moritz Lipp

32 ...up to microsecond precision? Firefox Michael Schwarz, Daniel Gruss, Moritz Lipp

33 ...up to microsecond precision? Edge 38 Firefox Michael Schwarz, Daniel Gruss, Moritz Lipp

34 ...up to microsecond precision? W3C standard 1 Edge 38 Firefox Michael Schwarz, Daniel Gruss, Moritz Lipp

35 ...up to microsecond precision? 0 0 Firefox 37/Chrome/Safari 5 W3C standard 5 1 Edge 38 Firefox Michael Schwarz, Daniel Gruss, Moritz Lipp

36 ...up to microsecond precision? 0 Tor 0 Firefox 37/Chrome/Safari 5 W3C standard 5 Edge 38 1 Firefox Michael Schwarz, Daniel Gruss, Moritz Lipp

37 ...up to microsecond precision? Fuzzyfox Tor Firefox 37/Chrome/Safari 5 W3C standard 5 Edge 38 1 Firefox Michael Schwarz, Daniel Gruss, Moritz Lipp

38 New timer

39 We require a higher resolution Current precision is not sufficient to measure cycle differences 11 Michael Schwarz, Daniel Gruss, Moritz Lipp

40 We require a higher resolution Current precision is not sufficient to measure cycle differences We have two possibilities 11 Michael Schwarz, Daniel Gruss, Moritz Lipp

41 We require a higher resolution Current precision is not sufficient to measure cycle differences We have two possibilities Recover a higher resolution from the available timer 11 Michael Schwarz, Daniel Gruss, Moritz Lipp

42 We require a higher resolution Current precision is not sufficient to measure cycle differences We have two possibilities Recover a higher resolution from the available timer Build our own high-resolution timer 11 Michael Schwarz, Daniel Gruss, Moritz Lipp

43 Recovering resolution - Clock interpolation Measure how often we can increment a variable between two timer ticks 12 Michael Schwarz, Daniel Gruss, Moritz Lipp

44 Recovering resolution - Clock interpolation Measure how often we can increment a variable between two timer ticks Average number of increments is the interpolation step 12 Michael Schwarz, Daniel Gruss, Moritz Lipp

45 Recovering resolution - Clock interpolation Measure how often we can increment a variable between two timer ticks Average number of increments is the interpolation step To measure with high resolution: 12 Michael Schwarz, Daniel Gruss, Moritz Lipp

46 Recovering resolution - Clock interpolation Measure how often we can increment a variable between two timer ticks Average number of increments is the interpolation step To measure with high resolution: Start measurement at clock edge 12 Michael Schwarz, Daniel Gruss, Moritz Lipp

47 Recovering resolution - Clock interpolation Measure how often we can increment a variable between two timer ticks Average number of increments is the interpolation step To measure with high resolution: Start measurement at clock edge Increment a variable until next clock edge 12 Michael Schwarz, Daniel Gruss, Moritz Lipp

48 Recovering resolution - Clock interpolation Measure how often we can increment a variable between two timer ticks Average number of increments is the interpolation step To measure with high resolution: Start measurement at clock edge Increment a variable until next clock edge Highly accurate: 500 ns (Firefox/Chrome), 15 µs (Tor) 12 Michael Schwarz, Daniel Gruss, Moritz Lipp

49 Recovering resolution - Edge thresholding We can get a higher resolution for a classifier only 13 Michael Schwarz, Daniel Gruss, Moritz Lipp

50 Recovering resolution - Edge thresholding We can get a higher resolution for a classifier only Often sufficient to see which of two functions takes longer 13 Michael Schwarz, Daniel Gruss, Moritz Lipp

51 Recovering resolution - Edge thresholding We can get a higher resolution for a classifier only Often sufficient to see which of two functions takes longer f slow f fast 13 Michael Schwarz, Daniel Gruss, Moritz Lipp

52 Recovering resolution - Edge thresholding We can get a higher resolution for a classifier only Often sufficient to see which of two functions takes longer f slow f fast Padding Padding Edge thresholding: apply padding such that the slow function crosses one more clock edge than the fast function. 13 Michael Schwarz, Daniel Gruss, Moritz Lipp

53 Recovering resolution - Edge thresholding percentage unaligned aligned padded both correct f slow misclassified f fast misclassified 14 Michael Schwarz, Daniel Gruss, Moritz Lipp

54 Recovering resolution - Edge thresholding percentage unaligned aligned padded both correct f slow misclassified f fast misclassified Yields nanosecond resolution 14 Michael Schwarz, Daniel Gruss, Moritz Lipp

55 Recovering resolution - Edge thresholding percentage unaligned aligned padded both correct f slow misclassified f fast misclassified Yields nanosecond resolution Firefox/Tor (2 ns), Edge (10 ns), Chrome (15 ns) 14 Michael Schwarz, Daniel Gruss, Moritz Lipp

56 Building a timer Goal: counter that does not block main thread 15 Michael Schwarz, Daniel Gruss, Moritz Lipp

57 Building a timer Goal: counter that does not block main thread Baseline settimeout: 4 ms (except Edge: 2 ms) 15 Michael Schwarz, Daniel Gruss, Moritz Lipp

58 Building a timer Goal: counter that does not block main thread Baseline settimeout: 4 ms (except Edge: 2 ms) CSS animation: increase width of element as fast as possible 15 Michael Schwarz, Daniel Gruss, Moritz Lipp

59 Building a timer Goal: counter that does not block main thread Baseline settimeout: 4 ms (except Edge: 2 ms) CSS animation: increase width of element as fast as possible Width of element is timestamp 15 Michael Schwarz, Daniel Gruss, Moritz Lipp

60 Building a timer Goal: counter that does not block main thread Baseline settimeout: 4 ms (except Edge: 2 ms) CSS animation: increase width of element as fast as possible Width of element is timestamp However, animation is limited to 60 fps 16 ms 15 Michael Schwarz, Daniel Gruss, Moritz Lipp

61 Building a timer - Web worker JavaScript can spawn new threads called web worker 16 Michael Schwarz, Daniel Gruss, Moritz Lipp

62 Building a timer - Web worker JavaScript can spawn new threads called web worker Web worker communicate using message passing 16 Michael Schwarz, Daniel Gruss, Moritz Lipp

63 Building a timer - Web worker JavaScript can spawn new threads called web worker Web worker communicate using message passing Let worker count and request timestamp in main thread 16 Michael Schwarz, Daniel Gruss, Moritz Lipp

64 Building a timer - Web worker JavaScript can spawn new threads called web worker Web worker communicate using message passing Let worker count and request timestamp in main thread Multiple possibilities: postmessage, MessageChannel or BroadcastChannel 16 Michael Schwarz, Daniel Gruss, Moritz Lipp

65 Building a timer - Web worker JavaScript can spawn new threads called web worker Web worker communicate using message passing Let worker count and request timestamp in main thread Multiple possibilities: postmessage, MessageChannel or BroadcastChannel Yields microsecond resolution (even on Tor and Fuzzyfox) 16 Michael Schwarz, Daniel Gruss, Moritz Lipp

66 Building a timer - Web worker Experimental feature to share data: SharedArrayBuffer 17 Michael Schwarz, Daniel Gruss, Moritz Lipp

67 Building a timer - Web worker Experimental feature to share data: SharedArrayBuffer Web worker can simultaneously read/write data 17 Michael Schwarz, Daniel Gruss, Moritz Lipp

68 Building a timer - Web worker Experimental feature to share data: SharedArrayBuffer Web worker can simultaneously read/write data No message passing overhead 17 Michael Schwarz, Daniel Gruss, Moritz Lipp

69 Building a timer - Web worker Experimental feature to share data: SharedArrayBuffer Web worker can simultaneously read/write data No message passing overhead One dedicated worker for incrementing the shared variable 17 Michael Schwarz, Daniel Gruss, Moritz Lipp

70 Building a timer - Web worker Experimental feature to share data: SharedArrayBuffer Web worker can simultaneously read/write data No message passing overhead One dedicated worker for incrementing the shared variable Firefox/Fuzzyfox: 2 ns, Chrome: 15 ns 17 Michael Schwarz, Daniel Gruss, Moritz Lipp

71 Building a timer - Web worker Experimental feature to share data: SharedArrayBuffer Web worker can simultaneously read/write data No message passing overhead One dedicated worker for incrementing the shared variable Firefox/Fuzzyfox: 2 ns, Chrome: 15 ns Sufficient for microarchitectural attacks 17 Michael Schwarz, Daniel Gruss, Moritz Lipp

72 Timer evaluation Number of cases cache hit cache miss Access time [SharedArrayBuffer increments] 18 Michael Schwarz, Daniel Gruss, Moritz Lipp

73 Attack Requirements

74 Attack requirements Timers were always the main focus 19 Michael Schwarz, Daniel Gruss, Moritz Lipp

75 Attack requirements Timers were always the main focus Reducing timer resolution is not sufficient 19 Michael Schwarz, Daniel Gruss, Moritz Lipp

76 Attack requirements Timers were always the main focus Reducing timer resolution is not sufficient Timers can (always) be built 19 Michael Schwarz, Daniel Gruss, Moritz Lipp

77 Attack requirements Timers were always the main focus Reducing timer resolution is not sufficient Timers can (always) be built Some attacks do not require timers at all 19 Michael Schwarz, Daniel Gruss, Moritz Lipp

78 Attack requirements Timers were always the main focus Reducing timer resolution is not sufficient Timers can (always) be built Some attacks do not require timers at all Important to understand requirements before designing countermeasures 19 Michael Schwarz, Daniel Gruss, Moritz Lipp

79

80 Identify requirements Currently 11 microarchitectural and side-channel attacks in JavaScript 20 Michael Schwarz, Daniel Gruss, Moritz Lipp

81 Identify requirements Currently 11 microarchitectural and side-channel attacks in JavaScript Analyse requirements for every attack 20 Michael Schwarz, Daniel Gruss, Moritz Lipp

82 Identify requirements Currently 11 microarchitectural and side-channel attacks in JavaScript Analyse requirements for every attack Results in 5 categories 20 Michael Schwarz, Daniel Gruss, Moritz Lipp

83 Identify requirements Currently 11 microarchitectural and side-channel attacks in JavaScript Analyse requirements for every attack Results in 5 categories Memory addresses Accurate timing Multithreading Shared data Sensor API 20 Michael Schwarz, Daniel Gruss, Moritz Lipp

84 Identify requirements Currently 11 microarchitectural and side-channel attacks in JavaScript Analyse requirements for every attack Results in 5 categories Memory addresses Accurate timing Multithreading Shared data Sensor API Every attack is in at least one category 20 Michael Schwarz, Daniel Gruss, Moritz Lipp

85 Attacks and Categories Memory addresses Accurate timing Multithreading Shared data Sensor API Rowhammer.js Practical Memory Deduplication Attacks in Sandboxed Javascript Fantastic Timers and Where to Find Them ASLR on the Line The spy in the sandbox Loophole Pixel perfect timing attacks with HTML5 The clock is still ticking Practical Keystroke Timing Attacks in Sandboxed JavaScript TouchSignatures Stealing sensitive browser data with the W3C Ambient Light Sensor API If accurate timing is not available, it can be approximated using a combination of multithreading and shared data. 21 Michael Schwarz, Daniel Gruss, Moritz Lipp

86 Memory Addresses Language does not provide addresses to programmer 22 Michael Schwarz, Daniel Gruss, Moritz Lipp

87 Memory Addresses Language does not provide addresses to programmer Closest to virtual address: array indices 22 Michael Schwarz, Daniel Gruss, Moritz Lipp

88 Memory Addresses Language does not provide addresses to programmer Closest to virtual address: array indices ArrayBuffer is page aligned, leaks 12 bits of address 22 Michael Schwarz, Daniel Gruss, Moritz Lipp

89 Memory Addresses Language does not provide addresses to programmer Closest to virtual address: array indices ArrayBuffer is page aligned, leaks 12 bits of address If 2 MB backing pages are used, 21 bits of address known 22 Michael Schwarz, Daniel Gruss, Moritz Lipp

90 Memory Addresses Language does not provide addresses to programmer Closest to virtual address: array indices ArrayBuffer is page aligned, leaks 12 bits of address If 2 MB backing pages are used, 21 bits of address known If not page aligned: detect page faults through timing 22 Michael Schwarz, Daniel Gruss, Moritz Lipp

91 Accurate Timing Nearly all attacks require accurate timing 23 Michael Schwarz, Daniel Gruss, Moritz Lipp

92 Accurate Timing Nearly all attacks require accurate timing No absolute timestamps required, only time differences 23 Michael Schwarz, Daniel Gruss, Moritz Lipp

93 Accurate Timing Nearly all attacks require accurate timing No absolute timestamps required, only time differences Required accuracy varies between milliseconds and nanoseconds 23 Michael Schwarz, Daniel Gruss, Moritz Lipp

94 Accurate Timing Nearly all attacks require accurate timing No absolute timestamps required, only time differences Required accuracy varies between milliseconds and nanoseconds Such timers can be built if not available (e.g., message passing) 23 Michael Schwarz, Daniel Gruss, Moritz Lipp

95 Accurate Timing Nearly all attacks require accurate timing No absolute timestamps required, only time differences Required accuracy varies between milliseconds and nanoseconds Such timers can be built if not available (e.g., message passing) If attack is repeatable, less accurate timing can be sufficient 23 Michael Schwarz, Daniel Gruss, Moritz Lipp

96 Multithreading JavaScript introduced multi threading with web workers 24 Michael Schwarz, Daniel Gruss, Moritz Lipp

97 Multithreading JavaScript introduced multi threading with web workers Enables new side-channel attacks 24 Michael Schwarz, Daniel Gruss, Moritz Lipp

98 Multithreading JavaScript introduced multi threading with web workers Enables new side-channel attacks Dispatch latency of event queue allows to infer activity of other tabs 24 Michael Schwarz, Daniel Gruss, Moritz Lipp

99 Multithreading JavaScript introduced multi threading with web workers Enables new side-channel attacks Dispatch latency of event queue allows to infer activity of other tabs Endless loop in worker allows to detect hardware interrupts 24 Michael Schwarz, Daniel Gruss, Moritz Lipp

100 Shared Data Usually no shared data between threads due to synchronization issues 25 Michael Schwarz, Daniel Gruss, Moritz Lipp

101 Shared Data Usually no shared data between threads due to synchronization issues Exception: SharedArrayBuffer 25 Michael Schwarz, Daniel Gruss, Moritz Lipp

102 Shared Data Usually no shared data between threads due to synchronization issues Exception: SharedArrayBuffer Only useful in combination with web workers 25 Michael Schwarz, Daniel Gruss, Moritz Lipp

103 Shared Data Usually no shared data between threads due to synchronization issues Exception: SharedArrayBuffer Only useful in combination with web workers Allows to build timers with extremely high resolution (up to 1 ns) 25 Michael Schwarz, Daniel Gruss, Moritz Lipp

104 Shared Data Usually no shared data between threads due to synchronization issues Exception: SharedArrayBuffer Only useful in combination with web workers Allows to build timers with extremely high resolution (up to 1 ns) Not enabled by default 25 Michael Schwarz, Daniel Gruss, Moritz Lipp

105 Sensor API Some side-channel attacks only require access to sensors 26 Michael Schwarz, Daniel Gruss, Moritz Lipp

106 Sensor API Some side-channel attacks only require access to sensors Several sensors are available in JavaScript 26 Michael Schwarz, Daniel Gruss, Moritz Lipp

107 Sensor API Some side-channel attacks only require access to sensors Several sensors are available in JavaScript Some require user consent, e.g., microphone 26 Michael Schwarz, Daniel Gruss, Moritz Lipp

108 Sensor API Some side-channel attacks only require access to sensors Several sensors are available in JavaScript Some require user consent, e.g., microphone Other can be used without user consent, e.g., ambient light 26 Michael Schwarz, Daniel Gruss, Moritz Lipp

109 Sensor API Some side-channel attacks only require access to sensors Several sensors are available in JavaScript Some require user consent, e.g., microphone Other can be used without user consent, e.g., ambient light There are attacks with these sensors 26 Michael Schwarz, Daniel Gruss, Moritz Lipp

110 Defenses

111 Countermeasures Countermeasures have to address all categories 27 Michael Schwarz, Daniel Gruss, Moritz Lipp

112 Countermeasures Countermeasures have to address all categories Should not be visible to the programmer 27 Michael Schwarz, Daniel Gruss, Moritz Lipp

113 Countermeasures Countermeasures have to address all categories Should not be visible to the programmer Implementation is on the microarchitectural level of JavaScript 27 Michael Schwarz, Daniel Gruss, Moritz Lipp

114 Countermeasures Countermeasures have to address all categories Should not be visible to the programmer Implementation is on the microarchitectural level of JavaScript If no category is usable for attacks anymore, future attacks are hard 27 Michael Schwarz, Daniel Gruss, Moritz Lipp

115 Memory Addresses #1: Buffer ASLR 28 Michael Schwarz, Daniel Gruss, Moritz Lipp

116 Memory Addresses #1: Buffer ASLR Ensure arrays are not page aligned 28 Michael Schwarz, Daniel Gruss, Moritz Lipp

117 Memory Addresses #1: Buffer ASLR Ensure arrays are not page aligned Attacker cannot assume that least significant 12 bits are 0 28 Michael Schwarz, Daniel Gruss, Moritz Lipp

118 Memory Addresses #1: Buffer ASLR Ensure arrays are not page aligned Attacker cannot assume that least significant 12 bits are 0 Only works for the first page 28 Michael Schwarz, Daniel Gruss, Moritz Lipp

119 Memory Addresses #1: Buffer ASLR Ensure arrays are not page aligned Attacker cannot assume that least significant 12 bits are 0 Only works for the first page Consecutive page borders can be detected through page faults 28 Michael Schwarz, Daniel Gruss, Moritz Lipp

120 Memory Addresses #2: Preloading Instead of lazy initialization for arrays, ensure that they are always memory backed 29 Michael Schwarz, Daniel Gruss, Moritz Lipp

121 Memory Addresses #2: Preloading Instead of lazy initialization for arrays, ensure that they are always memory backed Attacker cannot detect page borders through page faults anymore 29 Michael Schwarz, Daniel Gruss, Moritz Lipp

122 Memory Addresses #2: Preloading Instead of lazy initialization for arrays, ensure that they are always memory backed Attacker cannot detect page borders through page faults anymore Does not work if swapping or page deduplication is enabled 29 Michael Schwarz, Daniel Gruss, Moritz Lipp

123 Memory Addresses #2: Preloading Instead of lazy initialization for arrays, ensure that they are always memory backed Attacker cannot detect page borders through page faults anymore Does not work if swapping or page deduplication is enabled Has to be combined with Buffer ASLR 29 Michael Schwarz, Daniel Gruss, Moritz Lipp

124 Memory Addresses #3: Non-determinism For every array access, add another random access 30 Michael Schwarz, Daniel Gruss, Moritz Lipp

125 Memory Addresses #3: Non-determinism For every array access, add another random access Makes page border detection infeasible without requiring significantly more memory 30 Michael Schwarz, Daniel Gruss, Moritz Lipp

126 Memory Addresses #3: Non-determinism For every array access, add another random access Makes page border detection infeasible without requiring significantly more memory Attacker always times two accesses 30 Michael Schwarz, Daniel Gruss, Moritz Lipp

127 Memory Addresses #3: Non-determinism For every array access, add another random access Makes page border detection infeasible without requiring significantly more memory Attacker always times two accesses Distinguishing cached from non-cached addresses is hard 30 Michael Schwarz, Daniel Gruss, Moritz Lipp

128 Memory Addresses #4: Array Index Randomization Ensures arrays are not linear 31 Michael Schwarz, Daniel Gruss, Moritz Lipp

129 Memory Addresses #4: Array Index Randomization Ensures arrays are not linear Use a random linear function to map array index to underlying buffer 31 Michael Schwarz, Daniel Gruss, Moritz Lipp

130 Memory Addresses #4: Array Index Randomization Ensures arrays are not linear Use a random linear function to map array index to underlying buffer Index x maps to f (x) = ax + b mod n, where n is array length and a and b are randomly chosen 31 Michael Schwarz, Daniel Gruss, Moritz Lipp

131 Memory Addresses #4: Array Index Randomization Ensures arrays are not linear Use a random linear function to map array index to underlying buffer Index x maps to f (x) = ax + b mod n, where n is array length and a and b are randomly chosen Has to be combined with Buffer ASLR and either Preloading or Non-determinism 31 Michael Schwarz, Daniel Gruss, Moritz Lipp

132 Memory Addresses The four defenses prevent attackers from getting virtual and physical addresses 32 Michael Schwarz, Daniel Gruss, Moritz Lipp

133 Memory Addresses The four defenses prevent attackers from getting virtual and physical addresses Prevents many microarchitectural attacks 32 Michael Schwarz, Daniel Gruss, Moritz Lipp

134 Memory Addresses The four defenses prevent attackers from getting virtual and physical addresses Prevents many microarchitectural attacks Have to be combined for maximum security 32 Michael Schwarz, Daniel Gruss, Moritz Lipp

135 Memory Addresses The four defenses prevent attackers from getting virtual and physical addresses Prevents many microarchitectural attacks Have to be combined for maximum security Side effect: make exploits harder where addresses are required 32 Michael Schwarz, Daniel Gruss, Moritz Lipp

136 Accurate Timing Reducing the resolution of performance.now() is a first step 33 Michael Schwarz, Daniel Gruss, Moritz Lipp

137 Accurate Timing Reducing the resolution of performance.now() is a first step Only rounding the timestamps is not sufficient 33 Michael Schwarz, Daniel Gruss, Moritz Lipp

138 Accurate Timing Reducing the resolution of performance.now() is a first step Only rounding the timestamps is not sufficient Fuzzy time (Vattikonda et al.) adds random jitter 33 Michael Schwarz, Daniel Gruss, Moritz Lipp

139 Accurate Timing Reducing the resolution of performance.now() is a first step Only rounding the timestamps is not sufficient Fuzzy time (Vattikonda et al.) adds random jitter Timestamps are still monotonic, but clock edges are randomized 33 Michael Schwarz, Daniel Gruss, Moritz Lipp

140 Multithreading Only real solution is to prevent multithreading 34 Michael Schwarz, Daniel Gruss, Moritz Lipp

141 Multithreading Only real solution is to prevent multithreading We used a polyfill to not completely break websites 34 Michael Schwarz, Daniel Gruss, Moritz Lipp

142 Multithreading Only real solution is to prevent multithreading We used a polyfill to not completely break websites Some attacks can be prevented by adding random delays to postmessage 34 Michael Schwarz, Daniel Gruss, Moritz Lipp

143 Multithreading Only real solution is to prevent multithreading We used a polyfill to not completely break websites Some attacks can be prevented by adding random delays to postmessage Prevents certain timing primitives and attacks on the event-queue latency 34 Michael Schwarz, Daniel Gruss, Moritz Lipp

144 Shared Data Best countermeasures: do not allow shared data 35 Michael Schwarz, Daniel Gruss, Moritz Lipp

145 Shared Data Best countermeasures: do not allow shared data Many attacks are impossible without SharedArrayBuffer 35 Michael Schwarz, Daniel Gruss, Moritz Lipp

146 Shared Data Best countermeasures: do not allow shared data Many attacks are impossible without SharedArrayBuffer Alternative: delay access to buffer 35 Michael Schwarz, Daniel Gruss, Moritz Lipp

147 Shared Data Best countermeasures: do not allow shared data Many attacks are impossible without SharedArrayBuffer Alternative: delay access to buffer Still faster than message passing 35 Michael Schwarz, Daniel Gruss, Moritz Lipp

148 Shared Data Best countermeasures: do not allow shared data Many attacks are impossible without SharedArrayBuffer Alternative: delay access to buffer Still faster than message passing Degrades resolution of timing primitive to microseconds 35 Michael Schwarz, Daniel Gruss, Moritz Lipp

149 Sensor API Reduce resolution and update frequency of sensors 36 Michael Schwarz, Daniel Gruss, Moritz Lipp

150 Sensor API Reduce resolution and update frequency of sensors Sensor APIs should always ask user for permission 36 Michael Schwarz, Daniel Gruss, Moritz Lipp

151 Sensor API Reduce resolution and update frequency of sensors Sensor APIs should always ask user for permission Every sensor is usable for attacks, even ambient light sensor 36 Michael Schwarz, Daniel Gruss, Moritz Lipp

152 Sensor API Reduce resolution and update frequency of sensors Sensor APIs should always ask user for permission Every sensor is usable for attacks, even ambient light sensor To not break existing applications, sensors return constant value 36 Michael Schwarz, Daniel Gruss, Moritz Lipp

153 Implementation

154 Designing the Countermeasure Best solution is to implement defenses in the browser core 37 Michael Schwarz, Daniel Gruss, Moritz Lipp

155 Designing the Countermeasure Best solution is to implement defenses in the browser core Maintaining a browser fork is hard work 37 Michael Schwarz, Daniel Gruss, Moritz Lipp

156 Designing the Countermeasure Best solution is to implement defenses in the browser core Maintaining a browser fork is hard work We want a generic solution for multiple browsers 37 Michael Schwarz, Daniel Gruss, Moritz Lipp

157 Designing the Countermeasure Best solution is to implement defenses in the browser core Maintaining a browser fork is hard work We want a generic solution for multiple browsers Parsing JavaScript is hard 37 Michael Schwarz, Daniel Gruss, Moritz Lipp

158 Designing the Countermeasure Best solution is to implement defenses in the browser core Maintaining a browser fork is hard work We want a generic solution for multiple browsers Parsing JavaScript is hard Implementation in JavaScript Virtual machine layering 37 Michael Schwarz, Daniel Gruss, Moritz Lipp

159 Designing the Countermeasure Best solution is to implement defenses in the browser core Maintaining a browser fork is hard work We want a generic solution for multiple browsers Parsing JavaScript is hard Implementation in JavaScript Virtual machine layering Proof-of-concept is implemented as browser extension 37 Michael Schwarz, Daniel Gruss, Moritz Lipp

160 User Experience Some defenses might impair user experience, e.g., disable multithreading 38 Michael Schwarz, Daniel Gruss, Moritz Lipp

161 User Experience Some defenses might impair user experience, e.g., disable multithreading The user can choose one of several pre-defined protection levels 38 Michael Schwarz, Daniel Gruss, Moritz Lipp

162 User Experience Some defenses might impair user experience, e.g., disable multithreading The user can choose one of several pre-defined protection levels Protection levels apply different combinations of defenses 38 Michael Schwarz, Daniel Gruss, Moritz Lipp

163 User Experience Some defenses might impair user experience, e.g., disable multithreading The user can choose one of several pre-defined protection levels Protection levels apply different combinations of defenses Each defense can either be disabled, enabled, or require user permission 38 Michael Schwarz, Daniel Gruss, Moritz Lipp

164 Virtual Machine Layering Functions and properties are replaced by wrappers Page Context Script Extension Context Return Call Wrapper Call Filtered value Default value Allowed? Yes Original Function No 39 Michael Schwarz, Daniel Gruss, Moritz Lipp

165 Virtual Machine Layering Functions can be re-defined in JavaScript var o r i g i n a l r e f e r e n c e = window. performance. now ; window. performance. now = function ( ) { return 0 ; } ; 40 Michael Schwarz, Daniel Gruss, Moritz Lipp

166 Virtual Machine Layering Functions can be re-defined in JavaScript var o r i g i n a l r e f e r e n c e = window. performance. now ; window. performance. now = function ( ) { return 0 ; } ; // call the new function (via function name) a l e r t ( window. performance. now ( ) ) ; // == alert(0) 40 Michael Schwarz, Daniel Gruss, Moritz Lipp

167 Virtual Machine Layering Functions can be re-defined in JavaScript var o r i g i n a l r e f e r e n c e = window. performance. now ; window. performance. now = function ( ) { return 0 ; } ; // call the new function (via function name) a l e r t ( window. performance. now ( ) ) ; // == alert(0) // call the original function (only via reference) a l e r t ( o r i g i n a l r e f e r e n c e. c a l l ( window. performance ) ) ; 40 Michael Schwarz, Daniel Gruss, Moritz Lipp

168 Virtual Machine Layering Functions can be re-defined in JavaScript var o r i g i n a l r e f e r e n c e = window. performance. now ; window. performance. now = function ( ) { return 0 ; } ; // call the new function (via function name) a l e r t ( window. performance. now ( ) ) ; // == alert(0) // call the original function (only via reference) a l e r t ( o r i g i n a l r e f e r e n c e. c a l l ( window. performance ) ) ; Properties can be replaced by accessor properties 40 Michael Schwarz, Daniel Gruss, Moritz Lipp

169 Virtual Machine Layering for Objects Objects are proxied new Object Methods Script Proxy(Object) Filter Methods Object 41 Michael Schwarz, Daniel Gruss, Moritz Lipp

170 Virtual Machine Layering for Objects Objects are proxied new Object Methods Script Proxy(Object) Filter Methods Object All properties and functions are handled by the original object 41 Michael Schwarz, Daniel Gruss, Moritz Lipp

171 Virtual Machine Layering for Objects Objects are proxied new Object Methods Script Proxy(Object) Filter Methods Object All properties and functions are handled by the original object Functions and properties can be overwritten in the proxy object 41 Michael Schwarz, Daniel Gruss, Moritz Lipp

172 Self Protection Attacker tries to circumvent JavaScript Zero 42 Michael Schwarz, Daniel Gruss, Moritz Lipp

173 Self Protection Attacker tries to circumvent JavaScript Zero Self protection is necessary if implemented in JavaScript 42 Michael Schwarz, Daniel Gruss, Moritz Lipp

174 Self Protection Attacker tries to circumvent JavaScript Zero Self protection is necessary if implemented in JavaScript Use closures to hide all references to original functions ( function ( ) { // original is only accessible in this scope var o r i g i n a l = window. performance. now ; window. performance. now =... } ) ( ) ; 42 Michael Schwarz, Daniel Gruss, Moritz Lipp

175 Self Protection Attacker tries to circumvent JavaScript Zero Self protection is necessary if implemented in JavaScript Use closures to hide all references to original functions ( function ( ) { // original is only accessible in this scope var o r i g i n a l = window. performance. now ; window. performance. now =... } ) ( ) ; Prevent objects from being modified: Object.freeze 42 Michael Schwarz, Daniel Gruss, Moritz Lipp

176 Evaluation

177 Page Border Detection Border of pages leak 12 or 21 bits (depending on page size) 43 Michael Schwarz, Daniel Gruss, Moritz Lipp

178 Page Border Detection Border of pages leak 12 or 21 bits (depending on page size) Create huge array 43 Michael Schwarz, Daniel Gruss, Moritz Lipp

179 Page Border Detection Border of pages leak 12 or 21 bits (depending on page size) Create huge array Iterate over array, measure access time 43 Michael Schwarz, Daniel Gruss, Moritz Lipp

180 Page Border Detection Border of pages leak 12 or 21 bits (depending on page size) Create huge array Iterate over array, measure access time Page border raise pagefault, taking significantly longer to access 43 Michael Schwarz, Daniel Gruss, Moritz Lipp

181 Page Border Detection Access time [cycles] Array offset [KB] Michael Schwarz, Daniel Gruss, Moritz Lipp

182 Page Border Detection with Random Access Access time [cycles] ,000 2,000 3,000 4,000 5,000 Array offset [KB] 45 Michael Schwarz, Daniel Gruss, Moritz Lipp

183 Prime+Probe Find addresses (= array indices) that fall into same cache set 46 Michael Schwarz, Daniel Gruss, Moritz Lipp

184 Prime+Probe Find addresses (= array indices) that fall into same cache set Physical address defines in which cache set the data is cached 46 Michael Schwarz, Daniel Gruss, Moritz Lipp

185 Prime+Probe Find addresses (= array indices) that fall into same cache set Physical address defines in which cache set the data is cached Enough addresses in one set evicts the set (Prime) 46 Michael Schwarz, Daniel Gruss, Moritz Lipp

186 Prime+Probe Find addresses (= array indices) that fall into same cache set Physical address defines in which cache set the data is cached Enough addresses in one set evicts the set (Prime) Iterate again over addresses (Probe) 46 Michael Schwarz, Daniel Gruss, Moritz Lipp

187 Prime+Probe Find addresses (= array indices) that fall into same cache set Physical address defines in which cache set the data is cached Enough addresses in one set evicts the set (Prime) Iterate again over addresses (Probe) If it is fast, they are still cached 46 Michael Schwarz, Daniel Gruss, Moritz Lipp

188 Prime+Probe Find addresses (= array indices) that fall into same cache set Physical address defines in which cache set the data is cached Enough addresses in one set evicts the set (Prime) Iterate again over addresses (Probe) If it is fast, they are still cached If it is slow, someone used this cache set and evicted our addresses 46 Michael Schwarz, Daniel Gruss, Moritz Lipp

189 Prime+Probe 47 Michael Schwarz, Daniel Gruss, Moritz Lipp

190 Prime+Probe with Random Access 48 Michael Schwarz, Daniel Gruss, Moritz Lipp

191 Interrupt Detection Multithreading allows to detect interrupts 49 Michael Schwarz, Daniel Gruss, Moritz Lipp

192 Interrupt Detection Multithreading allows to detect interrupts Endless loop which counts number of increments in time window 49 Michael Schwarz, Daniel Gruss, Moritz Lipp

193 Interrupt Detection Multithreading allows to detect interrupts Endless loop which counts number of increments in time window Different number of increments indicate interrupt 49 Michael Schwarz, Daniel Gruss, Moritz Lipp

194 Interrupt Detection Multithreading allows to detect interrupts Endless loop which counts number of increments in time window Different number of increments indicate interrupt Fuzzy time prevents deterministic equally-sized time window 49 Michael Schwarz, Daniel Gruss, Moritz Lipp

195 Interrupt Detection Delta [counter] 1,850 1,800 1,750 tap tap tap tap 1, Runtime [s] 50 Michael Schwarz, Daniel Gruss, Moritz Lipp

196 Interrupt Detection with Fuzzy Time Delta [counter] tap tap tap tap Runtime [s] 51 Michael Schwarz, Daniel Gruss, Moritz Lipp

197 Event Queue Spying Messages between web workers are handled in the event queue 52 Michael Schwarz, Daniel Gruss, Moritz Lipp

198 Event Queue Spying Messages between web workers are handled in the event queue User activity is also handled in the event queue 52 Michael Schwarz, Daniel Gruss, Moritz Lipp

199 Event Queue Spying Messages between web workers are handled in the event queue User activity is also handled in the event queue Posting many messages allows to measure latency 52 Michael Schwarz, Daniel Gruss, Moritz Lipp

200 Event Queue Spying Messages between web workers are handled in the event queue User activity is also handled in the event queue Posting many messages allows to measure latency Latency indicates user input 52 Michael Schwarz, Daniel Gruss, Moritz Lipp

201 Event Queue Spying Delta [ms] ,560 2,570 2,580 2,590 2,600 2,610 2,620 2,630 2,640 Runtime [ms] 53 Michael Schwarz, Daniel Gruss, Moritz Lipp

202 Event Queue Spying with Message Delay Delta [ms] ,860 2,870 2,880 2,890 2,900 2,910 2,920 2,930 2,940 Runtime [ms] 54 Michael Schwarz, Daniel Gruss, Moritz Lipp

203 SharedArrayBuffer Timing Primitive SharedArrayBuffer allows to build a timing primitive with the highest resolution 55 Michael Schwarz, Daniel Gruss, Moritz Lipp

204 SharedArrayBuffer Timing Primitive SharedArrayBuffer allows to build a timing primitive with the highest resolution One web worker continuously increments variable in the shared array 55 Michael Schwarz, Daniel Gruss, Moritz Lipp

205 SharedArrayBuffer Timing Primitive SharedArrayBuffer allows to build a timing primitive with the highest resolution One web worker continuously increments variable in the shared array Other worker uses this as a timestamp 55 Michael Schwarz, Daniel Gruss, Moritz Lipp

206 SharedArrayBuffer Timing Primitive SharedArrayBuffer allows to build a timing primitive with the highest resolution One web worker continuously increments variable in the shared array Other worker uses this as a timestamp Adding random delay to access degrades resolution 55 Michael Schwarz, Daniel Gruss, Moritz Lipp

207 SharedArrayBuffer 56 Michael Schwarz, Daniel Gruss, Moritz Lipp

208 SharedArrayBuffer with Random Delay 57 Michael Schwarz, Daniel Gruss, Moritz Lipp

209 Defense Prevents Rowham- Page Dedu- DRAM Covert Anti- Cache Keystroke Browser mer.js plication Channel ASLR Eviction Timing Buffer ASLR Array preloading Non-deterministic array Array index randomization Low-resolution timestamp Fuzzy time * * * * WebWorker polyfill Message delay Slow SharedArrayBuffer No SharedArrayBuffer * * * * Summary Symbols indicate whether a policy fully prevents an attack, ( ), partly prevents and attack by making it more difficult ( ), or does not prevent an attack ( ). A star (*) indicates that all policies marked with a star must be combined to prevent an attack. 58 Michael Schwarz, Daniel Gruss, Moritz Lipp

210 User Experience 59 Michael Schwarz, Daniel Gruss, Moritz Lipp

211 Conclusion Just rounding timers is not sufficient 60 Michael Schwarz, Daniel Gruss, Moritz Lipp

212 Conclusion Just rounding timers is not sufficient Multithreading and shared data allow to build new timers 60 Michael Schwarz, Daniel Gruss, Moritz Lipp

213 Conclusion Just rounding timers is not sufficient Multithreading and shared data allow to build new timers Microarchitectural attacks in the browser are possible at the moment 60 Michael Schwarz, Daniel Gruss, Moritz Lipp

214 Conclusion Just rounding timers is not sufficient Multithreading and shared data allow to build new timers Microarchitectural attacks in the browser are possible at the moment Efficient countermeasures can be implemented in browsers 60 Michael Schwarz, Daniel Gruss, Moritz Lipp

215 Conclusion Just rounding timers is not sufficient Multithreading and shared data allow to build new timers Microarchitectural attacks in the browser are possible at the moment Efficient countermeasures can be implemented in browsers More microarchitectural attacks in JavaScript will appear 60 Michael Schwarz, Daniel Gruss, Moritz Lipp