Mensajes

como siempre gracias elektro , aqui se abren caminos para continuar la investigacion y en efecto calcular el progreso de una aplicacion en este caso de comprimir y extraer requiere mas documentacion del 7z  , por otro lado implemente la barra de manera y en efecto no es nada que ver con el proceso real mas si indica al usuario que algo esta pasando, que era la razon inicial por lo que la necesitaba ya en base a esto me pondre a investigar para que sea ya de manera exacta y precisa .
Gracias nuevamente a todos los que me asistieron

No puedo tener ninguna objeción contigo, te tomas las críticas muy bien, sin embargo me jode un poco que sigas empeñado en usar 7z.exe a estas alturas (cuando se te dió una muy buena alternativa más facil de implementar), ¿no ves que todo son problemas para ti? xD. Implementar un parsing de datos de la salida (stdOut / stdErr) de 7z.exe no es que sea algo imposible ni tampoco muy complicado, pero es un coñazo, tienes que buscar la linea exacta en la salida para encontrar el dato que te sirva (el valor de porcentaje "n%") y capturarlo, con eso ya tendrías el porcentaje para tu progressbar, pero tienes que capturar muchos más datos adicionales de la salida del programa 7z.exe para controlar posibles mensajes de error en la compresión/extracción.

Si al final solo quieres usar la barra de progreso como algo simbólico para indicar que "algo está pasando" (y no se sabe cuando acabará), entonces quizás prefieras ponerla en estado indeterminado:

• ProgressBar.IsIndeterminate Property

El aspecto te quedaría más o menos como ves aquí abajo (no exactamente así, pero no he encontrado otro GIF mejor):



Saludos.

como pregunta extra como depuro el proyecto en el otro computador?

Me refería a que instalases Visual Studio en ese otro PC (junto al código fuente de tu programa) para depurar la excepción que genera tu programa en (al parecer)tiempo de inicio. Si eso no fuese posible, entonces sencillamente puedes intentar controlar todas las excepciones de tu programa en el código fuente y generar un reporte detallado con el stacktrace para que se envíe automáticamente a "X" cuenta de correo (y con eso ya tendrías algo que poder depurar en tu PC), o también puedes tratar de hacer una depuración remota en condiciones suponiendo que en ese otro PC hayas distribuido el archivo de base de datos de información de depuración de tu programa ("AIRH.pdb")...



Ale, más cositas que leer sobre todas las cosas que acabo de mencionar :

• Specify Symbol (.pdb) and Source Files in the Visual Studio Debugger - MSDN
• Remote Debugging - docs.microsoft.com
• Application.DispatcherUnhandledException Event - MSDN
• AppDomain.UnhandledException Event - MSDN
• Globally catch exceptions in a WPF application? - stackoverflow

Saludos

El tema ha sido movido a .NET.

https://foro.elhacker.net/index.php?topic=478129.0

Estos de NASA tienen unos huevazos de oro. Pues nada, otra fantasía más que se suma a las declaraciones absurdas de esta "agencia del progreso y la exploración espacial" (agencia de payasos interestelares más bien). Y seguro que la fecha con ese "69" es mera casualidad, ¿verdad?, no buscan polémica ni nada, claro, es que no podría haber sido estimada para el año 2068 o el 2070, para nada...

Lo único que buscan es estar en boca de la gente, como siempre, y recurren a trucos baratos... a todos los que se les ocurran por pésimos e infantiles que sean. Aun llegará el año 2069 y estos tios seguirán sin reconocer de forma pública la existencia de vida alienígena inteligente, vaya unos hijos de...

no entiendo estas importaciones, me la podrías explicar?

¿Que significa exactamente cuando dices "no entiendo estas importaciones"?, no sé si entiendo lo que estás preguntando exactamente. Eso son importaciones de namespaces necesarias para varios miembros en la clase que te mostré.

Saludos

[GRACIAS]

Primero que nada, GRACIAS por compartir en el foro. Ahora, vamos con las críticas constructivas:



1.

¿Has pensado que ocurrirá si el usuario ha decidido instalar Firefox o Chrome en otro directorio, o si usa una versión portable, o si no se instaló ninguno de esos dos navegadores?.

Código (vbnet) [Seleccionar] Expandir

If My.Computer.FileSystem.FileExists("C:\Program Files\Google\Chrome\Application\chrome.exe") Then
   Dim Pr As New Process
   Dim Psi As New ProcessStartInfo("C:\Program Files\Google\Chrome\Application\chrome.exe")
   Psi.Arguments = "https://www.facebook.com/salvador.osvaldo.1"
   Pr.StartInfo = Psi
   Pr.StartInfo.WindowStyle = ProcessWindowStyle.Normal
   Pr.Start()
Else
   If My.Computer.FileSystem.FileExists("C:\Program Files\Mozilla Firefox\firefox.exe") Then
       Dim Prm As New Process
       Dim Psis As New ProcessStartInfo("C:\Program Files\Mozilla Firefox\firefox.exe")
       Psis.Arguments = "https://www.facebook.com/salvador.osvaldo.1"
       Prm.StartInfo = Psis
       Prm.StartInfo.WindowStyle = ProcessWindowStyle.Normal
       Prm.Start()
   Else
       System.Diagnostics.Process.Start("https://www.facebook.com/salvador.osvaldo.1")
   End If
End If

...Como programador, es un punto positivo para ti que intentes controlar las posibles "variables" de cada configuración de sistema operativo en el que se vaya a usar tu programa, sin embargo, en esta ocasión es algo innecesario (y de todas formas, incompleto), debes dejar que ShellEx se encargue él solo de iniciar el navegador predefinido en el sistema, tú por tu parte tan solo tienes que "iniciar" la dirección url (como si se tratase de un programa).



2.

Una regla básica y universal en la programación es que se deben declarar nombres descriptivos para los miembros/métodos... ¿esto que narices es?:

Código (vbnet) [Seleccionar] Expandir

If DLLs.Items.Count > 0 Then
           run2()
           ters()
           reae()
       Else
           run2()
       End If

Me enfado solo de verlo (y vamos a obviar que además los nombres no están capitalizados en Camel-Case, eso no es tan importante, pero bueno). run2, ters, reae,... Ay Dios. Si compartes un código fuente para que los demás lo puedan analizar y aprender algo nuevo, lo mínimo que puedes hacer es facilitarles un poco la comprensión escribiendo un nombre decente (que al menos no sean 4 letras aleatorias), o dejar una linea de comentario describiendo el propósito del método...



3.

PD : La parte de RUN Tiene algunos pequeños bug al inyectar el DLL de resto funciona de maravilla. XD

Es normal que tengas "pequeños bugs" y mil cosas más, puesto que estás usando el tipo de declaraciones obsoletas de VB6 (sentencia Declare Function) en lugar de usar la plataforma de invocación de .NET Framework, Platform Invoking. Aparte, los tipos de las funciones nativas que declaraste no son portables, es decir, no son compatibles con 64 Bits... en general casi todos esos parámetros de tipo "Integer" (digo casi todos, por que depende de la definición de la función nativa) debes cambiarlos por un tipo de tamaño dinámico como es IntPtr.

Antes de distribuir un código fuente como mínimo debes pasarle un análisis de código en Visual Studio (click derecho -> "Analyze" -> "Run Code Analysis on Solution") y corregir todos los warnings que te saldrán... la mitad de ellos referentes a lo que te acabo de decir, la portabilidad.

Yo en tu lugar directamente eliminaría todo este código que tienes al principio de la clase Form1:

Código (vbnet) [Seleccionar] Expandir

Public Const PROCESS_VM_READ = &H10
Public Const TH32CS_SNAPPROCESS = &H2
Public Const MEM_COMMIT = 4096
Public Const PAGE_READWRITE = 4
Public Const PROCESS_CREATE_THREAD = (&H2)
Public Const PROCESS_VM_OPERATION = (&H8)
Public Const PROCESS_VM_WRITE = (&H20)
Dim DLLFileName As String
Public Declare Function ReadProcessMemory Lib "kernel32" ( _
ByVal hProcess As Integer, _
ByVal lpBaseAddress As Integer, _
ByVal lpBuffer As String, _
ByVal nSize As Integer, _
ByRef lpNumberOfBytesWritten As Integer) As Integer

Public Declare Function LoadLibrary Lib "kernel32" Alias "LoadLibraryA" ( _
ByVal lpLibFileName As String) As Integer

Public Declare Function VirtualAllocEx Lib "kernel32" ( _
ByVal hProcess As Integer, _
ByVal lpAddress As Integer, _
ByVal dwSize As Integer, _
ByVal flAllocationType As Integer, _
ByVal flProtect As Integer) As Integer

Public Declare Function WriteProcessMemory Lib "kernel32" ( _
ByVal hProcess As Integer, _
ByVal lpBaseAddress As Integer, _
ByVal lpBuffer As String, _
ByVal nSize As Integer, _
ByRef lpNumberOfBytesWritten As Integer) As Integer

Public Declare Function GetProcAddress Lib "kernel32" ( _
ByVal hModule As Integer, ByVal lpProcName As String) As Integer

Private Declare Function GetModuleHandle Lib "Kernel32" Alias "GetModuleHandleA" ( _
ByVal lpModuleName As String) As Integer

Public Declare Function CreateRemoteThread Lib "kernel32" ( _
ByVal hProcess As Integer, _
ByVal lpThreadAttributes As Integer, _
ByVal dwStackSize As Integer, _
ByVal lpStartAddress As Integer, _
ByVal lpParameter As Integer, _
ByVal dwCreationFlags As Integer, _
ByRef lpThreadId As Integer) As Integer

Public Declare Function OpenProcess Lib "kernel32" ( _
ByVal dwDesiredAccess As Integer, _
ByVal bInheritHandle As Integer, _
ByVal dwProcessId As Integer) As Integer

Private Declare Function FindWindow Lib "user32" Alias "FindWindowA" ( _
ByVal lpClassName As String, _
ByVal lpWindowName As String) As Integer

Private Declare Function CloseHandle Lib "kernel32" Alias "CloseHandleA" ( _
ByVal hObject As Integer) As Integer

y lo reemplazaría por esto otro (todas estas definiciones las he extraido de mi framework comercial ElektroKit):

Código (vbnet) [Seleccionar] Expandir

Imports System.Diagnostics.CodeAnalysis
Imports System.Runtime.ConstrainedExecution
Imports System.Runtime.InteropServices
Imports System.Security
Imports System.Text
Imports System.Threading
Imports Microsoft.Win32.SafeHandles

<Flags>
Friend Enum LoadLibraryFlags As UInteger
   DontResolveDllReferences = &H1
   IgnoreCodeAuthzLevel = &H10
   LoadLibraryAsDataFile = &H2
   LoadLibraryAsDataFileExclusive = &H40
   LoadLibraryAsImageResource = &H20
   LoadLibrarySearchApplicationDir = &H200
   LoadLibrarySearchDefaultDirs = &H1000
   LoadLibrarySearchDllLoadDir = &H100
   LoadLibrarySearchSystem32 = &H800
   LoadLibrarySearchUserDirs = &H400
   LoadWithAlteredSearchPath = &H8
End Enum

<Flags>
Friend Enum MemoryAllocationType As UInteger
   Commit = &H1000
   Reserve = &H2000
   Reset = &H80000
   ResetUndo = &H1000000
   Physical = &H400000
   TopDown = &H100000
   LargePages = &H20000000
End Enum

<Flags>
Friend Enum MemoryProtectionOptions As UInteger
   Execute = &H10
   ExecuteRead = &H20
   ExecuteReadWrite = &H40
   ExecuteWriteCopy = &H80
   NoAccess = &H1
   [ReadOnly] = &H2
   ReadWrite = &H4
   WriteCopy = &H8
   Guard = &H100
   NoCache = &H200
   WriteCombine = &H400
End Enum

<Flags>
Friend Enum ProcessAccessRights As Integer
   AllAccess = (ProcessAccessRights.StandardRightsRequired Or ProcessAccessRights.Synchronize Or &HFFFF)
   CreateThread = &H2
   SetSessionId = &H4
   VirtualMemoryOperation = &H8
   VirtualMemoryRead = &H10
   VirtualMemoryWrite = &H20
   DuplicateHandle = &H40
   CreateProcess = &H80
   SetQuota = &H100
   SetInformation = &H200
   QueryInformation = &H400
   SuspendResume = &H800
   QueryLimitedInformation = &H1000
   Synchronize = StandardAccessRights.Synchronize
   Delete = StandardAccessRights.Delete
   ReadControl = StandardAccessRights.ReadControl
   WriteDac = StandardAccessRights.WriteDac
   WriteOwner = StandardAccessRights.WriteOwner
   StandardRightsRequired = StandardAccessRights.StandardRightsRequired
End Enum

<Flags>
Friend Enum StandardAccessRights As Integer
   Delete = &H10000
   ReadControl = &H20000
   WriteDac = &H40000
   WriteOwner = &H80000
   Synchronize = &H100000
   StandardRightsRequired = &HF0000
   StandardRightsRead = StandardAccessRights.ReadControl
   StandardRightsWrite = StandardAccessRights.ReadControl
   StandardRightsExecute = StandardAccessRights.ReadControl
   StandardRightsAll = &H1F0000
End Enum

<Flags>
Friend Enum ThreadCreationFlags As UInteger
   CreateSuspended = &H4
   StackSizeParamIsAReservation = &H10000
End Enum

''' <summary>
''' Represents a handle to a module returned by <see cref="NativeMethods.LoadLibrary"/>
''' or <see cref="NativeMethods.LoadLibraryEx"/> functions.
''' </summary>
Public NotInheritable Class SafeModuleHandle : Inherits SafeHandleZeroOrMinusOneIsInvalid

   <SuppressMessage("Microsoft.Security", "CA2122:DoNotIndirectlyExposeMethodsWithLinkDemands")>
   Public Sub New()
       MyBase.New(ownsHandle:=True)
   End Sub

   <ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)>
   Protected Overrides Function ReleaseHandle() As Boolean
       Return NativeMethods.FreeLibrary(Me)
   End Function

End Class

<DebuggerStepThrough>
<StructLayout(LayoutKind.Sequential)>
Friend Structure SecurityAttributes
   Friend Length As Integer
   Friend SecurityDescriptor As IntPtr
   Friend InheritHandle As Integer
End Structure

<SuppressUnmanagedCodeSecurity>
Friend NotInheritable Class NativeMethods

   Private Sub New()
   End Sub

   <DllImport("Kernel32.dll", SetLastError:=True)>
   Friend Shared Function CloseHandle(ByVal hObject As IntPtr
   ) As <MarshalAs(UnmanagedType.Bool)> Boolean
   End Function

   <DllImport("kernel32.dll", SetLastError:=True)>
   Friend Shared Function CreateRemoteThread(ByVal hProcess As IntPtr,
                                             ByVal threadAttributes As IntPtr,
                                             ByVal stackSize As IntPtr,
                                             ByVal startAddress As IntPtr,
                                             ByVal threadParameter As IntPtr,
               <MarshalAs(UnmanagedType.U4)> ByVal creationFlags As ThreadCreationFlags,
                                             ByRef refThreadId As UInteger
   ) As IntPtr
   End Function

   <DllImport("kernel32.dll", SetLastError:=True)>
   Friend Shared Function CreateRemoteThread(ByVal hProcess As IntPtr,
                                             ByVal threadAttributes As IntPtr,
                                             ByVal stackSize As IntPtr,
                                             ByVal startAddress As UIntPtr,
                                             ByVal threadParameter As IntPtr,
               <MarshalAs(UnmanagedType.U4)> ByVal creationFlags As ThreadCreationFlags,
                                             ByRef refThreadId As UInteger
   ) As IntPtr
   End Function

   <DllImport("kernel32.dll", SetLastError:=True)>
   Friend Shared Function CreateRemoteThread(ByVal hProcess As IntPtr,
                                             ByVal threadAttributes As IntPtr,
                                             ByVal stackSize As IntPtr,
                                             ByVal startAddress As ThreadStart,
                                             ByVal threadParameter As IntPtr,
               <MarshalAs(UnmanagedType.U4)> ByVal creationFlags As ThreadCreationFlags,
                                             ByRef refThreadId As UInteger
   ) As IntPtr
   End Function

   <DllImport("kernel32.dll", SetLastError:=True)>
   Friend Shared Function CreateRemoteThread(ByVal hProcess As IntPtr,
                                      <[In]> ByRef refThreadAttributes As SecurityAttributes,
                                             ByVal stackSize As IntPtr,
                                             ByVal startAddress As IntPtr,
                                             ByVal threadParameter As IntPtr,
               <MarshalAs(UnmanagedType.U4)> ByVal creationFlags As ThreadCreationFlags,
                                             ByRef refThreadId As UInteger
   ) As IntPtr
   End Function

   <DllImport("kernel32.dll", SetLastError:=True)>
   Friend Shared Function CreateRemoteThread(ByVal hProcess As IntPtr,
                                      <[In]> ByRef refThreadAttributes As SecurityAttributes,
                                             ByVal stackSize As IntPtr,
                                             ByVal startAddress As UIntPtr,
                                             ByVal threadParameter As IntPtr,
               <MarshalAs(UnmanagedType.U4)> ByVal creationFlags As ThreadCreationFlags,
                                             ByRef refThreadId As UInteger
   ) As IntPtr
   End Function

   <DllImport("kernel32.dll", SetLastError:=True)>
   Friend Shared Function CreateRemoteThread(ByVal hProcess As IntPtr,
                                      <[In]> ByRef refThreadAttributes As SecurityAttributes,
                                             ByVal stackSize As IntPtr,
                                             ByVal startAddress As ThreadStart,
                                             ByVal threadParameter As IntPtr,
               <MarshalAs(UnmanagedType.U4)> ByVal creationFlags As ThreadCreationFlags,
                                             ByRef refThreadId As UInteger
   ) As IntPtr
   End Function

   <DllImport("User32.dll", SetLastError:=True, CharSet:=CharSet.Ansi, BestFitMapping:=False, ThrowOnUnmappableChar:=True)>
   Friend Shared Function FindWindow(ByVal className As String,
                                     ByVal windowName As String
   ) As IntPtr
   End Function

   <DllImport("User32.dll", SetLastError:=True, CharSet:=CharSet.Ansi, BestFitMapping:=False, ThrowOnUnmappableChar:=True)>
   Friend Shared Function FindWindowEx(ByVal hwndParent As IntPtr,
                                       ByVal hwndChildAfter As IntPtr,
                                       ByVal strClassName As String,
                                       ByVal strWindowName As String
   ) As IntPtr
   End Function

   <DllImport("User32.dll", SetLastError:=True, CharSet:=CharSet.Ansi, BestFitMapping:=False, ThrowOnUnmappableChar:=True)>
   Friend Shared Function FindWindowEx(ByVal hwndParent As HandleRef,
                                       ByVal hwndChildAfter As HandleRef,
                                       ByVal strClassName As String,
                                       ByVal strWindowName As String
   ) As IntPtr
   End Function

   <DllImport("Kernel32.dll", SetLastError:=True)>
   Friend Shared Function FreeLibrary(ByVal handle As IntPtr
   ) As <MarshalAs(UnmanagedType.Bool)> Boolean
   End Function

   <DllImport("Kernel32.dll", SetLastError:=True)>
   Friend Shared Function FreeLibrary(ByVal handle As SafeModuleHandle
   ) As <MarshalAs(UnmanagedType.Bool)> Boolean
   End Function

   <DllImport("Kernel32.dll", SetLastError:=True, CharSet:=CharSet.Ansi, BestFitMapping:=False, ThrowOnUnmappableChar:=True)>
   Friend Shared Function GetModuleHandle(ByVal moduleName As String
   ) As IntPtr
   End Function

   <DllImport("Kernel32.dll", SetLastError:=True, CharSet:=CharSet.Ansi, BestFitMapping:=False, ThrowOnUnmappableChar:=True)>
   Friend Shared Function GetProcAddress(ByVal hModule As IntPtr,
                                         ByVal procName As String
   ) As IntPtr
   End Function

   <DllImport("Kernel32.dll", SetLastError:=True, CharSet:=CharSet.Ansi, BestFitMapping:=False, ThrowOnUnmappableChar:=True)>
   Friend Shared Function GetProcAddress(ByVal hModule As SafeModuleHandle,
                                         ByVal procName As String
   ) As IntPtr
   End Function

   <DllImport("Kernel32.dll", SetLastError:=True, CharSet:=CharSet.Ansi, BestFitMapping:=False, ThrowOnUnmappableChar:=True)>
   Friend Shared Function LoadLibrary(ByVal fileName As String
   ) As SafeModuleHandle
   End Function

   <DllImport("Kernel32.dll", SetLastError:=True, CharSet:=CharSet.Ansi, BestFitMapping:=False, ThrowOnUnmappableChar:=True)>
   Friend Shared Function LoadLibraryEx(ByVal fileName As String,
                                        ByVal hFile As IntPtr,
          <MarshalAs(UnmanagedType.U4)> ByVal flags As LoadLibraryFlags
   ) As SafeModuleHandle
   End Function

   <DllImport("Kernel32.dll", SetLastError:=True)>
   Friend Shared Function OpenProcess(
        <MarshalAs(UnmanagedType.U4)> ByVal processAccess As ProcessAccessRights,
                                      ByVal inheritHandle As Boolean,
                                      ByVal pid As Integer
   ) As IntPtr
   End Function

   <DllImport("Kernel32.dll", SetLastError:=True)>
   Friend Shared Function ReadProcessMemory(ByVal hProcess As IntPtr,
                                            ByVal baseAddress As IntPtr,
                                            ByVal buffer As IntPtr,
                                            ByVal size As IntPtr,
                                            ByRef refNumberOfBytesRead As Integer
   ) As <MarshalAs(UnmanagedType.Bool)> Boolean
   End Function

   <DllImport("Kernel32.dll", SetLastError:=True)>
   Friend Shared Function ReadProcessMemory(ByVal hProcess As IntPtr,
                                            ByVal baseAddress As IntPtr,
                                            ByVal buffer As IntPtr,
                                            ByVal size As UInteger,
                                            ByRef refNumberOfBytesRead As Integer
   ) As <MarshalAs(UnmanagedType.Bool)> Boolean
   End Function

   <DllImport("Kernel32.dll", SetLastError:=True)>
   Friend Shared Function ReadProcessMemory(ByVal hProcess As IntPtr,
                                            ByVal baseAddress As IntPtr,
                                      <Out> ByVal buffer As Byte(),
                                            ByVal size As UInteger,
                                            ByRef refNumberOfBytesRead As Integer
   ) As <MarshalAs(UnmanagedType.Bool)> Boolean
   End Function

   <DllImport("Kernel32.dll", SetLastError:=True, CharSet:=CharSet.Ansi, BestFitMapping:=False, ThrowOnUnmappableChar:=True)>
   Friend Shared Function ReadProcessMemory(ByVal hProcess As IntPtr,
                                            ByVal baseAddress As IntPtr,
                                      <Out> ByVal buffer As StringBuilder,
                                            ByVal size As Integer,
                                            ByRef refNumberOfBytesRead As Integer
   ) As <MarshalAs(UnmanagedType.Bool)> Boolean
   End Function

   <DllImport("Kernel32.dll", SetLastError:=True)>
   Friend Shared Function ReadProcessMemory(ByVal hProcess As IntPtr,
                                            ByVal baseAddress As UIntPtr,
                                            ByVal buffer As IntPtr,
                                            ByVal size As IntPtr,
                                            ByRef refNumberOfBytesRead As Integer
   ) As <MarshalAs(UnmanagedType.Bool)> Boolean
   End Function

   <DllImport("Kernel32.dll", SetLastError:=True)>
   Friend Shared Function ReadProcessMemory(ByVal hProcess As IntPtr,
                                            ByVal baseAddress As UIntPtr,
                                            ByVal buffer As IntPtr,
                                            ByVal size As Integer,
                                            ByRef refNumberOfBytesRead As Integer
   ) As <MarshalAs(UnmanagedType.Bool)> Boolean
   End Function

   <DllImport("Kernel32.dll", SetLastError:=True)>
   Friend Shared Function ReadProcessMemory(ByVal hProcess As IntPtr,
                                            ByVal baseAddress As UIntPtr,
                                      <Out> ByVal buffer As Byte(),
                                            ByVal size As Integer,
                                            ByRef refNumberOfBytesRead As Integer
   ) As <MarshalAs(UnmanagedType.Bool)> Boolean
   End Function

   <DllImport("Kernel32.dll", SetLastError:=True, CharSet:=CharSet.Ansi, BestFitMapping:=False, ThrowOnUnmappableChar:=True)>
   Friend Shared Function ReadProcessMemory(ByVal hProcess As IntPtr,
                                            ByVal baseAddress As UIntPtr,
                                      <Out> ByVal buffer As StringBuilder,
                                            ByVal size As Integer,
                                            ByRef refNumberOfBytesRead As Integer
   ) As <MarshalAs(UnmanagedType.Bool)> Boolean
   End Function
   <DllImport("Kernel32.dll", SetLastError:=True)>
   Friend Shared Function VirtualAlloc(ByVal address As IntPtr,
                                       ByVal size As UInteger,
         <MarshalAs(UnmanagedType.U4)> ByVal allocationType As MemoryAllocationType,
         <MarshalAs(UnmanagedType.U4)> ByVal protection As MemoryProtectionOptions
   ) As IntPtr
   End Function

   <DllImport("Kernel32.dll", SetLastError:=True)>
   Friend Shared Function VirtualAlloc(ByVal address As UIntPtr,
                                       ByVal size As UInteger,
         <MarshalAs(UnmanagedType.U4)> ByVal allocationType As MemoryAllocationType,
         <MarshalAs(UnmanagedType.U4)> ByVal protection As MemoryProtectionOptions
   ) As UIntPtr
   End Function

   <DllImport("Kernel32.dll", ExactSpelling:=True, SetLastError:=True)>
   Friend Shared Function VirtualAllocEx(ByVal hProcess As IntPtr,
                                         ByVal address As IntPtr,
                                         ByVal size As UInteger,
           <MarshalAs(UnmanagedType.U4)> ByVal allocationType As MemoryAllocationType,
           <MarshalAs(UnmanagedType.U4)> ByVal protection As MemoryProtectionOptions
   ) As IntPtr
   End Function

   <DllImport("Kernel32.dll", ExactSpelling:=True, SetLastError:=True)>
   Friend Shared Function VirtualAllocEx(ByVal hProcess As IntPtr,
                                         ByVal address As UIntPtr,
                                         ByVal size As UInteger,
           <MarshalAs(UnmanagedType.U4)> ByVal allocationType As MemoryAllocationType,
           <MarshalAs(UnmanagedType.U4)> ByVal protection As MemoryProtectionOptions
   ) As UIntPtr
   End Function

   <DllImport("Kernel32.dll", SetLastError:=True)>
   Friend Shared Function WriteProcessMemory(ByVal hProcess As IntPtr,
                                             ByVal baseAddress As IntPtr,
                                             ByVal buffer As Byte(),
                                             ByVal size As IntPtr,
                                       <Out> ByRef refNumberOfBytesWritten As IntPtr
   ) As <MarshalAs(UnmanagedType.Bool)> Boolean
   End Function

   <DllImport("Kernel32.dll", SetLastError:=True)>
   Friend Shared Function WriteProcessMemory(ByVal hProcess As IntPtr,
                                             ByVal baseAddress As UIntPtr,
                                             ByVal buffer As Byte(),
                                             ByVal size As IntPtr,
                                       <Out> ByRef refNumberOfBytesWritten As IntPtr
   ) As <MarshalAs(UnmanagedType.Bool)> Boolean
   End Function

   <DllImport("Kernel32.dll", SetLastError:=True)>
   Friend Shared Function WriteProcessMemory(ByVal hProcess As IntPtr,
                                             ByVal baseAddress As IntPtr,
                                             ByVal buffer As IntPtr,
                                             ByVal size As IntPtr,
                                       <Out> ByRef refNumberOfBytesWritten As IntPtr
   ) As <MarshalAs(UnmanagedType.Bool)> Boolean
   End Function

   <DllImport("Kernel32.dll", SetLastError:=True)>
   Friend Shared Function WriteProcessMemory(ByVal hProcess As IntPtr,
                                             ByVal baseAddress As UIntPtr,
                                             ByVal buffer As IntPtr,
                                             ByVal size As IntPtr,
                                       <Out> ByRef refNumberOfBytesWritten As IntPtr
   ) As <MarshalAs(UnmanagedType.Bool)> Boolean
   End Function

End Class

...Evidentemente vas a tener que realizar las adaptaciones necesarias en el resto de tu código, puesto que los parámetros de las funciones cambian de tipo (son portables), del código que tenías, al que te acabo de mostrar.

PD: fíjate que especifiqué el set de caracteres ANSI para las funcioens que toman un string, quizás quieras cambiarlo según tus necesidades.

Saludos.

Efectivamente, la manera de hacerlo es como te ha indicado el compañero @Slava_TZD. Añado una pequeña refactorización al código:

Código [Seleccionar] Expandir

WMIC.exe ComputerSystem WHERE name="%COMPUTERNAME%" CALL rename name="NUEVO_NOMBRE"

Saludos.

mayormente envio virus creados por mi a mis profesores.

Genial tu declaración pública... ahora el robot indizador de Google, Facebook, la CIA, la NSA, el FBI, la Policia Nacional de España, ex-novias reencorosas, enemigos y archienemigos, el niño al que le haceis bullying en clase y puede que incluso tus profesores ya lo sepan. -.-

[Python]

La cosa es, que es tan sencillo como matar el proceso para no lidiar con el programa.

Había pensado sobre un segundo proceso que estuviese pendiente de si el primero lo cerraban, o mataban el proceso, pero pensandolo bien si matan uno muy probablemente matasen el otro. ¿Alguna idea?

Se me ocurren chapuzas como que esté matando siempre el proceso del administrador de tareas, pero podrían matar los procesos mediante la consola, lo cuál también podría matar al cmd... - que sangriento suena todo esto -

No te comas mucho el coco, en principio es algo mucho mas sencillo de resolver de lo que parece (más abajo se entenderá por que digo "en principio"). Para prevenir todos los males solamente necesitas modificar el modo del proceso a modo crítico, es decir, convertirlo en un proceso crítico (el cual, si se mata, se mostrará un BSOD y el usuario tendría que reiniciar el equipo...)

Eso sí, hacer esto en Python... vamos a ver, estamos hablando de un script, no un executable, así que a menos que establezcas el executable del intérprete (py.exe) como proceso crítico, o estés usando algun framework para el diseño de interfaces de usuario que compile un executable (tu programa)... pues de lo contrario no podrás llevar a cabo esta metodología en dicho lenguaje.

En fin, te explico más en profundidad, para volver un proceso a modo crítico en Windows, primero debes establecer el privilegio de proceso SE_DEBUG_NAME ("SeDebugPrivilege") en tu proceso, para ello deberás lidiar con las siguientes funciones nativas de Windows: OpenProcessToken, CloseHandle, LookupPrivilegeValue y AdjustTokenPrivileges y las estructuras LUID_AND_ATTRIBUTES y TOKEN_PRIVILEGES, y entonces podrás llamar a la función nativa (e indocumentada) de Windows RtlSetProcessIsCritical para volver el proceso crítico.

Aquí te dejo toda la documentación necesaria:

• RtlSetProcessIsCritical Function - geoffchappell.com
• LookupPrivilegeValue Function - MSDN
• AdjustTokenPrivileges Function - MSDN
• OpenProcessToken Function - MSDN
• CloseHandle Function - MSDN
• TOKEN_PRIVILEGES structure - MSDN
• LUID_AND_ATTRIBUTES structure - MSDN
• Privilege Constants - MSDN

¿Y como implementar todo esto en Python?, pues si te digo la verdad... no tengo ni p**a idea, nunca lo he necesitado hacer ni me interesa Python, pero se que hay algunas librerías gratuitas para Python que te permiten invocar miembros de la API de Windows, como por ejemplo PyWin32, ese podría ser el camino a seguir por donde empezar a documentarse y probar...

• https://sourceforge.net/projects/pywin32/

...en C++ sería coser y cantar (acceso directo a las funciones y estructuras nativas de la API de Windows), en lenguajes como C# y VB.NET se puede implementar y hacerlo todo en 10 minutejos (servicio de invocación de plataforma más conocido como P/Invoking para el acceso a funciones y estructuras nativas de la API de Windows), pero en Python la verdad es que no se ni tan siquiera si se podrá, pero supongo que algún modo habrá si existe soporte para exponer el uso de funciones nativas del S.O. mediante algún módulo/libreria... o puede que no.

Había pensado sobre un segundo proceso que estuviese pendiente de si el primero lo cerraban, o mataban el proceso, pero pensandolo bien si matan uno muy probablemente matasen el otro.

A menos que tengas mucho tiempo libre con ganas de aprender cosas nuevas documentándote y no te importe sufrir una estresante y larga etapa de ensayo y error, lo que yo haría en tu lugar sería desarrollar un segundo executable, pero en C++, C# o VB.NET y solamente para que cumpliese la función de volver el proceso a modo crítico por los motivos que he dicho (por que es facil de hacer en esos lenguajes), esa sería su única funcionalidad del programa, y el resto ya con tu executable generado con Python. Pienso que eso sería mucho más viable que (intentar) hacerlo directamente en Python... a menos que ya tengas algo de experiencia en estos temas de llamadas a miembros Win32 desde Python, claro está.



Una alternativa a esto, sería desarrollar un servicio de Windows que trabajase en segundo plano para monitorizar la "existencia" del proceso en cuestión. Seguiría habiendo peligro de que el usuario cierre el programa, pero no el servicio, bueno, en realidad si, pero no sería un problema ya que puedes crear un servicio de sistema que se reinicie automáticamente en caso de cierre y no se pueda deshabilitar/detener de forma natural. Sin embargo, tampoco sé como se haría esto en Python.

Saludos.

[Process]

no se si para obtener el proceso seria algo como esto Label3.Text = Pr.ProcessName

Si, pero no entiendo la pregunta, ya que por un lado dices que el nombre del executable se llama "hl.exe", pero por otro lado el nombre del executable que declaras en la clase Process se llama "counterstrike.exe", ¿en que quedamos?.

...eso me hace sospechar que o bien te equivocaste, o a lo mejor "counterstrike.exe" es una especie de launcher o loader. Ten en cuenta que evidentemente la propiedad Process.ProcessName no te va a devolver el nombre de un proceso hijo en el árbol de procesos, es decir, un proceso secundario (hijo) que haya sido ejecutado por el proceso principal (padre). Para obtener los procesos hijo puedes realizar una consulta a las clases de WMI (Windows Management Instrumentation). Por si te sirve, aquí te dejo una función reutilizable que he extraido de mi framework comercial ElektroKit:

Código (vbnet) [Seleccionar] Expandir

#Region " Imports "

Imports System.ComponentModel
Imports System.Management
Imports System.Runtime.CompilerServices

#End Region

#Region " Process Extensions "

Namespace ElektroKit.Core.Extensions.Process

   ''' ----------------------------------------------------------------------------------------------------
   ''' <summary>
   ''' Contains custom extension methods to use with the <see cref="Process"/> type.
   ''' </summary>
   ''' ----------------------------------------------------------------------------------------------------
   <HideModuleName>
   Public Module ProcessExtensions

#Region " Public Extension Methods "

       ''' ----------------------------------------------------------------------------------------------------
       ''' <summary>
       ''' Gets the child processes of the source <see cref="Process"/>.
       ''' </summary>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <example> This is a code example.
       ''' <code>
       ''' Dim mainProcess As Process = Process.GetProcessesByName("Explorer").Single()
       ''' Dim childProcesses As IEnumerable(Of Process) = mainProcess.GetChildProcesses()
       '''
       ''' For Each p As Process In childProcesses
       '''     Console.WriteLine(p.ProcessName)
       ''' Next
       ''' </code>
       ''' </example>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <param name="sender">
       ''' The source <see cref="Process"/>.
       ''' </param>
       ''' ----------------------------------------------------------------------------------------------------
       ''' <returns>
       ''' A <see cref="IEnumerable(Of Process)"/> containing the child processes.
       ''' </returns>
       ''' ----------------------------------------------------------------------------------------------------
       <DebuggerStepThrough>
       <Extension>
       <EditorBrowsable(EditorBrowsableState.Always)>
       Public Iterator Function GetChildProcesses(ByVal sender As Process) As IEnumerable(Of Process)

           Dim scope As New ManagementScope("root\CIMV2")
           Dim query As New SelectQuery(String.Format("SELECT ProcessID FROM Win32_Process WHERE ParentProcessID={0}", sender.Id))
           Dim options As New EnumerationOptions With {
               .ReturnImmediately = True,
               .Rewindable = False,
               .DirectRead = True,
               .EnumerateDeep = False
           }

           Using mos As New ManagementObjectSearcher(scope, query, options),
                 moc As ManagementObjectCollection = mos.Get()

               For Each mo As ManagementObject In moc
                   Dim value As Object = mo.Properties("ProcessID").Value()
                   If (value IsNot Nothing) Then
                       Yield Process.GetProcessById(Convert.ToInt32(value))
                   End If
               Next
           End Using

       End Function

#End Region

   End Module

End Namespace

#End Region

Modo de empleo:

Código (vbnet) [Seleccionar] Expandir

Imports ElektroKit.Core.Extensions.Process

Código (vbnet) [Seleccionar] Expandir

Dim mainProcess As Process = Process.GetProcessesByName("Explorer").Single()
Dim childProcesses As IEnumerable(Of Process) = mainProcess.GetChildProcesses()

For Each p As Process In childProcesses
   Console.WriteLine(p.ProcessName)
Next

Saludos.