SEAL (kryptografisk algoritm)

Den aktuella versionen av sidan har ännu inte granskats av erfarna bidragsgivare och kan skilja sig väsentligt från versionen som granskades den 26 mars 2014; kontroller kräver 9 redigeringar .

SEAL ( S oftware -optimized Encryption Algorithm , mjukvaruoptimerad krypteringsalgoritm) är en symmetrisk strömdatakrypteringsalgoritm optimerad för programimplementering .

Utvecklad på IBM 1993 av Phil Rogaway och Don Coppersmith . _ _ _ Algoritmen är optimerad och rekommenderas för 32-bitars processorer . Det kräver flera kilobyte cacheminne och åtta 32-bitars register för att fungera . Krypteringshastigheten är cirka 4 maskincykler per byte text . En 160-bitars nyckel används för kodning och avkodning . För att undvika oönskad hastighetsförlust på grund av långsamma nyckelbearbetningsoperationer utför SEAL flera transformationer på den, vilket resulterar i tre tabeller av en viss storlek. Istället för själva nyckeln används dessa tabeller direkt för att kryptera och dekryptera texten.

Algoritmen anses vara mycket pålitlig, mycket snabb [1] och skyddas av US patent nr 5454039 [2] sedan december 1993 .

Historik

1991 beskrev Ralph C. Merkle kostnadseffektiviteten hos mjukvarubaserade chiffer . Enligt hans åsikt var de mest effektiva av dessa Khufu , FEAL och RC4 . Kundernas ständigt ökande behov av tillförlitlig kryptografi krävde dock sökandet efter nya och förfining av gamla lösningar.

Sommaren 1992 började utvecklingen av den första versionen av den nya mjukvaruoptimerade SEAL 1.0 - algoritmen . Utvecklarna tog huvudidéerna och driftprincipen från blockchifferet Ralph Merkle ( eng. Ralph C. Merkle ) Khufu , som tycktes dem vara den mest perfekta på den tiden. De bestämde sig för att uppnå de bästa egenskaperna hos projektet (främst hastighet), vilket minskade utbudet av utrustning som det är möjligt att genomföra på. Valet gjordes till förmån för 32-bitarsmaskiner med minst åtta allmänna register och en cache på minst 8 KB . I mars 1993 togs beslutet att skapa ett blockchiffer , men strukturen från familjen av pseudo-slumpmässiga funktioner , utvecklad i oktober samma år, fungerade snabbare, vilket ledde till att utvecklare strömmade kryptering .

Denna struktur bestod av fyra register , som var och en ändrade sin "granne" beroende på tabellen som erhölls från nyckeln . Efter ett antal sådana modifieringar läggs registervärdena till nyckelsekvensen, som växer med varje iteration tills den når en viss längd.

Under utvecklingen ägnades nästan all uppmärksamhet åt den inre slingan av algoritmen , eftersom registerinitieringsproceduren och metoden för att generera tabeller från nyckeln hade liten effekt på dess säkerhet. I sin slutliga form dök SEAL 1.0-projektet upp först i december 1993 .

1996 Helen Handschuh och Henri Gilbert attacker mot SEAL 1.0 och på själva SEAL 1.0. De behövde texter, vart och ett av fyra 32-bitars ord långa, för att hitta beroendet av pseudoslumpfunktionen på nyckeln . Som ett resultat gjordes vissa förbättringar och ändringar i nästa versioner av SEAL 3.0- och SEAL 2.0- algoritmerna . Till exempel, i version 1.0 slutade varje iteration med en nyckelsekvens med en modifiering av endast två register , och i version 3.0 modifierades alla fyra. SEAL 3.0 och SEAL 2.0 använde också SHA-1 ( Secure Hash Algorithm-1 ) algoritmen för att generera tabeller istället för den ursprungliga SHA , vilket gjorde dem mer motståndskraftiga mot kryptoanalys . $2^{30}$

Beskrivning

När algoritmen beskrivs används följande operationer och notation:

siffror i det hexadecimala talsystemet börjar med tecknen "0x" och använder i posten, förutom decimalsiffror, tecknen "a" , "b" , "c" , "d" , "e" och "f" , som betecknar decimaltal från 10 till 15 respektive;
under uttrycket Y t skall förstås som en cyklisk förskjutning av registret Y till höger med t bitar; $\ggg$
under uttrycket Y t ska förstås som en cyklisk förskjutning av registret Y till vänster med t bitar; $\lll$
operation X Y betyder bitvis logisk multiplikation ( engelska AND ) av registren X och Y ; $\Och$
operation X Y betyder bitvis logisk addition ( engelska OR ) av registren X och Y ; $\lor$
operation X Y betyder bitvis addition modulo 2 ( engelska XOR ) register X och Y ; $\ plus$
under X Y är det nödvändigt att förstå konkatenation ( engelsk sammanfogning ) av register X och Y ; $\lVert$
uttryck udda (X) betecknar en logisk funktion av argumentet X , som utvärderas till TRUE ( eng. TRUE ) endast om X är ett jämnt tal .

Skapa krypteringstabeller från en nyckel

För att undvika förlust av krypteringshastighet vid långsamma operationer använder algoritmen tre tabeller: R , S och T . Dessa tabeller beräknas med hjälp av en procedur från SHA-1- algoritmen och beror endast på nyckeln . Att fylla dessa tabeller kan beskrivas med G -funktionen, som returnerar ett 160-bitars värde från en 160-bitars sträng och ett 32-bitars nummer . $a$ $i$ $G_{a}(i)$

Vi introducerar följande funktioner och variabler beroende på index : $t$

att installera och $0\leq t\leq 19$ $K_{t}={\mbox{0x}}5a827999$ $f_{t}(B,C,D)=(B\And C)\lor (B\And D);$
att installera och $20\leq t\leq 39$ $K_{t}={\mbox{0x}}6ed9eba1$ $f_{t}(B,C,D)=B\oplus C\oplus D;$
att installera och $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);$
att installera och $60\leq t\leq 79$ $K_{t}={\mbox{0x}}ca62c1d6$ $f_{t}(B,C,D)=B\oplus C\oplus D.$

160-bitarssträngen delas sedan upp i fem 32-bitars ord så att $a$ $a=H_{0}\lVert H_{1}\lVert H_{2}\lVert H_{3}\lVert H_{4}.$

Sexton 32-bitars ord skapas också $W_{0}=i,~~W_{1}=W_{2}=...=W_{15}=0^{32}.$

Sedan utförs de slutliga beräkningarna:

${\mbox{För}}~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{För}}~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}.$

Vi introducerar funktionen var för ${\displaystyle \Gamma _{a}(i)=H_{i~mod~5}^{i))$ $H_{0}^{5j}\lVert H_{1}^{5j+1}\lVert H_{2}^{5j+2}\lVert H_{3}^{5j+3}\lVert H_ {4}^{5j+4}=G_{a}(j)$ $j={\mathcal {b}}i/5{\mathcal {c}}.$

Sedan tabeller:

$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.$

Vidare används inte nyckeln i algoritmen. $a$

Initiering av tjänsteregister

Innan en pseudo-slumpmässig funktion genereras måste fyra 32-bitars tjänstregister ( , , och ) och fyra 32-bitars ord ( , , och ) förberedas. Deras värden bestäms från tabellerna och , ett 32-bitars nummer och något nummer i följande procedur. $A$ $B$ $C$ $D$ $n_{1}$ $n_{2}$ ${\displaystyle n_{3))$ ${\displaystyle n_{4))$ $R$ $T$ $n$ $l$

${\mbox{procedur}}~{\mbox{Initialisera}}~(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{för}}~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})\vänsterpil (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;

Skapa en pseudo-slumpmässig funktion

För att kryptera text måste du skapa en pseudo-slumpmässig funktion.

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

$y=0^{L};$

${\mbox{för}}~l\leftarrow 0~{\mbox{to}}~\infty ~{\mbox{do}}$

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

${\mbox{för}}~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)\And {\mbox{0x}}7fc;~~D\leftarrow D+T[P/4];~~C\leftarrow C\ggg 9;~~D\ vänsterpil D\oplus C;$

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

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

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

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

$Q\leftarrow (Q+D)\And {\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\ plus S[4i-1];$

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

${\mbox{if}}~odd(i)~{\mbox{then}}~(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_{ fyra});$

Krypteringsprocessen består av ett stort antal iterationer , som var och en slutar med genereringen av en pseudo-slumpmässig funktion . Antalet godkända iterationer visas av räknaren l . Alla är uppdelade i flera steg med liknande operationer. I varje steg används de övre 9 bitarna i ett av registren ( A , B , C eller D ) som en pekare med vilken ett värde väljs från tabell T. Detta värde adderas aritmetiskt eller bitvis modulo 2 (XOR) med nästa register (återigen ett av A , B , C eller D ). Det första valda registret roteras sedan åt höger med 9 platser. Vidare modifieras antingen värdet för det andra registret genom addition eller XOR med innehållet i det första (redan skiftat) och övergången till nästa steg utförs, eller så utförs denna övergång omedelbart. Efter 8 sådana omgångar läggs värdena A , B , C och D till (arithmetiskt eller XORed ) med vissa ord från tabell S och läggs till i tangentsekvensen y . Det sista steget i iterationen är att lägga till ytterligare 32-bitars värden ( n1 , n2 eller n3 , n4 ) till registren . Dessutom beror valet av ett specifikt värde på pariteten för numret för denna iteration .

Egenskaper och praktisk tillämpning

När man utvecklade denna algoritm ägnades den största uppmärksamheten åt följande egenskaper och idéer:

använda en stor (cirka 2Kbyte ) tabell T erhållen från en stor 160-bitars nyckel ;
alternering av aritmetiska operationer (addition och bitvis XOR );
använda internt systemtillstånd som inte explicit visas i dataströmmen (värdena n1 , n2 , n3 och n4 , som ändrar registren i slutet av varje iteration );
användningen av operationer som skiljer sig från varandra beroende på iterationssteget och dess antal.

SEAL - chifferet kräver ungefär fyra maskincykler för att kryptera och dekryptera varje byte med text . Den körs med cirka 58 Mbps på en 32-bitars 50 MHz-processor och är en av de snabbaste chiffrarna som finns .

Anteckningar

↑ P.Rogaway , D.Coppersmith . En mjukvaruoptimerad krypteringsalgoritm . — 1998.
↑ US-patent 5 454 039 "Programvarueffektiv pseudoslumpfunktion och användningen därav för kryptering"

Källor

Schneier B. Tillämpad kryptografi. Protokoll, algoritmer, källkod i C-språk = Applied Cryptography. Protocols, Algoritms and Source Code i C. - M . : Triumf, 2002. - S. 446-448. — 816 sid. - 3000 exemplar. - ISBN 5-89392-055-4 .
P.Rogaway , D.Coppersmith . En mjukvaruoptimerad krypteringsalgoritm . — 1998.
Helen Handshuh , H. Gilbert -Kryptanalys av SEAL-krypteringsalgoritmen. — 1997. $X^{2}$

Länkar

US-patent 5 675 652 "Datorläsbar enhet som implementerar en mjukvarueffektiv kryptering av pseudoslumpmässiga funktioner"
Inofficiell implementering av SEAL 3.0-algoritmen i C Arkiverad 5 mars 2016 på Wayback Machine
Inofficiell implementering av SEAL 3.0-algoritmen i Delphi Arkiverad 4 mars 2016 på Wayback Machine

Symmetriska kryptosystem
Streama chiffer	A3 A5 A8 Decim F-FCSR Spannmål HC-256 KCipher-2 MICKEY MUGI GÄDDA Phelix RC4 Kanin TÄTA SNÖ SOSEMANUK Salsa20 STRUMOK Trivium VMPC
Feistel nätverk	GOST 28147-89 (Magma) blåsfisk Kamelia CAST-128 CAST-256 CIFERUNICORN-A CIPHERUNICORN-E CLEFIA Kobra HANDLA DES DESX DFC E2 ENRUPT FEAL HPC ANING KASUMI Khafre Khufu LOKI97 MacGuffin MARS MASKA DIMMIG1 Ny DES NDS RC5 RC6 UTSÄDE Simon Sinople skipjack SM4 Fläck TE XTEA XXTEA Raiden RTEA Trippel DES Tvåfisk
SP nätverk	gräshoppa 3 sätt ABC ARIA AES (Rijndael) Akelarre Anubis BaseKing Bas Omatic Bälte CRYPTON Diamant2 grand cru Hierocrypt-3 Hierocrypt-L1 KHAZAD Kalyna djävulen närvarande Regnbåge SÄKRARE HAJ FYRKANT Orm tre fiskar
Övrig	GRODA NUSH REDOC SC2000 SHACAL CS-Chiffer