API tools faq
paste
Guest User

Untitled

a guest
Jun 10th, 2013
1,225
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 17.07 KB | None | 0 0
raw download clone embed print report
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4. #include <time.h>
  5. #include <math.h>
  6. #include <xmmintrin.h>
  7. #include <emmintrin.h>
  8.  
  9. //#define RANDGEN
  10. //#define TEST
  11. #ifndef TEST
  12. //#define RANDOM1
  13. //#define RANDOM2
  14. #endif
  15.  
  16. #define MAX_RANDS   2048
  17.  
  18. typedef unsigned char u8;
  19. typedef unsigned short u16;
  20. typedef unsigned int u32;
  21. typedef unsigned long long u64;
  22.  
  23. typedef u16 uxx;
  24.  
  25. u8 carry;
  26. uxx acc;
  27. u8 rand_seed[2];
  28. uxx key[4];
  29. __declspec(align(16)) uxx xor_table[128];
  30. u8 decoded_handler[128];
  31.  
  32. uxx rands[65536][MAX_RANDS];
  33. u32 rands_cur_seed, rands_cur_pos;
  34.  
  35. #define rnd_calc() {    \
  36.     register int seed;  \
  37.     rand_seed[1] += rand_seed[0];   \
  38.     seed = *(u16*)&rand_seed[0] + 0x2A89;   \
  39.     *(u16*)&rand_seed[0] = seed & 0xFFFF;   \
  40.     seed = *(u16*)&rand_seed[0] + 0x4321 + ((seed >> 16) & 1);  \
  41.     *(u16*)&rand_seed[0] = seed & 0xFFFF;   \
  42. }
  43.  
  44. #define rnd() (rands[rands_cur_seed][rands_cur_pos--])
  45. #define rndd(a) (*(u32*)&rands[rands_cur_seed][rands_cur_pos - (a)])
  46. #define rndq(a) (*(u64*)&rands[rands_cur_seed][rands_cur_pos - (a)])
  47. #define rndx(a) (*(__m128i*)&rands[rands_cur_seed][rands_cur_pos - (a)])
  48. #define srnd(seed) { rands_cur_pos = MAX_RANDS - 1; rands_cur_seed = (seed); }
  49.  
  50. void gen_rands() {
  51.     int i, j;
  52.     for(i = 0; i < 65536; i++) {
  53.         *(u16*)&rand_seed[0] = i & 0xffff;
  54.         for(j = 0; j < MAX_RANDS; j += 4) {
  55.             rnd_calc();
  56.             rands[i][MAX_RANDS - 1 - j - 0] = (rand_seed[1] ^ rand_seed[0]) & 0xFF;
  57.             rnd_calc();
  58.             rands[i][MAX_RANDS - 1 - j - 1] = (rand_seed[1] ^ rand_seed[0]) & 0xFF;
  59.             rnd_calc();
  60.             rands[i][MAX_RANDS - 1 - j - 2] = (rand_seed[1] ^ rand_seed[0]) & 0xFF;
  61.             rnd_calc();
  62.             rands[i][MAX_RANDS - 1 - j - 3] = (rand_seed[1] ^ rand_seed[0]) & 0xFF;
  63.         }
  64.     }
  65. }
  66.  
  67. void save_rands() {
  68.     int i, j;
  69.     printf("uxx rands[65536][2048] = {\n");
  70.     for(i = 0; i < 65536; i++) {
  71.         printf("    {");
  72.         for(j = 0; j < MAX_RANDS; j++) {
  73.             if((j & 0x1F) == 0)
  74.                 printf("\n");
  75.             printf("%02x,", rands[i][j]);
  76.         }
  77.         printf("\n  },\n");
  78.     }
  79. }
  80.  
  81. #define permute_key_0(level) {  \
  82.     register uxx tmp = (level ^ key[1]) + key[0];   \
  83.     tmp = ((tmp & 0xFF) - key[2] - (((tmp >> 8) & 1) ^ 1)) ^ 0x100; \
  84.     tmp = (tmp & 0xFF) + key[3] + ((tmp >> 8) & 1); \
  85.     key[3] = tmp & 0xFF;    \
  86.     tmp = (tmp & 0xFF) + key[2] + ((tmp >> 8) & 1); \
  87.     key[2] = tmp & 0xFF;    \
  88.     tmp = (tmp & 0xFF) + key[1] + ((tmp >> 8) & 1); \
  89.     key[1] = tmp & 0xFF;    \
  90.     tmp = (tmp & 0xFF) + key[0] + ((tmp >> 8) & 1); \
  91.     key[0] = tmp & 0xFF;    \
  92. }
  93.  
  94. #define permute_key_1(level) {  \
  95.     register uxx tmp = level + key[3] + 1;  \
  96.     key[3] = tmp & 0xFF;    \
  97.     tmp = (tmp & 0xFF) + key[2] + ((tmp >> 8) & 1); \
  98.     key[2] = tmp & 0xFF;    \
  99.     tmp = (tmp & 0xFF) + key[1] + ((tmp >> 8) & 1); \
  100.     key[1] = tmp & 0xFF;    \
  101.     tmp = (tmp & 0xFF) + key[0] + ((tmp >> 8) & 1); \
  102.     key[0] = tmp & 0xFF;    \
  103. }
  104.  
  105. #define permute_key_2(level) {  \
  106.     register uxx tmp = (key[0] + level) & 0xFF; \
  107.     key[0] = key[3];    \
  108.     key[3] = tmp;   \
  109.     tmp = key[1];   \
  110.     key[1] = key[2];    \
  111.     key[2] = tmp;   \
  112. }
  113.  
  114. #define permute_key_3(level) {  \
  115.     permute_key_2(level);   \
  116.     permute_key_1(level);   \
  117. }
  118.  
  119. #define permute_key_4(level) {  \
  120.     permute_key_2(level);   \
  121.     permute_key_0(level);   \
  122. }
  123.  
  124. #define permute_key_5(level) {  \
  125.     register uxx tmp = key[1];  \
  126.     key[0] = ((((level << 1) ^ 0xFF) + key[0]) - level) & 0xFF; \
  127.     key[1] = key[3];    \
  128.     key[3] = key[2];    \
  129.     key[2] = tmp;   \
  130. }
  131.  
  132. #define permute_key_6(level) {  \
  133.     permute_key_5(level);   \
  134.     permute_key_1(level);   \
  135. }
  136.  
  137. #define permute_key_7(level) {  \
  138.     permute_key_5(level);   \
  139.     permute_key_0(level);   \
  140. }
  141.  
  142. #define key_shedule(level, idx) {   \
  143.     switch(idx) {   \
  144.     case 0: permute_key_0(level); break;    \
  145.     case 1: permute_key_1(level); break;    \
  146.     case 2: permute_key_2(level); break;    \
  147.     case 3: permute_key_3(level); break;    \
  148.     case 4: permute_key_4(level); break;    \
  149.     case 5: permute_key_5(level); break;    \
  150.     case 6: permute_key_6(level); break;    \
  151.     case 7: permute_key_7(level); break;    \
  152.     }   \
  153. }
  154.  
  155. #define rnddwswap64(a) ((((u64)(rndd(a) >> 16) | (rndd(a) << 16)) << 32) | ((rndd(a - 2) >> 16) | (rndd(a - 2) << 16)))
  156.  
  157. void permute_round(u8 idx) {
  158.     __declspec(align(16)) static u32 saturate_mask[4] = {0x00FF00FF, 0x00FF00FF, 0x00FF00FF, 0x00FF00FF};
  159.     __declspec(align(16)) static u32 and_mask[4] = {0x00010001, 0x00010001, 0x00010001, 0x00010001};
  160.     switch(idx) {
  161.     case 0: {
  162.         register int i;
  163.         __m128i smsk = _mm_loadu_si128((__m128i*)&saturate_mask[0]);
  164.         for(i = 0x7F; i >= 0; i -= 8) {
  165.             __m128i rndx = _mm_loadu_si128((__m128i*)&rands[rands_cur_seed][rands_cur_pos - 7]);
  166.             __m128i tmp0 = _mm_slli_epi16(*(__m128i*)&xor_table[i - 7], 1);
  167.             __m128i tmp1 = _mm_srli_epi16(rndx, 7);
  168.             tmp0 = _mm_or_si128(tmp0, tmp1);
  169.             *(__m128i*)&xor_table[i - 7] = _mm_and_si128(tmp0, smsk);
  170.             rands_cur_pos -= 8;
  171.         }
  172.         break;
  173.     }
  174.     case 1: {
  175.         register int i;
  176.         for(i = 0x7F; i>= 0; i -= 8) {
  177.             __m128i rndx = _mm_loadu_si128((__m128i*)&rands[rands_cur_seed][rands_cur_pos - 7]);
  178.             *(__m128i*)&xor_table[i - 7] = _mm_add_epi8(*(__m128i*)&xor_table[i - 7], rndx);
  179.             rands_cur_pos -= 8;
  180.         }
  181.         break;
  182.     }
  183.     case 2: {
  184.         register int i;
  185.         register uxx tmp = (rnd() >> 7) & 1;
  186.         for(i = 0x7F; i >= 0; i -= 4) {
  187.             tmp = (xor_table[i - 0] << 1) | tmp;
  188.             xor_table[i - 0] = tmp & 0xFF;
  189.             xor_table[i - 1] |= (tmp & 0x100);
  190.             tmp = xor_table[i - 1] & 1;
  191.             xor_table[i - 1] >>= 1;
  192.             tmp = (xor_table[i - 2] << 1) | tmp;
  193.             xor_table[i - 2] = tmp & 0xFF;
  194.             xor_table[i - 3] |= (tmp & 0x100);
  195.             tmp = xor_table[i - 3] & 1;
  196.             xor_table[i - 3] >>= 1;
  197.         }
  198.         break;
  199.     }
  200.     case 3: {
  201.         register int i;
  202.         for(i = 0x7F; i >= 0; i -= 8) {
  203.             __m128i rndx = _mm_loadu_si128((__m128i*)&rands[rands_cur_seed][rands_cur_pos - 7]);
  204.             *(__m128i*)&xor_table[i - 7] = _mm_xor_si128(*(__m128i*)&xor_table[i - 7], rndx);
  205.             rands_cur_pos -= 8;
  206.         }
  207.         break;
  208.     }
  209.     case 4: {
  210.         register int i;
  211.         __m128i smsk = _mm_loadu_si128((__m128i*)&saturate_mask[0]);
  212.         __m128i amsk = _mm_loadu_si128((__m128i*)&and_mask[0]);
  213.         for(i = 0x7F; i >= 0; i -= 8) {
  214.             __m128i rndx = _mm_loadu_si128((__m128i*)&rands[rands_cur_seed][rands_cur_pos - 7]);
  215.             __m128i tmp0;
  216.             rndx = _mm_xor_si128(rndx, smsk);
  217.             tmp0 = _mm_add_epi8(*(__m128i*)&xor_table[i - 7], rndx);
  218.             *(__m128i*)&xor_table[i - 7] = _mm_add_epi8(tmp0, amsk);
  219.             rands_cur_pos -= 8;
  220.         }
  221.         break;
  222.     }
  223.     case 5: {
  224.         register int i;
  225.         register uxx tmp = rnd() << 1;
  226.         for(i = 0x7F; i >= 0; i -= 4) {
  227.             xor_table[i - 0] |= (tmp & 0x100);
  228.             tmp = xor_table[i - 0] & 1;
  229.             xor_table[i - 0] >>= 1;
  230.             tmp = (xor_table[i - 1] << 1) | tmp;
  231.             xor_table[i - 1] = tmp & 0xFF;
  232.             xor_table[i - 2] |= (tmp & 0x100);
  233.             tmp = xor_table[i - 2] & 1;
  234.             xor_table[i - 2] >>= 1;
  235.             tmp = (xor_table[i - 3] << 1) | tmp;
  236.             xor_table[i - 3] = tmp & 0xFF;
  237.         }
  238.         break;
  239.     }
  240.     case 6: {
  241.         register int i;
  242.         for(i = 0; i < 0x80; i += 8) {
  243.             *(u64*)&xor_table[i + 0] = ((*(u64*)&xor_table[i + 0] >> 1) | (rnddwswap64(3) & 0x0080008000800080)) & 0x00FF00FF00FF00FF;
  244.             *(u64*)&xor_table[i + 4] = ((*(u64*)&xor_table[i + 4] >> 1) | (rnddwswap64(7) & 0x0080008000800080)) & 0x00FF00FF00FF00FF;
  245.             rands_cur_pos -= 8;
  246.         }
  247.         break;
  248.     }
  249.     case 7: {
  250.         register int i;
  251.         __m128i smsk = _mm_loadu_si128((__m128i*)&saturate_mask[0]);
  252.         for(i = 0; i < 0x80; i += 8) {
  253.             *(__m128i*)&xor_table[i] = _mm_xor_si128(*(__m128i*)&xor_table[i], smsk);
  254.         }
  255.         break;
  256.     }
  257.     }
  258. }
  259.  
  260. void permute_xor_table() {
  261.     u16 crc = (key[2] & 0xFF) | ((key[3] & 0xFF) << 8);
  262.     srnd((key[0] & 0xFF) | ((key[1] & 0xFF) << 8));
  263.     permute_round(((xor_table[0] >> (((crc & 0x8000) >> 15) << 2)) & 0x0F) >> 1);
  264.     permute_round(((xor_table[1] >> (((crc & 0x4000) >> 14) << 2)) & 0x0F) >> 1);
  265.     permute_round(((xor_table[2] >> (((crc & 0x2000) >> 13) << 2)) & 0x0F) >> 1);
  266.     permute_round(((xor_table[3] >> (((crc & 0x1000) >> 12) << 2)) & 0x0F) >> 1);
  267.     permute_round(((xor_table[4] >> (((crc & 0x0800) >> 11) << 2)) & 0x0F) >> 1);
  268.     permute_round(((xor_table[5] >> (((crc & 0x0400) >> 10) << 2)) & 0x0F) >> 1);
  269.     permute_round(((xor_table[6] >> (((crc & 0x0200) >> 9) << 2)) & 0x0F) >> 1);
  270.     permute_round(((xor_table[7] >> (((crc & 0x0100) >> 8) << 2)) & 0x0F) >> 1);
  271.     permute_round(((xor_table[8] >> (((crc & 0x0080) >> 7) << 2)) & 0x0F) >> 1);
  272.     permute_round(((xor_table[9] >> (((crc & 0x0040) >> 6) << 2)) & 0x0F) >> 1);
  273.     permute_round(((xor_table[10] >> (((crc & 0x0020) >> 5) << 2)) & 0x0F) >> 1);
  274.     permute_round(((xor_table[11] >> (((crc & 0x0010) >> 4) << 2)) & 0x0F) >> 1);
  275.     permute_round(((xor_table[12] >> (((crc & 0x0008) >> 3) << 2)) & 0x0F) >> 1);
  276.     permute_round(((xor_table[13] >> (((crc & 0x0004) >> 2) << 2)) & 0x0F) >> 1);
  277.     permute_round(((xor_table[14] >> (((crc & 0x0002) >> 1) << 2)) & 0x0F) >> 1);
  278.     permute_round(((xor_table[15] >> (((crc & 0x0001) >> 0) << 2)) & 0x0F) >> 1);
  279. }
  280.  
  281. #define permute(level) {    \
  282.     key_shedule(level, (key[(level >> 4) & 3] >> 2) & 7);   \
  283.     permute_xor_table();    \
  284. }
  285.  
  286. void expand_key(u8 *iv) {
  287.     int i;
  288.     for(i = 0; i < 8; i++)
  289.         xor_table[i] = iv[i];
  290.     key[0] = xor_table[0];
  291.     key[1] = xor_table[1];
  292.     key[2] = xor_table[2];
  293.     key[3] = xor_table[3];
  294.     srnd((key[0] & 0xFF) | ((key[1] & 0xFF) << 8));
  295.     for(i = 0; i < 0x78; i += 8) {
  296.         *(u64*)&xor_table[i + 8 + 0] = (*(u64*)&xor_table[i + 0] + rnddwswap64(3)) & 0x00FF00FF00FF00FF;
  297.         *(u64*)&xor_table[i + 8 + 4] = (*(u64*)&xor_table[i + 4] + rnddwswap64(7)) & 0x00FF00FF00FF00FF;
  298.         rands_cur_pos -= 8;
  299.     }
  300. }
  301.  
  302. unsigned char level0_iv[] = {
  303.     0x2C, 0xA5, 0xB4, 0x2D, 0xF7, 0x3A, 0x26, 0x12
  304. };
  305.  
  306. u8 encoded_handler0[] = {
  307.     0xF4, 0xD7, 0xD1, 0x9E, 0x46, 0x4F, 0x90, 0xF0, 0xA1, 0x3C, 0x59, 0xA3, 0xFA, 0x09, 0x3C, 0x2A,
  308.     0x0B, 0x5A, 0x44, 0x1B, 0x7E, 0x23, 0x72, 0x63, 0xDD, 0xFA, 0x41, 0x27, 0x9A, 0x46, 0x8B, 0xAE,
  309.     0xA7, 0xFB, 0xE2, 0xF5, 0x04, 0x01, 0x9A, 0x51, 0xC3, 0x7A, 0x35, 0x58, 0x81, 0xAC, 0x59, 0xC2,
  310.     0xC3, 0x2A, 0xE4, 0x26, 0xAB, 0x90, 0x1F, 0x52, 0x84, 0xD4, 0xF5, 0x49, 0xC5, 0xE1, 0x55, 0xDC,
  311.     0xD8, 0x41, 0x28, 0xD1, 0x43, 0xF6, 0xF7, 0xA6, 0x6E, 0x52, 0xD2, 0xE4, 0x34, 0x39, 0xA1, 0x15,
  312.     0x1A, 0x31, 0x13, 0x0F, 0x21, 0xEA, 0xBF, 0x27, 0xF3, 0x23, 0xA4, 0xA0, 0x30, 0x67, 0x43, 0x32,
  313.     0x9B, 0x5C, 0xD2, 0xAB, 0x9F, 0x1B, 0x46, 0xD2, 0x7C, 0x3F, 0x6E, 0xD7, 0x23, 0xC8, 0xA6, 0xA1,
  314.     0x5E, 0x3D
  315. };
  316.  
  317. unsigned char level1_iv[] = {
  318.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  319. };
  320.  
  321. u8 encoded_handler1[] = {
  322.     0x50, 0xF1, 0xFB, 0x44, 0xBD, 0xC1, 0xB1, 0x5E, 0xE4, 0x18, 0x03, 0x52, 0x1A, 0x1C, 0x93, 0x36,
  323.     0x6E, 0x2D, 0x2B, 0x2B, 0xB9, 0x5A, 0xA1, 0x58, 0x7B, 0x32, 0xDB, 0x9A, 0xA3, 0x49, 0x40, 0x12,
  324.     0x06, 0x9C, 0xBB, 0x49, 0xAE, 0xB3, 0xFF, 0x67, 0xF0, 0xD2, 0x8F, 0x6E, 0x45, 0xB7, 0xE5, 0x9A,
  325.     0x80, 0xAB, 0xFF, 0xD3, 0x98, 0x9A, 0x94, 0x0A, 0x72, 0x81, 0xCF, 0x0A, 0xFF, 0xFB, 0x54, 0xD9,
  326.     0x0C, 0xE3, 0x22, 0xF1, 0xE2, 0xD2, 0xF4, 0xC7, 0x86, 0x81, 0x90, 0x0B, 0x04, 0xD2, 0x44, 0x66,
  327.     0xC1, 0x68, 0xCA
  328. };
  329.  
  330. void decode(u8 *enc, uxx *xor, u8 *dec, u8 size) {
  331.     int i;
  332.     for(i = 0; i < (size & 0xFC); i+=8) {
  333.         register u64 tmp = xor[0x7f - i - 4] | (xor[0x7f - i - 5] << 8) | (xor[0x7f - i - 6] << 16) | ((u32)xor[0x7f - i - 7] << 24);
  334.         tmp = (tmp << 32) | (xor[0x7f - i - 0] | (xor[0x7f - i - 1] << 8) | (xor[0x7f - i - 2] << 16) | ((u32)xor[0x7f - i - 3] << 24));
  335.         *(u64*)&dec[i] = *(u64*)&enc[i] ^ tmp;
  336.     }
  337.     for(i = (size & 0xFC); i < size; i++) {
  338.         dec[i] = enc[i] ^ xor[0x7f - i];
  339.     }
  340. }
  341.  
  342. int crccheck(u8 *buf, u8 size) {
  343.     int i;
  344.     u16 sum = 0;
  345.     for(i = 0; i < (size & 0xFC); i+=4) {
  346.         sum += buf[i + 0];
  347.         sum += buf[i + 1];
  348.         sum += buf[i + 2];
  349.         sum += buf[i + 3];
  350.     }
  351.     for(i = (size & 0xFC); i < size; i++) {
  352.         sum += buf[i];
  353.     }
  354.     return sum == (buf[size] | (buf[size + 1] << 8));
  355. }
  356.  
  357. #define log2of10 3.32192809488736234787
  358.  
  359. static double rt_log2(double x)
  360. {
  361.     return log2of10 * log10(x);
  362. }
  363.  
  364. double entropy(u8 *data, u32 size)
  365. {
  366.     u32 ccount[256], totalc = 0, i;
  367.     double prob[256], cexp, ent = 0.0;
  368.     u8 *bp = data, c;
  369.  
  370.     for (i = 0; i < 256; i += 8) {
  371.         *(u64*)&ccount[i + 0] = 0;
  372.         *(u64*)&ccount[i + 2] = 0;
  373.         *(u64*)&ccount[i + 4] = 0;
  374.         *(u64*)&ccount[i + 6] = 0;
  375.     }
  376.     totalc = 0;
  377.  
  378.     while (size-- > 0) {
  379.         c = *bp++;
  380.         ccount[c]++;
  381.         totalc++;
  382.     }
  383.  
  384.     cexp = totalc / 256.0;
  385.     for (i = 0; i < 256; i += 4) {
  386.         prob[i + 0] = ((double) ccount[i + 0]) / totalc;
  387.         prob[i + 1] = ((double) ccount[i + 1]) / totalc;
  388.         prob[i + 2] = ((double) ccount[i + 2]) / totalc;
  389.         prob[i + 3] = ((double) ccount[i + 3]) / totalc;
  390.     }
  391.  
  392.     for (i = 0; i < 256; i++) {
  393.         if (prob[i] > 0.0)
  394.             ent += prob[i] * rt_log2(1 / prob[i]);
  395.     }
  396.  
  397.     return ent;
  398. }
  399.  
  400. void dump(u8 *buf, u8 *key, u8 size, float ent) {
  401.     FILE *o = NULL;
  402.     char n[64];
  403.     sprintf(n, "%.4f-%02X%02X%02X%02X%02X%02X%02X%02X.bin", ent, key[0], key[1], key[2], key[3], key[4], key[5], key[6], key[7]);
  404.     o=fopen(n, "wb");
  405.     fwrite(buf, 1, size, o);
  406.     fclose(o);
  407. }
  408.  
  409. void flush(u8 *buf, unsigned long long count, char *name, int size) {
  410.     FILE *o = NULL;
  411.     o=fopen(name, "wb");
  412.     fwrite(&count, 1, 8, o);
  413.     fwrite(buf, 1, size, o);
  414.     fclose(o);
  415. }
  416.  
  417. void load(u8 *buf, unsigned long long *count, char *name, int size) {
  418.     FILE *o = NULL;
  419.     if((o=fopen(name, "rb")) != NULL) {
  420.         fread(count, 1, 8, o);
  421.         fread(buf, 1, size, o);
  422.         fclose(o);
  423.     } else {
  424.         memset(buf, 0, size);
  425.     }
  426. }
  427.  
  428. unsigned long long long_count, short_count;
  429. u32 long_chunks[0x8000000];
  430. u32 short_chunks[0x800];
  431.  
  432. #ifndef TEST
  433. u32 *long_seed = (u32*)&level1_iv[4];
  434. u16 *counter = (u16*)&level1_iv[0];
  435. u16 *short_seed = (u16*)&level1_iv[2];
  436. unsigned long long *iv = (unsigned long long*)level1_iv;
  437. u8 *encoded_handler = encoded_handler1;
  438. u8 handler_size = sizeof(encoded_handler1);
  439. #else
  440. u32 *long_seed = (u32*)&level0_iv[4];
  441. u16 *counter = (u16*)&level0_iv[0];
  442. u16 *short_seed = (u16*)&level0_iv[2];
  443. unsigned long long *iv = (unsigned long long*)level0_iv;
  444. u8 *encoded_handler = encoded_handler0;
  445. u8 handler_size = sizeof(encoded_handler0);
  446. #endif
  447.  
  448. int main() {
  449.     int i;
  450.     char sname[128];
  451. #ifdef RANDOM1
  452.     srand((int)time(NULL));
  453. #endif
  454. #ifdef RANDOM2
  455.     srand((int)time(NULL));
  456. #endif
  457. #ifndef RANDGEN
  458.     printf("rand generate...");
  459. #endif
  460.     gen_rands();
  461. #ifdef RANDGEN
  462.     save_rands();
  463.     exit(0);
  464. #else
  465.     printf(" done\n");
  466. #endif
  467.     long_count = 0x100000000UL;
  468. #ifndef TEST
  469.     load((u8*)long_chunks, &long_count, "long_brute.data", sizeof(long_chunks));
  470. #endif
  471.     memset(short_chunks, 0, sizeof(short_chunks));
  472.     printf("brute start...\n");
  473. #ifndef TEST
  474. //  (*long_seed) = 0;
  475.     (*short_seed) = 0;
  476. #endif
  477.     while (long_count > 0) {
  478.         u32 lidx, lbit;
  479. #ifndef TEST
  480.     #ifdef RANDOM1
  481.         u32 tmp;
  482.         (*long_seed) = rand();
  483.         tmp = rand() << 15;
  484.         (*long_seed) |= tmp;
  485.         tmp = (rand() & 3) << 30;\
  486.         (*long_seed) |= tmp;
  487.     #endif
  488. #endif
  489.         short_count = 0x10000;
  490.         sprintf(sname, "short_brute_%08X.data", (*long_seed));
  491. #ifndef TEST
  492.         load((u8*)short_chunks, &short_count, sname, sizeof(short_chunks));
  493. #endif
  494.         lidx = (*long_seed) >> 5;
  495.         lbit = 1 << ((*long_seed) & 0x1F);
  496.         if (!(long_chunks[lidx] & lbit)) {
  497.             long_chunks[lidx] |= lbit;
  498.             long_count--;
  499.             printf(" long chunk %08X in progress...\n", (*long_seed));
  500.             while (short_count > 0)
  501.             {
  502.                 u32 sidx, sbit;
  503. #ifndef TEST
  504.     #ifdef RANDOM2
  505.                 u32 tmp;
  506.                 (*short_seed) = rand();
  507.                 tmp = (rand() & 1) << 15;
  508.                 (*short_seed) |= tmp;
  509.     #endif
  510. #endif
  511.                 sidx = (*short_seed) >> 5;
  512.                 sbit = 1 << ((*short_seed) & 0x1F);
  513.                 if (!(short_chunks[sidx] & sbit)) {
  514.                     short_chunks[sidx] |= sbit;
  515.                     short_count--;
  516. #ifndef TEST
  517.                     (*counter) = 0;
  518. #endif
  519.                     printf("  short chunk %04X in progress...\n", (*short_seed));
  520. #ifndef TEST
  521.                     for(i = 0; i < 0x10000; i++)
  522. #else
  523.                     for(i = (*counter); i < 0x10000; i++)
  524. #endif
  525.                     {
  526.                         expand_key((u8*)iv);
  527.                         permute(0x00);
  528.                         permute(0x02);
  529.                         permute(0x05);
  530.                         permute(0x04);
  531.                         permute(0x03);
  532.                         permute(0x1D);
  533.                         permute(0x1C);
  534.                         permute(0x1E);
  535.                         permute_key_6(0x1B);
  536.                         permute(0x1B);
  537.                         permute(0x07);
  538.                         permute(0x08);
  539.                         permute_key_0(0x06);
  540.                         permute_xor_table();
  541.                         permute(0x09);
  542.                         permute(0x0c);
  543.                         permute(0x20);
  544.                         permute(0x21);
  545.                         permute(0x22);
  546.                         permute_key_4(0x22);
  547.                         permute_xor_table();
  548.                         permute(0x23);
  549.                         permute(0x24);
  550.                         permute(0x25);
  551.                         permute(0x26);
  552.                         permute(0x0E);
  553.                         permute(0x0F);
  554.                         permute(0x10);
  555.                         permute(0x12);
  556.                         permute(0x11);
  557.                         decode(encoded_handler, xor_table, decoded_handler, handler_size);
  558. #ifdef TEST
  559.                         if((xor_table[0] == 0xFD) && (xor_table[1] == 0x22) && (xor_table[2] == 0x3C) && (xor_table[3] == 0x40)) {
  560. #else
  561.                         if(crccheck(decoded_handler, handler_size - 2)) {
  562.                             u8 *k = (u8 *)iv;
  563.                             float ent = (float)entropy(decoded_handler, handler_size - 2);
  564. #endif
  565. #ifdef TEST
  566.                             if(i == 0xA52C)
  567. #endif
  568.                             {
  569. #ifdef TEST
  570.                                 printf("    PASS!\n");
  571. #else
  572.                                 printf("    crc check passed for a key: %02X %02X %02X %02X %02X %02X %02X %02X (entropy = %.4f)\n",k[0], k[1], k[2], k[3], k[4], k[5], k[6], k[7], ent);
  573.                                 dump(decoded_handler, k, handler_size, ent);
  574. #endif
  575.                             }
  576.                         }
  577.                         (*counter)++;
  578.                     }
  579.                 }
  580. #ifndef RANDOM2
  581.                 (*short_seed)++;
  582. #endif
  583.                 flush((u8*)short_chunks, short_count, sname, sizeof(short_chunks));
  584.             }
  585. #ifndef RANDOM1
  586.             (*long_seed)++;
  587. #endif
  588.             flush((u8*)long_chunks, long_count, "long_brute.data", sizeof(long_chunks));
  589.         }
  590.     }
  591.     return;
  592. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
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!