Accès plus sécurisé aux fichiers et aux données dans les Windows Forms

Mise à jour : novembre 2007

Le .NET Framework utilise des autorisations permettant de protéger les ressources et les données. Les autorisations accordées à votre application déterminent les conditions dans lesquelles elle peut lire ou écrire des données. Lorsque votre application s'exécute dans un environnement de confiance partielle, vous pouvez ne pas avoir accès à vos données ou vous pouvez devoir modifier la façon dont vous y accédez.

En cas de restriction de sécurité, vous avez deux options : déclarer l'autorisation (en supposant qu'elle a été accordée à votre application) ou utiliser une version de la fonctionnalité écrite pour fonctionner à un niveau de confiance partielle. Les sections suivantes montrent comment utiliser l'accès aux fichiers, aux bases de données et au Registre à partir d'applications qui s'exécutent dans un environnement de confiance partielle.

Remarque :

Par défaut, les outils qui génèrent des déploiements ClickOnce leur affectent leur valeur par défaut afin de demander la Confiance totale depuis les ordinateurs sur lesquels ils s'exécutent. Si vous souhaitez bénéficier des avantages supplémentaires en matière de sécurité relatifs à l'exécution à un niveau de confiance partielle, vous devez modifier cette valeur par défaut dans Visual Studio ou l'un des outils du Kit de développement logiciel (SDK) Windows (Mage.exe ou MageUI.exe). Pour plus d'informations sur la sécurité Windows Forms et sur la définition du niveau de confiance approprié pour votre application, consultez Vue d'ensemble de la sécurité dans les Windows Forms.

Accès aux fichiers

La classe FileIOPermission contrôle l'accès aux fichiers et aux dossiers dans le .NET Framework. Par défaut, le système de sécurité n'accorde pas de FileIOPermission aux environnements de confiance partielle, tels que les zones Intranet local et Internet. Une application nécessitant un accès aux fichiers peut toutefois fonctionner dans ces types d'environnements si vous modifiez sa conception ou utilisez d'autres méthodes pour accéder aux fichiers. Par défaut, la zone Intranet local a le droit d'avoir les mêmes accès aux répertoires et aux sites, de se reconnecter à son site d'origine et de lire des données à partir de son répertoire d'installation. Par défaut, la zone Internet a uniquement le droit de se reconnecter à son site d'origine.

Fichiers spécifiés par l'utilisateur

Lorsque l'utilisateur ne dispose pas d'autorisation d'accès aux fichiers, vous pouvez l'inviter à fournir des informations de fichier spécifiques à l'aide de la classe OpenFileDialog ou SaveFileDialog. Cette interaction avec l'utilisateur vous aide à empêcher toute tentative malveillante de l'application visant à charger des fichiers privés ou à remplacer des fichiers sensibles. Les méthodes OpenFile et OpenFile fournissent l'accès au fichier en lecture et en écriture en ouvrant le flux de données du fichier que l'utilisateur a spécifié. Cette méthode permet également de protéger le fichier de l'utilisateur en masquant son chemin d'accès.

Remarque :
Ces autorisations diffèrent en fonction de si votre application se trouve dans la zone Internet ou dans la zone Intranet. Les applications de la zone Internet peuvent uniquement utiliser le OpenFileDialog, alors que les applications de la zone Intranet dispose de l'autorisation non restreinte d'accéder à la boîte de dialogue Fichier.

La classe FileDialogPermission spécifie le type de boîte de dialogue Fichier que votre application peut utiliser. Le tableau suivant indique la valeur requise pour utiliser chaque classe FileDialog.

Remarque :
L'autorisation spécifique n'est pas demandée tant que la méthode OpenFile n'est pas effectivement appelée.

L'autorisation d'afficher une boîte de dialogue Fichier ne permet pas à votre application d'avoir un accès complet à tous les membres des classes FileDialog, OpenFileDialog et SaveFileDialog. Pour connaître les autorisations exactes requises pour appeler chaque méthode, consultez la rubrique de référence de cette méthode dans la documentation de la bibliothèque de classes du .NET Framework.

L'exemple de code suivant utilise la méthode OpenFile pour ouvrir un fichier spécifié par l'utilisateur dans un contrôle RichTextBox. L'exemple requiert FileDialogPermission et la valeur d'énumération Open associée. L'exemple montre comment gérer l'SecurityException afin de déterminer si la fonctionnalité d'enregistrement doit être désactivée. Cet exemple requiert que votre Form ait un contrôle Button nommé ButtonOpen et un contrôle RichTextBox nommé RtfBoxMain.

Remarque :
La logique de programmation pour la fonctionnalité d'enregistrement n'est pas illustrée dans l'exemple.

 [Visual Basic]
Private Sub ButtonOpen_Click(ByVal sender As System.Object, _
    ByVal e As System.EventArgs) Handles ButtonOpen.Click 

    Dim editingFileName as String = ""
    Dim saveAllowed As Boolean = True

    ' Displays the OpenFileDialog.
    If (OpenFileDialog1.ShowDialog() = DialogResult.OK) Then
        Dim userStream as System.IO.Stream
        Try 
            ' Opens the file stream for the file selected by the user.
            userStream =OpenFileDialog1.OpenFile() 
            Me.RtfBoxMain.LoadFile(userStream, _
                RichTextBoxStreamType.PlainText)
        Finally
            userStream.Close()
        End Try

        ' Tries to get the file name selected by the user.
        ' Failure means that the application does not have
        ' unrestricted permission to the file.
        Try 
            editingFileName = OpenFileDialog1.FileName
        Catch ex As Exception
            If TypeOf ex Is System.Security.SecurityException Then 
                ' The application does not have unrestricted permission 
                ' to the file so the save feature will be disabled.
                saveAllowed = False 
            Else 
                Throw ex
            End If
        End Try
    End If
End Sub

private void ButtonOpen_Click(object sender, System.EventArgs e) 
{
    String editingFileName = "";
    Boolean saveAllowed = true;

    // Displays the OpenFileDialog.
    if (openFileDialog1.ShowDialog() == DialogResult.OK) 
    {
        // Opens the file stream for the file selected by the user.
        using (System.IO.Stream userStream = openFileDialog1.OpenFile()) 
        {
            this.RtfBoxMain.LoadFile(userStream,
                RichTextBoxStreamType.PlainText);
            userStream.Close();
        }

        // Tries to get the file name selected by the user.
        // Failure means that the application does not have
        // unrestricted permission to the file.
        try 
        {
            editingFileName = openFileDialog1.FileName;
        } 
        catch (Exception ex) 
        {
            if (ex is System.Security.SecurityException) 
            {
                // The application does not have unrestricted permission 
                // to the file so the save feature will be disabled.
                saveAllowed = false; 
            } 
            else 
            {
                throw ex;
            }
        }
    }
}

Remarque :
Dans Visual C#, veillez à ajouter le code permettant d'activer le gestionnaire d'événements. En utilisant le code de l'exemple précédent, le code suivant indique comment activer le gestionnaire d'événements.this.ButtonOpen.Click += newSystem.Windows.Forms.EventHandler(this.ButtonOpen_Click);

Autres fichiers

Vous devrez parfois lire ou écrire des fichiers que l'utilisateur ne spécifie pas, comme lorsque vous devez rendre des paramètres d'application persistants. Dans les zones Intranet local et Internet, votre application n'est pas autorisée à stocker des données dans un fichier local. Elle peut cependant stocker des données dans un stockage isolé. Le stockage isolé est un compartiment de données abstrait (pas un emplacement de stockage spécifique) qui comporte un ou plusieurs fichiers de stockage isolé, appelés magasins, qui contiennent les emplacements de répertoire réels où les données sont stockées. Les autorisations d'accès aux fichiers telles que FileIOPermission ne sont pas requises ; à la place, la classe IsolatedStoragePermission contrôle les autorisations pour le stockage isolé. Par défaut, les applications qui s'exécutent dans les zones Intranet local et Internet peuvent stocker des données à l'aide du stockage isolé ; les paramètres, tels que le quota de disque, peuvent cependant varier. Pour plus d'informations sur le stockage isolé, consultez Introduction au stockage isolé.

L'exemple ci-dessous utilise le stockage isolé pour écrire des données dans un fichier situé dans un magasin. L'exemple requiert IsolatedStorageFilePermission et la valeur d'énumération DomainIsolationByUser. L'exemple montre comment lire et écrire certaines valeurs de propriété du contrôle Button dans un fichier situé dans un stockage isolé. La fonction Read est appelée après le démarrage de l'application et la fonction Write, avant sa fin. L'exemple requiert que les fonctions Read et Write soient présentes en tant que membres d'un Form qui contient un contrôle Button nommé MainButton.

' Reads the button options from the isolated storage. Uses Default values 
' for the button if the options file does not exist.
Public Sub Read() 
    Dim isoStore As System.IO.IsolatedStorage.IsolatedStorageFile = _
        System.IO.IsolatedStorage.IsolatedStorageFile. _ 
        GetUserStoreForDomain()

    Dim filename As String = "options.txt"
    Try
        ' Checks to see if the options.txt file exists.
        If (isoStore.GetFileNames(filename).GetLength(0) <> 0) Then

            ' Opens the file because it exists.
            Dim isos As New System.IO.IsolatedStorage.IsolatedStorageFileStream _ 
                 (filename, IO.FileMode.Open,isoStore)
            Dim reader as System.IO.StreamReader
            Try 
                reader = new System.IO.StreamReader(isos)

                ' Reads the values stored.
                Dim converter As System.ComponentModel.TypeConverter
                converter = System.ComponentModel.TypeDescriptor.GetConverter _ 
                    (GetType(Color))

                Me.MainButton.BackColor = _ 
                        CType(converter.ConvertFromString _ 
                         (reader.ReadLine()), Color)
                me.MainButton.ForeColor = _
                        CType(converter.ConvertFromString _ 
                         (reader.ReadLine()), Color)

                converter = System.ComponentModel.TypeDescriptor.GetConverter _ 
                    (GetType(Font))
                me.MainButton.Font = _
                        CType(converter.ConvertFromString _ 
                         (reader.ReadLine()), Font)

            Catch ex As Exception
                Debug.WriteLine("Cannot read options " + _
                    ex.ToString())
            Finally
                reader.Close()
            End Try
        End If

    Catch ex As Exception
        Debug.WriteLine("Cannot read options " + ex.ToString())
    End Try
End Sub

' Writes the button options to the isolated storage.
Public Sub Write() 
    Dim isoStore As System.IO.IsolatedStorage.IsolatedStorageFile = _
        System.IO.IsolatedStorage.IsolatedStorageFile. _ 
        GetUserStoreForDomain()

    Dim filename As String = "options.txt"
    Try 
        ' Checks if the file exists, and if it does, tries to delete it.
        If (isoStore.GetFileNames(filename).GetLength(0) <> 0) Then
            isoStore.DeleteFile(filename)
        End If
    Catch ex As Exception
        Debug.WriteLine("Cannot delete file " + ex.ToString())
    End Try

    ' Creates the options.txt file and writes the button options to it.
    Dim writer as System.IO.StreamWriter
    Try 
        Dim isos As New System.IO.IsolatedStorage.IsolatedStorageFileStream _ 
             (filename, IO.FileMode.CreateNew, isoStore)

        writer = New System.IO.StreamWriter(isos)
        Dim converter As System.ComponentModel.TypeConverter

        converter = System.ComponentModel.TypeDescriptor.GetConverter _ 
           (GetType(Color))
        writer.WriteLine(converter.ConvertToString( _
            Me.MainButton.BackColor))
        writer.WriteLine(converter.ConvertToString( _
            Me.MainButton.ForeColor))

        converter = System.ComponentModel TypeDescriptor.GetConverter _ 
           (GetType(Font))
        writer.WriteLine(converter.ConvertToString( _
            Me.MainButton.Font))

    Catch ex as Exception
        Debug.WriteLine("Cannot write options " + ex.ToString())

    Finally
        writer.Close()
    End Try
End Sub

// Reads the button options from the isolated storage. Uses default values 
// for the button if the options file does not exist.
public void Read() 
{
    System.IO.IsolatedStorage.IsolatedStorageFile isoStore = 
        System.IO.IsolatedStorage.IsolatedStorageFile.
        GetUserStoreForDomain();

    string filename = "options.txt";
    try
    {
        // Checks to see if the options.txt file exists.
        if (isoStore.GetFileNames(filename).GetLength(0) != 0) 
        {
            // Opens the file because it exists.
            System.IO.IsolatedStorage.IsolatedStorageFileStream isos = 
                new System.IO.IsolatedStorage.IsolatedStorageFileStream
                    (filename, System.IO.FileMode.Open,isoStore);
            System.IO.StreamReader reader = null;
            try 
            {
                reader = new System.IO.StreamReader(isos);

                // Reads the values stored.
                TypeConverter converter ;
                converter = TypeDescriptor.GetConverter(typeof(Color));

                this.MainButton.BackColor = 
                 (Color)(converter.ConvertFromString(reader.ReadLine()));
                this.MainButton.ForeColor = 
                 (Color)(converter.ConvertFromString(reader.ReadLine()));

                converter = TypeDescriptor.GetConverter(typeof(Font));
                this.MainButton.Font = 
                  (Font)(converter.ConvertFromString(reader.ReadLine()));
            }
            catch (Exception ex)
            { 
                System.Diagnostics.Debug.WriteLine
                     ("Cannot read options " + ex.ToString());
            }
            finally
            {
                reader.Close();
            }
        }
    } 
    catch (Exception ex) 
    {
        System.Diagnostics.Debug.WriteLine
            ("Cannot read options " + ex.ToString());
    }
}

// Writes the button options to the isolated storage.
public void Write() 
{
    System.IO.IsolatedStorage.IsolatedStorageFile isoStore = 
        System.IO.IsolatedStorage.IsolatedStorageFile.
        GetUserStoreForDomain();

    string filename = "options.txt";
    try 
    {
        // Checks if the file exists and, if it does, tries to delete it.
        if (isoStore.GetFileNames(filename).GetLength(0) != 0) 
        {
            isoStore.DeleteFile(filename);
        }
    }
    catch (Exception ex) 
    {
        System.Diagnostics.Debug.WriteLine
            ("Cannot delete file " + ex.ToString());
    }

    // Creates the options file and writes the button options to it.
    System.IO.StreamWriter writer = null;
    try 
    {
        System.IO.IsolatedStorage.IsolatedStorageFileStream isos = new 
            System.IO.IsolatedStorage.IsolatedStorageFileStream(filename, 
            System.IO.FileMode.CreateNew,isoStore);

        writer = new System.IO.StreamWriter(isos);
        TypeConverter converter ;

        converter = TypeDescriptor.GetConverter(typeof(Color));
        writer.WriteLine(converter.ConvertToString(
            this.MainButton.BackColor));
        writer.WriteLine(converter.ConvertToString(
            this.MainButton.ForeColor));

        converter = TypeDescriptor.GetConverter(typeof(Font));
        writer.WriteLine(converter.ConvertToString(
            this.MainButton.Font));

    }
    catch (Exception ex)
    { 
        System.Diagnostics.Debug.WriteLine
           ("Cannot write options " + ex.ToString());
    }
    finally
    {
        writer.Close();
    }
}

Accès aux bases de données

Les autorisations requises pour accéder à une base de données varient selon le fournisseur de la base de données ; toutefois, seules applications qui s'exécutent avec les autorisations appropriées peuvent accéder à une base de données via une connexion de données. Pour plus d'informations sur les autorisations requises pour accéder à une base de données, consultez Sécurité d'accès du code et ADO.NET.

Si vous ne pouvez pas accéder directement à une base de données parce que vous souhaitez que votre application s'exécute à un niveau de confiance partielle, vous pouvez utiliser un service Web XML en tant qu'autre moyen d'accéder à vos données. Un service Web XML est un logiciel accessible par programme sur un réseau via XML. Avec les Services Web XML, les applications peuvent partager des données dans des zones de groupe de codes. Par défaut, les applications des zones Intranet local et Internet sont autorisées à accéder à leurs sites d'origine, ce qui leur permet d'appeler un service Web XML. Pour plus d'informations sur la génération d'un service Web XML, consultez Services Web XML utilisant ASP.NET. Pour plus d'informations sur l'utilisation d'un service Web XML, consultez Building XML Web Service Clients.

Accès au Registre

La classe RegistryPermission contrôle l'accès au Registre du système d'exploitation. Par défaut, seules les applications qui s'exécutent localement peuvent accéder au Registre. RegistryPermission permet uniquement d'essayer d'accéder au Registre à une application ; elle ne garantit pas que l'accès réussira, étant donné que le système d'exploitation applique encore la sécurité au Registre.

Étant donné que vous ne pouvez pas accéder au Registre avec un niveau de confiance partielle, vous pouvez devoir rechercher d'autres méthodes de stockage de vos données. Lorsque vous stockez des paramètres d'application, utilisez le stockage isolé au lieu du Registre. Vous pouvez également utiliser le stockage isolé pour stocker d'autres fichiers d'application. Vous pouvez également stocker des informations d'application globales relatives au serveur ou au site d'origine étant donné que, par défaut, une application a le droit d'accéder à son site d'origine.

Voir aussi

Concepts

Impression plus sécurisée dans les Windows Forms

Considérations supplémentaires sur la sécurité des Windows Forms

Vue d'ensemble de la sécurité dans les Windows Forms

Référence

Outil Manifest Generation and Editing (Mage.exe)

Manifest Generation and Editing, outil du client graphique (MageUI.exe)

Autres ressources

Sécurité des Windows Forms