API tools faq
paste
Advertisement
Guest User

hrjg23kjg42

a guest
Jul 22nd, 2014
154
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 15.59 KB | None | 0 0
raw download clone embed print report
  1. signed int __fastcall check_code(BYTE *email, BYTE *serial)
  2. {
  3.   int v2; // ebp@0
  4.   BYTE *p; // ebx@1
  5.   signed int i; // ecx@1
  6.   BYTE c; // al@2
  7.   int v6; // edi@9
  8.   signed int i1; // edx@9
  9.   BYTE v8; // cl@10
  10.   char v9; // al@10
  11.   int v10; // edx@16
  12.   signed int v11; // esi@16
  13.   BYTE v12; // cl@17
  14.   char v13; // al@17
  15.   int s4; // ecx@23
  16.   signed int v15; // esi@23
  17.   BYTE v16; // bl@24
  18.   char v17; // al@24
  19.   unsigned int s3; // esi@30
  20.   signed int v19; // edi@30
  21.   char v20; // bl@31
  22.   char v21; // al@31
  23.   struct_1 *v22; // ebx@37
  24.   int v23; // edx@37
  25.   signed int v24; // esi@37
  26.   char v25; // cl@38
  27.   char v26; // al@38
  28.   int v27; // edi@44
  29.   signed int v28; // esi@44
  30.   char v29; // cl@45
  31.   char v30; // al@45
  32.   int b2; // ecx@51
  33.   signed int v32; // esi@51
  34.   char v33; // bl@52
  35.   char v34; // al@52
  36.   unsigned int b1; // esi@58
  37.   signed int v36; // edx@58
  38.   char v37; // bl@59
  39.   char v38; // al@59
  40.   struct_1 *v39; // ebx@65
  41.   int v40; // edi@65
  42.   signed int v41; // edx@65
  43.   char v42; // cl@66
  44.   char v43; // al@66
  45.   int v44; // ecx@72
  46.   signed int v45; // esi@72
  47.   char v46; // dl@73
  48.   char v47; // al@73
  49.   int c2; // edx@79
  50.   signed int v49; // esi@79
  51.   char v50; // bl@80
  52.   char v51; // al@80
  53.   unsigned int c1; // esi@86
  54.   signed int v53; // edi@86
  55.   char v54; // bl@87
  56.   char v55; // al@87
  57.   struct_1 *v56; // ebx@93
  58.   int v57; // ecx@93
  59.   signed int v58; // esi@93
  60.   char v59; // dl@94
  61.   char v60; // al@94
  62.   int v61; // edi@100
  63.   signed int v62; // esi@100
  64.   char v63; // dl@101
  65.   char v64; // al@101
  66.   int d2; // edx@107
  67.   signed int v66; // esi@107
  68.   char v67; // bl@108
  69.   char v68; // al@108
  70.   unsigned int d1; // esi@114
  71.   signed int v70; // ecx@114
  72.   char v71; // bl@115
  73.   char v72; // al@115
  74.   struct_1 *n; // edi@121
  75.   struct_1 *l_k; // ebx@121
  76.   struct_1 *e; // esi@121
  77.   struct_1 *enc; // ebx@121
  78.   struct_1 *v77; // esi@121
  79.   int v78; // eax@121
  80.   int *v79; // ecx@121
  81.   char *v80; // edx@121
  82.   unsigned int v81; // esi@121
  83.   bool f; // cf@123
  84.   DWORD v83; // eax@124
  85.   struct_1 *v84; // eax@126
  86.   int v85; // ebx@126
  87.   struct_1 *es0; // esi@126
  88.   signed int i0; // edi@126
  89.   int es1; // eax@127
  90.   struct_1 *exp1; // ebx@128
  91.   int v90; // esi@128
  92.   DWORD *hard_hash_list; // ebx@128
  93.   int data_3h; // edi@128
  94.   DWORD *p1; // ecx@129
  95.   DWORD *p2; // edx@129
  96.   unsigned int len; // esi@129
  97.   signed int ii; // esi@133
  98.   struct_1 *l_k__; // [sp+Ch] [bp-25Ch]@1
  99.   struct_1 *o; // [sp+10h] [bp-258h]@23
  100.   struct_1 *t0; // [sp+14h] [bp-254h]@16
  101.   struct_1 *tmp0; // [sp+18h] [bp-250h]@1
  102.   struct_1 *n_; // [sp+1Ch] [bp-24Ch]@121
  103.   md5_context ctxmd4; // [sp+20h] [bp-248h]@121
  104.   aes_context ctxaes128; // [sp+B8h] [bp-1B0h]@121
  105.   DWORD k[4]; // [sp+1B0h] [bp-B8h]@37
  106.   char hash2; // [sp+1C0h] [bp-A8h]@121
  107.   char v107; // [sp+1D0h] [bp-98h]@133
  108.   char Text[132]; // [sp+1E0h] [bp-88h]@134
  109.   unsigned int v109; // [sp+264h] [bp-4h]@1
  110.  
  111.   v109 = (unsigned int)&l_k__ ^ __security_cookie;
  112.   p = serial;
  113.   tmp0 = (struct_1 *)email;
  114.   l_k__ = (struct_1 *)serial;
  115.   i = 0;
  116.   while ( 1 )
  117.   {
  118.     c = serial[i];
  119.     if ( (char)c < '0' || (char)c > '9' )
  120.     {
  121.       if ( ((char)c < 'A' || (char)c > 'F') && ((char)c < 'a' || (char)c > 'f') )
  122.         return 0;
  123.     }
  124.     ++i;
  125.     if ( i >= (signed int)0x20u )
  126.     {
  127.       v6 = 0;
  128.       i1 = 0;
  129.       do
  130.       {
  131.         v8 = p[i1];
  132.         v9 = v8 - 48;
  133.         if ( (unsigned __int8)(v8 - 48) > 9u )
  134.         {
  135.           if ( (unsigned __int8)(v8 - 'a') > 5u )
  136.           {
  137.             if ( (unsigned __int8)(v8 - 'A') > 5u )
  138.               break;
  139.             v9 = v8 - 0x37;
  140.           }
  141.           else
  142.           {
  143.             v9 = v8 - 0x57;
  144.           }
  145.         }
  146.         ++i1;
  147.         v6 = v9 + 16 * v6;
  148.       }
  149.       while ( i1 < 8 );
  150.       v10 = 0;
  151.       t0 = (struct_1 *)v6;
  152.       v11 = 0;
  153.       do
  154.       {
  155.         v12 = p[v11];
  156.         v13 = v12 - 48;
  157.         if ( (unsigned __int8)(v12 - 48) > 9u )
  158.         {
  159.           if ( (unsigned __int8)(v12 - 97) > 5u )
  160.           {
  161.             if ( (unsigned __int8)(v12 - 65) > 5u )
  162.               break;
  163.             v13 = v12 - 55;
  164.           }
  165.           else
  166.           {
  167.             v13 = v12 - 87;
  168.           }
  169.         }
  170.         ++v11;
  171.         v10 = v13 + 16 * v10;
  172.       }
  173.       while ( v11 < 8 );
  174.       s4 = 0;
  175.       o = (struct_1 *)v10;
  176.       v15 = 0;
  177.       do
  178.       {
  179.         v16 = p[v15];
  180.         v17 = v16 - '0';
  181.         if ( (unsigned __int8)(v16 - '0') > 9u )
  182.         {
  183.           if ( (unsigned __int8)(v16 - 'a') > 5u )
  184.           {
  185.             if ( (unsigned __int8)(v16 - 'A') > 5u )
  186.               break;
  187.             v17 = v16 - '7';
  188.           }
  189.           else
  190.           {
  191.             v17 = v16 - 'W';
  192.           }
  193.         }
  194.         p = (BYTE *)l_k__;
  195.         ++v15;
  196.         s4 = v17 + 16 * s4;
  197.       }
  198.       while ( v15 < 8 );
  199.       s3 = 0;
  200.       v19 = 0;
  201.       do
  202.       {
  203.         v20 = *((_BYTE *)&l_k__->ind + v19);
  204.         v21 = v20 - 48;
  205.         if ( (unsigned __int8)(v20 - 48) > 9u )
  206.         {
  207.           if ( (unsigned __int8)(v20 - 97) > 5u )
  208.           {
  209.             if ( (unsigned __int8)(v20 - 65) > 5u )
  210.               break;
  211.             v21 = v20 - 55;
  212.           }
  213.           else
  214.           {
  215.             v21 = v20 - 87;
  216.           }
  217.         }
  218.         ++v19;
  219.         s3 = v21 + 16 * s3;
  220.       }
  221.       while ( v19 < 8 );
  222.       v22 = l_k__;
  223.       v23 = 0;
  224.       k[0] = ((((_DWORD)t0 << 16) | (unsigned __int16)((unsigned __int16)o & 0xFF00)) << 8) | (((s3 >> 16) | s4 & 0xFF0000) >> 8);
  225.       v24 = 0;
  226.       do
  227.       {
  228.         v25 = *((_BYTE *)&l_k__->d3 + v24);
  229.         v26 = v25 - 48;
  230.         if ( (unsigned __int8)(v25 - 48) > 9u )
  231.         {
  232.           if ( (unsigned __int8)(v25 - 97) > 5u )
  233.           {
  234.             if ( (unsigned __int8)(v25 - 65) > 5u )
  235.               break;
  236.             v26 = v25 - 55;
  237.           }
  238.           else
  239.           {
  240.             v26 = v25 - 87;
  241.           }
  242.         }
  243.         ++v24;
  244.         v23 = v26 + 16 * v23;
  245.       }
  246.       while ( v24 < 8 );
  247.       v27 = 0;
  248.       t0 = (struct_1 *)v23;
  249.       v28 = 0;
  250.       do
  251.       {
  252.         v29 = *((_BYTE *)&l_k__->d3 + v28);
  253.         v30 = v29 - 48;
  254.         if ( (unsigned __int8)(v29 - 48) > 9u )
  255.         {
  256.           if ( (unsigned __int8)(v29 - 97) > 5u )
  257.           {
  258.             if ( (unsigned __int8)(v29 - 65) > 5u )
  259.               break;
  260.             v30 = v29 - 55;
  261.           }
  262.           else
  263.           {
  264.             v30 = v29 - 87;
  265.           }
  266.         }
  267.         ++v28;
  268.         v27 = v30 + 16 * v27;
  269.       }
  270.       while ( v28 < 8 );
  271.       b2 = 0;
  272.       o = (struct_1 *)v27;
  273.       v32 = 0;
  274.       do
  275.       {
  276.         v33 = *((_BYTE *)&v22->d3 + v32);
  277.         v34 = v33 - 48;
  278.         if ( (unsigned __int8)(v33 - 48) > 9u )
  279.         {
  280.           if ( (unsigned __int8)(v33 - 97) > 5u )
  281.           {
  282.             if ( (unsigned __int8)(v33 - 65) > 5u )
  283.               break;
  284.             v34 = v33 - 55;
  285.           }
  286.           else
  287.           {
  288.             v34 = v33 - 87;
  289.           }
  290.         }
  291.         v22 = l_k__;
  292.         ++v32;
  293.         b2 = v34 + 16 * b2;
  294.       }
  295.       while ( v32 < 8 );
  296.       b1 = 0;
  297.       v36 = 0;
  298.       do
  299.       {
  300.         v37 = *((_BYTE *)&l_k__->d3 + v36);
  301.         v38 = v37 - 48;
  302.         if ( (unsigned __int8)(v37 - 48) > 9u )
  303.         {
  304.           if ( (unsigned __int8)(v37 - 97) > 5u )
  305.           {
  306.             if ( (unsigned __int8)(v37 - 65) > 5u )
  307.               break;
  308.             v38 = v37 - 55;
  309.           }
  310.           else
  311.           {
  312.             v38 = v37 - 87;
  313.           }
  314.         }
  315.         ++v36;
  316.         b1 = v38 + 16 * b1;
  317.       }
  318.       while ( v36 < 8 );
  319.       v39 = l_k__;
  320.       v40 = 0;
  321.       v41 = 0;
  322.       k[1] = (((unsigned __int16)((unsigned __int16)o & 0xFF00) | ((_DWORD)t0 << 16)) << 8) | (((b1 >> 16) | b2 & 0xFF0000) >> 8);
  323.       do
  324.       {
  325.         v42 = *((_BYTE *)&l_k__[1].buf + v41);
  326.         v43 = v42 - 48;
  327.         if ( (unsigned __int8)(v42 - 48) > 9u )
  328.         {
  329.           if ( (unsigned __int8)(v42 - 97) > 5u )
  330.           {
  331.             if ( (unsigned __int8)(v42 - 65) > 5u )
  332.               break;
  333.             v43 = v42 - 55;
  334.           }
  335.           else
  336.           {
  337.             v43 = v42 - 87;
  338.           }
  339.         }
  340.         ++v41;
  341.         v40 = v43 + 16 * v40;
  342.       }
  343.       while ( v41 < 8 );
  344.       v44 = 0;
  345.       o = (struct_1 *)v40;
  346.       v45 = 0;
  347.       do
  348.       {
  349.         v46 = *((_BYTE *)&l_k__[1].buf + v45);
  350.         v47 = v46 - 48;
  351.         if ( (unsigned __int8)(v46 - 48) > 9u )
  352.         {
  353.           if ( (unsigned __int8)(v46 - 97) > 5u )
  354.           {
  355.             if ( (unsigned __int8)(v46 - 65) > 5u )
  356.               break;
  357.             v47 = v46 - 55;
  358.           }
  359.           else
  360.           {
  361.             v47 = v46 - 87;
  362.           }
  363.         }
  364.         ++v45;
  365.         v44 = v47 + 16 * v44;
  366.       }
  367.       while ( v45 < 8 );
  368.       c2 = 0;
  369.       t0 = (struct_1 *)v44;
  370.       v49 = 0;
  371.       do
  372.       {
  373.         v50 = *((_BYTE *)&v39[1].buf + v49);
  374.         v51 = v50 - 48;
  375.         if ( (unsigned __int8)(v50 - 48) > 9u )
  376.         {
  377.           if ( (unsigned __int8)(v50 - 97) > 5u )
  378.           {
  379.             if ( (unsigned __int8)(v50 - 65) > 5u )
  380.               break;
  381.             v51 = v50 - 55;
  382.           }
  383.           else
  384.           {
  385.             v51 = v50 - 87;
  386.           }
  387.         }
  388.         v39 = l_k__;
  389.         ++v49;
  390.         c2 = v51 + 16 * c2;
  391.       }
  392.       while ( v49 < 8 );
  393.       c1 = 0;
  394.       v53 = 0;
  395.       do
  396.       {
  397.         v54 = *((_BYTE *)&l_k__[1].buf + v53);
  398.         v55 = v54 - 48;
  399.         if ( (unsigned __int8)(v54 - 48) > 9u )
  400.         {
  401.           if ( (unsigned __int8)(v54 - 97) > 5u )
  402.           {
  403.             if ( (unsigned __int8)(v54 - 65) > 5u )
  404.               break;
  405.             v55 = v54 - 55;
  406.           }
  407.           else
  408.           {
  409.             v55 = v54 - 87;
  410.           }
  411.         }
  412.         ++v53;
  413.         c1 = v55 + 16 * c1;
  414.       }
  415.       while ( v53 < 8 );
  416.       v56 = l_k__;
  417.       k[2] = (((c1 >> 16) | c2 & 0xFF0000) >> 8) | ((((_DWORD)o << 16) | (unsigned __int16)((unsigned __int16)t0 & 0xFF00)) << 8);
  418.       v57 = 0;
  419.       v58 = 0;
  420.       do
  421.       {
  422.         v59 = *((_BYTE *)&l_k__[2].ind + v58);
  423.         v60 = v59 - 48;
  424.         if ( (unsigned __int8)(v59 - 48) > 9u )
  425.         {
  426.           if ( (unsigned __int8)(v59 - 97) > 5u )
  427.           {
  428.             if ( (unsigned __int8)(v59 - 65) > 5u )
  429.               break;
  430.             v60 = v59 - 55;
  431.           }
  432.           else
  433.           {
  434.             v60 = v59 - 87;
  435.           }
  436.         }
  437.         ++v58;
  438.         v57 = v60 + 16 * v57;
  439.       }
  440.       while ( v58 < 8 );
  441.       v61 = 0;
  442.       t0 = (struct_1 *)v57;
  443.       v62 = 0;
  444.       do
  445.       {
  446.         v63 = *((_BYTE *)&l_k__[2].ind + v62);
  447.         v64 = v63 - 48;
  448.         if ( (unsigned __int8)(v63 - 48) > 9u )
  449.         {
  450.           if ( (unsigned __int8)(v63 - 97) > 5u )
  451.           {
  452.             if ( (unsigned __int8)(v63 - 65) > 5u )
  453.               break;
  454.             v64 = v63 - 55;
  455.           }
  456.           else
  457.           {
  458.             v64 = v63 - 87;
  459.           }
  460.         }
  461.         ++v62;
  462.         v61 = v64 + 16 * v61;
  463.       }
  464.       while ( v62 < 8 );
  465.       d2 = 0;
  466.       o = (struct_1 *)v61;
  467.       v66 = 0;
  468.       do
  469.       {
  470.         v67 = *((_BYTE *)&v56[2].ind + v66);
  471.         v68 = v67 - 48;
  472.         if ( (unsigned __int8)(v67 - 48) > 9u )
  473.         {
  474.           if ( (unsigned __int8)(v67 - 97) > 5u )
  475.           {
  476.             if ( (unsigned __int8)(v67 - 65) > 5u )
  477.               break;
  478.             v68 = v67 - 55;
  479.           }
  480.           else
  481.           {
  482.             v68 = v67 - 87;
  483.           }
  484.         }
  485.         v56 = l_k__;
  486.         ++v66;
  487.         d2 = v68 + 16 * d2;
  488.       }
  489.       while ( v66 < 8 );
  490.       d1 = 0;
  491.       v70 = 0;
  492.       do
  493.       {
  494.         v71 = *((_BYTE *)&l_k__[2].ind + v70);
  495.         v72 = v71 - 48;
  496.         if ( (unsigned __int8)(v71 - 48) > 9u )
  497.         {
  498.           if ( (unsigned __int8)(v71 - 97) > 5u )
  499.           {
  500.             if ( (unsigned __int8)(v71 - 65) > 5u )
  501.               break;
  502.             v72 = v71 - 55;
  503.           }
  504.           else
  505.           {
  506.             v72 = v71 - 87;
  507.           }
  508.         }
  509.         ++v70;
  510.         d1 = v72 + 16 * d1;
  511.       }
  512.       while ( v70 < 8 );
  513.       ctxmd4.state[0] = 0x67452301u;
  514.       k[3] = (((d1 >> 16) | d2 & 0xFF0000) >> 8) | (((unsigned __int16)((unsigned __int16)o & 0xFF00) | ((_DWORD)t0 << 16)) << 8);
  515.       ctxmd4.state[1] = 0xEFCDAB89u;
  516.       ctxmd4.state[2] = 0x98BADCFEu;
  517.       ctxmd4.state[3] = 0x10325476u;
  518.       ctxmd4.total[0] = 0;
  519.       ctxmd4.total[1] = 0;
  520.       md4_update(&ctxmd4, (int)tmp0, strlen((const char *)tmp0));
  521.       md4_result((int)&hash2, (int)&ctxmd4);
  522.       aes_128_set_key((int)&hash2, &ctxaes128);
  523.       aes_ecb_decrypt((int)k, (int)k, &ctxaes128);
  524.       *(_DWORD *)(dword_5B087C + 0x234) = 16;
  525.       n = (struct_1 *)malloc_ctx(0);
  526.       n_ = n;
  527.       l_k = (struct_1 *)malloc_ctx(0);
  528.       l_k__ = l_k;
  529.       e = (struct_1 *)malloc_ctx(0x10001u);
  530.       t0 = e;
  531.       inv(0x200u, (BYTE *)N_MODULE, n);
  532.       inv(0x10u, (BYTE *)k, l_k);
  533.       enc = (struct_1 *)malloc_ctx(0);
  534.       o = enc;
  535.       rsa_encrypt(v2, n, l_k__, e, n, enc);
  536.       v77 = (struct_1 *)malloc_ctx(0);
  537.       sub_402DF0(v2, 0x1000u, v77);
  538.       v78 = strcmp(enc, v77);
  539.       tmp0 = (struct_1 *)malloc_ctx(v78 == 0);
  540.       inv_to_buf(0x200u, (int)enc, &DATA_BY_3h_BYTES, 1);
  541.       ctxmd4.state[0] = 0x67452301u;
  542.       ctxmd4.state[1] = 0xEFCDAB89u;
  543.       ctxmd4.state[2] = 0x98BADCFEu;
  544.       ctxmd4.state[3] = 0x10325476u;
  545.       ctxmd4.total[0] = 0;
  546.       ctxmd4.total[1] = 0;
  547.       md4_update(&ctxmd4, (int)&DATA_BY_3h_BYTES, 0x200u);
  548.       md4_result((int)&hash2, (int)&ctxmd4);
  549.       v79 = &HARD_HASH;
  550.       v80 = &hash2;
  551.       v81 = 0xCu;
  552.       while ( *v79 == *(_DWORD *)v80 )
  553.       {
  554.         ++v79;
  555.         v80 += 4;
  556.         f = v81 < 4;
  557.         v81 -= 4;
  558.         if ( f )
  559.         {
  560.           v83 = 1;
  561.           goto next2;
  562.         }
  563.       }
  564.       v83 = 0;
  565. next2:
  566.       v84 = (struct_1 *)malloc_ctx(v83);
  567.       v85 = strcmp(tmp0, v84) == 0;
  568.       es0 = (struct_1 *)malloc_ctx(0);
  569.       sub_402A40(es0, (BYTE *)n, es0);
  570.       i0 = 7;
  571.       do
  572.       {
  573.         es1 = sub_4035B0(es0);
  574.         sub_402F00(es0, -es1, es0);
  575.         --i0;
  576.       }
  577.       while ( i0 );
  578.       sub_402B20(es0, 9 * v85, es0);
  579.       exp1 = t0;
  580.       sub_402AB0(v2, t0, (BYTE *)es0, t0);
  581.       v90 = (int)o;
  582.       rsa_encrypt(v2, 0, l_k__, exp1, n_, o);
  583.       inv_to_buf(0x200u, v90, &DATA_BY_3h_BYTES, 1);
  584.       hard_hash_list = (DWORD *)&HARD_HASH_LIST;
  585.       data_3h = (int)&DATA_BY_3h_BYTES;
  586. loop:
  587.       ctxmd4.total[1] = 0;
  588.       ctxmd4.total[0] = 0;
  589.       ctxmd4.state[0] = 0x67452301u;
  590.       ctxmd4.state[1] = 0xEFCDAB89u;
  591.       ctxmd4.state[2] = 0x98BADCFEu;
  592.       ctxmd4.state[3] = 0x10325476u;
  593.       md0_update(&ctxmd4, data_3h, 3u);
  594.       md0_result(&ctxmd4, (struct_1 *)&hash2);
  595.       p1 = hard_hash_list;
  596.       p2 = (DWORD *)&hash2;
  597.       len = 0xCu;
  598.       while ( *p1 == *p2 )
  599.       {
  600.         ++p1;
  601.         ++p2;
  602.         f = len < 4;
  603.         len -= 4;
  604.         if ( f )
  605.         {
  606.           data_3h += 3;
  607.           hard_hash_list += 4;
  608.           if ( data_3h < (signed int)&END_DATA_BY_3h_BYTES )
  609.             goto loop;
  610.           inv_to_buf(0x10u, (int)l_k__, &v107, 1);
  611.           aes_128_set_key((int)&v107, &ctxaes128);
  612.           ii = 0;
  613.           do
  614.           {
  615.             aes_ecb_decrypt((int)&(&TEXT)[ii], (int)&Text[ii], &ctxaes128);
  616.             ii += 0x10u;
  617.           }
  618.           while ( ii < (signed int)0x80u );
  619.           MessageBoxA(0, Text, dword_584188, 0);
  620.           return 1;
  621.         }
  622.       }
  623.       return 0;
  624.     }
  625.   }
  626. }
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!