Ver el código de «SHA-2»

'''''SHA-2'''''<ref name="preimage-guo" /> es un conjunto de funciones hash criptográficas ('''SHA-224, SHA-256, SHA-384, SHA-512''') diseñadas por la [[National Security Agency|Agencia de Seguridad Nacional]] (NSA) y publicada en 2001 por el [[NIST|Instituto Nacional de Estándares y Tecnología]] (NIST) como un [[Federal Information Processing Standard| 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 [[Secure Hash Algorithm|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 elaborar una función hash más fuerte.<ref>{{cita web|url=http://www.schneier.com/blog/archives/2005/02/cryptanalysis_o.html|título=Schneier on Security: Cryptanalysis of SHA-1|fechaacceso=8 de noviembre de 2011|editorial=Schneier.com}}</ref> 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.<ref name="nist.gov">[http://www.nist.gov/itl/csd/sha-100212.cfm NIST Selects Winner of Secure Hash Algorithm (SHA-3) Competition]</ref> A diferencia de SHA-2 con SHA-1, el algoritmo SHA-3 no es derivación del SHA-2.

== Función hash ==
[[Archivo:SHA-2 diagram.png|alt=|miniaturadeimagen|400x400px|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: <br />
<math>\operatorname{Ch}(E,F,G) = (E \land F) \oplus (\neg E \land G)</math>
<math>\operatorname{Ma}(A,B,C) = (A \land B) \oplus (A \land C) \oplus (B \land C)</math>
<math>\Sigma_0(A) = (A\!\ggg\!2) \oplus (A\!\ggg\!13) \oplus (A\!\ggg\!22)</math>
<math>\Sigma_1(E) = (E\!\ggg\!6) \oplus (E\!\ggg\!11) \oplus (E\!\ggg\!25)</math> <br />
La rotación de bit usa diferentes constantes para el SHA-512. Los números proporcionados corresponden a la SHA-256.
El rojo <math>\color{red}\boxplus</math> es suma módulo 2<sup>32</sup>.]]
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 [[Secure Hash Algorithm|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.<ref>Federal Register Notice 02-21599, [https://federalregister.gov/a/02-21599 Announcing Approval of FIPS Publication 180-2]</ref>

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]].<ref>[http://csrc.nist.gov/publications/fips/fips180-2/fips180-2withchangenotice.pdf FIPS 180-2 with Change Notice 1]</ref>
En octubre de 2008, el estándar fue actualizado en el FIPS PUB 180-3, incluyendo el SHA-224 de la notificación de 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.<ref>Federal Register Notice E8-24743, [https://federalregister.gov/a/E8-24743 Announcing Approval of FIPS Publication 180-3]</ref><ref>FIPS SP 800-107 [http://csrc.nist.gov/publications/nistpubs/800-107-rev1/sp800-107-rev1.pdf Recommendation for Applications Using Approved Hash Algorithms]</ref><ref>FIPS SP 800-57 [http://csrc.nist.gov/publications/nistpubs/800-57/sp800-57_part1_rev3_general.pdf Recommendation for Key Management: Part 1: General]</ref> Datos de prueba detallados y ejemplos de mensajes "resumidos" fueron también eliminados del estándar y fueron proporcionados como documentos separados.<ref>NIST Algorithm Examples, [http://csrc.nist.gov/groups/ST/toolkit/examples.html#aHashing Secure Hashing]</ref>

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.<ref>Federal Register Notice 2012-5400, [https://federalregister.gov/a/2012-5400 Announcing Approval of FIPS Publication 180-4]</ref>

La SHA-256 y SHA-512 son nuevas funciones hash con 8 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|Estados Unidos de América]] (patente con identificación 6829355) y fueron liberados bajo una licencia libre de derechos de autor.<ref>{{cita publicación |título=Licensing Declaration for US patent 6829355.|url=https://datatracker.ietf.org/ipr/858/|fechaacceso=17 de febrero de 2008}}</ref>

A finales de 2013, los mejores ataques públicos consiguieron romper las 46 de las 64 iteraciones del SHA-256<ref>Mario Lamberger and Florian Mendel, [http://eprint.iacr.org/2011/037.pdf Higher-Order Differential Attack on Reduced SHA-256], consultado el 24 de agosto de 2012.</ref> y 46 de las 80 iteraciones del SHA-512. Información más detallada en [[#Criptoanálisis y validación| la sección "Criptoanálisis y validación" siguiente]].<ref>Yu Sasaki, Lei Wang, and Kazumaro Aoki, [http://eprint.iacr.org/2009/479.pdf Preimage Attacks on 41-Step SHA-256 and 46-Step SHA-512], consultado el 3 de enero de 2010.</ref>

== Comparación de funciones SHA ==
En la tabla de abajo, ''estado interno'' significa "suma hash interna" después de cada compresión de un bloque de datos.

{| class="wikitable"
|-
! colspan="2"|Algoritmo y <br />variante
! Tamaño de salida (bits).
! Tamaño del estado interno (bits).
! Tamaño del bloque (bits).
! Tamaño máximo del mensaje (bits).
! Longitud de la palabra (bits).
! Iteraciones
! Operaciones
! [[Colisión (hash)|Colisiones]] encontradas
! Ejemplo de rendimiento ([[Mebibyte|MiB]]/s)<ref>{{cita web|url=http://www.cryptopp.com/benchmarks-amd64.html|título=Crypto++ 5.6.0 Benchmarks|fechaacceso=13 de junio de 2013|fechaarchivo=14 de octubre de 2016|urlarchivo=https://web.archive.org/web/20161014211419/http://www.cryptopp.com/benchmarks-amd64.html|deadurl=yes}}</ref>
|- style="text-align:center;"
| colspan="2"|'''MD5''' (como referencia) || 128 || 128 || 512 || 2<sup>64</sup> - 1 || 32 || 64 || +, and, or, xor, rot || {{No|Si}} || 335
|- style="text-align:center;"
| colspan="2"|'''SHA-0''' || 160 || 160 || 512 || 2<sup>64</sup> - 1 || 32 || 80 || +, and, or, xor, rot || {{No|Si}} || -
|- style="text-align:center;"
| colspan="2"|'''SHA-1''' || 160 || 160 || 512 || 2<sup>64</sup> - 1 || 32 || 80 || +, and, or, xor, rot ||  {{No|Si}} || 192
|- style="text-align:center;"
| rowspan="2"|'''SHA-2''' || ''SHA-224'' <br /> ''SHA-256'' || 224<br />256 || 256 || 512 || 2<sup>64</sup> - 1 || 32 || 64 || +, and, or, xor, shr, rot || Ninguna || 139
|- style="text-align:center;"
| ''SHA-384'' <br /> ''SHA-512'' <br /> ''SHA-512/224'' <br /> ''SHA-512/256'' || 384 <br /> 512 <br /> 224 <br /> 256 || 512 || 1024 || 2<sup>128</sup> - 1 || 64 || 80 || +, and, or, xor, shr, rot || Ninguna || 154
|- style="text-align:center;"
| colspan="2"|'''SHA-3''' || 224/256/384/512 || 1600<br />(5×5 array de palabras de 64-bit) ||1152/1088/832/576 ||Ilimitado|| 64 || 24 || and, xor, not, rot || Ninguna ||
|}

Los datos de rendimientos descritos anteriormente fueron realizados con una implementación de un único hilo (hebra) de un [[AMD Opteron]] 8354 a 2.2&nbsp;GHz bajo un Linux x64, y sólo sirven para una ruda comparación general. Para un mayor detalle de las mediciones de rendimiento en arquitecturas de procesadores modernos se facilita la siguiente tabla.

{| class="wikitable"
|-
! Arquitectura CPU
! Frecuencia
! Algoritmo
! Tamaño palabra (bits).
! Ciclo/Byte [[x86]]
! MiB/s x86
! Ciclo/Byte [[x86-64]]
! MiB/s x86-64
|- style="text-align:center;"
| rowspan="2"|[[Ivy Bridge (microarchitecture)|Intel Ivy Bridge]]|| rowspan="2" |3.5&nbsp;GHz || SHA-256 || 32-bit || 16.80 || 199 || 13.05 || 256
|- style="text-align:center;"
| SHA-512 || 64-bit || 43.66 || 76 || 8.48 || 394
|- style="text-align:center;"
| rowspan="2"|[[Piledriver (microarchitecture)|AMD Piledriver]]|| rowspan="2" |3.8&nbsp;GHz || SHA-256 || 32-bit || 22.87 || 158 || 18.47 || 196
|- style="text-align:center;"
| SHA-512 || 64-bit || 88.36 || 41 || 12.43 || 292
|}

Los resultados de rendimiento etiquetados como 'x86' fueron obtenidos usando un código de 32 bits en procesadores de 64 bits, mientras que los etiquetados como 'x86-64' son códigos de 64 bits. Mientras que SHA-256 está diseñado para operaciones de 32 bits, se beneficia computacionalmente del código optimizado para procesadores de 64 bits. Las implementaciones de 32 bits para SHA-512 son significativamente más lentas que sus equivalente en 64 bits. Las variaciones de ambos algoritmos con diferente tamaños de salida tienen un rendimiento similar, ya que las funciones de expansión y compresión del mensaje son idénticas, y únicamente varia los valores iniciales y los tamaños de salida. Las mejores implementaciones del MD5 y SHA-1 consiguen un rendimiento entre 4,5 y 6 ciclos por byte en procesadores modernos.

Los ensayos fueron llevado a cabo por la [[Universidad de Chicago|Universidad de Illinois en Chicago]] en su sistema hydra8 ejecutado en un Intel Xeon E3-1275 V2 a una frecuencia de reloj de 3,5&nbsp;GHz, y en su sistema hydra9 ejecutada en un AMD A10-5800K con una frecuencia de 3,8&nbsp;GHz.<ref>SUPERCOP Benchmarks [http://bench.cr.yp.to/results-hash.html Measurements of hash functions, indexed by machine] {{Wayback|url=http://bench.cr.yp.to/results-hash.html |date=20131204165905 }}</ref> Las velocidades referenciadas como ciclos por bytes son la mediana del rendimiento de un algoritmo tratando con un mensaje de 4096 bytes usando el software de "benchmarking" criptográfico SUPERCOP.<ref>{{Cita web |url=http://bench.cr.yp.to/supercop.html |título=SUPERCOP Benchmarking Toolkit |fechaacceso=2 de enero de 2014 |urlarchivo=https://web.archive.org/web/20150215055126/http://bench.cr.yp.to/supercop.html |fechaarchivo=15 de febrero de 2015 }}</ref> El rendimiento MiB/s se extrapolan de la velocidad del reloj de una CPU de un solo núcleo, rendimiento que varía en el mundo real debido a numerosos factores.

== Aplicaciones ==
Las funciones hash SHA-2 están implementadas en una gran variedad de aplicaciones y protocolos de seguridad, como por ejemplo: [[Transport Layer Security|TLS]] y [[Secure Sockets Layer|SSL]], [[Pretty Good Privacy|PGP]], [[Secure Shell|SSH]], [[S/MIME]], [[Bitcoin]], [[Peer-to-peer#Otras_Aplicaciones|PPCoin]] y [[IPsec]].

La [[Criptodivisa|moneda criptográfica]] [[Bitcoin]] depende en gran medida en un doble uso del SHA-256. El SHA-256 es usado para identificar los paquetes software de [[Debian GNU/Linux]]<ref>{{cita web|url=http://google.com/codesearch/p?hl=en#nywQboHfkw4/apt/apt-pkg/acquire-item.cc&q=SHA256|título=Debian codebase in Google Code|fechaacceso=8 de noviembre de 2011|editorial=Google|urlarchivo=https://web.archive.org/web/20111107215111/http://google.com/codesearch/p?hl=en#nywQboHfkw4/apt/apt-pkg/acquire-item.cc&q=SHA256|fechaarchivo=7 de noviembre de 2011}}</ref> y en el estándar de mensaje firmado [[DKIM]]; SHA-512 es parte del sistema para identificar los vídeos guardados en el [[Tribunal Penal Internacional para Ruanda]].<ref>John Markoff, [http://www.nytimes.com/2009/01/27/science/27arch.html A Tool to Verify Digital Records, Even as Technology Shifts], ''New York Times'', January 26, 2009</ref> SHA-256 y SHA-512 fueron propuestos para ser usados en [[DNSSEC]].<ref>RFC 5702,[http://www.rfc-editor.org/rfc/rfc5702.txt RFC-Editor.org]</ref> Los proveedores de [[Unix]] y Linux están adoptando SHA-2 de 256 y 512 bits para aplicarlo en las contraseñas de seguridad.<ref>Ulrich Drepper, [http://people.redhat.com/drepper/sha-crypt.html Unix crypt with SHA-256/512]</ref>

SHA-1 y SHA-2 son algoritmos hash de seguridad requeridos por ley en ciertas aplicaciones del [[Gobierno_federal_de_los_Estados_Unidos| gobierno de Estados Unidos]], junto con el uso de otros algoritmos y protocolos criptográficos, para la protección de información clasificada y sensible. FIPS PUB 180-1 también alentó la adopción y uso del SHA-1 por parte de organizaciones privadas y comerciales. El gobierno está dejando de utilizar SHA-1, tal como expone el U.S. National Institute of Standards and Technology, "Las agencias federales '''''deberían''''' dejar de usar el SHA-1 para... aplicaciones que necesiten resistencia de colisión tan pronto como sea posible, y deberán usar familias de funciones hash SHA-2 para estas aplicaciones después de 2010" (énfasis en el original).<ref>National Institute on Standards and Technology Computer Security Resource Center, [http://csrc.nist.gov/groups/ST/hash/policy.html NIST's Policy on Hash Functions] {{Wayback|url=http://csrc.nist.gov/groups/ST/hash/policy.html |date=20110609064344 }}, consultado el 29 de marzo de 2009.</ref>
La directiva de NIST de que las agencias del gobierno estadounidense deban dejar de usar el SHA-1 después de 2010<ref>{{cita web|url=http://csrc.nist.gov/groups/ST/toolkit/secure_hashing.html|título=Secure Hashing - NIST Computer Security Division - Computer Security Resource Center|fechaacceso=25 de noviembre de 2010|obra=[[NIST]]|urlarchivo=https://web.archive.org/web/20110625054822/http://csrc.nist.gov/groups/ST/toolkit/secure_hashing.html|fechaarchivo=25 de junio de 2011}}</ref> y la finalización del SHA-3<ref name="nist.gov"/> deberían acelerar la migración del SHA-1.

Las funciones SHA-2 no son tan ampliamente usadas como SHA-1, a pesar de su mejora en seguridad. Las razones pueden incluir una falta de soporte del SHA-2 en sistemas que ejecutan [[Windows XP]] SP2 o anteriores,<ref>Microsoft Corporation,[http://download.microsoft.com/download/6/8/7/687484ed-8174-496d-8db9-f02b40c12982/Overview%20of%20Windows%20XP%20Service%20Pack%203.pdf Overview of Windows XP Service Pack 3] {{Wayback|url=http://download.microsoft.com/download/6/8/7/687484ed-8174-496d-8db9-f02b40c12982/Overview%20of%20Windows%20XP%20Service%20Pack%203.pdf |date=20090117080827 }}</ref> o por una falta de urgencia percibida mientras no se haya descubierto aún colisiones en el SHA-1.

== Criptoanálisis y validación ==
Para una función en la cual ''L'' es el número de [[bit]]s del [[Función hash criptográfica|mensaje tratado]], encontrar un mensaje que corresponde con el mensaje tratado siempre se puede conseguir empleando una búsqueda de [[ataque de fuerza bruta|fuerza bruta]] con 2<sup>''L''</sup> evaluaciones. A esto se le denomina [[Colisión (hash)|ataque preimagen]] y puede ser práctico o no dependiendo del valor de ''L'' y del entorno de computación empleado. El segundo criterio, encontrar dos mensajes diferentes que producen el mismo mensaje tratado, se le conoce como [[Colisión (hash)|colisión]], requiere únicamente una media de 2<sup>''L''/2</sup> evaluaciones si se emplea un [[ataque de cumpleaños]].

A efectos prácticos, existe una gran preocupación ante este nuevo tipo de ataques ya que podrían permitir el uso de otros más eficientes. Aunque no se hayan visto casos de este tipo, existe una creciente creencia en emplear nuevos algoritmos hash más fuertes. Algunas aplicaciones que emplean sistemas criptográficos hash, por ejemplo para almacenar contraseñas, son mínimamente afectados por un [[Colisión (hash)|ataque de colisión]]. Generar una contraseña que funcione para una cuenta dada requiere un ataque de preimagen, además de acceder al hash de la contraseña original (normalmente en un fichero <tt>[[Autenticación#Shadow_Password|shadow]]</tt>) el cual puede ser o no trivial. Recuperar una contraseña encriptada (p.e, obtener la contraseña para ser usada en otras cuentras del usuario) es imposible mediante ataques. (Sin embargo, incluso empleando un sistema hash seguro no puede impedir ataques de fuerza bruta en [[Contraseña|contraseñas débiles]] (p.e, 1234)).

En el caso de documentos firmados, un atacante no puede simplemente falsificar una firma a partir de un documento existente, el atacante debería generar dos pares de documentos, uno inocuo y otro dañado, y obtener la clave privada del titular para firmar el inocuo documento. Hay situaciones concretas en las que es posible; hasta finales de 2008, fue posible crear un certificado falsificado de
[[Transport Layer Security|SSL]] empleando una colisión de [[MD5]]<ref>Alexander Sotirov, Marc Stevens,
Jacob Appelbaum, Arjen Lenstra, David Molnar, Dag Arne Osvik, Benne de Weger, [http://www.win.tue.nl/hashclash/rogue-ca/ MD5 considered harmful today: Creating a rogue CA certificate], consultado el 29 de marzo de 2009.</ref>

Existen dos [[Colisión (hash)|ataques de preimagen]] [[Ataque_Meet-in-the-middle| por encuentro a medio camino]] contra SHA-2 con los que se reduce el número de iteraciones. El primero de ellos, respecto SHA-256, se resuelve en 41 rondas con respecto a 64 rondas con una complejidad temporal de 2<sup>253.5</sup> y una complejidad espacial de 2<sup>16</sup>; respecto SHA-512, se resuelve en 46 rondas con respecto a 80 rondas con una complejidad temporal de 2<sup>502</sup> y una complejidad espacial de 2<sup>22</sup>.<ref name=preimage-guo>{{Cite journal |author=Jian Guo, Krystian Matusiewicz |date=25 de noviembre de 2008 |title=Preimages for Step-Reduced SHA-2 |url=http://eprint.iacr.org/2009/477.pdf}}</ref>

=== Validación oficial ===
{{Main|CMVP}}
Las implementaciones de todas las funciones de seguridad aprobadas por FIPS son oficialmente validadas mediante un programa CMVP y necesariamente ejecutadas por la [[NIST|Instituto Nacional de Estándares y Tecnología]] (NIST) y la [[Communications Security Establishment]] (CSE). Para una verificación informal, fue dispuesto en la página web del [[NIST]] un paquete para generar un alto número de vectores de prueba; sin embargo, los resultados de verificación no pueden reemplazar de ninguna forma a la validación formal de CMVP, el cual es requerido por ley para ciertas aplicaciones.

== Ejemplos de variantes del SHA-2 ==

Valores hash para una [[cadena de caracteres]] vacía.
 <span style="color: green;">SHA224("")
 0x d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f</span>
 <span style="color: green;">SHA256("")
 0x e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855</span>
 <span style="color: green;">SHA384("")
 0x 38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b</span>
 <span style="color: green;">SHA512("")
 0x cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e</span>
 <span style="color: green;">SHA512/224("")
 0x 6ed0dd02806fa89e25de060c19d3ac86cabb87d6a0ddd05c333b84f4</span>
 <span style="color: green;">SHA512/256("")
 0x c672b8d1ef56ed28ab87c3622c5114069bdd3ad7b8f9737498d0c01ecef0967a</span>

Incluso un pequeño cambio en el mensaje (con una apabullante probabilidad) dará como resultado un hash completamente distinto, debido al [[Función_hash#Continuidad._Efecto_avalancha| efecto avalancha]]. Por ejemplo, añadiendo un punto al final de la frase:
 <span style="color: green;">SHA224("The quick brown fox jumps over the lazy dog")
 0x 730e109bd7a8a32b1cb9d9a09aa2325d2430587ddbc0c38bad911525</span>
 <span style="color: green;">SHA224("The quick brown fox jumps over the lazy dog.")
 0x 619cba8e8e05826e9b8c519c0a5c68f4fb653e8a3d8aa04bb2c8cd4c</span>

 <span style="color: green;">SHA256("The quick brown fox jumps over the lazy dog")
 0x d7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592</span>
 <span style="color: green;">SHA256("The quick brown fox jumps over the lazy dog.")
 0x ef537f25c895bfa782526529a9b63d97aa631564d5d789c2b765448c8635fb6c</span>

 <span style="color: green;">SHA384("The quick brown fox jumps over the lazy dog")
 0x ca737f1014a48f4c0b6dd43cb177b0afd9e5169367544c494011e3317dbf9a509cb1e5dc1e85a941bbee3d7f2afbc9b1</span>
 <span style="color: green;">SHA384("The quick brown fox jumps over the lazy dog.")
 0x ed892481d8272ca6df370bf706e4d7bc1b5739fa2177aae6c50e946678718fc67a7af2819a021c2fc34e91bdb63409d7</span>

 <span style="color: green;">SHA512("The quick brown fox jumps over the lazy dog")
 0x 07e547d9586f6a73f73fbac0435ed76951218fb7d0c8d788a309d785436bbb642e93a252a954f23912547d1e8a3b5ed6e1bfd7097821233fa0538f3db854fee6</span>
 <span style="color: green;">SHA512("The quick brown fox jumps over the lazy dog.")
 0x 91ea1245f20d46ae9a037a989f54f1f790f0a47607eeb8a14d12890cea77a1bbc6c7ed9cf205e67b7f2b8fd4c7dfd3a7a8617e45f3c463d481c7e586c39ac1ed</span>

 <span style="color: green;">SHA512/224("The quick brown fox jumps over the lazy dog")
 0x 944cd2847fb54558d4775db0485a50003111c8e5daa63fe722c6aa37</span>
 <span style="color: green;">SHA512/224("The quick brown fox jumps over the lazy dog.")
 0x 6d6a9279495ec4061769752e7ff9c68b6b0b3c5a281b7917ce0572de</span>

 <span style="color: green;">SHA512/256("The quick brown fox jumps over the lazy dog")
 0x dd9d67b371519c339ed8dbd25af90e976a1eeefd4ad3d889005e532fc5bef04d</span>
 <span style="color: green;">SHA512/256("The quick brown fox jumps over the lazy dog.")
 0x 1546741840f8a492b959d9b8b2344b9b0eb51b004bba35c0aebaac86d45264c3</span>

== Pseudocódigo ==
A continuación un [[pseudocódigo]] para un algoritmo SHA-256. Nótese el gran incremento a la hora de mezclar los bits de la palabra <code>w&#91;16..63&#93;</code> comparada con SHA-1.

 <span style="color: green;">''Nota 1: Todas las variables son enteros sin signo de 32 bits y se emplea módulo 2<sup>32</sup> para su cálculo''</span>
 <span style="color: green;">''Nota 2: Para cada ronda, existe una constante específica k&#91;i&#93; y una entrada en el array del mensaje w&#91;i&#93;, 0 = i = 63''</span>
 <span style="color: green;">''Nota 3: La función de compresión emplea 8 variables de trabajo</span>
 <span style="color: green;">''Nota 4: La convención de Big-endian es usada cuando se expresan las constantes en este pseudocódigo,''</span>
     <span style="color: green;">''y cuando se parsea el bloque de datos del mensaje de bytes a palabras, por ejemplo,''</span>
     <span style="color: green;">''la primera palabra del mensaje de entrada "abc" tras su concatenación es 0x61626380''</span>

 <span style="color:green;">''Inicialización de los valores hash:''</span>
 <span style="color:green;">(primeros 32 bits de la <em>parte decimal</em> de las raíces cuadradas de los primeros números primos del intervalo [2,19]:</span>
 h0 := 0x6a09e667
 h1 := 0xbb67ae85
 h2 := 0x3c6ef372
 h3 := 0xa54ff53a
 h4 := 0x510e527f
 h5 := 0x9b05688c
 h6 := 0x1f83d9ab
 h7 := 0x5be0cd19

 <span style="color:green;">''Inicialización del array con las constantes de las rondas:''</span>
 <span style="color:green;">(primeros 32 bits de la ''parte decimal'' de las raíces cúbicas de los 64 primeros números primos del intervalo [2,311]):</span>
 k&#91;0..63&#93; :=
    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2

 <span style="color:green;">''Preprocesamiento:''</span>
 append the bit '1' to the message
 append k bits '0', where k is the minimum number >= 0 such that the resulting message
     length (módulo 512 in ''bits'') is 448.
 append length of message (before pre-processing), in ''bits'', as 64-bit big-endian integer

 <span style="color:green;">''Procesamiento del mensaje en sucesivos trozos de 512 bits:''</span>
 break message into 512-bit chunks
 '''for''' each chunk
     create a 64-entry message schedule array w&#91;0..63&#93; of 32-bit words
     <span style="color:green;">''(Los valores iniciales de w&#91;0..63&#93; no importan, en muchas implementaciones usan el valor 0)''</span>
     copy chunk into first 16 words w[0..15] of the message schedule array

     <span style="color:green;">''Expansión de las primeras 16 palabras hasta completar las 48 palabras w&#91;16..63&#93; del array del mensaje:''</span>
     '''for''' i '''from''' 16 to 63
         s0 := (w&#91;i-15&#93; '''rightrotate''' 7) '''xor''' (w&#91;i-15&#93; '''rightrotate''' 18) '''xor''' (w&#91;i-15&#93; '''rightshift''' 3)
         s1 := (w&#91;i-2&#93; '''rightrotate''' 17) '''xor''' (w&#91;i-2&#93; '''rightrotate''' 19) '''xor''' (w&#91;i-2&#93; '''rightshift''' 10)
         w&#91;i&#93; := w&#91;i-16&#93; '''+''' s0 '''+''' w&#91;i-7&#93; '''+''' s1

     <span style="color:green;">''Inicialización de las variables de trabajo con los valores hash actuales:''</span>
     a := h0
     b := h1
     c := h2
     d := h3
     e := h4
     f := h5
     g := h6
     h := h7

     <span style="color:green;">''Bucle principal de la función de compresión:''</span>
     '''for''' i '''from''' 0 to 63
         S1 := (e '''rightrotate''' 6) '''xor''' (e '''rightrotate''' 11) '''xor''' (e '''rightrotate''' 25)
         ch := (e '''and''' f) '''xor''' (('''not''' e) '''and''' g)
         temp1 := h '''+''' S1 '''+''' ch '''+''' k&#91;i&#93; '''+''' w&#91;i&#93;
         S0 := (a '''rightrotate''' 2) '''xor''' (a '''rightrotate''' 13) '''xor''' (a '''rightrotate''' 22)
         maj := (a '''and''' b) '''xor''' (a '''and''' c) '''xor''' (b '''and''' c)
         temp2 := S0 '''+''' maj

         h := g
         g := f
         f := e
         e := d '''+''' temp1
         d := c
         c := b
         b := a
         a := temp1 '''+''' temp2

     <span style="color:green;">''Inserción del trozo comprimido al valor hash actual:''</span>
     h0 := h0 '''+''' a
     h1 := h1 '''+''' b
     h2 := h2 '''+''' c
     h3 := h3 '''+''' d
     h4 := h4 '''+''' e
     h5 := h5 '''+''' f
     h6 := h6 '''+''' g
     h7 := h7 '''+''' h

 <span style="color:green;">''Producción del valor final del hash (en formato big-endian):''</span>
 digest := hash := h0 '''append''' h1 '''append''' h2 '''append''' h3 '''append''' h4 '''append''' h5 '''append''' h6 '''append''' h7

La computación de los valores <code>ch</code> y <code>maj</code> puede ser optimizada de la misma forma [[SHA-1#SHA-1 pseudocode|tal como está descrita para SHA-1]].

SHA-224 es idéntico que SHA-256, excepto por:
* los valores iniciales de hash desde <code>h0</code> hasta <code>h7</code> son diferentes, y
* la salida está construida por la omisión de <code>h7</code>.

 <span style="color:green;">Valores hash iniciales para el SHA-224 (en big endian):</span>
 <span style="color:green;">(Los segundos 32 bits de la parte decimal de la raíces cuadradas del noveno al decimosexto número primo del intervalo [23,53]</span>
 h&#91;0..7&#93; :=
     0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4

SHA-512 estructuralmente es idéntico al SHA-256, pero:
* el mensaje es partido en trozos de 1024 bits,
* los valores iniciales del hash y las constantes de las iteraciones son extendidas a 64 bits,
* hay 80 iteraciones en vez de 64,
* las constantes de cada iteración están basadas en los primeros 80 primos del intervalo [2,409],
* el tamaño de palabra usado para los cálculos tiene una longitud de 64 bits,
* la longitud adjunta del mensaje (antes del preprocesado), en ''bits'', es de un entero big-endian de 128 bits, y
* los desplazamientos y rotaciones usadas son distintas.

 <span style="color:green;">Valores hash iniciales para el SHA-512 (en big-endian):</span>
 
 h&#91;0..7&#93; := 0x6a09e667f3bcc908, 0xbb67ae8584caa73b, 0x3c6ef372fe94f82b, 0xa54ff53a5f1d36f1,
            0x510e527fade682d1, 0x9b05688c2b3e6c1f, 0x1f83d9abfb41bd6b, 0x5be0cd19137e2179

 <span style="color:green;">Constantes de cada ronda del SHA-512:</span>
 
 k&#91;0..79&#93; := [ 0x428a2f98d728ae22, 0x7137449123ef65cd, 0xb5c0fbcfec4d3b2f, 0xe9b5dba58189dbbc, 0x3956c25bf348b538,
               0x59f111f1b605d019, 0x923f82a4af194f9b, 0xab1c5ed5da6d8118, 0xd807aa98a3030242, 0x12835b0145706fbe,
               0x243185be4ee4b28c, 0x550c7dc3d5ffb4e2, 0x72be5d74f27b896f, 0x80deb1fe3b1696b1, 0x9bdc06a725c71235,
               0xc19bf174cf692694, 0xe49b69c19ef14ad2, 0xefbe4786384f25e3, 0x0fc19dc68b8cd5b5, 0x240ca1cc77ac9c65,
               0x2de92c6f592b0275, 0x4a7484aa6ea6e483, 0x5cb0a9dcbd41fbd4, 0x76f988da831153b5, 0x983e5152ee66dfab,
               0xa831c66d2db43210, 0xb00327c898fb213f, 0xbf597fc7beef0ee4, 0xc6e00bf33da88fc2, 0xd5a79147930aa725,
               0x06ca6351e003826f, 0x142929670a0e6e70, 0x27b70a8546d22ffc, 0x2e1b21385c26c926, 0x4d2c6dfc5ac42aed,
               0x53380d139d95b3df, 0x650a73548baf63de, 0x766a0abb3c77b2a8, 0x81c2c92e47edaee6, 0x92722c851482353b,
               0xa2bfe8a14cf10364, 0xa81a664bbc423001, 0xc24b8b70d0f89791, 0xc76c51a30654be30, 0xd192e819d6ef5218,
               0xd69906245565a910, 0xf40e35855771202a, 0x106aa07032bbd1b8, 0x19a4c116b8d2d0c8, 0x1e376c085141ab53,
               0x2748774cdf8eeb99, 0x34b0bcb5e19b48a8, 0x391c0cb3c5c95a63, 0x4ed8aa4ae3418acb, 0x5b9cca4f7763e373,
               0x682e6ff3d6b2b8a3, 0x748f82ee5defb2fc, 0x78a5636f43172f60, 0x84c87814a1f0ab72, 0x8cc702081a6439ec,
               0x90befffa23631e28, 0xa4506cebde82bde9, 0xbef9a3f7b2c67915, 0xc67178f2e372532b, 0xca273eceea26619c,
               0xd186b8c721c0c207, 0xeada7dd6cde0eb1e, 0xf57d4f7fee6ed178, 0x06f067aa72176fba, 0x0a637dc5a2c898a6,
               0x113f9804bef90dae, 0x1b710b35131c471b, 0x28db77f523047d84, 0x32caab7b40c72493, 0x3c9ebe0a15c9bebc,
               0x431d67c49c100d4c, 0x4cc5d4becb3e42b6, 0x597f299cfc657e2a, 0x5fcb6fab3ad6faec, 0x6c44198c4a475817]

SHA-384 es idéntico a SHA-512, exceptuando que:
* los valores iniciales del hash desde <code>h0</code> hasta <code>h7</code> son diferentes (son tomados desde el noveno hasta el decimosexto primo), y
* la salida es construida omitiendo <code>h6</code> y <code>h7</code>.
 <span style="color:green;">Valores hash iniciales para SHA-384 (en big-endian):</span>
 
 h&#91;0..7&#93; := 0xcbbb9d5dc1059ed8, 0x629a292a367cd507, 0x9159015a3070dd17, 0x152fecd8f70e5939,
            0x67332667ffc00b31, 0x8eb44a8768581511, 0xdb0c2e0d64f98fa7, 0x47b5481dbefa4fa4

SHA-512/t es idéntico a SHA-512 excepto por:
* los valores iniciales del hash desde <code>h0</code> hasta <code>h7</code> son dados por la ''función de generación IV de SHA-512/t'',
* las salida es construida mediante truncamiento de la concatenación desde <code>h0</code> hasta <code>h7</code> en el ''t'' bit,
* no está permitido que ''t'' sea igual a 384, en su lugar SHA-384 deberá ser usado como está especificado, y
* los valores 224 y 256 para ''t'' están especialmente mencionados como aprobados.

== Implementaciones ==
=== Implementaciones en lenguajes comunes ===

Las funciones hash SHA se pueden encontrar en muchos de los lenguajes de programación modernos, como por ejemplo [[C (lenguaje de programación)|C]], [[C++]], [[C Sharp|C#]], [[Go_(lenguaje_de_programación)|Go]],<ref>{{cita web|url=http://golang.org/src/pkg/crypto/sha256/|título=The Go Programming Language|fechaacceso=4 de febrero de 2013|deadurl=no}}</ref> [[Javascript]], [[Java (programming language)|Java]],<ref>{{cita web|url=https://www.owasp.org/index.php/Hashing_Java#Complete_Java_Sample|título=Hashing Java|fechaacceso=8 de noviembre de 2011|editorial=OWASP}}</ref> [[Python]],<ref>{{cita web|url=http://docs.python.org/library/hashlib.html|título=14.1. hashlib — Secure hashes and message digests — Python v2.7.2 documentation|fechaacceso=8 de noviembre de 2011|editorial=Docs.python.org}}</ref> [[PHP]],<ref>{{cita web|url=http://php.net/manual/en/function.hash.php|título=hash - Manual|fechaacceso=8 de noviembre de 2011|fecha=4 de noviembre de 2011|editorial=PHP}}</ref> [[Perl]],<ref>{{cita web|url=http://search.cpan.org/~mshelor/Digest-SHA-5.62/lib/Digest/SHA.pm|título=Digest::SHA|fechaacceso=8 de noviembre de 2011|editorial=search.cpan.org|urlarchivo=https://web.archive.org/web/20111030081312/http://search.cpan.org/~mshelor/Digest-SHA-5.62/lib/Digest/SHA.pm|fechaarchivo=30 de octubre de 2011}}</ref> y [[Ruby]].<ref>{{cita web|url=http://ruby-doc.org/stdlib-2.0.0/libdoc/digest/rdoc/Digest.html|título=Module: Digest|fechaacceso=14 de octubre de 2013|editorial=Ruby}}</ref>

=== Otras implementaciones ===

<!-- En esta sección deberían incluirse únicamente aquellas implementaciones comercialmente o algoritmicamente significantes, así como aquellas ampliamente utilizadas en tecnologías y plataformas existentes -->

;[[Bouncy Castle]]: La biblioteca Bouncy Castle es una biblioteca gratuita escrita en Java y en C# que contiene implementaciones de los algoritmos SHA-1, SHA-224, SHA-256, SHA-384 y SHA-512, así como de otros algoritmos como [[Whirlpool (cryptography)|Whirlpool]], [[Tiger (hash)|Tiger]], [[RIPEMD]], [[GOST (hash function)|GOST-3411]], [[MD2 (cryptography)|MD2]], [[MD4]] y [[MD5]].
;[[cryptlib]]: Biblioteca con herramientas de seguridad software, siendo esta [[multiplataforma]] y de [[código abierto]].
;[[Crypto++]]: Biblioteca en C++ con esquemas criptográficos e implementaciones de los algoritmos SHA-1, SHA-224, SHA-256, SHA-384 y SHA-512. Es de [[código abierto]] y con una licencia muy permisiva.
;[[jsSHA]]: Biblioteca escrita en [[JavaScript]] para realizar cálculos del tratamiento del SHA en la parte del cliente. Se puede utilizar en varios navegadores webs. jsSHA trabaja con la hipótesis de que [[JavaScript]] no es nativamente soportado para realizar operaciones de 64 bits tal como son requeridas en SHA-384 y SHA-512.
;[[libsparkcrypto]]: Implementación formalmente verificada que es usada ampliamente en algoritmos simétricos criptográficos en el [[lenguaje de programación]] y herramientas del SPARK. Completa la falta de errores en [[tiempo de ejecución]] como violaciones de rango, divisiones por cero y desbordamiento numérico.
;[[LibTomCrypt]]: Conjunto de herramientas portables de criptografía para ISO C. Todas ellas de dominio público.
;[[Libgcrypt]]: Biblioteca de propósito general para la criptografía basada en código de [[GNU Privacy Guard]].
;[[md5deep]]: Conjunto de programas para realizar un tratamiento en mensajes empleando MD5, SHA-1, SHA-256, Tiger, o Whirlpool con un número de arbitrario de ficheros. Suele ser empleada en [[seguridad informática]], administración de sistemas y comunidades de computación forense para ejecutar gran número de ficheros a través de diversos algoritmos criptográficos. Es similar al [[sha1sum]] de [[GNU Core Utilities]] y al [[md5sum]].
;[[OpenSSL]]: La ampliamente usada biblioteca OpenSSL <code>crypto</code> incluye implementaciones de los algoritmos de SHA-1, SHA-224, SHA-256, SHA-384 y SHA-512. Todas ellas son [[free software|libres]] y de [[open source|código abierto]].
;[[Transport_Layer_Security#Bibliotecas|PolarSSL]]: La pequeña biblioteca PolarSSL <code>crypto</code> y <code>SSL</code> incluye implementaciones de [[open source|código abierto]] de los algoritmos de SHA-1, SHA-224, SHA-256, SHA-384 y SHA-512.
;[[sphlib]]: Bliblioteca [[free software|libre]] y de [[open source|código abierto]] que implementa varias funciones hash, incluyendo SHA-1 y SHA-2, ambas portables (pero optimizadas) a C y a Java.
;[[VHDL]]: Colección de implementaciones [[hardware]] de funciones hash (incluyendo SHA-1 y SHA-2) portable (pero optimizada) a VHDL. Es [[free software|libre]] y de [[open source|código abierto]].

== Véase también ==
{{Portal|Criptografía}}
* [[Función hash|Funciones Hash]]
* [[Sellado de tiempo]]
* [[Message authentication code|Hash basado en Message Authentication Code (HMAC) o Keyed Hash]]
* [[Criptografía financiera]]
* Comandos de terminal <tt>[[sha1sum]]</tt> (<tt>sha224sum</tt>, <tt>sha256sum</tt>, <tt>sha384sum</tt> y <tt>sha512sum</tt>)

== Notas ==
* Henri Gilbert, Helena Handschuh: Security Analysis of SHA-256 and Sisters. [[Selected Areas in Cryptography]] 2003: pp.&nbsp;175-193
* {{enlace roto|1={{cite journal|title=Proposed Revision of Federal Information Processing Standard (FIPS) 180, Secure Hash Standard|journal=Federal Register|date=11 de julio de 1994|first=|last=|coauthors=|volume=59|issue=131|pages=35317-35318|id=|url=http://frwebgate1.access.gpo.gov/cgi-bin/waisgate.cgi?WAISdocID=5963452267+0+0+0&WAISaction=retrieve|format=|accessdate=26 de abril de 2007}} |2=http://frwebgate1.access.gpo.gov/cgi-bin/waisgate.cgi?WAISdocID=5963452267+0+0+0&WAISaction=retrieve |bot=InternetArchiveBot }}

== Referencias ==
{{Listaref|2}}

== Enlaces externos ==
<!-- En la versión inglesa de este artículo se sufrió de una excesiva promoción personal en este apartado.
 --- Por favor, no añadan enlaces a su propia página web. Ver https://es.wikipedia.org/wiki/Wikipedia:Conflicto_de_intereses
 --- Serán eliminados y podría ser bloqueado sin previo aviso. -->
* [https://web.archive.org/web/20150209025803/http://csrc.nist.gov/groups/STM/cavp/documents/shs/sha256-384-512.pdf Descripciones del SHA-256, SHA-384 y SHA-512] from [[National Institute of Standards and Technology|NIST]]
* [https://web.archive.org/web/20070113064108/http://csrc.nist.gov/CryptoToolkit/tkhash.html CSRC Herramienta criptográfica], en el sitio oficial del [[National Institute of Standards and Technology|NIST]] para el estándar de Hash seguro
** [http://csrc.nist.gov/publications/fips/fips180-4/fips-180-4.pdf FIPS 180-4: Secure Hash Standard (SHS)] ([[Portable Document Format|PDF]], 1.7 MB), versión actual del estándar de hash seguro (SHA-1, SHA-224, SHA-256, SHA-384 y SHA-512), marzo de 2012
* [https://www.cosic.esat.kuleuven.be/nessie/testvectors/hash/sha/index.html Pruebas vectoriales para SHA-256/384/512] {{Wayback|url=https://www.cosic.esat.kuleuven.be/nessie/testvectors/hash/sha/index.html |date=20141008212302 }} del proyecto [[NESSIE]]
* [http://csrc.nist.gov/groups/STM/cavp/index.html#03 Pruebas vectoriales para SHA-1, SHA-2] del sitio web de [[National Institute of Standards and Technology|NIST]]
* [https://web.archive.org/web/20100505162618/http://csrc.nist.gov/groups/ST/hash/index.html NIST Cryptographic Hash Project] Competición para elegir el algoritmo para SHA-3
* RFC 3874: Funciones Hash unidireccionales de 224 bits: SHA-224.
* RFC 6234: Algoritmos SHA, HMAC y HKDF (ambos últimos basados en SHA). Contiene ejemplos de implementación en lenguaje C.

{{Control de autoridades}}
[[Categoría:Criptografía]]
[[Categoría:Algoritmos de suma de verificación]]
[[Categoría:Funciones hash criptográficas]]