SecureString Classe

Définition

Représente le texte qui doit rester confidentiel, par exemple en le supprimant de la mémoire de l'ordinateur quand il n'est plus nécessaire. Cette classe ne peut pas être héritée.

public ref class SecureString sealed : IDisposable
public sealed class SecureString : IDisposable
type SecureString = class
    interface IDisposable
Public NotInheritable Class SecureString
Implements IDisposable
Héritage
SecureString
Implémente

Exemples

L’exemple suivant montre comment utiliser un SecureString pour sécuriser le mot de passe d’un utilisateur en vue de l’utiliser comme informations d’identification pour démarrer un nouveau processus.

using System;
using System.ComponentModel;
using System.Diagnostics;
using System.Security;

public class Example
{
    public static void Main()
    {
        // Instantiate the secure string.
        SecureString securePwd = new SecureString();
        ConsoleKeyInfo key;

        Console.Write("Enter password: ");
        do {
           key = Console.ReadKey(true);
           
           // Ignore any key out of range.
           if (((int) key.Key) >= 65 && ((int) key.Key <= 90)) {
              // Append the character to the password.
              securePwd.AppendChar(key.KeyChar);
              Console.Write("*");
           }   
        // Exit if Enter key is pressed.
        } while (key.Key != ConsoleKey.Enter);
        Console.WriteLine();
        
        try {
            Process.Start("Notepad.exe", "MyUser", securePwd, "MYDOMAIN");
        }
        catch (Win32Exception e) {
            Console.WriteLine(e.Message);
        }
        finally {
           securePwd.Dispose();
        }
    }
}
Imports System.ComponentModel
Imports System.Diagnostics
Imports System.Security

Public Class Example
    Public Shared Sub Main()
        ' Instantiate the secure string.
        Dim securePwd As New SecureString()
        Dim key As ConsoleKeyInfo
        
        Console.Write("Enter password: ")
        Do
           key = Console.ReadKey(True)

           ' Ignore any key out of range
           If CInt(key.Key) >= 65 And CInt(key.Key <= 90) Then    
              ' Append the character to the password.
              securePwd.AppendChar(key.KeyChar)
              Console.Write("*")
           End If                                    
        ' Exit if Enter key is pressed.
        Loop While key.Key <> ConsoleKey.Enter
        Console.WriteLine()
        
        Try
            Process.Start("Notepad.exe", "MyUser", securePwd, "MYDOMAIN")
        Catch e As Win32Exception
            Console.WriteLine(e.Message)
        Finally
           securePwd.Dispose()
        End Try
    End Sub
End Class

Remarques

Important

Nous vous déconseillons d’utiliser la classe pour le SecureString nouveau développement. Pour plus d’informations, consultez SecureString ne doit pas être utilisé sur GitHub.

SecureString est un type de chaîne qui fournit une mesure de sécurité. Il tente d’éviter de stocker des chaînes potentiellement sensibles dans la mémoire de processus sous forme de texte brut. (Pour connaître les limitations, toutefois, consultez la section Comment securestring est-il sécurisé ? ) La valeur d’une instance de SecureString est automatiquement protégée à l’aide d’un mécanisme pris en charge par la plateforme sous-jacente lorsque l’instance est initialisée ou lorsque la valeur est modifiée. Votre application peut rendre l’instance immuable et empêcher toute modification supplémentaire en appelant la MakeReadOnly méthode .

La longueur maximale d’une SecureString instance est de 65 536 caractères.

Important

Ce type implémente l'interface IDisposable. Lorsque vous avez terminé d’utiliser une instance du type, vous devez la supprimer directement ou indirectement. Pour supprimer directement le type Dispose, appelez sa méthode dans un bloc try/catch. Pour la supprimer indirectement, utilisez une construction de langage telle que using (dans C#) ou Using (dans Visual Basic). Pour plus d’informations, consultez la section « Utilisation d’un objet qui implémente IDisposable » dans la rubrique de l’interface IDisposable.

La SecureString classe et ses membres ne sont pas visibles par COM. Pour plus d'informations, consultez ComVisibleAttribute.

Dans cette section :

Chaîne et SecureString
Opérations SecureString
SecureString et interopérabilité
SecureString est-il sécurisé ?

String et SecureString

Une instance de la classe est à la System.String fois immuable et, lorsqu’elle n’est plus nécessaire, ne peut pas être planifiée par programmation pour le garbage collection ; autrement dit, l’instance est en lecture seule après sa création et il n’est pas possible de prédire quand l’instance sera supprimée de la mémoire de l’ordinateur. Étant donné que System.String les instances sont immuables, les opérations qui semblent modifier une instance existante créent en fait une copie de celle-ci à manipuler. Par conséquent, si un objet contient des String informations sensibles telles qu’un mot de passe, un numéro de carte de crédit ou des données personnelles, il existe un risque que les informations soient révélées après leur utilisation, car votre application ne peut pas supprimer les données de la mémoire de l’ordinateur.

Un SecureString objet est similaire à un String objet en ce qu’il a une valeur de texte. Toutefois, la valeur d’un SecureString objet est épinglée en mémoire, peut utiliser un mécanisme de protection, tel que le chiffrement, fourni par le système d’exploitation sous-jacent, peut être modifié jusqu’à ce que votre application la marque comme en lecture seule, et peut être supprimé de la mémoire de l’ordinateur par votre application appelant la Dispose méthode ou par le récupérateur de mémoire .NET Framework.

Pour une présentation des limitations de la SecureString classe, consultez la section Comment secureString est-il sécurisé ?

Retour au début

Opérations SecureString

La SecureString classe inclut des membres qui vous permettent d’effectuer les opérations suivantes :

Instancier un SecureString objet
Vous instanciez un SecureString objet en appelant son constructeur sans paramètre.

Ajouter des caractères à un SecureString objet
Vous pouvez ajouter un caractère unique à la fois à un SecureString objet en appelant sa AppendChar méthode ou InsertAt .

Important

Un SecureString objet ne doit jamais être construit à partir d’un String, car les données sensibles sont déjà soumises aux conséquences de persistance de la mémoire de la classe immuable String . La meilleure façon de construire un SecureString objet consiste à partir d’une source non managée caractère à la fois, telle que la Console.ReadKey méthode .

Supprimer des caractères d’un SecureString objet
Vous pouvez remplacer un caractère individuel en appelant la SetAt méthode, supprimer un caractère individuel en appelant la RemoveAt méthode ou supprimer tous les caractères de l’instance SecureString en appelant la Clear méthode .

Rendre l’objet SecureString en lecture seule
Une fois que vous avez défini la chaîne que l’objet SecureString représente, vous appelez sa MakeReadOnly méthode pour rendre la chaîne en lecture seule.

Obtenir des informations sur l’objet SecureString
La SecureString classe n’a que deux membres qui fournissent des informations sur la chaîne : sa Length propriété, qui indique le nombre d’unités de code encodées en UTF16 dans la chaîne , et la IsReadOnlyméthode , qui indique si l’instance est en lecture seule.

Libérer la mémoire allouée à l’instance SecureString
Étant donné que SecureString implémente l’interface IDisposable , vous libérez sa mémoire en appelant la Dispose méthode .

La SecureString classe n’a aucun membre qui inspecte, compare ou convertit la valeur d’un SecureString. L’absence de ces membres permet de protéger la valeur de l’instance contre une exposition accidentelle ou malveillante. Utilisez les membres appropriés de la System.Runtime.InteropServices.Marshal classe, tels que la SecureStringToBSTR méthode, pour manipuler la valeur d’un SecureString objet .

La bibliothèque de classes .NET Framework utilise SecureString couramment des instances des manières suivantes :

Retour au début

SecureString et interopérabilité

Étant donné que le système d’exploitation ne prend pas directement en charge SecureString, vous devez convertir la valeur de l’objet SecureString en type de chaîne requis avant de passer la chaîne à une méthode native. La Marshal classe a cinq méthodes qui effectuent cette opération :

Chacune de ces méthodes crée une chaîne de texte clair dans la mémoire non managée. Il est de la responsabilité du développeur de zéro et de libérer cette mémoire dès qu’elle n’est plus nécessaire. Chacune des méthodes de conversion de chaîne et d’allocation de mémoire a une méthode correspondante pour zéro et libérer la mémoire allouée :

Méthode d’allocation et de conversion Méthode zéro et gratuite
Marshal.SecureStringToBSTR Marshal.ZeroFreeBSTR
Marshal.SecureStringToCoTaskMemAnsi Marshal.ZeroFreeCoTaskMemAnsi
Marshal.SecureStringToCoTaskMemUnicode Marshal.ZeroFreeCoTaskMemUnicode
Marshal.SecureStringToGlobalAllocAnsi Marshal.ZeroFreeGlobalAllocAnsi
Marshal.SecureStringToGlobalAllocUnicode Marshal.ZeroFreeGlobalAllocUnicode

Retour au début

SecureString est-il sécurisé ?

Lorsqu’elle est créée correctement, une SecureString instance fournit plus de protection des données qu’un String. Lors de la création d’une chaîne à partir d’une source caractère à la fois, String crée plusieurs intermédiaires en mémoire, alors qu’une SecureString seule instance est créée. Le garbage collection des String objets n’est pas déterministe. De plus, étant donné que sa mémoire n’est pas épinglée, le récupérateur de mémoire effectue des copies supplémentaires des valeurs lors du déplacement et du compactage de String la mémoire. En revanche, la mémoire allouée à un SecureString objet est épinglée et cette mémoire peut être libérée en appelant la Dispose méthode .

Bien que les données stockées dans une SecureString instance soient plus sécurisées que les données stockées dans une String instance, il existe des limitations importantes quant à la sécurité d’une SecureString instance. Elles incluent notamment :

Plateforme
Sur le système d’exploitation Windows, le contenu du tableau de caractères interne d’une SecureString instance est chiffré. Toutefois, que ce soit en raison d’API manquantes ou de problèmes de gestion des clés, le chiffrement n’est pas disponible sur toutes les plateformes. En raison de cette dépendance de plateforme, SecureString ne chiffre pas le stockage interne sur une plateforme non Windows. D’autres techniques sont utilisées sur ces plateformes pour fournir une protection supplémentaire.

Duration
Même si l’implémentation SecureString est en mesure de tirer parti du chiffrement, le texte brut affecté à l’instance SecureString peut être exposé à différents moments :

  • Étant donné que Windows n’offre pas d’implémentation de chaîne sécurisée au niveau du système d’exploitation, le .NET Framework doit toujours convertir la valeur de la chaîne sécurisée en sa représentation en texte brut pour pouvoir l’utiliser.

  • Chaque fois que la valeur de la chaîne sécurisée est modifiée par des méthodes telles que AppendChar ou RemoveAt, elle doit être déchiffrée (c’est-à-dire convertie en texte brut), modifiée, puis chiffrée à nouveau.

  • Si la chaîne sécurisée est utilisée dans un appel d’interopérabilité, elle doit être convertie en chaîne ANSI, chaîne Unicode ou chaîne binaire (BSTR). Pour plus d’informations, consultez la section SecureString et interopérabilité .

L’intervalle de temps pendant lequel la valeur de l’instance SecureString est exposée est simplement raccourci par rapport à la String classe .

Stockage et utilisation
Plus généralement, la SecureString classe définit un mécanisme de stockage pour les valeurs de chaîne qui doivent être protégées ou gardées confidentielles. Toutefois, en dehors du .NET Framework lui-même, aucun mécanisme d’utilisation ne prend en charge SecureString. Cela signifie que la chaîne sécurisée doit être convertie en un formulaire utilisable (généralement un formulaire de texte clair) qui peut être reconnu par sa cible, et que le déchiffrement et la conversion doivent se produire dans l’espace utilisateur.

Dans l’ensemble, SecureString est plus sécurisé que parce qu’il String limite l’exposition des données de chaîne sensibles. Toutefois, ces chaînes peuvent toujours être exposées à n’importe quel processus ou opération ayant accès à la mémoire brute, comme un processus malveillant s’exécutant sur l’ordinateur hôte, un vidage de processus ou un fichier d’échange visible par l’utilisateur. Au lieu d’utiliser SecureString pour protéger les mots de passe, l’alternative recommandée consiste à utiliser un handle opaque pour les informations d’identification stockées en dehors du processus.

Retour au début

Constructeurs

SecureString()

Initialise une nouvelle instance de la classe SecureString.

SecureString(Char*, Int32)

Initialise une nouvelle instance de la classe SecureString à partir d'un sous-tableau d'objets Char.

Ce constructeur n’est pas conforme CLS. L’alternative conforme CLS est SecureString().

Propriétés

Length

Obtient le nombre de caractères dans la chaîne sécurisée actuelle.

Méthodes

AppendChar(Char)

Ajoute un caractère à la fin de la chaîne sécurisée actuelle.

Clear()

Supprime la valeur de la chaîne sécurisée actuelle.

Copy()

Crée une copie de la chaîne sécurisée actuelle.

Dispose()

Libère toutes les ressources utilisées par l’objet SecureString actuel.

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.

(Hérité de Object)
GetHashCode()

Fait office de fonction de hachage par défaut.

(Hérité de Object)
GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
InsertAt(Int32, Char)

Insère un caractère dans cette chaîne sécurisée à la position d'index spécifiée.

IsReadOnly()

Indique si cette chaîne sécurisée est en lecture seule.

MakeReadOnly()

Met en lecture seule la valeur texte de cette chaîne sécurisée.

MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de Object)
RemoveAt(Int32)

Supprime de cette chaîne sécurisée le caractère situé à la position d'index spécifiée.

SetAt(Int32, Char)

Remplace le caractère existant à la position d'index spécifiée par un autre caractère.

ToString()

Retourne une chaîne qui représente l'objet actuel.

(Hérité de Object)

S’applique à

Voir aussi