Segurança de acesso do código e o ADO.NETCode Access Security and ADO.NET

O .NET Framework oferece segurança baseada em função e segurança de acesso de código (CAS), ambas são implementadas por meio de uma infraestrutura comum fornecida pelo CLR (Common Language Runtime).The .NET Framework offers role-based security as well as code access security (CAS), both of which are implemented using a common infrastructure supplied by the common language runtime (CLR). No mundo do código não gerenciado, a maioria dos aplicativos é executada com as permissões do usuário ou da entidade de segurança.In the world of unmanaged code, most applications execute with the permissions of the user or principal. Como resultado, é possível que os sistemas de computador sejam danificados e os dados particulares sejam comprometidos quando um software mal-intencionado ou com erro for executado por um usuário com privilégios elevados.As a result, computer systems can be damaged and private data compromised when malicious or error-filled software is run by a user with elevated privileges.

Por sua vez, o código gerenciado em execução no .NET Framework inclui a segurança de acesso de código, que se aplica apenas ao código.By contrast, managed code executing in the .NET Framework includes code access security, which applies to code alone. O fato de o código ter a execução permitida ou não depende da origem do código ou de outros aspectos da identidade do código, não apenas da identidade da entidade de segurança.Whether the code is allowed to run or not depends on the code's origin or other aspects of the code's identity, not solely the identity of the principal. Isso reduz a probabilidade de que o código gerenciado seja mal-utilizado.This reduces the likelihood that managed code can be misused.

Permissões de acesso de códigoCode Access Permissions

Quando o código é executado, ele apresenta evidências que são avaliadas pelo sistema de segurança CLR.When code is executed, it presents evidence that is evaluated by the CLR security system. Normalmente, essas evidências englobam a origem de código, incluindo a URL, o site e a zona, e as assinaturas digitais que garantem a identidade do assembly.Typically, this evidence comprises the origin of the code including URL, site, and zone, and digital signatures that ensure the identity of the assembly.

O CLR permite que o código realize apenas as operações que ele tem permissão para executar.The CLR allows code to perform only those operations that the code has permission to perform. O código pode solicitar permissões, e essas solicitações são respeitadas com base na política de segurança definida por um administrador.Code can request permissions, and those requests are honored based on the security policy set by an administrator.

Observação

O código executado no CLR não pode conceder permissões a ele mesmo.Code executing in the CLR cannot grant permissions to itself. Por exemplo, o código pode solicitar e receber menos permissões do que uma política de segurança permite, mas nunca receberá mais permissões.For example, code can request and be granted fewer permissions than a security policy allows, but it will never be granted more permissions. Ao conceder as permissões, comece com nenhuma permissão e depois adicione as permissões mais restritas para a tarefa específica que está sendo executada.When granting permissions, start with no permissions at all and then add the narrowest permissions for the particular task being performed. Começar com todas as permissões e depois negar permissões individuais resulta em aplicativos inseguros que podem conter brechas de segurança não intencionais para a concessão de mais permissões do que as necessárias.Starting with all permissions and then denying individual ones leads to insecure applications that may contain unintentional security holes from granting more permissions than required. Para obter mais informações, consulte Configurando política de segurança e Gerenciamento de política de segurança.For more information, see Configuring Security Policy and Security Policy Management.

Existem três tipos de permissões de acesso de código:There are three types of code access permissions:

  • As Code access permissions são derivadas da classe CodeAccessPermission.Code access permissions derive from the CodeAccessPermission class. São necessárias permissões para acessar recursos protegidos, como arquivos e variáveis de ambiente, e executar operações protegidas, como acessar código não gerenciado.Permissions are required in order to access protected resources, such as files and environment variables, and to perform protected operations, such as accessing unmanaged code.

  • As Identity permissions representam características que identificam um assembly.Identity permissions represent characteristics that identify an assembly. As permissões são concedidas a um assembly com base em evidências, o que pode incluir itens como uma assinatura digital ou a origem do código.Permissions are granted to an assembly based on evidence, which can include items such as a digital signature or where the code originated. As permissões de identidade também são derivadas da classe base CodeAccessPermission.Identity permissions also derive from the CodeAccessPermission base class.

  • As Role-based security permissions são baseadas no fato de uma entidade de segurança ter uma identidade especificada ou ser membro de uma função especificada.Role-based security permissions are based on whether a principal has a specified identity or is a member of a specified role. A classe PrincipalPermission permite verificações de permissões declarativas e imperativas na entidade de segurança ativa.The PrincipalPermission class allows both declarative and imperative permission checks against the active principal.

Para determinar se o código está autorizado a acessar um recurso ou executar uma operação, o sistema de segurança do runtime atravessa a pilha de chamadas, comparando as permissões concedidas de cada chamador com a permissão que está sendo exigida.To determine whether code is authorized to access a resource or perform an operation, the runtime's security system traverses the call stack, comparing the granted permissions of each caller to the permission being demanded. Se algum chamador na pilha de chamadas não tiver a permissão exigida, uma SecurityException será gerada e o acesso será recusado.If any caller in the call stack does not have the demanded permission, a SecurityException is thrown and access is refused.

Solicitando permissõesRequesting Permissions

A finalidade de solicitar permissões é informar ao runtime quais permissões seu aplicativo requer para ser executado, e garantir que ele receberá apenas as permissões de que realmente precisa.The purpose of requesting permissions is to inform the runtime which permissions your application requires in order to run, and to ensure that it receives only the permissions that it actually needs. Por exemplo, se seu aplicativo precisa gravar dados no disco local, ele requer a FileIOPermission.For example, if your application needs to write data to the local disk, it requires FileIOPermission. Se essa permissão não for concedida, o aplicativo falhará quando tentar gravar no disco.If that permission hasn't been granted, the application will fail when it attempts to write to the disk. Entretanto, se o aplicativo solicitar a FileIOPermission e essa permissão não for concedida, ele gerará a exceção no início e não será carregado.However, if the application requests FileIOPermission and that permission has not been granted, the application will generate the exception at the outset and will not load.

Em um cenário onde o aplicativo precisa apenas ler dados do disco, você pode solicitar que ele nunca receba permissões de gravação.In a scenario where the application only needs to read data from the disk, you can request that it never be granted any write permissions. No caso de um bug ou um ataque mal-intencionado, seu código não pode danificar os dados em que opera.In the event of a bug or a malicious attack, your code cannot damage the data on which it operates. Para obter mais informações, consulte solicitando permissões.For more information, see Requesting Permissions.

Segurança baseada em função e CASRole-Based Security and CAS

Implementar a segurança baseada em função e a segurança de acesso de código (CAS) melhora a segurança geral de seu aplicativo.Implementing both role-based security and code-accessed security (CAS) enhances overall security for your application. A segurança baseada em função pode ser baseada em uma conta do Windows ou uma identidade personalizada, tornando as informações sobre a entidade de segurança disponíveis ao thread atual.Role-based security can be based on a Windows account or a custom identity, making information about the security principal available to the current thread. Além disso, os aplicativos são geralmente necessários para fornecer acesso a dados ou recursos com base nas credenciais fornecidas pelo usuário.In addition, applications are often required to provide access to data or resources based on credentials supplied by the user. Em geral, esses aplicativos verificam a função de um usuário e fornecem acesso aos recursos com base nas funções.Typically, such applications check the role of a user and provide access to resources based on those roles.

A segurança baseada em função permite que um componente identifique os usuários atuais e suas funções associadas em tempo de execução.Role-based security enables a component to identify current users and their associated roles at run time. Essas informações são então mapeadas por meio de uma política de CAS para determinar o conjunto de permissões concedidas em tempo de execução.This information is then mapped using a CAS policy to determine the set of permissions granted at run time. Para um domínio de aplicativo especificado, o host pode alterar a política de segurança baseada em função padrão e definir uma entidade de segurança padrão que represente um usuário e as funções associadas a esse usuário.For a specified application domain, the host can change the default role-based security policy and set a default security principal that represents a user and the roles associated with that user.

O CLR usa permissões para implementar seu mecanismo de imposição de restrições em código gerenciado.The CLR uses permissions to implement its mechanism for enforcing restrictions on managed code. As permissões de segurança baseada em função fornecem um mecanismo para descobrir se um usuário (ou o agente que atua em nome do usuário) tem uma identidade em particular ou é membro de uma função especificada.Role-based security permissions provide a mechanism for discovering whether a user (or the agent acting on the user's behalf) has a particular identity or is a member of a specified role. Para obter mais informações, consulte permissões de segurança.For more information, see Security Permissions.

Dependendo do tipo de aplicativo que você está criando, você também deve considerar implementar as permissões baseadas em função no banco de dados.Depending on the type of application you are building, you should also consider implementing role-based permissions in the database. Para obter mais informações sobre a segurança baseada em funções no SQL Server, consulte segurança do SQL Server.For more information on role-based security in SQL Server, see SQL Server Security.

AssembliesAssemblies

Os assemblies formam a unidade fundamental de implantação, controle de versão, reutilização, escopo de ativação e permissões de segurança para um aplicativo .NET Framework.Assemblies form the fundamental unit of deployment, version control, reuse, activation scoping, and security permissions for a .NET Framework application. Um assembly fornece uma coleção de tipos e recursos que são criados para trabalhar em conjunto e formar uma unidade lógica de funcionalidade.An assembly provides a collection of types and resources that are built to work together and form a logical unit of functionality. Para o CLR, um tipo não existe fora do contexto de um assembly.To the CLR, a type does not exist outside the context of an assembly. Para obter mais informações sobre como criar e implantar assemblies, consulte programação com assemblies.For more information on creating and deploying assemblies, see Programming with Assemblies.

Assemblies de nomes fortesStrong-naming Assemblies

Um nome forte, ou assinatura digital, consiste na identidade do assembly, que inclui seu nome de texto simples, número de versão e informações de cultura (se fornecidas), além de uma chave pública e uma assinatura digital.A strong name, or digital signature, consists of the assembly's identity, which includes its simple text name, version number, and culture information (if provided), plus a public key and a digital signature. A assinatura digital é gerada a partir de um arquivo de assembly usando a chave privada correspondente.The digital signature is generated from an assembly file using the corresponding private key. O arquivo do assembly inclui o manifesto do assembly, o qual contém os nomes e os hashes de todos os arquivos que compõem o assembly.The assembly file contains the assembly manifest, which contains the names and hashes of all the files that make up the assembly.

Um assembly de nome forte oferece a um aplicativo ou componente uma identidade exclusiva que outro software pode usar para se referir a ele explicitamente.Strong naming an assembly gives an application or component a unique identity that other software can use to refer explicitly to it. O nome forte impede que os assemblies sejam enganados por um assembly que contém código hostil.Strong naming guards assemblies against being spoofed by an assembly that contains hostile code. O nome forte também garante a consistência entre versões diferentes de um componente.Strong-naming also ensures versioning consistency among different versions of a component. Você deve dar nomes fortes aos assemblies que serão implantados no GAC (cache de assembly global).You must strong name assemblies that will be deployed to the Global Assembly Cache (GAC). Para obter mais informações, consulte Criando e usando assemblies de nomes fortes.For more information, see Creating and Using Strong-Named Assemblies.

Confiança parcial no ADO.NET 2.0Partial Trust in ADO.NET 2.0

No ADO.NET 2.0, o Provedor de Dados .NET Framework para SQL Server, o Provedor de Dados .NET Framework para OLE DB, o Provedor de Dados .NET Framework para ODBC e o Provedor de Dados .NET Framework para Oracle podem agora ser todos executados em ambientes parcialmente confiáveis.In ADO.NET 2.0, the .NET Framework Data Provider for SQL Server, the .NET Framework Data Provider for OLE DB, the .NET Framework Data Provider for ODBC, and the .NET Framework Data Provider for Oracle can now all run in partially trusted environments. Em versões anteriores do .NET Framework, somente System.Data.SqlClient tinha suporte em aplicativos com confiança parcial.In previous releases of the .NET Framework, only System.Data.SqlClient was supported in less than full-trust applications.

Pelo menos um aplicativo parcialmente confiável que usa o provedor SQL Server deve ter permissões de execução e SqlClientPermission.At minimum, a partially trusted application using the SQL Server provider must have execution and SqlClientPermission permissions.

Propriedades de atributo de permissão para confiança parcialPermission Attribute Properties for Partial Trust

Para os cenários de confiança parcial, você pode usar membros SqlClientPermissionAttribute para restringir ainda mais os recursos disponíveis para o Provedor de Dados .NET Framework para SQL Server.For partial trust scenarios, you can use SqlClientPermissionAttribute members to further restrict the capabilities available for the .NET Framework Data Provider for SQL Server.

A tabela a seguir lista as propriedades SqlClientPermissionAttribute disponíveis e suas descrições:The following table lists the available SqlClientPermissionAttribute properties and their descriptions:

Propriedade de atributo de permissãoPermission attribute property DescriçãoDescription
Action Obtém ou define uma ação de segurança.Gets or sets a security action. Herdada de SecurityAttribute.Inherited from SecurityAttribute.
AllowBlankPassword Habilita ou desabilita o uso de uma senha em branco em uma cadeia de conexão.Enables or disables the use of a blank password in a connection string. Os valores válidos são true (para habilitar o uso de senhas em branco) e false (para desabilitar o uso de senhas em branco).Valid values are true (to enable the use of blank passwords) and false (to disable the use of blank passwords). Herdada de DBDataPermissionAttribute.Inherited from DBDataPermissionAttribute.
ConnectionString Identifica uma cadeia de conexão permitida.Identifies a permitted connection string. Várias cadeias de conexão podem ser identificadas.Multiple connection strings can be identified. Observação: Não inclua uma ID de usuário ou senha em sua cadeia de conexão.Note: Do not include a user ID or password in your connection string. Nesta versão, você não pode modificar restrições de cadeia de conexão usando a Ferramenta de Configuração do .NET Framework.In this release, you cannot change connection string restrictions using the .NET Framework Configuration Tool.

Herdada de DBDataPermissionAttribute.Inherited from DBDataPermissionAttribute.
KeyRestrictions Identifica os parâmetros de cadeia de conexão que são permitidos ou não.Identifies connection string parameters that are allowed or disallowed. Os parâmetros da cadeia de conexão são identificados no formato <nome do parâmetro > = .Connection string parameters are identified in the form <parameter name>=. Vários parâmetros podem ser especificados, sendo delimitados por um ponto e vírgula (;).Multiple parameters can be specified, delimited using a semicolon (;). Observação: Se você não especificar KeyRestrictions, mas definir KeyRestrictionBehavior Propriedade como AllowOnly ou PreventUsage, nenhum parâmetro de cadeia de conexão adicional será permitido.Note: If you do not specify KeyRestrictions, but you set KeyRestrictionBehavior property to AllowOnly or PreventUsage, no additional connection string parameters are allowed. Herdada de DBDataPermissionAttribute.Inherited from DBDataPermissionAttribute.
KeyRestrictionBehavior Identifica os parâmetros de cadeia de conexão como os únicos parâmetros adicionais permitidos (AllowOnly), ou identifica os parâmetros adicionais que não são permitidos (PreventUsage).Identifies the connection string parameters as the only additional parameters allowed (AllowOnly), or identifies the additional parameters that are not allowed (PreventUsage). AllowOnly é o padrão.AllowOnly is the default. Herdada de DBDataPermissionAttribute.Inherited from DBDataPermissionAttribute.
TypeID Obtém um identificador exclusivo para este atributo quando implementado em uma classe derivada.Gets a unique identifier for this attribute when implemented in a derived class. Herdada de Attribute.Inherited from Attribute.
Unrestricted Indica se a permissão irrestrita ao recurso é declarada.Indicates whether unrestricted permission to the resource is declared. Herdada de SecurityAttribute.Inherited from SecurityAttribute.

Sintaxe de ConnectionStringConnectionString Syntax

O exemplo a seguir demonstra como usar o elemento connectionStrings de um arquivo de configuração para permitir que somente uma cadeia de conexão específica seja usada.The following example demonstrates how to use the connectionStrings element of a configuration file to allow only a specific connection string to be used. Consulte cadeias de conexão para obter mais informações sobre como armazenar e recuperar cadeias de conexão de arquivos de configuração.See Connection Strings for more information on storing and retrieving connection strings from configuration files.

<connectionStrings>  
  <add name="DatabaseConnection"   
    connectionString="Data Source=(local);Initial   
    Catalog=Northwind;Integrated Security=true;" />  
</connectionStrings>  

Sintaxe de KeyRestrictionsKeyRestrictions Syntax

O exemplo a seguir habilita a mesma cadeia de conexão, habilita o uso das opções de cadeia de conexão Encrypt e Packet Size, mas restringe o uso de qualquer outra opção de cadeia de conexão.The following example enables the same connection string, enables the use of the Encrypt and Packet Size connection string options, but restricts the use of any other connection string options.

<connectionStrings>  
  <add name="DatabaseConnection"   
    connectionString="Data Source=(local);Initial   
    Catalog=Northwind;Integrated Security=true;"  
    KeyRestrictions="Encrypt=;Packet Size=;"  
    KeyRestrictionBehavior="AllowOnly" />  
</connectionStrings>  

Sintaxe de KeyRestrictionBehavior com PreventUsageKeyRestrictionBehavior with PreventUsage Syntax

O exemplo a seguir permite a mesma cadeia de conexão e todos os outros parâmetros de conexão, com exceção de User Id, Password e Persist Security Info.The following example enables the same connection string and allows all other connection parameters except for User Id, Password and Persist Security Info.

<connectionStrings>  
  <add name="DatabaseConnection"   
    connectionString="Data Source=(local);Initial   
    Catalog=Northwind;Integrated Security=true;"  
    KeyRestrictions="User Id=;Password=;Persist Security Info=;"  
    KeyRestrictionBehavior="PreventUsage" />  
</connectionStrings>  

Sintaxe de KeyRestrictionBehavior com AllowOnlyKeyRestrictionBehavior with AllowOnly Syntax

O exemplo a seguir permite duas cadeias de conexão que também contêm os parâmetros Initial Catalog, Connection Timeout, Encrypt e Packet Size.The following example enables two connection strings that also contain Initial Catalog, Connection Timeout, Encrypt, and Packet Size parameters. Todos os outros parâmetros de cadeia de conexão são restritos.All other connection string parameters are restricted.

<connectionStrings>  
  <add name="DatabaseConnection"   
    connectionString="Data Source=(local);Initial   
    Catalog=Northwind;Integrated Security=true;"  
    KeyRestrictions="Initial Catalog;Connection Timeout=;  
       Encrypt=;Packet Size=;"   
    KeyRestrictionBehavior="AllowOnly" />  
  
  <add name="DatabaseConnection2"   
    connectionString="Data Source=SqlServer2;Initial   
    Catalog=Northwind2;Integrated Security=true;"  
    KeyRestrictions="Initial Catalog;Connection Timeout=;  
       Encrypt=;Packet Size=;"   
    KeyRestrictionBehavior="AllowOnly" />  
</connectionStrings>  

Habilitando a confiança parcial com um conjunto de permissões personalizadoEnabling Partial Trust with a Custom Permission Set

Para habilitar o uso de permissões System.Data.SqlClient para uma zona específica, um administrador de sistema deve criar um conjunto de permissões personalizado e configurá-lo como o conjunto de permissões para uma zona específica.To enable the use of System.Data.SqlClient permissions for a particular zone, a system administrator must create a custom permission set and set it as the permission set for a particular zone. Os conjuntos de permissões padrão, como LocalIntranet, não podem ser modificados.Default permission sets, such as LocalIntranet, cannot be modified. Por exemplo, para incluir System.Data.SqlClient permissões para o código que tem um Zone de LocalIntranet, um administrador do sistema pode copiar o conjunto de permissões para LocalIntranet, renomeá-lo como "CustomLocalIntranet", adicionar as permissões de System.Data.SqlClient, importar o CustomLocalIntranet conjunto de permissões usando Caspol. exe (ferramenta de política de segurança de acesso do código)e defina o conjunto de permissões de LocalIntranet_Zone como CustomLocalIntranet.For example, to include System.Data.SqlClient permissions for code that has a Zone of LocalIntranet, a system administrator could copy the permission set for LocalIntranet, rename it to "CustomLocalIntranet", add the System.Data.SqlClient permissions, import the CustomLocalIntranet permission set using the Caspol.exe (Code Access Security Policy Tool), and set the permission set of LocalIntranet_Zone to CustomLocalIntranet.

Conjunto de permissões de exemploSample Permission Set

A seguir está um conjunto de permissões de exemplo para o Provedor de Dados .NET Framework para SQL Server em um cenário parcialmente confiável.The following is a sample permission set for the .NET Framework Data Provider for SQL Server in a partially trusted scenario. Para obter informações sobre como criar conjuntos de permissões personalizados, consulte Configurando conjuntos de permissões usando Caspol. exe.For information on creating custom permission sets, see Configuring Permission Sets Using Caspol.exe.

<PermissionSet class="System.Security.NamedPermissionSet"  
  version="1"  
  Name="CustomLocalIntranet"  
  Description="Custom permission set given to applications on  
    the local intranet">  
  
<IPermission class="System.Data.SqlClient.SqlClientPermission, System.Data, Version=2.0.0000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"  
version="1"  
AllowBlankPassword="False">  
<add ConnectionString="Data Source=(local);Integrated Security=true;"  
 KeyRestrictions="Initial Catalog=;Connection Timeout=;  
   Encrypt=;Packet Size=;"   
 KeyRestrictionBehavior="AllowOnly" />  
 </IPermission>  
</PermissionSet>  

Verificando o acesso de código ADO.NET usando permissões de segurançaVerifying ADO.NET Code Access Using Security Permissions

Para cenários de confiança parcial, você pode exigir privilégios CAS para determinados métodos em seu código especificando um SqlClientPermissionAttribute.For partial-trust scenarios, you can require CAS privileges for particular methods in your code by specifying a SqlClientPermissionAttribute. Se o privilégio não for permitido pela política de segurança restrita em vigor, uma exceção será gerada antes que seu código seja executado.If that privilege is not allowed by the restricted security policy in effect, an exception is thrown before your code is run. Para obter mais informações sobre a política de segurança, consulte Gerenciamento de políticas de segurança e práticas recomendadas de políticade segurança.For more information on security policy, see Security Policy Management and Security Policy Best Practices.

ExemploExample

O exemplo a seguir demonstra como escrever um código que requer um cadeia de conexão específica.The following example demonstrates how to write code that requires a particular connection string. Ele simula a negação de permissões irrestritas a System.Data.SqlClient, que um administrador de sistema implementaria usando uma política CAS no mundo real.It simulates denying unrestricted permissions to System.Data.SqlClient, which a system administrator would implement using a CAS policy in the real world.

Importante

Ao criar permissões CAS para ADO.NET, o padrão correto é começar com o caso mais restritivo (nenhuma permissão) e depois adicionar as permissões específicas que são necessárias para a tarefa em particular que o código precisa executar.When designing CAS permissions for ADO.NET, the correct pattern is to start with the most restrictive case (no permissions at all) and then add the specific permissions that are needed for the particular task that the code needs to perform. O padrão oposto, começando com todas as permissões e, em seguida, negar uma permissão específica, não é seguro porque há várias maneiras de expressar a mesma cadeia de conexão.The opposite pattern, starting with all permissions and then denying a specific permission, is not secure because there are many ways of expressing the same connection string. Por exemplo, se você iniciar com todas as permissões e depois tentar negar o uso da cadeia de conexão “server=someserver”, a cadeia de caracteres “server=someserver.mycompany.com” ainda será permitida.For example, if you start with all permissions and then attempt to deny the use of the connection string "server=someserver", the string "server=someserver.mycompany.com" would still be allowed. Ao iniciar sempre sem conceder absolutamente nenhuma permissão, você reduz as chances de haver brechas no conjunto de permissões.By always starting by granting no permissions at all, you reduce the chances that there are holes in the permission set.

O código a seguir demonstra como SqlClient realiza a exigência de segurança, que gera uma SecurityException caso as permissões CAS apropriadas não estejam estabelecidas.The following code demonstrates how SqlClient performs the security demand, which throws a SecurityException if the appropriate CAS permissions are not in place. A saída SecurityException é exibida na janela do console.The SecurityException output is displayed in the console window.

using System;
using System.Data;
using System.Data.SqlClient;
using System.Security;
using System.Security.Permissions;
 
namespace PartialTrustTopic {
   public class PartialTrustHelper : MarshalByRefObject {
      public void TestConnectionOpen(string connectionString) {
         // Try to open a connection.
         using (SqlConnection connection = new SqlConnection(connectionString)) {
            connection.Open();
         }
      }
   }
 
   class Program {
      static void Main(string[] args) {
         TestCAS("Data Source=(local);Integrated Security=true", "Data Source=(local);Integrated Security=true;Initial Catalog=Test");
      }
 
      static void TestCAS(string connectString1, string connectString2) {
         // Create permission set for sandbox AppDomain.
         // This example only allows execution.
         PermissionSet permissions = new PermissionSet(PermissionState.None);
         permissions.AddPermission(new SecurityPermission(SecurityPermissionFlag.Execution));
 
         // Create sandbox AppDomain with permission set that only allows execution,
         // and has no SqlClientPermissions.
         AppDomainSetup appDomainSetup = new AppDomainSetup();
         appDomainSetup.ApplicationBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase;
         AppDomain firstDomain = AppDomain.CreateDomain("NoSqlPermissions", null, appDomainSetup, permissions);
 
         // Create helper object in sandbox AppDomain so that code can be executed in that AppDomain.
         Type helperType = typeof(PartialTrustHelper);
         PartialTrustHelper firstHelper = (PartialTrustHelper)firstDomain.CreateInstanceAndUnwrap(helperType.Assembly.FullName, helperType.FullName);
 
         try {
            // Attempt to open a connection in the sandbox AppDomain.
            // This is expected to fail.
            firstHelper.TestConnectionOpen(connectString1);
            Console.WriteLine("Connection opened, unexpected.");
         }
         catch (System.Security.SecurityException ex) {
            Console.WriteLine("Failed, as expected: {0}",
                ex.FirstPermissionThatFailed);
 
            // Uncomment the following line to see Exception details.
            // Console.WriteLine("BaseException: " + ex.GetBaseException());
         }
 
         // Add permission for a specific connection string.
         SqlClientPermission sqlPermission = new SqlClientPermission(PermissionState.None);
         sqlPermission.Add(connectString1, "", KeyRestrictionBehavior.AllowOnly);
 
         permissions.AddPermission(sqlPermission);
 
         AppDomain secondDomain = AppDomain.CreateDomain("OneSqlPermission", null, appDomainSetup, permissions);
         PartialTrustHelper secondHelper = (PartialTrustHelper)secondDomain.CreateInstanceAndUnwrap(helperType.Assembly.FullName, helperType.FullName);
 
         // Try connection open again, it should succeed now.
         try {
            secondHelper.TestConnectionOpen(connectString1);
            Console.WriteLine("Connection opened, as expected.");
         }
         catch (System.Security.SecurityException ex) {
            Console.WriteLine("Unexpected failure: {0}", ex.Message);
         }
 
         // Try a different connection string. This should fail.
         try {
            secondHelper.TestConnectionOpen(connectString2);
            Console.WriteLine("Connection opened, unexpected.");
         }
         catch (System.Security.SecurityException ex) {
            Console.WriteLine("Failed, as expected: {0}", ex.Message);
         }
      }
   }
}
Imports System.Data
Imports System.Data.SqlClient
Imports System.Security
Imports System.Security.Permissions

Namespace PartialTrustTopic
   Public Class PartialTrustHelper
      Inherits MarshalByRefObject
      Public Sub TestConnectionOpen(ByVal connectionString As String)
         ' Try to open a connection.
         Using connection As New SqlConnection(connectionString)
            connection.Open()
         End Using
      End Sub
   End Class

   Class Program
      Public Shared Sub Main(ByVal args As String())
         TestCAS("Data Source=(local);Integrated Security=true", "Data Source=(local);Integrated Security=true;Initial Catalog=Test")
      End Sub

      Public Shared Sub TestCAS(ByVal connectString1 As String, ByVal connectString2 As String)
         ' Create permission set for sandbox AppDomain.
         ' This example only allows execution.
         Dim permissions As New PermissionSet(PermissionState.None)
         permissions.AddPermission(New SecurityPermission(SecurityPermissionFlag.Execution))

         ' Create sandbox AppDomain with permission set that only allows execution,
         ' and has no SqlClientPermissions.
         Dim appDomainSetup As New AppDomainSetup()
         appDomainSetup.ApplicationBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase
         Dim firstDomain As AppDomain = AppDomain.CreateDomain("NoSqlPermissions", Nothing, appDomainSetup, permissions)

         ' Create helper object in sandbox AppDomain so that code can be executed in that AppDomain.
         Dim helperType As Type = GetType(PartialTrustHelper)
         Dim firstHelper As PartialTrustHelper = DirectCast(firstDomain.CreateInstanceAndUnwrap(helperType.Assembly.FullName, helperType.FullName), PartialTrustHelper)

         Try
            ' Attempt to open a connection in the sandbox AppDomain.
            ' This is expected to fail.
            firstHelper.TestConnectionOpen(connectString1)
            Console.WriteLine("Connection opened, unexpected.")
         Catch ex As System.Security.SecurityException

            ' Uncomment the following line to see Exception details.
            ' Console.WriteLine("BaseException: " + ex.GetBaseException());
            Console.WriteLine("Failed, as expected: {0}", ex.FirstPermissionThatFailed)
         End Try

         ' Add permission for a specific connection string.
         Dim sqlPermission As New SqlClientPermission(PermissionState.None)
         sqlPermission.Add(connectString1, "", KeyRestrictionBehavior.AllowOnly)

         permissions.AddPermission(sqlPermission)

         Dim secondDomain As AppDomain = AppDomain.CreateDomain("OneSqlPermission", Nothing, appDomainSetup, permissions)
         Dim secondHelper As PartialTrustHelper = DirectCast(secondDomain.CreateInstanceAndUnwrap(helperType.Assembly.FullName, helperType.FullName), PartialTrustHelper)

         ' Try connection open again, it should succeed now.
         Try
            secondHelper.TestConnectionOpen(connectString1)
            Console.WriteLine("Connection opened, as expected.")
         Catch ex As System.Security.SecurityException
            Console.WriteLine("Unexpected failure: {0}", ex.Message)
         End Try

         ' Try a different connection string. This should fail.
         Try
            secondHelper.TestConnectionOpen(connectString2)
            Console.WriteLine("Connection opened, unexpected.")
         Catch ex As System.Security.SecurityException
            Console.WriteLine("Failed, as expected: {0}", ex.Message)
         End Try
      End Sub
   End Class
End Namespace

Você deverá ver esta saída na janela do console:You should see this output in the Console window:

Failed, as expected: <IPermission class="System.Data.SqlClient.  
SqlClientPermission, System.Data, Version=2.0.0.0,   
  Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1"  
  AllowBlankPassword="False">  
<add ConnectionString="Data Source=(local);Initial Catalog=  
  Northwind;Integrated Security=SSPI" KeyRestrictions=""  
KeyRestrictionBehavior="AllowOnly"/>  
</IPermission>  
  
Connection opened, as expected.  
Failed, as expected: Request failed.  

Interoperabilidade com código não gerenciadoInteroperability with Unmanaged Code

O código executado fora do CLR é chamado de código não gerenciado.Code that runs outside the CLR is called unmanaged code. Portanto, mecanismos de segurança, como o CAS, não podem ser aplicados a código não gerenciado.Therefore, security mechanisms such as CAS cannot be applied to unmanaged code. Componentes COM, interfaces ActiveX e funções da API do Windows são exemplos de código não gerenciado.COM components, ActiveX interfaces, and Windows API functions are examples of unmanaged code. Aplicam-se considerações de segurança especiais ao executar o código não gerenciado, para que você não coloque em risco a segurança geral do aplicativo.Special security considerations apply when executing unmanaged code so that you do not jeopardize overall application security. Para obter mais informações, consulte interoperação com código não gerenciado.For more information, see Interoperating with Unmanaged Code.

O .NET Framework também oferece suporte à compatibilidade com versões anteriores a componentes COM existentes fornecendo acesso por meio da interoperabilidade COM.The .NET Framework also supports backward compatibility to existing COM components by providing access through COM interop. Você pode incorporar componentes COM em um aplicativo .NET Framework usando ferramentas de interoperabilidade COM para importar os tipos COM relevantes.You can incorporate COM components into a .NET Framework application by using COM interop tools to import the relevant COM types. Uma vez importados, os tipos COM estão prontos para uso.Once imported, the COM types are ready to use. A interoperabilidade COM também permite que clientes COM acessem o código gerenciado exportando metadados do assembly para uma biblioteca de tipos e registrando o componente gerenciado como um componente COM.COM interop also enables COM clients to access managed code by exporting assembly metadata to a type library and registering the managed component as a COM component. Para obter mais informações, consulte interoperabilidade com avançada.For more information, see Advanced COM Interoperability.

Consulte tambémSee also