intel：spectre&Meltdown侧信道攻击（一）

 　　只要平时对安全领域感兴趣的读者确定都听过spectre&Meltdown侧信道攻击，今天简单介绍一下这种攻击的原理（ https://www.bilibili.com/video/av18144159?spm_id_from=333.788.b_765f64657363.1 这里有详细的视频介绍，墙裂推荐）。

 　　一、CPU顺序执行指令

         众所周知，程序是由一条条指令顺序排列构成的，老的cpu也是逐行执行指令；随着cpu的技术发展（著名的摩尔定律），cpu执行指令的速度愈来愈快，和内存读写速度的差距愈来愈大。理论上，CPU执行一条指令耗时纳秒左右，但从内存读一次数据须要耗时约100纳秒（参考这里：https://zhuanlan.zhihu.com/p/24726196），理论上相差了百倍，业界称为冯诺依曼瓶颈；这个速度差别不解决，CPU执行速度再快都没用；由此衍生出了近年来CPU的一个重要特性：乱序执行

        二、乱序执行：以下所示，好比有个if分支。正常状况下，若是MEM==0才会执行if分支；但CPU因为速度百倍于内存，等把这块内存的数据读出来，下面那4条指令早就执行完了，因此先不判断if条件是否成立，CPU会先执行这4条指令；等前面的指令执行完毕，轮到执行if 的时候，才会从内存读mem的数据，而后判断是否为0.  若是是，说明if这个分支原本就该执行，因为前面已经执行完毕，因此整个效率大大提高；退一步说，就算if条件不成立，cpu白执行了4条指令，这时只须要回退（主要是寄存器的值）便可，和之前的顺序执行比也没啥损失。这种提早预测分支执行的方法截至目前至少看起来没啥损失，还有必定的几率提高总体效率了！这个就是业界所谓的speculative execution！

         

 　　三、缓存cache

　　 前面说了，CPU执行指令的速度和从内存读数据的速度差了百倍。若是每次执行指令前都要从内存读取数据，CPU会闲死的；为了解决这个问题，衍生出了cpu另外一个很是重要的功能：缓存；第一次从内存读取数据后，cpu会先把这些数据存放在内部缓存。下次再须要用这些数据时，不会马上从内存读，而是先看看本身的缓存种是否已经有了，没有才会继续去内存读取；此种思想方法也能在必定程度上提高程序的执行效率和速度，但问题也随之而来：

        

 　　cpu的缓存是否有该数据，直接影响了从内存读取该数据的效率，理论上差了近百倍，这个差别是很是明显的，这就给黑客留下了“把柄”；

　　四、meltdown和side-channel attack

    （1）利用时间差，能够作的攻击有不少，先举一个通俗易懂的栗子：暴力猜密码

　          好比我设置了一个登录密码“cnblogs”，用户输入密码后，后台验证的逻辑是逐个字符比对。好比用户输入djgnyd，第一个字符就不对，直接返回false；好比用户输入cjhtsf，第一个字符对了，再继续比对第二个，结果发现第二个错了，再次返回。这就给了黑客可乘之机：屡次随机输入密码，利用不一样的返回时间差猜想输入的密码是否正确！这就是业界俗称的side-channel attack；

     （2）meltdown和side-channel attack

              接下来介绍本文的重点：利用spectre和meltdown读取任意内存的数据，而不受任何权限限制；计算机的整个内存种，咱们本身程序能用的只是一部分，还有不少内存是不能用的，好比部份内核的内存、其余进程的内存、其余虚拟机的内存（如下简称victim memory），操做系统会经过各类机制确保咱们的程序没法访问（好比保护模式下的0~3环+CPL/DPL/RPL等机制控制、操做系统对内存rwx属性的管理）。若是不慎读到这些内存，windows会弹出c000005内存访问错误；以下：

           （2.1）假设蓝色是咱们能正常使用的内存，红色是没法使用的victim内存；咱们在蓝色区域开辟一个数组A（绿色表示），只有两个元素A[0]和A[1]; 经过A指针访问这两个元素是ok的；可是要想经过A+X越界直接访问victim内存是不行的，cpu或操做系统会直接阻止，并抛出异常或弹框报错；

　　　  

 　　（2.2）同时继续再在蓝色区域开辟一个instrument 的数组，该数据全部数据一概不能存放cpu缓存（后面会解释缘由）；

 　　（2.3）接下来最关键的点来了：if(xxx) access Instrument[A[x]]

                     若是直接执行A[x]，因为越界到victim内存，会被终止；但这个指令在if条件分支，cpu的乱序执行特性会先不判断if条件是否成立，而是直接access Instrument[A[x]]；此时也不会检查A[x]是否越界，而是直接读取该内存数据；假如读取的数据是4，那么Instrument[A[x]] = G，这个G会被存到CPU缓存；而后又从Instrument0开始一致读取到7，判断哪一个数据读取的速度最快（上面有解释：没在缓存的只能从内存读，理论速度差了近百倍），很明显第4个单元的耗时最断，反推出A[x]=4，致使该victim的内存数据泄露；

　　　　　　有读者确定会问：就算是预测分支乱序执行，为啥不检查A[x]是否越界了？整个攻击最核心的点就在这里啊！我的猜想：这和是cpu、操做系统的分工不明确致使的；cpu提早预测分支指令执行，这时if条件是否成立还不知道了，又怎么去判断A[x]是否越界了？ 因此cpu spectaculative设计人员把这个验证的事情甩给了操做系统内核，但愿正常执行到该命令时操做系统内核能检查一下是否越界，若是有，再kill程序、抛出异常；但等到操做系统验证时为时已晚，access Instrument[A[x]] 这条指令已经被执行，对应内存的数据已经被读取到了cpu的缓存. 就算if条件不成立，回退的是寄存器的值，cpu缓存的值仍是存在的.......

          

　　这是核心的js代码：若是操做系统或浏览器没打补丁，理论上用户在浏览网页的时候，黑客能够经过这种方式从内存读取全部数据，致使密码等敏感数据泄露；

 　　

　　五、最后怎么避免本身的程序乱序执行代码了？VS里面把这里设置成已启用就行；

        

　　 六、简化的代码以下（精华都在注释了），几个核心的函数： 

        （1）_mm_clflush：清除内存某个单元在cpu中的L一、L二、L3全部的缓存

        （2）__rdtscp：开始计时

        （3）_mm_mfence：后面的指令只能顺序执行

#include <intrin.h>
#include <stdio.h>
#include <Windows.h>

#define SHIFT_NUMBER          0x0C
#define PAGE_SIZE             4096
#define BLOCK_SIZE            (1 << SHIFT_NUMBER)//0x1000，一个页

/*
(LPBYTE)_aligned_malloc(256 * BLOCK_SIZE, PAGE_SIZE)这里申请了256个页；用flush函数
将这256个页在cpu中的缓存失效
详细解释能够看这了：http://scc.qibebt.ac.cn/docs/optimization/VTune(TM)%20User's%20Guide/mergedProjects/analyzer_ec/mergedProjects/reference_olh/instruct32_hh/vc31.htm
https://zhuanlan.zhihu.com/p/141144249
*/
void CacheLineFlush(LPBYTE lpArray, UINT index) 
{
    _mm_clflush(&(lpArray[index << SHIFT_NUMBER]));
}

void CacheLineFlush_all(LPBYTE lpArray)
{
    for (UINT i = 0; i < 256; i++) 
        CacheLineFlush(lpArray, i);
}

/************************************************************************/
/* 统计各个块的访问速度，并返回最快的那个块的索引                       */
/************************************************************************/
BYTE GetAccessByte(LPBYTE lpArray) {
    UINT64 speed[256];
    UINT64 start, min;
    UINT index, junk;
    BYTE result;

    //为min赋初始值
    min = 0;

    //测试访问速度
    for (int i = 0; i < 256; i++) {
        //获取array[index]的地址；也就是页的索引
        index = i << SHIFT_NUMBER;
        //mfence指令用于序列化内存访问，即让乱序执行无效化。
        //后面的指令必须在前面的内存读写完成后再开始发射执行。
        _mm_mfence();
        //记录开始周期
        start = __rdtscp(&junk);
        junk = *(LPDWORD)(&lpArray[index]);//记录读取每一个单元的时间
        _mm_mfence();
        speed[i] = __rdtscp(&junk) - start;

        //若是是初始值，或者比当前值还小
        if ((min == 0) || (speed[i] < min)) {
            min = speed[i];
            result = (BYTE)i;
        }
    }

    return result;
}

/************************************************************************/
/* 用index做为数组索引，访问array的某个元素                             */
/************************************************************************/
BYTE AccessArray(LPBYTE lpArray, UINT index) {
    return lpArray[index << SHIFT_NUMBER];//左移12位，效果至关于乘以4096；那么能够把index当作是页的索引，这里访问index指向页开头的第一个字节；
}


int main()
{
    //假定的kernel内存
    BYTE kernel[4];
    //array是用户可控制的内存
    LPBYTE array;

    kernel[0] = 0x55;
    kernel[1] = 0xAA;
    kernel[2] = 0xF0;
    kernel[3] = 0x0F;
    /*
    分配256个页，做用至关于视频中的instrument；为何是256了？内存中每一个最小单元是1字节，能表示从0~255一共256个数；
    后续会挨个读取这256个页开头的第一个字节，若是速度快，说明cpu里面已经有缓存了，kernel单元（也就是视频中的victim单元）
    大概是是这个数；
    */
    array = (LPBYTE)_aligned_malloc(256 * BLOCK_SIZE, PAGE_SIZE);

    /*
    实现原理:
      kernel假定是受保护的内存数据 (本demo里可访问)。
      array为用户可控制的一个数组，一共分为256个块，每一个块的大小为2的整数倍: (1 << SHIFT_NUMBER)。
      而后从kernel中读取一个byte，以这个byte为索引，去访问array所对应的块。
      以后马上循环读取一遍array的各个块，若是以前访问成功了，那么对应的块应该还在缓存中，对应的访问时间要少不少。
      统计各个块的访问周期数，最快的块，他的索引就是受保护的那个byte。

      CacheLineFlush_all 函数用于把整个数组从缓存中清除出去，这样不至于污染访问速度。
      AccessArray 函数用于以一个索引去访问一个数组。
      GetAccessByte 函数用于测试数组的各个块的访问速度，返回最快的那个块的索引。
    */

    CacheLineFlush_all(array);//清空本身申请的256页在cpu的缓存，避免影响后续的读取计时
    AccessArray(array, kernel[0]);//这里为了突出重点说明侧信道攻击，并无用if分支预测执行，而是直接用kernel的元素作下标访问，让这个数写入cpu缓存
    printf("Access fastest: 0x%02X\n", (DWORD)GetAccessByte(array));//看看哪一个内存单元读取的速度最快，由此反推出kernel元素的值

    CacheLineFlush_all(array);
    AccessArray(array, kernel[1]);
    printf("Access fastest: 0x%02X\n", (DWORD)GetAccessByte(array));

    CacheLineFlush_all(array);
    AccessArray(array, kernel[2]);
    printf("Access fastest: 0x%02X\n", (DWORD)GetAccessByte(array));

    CacheLineFlush_all(array);
    AccessArray(array, kernel[3]);
    printf("Access fastest: 0x%02X\n", (DWORD)GetAccessByte(array));

    getchar();

    return 0;
}

参考：https://www.freebuf.com/articles/system/159811.html  一步一步理解CPU芯片漏洞：Meltdown与Spectre

           https://meltdownattack.com/ 官网

           https://www.bilibili.com/video/av18144159?spm_id_from=333.788.b_765f64657363.1  15分钟读懂英特尔熔断幽灵漏洞-Emory

           https://www.fortinet.com/blog/threat-research/into-the-implementation-of-spectre  （中文翻译：https://zhuanlan.zhihu.com/p/33635193）Spectre 攻击详解（详细的demo代码）

           https://bbs.pediy.com/thread-224040.htm 简短的demo代码，很是适合入门学习原理

           https://www.cnblogs.com/zenny-chen/archive/2013/03/28/2986527.html 与Cache相关的控制

           https://bbs.pediy.com/thread-254288.htm spectre跨进程泄露敏感信息