API tools faq
paste
Advertisement
ImoogiWild

Untitled

ImoogiWild
Jun 4th, 2018
97
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 19.54 KB | None | 0 0
raw download clone embed print report
  1. // ResMan.Classes.KeyCodeLibrary
  2. using System;
  3. using System.Text;
  4.  
  5. internal static class KeyCodeLibrary
  6. {
  7. private const long S11 = 7L;
  8.  
  9. private const long S12 = 12L;
  10.  
  11. private const long S13 = 17L;
  12.  
  13. private const long S14 = 22L;
  14.  
  15. private const long S21 = 5L;
  16.  
  17. private const long S22 = 9L;
  18.  
  19. private const long S23 = 14L;
  20.  
  21. private const long S24 = 20L;
  22.  
  23. private const long S31 = 4L;
  24.  
  25. private const long S32 = 11L;
  26.  
  27. private const long S33 = 16L;
  28.  
  29. private const long S34 = 23L;
  30.  
  31. private const long S41 = 6L;
  32.  
  33. private const long S42 = 10L;
  34.  
  35. private const long S43 = 15L;
  36.  
  37. private const long S44 = 21L;
  38.  
  39. public const string MyProductName = "ResManV131";
  40.  
  41. public const string B32Map = "0123456789ABCDEFGHJKLMNPRSTVWXYZ";
  42.  
  43. private const long OFFSET_4 = 4294967296L;
  44.  
  45. private const long MAXINT_4 = 2147483647L;
  46.  
  47. public static long ByteCounter;
  48.  
  49. public static long[] State;
  50.  
  51. public static byte[] ByteBuffer;
  52.  
  53. public static string GenKeyString(string UserName, string ProdName, long F_Code)
  54. {
  55. string text = null;
  56. string text2 = null;
  57. char[] array = null;
  58. long num = 0L;
  59. byte b = 0;
  60. byte b2 = 0;
  61. byte b3 = 0;
  62. byte b4 = 0;
  63. text = UserName.ToLower() + ProdName.ToLower();
  64. text2 = DigestStrToHexStr(text);
  65. array = HexStrToBinStr(text2);
  66. num = (F_Code & 0xFFFF);
  67. b = (byte)(num & 0xFF);
  68. b2 = (byte)((num & 0xFF00) / 256 & 0xFF);
  69. char c = array[array.Length - 1];
  70. char c2 = array[array.Length - 2];
  71. b3 = (byte)c;
  72. b4 = (byte)c2;
  73. b3 = (byte)(b3 ^ b);
  74. b4 = (byte)(b4 ^ b2);
  75. char c3 = (char)b3;
  76. char c4 = (char)b4;
  77. string text3 = new string(array);
  78. text3 = text3.Substring(0, array.Length - 2);
  79. text3 = text3 + c4 + c3;
  80. text3 = text3.Substring(2, text3.Length - 2);
  81. string text4 = DigestStrToHexStr(text3);
  82. string str = text4.Substring(0, 2);
  83. string str2 = text4.Substring(text4.Length - 2, 2);
  84. string str3 = BinStrToHexStr(text3);
  85. return str + str2 + str3;
  86. }
  87.  
  88. public static string Base32Enc(string StrIn)
  89. {
  90. byte b = 0;
  91. long num = 0L;
  92. byte b2 = 0;
  93. long num2 = 0L;
  94. long num3 = 0L;
  95. string text = null;
  96. string text2 = null;
  97. string text3 = null;
  98. int num4 = 0;
  99. int num5 = 0;
  100. text2 = "";
  101. text = StrIn;
  102. num2 = StrIn.Length * 8;
  103. num4 = (int)(num2 / 5);
  104. if (num2 % 5 != 0)
  105. {
  106. num4++;
  107. }
  108. num5 = StrIn.Length;
  109. num3 = 0L;
  110. b = 31;
  111. for (num = 0L; num < num4; num++)
  112. {
  113. b2 = (byte)text[text.Length - 1];
  114. b2 = (byte)((b2 & b) + 1);
  115. text3 = "0123456789ABCDEFGHJKLMNPRSTVWXYZ".Substring(b2 - 1, 1);
  116. text = MyShiftToRight(text, 5L);
  117. text2 = text3 + text2;
  118. }
  119. return text2;
  120. }
  121.  
  122. public static string BinStrToHexStr(string StrIn)
  123. {
  124. string text = "";
  125. foreach (char value in StrIn)
  126. {
  127. string text2 = Convert.ToString(value, 16);
  128. if (text2.Length == 1)
  129. {
  130. text2 = "0" + text2;
  131. }
  132. text += text2;
  133. }
  134. return text;
  135. }
  136.  
  137. public static bool ValidateKeyCode(string KeyCode, string UserName, string ProjName)
  138. {
  139. string text = "";
  140. string text2 = "";
  141. string text3 = "";
  142. string text4 = "";
  143. bool flag = false;
  144. if (KeyCode.Length == 32)
  145. {
  146. string text5 = new string(HexStrToBinStr(KeyCode));
  147. text = text5.Substring(text5.Length - 14, 14);
  148. string text6 = DigestStrToHexStr(text);
  149. text4 = text6.Substring(0, 2) + text6.Substring(text6.Length - 2, 2);
  150. text3 = KeyCode.Substring(0, 4);
  151. if (text3.ToUpper() == text4.ToUpper())
  152. {
  153. flag = true;
  154. }
  155. if (flag)
  156. {
  157. string sourceString = UserName.ToLower() + ProjName.ToLower();
  158. text2 = DigestStrToHexStr(sourceString);
  159. text = KeyCode.Substring(4, 24);
  160. text2 = text2.Substring(4, 24);
  161. }
  162. if (text.ToUpper() == text2.ToUpper())
  163. {
  164. flag = true;
  165. }
  166. }
  167. else
  168. {
  169. flag = false;
  170. }
  171. return flag;
  172. }
  173.  
  174. public static string RemoveDashes(string StrIn)
  175. {
  176. return StrIn.Replace("-", "");
  177. }
  178.  
  179. public static string Base32Dec(string StrIn)
  180. {
  181. int num = 0;
  182. byte b = 0;
  183. string text = null;
  184. string text2 = null;
  185. byte b2 = 0;
  186. long num2 = 0L;
  187. long num3 = 0L;
  188. try
  189. {
  190. num3 = StrIn.Length * 5;
  191. num2 = Convert.ToInt64(num3 / 8);
  192. for (num = 0; num < num2; num++)
  193. {
  194. text += '\0';
  195. }
  196. foreach (char value in StrIn)
  197. {
  198. b = Convert.ToByte("0123456789ABCDEFGHJKLMNPRSTVWXYZ".IndexOf(value));
  199. text = MyShift(text, 5L);
  200. char c = text[text.Length - 1];
  201. text = text.Substring(0, text.Length - 1);
  202. b2 = (byte)c;
  203. b2 = (byte)(b2 | b);
  204. c = (char)b2;
  205. text += c;
  206. byte b3 = (byte)text[text.Length - 2];
  207. }
  208. }
  209. catch (Exception)
  210. {
  211. return "";
  212. }
  213. return text;
  214. }
  215.  
  216. public static string MyShift(string StrIn, long Bits)
  217. {
  218. string text = "";
  219. byte b = 0;
  220. long num = 0L;
  221. string text2 = null;
  222. num = Convert.ToInt64(Bits / 8);
  223. b = Convert.ToByte(Bits % 8);
  224. int length = StrIn.Length;
  225. text2 = StrIn;
  226. if (length * 8 > Bits)
  227. {
  228. if (num > 0)
  229. {
  230. text2 = text2.Substring(length, (int)(length - num));
  231. for (int i = 0; i < num; i++)
  232. {
  233. text2 += '\0';
  234. }
  235. }
  236. byte b2 = 0;
  237. string text3 = "";
  238. for (int i = length - 1; i >= 0; i--)
  239. {
  240. byte b3 = (byte)text2[i];
  241. byte b4 = (byte)((int)b3 / (int)(byte)Math.Pow(2.0, (double)(8 - b)));
  242. byte b5 = (byte)((int)b3 % (int)(byte)Math.Pow(2.0, (double)(8 - b)));
  243. b3 = (byte)((double)(int)b5 * Math.Pow(2.0, (double)(int)b));
  244. b3 = Convert.ToByte(b3 | b2);
  245. text3 += (char)b3;
  246. b2 = b4;
  247. }
  248. text = "";
  249. for (int i = length - 1; i >= 0; i--)
  250. {
  251. text += text3[i];
  252. }
  253. }
  254. else
  255. {
  256. for (int i = 0; i < length; i++)
  257. {
  258. text += '\0';
  259. }
  260. }
  261. return text;
  262. }
  263.  
  264. public static string ShiftStrLeft(string StrIn, long Bits)
  265. {
  266. int num = 0;
  267. string text = null;
  268. string text2 = null;
  269. byte b = 0;
  270. byte b2 = 0;
  271. byte b3 = 0;
  272. byte b4 = 0;
  273. long num2 = 0L;
  274. byte b5 = 0;
  275. byte b6 = 0;
  276. byte b7 = 0;
  277. byte b8 = 0;
  278. num2 = Convert.ToInt64(Bits / 8);
  279. b4 = Convert.ToByte(Bits % 8);
  280. b2 = Convert.ToByte(255.0 - (Math.Pow(2.0, (double)(8 - b4)) - 1.0));
  281. b3 = (byte)(~b2);
  282. b8 = Convert.ToByte(Math.Pow(2.0, (double)(int)b4) - 1.0);
  283. num = 0;
  284. int length = StrIn.Length;
  285. int num3 = length * 8;
  286. text = StrIn;
  287. if (num3 > Bits)
  288. {
  289. if (num2 > 0)
  290. {
  291. text = text.Substring(length, (int)(length - num2));
  292. for (num = 0; num < num2; num++)
  293. {
  294. text += '\0';
  295. }
  296. text2 = text;
  297. }
  298. if (b4 > 0)
  299. {
  300. for (num = 0; num < text.Length; num++)
  301. {
  302. byte[] bytes = Encoding.ASCII.GetBytes(text.Substring(num, 1));
  303. b = bytes[0];
  304. b5 = Convert.ToByte(b & b2 & 0xFF);
  305. b6 = Convert.ToByte(b & b3 & 0xFF);
  306. b5 = (byte)((double)(int)b5 / Math.Pow(2.0, (double)(8 - b4)));
  307. b6 = (byte)((double)(int)b6 * Math.Pow(2.0, (double)(int)b4));
  308. if (num == 0)
  309. {
  310. b7 = b6;
  311. text2 = "";
  312. }
  313. else
  314. {
  315. b7 = (byte)(b7 | b5);
  316. text2 += (char)b7;
  317. b7 = b6;
  318. }
  319. }
  320. b7 = (byte)(b7 | (b5 & ~b8));
  321. text2 += (char)b7;
  322. }
  323. }
  324. else
  325. {
  326. for (num = 0; num < length; num++)
  327. {
  328. text2 += '\0';
  329. }
  330. }
  331. return text2;
  332. }
  333.  
  334. public static string MyShiftToRight(string StrIn, long Bits)
  335. {
  336. string text = "";
  337. byte b = 0;
  338. long num = 0L;
  339. string text2 = null;
  340. num = Convert.ToInt64(Bits / 8);
  341. b = Convert.ToByte(Bits % 8);
  342. int length = StrIn.Length;
  343. text2 = StrIn;
  344. if (length * 8 > Bits)
  345. {
  346. if (num > 0)
  347. {
  348. text2 = text2.Substring(length, (int)(length - num));
  349. for (int i = 0; i < num; i++)
  350. {
  351. text2 += '\0';
  352. }
  353. }
  354. byte b2 = 0;
  355. string text3 = "";
  356. for (int i = 0; i < length; i++)
  357. {
  358. byte b3 = (byte)text2[i];
  359. byte b4 = (byte)((int)b3 / (int)(byte)Math.Pow(2.0, (double)(int)b));
  360. byte b5 = (byte)((int)b3 % (int)(byte)Math.Pow(2.0, (double)(int)b));
  361. b3 = b4;
  362. b3 = Convert.ToByte(b3 | b2 * (byte)Math.Pow(2.0, (double)(8 - b)));
  363. text3 += (char)b3;
  364. b2 = b5;
  365. }
  366. text = "";
  367. for (int i = 0; i < length; i++)
  368. {
  369. text += text3[i];
  370. }
  371. }
  372. else
  373. {
  374. for (int i = 0; i < length; i++)
  375. {
  376. text += '\0';
  377. }
  378. }
  379. return text;
  380. }
  381.  
  382. public static char[] HexStrToBinStr(string StrIn)
  383. {
  384. char[] array = new char[StrIn.Length / 2];
  385. for (int i = 0; i < StrIn.Length - 1; i += 2)
  386. {
  387. string value = StrIn.Substring(i, 2);
  388. byte b = Convert.ToByte(value, 16);
  389. char c = (char)b;
  390. array[i / 2] = (char)b;
  391. }
  392. return array;
  393. }
  394.  
  395. private static string DigestStrToHexStr(string SourceString)
  396. {
  397. MD5Init();
  398. byte[] inputBuffer = StringToArray(SourceString);
  399. MD5Update(SourceString.Length, inputBuffer);
  400. MD5Final();
  401. return GetValues();
  402. }
  403.  
  404. private static byte[] StringToArray(string InString)
  405. {
  406. byte[] array = new byte[InString.Length + 1];
  407. for (int i = 0; i <= InString.Length; i++)
  408. {
  409. if (i == InString.Length)
  410. {
  411. array[i] = 0;
  412. }
  413. else
  414. {
  415. array[i] = (byte)InString[i];
  416. }
  417. }
  418. return array;
  419. }
  420.  
  421. private static string GetValues()
  422. {
  423. return LongToString(State[0]) + LongToString(State[1]) + LongToString(State[2]) + LongToString(State[3]);
  424. }
  425.  
  426. private static string LongToString(long Num)
  427. {
  428. string text = "";
  429. byte[] array = new byte[1];
  430. byte[] array2 = new byte[1];
  431. byte[] array3 = new byte[1];
  432. byte[] array4 = new byte[1];
  433. array[0] = (byte)(Num & 0xFF);
  434. array2[0] = (byte)((Num & 0xFF00) / 256);
  435. array3[0] = (byte)((Num & 0xFF0000) / 65536);
  436. text = BitConverter.ToString(array).Replace("-", "");
  437. text += BitConverter.ToString(array2).Replace("-", "");
  438. text += BitConverter.ToString(array3).Replace("-", "");
  439. if (Num < 0)
  440. {
  441. array4[0] = (byte)((Num & 0x7F000000) / 16777216 | 0x80);
  442. }
  443. else
  444. {
  445. array4[0] = (byte)((Num & 4278190080u) / 16777216);
  446. }
  447. return text + BitConverter.ToString(array4).Replace("-", "");
  448. }
  449.  
  450. private static void MD5Final()
  451. {
  452. byte[] array = new byte[72]
  453. {
  454. 128,
  455. 0,
  456. 0,
  457. 0,
  458. 0,
  459. 0,
  460. 0,
  461. 0,
  462. 0,
  463. 0,
  464. 0,
  465. 0,
  466. 0,
  467. 0,
  468. 0,
  469. 0,
  470. 0,
  471. 0,
  472. 0,
  473. 0,
  474. 0,
  475. 0,
  476. 0,
  477. 0,
  478. 0,
  479. 0,
  480. 0,
  481. 0,
  482. 0,
  483. 0,
  484. 0,
  485. 0,
  486. 0,
  487. 0,
  488. 0,
  489. 0,
  490. 0,
  491. 0,
  492. 0,
  493. 0,
  494. 0,
  495. 0,
  496. 0,
  497. 0,
  498. 0,
  499. 0,
  500. 0,
  501. 0,
  502. 0,
  503. 0,
  504. 0,
  505. 0,
  506. 0,
  507. 0,
  508. 0,
  509. 0,
  510. 0,
  511. 0,
  512. 0,
  513. 0,
  514. 0,
  515. 0,
  516. 0,
  517. 0,
  518. 0,
  519. 0,
  520. 0,
  521. 0,
  522. 0,
  523. 0,
  524. 0,
  525. 0
  526. };
  527. long value = ByteCounter * 8;
  528. long num = ByteCounter % 64;
  529. if (num <= 56)
  530. {
  531. MD5Update(56 - num, array);
  532. }
  533. else
  534. {
  535. MD5Update(120 - ByteCounter, array);
  536. }
  537. array[0] = (byte)(UnsignedToLong(value) & 0xFF);
  538. array[1] = (byte)((int)(UnsignedToLong(value) / 256) & 0xFF);
  539. array[2] = (byte)((int)(UnsignedToLong(value) / 65536) & 0xFF);
  540. array[3] = (byte)((int)(UnsignedToLong(value) / 16777216) & 0xFF);
  541. array[4] = 0;
  542. array[5] = 0;
  543. array[6] = 0;
  544. array[7] = 0;
  545. MD5Update(8L, array);
  546. }
  547.  
  548. private static void MD5Init()
  549. {
  550. ByteCounter = 0L;
  551. State[0] = UnsignedToLong(1732584193L);
  552. State[1] = UnsignedToLong(4023233417L);
  553. State[2] = UnsignedToLong(2562383102L);
  554. State[3] = UnsignedToLong(271733878L);
  555. }
  556.  
  557. private static long UnsignedToLong(long value)
  558. {
  559. if (value < 0 || value >= 4294967296L)
  560. {
  561. return 6L;
  562. }
  563. if (value <= 2147483647)
  564. {
  565. return value;
  566. }
  567. return value - 4294967296L;
  568. }
  569.  
  570. private static long LongToUnsigned(long value)
  571. {
  572. if (value < 0)
  573. {
  574. return value + 4294967296L;
  575. }
  576. return value;
  577. }
  578.  
  579. private static void MD5Update(long InputLen, byte[] InputBuffer)
  580. {
  581. long num = ByteCounter % 64;
  582. long num2 = 64 - num;
  583. ByteCounter += InputLen;
  584. long num5;
  585. if (InputLen >= num2)
  586. {
  587. long num3;
  588. for (num3 = 0L; num3 < num2; num3++)
  589. {
  590. ByteBuffer[num + num3] = InputBuffer[num3];
  591. }
  592. MD5Transform(ByteBuffer);
  593. long num4 = InputLen % 64;
  594. for (num5 = num2; num5 <= InputLen - num3 - num4; num5 += 64)
  595. {
  596. for (long num6 = 0L; num6 < 64; num6++)
  597. {
  598. ByteBuffer[num6] = InputBuffer[num5 + num6];
  599. }
  600. MD5Transform(ByteBuffer);
  601. }
  602. num = 0L;
  603. }
  604. else
  605. {
  606. num5 = 0L;
  607. }
  608. for (long num7 = 0L; num7 < InputLen - num5; num7++)
  609. {
  610. ByteBuffer[num + num7] = InputBuffer[num5 + num7];
  611. }
  612. }
  613.  
  614. private static void MD5Transform(byte[] Buffer)
  615. {
  616. long num = State[0];
  617. long num2 = State[1];
  618. long num3 = State[2];
  619. long num4 = State[3];
  620. long[] array = Decode(64, Buffer);
  621. FF(ref num, num2, num3, num4, array[0], 7L, -680876936L);
  622. FF(ref num4, num, num2, num3, array[1], 12L, -389564586L);
  623. FF(ref num3, num4, num, num2, array[2], 17L, 606105819L);
  624. FF(ref num2, num3, num4, num, array[3], 22L, -1044525330L);
  625. FF(ref num, num2, num3, num4, array[4], 7L, -176418897L);
  626. FF(ref num4, num, num2, num3, array[5], 12L, 1200080426L);
  627. FF(ref num3, num4, num, num2, array[6], 17L, -1473231341L);
  628. FF(ref num2, num3, num4, num, array[7], 22L, -45705983L);
  629. FF(ref num, num2, num3, num4, array[8], 7L, 1770035416L);
  630. FF(ref num4, num, num2, num3, array[9], 12L, -1958414417L);
  631. FF(ref num3, num4, num, num2, array[10], 17L, -42063L);
  632. FF(ref num2, num3, num4, num, array[11], 22L, -1990404162L);
  633. FF(ref num, num2, num3, num4, array[12], 7L, 1804603682L);
  634. FF(ref num4, num, num2, num3, array[13], 12L, -40341101L);
  635. FF(ref num3, num4, num, num2, array[14], 17L, -1502002290L);
  636. FF(ref num2, num3, num4, num, array[15], 22L, 1236535329L);
  637. GG(ref num, num2, num3, num4, array[1], 5L, -165796510L);
  638. GG(ref num4, num, num2, num3, array[6], 9L, -1069501632L);
  639. GG(ref num3, num4, num, num2, array[11], 14L, 643717713L);
  640. GG(ref num2, num3, num4, num, array[0], 20L, -373897302L);
  641. GG(ref num, num2, num3, num4, array[5], 5L, -701558691L);
  642. GG(ref num4, num, num2, num3, array[10], 9L, 38016083L);
  643. GG(ref num3, num4, num, num2, array[15], 14L, -660478335L);
  644. GG(ref num2, num3, num4, num, array[4], 20L, -405537848L);
  645. GG(ref num, num2, num3, num4, array[9], 5L, 568446438L);
  646. GG(ref num4, num, num2, num3, array[14], 9L, -1019803690L);
  647. GG(ref num3, num4, num, num2, array[3], 14L, -187363961L);
  648. GG(ref num2, num3, num4, num, array[8], 20L, 1163531501L);
  649. GG(ref num, num2, num3, num4, array[13], 5L, -1444681467L);
  650. GG(ref num4, num, num2, num3, array[2], 9L, -51403784L);
  651. GG(ref num3, num4, num, num2, array[7], 14L, 1735328473L);
  652. GG(ref num2, num3, num4, num, array[12], 20L, -1926607734L);
  653. HH(ref num, num2, num3, num4, array[5], 4L, -378558L);
  654. HH(ref num4, num, num2, num3, array[8], 11L, -2022574463L);
  655. HH(ref num3, num4, num, num2, array[11], 16L, 1839030562L);
  656. HH(ref num2, num3, num4, num, array[14], 23L, -35309556L);
  657. HH(ref num, num2, num3, num4, array[1], 4L, -1530992060L);
  658. HH(ref num4, num, num2, num3, array[4], 11L, 1272893353L);
  659. HH(ref num3, num4, num, num2, array[7], 16L, -155497632L);
  660. HH(ref num2, num3, num4, num, array[10], 23L, -1094730640L);
  661. HH(ref num, num2, num3, num4, array[13], 4L, 681279174L);
  662. HH(ref num4, num, num2, num3, array[0], 11L, -358537222L);
  663. HH(ref num3, num4, num, num2, array[3], 16L, -722521979L);
  664. HH(ref num2, num3, num4, num, array[6], 23L, 76029189L);
  665. HH(ref num, num2, num3, num4, array[9], 4L, -640364487L);
  666. HH(ref num4, num, num2, num3, array[12], 11L, -421815835L);
  667. HH(ref num3, num4, num, num2, array[15], 16L, 530742520L);
  668. HH(ref num2, num3, num4, num, array[2], 23L, -995338651L);
  669. II(ref num, num2, num3, num4, array[0], 6L, -198630844L);
  670. II(ref num4, num, num2, num3, array[7], 10L, 1126891415L);
  671. II(ref num3, num4, num, num2, array[14], 15L, -1416354905L);
  672. II(ref num2, num3, num4, num, array[5], 21L, -57434055L);
  673. II(ref num, num2, num3, num4, array[12], 6L, 1700485571L);
  674. II(ref num4, num, num2, num3, array[3], 10L, -1894986606L);
  675. II(ref num3, num4, num, num2, array[10], 15L, -1051523L);
  676. II(ref num2, num3, num4, num, array[1], 21L, -2054922799L);
  677. II(ref num, num2, num3, num4, array[8], 6L, 1873313359L);
  678. II(ref num4, num, num2, num3, array[15], 10L, -30611744L);
  679. II(ref num3, num4, num, num2, array[6], 15L, -1560198380L);
  680. II(ref num2, num3, num4, num, array[13], 21L, 1309151649L);
  681. II(ref num, num2, num3, num4, array[4], 6L, -145523070L);
  682. II(ref num4, num, num2, num3, array[11], 10L, -1120210379L);
  683. II(ref num3, num4, num, num2, array[2], 15L, 718787259L);
  684. II(ref num2, num3, num4, num, array[9], 21L, -343485551L);
  685. State[0] = LongOverflowAdd(State[0], num);
  686. State[1] = LongOverflowAdd(State[1], num2);
  687. State[2] = LongOverflowAdd(State[2], num3);
  688. State[3] = LongOverflowAdd(State[3], num4);
  689. }
  690.  
  691. private static void FF(ref long A, long B, long C, long D, long X, long S, long ac)
  692. {
  693. A = LongOverflowAdd4(A, (B & C) | (~B & D), X, ac);
  694. A = LongLeftRotate(A, S);
  695. A = LongOverflowAdd(A, B);
  696. }
  697.  
  698. private static void GG(ref long A, long B, long C, long D, long X, long S, long ac)
  699. {
  700. A = LongOverflowAdd4(A, (B & D) | (C & ~D), X, ac);
  701. A = LongLeftRotate(A, S);
  702. A = LongOverflowAdd(A, B);
  703. }
  704.  
  705. private static void HH(ref long A, long B, long C, long D, long X, long S, long ac)
  706. {
  707. A = LongOverflowAdd4(A, B ^ C ^ D, X, ac);
  708. A = LongLeftRotate(A, S);
  709. A = LongOverflowAdd(A, B);
  710. }
  711.  
  712. private static void II(ref long A, long B, long C, long D, long X, long S, long ac)
  713. {
  714. A = LongOverflowAdd4(A, C ^ (B | ~D), X, ac);
  715. A = LongLeftRotate(A, S);
  716. A = LongOverflowAdd(A, B);
  717. }
  718.  
  719. private static long LongLeftRotate(long value, long Bits)
  720. {
  721. Bits %= 32;
  722. if (Bits == 0)
  723. {
  724. return value;
  725. }
  726. long num = 0L;
  727. for (long num2 = 1L; num2 <= Bits; num2++)
  728. {
  729. long num3 = value & -1073741824;
  730. value = (value & 0x3FFFFFFF) * 2;
  731. num = value;
  732. int num4 = (num3 < 0) ? 1 : 0;
  733. if (num3 < 0 && num3 != -1073741824)
  734. {
  735. value += num4;
  736. }
  737. if (num3 == 1073741824)
  738. {
  739. value += -2147483648;
  740. }
  741. if (num3 == -1073741824)
  742. {
  743. value = value + -2147483648 + 1;
  744. }
  745. }
  746. return value;
  747. }
  748.  
  749. private static long LongOverflowAdd(long Val1, long Val2)
  750. {
  751. long num = (Val1 & 0xFFFF) + (Val2 & 0xFFFF);
  752. long num2 = num / 65536;
  753. long num3 = (Val1 & 4294901760u) / 65536 + (Val2 & 4294901760u) / 65536 + num2 & 0xFFFF;
  754. return UnsignedToLong(num3 * 65536 + (num & 0xFFFF));
  755. }
  756.  
  757. private static long LongOverflowAdd4(long Val1, long Val2, long val3, long val4)
  758. {
  759. long num = (Val1 & 0xFFFF) + (Val2 & 0xFFFF) + (val3 & 0xFFFF) + (val4 & 0xFFFF);
  760. long num2 = num / 65536;
  761. long num3 = (Val1 & 4294901760u) / 65536 + (Val2 & 4294901760u) / 65536 + (val3 & 4294901760u) / 65536 + (val4 & 4294901760u) / 65536 + num2 & 0xFFFF;
  762. return UnsignedToLong(num3 * 65536 + (num & 0xFFFF));
  763. }
  764.  
  765. private static long[] Decode(int Length, byte[] InputBuffer)
  766. {
  767. long[] array = new long[Length / 4];
  768. int num = 0;
  769. for (int i = 0; i < Length; i += 4)
  770. {
  771. double num2 = (double)(InputBuffer[i] + InputBuffer[i + 1] * 256 + InputBuffer[i + 2] * 65536 + InputBuffer[i + 3] * 16777216);
  772. array[num] = (long)num2;
  773. num++;
  774. }
  775. return array;
  776. }
  777.  
  778. public static string FormatKeyCode(string StrIn, int GrpLen)
  779. {
  780. int num = 0;
  781. int num2 = 0;
  782. string text = null;
  783. string text2 = null;
  784. int num3 = 0;
  785. int num4 = 0;
  786. num = StrIn.Length;
  787. int num5 = num / GrpLen;
  788. num4 = num % GrpLen;
  789. for (num2 = 0; num2 < num5; num2++)
  790. {
  791. num3 = num2 * GrpLen;
  792. text2 = StrIn.Substring(num3, GrpLen);
  793. text = ((num2 <= 0) ? (text + text2) : (text + "-" + text2));
  794. }
  795. if (num4 > 0)
  796. {
  797. text = text + "-" + StrIn.Substring(StrIn.Length - num4, num4);
  798. }
  799. return text;
  800. }
  801. }
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!