and Effi ficient Speculative Execution JIYONG YU, NAMRATA MANTRI, - - PowerPoint PPT Presentation

▶
and effi ficient speculative execution
SMART_READER_LITE
LIVE PREVIEW

and Effi ficient Speculative Execution JIYONG YU, NAMRATA MANTRI, - - PowerPoint PPT Presentation

Jul 09, 2023 247 likes •837 views

ISCA20 Section 5B Speculative Data-Oblivious Execution: Mobilizing Safe Prediction For Safe and Effi ficient Speculative Execution JIYONG YU, NAMRATA MANTRI, JOSEP TORRELLAS, ADAM MORRISON*, CHRISTOPHER W. FLETCHER UNIVERSITY OF ILLINOIS AT

slide-1
SLIDE 1

Speculative Data-Oblivious Execution: Mobilizing Safe Prediction For Safe and Effi ficient Speculative Execution

JIYONG YU, NAMRATA MANTRI, JOSEP TORRELLAS, ADAM MORRISON*, CHRISTOPHER W. FLETCHER

UNIVERSITY OF ILLINOIS AT URBANA-CHAMPAIGN ∗TEL AVIV UNIVERSITY

1

ISCA’20 Section 5B

slide-2
SLIDE 2

Speculative Execution Attacks

▪ Attacker exploits speculative execution to leak data through hardware usage

2

Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

slide-3
SLIDE 3

Speculative Execution Attacks

▪ Attacker exploits speculative execution to leak data through hardware usage

3

Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

if (addr < N) { // speculation // access instruction secret = load [addr]; // transmit instruction transmit secret; }

time

Speculation starts

slide-4
SLIDE 4

▪ Attacker exploits speculative execution to leak data through hardware usage

Speculative Execution Attacks

4

if (addr < N) { // speculation // access instruction secret = load [addr]; // transmit instruction transmit secret; }

time Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

Speculative secret is accessed

slide-5
SLIDE 5

▪ Attacker exploits speculative execution to leak data through hardware usage

Speculative Execution Attacks

5

if (addr < N) { // speculation // access instruction secret = load [addr]; // transmit instruction transmit secret; }

time Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

Speculative secret is transmitted via hardware usage

slide-6
SLIDE 6

▪ Attacker exploits speculative execution to leak data through hardware usage

Speculative Execution Attacks

6

if (addr < N) { // speculation // access instruction secret = load [addr]; // transmit instruction transmit secret; }

time Shared hardware Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

Speculative secret is transmitted via hardware usage

slide-7
SLIDE 7

▪ Attacker exploits speculative execution to leak data through hardware usage

Speculative Execution Attacks

7

if (addr < N) { // speculation // access instruction secret = load [addr]; // transmit instruction transmit secret; }

time Shared hardware Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

addr < N

slide-8
SLIDE 8

Speculative Execution Attacks

8

if (addr < N) { // speculation // access instruction secret = load [addr]; // transmit instruction transmit secret; }

time Shared hardware Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

addr > N

▪ Attacker exploits speculative execution to leak data through hardware usage

slide-9
SLIDE 9

▪ Attacker exploits speculative execution to leak data through hardware usage

Speculative Execution Attacks

9

if (addr < N) { // speculation // access instruction secret = load [addr]; // transmit instruction transmit secret; }

time Shared hardware

Attacker infers secret via hardware state

Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

addr > N

slide-10
SLIDE 10

Existing Mitigations

▪ How to deal with ?

10

transmit secret Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

slide-11
SLIDE 11

Existing Mitigations

▪ How to deal with ? ▪ Solution: Delayed Execution

▪ Prior works: SpecShield [PACT’19], NDA [MICRO’19], STT [MICRO’19]

11

transmit secret Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion Transmit instruction Hardware vulnerability load Cache side channel Floating point

  • perations

Subnormal floating point …… ……

slide-12
SLIDE 12

Existing Mitigations

▪ How to deal with ? ▪ Solution: Delayed Execution

▪ Prior works: SpecShield [PACT’19], NDA [MICRO’19], STT [MICRO’19]

12

transmit secret Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

if (addr < N) { // speculation // access instruction secret = load [addr]; // transmit instruction transmit secret; }

Delaying execution Transmit instruction Hardware vulnerability load Cache side channel Floating point

  • perations

Subnormal floating point …… ……

slide-13
SLIDE 13

Existing Mitigations

▪ How to deal with ? ▪ Solution: Delayed Execution

▪ Prior works: SpecShield [PACT’19], NDA [MICRO’19], STT [MICRO’19]

▪ Strong security guarantee ▪ High performance overhead

13

transmit secret Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion Transmit instruction Hardware vulnerability load Cache side channel Floating point

  • perations

Subnormal floating point …… ……

slide-14
SLIDE 14

Existing Mitigations

▪ How to deal with ? ▪ Solution: Delayed Execution

▪ Prior works: SpecShield [PACT’19], NDA [MICRO’19], STT [MICRO’19]

▪ Problem: High performance overhead

14

transmit secret

transmit Register File … secret … Execute Unit

Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion instruction instruction instruction instruction

Improve the performance of Delayed Execution and Maintain its security guarantee

slide-15
SLIDE 15

Speculative Data Oblivious (SDO): Executive Summary

15

Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

slide-16
SLIDE 16

Speculative Data Oblivious (SDO): Executive Summary

Idea 1. Execute eliminating operand-dependent hardware usage

16

transmit secret Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion High performance

slide-17
SLIDE 17

Speculative Data Oblivious (SDO): Executive Summary

Idea 1. Execute eliminating operand-dependent hardware usage

17

transmit secret Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion High performance High security, low performance

by eliminating operand-dependent hardware usage (being data oblivious)

slide-18
SLIDE 18

Speculative Data Oblivious (SDO): Executive Summary

Idea 1. Execute Idea 2. Predict how the execution should be performed eliminating operand-dependent hardware usage

18

transmit secret Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion High performance High security, low performance

by eliminating operand-dependent hardware usage (being data oblivious)

slide-19
SLIDE 19

Speculative Data Oblivious (SDO): Executive Summary

Idea 1. Execute Idea 2. Predict how the execution should be performed Problem: combining idea 1 & 2 creates security problems Solution: build on top of Speculative Taint Tracking (STT)

19

transmit secret Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion High performance High security, low performance

by eliminating operand-dependent hardware usage (being data oblivious)

slide-20
SLIDE 20

Example: Subnormal Floating-point Operation

▪ Double-precision floating point

▪ Normal input: (2.23e−308, 1.79e308), processed by Floating-Point Unit (FPU) ▪ Subnormal input: (4.9e−324, 2.23e−308), requiring microcode assist

20

Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

a = fpop a, b

Fast path (FPU only) Slow path (with microcode assist)

Latency = X Latency = Y > X (a is normal) && (b is normal) (a is subnormal) || (b is subnormal)

slide-21
SLIDE 21

Problem: Leaking Whether Input is Normal/Subnormal

21

Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion Fast path (FPU only) Slow path (with microcode assist)

Latency = Y > X // owned by attacker c = fpmult c, d // owned by victim a = fpmult a, b Latency = X

slide-22
SLIDE 22

22

Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

Problem: Leaking Whether Input is Normal/Subnormal

Fast path (FPU only) Slow path (with microcode assist)

Latency = Y > X // owned by attacker c = fpmult c, d

timeline

Both a and b are normal a = fpmult a, b

Using fast path

c = fpmult c, d

X

// owned by victim a = fpmult a, b Latency = X

slide-23
SLIDE 23

23

Fast path (FPU only) Slow path (with microcode assist) Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

Latency = X Latency = Y > X // owned by attacker c = fpmult c, d

timeline

Both a and b are normal a = fpmult a, b

Using fast path

c = fpmult c, d

timeline

a or b is subnormal a = fpmult a, b

Using slow path

c = fpmult c, d

X Y

// owned by victim a = fpmult a, b

Problem: Leaking Whether Input is Normal/Subnormal

slide-24
SLIDE 24

Idea 1: Being Data Oblivious

24

a = fpmult a, b Fast path (FPU only) Slow path (with microcode assist) Select the correct answer result (fast) result (slow) Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

Latency = X Latency = Y > X

slide-25
SLIDE 25

Idea 1: Being Data Oblivious

25

a = fpmult a, b Fast path (FPU only) Slow path (with microcode assist) Select the correct answer result (fast) result (slow) Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

Latency = X Latency = Y > X a = fpmult a, b c = fpmult c, d

Using fast and slow path Y X timeline

slide-26
SLIDE 26

26

a = fpmult a, b Fast path (FPU only) Slow path (with microcode assist) Select the correct answer result (fast) result (slow) Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

Latency = X Latency = Y > X a = fpmult a, b c = fpmult c, d

Y X Using fast and slow path timeline

Paying performance for security

Idea 1: Being Data Oblivious

slide-27
SLIDE 27

Idea 2: “Predicting” Execution to Perform

27

a = fpmult a, b Fast path (FPU only) Slow path (with microcode assist) Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

Latency = X Latency = Y > X a = fpmult a, b c = fpmult c, d

X Predicting fast path timeline Predictor

slide-28
SLIDE 28

28

a = fpmult a, b Fast path (FPU only) Slow path (with microcode assist) result (fast) Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

Latency = X Latency = Y > X a = fpmult a, b c = fpmult c, d

X Predicting fast path Dependent instructions timeline

Idea 2: “Predicting” Execution to Perform

May be invalid

Predictor

slide-29
SLIDE 29

29

a = fpmult a, b Fast path (FPU only) Slow path (with microcode assist) result (fast) Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

Latency = X Latency = Y > X

timeline

a = fpmult a, b c = fpmult c, d

X Predicting fast path Dependent instructions

a = fpmult a, b

P P+Y Resolving to slow path

Idea 2: “Predicting” Execution to Perform

Predictor

slide-30
SLIDE 30

30

a = fpmult a, b Fast path (FPU only) Slow path (with microcode assist) result (fast) Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

Latency = X Latency = Y > X

Dependent instructions

Potential new leakage

Idea 2: “Predicting” Execution to Perform

Predictor

slide-31
SLIDE 31

31

a = fpmult a, b Fast path (FPU only) Slow path (with microcode assist) result (fast) Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

Latency = X Latency = Y > X

Dependent instructions

Applying STT for Security

Speculative Taint Tracking

Predictor

slide-32
SLIDE 32

32

a = fpmult a, b Fast path (FPU only) Slow path (with microcode assist) result (fast) Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

Latency = X Latency = Y > X

Dependent instructions

Applying STT for Security

Speculative Taint Tracking

Prevent leakage via Prediction/Resolution

Predictor

slide-33
SLIDE 33

33

a = fpmult a, b Fast path (FPU only) Slow path (with microcode assist) result (fast) Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

Latency = X Latency = Y > X

Dependent instructions

Applying STT for Security

Speculative Taint Tracking

Prevent leakage via Prediction/Resolution “Taint” and hide sensitive results

Predictor

slide-34
SLIDE 34

34

Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

Applying STT for Security

How STT “prevents leakage via prediction/resolution”:

  • Never update predictors with any secret information
  • Delay resolution until safe

How STT “taints and hides sensitive results”:

  • Sensitive data is marked tainted
  • Taint propagates through program dataflow
  • Transmitters with tainted arguments are handled safely
slide-35
SLIDE 35

35

Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

Applying STT for Security

How STT “prevents leakage via prediction/resolution”:

  • Never update predictors with any secret information
  • Delay resolution until safe

How STT “taints and hides sensitive results”:

  • Sensitive data is marked tainted
  • Taint propagates through program dataflow
  • Transmitters with tainted arguments are handled safely
slide-36
SLIDE 36

36

Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

Applying STT for Security

How STT prevents leakage via prediction/resolution

  • Never update predictors with any secret information
  • Delaying resolution until safe

How STT taints and hides sensitive results:

  • Sensitive data is marked tainted
  • Taint propagates through program dataflow
  • Transmitters with tainted arguments are handled safely

STT Makes Prediction Great (SAFE) Again! We build predictors to reduce defense overhead

slide-37
SLIDE 37

Speculative Data Oblivious Execution (SDO)

37

Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

Idea 1. Safely execute transmitters in a data-oblivious (DO) manner Idea 2. Predict how the execution should be performed

SDO

Net result: execute unsafe transmitters early and safely Data Oblivious variants + Predicting which variant + Safe Prediction with STT =

slide-38
SLIDE 38

Speculative Data Oblivious Execution (SDO)

38

Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

What’s Next:

  • Generic SDO Framework
  • Implementing SDO for load instructions
  • Evaluation
  • Conclusion
slide-39
SLIDE 39

▪ Step 1: Define data-oblivious (DO) variants for unsafe transmitters

SDO Framework

39

Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

slide-40
SLIDE 40

SDO Framework: Step 1: Define Data-oblivious (DO) Variants

40

Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

Transmit instruction dest <- op args DO variants DO-op1 … DO-opN Execution of DO variants (dest1, success1) <- DO-op1 args … (destN, successN) <- DO-opN args

slide-41
SLIDE 41

SDO Framework: Step 1: Define Data-oblivious (DO) Variants

41

Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion dest = fpmult args Fast path (FPU only) Slow path (with microcode assist)

destfast, successfast <- fast_path args (successfast = TRUE if args is normal) destslow, successslow <- slow_path args (successslow = TRUE if args is subnormal) Transmit instruction dest <- op args DO variants DO-op1 … DO-opN Execution of DO variants (dest1, success1) <- DO-op1 args … (destN, successN) <- DO-opN args

slide-42
SLIDE 42

SDO Framework: Step 1: Define Data-oblivious (DO) Variants

42

Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion dest = fpmult args Fast path (FPU only) Slow path (with microcode assist)

destfast, successfast <- fast_path args (successfast = TRUE if args is normal) destslow, successslow <- slow_path args (successslow = TRUE if args is subnormal) Transmit instruction dest <- op args DO variants DO-op1 … DO-opN Execution of DO variants (dest1, success1) <- DO-op1 args … (destN, successN) <- DO-opN args

slide-43
SLIDE 43

SDO Framework: Step 2: Predict Which DO Variant to Use

43

Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

Transmit instruction dest <- op args DO variants DO-op1 … DO-opN Predictor Pred Predicting DO variant i <- Pred.predict (public_input) (desti, successi) <- DO-opi args

slide-44
SLIDE 44

SDO Framework: Step 2: Predict Which DO Variant to Use

44

Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion dest = fpmult args Fast path (FPU only) Slow path (with microcode assist)

destfast, successfast <- fast_path args (successfast = TRUE if args is normal successfast = FALSE if args is subnormal)

Static Predictor: always predicting “Fast path” destfast Dependent instructions

Transmit instruction dest <- op args DO variants DO-op1 … DO-opN Predictor Pred Predicting DO variant i <- Pred.predict (public_input) (desti, successi) <- DO-opi args

slide-45
SLIDE 45

SDO Framework: Step 3: Resolve Prediction when safe

45

Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion dest = fpmult args Fast path (FPU only) Slow path (with microcode assist) destfast Dependent instructions

Transmit instruction dest <- op args DO variants DO-op1 … DO-opN Predictor Pred Predicting DO variant i <- Pred.predict (public_input) (desti, successi) <- DO-opi args Resolving when safe Pred.update(…) if (!successi) squash from “dest <- op args”

slide-46
SLIDE 46

SDO Framework: Step 3: Resolve Prediction when safe

46

Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

Transmit instruction dest <- op args DO variants DO-op1 … DO-opN Predictor Pred Predicting DO variant i <- Pred.predict (public_input) (desti, successi) <- DO-opi args Resolving when safe Pred.update(…) if (!successi) squash from “dest <- op args”

dest = fpmult args Fast path (FPU only) Slow path (with microcode assist) destfast Dependent instructions successfast == FALSE

slide-47
SLIDE 47

Designing SDO for Loads

▪ Load is the vital motivation and challenge for SDO

▪ The execution of loads is complicated, susceptible to various attacks ▪ Most performance overhead comes from loads

47

Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

slide-48
SLIDE 48

Step 1: Define DO Variants for Loads

▪ DO variants

▪ DO-ldL1 : only accessing L1 ▪ DO-ldL2 : only accessing L1 and L2 sequentially ▪ DO-ldL3 : only accessing L1, L2 and L3 sequentially ▪ DO-ldMem : accessing L1, L2, L3 and DRAM sequentially

▪ (destXX, successXX) <- DO-ldXX addr // destXX = ⊥ if successXX == FALSE

48

Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

slide-49
SLIDE 49

Step 1: Define DO Variants for Loads

▪ DO variants

▪ DO-ldL1 : only accessing L1 ▪ DO-ldL2 : only accessing L1 and L2 sequentially ▪ DO-ldL3 : only accessing L1, L2 and L3 sequentially ▪ DO-ldMem : accessing L1, L2, L3 and DRAM sequentially

▪ (destXX, successXX) <- DO-ldXX addr // destXX = ⊥ if successXX == FALSE ▪ DO variants (DO-ldLi) must be free of adversary-observable hardware resource usage

▪ Cannot modify cache state (tag, data, LRU bits, etc.) ▪ Cannot incur address-dependent latency (e.g., free of bank conflict, port contention) ▪ ……

49

Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

slide-50
SLIDE 50

Step 1: Define DO Variants for Loads

▪ DO variants

▪ DO-ldL1 : only accessing L1 ▪ DO-ldL2 : only accessing L1 and L2 sequentially ▪ DO-ldL3 : only accessing L1, L2 and L3 sequentially ▪ DO-ldMem : accessing L1, L2, L3 and DRAM sequentially

▪ (destXX, successXX) <- DO-ldXX addr // destXX = ⊥ if successXX == FALSE ▪ DO variants (DO-ldLi) must be free of adversary-observable hardware resource usage

▪ Cannot modify cache state (tag, data, LRU bits, etc.) ▪ Cannot incur address-dependent latency (e.g., free of bank conflict, port contention) ▪ ……

▪ For more details (e.g., load re-ordering, performance optimizations) about DO variants, please see the paper

50

Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

slide-51
SLIDE 51

Step 2: Predict Which DO Variant to Use

▪ Goal: accurate and precise cache level prediction

▪ Suppose a load requires data from cache level i and the predictor predicts level j ▪ “accurate and precise”: i == j ▪ “accurate but imprecise”: i < j -> redundant cache access -> unnecessary load latency ▪ “inaccurate”: i > j

  • > cache miss -> writeback ⊥ to dependents -> squash

51

Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

Predicted level DO Variant 1(L1) DO-ldL1 2(L2) DO-ldL2 3(L3) DO-ldL3 4(Memory) DO-ldMem

slide-52
SLIDE 52

Step 2: Predict Which DO Variant to Use

▪ Goal: accurate and precise cache level prediction

▪ Suppose a load requires data from cache level i and the predictor predicts level j ▪ “accurate and precise”: i == j ▪ “accurate but imprecise”: i < j -> redundant cache access -> unnecessary load latency ▪ “inaccurate”: i > j

  • > cache miss -> writeback ⊥ to dependents -> squash

▪ Hybrid predictor:

▪ “Greedy” (for loads with irregular access pattern): Maintain a history, and pick the lowest level among history ▪ “Loop” (for loads with regular access pattern) Learn the recurring pattern, and predict based on the pattern

52

Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

Predicted level DO Variant 1(L1) DO-ldL1 2(L2) DO-ldL2 3(L3) DO-ldL3 4(Memory) DO-ldMem

slide-53
SLIDE 53

Step 3: Resolve When Load is Safe

▪ Update the predictor ▪ Squash if success == FALSE ▪ In a multi-processor:

DO-ldLX cannot modify cache state → Data fetched by DO-ldLX may not be cached in L1 → May missing cache invalidation

▪ Solution: send a second load request to validate if a cache invalidation was missed

▪ We adopt the validation infrastructure proposed in InvisiSpec [MICRO’18]

53

Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

slide-54
SLIDE 54

Performance Evaluation on SPEC2017

54

Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

Perf Overhead over Insecure Baseline

“Spectre” attack model Consider control-flow speculation “Futuristic” attack model Consider all types of speculation

Static L1: always predicting DO-ldL1 Static L2: always predicting DO-ldL2 Static L3: always predicting DO-ldL3 Hybrid: using the hybrid predictor Perfect: prediction is accurate and precise Transmitters:

  • Load
  • Floating-point multiplication
  • Floating-point division
slide-55
SLIDE 55

Conclusion

▪ SDO serves as a new speculative execution attack mitigation with high- performance and high-security ▪ The proposed SDO framework augments STT with significant speedup without compromising security Data Oblivious variants + Predicting which variant + Safe Prediction with STT = Safe, early execution of transmitters

55

Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

slide-56
SLIDE 56

56

slide-57
SLIDE 57

57

a = fpmult a, b Fast path (FPU only) Slow path (with microcode assist) result (fast) Introduction Speculative Data-Oblivious SDO Framework SDO for Loads Evaluation Conclusion

Latency = X Latency = Y > X

Dependent instructions

Applying STT for Security

Speculative Taint Tracking

Prevent leakage via Prediction/Resolution

Predictor

STT: prediction and resolution never depend on sensitive data We can build new predictors to get more performance

“Taint” and hide sensitive results