word refinement

4 files changed, 378 insertions, 409 deletions

diff --git a/chap/chap2.tex b/chap/chap2.tex
index 7f6b4f8..576da48 100644
--- a/chap/chap2.tex
+++ b/chap/chap2.tex
@@ -28,7 +28,7 @@ Diffie-Hellman，RSA 等密码的私钥。\supercite{TimingAttack} 这是最早�
 的数据时，访问这个地址的时间更短，利用这个性质，攻击者可以得知一个地址
 是否曾经被访问过。缓存计时攻击的常见形式有：
 
-\begin{itemize}
+\begin{enumerate}
 \item Evict+Time: 攻击者清除一个缓存组，然后对一个算法的运行进行计时，
   检查它的运行时间是否受到影响
 \item Prime+Probe: 受害者运行一段程序后，攻击者访问缓存某一组的每一路，
@@ -36,8 +36,9 @@ Diffie-Hellman，RSA 等密码的私钥。\supercite{TimingAttack} 这是最早�
 \item Flush+Reload: 攻击者利用 x86 的 clflush 等指令清除一个共享内存地
   址对应的缓存行，在受害者运行一段程序后，攻击者重新装载该行对应的地址
   的数据，通过测量访问时间推断受害者是否访问了这个共享的地址
-\end{itemize}
+\end{enumerate}
 
+% TODO: more side channels
 \section{Meltdown 和 Spectre 攻击的各种变体}
 
 处理器在执行指令遇到异常，或者推测式执行了错误的指令后，会回卷错误执行
@@ -47,7 +48,7 @@ instruction）。Meltdown\supercite{meltdown} 和
 Spectre\supercite{spectre} 是最早发现的两个利用暂态指令的攻击。此后发现
 了更多的 Meltdown 和 Spectre 的变体。为了找出更多的攻击类型和分析它们的
 防御方案，Claudio Canella 等人对这些攻击及其防御做了系统性的研
-究\supercite{systematic}，将所有暂态执行攻击分为 Meltdown型攻击
+究\supercite{systematic}，将所有暂态执行攻击分为 Meltdown 型攻击
 和 Spectre 型攻击两类。
 
 \subsection{Meltdown 型攻击}
@@ -59,53 +60,47 @@ Meltdown 型攻击利用的是处理器异常产生的暂态指令，这些指�
 \subsubsection{“熔断”（Meltdown）攻击}
 
 内存隔离是现代操作系统的核心安全功能之一。操作系统确保用户程序无法访问
-其他程序的内存或内核的内存。这种隔离是现代计算环境的基石，使得系统上可
+其他程序或内核空间的内存区域。现代计算环境利用这种隔离，使得系统上可
 以同时运行多个应用程序，和多个用户的进程。
 
-在现代处理器中，内核和用户进程之间的隔离通常由处理器的定义的权限位实现，
-这一位定义了内核的页是否可以被访问。这一位只能在进入内核态时设置，并在
-切换到用户态时清除。这个硬件特性使得操作系统可以将内核映射到每个进程的
-地址空间，在中断等事件发生时，可以高效地从用户进程切换至内核。因此，在
-操作系统的实现中，处理器从用户进程切换到内核时，不会改变内存映射。
+在现代处理器中，内核和用户进程之间的隔离，通常由处理器定义的一个权限位
+实现，它定义了内核的页是否可以被访问。这一位只能在进入内核态时设置，并
+在切换到用户态时清除。这个硬件特性使得操作系统可以将内核映射到每个进程
+的地址空间，在中断等事件发生时，可以在不改变内存地址映射的条件下，高效
+地从用户进程切换至内核。
 
-在 Meltdown\supercite{meltdown} 攻击中，任何用户进程都可以简单地读取所在机器的整个
-内核内存（包括映射在内核区域中的所有物理内存），从而完全破坏内存隔
-离。Meltdown 不利用任何软件漏洞，适用于所有主流操作系统。Meltdown 利用了
-大多数现代处理器中的侧信道信息，可以用于 2010 年以来的现代 Intel 处理器，
-也可能可用于其他厂商的处理器。
+Meltdown\supercite{meltdown} 攻击使得任何用户进程都可以简单地读取所在
+机器的整个内核区域的内存（包括映射在内核区域中的所有物理内存），从而完
+全破坏了内存隔离。Meltdown 不利用任何软件漏洞，而是利用了现代处理器中
+的侧信道，适用于所有主流的操作系统。这种攻击可以用于 2010 年以来的现代
+Intel 处理器，也可能可用于其他厂商的处理器。
 
 侧通道攻击通常需要非常具体地了解目标应用程序，并且只用于泄露其中的秘密
-信息，但 Meltdown 允许攻击者在可被攻击的处理器上，通过运行代码获得整个
-内核地址空间的数据，包括任何映射在内核中的物理内存。Meltdown 之所以简单和强大，是因为它利用了乱序执行产生的副作用。
-
-乱序执行是现代处理器用于提高性能的重要特性，用于隐藏功能单元的延迟，例
-如，读取内存的功能单元需要等待存储器中的数据到达。现代处理器在遇到长延
-迟的执行时，不会使处理器停顿，而是可以乱序操作，将后续的操作调度到空闲的功
-能单元中。
-
-从安全的角度，有一个发现很重要：易受攻击的乱序处理器允许非特权态的进
-程将数据从特权（内核或物理）地址载入临时的寄存器中。进一步，处理器可以
-基于该寄存器的值进行计算，例如用这个寄存器的值访问数组。如果一条指令不
-应该执行，通过简单地丢弃访问内存得到的结果，处理器可以确保程序执行的正
-确性。因此，在体系结构层次，即处理器执行计算的抽象定义下，不会出现安全
-问题。
-
-但是，乱序执行中的内存访问会影响缓存，而缓存的状态又可以通过缓存侧通道
-进行检测。因此，攻击者可以通过在乱序执行的指令流中，读取特权态的内存来，
-来得到整个内核内存的数据，并通过微体系结构隐蔽通道传送出来，然后攻击者在隐
-蔽信道的接收端，找出这个临时寄存器的值。因此，在微体系结构层次，即实际的
-硬件实现中，存在可利用的安全性问题。
+信息，但在易受攻击的处理器上，利用 Meltdown 攻击，可以通过运行代码获得
+整个内核地址空间的数据，包括任何映射在内核中的物理内存。
+
+在一个易受攻击的乱序处理器中，处理器允许非特权态的进程将数据从特权地址
+装载至临时的寄存器中。进一步，处理器可以使用该寄存器的值进行计算，例如
+用这个寄存器的值访问数组。如果一条指令不应该执行，通过简单地丢弃访问内
+存得到的结果，处理器可以确保程序执行的正确性。因此，在体系结构层次，即
+处理器执行计算的抽象定义下，不会出现安全问题。
+
+但是，乱序执行中的内存访问会改变缓存状态，而缓存的状态又可以通过缓存侧
+通道进行检测。因此，攻击者可以通过在乱序执行的指令流中，读取特权态的内
+存，来得到整个内核内存的数据，并通过微体系结构隐蔽通道传送出来，然后攻
+击者在隐蔽信道的接收端，找出这个临时寄存器的值。因此，在微体系结构层次，
+即实际的硬件实现中，存在可利用的安全性问题。
 
 % background: address spaces
-为了将不同的进程相互隔离，处理器支持虚拟地址空间，它将虚拟地址翻译为物
-理地址。虚拟地址空间将内存划分为一系列的页，系统通过多级页表将虚拟页翻
-译为物理页。页表是一个多级的结构，存放虚拟页到物理页的映射，同时，它还
-保存了每个页的保护属性，用于处理器进行权限检查，例如可读、可写、可执行、
-用户可读等。操作系统中每一个运行中的进程有一个对应的页表，页表所在的位
-置存放在处理器中的一个特定寄存器中，在上下文切换时，操作系统会更新这个
-寄存器，从而切换到处理器的进程可以使用这个进程对应的页表。利用这个机制，
-每个进程的虚拟地址空间映射到不同的物理区域，每个进程只能使用自己地址空
-间中的数据，从而达到进程间隔离的效果。
+为了将不同的进程相互隔离，处理器为操作系统提供了虚拟地址空间机制，它将
+虚拟地址翻译为物理地址。虚拟地址空间将内存划分为一系列的页，系统通过多
+级页表将虚拟页翻译为物理页。页表是一个多级的结构，存放虚拟页到物理页的
+映射，同时，它还保存了每个页的保护属性，用于处理器进行权限检查，例如可
+读、可写、可执行、用户可读等。操作系统中每一个运行中的进程有一个对应的
+页表，页表所在的位置存放在处理器的一个特定的寄存器中，在上下文切换时，
+操作系统更新这个寄存器，切换至处理器上的新进程可以使用这个进程对应的页
+表。利用这个机制，每个进程的虚拟地址空间映射到不同的物理内存区域，每个
+进程只能使用自己地址空间中的数据，从而达到进程间隔离的效果。
 
 每个地址空间都可以分为用户地址空间和内核地址空间。正在运行的进程可以访
 问用户地址空间，而内核地址空间只有进入内核态后可以访问，操作系统通过在
@@ -115,10 +110,10 @@ Meltdown 型攻击利用的是处理器异常产生的暂态指令，这些指�
 
 操作系统将内核地址空间映射至每个用户进程的地址空间中。处理器执行访存指
 令时，在将虚拟地址翻译为物理地址的时候，检查地址对应的权限位，判断用户
-是否可访问该地址。Meltdown攻击中，攻击者让处理器从用户不可访问的内核地
-址装载数据至寄存器，由于所有内核地址都可以翻译为合法的物理地址，处理器
-可以读取内核地址空间的数据，在产生异常前，攻击者构造的暂态指令序列可以
-将读取到的数据通过隐蔽信道发送给攻击者。
+空间的指令是否可访问该地址。在 Meltdown 攻击中，攻击者让处理器从用户不
+可访问的内核地址装载数据至寄存器，由于所有内核地址都可以翻译为合法的物
+理地址，处理器可以读取内核地址空间的数据，在产生异常前，攻击者构造的暂
+态指令序列可以将读取到的数据通过隐蔽信道发送给攻击者。
 
 图\ref{lst:meltdown}是一段 Meltdown 攻击的示例代码，通过它可以读取内核地址空间的数据：
 
@@ -136,72 +131,71 @@ mov rbx, qword [rbx + rax] ; 访问探测数组
 \label{lst:meltdown}
 \end{figure}
 
-这段 X86 指令读取了以 rcx 为地址的内核空间的数据，在用户态下，这个读取
+这段 x86 指令读取了以 rcx 为地址的内核空间的数据，在用户态下，这个读取
 内核空间数据的指令会产生异常，但是在处理器产生异常之前，这条指令可以将
-内核空间的数据读至寄存器，并且其后的指令也会执行，访问 rbx 指向的探测数
-组。在处理器回卷了产生异常的指令和其后执行的指令后，高速缓存中仍然保留
-了探测数组和内核数据相关的元素，从而攻击者可以通过扫描探测数组的每一
+内核空间的数据读至寄存器，并且其后的指令也会执行，访问 rbx 指向的探测
+数组。在处理器回卷了产生异常的指令和其后执行的指令后，高速缓存中仍然保
+留了探测数组和内核数据相关的元素，从而攻击者可以通过扫描探测数组的每一
 项，观察访问时间，以推测内核空间数据的值。
 
-Meltdown 打破了处理器内存隔离功能提供的所有安全保障。这种攻击可以用于现
-代台式机、笔记本电脑以及云服务器。 Meltdown 允许非特权进程读取映射在内
-核地址空间中的数据，包括 Linux，Android 和 OS X 上的整个物理内存，以
-及 Windows 上的大部分物理内存。这些内存可能包含其他进程的物理内存，以及
-内核共享的容器沙箱（如 Docker，LXC）或半虚拟化模式下的 Xen 中，虚拟化管
-理程序的内存，和其他虚拟化实例的内存。Meltdown 攻击的性能取决于处理器速
-度、TLB 和高速缓存大小、DRAM 速度等，可以以 3.2KB/s 到 503KB/s 的速度
-读取内核内存。因此，大量系统受到影响。
+Meltdown 打破了处理器内存隔离功能提供的所有安全保障。这种攻击可以用于
+现代台式机、笔记本电脑以及云服务器。 Meltdown 允许非特权进程读取映射在
+内核地址空间中的数据，包括 Linux，Android 和 OS X 上的整个物理内存，以
+及 Windows 上的大部分物理内存。这些内存可能包含其他进程的物理内存，以
+及内核共享的容器沙箱（如 Docker，LXC）或半虚拟化模式下的 Xen 中，虚拟
+化管理程序的内存，和其他虚拟化实例的内存。Meltdown 攻击可以以 3.2KB/s
+到 503KB/s 的速度读取内核内存。
 
 \subsubsection{“预兆”（Foreshadow）攻击}
 
 % foreshadow introduction
-由于现代广泛使用的操作系统和应用程序的大小可以轻松地达到数百万行代码，
-并且单个漏洞通常会破坏所有安全保证，所以在安全上很难信任现有的操作系统
-和应用程序。为了应对这些挑战，学术界和工业界开发了可信执行环境
-（Trusted Execution Environment, TEE），其中包含一个处理器常规执行环境
-之外的非分层保护模型，用于隔离应用程序，称为隔离区（enclave）。 TEE 利
-用只含有处理器和微码的最小可信计算基础（Trusted Computing Base），来保
-证相互不信任的隔离区的保密性和完整性。 每个隔离区的私有处理器和
-内存状态只可以由其内部运行的代码访问，并且在任何特权级别（包括潜在的恶
-  意操作系统和虚拟机管理程序）上运行的所有其他隔离区和软件都无法访
-问。除了强大的内存隔离外，TEE 通常还提供一个证明（attestation）原语，
-从而可以本地或远程地在运行时从密码学上验证特定的隔离区已经加载到真
-正的（因而被认为是安全的）TEE 处理器上。
-
-随着 2013 年 Intel 软件防护扩展（Software Guard eXtention,
-SGX）\supercite{sgx}的发布，硬件强制的 TEE 隔离和证明可以在现成的x86处
-理器上使用。由于 Intel SGX 承诺的强大安全保障，越来越多的行业参与者将这
-项技术应用于可受攻击者控制的机器上，需要安全执行的各种应用程序中。Open
-Whisper Systems 依靠 SGX 在 Signal 网络中实现隐私友好的联系人发现功
-能。\supercite{signal-sgx} 微软和 IBM 最近都宣布在其云基础架构中支
-持 SGX。各种现成的蓝光播放器以及 4K Netflix 客户端使用 SGX 对高分辨率视
-频流实施数字版权管理（DRM）。新兴的加密货币\supercite{mobilecoin}和的区
-块链\supercite{sawtooth}技术更加依赖于 SGX 的正确性。
-
-然而，当前的 SGX 实现并没有满足它的安全目标。Foreshadow 攻击利用现
-代 Intel 处理器中的乱序执行机制，可以从处理器的缓存中泄露明文
-的隔离区数据。Foreshadow 攻击的核心是利用 Meltdown 攻击相同的处理器
-漏洞，即处理器的访问控制逻辑允许攻击者在瞬态的乱序执行指令回滚之前，使
-用未授权内存访问的结果。然而，Meltdown 攻击针对传统的分层保护域，
-而 Foreshadow 考虑了一种非常不同的攻击模型，攻击者的目标不是从用户空间
-读取内核内存，而是破坏最先进的地址空间内隔离区保护域，它不在已经部署
-的用于防御 Meltdown 的内核页表隔离技术的保护之内。Foreshadow 使用了一
-种新的漏洞利用方法，并且基本的攻击完全可以由无特权的攻击者使用，而无需
-用 root 权限访问受害者机器。对于有 root 权限的攻击者，还可以使用一组可
-选的内核级优化技术，进一步降低 Foreshadow 攻击的噪声。
-
-Foreshadow 对 Intel SGX 所追求的安全模型产生了深远的影响，在没有微码补
-丁的情况下，当前的SGX处理器无法保证隔离区的数据保密性，也无法证
-明隔离区执行的完整性，包括英特尔自己的隔离区架构。此外，尽管 SGX
-希望内核级别的攻击者，但现有的 SGX 处理器甚至无法在没有特权的用户空间
-攻击者面前保护隔离区中的秘密数据。
-
-所有先前已知的针对 SGX 的攻击都依赖于软件特定的侧信道泄露或软件漏
-洞。 人们普遍认为，精心编写的隔离区可以通过坚持良好的编码实践，例如
-不使用依赖秘密数据的分支，来防止信息泄露。Intel 认为这些攻击都没有破
-坏 SGX 的安全保证，防止侧信道攻击应该是隔离区开发者的责任。 然
-而，Foreshadow 否定了这一论点，因为它完全依赖于基本的 Intel x86 处理器
-的行为，并且不利用任何软件漏洞，甚至不需要知道受害者隔离区的源代码。
+现代广泛使用的操作系统和应用程序的大小可以轻松地达到数百万行代码，并且
+单个漏洞通常会破坏所有安全保证，所以在安全上，现有的操作系统和应用程序
+难以信任。为了应对这些挑战，学术界和工业界开发了可信执行环境（Trusted
+  Execution Environment, TEE），其中包含一个处理器常规执行环境之外的非
+分层保护模型，用于隔离应用程序，称为隔离区（enclave）。 TEE 利用只含有
+处理器和微码的最小可信计算基（Trusted Computing Base），来保证相互不信
+任的隔离区的保密性和完整性。 每个隔离区的私有处理器和内存状态只可以由
+其内部运行的代码访问，并且在任何特权级别（包括潜在的恶意操作系统和虚拟
+  机管理程序）上运行的软件和所有其他隔离区都无法访问。除了强大的内存隔
+离外，TEE 通常还提供一个证明（attestation）原语，从而可以从本地或远程，
+在运行时从密码学上验证特定的隔离区已经加载到真正的（因而被认为是安全的）
+TEE 处理器上。
+
+2013 年发布的 Intel 软件防护扩展（Software Guard eXtention, SGX）
+\supercite{sgx}，使得 x86 处理器可以使用硬件强制的 TEE 隔离和证明。
+Intel SGX 承诺的强大安全保障，使越来越多的行业参与者将这项技术应用于可
+受攻击者控制的机器上，和需要安全执行的各种应用程序中。Open Whisper
+Systems 依靠 SGX 在 Signal 网络中实现隐私友好的联系人发现功能
+\supercite{signal-sgx} 。微软和 IBM 最近都宣布在其云基础架构中支持 SGX。
+各种现成的蓝光播放器以及 4K Netflix 客户端使用 SGX 对高分辨率视频流实
+施数字版权管理（DRM）。新兴的加密货币\supercite{mobilecoin}和的区块链
+\supercite{sawtooth}技术更是依赖于 SGX 的正确性。
+
+然而，Foreshadow\supercite{foreshadow} 攻击表明，当前的 SGX 实现并没有
+满足它的安全目标。Foreshadow 攻击利用现代 Intel 处理器中的乱序执行机制，
+可以从处理器的缓存中泄露明文的隔离区数据。Foreshadow 和 Meltdown 利用
+相似的处理器漏洞，处理器的控制逻辑允许攻击者在暂态的乱序执行指令回滚之
+前，使用未授权的内存访问的结果。和 Meltdown 攻击针对传统的分层保护域不
+同，Foreshadow 考虑了一种非常不同的攻击模型，攻击者的目标不是从用户空
+间读取内核内存，而是破坏最先进的地址空间内隔离区保护域，它不在已经部署
+的用于防御 Meltdown 的内核页表隔离技术的保护之内。在 Foreshadow 攻击中，
+无特权的普通用户即可完成基本的攻击，而无需以 root 的身份访问受害者机器。
+对于有 root 权限的攻击者，还可以使用一组可选的内核级优化技术，进一步降
+低 Foreshadow 攻击的噪声。
+
+Foreshadow 破坏了 Intel SGX 的安全模型，在没有微码补丁的情况下，当前的
+SGX 处理器无法保证隔离区的数据保密性，也无法证明隔离区执行的完整性，包
+括英特尔自己的隔离区架构。此外，尽管 SGX 期望可以防御内核级别的攻击者，
+但现有的 SGX 处理器甚至无法在没有特权的用户空间攻击者面前保护隔离区中
+的秘密数据。
+
+所有先前已知的针对 SGX 的攻击都依赖于软件特定的侧信道泄露或软件漏洞。
+人们普遍认为，精心编写的隔离区可以通过坚持良好的编码实践，例如不使用依
+赖秘密数据的分支，来防止信息泄露。这些攻击都没有破坏 Intel 定义的 SGX
+的安全保证，防止侧信道攻击应该是隔离区开发者的责任。 然而，Foreshadow
+否定了这一论点，因为它完全依赖于基本的 Intel x86 处理器的行为，并且不
+利用任何软件漏洞，甚至不需要知道受害者隔离区的源代码。
 
 % foreshadow attack
 \begin{figure}[htbp]
@@ -211,44 +205,45 @@ Foreshadow 对 Intel SGX 所追求的安全模型产生了深远的影响，在�
   \label{fig:addr-tran}
 \end{figure}
 
-在现代 Intel x86 处理器中，用一个虚拟内存地址访问内存时，处理器先在TLB
-中查询对应的物理地址，如果 TLB 中没有这个地址对应的项，则会在页表中找到
-虚拟地址对应的页表项，以获得对应的物理地址和访问权限信息。
-如果在虚拟机环境中，则需要如图 \ref{fig:addr-tran} 所示，增加一个扩展
-页表（Extended Page Table，EPT）的访问过程，将客户机的物理地址翻译为底
-层物理机的物理地址。最后，启用了 Intel SGX 的处理器还会进一步检查地址
-翻译的结果，确保这个地址翻译遵守硬件强制的隔离区访问控制限制。如果
-这三个独立的阶段报告一个访问违例，则处理器抛出一个页错误，控制流转向异
-常处理代码，而对于 SGX，大多数的隔离区内存违例会被处理器忽视，将内
-存装载指令得到的值设为 abort page 的值 -1.
+在现代 Intel x86 处理器中，用一个虚拟内存地址访问内存时，处理器先在
+TLB 中查询对应的物理地址，如果 TLB 中没有这个地址对应的项，则会在页表
+中找到虚拟地址对应的页表项，以获得对应的物理地址和访问权限信息。图
+\ref{fig:addr-tran} 展示了访问页表的过程。如果是在虚拟机环境中，则需要
+增加一个扩展页表（Extended Page Table，EPT）的访问过程，将客户机的物理
+地址翻译为底层物理机的物理地址。最后，启用了 Intel SGX 的处理器还会进
+一步检查地址翻译的结果，确保这个地址翻译遵守硬件强制的隔离区访问控制限
+制。如果这三个独立的阶段出现了一个访问违例，则处理器抛出一个页错误，控
+制流转向异常处理代码，而在启用了 SGX 的处理器中，大多数的隔离区内存违
+例会被处理器忽视，将内存装载指令得到的值设为 abort page 的值 -1.
 
 在体系结构层次上，以上的地址翻译过程在文档中有精确的描述。现代处理器为
-了加快地址翻译和内存访问，使用了并行访问和额外的缓存结构。在 Meltdown类
-型的攻击中，可以发现 Intel 的 CPU 将内存访问违例检查放到了指令提交的时
-间，使得在页错误发生之前，未授权的内存内容仍然可以到达流水线中其后执行
-的乱序执行的指令。Meltdown 攻击利用了这个时间窗口，在暂态指令中，将只有
-特权态能访问的内存编码至持久的微体系结构状态。
-
-现代 Intel 处理器使用虚拟地址索引，物理地址标签的一级缓存。如
-图\ref{fig:addr-tran} 所示，这种缓存索引方式使得地址翻译可以和一级缓存
-的查询并行。在得到虚拟地址对应的一级缓存组后，处理器还需要知道是否有某
-一路缓存含有需要的数据，因此处理器要将地址翻译得到的物理地址和缓存每一
-路的物理地址标签对比，在某一个有效的缓存路存在正确的物理地址时，此时一
-级缓存命中，数据返回至处理器的执行单元。
-
-Foreshadow\supercite{foreshadow} 是一种可以读取 Intel SGX 隔离区中秘
-密数据的 Meltdown 型攻击。如果对 SGX 使用 Meltdown 攻击，攻击者读取未授
-权的隔离区内存，不会产生异常，而是读出 abort page 值 -1. 但是 abort
-page 只在页权限检查通过后发生，攻击者可以将该页 present 位清除，即将该
-页设为不存在，此时处理器便会产生异常，但由于一级缓存使用虚拟地址索引，
-因此仍然可以从一级缓存读取该虚拟地址中的数据，从而暂态指令可以泄露 SGX
-隔离区中的数据。
-
-通过将一个页设为不存在，绕过地址翻译，从一级缓存读取数据的攻击方
-式，Intel 将其称为L1终端错误（L1 Terminal
-Fault）\supercite{l1tf}。Foreshadow-NG\supercite{foreshadowNG} 利用相同
-的原理，新增了Foreshadow-OS 和 Foreshadow-VMM 两种 Foreshadow 类型的攻
-击，可以绕过操作系统和虚拟机的隔离。
+了加快地址翻译和内存访问，使用了并行访问和额外的缓存结构。在 Meltdown
+类型的攻击中，可以发现 Intel 的 CPU 将内存访问违例检查放到了指令提交的
+时间，使得在页错误发生之前，未授权的内存内容仍然可以到达流水线中其后执
+行的乱序执行的指令。Meltdown 攻击利用了这个时间窗口，在暂态指令中，将
+只有特权态能访问的内存编码至持久的微体系结构状态。
+
+现代 Intel 处理器使用虚拟地址索引，物理地址标签的一级缓存。如图
+\ref{fig:addr-tran} 所示，这种缓存索引方式使得地址翻译可以和一级缓存的
+查询并行。在得到虚拟地址对应的一级缓存组后，处理器还需要知道是否有某一
+路缓存含有需要的数据，因此处理器要将地址翻译得到的物理地址和这组缓存每
+一路的物理地址标签对比，在某一个有效的缓存路存在正确的物理地址时，
+一级缓存命中，数据返回至处理器的执行单元。
+
+如果启用 SGX 的处理器使用 Meltdown 攻击，攻击者读取未授权的隔离区内存
+时，不会产生异常，而是读出 abort page 值 -1. 但是 abort page 只在页权
+限检查通过后发生，攻击者可以将该页的存在（present）位清除，即将该页设
+为不存在，此时处理器便会产生异常，但由于一级缓存使用虚拟地址索引，因此
+仍然可以从一级缓存读取该虚拟地址中的数据，从而暂态指令可以泄露 SGX 隔
+离区中的数据。
+
+% TODO: 在哪些处理器上能用这些攻击
+
+通过将一个页设为不存在，绕过地址翻译，从一级缓存读取数据的攻击方式，
+Intel 将其称为L1终端错误（L1 Terminal Fault）\supercite{l1tf}。 利用相
+同的原理，Foreshadow-NG\supercite{foreshadowNG} 新增了Foreshadow-OS 和
+Foreshadow-VMM 两种 Foreshadow 类型的攻击，可以绕过操作系统和虚拟机的
+隔离。
 
 
 % forshadow-OS
@@ -262,44 +257,44 @@ Fault）\supercite{l1tf}。Foreshadow-NG\supercite{foreshadowNG} 利用相同
 间解引用未映射的页将导致终端错误。
 
 Foreshadow-OS 利用了这种错误造成的暂态执行的指令。虽然访问页表中标记为
-不存在的页会触发终端错误存在，在页表项中的元数据表示在缓存中的物理地址
-的情况下，处理器仍然将一级数据高速缓存中未授权数据传递到暂态乱序执行中。
-然后可以和其他暂态执行攻击一样，将秘密数据从微体系结构暂态执行域带入体系结
-构状态中，例如，使用基于缓存的隐蔽通道。更糟糕的是，如果操作系统支持大
-于 4KB 的页（例如，2MB 或 1GB），攻击者可以通过无意的映射访问最大页面大
-小的内存范围。由于所有软件本质上共享相同的物理地址空间，因此元数据创建
-的虚拟到物理映射可能指向属于操作系统内核，VMM 内存，SGX
-隔离区，或 SMM 内存的数据。在操作系统通过 munmap 系统调用释放内存时，
-将页表项清零的常见情况下，攻击者可以访问存储在物理地址 0x00 的数据。
+不存在的页会触发终端错误，在页表项中的元数据表示缓存中的物理地址的情况
+下，处理器仍然将一级数据高速缓存中未授权的数据传递到暂态乱序执行中。然
+后可以和其他暂态执行攻击一样，利用缓存等侧信道构造隐蔽信道，将秘密数据
+从微体系结构暂态执行域带入体系结构状态中。如果操作系统支持大于 4KB 的
+页（例如，2MB 或 1GB），攻击者甚至可以访问最大页面大小的内存范围。由于
+所有软件本质上共享相同的物理地址空间，因此元数据创建的虚拟到物理映射可
+能指向属于操作系统内核，VMM 内存，SGX 隔离区，或 SMM 内存的数据。在操
+作系统通过 munmap 系统调用释放内存，将页表项清零的常见情况下，攻击者可
+以访问存储在物理地址 0x00 的数据。
 
 实验结果表明，在一个 i7-6820HQ CPU 上，Foreshadow-OS 通过利用瞬态执行，
 可以从已清除存在位的页中读取一级缓存的数据。
 
 % foreshadow-VMM
 
-虽然上述 Foreshadow-OS 变体允许无特权的攻击者使用未经授权的物理内存位置
-上的数据进行暂态计算，但他们无法直接控制访问哪些物理地址。因此，
-Foreshadow 攻击使用在可以直接控制客户机器物理地址和一级缓存标签比较的
-不可信虚拟机时时，会变得更有破坏性。这种攻击称为 Foreshadow-VMM.
+虽然上述 Foreshadow-OS 变体允许无特权的攻击者使用未经授权的物理内存位
+置上的数据进行暂态计算，但他们无法直接控制访问哪些物理地址。因此，
+Foreshadow 攻击使用在可以直接控制客户机器物理地址和一级缓存标签的比较
+过程的不可信虚拟机时时，会变得更有破坏性。这种攻击称为 Foreshadow-VMM.
 
-根据 Intel 处理器的架构规范\supercite{intel-spec}，客户机物理地址经过基
-于 EPT 的转换过程以找到底层主机物理内存地址。英特尔的分
-析\supercite{l1tf}显示，终端错误发生时，虚拟地址到物理地址处于早期阶段，
-在经过 EPT 转换之前，将转换出来的客户机物理地址传到一级缓存中进行标签比
-较。因此，恶意虚拟机可以控制用于访问一级缓存的暂态指令的物理地址。特别
-的，不可信的恶意客户虚拟机可以在自己的客户页表中修改页表项，指向客户机
-物理内存。该地址不会经过 EPT 转换，和一级缓存中的标签进行比较，就像它是
-主机物理地址一样。
+根据 Intel 处理器的架构规范\supercite{intel-spec}，客户机物理地址经过
+基于 EPT 的转换过程以找到底层主机物理内存地址。Intel 的分析
+\supercite{l1tf}显示，终端错误发生时，虚拟地址到物理地址的转换处于早期
+阶段，在经过 EPT 转换之前，将转换出来的客户机物理地址传到一级缓存中进
+行标签比较。因此，恶意虚拟机可以控制用于访问一级缓存的暂态指令的物理地
+址。特别的，不可信的恶意客户虚拟机可以在自己的客户页表中修改页表项，指
+向客户机物理内存。该地址不会经过 EPT 转换，和一级缓存中的标签进行比较，
+就像它是主机物理地址一样。
 
 \begin{figure}[htbp]
   \centering
-  \includegraphics[width=0.8\textwidth]{foreshadow-vmm.eps}
+  \includegraphics[width=0.6\textwidth]{foreshadow-vmm.eps}
   \caption{Foreshadow VMM 的一种使用场景\supercite{foreshadowNG}}
   \label{fig:foreshadow-vmm}
 \end{figure}
 
-图 \ref{fig:foreshadow-vmm} 展示了一种情况，一个恶意的虚拟机可以利用瞬
-时执行攻击窃取属于同一处理器核的另一个虚拟机中的数据。这种攻击并不局限
+图 \ref{fig:foreshadow-vmm} 展示了一种情况，一个恶意的虚拟机可以利用暂
+态执行攻击窃取属于同一处理器核的另一个虚拟机中的数据。这种攻击并不局限
 于超线程受害者，因为 Foreshadow-VMM 可以提取处理器物理核心一级数据高速
 缓存中的任何秘密。
 
@@ -307,62 +302,60 @@ Foreshadow 攻击使用在可以直接控制客户机器物理地址和一级缓
 \subsubsection{延迟浮点寄存器状态还原（LazyFP）攻击}
 
 % introduction
-LazyFP\supercite{lazyfp} 是一个 Meltdown 类型的攻击，它可以跨越进程和虚
-拟机的边界，泄露浮点处理单元（FPU）寄存器的状态。这种攻击利用 Intel 处
-理器处理设备不可用异常（\Fault{NM}）的行为。这个异常用于在操作系统中实
-现延迟 FPU 上下文切换的优化。在 LazyFP 攻击中，没有特权的本地执行的代码，
-可以利用 \Fault{NM} 异常的暂态指令，恢复受害者进程的 FPU 寄存器状态。
-由于 AES-NI 的密钥等数据可能存在 FPU 寄存器中，这种攻击导致的数据泄露
-对信息安全是个很大的威胁。
+LazyFP\supercite{lazyfp} 是一个 Meltdown 类型的攻击，它可以跨越进程和
+虚拟机的边界，泄露浮点处理单元（FPU）寄存器的状态。这种攻击利用 Intel
+处理器处理设备不可用异常（\Fault{NM}）的行为。这个异常用于在操作系统中
+实现延迟 FPU 上下文切换的优化。在 LazyFP 攻击中，没有特权的本地执行的
+代码，可以利用 \Fault{NM} 异常产生的暂态指令，恢复受害者进程的 FPU 寄
+存器状态。由于 AES-NI 的密钥等数据可能存在 FPU 寄存器中，这种攻击导致
+的数据泄露对信息安全是个很大的威胁。
 
 % background
 
 x87 浮点单元（FPU）是 x86 的处理器的一个扩展，其最初目的是加速浮点数的
-运算。它有自己的一组指令和寄存器。自 1989 年推出 Intel 486DX 以来，它是
-每个 x86 微处理器不可或缺的一部分，而在此之前，它是一个可选的外部协处理
-器。在上下文切换中，向内存保存 FPU 状态和恢复 FPU 的状态曾经是一个成本
-很高的操作，因为内存速度慢并且大小有限。此外，那时 FPU 只在少数程序中被
-使用。在 FPU 不被所有进程使用的情况下，在每个上下文切换时，切换 FPU 状
-态会产生不必要的开销。为了能够减少这种开销，x86 处理器引入了一个控制寄
-存器位 cr0.ts，允许操作系统打开和关闭FPU，当FPU关闭时，它会保持其状态，
-但用户和内核代码都无法访问。
+运算。它有独立于 x86 处理器的一组指令和寄存器。在 1989 年推出 Intel
+486DX 之前，它是一个可选的外部协处理器，此后成为 x86 微处理器不可或缺
+的一部分。在上下文切换中，向内存保存 FPU 状态，以及从内存恢复 FPU 的状
+态，曾经是一个开销很大的操作，因为内存速度慢并且大小有限。此外，那时
+FPU 只在少数程序中被使用。在 FPU 不被所有进程使用的情况下，在每个上下
+文切换时，切换 FPU 状态会产生不必要的开销。为了能够减少这种开销，x86
+处理器引入了一个控制寄存器位 cr0.ts，允许操作系统打开和关闭FPU，当FPU
+关闭时，它会保持其状态，但用户和内核代码都无法访问。
 
 利用 cr0.ts 实现的优化称为延迟 FPU 上下文切换（lazy FPU context
 switching）。核心思想是 FPU 寄存器状态仅在必要时进行上下文切换，并保留
 在不使用 FPU 的进程中。这样，操作系统可以避免不必要的保存和恢复 FPU 上
 下文的成本。
 
-操作系统跟踪当前 FPU 寄存器状态所属的进程，此进程称为FPU所有者。FPU 可
-以在启用和禁用状态，在 FPU 启用状态下，当前进程是 FPU 所有者，可以自由
-地执行 FPU 指令。当操作系统切换到另一个进程时，FPU 被禁用。在进程尝试执
-行 FPU 指令之前，它将保持禁用状态。由于 FPU 被禁用，使用浮点指令时，处
-理器会生成 \Fault{NM} 异常。操作系统处理 \Fault{NM} 异常的方式取决于当
-前进程是否为FPU 所有者，如果是，则 FPU 寄存器状态属于该进程，操作系统启
-用FPU，该进程再次可以自由执行FPU指令。否则，则操作系统在启用 FPU 的同时，
-将当前FPU 寄存器状态存储到 FPU 所有者进程的状态保存区域，并恢复当前进程
-的FPU 寄存器状态，并将该进程设为 FPU 的所有者。
-
-这个算法在不同操作系统中的实现可能不同，它们的共同点是，使用 FPU 的进程
-切换到不使用 FPU 的进程时，操作系统不需要上下文切换 FPU 寄存器的状态。
-
-虽然延迟 FPU 上下文切换仍然在现代的操作系统中广泛使用，但其基本假设通常
-不再适用。从 Intel MMX 指令集扩展，到后续的 SSE，AVX 和 AVX-512，FPU 寄
-存器状态已经扩展到更大的 SIMD 寄存器。SSE 指令集是 64 位 x86 处理器的必
-须组成部分，并且在几乎所有程序和库中用于实现不同的任务，例如内存复制。
-
-虽然更大的 FPU 寄存器状态使得避免 FPU 上下文切换更具吸引力，但在当前的
-软件中，每个进程最终都会使用 FPU 寄存器并触发 \Fault{NM} 异常。因
-此，Linux 内核已经默认将 FPU 寄存器作为普通上下文切换的一部分进行切换，
-在正常操作中不会生成 \Fault{NM} 异常。
+操作系统跟踪当前 FPU 寄存器状态所属的进程，此进程称为 FPU 所有者。FPU
+可以在启用和禁用状态，在 FPU 启用状态下，当前进程是 FPU 所有者，可以自
+由地执行 FPU 指令。当操作系统切换到另一个进程时，FPU 被禁用。在进程尝
+试执行 FPU 指令之前，它将保持禁用状态。由于 FPU 被禁用，使用浮点指令时，
+处理器会生成 \Fault{NM} 异常。操作系统处理 \Fault{NM} 异常的方式取决于
+当前进程是否为 FPU 所有者，如果是，则 FPU 寄存器状态属于该进程，操作系
+统启用 FPU，该进程再次可以自由执行 FPU 指令。否则，则操作系统在启用
+FPU 的同时，将当前 FPU 寄存器状态存储到 FPU 所有者进程的状态保存区域，
+并恢复当前进程的FPU 寄存器状态，并将该进程设为 FPU 的所有者。这个算法
+在不同操作系统中的实现可能不同，它们的共同点是，使用 FPU 的进程切换到
+不使用 FPU 的进程时，操作系统不需要上下文切换 FPU 寄存器的状态。
+
+虽然延迟 FPU 上下文切换仍然在现代的操作系统中广泛使用，但其基本假设通
+常不再适用。从 Intel MMX 指令集扩展，到后续的 SSE，AVX 和 AVX-512，FPU
+寄存器状态已经扩展到更大的 SIMD 寄存器。SSE 指令集是 64 位 x86 处理器
+的必须组成部分，并且在几乎所有程序和库中用于实现不同的任务，例如内存复
+制。因此，虽然更大的 FPU 寄存器状态使得避免 FPU 上下文切换更具吸引力，
+但在当前的软件中，每个进程最终都会使用 FPU 寄存器并触发 \Fault{NM} 异
+常。因此，Linux 内核已经默认将 FPU 寄存器作为普通上下文切换的一部分进
+行切换，在正常操作中不会生成 \Fault{NM} 异常。
 
 在使用 Intel 的硬件辅助虚拟化技术时，处理器在从客户机切换到管理程序时，
 不会切换FPU寄存器状态。虚拟机管理程序负责上下文切换 FPU 寄存器的状态，
 并且机制与非虚拟化操作系统的机制相同。因此，延迟 FPU 上下文切换也适用于
 虚拟机管理程序。
 
-在使用延迟 FPU 上下文切换的操作系统中，利用 LazyFP 攻击可以使没有特权的
-攻击者获取同一处理器硬件线程中 FPU 寄存器的数据。以下简单的例子可以泄
-露1比特的数据。
+在使用延迟 FPU 上下文切换的操作系统中，利用 LazyFP 攻击可以使没有特权
+的攻击者获取同一处理器硬件线程中 FPU 寄存器的数据。图 \ref{lst:lazyfp}
+的例子可以泄露1比特的数据。
 
 \begin{figure}
   \centering
@@ -376,9 +369,9 @@ mov rax, dword [mem + rax]
 \label{lst:lazyfp}
 \end{figure}
 
-在以上代码片段中，由于进程中 FPU 寄存器被禁用，movq 指令产
-生 \Fault{NM} 异常。操作系统会用对应用程序透明的方式处理该异常，恢复进
-程的状态并继续执行。
+在该代码片段中，由于进程中 FPU 寄存器被禁用，movq 指令产生 \Fault{NM}
+异常。操作系统会用对应用程序透明的方式处理该异常，恢复进程的状态并继续
+执行。
 
 而在处理器结束 movq 指令的执行并产生 \Fault{NM} 之前，已经执行了后续指
 令，虽然最终这些指令引起的体系结构状态更改会被丢弃，但在缓存中的状态仍
@@ -396,63 +389,23 @@ Spectre 型攻击利用处理器对控制流或数据流的预测，并进行推
 暂态指令。Spectre 型攻击中，暂态指令访问的是程序在体系结构层面能访问的
 数据，可以绕过软件定义的安全策略，如边界检查等。
 
-推测式执行的常见形式是控制流的推测式执行。控制流的推测式执行依赖于转移
-预测技术，包含了分支的预测、间接转移目标地址的预测和函数返回地址的预测，
-对应于 Spectre 攻击中 Spectre-PHT, Spectre-BTB, Spectre-RSB. 此外，处
-理器预测装载指令和程序序列之前访问地址未知的存储指令地址不冲突，
-推测式执行这样的装载指令，它对应 Spectre-STL.
-
-%%%% gtran: branch prediction
-
-%% \Todo: 关于处理器执行转移指令的背景知识，是否需要？
-
-%% \Fixme: 需要重新翻译的内容
-
-%% 在推测执行期间，处理器猜测分支指令的可能结果。更好的预测通过增加可成功
-%% 提交的推测性执行操作的数量来提高性能。
-
-%% 现代英特尔处理器的分支预测器，例如Haswell Xeon处理器，具有用于直接和间
-%% 接分支的多种预测机制。间接分支指令可以跳转到在运行时计算的任意目标地址。
-%% 例如，x86指令可以跳转到寄存器，存储器位置或堆栈中的地址，例如“jmp eax”，
-%% “jmp [eax]”和“ret”。 ARM上也支持间接分支（例如，“MOV pc，r14”），MIPS
-%% （例如，“jr \$ ra”），RISC-V（例如，“jalr x0，x1,0”）和其他处理器。与直
-%% 接分支相比，为了补偿额外的灵活性，使用至少两种不同的预测机制来优化间接
-%% 跳转和调用[35]。
+推测式执行的常见形式是控制流的推测式执行。控制流的推测式执行依赖于分支
+预测技术，包含了条件分支的预测、间接转移目标地址的预测和函数返回地址的
+预测，对应于 Spectre 攻击中 Spectre-PHT, Spectre-BTB, Spectre-RSB. 数
+据流的推测式执行也是一种推测式执行的形式，处理器预测装载指令和程序序列
+之前访问地址未知的存储指令地址不冲突，推测式执行这样的装载指令，它对应
+Spectre-STL.
 
-%% 英特尔[35]描述了处理器的预测
-%% •以静态或单调方式进行“直接呼叫和跳转”，
-%% •“间接呼叫和跳转”要么是单调的，要么是以不同的方式，这取决于最近的程序
-%% 行为，以及
-%% •“条件分支”分支目标以及是否将采用分支。
+Spectre 攻击使得受害者程序在暂态指令中执行在严格按序执行时不会执行的操
+作，这些操作会将秘密信息通过隐蔽信道泄露给攻击者。
 
-%% 因此，几个处理器组件用于预测分支的结果。分支目标缓冲区（BTB）保持从最
-%% 近执行的分支指令的地址到目标地址的映射[44]。即使在解码分支指令之前，处
-%% 理器也可以使用BTB来预测未来的代码地址。 Evtyushkin等。 [14]分析了英特
-%% 尔Haswell处理器的BTB，并得出结论，只有31个最低有效位的分支地址用于索引
-%% BTB。
-
-%% 对于条件分支，记录目标地址对于预测分支的结果不是必需的，因为目的地通常
-%% 在指令中被编码，同时在运行时确定条件。为了改进预测，处理器维护分支结果
-%% 的记录，包括最近的直接和间接分支。 Bhattacharya等。 [9]分析了近期英特
-%% 尔处理器中分支历史预测的结构。
-
-%% 尽管返回指令是一种间接分支，但是在现代CPU中经常使用用于预测目标地址的
-%% 单独机制。返回堆栈缓冲区（RSB）维护最近使用的调用堆栈部分的副本[15]。
-%% 如果RSB中没有可用数据，则不同的处理器将停止执行或使用BTB作为回退[15]。
-
-%% 分支预测逻辑（例如，BTB和RSB）通常不在物理核心之间共享[19]。因此，处理
-%% 器仅从在同一核上执行的先前分支学习。
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
-Spectre 攻击使得受害者程序在推测式地执行在严格按序执行的时不会执行的操
-作，这些操作会通过隐蔽信道将秘密信息泄露给攻击者。
-
-Spectre 攻击通常从设置阶段（setup phase）开始，攻击者执行一些用于训练
-处理器的操作，使得处理器在后续阶段执行可被攻击者利用的错误的推测式执行。
-此外，设置阶段中，攻击者可以操作高速缓存状态，从缓存中去除预测的分支所
-依赖的数据，使得推测式执行中的指令足够多，从而可以执行攻击者希望处理器
-执行的指令。在这个阶段，攻击者还可以进行隐蔽信道的准备，如
-Flush+Reload 攻击中清除探测数组对应缓存行的操作。
+Spectre 攻击通常分为三个阶段。第一个阶段是设置阶段（setup phase），攻
+击者执行一些用于训练处理器的操作，使得处理器在后续的阶段中，产生可被攻
+击者利用的错误的推测式执行。此外，在设置阶段中，需要增大推测式执行的窗
+口，使得推测式执行中的指令足够多，从而可以执行攻击者希望处理器执行的指
+令，实现方式包括操作高速缓存状态，从缓存中去除预测的分支所依赖的数据。
+在这个阶段，攻击者还可以进行隐蔽信道的准备，如Flush+Reload 攻击中清除
+探测数组对应缓存行的操作。
 
 在第二个阶段，处理器在推测式执行中，将受害者上下文中的秘密信息，传送至
 微体系结构隐蔽信道。攻击者向受害者通过系统调用等方式发送请求，以出发这个推
@@ -505,23 +458,23 @@ if (x < array1_size)
 
 图\ref{fig:spectre_v1}是边界检查结果和预测的方向的四种组合。在已知边
 界检查的结果之前，处理器预测最可能的结果，推测式地执行边界检查之后的代
-码。导致边界检查的结果不能及时得出的原因很多，如边界检查期间发生缓存缺
+码。有很多原因导致边界检查的结果不能及时得出，如边界检查期间发生缓存缺
 失，缺少空闲的执行单元，存在复杂的数据依赖。在这些情况下，正确预测的可
 以使执行时间更短。
 
 但是，处理器可以在不正确的路径推测式执行指令。在这个例子中，假设攻击者
 可以控制以如下方式运行：
 
-\begin{itemize}
+\begin{enumerate}
 \item 选择一个恶意越界的 \verb|x| 的值，使得 \verb|array1[x]| 指向受害
   者内存中的某个秘密字节 \verb|k|
 \item \verb|array1_size| 和 \verb|array2| 不在缓存中，但 \verb|k| 在缓
   存中
 \item 此前的操作中接收到的 \verb|x| 值均有效，使得分支预测器预测 if 为
   真
-\end{itemize}
+\end{enumerate}
 
-这样的缓存条件可以由攻击者构造，例如，通过构造访问模式造成
+攻击者可以构造这样的缓存条件，例如，通过使用一定的模式访问内存，造成
 \verb|array1_size| 和 \verb|array2| 被驱逐出缓存，再使受害者在合法的操
 作中使用秘密 \verb|k|.
 
@@ -608,11 +561,11 @@ ARM 处理器上进行验证，确认它们受 Spectre v1 的影响。
 %% \verb|TODO|: Spectre v1.1的内容，需要更详细地解释攻击原理
 
 推测式缓冲区溢出（Speculative Buffer Overflow）
-\supercite{spec-buffer-overflow} 是 Spectre-PHT 的另一种形式。处理器存
-在一个存储缓冲区（store buffer），往存储系统写入的数据在指令提交前将写
-入数据的地址和值存放在这个缓冲区中，后续的指令要使用这个地址的值时，可
-以将缓冲区中的数据转发给需要的指令。推测式缓冲区溢出利用了这个特性，例
-如图\ref{lst:spec-buf-overflow}中的程序：
+\supercite{spec-buffer-overflow} 是 Spectre-PHT 的另一种形式，被称为
+Spectre v1.1. 处理器存在一个存储缓冲区（store buffer），往存储系统写入
+的数据在指令提交前将写入数据的地址和值存放在这个缓冲区中，后续的指令要
+使用这个地址的值时，可以将缓冲区中的数据转发给需要的指令。推测式缓冲区
+溢出利用了这个特性，例如图\ref{lst:spec-buf-overflow}中的程序：
 
 \begin{figure}
 \begin{minted}{C}
@@ -635,8 +588,8 @@ if (x < len)
 
 \subsubsection{Spectre-BTB}
 
-Spectre v2 利用间接转移的推测式执行，用于预测间接转移的主要部件是 BTB，
-因此在分类上称为 Spectre-BTB.
+处理器遇到间接转移时，使用 BTB 预测转移的目标地址。Spectre v2 利用间接
+转移的错误推测式执行，这类攻击在分类上称为 Spectre-BTB.
 
 在 Spectre v2 中，攻击者可以对间接转移进行投毒，从而可以利用由此产生的
 转移预测错误，从另一个上下文（如另一进程）中读取任意内存。如果由于缓存
@@ -655,8 +608,7 @@ Spectre v2 利用间接转移的推测式执行，用于预测间接转移的主
 中 A 中训练，在上下文 B 中，转移预测器根据在 A 中的训练结果进行预测，
 导致处理器跳转至攻击者选择的目标地址处进行推测式执行。攻击者可以引导受
 害者推测式执行在正确的程序执行中永远不会执行的位置。由于推测性执行带来
-了可测量的副作用，这种攻击对于攻击者来说及其强大，即使在没有可利用的条
-件分支错误预测的情况下，也可以用它泄露受害者的内存。
+了可测量的副作用，这种攻击对于攻击者来说极其强大。
 
 举一个简单的攻击例子，攻击者试图读取受害者的内存，当发生间接转移时，攻
 击者可以控制两个寄存器。这在现实的二进制程序中很常见，因为操作从外部接
@@ -757,24 +709,21 @@ Spectre v4 利用的是装载指令的推测式执行。处理器执行装载指
 \subsection{NetSpectre}
 
 NetSpectre\supercite{netspectre} 是通过网络进行的 Spectre 攻击，使得
-Spectre 攻击可以用于不运行攻击者控制的代码的系统上，从而更多的设备受到
-Spectre 攻击的影响。
+Spectre 攻击可以用于不运行攻击者控制的代码的系统上，从而将 Spectre 攻
+击的影响扩大至更多的设备。
 
 和本地 Spectre 攻击类似，远程的 Spectre 攻击需要受害者存在 Spectre 组
 件代码，当这些代码可以通过网络接口调用时，攻击者可以向受害者发送一系列
-精心构造的请求，通过测量相应时间，泄露受害者内存中的秘密数据。
+精心构造的请求，通过测量响应时间，泄露受害者内存中的秘密数据。
 
 访问存储器的延迟可以反映在网络请求的延迟中，因此攻击者可以通过大量的测
-量，远程地区分缓存是否命中。因此，通过使用 Thrash+Reload，一种基于
+量，区分远程的机器缓存是否命中。因此，通过使用 Thrash+Reload，一种基于
 Evict+Reload 的远程缓存攻击方式，将 Spectre 攻击用于网络场景，可以每小
 时从目标系统泄露 15 比特数据。通过使用基于 AVX2 指令执行时间的侧信道，
 可以在 NetSpectre 中获得更高的性能，在局域网中可以每小时泄露 60 比特。
 通过使用 NetSpectre 攻击，攻击者可以破坏远程系统中部署的地址空间布局随
 机化（ASLR）防御机制。
 
-NetSpectre 攻击在网络上使用，需要攻击者访问受害者提供的网络接口，并且
-向受害者发送大量网络数据包。这些操作不一定需要在短时间内进行。
-
 在 NetSpectre 攻击中，攻击者需要利用两个 Spectre 组件：泄露组件和传输
 组件，这些组件在收到网络数据包时执行。泄漏组件在攻击者控制的内存地址处
 访问数据，并根据访问的数据改变一些微体系结构状态。传输组件可以进行任意操作，
@@ -798,17 +747,18 @@ if (x < bitstream_length)
 为了在远程攻击中使目标系统在推测式执行中改变微体系结构状态，攻击者采用原始
 Spectre 的方法。为了触发远程系统的推测式执行，攻击者进行以下操作：
 
-\begin{itemize}
+\begin{enumerate}
 \item 攻击者发送多个网络数据包，使得攻击者选择的 x 值总是在边界内，训
   练分支预测器在后续执行此边界检查的分支时，预测 x 在边界内
 \item 攻击者发送一个数据包，使得 x 越界，\verb|bitstream[x]| 是目标系
   统中的一个秘密数据位
 \item 分支预测器预测边界检查结果为真，推测式执行存储器的访问
-\end{itemize}
+\end{enumerate}
 
-在图\ref{fig:netspectre_leak}的代码中，虽然 flag 的值没有被修改，但是
-flag 的缓存状态会发生变化。如果 \verb|bitstream[x]| 为 1,则 flag 会进
-入缓存，通过 flag 的缓存状态，可以推断 \verb|bitstream[x]| 的值。
+在图 \ref{fig:netspectre_leak} 的代码中，当 x 越界时，虽然 flag 的值没
+有被修改，但是 flag 的缓存状态会发生变化。如果 \verb|bitstream[x]| 为
+1,则 flag 会进入缓存，通过 flag 的缓存状态，可以推断
+\verb|bitstream[x]| 的值。
 
 传输组件更简单，它只需要在一个操作中使用 flag，它的执行时间取决于 flag
 的缓存状态，例如，最简单的一个传输组件是直接返回 flag 的值。由于传输组
diff --git a/chap/chap3.tex b/chap/chap3.tex
index 329d223..9e49e95 100644
--- a/chap/chap3.tex
+++ b/chap/chap3.tex
@@ -1,15 +1,15 @@
 \chapter{Meltdown 和 Spectre 攻击的防御方案及分析}\label{sec:defense}
 
 Meltdown 和 Spectre 及其多种变体被发现后，研究者提出了多种减轻这些攻击
-的防御方法，它们需要对软件或硬件进行修改。
+的软硬件防御方法。本章讨论并分析已有的防御方法。
 
 \section{Meltdown型攻击的防御}
 
-Meltdown型攻击利用了暂态指令可以读取体系结构层次上不可访问的数据，并且
+Meltdown 型攻击利用了暂态指令可以读取体系结构层次上不可访问的数据，并且
 用此数据做计算。因此一种防御方式是使体系结构层次上不可访问的数据，在微
 架构层次上仍然不可访问。
 
-KAISER\supercite{kaiser}是一种已经部署在 Linux 内核上的一种防御
+KAISER\supercite{kaiser} 是一种已经部署在 Linux 内核上的一种防御
 Meltdown 攻击的方案。它的作用是在用户空间中去除内核空间的地址映射，使
 得用户空间的执行的指令无法访问内核空间的存储区域。
 
@@ -30,9 +30,9 @@ Intel 和 AMD 都提出了在分支指令后插入 lfence 指令阻止推测式�
 为一条串行化指令使用，可以在 lfence 指令提交前阻止新的指令执行，从而阻
 止了程序在推测式执行中对秘密数据进行操作。
 
-由于 lfence 性能开销大，LLVM提出推测式装载指令加固（Speculative
-Load Hardening）\supercite{spec-load-hardening} 技术，它的做法是将可能
-为 Spectre 组件的代码转为图\ref{fig:SLH}中的代码。
+由于 lfence 性能开销大，LLVM 提出推测式装载加固（Speculative Load
+  Hardening）\supercite{spec-load-hardening} 技术，它的做法是将可能为
+Spectre 组件的代码转为图 \ref{fig:SLH} 中的代码。
 
 \begin{figure}[htbp]
   \centering
@@ -56,9 +56,9 @@ Load Hardening）\supercite{spec-load-hardening} 技术，它的做法是将可�
 \label{fig:SLH}
 \end{figure}
 
-产生的代码在两个分支中，都计算一个分支条件的状态，并将其作为存储访问指
-令或泄露数据指令的一个数据依赖，从而在得出分支结果之前，无法访问或泄露
-一个秘密数据。
+在产生的代码中，一个条件分支的两个分支中，都计算一个分支条件的状态，并
+将其作为存储访问指令或泄露数据指令的一个数据依赖，从而在得出分支结果之
+前，无法访问或泄露一个秘密数据。
 
 retpoline\supercite{retpoline} 是 Google 提出的防御 Spectre-BTB 的方法。
 它的作用是把程序中的间接转移指令修改为一个指令序列，最终使用 ret 指令
@@ -111,6 +111,9 @@ Google 为 Chrome 浏览器使用了站点隔离（site isolation）技术，使
 
 \subsection{硬件防御方案}
 
+由于软件防御方案可防御的攻击类型有限，并且性能开销大，因此研究人员提出
+了多种硬件防御方案。
+
 \subsubsection{SafeSpec}
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% gtran %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -168,7 +171,7 @@ SafeSpec 防止推测式执行的产生的值影响提交状态，从而阻止�
 SafeSpec 原则可以用于在推测式执行中保护缓存和 TLB，方法是在处理器中加
 入以下影子结构：
 
-\begin{itemize}
+\begin{enumerate}
 \item 数据缓存：在已有的 Spectre 攻击中都用到了数据缓存作为隐蔽信道。
   它的影子结构保存了推测式执行中获取的缓存行。在装载/存储队列中，将获
   得了数据的推测式执行的装载指令指向影子结构的对应项，在同一个分支下访
@@ -183,7 +186,7 @@ SafeSpec 原则可以用于在推测式执行中保护缓存和 TLB，方法是�
   时，页表项也会带入数据缓存，这个过程也使用装载存储队列，因此数据缓存
   的保护足够保护这个过程。因此对 TLB 的保护只需要添加 TLB 本身的影子结
   构。
-\end{itemize}
+\end{enumerate}
 
 使用 MARSSx86 模拟上述 SafeSpec 模型，可以发现运行 SPEC2017 有平均 3\%
 的性能提升。性能提升的原因是影子结构增大了有效缓存的容量，避免了错误推
@@ -247,13 +250,13 @@ InvisiSpec 在不同的内存一致性模型下，会使用不同的执行策略
 可以导致内存一致性违例，此时处理器需要用恢复机制重新执行这个装载指令及
 其后的指令。
 
-TSO（Total Store Order）是 x86 体系结构所用的内存模型。TSO 允许一个装载
-操作在不同地址的存储操作之前完成，除此之外禁止所有可见的装载和存储的重
-排序。在实现中，为了防止可见的装载指令的重排序，需要确保一个装载操作读
-入的数据，在提交时仍然有效。如果处理器核遇到一个外部的缓存失效请求，则
-需要重新执行这个装载操作。存储指令的顺序由先入先出的写缓冲区保证。
-
-RC（Release Consistency）则允许任何访存操作的重排序，除非使用同步指令。
+常见的内存模型有 TSO（Total Store Order） 和 RC （Release Consistency）。
+TSO 是 x86 体系结构所用的内存模型。TSO 允许一个装载操作在不同地址的存
+储操作之前完成，除此之外禁止所有可见的装载和存储的重排序。在实现中，为
+了防止可见的装载指令的重排序，需要确保一个装载操作读入的数据，在提交时
+仍然有效。如果处理器核遇到一个外部的缓存失效请求，则需要重新执行这个装
+载操作。存储指令的顺序由先入先出的写缓冲区保证。RC 则允许同步指令之外
+的任何访存操作的重排序。
 
 InvisiSpec 关注不安全的推测式执行的装载指令（Unsafe Speculative
 Load，USL），在 Spectre 的攻击模型中，USL 是在未决分支之后的装载指令，
@@ -274,7 +277,7 @@ Point），这时其他线程可以看到这个操作在存储系统中的效果
 
 USL 请求的缓存行在 USL 发射时有可能已经在一级缓存中，这个缓存行也被载
 入推测式执行缓冲区。处理器可能接收对这一行的失效请求，但是 USL 会忽视
-这个请求，这个失效请求的效果的会在可见时间点处理。
+这个请求，这个失效请求的效果会在可见时间点处理。
 
 %\Todo: InvisiSpec  V: INVISISPEC: THWARTING SPECULATION ATTACKS
 
@@ -294,10 +297,11 @@ USL 请求的缓存行在 USL 发射时有可能已经在一级缓存中，这�
 
 %当USL发布并且线路加载到SB时，USL请求的线路可能已经在核心的L1缓存中。在这种情况下，核心可能会收到该行的无效。但是，USL忽略了这种失效，因为USL是不可见的，并且这种失效的任何影响都将在可见点处理。
 
-在可见时间点重新装载数据，有两种操作形式：验证（Validation）和曝光
-（Exposure）。验证操作将 USL 用到的数据，和存储系统中这些数据的最新的值
-做比较，如果不相同，USL 和其后的所有指令都需要重新执行。这个操作用于满
-足内存一致性模型，方法类似于基于值的内存保序方法。\supercite{cain-lapasti}
+在可见时间点重新装载数据，有两种操作形式。第一种方式是验证
+（Validation），它将 USL 用到的数据，和存储系统中这些数据的最新的值做
+比较，如果不相同，USL 和其后的所有指令都需要重新执行。这个操作用于满足
+内存一致性模型，方法类似于基于值的内存保序方法。
+\supercite{cain-lapasti}
 
 %如果在该窗口期间，核心已经收到USL加载的行的无效，则验证是在可抑制可见性窗口期间（由于内存一致性考虑）使可见的USL可见的方法。验证操作包括将USL使用的实际字节（存储在SB中）与从缓存层次结构加载的最新值进行比较。如果它们不相同，USL及其所有连续指令都会被压扁。这是满足内存一致性模型所必需的。这一步让人想起Cain和Lipasti的基于价值的记忆排序[31]。
 
@@ -305,9 +309,10 @@ USL 在验证阶段不能提交，需要等待验证结束，在这个时间段�
 取缓存行并写入缓存，比较推测式执行缓冲区和读入的缓存行中，USL 所要使用
 的数据。如果 USL 在 ROB 队头并且 ROB 已满，会导致流水线停顿。
 
-InvisiSpec 可以识别很多在 USL 可见之前，不会违反内存一致性模型的 USL，
-并对它们使用开销较低的曝光操作。这个操作只需要将读取到的一行数据存入缓
-存，当请求发送至存储系统后，指令即可提交，从而不会使流水线停顿。
+为了降低验证操作的开销，对部分 USL，InvisiSpec 使用另一种操作，称为曝
+光（Exposure），它用于在 USL 可见之前，不会违反内存一致性模型的 USL。
+这个操作只需要将读取到的一行数据存入缓存，当请求发送至存储系统后，指令
+即可提交，从而不会使流水线停顿。
 
 %值得庆幸的是，InvisiSpec识别出许多在其抑制可见性窗口期间无法违反内存一致性模型的USL，并允许它们以廉价的曝光可见。 如果在该窗口期间核心已经收到USL加载的行的无效，则这些USL在禁用可见性窗口期间不会被内存一致性模型压扁。 在曝光中，缓存层次结构返回的行只是存储在缓存中而不进行比较。 一旦将行请求发送到缓存层次结构，持续曝光的USL就会退出。 因此，USL不会阻止管道。
 
@@ -318,7 +323,7 @@ InvisiSpec 可以识别很多在 USL 可见之前，不会违反内存一致性�
 %当可以使USL可见时，并且总是在它收到其请求的高速缓存行之后，硬件触发验证或暴露事务。这样的事务再次重新请求该行，这次修改缓存层次结构，并将该行带到本地缓存。如第V-A4部分所述，验证和暴露交易的运作方式不同，并且具有不同的性能影响。
 
 InvisiSpec 针对 Spectre 和 Futuristic 两种攻击模型的设计略有不同。对
-于 Spectre 攻击模型，USL 在此前所有的控制流指令得出结果后，则进入可见时
+于 Spectre 攻击模型，USL 在此前所有的控制指令得出结果后，则进入可见时
 间点，此时处理器可以为这个指令执行验证或曝光操作。同时这些验证和曝光操
 作在时间上可以重叠。
 
@@ -335,11 +340,12 @@ InvisiSpec 针对 Spectre 和 Futuristic 两种攻击模型的设计略有不同
 %我们将这些设计称为InvisiSpec-Spectre（或IS-Spectre）和InvisiSpec-Future（或IS-Future）。它们显示在表II的第一行中。为了进行比较，第二行显示了如何使用基于栅栏的方法防御这些相同的攻击 - 遵循当前提出的防御幽灵的建议[32]。我们将这些设计称为Fence-Spectre和Fence- Future。前者在每个间接或有条件的分支后放置围栏;后者在每次装载前放置围栏。
 
 和基于 fence 的方法相比，InvisiSpec 性能更优，因为和传统的不安全的机器
-相比，装载指令执行的时间不变。通过将更多的验证操作转化为曝光操作，可以
-减少流水线的停顿。最后一个问题是，InvisiSpec 会在存储系统中产生更大的
-流量和缓存端口的竞争。
+相比，装载指令执行的时间不变。InvisiSpec 有几个影响性能的问题。一个是
+验证操作造成的流水线停顿，通过将更多的验证操作转化为曝光操作，可以减少
+流水线的停顿。另一个问题是，InvisiSpec 会在存储系统中产生更大的流量和
+缓存端口的竞争。
 
-对于 TSO 内存模型，如果一个装载指令之前不存在更老的装载指令或者 fence，
+对于 TSO 内存模型，如果一个装载指令之前不存在更早的装载指令或者 fence，
 则它不会被对它读取的行的失效请求取消，因此，这些 USL 在可见时间点可以使
 用曝光操作。相反，如果一个 USL 之前有其他的装载指令，则需要执行验证操
 作。而对于 RC 模型，只有在 USL 之前有 fence 的情况下，才需要执行验证操
@@ -359,17 +365,14 @@ InvisiSpec 针对 Spectre 和 Futuristic 两种攻击模型的设计略有不同
 一个 USL 执行两个内存访问，一个在首次发射的时候，另一个在验证或曝光的
 时候。如果第一个访问在末级缓存缺失并访问主存，则第二个访问也很可能访问
 主存。
-
 为了提高性能，InvisiSpec 为每个核添加一个末级缓存推测式执行缓冲区
 （LLC-SB），USL 的第一个访问如果来自主存，则将获取的一行同时放入LLC-SB，
 此后在验证时，就可以从 LLC-SB 获取数据，而无需访问主存。而在另一个核访
 问了这一行时，为了防止 LLC-SB 获取过时的数据，才需要使 LLC-SB 中的这一
 行失效，验证和曝光操作将会从存储系统中存有最新数据的地方获取数据。
 
-%%%%%%%%%%%%%%%%%%% 
-
 在 gem5 模拟器下， 使用 SPEC CPU2006 和 PARSEC 对 InvisiSpec 进行评测，
-以 Spectre 为威胁模型，在 TSO 内存模型下，InvisiSpec 平均性能损失为
+在 TSO 内存模型下，以 Spectre 为威胁模型，InvisiSpec 平均性能损失为
 21\%，而使用 fence 性能下降 74\%.
 
 InvisiSpec 的性能开销来源于三个方面，一个是验证导致的流水线停顿，在大
@@ -384,7 +387,7 @@ InvisiSpec 会增大存储系统中各个缓存之间，和缓存和主存之间
 
 隐蔽信道是在已有的保护机制下，在不允许通信的进程之间传输信息的信道。例
 如，当侧信道用于向攻击者传送秘密数据时，这种攻击包含一段在受害者保护域
-内执行的代码，用于访问秘密数据，和一个发送器，用于将秘密传递给攻击者。
+内执行的代码，用于访问秘密数据，以及一个传送器，用于将秘密传递给攻击者。
 这些部分构成了一个数据通道，它基于秘密信息调制这个信道。由攻击者控制，
 并在受害者保护域之外的接收器，可以监听信道上的信号，并对其进行解码以确
 定该秘密。图\ref{fig:dawg-schema}描述了这种攻击模式。
@@ -396,31 +399,32 @@ InvisiSpec 会增大存储系统中各个缓存之间，和缓存和主存之间
   \label{fig:dawg-schema}
 \end{figure}
 
-经典的对 RSA 的攻击中，代码使用了一段依赖于秘密的执行序列，将私密信息通
-过执行序列传送到了指令缓存状态中，这造成了一个攻击者可以推断秘密数据的
-隐蔽信道。在这种情况中，访问秘密数据和传送秘密数据的代码均在已有的 RSA
-代码中。共享指令缓存的攻击者可以用一个接收器解码来自缓存信道的信息。
+经典的对 RSA 的攻击\supercite{RemoteTA}中，代码使用了一段依赖于秘密的
+执行序列，将私密信息通过执行序列传送到了指令缓存状态中，这造成了一个攻
+击者可以推断秘密数据的隐蔽信道。在这种情况中，访问秘密数据和传送秘密数
+据的代码均在已有的 RSA代码中。共享指令缓存的攻击者可以用一个接收器解码
+来自缓存信道的信息。
 
 Meltdown 和 Spectre 提供了新了构造数据通道的方式。通过利用错误的推测式
 执行，攻击者可以使处理器执行通常无法访问的代码路径。在 Meltdown 中，攻
 击者推测式执行一段代码，作为数据通道，它可以非法访问秘密数据，并在异常
 发生之前通过微体系结构副作用传输至接受者。在 Spectre 中，攻击者使分支预测器
-预测错误，使处理器沿着攻击者选择的路径推测式执行，这在受害者中形成了数
+预测错误，使处理器沿着攻击者选择的路径进行推测式执行，在受害者中形成了数
 据通道。因此，构建数据通道有三种方法：
 
-\begin{itemize}
+\begin{enumerate}
 \item 数据通道在受害者的代码中已经存在，例如对 RSA 的攻击
 \item 攻击者编写了这个数据通道，如 Meltdown
-\item 攻击者从受害者已有的代码中合成数据通道
-\end{itemize}
+\item 攻击者从受害者已有的代码中合成数据通道，如 Spectre
+\end{enumerate}
 
-这个框架可以用于除缓存状态之外的侧通道，描述通过分支预测器或 TLB 状态造
+这个框架可以用于描述除缓存状态之外的侧通道，例如通过分支预测器或 TLB 状态造
 成的数据泄露。在未来，可能有更多种类的构造数据通道的方法。
 
 DAWG（Dynamically Allocated Way Guard）\supercite{dawg} 是利用保护域之
-间的强隔离防止数据提取的方法，它阻止了任何一对发送器/接收器共享相同的信
+间的强隔离防止数据被攻击者提取的方法，它阻止了任何一对传送器/接收器共享相同的信
 道。这是一种用于缓存等组相联结构设计的的安全路划分机制。DAWG 为组相联的
-结构添加保护域信息，以提供强隔离。和 Intel CAT 不同，DAWG 不允许跨保护
+结构添加保护域信息，以提供强隔离。和 Intel CAT \supercite{IntelCAT}不同，DAWG 不允许跨保护
 域发生缓存命中。
 
 DAWG 的目标是阻止任何攻击者和受害者安全域之间的基于缓存的信道。实现方
@@ -429,7 +433,7 @@ DAWG 的目标是阻止任何攻击者和受害者安全域之间的基于缓存
 
 \begin{figure}[htbp]
   \centering
-  \includegraphics[width=0.8\textwidth]{dawg-cache.pdf}
+  \includegraphics[width=0.6\textwidth]{dawg-cache.pdf}
   \caption{DAWG 缓存设计\supercite{dawg}}
   \label{fig:dawg-cache}
 \end{figure}
@@ -485,36 +489,20 @@ Decoding (CSD)\supercite{context-sensitive-decoding}，一种微码翻译机制
 的扩展，用于动态按需自定义微操作指令流。CSF 利用 CSD，在微指令流中注入
 fence 等微码，阻止不安全指令的推测式执行。
 
-CSD 是一种根据执行上下文，把指令翻译为不同的自定义的微码的技术。操作系
+CSD 是一种根据执行上下文，把指令翻译为不同的自定义微码的技术。操作系
 统、运行时系统等软件可以通过配置 MSR，设定不同的微码翻译模式。它可以在
-不重新编译的情况下，使不安全的程序变为安全的程序，把优化性能的代码变为
-功耗优化的代码。系统软件可以利用已有的微码更新功能将自定义的微码更新至
-寄存器。CSD 可以通过多种事件触发自定义微码翻译模式。
+不重新编译的情况下，使不安全的程序变为安全的程序，把面向性能优化的代码变为
+面向功耗优化的代码。系统软件可以利用已有的微码更新功能将自定义的微码更新至
+处理器中。CSD 可以通过多种事件触发自定义微码翻译模式。
 
 CSF 由以下几个关键部件组成：
-\begin{itemize}
+\begin{enumerate}
 \item 微码自定义机制 CSD：使处理器精确地在指令流中插入 fence，减轻推测
   式执行中不期望的副作用
 \item 译码级信息流追踪（DLIFT）框架：用于检测潜在不安全的执行模式，触
   发微码自定义机制
 \item 错误训练防御：用于保护分支预测器、返回地址栈等部件
-\end{itemize}
-
-为了降低 fence 的性能开销，CSF 还提出了3种新的用于防
-御 Spectre 的 fence. 在 fence 操作的设计上有以下考虑：
-
-\begin{itemize}
-\item 作用位置：x86 的 lfence 作用在指令队列阶段，使得后续的指令
-  在lfence 提交前无法进入指令队列后的流水线结构。fence 作用在更晚的阶段
-  的结构，可以减少 fence 对性能的影响，而保护的侧信道更少。
-\item 严格和宽松的 fence：严格的 fence 会阻止所有指令越过 fence，而宽松
-  的 fence 允许某些指令越过它们。例如 lfence 是个严格
-  的 fence，而 sfence 允许存储指令之外的指令越过 fence，是个宽松
-  的 fence.
-\end{itemize}
-
-表 \ref{tab:csffence} 是 CSF 定义的三种 fence，它们防御的 Spectre 变体
-有所不同。
+\end{enumerate}
 
 \begin{table}
   \centering
@@ -534,29 +522,40 @@ CFENCE & 缓存控制器 & 宽松 & 无 & v1\tabularnewline
 \centering
 \end{table}
 
+为了降低 fence 的性能开销，CSF 还提出了3种新的用于防御 Spectre 的
+fence. 表 \ref{tab:csffence} 列出了它们的特性和防御的攻击种类。在
+fence 操作的设计上有以下考虑：
+
+\begin{enumerate}
+\item 作用位置：x86 的 lfence 作用在指令队列阶段，使得后续的指令
+  在lfence 提交前无法进入指令队列后的流水线结构。fence 作用在更晚的阶段
+  的结构，可以减少 fence 对性能的影响，而保护的侧信道更少。
+\item 严格和宽松的 fence：严格的 fence 会阻止所有指令越过 fence，而宽松
+  的 fence 允许某些指令越过它们。例如 lfence 是个严格
+  的 fence，而 sfence 允许存储指令之外的指令越过 fence，是个宽松
+  的 fence.
+\end{enumerate}
 
-CSF 防御 Spectre 的开销在 8\% 以下。
+使用 CSF 和自定义的 fence，防御 Spectre 的开销在 8\% 以下。
 
 \subsubsection{Conditional Speculation}
 
-Conditional Speculation \supercite{conditional-speculation} 是一种检测
-推测式执行中的潜在的泄露数据的访存指令，并阻止其执行的方法。为了检测可
-能在推测式执行中泄露数据的指令，此工作提出安全依赖（security
-dependence）的概念，类似于数据依赖和控制依赖，这种新的依赖性用于描述泄
-漏微体系结构信息具有潜在安全风险的推测性执行的指令。对于信道 $c$，指令 $j$
-安全依赖于指令 $i$，如果：
+条件推测式执行（Conditional Speculation）
+\supercite{conditional-speculation} 是一种检测推测式执行中的潜在的泄露
+数据的指令，并阻止其执行的方法。为了检测可能在推测式执行中泄露数据的指
+令，此工作提出安全依赖（security dependence）的概念，类似于数据依赖和
+控制依赖，执行存在安全依赖的指令则产生安全冒险。这种新的依赖用于描述具
+有潜在的泄漏微体系结构信息的安全风险的推测性执行的指令。对于信道 $c$，
+指令 $j$ 安全依赖于指令 $i$，如果：
 
-\begin{itemize}
+\begin{enumerate}
 \item 在程序序列中，指令 $j$ 在 $i$ 之前
 \item $j$ 在 $i$ 之前推测式地执行，并且 $j$ 会通过信道 $c$ 泄露数据
-\end{itemize}
+\end{enumerate}
 
 因为信息可以从多种信道上泄露，所以安全依赖的定义指定了某种信道。针对缓
 存信道，如果指令 $j$ 不修改缓存的内容，则它对于缓存信道不具有安全依赖，
-尽管它可能会泄露某些信息。
-
-根据以上定义，表\ref{tab:secdep}总结了 Spectre 攻击中的主要的安全依赖。
-Spectre 攻击的安全依赖性来自两种情况，访存-访存推测和分支-访存推测。
+尽管它可能会通过其他信道泄露某些信息。
 
 \begin{table}
   \centering
@@ -579,11 +578,10 @@ SpectrePrime & 条件分支 & 访存\tabularnewline
 \centering
 \end{table}
 
+根据以上定义，表 \ref{tab:secdep} 总结了 Spectre 攻击中的主要的安全依赖。
+Spectre 攻击的安全依赖性来自两种情况，分支-访存依赖和访存-访存依赖。
 在条件推测式执行的流水线中，在发射队列中引入了安全冒险检测，以识别具有
-安全依赖的可疑的不安全指令。只要在执行阶段确认了真正的冒险，那些不安全
-的推测式执行将会使用现有的重执行和推测式执行恢复机制终止并丢弃。
-
-% the following is from gtran
+安全依赖的可疑的不安全指令。
 
 \begin{figure}[htbp]
   \centering
@@ -592,9 +590,10 @@ SpectrePrime & 条件分支 & 访存\tabularnewline
   \label{fig:cond-spec}
 \end{figure}
 
-安全冒险的检测逻辑用一个矩阵实现。处理器中通常用矩阵跟踪数据依赖，而在
-安全检测中，处理器使用安全依赖矩阵确定要发射的指令是否存在安全相关。添
-加了安全依赖矩阵的发射阶段如图\ref{fig:cond-spec}所示。
+安全冒险的检测逻辑用一个矩阵实现。处理器中通常用矩阵跟踪数据依赖和指令
+的年龄信息，而用于安全检测时，处理器使用安全依赖矩阵确定要发射的指令是
+否存在安全依赖。图 \ref{fig:cond-spec} 展示了一个使用矩阵跟踪数据依赖
+和指令年龄信息，并加入安全依赖矩阵检测安全冒险的发射阶段。
 
 安全依赖矩阵是一个 NxN 比特的数组，其中 N 为发射队列大小，用发射队列的
 位置索引。对于指令队列中位置为 X, Y 的指令，如果该矩阵 Matrix 的位
@@ -618,40 +617,41 @@ Matrix[X,Y] {}={} & (IQ[X].opcode == Memory) \\
 在实现中，图\ref{fig:cond-spec}展示了发射队列的三个阶段。第一阶段中，数
 据依赖矩阵生成一个依赖向量；第二阶段中，该向量发送至年龄矩阵，用于选择
 最老的可发射的指令；在第三阶段，处理器将被选择要发射的指令放进安全依赖
-矩阵，查询它们的安全相关性。当一个将要发射的指令存在安全冒险时，它会被
-标上可疑推测式执行(\emph{suspect speculation})标记。
+矩阵，查询它们的安全依赖性。当一个将要发射的指令存在安全冒险时，它会被
+标上\emph{可疑推测式执行(suspect speculation)}标记。
 
-在指令 X 发射后，更新向量寄存器中的对应位设为0，在下一周期，依赖矩阵中
-X 对应的一列将会重置，意味着待发射指令和 X 的之间的安全相关被清除。
+在指令 X 发射后，更新向量寄存器（update-vector）中的对应位设为0，在下
+一周期，依赖矩阵中X 对应的一列将会重置，意味着待发射指令和 X 的之间的
+安全相关被清除。
 
 一种简单的冒险消除方式是阻止发射队列中标记了可疑推测式执行指令的执行，
 但是这种策略会导致性能下降。为了实现性能，安全性和透明性的平衡，条件推
-测式执行提出了两种过滤机制，以找出错误识别的安全安全冒险。基于缓存命中
-的冒险过滤器针对命中缓存的推测式执行指令。因为它们的推测式执行不会改变
-缓存的内容，所以它们是安全的。另一个提出的过滤器，基于可信页面缓冲区
+测式执行提出了两种过滤机制，以找出错误识别的安全冒险。基于缓存命中
+的冒险过滤器针对命中缓存的推测式执行指令，因为它们的推测式执行不会改变
+缓存的内容，所以它们是安全的。基于可信页面缓冲区
 （Trusted Page Buffer, TPBuf）的冒险过滤器，从另一个角度识别安全的推测
 推测式执行的指令。对于使用基于共享内存（例如 Flush+Reload）的缓存侧通道
-攻击窃取内存信息的 Spectre 变体，他们对恶意组件的推测式执行具有名
-为 S-Pattern 的共同特征。 TPBuf 从所有推测式执行中捕获 S-Pattern，对于
-任何推测式执行的访存指令，如果它与 S-Pattern 不匹配，则被认为是安全的。
+攻击窃取内存信息的 Spectre 变体，他们对恶意组件的推测式执行具有称
+为\emph{S-模式}的共同特征。 TPBuf 从所有推测式执行中捕获S-模式，对于
+任何推测式执行的访存指令，如果它与S-模式不匹配，则被认为是安全的。
 
 % hit-based
 
-考虑到大多数程序有良好的时间局部性和空间局部性，一级缓存命中的访存请求
+考虑到大多数程序有良好的时间局部性和空间局部性，并且一级缓存命中的访存请求
 不会修改缓存的内容，因此可以使用基于缓存命中的冒险过滤器，以减少阻止可
 疑推测式执行的指令造成的性能损失。只要访存指令的访问命中一级缓存，则该
 指令正常执行，但是如果缓存缺失，则该指令将会重新回到发射队列，直到安全
-依赖得到解决，才可疑重新发射。这个过滤器只需要对一级缓存的控制逻辑做少
-量修改，即不处理标记为可疑推测式执行的访存请求。
+依赖得到解决，才可以重新发射。这个过滤器只需要对一级缓存的控制逻辑做少
+量修改，即不处理标记为可疑推测式执行，并且不命中的访存请求。
 
 % TPBuf
 如果一个程序的一级缓存命中率低，则基于缓存命中的冒险过滤器仍然会阻止大
 量的推测式执行。对于利用共享内存构造侧信道的 Spectre 攻击方式，并非所有
-的一级缓存缺失都可作为隐蔽信道使用。因此可以使用基于可信页面缓冲区的冒
+的一级缓存缺失都可作为隐蔽信道使用。因此可以使用基于 TPBuf 的冒
 险过滤器，检测这些指令中安全的指令。在这些攻击中，Spectre 组件的执行中
 包含两个特殊的访存指令，记为 A 和 B，它们有如下的行为：
 
-\begin{itemize}
+\begin{enumerate}
 \item A 推测式地访问敏感数据，B 推测式地访问攻击者和受害者共享的内存区
   域，用于构造受害者和攻击者之间的侧信道。通常秘密数据的内存区域和用于
   构造侧信道的共享内存区域在不同的内存页，因此它们访问不同的页。
@@ -659,19 +659,19 @@ X 对应的一列将会重置，意味着待发射指令和 X 的之间的安全
   器推测式执行中访问 B 造成缓存缺失，重新将缓存行载入一级缓存，攻击者
   再探测共享内存的缓存行发现这一变化。因此要通过缓存侧信道泄露信息，需
   要 B 在缓存中不命中。
-\item 指令 B 依赖于指令 A，A的结果用于计算共享内存区域的索引。这种设计
-  也是攻击者推断处秘密数据要点。
-\end{itemize}
+\item 指令 B 依赖于指令 A，A的结果用于计算共享内存区域的索引。这个特性
+  也是攻击者推断出秘密数据的要求。
+\end{enumerate}
 
 在 TPBuf 过滤器中，以上行为模式称为 S-pattern. 如果观察到推测式执行的
 指令序列具有以下特征，则认为它具有 S-pattern:
 
-\begin{itemize}
+\begin{enumerate}
 \item 至少有两个指令 A 和 B 访问不同的内存页
 \item 指令 B 导致一级缓存缺失
 \item B 依赖于 A
 \item A 和 B 之间可能有多个指令
-\end{itemize}
+\end{enumerate}
 
 TPBuf 它记录了所有推测式的存储器访问请求，当一个新的请求在一级缓存中缺
 失时，其页地址将会和 TPBuf 中其他访问的页地址比较，如果有至少一个访问访
@@ -679,13 +679,13 @@ TPBuf 它记录了所有推测式的存储器访问请求，当一个新的请�
 
 \begin{figure}[htbp]
   \centering
-  \includegraphics[width=0.8\textwidth]{tpbuf.eps}
+  \includegraphics[width=0.6\textwidth]{tpbuf.eps}
   \caption{TPBuf 的结构\supercite{conditional-speculation}}
   \label{fig:tpbuf}
 \end{figure}
 
 
-TPBuf 的结构如图\ref{fig:tpbuf}所示。TPBuf 的条目和 LSQ 的条目一一对应，
+TPBuf 的结构如图 \ref{fig:tpbuf} 所示。TPBuf 的条目和装载存储队列（LSQ）的条目一一对应，
 它的条目分配、提交等操作和 LSQ 一起进行。TPBuf 包含了所有进行中的推测式
 的访存指令。为了避免攻击者访问未授权的数据，并将其传播到自己的地址空间，
 需要先用 TLB 获得访问的物理地址，将其写入 TPBuf 中该访问对应的一
@@ -720,11 +720,11 @@ Spectre 攻击需要分为三个步骤：从存储系统装载秘密数据，将
 也不会泄露给攻击者。
 
 因此，SpectreGuard 允许第一步发生，但将第二步延迟至装载秘密数据的指令
-之前所有分支均已解决。并且，在经过软件标记之后，第一步中仅当数据在敏感
+之前所有分支均已解决。并且，在经过软件标记之后，第一步中装载的数据仅当在敏感
 内存区域时，才需要延迟转发。当秘密数据不经常访问时，总体开销可以忽略。
 
 敏感数据的标记通过在页表中添加一个位实现，在软件中可以扩展操作系统
-的mmap, mprotect 等接口，或通过运行库、编译器、连接器实现。在微体系结构中，
+的mmap, mprotect 等接口，或通过运行库、编译器、链接器实现。在微体系结构中，
 指令执行后，执行结果将转发至后续依赖于这个指令的指令，而如果指令是访问
 了敏感区域的指令，则推迟它的转发。
 
@@ -742,18 +742,18 @@ Spectre 攻击需要分为三个步骤：从存储系统装载秘密数据，将
 % 
 %   Data Oblivious ISA(OISA)是一种 ISA 扩展，用于阻止信息通过侧信道泄露。
 %   设计原则：
-%   \begin{itemize}
+%   \begin{enumerate}
 %   \item ISA的安全性和微体系结构无关
 %   \item ISA不会阻止现代微处理器的优化技术
-%   \end{itemize}
+%   \end{enumerate}
 % 
 %   OISA有以下组件：
-%   \begin{itemize}
+%   \begin{enumerate}
 %   \item 动态跟踪敏感数据：使用DIFT跟踪程序运行时私密数据在处理器中的传
 %     播。所有数据都有 confidential/public 标记，标签在读取操作数时必须
 %     解析
 %   \item 指令定义操作数可以接受 public 还是 public/confidential 数据
-%   \end{itemize}
+%   \end{enumerate}
 % \end{comment}
 % 
 % % vim:ts=4:sw=4
diff --git a/chap/chap6.tex b/chap/chap6.tex
index 2b40f0d..cedcc8b 100644
--- a/chap/chap6.tex
+++ b/chap/chap6.tex
@@ -10,7 +10,7 @@
 升，是一个值得研究的问题。只通过软件的修改难以防御多种类型的 Spectre
 攻击，因此需要通过改进微架构的设计，以解决 Spectre 攻击的问题。本文主
 要工作如下：
-\begin{itemize}
+\begin{enumerate}
 \item 首先调研已有的 Meltdown 和 Spectre 的攻击变体，包括
   对 Meltdown 和 Spectre 的分类，各类攻击的原理，和它们的利用方式。
 \item 调研已有的 Meltdown 和 Spectre 的防御方法，包括软件防御、硬件防御
@@ -25,7 +25,7 @@
   的性能开销，使用 SPEC CPU2006 评测了这种微架构的性能，和原有的不安全
   的处理器相比，性能开销为 8.5\%，优于只用 InvisiSpec 执行推测式执行的
   指令或阻止检测出的不安全指令的方法。
-\end{itemize}
+\end{enumerate}
 
 \section{未来工作展望}
 
diff --git a/thesis.bib b/thesis.bib
index ddcbddb..8e6929a 100644
--- a/thesis.bib
+++ b/thesis.bib
@@ -846,4 +846,23 @@ This thesis highlights two aspects of the BOOM design: its industry-competitive
 	type = {OL},
 }
 
+@article{RemoteTA,
+  title={Remote Timing Attacks Are Practical},
+  author={David Brumley and Dan Boneh},
+  journal={Computer Networks},
+  year={2003},
+  volume={48},
+  pages={701-716},
+  type = {J},
+}
+
+@article{IntelCAT,
+  title={Cache QoS: From concept to reality in the Intel® Xeon® processor E5-2600 v3 product family},
+  author={Andrew Herdrich and Edwin Verplanke and Priya Autee and Ramesh Illikkal and Chris Gianos and Ronak Singhal and Ravi R. Iyer},
+  journal={2016 IEEE International Symposium on High Performance Computer Architecture (HPCA)},
+  year={2016},
+  pages={657-668},
+  type={C},
+}
+
 % vim:ts=4:sw=4