CA2117: os tipos APTCA só devem estender tipos base APTCA

Artigo
06/08/2015

TypeName	AptcaTypesShouldOnlyExtendAptcaBaseTypes
CheckId	CA2117
Categoria	Microsoft.Security
Alteração Significativa	Quebra

Causa

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

Descrição da Regra

Por padrão, o utilitário ou protegido digitar os assemblies com nomes fortes é protegido em implicitamente por Demandas de herança para o modo confiança total.Os assemblies de nome forte marcados com o atributo de AllowPartiallyTrustedCallersAttribute (APTCA) não têm essa proteção.O atributo desabilita a procura de herança.Isso torna os tipos expostos declarados no assembly herdável por tipos que não tem a confiança total.

Quando o atributo de APTCA presentes em um assembly totalmente confiável, e um tipo no assembly é herdada de um tipo que não permitir chamadores parcialmente confiáveis, uma exploração de segurança é possível.Se dois tipos T1 e T2 atendem às condições a seguir, os chamadores mal-intencionados podem usar o tipo T1 para ignorar a procura implícita de herança de confiança total que protege T2:

T1 é um tipo público declarado em um assembly totalmente confiável que tem o atributo de APTCA.
T1 herda de um tipo T2 fora do assembly.
o assembly deT2 não tenha um atributo de APTCA e, consequentemente, não deve ser herdável digitar pelos assemblies parcialmente confiáveis.

Um tipo parcialmente confiável X pode herdar de T1, que fornece acesso a membros herdados declarados em T2.Como T2 não tenha um atributo de APTCA, seu tipo derivado imediato (T1) deve satisfazer uma procura de herança para o modo confiança total; T1 tem a confiança total e os como consequência essa verificação.O risco de segurança é porque participa de X não atender à procura de herança que protege T2 de subclassing não confiável.Por esse motivo, os tipos com o atributo de APTCA não devem estender os tipos que não têm o atributo.

Outra problema de segurança, e talvez mais comuns, que são o tipo derivado () podeT1, com o erro do programador, membros protegidos exposição do tipo que requer a confiança total (T2).Quando isso ocorre, os chamadores não confiáveis obtiverem acesso a informações que deve estar disponível apenas para tipos totalmente confiável.

Como Corrigir Violações

Se o tipo relatado pela violação estiver em um assembly que não requer o atributo de APTCA, exclua-o.

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

É possível corrigir uma violação adicionando o atributo de APTCA a assemblies dos tipos de base relatados pela violação.Não faça isto sem primeiro realizar uma análise de segurança intensiva de todo o código em assemblies e de qualquer código que depende dos assemblies.

Quando Suprimir Alertas

Para suprimir com segurança um aviso desta regra, você deve assegurar que os membros protegidos expostas por seu tipo não permitam direta ou indiretamente quais os chamadores não confiáveis acessem informações confidenciais, as operações, ou recursos que podem ser usados em uma forma destrutiva.

Exemplo

O exemplo a seguir usa dois assemblies e um aplicativo de teste para ilustrar a vulnerabilidade de segurança detectada por esta regra.O primeiro assembly não tenha um atributo de APTCA e não deve ser herdável 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 assembly, representado por T1 na discussão anterior, está totalmente confiável e permitir chamadores parcialmente confiáveis.

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 na 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.