HC-256

HC-256 er et strømkrypteringssystem udviklet af kryptograf Hongjun Wu fra Institute of Infocommunication Research i Singapore. Først udgivet i 2004. 128-bit versionen blev indsendt til eSTREAM- konkurrencen , som havde til formål at skabe europæiske standarder for strømkrypteringssystemer. Algoritmen var en af de fire finalister i den første profilkonkurrence (stream-cifre til softwareapplikationer med høj båndbredde). [1 ]

Beskrivelse af algoritmen

HC-256- strømchifferen genererer en nøglesekvens (keystream) op til bit lang ved hjælp af en 256-bit hemmelig nøgle og en 256-bit initialiseringsvektor. $2^{128}$

HC-256 indeholder to hemmelige tabeller, hver med 1024 32-bit indgange. Hvert trin opdaterer et element fra tabellen ved hjælp af en ikke-lineær feedbackfunktion. Hvert 2048 trin vil alle elementer i de to tabeller blive opdateret. [en]

Operationer, funktioner, variabler

Algoritmen bruger følgende operationer:

$+$ : x+y betyder x+y mod , hvor 0 x og 0 y : x y betyder x - y mod 1024 : bitvis XOR : sammenkædning : højre skiftoperator med det angivne antal bit : venstre skiftoperator med det angivne antal bits : cirkulært skift til højre, x n betyder ((x n) (x (32 - n)), hvor 0 n 32 og 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 bruger to tabeller, P og Q. Nøglen og initialiseringsvektoren er angivet med henholdsvis K og V. Tastesekvensen er betegnet S.

$P$ : tabel med 1024 32-bit elementer. Hvert element er betegnet med P[i], hvor 0 er 1023. : en tabel med 1024 32-bit elementer. Hvert element er betegnet med P[i], hvor 0 er 1023. : 256-bit nøgle af HC-256 algoritmen. : 256-bit initialiseringsvektor af HC-256 algoritmen. : nøglesekvens genereret af HC-256-algoritmen. 32-bit elementet ved udgangen af det i-te trin er angivet med . S= || || || … $\leq$ $\leq$
$Q$ $\leq$ $\leq$
$K$
$V$
$S$ $S_{i}$ $S_{0}$ $S_{1}$ $S_{2}$

HC-256 har seks 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}}]}$

Her er x = || || || — 32-bit ord. , , , består af 1 byte hver, og , er henholdsvis lav og høj byte. [2] $x_{3}$ $x_{2}$ $x_{1}$ $x_{0}$ $x_{0}$ $x_{1}$ $x_{2}$ $x_{3}$ $x_{0}$ $x_{3}$

Initialiseringsproces

Initialiseringsprocessen i HC-256 består i at konvertere P og Q med en nøgle og en initialiseringsvektor og køre kryptering 4096 gange uden at generere et output.

1. Sammensætning af K = || || … || og V = || || … || , hvor og består af 32 bits. Nøglen og initialiseringsvektoren udvides til et 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))$ tager følgende værdier:

{{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. Opdater tabel P og 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 (nøglesekvensgenereringsalgoritme) 4096 gange uden at generere output.

Initialiseringsprocessen er fuldført, og chifferen er klar til at generere nøglesekvensen. [3]

Algoritme til generering af en nøglesekvens

Hvert trin opdaterer et element fra tabellen og genererer et 32-bit outputelement. Processen til at generere en nøglesekvens er beskrevet nedenfor:

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 Krypteringssikkerhed

Forfatterne fremsatte følgende sikkerhedserklæringer om HC-256:

Der er ingen skjulte defekter i HC-256.
Den mindste periode forventes ikke at være meget større end . $2^{256}$
At genvinde den hemmelige nøgle er lige så svært som brute force.
Et vellykket angreb kræver mere end lidt af nøglesekvensen. $2^{128}$
Der er ingen svage taster i HC-256.

Periode

HC-256-algoritmen sikrer, at nøglesekvensens periode er meget stor. Men det er svært at præcisere det. Den gennemsnitlige periode for en nøglesekvens estimeres til at være ca. $2^{65546}$

Privat nøglesikkerhed

Udgangsfunktionen og feedbackfunktionen på HC-256 er meget ikke-lineær. Den ikke-lineære output-funktion giver mulighed for meget lidt informationslækage ved hvert trin. Den ikke-lineære feedback-funktion sikrer, at den hemmelige nøgle ikke kan bestemmes ud fra denne læk.

Fra analysen af værdierne af funktioner og følger: $h_{1}(x)$ $h_{2}(x)$

For det følger nemlig af betingelsen , at . Da med sandsynlighed ca , er sandsynligheden for , også ca . Det betyder, at der lækkes cirka en bit information ved hver kollision . Samlede kampe. For at gendanne P skal du bruge outputresultater. Så vi kan konkludere, at nøglen til HC-256 er sikker, og at den ikke kan bestemmes hurtigere end en komplet søgning af nøglerne. ${~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\ca. 2^{53.1}~}$

Sikkerhed for initialiseringsprocessen

HC-256 initialiseringsprocessen består af to trin (se ovenfor). P og Q konverteres ved hjælp af nøglen K og initialiseringsvektoren V. Hver bit af K og V påvirker alle bits i de to tabeller, og hver ændring i dem fører til ukontrollerede ændringer i tabellerne. Kryptering kører 4096 gange uden at generere et output, så tabellerne P og Q bliver mere tilfældige. Efter initialiseringsprocessen resulterer ændringer af K og V ikke i ændringer af tastesekvensen. [fire]

Angreb på HC-256

I 2008 foreslog Erik Zenner en måde at angribe HC-256-chifferet på. Det foreslåede timingangreb giver dig mulighed for at gendanne den indre tilstand, som er 2 tabeller med 1024 32-bit elementer, samt nøglen. Angrebet kræver 8 kilobyte af den kendte nøglesekvens, 6148 nøjagtige målinger af cachelæsetiden og beregningstid svarende til nøgletesttiden. Det følger heraf, at HC-256 i teorien er sårbar over for timing angreb. [5] $2^{55}$

Du bør også være opmærksom på udgivelsen af Gautham Sekar og Bart Preneel, som foreslår en klasse af kendetegn, som hver især kræver test af nær- lineære funktioner. Hver ligning indeholder 8 bits af nøglesekvensen. Sandsynligheden for et vellykket resultat er 0,9772. Til sammenligning krævede en lignende metode kendt før og foreslået af forfatteren til HC-256 selv funktioner, som hver inkluderede 10 bits af en nøglesekvens. [6] $2^{276.8}$ $2^{280}$

Konklusion

HC-256 er praktisk til moderne mikroprocessorer . Afhængigheden mellem operationer i HC-256 holdes på et minimum: tre på hinanden følgende trin af algoritmen kan beregnes parallelt. Paralleliseringsevnen gør det muligt for HC-256 at være effektiv i nutidens processorer. Forfatterne implementerede HC-256 i programmeringssproget C og testede dens ydeevne på Pentium 4-processoren . HC-256-krypteringshastigheden når 1,93 bps. HC-256 er ikke patenteret og er frit tilgængelig. [7]

Noter

↑ Hongjun Wu . Stream Cipher HC-256, s. en.
↑ Hongjun Wu . Stream Cipher HC-256, s. 2.
↑ 12 Hongjun Wu . Stream Cipher HC-256, s. 3.
↑ Hongjun Wu . Stream Cipher HC-256, s. 4-6.
↑ Erik Zenner . Cache-timingsanalyse af eStream-finalister, s. 1-4.
↑ Gautham Sekar og Bart Preneel . Forbedrede skelnende angreb på HC-256, s. 1, 2, 6.
↑ Hongjun Wu . Stream Cipher HC-256, s. 1, 14.

Links

Symmetriske kryptosystemer
Stream-cifre	A3 A5 A8 Decim F-FCSR Korn HC-256 KCipher-2 MICKEY MUGI GEDD Phelix RC4 Kanin FORSEGLE SNE SOSEMANUK Salsa 20 STRUMOK Trivium VMPC
Feistel netværk	GOST 28147-89 (Magma) blæsefisk Camellia CAST-128 CAST-256 CIFERUNIKORN-A CIFERUNIKORN-E CLEFIA Cobra DEL DES DESX DFC E2 ENRUPT FEAL HPC IDE KASUMI Khafre Khufu LOKI97 MacGuffin MARS MESH MISTY1 NyDES NDS RC5 RC6 FRØ Simon Sinople skipjack SM4 Speck TE XTEA XXTEA Raiden RTEA Triple DES To fisk
SP netværk	Græshoppe 3 vejs ABC ARIA AES (Rijndael) Akelarre Anubis BaseKing Bas Omatic Bælte CRYPTON Diamant 2 grand cru Hierocrypt-3 Hierocrypt-L1 KHAZAD Kalyna Lucifer til stede Regnbue SIKRERE HAJ FIRKANT Slange tre fisk
Andet	FRØ NUSH REDOC SC2000 SHACAL CS-Cipher