A ver, iré por pasos:

Primero se ha de alargar el mensaje hasta que su longitud en bits sea congruente con 448 mod 512, lo que significa que la longitud dividida entre 512 ha de dar de resto 448. Este alargamiento se hace añadiendo un 1 obligatorio y tantos ceros como sea necesario. Hay que tener en cuenta que el 1 se añade siempre, aunque la longitud del mensaje ya sea congruente, por lo que siempre se añadirán entre 1 y 512 bits.

Se concatena al final del mensaje alargado una representación de 64 bits de la longitud original del mensaje (sin alargar). Si los 64 bits no son suficientes para representar la longitud, se cogen los 64 bits de menor peso. Después de esto, tendremos un mensaje de longitud múltiplo de 512 y de 32 bits (una palabra), ya que cada bloque de 512 bits contiene 16 palabras de 32 bits.

Para calcula la salida, es necesario utilizar un buffer de cuatro palabras, A, B, C, y D, que se inicializan con los siguientes valores hexadecimales:
A: 01 23 45 67
B: 89 ab cd ef
C: fe dc ba 98
D: 76 54 32 10

También se defines cuatro funciones:
F(X,Y,Z) = (X AND Y) OR ((NOT X) AND Z)
G(X,Y,Z) = (X AND Y) OR (Y AND (NOT Z))
H(X,Y,Z) = X XOR Y XOR Z
I(X,Y,Z) = Y XOR (X OR (NOT Z))

Estas funciones utilizan tres palabras como entrada (B, C y D) y dan una como salida y cada función es aplicada dicieséis veces antes de pasar a la siguiente de la siguiente forma:
                                                   M[k]         T[ i]                B
                                                      |              |                  |
A---------------------------------+------+-----------+----<<s-----+
                                            |
B----                                     |
       |                                    |
C-------Función que toque---salida
       |
D----

El resultado de eso es la nueva B, la nueva A es la anterior D, la nueva C es la anterior B y la nueva D es la anterior C. M[k] es un bloque de 32 bits del mensaje y T[ i] es un elemento de una tabla de 64 elementos (16 veces cada función por cuatro funciones = 64 rondas) que es igual a la parte entera de 4294967296 el valor absoluto del seno de i. El operador (+) de la representación indica una suma módulo 2^32 y y <<s es una rotación a la izquierda de s bits.

Como he dicho, se hace 16 veces este paso con cada función, donde los valores de las cuatro palabras de la vuelta anterior son los iniciales de la siguiente vuelta. Una vez se han hecho las 16 vueltas con una función, se pasa a la siguiente función con los valores de las cuatro palabras de la anterior vuelta. Los valores iniciales de la cuatro palabras son aquellos con los que las hemos inicializado.

La salida se obtiene de A, B, C y D, donde D es el byte más significativo y A el menos significativo.

Espero que te haya quedado claro.

Un saludo de ghastlyX

Todas las palabras que usa MD5 son de 32 bits.

MD5 va cifrando en bloques de 512 bits, M[k] es un bloque de bits (una palabra) del mensaje después de haber rellenado y todo. T[ i] (donde i es el número de orden, puede ser por ejemplo 22) es un elemento de una tabla de 64 elementos que se calcula así:

Se calcula el seno de i (i está en radianes, no en grados). Se coge el valor absoluto (si no sabes lo que es, quiere decir pasarlo a positivo, es decir, si es positivo queda igual, si es negativo queda el mismo número pero positivo). El resultado de esto se multiplica por 4294967296 y se coge después sólo la parte entera (se ignoran los decimales). Así se obtiene T[ i].

Rotar los bits a la izquierda una posición es pasar cada bit de la palabra una posición a la izquierda. El que estaba más a la izquierda es desechado. El de más a la derecha se rellena con un cero. Hacerlo s posiciones es lo mismo, pero s veces.

Si has entendido, el proceso que indica el esquema se hace 16 veces con cada función. Los valores de las cuatro palabras que usa son determinadas por la ronda anterior. El valor de lo que se calcula en ese esquema será el valor de B en la próxima vuelta, el valor de la antigua D, sin modificar, pasa a ser el valor de la nueva A, el valor de la anterior B es la nueva C y el valor de la anterior C es la nueva D.

Es la misma B que está al principio. La palabra B es usada en la función que toca y también donde te la he puesto. Lo ideal es que hubiera hecho otra flecha desde la B del principio, pero como dibujar con guiones no me lo permetía, la he vuelto a escribir ahí.

Esto ya lo he explicado con lo de T[ i], excepto lo del paréntesis. Se hace lo del esquema 16 veces con cada función, para luego pasar a la siguiente función (que también se hace 16 veces). De esta manera son 16 veces por función y hay 4 funciones (16x4=64), por lo que se hacen 64 vueltas. Por eso digo que T[ i] es un elemento de una tabla de 64 elementos, ya que se usa un T[ i] diferente en cada una de las 64 vueltas, por eso son 64 elementos los de la tabla.

Un saludo de ghastlyX

A ver, fíjate bien en el esquema:
                                                   M[k]         T[ i]                B
                                                      |              |                  |
A---------------------------------+------+-----------+----<<s-----+
                                            |
B----                                     |
       |                                    |
C-------Función que toque---salida
       |
D----

B, C, D se usan en la función, que da una palabra de 32 bits (lo que he puesto salida). Esta salida se suma con A módulo 2^32. El resultado se suma con M[k] módulo 2^32 y lo mismo con T[ i]. Luego se hace la rotación a la izquierda de s bits y lo que quede se suma con B (la misma que has introducido en la función) módulo 2^32. Entonces queda una palabra de 32 bits como salida, que es la nueva B, la nueva A es la anterior D, la nueva C es la anterior B y la nueva D es la anterior C.

Un saludo de ghastlyX