MACTripleDES Clase

Definición

Espacio de nombres:

System.Security.Cryptography

Ensamblado:

mscorlib.dll

Calcula un código de autenticación de mensajes (MAC) mediante TripleDES para los datos de entrada CryptoStream.

public ref class MACTripleDES : System::Security::Cryptography::KeyedHashAlgorithm

public class MACTripleDES : System.Security.Cryptography.KeyedHashAlgorithm

[System.Runtime.InteropServices.ComVisible(true)]
public class MACTripleDES : System.Security.Cryptography.KeyedHashAlgorithm

type MACTripleDES = class
    inherit KeyedHashAlgorithm

[<System.Runtime.InteropServices.ComVisible(true)>]
type MACTripleDES = class
    inherit KeyedHashAlgorithm

Public Class MACTripleDES
Inherits KeyedHashAlgorithm

Herencia

Object

HashAlgorithm

KeyedHashAlgorithm

MACTripleDES

Atributos

ComVisibleAttribute

Ejemplos

En el ejemplo siguiente se crea un MAC para un archivo denominado input.txt, que se encuentra en la carpeta que contiene el archivo ejecutable de ejemplo. El MAC y el texto original se escriben en un archivo denominado encrypted.hsh en la misma carpeta. A continuación, se lee el archivo firmado y el MAC se calcula para la parte de texto del archivo y se compara con el MAC que se incluye con el texto.

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

public class MACTripleDESexample
{

    public static void Main(string[] Fileargs)
    {
        string dataFile;
        string signedFile;
        //If no file names are specified, create them.
        if (Fileargs.Length < 2)
        {
            dataFile = @"text.txt";
            signedFile = "signedFile.enc";

            if (!File.Exists(dataFile))
            {
                // Create a file to write to.
                using (StreamWriter sw = File.CreateText(dataFile))
                {
                    sw.WriteLine("Here is a message to sign");
                }
            }
        }
        else
        {
            dataFile = Fileargs[0];
            signedFile = Fileargs[1];
        }
        try
        {
            // Create a random key using a random number generator. This would be the
            //  secret key shared by sender and receiver.
            byte[] secretkey = new Byte[24];
            //RNGCryptoServiceProvider is an implementation of a random number generator.
            using (RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider())
            {
                // The array is now filled with cryptographically strong random bytes.
                rng.GetBytes(secretkey);

                // Use the secret key to sign the message file.
                SignFile(secretkey, dataFile, signedFile);

                // Verify the signed file
                VerifyFile(secretkey, signedFile);
            }
        }
        catch (IOException e)
        {
            Console.WriteLine("Error: File not found", e);
        }
    }  //end main
    // Computes a keyed hash for a source file and creates a target file with the keyed hash
    // prepended to the contents of the source file.
    public static void SignFile(byte[] key, String sourceFile, String destFile)
    {
        // Initialize the keyed hash object.
        using (MACTripleDES hmac = new MACTripleDES(key))
        {
            using (FileStream inStream = new FileStream(sourceFile, FileMode.Open))
            {
                using (FileStream outStream = new FileStream(destFile, FileMode.Create))
                {
                    // Compute the hash of the input file.
                    byte[] hashValue = hmac.ComputeHash(inStream);
                    // Reset inStream to the beginning of the file.
                    inStream.Position = 0;
                    // Write the computed hash value to the output file.
                    outStream.Write(hashValue, 0, hashValue.Length);
                    // Copy the contents of the sourceFile to the destFile.
                    int bytesRead;
                    // read 1K at a time
                    byte[] buffer = new byte[1024];
                    do
                    {
                        // Read from the wrapping CryptoStream.
                        bytesRead = inStream.Read(buffer, 0, 1024);
                        outStream.Write(buffer, 0, bytesRead);
                    } while (bytesRead > 0);
                }
            }
        }
        return;
    } // end SignFile

    // Compares the key in the source file with a new key created for the data portion of the file. If the keys
    // compare the data has not been tampered with.
    public static bool VerifyFile(byte[] key, String sourceFile)
    {
        bool err = false;
        // Initialize the keyed hash object.
        using (MACTripleDES hmac = new MACTripleDES(key))
        {
            // Create an array to hold the keyed hash value read from the file.
            byte[] storedHash = new byte[hmac.HashSize / 8];
            // Create a FileStream for the source file.
            using (FileStream inStream = new FileStream(sourceFile, FileMode.Open))
            {
                // Read in the storedHash.
                inStream.Read(storedHash, 0, storedHash.Length);
                // Compute the hash of the remaining contents of the file.
                // The stream is properly positioned at the beginning of the content,
                // immediately after the stored hash value.
                byte[] computedHash = hmac.ComputeHash(inStream);
                // compare the computed hash with the stored value

                for (int i = 0; i < storedHash.Length; i++)
                {
                    if (computedHash[i] != storedHash[i])
                    {
                        err = true;
                    }
                }
            }
        }
        if (err)
        {
            Console.WriteLine("Hash values differ! Signed file has been tampered with!");
            return false;
        }
        else
        {
            Console.WriteLine("Hash values agree -- no tampering occurred.");
            return true;
        }
    } //end VerifyFile
} //end class

Imports System.IO
Imports System.Security.Cryptography

Public Class MACTripleDESexample

    Public Shared Sub Main(ByVal Fileargs() As String)
        Dim dataFile As String
        Dim signedFile As String
        'If no file names are specified, create them.
        If Fileargs.Length < 2 Then
            dataFile = "text.txt"
            signedFile = "signedFile.enc"

            If Not File.Exists(dataFile) Then
                ' Create a file to write to.
                Using sw As StreamWriter = File.CreateText(dataFile)
                    sw.WriteLine("Here is a message to sign")
                End Using
            End If

        Else
            dataFile = Fileargs(0)
            signedFile = Fileargs(1)
        End If
        Try
            ' Create a random key using a random number generator. This would be the
            '  secret key shared by sender and receiver.
            Dim secretkey() As Byte = New [Byte](23) {}
            'RNGCryptoServiceProvider is an implementation of a random number generator.
            Using rng As New RNGCryptoServiceProvider()
                ' The array is now filled with cryptographically strong random bytes.
                rng.GetBytes(secretkey)

                ' Use the secret key to encode the message file.
                SignFile(secretkey, dataFile, signedFile)

                ' Take the encoded file and decode
                VerifyFile(secretkey, signedFile)
            End Using
        Catch e As IOException
            Console.WriteLine("Error: File not found", e)
        End Try

    End Sub

    ' Computes a keyed hash for a source file and creates a target file with the keyed hash
    ' prepended to the contents of the source file. 
    Public Shared Sub SignFile(ByVal key() As Byte, ByVal sourceFile As String, ByVal destFile As String)
        ' Initialize the keyed hash object.
        Using myhmac As New MACTripleDES(key)
            Using inStream As New FileStream(sourceFile, FileMode.Open)
                Using outStream As New FileStream(destFile, FileMode.Create)
                    ' Compute the hash of the input file.
                    Dim hashValue As Byte() = myhmac.ComputeHash(inStream)
                    ' Reset inStream to the beginning of the file.
                    inStream.Position = 0
                    ' Write the computed hash value to the output file.
                    outStream.Write(hashValue, 0, hashValue.Length)
                    ' Copy the contents of the sourceFile to the destFile.
                    Dim bytesRead As Integer
                    ' read 1K at a time
                    Dim buffer(1023) As Byte
                    Do
                        ' Read from the wrapping CryptoStream.
                        bytesRead = inStream.Read(buffer, 0, 1024)
                        outStream.Write(buffer, 0, bytesRead)
                    Loop While bytesRead > 0
                End Using
            End Using
        End Using
        Return

    End Sub
    ' end SignFile

    ' Compares the key in the source file with a new key created for the data portion of the file. If the keys 
    ' compare the data has not been tampered with.
    Public Shared Function VerifyFile(ByVal key() As Byte, ByVal sourceFile As String) As Boolean
        Dim err As Boolean = False
        ' Initialize the keyed hash object. 
        Using hmac As New MACTripleDES(key)
            ' Create an array to hold the keyed hash value read from the file.
            Dim storedHash(hmac.HashSize / 8) As Byte
            ' Create a FileStream for the source file.
            Using inStream As New FileStream(sourceFile, FileMode.Open)
                ' Read in the storedHash.
                inStream.Read(storedHash, 0, storedHash.Length - 1)
                ' Compute the hash of the remaining contents of the file.
                ' The stream is properly positioned at the beginning of the content, 
                ' immediately after the stored hash value.
                Dim computedHash As Byte() = hmac.ComputeHash(inStream)
                ' compare the computed hash with the stored value
                Dim i As Integer
                For i = 0 To storedHash.Length - 2
                    If computedHash(i) <> storedHash(i) Then
                        err = True
                    End If
                Next i
            End Using
        End Using
        If err Then
            Console.WriteLine("Hash values differ! Signed file has been tampered with!")
            Return False
        Else
            Console.WriteLine("Hash values agree -- no tampering occurred.")
            Return True
        End If

    End Function 'VerifyFile 
End Class
'end class

Comentarios

Se puede usar un MAC para determinar si se ha alterado un mensaje enviado a través de un canal no seguro, siempre que el remitente y el receptor compartan una clave secreta. El remitente calcula el MAC para los datos originales y envía ambos como un único mensaje. El receptor vuelve a calcular el MAC en el mensaje recibido y comprueba que el MAC calculado coincide con el MAC transmitido.

Cualquier cambio en los datos o mac da como resultado un error de coincidencia, ya que se requiere el conocimiento de la clave secreta para cambiar el mensaje y reproducir el MAC correcto. Por lo tanto, si los códigos coinciden, el mensaje se autentica.

MACTripleDES usa una clave de 16 o 24 bytes de longitud y genera una secuencia hash de 8 bytes de longitud.

Constructores

MACTripleDES()	Inicializa una nueva instancia de la clase MACTripleDES.
MACTripleDES(Byte[])	Inicializa una nueva instancia de la clase MACTripleDES con los datos de clave especificados.
MACTripleDES(String, Byte[])	Inicializa una nueva instancia de la clase MACTripleDES con los datos de clave especificados y mediante la implementación de TripleDES indicada.

Campos

HashSizeValue	Representa el tamaño en bits del código hash calculado. (Heredado de HashAlgorithm)
HashValue	Representa el valor del código hash calculado. (Heredado de HashAlgorithm)
KeyValue	Clave que se va a usar en el algoritmo hash. (Heredado de KeyedHashAlgorithm)
State	Representa el estado del cálculo del valor hash. (Heredado de HashAlgorithm)

Propiedades

CanReuseTransform	Obtiene un valor que indica si la transformación actual puede volver a usarse. (Heredado de HashAlgorithm)
CanTransformMultipleBlocks	Cuando se invalida en una clase derivada, obtiene un valor que indica si se pueden transformar varios bloques. (Heredado de HashAlgorithm)
Hash	Obtiene el valor del código hash calculado. (Heredado de HashAlgorithm)
HashSize	Obtiene el tamaño en bits del código hash calculado. (Heredado de HashAlgorithm)
InputBlockSize	Cuando se invalida en una clase derivada, obtiene el tamaño del bloque de entrada. (Heredado de HashAlgorithm)
Key	Obtiene o establece la clave que se va a usar en el algoritmo hash. (Heredado de KeyedHashAlgorithm)
OutputBlockSize	Cuando se invalida en una clase derivada, obtiene el tamaño del bloque de salida. (Heredado de HashAlgorithm)
Padding	Obtiene o establece el modo de relleno utilizado en el algoritmo hash.

Métodos

Clear()	Libera todos los recursos que utiliza la clase HashAlgorithm. (Heredado de HashAlgorithm)
ComputeHash(Byte[])	Calcula el valor hash para la matriz de bytes especificada. (Heredado de HashAlgorithm)
ComputeHash(Byte[], Int32, Int32)	Calcula el valor hash para la región especificada de la matriz de bytes indicada. (Heredado de HashAlgorithm)
ComputeHash(Stream)	Calcula el valor hash del objeto Stream especificado. (Heredado de HashAlgorithm)
ComputeHashAsync(Stream, CancellationToken)	Calcula de manera asincrónica el valor hash del objeto Stream especificado. (Heredado de HashAlgorithm)
Dispose()	Libera todos los recursos usados por la instancia actual de la clase HashAlgorithm. (Heredado de HashAlgorithm)
Dispose(Boolean)	Libera los recursos que usa la instancia MACTripleDES.
Equals(Object)	Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object)
Finalize()	Libera los recursos no administrados que MACTripleDES usa.
GetHashCode()	Sirve como la función hash predeterminada. (Heredado de Object)
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
HashCore(Byte[], Int32, Int32)	Redirige los datos escritos en el objeto al cifrador TripleDES para el cálculo del código de autenticación de mensajes (MAC).
HashCore(ReadOnlySpan<Byte>)	Envía los datos escritos en el objeto al algoritmo hash para el cálculo del valor hash. (Heredado de HashAlgorithm)
HashFinal()	Devuelve el código de autenticación de mensajes (MAC) calculado una vez que se han escrito todos los datos en el objeto.
Initialize()	Inicializa una instancia de MACTripleDES.
MemberwiseClone()	Crea una copia superficial del Object actual. (Heredado de Object)
ToString()	Devuelve una cadena que representa el objeto actual. (Heredado de Object)
TransformBlock(Byte[], Int32, Int32, Byte[], Int32)	Calcula el valor hash para la región especificada de la matriz de bytes de entrada y copia la región especificada de la matriz de bytes de entrada resultante en la región indicada de la matriz de bytes de salida. (Heredado de HashAlgorithm)
TransformFinalBlock(Byte[], Int32, Int32)	Calcula el valor hash para la región especificada de la matriz de bytes indicada. (Heredado de HashAlgorithm)
TryComputeHash(ReadOnlySpan<Byte>, Span<Byte>, Int32)	Intenta calcular el valor de hash para la matriz de bytes especificada. (Heredado de HashAlgorithm)
TryHashFinal(Span<Byte>, Int32)	Intenta finalizar el cálculo de hash una vez que el algoritmo hash procesa los últimos datos. (Heredado de HashAlgorithm)

Implementaciones de interfaz explícitas

IDisposable.Dispose()

Libera los recursos no administrados que usa HashAlgorithm y, de forma opcional, libera los recursos administrados. (Heredado de HashAlgorithm)