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

Article
08/10/2011

TypeName	AptcaMethodsShouldOnlyCallAptcaMethods
CheckId	CA2116
Catégorie	Microsoft.Security
Modification avec rupture	Oui

Cause

Une méthode dans un assembly doté de l'attribut System.Security.AllowPartiallyTrustedCallersAttribute appelle une méthode dans un assembly qui en est dépourvu.

Description de la règle

Par défaut, des méthodes publiques ou protégées dans les assemblys dotés de noms forts sont protégées implicitement par un Demandes de liaison de confiance totale ; seuls des appelants dotés d'une confiance totale peuvent accéder à un assembly à nom fort. Les assemblys dotés de noms forts marqués de l'attribut AllowPartiallyTrustedCallersAttribute (APTCA) n'ont pas cette protection. L'attribut désactive la demande de liaison, rendant ainsi l'assembly accessible aux appelants qui ne disposent pas d'une confiance totale, notamment les codes qui s'exécutent depuis un intranet ou 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 satisfont les conditions suivantes, des appelants malveillants peuvent utiliser la méthode M1 pour contourner la demande de liaison de confiance totale implicite qui protège le type M2 :

M1 est une méthode publique déclarée dans un assembly doté d'une confiance totale et de l'attribut APTCA.
M1 appelle une méthode M2 située à l'extérieur de l'assembly de M1.
L'assembly de M2 ne dispose pas de l'attribut APTCA et, par conséquent, ne doit pas être exécuté par des appelants dotés d'une confiance partiellement ni en leur nom.

Un appelant doté d'une confiance partielle X peut appeler la méthode M1, provoquant l'appel à M2 par M1. Sachant que M2 est dépourvu d'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 ce contrôle. En termes de sécurité, le problème tient dans ce que X ne contribue pas à satisfaire la demande de liaison qui protège M2 des appelants non approuvés. Par conséquent, les méthodes dotées de l'attribut APTCA ne doivent pas appeler de méthodes qui en sont dépourvues.

Comment corriger les violations

Si l'attribut APCTA est requis, utilisez une demande pour protéger la méthode qui effectue l'appel dans l'assembly doté d'une confiance totale. Les autorisations exactes que vous demandez dépendent des fonctionnalités exposées par votre méthode. Autant que faire se peut, protégez la méthode avec une demande de confiance totale pour vous assurer que les fonctionnalités sous-jacentes ne sont pas exposées à des appelants dotés d'une confiance partiellement. Si vous ne le pouvez pas, sélectionnez un jeu d'autorisations qui protègent efficacement les fonctionnalités exposées. Pour plus d'informations sur les demandes, consultez Demandes.

Quand supprimer les avertissements

Pour supprimer sans risque un avertissement de cette règle, vous devez vous assurer que la fonctionnalité exposée par votre méthode ne donne pas, directement ou indirectement, aux appelants un accès à des informations, des opérations ou des ressources sensibles, susceptibles d'être utilisées de façon destructrice.

Exemple

L'exemple suivant utilise deux assemblys et une application de test pour illustrer la faille de sécurité détectée par cette règle. Le premier assembly ne dispose pas de l'attribut APTCA et ne doit pas être accessible à des appelants dotés d'une confiance partielle (représentés par M2 dans l'exposé précédent).

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.");
      }
   }
}

Le second assembly, représenté par M1 dans l'exposé précédent, est doté d'une confiance totale et autorise des appelants dotés d'une confiance partielle.

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();
     }
   }
}

L'application de test (représentée par X dans l'examen précédent) est dotée d'une confiance partielle.

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 :