Imports System
Imports System.IO
Imports System.Security.Cryptography



Public Class HMACSHA1example

    ' Computes a keyed hash for a source file, creates a target file with the keyed hash
    ' prepended to the contents of the source file, then decrypts the file and compares
    ' the source and the decrypted files.
    Public Shared Sub EncodeFile(ByVal key() As Byte, ByVal sourceFile As String, ByVal destFile As String)
        ' Initialize the keyed hash object.
        Dim myhmacsha1 As New HMACSHA1(key)
        Dim inStream As New FileStream(sourceFile, FileMode.Open)
        Dim outStream As New FileStream(destFile, FileMode.Create)
        ' Compute the hash of the input file.
        Dim hashValue As Byte() = myhmacsha1.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
        myhmacsha1.Clear()
        ' Close the streams
        inStream.Close()
        outStream.Close()
        Return

    End Sub


    ' Decrypt the encoded file and compare to original file.
    Public Shared Function DecodeFile(ByVal key() As Byte, ByVal sourceFile As String) As Boolean
        ' Initialize the keyed hash object. 
        Dim hmacsha1 As New HMACSHA1(key)
        ' Create an array to hold the keyed hash value read from the file.
        Dim storedHash(hmacsha1.HashSize / 8) As Byte
        ' Create a FileStream for the source file.
        Dim inStream As 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.
        Dim computedHash As Byte() = hmacsha1.ComputeHash(inStream)
        ' compare the computed hash with the stored value
        Dim i As Integer
        For i = 0 To storedHash.Length
            If computedHash(i) <> storedHash(i) Then
                Console.WriteLine("Hash values differ! Encoded file has been tampered with!")
                Return False
            End If
        Next i
        Console.WriteLine("Hash values agree -- no tampering occurred.")
        Return True

    End Function
    Private Const usageText As String = "Usage: HMACSHA1 inputfile.txt encryptedfile.hsh" + vbLf + "You must specify the two file names. Only the first file must exist." + vbLf

    Public Shared Sub Main(ByVal Fileargs() As String)
        'If no file names are specified, write usage text.
        If Fileargs.Length < 2 Then
            Console.WriteLine(usageText)
        Else
            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](63) {}
                'RNGCryptoServiceProvider is an implementation of a random number generator.
                Dim 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.
                EncodeFile(secretkey, Fileargs(0), Fileargs(1))

                ' Take the encoded file and decode
                DecodeFile(secretkey, Fileargs(1))
            Catch e As IOException
                Console.WriteLine("Error: File not found", e)
            End Try
        End If

    End Sub
End Class

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

public class HMACSHA1example
{
    // Computes a keyed hash for a source file, creates a target file with the keyed hash
    // prepended to the contents of the source file, then decrypts the file and compares
    // the source and the decrypted files.
    public static void EncodeFile(byte[] key, String sourceFile, String destFile)
    {
        // Initialize the keyed hash object.
        HMACSHA1 myhmacsha1 = new HMACSHA1(key);
        FileStream inStream = new FileStream(sourceFile, FileMode.Open);
        FileStream outStream = new FileStream(destFile, FileMode.Create);
        // Compute the hash of the input file.
        byte[] hashValue = myhmacsha1.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); 
        myhmacsha1.Clear();
        // Close the streams
        inStream.Close();
        outStream.Close();
        return;
    } // end EncodeFile


    // Decrypt the encoded file and compare to original file.
    public static bool DecodeFile(byte[] key, String sourceFile)
    {
        // Initialize the keyed hash object. 
        HMACSHA1 hmacsha1 = new HMACSHA1(key);
        // Create an array to hold the keyed hash value read from the file.
        byte[] storedHash = new byte[hmacsha1.HashSize/8];
        // Create a FileStream for the source file.
        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 = hmacsha1.ComputeHash(inStream);
        // compare the computed hash with the stored value
        for (int i =0; i < storedHash.Length; i++)
        {
            if (computedHash[i] != storedHash[i])
            {
                Console.WriteLine("Hash values differ! Encoded file has been tampered with!");
                return false;
            }
        }
        Console.WriteLine("Hash values agree -- no tampering occurred.");
        return true;
    } //end DecodeFile

    private const string usageText = "Usage: HMACSHA1 inputfile.txt encryptedfile.hsh\nYou must specify the two file names. Only the first file must exist.\n";
    public static void Main(string[] Fileargs)
    {
        //If no file names are specified, write usage text.
        if (Fileargs.Length < 2)
        {
            Console.WriteLine(usageText);
        }
        else
        {
            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[64];
                //RNGCryptoServiceProvider is an implementation of a random number generator.
                RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
                // The array is now filled with cryptographically strong random bytes.
                rng.GetBytes(secretkey); 

                // Use the secret key to encode the message file.
                EncodeFile(secretkey, Fileargs[0], Fileargs[1]);

                // Take the encoded file and decode
                DecodeFile(secretkey, Fileargs[1]);
            }
            catch (IOException e)
            {
                Console.WriteLine("Error: File not found",e);
            }
        } //end if-else

    }  //end main
} //end class

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

// Computes a keyed hash for a source file, creates a target file with the keyed hash
// prepended to the contents of the source file, then decrypts the file and compares
// the source and the decrypted files.
void EncodeFile( array<Byte>^key, String^ sourceFile, String^ destFile )
{

   // Initialize the keyed hash object.
   HMACSHA1^ myhmacsha1 = gcnew HMACSHA1( key );
   FileStream^ inStream = gcnew FileStream( sourceFile,FileMode::Open );
   FileStream^ outStream = gcnew FileStream( destFile,FileMode::Create );

   // Compute the hash of the input file.
   array<Byte>^hashValue = myhmacsha1->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
   array<Byte>^buffer = gcnew array<Byte>(1024);
   do
   {

      // Read from the wrapping CryptoStream.
      bytesRead = inStream->Read( buffer, 0, 1024 );
      outStream->Write( buffer, 0, bytesRead );
   }
   while ( bytesRead > 0 );

   myhmacsha1->Clear();

   // Close the streams
   inStream->Close();
   outStream->Close();
   return;
} // end EncodeFile



// Decrypt the encoded file and compare to original file.
bool DecodeFile( array<Byte>^key, String^ sourceFile )
{

   // Initialize the keyed hash object. 
   HMACSHA1^ hmacsha1 = gcnew HMACSHA1( key );

   // Create an array to hold the keyed hash value read from the file.
   array<Byte>^storedHash = gcnew array<Byte>(hmacsha1->HashSize / 8);

   // Create a FileStream for the source file.
   FileStream^ inStream = gcnew 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.
   array<Byte>^computedHash = hmacsha1->ComputeHash( inStream );

   // compare the computed hash with the stored value
   for ( int i = 0; i < storedHash->Length; i++ )
   {
      if ( computedHash[ i ] != storedHash[ i ] )
      {
         Console::WriteLine( "Hash values differ! Encoded file has been tampered with!" );
         return false;
      }

   }
   Console::WriteLine( "Hash values agree -- no tampering occurred." );
   return true;
} //end DecodeFile


int main()
{
   array<String^>^Fileargs = Environment::GetCommandLineArgs();
   String^ usageText = "Usage: HMACSHA1 inputfile.txt encryptedfile.hsh\nYou must specify the two file names. Only the first file must exist.\n";

   //If no file names are specified, write usage text.
   if ( Fileargs->Length < 3 )
   {
      Console::WriteLine( usageText );
   }
   else
   {
      try
      {

         // Create a random key using a random number generator. This would be the
         //  secret key shared by sender and receiver.
         array<Byte>^secretkey = gcnew array<Byte>(64);

         //RNGCryptoServiceProvider is an implementation of a random number generator.
         RNGCryptoServiceProvider^ rng = gcnew RNGCryptoServiceProvider;

         // The array is now filled with cryptographically strong random bytes.
         rng->GetBytes( secretkey );

         // Use the secret key to encode the message file.
         EncodeFile( secretkey, Fileargs[ 1 ], Fileargs[ 2 ] );

         // Take the encoded file and decode
         DecodeFile( secretkey, Fileargs[ 2 ] );
      }
      catch ( IOException^ e ) 
      {
         Console::WriteLine( "Error: File not found", e );
      }

   }
} //end main

import System.*;
import System.IO.*;
import System.Security.Cryptography.*;

public class HMACSHA1Example
{
    // Computes a keyed hash for a source file, creates a target file with the
    // keyed hash prepended to the contents of the source file, then decrypts 
    // the file and compares the source and the decrypted files.
    public static void EncodeFile(ubyte key[], String sourceFile, 
        String destFile)
    {
        // Initialize the keyed hash object.
        HMACSHA1 myhmacsha1 = new HMACSHA1(key);
        FileStream inStream = new FileStream(sourceFile, FileMode.Open);
        FileStream outStream = new FileStream(destFile, FileMode.Create);

        // Compute the hash of the input file.
        ubyte hashValue[] = myhmacsha1.ComputeHash(inStream);

        // Reset inStream to the beginning of the file.
        inStream.set_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
        ubyte buffer[] = new ubyte[1024];
        do {
            // Read from the wrapping CryptoStream.
            bytesRead = inStream.Read(buffer, 0, 1024);
            outStream.Write(buffer, 0, bytesRead);
        } while (bytesRead > 0);
        myhmacsha1.Clear();

        // Close the streams
        inStream.Close();
        outStream.Close();
        return;
    } // end EncodeFile

    // Decrypt the encoded file and compare to original file.
    public static boolean DecodeFile(ubyte key[], String sourceFile)
    {
        // Initialize the keyed hash object. 
        HMACSHA1 hmacsha1 = new HMACSHA1(key);

        // Create an array to hold the keyed hash value read from the file.
        ubyte storedHash[] = new ubyte[hmacsha1.get_HashSize() / 8];

        // Create a FileStream for the source file.
        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.
        ubyte computedHash[] = hmacsha1.ComputeHash(inStream);

        // compare the computed hash with the stored value
        for (int i = 0; i < storedHash.length; i++) {
            if (computedHash.get_Item(i) != storedHash.get_Item(i)) {
                Console.WriteLine("Hash values differ! Encoded file has been " 
                    + " tampered with!");
                return false;
            }
        }
        Console.WriteLine("Hash values agree -- no tampering occurred.");
        return true;
    } //DecodeFile //end DecodeFile


    private static String usageText = "Usage: HMACSHA1 inputfile.txt " 
        + "encryptedfile.hsh\nYou must specify the two file names. Only " 
        + "the first file must exist.\n";


    public static void main(String[] fileargs)
    {
        //If no file names are specified, write usage text.
        if (fileargs.length < 2) {
            Console.WriteLine(usageText);
        }
        else {
            try {
                // Create a random key using a random number generator. This
                // would be the secret key shared by sender and receiver.
                ubyte secretKey[] = new ubyte[64];

                // RNGCryptoServiceProvider is an implementation of a random
                // number generator.
                RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();

                // The array is now filled with cryptographically strong
                // random bytes.
                rng.GetBytes(secretKey);

                // Use the secret key to encode the message file.
                EncodeFile(secretKey, fileargs[0], fileargs[1]);

                // Take the encoded file and decode
                DecodeFile(secretKey, fileargs[1]);
            }
            catch (IOException e) {
                Console.WriteLine("Error: File not found", e);
            }
        }//end if-else
    } //end main
} //end class HMACSHA1Example