Want more features on Pastebin? Sign Up, it's FREE!
Guest

unpack-4142.c

By: a guest on Jun 2nd, 2011  |  syntax: C  |  size: 27.36 KB  |  views: 1,436  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. /*\
  2. |*|
  3. |*| Skype 4142 Decompression v1.002 by Sean O'Neil.
  4. |*| Copyright (c) 2004-2009 by VEST Corporation.
  5. |*| All rights reserved. Strictly Confidential!
  6. |*|
  7. |*| Date: 29.10.2009
  8. |*|
  9. \*/
  10.  
  11. #include "skype_basics.h"
  12. #pragma warning(disable:4311 4312)
  13.  
  14. u8 unpack_42_CF2848[8] = {0, 0, 0, 0, '%', 's', 0, 0};
  15.  
  16. extern void * malloc_719490(void * *the_ptr, u32 bytes);
  17. extern u32 pack_42_find_code_76A070(u32 *code_array, u32 look_for);
  18. extern u32 pack_42_init_769FB0(u32 ctx);
  19. extern u32 pack_42_thing1_E3B7F4[];
  20. extern u16 pack_42_word_E3B7A0[];
  21. extern u32 pack_42_thing2_E3B804[];
  22. extern u16 * pack_42_word_off_E3B748[];
  23.  
  24. char *unpack_42_off_E3B054[11] =
  25. {
  26.     "",
  27.     "tdmhkpcgwbzfvjq",
  28.     "eaiouy",
  29.     "nrlsx",
  30.     "0216345789",
  31.     "SMTBRLNPKCDHGJWFVZXQ",
  32.     "AEIOUY",
  33.     " ",
  34.     "\x82\x99\xB8\xB3\xA9\x81\xBC\x9C\x85\x95\xA1\x9B\xA8\x84\xB0\x90\x80\xB6\x94\xA4\x91\xBA\x9E\x9A\xA0\xB5\xBD\xBE\xA7\x9D\x97\xA5\x9F\xAA\xB1\x83\x8C\x93\xB2\x98\xA6\xA2\xBB\x88\xAD\x96\x8F\xB4\xA3\x92\xBF\x87\xB7\x8B\x8D\xB9\x89\x8A\x8E\xAE\x86\xAC\xAB\xAF",
  35.     "\xD7\xC3\xD0\xC5\xE5\xC4\xE3\xD1\xE6\xE7\xEC\xE4\xE8\xEF\xE9\xD9\xD8\xEB\xEA\xE2\xC2\xE0\xED\xC6\xDB\xE1\xCE\xCF\xC0\xC1\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xD2\xD3\xD4\xD5\xD6\xDA\xDC\xDD\xDE\xDF\xEE\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF",
  36.     "\x2E\x2D\x2F\x5F\x21\x2B\x2C\x29\x3A\x28\x2A\x3F\x0D\x0A\x27\x26\x22\x3D\x3B\x7E\x40\x3E\x3C\x7C\x5E\x5D\x5B\x5C\x23\x60\x24\x25\x7B\x7D\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0B\x0C\x0E\x0F\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F\x7F"
  37. };
  38.  
  39. u8 Load_Byte(u32 ctx)
  40. {
  41.   u32 *bytes; // eax@1
  42.   u8 b; // al@4
  43.   u8 **byte_ptr; // ecx@5
  44. /*
  45.   u32 i;
  46.   u8 c[333*4];
  47.  
  48.   memcpy (c, (void *)ctx, sizeof(c));
  49.   dword(c,0x1F6) = 0xCCCCCCCC;
  50.   dword(c,0x1FA) = 0xCCCCCCCC;
  51.   dword(c,0x202) = 0xCCCCCCCC;
  52.   dword(c,0x20E) = 0xCCCCCCCC;
  53.   dword(c,0x212) = 0xCCCCCCCC;
  54.   dword(c,0x312) = 0xCCCCCCCC;
  55.   dword(c,0x51E) = 0xCCCCCCCC;
  56.   for (i = 0; i < 333*4; i++)
  57.   {
  58.       if ((i&15)==0) printf ("\n%04X:", i);
  59.       printf (" %02X", c[i]);
  60.   }
  61.   printf ("\n");
  62. */
  63.   bytes = (u32 *)dword(ctx,0x1FA);
  64.   if ( *bytes )
  65.   {
  66.     --*bytes;
  67.     byte_ptr = (u8 **)dword(ctx,0x1F6);
  68.     b = *(*byte_ptr)++;
  69.   }
  70.   else
  71.   {
  72.     ++dword(ctx,0x1FE);
  73.     if ( dword(ctx,0x1FE) > 3 ) dword(ctx,0x202) = 1;
  74.     b = 0;
  75.   }
  76.   return b;
  77. }
  78.  
  79. void unpack_42_769E50(u32 ctx)
  80. {
  81.   u32 v2; // al@2
  82.  
  83.   for ( ; dword(ctx,8) <= 0x800000; byte(ctx,12) = (u8)v2 )
  84.   {
  85.     dword(ctx,4) = (2 * dword(ctx,4) | byte(ctx,12) & 1) << 7;
  86.     v2 = Load_Byte(ctx);
  87.     dword(ctx,8) <<= 8;
  88.     dword(ctx,4) |= v2 >> 1;
  89.   }
  90. }
  91.  
  92. u32 pack_42_bits_769F30(u32 ctx, u8 bits)
  93. {
  94.   u32 result; // eax@1
  95.   u32 v4; // edi@1
  96.  
  97.   unpack_42_769E50(ctx);
  98.   v4 = dword(ctx,8) >> bits;
  99.   result = dword(ctx,4) / v4;
  100.   if ( result >> bits ) result = (1 << bits) - 1;
  101.   dword(ctx,4) -= v4 * result;
  102.   if ( (result + 1) >> bits ) dword(ctx,8) -= v4 * result; else dword(ctx,8) = v4;
  103.   return result;
  104. }
  105.  
  106. u32 unpack_42_769EA0(u32 ctx, u16 *word_array)
  107. {
  108.   u32 v2; // ecx@1
  109.   u32 v3; // ebx@1
  110.   u32 v6; // eax@3
  111.   u32 result; // eax@5
  112.   u32 v8; // ecx@5
  113.   u32 v9; // ebp@5
  114.  
  115.   unpack_42_769E50(ctx);
  116.   v3 = dword(ctx,8) >> 12;
  117.   v2 = dword(ctx,4) / v3;
  118.   if ( v2 & 0xFFFFF000 ) v2 = 0xFFF;
  119.   v6 = 1;
  120.   if ( word_array[1] <= v2 ) while ( word_array[++v6] <= v2 );
  121.   v8 = word_array[v6];
  122.   v9 = word_array[v6-1];
  123.   result = v6 - 1;
  124.   dword(ctx,4) -= v3 * v9;
  125.   if ( v8 & 0xFFFFF000 ) dword(ctx,8) -= v3 * v9;
  126.   else dword(ctx,8) = v3 * (v8 - v9);
  127.   return result;
  128. }
  129.  
  130. u32 unpack_42_769F30(u32 ctx, u32 bits)
  131. {
  132.   u32 result; // eax@1
  133.   u32 v4; // edi@1
  134.  
  135.   unpack_42_769E50(ctx);
  136.   v4 = dword(ctx,8) >> bits;
  137.   result = dword(ctx,4) / v4;
  138.   if ( (u32)result >> bits ) result = (1 << bits) - 1;
  139.   dword(ctx,4) -= v4 * result;
  140.   if ( (u32)(result + 1) >> bits ) dword(ctx,8) -= v4 * result;
  141.   else dword(ctx,8) = v4;
  142.   return result;
  143. }
  144.  
  145. u32 unpack_42_dword_76ADE0(u32 ctx, u32 *word_ptr, u32 a3)
  146. {
  147.   u32 result; // eax@1
  148.   u32 v5;
  149.   u32 v6; // esi@2
  150.   u32 v7; // eax@4
  151.   u32 v8; // edi@4
  152.   u32 v9; // ebp@7
  153.   u32 v10; // edi@7
  154.   u32 v11; // esi@7
  155.   u32 v15; // ebx@11
  156.   u32 v16; // edx@11
  157.  
  158.   result = unpack_42_769EA0(ctx, (u16 *)word_ptr[3]);
  159.   if ( result >= ((u32)1 << word_ptr[1]) )
  160.   {
  161.     v6 = result - word_ptr[2];
  162.     if ( v6 >= word_ptr[0] )
  163.     {
  164.       if ( a3 || (v7 = unpack_42_dword_76ADE0(ctx, word_ptr, 1), v8 = word_ptr[0], v7 > 32 - v8) )
  165.       {
  166.         dword(ctx,0x202) = 1;
  167.         return 0;
  168.       }
  169.       v6 = v8 + v7;
  170.     }
  171.     v11 = v6 - 1;
  172.     v9 = 1 << v11;
  173.     v10 = 0;
  174.     if ( v6 > 1 )
  175.     {
  176.       v5 = 16;
  177.       do
  178.       {
  179.         v15 = __min ( v11 - v10, 16 );
  180.         v16 = (u16)unpack_42_769F30(ctx, v15) << (u8)v10;
  181.         v10 += v15;
  182.         v9 += v16;
  183.       }
  184.       while ( v10 < v11 );
  185.     }
  186.     result = v9;
  187.   }
  188.   return result;
  189. }
  190.  
  191. u32 unpack_42_76AEA0(u32 a1, u32 ctx)
  192. {
  193.   u32 v2; // eax@1
  194.   u32 result; // eax@2
  195.  
  196.   v2 = dword(ctx,0x20E);
  197.   if ( *(u32 *)v2 >= a1 )
  198.   {
  199.     *(u32 *)v2 -= a1;
  200.     result = 1;
  201.   }
  202.   else
  203.   {
  204.     dword(ctx,0x202) = 1;
  205.     result = 0;
  206.   }
  207.   return result;
  208. }
  209.  
  210. void unpack_42_from_9944D0(u32 *where_from)
  211. {
  212.   u32 v3, *where_to; // eax@2
  213.  
  214.   v3 = where_from[65] + 1;
  215.   if ( v3 > where_from[66] )
  216.   {
  217.     v3 = where_from[65] + 32;
  218.     where_from[66] = v3;
  219.     if ( where_from[64] == (u32)where_from ) where_from[64] = 0;
  220.     where_to = (u32 *)where_from[64];
  221.     malloc_719490((void * *)&where_to, 8 * v3);
  222.     if ( !where_from[64] ) memcpy(where_to, where_from, 8 * where_from[65]);
  223.     where_from[64] = (u32)where_to;
  224.   }
  225. }
  226.  
  227. u32 *unpack_42_from_951460(u32 *where_from)
  228. {
  229.   u32 *result; // eax@3
  230.  
  231.   if ( where_from[65] >= where_from[66] ) unpack_42_from_9944D0(where_from);
  232.   result = (u32 *) (where_from[64] + 8 * where_from[65]);
  233.   where_from[65]++;
  234.   if ( result )
  235.   {
  236.     result[0] = 0;
  237.     result[1] = 0;
  238.   }
  239.   return result;
  240. }
  241.  
  242. void unpack_42_inc_85BEE0(u32 increment, u32 ctx)
  243. {
  244.   u32 v3; // eax@1
  245.   u32 v4; // eax@2
  246.   u32 v5; // esi@4
  247.   u32 v7; // [sp+0h] [bp-4h]@1
  248.  
  249.   v3 = increment + dword(ctx,0x204);
  250.   if ( (u32)v3 > dword(ctx,0x208) )
  251.   {
  252.     v4 = v3 + 0x1FF;
  253.     dword(ctx,0x208) = v4;
  254.     if (dword(ctx,0x200) == ctx) dword(ctx,0x200) = 0;
  255.     v7 = dword(ctx,0x200);
  256.     malloc_719490((void * *)&v7, v4);
  257.     v5 = v7;
  258.     if ( !dword(ctx,0x200) ) memcpy((void *)v7, (void *)ctx, dword(ctx,0x204));
  259.     dword(ctx,0x200) = v5;
  260.   }
  261. }
  262.  
  263. u32 unpack_42_byte_85BDC0(u32 ctx, u32 the_byte)
  264. {
  265.   u32 str; // eax@3
  266.   u32 v4; // ecx@3
  267.   u32 v5; // eax@3
  268.  
  269.   if ( dword(ctx,0x204) >= dword(ctx,0x208) ) unpack_42_inc_85BEE0(1, ctx);
  270.   v4 = dword(ctx,0x204);
  271.   v5 = dword(ctx,0x200);
  272.   str = v4 + v5;
  273.   dword(ctx,0x204) = v4 + 1;
  274.   if (str) *(u8 *)str = *(u8 *)the_byte;
  275.   return str;
  276. }
  277.  
  278. void unpack_42_inc_76AD90(u32 ctx, u32 increment)
  279. {
  280.   u32 *v2; // ecx@1
  281.  
  282.   v2 = (u32 *)dword(ctx,0x1FA);
  283.   dword(ctx,0x206) += increment;
  284.   if ( *v2 < increment )
  285.   {
  286.     dword(ctx,0x1FE) += increment - *v2;
  287.     *(u8 **)dword(ctx,0x1F6) += *v2 - increment;
  288.     *(u32 *)dword(ctx,0x1FA) = 0;
  289.     if ( dword(ctx,0x1FE) > 3 ) dword(ctx,0x202) = 1;
  290.   }
  291.   else
  292.   {
  293.     *v2 -= increment;
  294.   }
  295. }
  296.  
  297. u32 *unpack_41_dword_715D70(u32 *a1, u32 a3)
  298. {
  299.   u32 v3; // eax@1
  300.   u32 v6; // edi@3
  301.   u32 *result; // eax@6
  302.   u32 *v8; // eax@6
  303.  
  304.   v3 = a1[2];
  305.   if ( v3 >= a1[1] )
  306.   {
  307.     if ( v3 >= 8 ) v6 = (((v3 >= 32) - 1) & -24) + 32; else v6 = 4;
  308.     malloc_719490((void * *)a1, 16 * (v6 + v3));
  309.     a1[1] += v6;
  310.   }
  311.   memmove((void *) (16 * a3 + a1[0] + 16), (void *) (16 * a3 + a1[0]), 16 * (a1[2] - a3));
  312.   v8 = (u32 *)a1[0];
  313.   ++a1[2];
  314.   result = v8 + 4 * a3;
  315.   if ( result )
  316.   {
  317.     result[0] = 0;
  318.     result[1] = 0;
  319.     result[2] = 0;
  320.   }
  321.   return result;
  322. }
  323.  
  324. u32 *unpack_42_dword_714540(u32 *a1, u32 a3, u32 a4)
  325. {
  326.   u32 *result; // eax@1
  327.  
  328.   result = unpack_41_dword_715D70(a1 + 1, a1[3]);
  329.   result[0] = 0;
  330.   result[1] = a3;
  331.   result[2] = a4;
  332.   return result;
  333. }
  334.  
  335. u32 *unpack_42_5_7147B0(u32 * a1, u32 a3)
  336. {
  337.   u32 *the_thing; // eax@1
  338.   u32 *v4; // esi@1
  339.   u32 *v5; // eax@1
  340.  
  341.   v5 = unpack_41_dword_715D70(a1 + 1, a1[3]);
  342.   v4 = v5;
  343.   v5[0] = 5;
  344.   v5[1] = a3;
  345.   the_thing = (u32 *)malloc(16);
  346.   if ( the_thing )
  347.   {
  348.     the_thing[0] = -1;
  349.     the_thing[1] = 0;
  350.     the_thing[2] = 0;
  351.     the_thing[3] = 0;
  352.     v4[2] = (u32)the_thing;
  353.   }
  354.   else
  355.   {
  356.     the_thing = 0;
  357.     v4[2] = 0;
  358.   }
  359.   return the_thing;
  360. }
  361.  
  362. u32 *unpack_42_3_7145D0(u32 *a1, const u8 *a2, u32 skype_id, u32 a5)
  363. {
  364.   u32 *v5; // eax@1
  365.   u32 *v8; // esi@1
  366.   u8 *v9; // eax@4
  367.  
  368.   v5 = unpack_41_dword_715D70(a1 + 1, *(a1 + 3));
  369.   v8 = v5;
  370.   v5[0] = 3;
  371.   v5[1] = skype_id;
  372.   if ( !a2 ) a2 = unpack_42_CF2848;
  373.   v5[3] = a5 + 1;
  374.   if ( a5 )
  375.   {
  376.     v9 = memchr(a2, 0, a5);
  377.     if ( v9 ) *(v8 + 3) = (u32) (v9 - a2 + 1);
  378.   }
  379.   v8[2] = (u32)malloc(v8[3]);
  380.   memcpy((void *)v8[2], a2, v8[3]);
  381.   *(u8 *)(*(v8 + 3) + *(v8 + 2) - 1) = 0;
  382.   return v8;
  383. }
  384.  
  385. void unpack_42_6_7393A0(u32 *context, u32 a2)
  386. {
  387.   u32 *v8; // ebp@1
  388.   u32 *v9; // eax@4
  389.   void *v10; // esi@14
  390.   u32 *v11; // eax@15
  391.   void *v13; // [sp+8h] [bp-4h]@14
  392.  
  393.   v8 = context + 33;
  394.   if ( a2 != *(context + 33) )
  395.   {
  396.     if ( (u32)a2 > 32 )
  397.     {
  398.     // if ( (u32)a2 > 0x3FFFFFFF ) __asm int 3;
  399.       *(context + 34) = a2;
  400.       if ( *(context + 32) == (u32)context ) *(context + 32) = 0;
  401.       v13 = (void *)*(context + 32);
  402.       malloc_719490(&v13, 4 * a2);
  403.       v10 = v13;
  404.       if ( !*(context + 32) )
  405.       {
  406.         v11 = &a2;
  407.         if ( a2 >= *v8 ) v11 = (u32 *)(context + 33);
  408.         memcpy(v13, context, 4 * *v11);
  409.       }
  410.       *(context + 32) = (u32)v10;
  411.       *v8 = a2;
  412.     }
  413.     else
  414.     {
  415.       if ( *(context + 32) != (u32)context )
  416.       {
  417.         v9 = &a2;
  418.         if ( a2 >= *v8 ) v9 = (u32 *)(context + 33);
  419.         memcpy(context, (void *)*(context + 32), 4 * *v9);
  420.         if ( *(context + 32) ) free((void *)*(context + 32));
  421.         *(context + 32) = (u32)context;
  422.       }
  423.       *v8 = a2;
  424.       *(context + 34) = 32;
  425.     }
  426.   }
  427. }
  428.  
  429. void unpack_42_end_context_720CA0(u32 *context)
  430. {
  431.   if ( context[32] != (u32)context )
  432.   {
  433.     if ( context[32] ) free((void *)context[32]);
  434.     context[32] = (u32)context;
  435.   }
  436.   context[33] = 0;
  437.   context[34] = 32;
  438. }
  439.  
  440. u32 *unpack_42_6_714690(u32 *a1, u32 dwords, u32 skype_id, u32 a4)
  441. {
  442.   u32 *v6; // eax@1
  443.   u32 *v8; // esi@1
  444.   u32 v9; // ecx@2
  445.   u32 v13; // qax@1
  446.  
  447.   v13 = 4 * dwords;
  448. // if (v13 < dwords) __asm int 3;
  449.   v8 = unpack_41_dword_715D70(a1 + 1, *(a1 + 3));
  450.   v8[0] = 6;
  451.   v8[1] = skype_id;
  452.   v8[3] = 4 * dwords;
  453.   v6 = (u32 *)malloc(v13);
  454.   v8[2] = (u32)v6;
  455.   if ( dwords )
  456.   {
  457.     v9 = a4 - (u32)v6;
  458.     do
  459.     {
  460.       *v6 = *(u32 *)((u8 *)v6 + v9);
  461.       ++v6;
  462.       --dwords;
  463.     }
  464.     while ( dwords );
  465.   }
  466.   return v8;
  467. }
  468.  
  469. void unpack_42_list_76B1B0(u32 ctx, u32 *into_list, u32 a3)
  470. {
  471.   u32 *v4; // eax@3
  472.   u32 *v5; // esi@5
  473.   u32 *v6; // ecx@10
  474.   u32 v7; // ebx@10
  475.   u32 v8; // eax@11
  476.   u32 v9; // edi@14
  477.   u32 v10; // ebx@16
  478.   u32 v12; // eax@21
  479.   u16 **v13; // edi@25
  480.   u32 v14; // eax@26
  481.   u32 v15; // eax@27
  482.   u32 v17; // esi@27
  483.   u8 v18; // bl@29
  484.   u32 v20; // eax@38
  485.   u32 v21; // ebx@38
  486.   u32 v22; // esi@41
  487.   u32 increment; // esi@45
  488.   u32 v25; // eax@5
  489.   u32 v26; // eax@7
  490.   u32 v33; // ebx@17
  491.   u32 v34; // eax@23
  492.   u32 v35; // ST08_4@24
  493.   u32 *v36; // eax@24
  494.   char *v39; // ecx@29
  495.   u32 v40; // edi@43
  496.   u32 v41; // eax@45
  497.   u32 *v42; // eax@48
  498.   u32 *v44; // eax@48
  499.   u32 v45; // ecx@48
  500.   u32 v46; // eax@52
  501.   u32 v50; // [sp+28h] [bp-9Ch]@3
  502.   u32 v52; // [sp+24h] [bp-A0h]@5
  503.   u8 skype_id[5]; // [sp+17h] [bp-ADh]@8
  504.   u32 context[37]; // [sp+2Ch] [bp-98h]@41
  505.  
  506.   if ( a3 >= dword(ctx,0x1F2) ) goto LABEL_2;
  507.   v50 = 2;
  508.   v4 = &v50;
  509.   if ( a3 <= 2 ) v4 = &a3;
  510.   v25 = *v4;
  511.   v5 = &dword(ctx,18+160*v25);
  512.   v52 = 0;
  513.   if ( a3 )
  514.   {
  515.     if ( v5[39] )
  516.     {
  517.       v26 = unpack_42_dword_76ADE0(ctx, pack_42_thing1_E3B7F4, 0);
  518.       v52 = v26;
  519.       if (v26 > v5[39])
  520.       {
  521. LABEL_2:
  522.         dword(ctx,0x202) = 1;
  523.         return;
  524.       }
  525.     }
  526.   }
  527.   v5[39] = 0;
  528.   *(u32 *)(skype_id+1) = 0;
  529.   if ( dword(ctx,0x202) == 0 )
  530.   {
  531.     while ( 1 )
  532.     {
  533.       if ( !v52 )
  534.       {
  535.         v8 = unpack_42_769EA0(ctx, pack_42_word_E3B7A0);
  536.         if ( !v8 ) return;
  537.         if ( (u32)v8 > 6 )
  538.         {
  539.           v10 = v8 - 6;
  540.           v9 = unpack_42_dword_76ADE0(ctx, pack_42_thing1_E3B7F4, 0);
  541.           if ( v10 )
  542.           {
  543.             v33 = v5[v10];
  544.             memmove(v5 + 1, v5, 4 * v10);
  545.             v5[0] = v33;
  546.           }
  547.         }
  548.         else
  549.         {
  550.           if ( v8 != 6 ) v9 = v8 - 1;
  551.           else v9 = unpack_42_dword_76ADE0(ctx, pack_42_thing1_E3B7F4, 0) + 5;
  552.         }
  553.         v7 = v5[0];
  554.         *(u32 *)(skype_id+1) += v9;
  555.       }
  556.       else
  557.       {
  558.         v7 = v5[v5[39]*2+8];
  559.         --v52;
  560.         *(u32 *)(skype_id+1) = v5[v5[39]*2+7];
  561.         pack_42_find_code_76A070(v5, v7);
  562.       }
  563.       if ( v5[39] < 16 )
  564.       {
  565.         v6 = *(u32 **)(skype_id+1);
  566.         v5[v5[39]*2+7] = *(u32 *)(skype_id+1);
  567.         v5[8+2*v5[39]++] = v7;
  568.       }
  569.       v12 = dword(ctx,0x20E);
  570.       if ( *(u32 *)v12 < 16 ) goto LABEL_2;
  571.       *(u32 *)v12 -= 16;
  572.       switch ( v7 )
  573.       {
  574.         case 0:
  575.           v34 = unpack_42_dword_76ADE0(ctx, pack_42_thing2_E3B804, 0);
  576.           unpack_42_dword_714540(into_list, *(u32 *)(skype_id+1), v34);
  577.           goto LABEL_50;
  578.         case 5:
  579.           v35 = a3 + 1;
  580.           v36 = unpack_42_5_7147B0(into_list, *(u32 *)(skype_id+1));
  581.           unpack_42_list_76B1B0(ctx, v36, v35);
  582.           goto LABEL_50;
  583.         case 3:
  584.           v13 = pack_42_word_off_E3B748;
  585.           v50 = 0;
  586.           while ( 2 )
  587.           {
  588.             v14 = dword(ctx,0x20E);
  589.             if ( *(u32 *)v14 < 1 )
  590.             {
  591. LABEL_39:
  592.               dword(ctx,0x202) = 1;
  593.               goto LABEL_50;
  594.             }
  595.             --*(u32 *)v14;
  596.             v17 = unpack_42_769EA0(ctx, v13[1]);
  597.             v13 = pack_42_word_off_E3B748 + 2 * v17;
  598.             v15 = 0;
  599.             if ( (*v13)[1] != 0x1000 ) v15 = unpack_42_769EA0(ctx, v13[0]);
  600.             v39 = unpack_42_off_E3B054[v17];
  601.             v18 = v39[v15];
  602.             skype_id[0] = v39[v15];
  603.             if ( dword(ctx,0x202) != 0 )
  604.             {
  605.               v18 = 0;
  606.               skype_id[0] = 0;
  607.             }
  608.             if ( (u32)v50 >= dword(ctx,0x522) ) unpack_42_byte_85BDC0(ctx + 0x31E, (u32)skype_id);
  609.             else *(u8 *)(v50 + dword(ctx,0x51E)) = v18;
  610.             if ( !v18 ) break;
  611.             v50++;
  612.           }
  613.           if ( !dword(ctx,0x202) ) unpack_42_3_7145D0(into_list, (const u8 *)dword(ctx,0x51E), *(u32 *)(skype_id+1), 0x7FFFFFFF);
  614.           goto LABEL_49;
  615.         case 6:
  616.           v20 = unpack_42_dword_76ADE0(ctx, pack_42_thing2_E3B804, 0);
  617.           v21 = v20;
  618.           if ( (u32)v20 > 0x3FFFFFFF ) goto LABEL_39;
  619.           if ( !unpack_42_76AEA0(4 * v20, ctx) ) goto LABEL_50;
  620.           v22 = 0;
  621.           context[32] = (u32)context;
  622.           context[33] = 0;
  623.           context[34] = 32;
  624.           unpack_42_6_7393A0(context, v21);
  625.           if ( !v21 ) goto LABEL_44;
  626.           break;
  627.         case 4:
  628.           v41 = unpack_42_dword_76ADE0(ctx, pack_42_thing2_E3B804, 0);
  629.           increment = v41;
  630.           unpack_42_76AEA0(v41, ctx);
  631.           goto LABEL_46;
  632.         case 1:
  633.           v46 = unpack_42_dword_76ADE0(ctx, pack_42_thing2_E3B804, 0);
  634.           increment = v46;
  635.           if ( v46 > 8 ) dword(ctx,0x202) = 1;
  636. LABEL_46:
  637.           if ( increment < -1 ) goto LABEL_47;
  638.           goto LABEL_49;
  639.         case 2:
  640.           increment = 6;
  641. LABEL_47:
  642.           if ( !dword(ctx,0x202) )
  643.           {
  644.             v42 = unpack_42_from_951460(&dword(ctx,0x212));
  645.             v42[0] = (u32)into_list;
  646.             v42[1] = into_list[3];
  647.             v44 = unpack_41_dword_715D70(into_list + 1, into_list[3]);
  648.             v45 = *(u32 *)(skype_id+1);
  649.             v44[0] = 2;
  650.             v44[1] = v45;
  651.             v44[2] = increment;
  652.             v44[3] = v7;
  653.             unpack_42_inc_76AD90(ctx, increment);
  654.           }
  655.           goto LABEL_49;
  656.         default:
  657.           goto LABEL_50;
  658.       }
  659.       do
  660.       {
  661.         if ( dword(ctx,0x202) )
  662.         {
  663.           unpack_42_end_context_720CA0(context);
  664.           return;
  665.         }
  666.         v40 = context[32] + 4 * v22++;
  667.         *(u32 *)v40 = unpack_42_dword_76ADE0(ctx, pack_42_thing2_E3B804, 0);
  668.       }
  669.       while ( v22 < v21 );
  670. LABEL_44:
  671.       unpack_42_6_714690(into_list, v21, *(u32 *)(skype_id+1), context[32]);
  672.       unpack_42_end_context_720CA0(context);
  673. LABEL_49:
  674. LABEL_50:
  675.       if ( dword(ctx,0x202) ) return;
  676.     }
  677.   }
  678. }
  679.  
  680. void unpack_42_2_715200(u32 *the_thing, u32 a2, u32 a3)
  681. {
  682.   if ( (the_thing[0] == 3) || (the_thing[0] == 4) || (the_thing[0] == 6) )
  683.   {
  684.     if ( the_thing[2] ) free((void *)the_thing[2]);
  685.   }
  686.   else
  687.   {
  688.     if ( the_thing[0] == 5 )
  689.     {
  690.       if ( the_thing[2] ) Load_Byte(the_thing[2]);
  691.     }
  692.   }
  693.   the_thing[0] = 2;
  694.   the_thing[2] = a2;
  695.   the_thing[3] = a3;
  696. }
  697.  
  698. void unpack_42_4_715250(u32 bytes, u32 *the_thing, u32 blob)
  699. {
  700.   if ( the_thing[0] == 3 || the_thing[0] == 4 || the_thing[0] == 6 )
  701.   {
  702.     if ( the_thing[2] ) free((void *)the_thing[2]);
  703.   }
  704.   else
  705.   {
  706.     if ( the_thing[0] == 5 )
  707.     {
  708.       if ( the_thing[2] ) Load_Byte(the_thing[2]);
  709.     }
  710.   }
  711.   the_thing[0] = 4;
  712.   the_thing[2] = (u32)malloc(bytes);
  713.   the_thing[3] = bytes;
  714.   memcpy((void *)the_thing[2], (void *)blob, bytes);
  715. }
  716.  
  717. void unpack_42_1_7151B0(u32 *the_thing, u32 a2, u32 a3)
  718. {
  719.   if ( the_thing[0] == 3 || the_thing[0] == 4 || the_thing[0] == 6 )
  720.   {
  721.     if ( the_thing[2] ) free((void *)the_thing[2]);
  722.   }
  723.   else
  724.   {
  725.     if ( the_thing[0] == 5 )
  726.     {
  727.       if ( the_thing[2] ) Load_Byte(the_thing[2]);
  728.     }
  729.   }
  730.   the_thing[0] = 1;
  731.   the_thing[2] = a2;
  732.   the_thing[3] = a3;
  733. }
  734.  
  735. u32 unpack_42_76AEC0(u32 *list_size, u32 ctx, u32 *into_list)
  736. {
  737.   u32 v3;
  738.   u32 t2;
  739.   u32 t3;
  740.   u32 v7; // eax@5
  741.   u32 v8; // eax@9
  742.   u32 v9; // eax@13
  743.   u32 v10; // edx@13
  744.   u32 *v12; // ecx@18
  745.   u32 *the_thing; // esi@19
  746.   u32 v17; // eax@37
  747.   u32 v18; // eax@41
  748.   u8 v19; // al@13
  749.   u32 *v22; // ecx@18
  750.   u8 *v24; // ecx@27
  751.   u64 the_qword; // [sp+14h] [bp-8h]@28
  752.  
  753.   dword(ctx,0x206) = 0;
  754.   dword(ctx,0x202) = 0;
  755.   dword(ctx,0x1FE) = 0;
  756.   dword(ctx,0x20A) = -1;
  757.   dword(ctx,0x20E) = (u32)list_size;
  758.   if ( Load_Byte(ctx) != 0x42 ) return 0;
  759.   v7 = dword(ctx,0x51E);
  760.   if ( v7 != ctx + 0x31E )
  761.   {
  762.     if ( v7 ) free((void *)dword(ctx,0x51E));
  763.     dword(ctx,0x51E) = ctx + 0x31E;
  764.   }
  765.   dword(ctx,0x522) = 0;
  766.   dword(ctx,0x526) = 0x200;
  767.   v8 = dword(ctx,0x312);
  768.   if ( v8 != ctx + 0x212 )
  769.   {
  770.     if ( v8 ) free((void *)dword(ctx,0x312));
  771.     dword(ctx,0x312) = ctx + 0x212;
  772.   }
  773.   dword(ctx,0x316) = 0;
  774.   dword(ctx,0x31A) = 32;
  775.   pack_42_init_769FB0(ctx);
  776.   v19 = Load_Byte(ctx);
  777.   byte(ctx,12) = v19;
  778.   dword(ctx,4) = (u32)v19 >> 1;
  779.   dword(ctx,8) = 128;
  780.   unpack_42_list_76B1B0(ctx, into_list, 0);
  781.   dword(ctx,8) >>= 1;
  782.   unpack_42_769E50(ctx);
  783.   v9 = dword(ctx,0x1FE);
  784.   if ( v9 <= 3 )
  785.   {
  786.     *(u8 **)dword(ctx,0x1F6) += v9 - 3;
  787.     v10 = 3 - dword(ctx,0x1FE);
  788.     *(u32 *)dword(ctx,0x1FA) += v10;
  789.     dword(ctx,0x1FE) = 0;
  790.   }
  791.   else
  792.   {
  793.     dword(ctx,0x202) = 1;
  794.   }
  795.   v3 = 0;
  796.   if ( dword(ctx,0x316) != 0 )
  797.   {
  798.     while ( 1 )
  799.     {
  800.       if ( dword(ctx,0x202) != 0 ) goto LABEL_37;
  801.       v22 = (u32 *)dword(ctx,0x312) + 2 * v3;
  802.       v12 = (u32 *)v22[0];
  803.       if ( v22[1] >= v12[3] )
  804.       {
  805.         the_thing = 0;
  806.       }
  807.       else
  808.       {
  809.         the_thing = (u32 *)v12[1] + 4 * v22[1];
  810.       }
  811.       t2 = the_thing[2];
  812.       t3 = the_thing[3];
  813.       if ( t2 > dword(ctx,0x206) )
  814.       {
  815.         dword(ctx,0x202) = 1;
  816.         goto LABEL_37;
  817.       }
  818.       if ( t3 == 1 ) break;
  819.       if ( t3 == 2 )
  820.       {
  821.         v24 = *(u8 **)dword(ctx,0x1F6);
  822.         unpack_42_2_715200(the_thing, v24[0]+((v24[1]+((v24[2]+(v24[3]<<8))<<8))<<8),v24[4]+(v24[5]<<8));
  823.       }
  824.       else
  825.       {
  826.         if ( t3 == 4 )
  827.         {
  828.           unpack_42_4_715250(t2, the_thing, *(u32 *)dword(ctx,0x1F6));
  829. LABEL_33:
  830.           goto LABEL_34;
  831.         }
  832.         // __asm int 3;
  833.       }
  834. LABEL_34:
  835.       *(u8 **)dword(ctx,0x1F6) += t2;
  836.       dword(ctx,0x206) -= t2;
  837.       if ( ++v3 >= dword(ctx,0x316) ) goto LABEL_37;
  838.     }
  839.     the_qword = 0;
  840.     if ( t2 )
  841.     {
  842.       memcpy ((void *)&the_qword, *(u8 **)dword(ctx,0x1F6), t2);
  843.     }
  844.     unpack_42_1_7151B0(the_thing, (u32)the_qword, (u32)(the_qword>>32));
  845.     goto LABEL_33;
  846.   }
  847. LABEL_37:
  848.   v17 = dword(ctx,0x312);
  849.   if ( v17 != ctx + 0x212 )
  850.   {
  851.     if ( v17 != 0 ) free((void *)dword(ctx,0x312));
  852.     dword(ctx,0x312) = ctx + 0x212;
  853.   }
  854.   dword(ctx,0x316) = 0;
  855.   dword(ctx,0x31A) = 32;
  856.   v18 = dword(ctx,0x51E);
  857.   if ( v18 != ctx + 0x31E )
  858.   {
  859.     if ( v18 != 0 ) free((void *)dword(ctx,0x51E));
  860.     dword(ctx,0x51E) = ctx + 0x31E;
  861.   }
  862.   dword(ctx,0x522) = 0;
  863.   dword(ctx,0x526) = 0x200;
  864.   return dword(ctx,0x202) == 0;
  865. }
  866.  
  867. u32 unpack_41_dword_896070(u32 *into_dword, u8 **packed_dword, u32 *packed_bytes)
  868. {
  869.   u32 v5; // esi@1
  870.   u8 v8; // dl@3
  871.  
  872.   *into_dword = 0;
  873.   v5 = 0;
  874.   while ( 1 )
  875.   {
  876.     if ( (*packed_bytes)-- == 0 ) break;
  877.     v8 = *(*packed_dword)++;
  878.     *into_dword |= (v8 & 127) << v5;
  879.     v5 += 7;
  880.     if ( v8 <= 127 ) return 1;
  881.   }
  882.   return 0;
  883. }
  884.  
  885. u32 * unpack_41_0_715D70(u32 *the_thing, u32 the_dword)
  886. {
  887.   u32 v2; // eax@1
  888.   u32 v5; // edi@3
  889.   u32 * new_thing; // eax@6
  890.   u32 * v7; // eax@6
  891.  
  892.   v2 = the_thing[2];
  893.   if ( v2 >= the_thing[1] )
  894.   {
  895.     if ( v2 >= 8 ) v5 = (((v2 >= 32) - 1) & -24) + 32; else v5 = 4;
  896.     malloc_719490((void * *)the_thing, 16 * (v5 + v2));
  897.     *(the_thing + 1) += v5;
  898.   }
  899.   memmove((void *)(16 * the_dword + *the_thing + 16), (void *)(16 * the_dword + *the_thing), 16 * (*(the_thing + 2) - the_dword));
  900.   v7 = (u32 *)*the_thing;
  901.   ++*(the_thing + 2);
  902.   new_thing = v7 + 4 * the_dword;
  903.   if ( new_thing )
  904.   {
  905.     new_thing[0] = 0;
  906.     new_thing[1] = 0;
  907.     new_thing[2] = 0;
  908.     new_thing[3] = 0;
  909.   }
  910.   return new_thing;
  911. }
  912.  
  913. u32 unpack_42_ctx_init_76ACD0(u32 max_depth, u32 ctx, u32 packed_blob, u32 packed_bytes)
  914. {
  915.   memset ((void *)ctx, 0xCC, 333*4);
  916.   dword(ctx,0x1F2) = max_depth;
  917.   dword(ctx,0x1FA) = packed_bytes;
  918.   dword(ctx,0x1F6) = packed_blob;
  919.   dword(ctx,0x312) = ctx + 0x212;
  920.   dword(ctx,0x316) = 0;
  921.   dword(ctx,0x31A) = 32;
  922.   dword(ctx,0x51E) = ctx + 0x31E;
  923.   dword(ctx,0x522) = 0;
  924.   dword(ctx,0x526) = 0x200;
  925.   return ctx;
  926. }
  927.  
  928. void unpack_42_ctx_end_714D90(u32 ctx)
  929. {
  930.   if ( dword(ctx,0x51E) != ctx + 0x31E )
  931.   {
  932.     if ( dword(ctx,0x51E) ) free(*(void * *)(ctx + 0x51E));
  933.     dword(ctx,0x51E) = ctx + 0x31E;
  934.   }
  935.   dword(ctx,0x522) = 0;
  936.   dword(ctx,0x526) = 0x200;
  937.   if ( *(void * *)(ctx + 0x312) != (void *)(ctx + 0x212) )
  938.   {
  939.     if ( *(void * *)(ctx + 0x312) ) free(*(void * *)(ctx + 0x312));
  940.     dword(ctx,0x312) = ctx + 0x212;
  941.   }
  942.   dword(ctx,0x316) = 0;
  943.   dword(ctx,0x31A) = 32;
  944.   *(u32 *)ctx = 0;
  945. }
  946.  
  947. u32 unpack_4142(u32 *into_list, u8 **packed_blob, u32 *packed_bytes, u8 *pack_42, u32 max_depth, u32 *list_size);
  948.  
  949. u32 unpack_41_715680(u8 **packed_blob, u32 *the_thing, u32 *packed_bytes, u32 max_depth, u32 *list_size)
  950. {
  951.     u32 *v9; // ebx@8
  952.     u8 *v12; // eax@16
  953.     u32 v15; // ecx@17
  954.     u32 v25; // ebx@35
  955.     u32 tt;
  956.    
  957.     --*packed_bytes;
  958.     if (*packed_bytes == 0) return 0;
  959.     the_thing[0] = *(*packed_blob)++;
  960.     the_thing[1] = 0;
  961.     the_thing[2] = 0;
  962.     the_thing[3] = 0;
  963.     if (!unpack_41_dword_896070(the_thing + 1, packed_blob, packed_bytes)) return 0;
  964.     switch (*the_thing)
  965.     {
  966.     case 0:
  967.         return unpack_41_dword_896070(the_thing + 2, packed_blob, packed_bytes);
  968.     case 1:
  969.         v9 = packed_bytes;
  970.         if (*packed_bytes < 8) return 0;
  971.         the_thing[2] = _bswap32(dword(*packed_blob,4));
  972.         the_thing[3] = _bswap32(dword(*packed_blob,0));
  973.         *packed_blob += 8;
  974.         *v9 -= 8;
  975.         return 1;
  976.     case 2:
  977.         if (*packed_bytes < 6) return 0;
  978.         the_thing[2] = _bswap32(dword(*packed_blob,0));
  979.         the_thing[3] = ntohs(word(*packed_blob,4));
  980.         *packed_blob += 6;
  981.         *packed_bytes -= 6;
  982.         return 1;
  983.     case 3:
  984.         v12 = memchr(*packed_blob, 0, *packed_bytes);
  985.         if (!v12 || (v15 = (u32)(v12 - *packed_blob + 1), the_thing[3] = (u32)(v12 - *packed_blob + 1), *list_size < v15)) return 0;
  986.         *list_size -= v15;
  987.         memcpy((void *)(the_thing[2] = (u32)malloc(the_thing[3])), *packed_blob, the_thing[3]);
  988.         *packed_blob += the_thing[3];
  989.         *packed_bytes -= the_thing[3];
  990.         return 1;
  991.     case 4:
  992.         if (!unpack_41_dword_896070(the_thing+3, packed_blob, packed_bytes) || (*packed_bytes < the_thing[3]) || (*list_size < the_thing[3])) return 0;
  993.         *list_size -= the_thing[3];
  994.         memcpy((void *)(the_thing[2] = (u32)malloc(the_thing[3])), *packed_blob, the_thing[3]);
  995.         *packed_blob += the_thing[3];
  996.         *packed_bytes -= the_thing[3];
  997.         return 1;
  998.     default:
  999.         if (*the_thing != 5)
  1000.         {
  1001.             if ((*the_thing != 6)
  1002.                 || !unpack_41_dword_896070(&tt, packed_blob, packed_bytes)
  1003.                 || (tt > *packed_bytes)
  1004.                 || (tt >= 128*1024*1024)
  1005.                 || (*list_size < (the_thing[3] = 4*tt)))
  1006.                 return 0;
  1007.             *list_size -= 4*tt;
  1008.             the_thing[2] = (u32) malloc(the_thing[3]);
  1009.             if (!tt) return 1;
  1010.             for (v25 = 0; v25 < tt; v25++)
  1011.             {
  1012.                 if (!unpack_41_dword_896070(&dword(the_thing[2],v25*4), packed_blob, packed_bytes)) return 0;
  1013.             }
  1014.             return 1;
  1015.         }
  1016.         if (*list_size < 16) return 0;
  1017.         *list_size -= 16;
  1018.         if (the_thing[2] = (u32) malloc (16))
  1019.         {
  1020.             dword(the_thing[2],0) = -1;
  1021.             dword(the_thing[2],4) = 0;
  1022.             dword(the_thing[2],8) = 0;
  1023.             dword(the_thing[2],12) = 0;
  1024.         }
  1025.         return unpack_4142((u32 *)the_thing[2], packed_blob, packed_bytes, 0, max_depth - 1, list_size);
  1026.     }
  1027. }
  1028.  
  1029. u32 unpack_4142(u32 *into_list, u8 **packed_blob, u32 *packed_bytes, u8 *pack_42, u32 max_depth, u32 *list_size)
  1030. {
  1031.   u32 v13;
  1032.   u32 length;
  1033.   u32 *length_ptr;
  1034.   u32 max_length;
  1035.   u32 *the_thing;
  1036.   u32 v22;
  1037.   u32 n;
  1038.   u32 ctx[333];
  1039.  
  1040.   if ( pack_42 ) *pack_42 = 0;
  1041.   if ( !max_depth || !*packed_bytes ) return 0;
  1042.   if ( **packed_blob == 0x41 )
  1043.   {
  1044.     --*packed_bytes;
  1045.     ++*packed_blob;
  1046.     if ( unpack_41_dword_896070(&length, packed_blob, packed_bytes) )
  1047.     {
  1048.       v22 = 100;
  1049.       length_ptr = (u32 *)&v22;
  1050.       if ( length <= 100 ) length_ptr = &length;
  1051.       max_length = into_list[3] + *length_ptr;
  1052.       if ( into_list[2] < max_length )
  1053.       {
  1054.         into_list[2] = max_length;
  1055.         malloc_719490((void **)into_list + 1, 16 * max_length);
  1056.       }
  1057.       n = 0;
  1058.       if ( !length ) return 1;
  1059.       while ( *list_size >= 16 )
  1060.       {
  1061.         *list_size -= 16;
  1062.         the_thing = unpack_41_0_715D70(into_list+1, into_list[3]);
  1063.         if ( !unpack_41_715680(packed_blob, the_thing, packed_bytes, max_depth, list_size)) break;
  1064.         if ( ++n >= length ) return 1;
  1065.       }
  1066.     }
  1067.     return 0;
  1068.   }
  1069.   if ( pack_42 ) *pack_42 = 1;
  1070.   unpack_42_ctx_init_76ACD0(max_depth, (u32)ctx, (u32)packed_blob, (u32)packed_bytes);
  1071.   v13 = unpack_42_76AEC0(list_size, (u32)ctx, into_list) != 0;
  1072.   unpack_42_ctx_end_714D90((u32)ctx);
  1073.   return v13;
  1074. }
clone this paste RAW Paste Data