Encriptacion MD5 y Sha1,2

T1
CARLOS
TECNOLOGICO DE ESTUDIOS SUPERIORES DE ECATEPEC |
FUNDAMENTOS DE INGENIERIA EN SISTEMAS
COMPUTACIONALES.
OBJETIVO SHA 1
Investigar MD5, SHA1, SHA2

Que es y cómo funciona SHA1
Se trata de un algoritmo como muchos otros algoritmos existentes

DATOS de encriptación (o cifrado) pero con muchas diferencias. Fue
propuesto allá en 1993 por la NSA y adoptado como un estándar
López Morales Juan Carlos federal sin embargo al corto tiempo de 2 años se mejoró (pues
https://es.wikipedia.org/wiki/S existían vulnerabilidades) y la actualización se llamó SHA1.
HA-2
https://statusexcessu.wordpr Las siglas SHA significan Secure Hash Algorithm y SHA1 es mucho
ess.com/2013/04/18/sha-1/ mas seguro que MD5. Lo interesante de SHA1 es que separa en
https://es.scribd.com/doc/79 bloques de 512 bits y además para cada bloque añade 80 vueltas
05830/Algoritmo-MD5 con unos vectores llamados ABCDE y se mezclan con el siguiente y
así sucesivamente hasta hacer un resumen de 160 bits de todo el
documento. Dentro de esas 80 vueltas a cada bloque creado de
512 bits se le aplicarán 4 funciones distintas.
Lo preocupante de SHA1 es que ya han logrado crear un método

para generar colisiones y esto significa tener 2 archivos con
contenido distinto, pero con la misma firma SHA1. Lo malo es que
SHA1 se sigue utilizando, lo bueno es que ya existen alternativas
para migrar como SHA-256 o superiores.
SHA-1
SHA-1 ha sido examinado muy de cerca por la comunidad criptográfica pública y no se ha encontrado
ningún ataque eficaz. No obstante, en el año 2004, se dio a conocer un número significativo de ataques
contra funciones criptográficas de hash con una estructura similar a SHA-1, lo que plantea dudas sobre la
seguridad a largo plazo de SHA-1.
SHA-0 y SHA-1 producen una salida resumen de 160 bits (20 bytes) de un mensaje que puede tener un
tamaño máximo de 264 bits, y se basa en principios similares a los usados por el profesor Ronald L.
Rivest del MIT en el diseño de los algoritmos de resumen de mensaje MD4 y MD5.
FUNDAMENTOS DE 5501 INGENIERIA EN LOPEZ MORALES JUAN

TELECOMUNICACIONES SISTEMAS CARLOS
COMPUTACIONALES
T1 CARLOS
COMPUTACIONALES.
La codificación hash vacía para SHA-1 corresponde a:
SHA1("") = da39a3ee5e6b4b0d3255bfef95601890afd80709
Ataques contra SHA-1

En 2004 se encontró una debilidad matemática en SHA-1, que permitiría encontrar colisiones de hash
más rápido. Sin embargo, este hallazgo resulta poco relevante, pues la complejidad de búsqueda de
colisiones pasaría de 280 a 269, algo que aún es computacionalmente inviable, requiriendo incluso más
trabajo que MD5 (264).
La resistencia del algoritmo SHA-1 se ha visto comprometida a lo largo del año 2005. Después de que
MD5, entre otros, quedara seriamente comprometido en el 2004 por parte de un equipo de investigadores
chinos, el tiempo de vida de SHA-1 quedó visto para sentencia.
El mismo equipo de investigadores chinos, compuesto por Xiaoyun Wang, Yiqun Lisa Yin y Hongbo Yu
(principalmente de la Shandong University en China), ha demostrado que son capaces de romper el SHA-1
en al menos 269 operaciones, unas 2000 veces más rápido que un ataque de fuerza bruta (que requeriría
280 operaciones). Los últimos ataques contra SHA-1 han logrado debilitarlo hasta 263.
Según el NIST:
«Este ataque es de particular importancia para las aplicaciones que usan firmas digitales tales como
marcas de tiempo y notarías. Sin embargo, muchas aplicaciones que usan firmas digitales incluyen
información sobre el contexto que hacen este ataque difícil de llevar a cabo en la práctica.»
A pesar de que 263 suponen aún un número alto de operaciones, se encuentra dentro de los límites de las
capacidades actuales de cálculos, y es previsible que con el paso del tiempo romper esta función sea
trivial, al aumentar las capacidades de cálculo y al ser más serios los ataques contra SHA-1.
El 23 de febrero de 2017, un equipo formado por Google y CWI Amsterdam, han anunciado la primera
colisión de SHA-1, la cual ha sido nombrada como SHAttered.
La importancia de la rotura de una función hash se debe interpretar en el siguiente sentido: Un hash
permite crear una huella digital, teóricamente única, de un archivo. Una colisión entre hashes supondría la
posibilidad de la existencia de dos documentos con la misma huella. La inicial similitud propuesta con la
equivalencia a que hubiese personas que compartiesen las mismas huellas digitales, o peor aún, el
mismo ADN no es adecuada pues, aunque fuera trivial encontrar dos ficheros con el mismo resumen

COMPUTACIONALES
2
T1 CARLOS
COMPUTACIONALES.
criptográfico ello no implicaría que los ficheros fueran congruentes en el contexto adecuado. Siguiendo
con la hipótesis de la similitud biométrica de dos personas, sería el equivalente a necesitar modificar el
número de brazos en una persona para que su impresión dactilar fuera igual a la de otra.
A pesar de que el NIST contempla funciones de SHA de mayor tamaño (por ejemplo, el SHA-512, de 512
bits de longitud), expertos de la talla de Bruce Schneier abogan por, sin llamar a alarmismos, buscar una
nueva función hash estandarizada que permita sustituir a SHA-1. Los nombres que se mencionan al
respecto son Tiger, de los creadores de Serpent, y WHIRLPOOL, de los creadores de AES.
SHA – 1
Publicado por José Domingo el abril 18, 2013
Publicado en: Uncategorized. Deja un comentario
NIST presentó en 1993 un algoritmo basado en las mismas técnicas que MD5 y denominado SHA (Secure
Hash Algorithm).
El primer miembro de la familia fue publicado en 1993 es oficialmente llamado SHA. Sin embargo, hoy día,
no oficialmente se le llama SHA‐0 para evitar confusiones con sus sucesores. Dos años más tarde el
primer sucesor de SHA fue publicado con el nombre de SHA‐1.
Este algoritmo en 1995 la Agencia de Seguridad Nacional (NSA) lo sustituyó por una versión mejorada
que actualmente se conoce como SHA-1 y que se considera más seguro que MD5. Produce un código
hash de 160 bits para mensajes de longitud máxima 264 bits, aunque existen otras variantes poco
utilizadas todavía que producen códigos de mayor longitud.
En general, SHA1 se considera el mejor algoritmo de la familia de Algoritmos HASH o de resumen y es el

que se aplica en la mayoría de las aplicaciones de firma electrónica. Por lo tanto es muy habitual aplicar
SHA1 seguido de RSA para realizar una firma electrónica de un documento, o bien el algoritmo DSA
específico para firma electrónica que también utiliza SHA1 internamente.
Ejemplo de hashes
Estos son ejemplos de SHA-1 digiere. ASCII codificación se utiliza para todos los mensajes.
SHA1 (” El rápido zorro marrón salta sobre el perro perezoso “) = 2fd4e1c6 7a2d28fc ed849ee1 bb76e739
1b93eb12

COMPUTACIONALES
3
T1 CARLOS
COMPUTACIONALES.
Incluso un pequeño cambio en el mensaje, con una probabilidad abrumadora, resultando en un hash
completamente diferente debido al efecto avalancha.
La codificación hash vacía para SHA‐1 corresponde a:
SHA1(“”) = da39a3ee5e6b4b0d3255bfef95601890afd80709
Es imposible encontrar un mensaje que se corresponde con un determinado mensaje.

Es imposible encontrar dos diferentes mensajes que producen el mismo mensaje.
Si un mensaje se cambia incluso de un solo carácter, el resultado será un mensaje totalmente diferente.
SHA‐0 y SHA‐1 producen una salida resumen de 160 bits (20 bytes) de un mensaje que puede tener un
tamaño máximo de 264 bits, y se basa en principios similares a los usados por el profesor Ronald L.
Rivest del MIT en el diseño de los algoritmos de resumen de mensaje MD4 y MD5.
El procesamiento consta de cinco pasos los cuales se explican a continuación:
Se incorporan bits de relleno al mensaje de entrada de tal modo que cumpla:

El relleno consiste en un uno seguido de los ceros que sean necesarios. Aunque el mensaje ya tenga la
longitud deseada, se debe efectuar el relleno, por lo que el número de bits de dicho relleno está en el
rango de 1 a 512 bits.
A la salida del paso 1, se le añade un bloque de 64 bits que represente la longitud del mensaje original
antes de ser rellenado.
Se inicializa la memoria temporal MD, la cual consta de 160 bits y su finalidad es almacenar los
resultados intermedios y finales de la función de dispersión. La MD consta de 5 registros (A,B,C,D,E) de 32
bits cada uno, los valores con los que se inicializan son los siguientes (valores hexadecimales):
A=67452301
B=EFCDAB89
C=98BADCFE
D=10325476
E= C3D2E1F0
4.Se procesa el mensaje por bloques de 512 bits, cada uno pasa por un módulo que consta de 4 rondas
de procesamiento de 20 pasos cada una. Las rondas tienen una estructura similar, con la excepción de
que cada una ocupa una función lógica primitiva diferente (f1, f2, f3 y f4).

COMPUTACIONALES
4
T1 CARLOS
COMPUTACIONALES.
figure95
La entrada a cada ronda consta del bloque de 512 bits que
se esté procesando (Yq) y los 160 bits de la memoria MD,
nótese que cada bloque de 512 bits actualizará el valor de la
memoria temporal. Cada ronda también hace uso de la
constante aditiva Kt, donde 0<= t <= 79 indica uno de
los 80 pasos a lo largo de las cuatro rondas.
5.- Una vez que se procesan los L bloques de 512 bits, el

resumen del mensaje son los 160 bits de salida del último
bloque.
SHA‐1 tiene estas propiedades y, por tanto, a que se refiere

como seguro. Está diseñado para trabajar con el Algoritmo
de Firma Digital (DSA). SHA‐1 es una forma de función de
hash.
Funciones en un solo sentido se caracterizan por dos

propiedades. La primera es que son de sentido único. Esto
significa que usted puede tomar un mensaje y calcular un
valor de hash, pero no se puede tomar un valor hash y recrear el mensaje original. También es libre de
colisión y, por tanto, no hay dos mensajes hash con el mismo valor.
Aplicaciones de SHA‐1
SHA‐1 puede ser usado en una variedad de aplicaciones:
1. Aplicaciones de seguridad que requieren autenticación
2. E‐mail 4. Distribución de software
3. Transferencia electrónica de fondos 5. Almacenamiento de datos
SHA‐1 ha sido examinado muy de cerca por la comunidad criptográfica pública, y no se ha encontrado
ningún ataque efectivo. No obstante, en el año 2004, un número de ataques significativos fueron

COMPUTACIONALES
5
T1 CARLOS
COMPUTACIONALES.
divulgados sobre funciones criptográficas de hash con una estructura similar a SHA‐1; lo que ha
planteado dudas sobre la seguridad a largo plazo de SHA‐1.
SHA-2 es un conjunto de funciones hash criptográficas (SHA-224, SHA-256, SHA-384, SHA-512)

diseñadas por la Agencia de Seguridad Nacional (NSA) y publicada en 2001 por el Instituto Nacional de
Estándares y Tecnología (NIST) como un Estándar Federal de Procesamiento de la Información (FIPS).
Una función hash es un algoritmo que transforma ("digiere") un conjunto arbitrario de elementos de datos,
como puede ser un fichero de texto, en un único valor de longitud fija (el "hash"). El valor hash calculado
puede ser utilizado para la verificación de la integridad de copias de un dato original sin la necesidad de
proveer el dato original. Esta irreversibilidad significa que un valor hash puede ser libremente distribuido o
almacenado, ya que sólo se utiliza para fines de comparación. SHA significa algoritmo de hash seguro.
SHA-2 incluye un significante número de cambios respecto a su predecesor, SHA-1; y consiste en un
conjunto de cuatro funciones hash de 224, 256, 384 o 512 bits.
La seguridad proporcionada por un algoritmo hash es sumamente dependiente de su capacidad de

producir un único valor para un conjunto de datos dados. Cuando una función hash produce el mismo
valor para dos conjuntos de datos distintos, entonces se dice que se ha producido una colisión. Una
colisión aumenta la posibilidad de que un atacante pueda elaborar computacionalmente conjuntos de
datos que proporcionen acceso a información segura o para alterar ficheros de datos informáticos de tal
forma que no cambiara el valor hash resultante y así eludir la detección. Una función hash fuerte es
aquella que es resistente a este tipo de ataques computacionales mientras que una función hash débil es
aquella donde existe una creencia casi certera de que se pueden producir colisiones. Finalmente, una
función hash quebrantada es aquella sobre la que se conoce métodos computacionales para producir
colisiones.
En 2005, se identificaron fallas de seguridad en el SHA-1, permitiendo que existiera una debilidad
matemática y evidenciando así la necesidad de una elaborar una función hash más fuerte.1 Aunque el
SHA-2 se comporta de forma parecida al algoritmo SHA-1, estos ataques no han sido extendidos
satisfactoriamente a SHA-2.
La competición de funciones hash de la NIST seleccionó una nueva función hash, el SHA-3, en 2012.2 A
diferencia de SHA-2 con SHA-1, el algoritmo SHA-3 no es derivación del SHA-2.
Índice
1 Función hash
2 Comparación de funciones SHA

COMPUTACIONALES
6
T1 CARLOS
COMPUTACIONALES.
3 Aplicaciones
4 Criptoanálisis y validación
4.1 Validación oficial
5 Ejemplos de variantes del SHA-2
6 Pseudocódigo
7 Implementaciones
7.1 Implementaciones en lenguajes comunes
7.2 Otras implementaciones
8 Ver también
9 Notas
10 Referencias
11 Enlaces externos
Función hash
Una iteración en la función de compresión de la familia SHA-2. Las funciones Ch, Σ1, Maj y Σ0 representan
las siguientes operaciones:
{\displaystyle \operatorname {Ch} (E,F,G)=(E\land F)\oplus (\neg E\land G)} \operatorname
{Ch}(E,F,G)=(E\land F)\oplus (\neg E\land G) {\displaystyle \operatorname {Ma} (A,B,C)=(A\land B)\oplus
(A\land C)\oplus (B\land C)} \operatorname {Ma}(A,B,C)=(A\land B)\oplus (A\land C)\oplus (B\land C)
{\displaystyle \Sigma _{0}(A)=(A\!\ggg \!2)\oplus (A\!\ggg \!13)\oplus (A\!\ggg \!22)} \Sigma
_{0}(A)=(A\!\ggg \!2)\oplus (A\!\ggg \!13)\oplus (A\!\ggg \!22) {\displaystyle \Sigma _{1}(E)=(E\!\ggg
\!6)\oplus (E\!\ggg \!11)\oplus (E\!\ggg \!25)} \Sigma _{1}(E)=(E\!\ggg \!6)\oplus (E\!\ggg \!11)\oplus
(E\!\ggg \!25)
La rotación de bit usa diferentes constantes para el SHA-512. Los números proporcionados corresponden
a la SHA-256. El rojo {\displaystyle \color {red}\boxplus } \color {red}\boxplus es suma módulo 232.
Con la publicación del FIPS PUB 180-2, NIST añadió tres nuevas funciones hash en la familia de SHA. Los
algoritmos eran comúnmente conocidos como SHA-2, especificados posteriormente por su longitud (en
bits): SHA-256, SHA-384, y SHA-512.
Los algoritmos fueron previamente publicados en 2001 en el borrador FIPS PUB 180-2, momento en el
cual se aceptaban revisiones públicas y comentarios. En agosto de 2002, FIPS PUB 180-2 se convirtió en
el nuevo estándar de hash seguro, reemplazando el FIPS PUB 180-1, el cual fue publicado en abril de
1995. La actualización del estándar incluyó el algoritmo original SHA-1, con la notación técnica
consistente con la que describía el funcionamiento interno de la familia SHA-2.3
En febrero de 2004, se publicó una noticia de modificación para FIPS PUB 180-2, especificando una
variante adicional (SHA-224) para que coincidiera la longitud de la clave con la de Triple DES.4 En octubre
de 2008, el estándar fue actualizado en el FIPS PUB 180-3, incluyendo el SHA-224 de la notificación de

COMPUTACIONALES
7
T1 CARLOS
COMPUTACIONALES.
modificación pero sin modificar fundamentalmente el estándar. La primera motivación de la actualización

del estándar fue redistribuir la información de seguridad de los algoritmos de hash y recomendaciones
para su uso en la "Special Publications" 800-107 y 800-57.567 Datos de prueba detallados y ejemplos de
mensajes "resumidos" fueron también eliminados del estándar y fueron proporcionados como
documentos separados.8
En marzo de 2012, el estándar fue actualizado a FIPS PUB 180-4, añadiendo las funciones hash SHA-
512/224 y SHA-512/256, y describiendo un método para la generación inicial de valores mediante
versiones truncadas del SHA-512. Adicionalmente, una restricción previa del relleno de los datos de
entrada para el cálculo del hash fue eliminada, permitiendo que los datos hash fueran calculados
simultáneamente con la generación del contenido, tal como una retransmisión en tiempo real de un vídeo
o audio. El relleno final del bloque de datos debe seguir ocurriendo antes de la salida del hash.9
La SHA-256 y SHA-512 son nuevas funciones hash con palabras de tamaño 32 y 64 bits, respectivamente.
Usan diferentes desplazamientos y constantes, pero su estructura son por otra parte virtualmente
idéntica, diferenciándose únicamente por el número de iteraciones. SHA-224 y SHA-384 son simples
versiones de truncado de las dos anteriores funciones y estas son calculadas con diferentes valores
iniciales. SHA-512/224 y SHA-512/256 son también versiones truncadas de SHA-512, pero los valores
iniciales son generados usando un método descrito en el FIPS PUB 180-4. La familia de algoritmos SHA-2
están patentados en los Estados Unidos de América (patente con identificación 6829355) y fueron
liberados bajo una licencia libre de derechos de autor.10
A finales de 2013, los mejores ataques públicos consiguieron romper las 46 de las 64 iteraciones del SHA-
25611 y 46 de las 80 iteraciones del SHA-512. Información más detallada en la sección "Criptoanálisis y
validación" siguiente.12

COMPUTACIONALES
8
Algoritmo y Tamaño de Tamaño Tamaño del Tamaño Longitud Iteraciones Operaciones Colisionesencontradas Ejemplo de
variante salida (bits). del bloque (bits). máximo de la rendimiento (MiB/s)13
estado del palabra
interno mensaje (bits).
(bits). (bits).
MD5 (como referencia) 128 128 512 264 - 1 32 64 +, and, or, xor, rot 335
Si
SHA-0 160 160 512 264 - 1 32 80 +, and, or, xor, rot -

Si
SHA-1 160 160 512 264 - 1 32 80 +, and, or, xor, rot 192
Si
SHA- SHA-224 224 256 512 264 - 1 32 64 +, and, or, xor, shr, rot Ninguna 139
2 SHA-256 256
SHA-384 384 512 1024 2128 - 1 64 80 +, and, or, xor, shr, rot Ninguna 154
SHA-512 512
SHA-512/224 224
SHA-512/256 256
SHA-3 224/256/384/512 1600 1152/1088/832/576 Ilimitado 64 24 and, xor, not, rot Ninguna
(5×5
array de
palabras
de 64-
bit)

COMPUTACIONALES
Algoritmo MD5
¿Qué es MD5?
MD5 es uno de los algoritmos de reducción criptográficos diseñados por el profesor

Ronald Rivest del MIT (Massachusetts Institute of Technology, Instituto Tecnológico de
Massachusetts). Fue desarrollado en 1991 como reemplazo del algoritmo MD4 después
de que Hans Dobbertin descubriese su debilidad.
A pesar de su amplia difusión actual, la sucesión de problemas de seguridad detectados

desde que, en 1996, Hans Dobbertin anunciase una colisión de hash plantea una serie de
dudas acerca de su uso futuro.
Colision de hash:
En informática, una colisión de hash es una situación que se produce cuando dos
entradas distintas a una función de hash producen la misma salida.
Es matemáticamente imposible que una función de hash carezca de colisiones, ya que el

número potencial de posibles entradas es mayor que el número de salidas que puede
producir un hash. Sin embargo, las colisiones se producen más frecuentemente en los
malos algoritmos. En ciertas aplicaciones especializadas con un relativamente pequeño
número de entradas que son conocidas de antemano es posible construir una función de
hash perfecta, que se asegura que todas las entradas tengan una salida diferente. Pero en
una función en la cual se puede introducir datos de longitud arbitraria y que devuelve un
hash de tamaño fijo (como MD5), siempre habrá colisiones, dado que un hash dado
puede pertenecer a un infinito número de entradas.
Una de las propiedades deseables de las funciones de hash criptográficas es que sea
computacionalmente imposible que se produzca una colisión. El valor de una función
hash puede ser usado para certificar que un texto dado (o cualquier otro dato) no ha sido
modificado, publicando el valor firmado de la función de hash si no es factible que se
produzca una colisión. En este contexto, factible se refiere a cualquier método capaz de
producirla más rápido que un ataque de cumpleaños de fuerza bruta.
El proceso de encontrar dos valores arbitrarios cuyos hashes collisionan se llama ataque
de colisiones. El proceso de encontrar un valor arbitrario cuyo hash colisione con otro
hash dado se llama ataque preimagen. Un ataque preimagen exitoso es mucho más serio
que un ataque de colisiones exitoso.
• Hashing Perfecto: Existe una Función de Enumeración que asigna a cada valor
del dominio una única posición de memoria. No posee colisiones.
• Hashing Puro: La función de Hash puede asignar a dos valores distintos el
mismo lugar en memoria. y h(x1) = h(x2). Estos dos valores reciben el
nombre de sinónimos. Las estructuras de hashing puros poseen colisiones y en
consecuencia se deberán establecer mecanismos para tratar los mismos.
Podemos clasificarlos en estructuras cerradas y abiertas y dentro de las abiertas
en estáticas y dinámicas:
o Cerradas: No utilizan un nuevo espacio en memoria.
o Abiertas: Utilizan espacio adicional.
 Estática: La estructura principal no crece.
 Dinámica: La estructura principal se expande a medida que
aumenta la cantidad de elementos.
Codificación:
La codificación del MD5 de 128 bits es representada típicamente como un número de

32 dígitos hexadecimal. El siguiente código de 28 bytes ASCII será tratado con MD5 y
veremos su correspondiente hash de salida:
MD5("Esto sí es una prueba de MD5") =

e99008846853ff3b725c27315e469fbc
Un simple cambio en el mensaje nos da un cambio total en la codificación hash, en este

caso cambiamos dos letras, el «sí» por un «no».
MD5("Esto no es una prueba de MD5") =

dd21d99a468f3bb52a136ef5beef5034
Otro ejemplo sería la codificación de un campo vacío:
MD5("") = d41d8cd98f00b204e9800998ecf8427e
Algoritmo:
• Terminologías y notaciones
En este documento "palabra" es una entidad de 32 bits y byte es una entidad de 8 bits.
Una secuencia de bits puede ser interpretada de manera natural como una secuencia de
bytes, donde cada grupo consecutivo de ocho bits se interpreta como un byte con el bit
más significativo al principio. Similarmente, una secuencia de bytes puede ser
interpretada como una secuencia de 32 bits (palabra), donde cada grupo consecutivo de
cuatro bytes se interpreta como una palabra en la que el byte menos significativo está al
principio.
El símbolo "+" significa suma de palabras.

X <<< s se interpreta por un desplazamiento a la izquierda 's'
posiciones
not(x) se entiende como el complemento de x
• Descripción del algoritmo md5
Empezamos suponiendo que tenemos un mensaje de 'b' bits de entrada, y que nos
gustaría encontrar su resumen. Aquí 'b' es un valor arbitrario entero no negativo, pero
puede ser cero, no tiene por qué ser múltiplo de ocho, y puede ser muy largo.
Imaginemos los bits del mensaje escritos así:
m0 m1 ... m{b-1}
Los siguientes cinco pasos son efectuados para calcular el resumen del mensaje.
Paso 1. Añadiendo bits [editar]
El mensaje será extendido hasta que su longitud en bits sea congruente con 448, módulo
512. Esto es, si se le resta 448 a la longitud del mensaje tras este paso, se obtiene un
múltiplo de 512. Esta extensión se realiza siempre, incluso si la longitud del mensaje es
ya congruente con 448, módulo 512.
La extensión se realiza como sigue: un sólo bit "1" se añade al mensaje, y después bits
"0" se añaden hasta que la longitud en bits del mensaje extendido se haga congruente
con 448, módulo 512. En todos los mensajes se añade al menos un bit y como máximo
512.
Paso 2. Longitud del mensaje [editar]
Un entero de 64 bits que represente la longitud 'b' del mensaje (longitud antes de añadir
los bits) se concatena al resultado del paso anterior. En el supuesto no deseado de que 'b'
sea mayor que 2^64, entonces sólo los 64 bits de menor peso de 'b' se usarán.
En este punto el mensaje resultante (después de rellenar con los bits y con 'b') se tiene
una longitud que es un múltiplo exacto de 512 bits. A su vez, la longitud del mensaje es
múltiplo de 16 palabras (32 bits por palabra). Con M[0 ... N-1] denotaremos las palabras
del mensaje resultante, donde N es múltiplo de 16.
Paso 3. Inicializar el búfer MD [editar]
Un búfer de cuatro palabras (A, B, C, D) se usa para calcular el resumen del mensaje.
Aquí cada una de las letras A, B, C, D representa un registro de 32 bits. Estos registros
se inicializan con los siguientes valores hexadecimales, los bits de menor peso primero:
palabra A: 01 23 45 67
palabra B: 89 ab cd ef
palabra C: fe dc ba 98
palabra D: 76 54 32 10
Paso 4. Procesado del mensaje en bloques de 16 palabras [editar]
Primero definimos cuatro funciones auxiliares que toman como entrada tres palabras de
32 bits y su salida es una palabra de 32 bits.
Los operadores son las funciones XOR, AND, OR y NOT
respectivamente.
En cada posición de cada bit F actúa como un condicional: si X, entonces Y sino Z. La

función F podría haber sido definida usando + en lugar de v ya que XY y not(x) Z nunca
tendrán unos ('1') en la misma posición de bit. Es interesante resaltar que si los bits de
X, Y y Z son independientes y no sesgados, cada uno de los bits de F(X,Y,Z) será
independiente y no sesgado.
Las funciones G, H e I son similares a la función F, ya que actúan "bit a bit en paralelo"
para producir sus salidas de los bits de X, Y y Z, en la medida que si cada bit
correspondiente de X, Y y Z son independientes y no sesgados, entonces cada bit de
G(X,Y,Z), H(X,Y,Z) e I(X,Y,Z) serán independientes y no sesgados. Nótese que la
función H es la comparación bit a bit "xor" o función "paridad" de sus entradas.
Este paso usa una tabla de 64 elementos T[1 ... 64] construida con la función Seno.
Denotaremos por T[i] el elemento i-ésimo de esta tabla, que será igual a la parte entera
del valor absoluto del seno de 'i' 4294967296 veces, donde 'i' está en radianes.
Código del MD5:
/* Procesar cada bloque de 16 palabras. */

para i = 0 hasta N/16-1 hacer
/* Copiar el bloque 'i' en X. */

para j = 0 hasta 15 hacer
hacer X[j] de M[i*16+j].
fin para /* del bucle 'j' */
/* Guardar A como AA, B como BB, C como CC, y D como DD. */

AA = A
BB = B
CC = C
DD = D
/* Ronda 1. */
/* [abcd k s i] denotarán la operación
a = b + ((a + F(b, c, d) + X[k] + T[i]) <<< s). */
/* Hacer las siguientes 16 operaciones. */
[ABCD 0 7 1] [DABC 1 12 2] [CDAB 2 17 3] [BCDA 3 22 4]
/* Ronda 2. */
/* [abcd k s i] denotarán la operación
a = b + ((a + G(b, c, d) + X[k] + T[i]) <<< s). */
/* Ronda 3. */
/* [abcd k s t] denotarán la operación
a = b + ((a + H(b, c, d) + X[k] + T[i]) <<< s). */
/* Ronda 4. */
/* [abcd k s t] denotarán la operación
a = b + ((a + I(b, c, d) + X[k] + T[i]) <<< s). */
/* Ahora realizar las siguientes sumas. (Este es el incremento de

cada
uno de los cuatro registros por el valor que tenían antes de que
este bloque fuera inicializado.) */
A = A + AA
B = B + BB
C = C + CC
D = D + DD
fin para /* del bucle en 'i' */
Paso 5. Salida [editar]
El resumen del mensaje es la salida producida por A, B, C y D. Esto es, se comienza el

byte de menor peso de A y se acaba con el byte de mayor peso de D.
Seguridad [editar]
A pesar de haber sido considerado criptográficamente seguro en un principio, ciertas
investigaciones han revelado vulnerabilidades que hacen cuestionable el uso futuro del
MD5. En agosto del 2004, Xiaoyun Wang, Dengguo Feng, Xuejia Lai y Hongbo Yu
anunciaron el descubrimiento de colisiones de hash para MD5. Su ataque se consumó
en una hora de cálculo con un clúster IBM P690.
Aunque dicho ataque era analítico, el tamaño del hash (128 bits) es lo suficientemente
pequeño como para que resulte vulnerable frente a ataques de 'fuerza bruta' tipo
'cumpleaños' (Ataque de cumpleaños). El proyecto de computación distribuida
MD5CRK arrancó en marzo del 2004 con el propósito de demostrar que MD5 es
inseguro frente a uno de tales ataques, aunque acabó poco después del aviso de la
publicación de la vulnerabilidad del equipo de Wang.
Debido al descubrimiento de métodos sencillos para generar colisiones de hash, muchos

investigadores recomiendan su sustitución por algoritmos alternativos tales como SHA-
1 o RIPEMD-160.
Aplicaciones [editar]
Los resúmenes MD5 se utilizan extensamente en el mundo del software para
proporcionar la seguridad de que un archivo descargado de Internet no se ha alterado.
Comparando una suma MD5 publicada con la suma de comprobación del archivo
descargado, un usuario puede tener la confianza suficiente de que el archivo es igual
que el publicado por los desarrolladores. Esto protege al usuario contra los 'Caballos de
Troya' o 'Troyanos' y virus que algún otro usuario malicioso pudiera incluir en el
software. La comprobación de un archivo descargado contra su suma MD5 no detecta
solamente los archivos alterados de una manera maliciosa, también reconoce una
descarga corrupta o incompleta.
Para comprobar la integridad de un archivo descargado de Internet se puede utilizar una

herramienta MD5 para comparar la suma MD5 de dicho archivo con un archivo
MD5SUM con el resumen MD5 del primer archivo. En los sistemas UNIX, el comando
de md5sum es un ejemplo de tal herramienta. Además, también está implementado en el
lenguaje de scripting PHP como MD5("") entre otros.
En sistemas UNIX y GNU/Linux se utiliza el algoritmo MD5 para cifrar las claves de
los usuarios. En el disco se guarda el resultado del MD5 de la clave que se introduce al
dar de alta un usuario, y cuando éste quiere entrar en el sistema se compara la entrada
con la que hay guardada en el disco duro, si coinciden, es la misma clave y el usuario
será autenticado. He ahí el problema de encontrar y generar colisiones de hash a
voluntad.
El MD5 también se puede usar para comprobar que los correos electrónicos no han sido
alterados usando claves públicas y privadas.
Implementación:
/*********************************************************************
********
* md5.js
*
* A JavaScript implementation derived from the RSA Data Security,
Inc. MD5
* Message-Digest Algorithm. See
http://cw.oaktree.co.uk/site/legal.html for
* details.
*
* Copyright (C) Paul Johnston 1999 - 2000. Distributed under the
LGPL.
*********************************************************************
********/
/* to convert strings to a list of ascii values */

var sAscii = " !\"#$%&'()*+,-.
/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ"
var sAscii = sAscii + "[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";
/* convert integer to hex string */

var sHex = "0123456789ABCDEF";
function hex(i)
{
h = "";
for(j = 0; j <= 3; j++)
{
h += sHex.charAt((i >> (j * 8 + 4)) & 0x0F) +
sHex.charAt((i >> (j * 8)) & 0x0F);
}
return h;
}
/* add, handling overflows correctly */

function add(x, y)
{
return ((x&0x7FFFFFFF) + (y&0x7FFFFFFF)) ^ (x&0x80000000) ^
(y&0x80000000);
}
/* MD5 rounds functions */

function R1(A, B, C, D, X, S, T)
{
q = add(add(A, (B & C) | ((~B) & D)), add(X, T));
return add((q << S) | (q >>> (32 - S)), B);
}
{
q = add(add(A, (B & D) | (C & (~D))), add(X, T));
return add((q << S) | (q >>> (32 - S)), B);
}
{
q = add(add(A, B ^ C ^ D), add(X, T));
return add((q << S) | (q >>> (32 - S)), B);
}
{
q = add(add(A, C ^ (B | (~D))), add(X, T));
return add((q << S) | (q >>> (32 - S)), B);
}
/* main entry point */

function calcMD5(sInp) {
/* Calculate length in machine words, including padding */

wLen = (((sInp.length + 8) >> 6) + 1) << 4;
var X = new Array(wLen);
/* Convert string to array of words */

j = 4;
for (i = 0; (i * 4) < sInp.length; i++)
{
X[i] = 0;
for (j = 0; (j < 4) && ((j + i * 4) < sInp.length); j++)
{
X[i] += (sAscii.indexOf(sInp.charAt((i * 4) + j)) + 32) << (j *
8);
}
}
/* Append padding bits and length */

if (j == 4)
{
X[i++] = 0x80;
}
else
{
X[i - 1] += 0x80 << (j * 8);
}
for(; i < wLen; i++) { X[i] = 0; }
X[wLen - 2] = sInp.length * 8;
/* hard coded initial values */

a = 0x67452301;
b = 0xefcdab89;
c = 0x98badcfe;
d = 0x10325476;
/* Process each 16 word block in turn */

for (i = 0; i < wLen; i += 16) {
aO = a;
bO = b;
cO = c;
dO = d;
a = R1(a, b, c, d, X[i+ 0], 7 , 0xd76aa478);

d = R1(d, a, b, c, X[i+ 1], 12, 0xe8c7b756);
c = R1(c, d, a, b, X[i+ 2], 17, 0x242070db);
b = R1(b, c, d, a, X[i+ 3], 22, 0xc1bdceee);
a = R1(a, b, c, d, X[i+ 4], 7 , 0xf57c0faf);
d = R1(d, a, b, c, X[i+ 5], 12, 0x4787c62a);
c = R1(c, d, a, b, X[i+ 6], 17, 0xa8304613);
b = R1(b, c, d, a, X[i+ 7], 22, 0xfd469501);
a = R1(a, b, c, d, X[i+ 8], 7 , 0x698098d8);
d = R1(d, a, b, c, X[i+ 9], 12, 0x8b44f7af);
c = R1(c, d, a, b, X[i+10], 17, 0xffff5bb1);
b = R1(b, c, d, a, X[i+11], 22, 0x895cd7be);
a = R1(a, b, c, d, X[i+12], 7 , 0x6b901122);
d = R1(d, a, b, c, X[i+13], 12, 0xfd987193);
c = R1(c, d, a, b, X[i+14], 17, 0xa679438e);
b = R1(b, c, d, a, X[i+15], 22, 0x49b40821);
a = R2(a, b, c, d, X[i+ 1], 5 , 0xf61e2562);

d = R2(d, a, b, c, X[i+ 6], 9 , 0xc040b340);
c = R2(c, d, a, b, X[i+11], 14, 0x265e5a51);
b = R2(b, c, d, a, X[i+ 0], 20, 0xe9b6c7aa);
a = R2(a, b, c, d, X[i+ 5], 5 , 0xd62f105d);
d = R2(d, a, b, c, X[i+10], 9 , 0x2441453);
c = R2(c, d, a, b, X[i+15], 14, 0xd8a1e681);
b = R2(b, c, d, a, X[i+ 4], 20, 0xe7d3fbc8);
a = R2(a, b, c, d, X[i+ 9], 5 , 0x21e1cde6);
d = R2(d, a, b, c, X[i+14], 9 , 0xc33707d6);
c = R2(c, d, a, b, X[i+ 3], 14, 0xf4d50d87);
b = R2(b, c, d, a, X[i+ 8], 20, 0x455a14ed);
a = R2(a, b, c, d, X[i+13], 5 , 0xa9e3e905);
d = R2(d, a, b, c, X[i+ 2], 9 , 0xfcefa3f8);
c = R2(c, d, a, b, X[i+ 7], 14, 0x676f02d9);
b = R2(b, c, d, a, X[i+12], 20, 0x8d2a4c8a);
a = R3(a, b, c, d, X[i+ 5], 4 , 0xfffa3942);

d = R3(d, a, b, c, X[i+ 8], 11, 0x8771f681);
c = R3(c, d, a, b, X[i+11], 16, 0x6d9d6122);
b = R3(b, c, d, a, X[i+14], 23, 0xfde5380c);
a = R3(a, b, c, d, X[i+ 1], 4 , 0xa4beea44);
d = R3(d, a, b, c, X[i+ 4], 11, 0x4bdecfa9);
c = R3(c, d, a, b, X[i+ 7], 16, 0xf6bb4b60);
b = R3(b, c, d, a, X[i+10], 23, 0xbebfbc70);
a = R3(a, b, c, d, X[i+13], 4 , 0x289b7ec6);
d = R3(d, a, b, c, X[i+ 0], 11, 0xeaa127fa);
c = R3(c, d, a, b, X[i+ 3], 16, 0xd4ef3085);
b = R3(b, c, d, a, X[i+ 6], 23, 0x4881d05);
a = R3(a, b, c, d, X[i+ 9], 4 , 0xd9d4d039);
d = R3(d, a, b, c, X[i+12], 11, 0xe6db99e5);
c = R3(c, d, a, b, X[i+15], 16, 0x1fa27cf8);
b = R3(b, c, d, a, X[i+ 2], 23, 0xc4ac5665);
a = R4(a, b, c, d, X[i+ 0], 6 , 0xf4292244);

d = R4(d, a, b, c, X[i+ 7], 10, 0x432aff97);
c = R4(c, d, a, b, X[i+14], 15, 0xab9423a7);
b = R4(b, c, d, a, X[i+ 5], 21, 0xfc93a039);
a = R4(a, b, c, d, X[i+12], 6 , 0x655b59c3);
d = R4(d, a, b, c, X[i+ 3], 10, 0x8f0ccc92);
c = R4(c, d, a, b, X[i+10], 15, 0xffeff47d);
b = R4(b, c, d, a, X[i+ 1], 21, 0x85845dd1);
a = R4(a, b, c, d, X[i+ 8], 6 , 0x6fa87e4f);
d = R4(d, a, b, c, X[i+15], 10, 0xfe2ce6e0);
c = R4(c, d, a, b, X[i+ 6], 15, 0xa3014314);
b = R4(b, c, d, a, X[i+13], 21, 0x4e0811a1);
a = R4(a, b, c, d, X[i+ 4], 6 , 0xf7537e82);
d = R4(d, a, b, c, X[i+11], 10, 0xbd3af235);
c = R4(c, d, a, b, X[i+ 2], 15, 0x2ad7d2bb);
b = R4(b, c, d, a, X[i+ 9], 21, 0xeb86d391);
a = add(a, aO);
b = add(b, bO);
c = add(c, cO);
d = add(d, dO);
}
return hex(a) + hex(b) + hex(c) + hex(d);
}
Formulario de login
<html><head><title></title>
<script language="JavaScript" src="md5.js"></script>
<script language="JavaScript">
numero = Math.random().toString();
function calculaMD5() {
var pw = document.forms["login"].elements["password"].value
pw += numero
return calcMD5(pw)
}
function enviaMD5(hash) {
document.forms["login"].elements["cifrado"].value = hash;
document.forms["login"].elements["numero"].value = numero;
document.forms["login"].submit();
}
</script>
</head>
<body>
<form action="auth.php3" method="POST" name="login">
Usuario: <input type="Text" name="usuario"><br>
Password: <input type="Password" name="password"><br>
<input type="Hidden" name="cifrado" value="">
<input type="Hidden" name="numero" value="">
<input type="Submit" value=" Login " onClick="enviaMD5(calculaMD5())">

Encriptacion MD5 y Sha1,2

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Encriptacion MD5 y Sha1,2

Cargado por

Copyright:

Formatos disponibles

T1

Investigar MD5, SHA1, SHA2

Se trata de un algoritmo como muchos otros algoritmos existentes

Lo preocupante de SHA1 es que ya han logrado crear un método

FUNDAMENTOS DE 5501 INGENIERIA EN LOPEZ MORALES JUAN

La codificación hash vacía para SHA-1 corresponde a:

Ataques contra SHA-1

FUNDAMENTOS DE 5501 INGENIERIA EN LOPEZ MORALES JUAN

En general, SHA1 se considera el mejor algoritmo de la familia de Algoritmos HASH o de resumen y es el

FUNDAMENTOS DE 5501 INGENIERIA EN LOPEZ MORALES JUAN

La codificación hash vacía para SHA‐1 corresponde a:

Es imposible encontrar un mensaje que se corresponde con un determinado mensaje.

El procesamiento consta de cinco pasos los cuales se explican a continuación:

Se incorporan bits de relleno al mensaje de entrada de tal modo que cumpla:

FUNDAMENTOS DE 5501 INGENIERIA EN LOPEZ MORALES JUAN

5.- Una vez que se procesan los L bloques de 512 bits, el

SHA‐1 tiene estas propiedades y, por tanto, a que se refiere

Funciones en un solo sentido se caracterizan por dos

SHA‐1 puede ser usado en una variedad de aplicaciones:

1. Aplicaciones de seguridad que requieren autenticación

2. E‐mail 4. Distribución de software

3. Transferencia electrónica de fondos 5. Almacenamiento de datos

FUNDAMENTOS DE 5501 INGENIERIA EN LOPEZ MORALES JUAN

SHA-2 es un conjunto de funciones hash criptográficas (SHA-224, SHA-256, SHA-384, SHA-512)

La seguridad proporcionada por un algoritmo hash es sumamente dependiente de su capacidad de

FUNDAMENTOS DE 5501 INGENIERIA EN LOPEZ MORALES JUAN

FUNDAMENTOS DE 5501 INGENIERIA EN LOPEZ MORALES JUAN

modificación pero sin modificar fundamentalmente el estándar. La primera motivación de la actualización

FUNDAMENTOS DE 5501 INGENIERIA EN LOPEZ MORALES JUAN

SHA-0 160 160 512 264 - 1 32 80 +, and, or, xor, rot -

FUNDAMENTOS DE 5501 INGENIERIA EN LOPEZ MORALES JUAN

MD5 es uno de los algoritmos de reducción criptográficos diseñados por el profesor

A pesar de su amplia difusión actual, la sucesión de problemas de seguridad detectados

Es matemáticamente imposible que una función de hash carezca de colisiones, ya que el

La codificación del MD5 de 128 bits es representada típicamente como un número de

MD5("Esto sí es una prueba de MD5") =

Un simple cambio en el mensaje nos da un cambio total en la codificación hash, en este

MD5("Esto no es una prueba de MD5") =

Otro ejemplo sería la codificación de un campo vacío:

El símbolo "+" significa suma de palabras.

• Descripción del algoritmo md5

Paso 1. Añadiendo bits [editar]

Paso 2. Longitud del mensaje [editar]

Paso 3. Inicializar el búfer MD [editar]

Paso 4. Procesado del mensaje en bloques de 16 palabras [editar]

En cada posición de cada bit F actúa como un condicional: si X, entonces Y sino Z. La

Código del MD5:

/* Procesar cada bloque de 16 palabras. */

/* Copiar el bloque 'i' en X. */

/* Guardar A como AA, B como BB, C como CC, y D como DD. */

/* Ahora realizar las siguientes sumas. (Este es el incremento de

fin para /* del bucle en 'i' */

Paso 5. Salida [editar]

El resumen del mensaje es la salida producida por A, B, C y D. Esto es, se comienza el

Debido al descubrimiento de métodos sencillos para generar colisiones de hash, muchos

Para comprobar la integridad de un archivo descargado de Internet se puede utilizar una

/* to convert strings to a list of ascii values */

/* convert integer to hex string */

/* add, handling overflows correctly */

/* MD5 rounds functions */

/* main entry point */

/* Calculate length in machine words, including padding */

/* Convert string to array of words */

/* Append padding bits and length */