CA2117 : Les types APTCA doivent uniquement étendre des types de base APTCACA2117: APTCA types should only extend APTCA base types

TypeNameTypeName AptcaTypesShouldOnlyExtendAptcaBaseTypesAptcaTypesShouldOnlyExtendAptcaBaseTypes
CheckIdCheckId CA2117CA2117
CategoryCategory Microsoft.SecurityMicrosoft.Security
Modification avec ruptureBreaking Change RuptureBreaking

CauseCause

Un type public ou protégé dans un assembly avec le System.Security.AllowPartiallyTrustedCallersAttribute attribut hérite d’un type déclaré dans un assembly qui n’a pas l’attribut.A public or protected type in an assembly with the System.Security.AllowPartiallyTrustedCallersAttribute attribute inherits from a type declared in an assembly that does not have the attribute.

Description de la règleRule description

Par défaut, les types publics ou protégés dans les assemblys avec noms forts sont implicitement protégés par un InheritanceDemand pour la confiance totale.By default, public or protected types in assemblies with strong names are implicitly protected by an InheritanceDemand for full trust. Assemblys avec nom fort est marqué avec le AllowPartiallyTrustedCallersAttribute attribut (APTCA) n’ont pas cette protection.Strong-named assemblies marked with the AllowPartiallyTrustedCallersAttribute (APTCA) attribute do not have this protection. L’attribut désactive la demande d’héritage.The attribute disables the inheritance demand. Types exposés déclarées dans un assembly sans une demande d’héritage peuvent être héritées par les types qui n’ont pas de confiance totale.Exposed types declared in an assembly without an inheritance demand are inheritable by types that do not have full trust.

Lorsque l’attribut APTCA est présent sur un assembly entièrement fiable, et un type dans l’assembly hérite d’un type qui n’autorise pas les appelants partiellement approuvés, une faille de sécurité est possible.When the APTCA attribute is present on a fully trusted assembly, and a type in the assembly inherits from a type that does not allow partially trusted callers, a security exploit is possible. Si deux types T1 et T2 remplir les conditions suivantes, des appelants malveillants peuvent utiliser le type T1 pour contourner la demande de l’héritage de confiance totale implicite qui protège T2:If two types T1 and T2 meet the following conditions, malicious callers can use the type T1 to bypass the implicit full trust inheritance demand that protects T2:

  • T1 un type public est déclaré dans un assembly entièrement fiable qui possède l’attribut APTCA.T1 is a public type declared in a fully trusted assembly that has the APTCA attribute.

  • T1 hérite d’un type T2 hors de son assembly.T1 inherits from a type T2 outside its assembly.

  • T2d’assembly n’a pas l’attribut APTCA et, doit donc pas être héritée par les types dans les assemblys de confiance partiel.T2's assembly does not have the APTCA attribute and, therefore, should not be inheritable by types in partially trusted assemblies.

Un type de niveau de confiance partiel X peut hériter de T1, ce qui lui donne accès aux membres hérités déclarés dans T2.A partially trusted type X can inherit from T1, which gives it access to inherited members declared in T2. Étant donné que T2 n’a pas l’attribut APTCA, son type dérivé immédiat (T1) doit satisfaire une demande d’héritage pour une confiance totale ; T1 dispose d’une confiance totale et par conséquent satisfait cette vérification.Because T2 does not have the APTCA attribute, its immediate derived type (T1) must satisfy an inheritance demand for full trust; T1 has full trust and therefore satisfies this check. Le risque de sécurité est car X ne participe pas à satisfaire la demande d’héritage qui protège T2 à partir de sous-classement non approuvé.The security risk is because X does not participate in satisfying the inheritance demand that protects T2 from untrusted subclassing. Pour cette raison, les types avec l’attribut APTCA ne doivent pas étendre les types qui n’ont pas l’attribut.For this reason, types with the APTCA attribute must not extend types that do not have the attribute.

Un autre problème de sécurité et peut-être un plus courant, qui est le type dérivé (T1) peut, par le biais des erreurs de programmation, exposer des membres protégés du type qui requiert une confiance totale (T2).Another security issue, and perhaps a more common one, is that the derived type (T1) can, through programmer error, expose protected members from the type that requires full trust (T2). Lorsque cette exposition se produit, les appelants non approuvés ont accès aux informations qui doivent être disponibles uniquement aux types de niveau de confiance suffisant.When this exposure occurs, untrusted callers gain access to information that should be available only to fully trusted types.

Comment corriger les violationsHow to fix violations

Si le type indiqué par la violation est dans un assembly qui ne nécessite pas l’attribut APTCA, supprimez-le.If the type reported by the violation is in an assembly that does not require the APTCA attribute, remove it.

Si l’attribut APTCA est requis, ajoutez une demande d’héritage pour une confiance totale pour le type.If the APTCA attribute is required, add an inheritance demand for full trust to the type. La demande d’héritage protège contre l’héritage par les types non approuvés.The inheritance demand protects against inheritance by untrusted types.

Il est possible de corriger une violation en ajoutant l’attribut APTCA pour les assemblys des types de base signalés par la violation.It is possible to fix a violation by adding the APTCA attribute to the assemblies of the base types reported by the violation. Ne le faites pas sans la première réalisation d’une révision de sécurité de tout le code dans les assemblys et de tout le code qui repose sur les assemblys.Do not do this without first conducting an intensive security review of all code in the assemblies and all code that depends on the assemblies.

Quand supprimer les avertissementsWhen to suppress warnings

Pour supprimer sans risque un avertissement de cette règle, vous devez vous assurer que les membres protégés exposés par votre type n’autorisent pas, directement ou indirectement, à des appelants non approuvés à accéder aux informations sensibles, des opérations ou des ressources qui peuvent être utilisées dans une action destructrice.To safely suppress a warning from this rule, you must ensure that protected members exposed by your type do not directly or indirectly allow untrusted callers to access sensitive information, operations, or resources that can be used in a destructive manner.

ExempleExample

L’exemple suivant utilise deux assemblys et une application de test pour illustrer la vulnérabilité de sécurité détectée par cette règle.The following example uses two assemblies and a test application to illustrate the security vulnerability detected by this rule. Le premier assembly n’a pas l’attribut APTCA et ne doit pas être hérité par les types de niveau de confiance partiel (représenté par T2 dans la discussion précédente).The first assembly does not have the APTCA attribute and should not be inheritable by partially trusted types (represented by T2 in the previous discussion).

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

// This code is compiled into a strong-named assembly
// that requires full trust. 

namespace AptcaTestLibrary
{
   public class ClassRequiringFullTrustWhenInherited
   {
      // This field should be overridable by fully trusted derived types.
      protected static string location = "shady glen";
     
      // A trusted type can see the data, but cannot change it.
      public virtual string TrustedLocation 
      {
         get 
         {
            return location;
         }
      }
   }
}

Le deuxième assembly, représenté par T1 dans la discussion précédente, est entièrement fiable, et permet aux appelants partiellement approuvés.The second assembly, represented by T1 in the previous discussion, is fully trusted and allows partially trusted callers.

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

// This class is compiled into an assembly that executes with full 
// trust and allows partially trusted callers. 

// Violates rule: AptcaTypesShouldOnlyExtendAptcaBaseTypes.

namespace AptcaTestLibrary
{
   public class InheritAClassRequiringFullTrust: 
      ClassRequiringFullTrustWhenInherited
   {
      private DateTime meetingDay = DateTime.Parse("February 22 2003");

      public override string ToString() 
      {
         // Another error:
         // This method gives untrusted callers the value 
         // of TrustedLocation. This information should 
         // only be seen by trusted callers.
         string s = String.Format(
            "Meet at the {0} {1}!", 
            this.TrustedLocation, meetingDay.ToString());
         return s;
      }
   }
}

Le type de test, représenté par X dans la discussion précédente, est dans un assembly partiellement approuvé.The test type, represented by X in the previous discussion, is in a partially trusted assembly.

using System;
using AptcaTestLibrary;

// If this test application is run from the local machine, 
//  it gets full trust by default.
// Remove full trust.
[assembly: System.Security.Permissions.PermissionSetAttribute(
   System.Security.Permissions.SecurityAction.RequestRefuse, Name = "FullTrust")]

namespace TestSecLibrary
{
    class InheritFromAFullTrustDecendent : ClassRequiringFullTrust
    {
        public InheritFromAFullTrustDecendent()
        {
            // This constructor maliciously overwrites the protected 
            // static member in the fully trusted class.
            // Trusted types will now get the wrong information from 
            // the TrustedLocation property.
            InheritFromAFullTrustDecendent.location = "sunny meadow";
        }

        public override string ToString()
        {
            return InheritFromAFullTrustDecendent.location;
        }
    }

    class TestApctaInheritRule
    {
        public static void Main()
        {
            ClassRequiringFullTrust iclass =
               new ClassRequiringFullTrust();
            Console.WriteLine(iclass.ToString());

            // You cannot create a type that inherits from the full trust type
            // directly, but you can create a type that inherits from 
            // the APTCA type which in turn inherits from the full trust type.

            InheritFromAFullTrustDecendent inherit =
               new InheritFromAFullTrustDecendent();
            //Show the inherited protected member has changed.
            Console.WriteLine("From Test: {0}", inherit.ToString());

            // Trusted types now get the wrong information from 
            // the TrustedLocation property.
            Console.WriteLine(iclass.ToString());
        }
    }
}

Cet exemple génère la sortie suivante :This example produces the following output:

Meet at the shady glen 2/22/2003 12:00:00 AM!
From Test: sunny meadow
Meet at the sunny meadow 2/22/2003 12:00:00 AM!

CA2116 : Les méthodes APTCA doivent appeler seulement des méthodes APTCACA2116: APTCA methods should only call APTCA methods

Voir aussiSee also