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

TypeNameTypeName AptcaMethodsShouldOnlyCallAptcaMethodsAptcaMethodsShouldOnlyCallAptcaMethods
CheckIdCheckId CA2116CA2116
CategoryCategory Microsoft.SecurityMicrosoft.Security
Modification avec ruptureBreaking Change RuptureBreaking

CauseCause

Une méthode dans un assembly avec le System.Security.AllowPartiallyTrustedCallersAttribute attribut appelle une méthode dans un assembly qui n’a pas l’attribut.A method in an assembly with the System.Security.AllowPartiallyTrustedCallersAttribute attribute calls a method in an assembly that does not have the attribute.

Description de la règleRule description

Par défaut, les méthodes publiques ou protégées dans les assemblys avec noms forts sont implicitement protégés par un demandes de liaison de confiance totale ; uniquement de confiance suffisant pour les appelants peuvent accéder à un assembly avec nom fort.By default, public or protected methods in assemblies with strong names are implicitly protected by a Link Demands for full trust; only fully trusted callers can access a strong-named assembly. 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 de liaison, ce qui rend l’assembly accessible aux appelants qui n’ont pas de confiance totale, comme le code exécuté à partir d’un intranet ou Internet.The attribute disables the link demand, making the assembly accessible to callers that do not have full trust, such as code executing from an intranet or the Internet.

Lorsque l’attribut APTCA est présent sur un assembly entièrement fiable, et l’assembly exécute le code dans un autre assembly 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 the assembly executes code in another assembly that does not allow partially trusted callers, a security exploit is possible. Si deux méthodes M1 et M2 remplir les conditions suivantes, des appelants malveillants peuvent utiliser la méthode M1 pour ignorer la demande de liaison de confiance totale implicite qui protège M2:If two methods M1 and M2 meet the following conditions, malicious callers can use the method M1 to bypass the implicit full trust link demand that protects M2:

  • M1 une méthode publique est déclarée dans un assembly entièrement fiable qui possède l’attribut APTCA.M1 is a public method declared in a fully trusted assembly that has the APTCA attribute.

  • M1 appelle une méthode M2 en dehors de M1d’assembly.M1 calls a method M2 outside M1's assembly.

  • M2d’assembly n’a pas l’attribut APTCA et, par conséquent, ne doit pas être exécuté par ou pour le compte des appelants partiellement approuvés.M2's assembly does not have the APTCA attribute and, therefore, should not be executed by or on behalf of callers that are partially trusted.

Un appelant de confiance partiel X peut appeler méthode M1, ce qui provoque M1 pour appeler M2.A partially trusted caller X can call method M1, causing M1 to call M2. Étant donné que M2 n’a pas l’attribut APTCA, son appelant immédiat (M1) doit satisfaire une demande de liaison pour la confiance totale ; M1 dispose d’une confiance totale et par conséquent satisfait cette vérification.Because M2 does not have the APTCA attribute, its immediate caller (M1) must satisfy a link demand for full trust; M1 has full trust and therefore satisfies this check. Le risque de sécurité est car X ne contribue pas à satisfaire la demande de liaison qui protège M2 provenant d’appelants non approuvés.The security risk is because X does not participate in satisfying the link demand that protects M2 from untrusted callers. Par conséquent, les méthodes avec l’attribut APTCA ne doivent pas appeler les méthodes qui n’ont pas l’attribut.Therefore, methods with the APTCA attribute must not call methods that do not have the attribute.

Comment corriger les violationsHow to fix violations

Si l’attribut APCTA est requis, utilisez une demande pour protéger la méthode qui appelle l’assembly de confiance totale.If the APCTA attribute is required, use a demand to protect the method that calls into the full trust assembly. Les autorisations exactes à la demande vous dépend de la fonctionnalité exposée par votre méthode.The exact permissions you demand will depend on the functionality exposed by your method. S’il est possible, protégez la méthode avec une demande de confiance totale pour s’assurer que la fonctionnalité sous-jacente n’est pas exposée aux appelants partiellement approuvés.If it is possible, protect the method with a demand for full trust to ensure that the underlying functionality is not exposed to partially trusted callers. Si ce n’est pas possible, sélectionnez un jeu d’autorisations qui protègent efficacement les fonctionnalités exposées.If this is not possible, select a set of permissions that effectively protects the exposed functionality.

Quand supprimer les avertissementsWhen to suppress warnings

Pour supprimer sans risque un avertissement de cette règle, vous devez vous assurer que la fonctionnalité exposée par votre méthode de ne pas, directement ou indirectement, permet aux appelants d’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 the functionality exposed by your method does not directly or indirectly allow callers to access sensitive information, operations, or resources that can be used in a destructive manner.

Exemple 1Example 1

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 accessible aux appelants partiellement approuvés (représenté par M2 dans la discussion précédente).The first assembly does not have the APTCA attribute and should not be accessible to partially trusted callers (represented by M2 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 and does 
// not allow partially trusted callers. 

namespace AptcaTestLibrary
{
   public class ClassRequiringFullTrust
   {
      public static void DoWork()
      {
        Console.WriteLine("ClassRequiringFullTrust.DoWork was called.");
      }
   }
}

Exemple 2Example 2

Le deuxième assembly est entièrement fiable et permet aux appelants de confiance partielle (représenté par M1 dans la discussion précédente).The second assembly is fully trusted and allows partially trusted callers (represented by M1 in the previous discussion).

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

// This assembly executes with full trust and 
// allows partially trusted callers. 

[assembly:AllowPartiallyTrustedCallers]  

namespace AptcaTestLibrary
{
   public class AccessAClassRequiringFullTrust
   {
      public static void Access()
      {    
         // This security check fails if the caller 
         // does not have full trust. 
         NamedPermissionSet pset= new NamedPermissionSet("FullTrust");

         // This try-catch block shows the caller's permissions.
         // Correct code would either not catch the exception,
         // or would rethrow it.
         try 
         {
            pset.Demand();
         }
         catch (SecurityException e)
         {
            Console.WriteLine("Demand for full trust:{0}", e.Message);
         }
         // Call the type that requires full trust.
         // Violates rule AptcaMethodsShouldOnlyCallAptcaMethods.
         ClassRequiringFullTrust.DoWork();
     }
   }
}

Exemple 3Example 3

L’application de test (représentée par X dans la discussion précédente) est partiellement approuvé.The test application (represented by X in the previous discussion) is partially trusted.

using System;
using AptcaTestLibrary;

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

namespace TestSecLibrary
{
   class TestApctaMethodRule
   {
      public static void Main()
      {
          // Indirectly calls DoWork in the full-trust class.
          ClassRequiringFullTrust testClass = new ClassRequiringFullTrust();
          testClass.Access();
      }
   }
}

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

Demand for full trust:Request failed.
ClassRequiringFullTrust.DoWork was called.

Voir aussiSee also