jasondrawdy/memorymapperLeichte Bibliothek, die es ermöglicht, sowohl native als auch verwaltete Assemblys in den Speicher zu laden, entweder durch Prozessinjektion in einen vom Benutzer angegebenen Prozess oder durch Selbstinjektion.
Memory Mapper ist eine leichtgewichtige Bibliothek, die es ermöglicht, sowohl native als auch verwaltete Assemblies in den Speicher zu laden, entweder durch Prozessinjektion in einen vom Benutzer angegebenen Prozess oder durch Selbstinjektion – die Technik, eine Assembly in den aktuell laufenden Prozess zu injizieren, der die Injektion versucht. Die Bibliothek bietet nicht nur Werkzeuge zum Laden von Assemblies, sondern auch die Möglichkeit, Daten zu verschlüsseln, zu entschlüsseln und verschiedene Mengen kryptografisch starker Daten zu erzeugen.
Hinweis: (Gilt NUR für die laufende Assembly, die Memory Mapper verwendet – nicht für Stubs/Shellcode)
Erkunden der Struktur einer PE (portable executable)
Lesen von Ressourcen aus verwalteten und nativen Assemblies
Laden nativer Assemblies in den Speicher mittels Prozessinjektion und Selbstinjektion
Laden verwalteter Assemblies in den Speicher mittels Prozessinjektion und anderen Techniken
Abrufen eines Byte-Arrays für eine beliebige Datei beliebiger Größe
Verschlüsseln und Entschlüsseln ganzer Dateien und roher Bytes
Erzeugen und Validieren von Prüfsummen für Dateien und rohe Bytes
Erzeugen kryptografisch starker Zufallsdaten mit einem SecureRandom-Objekt
Enthält mehrere Verschlüsselungs- und Hash-Algorithmen
Dieses Beispiel zeigt, wie eine native Assembly statisch mit dem NativeLoader-Werkzeug in den Speicher geladen wird. Das Beispiel lädt die Datei, indem es alle Bytes von der Festplatte einliest und dann die PE (portable executable), die mit den Bytes verbunden ist, direkt in den Speicher injiziert. Durch die Verwendung des nativen Loaders in Verbindung mit der Dynamischen Code-Kompilierung aus meiner Amaterasu-Bibliothek könnte man eine On-the-Fly-Codekompilierung und -injektion direkt aus dem Speicher erreichen.
using System;
using System.IO;
using System.Reflection;
using MemoryMapper;
namespace Example
{
class Program
{
static void Main(string[] args)
{
// Get the bytes of the file we want to load.
var filePath = "FileToReadBytesOf";
var fileBytes = File.ReadAllBytes(filePath);
// Check if the assembly is managed or native.
bool isManaged = false;
try
{
// Note — this is one of the simplest variations of checking assemblies
var assemblyName = AssemblyName.GetAssemblyName(filePath);
if (assemblyName != null)
if (assemblyName.FullName != null)
isManaged = true;
}
catch { isManaged = false; }
// Try loading the assembly if it's truly native.
if (!isManaged)
{
NativeLoader loader = new NativeLoader();
if (loader.LoadAssembly(fileBytes))
Console.WriteLine("Assembly loaded successfully!");
else
Console.WriteLine("Assembly could not be loaded.");
}
// Wait for user interaction.
Console.Read();
}
}
}
Dieses Beispiel zeigt, wie eine verwaltete Assembly statisch in den Speicher geladen wird, indem man ihre Bytes einliest – oder ein eingebettetes Byte-Array verwendet – und dann mit dem ManagedLoader in einen aktuell laufenden Prozess injiziert. Nahezu jede verwaltete Assembly kann mit dem bereitgestellten ManagedLoader-Werkzeug geladen werden.
using System;
using System.IO;
using System.Reflection;
using MemoryMapper;
namespace Example
{
class Program
{
static void Main(string[] args)
{
// Get the bytes of the file we want to load.
var filePath = "FileToReadBytesOf";
var fileBytes = File.ReadAllBytes(filePath);
// Check if the assembly is managed or native.
bool isManaged = false;
try
{
// Note — this is one of the simplest variations of checking assemblies
var assemblyName = AssemblyName.GetAssemblyName(filePath);
if (assemblyName != null)
if (assemblyName.FullName != null)
isManaged = true;
}
catch { isManaged = false; }
// Try loading the assembly if it's truly managed.
if (isManaged)
{
// Set the name of a surrogate process - the process we'll inject into.
var processName = "explorer.exe"; // Can also be the current process's name for self-injection.
ManagedLoader loader = new ManagedLoader();
if (loader.LoadAssembly(fileBytes, processName))
Console.WriteLine("Assembly loaded successfully!");
else
Console.WriteLine("Assembly could not be loaded.");
}
// Wait for user interaction.
Console.Read();
}
}
}
Icon: DesignBolts
http://www.designbolts.com/
Copyright © ∞ Jason Drawdy
Alle Rechte vorbehalten.
Die MIT-Lizenz (MIT)
Hiermit wird unentgeltlich, jeder Person, die eine Kopie dieser Software und der zugehörigen Dokumentationsdateien (die "Software") erhält, die Erlaubnis erteilt, die Software ohne Einschränkung zu nutzen, einschließlich und ohne Ausnahme der Rechte zur Verwendung, Vervielfältigung, Änderung, Zusammenführung, Veröffentlichung, Verteilung, Unterlizenzierung und/oder zum Verkauf von Kopien der Software, und um Personen, denen die Software bereitgestellt wird, diese Rechte zu gewähren, unter den folgenden Bedingungen:
Der obige Urheberrechtshinweis und dieser Genehmigungshinweis müssen in allen Kopien oder wesentlichen Teilen der Software enthalten sein.
DIE SOFTWARE WIRD "WIE BESEHEN" BEREITGESTELLT, OHNE JEGLICHE AUSDRÜCKLICHE ODER STILLSCHWEIGENDE GEWÄHRLEISTUNG, EINSCHLIESSLICH, ABER NICHT BESCHRÄNKT AUF DIE GEWÄHRLEISTUNG DER MARKTGÄNGIGKEIT, DER EIGNUNG FÜR EINEN BESTIMMTEN ZWECK UND DER NICHTVERLETZUNG VON RECHTEN DRITTER. IN KEINEM FALL SIND DIE AUTOREN ODER URHEBERRECHTSINHABER HAFTBAR FÜR JEGLICHE ANSPRÜCHE, SCHÄDEN ODER ANDERE VERPFLICHTUNGEN, OB AUS VERTRAG, UNERLAUBTER HANDLUNG ODER ANDERWEITIG, DIE AUS ODER IM ZUSAMMENHANG MIT DER SOFTWARE ODER DER NUTZUNG ODER ANDEREN GESCHÄFTEN MIT DER SOFTWARE ENTSTEHEN.
Sofern nicht in diesem Hinweis enthalten, darf der Name des oben genannten Urheberrechtsinhabers nicht in Werbung oder anderweitig zur Förderung des Verkaufs, der Nutzung oder anderer Geschäfte mit dieser Software ohne vorherige schriftliche Genehmigung verwendet werden.