24 respuestas en este tema

[Dante]

Hola quisiera saver si hay alguna forma de detectar si cuando se ejecute una determinada aplicación esta trabaja a nivel de kernel?

[jdepaz]

Hola,

 

Para responder a tu pregunta, es necesario contar con mas información o bien que expliques a detalle, porque decir "a nivel de kernel" resulta ambigüo, es decir, podría entenderse que la aplicación resulta ser otro "kernel" dentro del sistema operativo, o bien "a nivel de kernel" podría entenderse que la aplicación aplica funciones directas al firmware y sin o con necesidad del "kernel".

 

Bien, el "kernel" facilita abstracciones del hardware, administración de procesos, entre otras cosas, ahora bien, una aplicación en "Windows" implícitamente utiliza funciones expuestas en la librería "kernel.dll", y tú como desarrollador, puedes utilizar funciones explicitamente en tu aplicación realizando llamados al API de Windows, en este caso, utilizando funciones de la librería "kernel.dll".

 

 

 

Saludos

[escafandra]

Todas las APP trabajan a nivel Kernel pues es éste último donde terminan las API. Hay una estructura en capas de cebolla o anillo que aísla el Kernel de forma que según permisos se filtran accesos. Cuando un código se ejecuta desde el Kernel se dice que está en Ring0, el mismo núcleo y no va a pasar por los filtros. El código desde el Kernel tiene acceso a Todo, es el mismo S.O. aunque suele haber mecanismos de seguridad para evitar errores mortales. Un error  no controlado en Ring0 significa una bonita BSOD.

 

Hay un abismo entre Rin0 y el usuario. La forma de acceder al Kernel generalmente es con un driver que se suele cargar como un servicio. Un driver tiene una estructura de código muy especificada y se trata de un ejecutable completo. El driver suele tener un nombre de archivo con la extensión .sys. Para cargar un driver encontraremos APIs como OpenSCManager, CreateService, StartService...

 

Para cargar un driver necesitamos una app en modo usuario administrador que lo ejecutará y se comunicará con él, Algunas app pueden esconder al driver en su propio código y ocultarlo. Así que si depurando la app con un debugger encontramos un archivo.sys y el uso de API para cargar y manejar servicios, como OpenSCManager, CreateService, StartService, SendIOCTL... probablemente se trate de una app que trata de ejecutar código desde el Kernel

 

 

Saludos.

[Dante]

lo q quiero dectectar en concreto es el chetengine, aki esta el codigo fuente de este https://github.com/c...ne/cheat-engine sugun tengo entendido el realiza modificaciones a nivel de kernel en las variables del processo q uno escoja, lo q quiero detectar es cuando algun programa trate de trabaja en la memoria de otro programa,

 

El driver suele tener un nombre de archivo con la extensión .sys.

la aplicacion si lo tiene son dbk64.sys y dbk32.sys, pero mucha otras aplicaciones comunes tienes *.sys, lo q quisiar es algo parecido al ShellMonitor de escafandra pero para saver quien esta ejecutando codigo desde el kernel o se podria hacer un hook a las api OpenSCManager, CreateService, StartService

solo para informarme no para bloquerlas?

 

[escafandra]

cheat-engine trabaja con un driver cargado en el Kernel


Saludos.

[Dante]

si pero como puedo detectar cuando el trate de cargar ese driver

[jdepaz]

Hola,

 

Tal como dice escafandra:

 

 

 

cheat-engine trabaja con un driver cargado en el Kernel

 

Revisando la estructura del proyecto, creo que el driver es "DBKKernel" y hay una unidad llamada "DBK32functions" en la cual puedes analizar y verificar los llamados a las funciones, y alli puedes iniciar y encontrar la respuesta a tu pregunta acerca de la carga del driver.

 

Realizando un pasos a paso puedes realizar el análisis.

 

Saludos

[escafandra]

Para cargar un driver encontraremos APIs como OpenSCManager, CreateService, StartService...

Este fragmento de código es de cheat-engine y coincide con lo que ya te dije:

delphi

hService := OpenService(hSCManager, pchar(servicename), SERVICE_ALL_ACCESS);
        if hService=0 then
        begin
          hService:=CreateService(
             hSCManager,           // SCManager database
             pchar(servicename),   // name of service
             pchar(servicename),   // name to display
             SERVICE_ALL_ACCESS,   // desired access
             SERVICE_KERNEL_DRIVER,// service type
             SERVICE_DEMAND_START, // start type
             SERVICE_ERROR_NORMAL, // error control type
             pchar(driverloc),     // service's binary
             nil,                  // no load ordering group
             nil,                  // no tag identifier
             nil,                  // no dependencies
             nil,                  // LocalSystem account
             nil                   // no password
          );
        end

Fíjate en la API CreateService y el parámetro SERVICE_KERNEL_DRIVER. ¿No te da ya alguna idea de como detectarlo en tiempo de ejecución?
 
 
Saludos.

[jdepaz]

Excelente  , que bien

 

¡Mas detallado....imposible!

 

 

Saludos

[escafandra]

Para ilustrar un poco más:

cpp

__try
				{
					//switch to the selected process
					if (PsLookupProcessByProcessId((PVOID)(UINT64)(pinp->ProcessID),&selectedprocess)==STATUS_SUCCESS)	
					{
						KAPC_STATE apc_state;
						RtlZeroMemory(&apc_state,sizeof(apc_state));					
    					KeStackAttachProcess((PVOID)selectedprocess,&apc_state);
 
						__try
						{
							physical=MmGetPhysicalAddress((PVOID)pinp->BaseAddress);
						}
						__finally
						{
							KeUnstackDetachProcess(&apc_state);
						}
 
 
						ObDereferenceObject(selectedprocess);
 
					}
				}

La API que nos habilita desde el Kernel para escribir en el espacio de memoria de un proceso es KeStackAttachProcess

Saludos.

[Dante]

jeje me pongo a trabajar ahora mismo es q estaba de  vacaciones.

[Dante]

uff disculpen la demora es q llevo varios hilos de mi proyecto, estube buscando informacion sobre CreateService y KeStackAttachProcess pero todo me envia a las paginas de microsoft a las cuales no se la rason pero no tengo acceso, la idea q tengo es hacele un hook al estas api pero no encuentro a q libreria pertentecen, estoy trabajando con RAD Studio Berlin.

[escafandra]

KeStackAttachProcess es exportada por NtosKrnl.exe que pertenece al Kernel y solo puede ser hookeada desde un driver en Ring 0 escrito en C

cpp

VOID KeStackAttachProcess(
  _Inout_ PRKPROCESS   Process,
  _Out_   PRKAPC_STATE ApcState
);

CreateService es exportada por Advapi32.dll

cpp

SC_HANDLE WINAPI CreateService(
  _In_      SC_HANDLE hSCManager,
  _In_      LPCTSTR   lpServiceName,
  _In_opt_  LPCTSTR   lpDisplayName,
  _In_      DWORD     dwDesiredAccess,
  _In_      DWORD     dwServiceType,
  _In_      DWORD     dwStartType,
  _In_      DWORD     dwErrorControl,
  _In_opt_  LPCTSTR   lpBinaryPathName,
  _In_opt_  LPCTSTR   lpLoadOrderGroup,
  _Out_opt_ LPDWORD   lpdwTagId,
  _In_opt_  LPCTSTR   lpDependencies,
  _In_opt_  LPCTSTR   lpServiceStartName,
  _In_opt_  LPCTSTR   lpPassword
);

Saludos.

[Dante]

entonces desde delphi no hay forma de hookear esas API?, CreateService deve de ejecutarse nadamas cuando levanta el cheatengine no?, si es asi no resuelva nada hookeandolo.

[escafandra]

Saludos.
 
Felicidades por su presentación.

 

entonces desde delphi no hay forma de hookear esas API?, CreateService deve de ejecutarse nadamas cuando levanta el cheatengine no?, si es asi no resuelva nada hookeandolo.

CreareService es un API normal pero requiere elevación de administrador, para el hookear también. Se puede hacer un hook con delphi
KeStackAttachProcess no se puede hookear con delphi, requiere escribir un driver en modo Kernel en C.



Saludos

[Dante]

el problema del CreateService es segun entendi del funcionamieto del cheatengine q el lo usa para agregar el driver al kerner lo cual debe hacerlo al levatar por lo q no me sirve de nada hookearla porque ya el la habra usado o eso pieso no?

[escafandra]

Si inyectas en explorer.exe una dll con un Hook a la API CreateProcessInternalW controlas todos los procesos que crea y puedes inyectar inmediatamente para hookear el proceso que quieras.

También puedes descargar el driver tranquilamente y luego hookear la API para que no lo vuelvan a instalar. Otra opción es estar desinstalando el driver en un bucle localizado en un thread.


Saludos.

[Dante]

eso de desintalar el driver q usa es lo q creo q seria mejor, como se hace eso

[escafandra]

Como desinstalador completo paso a paso de un driver en C
 

cpp

//---------------------------------------------------------------------------
// Detiene el driver y lo descarga
// Driver es el nombre del driver sin extensión.sys (Simbolic Link)
BOOL UnLoadDriver(char* driver)
{
   SERVICE_STATUS ssService;
   SC_HANDLE      scManager;
   SC_HANDLE      scService;
 
   scManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
   if(scManager == NULL){
      return FALSE;  //No se ha contactado con Service Control Manager
 
   }
 
   scService = OpenService(scManager, TEXT(driver), SERVICE_ALL_ACCESS);
   if(!scService){
      if(GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST){
         CloseServiceHandle(scManager);
         return TRUE;
      }else{
         CloseServiceHandle(scManager);
         return FALSE;  //No se contactado con el driver
      }
   }
 
   if(!ControlService(scService, SERVICE_CONTROL_STOP, &ssService)){
      if(GetLastError() != ERROR_SERVICE_NOT_ACTIVE){
        CloseServiceHandle(scService);
        CloseServiceHandle(scManager);
        return FALSE;   // No se ha podido detener el servicio
      }
   }
 
   if(!DeleteService(scService)){
      CloseServiceHandle(scService);
      CloseServiceHandle(scManager);
      return FALSE;  // No ha podido eliminarse el driver
   }
 
   CloseServiceHandle(scService);
   CloseServiceHandle(scManager);
   return TRUE;
}

Desinstalador simple de un driver en delphi. Fragmento de código tomado de ZwOpenProcess. Un Hook al mismo Kernel.

delphi

var
 scManager: Integer;
 scService: Integer;
 ssService: SERVICE_STATUS;
 DriverName: String;
 DriverPath: String;
 
begin;
 Result:= FALSE;
 DriverName:= ChangeFileExt(DriverFileName, '');
 scManager := OpenSCManager(nil, nil, SC_MANAGER_CONNECT or _DELETE or SC_MANAGER_CREATE_SERVICE);
 if (scManager <> 0) then
  begin
    scService:= OpenService(scManager, PCHAR(DriverName), SERVICE_ALL_ACCESS);
    if(scService <> 0)then
      begin;
        Result:= ControlService(scService, SERVICE_CONTROL_STOP, ssService);
      end;
   end;
  CloseServiceHandle(scService);
  CloseServiceHandle(scManager);
 
  DriverPath:= SystemDir + '\drivers\' + DriverFileName;
  DeleteFile(DriverPath);
end;

Saludos.

[Dante]

intente lo de desintalar el driver y no me sirvio, pues al trabajar con otra version , no encontre el driver en el system32/driver/... ni lo pone en el registro como aparece el en la unidad DBK32functions.pas como me orientaron, al parecer el cambia esto en cada version, pues se me ocurio la idea de si es posible obtener un listado de servicios de tipo SERVICE_KERNEL_DRIVER?