SEAL (kriptográfiai algoritmus)

Az oldal jelenlegi verzióját még nem ellenőrizték tapasztalt közreműködők, és jelentősen eltérhet a 2014. március 26-án áttekintett verziótól ; az ellenőrzések 9 szerkesztést igényelnek .

A SEAL ( Softverre optimalizált titkosítási algoritmus , szoftverre optimalizált titkosítási algoritmus) egy szimmetrikus adatfolyam - titkosítási algoritmus , amelyet szoftveres implementációra optimalizáltak .

Phil Rogaway és Don Coppersmith fejlesztette ki az IBM - nél 1993 - ban . _ _ Az algoritmus optimalizált és 32 bites processzorokhoz ajánlott . Működéséhez több kilobájt gyorsítótár és nyolc 32 bites regiszter szükséges . A titkosítási sebesség körülbelül 4 gépi ciklus szövegbájtonként . A kódoláshoz és a dekódoláshoz 160 bites kulcsot használnak . A lassú kulcsfeldolgozási műveletek miatti nemkívánatos sebességveszteség elkerülése érdekében a SEAL előzetesen több átalakítást hajt végre rajta, ami három, bizonyos méretű táblát eredményez. Maga a kulcs helyett ezek a táblázatok közvetlenül a szöveg titkosítására és visszafejtésére szolgálnak.

Az algoritmust nagyon megbízhatónak, nagyon gyorsnak [1] tartják, és az US 5454039 [2] számú szabadalom védi 1993 decembere óta .

Történelem

1991 -ben Ralph C. Merkle leírta a szoftver alapú titkosítások költséghatékonyságát . Véleménye szerint ezek közül a leghatékonyabbak a Khufu , a FEAL és az RC4 voltak . Az ügyfelek megbízható kriptográfia iránti egyre növekvő igénye azonban új megoldások felkutatását és a régi megoldások finomítását tette szükségessé.

1992 nyarán megkezdődött az új, szoftverre optimalizált SEAL 1.0 algoritmus első verziójának fejlesztése. A fejlesztők a fő gondolatokat és a működési elvet a számukra akkoriban a legtökéletesebbnek tűnő Ralph Merkle ( eng. Ralph C. Merkle ) Khufu blokk titkosítástól vették át. Úgy döntöttek, hogy elérik a projekt legjobb jellemzőit (főleg a sebességet), leszűkítve azon berendezések körét, amelyeken a megvalósítás lehetséges. A választás a 32 bites gépek mellett esett, amelyek legalább nyolc általános célú regiszterrel és legalább 8 KB gyorsítótárral rendelkeznek . 1993 márciusában döntés született egy blokk titkosítás létrehozásáról , de a pszeudo-véletlen függvénycsaládból az év októberére kifejlesztett struktúra gyorsabban működött, ami arra késztette a fejlesztőket, hogy az adatfolyam - titkosítást alkalmazzák .

Ez a struktúra négy regiszterből állt, amelyek mindegyike megváltoztatta a "szomszédját" a kulcsból nyert táblázat függvényében . Számos ilyen módosítás után a regiszterértékek hozzáadódnak a kulcssorozathoz, amely minden iterációval növekszik, amíg el nem ér egy bizonyos hosszúságot.

A fejlesztés során szinte minden figyelem az algoritmus belső ciklusára irányult , mivel a regiszter inicializálási eljárása és a kulcsból táblák generálásának módja alig volt hatással annak biztonságára. A SEAL 1.0 projekt végleges formájában csak 1993 decemberében jelent meg .

1996-ban Helen Handschuh és Henri Gilbert SEAL 1.0 elleni támadásokat. Szövegekre volt szükségük , egyenként négy 32 bites szóból, hogy megtalálják az álvéletlen függvény függőségét a billentyűtől . Ennek eredményeként néhány fejlesztést és változtatást hajtottak végre a SEAL 3.0 és SEAL 2.0 algoritmus következő verzióiban. Például az 1.0-s verzióban minden egyes kulcssorozattal végzett iteráció csak két regiszter módosításával ért véget, a 3.0-s verzióban pedig mind a négy módosult. A SEAL 3.0 és SEAL 2.0 is az SHA-1 ( Secure Hash Algorithm-1 ) algoritmust használta a táblázatok előállításához az eredeti SHA helyett , ami ellenállóbbá tette őket a kriptoanalízissel szemben . $2^{30}$

Leírás

Az algoritmus leírásánál a következő műveleteket és jelöléseket használjuk:

a hexadecimális számrendszer számai "0x" karakterekkel kezdődnek, és a rekordban a decimális számjegyeken kívül az "a" , "b" , "c" , "d" , "e" és "f" karaktereket használják. , amelyek 10 és 15 közötti decimális számokat jelölnek;
az Y kifejezés alatt t az Y regiszter ciklikus eltolásaként kell érteni t bittel jobbra ; $\ggg$
az Y kifejezés alatt t az Y regiszter ciklikus eltolásaként kell érteni balra t bittel; $\lll$
az X Y művelet az X és Y regiszterek bitenkénti logikai szorzását ( angol AND ) jelenti ; $\És$
Az X Y művelet az X és Y regiszterek bitenkénti logikai összeadását jelenti ( angol VAGY ) ; $\lor$
Az X Y művelet a modulo 2 ( angolul XOR ) X és Y regiszterek bitenkénti összeadását jelenti ; $\oplus$
X Y alatt meg kell érteni az X és Y regiszterek összefűzését ( angol konkatenáció ) ; $\lVert$
a páratlan (X) kifejezés az X argumentum logikai függvényét jelöli , amely csak akkor IGAZ ( eng. TRUE ) lesz , ha X páros szám .

Titkosítási táblák létrehozása kulcsból

A lassú műveleteknél a titkosítási sebesség elvesztésének elkerülése érdekében az algoritmus három táblázatot használ: R , S és T . Ezeket a táblázatokat az SHA-1 algoritmus egyik eljárásával számítjuk ki, és csak a kulcstól függenek . A táblázatok kitöltése a G függvénnyel írható le , amely 160 bites sztringből 160 bites értéket és 32 bites számot ad vissza . $a$ $én$ $G_{a}(i)$

Az indextől függően a következő függvényeket és változókat vezetjük be : $t$

telepíteni és _ $0\leq t\leq 19$ $K_{t}={\mbox{0x}}5a827999$ $f_{t}(B,C,D)=(B\And C)\lor (B\And D);$
telepíteni és _ $20\leq t\leq 39$ $K_{t}={\mbox{0x}}6ed9eba1$ $f_{t}(B,C,D)=B\oplus C\oplus D;$
telepíteni és _ $40\leq t\leq 59$ $K_{t}={\mbox{0x}}8f1bbcdc$ $f_{t}(B,C,D)=(B\And C)\lor (B\And D)\lor (C\And D);$
telepíteni és _ $60\leq t\leq 79$ $K_{t}={\mbox{0x}}ca62c1d6$ $f_{t}(B,C,D)=B\oplus C\oplus D.$

A 160 bites karakterláncot ezután öt 32 bites szóra osztják úgy, hogy $a$ $a=H_{0}\lVert H_{1}\lVert H_{2}\lVert H_{3}\lVert H_{4}.$

Tizenhat 32 bites szó is létrejön $W_{0}=i,~~W_{1}=W_{2}=...=W_{15}=0^{32}.$

Ezután elvégezzük a végső számításokat:

${\mbox{For}}~t=16~{\mbox{to}}~79~{\mbox{do}}~W_{t}=(W_{t-3}\oplus W_{t -8}\oplus W_{t-14}\oplus W_{t-16})\lll 1;$
$A=H_{0};~B=H_{1};~C=H_{2};~D=H_{3};~E=H_{4};$
${\mbox{For}}~t=0~{\mbox{to}}~79~{\mbox{do}}$ ${\mbox{TEMP}}=A\lll 5+f_{t}(B,C,D)+E+W_{t}+K_{t};$ $E=D;~D=C;~C=B\lll 30;~B=A;~A=TEMP;$
$H_{0}=H_{0}+A;~H_{1}=H_{1}+B;~H_{2}=H_{2}+C;~H_{3}=H_{3 }+D;H_{4}=H_{4}+E;$
$G_{a}(i)=H_{0}\lVert H_{1}\lVert H_{2}\lVert H_{3}\lVert H_{4}.$

Bemutatjuk a függvényt , ahol for ${\displaystyle \Gamma _{a}(i)=H_{i~mod~5}^{i))$ $H_{0}^{5j}\lH_{1}^{5j+1}\lH_{2}^{5j+2}\lH_{3}^{5j+3}\lH_-csúcs. {4}^{5j+4}=G_{a}(j)$ $j={\mathcal {b}}i/5{\mathcal {c}}.$

Aztán táblázatok:

$T[i]=\Gamma _{a}(i),~~0\leq i<512;$

$S[j]=\Gamma _{a}({\mbox{0x}}1000+j),~~0\leq j<256;$

$R[k]=\Gamma _{a}({\mbox{0x}}2000+k),~~0\leq k<256.$

Ezenkívül a kulcsot nem használják az algoritmusban. $a$

Szolgáltatási nyilvántartások inicializálása

A pszeudo-véletlen függvény generálása előtt négy 32 bites szolgáltatásregisztert ( , , és ) és négy 32 bites szót ( , , és ) kell elkészíteni. Értékeiket a táblázatokból és egy 32 bites számból és néhány számból határozzuk meg a következő eljárásban. $A$ $B$ $C$ $D$ $n_{1}$ $n_{2}$ ${\displaystyle n_{3))$ ${\displaystyle n_{4))$ $R$ $T$ $n$ $l$

${\mbox{procedure}}~{\mbox{Inicializálás}}~(n,l,A,B,C,D,n_{1},n_{2},n_{3},n_{4 })$

A\leftarrow n\oplus R[4l];

B\leftarrow (n\ggg 8)\oplus R[4l+1];

C\leftarrow (n\ggg 16)\oplus R[4l+2];

D\leftarrow (n\ggg 24)\oplus R[4l+3];

${\mbox{for}}~j\leftarrow 1~{\mbox{to}}~2~{\mbox{do}}$

P\leftarrow A\And {\mbox{0x}}7fc;~~B\leftarrow B+T[P/4];~~A\leftarrow A\ggg 9;

P\leftarrow B\And {\mbox{0x}}7fc;~~C\leftarrow C+T[P/4];~~B\leftarrow B\ggg 9;

P\leftarrow C\And {\mbox{0x}}7fc;~~D\leftarrow D+T[P/4];~~C\leftarrow C\ggg 9;

P\leftarrow D\And {\mbox{0x}}7fc;~~A\leftarrow A+T[P/4];~~D\leftarrow D\ggg 9;

$(n_{1},n_{2},n_{3},n_{4})\leftarrow (D,B,A,C);$

P\leftarrow A\And {\mbox{0x}}7fc;~~B\leftarrow B+T[P/4];~~A\leftarrow A\ggg 9;

P\leftarrow B\And {\mbox{0x}}7fc;~~C\leftarrow C+T[P/4];~~B\leftarrow B\ggg 9;

P\leftarrow C\And {\mbox{0x}}7fc;~~D\leftarrow D+T[P/4];~~C\leftarrow C\ggg 9;

P\leftarrow D\And {\mbox{0x}}7fc;~~A\leftarrow A+T[P/4];~~D\leftarrow D\ggg 9;

Pszeudo-véletlen függvény létrehozása

A szöveg titkosításához létre kell hoznia egy pszeudo-véletlen függvényt.

${\mbox{function}}~{\mbox{SEAL}}~(a,n,L)$

$y=0^{L};$

${\mbox{for}}~l\leftarrow 0~{\mbox{to}}~\infty ~{\mbox{do}}$

${\mbox{Inicializálás}}~(n,l,A,B,C,D,n_{1},n_{2},n_{3},n_{4});$

${\mbox{for}}~i\leftarrow 1~{\mbox{to}}~64~{\mbox{do}}$

$P\leftarrow A\And {\mbox{0x}}7fc;~~B\leftarrow B+T[P/4];~~A\leftarrow A\ggg 9;~~B\leftarrow B\oplus A;$

$Q\leftarrow B\And {\mbox{0x}}7fc;~~C\leftarrow C\oplus T[Q/4];~~B\leftarrow B\ggg 9;~~C\leftarrow C+ B ;$

$P\leftarrow (P+C)\És {\mbox{0x}}7fc;~~D\leftarrow D+T[P/4];~~C\leftarrow C\ggg 9;~~D\ balra nyíl D\oplus C;$

$Q\leftarrow (Q+D)\És {\mbox{0x}}7fc;~~A\leftarrow A\oplus T[Q/4];~~D\leftarrow D\ggg 9;~~A \leftarrow A+D;$

$P\leftarrow (P+A)\És {\mbox{0x}}7fc;~~B\leftarrow B\oplus T[P/4];~~A\leftarrow A\ggg 9;$

$Q\leftarrow (Q+B)\És {\mbox{0x}}7fc;~~C\leftarrow C+T[Q/4];~~B\leftarrow B\ggg 9;$

$P\leftarrow (P+C)\És {\mbox{0x}}7fc;~~D\leftarrow D\oplus T[P/4];~~C\leftarrow C\ggg 9;$

$Q\leftarrow (Q+D)\És {\mbox{0x}}7fc;~~A\leftarrow A+T[Q/4];~~D\leftarrow D\ggg 9;$

$y\leftarrow y~\lVert ~B+S[4i-4]~\lVert ~C\oplus S[4i-3]~\lVert ~D+S[4i-2]~\lVert ~A\ plusz S[4i-1];$

${\mbox{if}}~|y|\geq L~{\mbox{then}}~{\mbox{return}}~~y_{0}y_{1}...y_{L- egy};$

${\mbox{if}}~páratlan(i)~{\mbox{akkor}}~(A,B,C,D)\leftarrow (A+n_{1},B+n_{2}, C\oplus n_{1},D\oplus n_{2});$

${\mbox{else}}~(A,B,C,D)\leftarrow (A+n_{3},B+n_{4},C\oplus n_{3},D\oplus n_{ négy});$

A titkosítási folyamat nagyszámú iterációból áll, amelyek mindegyike egy pszeudo-véletlen függvény generálásával végződik . Az átment iterációk számát az l számláló mutatja . Mindegyikük több szakaszra oszlik hasonló műveletekkel. Minden szakaszban az egyik regiszter ( A , B , C vagy D ) felső 9 bitjét használjuk mutatóként , amellyel kiválasztunk egy értéket a T táblázatból . Ezt az értéket aritmetikailag vagy bitenkénti modulo 2 (XOR) adjuk hozzá a következő regiszterrel (ismét az A , B , C vagy D valamelyikével ). Az első kiválasztott regiszter ezután 9 pozícióval jobbra fordul . Továbbá vagy a második regiszter értékét módosítjuk összeadással, vagy XOR -t az első (már eltolt) tartalmával, és végrehajtjuk az átmenetet a következő szakaszba, vagy ezt az átmenetet azonnal végrehajtjuk. 8 ilyen kör után az A , B , C és D értékek hozzáadódnak (számtanilag vagy XORed ) bizonyos szavakkal az S táblázatból , és hozzáadódnak az y billentyűsorozathoz . Az iteráció utolsó lépése további 32 bites értékek ( n1 , n2 vagy n3 , n4 ) hozzáadása a regiszterekhez . Ezenkívül egy adott érték kiválasztása az iteráció számának paritásától függ .

Tulajdonságok és gyakorlati alkalmazás

Az algoritmus kidolgozásakor a fő figyelmet a következő tulajdonságokra és ötletekre fordítottuk:

egy nagy (körülbelül 2 Kbyte -os) T tábla használata , amelyet egy nagy, 160 bites kulcsból nyerünk ;
aritmetikai műveletek váltakozása (összeadás és bitenkénti XOR );
olyan belső rendszerállapot használata, amely nem jelenik meg kifejezetten az adatfolyamban (az n1 , n2 , n3 és n4 értékek, amelyek minden iteráció végén megváltoztatják a regisztereket );
az iterációs szakasztól és annak számától függően egymástól eltérő műveletek használata .

A SEAL titkosítás körülbelül négy gépi ciklust igényel a szöveg minden egyes bájtjának titkosításához és visszafejtéséhez . Körülbelül 58 Mbps sebességgel fut egy 32 bites 50 MHz-es processzoron , és az egyik leggyorsabb titkosítás .

Jegyzetek

↑ P.Rogaway , D.Coppersmith . Szoftverre optimalizált titkosítási algoritmus . – 1998.
↑ US 5,454,039 számú szabadalom "Szoftver-hatékony álvéletlen funkció és ennek használata titkosításra"

Források

Schneier B. Alkalmazott kriptográfia. Protokollok, algoritmusok, forráskód C nyelven = Applied Cryptography. Protokollok, algoritmusok és forráskód a C.- M. -ben: Triumf, 2002. - S. 446-448. — 816 p. - 3000 példányban. - ISBN 5-89392-055-4 .
P. Rogaway , D. Coppersmith . Szoftverre optimalizált titkosítási algoritmus . – 1998.
Helen Handshuh , H. Gilbert - A SEAL titkosítási algoritmus kriptoanalízise. – 1997. $X^{2}$

Linkek

5 675 652 számú amerikai egyesült államokbeli szabadalom "Szoftverhatékony pszeudovéletlen funkciójú titkosítást megvalósító számítógéppel olvasható eszköz"
A SEAL 3.0 algoritmus nem hivatalos implementációja C nyelven Archiválva : 2016. március 5. a Wayback Machine -nél
A SEAL 3.0 algoritmus nem hivatalos implementációja a Delphiben Archiválva : 2016. március 4. a Wayback Machine -nél

Szimmetrikus titkosítási rendszerek
Rejtjelfolyam adatfolyam	A3 A5 A8 Decim F-FCSR Gabona HC-256 KCipher-2 MICKEY MUGI CSUKA Phelix RC4 Nyúl FÓKA HÓ SOSEMANUK Salsa20 STRUMOK Trivium VMPC
Feistel hálózat	GOST 28147-89 (Magma) blowfish Kamélia CAST-128 CAST-256 CIPHERUNICORN-A CIPHERUNICORN-E CLEFIA Kobra ÜZLET DES DESX DFC E2 EnRUPT FEAL HPC ÖTLET KASUMI Khafre Khufu LOKI97 MacGuffin MARS HÁLÓ MISTY1 NewDES NDS RC5 RC6 MAG Simon Sinopoli skipjack SM4 Folt TEA XTEA XXTEA Raiden RTEA Tripla DES Kéthal
SP hálózat	Szöcske 3 út ABC ÁRIA AES (Rijndael) Akelarre Anubis BaseKing Bass Omatic Öv CRYPTON Gyémánt2 grand cru Hierocrypt-3 Hierocrypt-L1 KHAZAD Kalyna Lucifer jelenlegi Szivárvány BIZTONSÁGOSBAN CÁPA NÉGYZET Kígyó háromhal
Egyéb	BÉKA NUSH REDOC SC2000 SHACAL CS-Cipher