Mensajes

Bueno como el contenido es muy largo y se me subía a medias. Os pongo el enlace y la guía. Es simplemente una aplicación que permite cargar una dll desde memoria o disco y en principio desde el programa principal que arranca la dll se llama a las funciones de la misma. En principio esta incompleto ya que podría incluirse mejoras al programa principal para pasar inadvertida en tiempo de ejecucion.
Fuente:
http://www.mpgh.net/forum/showthread.php?t=1101356

Hola hay componentes de una dll que son detectados pero no se sí se podría cifrar una .dll ya que nunca lo he escuchado un salu2  

interesante actualizando el stub sería bastante no? el binder tiene funciones parecidas pero creo que en el crypter es diferente porque encriptas la informacion un salu2

esta buenisimo sobre todo la opcion de regedit con sus antidotos y todo thx

merci

en ningun momento dudaba solamente que con los avances en seguridad uno desconfia hasta de su sombra.. no aora enserio tus aportes son muy buenos siento haber escrito gracias y un salu2, y disculpa de nuevo!

Yo encantado te ayudo. eso si te digo por adelantado que java no es mi fuerte pero bueno. cualquier cosa k no entiendas consultala o si es codigo ponlo o cualquier que podamos hacer para ayudarte lo haremos.

Yo puedo en que lenguaje esta hecho c++?

Hola lo primero hice una mini clase para inyectar una dll a un proceso es la siguiente:

Código [Seleccionar] Expandir

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Runtime.InteropServices;
using System.Diagnostics;

namespace DllInject
{
   public class HVInjector
   {
       [DllImport("kernel32.dll")]
       public static extern IntPtr OpenProcess(int dwDesiredAccess, bool bInheritHandle, int dwProcessId);

       [DllImport("kernel32.dll", CharSet = CharSet.Auto)]
       public static extern IntPtr GetModuleHandle(string lpModuleName);

       [DllImport("kernel32", CharSet = CharSet.Ansi, ExactSpelling = true, SetLastError = true)]
       static extern IntPtr GetProcAddress(IntPtr hModule, string procName);

       [DllImport("kernel32.dll", SetLastError = true, ExactSpelling = true)]
       static extern IntPtr VirtualAllocEx(IntPtr hProcess,
           IntPtr lpAddress,
           uint dwSize,
           uint flAllocationType,
           uint flProtect);

       [DllImport("kernel32.dll", SetLastError = true)]
       static extern bool WriteProcessMemory(IntPtr hProcess,
           IntPtr lpBaseAddress,
           byte[] lpBuffer,
           uint nSize,
           out UIntPtr lpNumberOfBytesWritten);

       [DllImport("kernel32.dll")]
       static extern IntPtr CreateRemoteThread(IntPtr hProcess,
           IntPtr lpThreadAttributes,
           uint dwStackSize,
           IntPtr lpStartAddress,
           IntPtr lpParameter,
           uint dwCreationFlags,
           IntPtr lpThreadId);

       // privileges
       const int PROCESS_CREATE_THREAD = 0x0002;
       const int PROCESS_QUERY_INFORMATION = 0x0400;
       const int PROCESS_VM_OPERATION = 0x0008;
       const int PROCESS_VM_WRITE = 0x0020;
       const int PROCESS_VM_READ = 0x0010;

       // used for memory allocation
       const uint MEM_COMMIT = 0x00001000;
       const uint MEM_RESERVE = 0x00002000;
       const uint PAGE_READWRITE = 4;

       public static int inject(string dllPath, Process tProcess)
       {
           Process targetProcess = tProcess;
           string dllName = dllPath;

           // the target process
           // geting the handle of the process - with required privileges
           IntPtr procHandle = OpenProcess(PROCESS_CREATE_THREAD | PROCESS_QUERY_INFORMATION | PROCESS_VM_OPERATION | PROCESS_VM_WRITE | PROCESS_VM_READ, false, targetProcess.Id);
           // searching for the address of LoadLibraryA and storing it in a pointer
           IntPtr loadLibraryAddr = GetProcAddress(GetModuleHandle("kernel32.dll"), "LoadLibraryA");
           // name of the dll we want to inject
           // alocating some memory on the target process - enough to store the name of the dll
           // and storing its address in a pointer
           IntPtr allocMemAddress = VirtualAllocEx(procHandle, IntPtr.Zero, (uint)((dllName.Length + 1) * Marshal.SizeOf(typeof(char))), MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
           // writing the name of the dll there
           UIntPtr bytesWritten;
           WriteProcessMemory(procHandle, allocMemAddress, Encoding.Default.GetBytes(dllName), (uint)((dllName.Length + 1) * Marshal.SizeOf(typeof(char))), out bytesWritten);
           // creating a thread that will call LoadLibraryA with allocMemAddress as argument
           CreateRemoteThread(procHandle, IntPtr.Zero, 0, loadLibraryAddr, allocMemAddress, 0, IntPtr.Zero);
           return 0;
       }
   }
}

La inyección me la hace bien pero ahora quiero llamar de alguna manera la función de mi dll supongo que tendre que usar getprocessaddress. Y para sacarlas en modo ASM necesito usar dependency walker pero de momento no consigo cargar una librería de clases hecha en visual studio con dependency walker para ver las address. un salu2

como se que no infecta a los usuarios como a mi?.
Si estas limpio eres un makina pero lo dudo xD no se pork.