Share via

CA2112: Los tipos seguros no deben exponer campos

  • Artículo
Elemento Valor
RuleId CA2112
Category Microsoft.Security
Cambio importante Problemático

Causa

Un tipo público o protegido contiene campos públicos y está protegido por peticiones de vínculos.

Nota

Esta regla está en desuso. Para más información, consulte Reglas en desuso.

Descripción de la regla

Si el código tiene acceso a una instancia de tipo que está protegida por una solicitud de vínculo, el código no cumplirá la solicitud para obtener acceso a los campos del tipo.

Cómo corregir infracciones

Para corregir una infracción de esta regla, haga que los campos no sean públicos y agregue propiedades o métodos públicos que devuelvan los datos de los campos. Las comprobaciones de seguridad de LinkDemand en los tipos protegen el acceso a sus propiedades y métodos. Pero la seguridad de acceso del código no se aplica a los campos.

Cuándo suprimir las advertencias

Tanto para solucionar los problemas de seguridad como para tener un buen diseño, debe corregir las infracciones convirtiendo los campos públicos en no públicos. Puede suprimir una advertencia de esta regla si el campo no contiene información que deba permanecer protegida y no se basa en el contenido del campo.

Ejemplo

El ejemplo siguiente se compone de un tipo de biblioteca (SecuredTypeWithFields) con campos no seguros, un tipo (Distributor) que puede crear instancias del tipo de biblioteca y que pasa erróneamente instancias a tipos no tienen permiso para crearlas, y código de aplicación que puede leer los campos de una instancia aunque no tenga el permiso que protege el tipo.

El siguiente código de biblioteca infringe la regla.

using System;
using System.Reflection;
using System.Security;
using System.Security.Permissions;

namespace SecurityRulesLibrary
{
   // This code requires immediate callers to have full trust.
   [System.Security.Permissions.PermissionSetAttribute(
       System.Security.Permissions.SecurityAction.LinkDemand, 
       Name="FullTrust")]
   public class SecuredTypeWithFields 
   {
      // Even though the type is secured, these fields are not.
      // Violates rule: SecuredTypesShouldNotExposeFields.
      public double xValue;
      public double yValue;
      
      public SecuredTypeWithFields (double x, double y) 
      {
         xValue = x;
         yValue = y;
         Console.WriteLine(
            "Creating an instance of SecuredTypeWithFields.");
      }
      public override string ToString()
      {
          return String.Format (
            "SecuredTypeWithFields {0} {1}", xValue, yValue);
      }
   }
}

Ejemplo 1

La aplicación no puede crear una instancia debido a la petición de vínculo que protege el tipo protegido. La siguiente clase permite a la aplicación obtener una instancia del tipo protegido.

using System;
using System.Reflection;
using System.Security;
using System.Security.Permissions;

// This assembly executes with full trust. 

namespace SecurityRulesLibrary
{
   // This type creates and returns instances of the secured type.
   // The GetAnInstance method incorrectly gives the instance 
   // to a type that does not have the link demanded permission.

   public class Distributor
   {
      static SecuredTypeWithFields s = new SecuredTypeWithFields(22,33);
      public static SecuredTypeWithFields GetAnInstance ()
      {
            return s;
      }

      public static void DisplayCachedObject ()
      {
         Console.WriteLine(
            "Cached Object fields: {0}, {1}", s.xValue , s.yValue);
      }
   }
}

Ejemplo 2

En la aplicación siguiente se muestra cómo puede acceder el código a los campos de un tipo protegido sin permiso para acceder a sus métodos.

using System;
using System.Security;
using System.Security.Permissions;
using SecurityRulesLibrary;

// This code executes with partial trust.
[assembly: System.Security.Permissions.PermissionSetAttribute(
   System.Security.Permissions.SecurityAction.RequestRefuse,
   Name = "FullTrust")]
namespace TestSecurityExamples
{
    public class TestLinkDemandOnField
    {
        [STAThread]
        public static void Main()
        {
            // Get an instance of the protected object.
            SecuredTypeWithFields secureType = Distributor.GetAnInstance();

            // Even though this type does not have full trust,
            // it can directly access the secured type's fields.
            Console.WriteLine(
               "Secured type fields: {0}, {1}",
               secureType.xValue,
               secureType.yValue);
            Console.WriteLine("Changing secured type's field...");
            secureType.xValue = 99;

            // Distributor must call ToString on the secured object.
            Distributor.DisplayCachedObject();

            // If the following line is uncommented, a security 
            // exception is thrown at JIT-compilation time because 
            // of the link demand for full trust that protects 
            // SecuredTypeWithFields.ToString().

            // Console.WriteLine("Secured type {0}",secureType.ToString());
        }
    }
}

Este ejemplo produce el siguiente resultado:

Creating an instance of SecuredTypeWithFields.
Secured type fields: 22, 33
Changing secured type's field...
Cached Object fields: 99, 33

Consulte también