API tools faq
paste
Advertisement
Guest User

Untitled

a guest
May 26th, 2018
84
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 6.24 KB | None | 0 0
raw download clone embed print report
  1. uint32_t tsl_decrypt_id(const int& id) {
  2.     return ror4(id ^ 0x4DF5CE80, 6) ^ (ror4(id ^ 0x4DF5CE80, 6) << 16) ^ 0xC63740F;
  3. }
  4.  
  5. uint64_t tsl_decrypt_playercontroller(struct Tsl *tsl, uint64_t prop)
  6. {
  7.     struct uint128_t xmm;
  8.     if (!READ(prop, &xmm, 16))
  9.     {
  10.         return 0;
  11.     }
  12.  
  13.     uint32_t key = (uint32_t)xmm.low;
  14.     if (!IsValid(xmm.high))
  15.         return 0;
  16.     if (!mem->IsValid(xmm.high) || !mem->IsValid(key))
  17.         return 0;
  18.  
  19.     int v9; // edx
  20.     int v10; // ecx
  21.     int v11; // edx
  22.     __int64 v12; // rcx
  23.  
  24.     if (IDA_HIWORD(key) & 4)
  25.         v9 = ~(~(_DWORD(key) >> 16) - 306);
  26.     else
  27.         IDA_LOWORD(v9) = _WORD(IDA_HIWORD(key)) + 204;
  28.     v10 = ((unsigned __int16)v9 + 19198) ^ (unsigned __int16)(_WORD(IDA_LOWORD(key)) + 30);
  29.     v11 = (unsigned __int8)(((v9 - 2) ^ (IDA_LOWORD(key) + 30)) + 14) ^ ((v10 >> 8) + 132);
  30.     if (IDA_LOWORD(key) & 2)
  31.         v12 = xmm.high ^ key;
  32.     else
  33.         v12 = xmm.high + key;
  34.  
  35.     auto index = (v11 % 128);
  36.  
  37.     uint64_t func = READ64(GET_ADDR(TABLE) + 0x8 * index);
  38.  
  39.     if (auto encValue = decrypt(tsl, func, v12))
  40.         return ror8(encValue, 6);
  41.  
  42.     return 0;
  43. }
  44.  
  45. uint64_t tsl_decrypt_pawn(struct Tsl *tsl, uint64_t prop)
  46. {
  47.     struct uint128_t xmm;
  48.     if (!READ(prop, &xmm, 16))
  49.     {
  50.         return 0;
  51.     }
  52.  
  53.     uint32_t key = (uint32_t)xmm.low;
  54.     if (!IsValid(xmm.high))
  55.         return 0;
  56.     if (!mem->IsValid(xmm.high) || !mem->IsValid(key))
  57.         return 0;
  58.  
  59.     unsigned int v6; // ecx
  60.     int v7; // edx
  61.     int v8; // eax
  62.     int v9; // ecx
  63.     __int64 v19 = key; // [rsp+68h] [rbp+20h]
  64.  
  65.     v6 = (unsigned int)v19 >> 16;
  66.     if (v19 & 0x40000)
  67.         v6 = ~(~v6 - 240);
  68.     else
  69.         IDA_LOWORD(v6) = v6 + 160;
  70.     v7 = (unsigned __int16)v19 ^ ((unsigned __int16)v6 + 12432);
  71.     v8 = v7 >> 8;
  72.     v9 = (unsigned __int8)((unsigned __int16)(v19 ^ (v6 + 12432)) >> 8);
  73.     if (v8 & 4)
  74.         v9 = ~(~v9 + 48);
  75.     else
  76.         IDA_LOBYTE(v9) = v9 - 32;
  77.  
  78.     auto index = (((unsigned __int8)v7 ^ ((unsigned __int8)v9 + 224)) % 128);
  79.  
  80.     uint64_t func = READ64(GET_ADDR(TABLE) + 0x8 * index);
  81.  
  82.     if (auto encValue = decrypt(tsl, func, (xmm.high - (unsigned int)v19)))
  83.         return ror8(encValue, 80);
  84.  
  85.     return 0;
  86. }
  87.  
  88. uint64_t tsl_decrypt_rootcomponent(struct Tsl *tsl, uint64_t prop)
  89. {
  90.     struct uint128_t xmm;
  91.     if (!READ(prop, &xmm, 16))
  92.     {
  93.         return 0;
  94.     }
  95.  
  96.     uint32_t key = (uint32_t)xmm.low;
  97.     if (!IsValid(xmm.high))
  98.         return 0;
  99.     if (!mem->IsValid(xmm.high) || !mem->IsValid(key))
  100.         return 0;
  101.  
  102.     unsigned int v6; // ecx
  103.     int v7; // edx
  104.     int v8; // eax
  105.     int v9; // ecx
  106.     __int64 v19 = key; // [rsp+68h] [rbp+20h]
  107.  
  108.     v6 = (unsigned int)v19 >> 16;
  109.     if (v19 & 0x40000)
  110.         v6 = ~(~v6 - 240);
  111.     else
  112.         IDA_LOWORD(v6) = v6 + 160;
  113.     v7 = (unsigned __int16)v19 ^ ((unsigned __int16)v6 + 12432);
  114.     v8 = v7 >> 8;
  115.     v9 = (unsigned __int8)((unsigned __int16)(v19 ^ (v6 + 12432)) >> 8);
  116.     if (v8 & 4)
  117.         v9 = ~(~v9 + 48);
  118.     else
  119.         IDA_LOBYTE(v9) = v9 - 32;
  120.  
  121.     auto index = (((unsigned __int8)v7 ^ ((unsigned __int8)v9 + 224)) % 128);
  122.  
  123.     uint64_t func = READ64(GET_ADDR(TABLE) + 0x8 * index);
  124.  
  125.     if (auto encValue = decrypt(tsl, func, (xmm.high - (unsigned int)v19)))
  126.         return ror8(encValue, 80);
  127.  
  128.     return 0;
  129. }
  130.  
  131. uint64_t tsl_decrypt_gameinst(struct Tsl *tsl, uint64_t prop)
  132. {
  133.     struct uint128_t xmm;
  134.     if (!READ(prop, &xmm, 16))
  135.     {
  136.         return 0;
  137.     }
  138.  
  139.     uint32_t key = (uint32_t)xmm.low;
  140.     if (!IsValid(xmm.high))
  141.         return 0;
  142.     if (!mem->IsValid(xmm.high) || !mem->IsValid(key))
  143.         return 0;
  144.  
  145.     int v12 = (unsigned __int16)(IDA_LOWORD(key) - 37) ^ ((unsigned __int16)ror2(IDA_HIWORD(key), 8) + 6005);
  146.  
  147.     auto index = ((((unsigned __int8)((v12 >> 8) - 99) + 214) ^ (unsigned __int8)(((IDA_LOWORD(key) - 37) ^ (ror2(IDA_HIWORD(key), 8) + 117)) + 51))
  148.         % 128);
  149.  
  150.     uint64_t func = READ64(GET_ADDR(TABLE) + 0x8 * index);
  151.  
  152.     if (auto encValue = decrypt(tsl, func, (~(~xmm.high ^ key))))
  153.         return ror8(encValue, -95);
  154.  
  155.     return 0;
  156. }
  157.  
  158. uint64_t tsl_decrypt_ulevel(struct Tsl *tsl, uint64_t prop)
  159. {
  160.     struct uint128_t xmm;
  161.     if (!READ(prop, &xmm, 16))
  162.     {
  163.         return 0;
  164.     }
  165.  
  166.     uint32_t key = (uint32_t)xmm.low;
  167.     if (!IsValid(xmm.high))
  168.         return 0;
  169.     if (!mem->IsValid(xmm.high) || !mem->IsValid(key))
  170.         return 0;
  171.  
  172.     int v6; // edx
  173.     int v7; // ecx
  174.     __int64 v8; // rdx
  175.  
  176.     v6 = (unsigned __int16)(IDA_LOWORD(key) - 66) ^ ((unsigned __int16)(IDA_HIWORD(key) + 122) + 10910);
  177.     v7 = (unsigned __int8)(((IDA_LOWORD(key) - 66) ^ (IDA_HIWORD(key) + 24)) - 82) ^ ((unsigned __int8)((v6 >> 8) + 114) + 68);
  178.     v8 = IDA_LOWORD(key) & 2 ? xmm.high ^ key : xmm.high + key;
  179.  
  180.     auto index = (v7 % 128);
  181.  
  182.     uint64_t func = READ64(GET_ADDR(TABLE) + 0x8 * index);
  183.  
  184.     if (auto encValue = decrypt(tsl, func, v8))
  185.         return ror8(encValue, 38);
  186.  
  187.     return 0;
  188. }
  189.  
  190. uint64_t tsl_decrypt_actor(struct Tsl *tsl, uint64_t prop)
  191. {
  192.     struct uint128_t xmm;
  193.     if (!READ(prop, &xmm, 16))
  194.     {
  195.         return 0;
  196.     }
  197.  
  198.     uint32_t key = (uint32_t)xmm.low;
  199.     if (!IsValid(xmm.high))
  200.         return 0;
  201.     if (!mem->IsValid(xmm.high) || !mem->IsValid(key))
  202.         return 0;
  203.  
  204.     int v13; // eax
  205.     __int16 v14; // dx
  206.     __int16 v15; // ax
  207.     int v16; // edx
  208.  
  209.     v13 = _DWORD(key) >> 16;
  210.     if (IDA_HIWORD(key) & 2)
  211.     {
  212.         v14 = v13 - 114;
  213.         v15 = v13 + 114;
  214.         IDA_LOWORD(v16) = ~v14;
  215.     }
  216.     else
  217.     {
  218.         v15 = v13 ^ 0x72;
  219.         v16 = (_DWORD(key) >> 16) + 115;
  220.     }
  221.  
  222.     auto index = (((((unsigned __int16)((~v15 + v16 - 25030) ^ ~((~IDA_LOWORD(key) + 102) ^ 0xFF9A)) >> 8)
  223.         + 12) ^ (unsigned __int8)~((~((~(_BYTE)v15 + v16 + 58) ^ ~((~(_BYTE)IDA_LOWORD(key) + 102) ^ 0x9A))
  224.             - 106) ^ 0x6A))
  225.         % 128);
  226.  
  227.     uint64_t func = READ64(GET_ADDR(TABLE) + 0x8 * index);
  228.  
  229.     if (auto encValue = decrypt(tsl, func, (key + rol8(key + xmm.high, 8 * (IDA_LOWORD(key) & 7u)))))
  230.         return ror8(encValue, 82);
  231.  
  232.     return 0;
  233. }
  234.  
  235. uint64_t tsl_decrypt_localplayer(struct Tsl *tsl, uint64_t prop)
  236. {
  237.     struct uint128_t xmm;
  238.     if (!READ(prop, &xmm, 16))
  239.     {
  240.         return 0;
  241.     }
  242.  
  243.     uint32_t key = (uint32_t)xmm.low;
  244.     if (!IsValid(xmm.high))
  245.         return 0;
  246.     if (!mem->IsValid(xmm.high) || !mem->IsValid(key))
  247.         return 0;
  248.  
  249.     auto index = ((((unsigned __int8)(((unsigned __int16)((IDA_HIWORD(key) - 8454) ^ ~((~IDA_LOWORD(key) - 90) ^ 0x5A)) >> 8)
  250.         - 54)
  251.         + 140) ^ (unsigned __int8)~((~((IDA_HIWORD(key) - 6) ^ ~((~(_BYTE)IDA_LOWORD(key) - 90) ^ 0x5A))
  252.             - 42) ^ 0x2A))
  253.         % 128);
  254.  
  255.     uint64_t func = READ64(GET_ADDR(TABLE) + 0x8 * index);
  256.  
  257.     if (auto encValue = decrypt(tsl, func, (key + rol8(key + xmm.high, 8 * (IDA_LOWORD(key) & 7u)))))
  258.         return ror8(encValue, 18);
  259.  
  260.     return 0;
  261. }
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!