SHARE
TWEET

hrjg23kjg42

a guest Jul 22nd, 2014 94 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  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. }
RAW Paste Data
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!
 
Top