[C#] SharpB00mer - Read/Write Memory Kütüphanesi

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CylSharpBoomer.Lib
{
    class CylSharpProcess
    {
        #region <-=[/\_CylSharp Process Controls_/\]=->
        public static bool SharpTestProcessByName(string ProcName)
        {
            //My TestProcess Class. If Process Open, It Will return true. Else, false...
            Process[] pname = Process.GetProcessesByName(ProcName);

            if (pname.Length == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        public static bool SharpTestProcessByPID(int PID)
        {
            //My TestProcess Class. If Process Open, It Will return true. Else, false...
            Process procid = Process.GetProcessById(PID);

            if (Convert.ToInt32(procid) != 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        public static string SharpGetPID(string ProcName)
        {
            //I Already Added ".exe" to filename. You Shouldn't Write This!
            var p = new Process();
            p.StartInfo.FileName = ProcName + ".exe";
            string ProcID = Convert.ToString(p.Id);

            if (CylSharpProcess.SharpTestProcessByName(ProcName))
            {
                return ProcID;
            }
            else
            {
                return "Not Running!";
            }
        }
        #endregion

        #region <-=[/\_CylSharp Module Handlers_/\]=->
        public struct SharpModules
        {
            //My F*ckn Module Struct. If you are not idiot, you can understand this shitty thing!
            //Here, i defined some things.
            public string moduleName;
            public int moduleAddress;
            public bool fp;
            public SharpModules(string ProcName, string moduleName_)
            {
                //Here, i defined some things, again.
                moduleName = moduleName_;
                moduleAddress = 0x000000;
                try
                {
                    if (SharpTestProcessByName(ProcName))
                    {
                        Process[] p = Process.GetProcessesByName(ProcName);
                        foreach (ProcessModule m in p[0].Modules)
                        {
                            if (m.ModuleName == moduleName_)
                            {
                                moduleAddress = (Int32)m.BaseAddress;
                                fp = true;
                            }
                        }
                        fp = true;
                    }
                    else
                    {
                        fp = false;
                    }
                }
                catch
                {
                    fp = false;
                }
            }
        }
        #endregion
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Windows.Forms;

namespace CylSharpBoomer.Lib
{
    #region My Memory Class. Are you ready?
    class CylSharpMem
    {
        #region SharpyNativeMethods
        internal static class CylSharpMethods
        {
            internal delegate int ThreadProc(IntPtr param);

            [DllImport("kernel32.dll")]
            internal static extern IntPtr OpenProcess(ProcessAccessFlags dwDesiredAccess, [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle, int dwProcessId);

            [DllImport("kernel32.dll")]
            internal static extern Int32 CloseHandle(IntPtr hProcess);

            [DllImport("Kernel32.dll")]
            internal static extern bool ReadProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, byte[] lpBuffer, UInt32 nSize, ref UInt32 lpNumberOfBytesRead);

            [DllImport("kernel32.dll")]
            internal static extern bool WriteProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, byte[] lpBuffer, IntPtr nSize, ref UInt32 lpNumberOfBytesWritten);

            [DllImport("kernel32.dll", SetLastError = true, ExactSpelling = true)]
            internal static extern bool VirtualFreeEx(IntPtr hProcess, IntPtr lpAddress, IntPtr dwSize, FreeType dwFreeType);

            [DllImport("kernel32.dll", SetLastError = true)]
            internal static extern UInt32 WaitForSingleObject(IntPtr hProcess, UInt32 dwMilliseconds);

            [DllImport("kernel32.dll")]
            internal static extern IntPtr CreateRemoteThread(IntPtr hProcess, IntPtr lpThreadAttributes, IntPtr dwStackSize, IntPtr lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, IntPtr lpThreadId);

            [DllImport("kernel32.dll", SetLastError = true, ExactSpelling = true)]
            internal static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr lpAddress, IntPtr dwSize, UInt32 flAllocationType, UInt32 flProtect);
        }
        #endregion

        #region CylSharpSuperSecretEnums
        internal enum ProcessAccessFlags : uint
        {
            All = 0x001F0FFF,
            Terminate = 0x00000001,
            CreateThread = 0x00000002,
            VMOperation = 0x00000008,
            VMRead = 0x00000010,
            VMWrite = 0x00000020,
            DupHandle = 0x00000040,
            SetInformation = 0x00000200,
            QueryInformation = 0x00000400,
            Synchronize = 0x00100000
        }
        private enum EncodingType
        {
            ASCII,
            Unicode,
            UTF7,
            UTF8
        }
        [Flags]
        internal enum FreeType
        {
            Decommit = 0x4000,
            Release = 0x8000,
        }
        #endregion

        #region SharpyDefinesThings
        private static IntPtr ProcessHandle;

        const UInt32 INFINITE = 0xFFFFFFFF;
        const UInt32 WAIT_ABANDONED = 0x00000080;
        const UInt32 WAIT_OBJECT_0 = 0x00000000;
        const UInt32 WAIT_TIMEOUT = 0x00000102;
        #endregion

        #region SharpyUberSuperMegaProcessControlUnit
        internal static void SharpyOpenProcess(int pId, ProcessAccessFlags ProcessAccess = ProcessAccessFlags.All)
        {
            ProcessHandle = CylSharpMethods.OpenProcess(ProcessAccess, false, pId);
        }
        internal static int AllocateMemory(int memorySize)
        {
            return (int)CylSharpMethods.VirtualAllocEx(ProcessHandle, (IntPtr)0, (IntPtr)memorySize, 0x1000, 0x40);
            //Ur Mom Gay
        }
        internal static IntPtr CreateRemoteThread(int address)
        {
            return CylSharpMethods.CreateRemoteThread(ProcessHandle, (IntPtr)0, (IntPtr)0, (IntPtr)address, (IntPtr)0, 0, (IntPtr)0);
        }
        internal static void WaitForSingleObject(IntPtr threadHandle)
        {
            if (CylSharpMethods.WaitForSingleObject(threadHandle, INFINITE) != WAIT_OBJECT_0)
            {
                MessageBox.Show("I Can't Wait For A Single Object You Mother F*ckn Programmer Bitch! -Cylops", "A Message From Cylops! => (You Bitch!)", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
        internal static void FreeMemory(int address)
        {
            bool result;
            result = CylSharpMethods.VirtualFreeEx(ProcessHandle, (IntPtr)address, (IntPtr)0, FreeType.Release);
        }
        internal static void CloseProcess(IntPtr handle)
        {
            Int32 result = CylSharpMethods.CloseHandle(handle);
        }
        #endregion

        #region CylSharp Writes Memory
        internal static void WriteBoolean(int Address, bool Value)
        {
            UInt32 nBytesRead = 0;
            byte[] bArray = BitConverter.GetBytes(Value);
            bool flag = CylSharpMethods.WriteProcessMemory(ProcessHandle, (IntPtr)Address, bArray, (IntPtr)2, ref nBytesRead);
        }
        internal static void WriteBytes(int address, byte[] value)
        {
            bool success;
            UInt32 nBytesRead = 0;
            success = CylSharpMethods.WriteProcessMemory(ProcessHandle, (IntPtr)address, value, (IntPtr)value.Length, ref nBytesRead);
        }
        internal static void WriteStruct(int address, object value)
        {
            bool success;
            byte[] buffer = RawSerialize(value);
            UInt32 nBytesRead = 0;
            success = CylSharpMethods.WriteProcessMemory(ProcessHandle, (IntPtr)address, buffer, (IntPtr)buffer.Length, ref nBytesRead);
        }
        internal static void WriteInt(int address, int value)
        {
            bool success;
            byte[] buffer = BitConverter.GetBytes(value);
            UInt32 nBytesRead = 0;
            success = CylSharpMethods.WriteProcessMemory(ProcessHandle, (IntPtr)address, buffer, (IntPtr)4, ref nBytesRead);
        }
        internal static void WriteFloat(int address, float value)
        {
            bool success;
            byte[] buffer = BitConverter.GetBytes(value);
            UInt32 nBytesRead = 0;
            success = CylSharpMethods.WriteProcessMemory(ProcessHandle, (IntPtr)address, buffer, (IntPtr)4, ref nBytesRead);
        }
        internal static void WriteShort(int address, short value)
        {
            bool success;
            byte[] buffer = BitConverter.GetBytes(value);
            UInt32 nBytesRead = 0;
            success = CylSharpMethods.WriteProcessMemory(ProcessHandle, (IntPtr)address, buffer, (IntPtr)2, ref nBytesRead);
        }
        internal static void WriteByte(int address, byte value)
        {
            bool success;
            byte[] buffer = BitConverter.GetBytes(value);
            UInt32 nBytesRead = 0;
            success = CylSharpMethods.WriteProcessMemory(ProcessHandle, (IntPtr)address, buffer, (IntPtr)1, ref nBytesRead);
        }
        #endregion

        #region CylSharp Reads Ur Memory
        internal static bool ReadBool(int Address)
        {
            IntPtr intPtr = IntPtr.Zero;
            byte[] bArray = new byte[4];
            UInt32 intPtr1 = 0;
            CylSharpMethods.ReadProcessMemory(ProcessHandle, (IntPtr)Address, bArray, 2, ref intPtr1);
            int rBInt = BitConverter.ToInt32(bArray, 0);
            int num = rBInt;
            bool boolValue = num != 0;
            return boolValue;
        }
        internal static byte[] ReadBytes(int address, int size)
        {
            bool success;
            byte[] buffer = new byte[size];
            UInt32 nBytesRead = 0;
            success = CylSharpMethods.ReadProcessMemory(ProcessHandle, (IntPtr)address, buffer, (uint)size, ref nBytesRead);
            return buffer;
        }
        internal static int ReadInt(int address)
        {
            bool success;
            byte[] buffer = new byte[4];
            UInt32 nBytesRead = 0;
            success = CylSharpMethods.ReadProcessMemory(ProcessHandle, (IntPtr)address, buffer, 4, ref nBytesRead);
            return BitConverter.ToInt32(buffer, 0);
        }
        internal static uint ReadUInt(uint address)
        {
            bool success;
            byte[] buffer = new byte[4];
            UInt32 nBytesRead = 0;
            success = CylSharpMethods.ReadProcessMemory(ProcessHandle, (IntPtr)address, buffer, 4, ref nBytesRead);
            return BitConverter.ToUInt32(buffer, 0);
        }
        internal static float ReadFloat(int address)
        {
            bool success;
            byte[] buffer = new byte[4];
            UInt32 nBytesRead = 0;
            success = CylSharpMethods.ReadProcessMemory(ProcessHandle, (IntPtr)address, buffer, 4, ref nBytesRead);
            return BitConverter.ToSingle(buffer, 0);
        }
        internal static string ReadUnicode(uint address, uint maxSize, ref uint _bytesRead)
        {
            bool success;
            byte[] buffer = new byte[maxSize];
            UInt32 nBytesRead = 0;
            success = CylSharpMethods.ReadProcessMemory(ProcessHandle, (IntPtr)address, buffer, maxSize, ref nBytesRead);
            _bytesRead = nBytesRead;
            return ByteArrayToString(buffer, EncodingType.Unicode);
        }
        internal static object ReadStruct(int address, Type anyType)
        {
            int rawsize = Marshal.SizeOf(anyType);
            bool success;
            byte[] buffer = new byte[rawsize];
            UInt32 nBytesRead = 0;
            success = CylSharpMethods.ReadProcessMemory(ProcessHandle, (IntPtr)address, buffer, (UInt32)rawsize, ref nBytesRead);
            return RawDeserialize(buffer, 0, anyType);
        }
        #endregion

        #region IDK This Area But I Think They Are Important So;
        private static object RawDeserialize(byte[] rawData, int position, Type anyType)
        {
            int rawsize = Marshal.SizeOf(anyType);
            if (rawsize > rawData.Length)
                return null;
            IntPtr buffer = Marshal.AllocHGlobal(rawsize);
            Marshal.Copy(rawData, position, buffer, rawsize);
            object retobj = Marshal.PtrToStructure(buffer, anyType);
            Marshal.FreeHGlobal(buffer);
            return retobj;
        }
        private static byte[] RawSerialize(object anything)
        {
            int rawSize = Marshal.SizeOf(anything);
            IntPtr buffer = Marshal.AllocHGlobal(rawSize);
            Marshal.StructureToPtr(anything, buffer, false);
            byte[] rawDatas = new byte[rawSize];
            Marshal.Copy(buffer, rawDatas, 0, rawSize);
            Marshal.FreeHGlobal(buffer);
            return rawDatas;
        }
        private static string ByteArrayToString(byte[] bytes)
        {
            return ByteArrayToString(bytes, EncodingType.Unicode);
        }
        private static string ByteArrayToString(byte[] bytes, EncodingType encodingType)
        {
            System.Text.Encoding encoding = null;
            string result = "";
            switch (encodingType)

            {
                case EncodingType.ASCII:
                    encoding = new System.Text.ASCIIEncoding();
                    break;
                case EncodingType.Unicode:
                    encoding = new System.Text.UnicodeEncoding();
                    break;
                case EncodingType.UTF7:
                    encoding = new System.Text.UTF7Encoding();
                    break;
                case EncodingType.UTF8:
                    encoding = new System.Text.UTF8Encoding();
                    break;
            }

            for (int i = 0; i < bytes.Length; i += 2)
            {
                if (bytes[i] == 0 && bytes[i + 1] == 0)
                {
                    result = encoding.GetString(bytes, 0, i);
                    break;
                }
            }

            return result;
        }
        private static byte[] StringToByteArray(string str, EncodingType encodingType)
        {
            System.Text.Encoding encoding = null;
            switch (encodingType)
            {
                case EncodingType.ASCII:
                    encoding = new System.Text.ASCIIEncoding();
                    break;
                case EncodingType.Unicode:
                    encoding = new System.Text.UnicodeEncoding();
                    break;
                case EncodingType.UTF7:
                    encoding = new System.Text.UTF7Encoding();
                    break;
                case EncodingType.UTF8:
                    encoding = new System.Text.UTF8Encoding();
                    break;
            }
            return encoding.GetBytes(str);
        }
        #endregion
    }
    #endregion
}