Step 1

Divide M(i) into 16 words W(0), W(1), … , W(15), where W(0) is the left-most word.

Step 2

For t = 16 to 79 do

W(t) = S^1( W(t-3) XOR W(t-8) XOR W(t-14) XOR W(t-16) )

Step 3

Let A = H0, B = H1, C = H2, D = H3, E = H4

Step 4

For t = 0 to 79 do

TEMP = S^5(A) + f(t;B,C,D) + E + W(t) + K(t);

E = D;

D = C;

C = S^30(B);

B = A;

A = TEMP;

Step 5

H0 = H0 + A;

H1 = H1 + B;

H2 = H2 + C;

H3 = H3 + D;

H4 = H4 + E;

File : SHA1.cs (Berisi Class SHA1)

using System;

using System.Collections.Generic;

using System.Text;

namespace IlkompSHA1

{

public class SHA1

{

// private

private uint f( int t, uint B, uint C, uint D )

{

if(t >= 0 && t <= 19)

{

return (B & C) | ((~B) & D);

}

else if (t >= 20 && t <= 39)

{

return (B ^ C ^ D);

}

else if (t >= 40 && t <= 59)

{

return (B & C) | (B & D) | (C & D);

}

else

{

return (B ^ C ^ D);

}

}

private uint K( int t )

{

if (t >= 0 && t <= 19)

{

return 0x5A827999 ;

}

else if (t >= 20 && t <= 39)

{

return 0x6ED9EBA1;

}

else if (t >= 40 && t <= 59)

{

return 0x8F1BBCDC;

}

else

{

return 0xCA62C1D6;

}

}

private void ProcessMessageBlock()

{

int t; // Loop counter

uint temp; // Temporary word value

uint[] W = new uint[80]; // Word sequence

uint A, B, C, D, E; // Word buffers

for (t = 0; t < 16; t++)

{

W[t] = ((uint)Message_Block[t * 4]) << 24;

W[t] |= ((uint)Message_Block[t * 4 + 1]) << 16;

W[t] |= ((uint)Message_Block[t * 4 + 2]) << 8;

W[t] |= ((uint)Message_Block[t * 4 + 3]);

}

for (t = 16; t < 80; t++)

{

W[t] = CircularShift(1, W[t–3] ^ W[t–8] ^ W[t–14] ^ W[t–16]);

}

A = H[0];

B = H[1];

C = H[2];

D = H[3];

E = H[4];

for (t = 0; t < 80; t++)

{

temp = CircularShift(5, A) + f(t,B,C,D) + E + W[t] + K(t);

E = D;

D = C;

C = CircularShift(30, B);

B = A;

A = temp;

}

H[0] = (H[0] + A) ;

H[1] = (H[1] + B) ;

H[2] = (H[2] + C) ;

H[3] = (H[3] + D) ;

H[4] = (H[4] + E) ;

Message_Block_Index = 0;

}

private void PadMessage()

{

if (Message_Block_Index > 55)

{

Message_Block[Message_Block_Index++] = 0x80;

while (Message_Block_Index < 64)

{

Message_Block[Message_Block_Index++] = 0;

}

ProcessMessageBlock();

while (Message_Block_Index < 56)

{

Message_Block[Message_Block_Index++] = 0;

}

}

else

{

Message_Block[Message_Block_Index++] = 0x80;

while (Message_Block_Index < 56)

{

Message_Block[Message_Block_Index++] = 0;

}

}

Message_Block[56] = (byte)((Length_High >> 24) );

Message_Block[57] = (byte)((Length_High >> 16) );

Message_Block[58] = (byte)((Length_High >> 8) );

Message_Block[59] = (byte)((Length_High) );

Message_Block[60] = (byte)((Length_Low >> 24) );

Message_Block[61] = (byte)((Length_Low >> 16) );

Message_Block[62] = (byte)((Length_Low >> 8) );

Message_Block[63] = (byte)((Length_Low) );

ProcessMessageBlock();

}

// Performs a circular left shift operation

private UInt32 CircularShift(int bits, UInt32 word)

{

return (word << bits) | (word >> (32 – bits));

}

private UInt32[] H = new UInt32[5]; // Message digest buffers

private UInt32 Length_Low; // Message length in bits

private UInt32 Length_High; // Message length in bits

private byte[] Message_Block = new byte[64] // 512-bit message blocks

private int Message_Block_Index; // Index into message block array

private bool Computed; // Is the digest computed?

private bool Corrupted; // Is the message digest corruped?

public SHA1()

{

this.Reset();

}

public void Reset()

{

Length_Low = 0;

Length_High = 0;

Message_Block_Index = 0;

H[0] = 0x67452301;

H[1] = 0xEFCDAB89;

H[2] = 0x98BADCFE;

H[3] = 0x10325476;

H[4] = 0xC3D2E1F0;

Computed = false;

Corrupted = false;

}

public bool Result(ref UInt32[] message_digest_array)

{

int i; // Counter

if (Corrupted)

{

return false;

}

if (!Computed)

{

PadMessage();

Computed = true;

}

for (i = 0; i < 5; i++)

{

message_digest_array[i] = H[i];

}

return true;

}

public void Input(Byte[] message_array, UInt32 length)

{

if (length <= 0)

{

return;

}

if (Computed || Corrupted)

{

Corrupted = true;

return;

}

int i = 0;

int j = 0;

while ((length > 0) && !Corrupted)

{

i = Message_Block_Index++;

Message_Block[i] = (byte)(message_array[j] & 0xFF);

Length_Low += 8;

if (Length_Low == 0)

{

Length_High++;

if (Length_High == 0)

{

Corrupted = true; // Message is too long

}

}

if (Message_Block_Index == 64)

{

ProcessMessageBlock();

}

j = j + 1;

length = length – 1;

}

}

public void Input(byte message_element)

{

byte[] tmp = { message_element };

Input(tmp, 1);

}

}

}

File : Form1.cs (Berisi method dari Tampilan GUI ketika di click)

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Text;

using System.Windows.Forms;

using Microsoft.VisualBasic;

// created by BayuPRN

namespace IlkompSHA1

{

public partial class MainForm : Form

{

public MainForm()

{

InitializeComponent();

}

private void bFile_Click(object sender, EventArgs e)

{

DialogResult d = OpenDialog.ShowDialog();

if (d == DialogResult.OK || d == DialogResult.Yes)

{

String fn = OpenDialog.FileName;

MyFileIO fio = new MyFileIO(fn);

if (fio.FileExists())

{

txtFile.Text = fn;

byte[] bindata = new byte[1];

fio.LoadFile(ref bindata);

SHA1 sha = new SHA1();

sha.Reset();

int i;

for (i = 0; i <= bindata.Length – 1; i++)

{

sha.Input(bindata[i]);

}

uint[] message_diggest = new uint[5];

if (!sha.Result(ref message_diggest))

{

txtHasil.Text = “File tidak dapat diakses!”;

}

else

{

txtHasil.Text = String.Format (“{0}-{1}-{2}-{3}-{4}”,

Conversion.Hex(message_diggest[0]),

Conversion.Hex(message_diggest[1]),

Conversion.Hex(message_diggest[2]),

Conversion.Hex(message_diggest[3]),

Conversion.Hex(message_diggest[4]));

}

}

else

{

MessageBox.Show(“File tidak dapat diakses atau file tidak ada.”, “:: SHA1 Error”, MessageBoxButtons.OK);

}

}

}

}

}

File : MyFileIO.cs (Berisi class untuk mengakses/membaca isi file)

using System;

using System.Collections.Generic;

using System.Text;

using System.IO;

namespace IlkompSHA1

{

public class MyFileIO

{

private String fn;

public MyFileIO( String fileName )

{

fn = fileName;

}

public bool FileExists()

{

if(File.Exists(fn)){

return true;

} else {

return false;

}

}

public bool LoadFile(ref byte[] BinData)

{

FileStream fs;

try

{

fs = new FileStream( fn, FileMode.Open );

BinData = new byte[fs.Length ];

fs.Read( BinData, 0, (int)fs.Length );

fs.Close();

return true;

}catch(Exception ex){

return false;

}

}

}

}

Keterangan

Program dibuat menggunakan bahasa C#.NET dan dikompilasi menggunakan .NET Framework v.2.0. Untuk menjalankan program minimal Microsoft .NET Famework versi 2.0 (Windows) atau Mono versi 2.4 (Linux) sudah terinstall di komputer.

Untuk menjalankan program di Windows, jalankan IlkompSHA1.exe

Untuk menjalankan di linux, melalui console jalankan perintah

$> mono IlkompSHA1.exe

Jika ingin mengkompilasi ulang source code di Windows, ketikkan

$> msbuild IlkompSHA1.sln

Jika ingin mengkompilasi ulang source code di Linux, ketikkan

$> xbuild IlkompSHA1.sln