SHA-2
Az SHA-2 (angolul: Secure Hash Algorithm 2) kriptográfiai hashfüggvények csoportja, melyet az Egyesült Államok Nemzetbiztonsági Ügynöksége (NSA) tervezett és publikált 2002-ben.[1] A publikált dokumentum az SHA-1 mellett három új függvényt definiált: SHA-256, SHA-384 és SHA-512 néven, ahol a számok a függvények lenyomatának a bitekben meghatározott hosszát jelölik. 2015 augusztusában az NSA a FIPS PUB 180-4 kiadványában bővítette a függvények számát, így a SHA-2 család hat hash függvényből áll: SHA-224, SHA-256, SHA-384, SHA-512, SHA-512/224, SHA-512/256.[2]
Története
[szerkesztés]Az Egyesült Államok Nemzetbiztonsági Ügynöksége (NSA) a Capstone projekt[3] keretében kapott megbízást, hogy olyan biztonságos kriptográfiai algoritmusokat fejlesszen ki, amely megfelelnek az Egyesült Államokban 1987-ben elfogadott számítógép-biztonsági törvénynek (angolul: Computer Security Act). Ennek eredménye a Secure Hash Algorithm (SHA), melynek leírását 1993-ban publikálta az amerikai Nemzeti Szabványügyi és Technológiai Intézet (NIST) a FIPS 180 elnevezésű dokumentumban.[4] Az első specifikációban szereplő algoritmusra a szakmai körökben SHA-0 néven hivatkoznak. A szabványt 1995-ben az FIPS 180-1 elnevezésű leírásban felülbírálták, ez a SHA-1 nevű függvény első definícióját tartalmazta.[5]
Az SHA-2 algoritmusok első ismertetője a 2002-ben kiadott FIPS 180-2 kiadványban szerepelt.[1] A leírás a korábbi SHA-1 algoritmus mellett megfogalmazta az SHA-256, SHA-384 valamint SHA-512 függvényeket.
A FIPS 180-2 leírásból 2004-ben kiadtak egy újabb változatot, amely az SHA-2 családot bővítette az SHA-224 függvénnyel.[6]
Algoritmusok összehasonlítása
[szerkesztés]Az SHA-2 szabványcsalád több, különböző paraméterekkel rendelkező algoritmust tartalmaz. Ezek mind ugyanazon elveken alapulnak, de eltérő hashhosszt és belső blokkstruktúrát alkalmaznak. Az SHA-1, amelyet korábban széles körben használtak, nem része az SHA-2 családnak, de azonos dokumentumban (FIPS PUB 180-2) szerepel.
| Algoritmus | Kimeneti hossz (bit) | Bemeneti blokk (bit) | Belső állapot (bit) | Megjegyzés |
|---|---|---|---|---|
| SHA-1 | 160 | 512 | 160 | Ma már nem biztonságosnak tekintett |
| SHA-224 | 224 | 512 | 256 | SHA-256 módosított változata |
| SHA-256 | 256 | 512 | 256 | Legelterjedtebb változat |
| SHA-384 | 384 | 1024 | 512 | SHA-512 módosított változata |
| SHA-512 | 512 | 1024 | 512 | Nagyobb biztonság, 64 bites architektúrához optimalizált |
| SHA-512/224 | 224 | 1024 | 512 | SHA-512-ből származtatott rövidebb kimenet |
| SHA-512/256 | 256 | 1024 | 512 | SHA-512-ből származtatott rövidebb kimenet |
SHA-1
[szerkesztés]Az SHA-1 (Secure Hash Algorithm 1) az SHA-0 továbbfejlesztett változata, amelyet az NSA fejlesztett ki, és az NIST szabványosított a FIPS PUB 180-1 dokumentumban 1995-ben. Bár az SHA-1 nem része az SHA-2 algoritmuscsaládnak, a két eljárás kapcsolódik egymáshoz, mivel az FIPS PUB 180-2 dokumentumban mindkettő szerepel, illetve az SHA-2 algoritmusok a felépítésükben hasonlítanak az SHA-1-re.
Az SHA-1 160 bites kivonatokat állít elő, és sokáig az egyik legelterjedtebb hash algoritmus volt. Azonban a 2000-es évek végétől kezdve több elméleti és gyakorlati törést publikáltak rá, köztük az első gyakorlati ütközést a Google és a CWI kutatói 2017-ben (SHAttered támadás).
Ma az SHA-1-et már nem tekintik biztonságosnak, és az olyan szabványosítási szervezetek, mint a NIST, nem javasolják a használatát.
SHA-224
[szerkesztés]Az SHA-224 az SHA-2 algoritmuscsalád egyik tagja, amely az SHA-256 rövidített változata. Ugyanazt a belső szerkezetet és blokkfeldolgozást használja, mint az SHA-256, de a kimenet hossza 224 bitre van levágva, és más kezdő hash értékekkel dolgozik.
Elsősorban olyan rendszerekben használják, ahol a rövidebb hash elegendő biztonságot nyújt, de kisebb adattárolási igény vagy sávszélesség miatt előnyösebb.
- Felhasználás
Az SHA-224-et például az IPsec protokollcsalád egyes implementációi használják, különösen olyan környezetekben, ahol hardveres gyorsítás korlátozott, és fontos a hash méretének minimalizálása. Ezen kívül támogatja több kriptográfiai könyvtár is, például az OpenSSL vagy a WolfSSL.
SHA-256
[szerkesztés]Az SHA-256 az SHA-2 algoritmuscsalád legismertebb és legszélesebb körben alkalmazott tagja. 256 bites kimenetet (32 bájt) állít elő, és 512 bites blokkokban dolgozik. Belső állapottömbje 256 bites, és 64 körös feldolgozási lépést alkalmaz.
Az SHA-256 az SHA-1 logikai felépítésén alapul, de több biztonsági megerősítéssel és hosszabb kimenettel. A legtöbb modern kriptográfiai protokollban és rendszerben alapértelmezettnek tekinthető.
- Felhasználás
Az SHA-256 szerepel a TLS protokollban (amely az HTTPS alapja), valamint PGP, SSH, IPsec és más biztonsági technológiákban is. Emellett a legismertebb alkalmazása a Bitcoin és sok más kriptovaluta rendszere, amelyek a tranzakciók hash-értékét SHA-256 segítségével számítják ki. Az algoritmus implementációja megtalálható minden jelentősebb kriptográfiai könyvtárban, például az OpenSSL, Bouncy Castle, libsodium és Python hashlib moduljában.
SHA-384
[szerkesztés]Az SHA-384 az SHA-2 algoritmuscsalád egyik nagyobb bitmélységű tagja. A 64 bites architektúrára optimalizált SHA-512 algoritmus módosított változata, amely eltérő kezdőértékekkel (initial hash value) dolgozik, és a kimenetet 384 bitre rövidíti.
Ez az algoritmus elsősorban olyan környezetekben előnyös, ahol megnövelt biztonsági szintre van szükség, de az 512 bites kimenet túl nagy lenne.
- Felhasználás
Az SHA-384-et gyakran használják a PKI rendszerekben tanúsítványok aláírására, például a X.509 tanúsítványokban. Alkalmazzák az IPsec egyes konfigurációiban, illetve az SSL/TLS protokollban is opcióként elérhető. A nagyvállalati szintű titkosítási modulok (pl. HSM) gyakran natívan támogatják.
SHA-512
[szerkesztés]Az SHA-512 az SHA-2 algoritmuscsalád egyik legerősebb és legnagyobb kimenetű tagja. 512 bites (64 bájtos) kivonatot állít elő, és 1024 bites bemeneti blokkokban dolgozik. Belső állapottömbje 512 bites, a feldolgozás 80 körben történik, 64 bites műveletekkel.
Az algoritmust kifejezetten a 64 bites számítógépes architektúrákhoz optimalizálták, így ilyen környezetekben gyorsabb lehet, mint az SHA-256. Nagyobb ellenállást nyújt az ütközési támadásokkal szemben, és magas biztonsági szintet képvisel.
- Felhasználás
Az SHA-512-t használják többek között a TLS protokollban, tanúsítvány-aláírási folyamatokban és kormányzati adatvédelmi rendszerekben. Népszerű választás olyan alkalmazásokban is, ahol hosszú távú kriptográfiai biztonság követelmény (pl. egészségügyi vagy pénzügyi rendszerek). Az OpenBSD operációs rendszer például az SHA-512-t alkalmazza a jelszó-hashelés alapértelmezett módszereként.
SHA-512/224 és SHA-512/256
[szerkesztés]Az SHA-512/224 és SHA-512/256 az SHA-2 algoritmuscsalád tagjai, amelyek az SHA-512 algoritmus feldolgozási struktúráját használják, de a végső kimenetüket rövidebbre vágják: 224, illetve 256 bit hosszúságúra. Mindkét algoritmus egyedi kezdő hash-értékekkel dolgozik, azaz nem egyszerű truncálásról van szó.
Céljuk, hogy a 64 bites rendszerekre optimalizált SHA-512 sebesség- és biztonsági előnyeit kombinálják a rövidebb hash értékek előnyeivel.
- Felhasználás
Ezek az algoritmusok kevésbé elterjedtek, de szerepelnek a FIPS PUB 180-4 szabványban, és támogatottak a legtöbb modern kriptográfiai könyvtárban. Alkalmazásuk olyan környezetekben lehet előnyös, ahol a 64 bites architektúra miatt az SHA-512 gyorsabb, mint az SHA-256, de a hosszabb kimenet nem szükséges.
Felhasználása
[szerkesztés]A hash függvény olyan függvény, amely tetszőleges hosszúságú bemeneti üzenetből egy rögzített hosszúságú karakterláncot („ujjlenyomat”) hoz létre. A kriptográfiai hash függvények számos olyan tulajdonsággal rendelkeznek, amelyek alkalmassá teszik őket az üzenet integritásának ellenőrzésére és a digitális aláírási megoldások részeként történő használatra.
Az SHA-2 hash függvényeket számos biztonsági alkalmazásban és protokollban alkalmazzák, úgy mint a TLS, az SSL, a PGP, az SSH, az S/MIME és az IPsec.
A Bitcoin digitális fizetőeszköz és klónjai SHA-256 algoritmust használnak.
Megbízhatósága
[szerkesztés]A kriptográfiai módszerek sebezhetőségeinek feltárásával a kriptoanalízis foglalkozik, célja a bennük elrejtett információ felfedése, támadási lehetőségeinek vizsgálata.
Egy hash függvénynél az előkép megszerzésére irányuló támadás esetén, ahol a kódolt hashben lévő bitek száma L, egy adott üzenet megtalálásához „nyers erővel” avagy brute force-támadással 2L kiértékelés elvégzésére van szükség. Ez a fajta módszer nagyban függ a felhasználható számítási kapacitástól, és így a variációk számának nagyságától függően a sikeresség elérése időben vagy pénzügyileg adott esetben kevésbé gazdaságos.
Egy másik támadási vektor az ütközések keresése (angolul: collision attack), amikor a cél hogy eltérő bemenetre ugyanazt a kimenetet generálja a függvény. Ennek a megoldásnak ugyan a brute force támadással ellentétben más a célja, de azt bizonyítja hogy lehetséges a függvény kompromittálása. A megoldásához L bitet tartalmazó kódolt hash esetében átlagosan 2L/2 kiértékelésre lehet szükség, ami nagyságrendekkel gazdaságosabban kivitelezhető mint a nyers erővel történő támadási formával.
SHA-1 esetében a Google kutatói 2017-ben publikáltak egy dokumentumot, amely két eltérő fájl esetében ugyanazon hash értéket előállítását mutatja be.[7] A tanulmány szerint a megoldáshoz 263.1 műveletre volt szükség, aminek futtatására 65 000 évre volna szükség egy processzorros (single-CPU) rendszerrel és 110 évig tartana ugyanez egy grafikai processzor (single-GPU) alkalmazásával. Ezzel szemben egy teoretikus brute force támadás 12 000 000 évbe telne grafikai processzor (single-GPU) használatával.
2019-ben francia és szingapúri kutatók publikációjukban szintén az SHA-1 függvény sebezhetőségét állapították meg, amihez egy szabadon megválasztható a prefixű ütközéses támadást használtak.[8]
SHA-2 esetében is több tanulmány készült a lehetséges támadási vektorokról.
Publikációk az SHA-2 támadásokról
[szerkesztés]| Publikáció | Publikálás éve | Támadási mód | Támadás | Változat | Lépésszám | Nehézség |
|---|---|---|---|---|---|---|
| New Collision Attacks Against Up To 24-step SHA-2[9] |
2008 | determinisztikus | ütközés keresés | SHA-256 | 24/64 | 228.5 |
| SHA-512 | 24/80 | 232.5 |
Minta kimenetek
[szerkesztés]Az SHA-2 függvények kimenete üres (nulla hosszúságú üzenet) bemenetek esetén:
SHA224("") 0x d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f SHA256("") 0x e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 SHA384("") 0x 38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b SHA512("") 0x cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e SHA512/224("") 0x 6ed0dd02806fa89e25de060c19d3ac86cabb87d6a0ddd05c333b84f4 SHA512/256("") 0x c672b8d1ef56ed28ab87c3622c5114069bdd3ad7b8f9737498d0c01ecef0967a
Még az üzenet egy kis változtatása is (nagy valószínűséggel) jelentősen eltérő eredményt ad a lavinahatás (angolul: avalanche effect) következtében.
Például a következő esetben az üzenetek csak egyetlen karakterben térnek el (a szavak Hamming-távolsága egy), a kimenet mégis teljesen eltérő:
SHA256("majom") 0x 56026d01f89f22ae2293833a736b5bcdc8cbee4852d3c3ab2067000f969d38fa SHA256("bajom") 0x 390e091b2978c04af5258725d9ea52c98f7d6d3cec11981bf88e638daf870782
Pszeudokód
[szerkesztés]SHA-256
[szerkesztés]Változók kezdőértékének a beállítása: h0 := 0x6a09e667 h1 := 0xbb67ae85 h2 := 0x3c6ef372 h3 := 0xa54ff53a h4 := 0x510e527f h5 := 0x9b05688c h6 := 0x1f83d9ab h7 := 0x5be0cd19 Konstansok értékének a beállítása: k[0..63] := 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 Előfeldolgozás: begin with the original message of length L bits append a single '1' bit append K '0' bits, where K is the minimum number >= 0 such that L + 1 + K + 64 is a multiple of 512 append L as a 64-bit big-endian integer, making the total post-processed length a multiple of 512 bits such that the bits in the message are L 1 00..<K 0's>..00 <L as 64 bit integer> = k*512 total bits Az üzenet egymást követő 512-bites darabjaira a következő műveletek végrehajtása: break message into 512-bit chunks for each chunk create a 64-entry message schedule array w[0..63] of 32-bit words (A w[0..63] kezdőértékei nem számítanak, ezért sok implementáció kinullázza őket) copy chunk into first 16 words w[0..15] of the message schedule array Az első 16 darab 32 bites szó kiterjesztése 64 bitesre: for i from 16 to 63 s0 := (w[i-15] rightrotate 7) xor (w[i-15] rightrotate 18) xor (w[i-15] rightshift 3) s1 := (w[i- 2] rightrotate 17) xor (w[i- 2] rightrotate 19) xor (w[i- 2] rightshift 10) w[i] := w[i-16] + s0 + w[i-7] + s1 A használni kívánt változók inicializálása az aktuális hash értékekre: a := h0 b := h1 c := h2 d := h3 e := h4 f := h5 g := h6 h := h7 Tömörítési funkció fő ciklusa: 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) t1 := h + S1 + ch + k[i] + w[i] S0 := (a rightrotate 2) xor (a rightrotate 13) xor (a rightrotate 22) maj := (a and b) xor (a and c) xor (b and c) t2 := S0 + maj h := g g := f f := e e := d + t1 d := c c := b b := a a := t1 + t2 A tömörített darab hozzáadása az aktuális hash értékhez: h0 := h0 + a h1 := h1 + b h2 := h2 + c h3 := h3 + d h4 := h4 + e h5 := h5 + f h6 := h6 + g h7 := h7 + h A végső hash érték előállítása (big endianként): digest := hash := h0 append h1 append h2 append h3 append h4 append h5 append h6 append h7
SHA-224
[szerkesztés]Az SHA-224 szinte teljesen megegyezik az SHA-256 megoldásával, csupán a kezdeti h0 és h7 hash értékek eltérőek, és a kimenet a h7 hozzáfűzése nélkül áll össze.
SHA-224 kezdőértékek (big endianként):
h[0..7] := 0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4
SHA-512
[szerkesztés]Az SHA-512 esetében a számok 64 bit hosszúak, az üzenet 1024-bites darabokra van osztva, a k tömb pedig 80 elemű. A fő ciklus 64 helyett 80-szor fut le és a használt eltolási és forgatási bitek számai is eltérőek.
SHA-512 kezdőértékek (big endianként):
h[0..7] := 0x6a09e667f3bcc908, 0xbb67ae8584caa73b, 0x3c6ef372fe94f82b, 0xa54ff53a5f1d36f1,
0x510e527fade682d1, 0x9b05688c2b3e6c1f, 0x1f83d9abfb41bd6b, 0x5be0cd19137e2179
SHA-512 konstansok:
k[0..79] := [ 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-512 fő ciklus funkciók:
S0 := (a rightrotate 28) xor (a rightrotate 34) xor (a rightrotate 39)
S1 := (e rightrotate 14) xor (e rightrotate 18) xor (e rightrotate 41)
s0 := (w[i-15] rightrotate 1) xor (w[i-15] rightrotate 8) xor (w[i-15] rightshift 7)
s1 := (w[i-2] rightrotate 19) xor (w[i-2] rightrotate 61) xor (w[i-2] rightshift 6)
Jegyzetek
[szerkesztés]- ↑ a b Announcing Approval of Federal Information Processing Standard (FIPS) 180-2, Secure Hash Standard; a Revision of FIPS 180-1. www.federalregister.gov (angolul) (2002. augusztus 26.) (Hozzáférés: 2021. november 9.)
- ↑ FIPS PUB 180-4: Secure Hash Standard (SHS). nvlpubs.nist.gov (angolul) (2015. augusztus) (Hozzáférés: 2021. november 9.)
- ↑ What is Capstone? x5.net (angolul) (Hozzáférés: 2021. november 10.)
- ↑ FIPS 180 – Secure Hash Standard (SHS). csrc.nist.gov (angolul) (1993. május 11.) (Hozzáférés: 2021. november 10.)
- ↑ FIPS 180-1 – Secure Hash Standard. csrc.nist.gov (angolul) (1995. április 17.) (Hozzáférés: 2021. november 10.)
- ↑ FIPS Publication 180-2 (with Change Notice 1). csrc.nist.gov (angolul) (2004. február 25.) (Hozzáférés: 2021. november 10.)
- ↑ SHAttered: The first collision for full SHA-1. shattered.it (angolul) (Hozzáférés: 2021. november 10.)
- ↑ Nemzeti Kibervédelmi Intézet – Újabb szög az SHA-1 koporsójába. nki.gov.hu (magyarul) (Hozzáférés: 2021. november 10.)
- ↑ Somitra Kumar Sanadhya (2008). „New Collision Attacks Against Up To 24-step SHA-2”. IACR Cryptology ePrint Archive 2008:270.
Források
[szerkesztés]- Wouter Penard – Tim van Werkhoven: On the Secure Hash Algorithm family. www.staff.science.uu.nl (angolul) (Hozzáférés: 2021. november 9.) arch
További információk
[szerkesztés]- Online tools – Hash függvény generátorok Archiválva 2023. február 6-i dátummal a Wayback Machine-ben
- SHAttered – The first collision for full SHA-1 (angolul)
