SHA256Managed Classe

Definizione

Spazio dei nomi:

System.Security.Cryptography

Assembly:

System.Security.Cryptography.dll

Source:

SHA256Managed.cs

Attenzione

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

Consente di calcolare l'hash SHA256 per i dati di input utilizzando la libreria gestita.

public ref class SHA256Managed sealed : 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

[<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

Public NotInheritable Class SHA256Managed
Inherits SHA256

Ereditarietà

Object

HashAlgorithm

SHA256

SHA256Managed

Attributi

ObsoleteAttribute

Esempio

Nell'esempio seguente viene calcolato l'hash SHA-256 per tutti i file in una directory.

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

Commenti

L'hash viene usato come valore univoco di dimensioni fisse che rappresentano una grande quantità di dati. Gli hash di due set di dati devono corrispondere se e solo se i dati corrispondenti corrispondono anche. Le piccole modifiche apportate ai dati comportano modifiche imprevedibili di grandi dimensioni nell'hash.

Le dimensioni hash per l'algoritmo SHA256Managed sono 256 bit.

Costruttori

SHA256Managed()

Obsoleti. Inizializza una nuova istanza della classe SHA256Managed utilizzando la libreria gestita.

Campi

HashSizeInBits	Obsoleti. Dimensioni hash prodotte dall'algoritmo SHA256, in bit. (Ereditato da SHA256)
HashSizeInBytes	Obsoleti. Dimensioni hash prodotte dall'algoritmo SHA256, in byte. (Ereditato da SHA256)
HashSizeValue	Obsoleti. Rappresenta la dimensione in bit del codice hash calcolato. (Ereditato da HashAlgorithm)
HashValue	Obsoleti. Rappresenta il valore del codice hash calcolato. (Ereditato da HashAlgorithm)
State	Obsoleti. Rappresenta lo stato del calcolo hash. (Ereditato da HashAlgorithm)

Proprietà

CanReuseTransform	Obsoleti. Ottiene un valore che indica se è possibile riutilizzare la trasformazione corrente. (Ereditato da HashAlgorithm)
CanTransformMultipleBlocks	Obsoleti. Quando ne viene eseguito l'override in una classe derivata, ottiene un valore che indica se è possibile trasformare più blocchi. (Ereditato da HashAlgorithm)
Hash	Obsoleti. Ottiene il valore del codice hash calcolato. (Ereditato da HashAlgorithm)
HashSize	Obsoleti. Ottiene la dimensione in bit del codice hash calcolato. (Ereditato da HashAlgorithm)
InputBlockSize	Obsoleti. Quando ne viene eseguito l'override in una classe derivata, ottiene la dimensione del blocco di input. (Ereditato da HashAlgorithm)
OutputBlockSize	Obsoleti. Quando ne viene eseguito l'override in una classe derivata, ottiene la dimensione del blocco di output. (Ereditato da HashAlgorithm)

Metodi

Clear()	Obsoleti. Rilascia tutte le risorse usate dalla classe HashAlgorithm. (Ereditato da HashAlgorithm)
ComputeHash(Byte[])	Obsoleti. Consente di calcolare il valore hash della matrice di byte specificata. (Ereditato da HashAlgorithm)
ComputeHash(Byte[], Int32, Int32)	Obsoleti. Calcola il valore hash dell'area specifica della matrice di byte specificata. (Ereditato da HashAlgorithm)
ComputeHash(Stream)	Obsoleti. Calcola il valore hash per l'oggetto Stream specificato. (Ereditato da HashAlgorithm)
ComputeHashAsync(Stream, CancellationToken)	Obsoleti. Calcola in modo asincrono il valore hash per l'oggetto Stream specificato. (Ereditato da HashAlgorithm)
Dispose()	Obsoleti. Rilascia tutte le risorse usate dall'istanza corrente della classe HashAlgorithm. (Ereditato da HashAlgorithm)
Dispose(Boolean)	Obsoleti. Rilascia le risorse non gestite usate da HashAlgorithm e, facoltativamente, le risorse gestite. (Ereditato da HashAlgorithm)
Equals(Object)	Obsoleti. Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetHashCode()	Obsoleti. Funge da funzione hash predefinita. (Ereditato da Object)
GetType()	Obsoleti. Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
HashCore(Byte[], Int32, Int32)	Obsoleti. Quando ne viene eseguito l'override in una classe derivata, indirizza i dati scritti nell'oggetto verso l'algoritmo hash per il calcolo dell'hash. (Ereditato da HashAlgorithm)
HashCore(ReadOnlySpan<Byte>)	Obsoleti. Consente di indirizzare i dati scritti nell'oggetto nell'algoritmo hash per il calcolo dell'hash. (Ereditato da HashAlgorithm)
HashFinal()	Obsoleti. Quando ne viene eseguito l'override in una classe derivata, finalizza il calcolo hash una volta che gli ultimi dati sono stati elaborati dall'algoritmo hash crittografico. (Ereditato da HashAlgorithm)
Initialize()	Obsoleti. Inizializza un'istanza di SHA256Managed.
MemberwiseClone()	Obsoleti. Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
ToString()	Obsoleti. Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)
TransformBlock(Byte[], Int32, Int32, Byte[], Int32)	Obsoleti. Consente di calcolare il valore hash dell'area specifica della matrice di byte di input e di copiare una determinata area della matrice di byte di input nell'area specifica della matrice di byte di output. (Ereditato da HashAlgorithm)
TransformFinalBlock(Byte[], Int32, Int32)	Obsoleti. Calcola il valore hash dell'area specifica della matrice di byte specificata. (Ereditato da HashAlgorithm)
TryComputeHash(ReadOnlySpan<Byte>, Span<Byte>, Int32)	Obsoleti. Tenta di calcolare il valore hash per la matrice di byte specificata. (Ereditato da HashAlgorithm)
TryHashFinal(Span<Byte>, Int32)	Obsoleti. Tenta di finalizzare il calcolo hash dopo l'elaborazione degli ultimi dati da parte dell'algoritmo hash. (Ereditato da HashAlgorithm)

Vedi anche

• servizi crittografici