[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