HC-256

HC-256 är ett strömkrypteringssystem utvecklat av kryptografen Hongjun Wu från Institute of Infocommunication Research i Singapore. Första gången publicerad 2004. 128-bitarsversionen skickades till eSTREAM- tävlingen , som syftade till att skapa europeiska standarder för strömkrypteringssystem. Algoritmen var en av de fyra finalisterna i den första profiltävlingen (strömningschiffer för mjukvaruapplikationer med hög bandbredd). [1 ]

Beskrivning av algoritmen

HC-256- strömchifferet genererar en nyckelsekvens (nyckelström) upp till bitar lång med hjälp av en 256-bitars hemlig nyckel och en 256-bitars initialiseringsvektor. $2^{128}$

HC-256 innehåller två hemliga tabeller, var och en med 1024 32-bitars poster. Varje steg uppdaterar ett element från tabellen med hjälp av en icke-linjär återkopplingsfunktion. Varje 2048:e steg kommer alla element i de två tabellerna att uppdateras. [ett]

Operationer, funktioner, variabler

Algoritmen använder följande operationer:

$+$ : x+y betyder x+y mod , där 0 x och 0 y : x y betyder x - y mod 1024 : bitvis XELLER : sammanlänkning : höger skiftoperator med angivet antal bitar : vänster skiftoperator med angivet antal bitar : cirkulär förskjutning åt höger, x n betyder ((x n) (x (32 - n)), där 0 n 32 och 0 x $2^{32}$ $\leq$ $<$ $2^{32}$ $\leq$ $<$ $2^{32}$
$\boxminus$ $\boxminus$
$\ plus$
$||$
$\gg$
$\ll$
$\ggg$ $\ggg$ $\gg$ $+$ $\ll$ $\leq$ $<$ $\leq$ $<$ $2^{32}$

HC-256 använder två tabeller, P och Q. Nyckeln och initialiseringsvektorn betecknas med K respektive V. Tangentsekvensen betecknas S.

$P$ : tabell med 1024 32-bitars element. Varje element betecknas med P[i], där 0 är 1023. : en tabell med 1024 32-bitars element. Varje element betecknas med P[i], där 0 är 1023. : 256-bitars nyckel för HC-256-algoritmen. : 256-bitars initialiseringsvektor för HC-256-algoritmen. : nyckelsekvens genererad av HC-256-algoritmen. 32-bitarselementet vid utgången av det i:te steget betecknas med . S= || || || … $\leq$ $\leq$
$F$ $\leq$ $\leq$
$K$
$V$
$S$ $Si}$ $S_{0}$ $S_{1}$ $S_{2}$

HC-256 har sex funktioner:

${{f_{1}}(x)=(x>>>7)\oplus (x>>>18)\oplus (x>>3)}$
${{f_{2}}(x)=(x>>>17)\oplus (x>>>19)\oplus (x>>10)}$
${{g_{1}}(x,y)=((x>>>10)\oplus (y>>>23))+Q[(x\oplus y)mod~1024]}$
${{g_{2}}(x,y)=((x>>>10)\oplus (y>>>23))+P[(x\oplus y)mod~1024]}$
${{h_{1}}(x)=Q[{x_{0}}]+Q[256+{x_{1}}]+Q[512+{x_{2}}]+Q[768+{x_{3}}]}$
${{h_{2}}(x)=P[{x_{0}}]+P[256+{x_{1}}]+P[512+{x_{2}}]+P[768+{x_{3}}]}$

Här är x = || || || — 32-bitars ord. , , , består av 1 byte vardera, och , är låg respektive hög byte. [2] $x_{3}$ $x_{2}$ $x_{1}$ $x_{0}$ $x_{0}$ $x_{1}$ $x_{2}$ $x_{3}$ $x_{0}$ $x_{3}$

Initieringsprocess

Initieringsprocessen i HC-256 består av att konvertera P och Q med en nyckel och en initieringsvektor och köra kryptering 4096 gånger utan att generera en utdata.

1. Komponera K = || || … || och V = || || … || , där och består av 32 bitar. Nyckeln och initialiseringsvektorn expanderas till en array (0 i 2559). $K_{0}$ $K_1$ ${\displaystyle K_{7))$ $V_{0}$ $V_{1}$ ${\displaystyle V_{7))$ $K_{i}$ $V_i$ $W_i$ $\leq$ $\leq$

${W_{i))$ tar följande värden:

{{K_{i}},~0\leq i\leq 7}

{{V_{i-8)),~8\leq i\leq 15}

{{f_{2}}({W_{i-2}})+W_{i-7}+f_{1}(W_{i-15})+W_{i-16}+i, ~16\leq i\leq 2559}

2. Uppdatera tabellerna P och Q med W:

${\displaystyle {{P[i]}={W_{i+512)),~0\leq i\leq 1023))$
${\displaystyle {{Q[i]}={W_{i+1536)),~0\leq i\leq 1023))$

3. Kör kryptering (nyckelsekvensgenereringsalgoritm) 4096 gånger utan att generera utdata.

Initieringsprocessen är klar och chiffern är redo att generera nyckelsekvensen. [3]

Algoritm för att generera en nyckelsekvens

Varje steg uppdaterar ett element från tabellen och genererar ett 32-bitars utdataelement. Processen för att generera en nyckelsekvens beskrivs nedan:

i=0;
repeat until enough keystream bits are generated.
{

j = i mod 1024;
if (i mod 2048) < 1024
{ P[j] = P[j] + P[j

\boxminus

10] +

g_{1}

(P[j

\boxminus

3], P[j

\boxminus

1023]);

S_{i}=h_{1}

(P[j

\boxminus

12])

\oplus

P[j];
} else
{ Q[j] = Q[j] + Q[j

\boxminus

10] +

g_{2}

(Q[j

\boxminus

3], Q[j

\boxminus

1023]);

S_{i}=h_{2}

(Q[j

\boxminus

12])

\oplus

Q[j];
} end-if
i = i + 1;

}
end-repeat
[3]

HC-256 Encryption Security

Författarna gjorde följande säkerhetsförklaringar om HC-256:

Det finns inga dolda defekter i HC-256.
Den minsta perioden förväntas inte bli mycket större än . $2^{256}$
Att återställa den hemliga nyckeln är lika svårt som brute force.
En framgångsrik attack kräver mer än lite av nyckelsekvensen. $2^{128}$
Det finns inga svaga nycklar i HC-256.

Period

HC-256-algoritmen säkerställer att nyckelsekvensens period är mycket stor. Men det är svårt att precisera det. Den genomsnittliga perioden för en nyckelsekvens uppskattas till ca . $2^{65546}$

Privat nyckelsäkerhet

Utgångsfunktionen och återkopplingsfunktionen hos HC-256 är mycket icke-linjär. Den icke-linjära utgångsfunktionen tillåter mycket lite informationsläckage vid varje steg. Den icke-linjära återkopplingsfunktionen säkerställer att den hemliga nyckeln inte kan fastställas från denna läcka.

Från analysen av funktionernas värden och följer: $h_{1}(x)$ $h_{2}(x)$

Av villkoret följer nämligen att . Eftersom med sannolikhet om , är sannolikheten att , också om . Det betyder att ungefär en bit information läcker ut vid varje kollision . Totalt antal matcher. För att återställa P behöver du utdataresultat. Så vi kan dra slutsatsen att nyckeln till HC-256 är säker och att den inte kan fastställas snabbare än en fullständig sökning av nycklarna. ${~2048*\alpha \leq i<j<2048*\alpha +1024~}$ ${~{S_{i}}={S_{j}}~}$ ${~h_{1}(x)(P[i\boxminus 12])\oplus P[i]=h_{1}(x)(P[j\boxminus 12])\oplus P[j] ~}$ ${~h_{1}(x)(P[i\boxminus 12])=h_{1}(x)(P[j\boxminus 12])~}$ ${2^{-31))$ ${~P[i]=P[j]~}$ ${2^{-31))$ ${2^{-26.1))$ ${\approx 2^{-12}~}$ ${~{\frac {1024*32}{2^{-12}*2^{-26.1}}}*1024\approx 2^{53.1}~}$

Säkerhet för initieringsprocessen

HC-256-initieringsprocessen består av två steg (se ovan). P och Q omvandlas med hjälp av nyckeln K och initialiseringsvektorn V. Varje bit av K och V påverkar alla bitarna i de två tabellerna, och varje ändring i dem leder till okontrollerade ändringar i tabellerna. Kryptering körs 4096 gånger utan att generera en utdata, så tabellerna P och Q blir mer slumpmässiga. Efter initieringsprocessen resulterar ändringar i K och V inte i ändringar i tangentsekvensen. [fyra]

Attacker på HC-256

2008 föreslog Erik Zenner ett sätt att attackera HC-256-chifferet. Den föreslagna timingattacken låter dig återställa det inre tillståndet, vilket är 2 tabeller med 1024 32-bitars element, såväl som nyckeln. Attacken kräver 8 kilobyte av den kända nyckelsekvensen, 6148 exakta mätningar av cache-lästiden och beräkningstid som motsvarar nyckeltestningstiden. Det följer att, i teorin, är HC-256 sårbar för timingattacker. [5] $2^{55}$

Du bör också vara uppmärksam på publiceringen av Gautham Sekar och Bart Preneel, som föreslår en klass av särskiljare, som var och en kräver testning av nära linjära funktioner. Varje ekvation inkluderar 8 bitar av nyckelsekvensen. Sannolikheten för ett framgångsrikt resultat är 0,9772. Som jämförelse krävde en liknande metod känd tidigare och föreslagen av författaren till HC-256 själv funktioner, som var och en inkluderade 10 bitar av en nyckelsekvens. [6] $2^{276.8}$ $2^{280}$

Slutsats

HC-256 är praktiskt för moderna mikroprocessorer . Beroendet mellan operationer i HC-256 hålls till ett minimum: tre på varandra följande steg av algoritmen kan beräknas parallellt. Parallelliseringsförmågan gör att HC-256 är effektiv i dagens processorer. Författarna implementerade HC-256 i programmeringsspråket C och testade dess prestanda på Pentium 4-processorn . HC-256-krypteringshastigheten når 1,93 bps. HC-256 är inte patenterad och är fritt tillgänglig. [7]

Anteckningar

↑ Hongjun Wu . Stream Cipher HC-256, sid. ett.
↑ Hongjun Wu . Stream Cipher HC-256, sid. 2.
↑ 12 Hongjun Wu . Stream Cipher HC-256, sid. 3.
↑ Hongjun Wu . Stream Cipher HC-256, sid. 4-6.
↑ Erik Zenner . Cachetidsanalys av eStream-finalister, sid. 1-4.
↑ Gautham Sekar och Bart Preneel . Förbättrade särskiljande attacker på HC-256, sid. 1, 2, 6.
↑ Hongjun Wu . Stream Cipher HC-256, sid. 1, 14.

Länkar

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