Foro de elhacker.net

Hola, tengo una duda que no he resuelto todavia. y es como obtener esta info :

---

Bien, Por mi cuenta he podido obtener, esos campos, pero en el campo StartAdress , no se como obtener ese tipo de informacion (Modulename + Adress) .

Esto es lo que tengo hasta ahora :

  Dim processEx As Process = System.Diagnostics.Process.GetProcessById(4080)
 
        For Each pT As ProcessThread In processEx.Threads
 
            Dim TID As IntPtr = pT.Id
            Dim StarAdress As IntPtr = pT.StartAddress
 
            ' aqui , por lo que investigue , se tiene que buscar la informacion de los simbolos o algo asi
            ' Usando la API dbghelp.dll
            ' Pero no hacer como hacerlo , tambien lei sobre otras cosas. como por ejemplo NtQueryInformationThread o algo asi
 
 
        Next

Como ven la informacion que obtengo de StartAdress, es del tipo intptr . no string .

---

Esta es la informacion que he encontrado hasta ahora :

Getting module name from thread information (https://stackoverflow.com/questions/5157083/getting-module-name-from-thread-information)

How to retrieve starting address of a thread in windows? (https://stackoverflow.com/questions/11147846/how-to-retrieve-starting-address-of-a-thread-in-windows)

Pero no entiendo ni pito. Ayudaa....
Gracias de antemano.

La forma en que lo hacen en el segundo link (NtQueryInformationThread) es sencilla en C++, pero no tengo mucha experiencia llamando a funciones de la API desde .NET, y nunca he programado en Vb.Net. De cualquier forma, van algunos consejos que te podrían servir al menos darte una idea general.

En C# sería algo más o menos así:

Obtener handle a cada hilo mediante la función de la API OpenThread (kernel32.dll):

IntPtr hThread = OpenThread(0x0040, false, idHilo);

Luego llamas a NtQueryInformationThread (ntdll.dll):

IntPtr startAddress = Marshal.AllocHGlobal(IntPtr.Size);
NtQueryInformationThread(hThread, 9, startAddress, IntPtr.Size, IntPtr.Zero);

Cierras el handle con la función de API CloseHandle (kernel32.dll):

CloseHandle(hThread);

Obviamente habría que hacer manejo de errores y demás, pero para empezar podrías probar a ver si te sirve de esta manera.

Si , exactamente lo estaba haciendo asi, hasta que no pude encontrar el equivalente a NtQueryInformationThread en .net. basado en lo que busque de c++ , el pinvoke deberia ser asi :

 <DllImport("ntdll.dll", CharSet:=CharSet.Unicode, SetLastError:=True)>
    Public Shared Function NtQueryInformationThread(ByVal ThreadHandle As IntPtr, ByVal ThreadInformationClass As ThreadInfoClass, ByRef ThreadInformation As IntPtr, ByVal ThreadInformationLength As IntPtr, ByVal ReturnLength As IntPtr) As IntPtr
    End Function
 
    Public Enum ThreadInfoClass
        ThreadBasicInformation
        ThreadTimes
        ThreadPriority
        ThreadBasePriority
        ThreadAffinityMask
        ThreadImpersonationToken
        ThreadDescriptorTableEntry
        ThreadEnableAlignmentFaultFixup
        ThreadEventPair_Reusable
        ThreadQuerySetWin32StartAddress
        ThreadZeroTlsCell
        ThreadPerformanceCount
        ThreadAmILastThread
        ThreadIdealProcessor
        ThreadPriorityBoost
        ThreadSetTlsArrayAddress
        ThreadIsIoPending
        ThreadHideFromDebugger
        MaxThreadInfoClass
    End Enum

'Deberia' , esto lo hice basado en la documentacion de c++ , y el ThreadInfoClass me parece que esta incompleto. si funciona , es un milagro.


Elektro se te estraña ...

Más o menos, aunque la función devuelve un simple entero, y alguno de los parámetros no es del todo exacto. En C# sería algo así:

[DllImport("ntdll.dll", CharSet = CharSet.Unicode, SetLastError = true)]
static extern int NtQueryInformationThread(IntPtr ThreadHandle, ThreadInfoClass ThreadInformationClass, IntPtr ThreadInformation, int ThreadInformationLength, IntPtr ReturnLength);

Para conseguir el StartAddress no importa si el enum está incompleto, ya que el único valor que necesitas es 9 (ThreadQuerySetWin32StartAddress).

Por lo demás, y aunque no lo he probado, no veo por qué no habría de funcionar.

Ya lo hice, pero para nada, esto obtiene el StartAdress. Lo mismo que yo obtengo en el codigo que puse al principio.

Pero no obtiene El startAdress en la forma que quiero, (ModuleName+Offset adress)
como por ejemplo : CodeSmart.exe+0xb426ee

Sigo necesitando ayuda. se agradece cualquier sugerencia.

Sí, en lo que yo me enfoqué es sólo en la dirección, porque pensé que te referías a eso. Pero ¿seguro que es lo mismo que ya obtenías? Que yo recuerde, pT.StartAddress no te da exactamente lo que quieres. O sea, según yo, el resultado que obtienes es distinto al que te da NtQueryInformationThread, y sólo este último es el que se corresponde con lo que te muestran herramientas como Process Explorer o PocessHacker. Prueba a mostrar los hilos de Process.GetCurrentProcess() de una forma y la otra y verás (o no, si es que me falla la memoria).

Para conseguir los nombres creo que sí necesitarías dbghelp.dll, como dicen en el segundo link que pusiste. Si más tarde tengo tiempo, reviso bien la información y posteo lo que encuentre.

Le di una revisada rápida a la documentación de la API Debug Help y no es muy difícil, siempre que lo que quieras sea algo básico. Eso sí, hacerlo desde .NET será engorroso porque las funciones de esta API toman varias estructuras que tendrías que definir en tu programa. De cualquier forma, te explico más o menos como lo podrías hacer, con una mezcla de pseudocódigo y C. En este ejemplo se mostraría la información para el proceso actual:

Primero deberías inicializar el manejador de símbolos y luego cargar las tablas de cada módulo cargado por el proceso. Esto carga los nombres de funciones de las dll y demás:

HANDLE hProcess = GetCurrentProcess();
SymInitialize(hProcess, NULL, TRUE);
 
/* En C llamariamos a CreateToolhelp32Snapshot() y Module32First()/Module32Next() para obtener los modulos cargados.
En .NET creo que los obtienes directamente en Process.Modules */
For cada Modulo en proceso.Modules
	SymLoadModule64(hProcess, NULL, Modulo.FileName, Modulo.ModuleName, Modulo.BaseAddress, Modulo.ModuleMemorySize);
Next Modulo

A SymInitialize le podrías pasar como segundo parámetro una cadena con rutas separadas por punto y coma, como se explica en: https://docs.microsoft.com/en-us/windows/win32/debug/symbol-paths . Esto te serviría, por ejemplo, para usar el servidor de símbolos de Microsoft, pero es opcional.

Después, iteras a través de los hilos del proceso:

/* En C, Thread32First()/Thread32Next(). En .NET, en la coleccion Threads */
IMAGEHLP_SYMBOL64 *pSym = NULL;
For cada thread en proceso.ProcessThreads
 

Y dentro del for, por cada hilo, obtienes un contexto:

	HANDLE hThread = OpenThread(THREAD_ALL_ACCESS, false, thread.id);
	CONTEXT context;
	context.ContextFlags = CONTEXT_FULL;
 
	// Comparar el id, NO el handle
	if (thread.id == System.Threading.Thread.CurrentThread.ManagedThreadId)
              RtlCaptureContext(&context);
	else {
              SuspendThread(hThread);
              GetThreadContext(hThread, &context);
              ResumeThread(hThread);
	}

Llamamos a NtQueryInformationThread() para obtener la dirección de inicio:

       size_t startAddress;
 
       NtQueryInformationThread(hThread, ThreadQuerySetWin32StartAddress, &startAddress, sizeof(startAddress), NULL);

Obtenemos el nombre del módulo (dll/exe) que contiene la función. Dos opciones:

---

Opción 1.

Llamas a StackWalk64():

       STACKFRAME64 sf64;
       sf64.AddrPC.Offset = context.Eip;
       sf64.AddrPC.Mode = AddrModeFlat;
       sf64.AddrFrame.Offset = context.Ebp;
       sf64.AddrFrame.Mode = AddrModeFlat;
       sf64.AddrStack.Offset = context.Esp;
       sf64.AddrStack.Mode = AddrModeFlat;
 
       StackWalk64(IMAGE_FILE_MACHINE_I386, hProcess, hThread, &sf64, &context, NULL, SymFunctionTableAccess64, SymGetModuleBase64, NULL);

Luego a SymGetModuleInfo64():

       IMAGEHLP_MODULE64 module;
       memset(&module, 0, sizeof(module));
       module.SizeOfStruct = sizeof(module);
       SymGetModuleInfo64(hProcess, sf64.AddrPC.Offset, &module);
 

---

Opción 2 (recomendada).

Obtenemos directamente el nombre del módulo pasandole startAddress:

       IMAGEHLP_MODULE64 module;
       memset(&module, 0, sizeof(module));
       module.SizeOfStruct = sizeof(module);
       SymGetModuleInfo64(hProcess, startAddress, &module);
 

---

Luego obtenemos el nombre de la función:

       if (!pSym) (IMAGEHLP_SYMBOL64*)malloc(sizeof(IMAGEHLP_SYMBOL64) + MAX_SYM_NAME * sizeof(TCHAR));
 
       memset(pSym, 0, sizeof(IMAGEHLP_SYMBOL64) + MAX_SYM_NAME);
       pSym->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL64);
       pSym->MaxNameLength = MAX_SYM_NAME;
 
       SymGetSymFromAddr64(hProcess, startAddress, NULL, pSym);

Con esto, ya podrias mostrar la información que quieres:

	Console.WriteLine(module.ModuleName & "!" & pSym.Name & "+" (startAddress - pSym.Address).ToString("x"))
	CloseHandle(hThread);
Next thread
free(pSym);
 

Lo anterior mostraría algo tipo:


Por supuesto, esto sólo es un ejemplo para darte una idea. No es nada robusto, no verifico errores, etc., y no es nada limpio, pero lo hice así para que fuera lo más simple posible, además de que sólo le di una leída muy deprisa a la documentación y apenas le dediqué unos minutos al ejemplo. Si lo conviertes correctamente a VB, debería funcionar en general, pero probablemente haya casos límite donde podría fallar. Obviamente, para implementarlo bien, deberías revisar con calma la documentación de las funciones usadas, pero creo que este ejemplo puede servir como punto de partida.

Editado para hacer unas cuantas correcciones.

Hola, De tanto buscar encontre este codigo Fuente : https://github.com/itsmeny/Process_Thread_Info (https://github.com/itsmeny/Process_Thread_Info) basicamente todo lo que necesito pero , hay un pequeño detalle , no funciona, o al menos a mi no me funciona, el error esta en la funcion del dbghelp SymFromAddr .

No se si son los parametros correctos , de verdad no se por que me da el error. Coloco la funcion importante :

   public static String GetThreadStartAddress(IntPtr hProc, uint threadId)
        {
            IntPtr hThread = IntPtr.Zero;
            GCHandle handle = default(GCHandle);
 
            try
            {
                hThread = DbgHelpNative.OpenThread(DbgHelpNative.ThreadAccess.QUERY_INFORMATION, false, threadId);
 
                if (hThread == IntPtr.Zero)
                {
                    throw new Win32Exception("OpenThread failed");
                }
 
                var threadAddress = new IntPtr[1];
 
                handle = GCHandle.Alloc(threadAddress, GCHandleType.Pinned);
                var result = NtQueryInformationThread(hThread, ThreadInfomationClass.threadquerysetwin32startaddress, handle.AddrOfPinnedObject(), IntPtr.Size, IntPtr.Zero);
 
                if (result != 0)
                {
                    throw new Win32Exception(string.Format("NtQueryInformationThread failed; NTSTATUS = {0:X8}", result));
                }
 
                DbgHelpNative.SymSetOptions(DbgHelpNative.Options.SYMOPT_UNDNAME | DbgHelpNative.Options.SYMOPT_DEFERRED_LOADS);
 
                if (!DbgHelpNative.SymInitialize(hProc, null, true))
                {
                    throw new Win32Exception("SymInitialize failed");
                }
 
                DbgHelpNative.SYMBOL_INFO symbolInfo = new DbgHelpNative.SYMBOL_INFO();
 
                symbolInfo.SizeOfStruct = (uint)Marshal.SizeOf(typeof(DbgHelpNative.SYMBOL_INFO)) - 1024;
 
                symbolInfo.MaxNameLen = 1024;
 
                ulong displacement;
 
                if (!DbgHelpNative.SymFromAddr(hProc, (ulong)threadAddress[0], out displacement, ref symbolInfo))
                {
                    throw new Win32Exception("SymFromAddr failed");
                }
                return symbolInfo.Name;
                //return threadAddress[0];
            }
            finally
            {
                if (hThread != IntPtr.Zero)
                {
                    DbgHelpNative.CloseHandle(hThread);
                }
 
                if (handle.IsAllocated)
                {
                    handle.Free();
                }
            }
        }

Falla justo aqui :

  if (!DbgHelpNative.SymFromAddr(hProc, (ulong)threadAddress[0], out displacement, ref symbolInfo))
                {
                    throw new Win32Exception("SymFromAddr failed");
                }

No se que podria estar mal, alguna Idea ?

No lo he probado pero ¿lo estás compilando para x86, x64, o Any CPU? Y si es este último, ¿tienes activado "Prefer 32-bit"? Te lo digo porque las funciones de depuración son muy quisquillosas en cuanto a la arquitectura.  Te recomendaría primero que nada meterle al programa PIDs de procesos tanto de 32 como de 64 bits a ver si falla con ambos o no. Y luego recompilarlo a otra arquitectura y probar de nuevo. Y es que si compilas para 32 o con prioridad a 32, probablemente no podrías usarlo con procesos de 64 y quizás tampoco al revés (digo probablemente porque no he revisado ese código).

Hablando de eso, y por si acaso, me faltó decir que el ejemplo que puse funcionaría en 32 bits. Para 64, habría que hacer unos pocos cambios, como sustituir los campos Eip, Ebp y Esp de context por sus variantes para x64 (Rip, Rbp, Rsp), pasar IMAGE_FILE_MACHINE_AMD64 a StackWalk64() y cambiar el tipo de la variable startAddress y su tamaño a 64 bits en vez de DWORD (de hecho, sería mejor usar un tipo que cambie con la arquitectura, como un puntero, size_t, etc.).

De cualquier forma, veré si luego tengo tiempo de revisar el código que encontraste y buscar el error.

Descargué el código y parece funcionar correctamente, pero como imaginaba, sólo en una misma arquitectura. Si lo compilas para x86 (o ANY + "Prefer 32-bit") sólo admite id de procesos de 32 bits, y lo mismo para 64.

Eso sí, la excepción de la que hablabas no tiene razón de ser, ya que es normal que SymFromAddr falle a veces. Eso sólo significa que no encontró el símbolo (nombre de función) porque el ejecutable del proceso fue compilado sin información de depuración (no hay archivo .pdb, etc.). Es justamente lo que pasa en la imagen que pusiste en tu mensaje original, donde pone: CodeSmart.exe+0xb426ee. Como no encontró el símbolo (SymFromAddr falló), simplemente pone el offset.

Si quisieras hacer algo similar, ese offset lo calcularías:

threadAddress[0] - module.BaseAddress

donde module es el módulo (.dll o .exe) que contiene la función, y lo obtienes mediante la función de la API SymGetModuleInfo64. Así, simplemente harías que aquí:

      if (!DbgHelpNative.SymFromAddr(hProc, (ulong)threadAddress[0], out displacement, ref symbolInfo))

se devuelva una cadena con el offset. O simplente devuelves "No se encontro simbolo" o lo que quieras.

---

Edito:

Me entró curiosidad por ver por qué si se compila para x64 no puede aceptar procesos de 32 bits, ya que desde la API en C++ es sencillo hacerlo (pasando los flags adecuados a CreateToolhelp32Snapshot). Resulta que cuando el programa se ejecuta en 64 bits, no carga módulos de 32 bits, y no sé si haya forma de especificar en .NET que lo haga. Probé hacerlo manualmente mediante la API de Windows (como lo hago en C++) y funciona.

Por si te interesa (o alguien más que le llame la atención el tema), lo harías así:

Primero, eliminar esta línea de la función GetThreadStartAddress():

                if (!DbgHelpNative.SymInitialize(hProc, null, true))
                {
                    throw new Win32Exception("SymInitialize failed");
                }

Pues SymInitialize() sólo se debe llamar una vez por proceso, y aquí se está llamando por cada hilo. Y en este caso, lo correcto es llamar a SymCleanup() al final.

Luego, definir esta estructura y dllimports:

       [StructLayout(LayoutKind.Sequential)]
        public struct MODULEENTRY32
        {
            public uint dwSize;
            uint th32ModuleID;
            uint th32ProcessID;
            uint GlblcntUsage;
            uint ProccntUsage;
            public IntPtr modBaseAddr;
            public uint modBaseSize;
            IntPtr hModule;
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
            public string szModule;
            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
            public string szExePath;
        }
 
        [DllImport("kernel32.dll", CharSet = CharSet.Ansi, SetLastError = true)]
        public static extern IntPtr CreateToolhelp32Snapshot(uint flags, uint processid);
        [DllImport("kernel32.dll", CharSet = CharSet.Ansi, SetLastError = true)]
        public static extern bool Module32First(IntPtr hSnapshot, ref MODULEENTRY32 lpme);
        [DllImport("kernel32.dll", CharSet = CharSet.Ansi, SetLastError = true)]
        public static extern bool Module32Next(IntPtr hSnapshot, ref MODULEENTRY32 lpme);

Finalmente, el código, que puse dentro de get_process_thread_Click() sólo por simplicidad:

        private void get_process_thread_Click(object sender, EventArgs e)
        {
            Process proc = Process.GetProcessById(int.Parse(proc_txt.Text));
 
 
            // Los flags: TH32CS_SNAPMODULE | TH32CS_SNAPMODULE32
            IntPtr hSnap = DbgHelpNative.CreateToolhelp32Snapshot(0x00000008 | 0x00000010, (uint)proc.Id);
 
            // INVALID_HANDLE_VALUE
            if ((long)hSnap == -1)
            {
                // Error
            }
 
            if (!DbgHelpNative.SymInitialize(proc.Handle, null, true))
            {
                throw new Win32Exception("SymInitialize failed");
            }
 
            DbgHelpNative.MODULEENTRY32 me = new DbgHelpNative.MODULEENTRY32();
 
            me.dwSize = (uint)Marshal.SizeOf(me);
 
            if (DbgHelpNative.Module32First(hSnap, ref me))
            {
                do
                {
                    if (0 == DbgHelpNative.SymLoadModule64(proc.Handle, IntPtr.Zero, me.szExePath, me.szModule, (ulong)me.modBaseAddr, (uint)me.modBaseSize))
                    {
                        /* Esta segunda verificacion es necesaria, ya que cuando SymLoadModule64
                         * devuelve 0, si TAMBIEN GetLastError es 0, simplemente significa
                         * que el modulo ya habia sido cargado*/
 
                        // En caso contrario, hay error
                        if (Marshal.GetLastWin32Error() != 0)
                        {
                            // Error: no se cargo el modulo
                        }
 
                    }
                } while (DbgHelpNative.Module32Next(hSnap, ref me));
            }
 
 
            ProcessThreadCollection procThread = proc.Threads;
            threadinfo_list.Items.Clear();
            int idx = 0;
            foreach (ProcessThread i in procThread)
            {
                threadinfo_list.Items.Add(i.Id.ToString());
                threadinfo_list.Items[idx].SubItems.Add(DbgHelp.GetThreadStartAddress(proc.Handle, (uint)i.Id));
                threadinfo_list.Items[idx].SubItems.Add(i.PriorityLevel.ToString());
                idx++;
            }
 
            DbgHelpNative.SymCleanup(proc.Handle);
            DbgHelpNative.CloseHandle(hSnap);
        }

Con esto, al compilar para x64 (o ANY con "Prefer 32-bit" deshabilitado) ya aceptaría procesos de ambas arquitecturas.

Que demonios!! Funciona.  ;-) Gracias por tomarte el tiempo en esto .

---

Ayer lo logre de esta manera, Primero me descargue el codigo del ProcessHacker y me puse a analizarlo.  Al final, tome todo el proyecto del PH y lo puse en 1 API : https://github.com/DestroyerDarkNess/Xylon.PH (https://github.com/DestroyerDarkNess/Xylon.PH) , Despues facilmente use el codigo del PH al final asi quedo : https://github.com/DestroyerDarkNess/ProcessThreadInfo (https://github.com/DestroyerDarkNess/ProcessThreadInfo)

 Private WithEvents _threadP As ThreadProvider = Nothing
 
    Private Sub buttonWalk_Click(sender As Object, e As EventArgs) Handles buttonWalk.Click
        Dim processEx As Process = System.Diagnostics.Process.GetProcessById(TextBox1.Text)
        listViewCallStack.Items.Clear()
 
        _threadP = New ThreadProvider(processEx.Id)
        _threadP.LoadKernelSymbols()
        _threadP.Run()
    End Sub
 
    Private Sub _threadP_BeforeUpdate() Handles _threadP.BeforeUpdate
        listViewCallStack.Items.Clear()
    End Sub
 
    Private Sub _threadP_ResolveSybol(sender As Object, e As ThreadProvider.ResolveSybolData) Handles _threadP.ResolveSybol
 
        Me.BeginInvoke(Sub()
                           Debug.WriteLine("TID: " & e.TID & "  StartAdress: " & e.ResolveInfo.Symbol)
                           Dim ItemN As New ListViewItem
                           ItemN.Text = e.TID
                           ItemN.SubItems.Add(e.ResolveInfo.Symbol)
                           listViewCallStack.Items.Add(ItemN)
                       End Sub)
 
    End Sub
 
    Private Sub _threadP_Error(ex As Exception) Handles _threadP.[Error]
        MsgBox(ex.Message)
    End Sub

---