Ver el código de «SHA-1»

{{Ficha de método de cifrado|nombre=SHA-1|diseñador=[[Agencia de Seguridad Nacional]]|publicación=1993 (SHA-0),<br />1995 (SHA-1)|series=([[SHA-0]]), SHA-1, [[SHA-2]], [[SHA-3]]|certificación=[[Federal Information Processing Standard|FIPS]] PUB 180-4, [[CRYPTREC]] (Monitoreado)|longitud clave=160 bits|longitud bloque=512 bits|estructura=[[Construcción Merkle-Damgård]]|rounds=80|criptoanálisis=Un ataque realizado en 2011 por Marc Stevens puede producir colisiones de hash con una complejidad entre 2<sup>60.3</sup> y 2<sup>65.3</sup> operaciones. La primera colisión fue publicada el 23 de febrero de 2017.  SHA-1 es susceptible a los [[ataques de extensión de longitud]].}}

En [[criptografía]], '''SHA-1''' ('''''Secure Hash Algorithm 1''''') es una [[función hash]] que toma una entrada y produce un valor hash de 160 [[Bit|bits]] (20 [[Byte|bytes]]) conocido como [[Función hash criptográfica|resumen de mensaje]], que generalmente se representa como 40 dígitos [[Sistema hexadecimal|hexadecimales]]. Fue diseñado por la [[Agencia de Seguridad Nacional]] de los [[Estados Unidos]] (NSA) y es un [[Federal Information Processing Standard|Estándares Federales de Procesamiento de Información]] de EE. UU.<ref name=":9">{{Cita publicación|url=https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf|título=Secure hash standard|apellidos=|fecha=2015|publicación=National Institute of Standards and Technology (US)|editorial=National Institute of Standards and Technology (U.S.)|número=NIST FIPS 180-4|fechaacceso=2024-10-03|idioma=en|doi=10.6028/nist.fips.180-4|id=Federal Information Processing Standards Publication 180-4|urlarchivo=https://web.archive.org/web/20200107195003/https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf|fechaarchivo=2020-01-07}}</ref> Aunque el algoritmo ha sido roto criptográficamente,<ref name=":0">{{Cita web|url=https://blog.mozilla.org/security/2017/02/23/the-end-of-sha-1-on-the-public-web/|título=The end of SHA-1 on the Public Web|fechaacceso=2024-10-03|apellido=Jones|nombre=J. C.|fecha=2017-02-23|sitioweb=Mozilla Security Blog|idioma=en-US}}</ref><ref name=":5">{{Cita web|url=https://www.schneier.com/blog/archives/2005/02/sha1_broken.html|título=SHA-1 Broken - Schneier on Security|fechaacceso=2024-10-03|sitioweb=www.schneier.com|idioma=en}}</ref><ref name=":1">{{Cita web|url=https://www.ntu.edu.sg/news/detail/critical-flaw-demonstrated-in-common-digital-security-algorithm|título=Critical flaw demonstrated in common digital security algorithm|fechaacceso=2024-10-03|sitioweb=Corporate NTU|editorial=Nanyang Technological University, Singapore|idioma=en}}</ref><ref name=":6">{{Cita web|url=https://www.schneier.com/blog/archives/2005/08/new_cryptanalyt.html|título=New Cryptanalytic Results Against SHA-1 - Schneier on Security|fechaacceso=2024-10-03|sitioweb=www.schneier.com|idioma=en}}</ref><ref name=":2">{{Cita web|url=https://eprint.iacr.org/2020/014.pdf|título=SHA-1 is a Shambles First Chosen-Prefix Collision on SHA-1 and Application to the PGP Web of Trust|autor=Leurent, Gaëtan; Peyrin, Thomas|fecha=2020-01-05|sitioweb=Cryptology ePrint Archive, Report 2020/014|idioma=en}}</ref><ref name=":3">{{Cita web|url=https://venturebeat.com/security/google-will-drop-sha-1-encryption-from-chrome-by-january-1-2017/|título=Google will drop SHA-1 encryption from Chrome by January 1, 2017|fechaacceso=2024-10-03|apellido=Protalinski|nombre=Emil|fecha=2015-12-18|sitioweb=VentureBeat|idioma=en-US}}</ref><ref name=":4">{{Cita web|url=https://sites.google.com/site/itstheshappening/|título=The SHAppening: freestart collisions for SHA-1|autor=Stevens, Marc; Karpman, Pierre; Peyrin, Thomas|idioma=en}}</ref> sigue siendo ampliamente utilizado.

Desde 2005, SHA-1 no se considera seguro frente a adversarios con mayores recursos,<ref>{{Cita web|url=https://www.schneier.com/blog/archives/2005/02/cryptanalysis_o.html|título=Cryptanalysis of SHA-1 - Schneier on Security|fechaacceso=2024-10-03|autor=Schneier, Bruce|fecha=18 de febrero de 2005|sitioweb=www.schneier.com}}</ref> y en 2010, muchas organizaciones recomendaron su sustitución.<ref name=":4" /><ref>{{Cita web|url=https://csrc.nist.gov/projects/hash-functions|título=Hash Functions {{!}} CSRC {{!}} CSRC|fechaacceso=2024-10-03|apellido=Computer Security Division|nombre=Information Technology Laboratory|fecha=2017-01-04|sitioweb=CSRC {{!}} NIST|idioma=EN-US|urlarchivo=https://web.archive.org/web/20110625054822/http://csrc.nist.gov/groups/ST/toolkit/secure_hashing.html|fechaarchivo=2011-06-25}}</ref><ref>{{Cita web|url=https://www.schneier.com/blog/archives/2015/10/sha-1_freestart.html|título=SHA-1 Freestart Collision - Schneier on Security|fechaacceso=2024-10-03|fecha=8 de octubre de 2015|sitioweb=Schneier on Security}}</ref> El [[Instituto Nacional de Estándares y Tecnología]] (NIST) desaconsejó formalmente el uso de SHA-1 en 2011 y prohibió su uso para firmas digitales en 2013, declarando que debería eliminarse completamente para 2030.<ref>{{Cita publicación|url=https://www.nist.gov/news-events/news/2022/12/nist-retires-sha-1-cryptographic-algorithm|título=NIST Retires SHA-1 Cryptographic Algorithm|fecha=2022-12-15|publicación=NIST|fechaacceso=2024-10-03|idioma=en}}</ref> A partir de 2020, los [[Ataque de colisión|ataques de prefijo elegido]] contra SHA-1 son prácticos.<ref name=":1" /><ref name=":2" /> Por lo tanto, se recomienda eliminar SHA-1 de los productos lo antes posible y, en su lugar, utilizar [[SHA-2]] o [[SHA-3]]. La sustitución de SHA-1 es urgente donde se utilice para [[Firma digital|firmas digitales]].

En 2017, los principales [[Navegador web|navegadores web]] dejaron de aceptar [[Certificado de clave pública|certificados SSL]] basados en SHA-1.<ref name=":0" /><ref name=":3" /><ref>{{Cita web|url=https://arstechnica.com/information-technology/2016/05/microsoft-to-retire-support-for-sha1-certificates-in-the-next-4-months/|título=Microsoft to retire support for SHA1 certificates in the next 4 months|fechaacceso=2024-10-03|apellido=Goodin|nombre=Dan|fecha=2016-05-04|sitioweb=Ars Technica|idioma=en-US}}</ref> En febrero de ese mismo año, el [[Centrum Wiskunde & Informatica|CWI]] de [[Ámsterdam]] y [[Google]] anunciaron que habían realizado un [[ataque de colisión]] contra SHA-1, publicando dos archivos PDF diferentes que generaban el mismo hash SHA-1.<ref>{{Cita web|url=https://phys.org/news/2017-02-cwi-google-collision-industry-standard.html|título=CWI, Google announce first collision for Industry Security Standard SHA-1|fechaacceso=2024-10-03|apellido=Slow'|nombre='industry Deprecation Proved To Be Too|sitioweb=phys.org|idioma=en}}</ref><ref name=":7">{{Cita publicación|url=https://link.springer.com/chapter/10.1007/978-3-319-63688-7_19|título=The First Collision for Full SHA-1|apellidos=Stevens|nombre=Marc|apellidos2=Bursztein|nombre2=Elie|fecha=2017|publicación=Advances in Cryptology – CRYPTO 2017|editorial=Springer International Publishing|páginas=570–596|fechaacceso=2024-10-03|apellidos-editor=Katz|nombre-editor=Jonathan|idioma=en|doi=10.1007/978-3-319-63688-7_19|urlarchivo=https://web.archive.org/web/20180515222208/http://shattered.io/eswiki/static/shattered.pdf|isbn=978-3-319-63688-7|fechaarchivo=15 de mayo de 2018|apellidos3=Karpman|nombre3=Pierre|apellidos4=Albertini|nombre4=Ange|apellidos5=Markov|nombre5=Yarik}}</ref><ref name=":8">{{Cita web|url=https://security.googleblog.com/2017/02/announcing-first-sha1-collision.html|título=Announcing the first SHA1 collision|fechaacceso=2024-10-03|autor=Marc Stevens; Elie Bursztein; Pierre Karpman; Ange Albertini; Yarik Markov; Alex Petit Bianco; Clement Baisse|fecha=23 de febrero de 2017|sitioweb=Google Online Security Blog|idioma=en}}</ref> No obstante, SHA-1 sigue siendo seguro para [[HMAC]].<ref>{{Cita publicación|url=https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-57pt1r5.pdf|título=Recommendation for key management:: part 1 - general|apellidos=Barker|nombre=Elaine|fecha=2020-05|publicación=National Institute of Standards and Technology|editorial=|número=NIST SP 800-57pt1r5|fechaacceso=2024-10-03|idioma=en|doi=10.6028/nist.sp.800-57pt1r5}}</ref>

[[Microsoft]] dejó de admitir la firma de código SHA-1 para [[Windows Update]] el 3 de agosto de 2020,<ref>{{Cita web|url=https://techcommunity.microsoft.com/t5/windows-it-pro-blog/sha-1-windows-content-to-be-retired-august-3-2020/ba-p/1544373|título=SHA-1 Windows content to be retired August 3, 2020|fechaacceso=2024-10-03|sitioweb=TECHCOMMUNITY.MICROSOFT.COM|idioma=en}}</ref> lo que también finalizó efectivamente las actualizaciones para versiones de Windows que no se hayan actualizado a SHA-2, como [[Windows 2000]] hasta [[Windows Vista|Vista]], así como versiones de [[Windows Server 2012|Windows Server]] desde [[Windows 2000 Server]] hasta [[Windows Server 2003|Server 2003]].

== Desarrollo ==
[[Archivo:SHA-1.svg|miniaturadeimagen|312x312px|Una iteración dentro de la función de compresión SHA-1:  - A, B, C, D y E son [[Palabra (informática)|palabras]] de 32 bits del estado;  

- ''F'' es una función no lineal que varía;  

- ⋘𝑛 denota una rotación de bits a la izquierda por ''n'' posiciones, donde ''n'' varía en cada operación;  

- W<sub>''t''</sub> es la palabra de mensaje expandida de la ronda ''t'';  

- K<sub>''t''</sub> es la constante de la ronda ''t''; 

-   [[Archivo:Boxplus.png|11x11px]]denota una suma módulo 2<sup>32</sup>.]]
SHA-1 produce un resumen de mensaje basado en principios similares a los usados por [[Ronald Rivest|Ronald L. Rivest]] del [[Instituto de Tecnología de Massachusetts|MIT]] en el diseño de los algoritmos de resumen de mensajes [[MD2]], [[MD4]] y [[MD5]], pero genera un valor hash mayor (160 bits frente a 128 bits).

SHA-1 fue desarrollado como parte del proyecto [[Capstone (criptografía)|Capstone]] del Gobierno de EE. UU.<ref>{{Cita web|url=http://x5.net/faqs/crypto/q150.html|título=Q150: What is Capstone?|fechaacceso=2024-10-03|sitioweb=x5.net}}</ref> La especificación original del algoritmo se publicó en 1993 bajo el título ''Secure Hash Standard'', [[Federal Information Processing Standard|FIPS]] PUB 180, por la agencia de estándares del gobierno de EE. UU., NIST ([[Instituto Nacional de Estándares y Tecnología]]).<ref>{{Cita libro|título=Proceedings of International Conference on Advances in Computing|editorial=Springer-Verlag|fecha=2013|fechaacceso=2024-10-03|isbn=978-81-322-0740-5|serie=Advances in intelligent systems and computing|apellidos=International Conference on Advances in Computing|nombre=Aswatha|apellidos2=Selvarani R|nombre3=T. V. Suresh|apellidos3=Kumar|url=https://books.google.com/books?id=L2OFg7OiV9YC&pg=PA551|idioma=en}}</ref><ref>''Secure Hash Standard, Federal Information Processing Standards Publication FIPS PUB 180'', National Institute of Standards and Technology, 11 de mayo de 1993.</ref> Esta versión ahora suele llamarse ''SHA-0''. Fue retirada por la [[Agencia de Seguridad Nacional|NSA]] poco después de su publicación y fue reemplazada por la versión revisada, publicada en 1995 en FIPS PUB 180-1 y comúnmente denominada ''SHA-1''. SHA-1 difiere de SHA-0 solo por una rotación de bits en la programación de mensajes de su [[función de compresión]]. Según la NSA, esto se hizo para corregir una falla en el algoritmo original que reducía su seguridad criptográfica, pero no proporcionaron más explicaciones.<ref>{{Cita web|url=https://www.federalregister.gov/documents/1994/07/11/94-16666/proposed-revision-of-federal-information-processing-standard-fips-180-secure-hash-standard|título=Proposed Revision of Federal Information Processing Standard (FIPS) 180, Secure Hash Standard|fechaacceso=2024-10-03|fecha=1994-07-11|sitioweb=Federal Register|idioma=en}}</ref><ref>{{Cita web|url=https://crypto.stackexchange.com/questions/62055/where-can-i-find-a-description-of-the-sha-0-hash-algorithm/62071#62071|título=Where can I find a description of the SHA-0 hash algorithm?|fechaacceso=2024-10-03|sitioweb=Cryptography Stack Exchange|idioma=en}}</ref> Las técnicas disponibles públicamente demostraron una vulnerabilidad de SHA-0 en 2004, antes de que se comprometiera SHA-1 en 2017.

== Aplicaciones ==

=== Criptografía ===
{{VT|Función hash criptográfica}}
SHA-1 forma parte de varias aplicaciones y protocolos de seguridad ampliamente utilizados, incluidos [[Seguridad de la capa de transporte|TLS]] y [[Seguridad de la capa de transporte#API de Secure Network Programming|SSL]], [[Pretty Good Privacy|PGP]], [[Secure Shell|SSH]], [[S/MIME]] e [[IPsec]]. Estas aplicaciones también pueden usar [[MD5]]; ambos, MD5 y SHA-1, descienden de [[MD4]].

SHA-1 y SHA-2 son los algoritmos hash requeridos por ley para su uso en ciertas aplicaciones del gobierno de EE. UU., incluidos otros algoritmos y protocolos criptográficos, para la protección de información sensible no clasificada. FIPS PUB 180-1 también alentaba la adopción y uso de SHA-1 por organizaciones privadas y comerciales. SHA-1 está siendo retirado de la mayoría de los usos gubernamentales; el NIST declaró: "Las agencias federales deben dejar de usar SHA-1 para... aplicaciones que requieran resistencia a colisiones tan pronto como sea práctico, y deben usar la familia de funciones hash [[SHA-2]] para estas aplicaciones después de 2010",<ref>{{Cita web|url=https://csrc.nist.gov/Projects/Hash-Functions/NIST-Policy-on-Hash-Functions|título=NIST Policy on Hash Functions - Hash Functions {{!}} CSRC {{!}} CSRC|fechaacceso=2024-10-03|apellido=Computer Security Division|nombre=Information Technology Laboratory|fecha=2017-01-04|sitioweb=CSRC {{!}} NIST|idioma=EN-US}}</ref> aunque más tarde se relajó para permitir el uso de SHA-1 para verificar firmas digitales y sellos de tiempo antiguos.<ref>{{Cita web|url=https://csrc.nist.gov/Projects/Hash-Functions/NIST-Policy-on-Hash-Functions|título=NIST Policy on Hash Functions - Hash Functions {{!}} CSRC {{!}} CSRC|fechaacceso=2024-10-03|apellido=Computer Security Division|nombre=Information Technology Laboratory|fecha=2017-01-04|sitioweb=CSRC {{!}} NIST|idioma=EN-US}}</ref>

Una de las principales motivaciones para la publicación del [[Secure Hash Algorithm|algoritmo de hash seguro]] fue el [[DSA|estándar de firma digital]], en el que se incorpora.

Las funciones hash SHA se han utilizado como base para los [[Cifrado por bloques|cifrados por bloque]] [[SHACAL]].

=== Integridad de los datos ===
Los sistemas de [[Control de versiones|control de revisiones]] como [[Git]], [[Mercurial]] y [[Monotone]] utilizan SHA-1, no por motivos de seguridad, sino para identificar revisiones y asegurar que los datos no han cambiado debido a una corrupción accidental. [[Linus Torvalds]] dijo sobre Git en 2007:<blockquote>Si tienes corrupción en el disco, si tienes corrupción en la [[DRAM]], si tienes algún tipo de problema, [[Git]] lo notará. No es una cuestión de posibilidades, es una garantía. Puedes tener personas que intentan ser maliciosas, pero tendrán éxito. [...] Nadie ha podido romper SHA-1, pero el punto es que SHA-1, en lo que respecta a Git, ni siquiera es una característica de seguridad. Es puramente un chequeo de consistencia. Las partes de seguridad están en otros lugares, por lo que muchas personas asumen que, dado que Git utiliza SHA-1 y SHA-1 se usa para cosas criptográficamente seguras, piensan que, está bien, es una gran característica de seguridad. No tiene nada que ver con la seguridad, es solo el mejor hash que puedes obtener... Te garantizo que, si pones tus datos en Git, puedes confiar en el hecho de que cinco años después, después de haber sido convertidos de tu disco duro a DVD a cualquier nueva tecnología y lo copiaste, cinco años después puedes verificar que los datos que obtienes son exactamente los mismos datos que pusiste. [...] Una de las razones por las que me importa es que, para el kernel, tuvimos una brecha en uno de los sitios de [[BitKeeper]] donde las personas intentaron corromper los repositorios del código fuente del kernel.<ref>{{Obra citada|título=Tech Talk: Linus Torvalds on git|apellidos=Google|url=https://www.youtube.com/watch?v=4XpnKHJAok8&t=56m20s|fechaacceso=2024-10-03|fecha=2007-05-14}}</ref></blockquote>Sin embargo, Git no requiere la [[Ataque de preimage|resistencia al segundo preimagen]] de SHA-1 como una característica de seguridad, ya que siempre preferirá mantener la versión más antigua de un objeto en caso de colisión, evitando que un atacante sobrescriba archivos de manera furtiva.<ref>{{Cita web|url=https://marc.info/?l=git&m=115678778717621&w=2|título='Re: Starting to think about sha-256?' - MARC|fechaacceso=2024-10-03|autor=Torvalds, Linus|sitioweb=marc.info}}</ref> Los ataques conocidos (hasta 2020) tampoco rompen la resistencia al segundo preimagen.<ref>{{Cita web|url=https://gitlab.com/sequoia-pgp/sequoia/-/commit/35119b755db270ab43a8e1ec13577bc0f9846546|título=openpgp: Pass the hash algo's security reqs to Policy::signature. (35119b75) · Commits · sequoia-pgp / sequoia · GitLab|fechaacceso=2024-10-03|fecha=2020-12-11|sitioweb=GitLab|idioma=en}}</ref>

== Criptoanálisis y validación ==
Para una función hash para la cual ''L'' es el número de bits en el resumen del mensaje, encontrar un mensaje que corresponda a un resumen de mensaje dado siempre se puede hacer utilizando una búsqueda de fuerza bruta en aproximadamente 2<sup>''L''</sup> evaluaciones. Esto se llama un [[Ataque de preimage|ataque de preimagen]] y puede ser práctico o no, dependiendo de ''L'' y el entorno computacional particular. Sin embargo, una colisión, que consiste en encontrar dos mensajes diferentes que producen el mismo resumen de mensaje, requiere en promedio solo alrededor de {{Nowrap|1.2 × 2<sup>''L''/2</sup>}} evaluaciones utilizando un [[ataque de cumpleaños]]. Así, la [[Fortaleza de seguridad|fortaleza]] de una función hash se compara generalmente con un cifrador simétrico de la mitad de la longitud del resumen del mensaje. SHA-1, que tiene un resumen de mensaje de 160 bits, se pensaba originalmente que tenía una fuerza de 80 bits.

Algunas de las aplicaciones que utilizan hashes criptográficos, como el almacenamiento de contraseñas, están solo mínimamente afectadas por un ataque de colisión. Construir una contraseña que funcione para una cuenta dada requiere un [[Ataque de preimage|ataque de preimagen]], así como acceso al hash de la contraseña original, que puede o no ser trivial. Invertir la encriptación de contraseñas (por ejemplo, para obtener una contraseña para probar contra la cuenta de un usuario en otro lugar) no es posible por medio de los ataques. Sin embargo, incluso un hash de contraseña seguro no puede prevenir ataques de fuerza bruta en [[Seguridad de la contraseña|contraseñas débiles]].

En el caso de la firma de documentos, un atacante no podría simplemente falsificar una firma de un documento existente: el atacante tendría que producir un par de documentos, uno inocuo y uno dañino, y conseguir que el titular de la clave privada firme el documento inocuo. Hay circunstancias prácticas en las que esto es posible; hasta finales de 2008, era posible crear certificados SSL falsificados utilizando una colisión de [[MD5]].<ref>{{Cita web|url=https://hashclash.win.tue.nl/rogue-ca/|título=MD5 considered harmful today|fechaacceso=2024-10-03|autor=Sotirov, Alexander; Stevens, Marc; Appelbaum, Jacob; Lenstra, Arjen; Molnar, David; Osvik, Dag Arne; de Weger, Benne|fecha=30 de diciembre de 2008|sitioweb=hashclash.win.tue.nl|idioma=en}}</ref>

Debido a la estructura de bloques e iterativa de los algoritmos y la ausencia de pasos finales adicionales, todas las funciones SHA (excepto SHA-3)<ref>{{Cita web|url=https://keccak.team/index.html|título=Strengths of Keccak – Design and security|fechaacceso=2024-10-03|sitioweb=The Keccak sponge function family|editorial=Keccak team|idioma=en|cita=A diferencia de SHA-1 y SHA-2, Keccak no presenta la vulnerabilidad de extensión de longitud, por lo que no requiere la construcción anidada de HMAC. En su lugar, el cálculo de MAC puede realizarse simplemente anteponiendo la clave al mensaje.}}</ref> son vulnerables a [[ataques de extensión de longitud]] y colisión de mensajes parciales.<ref>{{Cita web|url=https://www.schneier.com/books/cryptography-engineering|título=Schneier on Security: : Cryptography Engineering|fechaacceso=2024-10-03|sitioweb=www.schneier.com}}</ref> Estos ataques permiten a un atacante falsificar un mensaje firmado solo por un hash con clave – SHA(mensaje || clave) o SHA(clave || mensaje), extendiendo el mensaje y recalculando el hash sin conocer la clave. Una mejora simple para prevenir estos ataques es hacer hash dos veces: {{Nowrap|1=SHA<sub>d</sub>(''mensaje'') = SHA(SHA(0<sup>''b''</sup> {{!!}} ''message''))}} (la longitud de 0<sup>''b''</sup>, bloque cero, es igual al tamaño del bloque de la función hash).

=== SHA-0 ===
En CRYPTO 98, dos investigadores franceses, [[Florent Chabaud]] y [[Antoine Joux]], presentaron un ataque a SHA-0: se pueden encontrar [[Colisión (hash)|colisiones]] con una complejidad de 2<sup>61</sup>, menos que los  2^80 para una función hash ideal del mismo tamaño.<ref>{{Cita publicación|url=https://link.springer.com/chapter/10.1007/BFb0055720|título=Differential collisions in SHA-0|apellidos=Chabaud|nombre=Florent|apellidos2=Joux|nombre2=Antoine|fecha=1998|publicación=Advances in Cryptology — CRYPTO '98|editorial=Springer|páginas=56–71|fechaacceso=2024-10-03|apellidos-editor=Krawczyk|nombre-editor=Hugo|idioma=en|doi=10.1007/BFb0055720|isbn=978-3-540-68462-6}}</ref>

En 2004, [[Eli Biham|Biham]] y Chen encontraron casi colisiones para SHA-0 – dos mensajes que hash a valores casi iguales; en este caso, 142 de los 160 bits son iguales. También encontraron colisiones completas de SHA-0 reducidas a 62 de sus 80 rondas.<ref>{{Cita web|url=https://www.iacr.org/archive/crypto2004/31520290/biham-chen-sha0-proc-real-one.pdf|título=Near-Collisions of SHA-0|autor=Website. Biham, Eli; Chen, Rafi.|idioma=en}}</ref>

Posteriormente, el 12 de agosto de 2004, se anunció una colisión para el algoritmo completo SHA-0 por Joux, Carribault, Lemuet y Jalby. Esto se logró utilizando una generalización del ataque de Chabaud y Joux. Encontrar la colisión tuvo una complejidad de 2<sup>51</sup> y tomó alrededor de 80,000 horas de procesador en una [[supercomputadora]] con 256 procesadores [[Intel Itanium 2|Itanium 2]] (equivalente a 13 días de uso continuo de la computadora).

El 17 de agosto de 2004, en la Rump Session de CRYPTO 2004, se anunciaron resultados preliminares por [[Wang Xiaoyun|Wang]], Feng, Lai y Yu, sobre un ataque a [[MD5]], SHA-0 y otras funciones hash. La complejidad de su ataque a SHA-0 es de 2<sup>40</sup>, significativamente mejor que el ataque de Joux ''et al''.<ref>{{Cita web|url=http://www.freedom-to-tinker.com/archives/000664.html|título=Report from Crypto 2004|idioma=en|urlarchivo=https://web.archive.org/web/20040821031401/http://www.freedom-to-tinker.com/archives/000664.html|fechaarchivo=2004-08-21|urlmuerta=sí}}</ref><ref>{{Cita noticia|título=Re: Any advance news from the crypto rump session?|url=news:fgrieu-05A994.05060218082004@individual.net|fecha=18 de agosto de 2004}}</ref>

En febrero de 2005, se anunció un ataque de [[Xiaoyun Wang]], [[Yiqun Lisa Yin]] y Hongbo Yu que podría encontrar colisiones en SHA-0 en 2<sup>39</sup> operaciones.<ref name=":5" /><ref>{{Cita web|url=http://www.infosec.sdu.edu.cn/paper/sha0-crypto-author-new.pdf|título=Efficient Collision Search Attacks on SHA-0|sitioweb=Shandong University|idioma=en|urlarchivo=https://web.archive.org/web/20050910132832/http://www.infosec.sdu.edu.cn/paper/sha0-crypto-author-new.pdf|fechaarchivo=2005-09-10}}</ref>

Otro ataque en 2008 aplicando el [[Ataque de Boomerang|ataque de boomerang]] redujo la complejidad de encontrar colisiones a 2<sup>33.6</sup>, lo que se estimó que tomaría 1 hora en una PC promedio del año 2008.<ref>{{Cita publicación|url=https://link.springer.com/chapter/10.1007/978-3-540-71039-4_2|título=Collisions on SHA-0 in One Hour|apellidos=Manuel|nombre=Stéphane|apellidos2=Peyrin|nombre2=Thomas|fecha=2008|publicación=Fast Software Encryption|editorial=Springer|páginas=16–35|fechaacceso=2024-10-03|apellidos-editor=Nyberg|nombre-editor=Kaisa|idioma=en|doi=10.1007/978-3-540-71039-4_2|isbn=978-3-540-71039-4}}</ref>

A la luz de los resultados de SHA-0, algunos expertos sugirieron que se reconsideraran los planes para el uso de SHA-1 en nuevos [[Criptosistema|sistemas criptográficos]]. Después de la publicación de los resultados de CRYPTO 2004, el NIST anunció que planeaba eliminar el uso de SHA-1 para 2010 en favor de las variantes SHA-2.<ref>{{Cita web|url=https://csrc.nist.gov/News/2004/NIST-Brief-Comments-on-Recent-Cryptanalytic-Attack|título=NIST Brief Comments on Recent Cryptanalytic Attacks on Secure Hashing Functions and the Continued Security Provided by SHA-1|fecha=23 de agosto de 2017|idioma=en}}</ref>

=== Ataques ===
A principios de 2005, [[Vincent Rijmen]] y [[Elisabeth Oswald]] publicaron un ataque a una versión reducida de SHA-1 – 53 de 80 rondas – que encuentra colisiones con un esfuerzo computacional de menos de 2<sup>80</sup> operaciones.<ref>{{Cita publicación|url=http://eprint.iacr.org/2005/010|título=Update on SHA-1|apellidos=Rijmen|nombre=Vincent|apellidos2=Oswald|nombre2=Elisabeth|fecha=2005|publicación=Cryptology ePrint Archive|idioma=en}}</ref>

En febrero de 2005, se anunció un ataque de Xiaoyun Wang, Yiqun Lisa Yin y Hongbo Yu.<ref name=":5" /> Los ataques pueden encontrar colisiones en la versión completa de SHA-1, requiriendo menos de 2<sup>69</sup> operaciones. (Una [[búsqueda de fuerza bruta]] requeriría 2<sup>80</sup> operaciones).

Los autores escriben: "En particular, nuestro análisis se basa en el ataque diferencial original a SHA-0, el ataque de casi colisión a SHA-0, las técnicas de colisión multibloque, así como las técnicas de modificación de mensajes utilizadas en el ataque de búsqueda de colisión en MD5. Romper SHA-1 no sería posible sin estas poderosas técnicas analíticas".<ref>{{Cita web|url=http://theory.csail.mit.edu/~yiqun/shanote.pdf|título=Collision Search Attacks on SHA1|sitioweb=Massachusetts Institute of Technology|idioma=en|urlarchivo=https://web.archive.org/web/20050219180957/http://theory.csail.mit.edu/~yiqun/shanote.pdf|fechaarchivo=2005-02-19}}</ref> Los autores han presentado una colisión para SHA-1 de 58 rondas, encontrada con 2<sup>33</sup> operaciones hash. El artículo con la descripción completa del ataque se publicó en agosto de 2005 en la conferencia CRYPTO.

En una entrevista, Yin declara que, "En términos generales, explotamos las siguientes dos debilidades: Una es que el paso de preprocesamiento de archivos no es lo suficientemente complicado; otra es que ciertas operaciones matemáticas en las primeras 20 rondas tienen problemas de seguridad inesperados".<ref>{{Cita web|url=https://www.zdnet.com/article/fixing-a-hole-in-security/|título=Fixing a hole in security|fechaacceso=2024-10-03|sitioweb=ZDNET|idioma=en}}</ref>

El 17 de agosto de 2005, se anunció una mejora al ataque de SHA-1 en nombre de [[Xiaoyun Wang]], [[Andrew Chi-Chih Yao|Andrew Yao]] y [[Frances Yao]] en la Rump Session de CRYPTO 2005, reduciendo la complejidad requerida para encontrar una colisión en SHA-1 a 2<sup>63</sup>.<ref name=":6" /> El 18 de diciembre de 2007 se explicaron y verificaron los detalles de este resultado por Martin Cochran.<ref>{{Cita publicación|url=http://eprint.iacr.org/2007/474|título=Notes on the Wang et al. 2<sup>63</sup> SHA-1 Differential Path|apellidos=Cochran|nombre=Martin|fecha=2007|publicación=Cryptology ePrint Archive|idioma=en}}</ref>

Christophe De Cannière y Christian Rechberger mejoraron aún más el ataque a SHA-1 en ''Finding SHA-1 Characteristics: General Results and Applications'', recibiendo el Best Paper Award en [[ASIACRYPT]] 2006. Se presentó una colisión de dos bloques para SHA-1 de 64 rondas, encontrada utilizando métodos no optimizados con 2<sup>35</sup> evaluaciones de función de compresión. Dado que este ataque requiere el equivalente a aproximadamente 2<sup>35</sup> evaluaciones, se considera un quiebre teórico significativo.<ref>{{Cita web|url=http://www.iaik.tugraz.at/content/research/krypto/sha1/SHA1Collision_Description.php|título=IAIK Krypto Group&nbsp;— Description of SHA-1 Collision Search Project|idioma=en|urlarchivo=https://web.archive.org/web/20130115071715/http://www.iaik.tugraz.at/content/research/krypto/sha1/SHA1Collision_Description.php|fechaarchivo=2013-01-15|urlmuerta=sí}}</ref> Su ataque se extendió aún más a 73 rondas (de 80) en 2010 por Grechnikov.<ref>{{Cita web|url=http://eprint.iacr.org/2010/413|título=Collisions for 72-step and 73-step SHA-1: Improvements in the Method of Characteristics|idioma=en}}</ref>Para encontrar una colisión real en las 80 rondas completas de la función hash, se requieren cantidades enormes de tiempo de computación. Con este fin, una búsqueda de colisiones para SHA-1 utilizando la plataforma de computación voluntaria [[Berkeley Open Infrastructure for Network Computing|BOINC]] comenzó el 8 de agosto de 2007, organizada por la [[Universidad Técnica de Graz|Universidad Tecnológica de Graz]]. El esfuerzo fue abandonado el 12 de mayo de 2009 debido a la falta de progreso.<ref>{{Cita web|url=http://boinc.iaik.tugraz.at/sha1_coll_search/|título=SHA-1 Collision Search Graz|idioma=en|urlarchivo=https://web.archive.org/web/20090225115007/http://boinc.iaik.tugraz.at/sha1_coll_search/|fechaarchivo=2009-02-25|urlmuerta=sí}}</ref>

En la sesión Rump de CRYPTO 2006, Christian Rechberger y Christophe De Cannière afirmaron haber descubierto un ataque de colisión en SHA-1 que permitiría a un atacante seleccionar al menos partes del mensaje.<ref>{{Cita web|url=https://www.heise.de/|título=heise online - IT-News, Nachrichten und Hintergründe|fechaacceso=2024-10-03|fecha=2024-10-03|sitioweb=heise online|idioma=de}}</ref><ref>{{Cita web|url=https://www.iacr.org/conferences/crypto2006/rumpsched.html|título=Crypto 2006 Rump Schedule|fechaacceso=2024-10-03|sitioweb=www.iacr.org}}</ref>

En 2008, una metodología de ataque presentada por Stéphane Manuel reportó colisiones de hash con una complejidad teórica estimada de 2<sup>51</sup> a 2<sup>57</sup> operaciones.<ref>{{Cita web|url=http://eprint.iacr.org/2008/469.pdf|título=Classification and Generation of Disturbance Vectors for Collision Attacks against SHA-1|apellido=Manuel|nombre=Stéphane|sitioweb=Cryptology ePrint Archive|idioma=en}}</ref> Sin embargo, luego retractó esa afirmación tras descubrir que las trayectorias de colisión local no eran realmente independientes, y finalmente citó un vector de colisión eficiente que ya era conocido antes de este trabajo.<ref>{{Cita publicación|url=https://link.springer.com/article/10.1007/s10623-010-9458-9|título=Classification and generation of disturbance vectors for collision attacks against SHA-1|apellidos=Manuel|nombre=Stéphane|fecha=2011-04-01|publicación=Designs, Codes and Cryptography|volumen=59|número=1|páginas=247–263|fechaacceso=2024-10-03|idioma=en|issn=1573-7586|doi=10.1007/s10623-010-9458-9}}</ref>

Cameron McDonald, Philip Hawkes y Josef Pieprzyk presentaron un ataque de colisión de hash con una complejidad estimada de 2<sup>52</sup> en la sesión Rump de Eurocrypt 2009.<ref>{{Cita web|url=http://eurocrypt2009rump.cr.yp.to/837a0a8086fa6ca714249409ddfae43d.pdf|título=SHA-1 collisions now 2^52|idioma=en}}</ref> Sin embargo, el artículo correspondiente, "Differential Path for SHA-1 with complexity O(2<sup>52</sup>)", fue retirado debido a que los autores descubrieron que su estimación era incorrecta.<ref>{{Cita publicación|url=http://eprint.iacr.org/2009/259|título=Differential Path for SHA-1 with complexity O(<sup>252</sup>)|apellidos=McDonald|nombre=Cameron|apellidos2=Hawkes|nombre2=Philip|fecha=2009|publicación=Cryptology ePrint Archive|idioma=en|apellidos3=Pieprzyk|nombre3=Josef}}</ref>

Uno de los ataques contra SHA-1 fue desarrollado por Marc Stevens,<ref>{{Cita web|url=http://2012.sharcs.org/slides/stevens.pdf|título=Cryptanalysis of MD5 & SHA-1|idioma=en}}</ref> quien estimó un costo de $2.77 millones (en 2012) para romper un solo valor de hash alquilando poder de procesamiento en servidores en la nube.<ref>{{Cita web|url=https://www.schneier.com/blog/archives/2012/10/when_will_we_se.html|título=When Will We See Collisions for SHA-1? - Schneier on Security|fechaacceso=2024-10-03|sitioweb=www.schneier.com}}</ref> Stevens desarrolló este ataque en un proyecto llamado HashClash,<ref>{{Cita web|url=https://code.google.com/archive/p/hashclash|título=Google Code Archive - Long-term storage for Google Code Project Hosting.|fechaacceso=2024-10-03|sitioweb=code.google.com}}</ref> implementando un ataque de trayectoria diferencial. El 8 de noviembre de 2010, afirmó haber implementado completamente un ataque de casi colisión contra SHA-1 completo, con una complejidad estimada equivalente a 2<sup>57.5</sup> compresiones SHA-1. Estimó que este ataque podría extenderse a una colisión completa con una complejidad de alrededor de 2<sup>61</sup>.

==== ''The SHAppening'' ====
El 8 de octubre de 2015, Marc Stevens, Pierre Karpman y Thomas Peyrin publicaron un ataque de colisión freestart contra la función de compresión de SHA-1 que requiere solo 2<sup>57</sup> evaluaciones de SHA-1. Esto no se traduce directamente en una colisión en la función hash SHA-1 completa (donde un atacante no puede elegir libremente el estado interno inicial), pero socava las afirmaciones de seguridad para SHA-1. En particular, fue la primera vez que se ''demostró'' un ataque contra SHA-1 completo; todos los ataques anteriores eran demasiado costosos para ser llevados a cabo. Los autores denominaron a este avance en la [[criptoanálisis]] de SHA-1 ''The SHAppening''.<ref name=":4" />

El método se basó en su trabajo anterior, así como en las trayectorias auxiliares (o boomerangs) para acelerar la técnica de Joux y Peyrin, utilizando tarjetas GPU de [[Nvidia]] de alto rendimiento y costo eficiente. La colisión fue encontrada en un clúster de 16 nodos con un total de 64 tarjetas gráficas. Los autores estimaron que una colisión similar podría encontrarse alquilando US$2,000 de tiempo de GPU en [[Amazon EC2|EC2]].<ref name=":4" />

Los autores estimaron que el costo de alquilar suficiente tiempo de CPU/GPU en EC2 para generar una colisión completa de SHA-1 en el momento de la publicación oscilaba entre US$75K y $120K, y señalaron que eso estaba bien dentro del presupuesto de organizaciones criminales, sin mencionar las [[Servicio de inteligencia|agencias de inteligencia]] nacionales. Por lo tanto, los autores recomendaron que SHA-1 fuera depreciado lo más pronto posible.<ref name=":4" />

==== ''SHAttered'' – primera colisión pública ====
El 23 de febrero de 2017, el [[Centrum Wiskunde & Informatica|CWI (Centrum Wiskunde & Informatica)]] y [[Google]] anunciaron el ataque ''SHAttered'', en el cual generaron dos archivos PDF diferentes con el mismo hash SHA-1 en aproximadamente 2<sup>63.1</sup> evaluaciones de SHA-1. Este ataque es aproximadamente 100,000 veces más rápido que forzar una colisión de SHA-1 mediante un [[ataque de cumpleaños]], que se estimaba tomaría 2<sup>80</sup> evaluaciones de SHA-1. El ataque requirió "el poder de procesamiento equivalente a 6,500 años de cálculos en una sola CPU y 110 años en una sola GPU".<ref name=":7" /><ref name=":8" />

'''''Birthday-Near-Collision Attack'' – primer ataque práctico de prefijo elegido'''

El 24 de abril de 2019, un artículo de Gaëtan Leurent y Thomas Peyrin presentado en Eurocrypt 2019 describió una mejora del [[Ataque de colisión#Ataque de colisión de prefijo determinado|ataque de prefijo determinado]] en funciones de digestión tipo [[Construcción Merkle-Damgård|Merkle-Damgård]] basadas en cifrados de bloque Davies-Meyer. Con estas mejoras, el método es capaz de encontrar colisiones de prefijo determinado en aproximadamente 2<sup>68</sup> evaluaciones de SHA-1. Esto es aproximadamente 1,000 millones de veces más rápido (y ahora utilizable para muchos ataques dirigidos, gracias a la posibilidad de elegir un prefijo, por ejemplo, código malicioso o identidades falsificadas en certificados firmados) que el ataque anterior con 2<sup>77.1</sup> evaluaciones (pero sin prefijo determinado, lo que lo hacía impráctico para la mayoría de ataques dirigidos debido a que las colisiones encontradas eran casi aleatorias)<ref>{{Cita publicación|url=https://marc-stevens.nl/research/papers/PhD%20Thesis%20Marc%20Stevens%20-%20Attacks%20on%20Hash%20Functions%20and%20Applications.pdf|título=Attacks on Hash Functions and Applications|apellidos=Stevens|nombre=Marc|fecha=19 de junio de 2012|publicación=Leiden University|oclc=795702954|isbn=9789461913173}}</ref> y es lo suficientemente rápido como para ser práctico para atacantes con recursos, requiriendo aproximadamente $100,000 en procesamiento en la nube. Este método también es capaz de encontrar colisiones de prefijo elegido en la función [[MD5]], pero con una complejidad de 2<sup>46.3</sup> no supera el mejor método disponible anteriormente a nivel teórico (2<sup>39</sup>), aunque potencialmente a nivel práctico (≤2<sup>49</sup>).<ref>{{Cita publicación|url=https://link.springer.com/chapter/10.1007/978-3-030-17659-4_18|título=From Collisions to Chosen-Prefix Collisions Application to Full SHA-1|apellidos=Leurent|nombre=Gaëtan|apellidos2=Peyrin|nombre2=Thomas|fecha=2019|publicación=Advances in Cryptology – EUROCRYPT 2019|editorial=Springer International Publishing|páginas=527–555|fechaacceso=2024-10-03|apellidos-editor=Ishai|nombre-editor=Yuval|idioma=en|doi=10.1007/978-3-030-17659-4_18|isbn=978-3-030-17659-4}}</ref> Este ataque tiene un requisito de memoria de más de 500 GB.

El 5 de enero de 2020, los autores publicaron un ataque mejorado llamado "shambles".<ref>{{Cita web|url=https://eprint.iacr.org/2020/014.pdf|título=SHA-1 is a Shambles First Chosen-Prefix Collision on SHA-1 and Application to the PGP Web of Trust|autor=Leurent, Gaëtan; Peyrin, Thomas|fecha=2020-01-05|sitioweb=Cryptology ePrint Archive, Report 2020/014}}</ref> En este artículo demuestran un ataque de colisión de prefijo elegido con una complejidad de 2<sup>63.4</sup>, que en el momento de la publicación costaría US$45K por colisión generada.

=== Validación oficial ===
Las implementaciones de todas las funciones de seguridad aprobadas por FIPS pueden ser validadas oficialmente a través del [[Cryptographic Module Validation Program|programa CMVP]], gestionado conjuntamente por el [[Instituto Nacional de Estándares y Tecnología]] (NIST) y el [[Communications Security Establishment|Centro de Seguridad de las Comunicaciones]] (CSE). Para la verificación informal, se pone a disposición un paquete para generar un gran número de vectores de prueba en el sitio del NIST; sin embargo, esta verificación no reemplaza la validación formal del CMVP, que es requerida por ley para ciertas aplicaciones.

A diciembre de 2013, hay más de 2000 implementaciones validadas de SHA-1, con 14 de ellas capaces de manejar mensajes con una longitud en bits no múltiplo de ocho.<ref>{{Cita web|url=http://csrc.nist.gov/groups/STM/cavp/documents/shs/shaval.htm|título=SHS Validation List|idioma=en|urlarchivo=https://web.archive.org/web/20110823092514/http://csrc.nist.gov/groups/STM/cavp/documents/shs/shaval.htm|fechaarchivo=2011-08-23}}</ref>

== Ejemplos y pseudocódigo ==

=== Ejemplos de hashes ===
A continuación, se muestran ejemplos [[Función hash criptográfica|resumen de mensajes]] de SHA-1 en codificación hexadecimal y en codificación [[Base64]] (de binario a [[ASCII]]).

* <code>SHA1("The quick brown fox jumps over the lazy '''d'''og")</code>
** Salida en hexadecimal: <code>2fd4e1c67a2d28fced849ee1bb76e7391b93eb12</code>
** Codificación binaria [[Base64]] a texto [[ASCII]] generada: <code>L9ThxnotKPzthJ7hu3bnORuT6xI=</code>

Incluso un pequeño cambio en el mensaje, con una probabilidad abrumadora, resultará en el cambio de muchos bits debido al [[efecto avalancha]]. Por ejemplo, cambiar <code>dog</code> por <code>cog</code> produce un hash con valores diferentes en 81 de los 160 bits:

* <code>SHA1("The quick brown fox jumps over the lazy '''c'''og")</code>
** Salida en hexadecimal: <code>de9f2c7fd25e1b3afad3e85a0bd17d9b100db4b3</code>
** Codificación binaria [[Base64]] a texto [[ASCII]] generada: <code>3p8sf9JeGzr60+haC9F9mxANtLM=</code>

El hash de la cadena de longitud cero es:

* <code>SHA1("")</code>
** Salida en hexadecimal: <code>da39a3ee5e6b4b0d3255bfef95601890afd80709</code>
** Codificación binaria [[Base64]] a texto [[ASCII]] generada: <code>2jmj7l5rSw0yVb/vlWAYkK/YBwk=</code>

=== Pseudocódigo para SHA-1 ===
[[Pseudocódigo]] para el algoritmo SHA-1:
 <span style="color: green;">''Note 1: Todas las variables son cantidades sin signo de 32 bits y se envuelven en el módulo 2<sup>32</sup> durante los cálculos, excepto por los siguientes:''</span>

         <span style="color: green;">''ml, longitud del mensaje, which is a 64-bit quantity, and''</span>
         <span style="color: green;">''hh, resumen del mensa, que es una cantidad de 160 bits.''</span>
 <span style="color: green;">''Note 2: Todas las constantes en este pseudocódigo están en [[Endianness|big endian]].''</span>
         <span style="color: green;">''Dentro de cada palabra, el byte más significativo se almacena en la posición de byte más a la izquierda.''</span> 
 
 <span style="color: green;">''Inicializar variables:''</span>
 
 h0 = 0x67452301
 h1 = 0xEFCDAB89
 h2 = 0x98BADCFE
 h3 = 0x10325476
 h4 = 0xC3D2E1F0
 
 ml = longitud del mensaje en bits (siempre un múltiplo del número de bits en un carácter).

 <span style="color: green;">''Preprocesamiento:''</span>
 agregar el bit '1' al mensaje, por ejemplo, agregar 0x80 si la longitud del mensaje es un múltiplo de 8 bits.
 añadir entre 0 ≤ k &#x3C; 512 bits de '0', de manera que la longitud resultante del mensaje sea [[Congruencia (teoría de números)|congruente]] a -64 ≡ 448 (mod 512)
 añadir ml, la longitud original de mensaje en bits, como un entero de 64 bits en big endian.
    Así, la longitud total es un múltiplo de 512 bits.
 
 <span style="color: green;">''Procesar el mensaje en bloques sucesivos de 512-bits:''</span>
 dividir el mensaje en bloques de 512 bits
 '''para''' cada bloque
     dividir el bloque en dieciséis palabras de 32 bits en ''bid endian''  w[i], 0 ≤ i ≤ 15
 
     <span style="color: green;">''Programar el mensaje: extender las dieciséis palabras de 32 bits en ochenta palabras de 32 bits:''</span>
     '''Para''' i '''desde''' 16 hasta 79
 <span style="color: green;">''Nota 3: SHA-0 se diferencia por no tener esta rotación a la izquierda.''</span>
         w[i] = (w[i-3] '''xor''' w[i-8] '''xor''' w[i-14] '''xor''' w[i-16]) '''leftrotate''' 1
 
     <span style="color: green;">''Inicializar el valor de hash para este bloque:''</span>
     a = h0
     b = h1
     c = h2
     d = h3
     e = h4
 
     <span style="color: green;">''Bucle principal:''</span><ref name=":9" /><ref>{{Cita web|url=http://www.faqs.org/rfcs/rfc3174.html|título=RFC 3174 - US Secure Hash Algorithm 1 (SHA1) (RFC3174)|fechaacceso=2024-10-05|sitioweb=www.faqs.org|idioma=en}}</ref>
     '''Para''' i '''desde''' 0 '''hasta''' 79
         '''if''' 0 ≤ i ≤ 19 '''then'''
             f = (b '''and''' c) '''or''' (('''not''' b) '''and''' d)
             k = 0x5A827999
         '''else if''' 20 ≤ i ≤ 39
             f = b '''xor''' c '''xor''' d
             k = 0x6ED9EBA1
         '''else if''' 40 ≤ i ≤ 59
             f = (b '''and''' c) '''or''' (b '''and''' d) '''or''' (c '''and''' d) 
             k = 0x8F1BBCDC
         '''else if''' 60 ≤ i ≤ 79
             f = b '''xor''' c '''xor''' d
             k = 0xCA62C1D6
 
         temp = (a '''leftrotate''' 5) + f + e + k + w[i]
         e = d
         d = c
         c = b '''leftrotate''' 30
         b = a
         a = temp
 
     <span style="color: green;">''Sumar el hash de este bloque al resultado hasta el momento:''</span>
     h0 = h0 + a
     h1 = h1 + b 
     h2 = h2 + c
     h3 = h3 + d
     h4 = h4 + e
 
 <span style="color:green;">''Generar el valor final del hash (big endian) como el número de 160 bits:''</span>
 hh = (h0 '''leftshift''' 128) '''or''' (h1 '''leftshift''' 96) '''or''' (h2 '''leftshift''' 64) '''or''' (h3 '''leftshift''' 32) '''or''' h4
El número <code>hh</code> es el resumen del mensaje, que puede escribirse en hexadecimal digest (base 16).

Los valores constantes empleados en el algoritmo se asumieron como [[números sin-nada-sacado-de-la-manga]]:

* Las cuatro constantes de ronda <code>k</code> son 2<sup>30</sup> multiplicado por las raíces cuadradas de 2, 3, 5 y 10. Sin embargo, se redondearon incorrectamente al entero más cercano en lugar de redondearse al entero impar más cercano, con proporciones equilibradas de bits cero y uno. Además, elegir la raíz cuadrada de 10 (que no es un número primo) la convirtió en un factor común para las otras dos raíces cuadradas elegidas de los primos 2 y 5, con posibles propiedades aritméticas utilizables en rondas sucesivas, lo que redujo la fuerza del algoritmo contra la detección de colisiones en algunos bits.
* Los primeros cuatro valores iniciales para <code>h0</code> a <code>h3</code> son los mismos que en el algoritmo MD5, y el quinto (para <code>h4</code>) es similar. Sin embargo, no fueron verificados adecuadamente para resistir la inversión de las primeras rondas con el fin de inferir posibles colisiones en algunos bits, lo cual es utilizable en ataques diferenciales multibloque.

En lugar de la formulación del FIPS PUB 180-1 original mostrada, se pueden usar las siguientes expresiones equivalentes para calcular <code>f</code> en el bucle principal mencionado arriba:
 <span style="color: green;">''Selección a nivel de bits entre'' c y d'', controlada por'' b''.''</span>
 (0  ≤ i ≤ 19): f = d '''xor''' (b '''and''' (c '''xor''' d))                <span style="color: green;">''(alternativa 1)''</span>
 (0  ≤ i ≤ 19): f = (b '''and''' c) '''or''' (('''not''' b) '''and''' d)           <span style="color: green;">''(alternativa 2)''</span>
 (0  ≤ i ≤ 19): f = (b '''and''' c) '''xor''' (('''not''' b) '''and''' d)          <span style="color: green;">''(alternativa 3)''</span>
 (0  ≤ i ≤ 19): f = vec_sel(d, c, b)                       <span style="color: green;">''(alternativa 4)''</span>
 &nbsp;[premo08]
 <span style="color: green;">''Función mayoritaria a nivel de bits.''</span>
 (40 ≤ i ≤ 59): f = (b '''and''' c) '''or''' (d '''and''' (b '''or''' c))          <span style="color: green;">''(alternativa 1)''</span>
 (40 ≤ i ≤ 59): f = (b '''and''' c) '''or''' (d '''and''' (b '''xor''' c))         <span style="color: green;">''(alternativa 2)''</span>
 (40 ≤ i ≤ 59): f = (b '''and''' c) '''xor''' (d '''and''' (b '''xor''' c))        <span style="color: green;">''(alternativa 3)''</span>
 (40 ≤ i ≤ 59): f = (b '''and''' c) '''xor''' (b '''and''' d) '''xor''' (c '''and''' d)  <span style="color: green;">''(alternativa 4)''</span>
 (40 ≤ i ≤ 59): f = vec_sel(c, b, c '''xor''' d)                 <span style="color: green;">''(alternativa 5)''</span>
También se demostró que para las rondas 32-79, el cálculo de:<ref>{{Cita web|url=https://www.intel.com/content/www/us/en/developer/articles/technical/improving-the-performance-of-the-secure-hash-algorithm-1.html|título=Improving the Performance of the Secure Hash Algorithm (SHA-1)|fechaacceso=2024-10-05|apellido=Loktyukhin|nombre=Maxim|sitioweb=Intel|idioma=en}}</ref>
 w[i] = (w[i-3] '''xor''' w[i-8] '''xor''' w[i-14] '''xor''' w[i-16]) '''leftrotate''' 1
puede ser reemplazado de la siguiente manera:
 w[i] = (w[i-6] '''xor''' w[i-16] '''xor''' w[i-28] '''xor''' w[i-32]) '''leftrotate''' 2
Esta transformación mantiene todos los operandos de 64 bits y, al eliminar la dependencia de   <code>w[i]</code> en <code>w[i-3]</code>, permite la implementación eficiente SIMD que usa una longitud de vector de 4, como en las instrucciones [[SSE]] de x86.

== Comparación de funciones SHA ==
En la siguiente tabla, el ''estado interno'' se refiere a la «suma interna hash» después de cada compresión de un bloque de datos.<ref>La siguiente table fue extraída del artículo [[Secure Hash Algorithm#Comparación de funciones SHA|Secure Hash Algorithm]].</ref>
{| class="wikitable"
|+Comparación de funciones SHA<ref>{{Cita publicación|url=http://bench.cr.yp.to/results-hash.html#amd64-skylake|título=Resultados-hash: amd64-skylake|apellidos=|nombre=|fecha=2020-12-21|publicación=Wikipedia|fechaacceso=2020-12-31|idioma=en|doi=|pmid=}}</ref>
! colspan="2" rowspan="2" |Algoritmo y variante
! rowspan="2" |Tamaño de salida
(bits)
! rowspan="2" |Tamaño del estado interno
(bits)
! rowspan="2" |Tamaño de bloque
(bits)
! rowspan="2" |Rondas
! rowspan="2" |Operaciones
! rowspan="2" |Seguridad contra [[Ataque de colisión|ataques de colisión]]
(bits)
! rowspan="2" |Capacidad
contrataques de extensión de longitud

(bits)
! colspan="2" |Rendimiento en [[Skylake (microarquitectura)|Skylake]] (cpb mediano)<ref>{{Cita web|url=http://bench.cr.yp.to/results-hash.html#amd64-skylake|título=Measurements table|sitioweb=bench.cr.yp.to.|idioma=en}}</ref>
! rowspan="2" |Publicado por primera vez
|-
!mensajes largos
!8 bytes
|-
| colspan="2" |'''[[MD5]]''' (como referencia)
|128
|128
(4 × 32)
|512
|64
|And, Xor, Or, Rot, Add (mod 2<sup>32</sup>)
|≤18
(colisiones encontradas)
|0
|4,99
|55,00
|1992
|-
| colspan="2" |'''SHA-0'''
| rowspan="2" |160
| rowspan="2" |160
(5 × 32)
| rowspan="2" |512
| rowspan="2" |80
| rowspan="2" |And, Xor, Or, Rot, Add (mod 2<sup>32</sup>)
|<34
(colisiones encontradas)
| rowspan="2" |0
|≈ SHA-1
|≈ SHA-1
|1993
|-
| colspan="2" |'''SHA-1'''
|<63
(colisiones encontradas)
|3,47
|52,00
|1995
|-
| rowspan="3" |'''[[SHA-2]]'''
|SHA-224
SHA-256
|224
256
|256
(8 × 32)
|512
|64
|And, Xor, Or, Rot, Shr, Add (mod 2<sup>32</sup> )
|112
128
|32
0
|7,62
7,63
|84,50
85,25
|2004
2001
|-
|SHA-384
SHA-512
|384
512
| rowspan="2" |512
(8 × 64)
| rowspan="2" |1024
| rowspan="2" |80
| rowspan="2" |And, Xor, Or, Rot, Shr, Add (mod 2<sup>64</sup> )
|192
256
|128 (≤ 384)
0
|5.12
5.06
|135,75
135,50
|2001
|-
|SHA-512/224
SHA-512/256
|224
256
|112
128
|288
256
|≈ SHA-384
|≈ SHA-384
|2012
|-
| rowspan="2" |'''[[SHA-3]]'''
|SHA3-224
SHA3-256
SHA3-384
SHA3-512
|224
256
384
512
| rowspan="2" |1600
(5 × 5 × 64)
|1152
1088
832
576
| rowspan="2" |24
| rowspan="2" |And, Xor, Rot, Not
|112
128
192
256
|448
512
768
1024
|8.12
8.59
11.06
15.88
|154,25
155,50
164,00
164,00
| rowspan="2" |2015
|-
|SHAKE128
SHAKE256
|''d'' (arbitrario)
''d'' (arbitrario)
|1344
1088
|min ( ''d'' / 2, 128)
min ( ''d'' / 2, 256)
|256
512
|7.08
8.59
|155.25
155.50
|}

== Implementaciones ==
A continuación se muestra una lista de bibliotecas criptográficas que admiten SHA-1:

* [[Botan (biblioteca criptográfica)|Botan]]
* [[Bouncy Castle]]
* [[cryptlib]]
* [[Crypto++]]
* [[Libgcrypt]]
* [[Mbed TLS]]
* [[Nettle (biblioteca criptográfica)|Nettle]]
* [[LibreSSL]]
* [[OpenSSL]]
* [[GnuTLS]]

La aceleración por hardware está proporcionada por las siguientes extensiones de procesadores:

* [[Extensiones Intel SHA]]: Disponibles en algunos procesadores x86 de [[Intel]] y [[Advanced Micro Devices|AMD]].
* [[VIA PadLock]].
* IBM [[z/Architecture]]: Disponible desde 2003 como parte de la Extensión Message-Security-Assist.<ref>IBM z/Architecture Principles of Operation, publicación número SA22-7832. Véase instrucciones KIMD y KLMD en el capítulo 7.</ref>

=== Contramedida para colisiones ===
Tras el ataque SHAttered, Mark Stevens y Dan Shumow publicaron "sha1collisiondetection" (SHA-1CD), una variante de SHA-1 que detecta ataques de colisión y cambia la salida del hash cuando se detecta una. La tasa de falsos positivos es de 2^-90.[2] SHA-1CD es utilizado por GitHub desde marzo de 2017 y por git desde la versión 2.13.0 de mayo de 2017.[3]

== Véase también ==
* [[Secure Hash Algorithm]]

== Referencias ==
{{listaref|2}}

== Additional bibliography ==

* {{Cita web|url=http://eprint.iacr.org/2004/146/ IACR.org|título=Near-Collisions of SHA-0|autor=[[Eli Biham]], Rafi Chen|fecha=2004|sitioweb=Cryptology ePrint Archive, Report 2004/146|editorial=apareció en CRYPTO 2004|idioma=en}}
* {{Cita web|url=http://www.infosec.sdu.edu.cn/paper/sha0-crypto-author-new.pdf|título=Efficient Collision Search Attacks on SHA-0|autor=[[Xiaoyun Wang]], Hongbo Yu y Yiqun Lisa Yin|editorial=apareció en CRYPTO 2005|idioma=en|fechaacceso=5 de octubre de 2024|fechaarchivo=10 de septiembre de 2005|urlarchivo=https://web.archive.org/web/20050910132832/http://www.infosec.sdu.edu.cn/paper/sha0-crypto-author-new.pdf|deadurl=yes}}
* {{Cita web|url=https://www.iacr.org/archive/crypto2005/36210017/36210017.pdf|título=Finding Collisions in the Full SHA-1|autor=[[Xiaoyun Wang]], Yiqun Lisa Yin y Hongbo Yu|sitioweb=CRYPTO 2005|idioma=en}}
* {{Cita web|url=https://link.springer.com/content/pdf/10.1007/978-3-540-24654-1_13.pdf|título=Security Analysis of SHA-256 and Sisters|autor=[[Henri Gilbert]], [[Helena Handschuh]]|fecha=2003|sitioweb=|editorial=[[Selected Areas in Cryptography]]|páginas=175–193|idioma=en}}
* {{Cita web|url=http://www.unixwiz.net/techtips/iguide-crypto-hashes.html|título=An Illustrated Guide to Cryptographic Hashes|autor=|fecha=|sitioweb=|editorial=|idioma=en}}
* {{Enlace roto|1={{Cita publicación|url=http://frwebgate1.access.gpo.gov/cgi-bin/waisgate.cgi?WAISdocID=5963452267+0+0+0&WAISaction=retrieve|título=Proposed Revision of Federal Information Processing Standard (FIPS) 180, Secure Hash Standard|fecha=1994-07-11|publicación=Federal Register|volumen=59|número=131|página=35317–35318|idioma=en|doi=}} |2=http://frwebgate1.access.gpo.gov/cgi-bin/waisgate.cgi?WAISdocID=5963452267+0+0+0&WAISaction=retrieve }}
* {{Cita publicación|url=http://people.ac.upc.edu/vbeltran/papers/HPCC2010.pdf|título=A CellBE-based HPC application for the analysis of vulnerabilities in cryptographic hash functions|apellidos=A. Cilardo, L. Esposito, A. Veniero, A. Mazzeo, V. Beltran, E. Ayugadé|fecha=2010|publicación=High Performance Computing and Communication international conference|idioma=en|fechaacceso=5 de octubre de 2024|fechaarchivo=30 de agosto de 2017|urlarchivo=https://web.archive.org/web/20170830045350/http://people.ac.upc.edu/vbeltran/papers/HPCC2010.pdf|deadurl=}}

== Enlaces externos ==

* [https://web.archive.org/web/20110625054822/http://csrc.nist.gov/groups/ST/toolkit/secure_hashing.html CSRC Cryptographic Toolkit] – [[:en:National_Institute_of_Standards_and_Technology|NIST]] (en inglés). Sitio web oficial del Secure Hash Standard.
* [https://web.archive.org/web/20161126003357/http://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf FIPS 180-4: Secure Hash Standard (SHS)] (en inglés).
* {{IETF RFC|3174|link=no}} (with sample C implementation) (en inglés).
* [https://www.zdnet.com/article/fixing-a-hole-in-security/ Entrevista con Yiqun Lisa Yin acerca de los ataques SHA-1] (en inglés).
* [http://www.heise-online.co.uk/security/Hash-cracked--/features/75686 Explicación de los ataques SHA-1] (3 páginas, 2006) (en inglés).
* [http://www.cryptography.com/cnews/hash.html Cryptography Research – Hash Collision Q&#x26;A] (en inglés).
* [[dmoz:Science/Math/Applications/Communication_Theory/Cryptography/Algorithms/Message_Digests|SHA-1]] en [[DMOZ|Curlie]].
* {{Cita video|título=Lecture on SHA-1 (1h 18m)|persona=Christof Paar|url=https://www.youtube.com/watch?v=5q8q4PhN0cw|sitio web=YouTube|urlarchivo=https://web.archive.org/web/20170424134012/http://www.emsec.rub.de/chair/_staff/christof-paar/|fechaarchivo=2017-04-24}}

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