[DLL] DatMemory

[davydavekk]

sup

(je suis pas certains d’être dans la bonne section, mais cette DLL pourra faciliter le développement de cheats)

J'avais poster une classe [ICI], qui permet de modifier la mémoire d'un processus. Depuis, j'ai continuer a travailler dessus, et donc je vais poster la nouvelle version ici. (et aussi les updates)​

Utilisation (C#) :

-Ajoutez la référence dans votre projet (Solution Explorer> Ajouter > Référence)
-Ajoutez :

using Memory; // A placer tout en haut de votre code

[Documentation arriveras plus tard .. ou pas.]

Questions/Critiques/Commentaires sont toujours bienvenus
(mais pas de critiques sur la présentation pls )

Source sur GitHub: Ce lien n'est pas visible, veuillez vous connecter pour l'afficher. Je m'inscris!
License GNU v3

En espérant que ça serve,
Davy.

 

[Sheenoby]

Tu le seras bien assez tôt ;) Merci du partage sinon.

 

[davydavekk]

#update

-Ajouté un wrapper pour VirtualProtectEx
-Amélioré l’implémentation d'IDisposable (thanks @Exetra)

 

[Astropilot]

Merci du partage c'est vraiment utile et pratique :)

 

[davydavekk]

J'ai tout réécrit, la source est sur GitHub (lien dans le 1er post).

 

[ragnarock]

Salut,

Ta dll est bien codée, il n'y a presque rien à redire :)

Dans ta classe des extensions, tu peux mettre directement le format dans le string.Format :

return string.Format("0x{0:X}", hexNumber);

(bon c'est vraiment un détail ça)


Aussi si tu veux, utiliser un template pour le memory read/write, dans ce genre là :

        public T Read<T>(uint address) where T : struct
        {
            var ret = new T();

            var structType = typeof(T);
            var structSize = Marshal.SizeOf(structType);

            var lpBuffer = IntPtr.Zero;

            try
            {
                lpBuffer = Marshal.AllocHGlobal(structSize);

                int lpBytesRead;
                ReadProcessMemory(ProcessHandle, address, lpBuffer, structSize, out lpBytesRead);

                if (lpBytesRead == structSize)
                {
                    var baRet = new byte[lpBytesRead];
                    Marshal.Copy(lpBuffer, baRet, 0, lpBytesRead);

                    ret = (T)Marshal.PtrToStructure(lpBuffer, structType);
                }
            }
            finally
            {
                if (lpBuffer != IntPtr.Zero)
                    Marshal.FreeHGlobal(lpBuffer);
            }

            return ret;
        }

        public bool Write<T>(uint address, T value) where T : struct
        {
            var structType = typeof(T);
            var structSize = Marshal.SizeOf(structType);

            var lpBytes = new byte[structSize];
            var lpBuffer = IntPtr.Zero;

            try
            {
                lpBuffer = Marshal.AllocHGlobal(Marshal.SizeOf(lpBytes[0]) * structSize); //allocate unmanaged memory

                Marshal.StructureToPtr(value, lpBuffer, true);

                int iBytesWritten = WriteProcessMemory(_Handle, address, lpBuffer, structSize);

                return size == iBytesWritten;
            }
            finally
            {
                if (lpBuffer != IntPtr.Zero)
                    Marshal.FreeHGlobal(lpBuffer);
            }
        }

Si tu veux un autre exemple de ce genre, bien mieux fait : Ce lien n'est pas visible, veuillez vous connecter pour l'afficher. Je m'inscris!. les memory read/write sont dans le fichier InProcessMemoryReader.cs, mais tout le reste mérite aussi d'être vu, elle est presque parfaite cette dll.

Voilà :)

 

[davydavekk]

Excellente idée les génériques, voici mon implémentation :

		public T Read<T>(uint address) where T : struct
		{
			if(address == 0)
				throw new ArgumentException("address");
			
			T ret;
			Type type = typeof(T);
			int size = Marshal.SizeOf(type);
			var buffer = new byte[size];
			uint read;
			IntPtr ptr = IntPtr.Zero;
			
			Win32.ReadProcessMemory(Handle, address, buffer,
			                        (uint)size, out read);
			
			if(read != size)
			{
				return new T();
			}
			
			ptr = Marshal.AllocHGlobal(size);
			Marshal.Copy(buffer, 0, ptr, size);
			
			ret = (T)Marshal.PtrToStructure(ptr, type);
			Marshal.FreeHGlobal(ptr);
			
			return ret;
		}
		
		public bool Write<T>(uint address, T newValue) where T : struct
		{
			if(address == 0)
				throw new ArgumentException("address");
			
			Type type = typeof(T);
			int size = Marshal.SizeOf(type);
			uint written;
			var buffer = new byte[size];
			IntPtr ptr = IntPtr.Zero;
			
			ptr = Marshal.AllocHGlobal(size);
			Marshal.StructureToPtr(newValue, ptr, true);
			Marshal.Copy(ptr, buffer, 0, size);
			
			Win32.WriteProcessMemory(Handle, address, buffer,
			                         (uint)size , out written);
			
			Marshal.FreeHGlobal(ptr);
			
			return written == size;
		}

 

[Zlox]

J'ai toujours ce problème de S4Client qui crash lorsque j'appuie sur le Boutton1 (et la valeur n'a pas l'air de changée)
Peut être sa vient de mon code ?

Imports Memory
Public Class Form1
    Dim m As New DatMemory("S4Client")

    Private Sub Button2_Click(sender As Object, e As EventArgs) Handles Button2.Click
        Timer1.Enabled = True
    End Sub


    Private Sub Timer1_Tick(sender As Object, e As EventArgs) Handles Timer1.Tick
        Dim MyP As Process() = Process.GetProcessesByName("S4Client")
        If MyP.Length = 0 Then
        Else
            m.FindProcess("S4Client")
        End If
    End Sub

    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click

        Dim old As UInteger = m.Protect(&H52E554, 4, PageRights.ExecuteReadWrite)
        m.WriteLong(&H52E554, 2348565970)
        m.RemoveProtect(&H52E554, 4, old)
        m.Dispose()

    End Sub

End Class

 

[davydavekk]

Je testerais ton code plus tard, mais je remarque déjà que tu change la protection uniquement sur 4 bytes, et non 8 (la taille d'une variable long).

Dans ton timer tu peut faire un truc du genre:

if !Attached
  m.FindProcess("blalala")
[code]

 

[Membre supprimé 358475]

Merci !

 

[-[L]egends]

#Report

 

[Evaelis]

Update du lien