ACE Encrypt

ACE (avancerad kryptografisk motor) är samlingen av enheter som implementerar både ett krypteringsschema för publik nyckel och ett digitalt signaturschema. Motsvarande namn för dessa system — «ACE Encrypt» och «ACE Sign». Scheman är baserade på Cramer-Shoups publika nyckelkrypteringsschema och Cramer-Shoups signaturschema. Introducerade varianter av dessa system är avsedda att uppnå en bra balans mellan prestanda och säkerhet för hela krypteringssystemet.

Författare

Alla algoritmer, implementerade i ACE är baserade på algoritmer utvecklade av Victor Shoup och Ronald Cramer. Den fullständiga algoritmspecifikationen är skriven av Victor Shoup. Implementering av algoritmer görs av Thomas Schweinberger och Mehdi Nassehi, dess stöd och underhåll görs av Victor Shoup. Thomas Schweinberger deltog i konstruktionen av ACE-specifikationsdokumentet och skrev även en användarmanual.

Ronald Cramer stannar för närvarande på universitetet i Århus, Danmark . Han arbetade på ACE Encrypt-projektet medan han bodde på ETH i Zürich , Schweiz .

Mehdi Nassehi och Thomas Schweinberger arbetade med ACE-projektet i IBMs forskningslabb i Zürich , Schweiz . Victor Shoup arbetar i IBMs forskningslabb i Zürich , Schweiz .

säkerhet

Krypteringsschemat i ACE kan bevisas säkert under rimliga och naturliga antaganden om svårhanterlighet. Dessa fyra antaganden är:

• Antagandet om Decision Diffie-Hellman (DDH).
• Starkt RSA-antagande
• SHA-1 sekund kollisionsmotstånd före bilden
• MARS summa/räknarläge pseudo-slumpmässighet

Grundläggande terminologi och notation

Här introducerar vi några notationer som används i den här artikeln.

Grundläggande matematisk notation

$\mathbb {Z}$ — Uppsättningen av heltal. $F_{2}[T]$ — Mängden univariata polynom med koefficienter i det finita fältet $F_{2}$ av kardinalitet 2. $A \operatörsnamn {rem} n$ — heltal $r\in \left\{0,\dots ,n-1\right\}$ så att $A\equiv r{\pmod {n}}$ för heltal $n>0$ och $A\in \mathbb {Z}$ . $A\operatörsnamn {rem} f$ — polynom $r\in F_{2}[T]$ med $\deg(r)<\deg(f)$ så att $A\equiv r{\pmod {f}}$ med $A,f\in F_{2}[T],f\neq 0$ .

Grundläggande strängnotation

$A^{\ast }$ — Uppsättningen av alla strängar. $A^{n}$ — Uppsättningen av alla strängar med längden n. För $x\in A^{\ast }L(x)$ — längden på strängen $x$ . Strängen med längden noll betecknas $\lambda _{A}$ . För $x,y\in A^{\ast }$$x\|y$ — resultatet av $x$ och $y$ sammanlänkning.

Bitar, bytes, ord

${\displaystyle b{\overset {\text{def}}{{}={}}}\left\{0,1\right\}} — Uppsättningen bitar$ . Låt oss ta alla uppsättningar av form $b,b^{n_{1}},(b^{n_{1}})^{n_{2}},...$ . För en sådan uppsättning A definierar vi "nollelementet":

$0_{b}{\stackrel {\mathrm {def} }{=}}0\in b$ ; $0_{A^{n}}{\stackrel {\mathrm {def} }{=}}(0_{A},. ..,0_{A})\in A^{n}$ för $n>0$ .

Vi definierar $B{\stackrel {\mathrm {def} }{{}={}}}b^{8}$ som en uppsättning byte, och $W{\stackrel {\mathrm {def} }{{}={}}}b^{32}$ som en uppsättning ord.

För $x\in A^{\ast }$ med $A\in \left\{b,B,W\right\}$ och $l>0$ definierar vi en utfyllnadsoperator:

$pad_{l}(x){\stackrel {\mathrm {def} }{=}}{\begin{cases}x,&L(x) \geq l\\x||0_{A^{lL(x)}},&L(x)<l\end{fall}}$ .

Konverteringsoperatör

Omvandlingsoperator $I_{src}^{dst}:src\to dst$ gör en omvandling mellan elementen $Z,F_{2}[T],b^{\ast },B^{\ast },W^{\ast }$ .

Krypteringsschema

Krypteringsnyckelpar

Krypteringsschemat använder två nyckeltyper: ACE offentlig nyckel: $(P,q,g_{1 },g_{2},c,d,h_{1},h_{2},k_{1},k_{2})$ . ACE privat nyckel: $(w,x,y,z_{1},z_{2})$ . För en given storleksparameter $m$ , så att $1024\leq m\leq 16384$ , definieras nyckelkomponenter som: $q$ — ett 256-bitars primtal . $P$ — ett m-bitars primtal, så att $P\equiv 1{\pmod {q}}$ . $g_{1},g_{2},c,d,h_{1},h_{2}$ — element $\left\{1,\dots ,P-1\right\}$ (vars multiplikativ ordning modulo $P$ delar $q$ ). $w,x,y,z_{1},z_{2}$ — element $\left\{0,\ prickar ,q-1\right\}$ . $k_{1},k_{2}$ — element $B^{\ast }$ med $L(k_ {1})=20l'+64$ och $L(k_{2})=32\left\lceil l/16\right\rceil +40$ , där $l=\left\lceil m/8\right\rceil$ och ${ \displaystyle l'=L_{b}(\left\lceil (2\left\lceil l/4\right\rceil +4)/16\right\rceil )}$ .

Nyckelgenerering

Algoritm. Nyckelgenerering för ACE-krypteringsschema. Inmatning: en storleksparameter $m$ , så att $1024\leq m\leq 16384$ . Utgång: ett offentligt/privat nyckelpar.

1. Generera ett slumpmässigt primtal $q$ , så att $2^{255}<q<2^{256}$ .
2. Generera ett slumpmässigt primtal $P$ , $2^{m-1}<P<2^{m}$ , så att $P\equiv 1(modq)$ .
3. Generera ett slumpmässigt heltal ${\displaystyle g_{1}\in \left\{2,...,P-1\right\}} ,$ så att $g_ {1}^{q}\equiv 1(modP)$ .
4. Generera slumpmässiga heltal $w\in \left\{1,...,q-1\right\}$ och $x,y,z_{1},z_{2}\in \left\{0,...,q-1\right\}$
5. Beräkna följande heltal i $\left\{1,...,P-1\right\}$ :
   
   
   
   
   $g_{2}\leftarrow g_{1}^{w}remP$ , $c\leftarrow g_{1}^ {x}remP$ , $d\leftarrow g_{1}^{y}remP$ , $h_{1} \leftarrow g_{1}^{z_{1}}remP$ , $h_{2}\leftarrow g_{1}^{z_{2}}remP$ .
6. Generera slumpmässiga bytesträngar $k_{1}\in B^{20l'+64}$ och $k_{2 }\in B^{2\left\lceil l/16\right\rceil +40}$ , där $l=L_{B}(P)$ och $l'=L_{B}(\left\lceil (2\left\lceil l/4\right\rceil +4)/16\ höger\rceil )$ .
7. Returnera den offentliga nyckeln/privata nyckelparet
   $((P, q,g_{1},g_{2},c,d,h_{1},h_{2},k_{1},k_{2}),(w,x,y,z_{1},z_ {2}))$

Chiffertextrepresentation

En chiffertext av ACE-krypteringsschemat har formen

$(s,u_{1},u_{2},v,e)$ ,

där komponenterna definieras som: $u_{1},u_{2},v$ — heltal från $\left\{1,...,P-1\right\}$ (vars multiplikativ ordning modulo $P$ delar $q$ ). $s$ — element $W^{4}$ . $e$ — element $B^{\ast }$ . $s,u_{1},u_{2},v$ kallar vi ingressen och $e$ — kryptogrammet . Om en klartext är en sträng som består av $l$ байт, så är längden av $e$ lika med $l+16\left\lceil l/1024 \right\rceil$ . Vi måste introducera funktionen $CEncode$ , som mappar en chiffertext till dess byte-sträng

representation, och den motsvarande inversa funktionen $CDecode$ . För heltal $l>0$ , ordsträng $s\in W^{4}$ , heltal $0\leq u_{1},u_{2},v<256^{l}$ och bytesträngen $e\in B^{\ast }$ ,

$CEncode(l,s,u_{1},u_{2},v,e){\stackrel {\mathrm {def} }{=}}I_{W^{\ast }} ^{B^{\ast }}(s)||pad_{l}(I_{Z}^{B^{\ast }}(u_{1}))||pad_{l}(I_{Z} ^{B^{\ast }}(u_{2}))||pad_{l}(I_{Z}^{B^{\ast }}(v))||e\in B^{\ast }$ .

För heltal $l>0$ , bytesträng $\psi \in B^{\ast }$ , så att $L(\ psi )\geq 3l+16$ ,

$CDecode(l,\psi ){\stackrel {\mathrm {def} }{=}}(I_{B^{\ast }}^{W^{\ast }}({\Bigl [ }\psi {\Bigr ]}_{0}^{16}),I_{B^{\ast }}^{Z}({\Bigl [}\psi {\Bigr]}_{16}^{ 16+l}),I_{B^{\ast }}^{Z}({\Bigl [}\psi {\Bigr ]}_{16+l}^{16+2l}),I_{B^ {\ast }}^{Z}({\Bigl [}\psi {\Bigr ]}_{16+2l}^{16+3l}),{\Bigl [}\psi {\Bigr ]}_{ 16+3l}^{L(\psi )})\in W^{4}\times Z\times Z\times Z\times B^{\ast }$ .

Krypteringsprocess

Algoritm. ACE asymmetrisk krypteringsoperation. ingång: offentlig nyckel $(P,q,g_{1},g_{2},c ,d,h_{1},h_{2},k_{1},k_{2})$ och bytesträng $M\in B^{\ast }$ . Utdata: byte sträng — chiffertext $\psi \$ av $M$ .

1. Generera $r\in \left\{0,...,q-1\right\}$ slumpmässigt.
2. Generera chiffertextingressen:
   1. Generera $s\in W^{4}$ slumpmässigt.
   2. Beräkna $u_{1}\leftarrow g_{1}^{r}remP$ , $u_{2}\leftarrow g_{2}^{r}remP$ .
   3. Beräkna $\alpha \ \leftarrow UOWHash^{\prime }(k_{1} ,L_{B}(P),s,u_{1},u_{2})\in Z$ ; Observera att $0<\alpha \ <2^{160}$ .
   4. Beräkna $v\leftarrow c^{r}d^{\alpha \ r}remP$ .
3. Beräkna nyckeln för den symmetriska krypteringsoperationen:
   1. ${\tilde {h_{1}}}\leftarrow h_{1}^{r}remP$ , ${\ displaystyle {\tilde {h_{2}}}\leftarrow h_{2}^{r}remP}$ .
   2. Beräkna $k\leftarrow ESHash(k,L_{B }(P),s,u_{1},u_{2},{\tilde {h_{1}}},{\tilde {h_{2}}})\in W^{8}$ .
4. Beräkna kryptogram $e\leftarrow SEnc(k,s,1024,M)$ .
5. Koda chiffertexten:
   $\psi \ \leftarrow CEncode(L_{B}(P),s,u_{ 1},u_{2},v,e)$ .
6. Returnera $\psi \$ .

Innan den symmetriska krypteringsprocessen påbörjas delas ingångsmeddelandet $M\in B^{\ast }$ in i block ${\displaystyle M_{1},...,M_{t}} ,$ där vart och ett av blocken, möjligen utom det sista, är på 1024 byte. Varje block krypteras av strömchifferet. För varje krypterat block $E_{i}$ beräknas 16-byte meddelandeautentiseringskod. Vi får kryptogrammet

$e=E_{1}||C_{1}||...||E_{t}||C_{t}$ . $L(e)=L(M)+16\left\lceil L(M)/m\right\rceil$ .

Observera att om $L(M)=0$ så är $L(e)=0$ .

Algoritm. ACE asymmetrisk krypteringsprocess. Ingång: $(k,s,M,m)\in W^{8}\times W^{4}\times Z\ gånger B^{\ast }$$m>0$ Utdata: $e\in B^{l}$ , $l=L(M)+16\left\lceil L(N)/m\right\rceil$ .

1. Om $M=\lambda _{B}$ , returnera $\lambda _{B}$ .
2. Initiera ett pseudo-slumpgeneratortillstånd:
   $genState\leftarrow InitGen(k,s)\in GenState$
3. Generera nyckeln $k_{AXU}AXUHash$ :
   $(k_{AXU},genState)\leftarrow GenWords((5L_{b}(\left\lceil m/64\right\rceil)+24),genState).$ .
4. $e\leftarrow \lambda _{B},i\leftarrow 0$ .
5. Medan $i<L(M)$ gör du följande:
   1. $r\leftarrow min(L(M)-i,m)$ .
   2. Generera maskvärden för krypteringen och MAC:
      1. $(mask_{m},genState)\leftarrow GenWords(4,genState)$ .
      2. $(mask_{e},genState)\leftarrow GenWords(r,genState)$ .
   3. Kryptera klartexten: $enc\leftarrow {\Bigl [}M{\Bigr ]}_{i}^{i+r}\oplus mask_{e}$ .
   4. Generera meddelandeautentiseringskoden:
      1. Om $i+r=L(M)$ , då $lastBlock\leftarrow 1$ ; else $lastBlock\leftarrow 0$ .
      2. $mac\leftarrow AXUHash(k_{AXU},lastBlock,enc )\in W^{4}$ .
   5. Uppdatera chiffertexten: $e\leftarrow e||enc||I_{W^{\ast }}^{B^{\ast }}(mac\oplus mask_{m})$ .
   6. $i\leftarrow i+r$ .
6. Returnera $e$ .

Dekrypteringsprocess

Algoritm. ACE-dekrypteringsprocess. Ingång: publik nyckel $(P,q,g_{1},g_{2},c ,d,h_{1},h_{2},k_{1},k_{2})$ och motsvarande privat nyckel $(w,x,y ,z_{1},z_{2})$ , byt e sträng $\psi \in B^{\ast }$ . Utdata: Dekrypterat meddelande $M\in B^{\ast }\cup {Reject}$ .

1. Dekryptera chiffertexten:
   1. Om $L(\psi )<3L_{B}(P)+16$ , returnera $Reject$ .
   2. Beräkna:
      $(s,u_{ 1},u_{2},v,e)\vänsterpil CDecode(L_{B}(P),\psi )\in W^{4}\times Z\times Z\times Z\times B^{\ast }$ ;
      
      Observera att $0\leq u_{1},u_{2},v<256^{l}$ , där $l =L_{B}(P)$ .
2. Verifiera chiffertextens ingress:
   1. Om $u_{1}\geq P$ eller $u_{2}\geq P$ eller $v\geq P$ , returnera sedan $Reject$ .
   2. Om $u_{1}^{q}\neq 1remP$ , returnera $Reject$ .
   3. $reject\leftarrow 0$ .
   4. Om $u_{2}\neq u_{1}^{w}remP$ , då $reject\leftarrow 1$ .
   5. Beräkna $\alpha \leftarrow UOWHash^{\prime }(k_{1}, L_{B}(P),s,u_{1},u_{2})\in Z$ ; Observera att $0\leq \alpha \leq 2^{160}$ .
   6. Om $v\neq u_{1}^{x+{\alpha }y}remP$ , då $reject\leftarrow 1$ .
   7. Om $reject=1$ , returnera sedan $Reject$ .
3. Beräkna nyckeln för den symmetriska dekrypteringsoperationen:
   1. ${\tilde {h_{1}}}\leftarrow u_{1}^{z_{1}}remP$ , ${\tilde {h_{2}}}\leftarrow u_{1}^{z_{2}}remP$ .
   2. Beräkna $k\leftarrow ESHash(k_{2},L_{ B}(P),s,u_{1},{\tilde {h_{1}}},{\tilde {h_{2}}})\in W^{8}$ .
4. Beräkna $M\leftarrow SDec(k,s,1024,e)$ ;observera att $SDec$ kan returnera $Reject$ .
5. Returnera $M$ .

Algoritm. Dekrypteringsoperation $SDec$ . Ingång: $(k,s,m,e)\in W^{8}\times W^{4}\times Z\times B^{\ast }$$m>0$ Utdata: Dekrypterat meddelande $M\in B^{\ast }\cup {Reject }$ .

1. Om $e=\lambda _{B}$ , returnera $\lambda _{B}$ .
2. Initiera ett pseudo-slumpgeneratortillstånd:
   $genState\leftarrow InitGen(k,s)\in GenState$
3. Generera nyckeln $k_{AXU}AXUHash$ :
   $(k_{AXU},genState^{\prime })\leftarrow GenWords((5L_{b}(\left\lceil m/64\right\rceil )+24),genState).$ .
4. $M\leftarrow \lambda _{B},i\leftarrow 0$ .
5. Medan $i<L(e)$ gör du följande:
   1. $r\leftarrow min(L(e)-i,m+16)-16$ .
   2. Om $r\leq 0$ , returnera $Reject$ .
   3. Generera maskvärden för krypteringen och MAC:
      1. $(mask_{m},genState)\leftarrow GenWords(4,genState)$ .
      2. $(mask_{e},genState)\leftarrow GenWords(r,genState)$ .
   4. Verifiera meddelandeautentiseringskoden:
      1. Om $i+r+16=L(M)$ , då $lastblock\leftarrow 1$ ; annars $lastblock\leftarrow 0$ .
      2. $\displaystyle mac\leftarrow AXUHash(k_{AXU} ,lastBlock,{\Bigl [}e{\Bigr ]}_{i}^{i+r})\in W^{4}}$ .
      3. Om ${\displaystyle {\Bigl [}e{\Big ]}r_{i+r} ^{i+r+16}\neq I_{W^{\ast }}^{B^{\ast }}(mac\oplus mask_{m})} , returnera sedan R$ e $displaystyle Avvisa}$ .
   5. Uppdatera klartexten: $M\leftarrow M||({\Bigl [}e{\Bigr ]}_{i}^{i+r})\oplus mask_{e})$ .
   6. $i\leftarrow i+r+16$ .
6. Returnera $M$ .

Signaturschema

Signaturschemat använder två nyckeltyper: ACE Signatur offentlig nyckel: $(N,h,x,e',k',s)$ . ACE Signatur privat nyckel: $(p,q,a)$ . För den givna storleksparametern $m$ , så att $1024\leq m\leq 16384$ , definieras nyckelkomponenter på följande sätt: $p$ — $\left\lfloor m/2\right\rfloor$ -bitars primtal med $(p-1)/2$ — är också ett primtal. $q$ — $\left\lfloor m/2\right\rfloor$ -bitars primtal med $(q-1)/2$ — är också ett primtal. $N$ — $N=pq$ och har antingen $m$ eller $m-1$ бит. $h,x$ — element $\left\{1,...,N-1\right\}$ (kvadratiska rester modulo $N$ ). $e'$ — 161-bitars primtal. $a$ — element $\left\{0,...,(p-1)(q-1)/4-1\right\}$$k'$ — element $B^{184}$ . $s$ — element $B^{32}$ .

Nyckelgenerering

Algoritm. Nyckelgenerering för ACE-signaturschemat med publika nyckel. Indata: storleksparameter $m$ , så att $1024\leq m\leq 16384$ . Utgång: offentligt/privat nyckelpar.

1. Generera slumpmässiga primtal $p,q$ , så att $(p-1)/2$ och $(q-1 )/2$ — är också ett primtal, och
   
   $2^{m_{1}-1}<p<2^{m_{1}}$ , ${\ displaystyle 2^{m_{2}-1}<q<2^{m_{2}}}$ , и $p\neq q$ , där
   $m_{1}=\left\lfloor m/2\right\rfloor$ och $m_{1}=\left\lceil m /2\right\rceil$ .
2. Ställ in $N\leftarrow pq$ .
3. Generera slumpmässigt primtal $e'$ , где $2^{160}\leq e'\leq 2^{161$ .
4. Generera slumpmässiga ${\displaystyle h'\in \left\{1,...,N-1\right\}} ,$ med hänsyn till $gcd( h',N)=1$ och $gcd(h'\pm 1,N)=1$ och beräkna $h\leftarrow (h')^{-2}remN$ .
5. Generera slumpmässigt $a\in \left\{0,...,(p-1)(q-1)/4-1\right\}$ och beräkna $x\leftarrow h^{a}remN$ .
6. Generera slumpmässiga bytesträngar $k'\in B^{184}$ , och $s\in B^{32}$ .
7. Returnera offentlig nyckel/privat nyckelpar
   $((N,h,x,e',k',s),(p,q, a))$ .

Signaturrepresentation

Signaturen i ACE-signaturschemat har formen ${\displaystyle (d,w,y,y',{\tilde {k}})} ,$ där komponenterna är definierat på följande sätt: $d$ — element $B^{64}$ . $w$ — heltal, så att $2^{160}\leq w\leq 2^{161}$ . $y,y'$ — element $\left\{1,...,N-1\right\}$ . ${\tilde {k}}$ — element $B^{\ast }$ ;observera att ${\displaystyle L({\tilde {k}})=64+20L_{B}(\left\lceil (L(M)+8)/64\right\rceil )} ,$ där ${ \displaystyle M}$ — meddelande undertecknas.

Vi måste introducera funktionen $SEncode$ , som mappar en signatur till dess bytesträngrepresentation, och den motsvarande inversa funktionen $SDecode$ . För heltal $l>0$ , byte string $d\in B^{64}$ , heltal $0\leq w\leq 256^{21 }$ och $0\leq y,y'<256^{l}$ , och bytesträngen ${\tilde {k}}\in B ^{\ast }$ ,

$SEncode(l,d,w,y,y',{\tilde {k}}){\stackrel {\mathrm {def} }{=}}d||pad_{21} (I_{Z}^{B^{\ast }}(w))||pad_{l}(I_{Z}^{B^{\ast }}(y))||pad_{l}(I_ {Z}^{B^{\ast }}(y'))||{\tilde {k}}\in B^{\ast }$ .

För heltal $l>0$ , bytesträng $\sigma \in B^{\ast }$ , där $L(\sigma )\geq 2l+53$ ,

$CSecode(l,\sigma ){ \stackrel {\mathrm {def} }{=}}({\Bigl [}\sigma {\Bigr ]}_{0}^{64},I_{B^{\ast }}^{Z}({ \Bigl [}\sigma {\Bigr ]}_{64}^{85}),I_{B^{\ast }}^{Z}({\Bigl [}\sigma {\Bigr ]}_{85 }^{85+l}),I_{B^{\ast }}^{Z}({\Bigl [}\sigma {\Bigr]}_{85+l}^{85+2l}),{ \Bigl [}\sigma {\Bigr ]}_{85+2l}^{L(\sigma )})\in B^{64}\times Z\times Z\times Z\times B^{\ast }$ .

Process för att skapa signatur

Algoritm. Process för generering av ACE-signatur. Inmatning: publik nyckel $(N,h,x,e',k',s)$ och motsvarande privat nyckel ${ \displaystyle (p,q,a)}$ och bytesträng $M\in B^{\ast }$ , $0\leq L(M)\ leq 2^{64}$ . Utdata: bytesträng — digital signatur $\sigma \in B^{\ast }$ .

1. Utför följande steg för att hasha indata:
   1. Generera en hash-nyckel ${\tilde {k}}\in B^{20m+64}$ slumpmässigt, så att $m=L_{b}(\left\lceil (L(M)+8)/64\right\rceil )$ .
   2. Beräkna $m_{h}\leftarrow I_{W^{\ast }}^{Z}(UOWHash^ {\prime \prime }({\tilde {k}},M))$ .
2. Välj ${\displaystyle {\tilde {y}}\in \left\{1,...,N-1\right\}} slumpmässigt och$ beräkna $y'\leftarrow {\tilde {y}}^{2}remN$ .
3. Beräkna $x'\leftarrow (y')^{r'}h^{m_{h}}remN$ .
4. Generera ett slumpmässigt primtal $e$ , $2^{160}\leq e\leq 2^{161}$ och dess korrekthetscertifikat ${\ displaystyle (w,d)}$ : $(e,w,d)\leftarrow GenCertPrime(s)$ . Upprepa detta steg tills $e\neq e'$ .
5. Ställ $r\leftarrow UOWHash^{\prime \prime \prime }(k' ,L_{B}(N),x',{\tilde {k}})\in Z$ ; Observera att $0\leq r<2^{160}$ .
6. Beräkna $y\leftarrow h^{b}remN$ , där
   $b\leftarrow e^{-1}(ar)rem(p'q')$ ,
   
   och där $p'=(p-1)/2$ och $q'=(q-1)/2$ .
7. Koda signaturen:
   $\sigma \leftarrow SEncode(L_{B}(N),d,w,y ,y',{\tilde {k}})$ .
8. Returnera $\sigma$

Anteckningar

I definitionen av ACE-krypteringsprocessen och ACE-signaturprocessen används någon hjälpfunktion (t.ex. UOWHash, ESHash och någon annan), vars definition går utöver denna artikel. Mer information om det finns i в.

Implementering, användning och prestanda

ACE Encryption Scheme rekommenderas av NESSIE (New European Schemes for Signatures, Integrity and Encryption) som asymmetriskt krypteringsschema. Pressmeddelandet är daterat till februari 2003.

Båda systemen implementerades i ANSI C, med användning av GNU GMP-biblioteket. Tester gjordes på två plattformar: Power PC 604 modell 43P under AIX-system och 266 MHz Pentium under Windows NT-system. Resultattabeller:

Tidskostnader på grunddrift

	Power PC		Pentium
	Operandstorlek (byte)		Operandstorlek (byte)
	512	1024	512	1024
Multiplikation	3,5 × 10 −5 s	1,0 × 10 −4 s	4,5 × 10 −5 s	1,4 × 10 −4 s
Kvadrering	3,3 × 10 −5 s	1,0 × 10 −4 s	4,4 × 10 −5 s	1,4 × 10 −4 s
Exponentiering	1,9 × 10 −2 s	1,2 × 10 −1 s	2,6 × 10 −2 s	1,7 × 10 −1 s

Utförande av krypteringsschema och signaturschema

	Power PC		Pentium
	Fasta kostnader (ms)	MBit/sek	Fasta kostnader (ms)	MBit/sek
Kryptera	160	18	230	16
Avkryptera	68	18	97	14
Skylt	48	64	62	52
Skyltuppsättning	29		41
Kontrollera	52	65	73	53

externa länkar

• http://www.alphaworks.ibm.com/tech/ace
• http://www.zurich.ibm.com/security/ace/
• NESSIE Portfölj med rekommenderade kryptografiska primitiver