VB08 hack?

[Akorn]

Originally Posted by JakeFrost77

Ach und jemand dem das Wort "Ironie" ein Fremdbegriff ist wohl nicht oder wie?

Es gibt hier genug user die der meinung sind das VB stehe über allem drüber.

[Endecs]

Originally Posted by nkkk

ich programmiere kein vb, aber ich prgrammieren viel C# was von funktionaumfang her fast genauso ist.

man kann in c# fast genauso die winApi funktionen ausführen wie in C++, oder anderen sprachen, für die einfachen hacks/bots
(werte im speicher der zielprozesses ändern, mit muktilevelpointern, mausklick/tastatur bots, packetbots) ist c# genausogut wie c++, meiner meinug nach.
zumal es bei hacks dieser art meistens nicht so stark auf performance ankommt, und c# einem in bestimmten bereichen schon arbeit abnimmt.

nur wenn du z.B. eine eigene dll injekten, detours nutzen, oder allemein den programmcode des zielprozesses ändern will, kann man das nur mit .net schlecht machen.

ich persönlich finde vb einfach von der Syntax her hässlich, aber wenn andere da anders denken habe ich da wenig probleme mit, solange ich mir nicht meterlangen v.B. quelltext durchlesen muss.

Naja ich finde eher C# hässlicher als VB, da bei C# mir die ganzen ; {} auf die nerven gehen und bei VB einfach enter drücken fertig.
Aber jedem das seine, der eine findet autoit sei das beste für ihn, der andere C++.

So und an TE:
Damit du es so leicht wie möglich hast, downloadest dir die BlackMagic.dll (Anhang)
Die fügst du als Verweis hinzu.
Dann Importierst du sie und Deklarierst.
Also so:

Imports Magic

Dim SUCHDIRWASAUS as new Blackmagic

So dann erstellst du dir ein Button oder was auch immer und solang du einen Static Offset hast oder einen Pointer, kannst du es z.B so schreiben:

SUCHDIRWASAUS.ReadUInt(&H8053E8)
Und Writen geht genauso einfach mit: SUCHDIRWASAUS.Writeuint(&H8053E8, ZAHL)

/e: Und bei Pointer könnte das dann so aussehen:
Dim NoClip = wow.readuint(&HADB754)
Dim NoClip2 = wow.readuint((NoClip) + &H38)
Dim NoClip3 = wow.readuint((NoClip2) + &H738)
wow.writebyte((NoClip3) + &HE3, 62)

Das sollte dann eigentlich alles erklären.

[nkkk]

hier mal ein funktion, die ich mal in meinen alten projekten gefunden habe, ich man kannn aus dem c# code auch vb code machen gibt tools dafür glaubich , er ist nicht sooo schön, aber ich denke er ist recht leicht verständlich

 Spoiler

C# code:

        public static T GetValue<T>(uint baseAdress, uint[] offsets, IntPtr hProcess)
            where T : struct
        {
            uint finalAdress = baseAdress;
            for (int i = 1; i < offsets.Length; i++) 
            {
                finalAdress = GetValue<uint>(finalAdress, hProcess);
                finalAdress += offsets[i];
            }
            return GetValue<T>(finalAdress, hProcess);
        }



        /// <summary>
        /// Liest einen wert aus einer bestimmen andresse eines anderen Prozesses
        /// </summary>
        /// <typeparam name="T">er Typ Des Wertes</typeparam>
        /// <param name="adress">Die adresse an der der Wert hingeschreiben soll</param>
        /// <param name="hProcess">Der ZielProzess</param>
        /// <returns>Der Wert</returns>
        public static T GetValue<T>(uint adress, IntPtr hProcess)
            where T : struct
        {
            uint size = (uint)Marshal.SizeOf(typeof(T));
            byte[] buffer = new byte[size];
            uint numberOfBytesRead;
            int numberOfBytesRead2;
            numberOfBytesRead2 = ApiFunctions.ReadProcessMemory(hProcess,
                adress,
                buffer,
                size,
                out numberOfBytesRead);
            if (numberOfBytesRead != numberOfBytesRead2)
            {
                MessageBox.Show("numberOfBytesRead != numberOfBytesRead2", "Fehler");
                throw new Exception("numberOfBytesRead != numberOfBytesRead2");
            }
            if (numberOfBytesRead != size)
            {
                throw new Exception("Es Konnte nicht aus dem Speicher Gelesen werden.");
            }
            T retv = default(T);
            unsafe 
            {
                fixed (byte* ob = &buffer[0]) 
                {
                    retv = (T) Marshal.PtrToStructure((IntPtr)ob, typeof(T));
                }
            }
            return retv;
        }



        /// <summary>
        /// Schreibt einen wert an eine bestimme andresse eines anderen Prozesses
        /// </summary>
        /// <typeparam name="T">er Typ Des Wertes</typeparam>
        /// <param name="adress">Die adresse an der der Wert hingeschreiben soll</param>
        /// <param name="hProcess">Der ZielProzess</param>
        /// <param name="value">Der Wert</param>
        public static void SetValue<T>(uint adress, IntPtr hProcess, T value)
            where T : struct
        {
            uint size = (uint)Marshal.SizeOf(typeof(T));
            byte[] buffer = new byte[size];

            unsafe
            {
                fixed (byte* ob = &buffer[0])
                {
                    Marshal.StructureToPtr(value, (IntPtr)ob, false);
                }
            }

            uint numberOfBytesRead;
            int numberOfBytesRead2;
            numberOfBytesRead2 = ApiFunctions.WriteProcessMemory(hProcess,
                adress,
                buffer,
                size,
                out numberOfBytesRead);
            if (numberOfBytesRead != numberOfBytesRead2)
            {
                MessageBox.Show("numberOfBytesRead != numberOfBytesRead2", "Fehler");
                throw new Exception("numberOfBytesRead != numberOfBytesRead2");
            }
            if (numberOfBytesRead != size)
            {
                throw new Exception("Es Konnte nicht in dem Speicher Geschrieben werden.");
            }
        }



        public static void SetValue<T>(uint baseAdress, uint[] offsets, IntPtr hProcess, T value)
            where T : struct
        {
            uint finalAdress = baseAdress;
            for (int i = 1; i < offsets.Length; i++)
            {
                finalAdress = GetValue<uint>(finalAdress, hProcess);
                finalAdress += offsets[i];
            }
            SetValue<T>(finalAdress, hProcess,value);
        }

[Endecs]

Das ganze in VB:

 Spoiler

Public Shared Function GetValue(Of T As Structure)(baseAdress As UInteger, offsets As UInteger(), hProcess As IntPtr) As T
Dim finalAdress As UInteger = baseAdress
For i As Integer = 1 To offsets.Length - 1
finalAdress = GetValue(Of UInteger)(finalAdress, hProcess)
finalAdress += offsets(i)
Next
Return GetValue(Of T)(finalAdress, hProcess)
End Function



''' <summary>
''' Liest einen wert aus einer bestimmen andresse eines anderen Prozesses
''' </summary>
''' <typeparam name="T">er Typ Des Wertes</typeparam>
''' <param name="adress">Die adresse an der der Wert hingeschreiben soll</param>
''' <param name="hProcess">Der ZielProzess</param>
''' <returns>Der Wert</returns>
Public Shared Function GetValue(Of T As Structure)(adress As UInteger, hProcess As IntPtr) As T
Dim size As UInteger = CUInt(Marshal.SizeOf(GetType(T)))
Dim buffer As Byte() = New Byte(size - 1) {}
Dim numberOfBytesRead As UInteger
Dim numberOfBytesRead2 As Integer
numberOfBytesRead2 = ApiFunctions.ReadProcessMemory(hProcess, adress, buffer, size, numberOfBytesRead)
If numberOfBytesRead <> numberOfBytesRead2 Then
MessageBox.Show("numberOfBytesRead != numberOfBytesRead2", "Fehler")
Throw New Exception("numberOfBytesRead != numberOfBytesRead2")
End If
If numberOfBytesRead <> size Then
Throw New Exception("Es Konnte nicht aus dem Speicher Gelesen werden.")
End If
Dim retv As T = Nothing
retv = DirectCast(Marshal.PtrToStructure(DirectCast(ob, IntPtr), GetType(T)), T)

Return retv
End Function



''' <summary>
''' Schreibt einen wert an eine bestimme andresse eines anderen Prozesses
''' </summary>
''' <typeparam name="T">er Typ Des Wertes</typeparam>
''' <param name="adress">Die adresse an der der Wert hingeschreiben soll</param>
''' <param name="hProcess">Der ZielProzess</param>
''' <param name="value">Der Wert</param>
Public Shared Sub SetValue(Of T As Structure)(adress As UInteger, hProcess As IntPtr, value As T)
Dim size As UInteger = CUInt(Marshal.SizeOf(GetType(T)))
Dim buffer As Byte() = New Byte(size - 1) {}

Marshal.StructureToPtr(value, DirectCast(ob, IntPtr), False)


Dim numberOfBytesRead As UInteger
Dim numberOfBytesRead2 As Integer
numberOfBytesRead2 = ApiFunctions.WriteProcessMemory(hProcess, adress, buffer, size, numberOfBytesRead)
If numberOfBytesRead <> numberOfBytesRead2 Then
MessageBox.Show("numberOfBytesRead != numberOfBytesRead2", "Fehler")
Throw New Exception("numberOfBytesRead != numberOfBytesRead2")
End If
If numberOfBytesRead <> size Then
Throw New Exception("Es Konnte nicht in dem Speicher Geschrieben werden.")
End If
End Sub



Public Shared Sub SetValue(Of T As Structure)(baseAdress As UInteger, offsets As UInteger(), hProcess As IntPtr, value As T)
Dim finalAdress As UInteger = baseAdress
For i As Integer = 1 To offsets.Length - 1
finalAdress = GetValue(Of UInteger)(finalAdress, hProcess)
finalAdress += offsets(i)
Next
SetValue(Of T)(finalAdress, hProcess, value)
End Sub