Calificación:
  • 0 voto(s) - 0 Media
  • 1
  • 2
  • 3
  • 4
  • 5
[Tutorial] C# Seguridad [Extremo]
#1
Tutorial de seguridad
Visual Studio .NET 2003
Este tutorial trata de la seguridad en .NET Framework y muestra dos formas de modificar los permisos de seguridad en C#: seguridad imperativa y declarativa.

Archivos de ejemplo

Vea Ejemplo de seguridad para descargar y generar los archivos de ejemplo que se utilizan en este tutorial.

Información adicional

Proteger una aplicación
Permisos
Directiva de seguridad
Comprobaciones de seguridad basada en funciones
Demandas de seguridad
Demandas
Tutorial

La mayoría de los programadores de componentes y aplicaciones no tienen por qué hacer nada especial para poder trabajar con el sistema de seguridad de .NET Framework y beneficiarse de la protección que ofrece.

Una excepción, que requiere un conocimiento más en profundidad y una consideración especial del sistema de seguridad, la componen las bibliotecas seguras. Este tipo de código representa el límite entre el código administrado seguro y el código no restringido, como el código nativo (es decir, aquel que la infraestructura de seguridad de .NET Framework no puede garantizar). Estas bibliotecas suelen requerir un alto nivel de confianza para su utilización, y son el único lugar en el código administrado donde un error de programación puede exponer potencialmente una vulnerabilidad en materia de seguridad. La seguridad del acceso al código no puede eliminar el potencial de los errores humanos; sin embargo, en comparación con el volumen mucho mayor de código de aplicación que utiliza unas pocas bibliotecas seguras, la cantidad de código que requiere un examen más detenido se reduce enormemente.

Ejemplos

El tutorial incluye los siguientes ejemplos:

Ejemplo 1: seguridad imperativa
Ejemplo 2: seguridad declarativa
Ejemplo 3: Supresión de seguridad
Seguridad

La seguridad de .NET Framework protege el código y los datos de su incorrecta utilización o de los daños que pueda causar otro código, al aplicar restricciones de seguridad en el código administrado. Cuando una aplicación de .NET Framework solicita permisos, la directiva de seguridad establecida por el administrador concede los permisos o rechaza ejecutar el código. La confianza se basa en las pruebas que aporte el código, como por ej. una firma digital, la procedencia del código, etc. Una vez concedida la confianza, la directiva de seguridad aplica permisos que controlan lo que se permite realizar al código (y, de no concederse, lo que no se le permite).

Permisos

La seguridad de .NET Framework permite la utilización de recursos protegidos en el código sólo si éste dispone de "permiso" para ello. Para expresarlo de otra forma, .NET Framework usa los conceptos de permisos, que representan el derecho del código desarrollado por un programador a obtener acceso a recursos protegidos. El código solicita los permisos que necesita, y la directiva de seguridad aplicada por .NET Framework determina qué permisos se conceden efectivamente al código.

.NET Framework proporciona al código diferentes clases de permisos de acceso, cada una de las cuales encapsula la capacidad de tener acceso a un recurso particular. Se pueden utilizar estos permisos para indicar a .NET Framework la autorización que requiere el código, así como aquello que está autorizado a hacer cualquier tipo de código que llame a nuestro código. La directiva también utiliza estos objetos para determinar qué permisos conceder al código.

Directiva

La aplicación de una directiva de seguridad es lo que convierte en seguro el código administrado de .NET Framework. Cada ensamblado que se carga está sujeto a una directiva de seguridad que concede permisos de código basados en la confianza, estando ésta basada en las pruebas aportadas por el código. Vea la documentación de .NET Framework en la lista Información adicional para obtener más información sobre cómo administrar la directiva de seguridad.

Solicitar permisos de seguridad en C#

Hay dos maneras de solicitar permisos de seguridad en C#:

Imperativamente: mediante llamadas a clases de permisos de .NET Framework
Declarativamente: mediante atributos de permisos de seguridad
Los dos ejemplos siguientes muestran estos dos modelos. Para obtener más información sobre la solicitud de permisos de seguridad, vea Demandas.

Ejemplo 1: seguridad imperativa

El siguiente es un ejemplo de uso de llamadas a .NET Framework para denegar el permiso UnmanagedCode.

// ImperativeSecurity.cs
using System;
using System.Security;
using System.Security.Permissions;
using System.Runtime.InteropServices;

class NativeMethods
{
// This is a call to unmanaged code. Executing this method requires
// the UnmanagedCode security permission. Without this permission
// an attempt to call this method will throw a SecurityException:
[DllImport("msvcrt.dll")]
public static extern int puts(string str);
[DllImport("msvcrt.dll")]
internal static extern int _flushall();
}

class MainClass
{
private static void CallUnmanagedCodeWithoutPermission()
{
// Create a security permission object to describe the
// UnmanagedCode permission:
SecurityPermission perm =
new SecurityPermission(SecurityPermissionFlag.UnmanagedCode);

// Deny the UnmanagedCode from our current set of permissions.
// Any method that is called on this thread until this method
// returns will be denied access to unmanaged code.
// Even though the CallUnmanagedCodeWithPermission method
// is called from a stack frame that already
// calls Assert for unmanaged code, you still cannot call native
// code. Because you use Deny here, the permission gets
// overwritten.
perm.Deny();

try
{
Console.WriteLine("Attempting to call unmanaged code without permission.");
NativeMethods.puts("Hello World!");
NativeMethods._flushall();
Console.WriteLine("Called unmanaged code without permission. Whoops!");
}
catch (SecurityException)
{
Console.WriteLine("Caught Security Exception attempting to call unmanaged code.");
}
}

private static void CallUnmanagedCodeWithPermission()
{
// Create a security permission object to describe the
// UnmanagedCode permission:
SecurityPermission perm =
new SecurityPermission(SecurityPermissionFlag.UnmanagedCode);

// Check that you have permission to access unmanaged code.
// If you don't have permission to access unmanaged code, then
// this call will throw a SecurityException.
// Even though the CallUnmanagedCodeWithPermission method
// is called from a stack frame that already
// calls Assert for unmanaged code, you still cannot call native
// code. Because you use Deny here, the permission gets
// overwritten.
perm.Assert();

try
{
Console.WriteLine("Attempting to call unmanaged code with permission.");
NativeMethods.puts("Hello World!");
NativeMethods._flushall();
Console.WriteLine("Called unmanaged code with permission.");
}
catch (SecurityException)
{
Console.WriteLine("Caught Security Exception attempting to call unmanaged code. Whoops!");
}
}

public static void Main()
{
// The method itself will call the security permission Deny
// for unmanaged code, which will override the Assert permission
// in this stack frame.
SecurityPermission perm = new
SecurityPermission(SecurityPermissionFlag.UnmanagedCode);
perm.Assert();
CallUnmanagedCodeWithoutPermission();

// The method itself will call the security permission Assert
// for unmanaged code, which will override the Deny permission in
// this stack frame.
perm.Deny();
CallUnmanagedCodeWithPermission();
}
}
Resultado

Attempting to call unmanaged code without permission.
Caught Security Exception attempting to call unmanaged code.
Attempting to call unmanaged code with permission.
Hello World!
Called unmanaged code with permission.
Ejemplo 2: seguridad declarativa

Éste es el mismo ejemplo, pero utilizando atributos para los permisos de seguridad

// DeclarativeSecurity.cs
using System;
using System.Security;
using System.Security.Permissions;
using System.Runtime.InteropServices;

class NativeMethods
{
// This is a call to unmanaged code. Executing this method requires
// the UnmanagedCode security permission. Without this permission,
// an attempt to call this method will throw a SecurityException:
[DllImport("msvcrt.dll")]
public static extern int puts(string str);
[DllImport("msvcrt.dll")]
internal static extern int _flushall();
}

class MainClass
{
// The security permission attached to this method will deny the
// UnmanagedCode permission from the current set of permissions for
// the duration of the call to this method:
// Even though the CallUnmanagedCodeWithoutPermission method is
// called from a stack frame that already calls
// Assert for unmanaged code, you still cannot call native code.
// Because this function is attached with the Deny permission for
// unmanaged code, the permission gets overwritten.
[SecurityPermission(SecurityAction.Deny, Flags =
SecurityPermissionFlag.UnmanagedCode)]
private static void CallUnmanagedCodeWithoutPermission()
{
try
{
Console.WriteLine("Attempting to call unmanaged code without permission.");
NativeMethods.puts("Hello World!");
NativeMethods._flushall();
Console.WriteLine("Called unmanaged code without permission. Whoops!");
}
catch (SecurityException)
{
Console.WriteLine("Caught Security Exception attempting to call unmanaged code.");
}
}

// The security permission attached to this method will force a
// runtime check for the unmanaged code permission whenever
// this method is called. If the caller does not have unmanaged code
// permission, then the call will generate a Security Exception.
// Even though the CallUnmanagedCodeWithPermission method is called
// from a stack frame that already calls
// Deny for unmanaged code, it will not prevent you from calling
// native code. Because this method is attached with the Assert
// permission for unmanaged code, the permission gets overwritten.
[SecurityPermission(SecurityAction.Assert, Flags =
SecurityPermissionFlag.UnmanagedCode)]
private static void CallUnmanagedCodeWithPermission()
{
try
{
Console.WriteLine("Attempting to call unmanaged code with permission.");
NativeMethods.puts("Hello World!");
NativeMethods._flushall();
Console.WriteLine("Called unmanaged code with permission.");
}
catch (SecurityException)
{
Console.WriteLine("Caught Security Exception attempting to call unmanaged code. Whoops!");
}
}

public static void Main()
{
SecurityPermission perm = new
SecurityPermission(SecurityPermissionFlag.UnmanagedCode);

// The method itself is attached with the security permission
// Deny for unmanaged code, which will override
// the Assert permission in this stack frame.
perm.Assert();
CallUnmanagedCodeWithoutPermission();

// The method itself is attached with the security permission
// Assert for unmanaged code, which will override the Deny
// permission in this stack frame.
perm.Deny();
CallUnmanagedCodeWithPermission();
}
}
Resultado

Attempting to call unmanaged code without permission.
Caught Security Exception attempting to call unmanaged code.
Attempting to call unmanaged code with permission.
Hello World!
Called unmanaged code with permission.
Seguridad y rendimiento

El sistema de seguridad de .NET Framework impide la descarga de código malintencionado desde la red, capaz de dañar su sistema informático. No obstante, estas comprobaciones de seguridad conllevan un costo, aun cuando su código nunca inicie una excepción de seguridad SecurityException.

Normalmente Common Language Runtime comprueba que el llamador de un método no administrado tenga permisos de acceso a código no administrado en tiempo de ejecución, para cada una de las llamadas al método administrado. Esto puede resultar muy costoso en aplicaciones que realizan muchas llamadas a código no administrado. El atributo SuppressUnmanagedCodeSecurityAttribute cambia este comportamiento predeterminado. Al declarar un método no administrado con este atributo, se comprueba la demanda de seguridad cuando el código que llama al método se carga en Common Language Runtime.

Nota de seguridad Al utilizar el atributo SuppressUnmanagedCodeSecurityAttribute, se debe tener especial cuidado para garantizar que no se está creando un vacío de seguridad. Por ejemplo, el programador necesita comprobar que está utilizando la API de código no administrado con seguridad y que los llamadores no podrán influir o realizar un uso no previsto de la llamada. Como alternativa, se puede agregar una demanda apropiada para asegurarse de que todos los llamadores poseen los permisos adecuados. Por ejemplo, si se realiza una llamada a código nativo para obtener acceso a un archivo (con el fin de aprovechar el almacenamiento estructurado como las propiedades de archivo extendidas, etc.) y se suprime la demanda de código no administrado, cualquier demanda de E/S de archivos deberá ser explícita para garantizar que no se utilice incorrectamente el código.
Ejemplo 3: Optimizar llamadas no administradas

En este ejemplo, la comprobación del permiso de código no administrado se ejecuta una vez en el momento de la carga, en lugar de en cada llamada al método no administrado. Si se llama al método no administrado en repetidas ocasiones, esto puede implicar una considerable pérdida del rendimiento.

// SuppressSecurity.cs
using System;
using System.Security;
using System.Security.Permissions;
using System.Runtime.InteropServices;

class NativeMethods
{
// This is a call to unmanaged code. Executing this method requires
// the UnmanagedCode security permission. Without this permission,
// an attempt to call this method will throw a SecurityException:
/* NOTE: The SuppressUnmanagedCodeSecurityAttribute disables the
check for the UnmanagedCode permission at runtime. Be Careful! */
[SuppressUnmanagedCodeSecurityAttribute()]
[DllImport("msvcrt.dll")]
internal static extern int puts(string str);
[SuppressUnmanagedCodeSecurityAttribute()]
[DllImport("msvcrt.dll")]
internal static extern int _flushall();
}

class MainClass
{
// The security permission attached to this method will remove the
// UnmanagedCode permission from the current set of permissions for
// the duration of the call to this method.
// Even though the CallUnmanagedCodeWithoutPermission method is
// called from a stack frame that already calls
// Assert for unmanaged code, you still cannot call native code.
// Because this method is attached with the Deny permission for
// unmanaged code, the permission gets overwritten. However, because
// you are using SuppressUnmanagedCodeSecurityAttribute here, you can
// still call the unmanaged methods successfully.
// The code should use other security checks to ensure that you don't
// incur a security hole.
[SecurityPermission(SecurityAction.Deny, Flags =
SecurityPermissionFlag.UnmanagedCode)]
private static void CallUnmanagedCodeWithoutPermission()
{
try
{
// The UnmanagedCode security check is disbled on the call
// below. However, the unmanaged call only displays UI. The
// security will be ensured by only allowing the unmanaged
// call if there is a UI permission.
UIPermission uiPermission =
new UIPermission(PermissionState.Unrestricted);
uiPermission.Demand();

Console.WriteLine("Attempting to call unmanaged code without UnmanagedCode permission.");
NativeMethods.puts("Hello World!");
NativeMethods._flushall();
Console.WriteLine("Called unmanaged code without UnmanagedCode permission.");
}
catch (SecurityException)
{
Console.WriteLine("Caught Security Exception attempting to call unmanaged code.");
}
}

// The security permission attached to this method will add the
// UnmanagedCode permission to the current set of permissions for the
// duration of the call to this method.
// Even though the CallUnmanagedCodeWithPermission method is called
// from a stack frame that already calls
// Deny for unmanaged code, it will not prevent you from calling
// native code. Because this method is attached with the Assert
// permission for unmanaged code, the permission gets overwritten.
// Because you are using SuppressUnmanagedCodeSecurityAttribute here,
// you can call the unmanaged methods successfully.
// The SuppressUnmanagedCodeSecurityAttribute will let you succeed,
// even if you don't have a permission.
[SecurityPermission(SecurityAction.Assert, Flags =
SecurityPermissionFlag.UnmanagedCode)]
private static void CallUnmanagedCodeWithPermission()
{
try
{
Console.WriteLine("Attempting to call unmanaged code with permission.");
NativeMethods.puts("Hello World!");
NativeMethods._flushall();
Console.WriteLine("Called unmanaged code with permission.");
}
catch (SecurityException)
{
Console.WriteLine("Caught Security Exception attempting to call unmanaged code. Whoops!");
}
}

public static void Main()
{
SecurityPermission perm = new
SecurityPermission(SecurityPermissionFlag.UnmanagedCode);

// The method itself is attached with the security permission Deny
// for unmanaged code, which will override the Assert permission in
// this stack frame. However, because you are using
// SuppressUnmanagedCodeSecurityAttribute, you can still call the
// unmanaged methods successfully.
// The code should use other security checks to ensure that you
// don't incur a security hole.
perm.Assert();
CallUnmanagedCodeWithoutPermission();

// The method itself is attached with the security permission
// Assert for unmanaged code, which will override the Deny
// permission in this stack frame. Because you are using
// SuppressUnmanagedCodeSecurityAttribute, you can call the
// unmanaged methods successfully.
// The SuppressUnmanagedCodeSecurityAttribute will let you succeed,
// even if you don't have a permission.
perm.Deny();
CallUnmanagedCodeWithPermission();
}
}
Resultado

Attempting to call unmanaged code without UnmanagedCode permission.
Hello World!
Called unmanaged code without UnmanagedCode permission.
Attempting to call unmanaged code with permission.
Hello World!
Called unmanaged code with permission.
Descripción del código

Observe en el ejemplo anterior que se permiten ambas llamadas no administradas aun cuando la primera de ellas no tiene el permiso UnmanagedCode. Al utilizar el atributo SuppressUnmanagedCodeSecurityAttribute se deben usar otras comprobaciones de seguridad para garantizar que no se va a incurrir en un vacío de seguridad. En el ejemplo precedente esto tiene lugar agregando la demanda (Demand) para el permiso UIPermission:

uiPermission.Demand();
antes de la llamada no administrada, lo cual asegura que el llamador tiene permiso para mostrar la interfaz de usuario.
#2
gracias, lo tomare en cuenta
#3
¡Tremendo!. Tengo que probar.
PD:¿Como sería algo parecido en vb.net?
WWW
#4
aver que puedo decir xD si toy usandolo pera en breve posteo si me Sirve (Y)
WWW


Posibles temas similares...
Tema Autor Respuestas Vistas Último mensaje
Información [Tutorial] Certificado SSL Gratis StartSSL 2016 Tutorial DarkMaster 26 4,741 28-04-2016, 03:39 AM
Último mensaje: Lob3zNo
Bombilla [Tutorial] SSL Gratis, Conseguir e Instalar Certificado DarkMaster 16 794 06-01-2016, 01:32 AM
Último mensaje: DarkMaster
  [Duda] COPIA DE SEGURIDAD PÁGINA WEB pedrovillarraga 8 303 02-08-2015, 04:12 PM
Último mensaje: YamaT
Bombilla copia de seguridad paginas web pedrovillarraga 1 170 02-05-2015, 09:42 AM
Último mensaje: Vicen
  Comprobar seguridad de la web con php TOMMYNRH 8 1,057 29-04-2015, 04:38 PM
Último mensaje: bseca
  [PUBLICO] Tutorial Botones con perspectiva 3D AngelKrak 0 204 17-01-2015, 05:44 AM
Último mensaje: AngelKrak
  seguridad en .httacess truzst23 16 1,557 27-08-2014, 06:32 PM
Último mensaje: TheBomberbe
Arcoiris Enseñe a los niños los fundamentos de la seguridad en línea R0bert0 2 348 10-08-2014, 05:09 AM
Último mensaje: habacuc78
  Estados Unidos reconoció que utiliza fallas de seguridad omegle23 17 949 06-06-2014, 05:44 AM
Último mensaje: yayito21
  [Tutorial] Aumentar el Tamaño Máximo al Cargar Archivos con PHP y Apache papanoel 0 646 22-01-2014, 04:38 AM
Último mensaje: papanoel



Usuarios navegando en este tema: 1 invitado(s)