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

 

 


Tema destacado: ¿Eres nuevo? ¿Tienes dudas acerca del funcionamiento de la comunidad? Lee las Reglas Generales


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación General
| | |-+  .NET (C#, VB.NET, ASP) (Moderador: kub0x)
| | | |-+  Obtener Informacion acerca del modulo correspondiente al StartAdress del Thread.
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] 2 Ir Abajo Respuesta Imprimir
Autor Tema: Obtener Informacion acerca del modulo correspondiente al StartAdress del Thread.  (Leído 4,436 veces)
**Aincrad**


Desconectado Desconectado

Mensajes: 610



Ver Perfil WWW
Obtener Informacion acerca del modulo correspondiente al StartAdress del Thread.
« en: 8 Junio 2022, 19:13 pm »

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 :

Código
  1.  Dim processEx As Process = System.Diagnostics.Process.GetProcessById(4080)
  2.  
  3.        For Each pT As ProcessThread In processEx.Threads
  4.  
  5.            Dim TID As IntPtr = pT.Id
  6.            Dim StarAdress As IntPtr = pT.StartAddress
  7.  
  8.            ' aqui , por lo que investigue , se tiene que buscar la informacion de los simbolos o algo asi
  9.            ' Usando la API dbghelp.dll
  10.            ' Pero no hacer como hacerlo , tambien lei sobre otras cosas. como por ejemplo NtQueryInformationThread o algo asi
  11.  
  12.  
  13.        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

How to retrieve starting address of a thread in windows?

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







En línea



RayR

Desconectado Desconectado

Mensajes: 190


Ver Perfil
Re: Obtener Informacion acerca del modulo correspondiente al StartAdress del Thread.
« Respuesta #1 en: 8 Junio 2022, 23:59 pm »

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):

Código
  1. IntPtr hThread = OpenThread(0x0040, false, idHilo);

Luego llamas a NtQueryInformationThread (ntdll.dll):

Código
  1. IntPtr startAddress = Marshal.AllocHGlobal(IntPtr.Size);
  2. NtQueryInformationThread(hThread, 9, startAddress, IntPtr.Size, IntPtr.Zero);

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

Código
  1. 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.


En línea

**Aincrad**


Desconectado Desconectado

Mensajes: 610



Ver Perfil WWW
Re: Obtener Informacion acerca del modulo correspondiente al StartAdress del Thread.
« Respuesta #2 en: 9 Junio 2022, 01:32 am »

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 :

Código
  1. <DllImport("ntdll.dll", CharSet:=CharSet.Unicode, SetLastError:=True)>
  2.    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
  3.    End Function
  4.  
  5.    Public Enum ThreadInfoClass
  6.        ThreadBasicInformation
  7.        ThreadTimes
  8.        ThreadPriority
  9.        ThreadBasePriority
  10.        ThreadAffinityMask
  11.        ThreadImpersonationToken
  12.        ThreadDescriptorTableEntry
  13.        ThreadEnableAlignmentFaultFixup
  14.        ThreadEventPair_Reusable
  15.        ThreadQuerySetWin32StartAddress
  16.        ThreadZeroTlsCell
  17.        ThreadPerformanceCount
  18.        ThreadAmILastThread
  19.        ThreadIdealProcessor
  20.        ThreadPriorityBoost
  21.        ThreadSetTlsArrayAddress
  22.        ThreadIsIoPending
  23.        ThreadHideFromDebugger
  24.        MaxThreadInfoClass
  25.    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 ...


En línea



RayR

Desconectado Desconectado

Mensajes: 190


Ver Perfil
Re: Obtener Informacion acerca del modulo correspondiente al StartAdress del Thread.
« Respuesta #3 en: 9 Junio 2022, 02:59 am »

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í:

Código
  1. [DllImport("ntdll.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  2. 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.
En línea

**Aincrad**


Desconectado Desconectado

Mensajes: 610



Ver Perfil WWW
Re: Obtener Informacion acerca del modulo correspondiente al StartAdress del Thread.
« Respuesta #4 en: 14 Junio 2022, 00:59 am »

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í:

Código
  1. [DllImport("ntdll.dll", CharSet = CharSet.Unicode, SetLastError = true)]
  2. 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.
En línea



RayR

Desconectado Desconectado

Mensajes: 190


Ver Perfil
Re: Obtener Informacion acerca del modulo correspondiente al StartAdress del Thread.
« Respuesta #5 en: 14 Junio 2022, 17:22 pm »

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.
En línea

RayR

Desconectado Desconectado

Mensajes: 190


Ver Perfil
Re: Obtener Informacion acerca del modulo correspondiente al StartAdress del Thread.
« Respuesta #6 en: 15 Junio 2022, 19:15 pm »

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:

Código
  1. HANDLE hProcess = GetCurrentProcess();
  2. SymInitialize(hProcess, NULL, TRUE);
  3.  
  4. /* En C llamariamos a CreateToolhelp32Snapshot() y Module32First()/Module32Next() para obtener los modulos cargados.
  5. En .NET creo que los obtienes directamente en Process.Modules */
  6. For cada Modulo en proceso.Modules
  7. SymLoadModule64(hProcess, NULL, Modulo.FileName, Modulo.ModuleName, Modulo.BaseAddress, Modulo.ModuleMemorySize);
  8. 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:

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

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

Código
  1. HANDLE hThread = OpenThread(THREAD_ALL_ACCESS, false, thread.id);
  2. CONTEXT context;
  3. context.ContextFlags = CONTEXT_FULL;
  4.  
  5. // Comparar el id, NO el handle
  6. if (thread.id == System.Threading.Thread.CurrentThread.ManagedThreadId)
  7.              RtlCaptureContext(&context);
  8. else {
  9.              SuspendThread(hThread);
  10.              GetThreadContext(hThread, &context);
  11.              ResumeThread(hThread);
  12. }

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

Código
  1.       size_t startAddress;
  2.  
  3.       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():

Código
  1.       STACKFRAME64 sf64;
  2.       sf64.AddrPC.Offset = context.Eip;
  3.       sf64.AddrPC.Mode = AddrModeFlat;
  4.       sf64.AddrFrame.Offset = context.Ebp;
  5.       sf64.AddrFrame.Mode = AddrModeFlat;
  6.       sf64.AddrStack.Offset = context.Esp;
  7.       sf64.AddrStack.Mode = AddrModeFlat;
  8.  
  9.       StackWalk64(IMAGE_FILE_MACHINE_I386, hProcess, hThread, &sf64, &context, NULL, SymFunctionTableAccess64, SymGetModuleBase64, NULL);

Luego a SymGetModuleInfo64():

Código
  1.       IMAGEHLP_MODULE64 module;
  2.       memset(&module, 0, sizeof(module));
  3.       module.SizeOfStruct = sizeof(module);
  4.       SymGetModuleInfo64(hProcess, sf64.AddrPC.Offset, &module);
  5.  




Opción 2 (recomendada).

Obtenemos directamente el nombre del módulo pasandole startAddress:

Código
  1.       IMAGEHLP_MODULE64 module;
  2.       memset(&module, 0, sizeof(module));
  3.       module.SizeOfStruct = sizeof(module);
  4.       SymGetModuleInfo64(hProcess, startAddress, &module);
  5.  




Luego obtenemos el nombre de la función:

Código
  1.       if (!pSym) (IMAGEHLP_SYMBOL64*)malloc(sizeof(IMAGEHLP_SYMBOL64) + MAX_SYM_NAME * sizeof(TCHAR));
  2.  
  3.       memset(pSym, 0, sizeof(IMAGEHLP_SYMBOL64) + MAX_SYM_NAME);
  4.       pSym->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL64);
  5.       pSym->MaxNameLength = MAX_SYM_NAME;
  6.  
  7.       SymGetSymFromAddr64(hProcess, startAddress, NULL, pSym);

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

Código
  1. Console.WriteLine(module.ModuleName & "!" & pSym.Name & "+" (startAddress - pSym.Address).ToString("x"))
  2. CloseHandle(hThread);
  3. Next thread
  4. free(pSym);
  5.  

Lo anterior mostraría algo tipo:

Código:
miEjecutable!mainCRTStartup+0
ntdll!TpCallbackIndependent+140

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.
« Última modificación: 18 Junio 2022, 00:05 am por RayR » En línea

**Aincrad**


Desconectado Desconectado

Mensajes: 610



Ver Perfil WWW
Re: Obtener Informacion acerca del modulo correspondiente al StartAdress del Thread.
« Respuesta #7 en: 15 Junio 2022, 23:26 pm »

Hola, De tanto buscar encontre este codigo Fuente : 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 :

Código
  1.   public static String GetThreadStartAddress(IntPtr hProc, uint threadId)
  2.        {
  3.            IntPtr hThread = IntPtr.Zero;
  4.            GCHandle handle = default(GCHandle);
  5.  
  6.            try
  7.            {
  8.                hThread = DbgHelpNative.OpenThread(DbgHelpNative.ThreadAccess.QUERY_INFORMATION, false, threadId);
  9.  
  10.                if (hThread == IntPtr.Zero)
  11.                {
  12.                    throw new Win32Exception("OpenThread failed");
  13.                }
  14.  
  15.                var threadAddress = new IntPtr[1];
  16.  
  17.                handle = GCHandle.Alloc(threadAddress, GCHandleType.Pinned);
  18.                var result = NtQueryInformationThread(hThread, ThreadInfomationClass.threadquerysetwin32startaddress, handle.AddrOfPinnedObject(), IntPtr.Size, IntPtr.Zero);
  19.  
  20.                if (result != 0)
  21.                {
  22.                    throw new Win32Exception(string.Format("NtQueryInformationThread failed; NTSTATUS = {0:X8}", result));
  23.                }
  24.  
  25.                DbgHelpNative.SymSetOptions(DbgHelpNative.Options.SYMOPT_UNDNAME | DbgHelpNative.Options.SYMOPT_DEFERRED_LOADS);
  26.  
  27.                if (!DbgHelpNative.SymInitialize(hProc, null, true))
  28.                {
  29.                    throw new Win32Exception("SymInitialize failed");
  30.                }
  31.  
  32.                DbgHelpNative.SYMBOL_INFO symbolInfo = new DbgHelpNative.SYMBOL_INFO();
  33.  
  34.                symbolInfo.SizeOfStruct = (uint)Marshal.SizeOf(typeof(DbgHelpNative.SYMBOL_INFO)) - 1024;
  35.  
  36.                symbolInfo.MaxNameLen = 1024;
  37.  
  38.                ulong displacement;
  39.  
  40.                if (!DbgHelpNative.SymFromAddr(hProc, (ulong)threadAddress[0], out displacement, ref symbolInfo))
  41.                {
  42.                    throw new Win32Exception("SymFromAddr failed");
  43.                }
  44.                return symbolInfo.Name;
  45.                //return threadAddress[0];
  46.            }
  47.            finally
  48.            {
  49.                if (hThread != IntPtr.Zero)
  50.                {
  51.                    DbgHelpNative.CloseHandle(hThread);
  52.                }
  53.  
  54.                if (handle.IsAllocated)
  55.                {
  56.                    handle.Free();
  57.                }
  58.            }
  59.        }

Falla justo aqui :

Código
  1.  if (!DbgHelpNative.SymFromAddr(hProc, (ulong)threadAddress[0], out displacement, ref symbolInfo))
  2.                {
  3.                    throw new Win32Exception("SymFromAddr failed");
  4.                }


No se que podria estar mal, alguna Idea ?

En línea



RayR

Desconectado Desconectado

Mensajes: 190


Ver Perfil
Re: Obtener Informacion acerca del modulo correspondiente al StartAdress del Thread.
« Respuesta #8 en: 16 Junio 2022, 21:21 pm »

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.
En línea

RayR

Desconectado Desconectado

Mensajes: 190


Ver Perfil
Re: Obtener Informacion acerca del modulo correspondiente al StartAdress del Thread.
« Respuesta #9 en: 17 Junio 2022, 23:28 pm »

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:

Código
  1. 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í:

Código
  1.      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():

Código
  1.                if (!DbgHelpNative.SymInitialize(hProc, null, true))
  2.                {
  3.                    throw new Win32Exception("SymInitialize failed");
  4.                }

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:

Código
  1.       [StructLayout(LayoutKind.Sequential)]
  2.        public struct MODULEENTRY32
  3.        {
  4.            public uint dwSize;
  5.            uint th32ModuleID;
  6.            uint th32ProcessID;
  7.            uint GlblcntUsage;
  8.            uint ProccntUsage;
  9.            public IntPtr modBaseAddr;
  10.            public uint modBaseSize;
  11.            IntPtr hModule;
  12.            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
  13.            public string szModule;
  14.            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
  15.            public string szExePath;
  16.        }
  17.  
  18.        [DllImport("kernel32.dll", CharSet = CharSet.Ansi, SetLastError = true)]
  19.        public static extern IntPtr CreateToolhelp32Snapshot(uint flags, uint processid);
  20.        [DllImport("kernel32.dll", CharSet = CharSet.Ansi, SetLastError = true)]
  21.        public static extern bool Module32First(IntPtr hSnapshot, ref MODULEENTRY32 lpme);
  22.        [DllImport("kernel32.dll", CharSet = CharSet.Ansi, SetLastError = true)]
  23.        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:

Código
  1.        private void get_process_thread_Click(object sender, EventArgs e)
  2.        {
  3.            Process proc = Process.GetProcessById(int.Parse(proc_txt.Text));
  4.  
  5.  
  6.            // Los flags: TH32CS_SNAPMODULE | TH32CS_SNAPMODULE32
  7.            IntPtr hSnap = DbgHelpNative.CreateToolhelp32Snapshot(0x00000008 | 0x00000010, (uint)proc.Id);
  8.  
  9.            // INVALID_HANDLE_VALUE
  10.            if ((long)hSnap == -1)
  11.            {
  12.                // Error
  13.            }
  14.  
  15.            if (!DbgHelpNative.SymInitialize(proc.Handle, null, true))
  16.            {
  17.                throw new Win32Exception("SymInitialize failed");
  18.            }
  19.  
  20.            DbgHelpNative.MODULEENTRY32 me = new DbgHelpNative.MODULEENTRY32();
  21.  
  22.            me.dwSize = (uint)Marshal.SizeOf(me);
  23.  
  24.            if (DbgHelpNative.Module32First(hSnap, ref me))
  25.            {
  26.                do
  27.                {
  28.                    if (0 == DbgHelpNative.SymLoadModule64(proc.Handle, IntPtr.Zero, me.szExePath, me.szModule, (ulong)me.modBaseAddr, (uint)me.modBaseSize))
  29.                    {
  30.                        /* Esta segunda verificacion es necesaria, ya que cuando SymLoadModule64
  31.                          * devuelve 0, si TAMBIEN GetLastError es 0, simplemente significa
  32.                          * que el modulo ya habia sido cargado*/
  33.  
  34.                        // En caso contrario, hay error
  35.                        if (Marshal.GetLastWin32Error() != 0)
  36.                        {
  37.                            // Error: no se cargo el modulo
  38.                        }
  39.  
  40.                    }
  41.                } while (DbgHelpNative.Module32Next(hSnap, ref me));
  42.            }
  43.  
  44.  
  45.            ProcessThreadCollection procThread = proc.Threads;
  46.            threadinfo_list.Items.Clear();
  47.            int idx = 0;
  48.            foreach (ProcessThread i in procThread)
  49.            {
  50.                threadinfo_list.Items.Add(i.Id.ToString());
  51.                threadinfo_list.Items[idx].SubItems.Add(DbgHelp.GetThreadStartAddress(proc.Handle, (uint)i.Id));
  52.                threadinfo_list.Items[idx].SubItems.Add(i.PriorityLevel.ToString());
  53.                idx++;
  54.            }
  55.  
  56.            DbgHelpNative.SymCleanup(proc.Handle);
  57.            DbgHelpNative.CloseHandle(hSnap);
  58.        }

Con esto, al compilar para x64 (o ANY con "Prefer 32-bit" deshabilitado) ya aceptaría procesos de ambas arquitecturas.
« Última modificación: 18 Junio 2022, 20:45 pm por RayR » En línea

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

Ir a:  

WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines