Sécurité d'accès du code et ADO.NETCode Access Security and ADO.NET

Le .NET Framework offre une sécurité basée sur les rôles ainsi qu'une sécurité d'accès du code (CAS, Code Access Security) implémentées à l'aide d'une infrastructure commune fournie par le Common Language Runtime (CLR).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). Dans l'univers du code non managé, la plupart des applications s'exécutent avec les autorisations de l'utilisateur ou d'une principal de sécurité.In the world of unmanaged code, most applications execute with the permissions of the user or principal. C'est pourquoi les systèmes informatiques peuvent être endommagés et des données privées compromises lorsqu'un utilisateur bénéficiant de privilèges élevés exécute des logiciels malveillants ou remplis d'erreurs.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.

En revanche, le code managé exécuté dans le .NET Framework inclut une sécurité d'accès du code qui s'applique au code seul.By contrast, managed code executing in the .NET Framework includes code access security, which applies to code alone. L'autorisation ou l'interdiction pour le code de s'exécuter dépend de son origine et d'autres aspects de son identité, et pas seulement de l'identité de la principal de sécurité.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. Cela réduit la probabilité que du code managé puisse être utilisé de façon abusive.This reduces the likelihood that managed code can be misused.

Autorisations d’accès du codeCode Access Permissions

Lors de l'exécution du code, ce dernier présente une preuve qui est évaluée par le système de sécurité CLR.When code is executed, it presents evidence that is evaluated by the CLR security system. Généralement, cette preuve comprend l'origine du code, notamment l'URL, le site, la zone et les signatures numériques qui garantissent l'identité de l'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.

Le CLR permet au code d'effectuer uniquement les opérations pour lesquelles il dispose d'une autorisation.The CLR allows code to perform only those operations that the code has permission to perform. Le code peut demander des autorisations qui lui sont accordées en fonction de la stratégie de sécurité définie par un administrateur.Code can request permissions, and those requests are honored based on the security policy set by an administrator.

Notes

Le code s'exécutant dans le CLR ne peut pas s'octroyer d'autorisations à lui-même.Code executing in the CLR cannot grant permissions to itself. Par exemple, un code peut demander et obtenir moins d'autorisations qu'une stratégie de sécurité le prévoit, mais il ne pourra jamais en obtenir plus.For example, code can request and be granted fewer permissions than a security policy allows, but it will never be granted more permissions. Lors de l’octroi d’autorisations, démarrez sans autorisation, puis ajoutez les autorisations les plus restrictives pour la tâche en cours d’exécution.When granting permissions, start with no permissions at all and then add the narrowest permissions for the particular task being performed. Démarrer avec toutes les autorisations puis en refuser individuellement génère des applications non sécurisées susceptibles de contenir des failles de sécurité involontaires dues à l'octroi de davantage d'autorisations que nécessaire.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. Pour plus d’informations, consultez Configuration de la stratégie de sécurité et de la gestion des stratégies de sécurité.For more information, see Configuring Security Policy and Security Policy Management.

Il existe trois types d'autorisations d'accès du code :There are three types of code access permissions:

  • Les Code access permissions sont dérivées de la classe CodeAccessPermission.Code access permissions derive from the CodeAccessPermission class. Des autorisations sont requises pour accéder à des ressources protégées, telles que des fichiers et des variables d'environnement, ainsi que pour effectuer des opérations protégées, telles que l'accès à du code non managé.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.

  • Les Identity permissions représentent les caractéristiques qui identifient un assembly.Identity permissions represent characteristics that identify an assembly. Des autorisations sont octroyées à un assembly sur la base d'une preuve, qui peut consister en différents éléments, tels qu'une signature numérique ou la provenance du code.Permissions are granted to an assembly based on evidence, which can include items such as a digital signature or where the code originated. Les autorisations d'identité dérivent également de la classe de base CodeAccessPermission.Identity permissions also derive from the CodeAccessPermission base class.

  • Les Role-based security permissions sont basées sur le fait qu'une principal de sécurité possède une identité spécifiée ou soit membre d'un rôle particulier.Role-based security permissions are based on whether a principal has a specified identity or is a member of a specified role. La classe PrincipalPermission permet de procéder à des vérifications d'autorisations déclaratives et impératives par rapport à la principal de sécurité active.The PrincipalPermission class allows both declarative and imperative permission checks against the active principal.

Pour déterminer si le code est autorisé à accéder à une ressources ou effectuer une opération, le système de sécurité du runtime parcourt la pile des appels, en comparant les autorisations de chaque appelant à l'autorisation faisant l'objet d'une demande.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. Si un appelant dans la pile des appels ne possède pas l'autorisation demandée, une exception SecurityException est levée et l'accès est refusé.If any caller in the call stack does not have the demanded permission, a SecurityException is thrown and access is refused.

Demande d'autorisationsRequesting Permissions

Les demandes d'autorisations ont pour but d'indiquer au runtime les autorisations dont votre application a besoin pour s'exécuter et de garantir que seules les autorisations requises lui sont octroyées.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. Par exemple, si votre application doit écrire des données sur le disque local, elle nécessite FileIOPermission.For example, if your application needs to write data to the local disk, it requires FileIOPermission. Si cette autorisation n'a pas été accordée, l'application échoue lorsqu'elle tente d'écrire sur le disque.If that permission hasn't been granted, the application will fail when it attempts to write to the disk. Cependant, si l'application demande FileIOPermission et que cette autorisation lui a été refusée, l'application génère l'exception dès le départ et ne se charge pas.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.

Dans un scénario dans lequel l'application a seulement besoin de lire des données du disque, vous pouvez demander à ce qu'aucune autorisation d'accès en écriture ne lui soit jamais octroyée.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. En cas de bogue ou d'attaque malveillante, votre code ne peut pas altérer les données sur lesquelles il opère.In the event of a bug or a malicious attack, your code cannot damage the data on which it operates. Pour plus d’informations, consultez demande d’autorisations.For more information, see Requesting Permissions.

Sécurité basée sur les rôles et sécurité d'accès du code (CAS)Role-Based Security and CAS

L'implémentation de la sécurité basée sur les rôles et de la sécurité d'accès du code (CAS) améliore la sécurité globale de votre application.Implementing both role-based security and code-accessed security (CAS) enhances overall security for your application. La sécurité basée sur les rôles peut utiliser un compte Windows ou une identité personnalisée, en mettant à la disposition du thread actuel des informations sur la principal de sécurité.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. Par ailleurs, les applications doivent souvent accorder l'accès aux données et aux ressources en fonction des informations d'identification fournies par l'utilisateur.In addition, applications are often required to provide access to data or resources based on credentials supplied by the user. Généralement, ces applications vérifient le rôle de l'utilisateur afin de lui donner accès aux ressources correspondant à ce rôle.Typically, such applications check the role of a user and provide access to resources based on those roles.

La sécurité basée sur les rôles permet à un composant d'identifier les utilisateurs actuels et leurs rôles associés au moment de l'exécution.Role-based security enables a component to identify current users and their associated roles at run time. Ces informations sont ensuite mappées à l'aide d'une stratégie de sécurité d'accès du code pour déterminer le jeu d'autorisations octroyées au moment de l'exécution.This information is then mapped using a CAS policy to determine the set of permissions granted at run time. Pour un domaine d'application spécifié, l'hôte peut modifier la stratégie de sécurité basée sur les rôles par défaut et définir une principal de sécurité par défaut qui représente un utilisateur et les rôles qui lui sont associés.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.

Le CLR utilise des autorisations pour mettre en œuvre son mécanisme destiné à imposer des restrictions sur du code managé.The CLR uses permissions to implement its mechanism for enforcing restrictions on managed code. Les autorisations de sécurité basées sur les rôles fournissent un mécanisme permettant de savoir si un utilisateur (ou l'agent qui agit en son nom) possède une identité particulière ou est membre d'un rôle spécifié.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. Pour plus d’informations, consultez autorisations de sécurité.For more information, see Security Permissions.

En fonction du type d'application en cours de construction, vous devez également envisager d'implémenter des autorisations basées sur les rôles dans la base de données.Depending on the type of application you are building, you should also consider implementing role-based permissions in the database. Pour plus d’informations sur la sécurité basée sur les rôles dans SQL Server, consultez SQL Server sécurité.For more information on role-based security in SQL Server, see SQL Server Security.

AssemblysAssemblies

Les assemblys constituent l'unité fondamentale dans le déploiement, le contrôle de version, la portée d'activation et les autorisations de sécurité d'une application .NET Framework.Assemblies form the fundamental unit of deployment, version control, reuse, activation scoping, and security permissions for a .NET Framework application. Ils fournissent une collection de types et de ressources qui sont générés pour fonctionner ensemble et former une unité logique de fonctionnalités.An assembly provides a collection of types and resources that are built to work together and form a logical unit of functionality. Pour le CLR, un type n'existe pas en dehors du contexte d'un assembly.To the CLR, a type does not exist outside the context of an assembly. Pour plus d’informations sur la création et le déploiement d’assemblys, consultez programmation avec des assemblys.For more information on creating and deploying assemblies, see Programming with Assemblies.

Attribution d'un nom fort à des assemblysStrong-naming Assemblies

Un nom fort, ou signature numérique, est constitué de l'identité de l'assembly (son simple nom textuel, son numéro de version et des informations de culture, le cas échéant) ainsi que d'une clé publique et d'une signature numérique.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. La signature numérique est générée à partir un fichier d'assembly à l'aide de la clé privée correspondante.The digital signature is generated from an assembly file using the corresponding private key. Le fichier d'assembly contient le manifeste d'assembly, qui à son tour comporte les noms et les hachages de tous les fichiers qui composent l'assembly.The assembly file contains the assembly manifest, which contains the names and hashes of all the files that make up the assembly.

L'attribution d'un nom fort à un assembly donne à une application ou un composant une identité unique que d'autres logiciels peuvent utiliser pour s'y référer explicitement.Strong naming an assembly gives an application or component a unique identity that other software can use to refer explicitly to it. L'attribution de noms forts aux assemblys les protège contre des falsifications par un assembly contenant un code hostile.Strong naming guards assemblies against being spoofed by an assembly that contains hostile code. Elle garantit également la cohérence du contrôle des versions d'un composant.Strong-naming also ensures versioning consistency among different versions of a component. Vous devez attribuer un nom fort aux assemblys qui seront déployés sur le cache GAC (Global Assembly Cache).You must strong name assemblies that will be deployed to the Global Assembly Cache (GAC). Pour plus d’informations, consultez Création et utilisation d’assemblys avec nom fort.For more information, see Creating and Using Strong-Named Assemblies.

Confiance partielle dans ADO.NET 2.0Partial Trust in ADO.NET 2.0

Dans ADO.NET 2.0, le fournisseur de données .NET Framework pour SQL Server , le fournisseur de données .NET Framework pour OLE DB, le fournisseur de données .NET Framework pour ODBC et le fournisseur de données .NET Framework pour Oracle peuvent tous s'exécuter dans des environnements bénéficiant d'une confiance partielle.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. Dans les mises en production précédentes du .NET Framework, seul System.Data.SqlClient était pris en charge dans des applications ne bénéficiant pas d’une confiance totale.In previous releases of the .NET Framework, only System.Data.SqlClient was supported in less than full-trust applications.

Au minimum, une application avec confiance partielle utilisant le fournisseur SQL Server doit disposer d'autorisations d'exécution et de l'objet SqlClientPermission.At minimum, a partially trusted application using the SQL Server provider must have execution and SqlClientPermission permissions.

Propriétés d'attribut d'autorisation pour la confiance partiellePermission Attribute Properties for Partial Trust

Pour des scénarios de confiance partielle, vous pouvez utiliser des membres de l'objet SqlClientPermissionAttribute pour restreindre davantage les capacités disponibles pour le fournisseur de données .NET Framework pour 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.

Le tableau suivant répertorie les propriétés de l'objet SqlClientPermissionAttribute disponibles et leurs descriptions :The following table lists the available SqlClientPermissionAttribute properties and their descriptions:

Propriété d'attribut d'autorisationPermission attribute property DescriptionDescription
Action Obtient ou définit une action de sécurité.Gets or sets a security action. Hérité de l'objet SecurityAttribute.Inherited from SecurityAttribute.
AllowBlankPassword Active ou désactive l'utilisation d'un mot de passe vide dans une chaîne de connexion.Enables or disables the use of a blank password in a connection string. Les valeurs valides sont true (pour activer l'utilisation des mots de passe vides) et false (pour la désactiver).Valid values are true (to enable the use of blank passwords) and false (to disable the use of blank passwords). Hérité de l'objet DBDataPermissionAttribute.Inherited from DBDataPermissionAttribute.
ConnectionString Identifie une chaîne de connexion autorisée.Identifies a permitted connection string. Plusieurs chaînes de connexion peuvent être identifiées.Multiple connection strings can be identified. Remarque : N'incluez pas d'ID utilisateur ni de mot de passe dans votre chaîne de connexion.Note: Do not include a user ID or password in your connection string. Dans cette version, vous ne pouvez pas modifier les restrictions liées à la chaîne de connexion à l'aide de l'outil de configuration .NET Framework.In this release, you cannot change connection string restrictions using the .NET Framework Configuration Tool.

Hérité de l'objet DBDataPermissionAttribute.Inherited from DBDataPermissionAttribute.
KeyRestrictions Identifie les paramètres de chaîne de connexion autorisés et non autorisés.Identifies connection string parameters that are allowed or disallowed. Les paramètres de chaîne de connexion sont identifiés dans le nom de paramètre de formulaire <> = .Connection string parameters are identified in the form <parameter name>=. Il est possible de spécifier plusieurs paramètres, délimités par un point-virgule (;).Multiple parameters can be specified, delimited using a semicolon (;). Remarque : Si aucun KeyRestrictions n'est spécifié et que la propriété KeyRestrictionBehavior a la valeur AllowOnly ou PreventUsage, aucun paramètre de chaîne de connexion supplémentaire n'est autorisé.Note: If you do not specify KeyRestrictions, but you set KeyRestrictionBehavior property to AllowOnly or PreventUsage, no additional connection string parameters are allowed. Hérité de l'objet DBDataPermissionAttribute.Inherited from DBDataPermissionAttribute.
KeyRestrictionBehavior Identifie les paramètres de chaîne de connexion comme étant les seuls paramètres supplémentaires autorisés (AllowOnly) ou identifie les paramètres supplémentaires qui ne sont pas autorisés (PreventUsage).Identifies the connection string parameters as the only additional parameters allowed (AllowOnly), or identifies the additional parameters that are not allowed (PreventUsage). AllowOnlyest la valeur par défaut.AllowOnly is the default. Hérité de l'objet DBDataPermissionAttribute.Inherited from DBDataPermissionAttribute.
TypeID Obtient un identificateur unique pour cet attribut lors de l'implémentation dans une classe dérivée.Gets a unique identifier for this attribute when implemented in a derived class. Hérité de l'objet Attribute.Inherited from Attribute.
Unrestricted Indique si une autorisation illimitée à la ressource est déclarée.Indicates whether unrestricted permission to the resource is declared. Hérité de l'objet SecurityAttribute.Inherited from SecurityAttribute.

Syntaxe de ConnectionStringConnectionString Syntax

L'exemple suivant illustre l'utilisation de l'élément connectionStrings d'un fichier de configuration pour n'autoriser l'utilisation que d'une seule chaîne de connexion spécifique.The following example demonstrates how to use the connectionStrings element of a configuration file to allow only a specific connection string to be used. Consultez chaînes de connexion pour plus d’informations sur le stockage et la récupération des chaînes de connexion à partir des fichiers de configuration.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>  

Syntaxe de KeyRestrictionsKeyRestrictions Syntax

L’exemple suivant active la même chaîne de connexion, active l’utilisation des Encrypt options Packet Size de chaîne de connexion et, mais restreint l’utilisation de toute autre option de chaîne de connexion.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>  

KeyRestrictionBehavior avec la syntaxe de PreventUsageKeyRestrictionBehavior with PreventUsage Syntax

L'exemple suivant active la même chaîne de connexion et autorise tous les autres paramètres de connexion à l'exception de User Id, Password et 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>  

KeyRestrictionBehavior avec la syntaxe de AllowOnlyKeyRestrictionBehavior with AllowOnly Syntax

L'exemple suivant active deux chaînes de connexion qui contiennent également des paramètres Initial Catalog, Connection Timeout, Encrypt et Packet Size.The following example enables two connection strings that also contain Initial Catalog, Connection Timeout, Encrypt, and Packet Size parameters. L'utilisation de tous les autres paramètres de chaîne de connexion est restreinte.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>  

Activation de confiance partielle avec un jeu d'autorisations personnaliséEnabling Partial Trust with a Custom Permission Set

Pour activer l'utilisation d'autorisations System.Data.SqlClient pour une zone particulière, un administrateur système doit créer un jeu d'autorisations personnalisé et le définir comme jeu d'autorisations pour une zone particulière.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. Les jeux d'autorisations par défaut, tels que LocalIntranet, ne peuvent pas être modifiés.Default permission sets, such as LocalIntranet, cannot be modified. Par exemple, pour inclure System.Data.SqlClient des autorisations pour du code qui Zone a LocalIntranetun de, un administrateur système peut copier le jeu LocalIntranetd’autorisations pour, le renommer en «CustomLocalIntranet» System.Data.SqlClient , ajouter les autorisations, importer le jeu d’autorisations CustomLocalIntranet à l’aide de Caspol. exe (outil stratégie de sécurité d’accès du code)et LocalIntranet_Zone définissez le jeu d’autorisations sur 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.

Exemple de jeu d'autorisationsSample Permission Set

Voici un exemple de jeu d'autorisations destiné au fournisseur de données .NET Framework pour SQL Serveur dans un scénario à confiance partielle.The following is a sample permission set for the .NET Framework Data Provider for SQL Server in a partially trusted scenario. Pour plus d’informations sur la création de jeux d’autorisations personnalisés, consultez Configuration des jeux d’autorisations à l’aide de 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>  

Vérification de l'accès du code ADO.NET à l'aide des autorisations de sécuritéVerifying ADO.NET Code Access Using Security Permissions

Dans les scénarios avec confiance partielle, vous pouvez exiger des privilèges de sécurité d'accès du code (CAS) pour des méthodes particulières dans votre code en spécifiant un objet SqlClientPermissionAttribute.For partial-trust scenarios, you can require CAS privileges for particular methods in your code by specifying a SqlClientPermissionAttribute. Si ce privilège n'est pas autorisé par la stratégie de sécurité limitée en vigueur, une exception est levée avant que votre code soit exécuté.If that privilege is not allowed by the restricted security policy in effect, an exception is thrown before your code is run. Pour plus d’informations sur la stratégie de sécurité, consultez meilleures pratiquespour la stratégie de sécurité et la gestion des stratégies de sécurité.For more information on security policy, see Security Policy Management and Security Policy Best Practices.

ExempleExample

L'exemple suivant montre comment écrire un code requérant une chaîne de connexion particulière.The following example demonstrates how to write code that requires a particular connection string. Il simule le refus d'autorisations illimitées à System.Data.SqlClient, qu'un administrateur système implémenterait à l'aide d'une stratégie de sécurité d'accès du code dans la réalité.It simulates denying unrestricted permissions to System.Data.SqlClient, which a system administrator would implement using a CAS policy in the real world.

Important

En cas d'utilisation d'autorisations de sécurité d'accès du code pour ADO.NET, le modèle correct consiste à commencer par le cas le plus restrictif (aucune autorisation) puis à ajouter les autorisations spécifiques nécessaires pour la tâche particulière que le code doit exécuter.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. En revanche, commencer par toutes les autorisations, puis tenter de refuser une autorisation spécifique n'est pas une approche sûre car il existe de nombreuses manières d'exprimer la même chaîne de connexion.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. Par exemple, si vous démarrez avec toutes les autorisations, puis refusez l'utilisation de la chaîne de connexion "server=someserver", vous pouvez continuer à utiliser "server=someserver.mycompany.com".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. En démarrant toujours en n'accordant aucune autorisation, vous limitez les risques de failles dans le jeu d'autorisations.By always starting by granting no permissions at all, you reduce the chances that there are holes in the permission set.

Le code suivant montre comment SqlClient exécute la demande de sécurité qui lève un objet SecurityException si les autorisations de sécurité d'accès du code (CAS) appropriées ne sont pas en place.The following code demonstrates how SqlClient performs the security demand, which throws a SecurityException if the appropriate CAS permissions are not in place. Le résultat de l'objet SecurityException s'affiche dans la fenêtre de 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

Vous devez voir ce résultat dans la fenêtre 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.  

Interopérabilité avec du code non managéInteroperability with Unmanaged Code

Le code qui s'exécute en dehors du CLR est appelé code non managé.Code that runs outside the CLR is called unmanaged code. Par conséquent, les mécanismes de sécurité, tels que la sécurité d'accès du code, ne peuvent pas être appliqués à du code non managé.Therefore, security mechanisms such as CAS cannot be applied to unmanaged code. Les composants COM, les interfaces ActiveX et les fonctions API Windows sont des exemples de code non managé.COM components, ActiveX interfaces, and Windows API functions are examples of unmanaged code. Des considérations de sécurité particulières s'appliquent lors de l'exécution de code non managé pour éviter de compromettre la sécurité globale des applications.Special security considerations apply when executing unmanaged code so that you do not jeopardize overall application security. Pour plus d’informations, consultez Interopération avec du code non managé.For more information, see Interoperating with Unmanaged Code.

Le .NET Framework prend également en charge la compatibilité descendante avec des composants COM existants en offrant un accès via COM Interop.The .NET Framework also supports backward compatibility to existing COM components by providing access through COM interop. Vous pouvez incorporer des composants COM dans une application .NET Framework en utilisant des outils de COM Interop pour importer les types COM pertinents.You can incorporate COM components into a .NET Framework application by using COM interop tools to import the relevant COM types. Une fois importés, les types COM sont prêts à être utilisés.Once imported, the COM types are ready to use. COM Interop permet également aux clients COM d'accéder à du code managé en exportant des métadonnées d'assembly dans une bibliothèque de types et en inscrivant le composant managé en tant que composant 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. Pour plus d’informations, consultez interopérabilité COM avancée.For more information, see Advanced COM Interoperability.

Voir aussiSee also