jasondrawdy/memorymapperLibrería ligera que permite mapear tanto ensamblados nativos como administrados en memoria, ya sea mediante inyección de procesos especificados por el usuario o autoinyección.
Memory Mapper es una librería ligera que permite mapear tanto ensamblados nativos como administrados en memoria, ya sea mediante inyección en un proceso especificado por el usuario o autoinyección; la técnica de inyectar un ensamblado en el proceso que actualmente está intentando realizar la inyección. La librería incluye herramientas no solo para mapear ensamblados, sino también para cifrar, descifrar y generar diversas cantidades de datos criptográficamente fuertes.
Nota: (Para el ensamblado en ejecución que usa Memory Mapper SOLAMENTE — no para stubs/shellcode)
Explorar la estructura de un PE (ejecutable portátil)
Leer recursos de ensamblados tanto administrados como nativos
Mapear ensamblados nativos en memoria mediante inyección en proceso y autoinyección
Mapear ensamblados administrados en memoria mediante inyección en proceso y otras técnicas
Obtener un arreglo de bytes para cualquier archivo de cualquier tamaño
Cifrar y descifrar archivos completos y bytes sin procesar
Generar y validar sumas de verificación de archivos y bytes sin procesar
Generar datos aleatorios criptográficamente fuertes usando un objeto SecureRandom
Viene incluido con múltiples algoritmos de cifrado y hash
Este ejemplo muestra cómo mapear estáticamente un ensamblado nativo en memoria usando la herramienta NativeLoader. El ejemplo carga el archivo leyendo todos sus bytes desde el disco y luego inyecta el PE (ejecutable portátil) asociado a los bytes directamente en memoria. Usando el cargador nativo junto con la Compilación Dinámica de Código de mi librería Amaterasu se podría lograr la compilación e inyección de código sobre la marcha, todo desde código en 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();
}
}
}
Este ejemplo muestra cómo mapear estáticamente un ensamblado administrado en memoria leyendo sus bytes — o usando un arreglo de bytes embebido — y luego usando ManagedLoader para inyectarlo en un proceso en ejecución. Casi cualquier ensamblado administrado puede ser mapeado con la herramienta ManagedLoader proporcionada.
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();
}
}
}
Icono: DesignBolts
http://www.designbolts.com/
Copyright © ∞ Jason Drawdy
Todos los derechos reservados.
The MIT License (MIT)
Por la presente se concede permiso, libre de cargos, a cualquier persona que obtenga una copia de este software y de los archivos de documentación asociados (el "Software"), para tratar con el Software sin restricción, incluyendo sin limitación los derechos de usar, copiar, modificar, fusionar, publicar, distribuir, sublicenciar y/o vender copias del Software, y para permitir a las personas a las que se les proporcione el Software hacer lo mismo, sujeto a las siguientes condiciones:
El aviso de copyright anterior y este aviso de permiso deberán incluirse en todas las copias o partes sustanciales del Software.
EL SOFTWARE SE PROPORCIONA "TAL CUAL", SIN GARANTÍA DE NINGÚN TIPO, EXPRESA O IMPLÍCITA, INCLUYENDO PERO NO LIMITADO A GARANTÍAS DE COMERCIABILIDAD, IDONEIDAD PARA UN PROPÓSITO PARTICULAR Y NO INFRACCIÓN. EN NINGÚN CASO LOS AUTORES O TITULARES DEL COPYRIGHT SERÁN RESPONSABLES POR CUALQUIER RECLAMO, DAÑO U OTRA RESPONSABILIDAD, YA SEA EN UNA ACCIÓN CONTRACTUAL, EXTRACONTRACTUAL O DE OTRO TIPO, DERIVADA DE, FUERA O EN RELACIÓN CON EL SOFTWARE O EL USO U OTRAS TRANSACCIONES EN EL SOFTWARE.
Salvo lo dispuesto en este aviso, el nombre del titular del copyright anterior no se utilizará en publicidad ni para promover la venta, uso u otras transacciones de este Software sin autorización previa por escrito.