¿Cómo prevenir la inyección de DLL?

Un día vi esto: iba a ser inyectado en tres DLL. ¿Cómo puedo detener estos procesos? O al menos, ¿cómo puedo evitar procesos de mayor prioridad? Estoy pensando que tal vez un controlador de anillo 0 podría ser la única forma de bloquear estos tres procesos, pero quería ver qué podía considerar.

------------------------------------------- ----- --------------------------------------------- ----- ----------------------------

1. La mejor solución técnica es cargar el código después de que se inicializa el programa. Cargando cuando no funciona correctamente. Un método es utilizar un bloqueo del cargador NT, que evitará eficazmente que se produzcan operaciones de carga. Otros enfoques incluyen parchear el código de carga directamente llamando al atacante de fallas de LoadLibrary (por ejemplo, insertando un punto de interrupción INT3 y depurándose usted mismo para manejar las condiciones esperadas).... Sin embargo, como hacker (en realidad, administrador de un sitio web vinculado a usted), nunca deja de introducir código de otras personas en su proceso de una forma u otra. Llamar a LoadLibrary resulta ser una conveniencia para CodeGo.net, pero hay muchas maneras de cargar código manualmente, y nunca querrás dejar de hacerlo por completo, excepto con el código ring0. Incluso si usas ring0, los hackers estarán de tu lado. Además, hay mucha inyección de DLL. Los programas que planifican, ayudan y amplían las funciones del sistema operativo se pueden inyectar mediante DLL en cualquier programa que agregue funciones.

2. Cómo lidiar con estas 3 técnicas defensivas: CreateRemoteThread Puedes evitar la técnica preferida (llamando a CreateRemoteThread de LoadLibrary) conectando LoadLibrary. En el enlace, puede consultar una lista de DLL que se sabe que forman parte del proceso y que se pueden cargar, o una lista de DLL conocidas que no desea cargar. Cuando se encuentra una DLL que no desea cargar, establece el último error SetLastError (ERROR_ACCESS_DENIED) y devuelve NULL. Esto parece funcionar, tal vez un código diferente sea más adecuado. Esto evitará que se cargue la DLL. Función SetWindowsHookEx Creo que la funcionalidad de bloqueo de la tecnología Create Remote Thread (CreateRemoteThread) funciona con la función SetWindowsHookEx, pero solo si llama a SetWindowsHookEx antes de que la tecnología haya comenzado a cargar su código (generalmente después de que se haya creado la ventana preferida en la aplicación). Instalación de gancho: es bueno utilizar esta técnica en vulnerabilidades de código tan tempranas. Nunca lo había visto antes. Puede defenderse de esto, pero debe explotar la vulnerabilidad del código llamando al punto de entrada LoadLibrary (en lugar de a la tabla IAT) conectándolo directamente. Como dijo el autor del artículo, hay muchas formas de atacar y es posible que te resulte difícil derrotarlas. Pero normalmente solo desea apuntar a una DLL específica para la carga (por ejemplo, una DLL de terceros específica, de hecho, una DLL de terceros en el software que no está escrita correctamente, es decir, puede haber otra defensa de gancho que le permita bloquear su carga). .

3. La mejor manera es asegurarse de que ningún proceso pueda obtener derechos de administrador o ejecutarse como cuenta de usuario de la aplicación. Sin este acceso, es imposible inyectar código en una aplicación, y una vez que dicho proceso obtiene acceso, puede hacer todo tipo de travesuras sin inyectarse en otros procesos, solo que el código inyectado es más fácil de ocultar.

4. ¿Por qué quieres bloquearlo? ¿Es esta una necesidad "comercial" real o simplemente está interesado en trabajar contra los "hackers"? Depende del diseño si los permisos lo permiten: el sistema operativo permite asignar a los administradores del sistema las funciones de la cuenta que están ejecutando. El artículo de Raymond Chen estará vinculado aquí pronto...

5 Dado que este cartel implica que está invirtiendo en anti-hacking, no significa mucho y me siento frívolo. Como un ex farsante. Sólo un consejo sobre la lucha contra los piratas informáticos. La mejor manera es dejar que se ejecute la lógica central del servidor. Por ejemplo, en un juego de disparos con personajes prioritarios, controle lo que el cliente envía al servidor. No dejes que se muevan. Deje que el servidor le diga a cada jugador la situación del cliente según su propia lógica. ¿A quién le importa si un hacker irrumpe en su propio cliente? Mientras pertenezca a otra persona, es fácil hablar de todo. Para los hacks de mapas de StarCraft, la solución es sencilla. No se filtrará y debería ser territorio inexplorado. También ahorra ancho de banda.

5.

6. ¿Estás buscando una solución bajo ring3? Si es así, desea incorporar funciones adicionales en el sistema que no están disponibles actualmente (al menos que yo sepa), por lo que requerirá algo de trabajo. Además, los controladores también pueden hacer esto; de hecho, la mayoría del software antivirus lo hace de forma regular. En cuanto a detenerse, es un poco complicado porque no puede registrarse como una devolución de llamada para la creación de procesos o la carga de DLL. Sin embargo, si su proceso se inició antes que ellos, puede conectar CreateRemoteThread y funciones similares globalmente y realizar dichas comprobaciones usted mismo. Entonces, de hecho, si no desea que CreateRemoteThread devuelva un mensaje de error, debe verificar qué CreateRemoteThread creará el hilo. Si hay un hash válido del programa original en el disco, entonces se puede verificar el hash antes de cargarlo, lo que anulará la prioridad. Si no tiene un hash, al menos puede buscar lugares simples donde se agrega este tipo de código, buscando DLL que no espera (como IAT o cadenas en ejecución). Si bien no es muy simple, parece hacer lo que estás pidiendo.

7. No estoy muy familiarizado con la API de Windows, pero puedo darte una sugerencia más general: mira tu Prevención de ejecución de datos (DPE) de Windows. Desde la perspectiva del sistema operativo, el proceso que figura en su enlace es un proceso válido. Sin embargo, la defensa en profundidad garantiza que los permisos de seguridad en toda la aplicación asigne espacio estáticamente para que cualquier tema recién generado falle o sobrescriba el espacio, aunque es posible que necesite mucha lógica para detectar y corregir esto. Inserte su código en un controlador de dispositivo u otro proceso de bajo nivel para poder anularlo bajo el paraguas de archivos de Windows. Acabo de ver la respuesta de Cthulon (¡su respuesta es excelente, por cierto!), y me temo que tiene razón: cualquiera que quiera realizar una inyección de código en su aplicación encontrará una manera. Los pasos anteriores aumentan la dificultad. Espero que esto ayude

8. Sólo una idea simple :) Inyectar su propio código usando sumas de comprobación CRC de agujeros de código puede ralentizar otros agujeros de código. Sondear la lista de módulos de proceso para cargar archivos DLL desconocidos podría ayudar a ralentizar a las personas que utilizan ganchos de subprocesos adicionales para inyectar algo antiguo.

9. Puede evitar el uso de la tecnología preferida (CreateRemoteThread que requiere LoadLibrary) conectando LoadLibrary. En su enlace, puede consultar la lista de DLL en el proceso que sabe que se pueden cargar, o puede consultar la lista de DLL conocidas que no desea cargar.

ü Cómo verificar el código cargable C# Detectar o verificar....El siguiente inyector base de código [DllImport("kernel32")]

public static extern IntPtr CreateRemoteThread(

IntPtr hProcess,

IntPtr lpThreadAttributes,

uint dwStackSize,

UIntPtr lpStartAddress, // puntero sin formato al proceso remoto

IntPtr lpParameter,

uint dwCreationFlags,

out IntPtr lpThreadId

[DllImport("kernel32.dll")]

IntPtr externo estático público OpenProcess(

UInt32 dwDesiredAccess,

Int32 bInheritHandle,

Int32 dwProcessId

);

[DllImport( "kernel32.dll")]

público estático externo Int32 CloseHandle(

IntPtr hObject

);

[DllImport("kernel32 .dll", SetLastError = true, ExactSpelling = true)]

static extern bool VirtualFreeEx(

IntPtr hProcess,

IntPtr lpAddress,

UIntPtr dwSize,

uint dwFreeType

);

[DllImport("kernel32.dll", CharSet = CharSet.Ansi, ExactSpelling = true)]

UIntPtr externo estático público GetProcAddress(

IntPtr hModule,

string procName

);

[DllImport ("kernel32.dll", SetLastError = true, ExactSpelling = true)]

static extern IntPtr VirtualAllocEx(

IntPtr hProcess,

IntPtr lpAddress,

p>

uint dwSize,

uint flAllocationType,

uint flProtect

);

[DllImport ("kernel32.dll")]

static extern bool WriteProcessMemory(

IntPtr hProcess,

IntPtr lpBaseAddr

ess,

string lpBuffer,

UIntPtr nSize,

out IntPtr lpNumberOfBytesWritten

[DllImport]. ("kernel32.dll", CharSet = CharSet.Auto)]

público estático externo IntPtr GetModuleHandle(

cadena lpModuleName

);

[DllImport("kernel32", SetLastError = true, ExactSpelling = true)]

interno estático externo Int32 WaitForSingleObject(

identificador IntPtr,

Int32 milisegundos

);

público Int32 GetProcessId(String proc)

{

Proceso[] ProcList;

ProcList = Process.GetProcessesByName(proc);

return ProcList[0].Id;

}

public void InjectDLL(IntPtr hProcess, String strDLLName, Process proc)

{

IntPtr bytesout = IntPtr.Zero;

IntPtr hThread = IntPtr.Length 1;

// En el target Asignar memoria en el espacio de direcciones virtuales del proceso

IntPtr AllocMem = IntPtr.Zero;

UIntPtr Injector = UIntPtr.

AllocMem= (IntPtr)VirtualAllocEx (hProcess, (IntPtr)null, (uint)LenWrite, 0x1000, 0x40); //asignación para WriteProcessMemory

// Escribe el nombre del .dll en nuestro espacio recién asignado.

WriteProcessMemory(hProcess, AllocMem, strDLLName, (UIntPtr)LenWrite, out bytesout);

//Puntero de función "inyector"

/Cargar dll< / p>

Inyector = (UIntPtr)GetProcAddress( GetModuleHandle("kernel32.dll"), "LoadLibraryA");

if (Inyector == null)

{< / p>

Console.WriteLine(" ¡Error del inyector!\n ");

// Error de devolución

return;

}

//Crea un hilo en el proceso de destino y almacena el identificador en hThread

//Carga nuestra DLL

hThread = (IntPtr)CreateRemoteThread(hProcess, (IntPtr)null , 0, Injector, AllocMem, 0, out bytesout);

// Asegúrese de que el identificador del subproceso sea válido

if (hThread == null)

{

// Mango de hilo incorrecto. .. error de devolución

Console.WriteLine(" hThread [ 1 ] Error!\n ");

return;

}

// Tiempo de espera de 10 segundos...

int Result = WaitForSingleObject(hThread, 10 * 1000);

// Comprueba si el hilo ha agotado el tiempo de espera...

if (Resultado == 0x00000080L || Resultado == 0x00000102L || Resultado == 0xFFFFFFFF)

{

//* Tiempo de espera del hilo...*/

Console.WriteLine(" hThread [ 2 ] Error! \n ");

// Asegúrese de que el identificador del hilo sea válido antes de cerrar...

/ / Asegúrese de que los identificadores de subprocesos sean válidos hasta que se cierren... evitando fallas.

if (hThread ! = null)

{

//Cerrar hilo en el proceso de destino

CloseHandle(hThread);

p>

}

return;

}

/ Hilo suspendido durante 1 segundo

Hilo. Sleep(1000);

// Limpiar el espacio asignado (Allocmem)

VirtualFreeEx(hProcess, AllocMem, (UIntPtr)0, 0x8000) )

/ / Asegúrese antes de cerrar que el identificador del hilo sea válido... evitando un bloqueo.

if (hThread != null)

{

//Cerrar el hilo en el proceso de destino

CloseHandle(hThread);

}

//retorno exitoso

return;

}

formulario público1()

{

InitializeComponent();

}

privado void Form1_Load(remitente del objeto, EventArgs e)

{< / p>

}

botón de anulación privada1_Click(remitente del objeto, EventArgs e)

{

String strDLLName = @"C.Users\muhammad( ) \Users\muhammad.qasim\Desktop\ qasim\testdllinject\testdllinject\bin\Debug\testdllinject.dll";

String strProcessName = "WindowsFormsApplication9";

Int32 ProcID = GetProcessId ( strProcessName);

Proceso proc = Process.GetProcessById(ProcID)

if (ProcID gt; = 0)

{