Mensajes

Tienes que especificar el juego y versión, incluso de ser posible subir una muestra para analizarla.

En mi caso tengo varios archivos .cdt pero corresponden a plantillas para Corel Draw.

Yo he localizado (googleando por Internet) otros archivos de extensión CDT que pertenecen a roms de Amstrad-CPC, si es que... a saber.

¿y cómo sabes que es algo para descompilar?

Supongo que será por intuición. Sin tener datos más conclusos solo podemos confiar en la intuición del usuario. Al menos en los video juegos actuales para PC generalmente se puede intuir de manera muy facil que un archivo está empacado por su tamaño (indiferentemente de si previamente ya conoces la extensión del archivo y sabes que se trata de un archivo empacado como por ejemplo los conocidos archivos de assets de Unity), y quizás también por su nombre y ubicación dentro del directorio del juego.

Por poner un ejemplo aleatorio: en el juego 'Final Fantasy XIII' el archivo 'white_z000u_img.win32.bin' que tiene una extensión de archivo genérica, pesa más de un gigabyte y está dentro de una carpeta llamada "zone", se intuye que podría contiene imágenes / texturas de lo que los desarrolladores denominarán "zona 0" dentro del video juego... puesto que además hay muchos más archivos como ese, de menor tamaño y haciendo referencia a otras "zonas"

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

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!

No me suena la extensión CDT, perfectamente podría ser un formato privativo... y en ese caso olvídate de hallar una herramienta para desempacar el contenido.

Saludos!

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.

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

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

Indicios de vida microbana en Venus...

Ahora cobra algo de sentido ese loco y surrealista proyecto de la NASA de hace algunos años (2014):

-> La NASA quiere colonizar Venus con una ciudad flotante
-> La NASA se plantea la posibilidad de enviar humanos a Venus, para vivir en dirigibles flotantes
-> Este es el plan de la NASA para explorar y colonizar Venus
-> High Altitude Venus Operational Concept (HAVOC)

[Eleкtro]

Elektro, con LosslessCut (https://mifi.no/losslesscut/) puedes cortar esas escenas sin tener que reencodear todo el video.

Lo he usado y hace un buen trabajo (tienes que bajarte el ffmpeg)

Saludos!

MkcSys, tu intención es buena y te lo agradezco, pero no es un método viable. Te explico, si tuviera que editar los videos lo haría, pero es que estamos hablando de 153 capítulos, y practicamente todos ellos (o la inmensa mayoría) tienen escenas en japonés, y yo no se en que partes del video están, logicamente no voy a ponerme a ver la serie completa (o en su defecto leerme todos los subítulos forzados) cientos de horas para encontrar cada escena e ir editando cada video... es algo inviable.

Eleкtro 4:3 imagen original si, pero de una resolución ridículamente pequeña, y con una calidad horrible. Comparada con la calidad que se ve en el remasterizado a 1080... ¡¡¡puff!!!. Como bien dices yo e visto la serie original, y eso creo da a mi opinión mas valor. En cualquier caso si fuera otro el que dijera lo que dices pues casi que lo consideraría, pero como te conozco en el sentido de que se que lo raro y tiquismiquis que eres a la hora de buscar problemas donde no les hay (no es el primer anime al que se lo haces) pues eso me lleva a reafirmarme mas aun. Todos esos supuestos problemas que dices que tiene para mi no lo son, solo están en tu cabeza. No es la primera vez que me lo as demostrado. Así que lo siento pero SÍ, si que creo que es mejor la remasterización, pero ademas con gran diferencia.
Saludos...

Songoku

Yo también vi la serie en mi infancia, sabes que tengo una edad.

Y bueno, me estás ofendiendo bastante pero por más que insistas con aquel otro anime no voy a ponerme a discutir contigo explicándote que lo que tu llamas "tiquismiquismo" o "cosas raras" se llama tener los sentidos agudizados y ser algo exigente, y si un anime tiene un HORRIBLE efecto de luz blanquecina en todas las escenas que no pega ni con cola y que es muy molesto, pues lo digo, yo no trago ese efecto, me resulta muy molesto para la vista, igual que en los años 2000 se hacia un abuso desmedido de los filtros de colores en las películas, y no me gusta ver una película en color sepia, pero a mucha gente le da igual y algunos ni son capaces de notarlo.
En fin, y que digas que los problemas están en mi cabeza... no, los problemas son reales y te los he explicado punto por punto en mi comentario anterior en lo que conlleva la transición de 4:3 a 16:9, que tampoco es que haga falta explicarlo por que lo sabes de sobra.

Por mucho 16:9 y mayor resolución que sea, la fuente de la imagen es LA MISMA a 4:3, así que a mayor resolución no significa mejor nivel de detalle, de hecho el nivel de detalle, exceptuando que los colores son más vivos, es mucho peor (ya expliqué punto por punto por que es peor) al ser un reescalado.

Y no puede ser de otra forma por que por aquella época no se digitalizaban los dibujos de la misma manera en que se hace hoy en día. Logicamente en la remasterización hay un gran trabajo de edición digitalizada sobre la imagen original en 4:3, pero basicamente estiran la imagen y la recortan, la recolorean digitalmente y ale, no se que mejora ves tu en eso, yo prefiero mil veces poder ver todos los detalles del metraje, a perderlos por la conversión de la relación de aspecto, y el problema del pincel gordo negro que eso es con lo que no puedo tragar, se ve horrible.

[youtube=640,360]https://www.youtube.com/watch?v=mCmUvRpKJ4c[/youtube]

Saludos.

Se podría hacer  un suboro de noticias o un subforo del foro libre para "noticias" off-topic, es una idea o una posibilidad.

Ya puestos mejor cataloguemos todas las noticias por categorias en distintos subforos: noticias científicas, informáticas, políticas, deportes, coronavirus... si no lo hacen así estarían discriminando al resto de noticias...

MALA IDEA

esto no s un protal de noticias como el abc.es donde todo está perfectamente organizado. En el foro libre están bien como están todas las noticias no-informáticas, puesto que ya es el lugar que corresponde para publicar temas "off-topic" como su propio nombre indica. Pero bueno, que me importará a mi lo que decidan hacer y como lo quieran organizar, si despues de todo lo que me hicieron yo ya solo me paso por aquí para estar un rato en el foro libre y opinar en algunos temas, abrir un par de temas por interés propio, y poco o nada más.

"Tema serio" dice... el primer mensaje en el foro de un individuo que tiene el síndrome de Sherlock Holmes. (Peligro, troll a la vista.)

Y digo yo, ¿PARA QUÉ ESTÁ LA POLICIA DE VERDAD?, ellos son los que montan operativos y tienen policias incubiertos en chats para cazar delincuentes, ya sea pedófilos o de toda índole. Lo vi en un documental. De todas formas creo que siempre pueden ayudar a la Policia proporcionándole datos de posibles sospechosos para que la Policia lo pueda investigar, de lo contrario mejor déjenles hacer su trabajo, que para eso está la Policia.

Gracias, pero como ya te dicho yo también tengo la saga Z y la GT. La Súper... ahora que lo dices creo que a llegado la hora de bajarla, tengo algún enlace por ahí de mega que antes aun no estaban todos los capítulos, pero seguro que ya estarán todos así que la bajaré.

Y bueno como ya te dicho en mas de una ocasión tienes unos gustos muy raros, por no decir muy malos. Osea decir que se ve mejor la serie original en 4:3 a baja resolución que una remasterizada a 1080p es ridículo en mi opinión. Para mi esta ultima se ve mucho mejor, y todos esos supuestos defectos que tu la encuentras me parece que solo están en tu cabeza. No es el primer anime al que le buscas problemas donde no les hay, por lo que no me extraña nada que digas esas cosas. Pero en fin cada loco con su tema, aunque eso si no me pareces un gran otaku jajajaja.
Suerte en tu búsqueda y saludos...

Songoku


P.D ya se que no te gusta para nada, pero aun así si al final te decides a mi no me cuesta nada pasarte mi dragonball en 1080. Solo hazme llegar algún medio de almacenamiento que la pueda contener y te la copio. Lo que no puedo como ya dije es pasártela por la red debido a mi mala conexión. O si esperas unos meses se supone que para últimos de este año o primeros del que viene llegará aquí la fibra óptica.

4:3 = Imagen original en su totalidad, no hay mucho más que decir.

16:9 = imagen estirada y recortada de todos los laterales, arriba abajo izquierda y derecha, pierdes la visión de detalles de los escenarios y la imagen en general se ve como más "grande" (por que está estirada)... es una sensación anómala y bastante incómoda, y el pincel negro, el que utilizan para dibujar los contornos de los personajes y de los objetos y de practicamente todo es bastante más gordo (supongo que por haber estitrado la imagen) y ese pincel queda HORRIBLE si comparas la misma imagen a 4:3 con la imagen a 16:9, insisto en que los personajes parecen cagarros negros, sobre todo cuando están lejos en el horirzonte, no se les distingue la cara ni nada, lo que por supuesto no ocurre con la serie a 4:3 original, el pincel negro es más fino y se aprecia mucho mejor TODO y cada uno de los detalles de cada fotograma, a pesar de tener una resolución menor.

Si esto para ti son "gustos raros", pues perfecto, yo opino lo mismo de quien con cierta edad haya tenido la oportunidad de ver la serie en su formato original a 4:3, y aun así prefiera estas "remasterizaciones" a 1080p, donde se pierden detalles, todo se vuelve más grande de forma anómala y los contornos negros demasiado gruesos hace que no se distingan a los personajes cuando están a lo lejos.

Saludos