SHA256Managed Classe

Définition

Attention

Derived cryptographic types are obsolete. Use the Create method on the base type instead.

Calcule le hachage SHA256 pour les données d'entrée à l'aide de la bibliothèque managée.

public ref class SHA256Managed sealed : System::Security::Cryptography::SHA256
public ref class SHA256Managed : System::Security::Cryptography::SHA256
public sealed class SHA256Managed : System.Security.Cryptography.SHA256
[System.Obsolete("Derived cryptographic types are obsolete. Use the Create method on the base type instead.", DiagnosticId="SYSLIB0021", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
public sealed class SHA256Managed : System.Security.Cryptography.SHA256
public class SHA256Managed : System.Security.Cryptography.SHA256
[System.Runtime.InteropServices.ComVisible(true)]
public class SHA256Managed : System.Security.Cryptography.SHA256
type SHA256Managed = class
    inherit SHA256
[<System.Obsolete("Derived cryptographic types are obsolete. Use the Create method on the base type instead.", DiagnosticId="SYSLIB0021", UrlFormat="https://aka.ms/dotnet-warnings/{0}")>]
type SHA256Managed = class
    inherit SHA256
[<System.Runtime.InteropServices.ComVisible(true)>]
type SHA256Managed = class
    inherit SHA256
Public NotInheritable Class SHA256Managed
Inherits SHA256
Public Class SHA256Managed
Inherits SHA256
Héritage
SHA256Managed
Attributs

Exemples

L’exemple suivant calcule le hachage SHA-256 pour tous les fichiers d’un répertoire.

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

// Print the byte array in a readable format.
void PrintByteArray( array<Byte>^array )
{
   int i;
   for ( i = 0; i < array->Length; i++ )
   {
      Console::Write( String::Format( "{0:X2}", array[ i ] ) );
      if ( (i % 4) == 3 )
            Console::Write( " " );

   }
   Console::WriteLine();
}

int main()
{
   array<String^>^args = Environment::GetCommandLineArgs();
   if ( args->Length < 2 )
   {
      Console::WriteLine( "Usage: hashdir <directory>" );
      return 0;
   }

   try
   {

      // Create a DirectoryInfo object representing the specified directory.
      DirectoryInfo^ dir = gcnew DirectoryInfo( args[ 1 ] );

      // Get the FileInfo objects for every file in the directory.
      array<FileInfo^>^files = dir->GetFiles();

      // Initialize a SHA256 hash object.
      SHA256 ^ mySHA256 = SHA256Managed::Create();
      array<Byte>^hashValue;

      // Compute and print the hash values for each file in directory.
      System::Collections::IEnumerator^ myEnum = files->GetEnumerator();
      while ( myEnum->MoveNext() )
      {
         FileInfo^ fInfo = safe_cast<FileInfo^>(myEnum->Current);

         // Create a fileStream for the file.
         FileStream^ fileStream = fInfo->Open( FileMode::Open );

         // Compute the hash of the fileStream.
         hashValue = mySHA256->ComputeHash( fileStream );

         // Write the name of the file to the Console.
         Console::Write( "{0}: ", fInfo->Name );

         // Write the hash value to the Console.
         PrintByteArray( hashValue );

         // Close the file.
         fileStream->Close();
      }
      return 0;
   }
   catch ( DirectoryNotFoundException^ ) 
   {
      Console::WriteLine( "Error: The directory specified could not be found." );
   }
   catch ( IOException^ ) 
   {
      Console::WriteLine( "Error: A file in the directory could not be accessed." );
   }

}
using System;
using System.IO;
using System.Security.Cryptography;

public class HashDirectory
{
    public static void Main(string[] args)
    {
        if (args.Length < 1)
        {
            Console.WriteLine("No directory selected.");
            return;
        }

        string directory = args[0];
        if (Directory.Exists(directory))
        {
            // Create a DirectoryInfo object representing the specified directory.
            var dir = new DirectoryInfo(directory);
            // Get the FileInfo objects for every file in the directory.
            FileInfo[] files = dir.GetFiles();
            // Initialize a SHA256 hash object.
            using (SHA256 mySHA256 = SHA256.Create())
            {
                // Compute and print the hash values for each file in directory.
                foreach (FileInfo fInfo in files)
                {
                    using (FileStream fileStream = fInfo.Open(FileMode.Open))
                    {
                        try
                        {
                            // Create a fileStream for the file.
                            // Be sure it's positioned to the beginning of the stream.
                            fileStream.Position = 0;
                            // Compute the hash of the fileStream.
                            byte[] hashValue = mySHA256.ComputeHash(fileStream);
                            // Write the name and hash value of the file to the console.
                            Console.Write($"{fInfo.Name}: ");
                            PrintByteArray(hashValue);
                        }
                        catch (IOException e)
                        {
                            Console.WriteLine($"I/O Exception: {e.Message}");
                        }
                        catch (UnauthorizedAccessException e)
                        {
                            Console.WriteLine($"Access Exception: {e.Message}");
                        }
                    }
                }
            }
        }
        else
        {
            Console.WriteLine("The directory specified could not be found.");
        }
    }

    // Display the byte array in a readable format.
    public static void PrintByteArray(byte[] array)
    {
        for (int i = 0; i < array.Length; i++)
        {
            Console.Write($"{array[i]:X2}");
            if ((i % 4) == 3) Console.Write(" ");
        }
        Console.WriteLine();
    }
}
Imports System.IO
Imports System.Security.Cryptography

Public Module HashDirectory

    Public Sub Main(ByVal args() As String)
        If args.Length < 1 Then
            Console.WriteLine("No directory selected")
            Return
        End If

        Dim targetDirectory As String = args(0)
        If Directory.Exists(targetDirectory) Then
            ' Create a DirectoryInfo object representing the specified directory.
            Dim dir As New DirectoryInfo(targetDirectory)
            ' Get the FileInfo objects for every file in the directory.
            Dim files As FileInfo() = dir.GetFiles()
            ' Initialize a SHA256 hash object.
            Using mySHA256 As SHA256 = SHA256.Create()
                ' Compute and print the hash values for each file in directory.
                For Each fInfo  As FileInfo In files
                    Try
                        ' Create a fileStream for the file.
                        Dim fileStream = fInfo.Open(FileMode.Open)
                        ' Be sure it's positioned to the beginning of the stream.
                        fileStream.Position = 0
                        ' Compute the hash of the fileStream.
                        Dim hashValue() As Byte = mySHA256.ComputeHash(fileStream)
                        ' Write the name of the file to the Console.
                        Console.Write(fInfo.Name + ": ")
                        ' Write the hash value to the Console.
                        PrintByteArray(hashValue)
                        ' Close the file.
                        fileStream.Close()
                    Catch e As IOException
                        Console.WriteLine($"I/O Exception: {e.Message}")
                    Catch e As UnauthorizedAccessException 
                        Console.WriteLine($"Access Exception: {e.Message}")
                    End Try    
                Next 
            End Using
        Else
           Console.WriteLine("The directory specified could not be found.")
        End If
    End Sub

    ' Print the byte array in a readable format.
    Public Sub PrintByteArray(array() As Byte)
        For i As Integer = 0 To array.Length - 1
            Console.Write($"{array(i):X2}")
            If i Mod 4 = 3 Then
                Console.Write(" ")
            End If
        Next 
        Console.WriteLine()

    End Sub 
End Module

Remarques

Le hachage est utilisé comme valeur unique de taille fixe représentant une grande quantité de données. Les hachages de deux jeux de données doivent correspondre si et uniquement si les données correspondantes correspondent également. De petites modifications apportées aux données entraînent de grandes modifications imprévisibles dans le hachage.

La taille de hachage de l’algorithme SHA256Managed est de 256 bits.

Constructeurs

SHA256Managed()
Obsolète.

Initialise une nouvelle instance de la classe SHA256Managed à l'aide de la bibliothèque managée.

Champs

HashSizeInBits
Obsolète.

Taille de hachage produite par l’algorithme SHA256, en bits.

(Hérité de SHA256)
HashSizeInBytes
Obsolète.

Taille de hachage produite par l’algorithme SHA256, en octets.

(Hérité de SHA256)
HashSizeValue
Obsolète.

Représente la taille, en bits, du code de hachage calculé.

(Hérité de HashAlgorithm)
HashValue
Obsolète.

Représente la valeur du code de hachage calculé.

(Hérité de HashAlgorithm)
State
Obsolète.

Représente l'état du calcul du hachage.

(Hérité de HashAlgorithm)

Propriétés

CanReuseTransform
Obsolète.

Obtient une valeur indiquant si la transformation actuelle peut être réutilisée.

(Hérité de HashAlgorithm)
CanTransformMultipleBlocks
Obsolète.

En cas de substitution dans une classe dérivée, obtient une valeur indiquant si plusieurs blocs peuvent être transformés.

(Hérité de HashAlgorithm)
Hash
Obsolète.

Obtient la valeur du code de hachage calculé.

(Hérité de HashAlgorithm)
HashSize
Obsolète.

Obtient la taille, en bits, du code de hachage calculé.

(Hérité de HashAlgorithm)
InputBlockSize
Obsolète.

En cas de substitution dans une classe dérivée, obtient la taille du bloc d'entrée.

(Hérité de HashAlgorithm)
OutputBlockSize
Obsolète.

En cas de substitution dans une classe dérivée, obtient la taille du bloc de sortie.

(Hérité de HashAlgorithm)

Méthodes

Clear()
Obsolète.

Libère toutes les ressources utilisées par la classe HashAlgorithm.

(Hérité de HashAlgorithm)
ComputeHash(Byte[])
Obsolète.

Calcule la valeur de hachage pour le tableau d'octets spécifié.

(Hérité de HashAlgorithm)
ComputeHash(Byte[], Int32, Int32)
Obsolète.

Calcule la valeur de hachage pour la région spécifiée du tableau d'octets spécifié.

(Hérité de HashAlgorithm)
ComputeHash(Stream)
Obsolète.

Calcule la valeur de hachage pour l'objet Stream spécifié.

(Hérité de HashAlgorithm)
ComputeHashAsync(Stream, CancellationToken)
Obsolète.

Calcule de manière asynchrone la valeur de hachage pour l'objet Stream spécifié.

(Hérité de HashAlgorithm)
Dispose()
Obsolète.

Libère toutes les ressources utilisées par l'instance actuelle de la classe HashAlgorithm.

(Hérité de HashAlgorithm)
Dispose(Boolean)
Obsolète.

Libère les ressources non managées utilisées par l’objet SHA256Managed et libère éventuellement les ressources managées.

Dispose(Boolean)
Obsolète.

Libère les ressources non managées utilisées par HashAlgorithm et libère éventuellement les ressources managées.

(Hérité de HashAlgorithm)
Equals(Object)
Obsolète.

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

(Hérité de Object)
GetHashCode()
Obsolète.

Fait office de fonction de hachage par défaut.

(Hérité de Object)
GetType()
Obsolète.

Obtient le Type de l'instance actuelle.

(Hérité de Object)
HashCore(Byte[], Int32, Int32)
Obsolète.

En cas de substitution dans une classe dérivée, achemine les données écrites dans l'objet vers l'algorithme de hachage SHA256 pour calculer le hachage.

HashCore(Byte[], Int32, Int32)
Obsolète.

En cas de substitution dans une classe dérivée, achemine les données écrites dans l'objet vers l'algorithme de hachage pour calculer le hachage.

(Hérité de HashAlgorithm)
HashCore(ReadOnlySpan<Byte>)
Obsolète.

Route les données écrites dans l’objet vers l’algorithme de hachage pour le calcul du hachage.

(Hérité de HashAlgorithm)
HashFinal()
Obsolète.

En cas de substitution dans une classe dérivée, finalise le calcul de hachage une fois les dernières données traitées par l'objet de flux de chiffrement.

HashFinal()
Obsolète.

En cas de remplacement dans une classe dérivée, finalise le calcul du hachage une fois les dernières données traitées par l’algorithme de hachage du chiffrement.

(Hérité de HashAlgorithm)
Initialize()
Obsolète.

Initialise une instance de SHA256Managed.

MemberwiseClone()
Obsolète.

Crée une copie superficielle du Object actuel.

(Hérité de Object)
ToString()
Obsolète.

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

(Hérité de Object)
TransformBlock(Byte[], Int32, Int32, Byte[], Int32)
Obsolète.

Calcule la valeur de hachage pour la région spécifiée du tableau d'octets d'entrée et copie la région spécifiée du tableau d'octets d'entrée dans la région spécifiée du tableau d'octets de sortie.

(Hérité de HashAlgorithm)
TransformFinalBlock(Byte[], Int32, Int32)
Obsolète.

Calcule la valeur de hachage pour la région spécifiée du tableau d'octets spécifié.

(Hérité de HashAlgorithm)
TryComputeHash(ReadOnlySpan<Byte>, Span<Byte>, Int32)
Obsolète.

Tente de calculer la valeur de hachage pour le tableau d’octets spécifié.

(Hérité de HashAlgorithm)
TryHashFinal(Span<Byte>, Int32)
Obsolète.

Tente de finaliser le calcul du hachage après que les dernières données ont été traitées par l’algorithme de hachage.

(Hérité de HashAlgorithm)

Implémentations d’interfaces explicites

IDisposable.Dispose()
Obsolète.

Libère les ressources non managées utilisées par HashAlgorithm et libère éventuellement les ressources managées.

(Hérité de HashAlgorithm)

S’applique à

Voir aussi