The MD5 Message Digest Algorithm

The MD5 Message Digest Algorithm

Following is the MD5 message digest algorithm. This page is a summary of the RFC1321 document which describes the MD5 message digest algorithm in detail and also contains a C implemtation of the algorithm. The document can be found here.

The MD5 message digest algorithm strength is theoretically as follows:

The difficulty of coming up with two messages having the same message digest is on the order of 2⁶⁴ operations.
The difficulty of coming up with any message having a given message digest is on the order of 2¹²⁸ operations.

We start with our original message which can have a length between 0 and an arbitrarily large number of bits. The length of the message need not be in multiples of 8.

Our message could be written down as follows, where b is the number of bits in the message:

m₀m₁m₂... m_b-1

The following five steps are performed to produce the digest:

1. Append Padding Bits

The message is padded so that it's length is congruent to 448, mod 512. This means that the message length is 64 bits short of being a multiple of 512.
Padding is always performed, even if the message is already the correct length.
Padding goes like this:
- A 1 bit is added to the end of the message
- The rest of the message is padded with 0 bits
At least one bit and at most 512 bits will be added to the message

2. Append Length

A 64-bit representation of b (the length of the original message) is appended to the result of step 1.
- If b is longer than 2⁶⁴ , then only the lower order bits are used.
At this point, the message has a length that is an exact multiple of 512 bits. This means the message can be broken down into some multiple N of 16 32-bit words.

3. Initialize Message Digest Buffer

A four-word buffer A, B, C, D is used to compute the message digest.
A, B, C, D are 32-bit registers initialized to the following values:
```
A: 01 23 45 67
B: 89 ab cd ef
C: fe dc ba 98
D: 76 54 32 10
```

4. Process the Message in 16-bit Blocks

We define four functions that take 3 32-bit words as input and produce 1 32-bit word as output where XY is the bitwise-and of X and Y, X | Y is the bitwise-or of X and Y, X' is the bitwise negation of X, and X xor Y is the bitwise-exclusive-or of X and Y.
```
F(X, Y, Z) = XY | X'Y
G(X, Y, Z) = XZ | YZ'
H(X, Y, Z) = X xor Y xor Z
I(X, Y, Z) = Y xor (X | Z')
```
The next part of the algorithm uses a 64-element table T[1 ... 64] constructed from the sine function where T[i] is the integer part of 4294967296abs(sin(i)) where i is in radians.

We process each 16 word block using the following tables:

/* Process each 16-word block. */
   For i = 0 to N/16-1 do

     /* Copy block i into X. */
     
     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]  [DABC  1 12  2]  [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]

     /* 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

   end /* of loop on i */

5. Output

The message digest produced as output is A, B, C, D. We begin with the low-order byte of A and end with the high-order byte of D.