jasondrawdy/memorymapperBibliothèque légère permettant de mapper à la fois les assemblies natives et managées en mémoire, soit par injection de processus d'un processus spécifié par l'utilisateur, soit par auto-injection.
Memory Mapper est une bibliothèque légère qui permet de mapper aussi bien les assemblys natifs que managés en mémoire, soit par injection de processus dans un processus spécifié par l'utilisateur, soit par auto-injection : la technique qui consiste à injecter un assembly dans le processus en cours tentant de réaliser l'injection. La bibliothèque inclut non seulement des outils pour mapper les assemblys, mais aussi des capacités de chiffrement, de déchiffrement et de génération de quantités variées de données cryptographiquement robustes.
*Remarque : (Pour l'assembly en cours d'exécution utilisant Memory Mapper UNIQUEMENT — pas pour les stubs/shellcode)
Explorer la structure d'un PE (portable executable)
Lire les ressources d'assemblys managés et natifs
Mapper des assemblys natifs en mémoire par injection de processus et auto-injection
Mapper des assemblys managés en mémoire par injection de processus et autres techniques
Obtenir un tableau d'octets pour tout fichier, quelle que soit sa taille
Chiffrer et déchiffrer des fichiers entiers et des octets bruts
Générer et valider des sommes de contrôle de fichiers et d'octets bruts
Générer des données aléatoires cryptographiquement robustes à l'aide d'un objet SecureRandom
Inclut plusieurs algorithmes de chiffrement et de hachage
Cet exemple montre comment mapper statiquement un assembly natif en mémoire à l'aide de l'outil NativeLoader. L'exemple charge le fichier en lisant tous ses octets depuis le disque, puis injecte le PE (portable executable) associé aux octets directement en mémoire. En utilisant le chargeur natif conjointement avec la Compilation de code dynamique de ma bibliothèque Amaterasu, on pourrait réaliser compilation et injection de code à la volée, entièrement depuis le code en mémoire.
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();
}
}
}
Cet exemple montre comment mapper statiquement un assembly managé en mémoire en lisant ses octets — ou en utilisant un tableau d'octets intégré — puis en utilisant le ManagedLoader pour injecter dans un processus en cours. Presque tout assembly managé peut être mappé à l'aide de l'outil ManagedLoader fourni.
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();
}
}
}
Icône : DesignBolts
http://www.designbolts.com/
Copyright © ∞ Jason Drawdy
Tous droits réservés.
La licence MIT (MIT)
Par la présente, toute personne obtenant une copie de ce logiciel et des fichiers de documentation associés (le « Logiciel ») est autorisée à traiter le Logiciel sans restriction, y compris, sans limitation, les droits d'utilisation, de copie, de modification, de fusion, de publication, de distribution, de sous-licence et/ou de vente de copies du Logiciel, et à permettre aux personnes à qui le Logiciel est fourni de le faire, sous réserve des conditions suivantes :
L'avis de copyright ci-dessus et cet avis d'autorisation doivent être inclus dans toutes les copies ou parties substantielles du Logiciel.
LE LOGICIEL EST FOURNI « EN L'ÉTAT », SANS GARANTIE D'AUCUNE SORTE, EXPRESSE OU IMPLICITE, Y COMPRIS, MAIS SANS S'Y LIMITER, LES GARANTIES DE QUALITÉ MARCHANDE, D'ADÉQUATION À UN USAGE PARTICULIER ET D'ABSENCE DE CONTREFAÇON. EN AUCUN CAS LES AUTEURS OU TITULAIRES DU COPYRIGHT NE POURRONT ÊTRE TENUS RESPONSABLES D'UNE RÉCLAMATION, DE DOMMAGES OU D'AUTRE RESPONSABILITÉ, QUE CE SOIT DANS LE CADRE D'UN CONTRAT, D'UN DÉLIT OU AUTRE, DÉCOULANT DE, OU EN RELATION AVEC LE LOGICIEL OU L'UTILISATION OU D'AUTRES OPÉRATIONS DANS LE LOGICIEL.
Sauf mention contraire dans le présent avis, le nom du détenteur du copyright ci-dessus ne pourra être utilisé dans des publicités ou autrement pour promouvoir la vente, l'utilisation ou d'autres transactions concernant ce Logiciel sans autorisation écrite préalable.