¿Cómo se hace la suplantación en .NET?
¿Existe una forma sencilla y lista para usar de hacerse pasar por un usuario en .NET?
Hasta ahora he estado usando esta clase del proyecto de código para todos mis requisitos de suplantación.
¿Existe una mejor manera de hacerlo utilizando .NET Framework?
Tengo un conjunto de credenciales de usuario (nombre de usuario, contraseña, nombre de dominio) que representa la identidad que necesito suplantar.
La "suplantación" en el espacio .NET generalmente significa ejecutar código bajo una cuenta de usuario específica. Es un concepto algo separado de obtener acceso a esa cuenta de usuario mediante un nombre de usuario y contraseña, aunque estas dos ideas se combinan con frecuencia.
Interpretación
Las API para la suplantación se proporcionan en .NET a través del System.Security.Principal
espacio de nombres:
El código más nuevo generalmente debe usar
WindowsIdentity.RunImpersonated
, que acepta un identificador para el token de la cuenta de usuario y luego unAction
oFunc<T>
para que se ejecute el código.WindowsIdentity.RunImpersonated(userHandle, () => { // do whatever you want as this user. });
o
var result = WindowsIdentity.RunImpersonated(userHandle, () => { // do whatever you want as this user. return result; });
También hay
WindowsIdentity.RunImpersonatedAsync
tareas asíncronas, disponibles en .NET 5+ o versiones anteriores si ingresa el paquete System.Security.Principal.Windows Nuget.await WindowsIdentity.RunImpersonatedAsync(userHandle, async () => { // do whatever you want as this user. });
o
var result = await WindowsIdentity.RunImpersonated(userHandle, async () => { // do whatever you want as this user. return result; });
El código anterior usaba el
WindowsIdentity.Impersonate
método para recuperar unWindowsImpersonationContext
objeto. Este objeto implementaIDisposable
, por lo que generalmente debe llamarse desde unusing
bloque.using (WindowsImpersonationContext context = WindowsIdentity.Impersonate(userHandle)) { // do whatever you want as this user. }
Si bien esta API todavía existe en .NET Framework, en general se debe evitar.
Accediendo a la cuenta de usuario
La API para usar un nombre de usuario y contraseña para obtener acceso a una cuenta de usuario en Windows es LogonUser
una API nativa de Win32. Actualmente no existe una API .NET administrada integrada para llamarlo.
[DllImport("advapi32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
internal static extern bool LogonUser(String lpszUsername, String lpszDomain, String lpszPassword, int dwLogonType, int dwLogonProvider, out IntPtr phToken);
Esta es la definición de llamada básica, sin embargo, hay mucho más que considerar antes de usarla en producción:
- Obtención de un identificador con el patrón de acceso "seguro".
- Cerrar las manijas nativas apropiadamente
- Niveles de confianza de seguridad de acceso al código (CAS) (solo en .NET Framework)
- Pasando
SecureString
cuando puedes recolectar uno de forma segura mediante las pulsaciones de teclas del usuario.
En lugar de escribir ese código usted mismo, considere usar mi biblioteca SimpleImpersonation , que proporciona un contenedor administrado alrededor de la LogonUser
API para obtener un identificador de usuario:
using System.Security.Principal;
using Microsoft.Win32.SafeHandles;
using SimpleImpersonation;
var credentials = new UserCredentials(domain, username, password);
using SafeAccessTokenHandle userHandle = credentials.LogonUser(LogonType.Interactive); // or another LogonType
Ahora puedes usarlo userHandle
con cualquiera de los métodos mencionados en la primera sección anterior. Esta es la API preferida a partir de la versión 4.0.0 de la biblioteca SimpleImpersonation. Consulte el archivo Léame del proyecto para obtener más detalles.
Acceso remoto a la computadora
Es importante reconocer que la suplantación es un concepto de máquina local . No se puede hacerse pasar por un usuario que sólo es conocido por una máquina remota. Si desea acceder a recursos en una computadora remota, la máquina local y la máquina remota deben estar conectadas al mismo dominio, o debe existir una relación de confianza entre los dominios de las dos máquinas. Si alguna de las computadoras no tiene dominio, no puede usar LogonUser
SimpleImpersonation para conectarse a esa máquina.
A continuación se ofrece una buena descripción general de los conceptos de suplantación de .NET.
- Michiel van Otegem: WindowsImpersonationContext simplificado
- Método WindowsIdentity.Impersonate (consulte los ejemplos de código)
Básicamente, aprovechará estas clases que están listas para usar en el marco .NET:
- Contexto de suplantación de Windows
- WindowsIdentidad
Sin embargo, el código a menudo puede ser largo y es por eso que ves muchos ejemplos como el que haces referencia que intentan simplificar el proceso.
Probablemente esto es lo que quieres:
using System.Security.Principal;
using(WindowsIdentity.GetCurrent().Impersonate())
{
//your code goes here
}
Pero realmente necesito más detalles para ayudarte. Podrías hacer la suplantación con un archivo de configuración (si estás intentando hacer esto en un sitio web), o mediante decoradores de métodos (atributos) si es un servicio WCF, o mediante... ya entiendes la idea.
Además, si estamos hablando de hacerse pasar por un cliente que llamó a un servicio (o aplicación web) en particular, debe configurar el cliente correctamente para que pase los tokens apropiados.
Finalmente, si lo que realmente quiere hacer es delegar, también necesita configurar AD correctamente para que los usuarios y las máquinas sean confiables para la delegación.
Editar:
Eche un vistazo aquí para ver cómo hacerse pasar por un usuario diferente y para obtener más documentación.
Aquí está mi versión vb.net de la respuesta de Matt Johnson. Agregué una enumeración para los tipos de inicio de sesión. LOGON32_LOGON_INTERACTIVE
fue el primer valor de enumeración que funcionó para el servidor SQL. Mi cadena de conexión simplemente era confiable. No hay nombre de usuario ni contraseña en la cadena de conexión.
<PermissionSet(SecurityAction.Demand, Name:="FullTrust")> _
Public Class Impersonation
Implements IDisposable
Public Enum LogonTypes
''' <summary>
''' This logon type is intended for users who will be interactively using the computer, such as a user being logged on
''' by a terminal server, remote shell, or similar process.
''' This logon type has the additional expense of caching logon information for disconnected operations;
''' therefore, it is inappropriate for some client/server applications,
''' such as a mail server.
''' </summary>
LOGON32_LOGON_INTERACTIVE = 2
''' <summary>
''' This logon type is intended for high performance servers to authenticate plaintext passwords.
''' The LogonUser function does not cache credentials for this logon type.
''' </summary>
LOGON32_LOGON_NETWORK = 3
''' <summary>
''' This logon type is intended for batch servers, where processes may be executing on behalf of a user without
''' their direct intervention. This type is also for higher performance servers that process many plaintext
''' authentication attempts at a time, such as mail or Web servers.
''' The LogonUser function does not cache credentials for this logon type.
''' </summary>
LOGON32_LOGON_BATCH = 4
''' <summary>
''' Indicates a service-type logon. The account provided must have the service privilege enabled.
''' </summary>
LOGON32_LOGON_SERVICE = 5
''' <summary>
''' This logon type is for GINA DLLs that log on users who will be interactively using the computer.
''' This logon type can generate a unique audit record that shows when the workstation was unlocked.
''' </summary>
LOGON32_LOGON_UNLOCK = 7
''' <summary>
''' This logon type preserves the name and password in the authentication package, which allows the server to make
''' connections to other network servers while impersonating the client. A server can accept plaintext credentials
''' from a client, call LogonUser, verify that the user can access the system across the network, and still
''' communicate with other servers.
''' NOTE: Windows NT: This value is not supported.
''' </summary>
LOGON32_LOGON_NETWORK_CLEARTEXT = 8
''' <summary>
''' This logon type allows the caller to clone its current token and specify new credentials for outbound connections.
''' The new logon session has the same local identifier but uses different credentials for other network connections.
''' NOTE: This logon type is supported only by the LOGON32_PROVIDER_WINNT50 logon provider.
''' NOTE: Windows NT: This value is not supported.
''' </summary>
LOGON32_LOGON_NEW_CREDENTIALS = 9
End Enum
<DllImport("advapi32.dll", SetLastError:=True, CharSet:=CharSet.Unicode)> _
Private Shared Function LogonUser(lpszUsername As [String], lpszDomain As [String], lpszPassword As [String], dwLogonType As Integer, dwLogonProvider As Integer, ByRef phToken As SafeTokenHandle) As Boolean
End Function
Public Sub New(Domain As String, UserName As String, Password As String, Optional LogonType As LogonTypes = LogonTypes.LOGON32_LOGON_INTERACTIVE)
Dim ok = LogonUser(UserName, Domain, Password, LogonType, 0, _SafeTokenHandle)
If Not ok Then
Dim errorCode = Marshal.GetLastWin32Error()
Throw New ApplicationException(String.Format("Could not impersonate the elevated user. LogonUser returned error code {0}.", errorCode))
End If
WindowsImpersonationContext = WindowsIdentity.Impersonate(_SafeTokenHandle.DangerousGetHandle())
End Sub
Private ReadOnly _SafeTokenHandle As New SafeTokenHandle
Private ReadOnly WindowsImpersonationContext As WindowsImpersonationContext
Public Sub Dispose() Implements System.IDisposable.Dispose
Me.WindowsImpersonationContext.Dispose()
Me._SafeTokenHandle.Dispose()
End Sub
Public NotInheritable Class SafeTokenHandle
Inherits SafeHandleZeroOrMinusOneIsInvalid
<DllImport("kernel32.dll")> _
<ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)> _
<SuppressUnmanagedCodeSecurity()> _
Private Shared Function CloseHandle(handle As IntPtr) As <MarshalAs(UnmanagedType.Bool)> Boolean
End Function
Public Sub New()
MyBase.New(True)
End Sub
Protected Overrides Function ReleaseHandle() As Boolean
Return CloseHandle(handle)
End Function
End Class
End Class
Debe utilizarlo con una Using
declaración que contenga algún código para ejecutarlo suplantado.