image

Lek in SHA-3-implementatie maakt collisions en preimage-aanvallen mogelijk

vrijdag 21 oktober 2022, 11:14 door Redactie, 7 reacties

In de officiële implementatie van het SHA-3-hashingalgoritme is een kwetsbaarheid gevonden die collisions en preimage-aanvallen mogelijk maakt. Het probleem speelt ook bij Python, PHP en verschillende andere projecten die van de code gebruikmaken. Het beveiligingslek, aangeduid als CVE-2022-37454, zat al sinds januari 2011 in de code, wat volgens onderzoeker Nicky Mouha aangeeft hoe lastig het is om kwetsbaarheden in cryptografische implementaties te vinden, ook al spelen die een belangrijke rol in de veiligheid van systemen.

Het secure hash algorithm (SHA) is een hashfunctie die van data een unieke hashcode maakt. Een hashingalgoritme wordt als veilig beschouwd als het voor elke willekeurige invoer een unieke uitvoer heeft en dat die uitvoer niet is terug te draaien zodat de invoer achterhaald kan worden. Doordat de uitvoer niet is te manipuleren worden hashes gebruikt om bijvoorbeeld de geldigheid van certificaten en bestanden aan te tonen en het gehasht opslaan van wachtwoorden.

Er zijn verschillende SHA-versies in omloop, waarvan SHA-2 het meestgebruikt is. Vanwege verschillende aanvallen is besloten om het gebruik van SHA-1 uit te faseren. SHA-3 is de meest recente versie. Wanneer de officiële SHA-3-implementatie (XKCP) bepaalde invoer te verwerken krijgt kan er een buffer overflow ontstaan, zo ontdekte Mouha. Hij is onderzoeker bij het Amerikaanse National Institute of Standards and Technology (NIST), dat onder andere verantwoordelijk is voor het opstellen van cybersecurityrichtlijnen voor de Amerikaanse overheid.

Via de kwetsbaarheid zijn volgens Mouha verschillende soorten aanvallen mogelijk, zoals collisions. Bij dergelijke aanvallen geeft verschillende invoer dezelfde uitvoer. Daardoor zijn digitale handtekeningen die met het algoritme zijn gemaakt niet meer te vertrouwen. Ook is het zo mogelijk om vervalste certificaten te maken die als echt worden beschouwd, waarmee bijvoorbeeld man-in-the-middle-aanvallen zijn uit te voeren. Verder maakt de kwetsbaarheid in XKCP "preimage-aanvallen" mogelijk. Daarmee kan een aanvaller aan de hand van een hash de originele invoer achterhalen.

Mouha meldt dat hij het bestaan van de kwetsbaarheid met andere partijen heeft gecoördineerd. Er is echter weinig verdere informatie over updates te vinden. De onderzoeker merkt verder op dat hij ook andere beveiligingslekken heeft gevonden maar die nu nog niet kan openbaren.

Reacties (7)
21-10-2022, 12:41 door Anoniem
Een lek of een undocumented feature?
21-10-2022, 15:17 door Anoniem
Ik vindt die SHA benamingen maar heel verwarrend. Even dat ik het goed begrijp. Er is SHA-1, SHA-2 en SHA-3. SHA-1 is een 'losse' hash functie die collisions heeft. SHA-2 en SHA-3 zijn niet 'losse' hash functie maar een groep van meerdere hash functies. Dus SHA-256 en SH-A512 gebaseerd op SHA-2 zijn niet kwetsbaar. Maar SHA-256 en SHA-512 gebaseerd op SHA-3 dan weer wel? Niet echt een logische/makkelijke structuur naar mijn mening.
21-10-2022, 16:27 door Anoniem
Ik snap dat collision en pre-image verhaal niet zo .

Het lijkt me dat een hash-uitkomst op basis van een bufferoverflow niet meer voldoet aan de definitie van SHA-3 .

Dus - er is een wiskundige definitie van SHA-3 .
En er is een standaard implementatie die daar meestal mee overkomt - maar bij een bufferoverflow afwijkt van de wiskundige definitie van SHA-3 in uitkomst .

Nu is het wel zo dat als "iedereen" de "standaard implementatie" gebruikt dat effectief de definitie wordt, en collisions/pre-images "kloppen" bij creatie en test.
Hopelijk komen er meer implementaties - zodat er meer kans is dat misbruik van implementatie bugs gedetecteerd kan worden.
21-10-2022, 16:41 door Anoniem
Door Anoniem: Ik vindt die SHA benamingen maar heel verwarrend. Even dat ik het goed begrijp. Er is SHA-1, SHA-2 en SHA-3. SHA-1 is een 'losse' hash functie die collisions heeft. SHA-2 en SHA-3 zijn niet 'losse' hash functie maar een groep van meerdere hash functies. Dus SHA-256 en SH-A512 gebaseerd op SHA-2 zijn niet kwetsbaar. Maar SHA-256 en SHA-512 gebaseerd op SHA-3 dan weer wel? Niet echt een logische/makkelijke structuur naar mijn mening.

Er is SHA-1 . Dat is één hash .
(en SHA-0. met vrij snel gevonden zwakheden. Wel interessant dat SHA-0 - afkomstig van de NSA , het tot en met publicatie als standaard haalde voordat het - ook door de NSA - teruggetrokken werd. Blijkbaar lag de zwakheid niet "al op de plank" en vonden ze hun "oopsie" pas nadat het door alle interne approvals gegaan was).


Er is een familie van hashes die SHA2 heten, met verschillende message lengtes , ietwat andere interne parameters, maar verder ontzettend hetzelfde. Vandaar "SHA2 familie"
https://en.wikipedia.org/wiki/SHA-2

En er is dan een nieuwe hash (familie) - SHA-3 .
Met een volkomen andere structuur dan SHA0/1/2, maar ook weer instelbare parameters die verschillende message lengtes geven.
https://en.wikipedia.org/wiki/SHA-3

Er is dus SHA3-512 - De familie naam "3" zit erin .

Verwarrend is wel dat de standaard naam van SHA2-256 "SHA-256" is . Ze dachten blijkbaar dat ze na SHA-0,SHA-1 met de SHA2 familie klaar waren, en dat SHA-bitlengte altijd SHA2 kon betekenen.

Je schrijft dus SHA-256 (=SHA2 familie) en SHA3-256 (=SHA3 familie) .
21-10-2022, 17:32 door Anoniem
@ Vandaag, 16:41 door Anoniem
Bedankt voor de opheldering :)
21-10-2022, 18:20 door spatieman
Door Anoniem: Een lek of een undocumented feature?

alleen als het een microsoft product is hehe..
21-10-2022, 20:40 door Anoniem
Door Anoniem: Een lek of een undocumented feature?

Zoals de titel aangeeft is het een lek in de (een van de) implementatie(s), niet in SHA-3 zelf.
Reageren

Deze posting is gelocked. Reageren is niet meer mogelijk.