开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 外挂编程 > 查看源码
algorithms.cpp
资源名称：openkore-2.0.7.zip　[点击查看]
上传用户：market2
上传日期：2018-11-18
资源大小：18786k
文件大小：7k
源码类别：

外挂编程

开发平台：

Windows_Unix

algorithms.cpp：源码内容
  1. //#define ROPP_DEBUG
  2. #ifdef ROPP_DEBUG
  3. #include <stdio.h>
  4. #endif
  5. #include "algorithms.h"
  7. #include "mcg_cipher.h"
  8. #include "rmd128.h"
  9. #include "misty1.h"
  10. #include "cast.h"
  11. #include "turtle.h"
  12. #include "feal8.h"
  13. #include "snefru.h"
  14. #include "tiger.h"
  15. #include "safer.h"
  16. #include "seal.h"
  19. // MacGuffin Cipher
  20. static dword
  21. func0(dword aKey)
  22. {
  23. byte Key[16]={0x40, 0xF2, 0x41, 0xB2, 0x69, 0xF6, 0xF1, 0xAF, 0x63, 0xF4, 0x5D, 0xFF, 0xE, 0x1B, 0x11, 0x9B};
  24. dword Blk[2]={0,0};
  25. static MCGKey ExpKey;
  26. static char KeyNE = 1;
  27. Blk[0]=aKey;
  28. if(KeyNE)
  29. {
  30. MCGKeyset(Key,&ExpKey);
  31. KeyNE = 0;
  32. }
  33. MCGBlockEncrypt0((byte*)Blk,&ExpKey);
  34. return Blk[0];
  35. }
  37. // MacGuffin Cipher
  38. static dword
  39. func1(dword aKey)
  40. {
  41. byte Key[16]={0x40, 0xF2, 0x41, 0xB2, 0x69, 0xF6, 0xF1, 0xAF, 0x63, 0xF4, 0x5B, 0xFF, 0xE, 0x1C, 0x11, 0x9B};
  42. dword Blk[2]={0,0};
  43. static MCGKey ExpKey;
  44. static char KeyNE = 1;
  45. Blk[0]=aKey;
  46. if(KeyNE)
  47. {
  48. MCGKeyset(Key,&ExpKey);
  49. KeyNE = 0;
  50. }
  51. MCGBlockEncrypt1((byte*)Blk,&ExpKey);
  52. return Blk[0];
  53. }
  55. //RIPEMD-128
  56. static dword
  57. func2(dword aKey)
  58. {
  59. dword MDbuf[4]={0,0,0,0};
  60. MDinit(MDbuf); //sub_502500
  61. MDfinish(MDbuf,(byte*)&aKey,4,1);
  62. return MDbuf[3];
  63. }
  65. // Snefru
  66. static dword
  67. func3(dword aKey)
  68. {
  69. dword input[16] = { 0x0023D6F7, 0 };
  70. dword output[4];
  72. input[7] = aKey;
  74. snefruHash512(output, input);
  76. return output[1];
  77. }
  79. // Tiger
  80. static dword
  81. func4(dword aKey)
  82. {
  83. dword res[6] = { 0 };
  84. dword str[16] = { 0 };
  86. str[1] = aKey;
  87. tiger(str, 64, res);
  89. return res[2];
  90. }
  92. // Safer
  93. static dword
  94. func5(dword aKey)
  95. {
  96. static safer_key_t saferKey1;
  97. static bool saferInited1 = false;
  99. if ( ! saferInited1 ) {
  100. Safer_Init_Module();
  102. safer_block_t Key = { 0x9C, 0x56, 0xD1, 0x12, 0x23, 0xC0, 0xB4, 0x37 };
  103. Safer_Expand_Userkey( Key, Key, 8, 0, saferKey1 );
  105. saferInited1 = true;
  106. }
  108. safer_block_t inBlock = { 0 };
  109. safer_block_t outBlock = { 0 };
  111. *(dword*)(inBlock) = aKey;
  112. Safer_Encrypt_Block( inBlock, saferKey1, outBlock );
  114. return *(dword*)(outBlock);
  115. }
  117. // Safer
  118. static dword
  119. func6(dword aKey)
  120. {
  121. static safer_key_t saferKey2;
  122. static bool saferInited2 = false;
  124. if ( ! saferInited2 ) {
  125. Safer_Init_Module();
  127. safer_block_t Key = { 0x9C, 0x56, 0xDD, 0x12, 0x23, 0xC1, 0xB4, 0x37 };
  128. Safer_Expand_Userkey( Key, Key, 8, 0, saferKey2 );
  130. saferInited2 = true;
  131. }
  133. safer_block_t inBlock = { 0 };
  134. safer_block_t outBlock = { 0 };
  136. *(dword*)(inBlock) = aKey;
  137. Safer_Decrypt_Block( inBlock, saferKey2, outBlock );
  139. return *(dword*)(outBlock);
  140. }
  142. // CAST
  143. static dword
  144. func7(dword aKey)
  145. {
  146. static cast_key CASTKey;
  147. static bool CASTInited = false;
  148. byte Key[16] = {
  149. 0x40, 0xF2, 0x41, 0xB2, 0x69, 0xF6, 0xF1, 0xAF,
  150. 0x63, 0xF3, 0x5D, 0xFF, 0x0E, 0x1C, 0x11, 0x9B
  151. };
  152. if(!CASTInited)
  153. {
  154. cast_setkey(&CASTKey, Key, 16);
  155. CASTInited = true;
  156. }
  157. byte inBlock[8] = {0, 0, 0, 0, 0, 0, 0, 0};
  158. byte outBlock[8] = {0, 0, 0, 0, 0, 0, 0, 0};
  159. *(dword*)(inBlock) = aKey;
  160. cast_encrypt(&CASTKey, inBlock, outBlock);
  161. return *(dword*)(outBlock);
  162. }
  164. // CAST
  165. static dword
  166. func8(dword aKey)
  167. {
  168. static cast_key CASTKey;
  169. static bool CASTInited = false;
  170. byte Key[16] = {
  171. 0x40, 0xF2, 0x41, 0xB2, 0x69, 0xF6, 0xF1, 0xAF,
  172. 0x63, 0xF4, 0x5E, 0xFF, 0x0E, 0x1C, 0x11, 0x9B
  173. };
  174. if(!CASTInited)
  175. {
  176. cast_setkey(&CASTKey, Key, 16);
  177. CASTInited = true;
  178. }
  179. byte inBlock[8] = {0, 0, 0, 0, 0, 0, 0, 0};
  180. byte outBlock[8] = {0, 0, 0, 0, 0, 0, 0, 0};
  181. *(dword*)(inBlock) = aKey;
  182. cast_decrypt(&CASTKey, inBlock, outBlock);
  183. return *(dword*)(outBlock);
  184. }
  186. // TURTLE
  187. static dword
  188. func9(dword aKey)
  189. {
  190. TURTLEWORD key[16] = { 0x40, 0xF2, 0x41, 0xB2, 0x69, 0xF6, 0xF2,
  191. 0xAF, 0x63, 0xF4, 0x5D, 0xFF, 0x0E, 0x1C, 0x11, 0x9B };
  192. TURTLEWORD block[8] = { 0 };
  193. TK turtle;
  195. turtle_key(key, 16, &turtle, 8);
  196. ((dword *) block)[0] = aKey;
  197. turtle_encrypt(block, &turtle);
  198. return ((dword *) block)[0];
  199. }
  201. // TURTLE
  202. static dword
  203. funcA(dword aKey)
  204. {
  205. TURTLEWORD key[16] = { 0x40, 0xF2, 0x41, 0xB2, 0x69, 0xF6, 0xF1,
  206. 0xA5, 0x63, 0xF4, 0x5D, 0xFF, 0x0E, 0x1C, 0x11, 0x9B };
  207. TURTLEWORD block[8] = { 0 };
  208. TK turtle;
  210. turtle_key(key, 16, &turtle, 8);
  211. ((dword *) block)[0] = aKey;
  212. turtle_decrypt(block, &turtle);
  213. return ((dword *) block)[0];
  214. }
  216. // FEAL-8
  217. static dword
  218. funcB(dword aKey)
  219. {
  220. unsigned char key[] = { 0x12, 0x43, 0x9F, 0x1F, 0xAB, 0xFF, 0x3A, 0x6F };
  221. unsigned char inBlock[8] = { 0 };
  222. unsigned char outBlock[8] = { 0 };
  223. F8_SetKey(key);
  224. ((dword *) inBlock)[0] = aKey;
  225. F8_Encrypt(inBlock, outBlock);
  226. return ((dword *) outBlock)[0];
  227. }
  229. // FEAL-8
  230. static dword
  231. funcC(dword aKey)
  232. {
  233. unsigned char key[] = { 0x22, 0x43, 0x9F, 0x1F, 0xAC, 0xFF, 0x3A, 0x6F };
  234. unsigned char inBlock[8] = { 0 };
  235. unsigned char outBlock[8] = { 0 };
  236. F8_SetKey(key);
  237. ((dword *) inBlock)[0] = aKey;
  238. F8_Decrypt(inBlock, outBlock);
  239. return ((dword *) outBlock)[0];
  240. }
  242. // Misty-1
  243. static dword
  244. funcD(dword aKey)
  245. {
  246. dword Key[4]={0x73DA73C3, 0x83FA7ECA, 0x83943092, 0xADEFCDEA};
  247. dword Cipher[2];
  248. dword Block[2]={0,0};
  249. static word ExpKey[32];
  250. static char KeyNE = 1;
  251. Block[0] = aKey;
  252. if (KeyNE) {
  253. MSTInit(ExpKey, Key);
  254. KeyNE = 0;
  255. }
  256. MSTEncryptD(ExpKey, Block, Cipher);
  257. return Cipher[0];
  258. }
  260. // Misty-1
  261. static dword
  262. funcE(dword aKey)
  263. {
  264. dword Key[4]={0x73DA73C3, 0x83FA7ECA, 0x84643092, 0xADEFCDEA};
  265. dword Cipher[2];
  266. dword Block[2]={0,0};
  267. static word ExpKey[32];
  268. static char KeyNE = 1;
  269. Block[0] = aKey;
  270. if(KeyNE)
  271. {
  272. MSTInit(ExpKey, Key);
  273. KeyNE = 0;
  274. }
  275. MSTEncryptE(ExpKey, Block, Cipher);
  276. return Cipher[0];
  277. }
  279. // SEAL
  280. static dword
  281. funcF(dword aKey)
  282. {
  283. byte key[20] = {
  284. 0x40, 0xF2, 0xFF, 0xB2, 0x69, 0xF6, 0xF1,
  285. 0xAF, 0x63, 0xF4, 0x5D, 0x41, 0x0E, 0x1C,
  286. 0x11, 0x9B, 0xF0, 0x45, 0xBE, 0xEA
  287. };
  288. dword buf[2] = {aKey, 0};
  289. seal_ctx sc;
  290. seal_key(&sc, key);
  291. seal_encrypt(&sc, buf, 2);
  292. return buf[0];
  293. }
  296. /*******************************************************/
  298. static dword (*funcs[])(dword) = {
  299. func0, func1, func2, func3, func4, func5, func6, func7,
  300. func8, func9, funcA, funcB, funcC, funcD, funcE, funcF
  301. };
  303. namespace OpenKore {
  304. namespace PaddedPackets {
  306. dword
  307. createHash(int map_sync, int sync, int account_id, short packet)
  308. {
  309. unsigned int slot = (packet * packet + map_sync + sync + account_id) & 0xF;
  310. #ifdef ROPP_DEBUG
  311. printf("Algorithm = %dn", slot);
  312. #endif
  313. return funcs[slot](packet * account_id + map_sync * sync);
  314. }
  316. dword
  317. createHash(int algorithm_id, dword key)
  318. {
  319. return funcs[algorithm_id](key);
  320. }
  322. } // PaddedPackets
  323. } // OpenKore