API tools faq
paste
Advertisement
allen343434

Untitled

allen343434
Mar 11th, 2017
66
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 33.80 KB | None | 0 0
raw download clone embed print report
  1. using System;
  2. using System.Collections.Generic;
  3. using System.ComponentModel;
  4. using System.Data;
  5. using System.Drawing;
  6. using System.Linq;
  7. using System.Text;
  8. using System.Threading.Tasks;
  9. using System.Windows.Forms;
  10. using System.Diagnostics;
  11. using System.Runtime.InteropServices;
  12.  
  13. namespace STEB_PSF_EXTERNAL
  14. {
  15. public partial class Form1 : Form
  16. {
  17.  
  18. #region DLL Imports
  19. private const int PROCESS_ALL_ACCESS = 0x1F0FFF;
  20. [DllImport("kernel32")]
  21. private static extern int OpenProcess(int AccessType, int InheritHandle, int ProcessId);
  22. [DllImport("kernel32", EntryPoint = "WriteProcessMemory")]
  23. private static extern byte WriteProcessMemoryByte(int Handle, int Address, ref byte Value, int Size, ref int BytesWritten);
  24. [DllImport("kernel32", EntryPoint = "WriteProcessMemory")]
  25. private static extern int WriteProcessMemoryInteger(int Handle, int Address, ref int Value, int Size, ref int BytesWritten);
  26. [DllImport("kernel32", EntryPoint = "WriteProcessMemory")]
  27. private static extern float WriteProcessMemoryFloat(int Handle, int Address, ref float Value, int Size, ref int BytesWritten);
  28. [DllImport("kernel32", EntryPoint = "WriteProcessMemory")]
  29. private static extern double WriteProcessMemoryDouble(int Handle, int Address, ref double Value, int Size, ref int BytesWritten);
  30.  
  31.  
  32. [DllImport("kernel32", EntryPoint = "ReadProcessMemory")]
  33. private static extern byte ReadProcessMemoryByte(int Handle, int Address, ref byte Value, int Size, ref int BytesRead);
  34. [DllImport("kernel32", EntryPoint = "ReadProcessMemory")]
  35. private static extern int ReadProcessMemoryInteger(int Handle, int Address, ref int Value, int Size, ref int BytesRead);
  36. [DllImport("kernel32", EntryPoint = "ReadProcessMemory")]
  37. private static extern float ReadProcessMemoryFloat(int Handle, int Address, ref float Value, int Size, ref int BytesRead);
  38. [DllImport("kernel32", EntryPoint = "ReadProcessMemory")]
  39. private static extern double ReadProcessMemoryDouble(int Handle, int Address, ref double Value, int Size, ref int BytesRead);
  40. [DllImport("kernel32")]
  41. private static extern int CloseHandle(int Handle);
  42.  
  43. [DllImport("user32")]
  44. private static extern int FindWindow(string sClassName, string sAppName);
  45. [DllImport("user32")]
  46. private static extern int GetWindowThreadProcessId(int HWND, out int processId);
  47. private Point _MousePosition;
  48. private Rectangle _CrosshairXLine;
  49. private Rectangle _CrosshairYLine;
  50. private bool _MouseInBounds;
  51.  
  52. [Flags]
  53. public enum ThreadAccess : int
  54. {
  55. TERMINATE = (0x0001),
  56. SUSPEND_RESUME = (0x0002),
  57. GET_CONTEXT = (0x0008),
  58. SET_CONTEXT = (0x0010),
  59. SET_INFORMATION = (0x0020),
  60. QUERY_INFORMATION = (0x0040),
  61. SET_THREAD_TOKEN = (0x0080),
  62. IMPERSONATE = (0x0100),
  63. DIRECT_IMPERSONATION = (0x0200)
  64. }
  65.  
  66. [DllImport("kernel32.dll")]
  67. static extern IntPtr OpenThread(ThreadAccess dwDesiredAccess, bool bInheritHandle, uint dwThreadId);
  68. [DllImport("kernel32.dll")]
  69. static extern uint SuspendThread(IntPtr hThread);
  70. [DllImport("kernel32.dll")]
  71. static extern int ResumeThread(IntPtr hThread);
  72.  
  73. private void SuspendProcess(int PID)
  74. {
  75. Process proc = Process.GetProcessById(PID);
  76.  
  77. if (proc.ProcessName == string.Empty)
  78. return;
  79.  
  80. foreach (ProcessThread pT in proc.Threads)
  81. {
  82. IntPtr pOpenThread = OpenThread(ThreadAccess.SUSPEND_RESUME, false, (uint)pT.Id);
  83.  
  84. if (pOpenThread == IntPtr.Zero)
  85. {
  86. break;
  87. }
  88.  
  89. SuspendThread(pOpenThread);
  90. }
  91. }
  92. public void ResumeProcess(int PID)
  93. {
  94. Process proc = Process.GetProcessById(PID);
  95.  
  96. if (proc.ProcessName == string.Empty)
  97. return;
  98.  
  99. foreach (ProcessThread pT in proc.Threads)
  100. {
  101. IntPtr pOpenThread = OpenThread(ThreadAccess.SUSPEND_RESUME, false, (uint)pT.Id);
  102.  
  103. if (pOpenThread == IntPtr.Zero)
  104. {
  105. break;
  106. }
  107.  
  108. ResumeThread(pOpenThread);
  109. }
  110. }
  111.  
  112. #endregion
  113.  
  114. #region Read
  115. public static Byte ReadInt8(string EXENAME, int Address)
  116. {
  117. byte Value = 0;
  118. checked
  119. {
  120. try
  121. {
  122. Process[] Proc = Process.GetProcessesByName(EXENAME);
  123. if (Proc.Length != 0)
  124. {
  125. int Bytes = 0;
  126. int Handle = OpenProcess(PROCESS_ALL_ACCESS, 0, Proc[0].Id);
  127. if (Handle != 0)
  128. {
  129. ReadProcessMemoryByte(Handle, Address, ref Value, 1, ref Bytes);
  130. CloseHandle(Handle);
  131. }
  132. }
  133. }
  134. catch
  135. { }
  136. }
  137. return Value;
  138. }
  139. public static Int16 ReadInt16(string EXENAME, int Address)
  140. {
  141. Int16 Value = 0;
  142. checked
  143. {
  144. try
  145. {
  146. Process[] Proc = Process.GetProcessesByName(EXENAME);
  147. if (Proc.Length != 0)
  148. {
  149. int Handle = OpenProcess(PROCESS_ALL_ACCESS, 0, Proc[0].Id);
  150. if (Handle != 0)
  151. {
  152. int Int32_Value = ReadInt32(EXENAME, Address);
  153. byte[] Int32_Value_Bytes = BitConverter.GetBytes(Int32_Value);
  154. Value = BitConverter.ToInt16(Int32_Value_Bytes, 0);
  155. CloseHandle(Handle);
  156. }
  157. }
  158. }
  159. catch { };
  160. }
  161. return Value;
  162. }
  163. public static Int32 ReadInt32(string EXENAME, int Address)
  164. {
  165. Int32 Value = 0;
  166. checked
  167. {
  168. try
  169. {
  170. Process[] Proc = Process.GetProcessesByName(EXENAME);
  171. if (Proc.Length != 0)
  172. {
  173. int Bytes = 0;
  174. int Handle = OpenProcess(PROCESS_ALL_ACCESS, 0, Proc[0].Id);
  175. if (Handle != 0)
  176. {
  177. ReadProcessMemoryInteger(Handle, Address, ref Value, 4, ref Bytes);
  178. CloseHandle(Handle);
  179. }
  180. }
  181. }
  182. catch
  183. { }
  184. }
  185. return Value;
  186. }
  187. public static Int64 ReadInt64(string EXENAME, int Address)
  188. {
  189. Int64 Value = 0;
  190. checked
  191. {
  192. try
  193. {
  194. Process[] Proc = Process.GetProcessesByName(EXENAME);
  195. if (Proc.Length != 0)
  196. {
  197. int Bytes = 0;
  198. int Handle = OpenProcess(PROCESS_ALL_ACCESS, 0, Proc[0].Id);
  199. if (Handle != 0)
  200. {
  201. byte[] Bytes8 = ReadByteArray(EXENAME, Address, 8);
  202. Value = BitConverter.ToInt64(Bytes8, 0);
  203. //ReadProcessMemoryInteger(Handle, Address, ref Value, 4, ref Bytes);
  204. CloseHandle(Handle);
  205. }
  206. }
  207. }
  208. catch
  209. { }
  210. }
  211. return Value;
  212. }
  213. public static float ReadFloat(string EXENAME, int Address)
  214. {
  215. float Value = 0;
  216. checked
  217. {
  218. try
  219. {
  220. Process[] Proc = Process.GetProcessesByName(EXENAME);
  221. if (Proc.Length != 0)
  222. {
  223. int Bytes = 0;
  224. int Handle = OpenProcess(PROCESS_ALL_ACCESS, 0, Proc[0].Id);
  225. if (Handle != 0)
  226. {
  227. ReadProcessMemoryFloat((int)Handle, Address, ref Value, 4, ref Bytes);
  228. CloseHandle(Handle);
  229. }
  230. }
  231. }
  232. catch
  233. { }
  234. }
  235. return Value;
  236. }
  237. public static double ReadDouble(string EXENAME, int Address)
  238. {
  239. double Value = 0;
  240. checked
  241. {
  242. try
  243. {
  244. Process[] Proc = Process.GetProcessesByName(EXENAME);
  245. if (Proc.Length != 0)
  246. {
  247. int Bytes = 0;
  248. int Handle = OpenProcess(PROCESS_ALL_ACCESS, 0, Proc[0].Id);
  249. if (Handle != 0)
  250. {
  251. ReadProcessMemoryDouble((int)Handle, Address, ref Value, 8, ref Bytes);
  252. CloseHandle(Handle);
  253. }
  254. }
  255. }
  256. catch
  257. { }
  258. }
  259. return Value;
  260. }
  261. #endregion
  262.  
  263. #region ReadPointer
  264. public static Byte ReadPointerInt8(string EXENAME, int Pointer, int[] Offset)
  265. {
  266. byte Value = 0;
  267. checked
  268. {
  269. try
  270. {
  271. Process[] Proc = Process.GetProcessesByName(EXENAME);
  272. if (Proc.Length != 0)
  273. {
  274. int Bytes = 0;
  275. int Handle = OpenProcess(PROCESS_ALL_ACCESS, 0, Proc[0].Id);
  276. if (Handle != 0)
  277. {
  278. foreach (int i in Offset)
  279. {
  280. ReadProcessMemoryInteger((int)Handle, Pointer, ref Pointer, 4, ref Bytes);
  281. Pointer += i;
  282. }
  283. ReadProcessMemoryByte((int)Handle, Pointer, ref Value, 2, ref Bytes);
  284. CloseHandle(Handle);
  285. }
  286. }
  287. }
  288. catch
  289. { }
  290. }
  291. return Value;
  292. }
  293. public static Int16 ReadPointerInt16(string EXENAME, int Pointer, int[] Offset)
  294. {
  295. Int16 Value = 0;
  296. checked
  297. {
  298. try
  299. {
  300. Process[] Proc = Process.GetProcessesByName(EXENAME);
  301. if (Proc.Length != 0)
  302. {
  303. int Bytes = 0;
  304. int Handle = OpenProcess(PROCESS_ALL_ACCESS, 0, Proc[0].Id);
  305. if (Handle != 0)
  306. {
  307. foreach (int i in Offset)
  308. {
  309. ReadProcessMemoryInteger((int)Handle, Pointer, ref Pointer, 2, ref Bytes);
  310. Pointer += i;
  311. }
  312. ReadInt16(EXENAME, Pointer);
  313. //ReadProcessMemoryInteger((int)Handle, Pointer, ref Value, 4, ref Bytes);
  314. CloseHandle(Handle);
  315. }
  316. }
  317. }
  318. catch
  319. { }
  320. }
  321. return Value;
  322. }
  323. public static int ReadPointerInt32(string EXENAME, int Pointer, int[] Offset)
  324. {
  325. int Value = 0;
  326. checked
  327. {
  328. try
  329. {
  330. Process[] Proc = Process.GetProcessesByName(EXENAME);
  331. if (Proc.Length != 0)
  332. {
  333. int Bytes = 0;
  334. int Handle = OpenProcess(PROCESS_ALL_ACCESS, 0, Proc[0].Id);
  335. if (Handle != 0)
  336. {
  337. foreach (int i in Offset)
  338. {
  339. ReadProcessMemoryInteger((int)Handle, Pointer, ref Pointer, 4, ref Bytes);
  340. Pointer += i;
  341. }
  342. ReadProcessMemoryInteger((int)Handle, Pointer, ref Value, 4, ref Bytes);
  343. CloseHandle(Handle);
  344. }
  345. }
  346. }
  347. catch
  348. { }
  349. }
  350. return Value;
  351. }
  352. public static Int64 ReadPointerInt64(string EXENAME, int Pointer, int[] Offset)
  353. {
  354. Int64 Value = 0;
  355. checked
  356. {
  357. try
  358. {
  359. Process[] Proc = Process.GetProcessesByName(EXENAME);
  360. if (Proc.Length != 0)
  361. {
  362. int Bytes = 0;
  363. int Handle = OpenProcess(PROCESS_ALL_ACCESS, 0, Proc[0].Id);
  364. if (Handle != 0)
  365. {
  366. foreach (int i in Offset)
  367. {
  368. ReadProcessMemoryInteger((int)Handle, Pointer, ref Pointer, 4, ref Bytes);
  369. Pointer += i;
  370. }
  371. Value = ReadInt64(EXENAME, Pointer);
  372. //ReadProcessMemoryInteger((int)Handle, Pointer, ref Value, 4, ref Bytes);
  373. CloseHandle(Handle);
  374. }
  375. }
  376. }
  377. catch
  378. { }
  379. }
  380. return Value;
  381. }
  382. public static float ReadPointerFloat(string EXENAME, int Pointer, int[] Offset)
  383. {
  384. float Value = 0;
  385. checked
  386. {
  387. try
  388. {
  389. Process[] Proc = Process.GetProcessesByName(EXENAME);
  390. if (Proc.Length != 0)
  391. {
  392. int Bytes = 0;
  393. int Handle = OpenProcess(PROCESS_ALL_ACCESS, 0, Proc[0].Id);
  394. if (Handle != 0)
  395. {
  396. foreach (int i in Offset)
  397. {
  398. ReadProcessMemoryInteger((int)Handle, Pointer, ref Pointer, 4, ref Bytes);
  399. Pointer += i;
  400. }
  401. ReadProcessMemoryFloat((int)Handle, Pointer, ref Value, 4, ref Bytes);
  402. CloseHandle(Handle);
  403. }
  404. }
  405. }
  406. catch
  407. { }
  408. }
  409. return Value;
  410. }
  411. public static double ReadPointerDouble(string EXENAME, int Pointer, int[] Offset)
  412. {
  413. double Value = 0;
  414. checked
  415. {
  416. try
  417. {
  418. Process[] Proc = Process.GetProcessesByName(EXENAME);
  419. if (Proc.Length != 0)
  420. {
  421. int Bytes = 0;
  422. int Handle = OpenProcess(PROCESS_ALL_ACCESS, 0, Proc[0].Id);
  423. if (Handle != 0)
  424. {
  425. foreach (int i in Offset)
  426. {
  427. ReadProcessMemoryInteger((int)Handle, Pointer, ref Pointer, 4, ref Bytes);
  428. Pointer += i;
  429. }
  430. ReadProcessMemoryDouble((int)Handle, Pointer, ref Value, 8, ref Bytes);
  431. CloseHandle(Handle);
  432. }
  433. }
  434. }
  435. catch
  436. { }
  437. }
  438. return Value;
  439. }
  440. #endregion
  441.  
  442. #region Write
  443. public static void WriteInt8(string EXENAME, int Address, byte Value)
  444. {
  445. checked
  446. {
  447. try
  448. {
  449. Process[] Proc = Process.GetProcessesByName(EXENAME);
  450. if (Proc.Length != 0)
  451. {
  452. int Bytes = 0;
  453. int Handle = OpenProcess(PROCESS_ALL_ACCESS, 0, Proc[0].Id);
  454. if (Handle != 0)
  455. {
  456. WriteProcessMemoryByte(Handle, Address, ref Value, 1, ref Bytes);
  457. }
  458. CloseHandle(Handle);
  459. }
  460. }
  461. catch
  462. { }
  463. }
  464. }
  465. public static void WriteInt16(string EXENAME, int Address, Int16 Value)
  466. {
  467. checked
  468. {
  469. try
  470. {
  471. Process[] Proc = Process.GetProcessesByName(EXENAME);
  472. if (Proc.Length != 0)
  473. {
  474. int Bytes = 0;
  475. int Handle = OpenProcess(PROCESS_ALL_ACCESS, 0, Proc[0].Id);
  476. if (Handle != 0)
  477. {
  478. WriteInt16(EXENAME, Address, Value);
  479. //WriteProcessMemoryByte(Handle, Address, ref Value, 2, ref Bytes);
  480. }
  481. CloseHandle(Handle);
  482. }
  483. }
  484. catch
  485. { }
  486. }
  487. }
  488. public static void WriteInt32(string EXENAME, int Address, int Value)
  489. {
  490. checked
  491. {
  492. try
  493. {
  494. Process[] Proc = Process.GetProcessesByName(EXENAME);
  495. if (Proc.Length != 0)
  496. {
  497. int Bytes = 0;
  498. int Handle = OpenProcess(PROCESS_ALL_ACCESS, 0, Proc[0].Id);
  499. if (Handle != 0)
  500. {
  501. WriteProcessMemoryInteger(Handle, Address, ref Value, 4, ref Bytes);
  502. }
  503. CloseHandle(Handle);
  504. }
  505. }
  506. catch
  507. { }
  508. }
  509. }
  510. public static void WriteInt64(string EXENAME, int Address, Int64 Value)
  511. {
  512. checked
  513. {
  514. try
  515. {
  516. Process[] Proc = Process.GetProcessesByName(EXENAME);
  517. if (Proc.Length != 0)
  518. {
  519. int Bytes = 0;
  520. int Handle = OpenProcess(PROCESS_ALL_ACCESS, 0, Proc[0].Id);
  521. if (Handle != 0)
  522. {
  523. byte[] Bytes8 = BitConverter.GetBytes(Value);
  524. WriteByteArray(EXENAME, Address, Bytes8);
  525. //WriteProcessMemoryInteger(Handle, Address, ref Value, 4, ref Bytes);
  526. }
  527. CloseHandle(Handle);
  528. }
  529. }
  530. catch
  531. { }
  532. }
  533. }
  534. public static void WriteFloat(string EXENAME, int Address, float Value)
  535. {
  536. checked
  537. {
  538. try
  539. {
  540. Process[] Proc = Process.GetProcessesByName(EXENAME);
  541. if (Proc.Length != 0)
  542. {
  543. int Bytes = 0;
  544. int Handle = OpenProcess(PROCESS_ALL_ACCESS, 0, Proc[0].Id);
  545. if (Handle != 0)
  546. {
  547. WriteProcessMemoryFloat(Handle, Address, ref Value, 4, ref Bytes);
  548. }
  549. CloseHandle(Handle);
  550. }
  551.  
  552. }
  553. catch
  554. { }
  555. }
  556. }
  557. public static void WriteDouble(string EXENAME, int Address, double Value)
  558. {
  559. checked
  560. {
  561. try
  562. {
  563. Process[] Proc = Process.GetProcessesByName(EXENAME);
  564. if (Proc.Length != 0)
  565. {
  566. int Bytes = 0;
  567. int Handle = OpenProcess(PROCESS_ALL_ACCESS, 0, Proc[0].Id);
  568. if (Handle != 0)
  569. {
  570. WriteProcessMemoryDouble(Handle, Address, ref Value, 8, ref Bytes);
  571. }
  572. CloseHandle(Handle);
  573. }
  574. }
  575. catch
  576. { }
  577. }
  578. }
  579. #endregion
  580.  
  581. #region WritePointer
  582. public static void WritePointerInt8(string EXENAME, int Pointer, int[] Offset, byte Value)
  583. {
  584. checked
  585. {
  586. try
  587. {
  588. Process[] Proc = Process.GetProcessesByName(EXENAME);
  589. if (Proc.Length != 0)
  590. {
  591. int Handle = OpenProcess(PROCESS_ALL_ACCESS, 0, Proc[0].Id);
  592. if (Handle != 0)
  593. {
  594. int Bytes = 0;
  595. foreach (int i in Offset)
  596. {
  597. ReadProcessMemoryInteger(Handle, Pointer, ref Pointer, 4, ref Bytes);
  598. Pointer += i;
  599. }
  600. WriteProcessMemoryByte(Handle, Pointer, ref Value, 1, ref Bytes);
  601. }
  602. CloseHandle(Handle);
  603. }
  604. }
  605. catch
  606. { }
  607. }
  608. }
  609. public static void WritePointerInt16(string EXENAME, int Pointer, int[] Offset, Int16 Value)
  610. {
  611. checked
  612. {
  613. try
  614. {
  615. Process[] Proc = Process.GetProcessesByName(EXENAME);
  616. if (Proc.Length != 0)
  617. {
  618. int Handle = OpenProcess(PROCESS_ALL_ACCESS, 0, Proc[0].Id);
  619. if (Handle != 0)
  620. {
  621. int Bytes = 0;
  622. foreach (int i in Offset)
  623. {
  624. ReadProcessMemoryInteger(Handle, Pointer, ref Pointer, 4, ref Bytes);
  625. Pointer += i;
  626. }
  627. WriteInt16(EXENAME, Pointer, Value);
  628. //WriteProcessMemoryInteger(Handle, Pointer, ref Value, 4, ref Bytes);
  629. }
  630. CloseHandle(Handle);
  631. }
  632. }
  633. catch
  634. { }
  635. }
  636. }
  637. public static void WritePointerInt32(string EXENAME, int Pointer, int[] Offset, int Value)
  638. {
  639. checked
  640. {
  641. try
  642. {
  643. Process[] Proc = Process.GetProcessesByName(EXENAME);
  644. if (Proc.Length != 0)
  645. {
  646. int Handle = OpenProcess(PROCESS_ALL_ACCESS, 0, Proc[0].Id);
  647. if (Handle != 0)
  648. {
  649. int Bytes = 0;
  650. foreach (int i in Offset)
  651. {
  652. ReadProcessMemoryInteger(Handle, Pointer, ref Pointer, 4, ref Bytes);
  653. Pointer += i;
  654. }
  655. WriteProcessMemoryInteger(Handle, Pointer, ref Value, 4, ref Bytes);
  656. }
  657. CloseHandle(Handle);
  658. }
  659. }
  660. catch
  661. { }
  662. }
  663. }
  664. public static void WritePointerInt64(string EXENAME, int Pointer, int[] Offset, Int64 Value)
  665. {
  666. checked
  667. {
  668. try
  669. {
  670. Process[] Proc = Process.GetProcessesByName(EXENAME);
  671. if (Proc.Length != 0)
  672. {
  673. int Handle = OpenProcess(PROCESS_ALL_ACCESS, 0, Proc[0].Id);
  674. if (Handle != 0)
  675. {
  676. int Bytes = 0;
  677. foreach (int i in Offset)
  678. {
  679. ReadProcessMemoryInteger(Handle, Pointer, ref Pointer, 4, ref Bytes);
  680. Pointer += i;
  681. }
  682. WriteInt64(EXENAME, Pointer, Value);
  683. //WriteProcessMemoryInteger(Handle, Pointer, ref Value, 4, ref Bytes);
  684. }
  685. CloseHandle(Handle);
  686. }
  687. }
  688. catch
  689. { }
  690. }
  691. }
  692. public static void WritePointerFloat(string EXENAME, int Pointer, int[] Offset, float Value)
  693. {
  694. checked
  695. {
  696. try
  697. {
  698. Process[] Proc = Process.GetProcessesByName(EXENAME);
  699. if (Proc.Length != 0)
  700. {
  701. int Handle = OpenProcess(PROCESS_ALL_ACCESS, 0, Proc[0].Id);
  702. if (Handle != 0)
  703. {
  704. int Bytes = 0;
  705. foreach (int i in Offset)
  706. {
  707. ReadProcessMemoryInteger(Handle, Pointer, ref Pointer, 4, ref Bytes);
  708. Pointer += i;
  709. }
  710. WriteProcessMemoryFloat(Handle, Pointer, ref Value, 4, ref Bytes);
  711. }
  712. CloseHandle(Handle);
  713. }
  714. }
  715. catch
  716. { }
  717. }
  718. }
  719. public static void WritePointerDouble(string EXENAME, int Pointer, int[] Offset, double Value)
  720. {
  721. checked
  722. {
  723. try
  724. {
  725. Process[] Proc = Process.GetProcessesByName(EXENAME);
  726. if (Proc.Length != 0)
  727. {
  728. int Handle = OpenProcess(PROCESS_ALL_ACCESS, 0, Proc[0].Id);
  729. if (Handle != 0)
  730. {
  731. int Bytes = 0;
  732. foreach (int i in Offset)
  733. {
  734. ReadProcessMemoryInteger(Handle, Pointer, ref Pointer, 4, ref Bytes);
  735. Pointer += i;
  736. }
  737. WriteProcessMemoryDouble(Handle, Pointer, ref Value, 8, ref Bytes);
  738. }
  739. CloseHandle(Handle);
  740. }
  741. }
  742. catch
  743. { }
  744. }
  745. }
  746. #endregion
  747.  
  748. #region Others
  749. public static byte[] ReadByteArray(string EXENAME, int Address, int count)
  750. {
  751. if (count > 0)
  752. {
  753. try
  754. {
  755. byte[] value = new byte[count];
  756. for (int i = 0; i < count; i++)
  757. {
  758. value[i] = ReadInt8(EXENAME, Address + i);
  759. }
  760. return value;
  761. }
  762. catch { };
  763. }
  764. return null;
  765. }
  766. public static void WriteByteArray(string EXENAME, int address, byte[] bytes)
  767. {
  768. for (int i = 0; i < bytes.Length; i++)
  769. {
  770. WriteInt8(EXENAME, address + i, bytes[i]);
  771. }
  772. }
  773.  
  774. public static string ReadStringUntilNULL(string EXENAME, int Address)
  775. {
  776. string value = "";
  777. bool endOfString = false;
  778. int counter = 0;
  779. while (!endOfString)
  780. {
  781. if (ReadInt8(EXENAME, Address + counter) > (byte)0)
  782. {
  783. value += (char)ReadInt8(EXENAME, Address + counter);
  784. }
  785. else
  786. {
  787. return value;
  788. }
  789. counter++;
  790. }
  791. return value;
  792. }
  793. public static void WriteString(string EXENAME, int Address, string value)
  794. {
  795. if (value != null)
  796. {
  797. int counter = 0;
  798. foreach (char chr in value.ToCharArray())
  799. {
  800. WriteInt8(EXENAME, Address + counter, (byte)chr);
  801. counter++;
  802. }
  803. }
  804. }
  805.  
  806. public static void WriteNOPs(string EXENAME, int address, int count)
  807. {
  808. for (int i = 0; i < count; i++)
  809. {
  810. WriteInt8(EXENAME, address + i, 0x90);
  811. }
  812. }
  813.  
  814. public static string CheckGame(string WindowTitle)
  815. {
  816. string result = "";
  817. checked
  818. {
  819. try
  820. {
  821. int Proc;
  822. int HWND = FindWindow(null, WindowTitle);
  823. GetWindowThreadProcessId(HWND, out Proc);
  824. int Handle = OpenProcess(PROCESS_ALL_ACCESS, 0, Proc);
  825. if (Handle != 0)
  826. {
  827. result = "Game is running...";
  828. }
  829. else
  830. {
  831. result = "Game is not running...";
  832. }
  833. CloseHandle(Handle);
  834. }
  835. catch
  836. { }
  837. }
  838. return result;
  839. }
  840.  
  841. public static void WriteCodeInjection(string EXENAME, int InjectAddress, byte[] InjectCode, int CodeCaveAddress, byte[] CodeCaveCode)
  842. {
  843. checked
  844. {
  845. try
  846. {
  847. WriteByteArray(EXENAME, InjectAddress, InjectCode);
  848. WriteByteArray(EXENAME, CodeCaveAddress, CodeCaveCode);
  849. }
  850. catch { };
  851. }
  852. }
  853.  
  854. #endregion
  855.  
  856.  
  857. public Form1()
  858. {
  859. InitializeComponent();
  860. }
  861.  
  862. public static int one = 0;
  863.  
  864. private void Form1_Load(object sender, EventArgs e)
  865. {
  866. webBrowser1.Navigate("http://adf.ly/1lGJfo");
  867. webBrowser1.ScriptErrorsSuppressed = true;
  868. }
  869.  
  870. private void Update_Tick(object sender, EventArgs e)
  871. {
  872. if (Process.GetProcessesByName("SpecialForce").Length > 0)
  873. {
  874. gameST.BackColor = System.Drawing.Color.FromArgb(191, 255, 0);
  875. statusTXT.Text = "Green = Press load.";
  876. }
  877. else
  878. {
  879. gameST.BackColor = System.Drawing.Color.FromArgb(255, 255, 0, 0);
  880. statusTXT.Text = "Red = SF.exe is not open.";
  881. }
  882. }
  883.  
  884. private void button1_Click(object sender, EventArgs e)
  885. {
  886. if (Process.GetProcessesByName("SpecialForce").Length > 0)
  887. {
  888. bool injcs = true;
  889. while (injcs)
  890. {
  891. Process[] NewProc = Process.GetProcessesByName("SpecialForce");
  892. if (NewProc.Length == 1)
  893. {
  894. System.Threading.Thread.Sleep(1000);
  895. try
  896. {
  897. if (checkBox1.Checked == true)
  898. {
  899. WriteNOPs("SpecialForce", 0x930F12, 6);
  900. }
  901. if (checkBox2.Checked == true)
  902. {
  903. WriteFloat("SpecialForce", 0xDA098C, 250);
  904. }
  905. if (checkBox3.Checked == true)
  906. {
  907. WriteNOPs("SpecialForce", 0xA7FBD4, 4);
  908. WriteNOPs("SpecialForce", 0xA7FB86, 6);
  909. }
  910. injcs = false;
  911. Application.Exit();
  912. }
  913. catch
  914. {
  915. statusTXT.Text = "Failed to inject.";
  916. }
  917. }
  918. }
  919. }
  920. else
  921. {
  922. MessageBox.Show("Start SF First", "STEB", MessageBoxButtons.OK, MessageBoxIcon.Error);
  923. }
  924. }
  925.  
  926. private void button2_Click(object sender, EventArgs e)
  927. {
  928. MessageBox.Show("Press StartGame, Press load Before Xigncode starts", "STEB", MessageBoxButtons.OK, MessageBoxIcon.Information);
  929. }
  930.  
  931. }
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!