MD5 Algoritma descript pada dengan contoh

Kita mulai dengan mengandaikan bahwa kita memiliki pesan b-bit sebagai input, dan
bahwa kita ingin mencari message digest nya. Berikut b adalah bilangan bulat positif
sewenang-wenang; b mungkin nol, tidak perlu kelipatan delapan, dan mungkin
sewenang-wenang besar. Kami membayangkan bit pesan ditulis sebagai berikut:
m_0 m_1 ... M_ {b-1}
Berikut lima langkah yang dilakukan untuk menghitung message digest dari pesan.
Langkah 1. Tambah Padding Bits
contoh. : Pesan harus "Hello World!", Yang merupakan panjang 12 byte, mereka ...

Pesannya adalah "empuk" (diperpanjang) sehingga panjangnya (dalam bit) adalah

kongruen dengan 448, modulo 512. Artinya , pesan tersebut diperpanjang sehingga
hanya 64 bit malu menjadi ple mul dari 512 bit panjang. Padding selalu dilakukan,
bahkan jika panjang pesan sudah kongruen dengan 448, modulo 512.
Padding dilakukan sebagai berikut: a single "1" bit ditambahkan ke pesan, dan
kemudian "0" bit ditambahkan sehingga panjang dalam bit dari pesan empuk menjadi
kongruen dengan 448, modulo 512. dalam semua, setidaknya satu bit dan paling
banyak 512 bit ditambahkan.
Ex. Dalam hal ini, pesan cocok blok bit tunggal 512, jadi kita akan menambahkan 448-
12 * 8 = 352 bantalan bit (itu akan mulai dengan "1" kemudian 351 "0" s)

Langkah 2. Tambah Panjang

A 64-bit representasi dari b (panjang pesan sebelum padding bit ditambahkan)
ditambahkan ke hasil langkah sebelumnya. Dalam hal tidak mungkin bahwa b lebih
besar dari 2 ^ 64, maka hanya low-order 64 bit b digunakan. (Bit ini ditambahkan
sebagai delapan byte dan ditambahkan low-order byte)
Ex. : Panjang pesan dalam bit adalah 96 bit == 00000000 00000000 00000000
00000000 00000000 00000000 00000000 01100000 ... Mengambil urutan byte rendah
pertama akan menghasilkan.
Pada titik ini pesan yang dihasilkan (setelah bantalan dengan bit dan dengan b) memiliki
panjang yang merupakan mulƟple tepat dari 512 bit. Ekuivalen, pesan ini memiliki
panjang yang merupakan mulƟple tepat dari 16 (32-bit) kata-kata. Mari M [0 ... N-1]
menunjukkan kata-kata pesan resulƟng, di mana N adalah mulƟple dari 16.

contoh Sekarang satu-satunya blok yang tersedia memegang

Langkah 3. INI Alize MD Buffer

Buffer empat kata (A, B, C , D) digunakan untuk menghitung message digest. Berikut
masing-masing A, B, C, D adalah 32-bit register. Register ini diinisialisasi dengan nilai-
nilai berikut dalam heksadesimal, rendah-order byte pertama):
32-bit register nilai (Hexa)
S
32‐bit registers values After conversion to in After Conversion to in
(Hexa) low‐order bytes first low‐order bytes first
(Hexa) (Decimal)
word A: 01 23 45 67 0x67452301 a: 1732584193 b:
word B: 89 ab cd ef 0xefcdab89 4023233417
word C: fe dc ba 98 0x98badcfe c: 2562383102
word D: 76 54 32 10 0x10325476 d: 271733878
etelah konversi ke rendah-order byte pertama (Hexa)
Langkah 4. Pesan Proses di 16-Firman Blok
Kami pertama mendefinisikan empat func ons tambahan yang masing-masing
mengambil sebagai masukan tiga kata 32-bit dan menghasilkan output satu kata 32-bit.
F (X, Y, Z) = XY v tidak (X) Z
G (X, Y, Z) = XZ v Y tidak (Z)
H (X, Y, Z) = X XOR Y XOR Z
I (X, Y, Z) = Y xOR (X v tidak (Z))
Dalam setiap posisi bit F bertindak sebagai bersyarat: jika X maka Y lain Z.
fungsi F bisa didefinisikan menggunakan + bukannya v sejak XY dan tidak (X ) Z tidak
akan pernah memiliki 1 di posisi bit yang sama.) sangat menarik untuk dicatat bahwa
jika bit X, Y, dan Z adalah independen dan berisi, setiap bit dari F (X, Y, Z) akan
independen dan berisi.
Fungsi G, H, dan saya mirip dengan fungsi F, dalam bahwa mereka bertindak
"bitwise paralel" untuk menghasilkan output mereka dari bit X, Y, dan Z, sedemikian
rupa bahwa jika bit yang sesuai dari X , Y, dan Z adalah independen dan berisi, maka
setiap bit dari G (X, Y, Z), H (X, Y, Z), dan I (X, Y, Z) akan independen dan berisi.
Perhatikan bahwa fungsi H adalah bit-wise "xor" atau fungsi "paritas" dari input.
Langkah ini menggunakan tabel 64-elemen T [1 ... 64] dibangun dari func sinus
pada. Mari T [i] menunjukkan unsur-i dari tabel, yang sama dengan bagian integer dari
4294967296 mes abs (sin (i)), di mana saya adalah dalam radian (beralih kalkulator
Anda ke mode Radian bukan mode Degrees) . Unsur-unsur dari tabel diberikan dalam
lampiran.
Lakukan hal berikut:
/* Process each 16-word
block. */ For i = 0 to
N/16-1 do
/* Copy block i into X. */
Ex. Now “X” the 16 words each of 32 bits will hold, as the following loop does
 For j = 0 to 15 do
Set X[j] to M[i*16+j]. end /* of loop on j */

/* Save
A as AA,
B as BB,
C as CC, and
D as DD. */ AA = A
BB = B

CC = C DD = D

/* Round 1. */
/* Let [abcd k s i] denote the operation
a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
/* Do the following 16 operations. */ [ABCD 0 7 1]
Ex. * Perform in Binary: F(b,c,d) = F(B,C,D) = BC v not(B) D =
(4023233417^2562383102)V(NOT(4023233417)^ 271733878) = 2562383102
* (a + F(b,c,d) + X[k] + T[i]) = 1732584193+2562383102+1819043144+3614090360
=9728100799(10 01000011110101110000100110111111)
The above is 34 bits, so we do modular additions, to get the results of only 32 bits
Î 9728100799 MOD (2Power32) = 1138166207 (01000011110101110000100110111111)
* ((a + F(b,c,d) + X[k] + T[i]) <<< s) = 1138166207 <<< 7 = 3951353761
OR 01000011110101110000100110111111 <<< 7 = 11101011100001001101111110100001
* Again Modular Addition with b: a = b + ((a + F(b,c,d) + X[k] +
T[i]) <<< s) = (4023233417+3951353761)MOD(2Power32) =
3679619882
* Now a is 3679619882. b, c, and d are not changed.
[DABC
1 12
2]
* Just as if you call [abcd k s i] by passing [DABC 1 12 2], meaning in the expression
mentioned
in the comment above, you will replace a by D, b by A, c by B d by C, k by 1, s by 12,
and i by 2
* Now c is 2562383102 and the rest of registers is unchanged
 [CDAB 2 17 3] [BCDA 3 22 4]
[ABCD 4 7 5] [DABC 5 12 6] [CDAB 6 17 7] [BCDA 7 22 8]
[ABCD 8 7 9] [DABC 9 12 10] [CDAB 10 17 11] [BCDA 11 22 12]
[ABCD 12 7 13] [DABC 13 12 14] [CDAB 14 17 15] [BCDA 15 22 16]

/*
Round
2. */
/* Let [abcd k s i] denote the
operation
a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
/* Do the following 16
operations. */
[ABCD 1 5 17] [DABC 6 9 18] [CDAB 11 14 19] [BCDA
0 20 20] [ABCD 5 5 21] [DABC 10 9 22] [CDAB 15 14 23]
[BCDA 4 20 24] [ABCD 9 5 25] [DABC 14 9 26] [CDAB 3
14 27] [BCDA 8 20 28] [ABCD 13 5 29] [DABC 2 9 30]
[CDAB 7 14 31] [BCDA 12 20 32]

/* Round 3. */
/* Let [abcd k s t] denote the operation
a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
/* Do the following 16 operations. */
[ABCD 5 4 33] [DABC 8 11 34] [CDAB 11 16 35] [BCDA 14 23 36]
[ABCD 1 4 37] [DABC 4 11 38] [CDAB 7 16 39] [BCDA 10 23 40]
[ABCD 13 4 41] [DABC 0 11 42] [CDAB 3 16 43] [BCDA 6 23 44]
[ABCD 9 4 45] [DABC 12 11 46] [CDAB 15 16 47] [BCDA 2 23 48]

/*
Round
4. */
/* Let [abcd k s t] denote the
operation
a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
/* Do the following 16
operations. */
[ABCD 0 6 49] [DABC 7 10 50] [CDAB 14 15 51] [BCDA
5 21 52] [ABCD 12 6 53] [DABC 3 10 54] [CDAB 10 15 55]
[BCDA 1 21 56] [ABCD 8 6 57] [DABC 15 10 58] [CDAB 6
15 59] [BCDA 13 21 60] [ABCD 4 6 61] [DABC 11 10 62]
[CDAB 2 15 63] [BCDA 9 21 64]
 Changed
Round/Function Iteration Value
Register
1 a 3679619882
2 d 2081685101
3 c 133919401
4 b 2426329734
5 a 1168620452
6 d 4019849227
7 c 370807664
8 b 420445366
1 / FF
9 a 4198619016
10 d 2676785399
11 c 1993335089
12 b 1109401451
13 a 4048899853
14 d 3950087495
15 c 1946913403
16 b 2833700088
17 a 260718522
18 d 1355334187
19 c 80112311
20 b 3466307461
21 a 396033290
22 d 1763835213
23 c 4239641319
24 b 3052862749
2 / GG
25 a 2616217882
26 d 921013414
27 c 2418186433
28 b 2064486443
29 a 1988550793
30 d 146954281
31 c 198383918
32 b 1503938765
33 a 1829143082
34 d 2652512423
35 c 44713168
36 b 3452888323
37 a 4152347168
 38 d 2590106416
3 / HH
39 c 4138040678
40 b 3946422880
41 a 1824650282
42 d 3516852032
43 c 823396667
44 b 206704551
45 a 1129083802
46 d 1795018062
47 c 2728674280
48 b 2145583183
49 a 3393064847
50 d 3765494986
51 c 2359501063
52 b 1432248893
53 a 449791293
54 d 411940788
55 c 548752943
56 b 1539193972
4 / II 57 a 3430658958
58 d 3442781692
59 c 1141842014
60 b 924561567
61 a 538764524
62 d 2077978953
63 c 4184057696
64 b 1186497226
The last four rows hold the last values of the four registers…
/* Then perform the following additions. (That is increment
each of the four registers by the value it had before this
block was started.) */
A = A + AA B = B + BB C = C + CC D = D + DD
Ex. At last Modular Addition with the original values
A = A + AA = (1732584193 + 538764524 ) MOD(2Power32) = 2271348717 =
10000111 01100010
00000111 11101101 = 0x876207ED
B = B + BB = (4023233417 + 1186497226) MOD(2Power32) = 914763347 =
00110110 10000110
00101110 01010011 = 0x36862E53
C = C + CC = (2562383102 + 4184057696) MOD(2Power32) = 2451473502 =
10010010 00011110
 10000100 01011110 = 0x921E845E
D = D + DD = (271733878 + 2077978953) MOD(2Power32) = 2349712831 =
10001100 00001101
11000101 10111111 = 0x8C0DC5BF

Ex. This is for the only first 512 bit block, now continue to the next 512-bit blocks.
But this is not in this example ☺ . We are done manipulating our “Hello World!”
message.
end /* of loop on i */
Step 5. Output

Pesan digest yang dihasilkan sebagai output adalah A, B, C, D. Artinya, kita mulai
dengan low-order byte dari A, dan berakhir dengan high-order byte D.
Ex. Setelah kita selesai dengan loop di atas, kita mengambil A, B, C, dan D
dan menyusun ulang byte mereka: (Setiap register 32 bit (4 Bytes))

A 4 3 2 1
B 8 7 6 5
C 12 11 10 9
D 16 15 14 13

* Sekarang MD5 digest disimpan sebagai byte di atas dalam urutan menaik
(1, 2, 3, ...) (Ingatlah bahwa satu byte setara dengan 2 hexadecimals)
* The MD5 digest untuk di atas Contohnya adalah
0xED076287532E86365E841E92BFC50D8C
Ringkasan
pesan-mencerna algoritma MD5 sederhana untuk melaksanakan, dan menyediakan
"sidik jari" atau message digest dari pesan panjang sewenang-wenang. Hal ini
menduga bahwa kesulitan datang dengan dua pesan yang memiliki pesan yang
sama digest adalah di urutan 2 ^ 64 ons opera, dan bahwa kesulitan datang dengan
pesan apapun yang memiliki pesan yang diberikan digest adalah di urutan 2 ^ 128
ons opera. Algoritma MD5 telah hati-hati scru nized kelemahan. Namun demikian,
algoritma yang relatif baru dan analisis keamanan lebih lanjut tentu saja dibenarkan,
seperti halnya dengan usulan baru semacam ini.

References

MD5 SpecificaƟons: hƩp://www.ieƞ.org/rfc/rfc1321.txt

MD5 ImplementaƟon in C#: hƩp://www.flowgroup.fr/download/md5.zip