ProtectedData ProtectedData ProtectedData ProtectedData Class

Définition

Fournit des méthodes de chiffrement et de déchiffrement des données.Provides methods for encrypting and decrypting data. Cette classe ne peut pas être héritée.This class cannot be inherited.

public ref class ProtectedData sealed
public sealed class ProtectedData
type ProtectedData = class
Public NotInheritable Class ProtectedData
Héritage
ProtectedDataProtectedDataProtectedDataProtectedData

Exemples

L’exemple suivant montre comment utiliser la protection des données.The following example shows how to use data protection.

#using <System.Security.dll>

using namespace System;
using namespace System::Security::Cryptography;

public ref class DataProtectionSample
{
private:

   // Create byte array for additional entropy when using Protect method.
   static array<Byte>^s_aditionalEntropy = {9,8,7,6,5};

public:
   static void Main()
   {
      
      // Create a simple byte array containing data to be encrypted.
      array<Byte>^secret = {0,1,2,3,4,1,2,3,4};
      
      //Encrypt the data.
      array<Byte>^encryptedSecret = Protect( secret );
      Console::WriteLine( "The encrypted byte array is:" );
      PrintValues( encryptedSecret );
      
      // Decrypt the data and store in a byte array.
      array<Byte>^originalData = Unprotect( encryptedSecret );
      Console::WriteLine( "{0}The original data is:", Environment::NewLine );
      PrintValues( originalData );
   }

   static array<Byte>^ Protect( array<Byte>^data )
   {
      try
      {
         
         // Encrypt the data using DataProtectionScope.CurrentUser. The result can be decrypted
         //  only by the same current user.
         return ProtectedData::Protect( data, s_aditionalEntropy, DataProtectionScope::CurrentUser );
      }
      catch ( CryptographicException^ e ) 
      {
         Console::WriteLine( "Data was not encrypted. An error occurred." );
         Console::WriteLine( e );
         return nullptr;
      }
   }

   static array<Byte>^ Unprotect( array<Byte>^data )
   {
      try
      {
         
         //Decrypt the data using DataProtectionScope.CurrentUser.
         return ProtectedData::Unprotect( data, s_aditionalEntropy, DataProtectionScope::CurrentUser );
      }
      catch ( CryptographicException^ e ) 
      {
         Console::WriteLine( "Data was not decrypted. An error occurred." );
         Console::WriteLine( e );
         return nullptr;
      }
   }

   static void PrintValues( array<Byte>^myArr )
   {
      System::Collections::IEnumerator^ myEnum = myArr->GetEnumerator();
      while ( myEnum->MoveNext() )
      {
         Byte i = safe_cast<Byte>(myEnum->Current);
         Console::Write( "\t{0}", i );
      }

      Console::WriteLine();
   }
};

int main()
{
   DataProtectionSample::Main();
}
using System;
using System.Security.Cryptography;

public class DataProtectionSample
{
    // Create byte array for additional entropy when using Protect method.
    static byte [] s_aditionalEntropy = { 9, 8, 7, 6, 5 };

    public static void Main()
    {
        // Create a simple byte array containing data to be encrypted.
        byte [] secret = { 0, 1, 2, 3, 4, 1, 2, 3, 4 };

        //Encrypt the data.
        byte [] encryptedSecret = Protect( secret );
        Console.WriteLine("The encrypted byte array is:");
        PrintValues(encryptedSecret);

        // Decrypt the data and store in a byte array.
        byte [] originalData = Unprotect( encryptedSecret );
        Console.WriteLine("{0}The original data is:", Environment.NewLine);
        PrintValues(originalData);
    }

    public static byte [] Protect( byte [] data )
    {
        try
        {
            // Encrypt the data using DataProtectionScope.CurrentUser. The result can be decrypted
            // only by the same current user.
            return ProtectedData.Protect( data, s_aditionalEntropy, DataProtectionScope.CurrentUser );
        } 
        catch (CryptographicException e)
        {
            Console.WriteLine("Data was not encrypted. An error occurred.");
            Console.WriteLine(e.ToString());
            return null;
        }
    }

    public static byte [] Unprotect( byte [] data )
    {
        try
        {
            //Decrypt the data using DataProtectionScope.CurrentUser.
            return ProtectedData.Unprotect( data, s_aditionalEntropy, DataProtectionScope.CurrentUser );
        } 
        catch (CryptographicException e)
        {
            Console.WriteLine("Data was not decrypted. An error occurred.");
            Console.WriteLine(e.ToString());
            return null;
        }
    }

    public static void PrintValues( Byte[] myArr )  
    {
        foreach ( Byte i in myArr )  
        {
            Console.Write( "\t{0}", i );
        }
        Console.WriteLine();
    }
}
Imports System.Security.Cryptography



Public Class DataProtectionSample
    ' Create byte array for additional entropy when using Protect method.
    Private Shared s_aditionalEntropy As Byte() = {9, 8, 7, 6, 5}


    Public Shared Sub Main()
        ' Create a simple byte array containing data to be encrypted.
        Dim secret As Byte() = {0, 1, 2, 3, 4, 1, 2, 3, 4}

        'Encrypt the data.
        Dim encryptedSecret As Byte() = Protect(secret)
        Console.WriteLine("The encrypted byte array is:")
        PrintValues(encryptedSecret)

        ' Decrypt the data and store in a byte array.
        Dim originalData As Byte() = Unprotect(encryptedSecret)
        Console.WriteLine("{0}The original data is:", Environment.NewLine)
        PrintValues(originalData)

    End Sub


    Public Shared Function Protect(ByVal data() As Byte) As Byte()
        Try
            ' Encrypt the data using DataProtectionScope.CurrentUser. The result can be decrypted
            '  only by the same current user.
            Return ProtectedData.Protect(data, s_aditionalEntropy, DataProtectionScope.CurrentUser)
        Catch e As CryptographicException
            Console.WriteLine("Data was not encrypted. An error occurred.")
            Console.WriteLine(e.ToString())
            Return Nothing
        End Try

    End Function


    Public Shared Function Unprotect(ByVal data() As Byte) As Byte()
        Try
            'Decrypt the data using DataProtectionScope.CurrentUser.
            Return ProtectedData.Unprotect(data, s_aditionalEntropy, DataProtectionScope.CurrentUser)
        Catch e As CryptographicException
            Console.WriteLine("Data was not decrypted. An error occurred.")
            Console.WriteLine(e.ToString())
            Return Nothing
        End Try

    End Function


    Public Shared Sub PrintValues(ByVal myArr() As [Byte])
        Dim i As [Byte]
        For Each i In myArr
            Console.Write(vbTab + "{0}", i)
        Next i
        Console.WriteLine()

    End Sub
End Class

Remarques

Cette classe fournit l’accès à l’API de protection des données (DPAPI) disponible dans les systèmes d’exploitation Windows.This class provides access to the Data Protection API (DPAPI) available in Windows operating systems. Il s’agit d’un service fourni par le système d’exploitation et ne nécessitant pas de bibliothèques supplémentaires.This is a service that is provided by the operating system and does not require additional libraries. Il assure la protection à l’aide des informations d’identification de l’utilisateur ou de l’ordinateur pour chiffrer ou déchiffrer les données.It provides protection using the user or machine credentials to encrypt or decrypt data.

Important

Étant donné qu’elle dépend de DPAPI ProtectedData , la classe est prise en charge uniquement sur la plateforme Windows.Because it depends on DPAPI, the ProtectedData class is supported on the Windows platform only. Son utilisation sur .NET Core sur des plateformes autres que Windows lève PlatformNotSupportedExceptionune.Its use on .NET Core on platforms other than Windows throws a PlatformNotSupportedException.

La classe se compose de deux wrappers pour l’interface DPAPI non managée Unprotect, Protect et.The class consists of two wrappers for the unmanaged DPAPI, Protect and Unprotect. Ces deux méthodes peuvent être utilisées pour chiffrer et déchiffrer des données telles que les mots de passe, les clés et les chaînes de connexion.These two methods can be used to encrypt and decrypt data such as passwords, keys, and connection strings.

Si vous utilisez ces méthodes pendant l’emprunt d’identité, vous pouvez recevoir l’erreur suivante: «La clé n’est pas valide pour une utilisation dans l’état spécifié.»If you use these methods during impersonation, you may receive the following error: "Key not valid for use in specified state." Cela est dû au fait que DPAPI stocke les données de clé dans des profils utilisateur.This occurs because the DPAPI stores the key data in user profiles. Si le profil n’est pas chargé, DPAPI ne pourra pas effectuer le déchiffrement.If the profile is not loaded, DPAPI won't be able to perform the decryption. Pour éviter cette erreur, chargez le profil de l’utilisateur dont vous souhaitez emprunter l’identité avant d’appeler l’une ou l’autre des méthodes.To prevent this error, load the profile of the user you want to impersonate before calling either method. L’utilisation de DPAPI avec l’emprunt d’identité peut entraîner des complications importantes et nécessite des choix de conception soignés.Using DPAPI with impersonation can incur significant complication and requires careful design choices.

Méthodes

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Inherited from Object)
Protect(Byte[], Byte[], DataProtectionScope) Protect(Byte[], Byte[], DataProtectionScope) Protect(Byte[], Byte[], DataProtectionScope) Protect(Byte[], Byte[], DataProtectionScope)

Chiffre les données contenues dans un tableau d'octets spécifié et retourne un tableau d'octets contenant les données chiffrées.Encrypts the data in a specified byte array and returns a byte array that contains the encrypted data.

ToString() ToString() ToString() ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Inherited from Object)
Unprotect(Byte[], Byte[], DataProtectionScope) Unprotect(Byte[], Byte[], DataProtectionScope) Unprotect(Byte[], Byte[], DataProtectionScope) Unprotect(Byte[], Byte[], DataProtectionScope)

Déchiffre les données contenues dans un tableau d'octets spécifié et retourne un tableau d'octets contenant les données déchiffrées.Decrypts the data in a specified byte array and returns a byte array that contains the decrypted data.

S’applique à