jasondrawdy/memorymapperBiblioteca leve que permite mapear assemblies nativos e gerenciados na memória, seja por injeção de processo especificado pelo usuário ou auto-injeção.
Memory Mapper é uma biblioteca leve que permite mapear assemblies nativos e gerenciados na memória, seja por meio de injeção de processo em um processo especificado pelo usuário ou por auto-injeção; a técnica de injetar um assembly no processo atualmente em execução que tenta realizar a injeção. A biblioteca vem com ferramentas não apenas para mapear assemblies, mas também com capacidades de criptografar, descriptografar e gerar diversas quantidades de dados criptograficamente fortes.
Nota: (Para o assembly em execução usando Memory Mapper APENAS — não para stubs/shellcode)
Explorar a estrutura de um PE (executável portátil)
Ler recursos de assemblies gerenciados e nativos
Mapear assemblies nativos na memória usando injeção de processo e auto-injeção
Mapear assemblies gerenciados na memória usando injeção de processo e outras técnicas
Obter um array de bytes para qualquer arquivo de qualquer tamanho
Criptografar e descriptografar arquivos inteiros e bytes brutos
Gerar e validar checksums de arquivos e bytes brutos
Gerar dados aleatórios criptograficamente fortes usando um objeto SecureRandom
Inclui múltiplos algoritmos de criptografia e hash
Este exemplo mostra como mapear estaticamente um assembly nativo na memória usando a ferramenta NativeLoader. O exemplo carrega o arquivo lendo todos os seus bytes do disco e então injeta o PE (executável portátil) associado aos bytes diretamente na memória. Usando o carregador nativo em conjunto com a Compilação Dinâmica de Código encontrada na minha biblioteca Amaterasu, é possível realizar compilação e injeção de código em tempo real, tudo a partir do código em memória.
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 exemplo mostra como mapear estaticamente um assembly gerenciado na memória lendo seus bytes — ou usando um array de bytes embutido — e então utilizando o ManagedLoader para injetá-lo em um processo atualmente em execução. Quase qualquer assembly gerenciado pode ser mapeado usando a ferramenta ManagedLoader fornecida.
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();
}
}
}
Ícone: DesignBolts
http://www.designbolts.com/
Copyright © ∞ Jason Drawdy
Todos os direitos reservados.
A Licença MIT (MIT)
A permissão é concedida, gratuitamente, a qualquer pessoa que obtenha uma cópia deste software e dos arquivos de documentação associados (o "Software"), para lidar com o Software sem restrição, incluindo, sem limitação, os direitos de usar, copiar, modificar, fundir, publicar, distribuir, sublicenciar e/ou vender cópias do Software, e permitir que as pessoas a quem o Software é fornecido o façam, sujeitas às seguintes condições:
O aviso de copyright acima e este aviso de permissão devem ser incluídos em todas as cópias ou partes substanciais do Software.
O SOFTWARE É FORNECIDO "COMO ESTÁ", SEM GARANTIA DE QUALQUER TIPO, EXPRESSA OU IMPLÍCITA, INCLUINDO, MAS NÃO SE LIMITANDO ÀS GARANTIAS DE COMERCIALIZAÇÃO, ADEQUAÇÃO A UM DETERMINADO FIM E NÃO VIOLAÇÃO. EM NENHUM CASO OS AUTORES OU TITULARES DE DIREITOS AUTORAIS SERÃO RESPONSÁVEIS POR QUALQUER RECLAMAÇÃO, DANOS OU OUTRA RESPONSABILIDADE, SEJA EM UMA AÇÃO DE CONTRATO, ATO ILÍCITO OU DE OUTRA FORMA, DECORRENTE DE, OU EM CONEXÃO COM O SOFTWARE OU O USO OU OUTRAS NEGOCIAÇÕES NO SOFTWARE.
Exceto conforme contido neste aviso, o nome do titular do copyright acima não deve ser usado em publicidade ou de outra forma para promover a venda, uso ou outras negociações neste Software sem autorização prévia por escrito.