jasondrawdy/memorymapperLibreria leggera che consente di mappare sia assembly nativi che gestiti in memoria tramite l'iniezione in un processo specificato dall'utente o l'auto-iniezione.
Memory Mapper è una libreria leggera che permette di mappare in memoria sia assembly nativi che gestiti, utilizzando l'iniezione di processo in un processo specificato dall'utente o l'auto-iniezione; la tecnica di iniettare un assembly nel processo attualmente in esecuzione che tenta di eseguire l'iniezione. La libreria include strumenti non solo per mappare assembly, ma anche per crittografare, decrittografare e generare varie quantità di dati crittograficamente forti.
Nota: (Per l'assembly in esecuzione che utilizza Memory Mapper SOLO — non per stub/shellcode)
Esplorare la struttura di un PE (eseguibile portatile)
Leggere risorse da assembly gestiti e nativi
Mappare assembly nativi in memoria utilizzando iniezione di processo e auto-iniezione
Mappare assembly gestiti in memoria utilizzando iniezione di processo e altre tecniche
Ottenere un array di byte per qualsiasi file di qualsiasi dimensione
Crittografare e decrittografare interi file e byte grezzi
Generare e convalidare checksum di file e byte grezzi
Generare dati casuali crittograficamente forti utilizzando un oggetto SecureRandom
Include molteplici algoritmi di crittografia e hashing
Questo esempio mostra come mappare staticamente un assembly nativo in memoria utilizzando lo strumento NativeLoader. L'esempio carica il file leggendo tutti i suoi byte dal disco e poi inietta il PE (eseguibile portatile) associato ai byte direttamente in memoria. Utilizzando il caricatore nativo insieme alla Compilazione Dinamica del Codice presente nella mia libreria Amaterasu si potrebbe ottenere una compilazione e iniezione del codice al volo, tutto dal codice in memoria.
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();
}
}
}
Questo esempio mostra come mappare staticamente un assembly gestito in memoria leggendo i suoi byte — o utilizzando un array di byte incorporato — e poi usando ManagedLoader per iniettarlo in un processo attualmente in esecuzione. Quasi ogni assembly gestito può essere mappato utilizzando lo strumento ManagedLoader fornito.
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();
}
}
}
Icona: DesignBolts
http://www.designbolts.com/
Copyright © ∞ Jason Drawdy
Tutti i diritti riservati.
The MIT License (MIT)
Autorizzazione è concessa, gratuitamente, a qualsiasi persona che ottenga una copia di questo software e dei file di documentazione associati (il "Software"), di trattare il Software senza restrizione, inclusi senza limitazione i diritti di utilizzare, copiare, modificare, unire, pubblicare, distribuire, concedere in sublicenza e/o vendere copie del Software, e di permettere alle persone a cui il Software è fornito di fare altrettanto, soggetto alle seguenti condizioni:
La suddetta nota sul copyright e questa nota di autorizzazione devono essere incluse in tutte le copie o parti sostanziali del Software.
IL SOFTWARE VIENE FORNITO "COSÌ COM'È", SENZA GARANZIA DI ALCUN TIPO, ESPRESSA O IMPLICITA, INCLUSO MA NON LIMITATO ALLE GARANZIE DI COMMERCIABILITÀ, IDONEITÀ PER UN PARTICOLARE SCOPO E NON VIOLAZIONE. IN NESSUN CASO GLI AUTORI O I TITOLARI DEL COPYRIGHT POTRANNO ESSERE RITENUTI RESPONSABILI PER QUALSIASI RECLAMO, DANNO O ALTRA RESPONSABILITÀ, SIA IN UN'AZIONE CONTRATTUALE, EXTRACONTRATTUALE O ALTRO, DERIVANTE DA, O IN CONNESSIONE CON IL SOFTWARE O L'USO O ALTRE OPERAZIONI NEL SOFTWARE.
Salvo quanto contenuto in questa nota, il nome del suddetto titolare del copyright non potrà essere utilizzato in pubblicità o altrimenti per promuovere la vendita, l'uso o altre operazioni relative a questo Software senza previa autorizzazione scritta.