Partager via

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

  • Article

Le .NET Framework utilise des autorisations pour protéger les ressources et les données. L’emplacement où votre application peut lire ou écrire des données dépend des autorisations accordées à l’application. Lorsque votre application s’exécute dans un environnement d’approbation partielle, vous n’avez peut-être pas accès à vos données ou vous devrez peut-être modifier la façon dont vous accédez aux données.

Lorsque vous rencontrez une 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 en confiance partielle. Les sections suivantes expliquent 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 d’approbation partielle.

Remarque

Par défaut, les outils qui génèrent des déploiements ClickOnce configurent ces déploiements pour demander la confiance totale sur les ordinateurs où ils s'exécutent. Si vous décidez que vous souhaitez que les avantages de sécurité ajoutés s’exécutent en 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 façon de déterminer le niveau de confiance approprié pour votre application, consultez Sécurité dans Windows Forms Overview.

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 le FileIOPermission dans les environnements d’approbation partielle tels que les zones intranet local et Internet. Toutefois, une application qui nécessite un accès aux fichiers peut toujours fonctionner dans ces environnements si vous modifiez la conception de votre application ou utilisez différentes méthodes pour accéder aux fichiers. Par défaut, la zone intranet locale a le droit d’avoir le même accès au site et au même accès au répertoire, de se connecter au site de son origine et de lire à partir de son répertoire d’installation. Par défaut, zone Internet ne dispose que du droit de se connecter au site de son origine.

Fichiers spécifiés par l'utilisateur

L’une des façons de ne pas avoir d’autorisation d’accès aux fichiers consiste à inviter l’utilisateur à fournir des informations de fichier spécifiques à l’aide de la classe OpenFileDialog ou SaveFileDialog. Cette interaction utilisateur permet d’assurer que l’application ne peut pas charger de fichiers privés ou remplacer des fichiers importants. Les méthodes OpenFile et OpenFile fournissent un accès en lecture et écriture de fichier en ouvrant le flux de fichiers pour le fichier spécifié par l’utilisateur. Les méthodes aident également à protéger le fichier de l’utilisateur en masquant le chemin d’accès du fichier.

Remarque

Ces autorisations diffèrent selon que votre application se trouve dans la zone Internet ou la zone Intranet. Les applications de zone Internet peuvent uniquement utiliser les OpenFileDialog, tandis que les applications intranet disposent d’autorisations de boîte de dialogue de fichiers illimitées.

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

Classe Valeur d’accès requise
OpenFileDialog Open
SaveFileDialog Save

Remarque

L’autorisation spécifique n’est pas demandée tant que la méthode OpenFile n’est pas réellement appelée.

L’autorisation d’afficher une boîte de dialogue de fichier n’accorde pas à votre application un accès complet à tous les membres du FileDialog, OpenFileDialoget aux classes SaveFileDialog. Pour obtenir 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 .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 nécessite FileDialogPermission et la valeur d’énumération Open associée. L’exemple montre comment gérer le SecurityException pour déterminer si la fonctionnalité d’enregistrement doit être désactivée. Cet exemple nécessite que votre Form dispose d’un contrôle Button nommé ButtonOpenet d’un contrôle RichTextBox nommé RtfBoxMain.

Remarque

La logique de programmation de la fonctionnalité d’enregistrement n’est pas affichée dans l’exemple.

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 du code pour activer le gestionnaire d’événements. En utilisant le code de l’exemple précédent, le code suivant montre comment activer le gestionnaire d’événements.this.ButtonOpen.Click += newSystem.Windows.Forms.EventHandler(this.ButtonOpen_Click);

Autres fichiers

Parfois, vous devez lire ou écrire dans des fichiers que l’utilisateur ne spécifie pas, par exemple lorsque vous devez conserver les paramètres de l’application. Dans les zones intranet et Internet locales, votre application n’a pas l’autorisation de stocker des données dans un fichier local. Toutefois, votre application pourra stocker des données dans un stockage isolé. Le stockage isolé est un compartiment de données abstrait (et non un emplacement de stockage spécifique) qui contient un ou plusieurs fichiers de stockage isolés, 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 comme FileIOPermission ne sont pas requises ; Au lieu de cela, la classe IsolatedStoragePermission contrôle les autorisations pour le stockage isolé. Par défaut, les applications qui s’exécutent dans l’intranet local et les zones Internet peuvent stocker des données à l’aide d’un stockage isolé ; toutefois, les paramètres tels que le quota de disque peuvent varier. Pour plus d'informations sur le stockage isolé, consultez Stockage Isolé.

L’exemple suivant utilise le stockage isolé pour écrire des données dans un fichier situé dans un magasin. L’exemple nécessite IsolatedStorageFilePermission et la valeur d’énumération DomainIsolationByUser. L’exemple illustre la lecture et l’écriture de certaines valeurs de propriété du contrôle Button dans un fichier dans un stockage isolé. La fonction Read serait appelée une fois l’application démarrée et la fonction Write serait appelée avant la fin de l’application. L’exemple nécessite que les fonctions Read et Write existent 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 à la base de données

Les autorisations requises pour accéder à une base de données varient en fonction du fournisseur de base de données ; toutefois, seules les 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 au code et ADO.NET.

Si vous ne pouvez pas accéder directement à une base de données, car vous souhaitez que votre application s’exécute en confiance partielle, vous pouvez utiliser un service Web comme autre moyen d’accéder à vos données. Un service web est un élément de logiciel accessible par programme sur un réseau. Avec les services Web, les applications peuvent partager des données entre des zones de groupe de code. Par défaut, les applications dans l’intranet local et les zones Internet ont le droit d’accéder à leurs sites d’origine, ce qui leur permet d’appeler un service Web hébergé sur le même serveur. Pour plus d’informations, consultez services web dans ASP.NET AJAX ou Windows Communication Foundation.

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 accorde uniquement à une application le droit d’essayer l’accès au Registre ; elle ne garantit pas que l’accès réussit, car le système d’exploitation applique toujours la sécurité sur le Registre.

Étant donné que vous ne pouvez pas accéder au Registre en cas d’approbation partielle, vous devrez peut-être trouver d’autres méthodes de stockage de vos données. Lorsque vous stockez les paramètres de l’application, utilisez le stockage isolé au lieu du Registre. Le stockage isolé peut également être utilisé pour stocker d’autres fichiers spécifiques à l’application. Vous pouvez également stocker des informations globales sur le serveur ou le site d’origine, car par défaut, une application est autorisée à accéder au site de son origine.

Voir aussi