Accueil Library Formation Code Téléchargements Support Evénements Communautés Forums
Ce sujet n'a pas encore été évalué - Évaluez ce sujet

Procédure : utilisation de la stratégie de sécurité d'accès au code pour limiter un assembly

Dernière mise à jour le 31 août 2004
Sur cette page

Objectifs Objectifs
S'applique à S'applique à
Résumé Résumé
À savoir avant de commencer À savoir avant de commencer
Création d'un assembly qui effectue des E/S sur fichier Création d'un assembly qui effectue des E/S sur fichier
Création d'une application Web Création d'une application Web
Test des E/S sur fichier sans limites de sécurité d'accès au code Test des E/S sur fichier sans limites de sécurité d'accès au code
Configuration de la stratégie de sécurité d'accès au code pour limiter les E/S sur fichier Configuration de la stratégie de sécurité d'accès au code pour limiter les E/S sur fichier
Test des E/S sur fichier avec limites de sécurité d'accès au code Test des E/S sur fichier avec limites de sécurité d'accès au code

Objectifs

Ce module vous permettra d'effectuer les opérations suivantes :

  • configurer la stratégie de sécurité d'accès au code pour les assemblys .NET ;

  • utiliser la sécurité d'accès au code pour restreindre les capacités d'E/S d'un assembly.

S'applique à

Ce module s'applique aux produits et technologies suivants :

  • Microsoft® Windows® 2000 Server et les systèmes d'exploitation Windows 2000 Professionnel, Windows Server? 2003, Windows XP Édition Professionnel ;

  • Microsoft .NET Framework version 1.1.

Résumé

Un administrateur peut configurer la stratégie de sécurité d'accès au code pour limiter les opérations de code (assemblys) .NET Framework. Ce module décrit comment configurer la stratégie de sécurité d'accès au code pour limiter la capacité d'un assembly à effectuer des E/S sur fichier et pour restreindre les E/S sur fichier à un répertoire spécifique.

À savoir avant de commencer

L'outil de configuration .NET Framework 1.1 permet de créer un nouveau jeu d'autorisations et un nouveau groupe de codes. Le jeu d'autorisations détermine ce que le code peut faire ou ne pas faire, et le groupe de codes associe le jeu d'autorisations à un code particulier, par exemple un assembly spécifique ou un jeu d'assemblys.

En plus de limiter les E/S sur fichier, la stratégie de sécurité d'accès au code permet d'imposer d'autres limites au code. Par exemple, vous pouvez limiter la capacité du code à accéder à d'autres types de ressources protégées par une sécurité d'accès au code, notamment les bases de données, les services d'annuaire, le journal d'événements, le Registre, les serveurs DNS (Domain Name System), le code non géré et les variables d'environnement.

Remarque : cette liste n'est pas exhaustive mais est représentative des nombreux types de ressources courants auxquels accèdent les applications Web.

Avant de commencer à utiliser la stratégie de sécurité d'accès au code pour limiter un assembly, vous devez connaître les éléments suivants :

  • Pour limiter une application Web de manière à ce qu'elle ne puisse pas accéder aux fichiers au sein de sa propre hiérarchie de répertoires virtuels, vous pouvez configurer l'application pour qu'elle s'exécute avec une sécurisation moyenne en intégrant les éléments suivants dans Web.config :

    <system.web>
  <trust level="Medium" />
</system.web>

    Cette méthode utilise la stratégie de sécurité d'accès au code ASP.NET pour limiter la capacité de l'application Web à effectuer des E/S sur fichier et impose également d'autres limites. Par exemple, une application moyennement sécurisée ne peut pas directement accéder au journal d'événements, au Registre ou aux sources de données OLE DB.

  • La stratégie de sécurité d'accès au code ASP.NET est configurée indépendamment de la stratégie de sécurité d'accès au code au niveau de l'entreprise, de l'ordinateur et de l'utilisateur. L'outil de configuration .NET Framework version 1.1 prend uniquement en charge la stratégie au niveau de l'entreprise, de l'ordinateur et de l'utilisateur.

    Vous devez gérer la stratégie ASP.NET en utilisant un éditeur de texte ou XML. Pour plus d'informations sur l'exécution des applications Web en sécurisation moyenne, consultez le module 9 « Utilisation de la sécurité d'accès au code avec ASP.NET ».

  • Lorsque vous créez un assembly, vous pouvez imposer des limites par programme à l'aide de la sécurité d'accès au code. Pour plus d'informations sur cette méthode, consultez le module 8 « La sécurité d'accès au code en pratique ».

  • Il est généralement conseillé d'éviter de créer des applications Web qui acceptent des noms et des chemins d'accès aux fichiers de l'utilisateur en raison des risques de sécurité générés par les problèmes de canonicalisation. Il se peut que vous deviez parfois accepter un nom de fichier en entrée. Cette procédure vous montre qu'il est possible de limiter un assembly pour s'assurer qu'il ne peut pas accéder à des parties arbitraires du système de fichiers. Pour plus d'informations sur l'exécution d'E/S sur fichier, consultez les sections « File I/O» du module 7 « Création d'assemblys sécurisés » et du module 8 « Utilisation de la sécurité d'accès au code en pratique » du document Amélioration de la sécurité des applications Web.

  • Pour plus d'informations sur les principes de base de la sécurité d'accès au code, consultez le module 8 « La sécurité d'accès au code en pratique » du document Amélioration de la sécurité des applications Web.

Création d'un assembly qui effectue des E/S sur fichier

Dans cette étape, vous créez un assembly qui effectue des E/S sur fichier à l'aide d'un nom de fichier fourni.

  • Pour créer un nouvel assembly qui effectue des E/S sur fichier

    1. Créez un nouveau projet de bibliothèque de classes nommé FileIO avec l'outil de développement Microsoft Visual C#? et renommez class1.cs par FileIO.cs.

    2. Ajoutez un nom fort à l'assembly.
      En ajoutant un nom fort, vous rendez l'assembly imperméable aux falsifications en le signant. Le composant de clé publique du nom fort fournit également une preuve cryptographique forte pour la stratégie de sécurité d'accès au code. Un administrateur peut appliquer une stratégie en utilisant le nom fort uniquement pour identifier l'assembly.

    3. Utilisez une version d'assembly fixe. Ouvrez Assemblyinfo.cs et configurez l'attribut AssemblyVersion comme indiqué ci-dessous :

      [assembly: AssemblyVersion("1.0.0.1")]

    4. Ajoutez les instructions using suivantes en haut du fichier FileIO.cs :

      using System.IO;
using System.Text;

    5. Renommez Class1 par FileWrapper et scellez la classe pour empêcher l'héritage.

      public sealed class FileWrapper

    6. Renommez le constructeur par défaut pour le faire correspondre au nom de la classe et remplacez-le par private, ce qui évite que les instances de la classe FileWrapper soient créées. Cette classe fournit uniquement des méthodes statiques.

    7. Ajoutez la méthode publique suivante pour qu'il lise à partir d'un fichier spécifique.

      public static string ReadFile(string filename)
{
  byte[] fileBytes = null;
  long fileSize = -1;
  Stream fileStream = null;

  try
  {
    if(null == filename)
    {
      throw new ArgumentException("Nom de fichier manquant");
    }
    // Canonicaliser et valider le nom de fichier fourni
    // GetFullPath :
    // - Recherche les caractères non valides (définis par Path.InvalidPathChars)
    // - Recherche les noms de périphériques Win32 qui ne sont pas des fichiers, tels que
    //   des lecteurs physiques, des ports série et parallèle, des pipes, des emplacements de courrier électronique,
    //   etc.
    // - Normalise le chemin de fichier

    filename = Path.GetFullPath(filename);
    fileStream = File.OpenRead(filename);
    if(!fileStream.CanRead)
    {
      throw new Exception("Impossible de lire à partir du fichier.");
    }
    fileSize = fileStream.Length;
    fileBytes = new byte[fileSize];
    fileStream.Read(fileBytes, 0, Convert.ToInt32(fileSize));
    return Encoding.ASCII.GetString(fileBytes);
  }
  catch(Exception ex)
  {
    throw ex;
  }
  finally
  {
    if (null != fileStream)
      fileStream.Close();
  }
}

Création d'une application Web

Dans cette étape, vous créez un assembly d'application Web qui appelle l'assembly d'E/S sur fichier.

  • Pour créer une application Web

    1. Ajoutez un nouveau projet d'application Web C# ASP.NET nommé FileIOWeb à votre solution actuelle.

    2. Ajoutez une référence de projet dans le nouveau projet qui référence le projet FileIO.

    3. Ajoutez une zone de texte dans WebForm1.aspx pour permettre à l'utilisateur de fournir un nom de fichier et un chemin d'accès au fichier. Configurez sa propriété Text sur c:\temp\somefile.txt et configurez son ID sur txtFileName.

    4. Ajoutez un bouton dans WebForm1.aspx et configurez sa propriété Text sur Read File et son ID sur btnReadFile.

    5. Double-cliquez sur le bouton Read File et ajoutez le code suivant au gestionnaire d'événements :

      string s = FileIO.FileWrapper.ReadFile( txtFileName.Text );
Response.Write(s);

    6. Générez la solution.

Test des E/S sur fichier sans limites de sécurité d'accès au code

Par défaut, les applications Web et les assemblys qu'elles appellent sur l'ordinateur local bénéficient d'une confiance totale attribuée par la stratégie de sécurité d'accès au code. Dans Machine.config, la configuration <trust> attribue par défaut le niveau de confiance totale à toutes les applications Web, comme suit :

<trust level="Full" originUrl="" />

Avec la confiance totale, les applications Web ne sont pas limitées par la stratégie de sécurité d'accès au code. La réussite ou l'échec de l'accès aux ressources sont déterminés simplement par la sécurité du système d'exploitation.

  • Pour tester les E/S sur fichier sans limites de sécurité d'accès au code

    1. Dans le Bloc-notes, créez un fichier texte nommé Somefile.txt contenant une simple chaîne de texte, puis placez ce fichier dans le répertoire C:\temp. Placez également une copie dans le répertoire racine C:\.

    2. Exécutez l'application Web et cliquez sur Read File.
      Le contenu du fichier texte apparaît.

    3. Entrez c:\somefile.txt dans la zone de texte et cliquez sur Read File.
      Le contenu du fichier texte apparaît.

Configuration de la stratégie de sécurité d'accès au code pour limiter les E/S sur fichier

Dans cette étape, vous configurez la stratégie de sécurité d'accès au code de l'assembly FileIO et lui accordez une autorisation FileIOPermission restreinte de sorte qu'il peut uniquement accéder aux fichiers sous le répertoire C:\Temp. Commencez par créer un nouveau jeu d'autorisations comprenant une autorisation FileIOPermission restreinte. Créez ensuite un nouveau groupe de codes pour associer le nouveau jeu d'autorisations avec l'assembly FileIO en utilisant une preuve de nom fort.

  • Pour créer un nouveau jeu d'autorisations

    1. Démarrez l'outil de configuration .NET Framework version 1.1 à partir du dossier programme Outils d'administration.

    2. Développez le nœud Stratégie de sécurité du runtime.
      Trois niveaux de stratégie de sécurité d'accès au code apparaissent : entreprise, ordinateur et utilisateur. Le quatrième niveau sur lequel vous pouvez configurer la stratégie de sécurité d'accès au code est le niveau du domaine d'application. ASP.NET implémente la stratégie au niveau du domaine d'application, mais celle-ci n'est pas maintenue lorsque vous utilisez l'outil de configuration .NET Framework version 1. Pour modifier la stratégie ASP.NET, vous devez utiliser un éditeur de texte.

      Pour plus d'informations sur la stratégie ASP.NET et sur son utilisation, consultez le module 9 « Utilisation de la sécurité d'accès au code avec ASP.NET ».

    3. Développez le nœud Ordinateur.
      Les dossiers Groupes de codes et Jeux d'autorisations apparaissent. Chaque fichier de stratégie contient un ensemble hiérarchique de groupes de codes. Les groupes de codes permettent d'attribuer des autorisations aux assemblys. Un groupe de codes se compose de deux éléments :

      • une condition d'appartenance : celle-ci est basée sur une preuve, par exemple le nom fort d'un assembly ;

      • un jeu d'autorisations : les autorisations du jeu d'autorisations sont accordées aux assemblys dont la preuve correspond à la condition d'appartenance.

      Un jeu d'autorisations est un regroupement qui contient un ensemble d'autorisations de sécurité d'accès au code individuelles. Les autorisations individuelles indiquent que le code est autorisé à accéder à des types de ressources spécifiques ou à effectuer des types d'opérations privilégiées spécifiques.

    4. Cliquez avec le bouton droit de la souris sur Jeux d'autorisations, puis cliquez sur Nouveau.

    5. Entrez RestictedFileIO dans le champ Nom, puis cliquez sur Suivant.

    6. Sélectionnez FileIO dans la liste Autorisations disponibles, puis cliquez sur Ajouter.

    7. Entrez c:\temp dans la colonne Chemin d'accès au fichier et sélectionnez Lecture et Découverte de chemin d'accès.
      Les autorisations de découverte du chemin d'accès sont requises par la fonction Path.GetFullPath utilisée par l'assembly FileIO pour canonicaliser et valider le nom de fichier fourni.

      Les autorisations de lecture sont requises par la méthode File.OpenRead utilisée par l'assembly FileIO pour ouvrir le fichier texte.

    8. Cliquez sur OK.

    9. Sélectionnez Sécurité dans la liste Autorisations disponibles et cliquez sur Ajouter.
      L'assembly FileIO requiert également l'autorisation d'exécution en plus de l'autorisation FileIOPermission. L'autorisation d'exécution est représentée par SecurityPermission dont la propriété Indicateurs est configurée sur SecurityPermissionFlag.Execution.

    10. Cliquez sur Activer l'exécution de l'assembly, puis cliquez sur OK.

    11. Cliquez sur Terminer pour achever la création du jeu d'autorisations.
      Vous avez maintenant créé un nouveau jeu d'autorisations nommé RestrictedFileIO contenant une autorisation FileIOPermission restreinte, qui autorise la lecture et la découverte de chemin d'accès vers le répertoire C:\Temp, et une autorisation SecurityPermission restreinte qui autorise l'exécution de l'assembly.

  • Pour créer un nouveau groupe de codes

    1. Développez Groupes de codes, puis Tout le code.

    2. Cliquez avec le bouton droit de la souris sur Tout le code, puis cliquez sur Nouveau.

    3. Entrez FileIOAssembly comme nom du groupe de codes, puis cliquez sur Suivant.

    4. Sélectionnez StrongName dans la liste déroulante Choisissez le type de condition pour ce groupe de codes.
      Ce groupe de codes permet d'appliquer des autorisations spécifiques définies par le jeu d'autorisations RestrictedFileIO à l'assembly FileIO. Un nom fort fournit une preuve cryptographique forte permettant uniquement d'identifier un assembly.

    5. Pour spécifier la clé publique de l'assembly FileIO, (qu'il possède car il contient un nom fort), cliquez sur Importer, puis naviguez jusqu'au dossier de sortie du projet contenant FileIO.dll. Cliquez sur Ouvrir pour extraire la clé publique de l'assembly.

    6. Cliquez sur Suivant, puis sélectionnez RestrictedFileIO dans la liste déroulante Utiliser un jeu d'autorisations existant.

    7. Cliquez sur Suivant puis sur Terminer pour achever la création du groupe de codes.
      Vous avez maintenant créé un nouveau groupe de codes qui applique les autorisations définies dans le jeu d'autorisations RestrictedFileIO à l'assembly FileIO.

    8. Dans la fenêtre de droite, sélectionnez le groupe de codes FileIOAssembly, puis cliquez sur Modifier les propriétés du groupe de codes.

    9. Sélectionnez Ce niveau de stratégie ne bénéficiera que des autorisations du jeu d'autorisations associé à ce groupe de codes et Les niveaux de stratégie en dessous de ce niveau ne seront pas évalués.
      En sélectionnant ces attributs pour le groupe de codes, vous vous assurez qu'aucun autre groupe de codes, que ce soit au niveau de l'ordinateur actuel ou au niveau du domaine d'application ASP.NET, n'affectera le jeu d'autorisations accordé à l'assembly FileIO. L'assembly bénéficie ainsi uniquement des autorisations définies par le jeu d'autorisations RestrictedFileIO que vous avez créé plus tôt.

      Remarque : si vous ne sélectionnez pas ces options, la stratégie par défaut de l'ordinateur accorde une confiance totale à l'assembly car celui-ci est installé sur l'ordinateur local et est concerné par le paramètre My_Computer_Zone.

    10. Cliquez sur OK pour fermer la boîte de dialogue Propriétés.

Test des E/S sur fichier avec limites de sécurité d'accès au code

Dans cette procédure, vous installez l'assembly FileIO dans le cache de l'assembly global (GAC). Exécutez ensuite l'application Web et essayez d'accéder aux fichiers à l'intérieur et à l'extérieur de C:\Temp. La stratégie de sécurité d'accès au code que vous avez configurée à l'étape précédente limite le code de sorte qu'il est uniquement autorisé à accéder aux fichiers sous C:\Temp.

L'assembly doit être installé dans le GAC car ASP.NET charge les assemblys de noms forts comme des assemblys neutres de domaine. Tous les assemblys de nom fort appelés par les applications Web d'ASP.NET doivent être installés dans le GAC. Pour plus d'informations sur ce sujet, consultez « Strong Names » dans le module 7 « Création d'assemblys sécurisés ».

Remarque : normalement, la stratégie par défaut de l'ordinateur et la stratégie ASP.NET accordent une confiance totale aux assemblys installés dans le GAC. Les attributs Ce niveau de stratégie ne bénéficiera que des autorisations du jeu d'autorisations associé à ce groupe de codes et Les niveaux de stratégie en dessous de ce niveau ne seront pas évalués que vous avez attribués au groupe de codes créé à l'étape précédente garantissent que l'assembly ne bénéficie pas d'une confiance totale et que seules lui sont accordées les autorisations définies par le jeu d'autorisations RestrictedFileIO que vous avez créé plus tôt.

  • Pour tester les E/S sur fichier avec limites de sécurité d'accès au code

    1. Installez l'assembly FileIO dans le GAC à l'aide de l'utilitaire Gacutil.exe.
      Une fois qu'il aura été créé avec succès dans Microsoft Visual Studio® .NET, vous pourrez appeler Gacutil.exe pour vérifier qu'il est placé dans le GAC.

      1. Affichez la boîte de dialogue Propriétés du projet FileIO dans Visual Studio .NET.

      2. Dans Propriétés communes, sélectionnez Événements de génération.

      3. Entrez C:\Program Files\Microsoft Visual Studio .NET 2003\SDK\v1.1\Bin\gacutil" -i $(TargetPath) dans le champ Ligne de commande de l'événement après génération.

      4. Cliquez sur OK pour fermer la boîte de dialogue Propriétés du projet.

    2. Régénérez la solution.

    3. Exécutez Iisreset.exe à partir d'une ligne de commande pour forcer le redémarrage du processus ASP.NET.
      L'autorisation de l'assembly FileIO est ainsi recalculée. Si le domaine d'application d'ASP.NET est toujours actif depuis la dernière exécution de l'application Web, l'assembly peut toujours être mis en cache par ASP.NET.

    4. Exécutez l'application Web et cliquez sur Read File.
      Le contenu du fichier texte devrait apparaître. La stratégie que vous avez créée autorise l'assembly FileIO à lire des fichiers de C:\Temp et au-dessous.

    5. Entrez c:\somefile.txt dans la zone de texte, puis cliquez sur Read File.
      Une exception SecurityException devrait être générée parce que la stratégie d'accès au code que vous avez configurée n'autorise pas des E/S sur fichier en dehors du répertoire C:\Temp.

      Les détails de l'exception indiquent qu'une demande d'autorisation FileIOPermission a échoué, comme indiqué ci-dessous :

      System.Security.SecurityException: Request for the permission of type 
System.Security.Permissions.FileIOPermission, mscorlib, Version=1.0.5000.0, 
Culture=neutral, PublicKeyToken=b77a5c561934e089 failed.
Cela vous a-t-il été utile ?
(1500 caractères restants)
© 2013 Microsoft. Tous droits réservés.