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 ![Wink](images/smilies/wink.png)
Ich hoffe es bringt euch was.
Und wer nicht weiß was CIL ist hier:
http://en.wikipedia.org/wiki/MSIL
mfg