[C#] Code-Injection

Hab mich jetzt einmal aus Faulheit(wollte die Windows-Maschine nciht starten hehe) mehr mit Mono-Apis auseinander gesetzt und die Cecil-Api gefunden.

Mit der ist eine Code-Injizierung möglich.
Die Cecil-Api gibt es hier:
http://www.mono-project.com/Cecil

Wr nicht weiß wozu es ist:
zB um Schadcode in eine andere Datei injizieren oder einen Crack zu schreiben).

Und hier ein Beispiel wie ihr Code in eine bestehende Datei injizieren könnt.

Code:

---

using System;
using Mono.Cecil;
using Mono.Cecil.Cil;

namespace codeinjection
{
    class Program
    {
        static void Main(string[] args)
        {
            //Assembly laden
            AssemblyDefinition asm= AssemblyFactory.GetAssembly("explorer.exe");

        //Definiere Methode "Test()" mit Rückgabewert void

            //Rückgabewert festlegen
            TypeReference returntype = asm.MainModule.Import(typeof(void));

            //Gerüst machen(static void Test())
            MethodDefinition testmethod = new MethodDefinition("Test", MethodAttributes.Private|MethodAttributes.Static, returntype);

            //Code in der Methode Test

            //Definiert eine CIL-Instruktion die einen String mit unserer Meldung auf den Stack legt...
            Instruction msg = testmethod.Body.CilWorker.Create(OpCodes.Ldstr, "Hello from Test()");

            //und importiert eine Methoden-Referenz auf Console.WriteLine(string), dazu wird
            //der im .NET Framework eingebaute System.Type verwendet
            MethodReference writeline = asm.MainModule.Import(typeof(Console).GetMethod("WriteLine",new Type[]{typeof(string)}));

            //Generiert CIL-Code in der Methode Test()

            //Message-String auf den Stack legen
            testmethod.Body.CilWorker.Append(msg);
            //Console.WriteLine aufruf generieren
            testmethod.Body.CilWorker.InsertAfter (msg,testmethod.Body.CilWorker.Create (OpCodes.Call,writeline));

            //Return generieren
            testmethod.Body.CilWorker.Append (testmethod.Body.CilWorker.Create (OpCodes.Ret));

            //Injiziert die Methode "Test()" in die Klasse Victim.Program, welche sich im Hauptmodul befindet.
            asm.MainModule.Inject(testmethod, asm.MainModule.Types["Victim.Program"]);


            //Main-Methode modifizieren ,dass die injizierte Code auch ausgeführt wird

            MethodReference testmethod_ref = null;
            foreach (MethodDefinition mdef in asm.MainModule.Types["Victim.Program"].Methods)
            {
                if (mdef.Name == "Test")
                {
                    testmethod_ref=asm.MainModule.Import(mdef);
                }

            }

            Instruction call_test = testmethod.Body.CilWorker.Create(OpCodes.Call, testmethod_ref);

            asm.EntryPoint.Body.CilWorker.InsertBefore (asm.EntryPoint.Body.Instructions[0],call_test);

            //Schreibt Datei auf die Festplatte
            AssemblyFactory.SaveAssembly(asm, "patched.exe");
            Console.ReadLine();

        }
    }
}

---

Die patched.exe ist dann die Datei mit den injizierten Code.
In diesen Fall injizieren wir folgenden Code in die explorer.exe

Code:

---

        private static void Test()
        {
            Console.WriteLine("Hello from Test()");


        }

---

Und in die Main-Methode wird eine Zeile injiziert womit die Methofde Test aufgerufn wird.
Das ganze ist zwar etwas komplziert ,aber mit dr Zeit versteht man das schon ;)

Ich hoffe es bringt euch was.
Und wer nicht weiß was CIL ist hier:
http://en.wikipedia.org/wiki/MSIL

mfg

http://www.edgeofnowhere.cc/viewtopic.php?t=430074
hier noch ein gutes tut zum thema "managed .net dll injection"

Ich hoff mal der Thread ist nicht schon zu alt...
Geht das auch mit C++?

Ja schon ,aber nicht mit den Snippet da hier die C# eigene Cecil API verwendet wird.

is top für nen wurm...^^


Geht das mit allen Exen ? (oder anders gefragt.. bei welchen Dateien geht es nicht?

Zitat:

---

Fehler 3 "Mono.Cecil.Cil.MethodBody" enthält keine Definition für "CilWorker", und es konnte keine Erweiterungsmethode "CilWorker" gefunden werden, die ein erstes Argument vom Typ "Mono.Cecil.Cil.MethodBody" akzeptiert. (Fehlt eine Using-Direktive oder ein Assemblyverweis?) C:\Users\root\documents\visual studio 2010\Projects\injectProgram\injectProgram\Program. cs 27 47 injectProgram

---

Kann doch aber eigentlich nicht sein..?

Zitat:

---

Zitat von Omegavirus

Kann doch aber eigentlich nicht sein..?

---

Kann durchaus sein. Die neue Version von Mono.Cecil hat das jetzt anders drinnen. Hier ein Update:

Code:

---

using System;
using Mono.Cecil;
using Mono.Cecil.Cil;
using Mono.Collection.Generic;

namespace codeinjection
{
    class Program
    {
        static void Main(string[] args)
        {
            //Assembly laden
            AssemblyDefinition asm = AssemblyDefinition.ReadAssembly("explorer.exe");

        //Definiere Methode "Test()" mit Rückgabewert void

            //Rückgabewert festlegen
            TypeReference returntype = asm.MainModule.Import(typeof(void));

            //Gerüst machen(static void Test())
            MethodDefinition testmethod = new MethodDefinition("Test", MethodAttributes.Private|MethodAttributes.Static, returntype);

            //Code in der Methode Test
            ILProcessor proc = testmethod.Body.GetILProcessor();
            //Definiert eine CIL-Instruktion die einen String mit unserer Meldung auf den Stack legt...
            Instruction msg = proc.Create(OpCodes.Ldstr, "Hello from Test()");

            //und importiert eine Methoden-Referenz auf Console.WriteLine(string), dazu wird
            //der im .NET Framework eingebaute System.Type verwendet
            MethodReference writeline = asm.MainModule.Import(typeof(Console).GetMethod("WriteLine",new Type[]{typeof(string)}));

            //Generiert CIL-Code in der Methode Test()

            //Message-String auf den Stack legen
            proc.Append(msg);
            //Console.WriteLine aufruf generieren
            proc.InsertAfter (msg, proc.Create(OpCodes.Call,writeline));

            //Return generieren
            proc.Append (proc.Create(OpCodes.Ret));

            //Injiziert die Methode "Test()" in die Klasse Victim.Program, welche sich im Hauptmodul befindet.
            asm.MainModule.Types["Victim.Program"].Methods.Add(testmethod);


            //Main-Methode modifizieren ,dass die injizierte Code auch ausgeführt wird

            MethodReference testmethod_ref = null;
            foreach (MethodDefinition mdef in asm.MainModule.Types["Victim.Program"].Methods)
            {
                if (mdef.Name == "Test")
                {
                    testmethod_ref = asm.MainModule.Import(mdef);
                }

            }

            Instruction call_test = proc.Create(OpCodes.Call, testmethod_ref);

            asm.EntryPoint.Body.GetILProcessor.InsertBefore (asm.EntryPoint.Body.Instructions[0], call_test);

            //Schreibt Datei auf die Festplatte
            asm.Write("patched.exe");
            Console.ReadLine();

        }
    }
}

---