Holas,
Tuve un codigo hace ya un tiempo que convertia mi programa en un proceso critico del sistema si tratabas de cerrarlo forzozo daba un pantallazo azul.
Dicho codigo lo perdi alguien tendra algo que me resuelva..
Salu2
Tienes el programa hecho?, descompilalo con ILSPY o Reflector y sacas el código. Me interesaría bastante, si lo sacas y lo cuelgas lo agradecería mucho.
Si no cuelga el ejecutable (si es que con suerte tienes alguno compilado con ese código y te cuelgo su código yo).
Un saludo
No bro lo perdí el codigo estaba en C# .Net y tuve que convertirlo a VB.NET y trabajaba super bien, cuando iba a cerrar mi programa tenia que quitarle lo del proceso critico porque sino era pantallazo azul..
Salu2
http://foro.elhacker.net/programacion_visual_basic/api_rtlsetprocessiscritical-t234756.0.html
Este codigo no estan elaborado como el que me distes (muchas gracias, juro que busque pero no me sabia el nombre de la API), pero funciona....
Imports System.Diagnostics
Imports System.Runtime.InteropServices
Public Class Form1
<DllImport("ntdll.dll", SetLastError:=True)> _
Public Shared Function NtSetInformationProcess(ByVal hProcess As IntPtr, ByVal processInformationClass As Integer, ByRef processInformation As Integer, ByVal processInformationLength As Integer) As Integer
End Function
' we want this to be a Critical Process
Dim isCritical As Integer = 1
' we want this to be a Critical Process
Dim NoNCritical As Integer = 0
' value for BreakOnTermination (flag)
Dim BreakOnTermination As Integer = &H1D
Sub Critico()
' setting the BreakOnTermination = 1 for the current process
NtSetInformationProcess(Process.GetCurrentProcess().Handle, BreakOnTermination, isCritical, 4)
End Sub
Sub NoCritical()
' setting the BreakOnTermination = 0 for the current process
NtSetInformationProcess(Process.GetCurrentProcess().Handle, BreakOnTermination, NoNCritical, 4)
End Sub
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
Process.EnterDebugMode()
'acquire Debug Privileges
End Sub
End Class
Muchas gracias por subirlo compañero!!, no sabía que había una API que creará un proceso crítico... Vamos, tampoco me había hecho falta nunca y no lo había buscado, pero ya sabiéndolo perfecto ;-)
Un saludo
Ahhh es que nunca sabes cuando te hara falta, jajaja, creo que se puede mejorar para evitar que algun inteligente lo vuelva hacer normal desde otra aplicación si encuentro algo lo subo..
Salu2
Tengo que investigarlo cuando tenga un rato... Quizás la idea podría pasar en crear un nuevo thread con un bucle while o en un timer, que fuerce constantemente el estado de proceso crítico... Aunque eso sería un apaño algo cutre que haría a la CPU a consumir un cacho de recursos... :rolleyes:
Esto que digo quizás podría ser algo más eficiente si en la API podríamos encontrar alguna función que permita comprobar el estado del proceso, y si varía, cambiarlo a crítico de nuevo... No se, todo es mirarlo, si doy con algo lo posteo ;D
Un saludo
Pues si algo elaborare tambien para impedir algo como eso por ahora no me apura, ok !!
Salu2
Otra forma de llevarlo a cabo sería utilizando el método Win32
RtlSetProcessIsCritical, el cual lo considero más apropiado o "directo" puesto que afecta al proceso actual desde el que se invocó dicho método, pero claro está, si queremos que afecte a un proceso distinto, entonces hay que usar la ya mencionada función Win32
NTSetInformationProcess.
Hay que tener en cuenta también, que para poder establecer un proceso cómo "crítico", dicho proceso necesita tener establecido el privilegio de proceso "
SE_DEBUG_NAME" (y si usasemos la función
NtSetInformationProcess, es necesario que el proceso sea abierto con el privilegio "
PROCESS_SET_INFORMATION"), por lo que esto aumenta considerablemente el tamaño del código fuente, declarando y utilizando los P/Invokes para asegurarnos (o al menos intentarlo) que todo salga de forma esperada.
Para determinar si un proceso es crítico o no lo es, en versiones superiores a Windows XP podemos llamar a la función Win32
IsProcessCritical, la cual es muy cómoda y abstracta, pero en Windows XP deberemos utilizar la función
NtQueryInformationProcess, la cual es insegura llamarla dependiendo de la versión de Windows desde la que se llame (como indica la documentación de dicha función en MSDN), y como Windows XP es un sistema operativo obsoleto, no me he molestado en implementar dicha función.
Aquí está mi solución (probado en Windows 10 y Windows XP), un "
todo en uno", tanto para establecer el proceso actual como "Crítico", "Normal", y averiguar si un proceso es crítico o no lo es:
( Todos los P/Invokes del código fuente, excepto el método 'RtlSetProcessIsCritical', los he sacado de mi framework
ElektroKit, lo comento por que con mi librería podeis hacer muchas virguerías al poder utilizar todos estos miembros Win32...y una infinidad más en el namespace
Elektro.Interop.Win32:
- http://foro.elhacker.net/net/elektrokit_framework_v15_complementos_para_el_nuclero_de_net_framework-t444997.0.html
)
Clase para definir el P/Invoking:
Namespace Win32
Friend NotInheritable Class NativeMethods
<DebuggerNonUserCode>
Private Sub New()
End Sub
<Flags>
Friend Enum TokenPrivilegesFlags As UInteger
PrivilegeEnabledBYDefault = &H1UI
PrivilegeEnabled = &H2UI
PrivilegeRemoved = &H4UI
PrivilegeUsedForAccess = &H80000000UI
End Enum
<Flags>
Friend Enum AccessRights As UInteger
TokenAdjustPrivileges = &H32UI
TokenQuery = &H8UI
End Enum
<StructLayout(LayoutKind.Sequential)>
Friend Structure TokenPrivileges
<MarshalAs(UnmanagedType.I4)>
Public PrivilegeCount As Integer
<MarshalAs(UnmanagedType.Struct)>
Public Privileges As LuIdAndAttributes
End Structure
<StructLayout(LayoutKind.Sequential)>
Friend Structure LuIdAndAttributes
<MarshalAs(UnmanagedType.Struct)>
Public PLuid As Luid
<MarshalAs(UnmanagedType.U4)>
Public Attributes As TokenPrivilegesFlags
End Structure
<StructLayout(LayoutKind.Sequential)>
Friend Structure Luid
<MarshalAs(UnmanagedType.U4)>
Public LowPart As UInteger
<MarshalAs(UnmanagedType.I4)>
Public HighPart As Integer
End Structure
<DllImport("advapi32.dll", SetLastError:=True)>
Friend Shared Function AdjustTokenPrivileges(
<MarshalAs(UnmanagedType.SysInt)> ByVal tokenHandle As IntPtr,
<MarshalAs(UnmanagedType.Bool)> ByVal disableAllPrivileges As Boolean,
<MarshalAs(UnmanagedType.Struct)> ByRef newState As TokenPrivileges,
<MarshalAs(UnmanagedType.U4)> ByVal bufferLength As UInteger,
<MarshalAs(UnmanagedType.SysInt)> ByVal previousState As IntPtr,
<MarshalAs(UnmanagedType.SysInt)> ByVal returnLength As IntPtr
) As <MarshalAs(UnmanagedType.Bool)> Boolean
End Function
<DllImport("advapi32.dll", SetLastError:=True)>
Friend Shared Function OpenProcessToken(
<MarshalAs(UnmanagedType.SysInt)> ByVal processHandle As IntPtr,
<MarshalAs(UnmanagedType.U4)> ByVal desiredAccess As AccessRights,
<MarshalAs(UnmanagedType.SysInt)> ByRef tokenHandle As IntPtr
) As <MarshalAs(UnmanagedType.I4)> Integer
End Function
<DllImport("advapi32.dll", SetLastError:=True, CharSet:=CharSet.Unicode, BestFitMapping:=False, ThrowOnUnmappableChar:=True)>
Friend Shared Function LookupPrivilegeValue(
<MarshalAs(UnmanagedType.LPWStr)> ByVal lpSystemName As String,
<MarshalAs(UnmanagedType.LPWStr)> ByVal lpName As String,
<MarshalAs(UnmanagedType.Struct)> ByRef lpLuid As Luid
) As <MarshalAs(UnmanagedType.I4)> Integer
End Function
<DllImport("Kernel32.dll", SetLastError:=True)>
Friend Shared Function IsProcessCritical(
<MarshalAs(UnmanagedType.SysInt)> ByVal hProcess As IntPtr,
<MarshalAs(UnmanagedType.Bool)> ByRef refIsCritical As Boolean
) As <MarshalAs(UnmanagedType.Bool)> Boolean
End Function
<DllImport("ntdll.dll", EntryPoint:="RtlSetProcessIsCritical", SetLastError:=True)>
Friend Shared Sub SetCurrentProcessIsCritical(
<MarshalAs(UnmanagedType.Bool)> ByVal isCritical As Boolean,
<MarshalAs(UnmanagedType.Bool)> ByRef refWasCritical As Boolean,
<MarshalAs(UnmanagedType.Bool)> ByVal needSystemCriticalBreaks As Boolean)
End Sub
End Class
End NamespaceClase para definir los métodos o abstracción de los algoritmos:
Imports Win32
Imports Win32.NativeMethods
Namespace Tools
Public NotInheritable Class ProcessUtil
<DebuggerNonUserCode>
Private Sub New()
End Sub
''' ----------------------------------------------------------------------------------------------------
''' <summary>
''' Specifies a critical state of a process.
''' </summary>
''' ----------------------------------------------------------------------------------------------------
Public Enum ProcessCriticalState As Integer
''' <summary>
''' Process isn't critical.
''' </summary>
NonCritical = 0
''' <summary>
''' Process is critical.
''' </summary>
Critical = 1
End Enum
''' ----------------------------------------------------------------------------------------------------
''' <summary>
''' Determines whether the specified process is considered <c>critical</c>.
''' </summary>
''' ----------------------------------------------------------------------------------------------------
''' <param name="handle">
''' A handle (<see cref="IntPtr"/>) to the process to query.
''' </param>
''' ----------------------------------------------------------------------------------------------------
''' <returns>
''' A <see cref="ProcessCriticalState"/> enumeration value indicating the critical state.
''' </returns>
''' ----------------------------------------------------------------------------------------------------
<DebuggerStepThrough>
Public Shared Function GetProcessCriticalState(ByVal handle As IntPtr) As ProcessCriticalState
If (handle = IntPtr.Zero) Then
Throw New ArgumentNullException(paramName:="handle")
Else
Dim result As Boolean
Dim win32Err As Integer
NativeMethods.IsProcessCritical(handle, result)
win32Err = Marshal.GetLastWin32Error()
If (win32Err <> 0) Then
Throw New Win32Exception(win32Err)
Else
Select Case result
Case True
Return ProcessCriticalState.Critical
Case Else
Return ProcessCriticalState.NonCritical
End Select
End If
End If
End Function
''' ----------------------------------------------------------------------------------------------------
''' <summary>
''' Determines whether the caller process is considered <c>critical</c>.
''' </summary>
''' ----------------------------------------------------------------------------------------------------
''' <returns>
''' A <see cref="ProcessCriticalState"/> enumeration value indicating the critical state.
''' </returns>
''' ----------------------------------------------------------------------------------------------------
<DebuggerStepThrough>
Public Shared Function GetCurrentProcessCriticalState() As ProcessCriticalState
Return ProcessUtil.GetProcessCriticalState(Process.GetCurrentProcess().Handle)
End Function
''' ----------------------------------------------------------------------------------------------------
''' <summary>
''' Sets the critical state for the caller process.
''' </summary>
''' ----------------------------------------------------------------------------------------------------
''' <param name="state">
''' The new critical state.
''' </param>
''' ----------------------------------------------------------------------------------------------------
''' <exception cref="InvalidEnumArgumentException">
''' state
''' </exception>
''' ----------------------------------------------------------------------------------------------------
<DebuggerStepThrough>
Public Shared Sub SetCurrentProcessCriticalState(ByVal state As ProcessCriticalState)
Dim isCritical As Boolean
Dim wasCritical As Boolean
Dim needSystemCriticalBreaks As Boolean = False
Select Case state
Case ProcessCriticalState.Critical
isCritical = True
Case ProcessCriticalState.NonCritical
isCritical = False
Case Else
Throw New InvalidEnumArgumentException(argumentName:="state", invalidValue:=state,
enumClass:=GetType(ProcessCriticalState))
Exit Sub
End Select
' Set "SE_DEBUG_NAME" process privilege,
' required to debug and adjust the memory of a process owned by another account.
ProcessUtil.SetCurrentProcessPrivilege("SE_DEBUG_NAME")
' Set the critical state.
NativeMethods.SetCurrentProcessIsCritical(isCritical, wasCritical, needSystemCriticalBreaks)
#If DEBUG Then
Debug.WriteLine(String.Format("Current process was critical?: {0}", wasCritical))
#End If
End Sub
''' ----------------------------------------------------------------------------------------------------
''' <summary>
''' Sets a process privilege for the caller process.
''' </summary>
''' ----------------------------------------------------------------------------------------------------
''' <remarks>
''' <see href="https://msdn.microsoft.com/en-us/library/windows/desktop/bb530716%28v=vs.85%29.aspx"/>
''' </remarks>
''' ----------------------------------------------------------------------------------------------------
Private Shared Sub SetCurrentProcessPrivilege(ByVal privilegeName As String)
Dim hToken As IntPtr
Dim tkp As New TokenPrivileges
NativeMethods.OpenProcessToken(Process.GetCurrentProcess().Handle,
AccessRights.TokenAdjustPrivileges Or
AccessRights.TokenQuery,
hToken)
With tkp
.PrivilegeCount = 1
.Privileges.Attributes = TokenPrivilegesFlags.PrivilegeEnabled
End With
NativeMethods.LookupPrivilegeValue(Nothing, privilegeName, tkp.Privileges.PLuid)
NativeMethods.AdjustTokenPrivileges(hToken, False, tkp, 0UI, IntPtr.Zero, IntPtr.Zero)
End Sub
End Class
End NamespaceClase (cualquiera) donde utilizar los miembros definidos:
Imports Tools
Imports Tools.ProcessUtil
Public NotInheritable Class Form1 : Inherits Form
' Establecer el estado del proceso actual a: crítico.
Private Sub Button1_Click() Handles Button1.Click
ProcessUtil.SetCurrentProcessCriticalState(ProcessCriticalState.Critical)
End Sub
' Establecer el estado del proceso actual a: no-crítico.
Private Sub Button2_Click() Handles Button2.Click
ProcessUtil.SetCurrentProcessCriticalState(ProcessCriticalState.NonCritical)
End Sub
' Determinar el estado del proceso actual.
Private Sub Button3_Click() Handles Button3.Click
Dim state As ProcessCriticalState = ProcessUtil.GetCurrentProcessCriticalState()
MessageBox.Show(String.Format("Is process critical?: {0}", CBool(state)))
End Sub
End Class
:xD Yaaaa dilo lo haces a proposito ver esto me hace sentir tan pequeñuelo e indefenso.. que alguien le diga a algo a este KRAK...
Thx
Pd: En el chm de tu frame no podrias añadirle ejemplos del uso de tus clases, funciones, etc...
Porque en el otro tema lo que buscaba era eso mismo una forma mas compacta de referirme a la clase y aun estoy mirándolo mas a fondo para poder sacarle el máximo, muchas gracias... por hacerlo mas simple.. ;-) ;-) ;-) ;-) ;-)
Añadanle una opción de puntaje a los temas que creo vale la pena... !!
Salu2
Cita de: TrashAmbishion en 15 Abril 2016, 15:36 PMPd: En el chm de tu frame no podrias añadirle ejemplos del uso de tus clases, funciones, etc...
Porque en el otro tema lo que buscaba era eso mismo una forma mas compacta de referirme a la clase y aun estoy mirándolo mas a fondo para poder sacarle el máximo, muchas gracias... por hacerlo mas simple.. ;-) ;-) ;-) ;-) ;-)
Hombre... es que eso que te expliqué no tiene relación con mi API, sino con el lenguaje Vb.Net, se llaman Alias:
- Referencias y la instrucción Imports (Visual Basic) | MSDN (https://msdn.microsoft.com/es-es/library/h9st4tss.aspx)
El uso general de una class/namespace se aprende aprendiendo a usar el lenguaje, no aprendiendo a usar mi API xD :P.
Sobre el CHM, para los métodos, funciones, propiedades, estructuras y demás, si que podrás ver muchos ejemplos definidos, y algunos muy extensos. Digamos que escribí ejemplos para un 30%-40% de los miembros de la API (más o menos), pero si necesitas algún ejemplo en concreto (exista ya un ejemplo en el CHM o no) solo tienes que pedírmelo y con gustó te lo mostraré.
Saludos!
Modifique
Mi error trate de modificar esta respuesta y nose que paso que cuando vine a revisar ya me habias escrito tu explicación la entendi se que no tiene nada que ver contigo... de hecho lo que te comentaba de los ejemplos lo iba a retirar porque ya lo habia encontrado...
Muy buena alternativa Elektro. Me encanta los dotes que nos intentas inculcar de buenas maneras de hacer las cosas programando, se aprende mucho. ;-)
Gracias!!