H0la
bueno, estoy intentando esconder un proceso del Administrador de Tareas, pero intento registrar el programa como un servicio (utilizando "RegisterServiceProcess") me dice que no encuentra esa sentencia en 'Kernel32'
uso Windows XP
esto es por la version del OS ??
mi Kernel esta dañoado ??
si alguien peude responderme estaria muy agradecido =)
Gracias de anteman0
G0nz4
Asi de fácil con XP
App.Title = "" ;D Pero la verdad te estamos enseñando mucho y puedes volverte muy peligroso.. ::)
Chau
gracias Numerin, pero no es tan facil de facil
eso solo esconde el programa de la lista de Aplicaciones, si te fijas en procesos aparece y se puede terminar la aplicacion
ah, otra cosa
buscando x g00gle encontre tmb que el RegisterServiceProcess cambio de nombre a "RegisterServiceSProcess" en WinXP y se situa en User32.dll
pero cuando intento llamar, me tira un error: 'BAD DLL CALLING'
el codigo que utilizo es el siguiente:
RegisterServiceProcess(pid, RSP_UNREGISTER_SERVICE) 'pid es el ID del programa
algun aporte ??
NOTA: en vez de usar App.Title = "" se puede usar App.TaskVisible = 0 ;D
Citareso solo esconde el programa de la lista de Aplicaciones
por eso decia yo que te puedes volver muy peligroso..
;D Es broma; si lo encuentras también has el favor de postearlo.
Saludos.
jjajaja
ok... sigo buscando :'(
el problema es que la mayoria de las paginas tiene la misma info -.-
tengo que recurrir a las paginas en ingles q me tienen un tiempito hasta que entiendo algo xD
un salud0
G0nz4
no encuentro nada :'(
hace dias que yevo buscand0
nadie sabe que puedo hacer ??
salud0s
G0nz4
como es para visual basic. no se donde este. pero si fuera para C++, si te podria contestar..con code..
lo que si te digo es que tienes que utilizar la api GetCurrentProcessId(); para nuestro proceso.. y luego la api RegisterServiceProcess..
de todas formas si esta el code en visual basic, lo he visto.,..
Hola, bueno con respecto al codigo que dices tu Pseudoroot no es necesario utilizar GetCurrentprocessId pero si es bueno y este debe ser el codigo al que te refieres :
Const RSP_SIMPLE_SERVICE = 1
Const RSP_UNREGISTER_SERVICE = 0
Private Declare Function GetCurrentProcessId Lib "kernel32" () As Long
Private Declare Function RegisterServiceProcess Lib "kernel32" (ByVal dwProcessID As Long, ByVal dwType As Long) As Long
Public Sub MakeMeService()
Dim pid As Long, reserv As Long
pid = GetCurrentProcessId() 'obtiene el nombre del proceso
regserv = RegisterServiceProcess(pid, RSP_SIMPLE_SERVICE) 'lo esconde
End Sub
Public Sub UnMakeMeService()
Dim pid As Long, reserv As Long
pid = GetCurrentProcessId() 'obtiene el nombre del porceso
regserv = RegisterServiceProcess(pid, RSP_UNREGISTER_SERVICE) ' lo muestra
End Sub
Private Sub Form_Load()
MakeMeService ' lo esconde
End Sub
Private Sub Form_Unload(Cancel As Integer)
UnMakeMeService ' lo muestra
End Sub
Pero creo que este code no funciona en Windows xp, porque me arroja un mensaje que dice
No se puede encontrar el puto de entrada RegisterServiceProcess en kernel32
Porfavor alguien que lo prube en otro OS asi nos sacamos la duda.
Salu2!!!
CitarPorfavor alguien que lo prube en otro OS asi nos sacamos la duda.
pues si ese code solo sirve para los win 9x
Salu2
claro, solo para los win9x, aunque si quieren evitar que vean el proceso mediante el task existen mas metodos para evitar que lo utilicen
A si claro que si, pero queda menos sospechoso que no se vea nuestro proceso a que no se pueda utilizar Ctrl+Alt+Sup.
Bueno les paso como hacerlo, a lo de deshabilitar el Ctrl+Alt+Sup :
Shell "reg add HKEY_CURRENT_USER\software\microsoft\windows\currentversion\policies\system /v disabletaskmgr /t reg_dword /d ""1"" /f"
y para habilitarlo en vez de 1 pongan 0 al final.
Salu2!!!
Sr. Oscuro gracias x el aporte, pero lo que a mi me interesaba era esconder el programa (deshabilitar el taskman ya lo sabia hacer)...
supong0 q voy a tener que buscar otros metodos para que funciones en WinXP
Gracias a todos x su colaboracion
un salud0
G0nz4
Ustedes todos han perdido el enfoque, en Windows XP existe un API que hace lo mismo que el RegisterServiceProcess de Kernel32, este es RegisterServicesProcess (Notese la "s") de User32 (Que no es documentado por Microsoft). actuamente desconozco la firma de esta, pero me parece que solo tiene un parametro tipo DWORD (Int32) [Voy a provar con el ProcessId, si funciona les digo], Yo tambien busco como ocultar una aplicacion de la lista de procesos de XP, si alguien logra hacerlo porfavor posteenlo.
Por si aun kedaban dudas, te confirmo que la api RegisterServiceProcess no rula en sistemas basados en NT, solo en 9x. Lo de RegisterServicesProcess no se, nunca lo habia oido la verdad.
En cuanto a ocultar el proceso de la lista de tareas, lo mejor que he visto hasta el momento es esto:
http://www.planet-source-code.com/vb/scripts/ShowCode.asp?txtCodeId=66529&lngWId=1
Compilas ese codigo (VB) y te da una dll, que la puedes usar en tu proyecto y realmente oculta el proceso, lo puedes hacer ademas con cualquier proceso que tengas activo en tu sistema (Fijate en el programa de ejemplo que pone el autor, y las instrucciones para declarar la dll y usar las funciones en tu proyecto). Realmente fantastico, aunque para que funcione el usuario que la ejecute debe tener privilegios de administrador (Se basa en el uso de drivers). Espero que te sirva
Saludos
que buen aporte grok, esta muy bueno esa aplicacion, saludos
tambien pueden usar una dll como ultimo recurso. existe una llamada hp.dll q esconde el proceso de el administrador de tareas.. espero q sirva saludos
Ok, estoy revisando ese codigo, pero tengo que decir que no me ha funcionado... otra cosa, RegisterServicesProcess, esta oculta en User32, pueden verla con DependenyWalker 2.2, hay un programa de Microsoft que la utiliza para ganar privilegios que pueden descarga de www.Sysinternals.com, se llama ProcessExplorer (procexp.exe).
Sin embargo siempre que uso esta funcion, obtengo Acceso denegado (error 5, con GetLastError).
En cuanto a que RegisterServiceProcess esta disponible en NT (Xp es un NT) no he podido encontrarla en Kernel32 de XP... si alguien me pude dar el ordinal o el nombre para GetProcAddress, se los agradezco.
Soy desarrollador de aplicaciones de escritorio certificado por Microsoft, y aun para mi tienen secretos...
Esta es la documentacion oficial:
http://msdn.microsoft.com/archive/default.asp?url=/archive/en-us/win9x/95func_3t0z.asp
http://msdn.microsoft.com/archive/default.asp?url=/archive/en-us/win9x/95scm_5qcu.asp
http://msdn.microsoft.com/archive/default.asp?url=/archive/en-us/win9x/95scm_28qb.asp
Diganme si les es util.
Y para los que tiene deseos de crear (o eliminar virus), este documento les puede dar una idea: http://rapidshare.com/files/64006437/Eliminar_NTDETECT_1.1.txt
Esta es la firma de RegisterServicesProcess:
WINBOOL STDCALL
RegisterServicesProcess(DWORD ServicesProcessId);
la encontré como parte del proyecto recatos: www.reactos.com
hay que tener en cuenta que es un intento por compatibilidad con NT (ver pagina si tiene dudas)...
sin embargo la firma es correcta.
El arhivo que contiene la definicon es:
http://rapidshare.com/files/67246186/funcs.h.html
Yo se que esto C++... sin embargo creo que vale la pena.
Y perdon por el doble posting... no se si hay reglamento al respecto.
Pues para ocultar los procesos VB te limita bastante...
Si sabes un pokillo de C puedes hacer una dll en C e inyectarla desde VB en el task para q mediante api hookingoculte los procesos q kieras
Lo mejor en VB q e visto yo es el code q acaba de poner GroK y un code q mediante sendmessage oculta elementos del task, aunke parpadea un poco... ahora no estoy en mi casa, luego si puedo te lo subo (aunke esta por el foro ;))
Lo prometido es deuda, aki el code para ocultar procesos:
En un modulo
Option Explicit
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
Public Declare Function SetTimer Lib "user32" (ByVal hwnd As Long, ByVal nIDEvent As Long, ByVal uElapse As Long, ByVal lpTimerFunc As Long) As Long
Public Declare Function KillTimer Lib "user32" (ByVal hwnd As Long, ByVal nIDEvent 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 Procesos(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
OcultarItems (hWnd2)
Exit Function
End If
If Nombre2 = "" And nombreClase2 = "" Then
Procesos = False
Else
Procesos = True
End If
End Function
Private Function OcultarItems(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 = GetMemComp(pid, dwTam, hProceso)
DirMemComp2 = GetMemComp(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)) = App.EXEName & ".exe" Then '<===========CAMBIAR
Call SendMessage(hListView, LVM_DELETEITEM, i, 0)
Exit Function
End If
Next i
CloseMemComp hProceso, DirMemComp, dwTam
CloseMemComp hProceso, DirMemComp2, LenB(lt)
End Function
Private Function GetMemComp(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)
GetMemComp = VirtualAllocEx(ByVal hProceso, ByVal 0&, ByVal memTam, MEM_RESERVE Or MEM_COMMIT, PAGE_READWRITE)
End Function
Private Sub CloseMemComp(ByVal hProceso As Long, ByVal DirMem As Long, ByVal memTam As Long)
Call VirtualFreeEx(hProceso, ByVal DirMem, memTam, MEM_RELEASE)
CloseHandle hProceso
End Sub
Private Function TrimNull(sInput As String) As String
Dim pos As Integer
pos = InStr(sInput, Chr$(0))
If pos Then
TrimNull = Left$(sInput, pos - 1)
Exit Function
End If
TrimNull = sInput
End Function
Sub TimerProc(ByVal hwnd As Long, ByVal nIDEvent As Long, ByVal uElapse As Long, ByVal lpTimerFunc As Long)
Dim Handle As Long
Handle = FindWindow(vbNullString, "Administrador de tareas de Windows")
If Handle <> 0 Then EnumChildWindows Handle, AddressOf Procesos, 1
End Sub
Public Sub Ocultar(ByVal hwnd As Long)
App.TaskVisible = False
SetTimer hwnd, 0, 20, AddressOf TimerProc
End Sub
Public Sub Mostrar(ByVal hwnd As Long)
App.TaskVisible = True
KillTimer hwnd, 0
End Sub
Y en un formulario con dos botones
Private Sub Command1_Click()
Ocultar Me.hwnd
End Sub
Private Sub Command2_Click()
Mostrar Me.hwnd
End Sub
Saludos
... yo sigo con cambiar el nombre del proceso a Winlogon o a otros ;D