MD5 (Message-Digest 5) Algorithm in C

[+] MD5 adalah sebuah fungsi hash yang digunakan secara luas dengan ukuran hash value 128-bit

[+] Pertama kali ditemukan oleh professor Ronald Rivest dari Artificial Intelligence Lab Massachussets Institute of Technology

[+] Algoritma dikutip dari wikipedia

Code:


- Seluruh variable pada unsigned integer 32-bit dan dan wrap modulo 2^32 saat melakukan perhitungan

Mendefinisikan r sebagai berikut
var int[64] r, k
r[ 0..15] := {7, 12, 17, 22,  7, 12, 17, 22,  7, 12, 17, 22,  7, 12, 17, 22}
r[16..31] := {5,  9, 14, 20,  5,  9, 14, 20,  5,  9, 14, 20,  5,  9, 14, 20}
r[32..47] := {4, 11, 16, 23,  4, 11, 16, 23,  4, 11, 16, 23,  4, 11, 16, 23}
r[48..63] := {6, 10, 15, 21,  6, 10, 15, 21,  6, 10, 15, 21,  6, 10, 15, 21}

Menggunakan bagian fraksional biner dari integral sinus sebagai konstanta:
for i from 0 to 63
    k[i] := floor(abs(sin(i + 1)) × 2^32)

Inisialisasi variabel:
var int h0 := 0x67452301
var int h1 := 0xEFCDAB89
var int h2 := 0x98BADCFE
var int h3 := 0x10325476

Pemrosesan awal:
append "1" bit to message
append "0" bits until message length in bits ≡ 448 (mod 512)
append bit length of message as 64-bit little-endian integer to message

Pengolahan pesan paada kondisi gumpalan 512-bit:
for each 512-bit chunk of message
    break chunk into sixteen 32-bit little-endian words w(i), 0 ≤ i ≤ 15

    Inisialisasi nilai hash pada gumpalan ini:
    var int a := h0
    var int b := h1
    var int c := h2
    var int d := h3

    Kalang utama:
    for i from 0 to 63
        if 0 ≤ i ≤ 15 then
            f := (b and c) or ((not b) and d)
            g := i
        else if 16 ≤ i ≤ 31
            f := (d and b) or ((not d) and c)
            g := (5×i + 1) mod 16
        else if 32 ≤ i ≤ 47
            f := b xor c xor d
            g := (3×i + 5) mod 16
        else if 48 ≤ i ≤ 63
            f := c xor (b or (not d))
            g := (7×i) mod 16

        temp := d
        d := c
        c := b
        b := ((a + f + k(i) + w(g)) leftrotate r(i)) + b
        a := temp

    Tambahkan hash dari gumpalan sebagai hasil:
    h0 := h0 + a
    h1 := h1 + b
    h2 := h2 + c
    h3 := h3 + d

var int digest := h0 append h1 append h2 append h3 (diwujudkan dalam little-endian)


[+] Implementasi dalam bahasa-C

Code:


/* md5_hashing_computation.c
 * Real Algorithm by : Prof. Ronald Rivest (csail.mit.edu)
 * Implementation By : Paulus Gandung Prakosa_ (0x1337day)
 */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <conio.h>

typedef unsigned long int u_int32;
typedef unsigned int u_int;

/* struktur data untuk komputasi MD5 */
struct md5_global_requirements
{
   // bit angka, hasil sisa bagi (2 pangkat 64)
   u_int32 mod[2];
   // penyangga gesekan (scratch buffer)
   u_int32 buffer[4];
   // penyangga masukan (input buffer)
   unsigned char input[64];
   // "digest" sesudah fungsi md5_hashing dipanggil
   unsigned char hash_digest[16];
};

static void md5_initialization(struct md5_global_requirements *);
static void md5_update(struct md5_global_requirements *, unsigned char *, unsigned int);
static void md5_hashing(struct md5_global_requirements *);
static void transform(u_int32 *, u_int32 *);

static unsigned char hash_padding[64] =
{
   0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

#define hashing_func1(x, y, z)      (((x) & (y)) | ((~x) & (z)))
#define hashing_func2(x, y, z)      (((x) & (z)) | ((y) & (~z)))
#define hashing_func3(x, y, z)      ((x) ^ (y) ^(z))
#define hashing_func4(x, y, z)      ((y) ^ ((x) | (~z)))

//  fungsi "rotate_left" memutar variabel x sebanyak n bits
#define rotate_left(x, nbytes)      (((x) << (nbytes)) | ((x) >> (32 - (nbytes))))

/* transform_1, transform_2, transform_3, transform_4 adalah fungsi
 * untuk ronde 1, 2, 3, 4
 * perputaran bit dipisahkan dari penambahan bit untuk mencegah
 * komputasi ulang
 */
#define transform_1(a, b, c, d, x, s, fraction) \
   {(a) += hashing_func1((b), (c), (d)) + (x) + (u_int32)(fraction); \
     (a) = rotate_left ((a), (s)); \
     (a) += (b); \
   }

#define transform_2(a, b, c, d, x, s, fraction) \
   {(a) += hashing_func2((b), (c), (d)) + (x) + (u_int32)(fraction); \
     (a) = rotate_left ((a), (s)); \
     (a) += (b); \
   }
   
#define transform_3(a, b, c, d, x, s, fraction) \
   {(a) += hashing_func3 ((b), (c), (d)) + (x) + (u_int32)(fraction); \
     (a) = rotate_left ((a), (s)); \
     (a) += (b); \
   }
   
#define transform_4(a, b, c, d, x, s, fraction) \
   {(a) += hashing_func4 ((b), (c), (d)) + (x) + (u_int32)(fraction); \
     (a) = rotate_left ((a), (s)); \
     (a) += (b); \
        }
   
/* waktunya untuk penginisialiasian fungsi-fungsi berikut :
 * - static void md5_initialization();
 * - static void md5_update();
 * - static void md5_hashing();
 * - static void transform();
 */
 
static void md5_initialization(hash_req)
struct md5_global_requirements *hash_req;
{
   /* set mod[0] dan mod[1] dengan nilai 0 */
   hash_req->mod[0] = (u_int32)0;
   hash_req->mod[1] = (u_int32)0;
   
   /* inisialisasi angka ajaib yang bersifat konstan */
   hash_req->buffer[0] = (u_int32)0x67452301;
   hash_req->buffer[1] = (u_int32)0xefcdab89;
   hash_req->buffer[2] = (u_int32)0x98badcfe;
   hash_req->buffer[3] = (u_int32)0x10325476;
}

static void md5_update(hash_req, input_buffer, buffer_length)
struct md5_global_requirements *hash_req;
unsigned char *input_buffer;
unsigned int buffer_length;
{
   u_int32 num[16];
   int mod_64;
   unsigned int loop1, loop2;
   
   /* hitung sisa bagi (modulus) bytes dengan 64 */
   mod_64 = (int)((hash_req->mod[0] >> 3) & 0x3f);
   
   /* update number dari bit */
   if ((hash_req->mod[0] + ((u_int32)buffer_length << 3)) < hash_req->mod[0])
   {
      hash_req->mod[1]++;
   }
   
   hash_req->mod[0] += ((u_int32)buffer_length << 3);
   hash_req->mod[1] += ((u_int32)buffer_length >> 29);
   
   while (buffer_length--)
   {
      /* tambahkan character baru ke dalam input_buffer dan naikkan nilai
       *  mod_64
       */
      hash_req->input[mod_64++] = *input_buffer++;
      
      /* ubah jika dibutuhkan */
      if (mod_64 == 0x40)
      {
         for (loop1 = 0, loop2 = 0; loop1 < 16; loop1++, loop2 += 4)
         {
            num[loop1] = (((u_int32)hash_req->input[loop2 + 3]) << 24) |
                       (((u_int32)hash_req->input[loop2 + 2]) << 16) |
                       (((u_int32)hash_req->input[loop2 + 1]) << 8) |
                       ((u_int32)hash_req->input[loop2]);
         }
         transform (hash_req->buffer, num);
         mod_64 = 0;
      }
   }
}

static void md5_hashing(hash_req)
struct md5_global_requirements *hash_req;
{
   u_int32 num[16];
   int mod_64;
   unsigned int loop1, loop2;
   unsigned int padding_length;
   
   /* simpan bit dari number */
   num[14] = hash_req->mod[0];
   num[15] = hash_req->mod[1];
   
   /* hitung sisa bagi (modulus) bytes dengan 64 */
   mod_64 = (int)((hash_req->mod[0] >> 3) & 0x3f);
   
   /* tambahkan ke 56 yang disisabagikan dengan 64 */
   padding_length = (mod_64 < 56) ? (56 - mod_64) : (120 - mod_64);
   md5_update (hash_req, hash_padding, padding_length);
   
   /* tambahkan panjang padding dengan bits dan ubah */
   for (loop1 = 0, loop2 = 0; loop1 < 14; loop1++, loop2 += 4)
   {
      num[loop1] = (((u_int32)hash_req->input[loop2 + 3]) << 24) |
                   (((u_int32)hash_req->input[loop2 + 2]) << 16) |
                   (((u_int32)hash_req->input[loop2 + 1]) << 8) |
                              ((u_int32)hash_req->input[loop2]);
   }
   transform (hash_req->buffer, num);
   
   /* pindahkan buffer di "digest" */
   for (loop1 = 0, loop2 = 0; loop1 < 4; loop1++, loop2 += 4)
   {
      hash_req->hash_digest[loop2] =
         (unsigned char)(hash_req->buffer[loop1] & 0xff);
      hash_req->hash_digest[loop2 + 1] =
         (unsigned char)((hash_req->buffer[loop1] >> 8) & 0xff);
      hash_req->hash_digest[loop2 + 2] =
         (unsigned char)((hash_req->buffer[loop1] >> 16) & 0xff);
      hash_req->hash_digest[loop2 + 3] =
         (unsigned char)((hash_req->buffer[loop1] >> 24) & 0xff);
   }
}

/* dasar langkah md5, mentransformasikan buffer yang ada
 * di dalamnya
 */
static void transform(buffer, input)
u_int32 *buffer;
u_int32 *input;
{
   u_int32 var1 = buffer[0];
   u_int32 var2 = buffer[1];
   u_int32 var3 = buffer[2];
   u_int32 var4 = buffer[3];
   
   /* variabel "fraction" yang ada dalam fungsi transform_1, transform_2,
    * transform_3, dan transform_4 didapatkan dari fungsi berikut :
    *
    * hasil fraksional biner dari integral sinus sebagai konstanta
    * for "i" from "0" to "63"
    * k[i] = floor(abs(sin(i + 1)) * pow(2, 32);
    */
   
   /* putaran 1 */
   #define s11      7
   #define s12      12
   #define s13      17
   #define s14      22
   transform_1(var1, var2, var3, var4, input[0], s11, (u_int)3614090360);
   transform_1(var4, var1, var2, var3, input[1], s12, (u_int)3905402710);
   transform_1(var3, var4, var1, var2, input[2], s13, (u_int)606105819);
   transform_1(var2, var3, var4, var1, input[3], s14, (u_int)3250441966);
   
   transform_1(var1, var2, var3, var4, input[4], s11, (u_int)4118548399);
   transform_1(var4, var1, var2, var3, input[5], s12, (u_int)1200080426);
   transform_1(var3, var4, var1, var2, input[6], s13, (u_int)2821735955);
   transform_1(var2, var3, var4, var1, input[7], s14, (u_int)4249261313);
   
   transform_1(var1, var2, var3, var4, input[8], s11, (u_int)1770035416);
   transform_1(var4, var1, var2, var3, input[9], s12, (u_int)2336552879);
   transform_1(var3, var4, var1, var2, input[10], s13, (u_int)4294925233);
   transform_1(var2, var3, var4, var1, input[11], s14, (u_int)2304563134);
   
   transform_1(var1, var2, var3, var4, input[12], s11, (u_int)1804603682);
   transform_1(var4, var1, var2, var3, input[13], s12, (u_int)4254626195);
   transform_1(var3, var4, var1, var2, input[14], s13, (u_int)2792965006);
   transform_1(var2, var3, var4, var1, input[15], s14, (u_int)1236535329);

   /* putaran 2 */
   #define s21      5
   #define s22      9
   #define s23      14
   #define s24      20
   transform_2(var1, var2, var3, var4, input[1], s21, (u_int)4129170786);
   transform_2(var4, var1, var2, var3, input[6], s22, (u_int)3225465664);
   transform_2(var3, var4, var1, var2, input[11], s23,  (u_int)643717713);
   transform_2(var2, var3, var4, var1, input[0], s24, (u_int)3921069994);
   
   transform_2(var1, var2, var3, var4, input[5], s21, (u_int)3593408605);
   transform_2(var4, var1, var2, var3, input[10], s22,  (u_int)38016083);
   transform_2(var3, var4, var1, var2, input[15], s23, (u_int)3634488961);
   transform_2(var2, var3, var4, var1, input[4], s24, (u_int)3889429448);
   
   transform_2(var1, var2, var3, var4, input[9], s21,  (u_int)568446438);
   transform_2(var4, var1, var2, var3, input[14], s22, (u_int)3275163606);
   transform_2(var3, var4, var1, var2, input[3], s23, (u_int)4107603335);
   transform_2(var2, var3, var4, var1, input[8], s24, (u_int)1163531501);
   
   transform_2(var1, var2, var3, var4, input[13], s21, (u_int)2850285829);
   transform_2(var4, var1, var2, var3, input[2], s22, (u_int)4243563512);
   transform_2(var3, var4, var1, var2, input[7], s23, (u_int)1735328473);
   transform_2(var2, var3, var4, var1, input[12], s24, (u_int)2368359562);
   
   /* putaran 3 */
   #define s31      4
   #define s32      11
   #define s33      16
   #define s34      23
   transform_3(var1, var2, var3, var4, input[5], s31, (u_int)4294588738);
   transform_3(var4, var1, var2, var3, input[8], s32, (u_int)2272392833);
   transform_3(var3, var4, var1, var2, input[11], s33, (u_int)1839030562);
   transform_3(var2, var3, var4, var1, input[14], s34, (u_int)4259657740);
   
   transform_3(var1, var2, var3, var4, input[1], s31, (u_int)2763975236);
   transform_3(var4, var1, var2, var3, input[4], s32, (u_int)1272893353);
   transform_3(var3, var4, var1, var2, input[7], s33, (u_int)4139469664);
   transform_3(var2, var3, var4, var1, input[10], s34, (u_int)3200236656);
   
   transform_3(var1, var2, var3, var4, input[13], s31,  (u_int)681279174);
   transform_3(var4, var1, var2, var3, input[0], s32, (u_int)3936430074);
   transform_3(var3, var4, var1, var2, input[3], s33, (u_int)3572445317);
   transform_3(var2, var3, var4, var1, input[6], s34,  (u_int)76029189);
   
   transform_3(var1, var2, var3, var4, input[9], s31, (u_int)3654602809);
   transform_3(var4, var1, var2, var3, input[12], s32, (u_int)3873151461);
   transform_3(var3, var4, var1, var2, input[15], s33,  (u_int)530742520);
   transform_3(var2, var3, var4, var1, input[2], s34, (u_int)3299628645);
   
   /* putaran 4 */
   #define s41      6
   #define s42      10
   #define s43      15
   #define s44      21
   transform_4(var1, var2, var3, var4, input[0], s41, (u_int)4096336452);
   transform_4(var4, var1, var2, var3, input[7], s42, (u_int)1126891415);
   transform_4(var3, var4, var1, var2, input[14], s43, (u_int)2878612391);
   transform_4(var2, var3, var4, var1, input[5], s44, (u_int)4237533241);
   
   transform_4(var1, var2, var3, var4, input[12], s41, (u_int)1700485571);
   transform_4(var4, var1, var2, var3, input[3], s42, (u_int)2399980690);
   transform_4(var3, var4, var1, var2, input[10], s43, (u_int)4293915773);
   transform_4(var2, var3, var4, var1, input[1], s44, (u_int)2240044497);
   
   transform_4(var1, var2, var3, var4, input[8], s41, (u_int)1873313359);
   transform_4(var4, var1, var2, var3, input[15], s42, (u_int)4264355552);
   transform_4(var3, var4, var1, var2, input[6], s43, (u_int)2734768916);
   transform_4(var2, var3, var4, var1, input[13], s44, (u_int)1309151649);
   
   transform_4(var1, var2, var3, var4, input[4], s41, (u_int)4149444226);
   transform_4(var4, var1, var2, var3, input[11], s42, (u_int)3174756917);
   transform_4(var3, var4, var1, var2, input[2], s43,  (u_int)718787259);
   transform_4(var2, var3, var4, var1, input[9], s44, (u_int)3951481745);
   
   buffer[0] += var1;
   buffer[1] += var2;
   buffer[2] += var3;
   buffer[3] += var4;
}

static void md5_print (struct md5_global_requirements *hash_req)
{
   int loop;
   printf("[+] MD5 Hash : ");
   for (loop = 0; loop < 16; loop++)
   {
      printf ("%02x", hash_req->hash_digest[loop]);
   }
   printf("\n");
}

static void string_to_digest (unsigned char *user_string)
{
   struct md5_global_requirements hash_req;
   unsigned int user_string_len = (unsigned int)strlen(user_string);
   
   md5_initialization(&hash_req);
   md5_update(&hash_req, user_string, user_string_len);
   md5_hashing(&hash_req);
   md5_print(&hash_req);
}

void main(void)
{
   unsigned char my_string[150];
   
   printf("[+] MD5 Hash Generator\n");
   printf("[+] Programmer : Paulus Gandung Prakosa_ (0x1337day)\n\n");
   
   printf("[+] enter normal text(plaintext) : ");
   gets(my_string);
   
   printf("[+] Plaintext : %s\n", my_string);
   string_to_digest(my_string);
   
   getch();
}


Makasi buat sharenya gan... Kalo bole tau, ini dipake buat project apaan ya ???

hash tu bwt apa ya mas bro
sorry newbie

Pratiwi Widya Wahyuni wrote:hash tu bwt apa ya mas bro
sorry newbie

Mbak,ini kan aliran Otomasi...
Qta udah ga seiman sama mereka

Detective wrote:

Pratiwi Widya Wahyuni wrote:hash tu bwt apa ya mas bro
sorry newbie

Mbak,ini kan aliran Otomasi...
Qta udah ga seiman sama mereka

masio gak seiman tapi tetap satu Hati...

SK comunity...

Semangat dolor

Wah di jaringan juga perlu nih.. Algoritma ini buat mengacak sesuatu berupa plain text.. Biasanya untuk password..

wah asik tuh..

Detective wrote:

Pratiwi Widya Wahyuni wrote:hash tu bwt apa ya mas bro
sorry newbie

Mbak,ini kan aliran Otomasi...
Qta udah ga seiman sama mereka

Ah namanya ilmu tuh g ada salahnya dipelajari mas..^ ^

hehehehe...

all ~# maaf ya kalo membuat semua bingung...

- pengertian hash secara umum :
"Hash adalah suatu teknik "klasik" dalam Ilmu Komputer yang banyak digunakan dalam praktek
secara mendalam. Hash merupakan suatu metode yang secara langsung mengakses record-record dalam suatu tabel dengan melakukan transformasi aritmatik pada key yang menjadi alamat dalam tabel tersebut. Key merupakan suatu input dari pemakai di mana pada umumnya berupa nilai atau string karakter. "

- pengertian hash dalam algoritma MD5
"plaintext (tidak perduli berapa huruf), yang ditransformasikan menjadi ciphertext yang panjangnya 32 huruf

Contoh :
Plaintext : Pratiwi Widya Wahyuni
MD5 Ciphertext : 744690b2b5041c689a248b07f016aa81"

rootboy wrote:all ~# maaf ya kalo membuat semua bingung...

- pengertian hash secara umum :
"Hash adalah suatu teknik "klasik" dalam Ilmu Komputer yang banyak digunakan dalam praktek
secara mendalam. Hash merupakan suatu metode yang secara langsung mengakses record-record dalam suatu tabel dengan melakukan transformasi aritmatik pada key yang menjadi alamat dalam tabel tersebut. Key merupakan suatu input dari pemakai di mana pada umumnya berupa nilai atau string karakter. "

- pengertian hash dalam algoritma MD5
"plaintext (tidak perduli berapa huruf), yang ditransformasikan menjadi ciphertext yang panjangnya 32 huruf

Contoh :
Plaintext : Pratiwi Widya Wahyuni
MD5 Ciphertext : 744690b2b5041c689a248b07f016aa81"

ooooo gt ya... makasi infonya gan

nice info gan.. lumayan nih buat nambah ilmu..

rootboy wrote:all ~# maaf ya kalo membuat semua bingung...

- pengertian hash secara umum :
"Hash adalah suatu teknik "klasik" dalam Ilmu Komputer yang banyak digunakan dalam praktek
secara mendalam. Hash merupakan suatu metode yang secara langsung mengakses record-record dalam suatu tabel dengan melakukan transformasi aritmatik pada key yang menjadi alamat dalam tabel tersebut. Key merupakan suatu input dari pemakai di mana pada umumnya berupa nilai atau string karakter. "

- pengertian hash dalam algoritma MD5
"plaintext (tidak perduli berapa huruf), yang ditransformasikan menjadi ciphertext yang panjangnya 32 huruf

Contoh :
Plaintext : Pratiwi Widya Wahyuni
MD5 Ciphertext : 744690b2b5041c689a248b07f016aa81"

Waooow...sangat membantu... Thanks for share