[C#] Code-Injection

[IRET]

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.

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

        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

[k0rxxx]

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

[Keksdose]

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

[IRET]

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

[conrado]

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


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

[Omegavirus]

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..?

[IRET]

Kann doch aber eigentlich nicht sein..?

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

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();

        }
    }
}