Tipos APTCA só devem estender APTCA tipos base

Causa

Um tipo público ou protegido em um assembly com o System.Security.AllowPartiallyTrustedCallersAttribute atributo herda de um tipo declarado em um assembly que não tem o atributo.

Descrição da regra

Por padrão, os tipos de públicos ou protegidos em assemblies com nomes fortes implicitamente são protegidos por um Demandas de herança confiança total. Assemblies de nomes de alta segurança marcados com o AllowPartiallyTrustedCallersAttribute Atributo (APTCA) não têm essa proteção. O atributo desativa a demanda de herança.Isso torna expostos tipos declarados no conjunto de módulos (assembly) herdados por tipos que não têm confiança total.

Quando o atributo APTCA estiver presente em um assembly totalmente confiável e um tipo no assembly herda de um tipo que não permite chamadores parcialmente confiável, uma exploração de segurança é possível.Se dois tipos de T1 e T2 atender às seguintes condições, chamadores mal-intencionados podem usar o tipo T1 para ignorar a demanda de herança implícita de confiança total que protege T2:

• T1 um tipo público é declarado em um assembly totalmente confiável que tem o atributo APTCA.

• T1 herda a partir de um tipo T2 fora do seu assembly.

• T2do assembly não tem o atributo APTCA e, portanto, não deve ser herdada por tipos em assemblies parcialmente confiável.

Um tipo parcialmente confiável X pode herdar de T1, que oferece-acesso para herdadas membros declarados em T2. Porque T2 não tem o atributo APTCA, (seu tipo derivado imediataT1) deve estar de acordo com uma demanda de herança para confiança total; T1 tem confiança total e, portanto, satisfaz essa verificação. O risco de segurança é porque X não participa de satisfazer a demanda de herança que protege T2 de subclassificação não confiável. Por esse motivo, os tipos com o atributo APTCA não devem estender tipos que não possuem o atributo.

Outro problema de segurança e talvez uma uma mais comum, é que o tipo derivado (T1) pode, por meio de erro do programador, expor membros protegidos do tipo que requer confiança total ()T2). Quando isso ocorrer, chamadores não confiáveis obter acesso às informações que devem estar disponível somente a tipos de totalmente confiável.

Como corrigir violações

Se o tipo de relatado pela violação é um assembly que não requer o atributo APTCA, remova-o.

Se o atributo APTCA for necessário, adicione uma demanda de herança para confiança total ao tipo.Isso protege contra herança por tipos não confiáveis.

É possível corrigir uma violação adicionando o atributo APTCA para módulos (assemblies) dos tipos de base relatados por violação.Não faça isso sem primeiro realizar uma revisão de segurança intensivo de todo o código nos assemblies do e todo o código que depende dos assemblies.

Quando suprimir avisos

Para suprimir com segurança um aviso da regra, você deve garantir que membros protegidos expostos pelo seu tipo não direta ou indiretamente permitem chamadores não confiáveis acessar informações confidenciais, operações ou recursos que podem ser usados de maneira destrutiva.

Exemplo

O exemplo a seguir usa dois assemblies e um aplicativo de teste para ilustrar a vulnerabilidade de segurança detectada por essa regra.A primeira assembly não tem o atributo APTCA e não deve ser herdadas por tipos parcialmente confiável (representados por T2 na discussão anterior).

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

O segundo conjunto é representado por T1 na discussão anterior, é totalmente confiável e permitem chamadores parcialmente confiável.

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

O tipo de teste, representado por X a discussão anterior, está em um assembly parcialmente confiável.

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

O exemplo produz a seguinte saída.

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!

Regras relacionadas

Métodos APTCA somente devem chamar métodos APTCA

Consulte também

Conceitos

Assemblies do .NET framework marcados com AllowPartiallyTrustedCallersAttribute

Usando bibliotecas de códigos parcialmente Confiável

Demandas de herança

Outros recursos

Diretrizes para Codificação Segura