CA2116 : Les méthodes APTCA doivent uniquement appeler des méthodes APTCA

  • Article
Élément Valeur
ID de la règle CA2116
Category Microsoft.Security
Modification avec rupture Rupture

Cause

Une méthode dans un assembly avec l’attribut System.Security.AllowPartiallyTrustedCallersAttribute appelle une méthode dans un assembly qui n’a pas l’attribut.

Notes

Cette règle est déconseillée. Pour plus d’informations, consultez Règles dépréciées.

Description de la règle

Par défaut, les méthodes publiques ou protégées dans les assemblys avec des noms forts sont implicitement protégées par des Demandes de liaison pour une confiance totale ; seuls les appelants entièrement approuvés peuvent accéder à un assembly avec nom fort. Les assemblys aux noms forts marqués avec l’attribut AllowPartiallyTrustedCallersAttribute (APTCA) ne bénéficient pas de cette protection. L’attribut désactive la demande de liaison, rendant l’assembly accessible aux appelants qui n’ont pas une confiance totale, comme le code s’exécutant à partir d’un intranet ou d’Internet.

Lorsque l’attribut APTCA est présent sur un assembly doté d’une confiance totale, et lorsque cet assembly exécute un code dans un autre assembly qui n’autorise pas les appelants dotés d’une confiance partielle, il devient possible d’exploiter une faille dans la sécurité. Si deux méthodes M1 et M2 remplissent les conditions suivantes, les appelants malveillants peuvent utiliser la méthode M1 pour contourner la demande implicite de lien de confiance totale qui protège M2 :

  • M1 est une méthode publique déclarée dans un assembly entièrement approuvé qui a l’attribut APTCA.

  • M1 appelle une méthode M2 en dehors de l’assembly de M1.

  • L’assembly de M2 n’a pas l’attribut APTCA et, par conséquent, ne doit pas être exécuté par ou pour le compte d’appelants qui sont partiellement approuvés.

Un appelant partiellement approuvé X peut appeler la méthode M1, ce qui provoque l’appel M2 par M1. Étant donné que M2 n’a pas l’attribut APTCA, son appelant immédiat (M1) doit satisfaire une demande de liaison de confiance totale ; M1 a une confiance totale et satisfait donc à cette vérification. Le risque de sécurité est dû au fait que X ne participe pas à la satisfaction de la demande de liaison qui protège M2 contre les appelants non approuvés. Par conséquent, les méthodes avec l’attribut APTCA ne doivent pas appeler des méthodes qui n’ont pas l’attribut.

Comment corriger les violations

Si l’attribut APTCA est requis, utilisez une demande pour protéger la méthode qui appelle l’assembly de confiance totale. Les autorisations exactes que vous exigez dépendent des fonctionnalités exposées par votre méthode. Si possible, protégez la méthode avec une demande de confiance totale pour vous assurer que la fonctionnalité sous-jacente n’est pas exposée à des appelants partiellement approuvés. Si cela n’est pas possible, sélectionnez un ensemble d’autorisations qui protège efficacement les fonctionnalités exposées.

Quand supprimer les avertissements

Pour supprimer en toute sécurité un avertissement de cette règle, vous devez vous assurer que les fonctionnalités exposées par votre méthode n’autorisent pas directement ou indirectement les appelants à accéder à des informations sensibles, ou des opérations ou ressources pouvant être utilisées de manière destructrice.

Exemple 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. Le premier assembly n’a pas l’attribut APTCA et ne doit pas être accessible aux appelants partiellement approuvés (représentés par M2 dans la discussion précédente).

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 2

Le deuxième assembly est entièrement fiable et autorise les appelants partiellement approuvés (représentés par M1 dans la discussion précédente).

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 3

L’application de test (représentée par X dans la discussion précédente) est partiellement approuvée.

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 produit la sortie suivante :

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

Voir aussi