[Ayuda] Prevenir que un Programa se Minimize o se cambie el foco de Windows.

[**Aincrad**]

Hola, Tengo un Problemilla.

Bueno les pondre en contexto. hace unos dias que vengo desarrollando un Cheat para Among US.

Among US es un juego creado en Unity. y la mayoria de estos juegos . permiten superponer formularios (GDI) sobre el.

El cheat lo estamos desarrollando un amigo y yo.

el caso es que le dio por probar el menu que hice sobre otros juegos, y por casualidad funciono. yo me quede como wtf.

Bueno el caso es que el cheat puede superponerse sobre varios juegos . como es el caso de Operation 7...

Pero tengo un problema. y es de lo que vengo a pedir guia.



El problema que tengo es que algunos juegos al perder el "Foco" de la ventana del mismo se minimizan. y quiero prevenir esto.

Osea me refiero a que cuando se muestra el cheat encima del juego en pantalla completa. obviamente el foco de windows cambia de la venta del juego a mi cheat. y en ese momento el juego al perder el foco se minimiza.



Para solucionar esto. se me  ocurrieron varias ideas :

1) Pausar (suspender) el Proceso del juego y reanudarlo cuando oculte el cheat.

 R: Use la clase vieja de Elektro para hacer esto pero por alguna razón no sirve.
      -La clase esa esta medio bug , no me detectaba el proceso tuve que acomodarla.
 
    Por alguna razon el Proceso del juego no se suspendio. no se que paso la verdad.
    -tal vez sea el anticheat xingcode que no deja-



2) Intente Usar AppActivate , al parecer intento funcionar pero , en una milesima de segundo se pierde la el foco de la venta del juego y por ende se minimiza.
 
 R: Pondre Mi codigo a continuacion, que hice para que mantener el foco en el juego :
   
   Modo de uso :

   

Código (vbnet) [Seleccionar] Expandir

Private ActiveProc As New ProcessActivate(ProcessGame)

   ProcessActivate.vb
   

Código (vbnet) [Seleccionar] Expandir

Public Class ProcessActivate

   Private Shared Monitor As Boolean = True
   Public Property ActivateMonitoring As Boolean
       Get
           Return Monitor
       End Get
       Set(value As Boolean)
           Monitor = value
       End Set
   End Property

   Private ProcessName As String = String.Empty

   Public Sub New(ByVal ProcName As String)
       ProcessName = ProcName

       Dim tsk As New Task(AddressOf AppActivateEx, TaskCreationOptions.LongRunning)
       tsk.Start()
   End Sub

   Private Sub AppActivateEx()
       On Error Resume Next
       Do While True
           If Monitor = True Then
               If Not ProcessName = String.Empty Then
                   If ProcessName.ToLower.EndsWith(".exe") Then ProcessName = ProcessName.Substring(0, ProcessName.Length - 4)

                   Dim proc() As Process = Process.GetProcessesByName(ProcessName)

                   If Not proc.Length = 0 Then

                       AppActivate(proc(0).MainWindowTitle)

                   End If
               End If
           End If
       Loop
   End Sub

End Class




Bueno Básicamente Necesito ayuda / Ideas , sobre como mantener el foco sobre la ventana del juego , aunque de click encima del Form del Cheat.

Incluso también me servia , alguna forma de tener el form del cheat desactivado aunque de click encima de el no llame al foco de ventana de windows. asi solo tendría que emular los clicks . etc..

Elektro una ayudita plox ...... :,v



Imagenes :

 

[tincopasan]

Hola:
         no he intentado lo que planteas, ya me voya aponer a ver que pasa, pero... ¿por qué no usar el cheat directamente con combinación de teclas?

[**Aincrad**]

Hola:
         no he intentado lo que planteas, ya me voya aponer a ver que pasa, pero... ¿por qué no usar el cheat directamente con combinación de teclas?

En efecto eso es lo que estoy haciendo actualmente. uso Up, Down , Left , Righ . para navegar por las opciones, un menu simple de cheat ON - OFF.



Pero deberia haber algun modo. de que al llamar a la venta del cheat. no se cambie el foco de windows. y ya con esto podria hacer un cheat con botones, textbox. etc..

[tincopasan]

tengo una idea, el problema es que no juego a nada, ¿alguna idea de un juego liviano para probar?

[Eleкtro]

El problema que tengo es que algunos juegos al perder el "Foco" de la ventana del mismo se minimizan. y quiero prevenir esto.

¿Pero lo estás jugando a pantalla completa dedicada, o ventana sin bordes?...

De todas formas si ese problema es tal y como dices, entonces lo más simple para prevenirlo sería desarrollar un cheat sin interfaz gráfica y así evitar el problema. Si no puedes vencer a tu enemigo, acomódate a él. xD

También puedes probar a utilizar la función de Windows 'SetWindowLongPtr' sobre la ventana de tu aplicación:
https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-setwindowlongptra

con la combinación de estilos extendidos de ventana: WS_EX_TOPMOST + WS_EX_NOACTIVATE:
https://docs.microsoft.com/en-us/windows/win32/winmsg/extended-window-styles

Teoricamente con esa combinación de estilos puedes superponer una ventana sobre las demás (top most) sin activar el foco de entrada de dicha ventana.

1) Pausar (suspender) el Proceso del juego y reanudarlo cuando oculte el cheat.

 R: Use la clase vieja de Elektro para hacer esto pero por alguna razón no sirve.
      -La clase esa esta medio bug , no me detectaba el proceso tuve que acomodarla.
 
    Por alguna razon el Proceso del juego no se suspendio. no se que paso la verdad.
    -tal vez sea el anticheat xingcode que no deja-

No se a que clase te refieres, pero esto te debería servir para suspender y reanudar el proceso:

https://foro.elhacker.net/net_c_vbnet_asp/libreria_de_snippets_para_vbnet_compartan_aqui_sus_snippets-t378770.0.html;msg1859297#msg1859297

Aquí te dejo una actualización del código:

UIAutomationUtil.vb

Código (vbnet) [Seleccionar] Expandir

Imports DevCase.Interop.Unmanaged.Win32
Imports DevCase.Interop.Unmanaged.Win32.Enums
Imports Microsoft.Win32.SafeHandles

Namespace DevCase.Core.IPC.Tools

   ''' ----------------------------------------------------------------------------------------------------
   ''' <summary>
   ''' Contains related UI automation utilities.
   ''' </summary>
   ''' ----------------------------------------------------------------------------------------------------
   <ImmutableObject(True)>
   Public NotInheritable Class UIAutomationUtil

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Prevents a default instance of the <see cref="UIAutomationUtil"/> class from being created.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       <DebuggerNonUserCode>
       Private Sub New()
       End Sub

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Pauses the execution of all the threads of the specified process.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <example> This is a code example.
       ''' <code>
       ''' ' Create and run a CMD process.
       ''' Dim p As New Process
       ''' p.StartInfo.FileName = "cmd.exe"
       ''' p.StartInfo.Arguments = "/C ""Dir /B /S /A C:\*"""
       ''' p.Start()
       '''
       ''' Thread.Sleep(2000) ' Let the CMD run the job for some seconds...
       '''
       ''' ' Pause the process.
       ''' Using ppo As PauseProcessObject = UIAutomationUtil.PauseProcess(p.Id)
       '''     ' Wait 5 seconds to let you observe that the process is paused...
       '''     Thread.Sleep(5000)
       '''
       '''     ' Resume the process.
       '''     UIAutomationUtil.ResumeProcess(ppo)
       ''' End Using
       ''' </code>
       ''' </example>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <param name="pid">
       ''' The process id (PID).
       ''' </param>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <returns>
       ''' The return value is a collection of openthread-handles to the thread handles of the process.
       ''' <para></para>
       ''' An openthread-handle could be used to suspend, resume or terminate a thread that the openthread-handle refers to.
       ''' </returns>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <remarks>
       ''' After pausing the threads of a process, call <see cref="ResumeProcess(PauseProcessObject)"/> function
       ''' to resume their threads.
       ''' <para></para>
       ''' To manually resume an openthread-handle, call <see cref="ResumeThread"/> function.
       ''' </remarks>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <exception cref="Win32Exception">
       ''' </exception>
       ''' ----------------------------------------------------------------------------------------------------
       <DebuggerStepThrough>
       Public Shared Function PauseProcess(pid As Integer) As PauseProcessObject

           Dim ppo As New PauseProcessObject(pid)
           For Each thread As ProcessThread In Process.GetProcessById(pid).Threads()
               ppo.handles_.Add(UIAutomationUtil.PauseThread(thread.Id))
           Next thread

           Return ppo

       End Function

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Resumes the execution of all the threads for the specified process.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <example> This is a code example.
       ''' <code>
       ''' ' Create and run a CMD process.
       ''' Dim p As New Process
       ''' p.StartInfo.FileName = "cmd.exe"
       ''' p.StartInfo.Arguments = "/C ""Dir /B /S /A C:\*"""
       ''' p.Start()
       '''
       ''' Thread.Sleep(2000) ' Let the CMD run the job for some seconds...
       '''
       ''' ' Pause the process.
       ''' Using ppo As PauseProcessObject = UIAutomationUtil.PauseProcess(p.Id)
       '''     ' Wait 5 seconds to let you observe that the process is paused...
       '''     Thread.Sleep(5000)
       '''
       '''     ' Resume the process.
       '''     UIAutomationUtil.ResumeProcess(ppo)
       ''' End Using
       ''' </code>
       ''' </example>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <param name="ppo">
       ''' A <see cref="PauseProcessObject"/> object containing all the process thread-handles.
       ''' </param>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <remarks>
       ''' After resuming the threads of a process, call the <see cref="PauseProcessObject.Dispose()"/> method
       ''' of the <paramref name="ppo"/> parameter to close their openthread-handles.
       ''' <para></para>
       ''' To manually close an openthread-handle, call <see cref="NativeMethods.CloseHandle(IntPtr)"/> function.
       ''' </remarks>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <exception cref="Win32Exception">
       ''' </exception>
       ''' ----------------------------------------------------------------------------------------------------
       <DebuggerStepThrough>
       Public Shared Sub ResumeProcess(ppo As PauseProcessObject)

           For Each safeOpenThreadHandle As SafeAccessTokenHandle In ppo.handles_
               UIAutomationUtil.ResumeThread(safeOpenThreadHandle)
           Next safeOpenThreadHandle

       End Sub

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Pauses the execution of the specified thread.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <example> This is a code example.
       ''' <code>
       ''' Dim threadId As ProcessThread = Process.GetProcessesByName("cmd.exe").FirstOrDefault.Threads(0).Id
       '''
       ''' Dim openThreadHandle As SafeAccessTokenHandle = PauseThread(threadId)
       '''
       ''' ' ResumeThread(openThreadHandle)
       ''' </code>
       ''' </example>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <param name="threadId">
       ''' The thread identifier.
       ''' </param>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <returns>
       ''' The return value is an openthread-handle to the thread handle.
       ''' <para></para>
       ''' An openthread-handle could be used to suspend, resume or terminate a thread that the open-handle refers to.
       ''' </returns>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <remarks>
       ''' After pausing a thread, call <see cref="ResumeThread"/> function to resume the thread and close the openthread-handle.
       ''' <para></para>
       ''' To manually close an openthread-handle, call <see cref="NativeMethods.CloseHandle(IntPtr)"/> function.
       ''' </remarks>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <exception cref="Win32Exception">
       ''' </exception>
       ''' ----------------------------------------------------------------------------------------------------
       <DebuggerStepThrough>
       Public Shared Function PauseThread(threadId As Integer) As SafeAccessTokenHandle

           Const threadAccessRights As ThreadAccessRights = ThreadAccessRights.SuspendResume Or ThreadAccessRights.Terminate
           Dim safeOpenThreadHandle As SafeAccessTokenHandle = NativeMethods.OpenThread(threadAccessRights, True, CUInt(threadId))
           Dim win32Err As Integer = Marshal.GetLastWin32Error()

           If safeOpenThreadHandle.IsInvalid() Then
               Throw New Win32Exception(win32Err)
           Else
               NativeMethods.SuspendThread64(safeOpenThreadHandle)
               Return safeOpenThreadHandle
           End If

       End Function

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Pauses the execution of the specified thread.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <example> This is a code example.
       ''' <code>
       ''' Dim thread As ProcessThread = Process.GetProcessesByName("cmd.exe").FirstOrDefault.Threads(0)
       ''' Dim safeOpenThreadHandle As SafeAccessTokenHandle = PauseThread(thread)
       '''
       ''' ' ResumeThread(openThreadHandle)
       ''' </code>
       ''' </example>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <param name="thread">
       ''' The thread.
       ''' </param>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <returns>
       ''' The return value is an openthread-handle to the thread handle.
       ''' <para></para>
       ''' An openthread-handle could be used to suspend, resume or terminate a thread that the open-handle refers to.
       ''' </returns>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <remarks>
       ''' After pausing a thread, call <see cref="ResumeThread"/> function to resume the thread and close the openthread-handle.
       ''' <para></para>
       ''' To manually close an openthread-handle, call <see cref="NativeMethods.CloseHandle(SafeHandle)"/> function.
       ''' </remarks>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <exception cref="Win32Exception">
       ''' </exception>
       ''' ----------------------------------------------------------------------------------------------------
       <DebuggerStepThrough>
       Public Shared Function PauseThread(thread As ProcessThread) As SafeAccessTokenHandle

           Return UIAutomationUtil.PauseThread(thread.Id)

       End Function

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Resumes the execution of the specified thread.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <param name="safeOpenThreadHandle">
       ''' An open thread handle.
       ''' <para></para>
       ''' This handle can be obtained by calling the <see cref="UIAutomationUtil.PauseThread"/>
       ''' or <see cref="NativeMethods.OpenThread(ThreadAccessRights, Boolean, UInteger)"/> functions.
       ''' </param>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <exception cref="Win32Exception">
       ''' </exception>
       ''' ----------------------------------------------------------------------------------------------------
       <DebuggerStepThrough>
       Public Shared Sub ResumeThread(safeOpenThreadHandle As SafeAccessTokenHandle)

           Dim result As Integer
           Dim win32Err As Integer

           If safeOpenThreadHandle.IsInvalid Then
               Throw New NullReferenceException("Handle is invalid.")
           End If

           result = NativeMethods.ResumeThread(safeOpenThreadHandle)
           win32Err = Marshal.GetLastWin32Error()

           If (result = -1) Then
               Throw New Win32Exception(win32Err)
           End If

       End Sub

   End Class

End Namespace


NativeMethods.vb

Código (vbnet) [Seleccionar] Expandir

Imports Microsoft.Win32.SafeHandles
Imports System.Runtime.ConstrainedExecution
Imports System.Security

Imports DevCase.Interop.Unmanaged.Win32.Enums

Namespace DevCase.Interop.Unmanaged.Win32

   ''' ----------------------------------------------------------------------------------------------------
   ''' <summary>
   ''' Platform Invocation methods (P/Invoke), access unmanaged code.
   ''' <para></para>
   ''' This class does not suppress stack walks for unmanaged code permission.
   ''' <see cref="Security.SuppressUnmanagedCodeSecurityAttribute"/> must not be applied to this class.
   ''' <para></para>
   ''' This class is for methods that can be used anywhere because a stack walk will be performed.
   ''' </summary>
   ''' ----------------------------------------------------------------------------------------------------
   ''' <remarks>
   ''' <see href="https://msdn.microsoft.com/en-us/library/ms182161.aspx"/>
   ''' </remarks>
   ''' ----------------------------------------------------------------------------------------------------
   Friend NotInheritable Class NativeMethods

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Prevents a default instance of the <see cref="NativeMethods"/> class from being created.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       <DebuggerNonUserCode>
       Private Sub New()
       End Sub

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Closes the specified object handle.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <remarks>
       ''' <see href="https://msdn.microsoft.com/es-es/library/windows/desktop/ms724211%28v=vs.85%29.aspx"/>
       ''' </remarks>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <param name="hObject">
       ''' The handle to the object being closed.
       ''' </param>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <returns>
       ''' If the function succeeds, the return value is <see langword="True"/>.
       ''' <para></para>
       ''' If the function fails, the return value is <see langword="False"/>.
       ''' <para></para>
       ''' To get extended error information, call <see cref="Marshal.GetLastWin32Error"/>.
       ''' </returns>
       ''' ----------------------------------------------------------------------------------------------------
       <SuppressUnmanagedCodeSecurity>
       <ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)>
       <DllImport("Kernel32.dll", SetLastError:=True)>
       Friend Shared Function CloseHandle(hObject As SafeHandle
       ) As <MarshalAs(UnmanagedType.Bool)> Boolean
       End Function

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Opens an existing thread object.
       ''' <para></para>
       ''' When done, don't forget to call <see cref="NativeMethods.CloseHandle"/> function.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <remarks>
       ''' <see href="https://msdn.microsoft.com/en-us/library/windows/desktop/ms684335%28v=vs.85%29.aspx"/>
       ''' </remarks>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <param name="desiredAccess">
       ''' The access to the thread object.
       ''' <para></para>
       ''' This access right is checked against the security descriptor for the thread.
       ''' </param>
       '''
       ''' <param name="inheritHandle">
       ''' If this value is <see langword="True"/>, processes created by this process will inherit the handle.
       ''' <para></para>
       ''' Otherwise, the processes do not inherit this handle.
       ''' </param>
       '''
       ''' <param name="threadId">
       ''' The identifier of the thread to be opened.
       ''' </param>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <returns>
       ''' If the function succeeds, the return value is an open handle to the specified thread.
       ''' <para></para>
       ''' If the function fails, the return value is <see cref="IntPtr.Zero"/>.
       ''' <para></para>
       ''' To get extended error information, call <see cref="Marshal.GetLastWin32Error"/>.
       ''' </returns>
       ''' ----------------------------------------------------------------------------------------------------
       <DllImport("Kernel32.dll", SetLastError:=True)>
       Friend Shared Function OpenThread(desiredAccess As ThreadAccessRights,
         <MarshalAs(UnmanagedType.Bool)> inheritHandle As Boolean,
                                         threadId As UInteger
       ) As SafeAccessTokenHandle
       End Function

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Decrements a thread's suspend count.
       ''' <para></para>
       ''' When the suspend count is decremented to zero, the execution of the thread is resumed.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <remarks>
       ''' <see href="https://msdn.microsoft.com/en-us/library/windows/desktop/ms685086%28v=vs.85%29.aspx"/>
       ''' </remarks>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <param name="hThread">
       ''' A handle to the thread to be resumed.
       ''' <para></para>
       ''' The handle must have the <see cref="ThreadAccessRights.SuspendResume"/> access right
       ''' </param>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <returns>
       ''' If the function succeeds, the return value is the thread's previous suspend count; otherwise, it is <c>-1</c>.
       ''' <para></para>
       ''' To get extended error information, call <see cref="Marshal.GetLastWin32Error"/>.
       ''' </returns>
       ''' ----------------------------------------------------------------------------------------------------
       <DllImport("Kernel32.dll", SetLastError:=True)>
       Friend Shared Function ResumeThread(hThread As SafeAccessTokenHandle
       ) As Integer
       End Function

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Suspends the specified 32-Bit thread.
       ''' <para></para>
       ''' A 32-bit application can suspend a 64-Bit thread using the <see cref="NativeMethods.SuspendThread64"/> function.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <remarks>
       ''' <see href="https://msdn.microsoft.com/en-us/library/windows/desktop/ms687400%28v=vs.85%29.aspx"/>
       ''' </remarks>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <param name="hThread">
       ''' A handle to the thread that is to be suspended.
       ''' <para></para>
       ''' The handle must have the <see cref="ThreadAccessRights.SuspendResume"/> access right
       ''' </param>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <returns>
       ''' If the function succeeds, the return value is the thread's previous suspend count; otherwise, it is <c>-1</c>.
       ''' <para></para>
       ''' To get extended error information, call <see cref="Marshal.GetLastWin32Error"/>.
       ''' </returns>
       ''' ----------------------------------------------------------------------------------------------------
       <DllImport("Kernel32.dll", EntryPoint:="Wow64SuspendThread", SetLastError:=True)>
       Friend Shared Function SuspendThread32(hThread As SafeAccessTokenHandle
       ) As Integer
       End Function

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Suspends the specified 64-Bit thread.
       ''' <para></para>
       ''' A 64-bit application can suspend a 32-Bit thread using the <see cref="NativeMethods.SuspendThread32"/> function.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <remarks>
       ''' <see href="https://msdn.microsoft.com/en-us/library/windows/desktop/ms686345%28v=vs.85%29.aspx"/>
       ''' </remarks>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <param name="hThread">
       ''' A handle to the thread that is to be suspended.
       ''' <para></para>
       ''' The handle must have the <see cref="ThreadAccessRights.SuspendResume"/> access right
       ''' </param>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <returns>
       ''' If the function succeeds, the return value is the thread's previous suspend count; otherwise, it is <c>-1</c>.
       ''' <para></para>
       ''' To get extended error information, call <see cref="Marshal.GetLastWin32Error"/>.
       ''' </returns>
       ''' ----------------------------------------------------------------------------------------------------
       <DllImport("Kernel32.dll", EntryPoint:="SuspendThread", SetLastError:=True)>
       Friend Shared Function SuspendThread64(hThread As SafeAccessTokenHandle
       ) As Integer
       End Function

   End Class

End Namespace

ThreadAccessRights .vb

Código (vbnet) [Seleccionar] Expandir

#Region " Thread Access-Rights "

Namespace DevCase.Interop.Unmanaged.Win32.Enums

   ''' ----------------------------------------------------------------------------------------------------
   ''' <summary>
   ''' Specifies thread-specific access rights.
   ''' </summary>
   ''' ----------------------------------------------------------------------------------------------------
   ''' <remarks>
   ''' <see href="https://msdn.microsoft.com/en-us/library/windows/desktop/ms686769%28v=vs.85%29.aspx"/>
   ''' </remarks>
   ''' ----------------------------------------------------------------------------------------------------
   <Flags>
   Public Enum ThreadAccessRights As Integer

       ''' <summary>
       ''' Required to delete the object.
       ''' </summary>
       Delete = CInt(StandardAccessRights.Delete)

       ''' <summary>
       ''' Required to read information in the security descriptor for the object, not including the information in the <c>SACL</c>.
       ''' <para></para>
       ''' To read or write the <c>SACL</c>, you must request the <c>ACCESS_SYSTEM_SECURITY</c> access right.
       ''' </summary>
       ReadControl = CInt(StandardAccessRights.ReadControl)

       ''' <summary>
       ''' Required to modify the <c>DACL</c> in the security descriptor for the object.
       ''' </summary>
       WriteDac = CInt(StandardAccessRights.WriteDac)

       ''' <summary>
       ''' Required to change the owner in the security descriptor for the object.
       ''' </summary>
       WriteOwner = CInt(StandardAccessRights.WriteOwner)

       ''' <summary>
       ''' The right to use the object for synchronization.
       ''' <para></para>
       ''' This enables a thread to wait until the object is in the signaled state.
       ''' </summary>
       Synchronize = CInt(StandardAccessRights.Synchronize)

       ''' <summary>
       ''' Required to terminate a thread
       ''' using <see cref="NativeMethods.TerminateThread"/> function.
       ''' </summary>
       Terminate = &H1

       ''' <summary>
       ''' Required to suspend or resume a thread
       ''' using <see cref="NativeMethods.SuspendThread32"/>,
       ''' <see cref="NativeMethods.SuspendThread64"/> and <see cref="NativeMethods.ResumeThread"/> functions.
       ''' </summary>
       SuspendResume = &H2

       ''' <summary>
       ''' Required to read the context of a thread using <c>GetThreadContext</c> function.
       ''' </summary>
       GetContext = &H8

       ''' <summary>
       ''' Required to write the context of a thread using <c>SetThreadContext</c> function.
       ''' </summary>
       SetContext = &H10

       ''' <summary>
       ''' Required to set certain information in the thread object.
       ''' </summary>
       SetInformation = &H20

       ''' <summary>
       ''' Required to read certain information from the thread object,
       ''' such as the exit code using <see cref="NativeMethods.GetExitCodeThread"/> function.
       ''' </summary>
       QueryInformation = &H40

       ''' <summary>
       ''' Required to set the impersonation token for a thread
       ''' using <c>SetThreadToken</c> function.
       ''' </summary>
       SetThreadToken = &H80

       ''' <summary>
       ''' Required to use a thread's security information directly without calling it by using a
       ''' communication mechanism that provides impersonation services.
       ''' </summary>
       Impersonate = &H100

       ''' <summary>
       ''' Required for a server thread that impersonates a client.
       ''' </summary>
       DirectImpersonation = &H200

       ''' <summary>
       ''' Required to set certain information in the thread object.
       ''' <para></para>
       ''' A handle that has the <see cref="ThreadAccessRights.SetInformation"/> access right
       ''' is automatically granted <see cref="ThreadAccessRights.SetLimitedInformation"/>.
       ''' </summary>
       SetLimitedInformation = &H400

       ''' <summary>
       ''' Required to read certain information from the thread objects.
       ''' <para></para>
       ''' A handle that has the <see cref="ThreadAccessRights.QueryInformation"/> access right
       ''' is automatically granted <see cref="ThreadAccessRights.QueryLimitedInformation"/>.
       ''' </summary>
       QueryLimitedInformation = &H800

   End Enum

End Namespace

#End Region

StandardAccessRights .vb

Código (vbnet) [Seleccionar] Expandir

#Region " Standard Access Rights "

Namespace DevCase.Interop.Unmanaged.Win32.Enums

   ''' ----------------------------------------------------------------------------------------------------
   ''' <summary>
   ''' Specifies the access rights that correspond to operations specific to a standard object type.
   ''' </summary>
   ''' ----------------------------------------------------------------------------------------------------
   ''' <remarks>
   ''' <see href="https://msdn.microsoft.com/en-us/library/windows/desktop/aa379607(v=vs.85).aspx"/>
   ''' </remarks>
   ''' ----------------------------------------------------------------------------------------------------
   <Flags>
   Public Enum StandardAccessRights As UInteger

       ''' <summary>
       ''' The right to delete the object.
       ''' </summary>
       Delete = &H10000

       ''' <summary>
       ''' The right to read the information in the object's security descriptor,
       ''' not including the information in the system access control list (SACL).
       ''' </summary>
       ReadControl = &H20000

       ''' <summary>
       ''' The right to modify the discretionary access control list (DACL) in the object's security descriptor.
       ''' </summary>
       WriteDac = &H40000

       ''' <summary>
       ''' The right to change the owner in the object's security descriptor.
       ''' </summary>
       WriteOwner = &H80000

       ''' <summary>
       ''' The right to use the object for synchronization.
       ''' <para></para>
       ''' This enables a thread to wait until the object is in the signaled state.
       ''' <para></para>
       ''' Some object types do not support this access right.
       ''' </summary>
       Synchronize = &H100000

       ''' <summary>
       ''' Combines <see cref="StandardAccessRights.Delete"/>,
       ''' <see cref="StandardAccessRights.ReadControl"/>, <see cref="StandardAccessRights.WriteDac"/>, and
       ''' <see cref="StandardAccessRights.WriteOwner"/> access.
       ''' </summary>
       StandardRightsRequired = &HF0000

       ''' <summary>
       ''' Same as <see cref="StandardAccessRights.ReadControl"/>.
       ''' </summary>
       StandardRightsRead = StandardAccessRights.ReadControl

       ''' <summary>
       ''' Same as <see cref="StandardAccessRights.ReadControl"/>.
       ''' </summary>
       StandardRightsWrite = StandardAccessRights.ReadControl

       ''' <summary>
       ''' Same as <see cref="StandardAccessRights.ReadControl"/>.
       ''' </summary>
       StandardRightsExecute = StandardAccessRights.ReadControl

       ''' <summary>
       ''' Combines <see cref="StandardAccessRights.Delete"/>,
       ''' <see cref="StandardAccessRights.ReadControl"/>, <see cref="StandardAccessRights.WriteDac"/>,
       ''' <see cref="StandardAccessRights.WriteOwner"/>, and <see cref="StandardAccessRights.Synchronize"/> access.
       ''' </summary>
       StandardRightsAll = &H1F0000

   End Enum

End Namespace

#End Region


PauseProcessObject.vb

[Eleкtro]

PauseProcessObject.vb

Código (vbnet) [Seleccionar] Expandir

Imports DevCase.Core.IPC.Tools
Imports Microsoft.Win32.SafeHandles

Namespace DevCase.Core.IPC

   ''' ----------------------------------------------------------------------------------------------------
   ''' <summary>
   ''' Represents the return value as a result of a call to
   ''' <see cref="UIAutomationUtil.PauseProcess(Integer)"/> and
   ''' <see cref="UIAutomationUtil.PauseThread"/> functions.
   ''' </summary>
   ''' ----------------------------------------------------------------------------------------------------
   Public NotInheritable Class PauseProcessObject : Implements IDisposable

#Region " Properties "

       ''' <summary>
       ''' Gets the process id. (PID)
       ''' </summary>
       <Browsable(True)>
       Public ReadOnly Property PID As Integer

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' A collection of openthread-handles that points to the suspended thread handles of the process.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       <Browsable(False)>
       Friend handles_ As Collection(Of SafeAccessTokenHandle)

#End Region

#Region " Constructors "

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Prevents a default instance of the <see cref="UIAutomationUtil"/> class from being created.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       <DebuggerNonUserCode>
       Private Sub New()
       End Sub

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Initializes a new instance of the <see cref="PauseProcessObject"/> class.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       <Browsable(False)>
       <DebuggerStepThrough>
       Friend Sub New(pid As Integer)
           Me.PID = pid
           Me.handles_ = New Collection(Of SafeAccessTokenHandle)
       End Sub

#End Region

#Region " IDisposable Implementation "

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Flag to detect redundant calls when disposing.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       Private isDisposed As Boolean = False

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Releases all the resources used by this instance.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       <DebuggerStepThrough>
       Public Sub Dispose() Implements IDisposable.Dispose
           Me.Dispose(isDisposing:=True)
           GC.SuppressFinalize(Me)
       End Sub

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <param name="isDisposing">
       ''' <see langword="True"/>  to release both managed and unmanaged resources;
       ''' <see langword="False"/> to release only unmanaged resources.
       ''' </param>
       ''' ----------------------------------------------------------------------------------------------------
       <DebuggerStepThrough>
       Private Sub Dispose(isDisposing As Boolean)
           If (Not Me.isDisposed) AndAlso (isDisposing) Then
               For Each item As SafeAccessTokenHandle In Me.handles_
                   If Not item?.IsClosed Then
                       Try : item.Close() : Catch : End Try
                   End If
               Next
               Me.handles_.Clear()
               Me.handles_ = Nothing
           End If
           Me.isDisposed = True
       End Sub

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Allows an object to try to free resources and perform other cleanup operations before it is reclaimed by garbage collection.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       Protected Overrides Sub Finalize()
           Me.Dispose(False)
           MyBase.Finalize()
       End Sub

#End Region

   End Class

End Namespace

Modo de empleo:

Código (vbnet) [Seleccionar] Expandir

Dim pid As Integer = Process.GetProcessesByName("hearthstone").Single().Id

' Pause the process.
Console.WriteLine($"Pausing process with PID: {pid}")
Using ppo As PauseProcessObject = UIAutomationUtil.PauseProcess(pid)
   ' Wait 5 seconds to let you observe that the process is paused...
   Console.WriteLine($"Sleeping for 5 seconds...")
   Thread.Sleep(5000)

   ' Resume the process.
   Console.WriteLine($"Resuming process with PID: {ppo.PID}")
   UIAutomationUtil.ResumeProcess(ppo)
End Using

Saludos.

[**Aincrad**]

¿Pero lo estás jugando a pantalla completa dedicada, o ventana sin bordes?...

De todas formas si ese problema es tal y como dices, entonces lo más simple para prevenirlo sería desarrollar un cheat sin interfaz gráfica y así evitar el problema. Si no puedes vencer a tu enemigo, acomódate a él. xD

También puedes probar a utilizar la función de Windows 'SetWindowLongPtr' sobre la ventana de tu aplicación:
https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-setwindowlongptra

con la combinación de estilos extendidos de ventana: WS_EX_TOPMOST + WS_EX_NOACTIVATE:
https://docs.microsoft.com/en-us/windows/win32/winmsg/extended-window-styles

Teoricamente con esa combinación de estilos puedes superponer una ventana sobre las demás (top most) sin activar el foco de entrada de dicha ventana.

Gracias bro, como siempre este es el único lugar donde siempre logro resolver completamente mis dudas gracias ti.

Como siempre tu conocimiento en .Net me dejaron boca abierta.... he quedado como que wtf.

Has dado justo en el clavo. justo lo que necesitaba.  Así lo resolví :

Funciona Perfectamente. Se puede interactuar con el cheat encima del juego y no perder el foco de la ventana del juego.

Código (vbnet) [Seleccionar] Expandir

#Region " No Windows Focus "

   Protected Overrides ReadOnly Property ShowWithoutActivation As Boolean
       Get
           Return True
       End Get
   End Property

   Private Const WS_EX_TOPMOST As Integer = &H8

   Private Const WS_THICKFRAME As Integer = &H40000
   Private Const WS_CHILD As Integer = &H40000000
   Private Const WS_EX_NOACTIVATE As Integer = &H8000000
   Private Const WS_EX_TOOLWINDOW As Integer = &H80

   Protected Overrides ReadOnly Property CreateParams As CreateParams
       Get
           Dim createParamsA As CreateParams = MyBase.CreateParams
           createParamsA.ExStyle = createParamsA.ExStyle Or WS_EX_TOPMOST Or WS_EX_NOACTIVATE Or WS_EX_TOOLWINDOW
           Return createParamsA
       End Get
   End Property

#End Region

No se a que clase te refieres, pero esto te debería servir para suspender y reanudar el proceso:

https://foro.elhacker.net/net_c_vbnet_asp/libreria_de_snippets_para_vbnet_compartan_aqui_sus_snippets-t378770.0.html;msg1859297#msg1859297

Aquí te dejo una actualización del código:

Por alguna razon tu clase no me funcionaba, pero esta actualizacion de codigo fuciona perfectamente. lo malo es q el juego se desconecta del servidor. y pos pausar el proceso tampoco funciona.

Este era mi actual codigo para pausar y reanudar procesos :

ProcessPausator.vb

Código (vbnet) [Seleccionar] Expandir

Public Class ProcessPausator

#Region " Pinvoke "

   Public Declare Function OpenThread Lib "kernel32.dll" (ByVal dwDesiredAccess As ThreadAccess, ByVal bInheritHandle As Boolean, ByVal dwThreadId As UInteger) As IntPtr
   Public Declare Function SuspendThread Lib "kernel32.dll" (ByVal hThread As IntPtr) As UInteger
   Public Declare Function ResumeThread Lib "kernel32.dll" (ByVal hThread As IntPtr) As UInteger
   Public Declare Function CloseHandle Lib "kernel32.dll" (ByVal hHandle As IntPtr) As Boolean

#End Region

#Region " Enum "

   Public Enum ThreadAccess As Integer
       TERMINATE = (&H1)
       SUSPEND_RESUME = (&H2)
       GET_CONTEXT = (&H8)
       SET_CONTEXT = (&H10)
       SET_INFORMATION = (&H20)
       QUERY_INFORMATION = (&H40)
       SET_THREAD_TOKEN = (&H80)
       IMPERSONATE = (&H100)
       DIRECT_IMPERSONATION = (&H200)
   End Enum

#End Region

   Public Shared Function PauseThread(ByRef Process_Name As String) As Boolean

       If Process_Name.ToLower.EndsWith(".exe") Then Process_Name = Process_Name.Substring(0, Process_Name.Length - 4)

       Dim proc() As Process = Process.GetProcessesByName(Process_Name)

       If Not proc.Length = 0 Then
           SuspendProcess(proc(0))
           Return True
       End If
       Return False
   End Function

   Public Shared Function ResumeThread(ByRef Process_Name As String) As Boolean

       If Process_Name.ToLower.EndsWith(".exe") Then Process_Name = Process_Name.Substring(0, Process_Name.Length - 4)

       Dim proc() As Process = Process.GetProcessesByName(Process_Name)

       If Not proc.Length = 0 Then
           ResumeProcess(proc(0))
           Return True
       End If
       Return False
   End Function

   Private Shared Sub SuspendProcess(ByVal process As System.Diagnostics.Process)
       For Each t As ProcessThread In process.Threads
           Dim th As IntPtr = OpenThread(ThreadAccess.SUSPEND_RESUME, False, t.Id)
           If Not th = IntPtr.Zero Then
               SuspendThread(th)
               CloseHandle(th)
           End If
       Next
   End Sub

   Private Shared Sub ResumeProcess(ByVal process As System.Diagnostics.Process)
       For Each t As ProcessThread In process.Threads
           Dim th As IntPtr = OpenThread(ThreadAccess.SUSPEND_RESUME, False, t.Id)
           If Not th = IntPtr.Zero Then
               ResumeThread(th)
               CloseHandle(th)
           End If
       Next
   End Sub

End Class


No es mucho pero es trabajo honesto .... pero si lo comparo a tu code.....

PD: Que opinas de mi mejor proyecto , que he hecho hasta ahora? .

es mi obra maestra : https://github.com/DestroyerDarkNess/DestroyerProtection

[Eleкtro]

Por alguna razon tu clase no me funcionaba, pero esta actualizacion de codigo fuciona perfectamente.

Si, es que... pff, ese post es del año 2013, creo que por aquél entonces solo llevaba 1 año o quizás menos con .NET, algún fallo tendrá ese código si dices que no funciona correctamente (aunque yo todo lo que publiqué también lo testeé).

No es mucho pero es trabajo honesto .... pero si lo comparo a tu code.....

Coño, lo mio también es trabajo honesto, literalmente todo el código que te he mostrado lo hice hoy para ayudarte xD (vale que aparte intento comercializar la libreria, pero eso es otro tema)

PD: Que opinas de mi mejor proyecto , que he hecho hasta ahora? .

es mi obra maestra : https://github.com/DestroyerDarkNess/DestroyerProtection

Bueno, aunque también he curioseado con metodologías anti-debugger y anti-virtualization y tengo hechas algunas implementaciones en .NET (bastante básicas), lo cierto es que la protección de código / ingeniería inversa no es mi especialidad así que lo que yo pueda opinar no haría suficiente mérito a tu labor.

Leyendo el Readme.md del repositorio se nota que es un trabajo bastante amplio, lleno de características. Me ha parecido curiosa la detección de DnSpy, pero te olvidas de un par más de decompiladores bastante populares que quizás quieras añadirlos a las detecciones: ILSpy, SAE (Simple Assembly Explorer) y .NET Reflector.
¿Y que hay de otras máquinas virtuales diferentes a VMWare y VirtualPC?, QEMU se utiliza mucho también. Adicionálmente a esto veo que faltaría protección anti-debug remota para bloquear el acceso de paquetes de red a programas como Fiddler, Wireshark o WPE Pro.

Solo son ideas que lanzo. Gran trabajo.

Saludos!

[**Aincrad**]

Coño, lo mio también es trabajo honesto, literalmente todo el código que te he mostrado lo hice hoy para ayudarte xD (vale que aparte intento comercializar la libreria, pero eso es otro tema)

Siempre ayudas de verdad. y aquellos testamentos que me ponías me ayudaron bastante.  deberían regresarte el Moderador.... como mínimo.

Leyendo el Readme.md del repositorio se nota que es un trabajo bastante amplio, lleno de características. Me ha parecido curiosa la detección de DnSpy

La deteccion es realmente sencilla. el Dnspy y el D4dot crean carpetas en Appdata-local. para guardar su configuracion , solo reviso si la carpeta existe. y listo. sin contar la deteccion de los procesos que hago ...

pero te olvidas de un par más de decompiladores bastante populares que quizás quieras añadirlos a las detecciones: ILSpy, SAE (Simple Assembly Explorer) y .NET Reflector.
¿Y que hay de otras máquinas virtuales diferentes a VMWare y VirtualPC?, QEMU se utiliza mucho también. Adicionálmente a esto veo que faltaría protección anti-debug remota para bloquear el acceso de paquetes de red a programas como Fiddler, Wireshark o WPE Pro.

Intentare agregarlos, aunque siempre la mejor protección para .Net, en mi experiencia es Obfuzcar bien el código . de manera de dejarlo completamente Irreconocible.

Ya lo otro seria pasarle un buen Packer. como por ejemplo Enigma o VMProtect.

básicamente la mayor parte del proyecto es gracias a esta guia :

An Anti-Reverse Engineering Guide

[tincopasan]

había pensado en hacerle un gancho a SetWindowsHookEx  y ver un enlace a WH_CALLWNDPROC para ver de manejar WM_SETFOCUS o WM_KILLFOCUS . Igual no es algo que muera por hacer, con respecto a.net que sea muy bueno el protector, porque es un lenguaje muy facil de aplicarle ingeniería, de hecho lo odio porque se supone de pago y es facil de robar los códigos.