Ergebnis 1 bis 7 von 7
  1. #1
    Transpinguin Avatar von IRET
    Registriert seit
    02.09.2008
    Beiträge
    1.295

    Standard [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
    Geändert von IRET (22.06.2009 um 10:32 Uhr)

  2. #2
    Sobig Wurm
    Registriert seit
    18.03.2007
    Beiträge
    200

    Standard

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

  3. #3
    W32.FunLove Avatar von Keksdose
    Registriert seit
    03.05.2009
    Beiträge
    155

    Standard

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

  4. #4
    Transpinguin Avatar von IRET
    Registriert seit
    02.09.2008
    Beiträge
    1.295

    Standard

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

  5. #5
    W32.FunLove
    Registriert seit
    09.08.2010
    Beiträge
    149

    Standard

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


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

  6. #6
    └──┤Ω-Virus├──┘
    Registriert seit
    30.07.2007
    Beiträge
    167

    Standard

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

  7. #7
    Transpinguin Avatar von IRET
    Registriert seit
    02.09.2008
    Beiträge
    1.295

    Standard AW: [C#] Code-Injection

    Zitat Zitat von Omegavirus Beitrag anzeigen
    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();
    
            }
        }
    }

Stichworte

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •