Conversión de código de MazarD a C#

[DaasCook]

Vale... pues tíos quisiera saber: ¿Es posible convertir el código de inyección por trampolín y/o el código de Redirección de Threads de MazarD a C#?...

Tengo pensado crear un driver a nivel kernel para darme los permisos necesarios y encima usar uno de los dos métodos más seguros de inyección de código... Pero, no quisiera perder mucho tiempo convirtiendo lo inconvertible (?); Por eso vengo a preguntar: ¿Es posible?.

Me manejo no de manera perfecta, pero si tengo conocimientos acera de los punteros en C#; Y pues las APIS no son problema; Por tal... ¿Qué Decís?.

Prost, OS!

[raul338]

Todo depende de lo que usa Mazard, que no se a cual codigo te refieres
Pero si, teoricamente se puede

[DaasCook]

Todo depende de lo que usa Mazard, que no se a cual codigo te refieres
Pero si, teoricamente se puede

Pues... el código es el siguiente (aunque ya había puesto un vínculo al .pdf):

Código (cpp) [Seleccionar] Expandir

#include <windows.h>
#include <stdio.h>
//Esta funcion hace la llamada a LoadLibrary pasandole el nombre de nuestra dll, después
//ejecuta el código sobreescrito por el jmp y salta a la instrucción siguiente al jmp
BYTE *CrearCodigo(DWORD Ruta,DWORD dLoadLibrary,DWORD RetDir,BYTE
*RepBuff,DWORD RepSize)
{
BYTE *codeBuff;
codeBuff=(BYTE*)malloc(20+RepSize);
//Guardamos registros y llamamos a LoadLibrary pasandole la ruta a nuestra dll
*codeBuff=0x60; //opcode correspondiente a pushad
codeBuff++;
//push path
*codeBuff=0x68;
codeBuff++;
*((DWORD*)codeBuff)=Ruta;
codeBuff+=4;
//mov eax,dLoadLibrary
*codeBuff=0xB8;
codeBuff++;
*((DWORD*)codeBuff)=dLoadLibrary;
codeBuff+=4;
*((WORD*)codeBuff)=0xD0FF; //call eax
codeBuff+=2;
*codeBuff=0x61; //popad
codeBuff++;
//Ahora metemos el codigo que ha sido reemplazado
memcpy(codeBuff,RepBuff,RepSize);
codeBuff+=RepSize;
//Ahora hacemos el salto a la dirección de la api
*codeBuff=0x68; //push RetDir
codeBuff++;
*((DWORD*)codeBuff)=(DWORD)RetDir;
codeBuff+=4;
*codeBuff=0xC3; //ret
codeBuff-=(19+RepSize);
return codeBuff;
}
int main()
{
void *hMsgBox;
DWORD dLoadLib;
DWORD pID;
HANDLE hproc;
DWORD size=5;
BYTE *ReplacedBuff;
DWORD oldprot;
void *repsite,*dllnsite;
BYTE *inject;
char laDll[]="c:\\ladll.dll";
BYTE *jmpBuff;
printf("Inyección por trampolin by MazarD\nhttp://www.mazard.info\n");
printf("PID del proceso a inyectarse:");
scanf("%d",&pID);
//Preparamos direcciones de apis necesarias
hMsgBox=GetProcAddress(LoadLibrary("user32.dll"),"MessageBoxA");
printf("Dirección de MessageBoxA:%.4x\n",hMsgBox);
dLoadLib=(DWORD)GetProcAddress(GetModuleHandle("kernel32.dll"),"LoadLibraryA");
printf("Dirección de LoadLibraryA:%.4x\n",dLoadLib);
//Abrimos el proceso y damos permisos en la zona de reemplazo
hproc=OpenProcess(PROCESS_ALL_ACCESS,false,pID);
VirtualProtect(hMsgBox,size,PAGE_EXECUTE_READWRITE,&oldprot);
//Leemos el codigo que será reemplazado
ReplacedBuff=(BYTE*)malloc(size+6);
memset(ReplacedBuff,90,size+6);
ReadProcessMemory(hproc,hMsgBox,ReplacedBuff,size,NULL);
//Reservamos memoria y guardamos el nombre de la dll
dllnsite=VirtualAllocEx(hproc,NULL,11,MEM_COMMIT |
MEM_RESERVE,PAGE_EXECUTE_READWRITE);
WriteProcessMemory(hproc,dllnsite,laDll,strlen(laDll)+1,NULL);
printf("Nombre de la dll en:%.4x\n",dllnsite);
//Creamos el codigo
inject=CrearCodigo((DWORD)dllnsite,dLoadLib,(DWORD)hMsgBox+5,ReplacedBuff,size);
//Reservamos memoria y guardamos el codigo
repsite=VirtualAllocEx(hproc,NULL,size+20,MEM_COMMIT |
MEM_RESERVE,PAGE_EXECUTE_READWRITE);
WriteProcessMemory(hproc,repsite,inject,size+20,NULL);
printf("Codigo Reemplazado en:%.4x\n",repsite);
//Creamos un salto hacia nuestro codigo y lo ponemos en el inicio de la api
jmpBuff=(BYTE*)malloc(5);
*jmpBuff=0xE9; //opcode correspondiente a jmp
jmpBuff++;
*((DWORD*)jmpBuff)=(DWORD)repsite-(DWORD)hMsgBox-5;
jmpBuff--;
WriteProcessMemory(hproc,hMsgBox,jmpBuff,5,NULL);
CloseHandle(hproc);
return 0;
}

Ojo ése es sólo el método de inyección por trampolín. En el vínculo dejé el .pdf de MazarD donde se pueden observar todos los demás códigos.

Yo leyendo un poco el código, pues lo veo posible, ya que los punteros en C# no son muy difíciles de manejar, el problema es que... Si por ser código administrado, ¿no vayan a haber problemas?.

Prost, OS!

[SRVAM]

ahi te dice las librerias que usan, implementalas en tu codigo .net y en teoria podrias hacer lo que quieres sin problemas xD

EDITO: si tu tienes las librerias, da igual que sea codigo manejado o no, puedes hacer las llamadas a los metodos de las librerias de mazarD sin problemas xD

[DaasCook]

ahi te dice las librerias que usan, implementalas en tu codigo .net y en teoria podrias hacer lo que quieres sin problemas xD

EDITO: si tu tienes las librerias, da igual que sea codigo manejado o no, puedes hacer las llamadas a los metodos de las librerias de mazarD sin problemas xD

Bien, entonces... comenzaré a convertir código, gracias por todo .

[[D4N93R]]

A qué nivel va a correr eso? En cuál ring?

[DaasCook]

A qué nivel va a correr eso? En cuál ring?

0, ¿Por qué?.

[[D4N93R]]

Pff, pues para no explicarte todo te pego esto de Lasse V. Karlsen:

You can not make kernel-mode device drivers in C# as the runtime can't be safely loaded into ring0 and operate as expected.

Additionally, C# doesn't create binaries suitable for loading as device drivers, particularly regarding entry points that drivers need to expose. The dependency on the runtime to jump in and analyze and JIT the binary during loading prohibits the direct access the driver subsystem needs to load the binary.

There is work underway, however, to lift some device drivers into user mode, you can see an interview here with Peter Wieland of the UDMF (User Mode Driver Framework) team.

User-mode drivers would be much more suited for managed work, but you'll have to google a bit to find out if C# and .NET will be directly supported. All I know is that kernel level drivers are not doable in only C#.

You can, however, probably make a C/C++ driver, and a C# service (or similar) and have the driver talk to the managed code, if you absolutely have to write a lot of code in C#.

[[Zero]]

0, ¿Por qué?.

¿Como vas a ejecutar ese codigo en ring 0? Leete esto anda:

Código [Seleccionar] Expandir

http://foro.elhacker.net/programacion_cc/principios_basicos_de_desarrollo_de_drivers_en_windows_lenguaje_c-t307017.0.html

Saludos

[DaasCook]

Eh ostia ¿Qué os pasa?. Calma, calma...

Dije que correría con privilegios de ring0, más no dije cómo se los daría.

He estado hojeando algunos artículos (si si más que esto)... Como MS Windows Internals, y... Rootkits - STWK, con lo cual terminé entendiendo que mi driver debería ser hecho en C/C++, de hecho mi driver está completo, tan solo necesitaba un buen GUI para mi inyector (por ende elegí C#)... y saber si aquel código se podía convertir (que por lo visto se puede).

Tan imbécil (?), no soy para creer que con código administrado podría crear un driver , Lo que sí es posible, es iniciar el servicio de mi driver, y ¡Zasca! que funciona.

Prost, OS! y espero no hayan más extrañas respuestas.