Cifrado ACE - ACE Encrypt

ACE ( Advanced Cryptographic Engine ): la colección de unidades, que implementa un esquema de cifrado de clave pública y un esquema de firma digital. Nombres correspondientes para estos esquemas: «ACE Encrypt» y «ACE Sign». Los esquemas se basan en el esquema de cifrado de clave pública Cramer-Shoup y el esquema de firma Cramer-Shoup. Las variantes introducidas de estos esquemas están destinadas a lograr un buen equilibrio entre el rendimiento y la seguridad de todo el sistema de cifrado.

Autores

Todos los algoritmos implementados en ACE se basan en algoritmos desarrollados por Victor Shoup y Ronald Cramer. La especificación completa de los algoritmos está escrita por Victor Shoup. La implementación de los algoritmos es realizada por Thomas Schweinberger y Mehdi Nassehi, su soporte y mantenimiento lo realiza Victor Shoup. Thomas Schweinberger participó en la construcción del documento de especificaciones ACE y también escribió un manual de usuario.

Ronald Cramer actualmente permanece en la universidad de Aarhus, Dinamarca . Trabajó en el proyecto de ACE Encrypt durante su estancia en ETH en Zürich , Suiza .

Mehdi Nassehi y Thomas Schweinberger trabajaron en el proyecto ACE en el laboratorio de investigación de IBM en Zúrich , Suiza .
Victor Shoup trabaja en el laboratorio de investigación de IBM en Zürich , Suiza .

Seguridad

El esquema de encriptación en ACE puede probarse como seguro bajo supuestos razonables y naturales de intratabilidad. Estos cuatro supuestos son:

• El supuesto Decisional Diffie-Hellman (DDH)
• Fuerte suposición de RSA
• Resistencia a colisiones de preimagen de 1 segundo SHA-1
• Pseudoaleatoriedad en modo suma / contador MARS

Terminología y notación básicas

Aquí presentamos algunas notaciones que se utilizan en este artículo.

Notación matemática básica

${\ Displaystyle \ mathbb {Z}}$- El conjunto de números enteros. - El conjunto de polinomios univariados con coeficientes en el campo finito de cardinalidad 2. - entero tal que para entero y . - polinomio con tal que con .
${\ Displaystyle F_ {2} [T]}$${\ Displaystyle F_ {2}}$
${\ Displaystyle A \ operatorname {rem} n}$${\ Displaystyle r \ in \ left \ {0, \ dots, n-1 \ right \}}$${\ Displaystyle A \ equiv r {\ pmod {n}}}$${\ Displaystyle n> 0}$${\ Displaystyle A \ in \ mathbb {Z}}$
${\ Displaystyle A \ operatorname {rem} f}$${\ Displaystyle r \ en F_ {2} [T]}$${\ Displaystyle \ deg (r) <\ deg (f)}$${\ Displaystyle A \ equiv r {\ pmod {f}}}$${\ Displaystyle A, f \ in F_ {2} [T], f \ neq 0}$

Notación de cadena básica

${\ Displaystyle A ^ {\ ast}}$- El conjunto de todas las cuerdas. - El conjunto de todas las cadenas con longitud n. Para : longitud de la cuerda . Se indica la cadena de longitud cero . Para - el resultado de y concatenación.
${\ Displaystyle A ^ {n}}$
${\ Displaystyle x \ in A ^ {\ ast} L (x)}$${\ Displaystyle x}$${\ Displaystyle \ lambda _ {A}}$
${\ Displaystyle x, y \ en A ^ {\ ast}}$ ${\ Displaystyle x \ | y}$${\ Displaystyle x}$${\ Displaystyle y}$

Bits, bytes, palabras

${\ Displaystyle b {\ overset {\ text {def}} {{} = {}}} \ left \ {0,1 \ right \}}$- El conjunto de bits.
Tomemos todos los conjuntos de formas . Para tal conjunto A definimos el "elemento cero": ${\ Displaystyle b, b ^ {n_ {1}}, (b ^ {n_ {1}}) ^ {n_ {2}}, ...}$

Definimos como un conjunto de bytes y como un conjunto de palabras. ${\ Displaystyle B {\ stackrel {\ mathrm {def}} {{} = {}}} b ^ {8}}$${\ Displaystyle W {\ stackrel {\ mathrm {def}} {{} = {}}} b ^ {32}}$

Para con y definimos un operador de relleno: ${\ Displaystyle x \ in A ^ {\ ast}}$${\ Displaystyle A \ in \ left \ {b, B, W \ right \}}$${\ Displaystyle l> 0}$

Operador de conversión

El operador de conversión realiza una conversión entre elementos . ${\ Displaystyle I_ {src} ^ {dst}: src \ to dst}$${\ Displaystyle Z, F_ {2} [T], b ^ {\ ast}, B ^ {\ ast}, W ^ {\ ast}}$

Esquema de cifrado

Par de claves de cifrado

El esquema de cifrado emplea dos tipos fundamentales:
la clave pública de la ECA: . ACE clave privada: . Para un parámetro de tamaño dado , de manera que , los componentes clave se definen como: - un número primo de 256 bits. - un número primo de m bits, tal que . - elementos (cuyo módulo de orden multiplicativo divide ). - elementos . - elementos con y , dónde y . ${\ Displaystyle (P, q, g_ {1}, g_ {2}, do, d, h_ {1}, h_ {2}, k_ {1}, k_ {2})}$
${\ Displaystyle (w, x, y, z_ {1}, z_ {2})}$
${\ Displaystyle m}$${\ Displaystyle 1024 \ leq m \ leq 16384}$
${\ Displaystyle q}$
${\ Displaystyle P}$${\ Displaystyle P \ equiv 1 {\ pmod {q}}}$
${\ Displaystyle g_ {1}, g_ {2}, do, d, h_ {1}, h_ {2}}$${\ Displaystyle \ left \ {1, \ dots, P-1 \ right \}}$${\ Displaystyle P}$${\ Displaystyle q}$
${\ Displaystyle w, x, y, z_ {1}, z_ {2}}$${\ Displaystyle \ left \ {0, \ dots, q-1 \ right \}}$
${\ Displaystyle k_ {1}, k_ {2}}$${\ Displaystyle B ^ {\ ast}}$${\ Displaystyle L (k_ {1}) = 20l '+ 64}$${\ Displaystyle L (k_ {2}) = 32 \ left \ lceil l / 16 \ right \ rceil +40}$${\ Displaystyle l = \ left \ lceil m / 8 \ right \ rceil}$${\ Displaystyle l '= L_ {b} (\ left \ lceil (2 \ left \ lceil l / 4 \ right \ rceil +4) / 16 \ right \ rceil)}$

Generación de claves

Algoritmo. Generación de claves para el esquema de cifrado ACE.
Entrada: un parámetro de tamaño , tal que . Salida: un par de claves pública / privada. ${\ Displaystyle m}$${\ Displaystyle 1024 \ leq m \ leq 16384}$

1. Genere un primo aleatorio , tal que .${\ Displaystyle q}$${\ Displaystyle 2 ^ {255} <q <2 ^ {256}}$
2. Generar un primer aleatoria , de tal manera que .${\ Displaystyle P}$${\ Displaystyle 2 ^ {m-1} <P <2 ^ {m}}$${\ Displaystyle P \ equiv 1 (modq)}$
3. Genere un número entero aleatorio , tal que .${\ Displaystyle g_ {1} \ in \ left \ {2, ..., P-1 \ right \}}$${\ Displaystyle g_ {1} ^ {q} \ equiv 1 (modP)}$
4. Genera enteros aleatorios y${\ Displaystyle w \ in \ left \ {1, ..., q-1 \ right \}}$${\ Displaystyle x, y, z_ {1}, z_ {2} \ in \ left \ {0, ..., q-1 \ right \}}$
5. Calcule los siguientes enteros en :${\ Displaystyle \ left \ {1, ..., P-1 \ right \}}$
   ${\ Displaystyle g_ {2} \ leftarrow g_ {1} ^ {w} remP}$, , , , .
   ${\ Displaystyle c \ leftarrow g_ {1} ^ {x} remP}$
   ${\ Displaystyle d \ leftarrow g_ {1} ^ {y} remP}$
   ${\ Displaystyle h_ {1} \ leftarrow g_ {1} ^ {z_ {1}} remP}$
   ${\ Displaystyle h_ {2} \ leftarrow g_ {1} ^ {z_ {2}} remP}$
6. Genere cadenas de bytes aleatorias y , donde y .${\ Displaystyle k_ {1} \ in B ^ {20l '+ 64}}$${\ Displaystyle k_ {2} \ in B ^ {2 \ left \ lceil l / 16 \ right \ rceil +40}}$${\ Displaystyle l = L_ {B} (P)}$${\ Displaystyle l '= L_ {B} (\ left \ lceil (2 \ left \ lceil l / 4 \ right \ rceil +4) / 16 \ right \ rceil)}$
7. Devuelve el par de clave pública / clave privada
   ${\ Displaystyle ((P, q, g_ {1}, g_ {2}, do, d, h_ {1}, h_ {2}, k_ {1}, k_ {2}), (w, x, y) , z_ {1}, z_ {2}))}$

Representación de texto cifrado

Un texto cifrado del esquema de cifrado ACE tiene la forma

donde los componentes se definen como: - números enteros de (cuyo módulo de orden multiplicativo divide ). - elemento . - elemento . llamamos el preámbulo y el criptograma . Si un texto plano es una cadena que consta de байт, entonces la longitud de es igual a . Necesitamos introducir la función , que mapea un texto cifrado a su cadena de bytes
${\ Displaystyle u_ {1}, u_ {2}, v}$${\ Displaystyle \ left \ {1, ..., P-1 \ right \}}$${\ Displaystyle P}$${\ Displaystyle q}$
${\ Displaystyle s}$${\ Displaystyle W ^ {4}}$
${\ Displaystyle e}$${\ Displaystyle B ^ {\ ast}}$
${\ Displaystyle s, u_ {1}, u_ {2}, v}$${\ Displaystyle e}$${\ Displaystyle l}$${\ Displaystyle e}$${\ Displaystyle l + 16 \ left \ lceil l / 1024 \ right \ rceil}$
${\ Displaystyle CEncode}$

representación, y la función inversa correspondiente . Para el entero , la cadena de palabras , los enteros y la cadena de bytes ,${\ Displaystyle CDecode}$${\ Displaystyle l> 0}$${\ Displaystyle s \ en W ^ {4}}$${\ Displaystyle 0 \ leq u_ {1}, u_ {2}, v <256 ^ {l}}$${\ Displaystyle e \ in B ^ {\ ast}}$

Para entero , cadena de bytes , tal que ,${\ Displaystyle l> 0}$${\ Displaystyle \ psi \ in B ^ {\ ast}}$${\ Displaystyle L (\ psi) \ geq 3l + 16}$

Proceso de cifrado

Algoritmo. Operación de cifrado asimétrico ACE.
entrada: clave pública y cadena de bytes . Salida: cadena de bytes - texto cifrado de . ${\ Displaystyle (P, q, g_ {1}, g_ {2}, do, d, h_ {1}, h_ {2}, k_ {1}, k_ {2})}$${\ Displaystyle M \ en B ^ {\ ast}}$
${\ Displaystyle \ psi \}$${\ Displaystyle M}$

1. Generar al azar.${\ Displaystyle r \ in \ left \ {0, ..., q-1 \ right \}}$
2. Genere el preámbulo del texto cifrado:
   1. Generar al azar.${\ Displaystyle s \ en W ^ {4}}$
   2. Calcular , .${\ Displaystyle u_ {1} \ leftarrow g_ {1} ^ {r} remP}$${\ Displaystyle u_ {2} \ leftarrow g_ {2} ^ {r} remP}$
   3. Compute ; nota eso .${\ Displaystyle \ alpha \ \ leftarrow UOWHash ^ {\ prime} (k_ {1}, L_ {B} (P), s, u_ {1}, u_ {2}) \ in Z}$${\ Displaystyle 0 <\ alpha \ <2 ^ {160}}$
   4. Calcular .${\ Displaystyle v \ leftarrow c ^ {r} d ^ {\ alpha \ r} remP}$
3. Calcule la clave para la operación de cifrado simétrico:
   1. ${\ Displaystyle {\ tilde {h_ {1}}} \ leftarrow h_ {1} ^ {r} remP}$, .${\ Displaystyle {\ tilde {h_ {2}}} \ leftarrow h_ {2} ^ {r} remP}$
   2. Calcular .${\ displaystyle k \ leftarrow ESHash (k, L_ {B} (P), s, u_ {1}, u_ {2}, {\ tilde {h_ {1}}}, {\ tilde {h_ {2}} }) \ en W ^ {8}}$
4. Calcule el criptograma .${\ Displaystyle e \ leftarrow SEnc (k, s, 1024, M)}$
5. Codifique el texto cifrado:
   ${\ Displaystyle \ psi \ \ leftarrow CEncode (L_ {B} (P), s, u_ {1}, u_ {2}, v, e)}$.
6. Regreso .${\ Displaystyle \ psi \}$

Antes de iniciar el proceso de cifrado simétrico, el mensaje de entrada se divide en bloques , donde cada uno de los bloques, posiblemente excepto el último, es de 1024 bytes. Cada bloque está encriptado por el cifrado de flujo. Para cada bloque cifrado, se calcula un código de autenticación de mensaje de 16 bytes. Obtenemos el criptograma${\ Displaystyle M \ en B ^ {\ ast}}$${\ Displaystyle M_ {1}, ..., M_ {t}}$${\ Displaystyle E_ {i}}$

Tenga en cuenta que si , entonces . ${\ Displaystyle L (M) = 0}$${\ Displaystyle L (e) = 0}$

Algoritmo. Proceso de cifrado asimétrico ACE.
Entrada: Salida: , . ${\ Displaystyle (k, s, M, m) \ in W ^ {8} \ times W ^ {4} \ times Z \ times B ^ {\ ast}}$ ${\ Displaystyle m> 0}$
${\ Displaystyle e \ en B ^ {l}}$${\ Displaystyle l = L (M) +16 \ left \ lceil L (N) / m \ right \ rceil}$

1. Si , entonces regresa .${\ Displaystyle M = \ lambda _ {B}}$${\ Displaystyle \ lambda _ {B}}$
2. Inicialice un estado de generador pseudoaleatorio:
   ${\ displaystyle genState \ leftarrow InitGen (k, s) \ in GenState}$
3. Genera la clave :${\ displaystyle k_ {AXU} AXUHash}$
   ${\ displaystyle (k_ {AXU}, genState) \ leftarrow GenWords ((5L_ {b} (\ left \ lceil m / 64 \ right \ rceil) +24), genState).}$.
4. ${\ displaystyle e \ leftarrow \ lambda _ {B}, i \ leftarrow 0}$.
5. Mientras , haz lo siguiente: ${\ Displaystyle i <L (M)}$
   1. ${\ Displaystyle r \ leftarrow min (L (M) -i, m)}$.
   2. Genere valores de máscara para el cifrado y MAC:
      1. ${\ displaystyle (máscara_ {m}, genState) \ leftarrow GenWords (4, genState)}$.
      2. ${\ displaystyle (máscara_ {e}, genState) \ leftarrow GenWords (r, genState)}$.
   3. Cifrar el texto llano: .${\ Displaystyle enc \ leftarrow {\ Bigl [} M {\ Bigr]} _ {i} ^ {i + r} \ oplus mask_ {e}}$
   4. Genere el código de autenticación del mensaje:
      1. Si , entonces ; más .${\ Displaystyle i + r = L (M)}$${\ displaystyle lastBlock \ leftarrow 1}$${\ displaystyle lastBlock \ leftarrow 0}$
      2. ${\ displaystyle mac \ leftarrow AXUHash (k_ ​​{AXU}, lastBlock, enc) \ in W ^ {4}}$.
   5. Actualizar el texto cifrado: .${\ Displaystyle e \ leftarrow e || enc || I_ {W ^ {\ ast}} ^ {B ^ {\ ast}} (mac \ oplus mask_ {m})}$
   6. ${\ Displaystyle i \ lefttarrow i + r}$.
6. Regreso .${\ Displaystyle e}$

Proceso de descifrado

Algoritmo. Proceso de descifrado ACE.
Entrada: clave pública y clave privada correspondiente , byt e string . Salida: mensaje descifrado . ${\ Displaystyle (P, q, g_ {1}, g_ {2}, do, d, h_ {1}, h_ {2}, k_ {1}, k_ {2})}$${\ Displaystyle (w, x, y, z_ {1}, z_ {2})}$${\ Displaystyle \ psi \ in B ^ {\ ast}}$
${\ Displaystyle M \ in B ^ {\ ast} \ cup {Rechazar}}$

1. Descifre el texto cifrado:
   1. Si , entonces regresa .${\ Displaystyle L (\ psi) <3L_ {B} (P) +16}$${\ Displaystyle Rechazar}$
   2. Calcular:
      ${\ displaystyle (s, u_ {1}, u_ {2}, v, e) \ leftarrow CDecode (L_ {B} (P), \ psi) \ in W ^ {4} \ times Z \ times Z \ times Z \ times B ^ {\ ast}}$;
      
      tenga en cuenta que , donde .${\ Displaystyle 0 \ leq u_ {1}, u_ {2}, v <256 ^ {l}}$${\ Displaystyle l = L_ {B} (P)}$
2. Verifique el preámbulo del texto cifrado:
   1. Si o o , regresa .${\ Displaystyle u_ {1} \ geq P}$${\ Displaystyle u_ {2} \ geq P}$${\ Displaystyle v \ geq P}$${\ Displaystyle Rechazar}$
   2. Si , entonces regresa .${\ Displaystyle u_ {1} ^ {q} \ neq 1remP}$${\ Displaystyle Rechazar}$
   3. ${\ Displaystyle rechazar \ leftarrow 0}$.
   4. Si , entonces .${\ Displaystyle u_ {2} \ neq u_ {1} ^ {w} remP}$${\ displaystyle rechazar \ leftarrow 1}$
   5. Compute ; nota eso .${\ Displaystyle \ alpha \ leftarrow UOWHash ^ {\ prime} (k_ {1}, L_ {B} (P), s, u_ {1}, u_ {2}) \ in Z}$${\ Displaystyle 0 \ leq \ alpha \ leq 2 ^ {160}}$
   6. Si , entonces .${\ Displaystyle v \ neq u_ {1} ^ {x + {\ alpha} y} remP}$${\ displaystyle rechazar \ leftarrow 1}$
   7. Si , entonces regresa .${\ Displaystyle Rechazar = 1}$${\ Displaystyle Rechazar}$
3. Calcule la clave para la operación de descifrado simétrico:
   1. ${\ Displaystyle {\ tilde {h_ {1}}} \ leftarrow u_ {1} ^ {z_ {1}} remP}$, .${\ Displaystyle {\ tilde {h_ {2}}} \ leftarrow u_ {1} ^ {z_ {2}} remP}$
   2. Calcular .${\ displaystyle k \ leftarrow ESHash (k_ ​​{2}, L_ {B} (P), s, u_ {1}, {\ tilde {h_ {1}}}, {\ tilde {h_ {2}}}) \ en W ^ {8}}$
4. Compute ; tenga en cuenta que puede regresar .${\ Displaystyle M \ leftarrow SDec (k, s, 1024, e)}$${\ Displaystyle SDec}$${\ Displaystyle Rechazar}$
5. Regreso .${\ Displaystyle M}$

Algoritmo. Operación de descifrado . Entrada: Salida: Mensaje descifrado . ${\ Displaystyle SDec}$
${\ Displaystyle (k, s, m, e) \ in W ^ {8} \ times W ^ {4} \ times Z \ times B ^ {\ ast}}$ ${\ Displaystyle m> 0}$
${\ Displaystyle M \ in B ^ {\ ast} \ cup {Rechazar}}$

1. Si , entonces regresa .${\ Displaystyle e = \ lambda _ {B}}$${\ Displaystyle \ lambda _ {B}}$
2. Inicialice un estado de generador pseudoaleatorio:
   ${\ displaystyle genState \ leftarrow InitGen (k, s) \ in GenState}$
3. Genera la clave :${\ displaystyle k_ {AXU} AXUHash}$
   ${\ displaystyle (k_ {AXU}, genState ^ {\ prime}) \ leftarrow GenWords ((5L_ {b} (\ left \ lceil m / 64 \ right \ rceil) +24), genState).}$.
4. ${\ Displaystyle M \ flecha izquierda \ lambda _ {B}, i \ flecha izquierda 0}$.
5. Mientras , haz lo siguiente: ${\ Displaystyle i <L (e)}$
   1. ${\ Displaystyle r \ leftarrow min (L (e) -i, m + 16) -16}$.
   2. Si , entonces regresa .${\ Displaystyle r \ leq 0}$${\ Displaystyle Rechazar}$
   3. Genere valores de máscara para el cifrado y MAC:
      1. ${\ displaystyle (máscara_ {m}, genState) \ leftarrow GenWords (4, genState)}$.
      2. ${\ displaystyle (máscara_ {e}, genState) \ leftarrow GenWords (r, genState)}$.
   4. Verifique el código de autenticación del mensaje:
      1. Si , entonces ; más .${\ Displaystyle i + r + 16 = L (M)}$${\ Displaystyle lastblock \ leftarrow 1}$${\ Displaystyle lastblock \ leftarrow 0}$
      2. ${\ displaystyle mac \ leftarrow AXUHash (k_ ​​{AXU}, lastBlock, {\ Bigl [} e {\ Bigr]} _ {i} ^ {i + r}) \ in W ^ {4}}$.
      3. Si , entonces regresa .${\ Displaystyle {\ Bigl [} e {\ Big]} r_ {i + r} ^ {i + r + 16} \ neq I_ {W ^ {\ ast}} ^ {B ^ {\ ast}} (mac \ oplus mask_ {m})}$${\ Displaystyle Rechazar}$
   5. Actualizar el texto llano: .${\ Displaystyle M \ leftarrow M || ({\ Bigl [} e {\ Bigr]} _ {i} ^ {i + r}) \ oplus mask_ {e})}$
   6. ${\ Displaystyle i \ lefttarrow i + r + 16}$.
6. Regreso .${\ Displaystyle M}$

Esquema de firma

El esquema de firma emplea dos tipos principales:
ACE clave pública Firma: . ACE Firma clave privada: . Para el parámetro de tamaño dado , de modo que , los componentes clave se definen de la siguiente manera: - -número primo de bits con - también es un número primo. - -bit número primo con - también es un número primo. - y tiene o бит. - elementos (módulo de residuos cuadráticos ). - Número primo de 161 bits. - elemento - elementos . - elementos . ${\ Displaystyle (N, h, x, e ', k', s)}$
${\ Displaystyle (p, q, a)}$
${\ Displaystyle m}$${\ Displaystyle 1024 \ leq m \ leq 16384}$
${\ Displaystyle p}$${\ Displaystyle \ left \ lfloor m / 2 \ right \ rfloor}$${\ displaystyle (p-1) / 2}$
${\ Displaystyle q}$${\ Displaystyle \ left \ lfloor m / 2 \ right \ rfloor}$${\ displaystyle (q-1) / 2}$
${\ Displaystyle N}$${\ Displaystyle N = pq}$${\ Displaystyle m}$${\ Displaystyle m-1}$
${\ Displaystyle h, x}$${\ Displaystyle \ left \ {1, ..., N-1 \ right \}}$${\ Displaystyle N}$
${\ Displaystyle e '}$
${\ Displaystyle a}$${\ Displaystyle \ left \ {0, ..., (p-1) (q-1) / 4-1 \ right \}}$
${\ Displaystyle k '}$${\ Displaystyle B ^ {184}}$
${\ Displaystyle s}$${\ Displaystyle B ^ {32}}$

Generación de claves

Algoritmo. Generación de claves para el esquema de firma de clave pública ACE.
Entrada: parámetro de tamaño , tal que . Salida: par de claves pública / privada. ${\ Displaystyle m}$${\ Displaystyle 1024 \ leq m \ leq 16384}$

1. Genere números primos aleatorios , de modo que y - también sea un número primo, y${\ Displaystyle p, q}$${\ displaystyle (p-1) / 2}$${\ displaystyle (q-1) / 2}$
   ${\ Displaystyle 2 ^ {m_ {1} -1} <p <2 ^ {m_ {1}}}$, , И , donde${\ Displaystyle 2 ^ {m_ {2} -1} <q <2 ^ {m_ {2}}}$${\ Displaystyle p \ neq q}$
   
   
   ${\ Displaystyle m_ {1} = \ left \ lfloor m / 2 \ right \ rfloor}$y .${\ Displaystyle m_ {1} = \ left \ lceil m / 2 \ right \ rceil}$
2. Establecer .${\ Displaystyle N \ leftarrow pq}$
3. Genera un número primo aleatorio , где .${\ Displaystyle e '}$${\ Displaystyle 2 ^ {160} \ leq e '\ leq 2 ^ {161}}$
4. Genere aleatoriamente , teniendo en cuenta y , y calcule .${\ Displaystyle h '\ in \ left \ {1, ..., N-1 \ right \}}$${\ Displaystyle mcd (h ', N) = 1}$${\ Displaystyle mcd (h '\ pm 1, N) = 1}$${\ Displaystyle h \ leftarrow (h ') ^ {- 2} remN}$
5. Genere aleatorio y calcule .${\ Displaystyle a \ in \ left \ {0, ..., (p-1) (q-1) / 4-1 \ right \}}$${\ displaystyle x \ leftarrow h ^ {a} remN}$
6. Genere cadenas de bytes aleatorias y .${\ Displaystyle k '\ in B ^ {184}}$${\ Displaystyle s \ en B ^ {32}}$
7. Devolver par de clave pública / clave privada
   ${\ Displaystyle ((N, h, x, e ', k', s), (p, q, a))}$.

Representación de firma

La firma en el esquema de firmas ACE tiene la forma , donde los componentes se definen de la siguiente manera: - elemento . - entero, tal que . - elementos . - elemento ; tenga en cuenta que , donde - mensaje que se está firmando.${\ Displaystyle (d, w, y, y ', {\ tilde {k}})}$
${\ Displaystyle d}$${\ Displaystyle B ^ {64}}$
${\ Displaystyle w}$${\ Displaystyle 2 ^ {160} \ leq w \ leq 2 ^ {161}}$
${\ Displaystyle y, y '}$${\ Displaystyle \ left \ {1, ..., N-1 \ right \}}$
${\ Displaystyle {\ tilde {k}}}$${\ Displaystyle B ^ {\ ast}}$${\ displaystyle L ({\ tilde {k}}) = 64 + 20L_ {B} (\ left \ lceil (L (M) +8) / 64 \ right \ rceil)}$${\ Displaystyle M}$

Necesitamos introducir la función, que mapea una firma en su representación de cadena de bytes y la función inversa correspondiente . Para enteros , cadenas de bytes , enteros y , y cadenas de bytes ,${\ Displaystyle SEncode}$${\ Displaystyle SDecode}$${\ Displaystyle l> 0}$${\ Displaystyle d \ in B ^ {64}}$${\ Displaystyle 0 \ leq w \ leq 256 ^ {21}}$${\ Displaystyle 0 \ leq y, y '<256 ^ {l}}$${\ Displaystyle {\ tilde {k}} \ in B ^ {\ ast}}$

Para entero , cadena de bytes , donde ,${\ Displaystyle l> 0}$${\ Displaystyle \ sigma \ in B ^ {\ ast}}$${\ Displaystyle L (\ sigma) \ geq 2l + 53}$

Proceso de generación de firmas

Algoritmo. Proceso de generación de firmas ACE.
Entrada: clave pública y una clave privada correspondiente y el byte de cadena , . Salida: cadena de bytes - firma digital . ${\ Displaystyle (N, h, x, e ', k', s)}$${\ Displaystyle (p, q, a)}$${\ Displaystyle M \ en B ^ {\ ast}}$${\ Displaystyle 0 \ leq L (M) \ leq 2 ^ {64}}$
${\ Displaystyle \ sigma \ in B ^ {\ ast}}$

1. Realice los siguientes pasos para aplicar un hash a los datos de entrada:
   1. Genere una clave hash al azar, tal que .${\ Displaystyle {\ tilde {k}} \ in B ^ {20m + 64}}$${\ Displaystyle m = L_ {b} (\ left \ lceil (L (M) +8) / 64 \ right \ rceil)}$
   2. Calcular .${\ Displaystyle m_ {h} \ flecha izquierda I_ {W ^ {\ ast}} ^ {Z} (UOWHash ^ {\ prime \ prime} ({\ tilde {k}}, M))}$
2. Seleccione al azar y calcule .${\ Displaystyle {\ tilde {y}} \ in \ left \ {1, ..., N-1 \ right \}}$${\ displaystyle y '\ leftarrow {\ tilde {y}} ^ {2} remN}$
3. Calcular .${\ displaystyle x '\ leftarrow (y') ^ {r '} h ^ {m_ {h}} remN}$
4. Generar un número primo aleatorio , y su certificado de corrección : . Repita este paso hasta .${\ Displaystyle e}$${\ Displaystyle 2 ^ {160} \ leq e \ leq 2 ^ {161}}$${\ Displaystyle (w, d)}$${\ Displaystyle (e, w, d) \ leftarrow GenCertPrime (s)}$${\ Displaystyle e \ neq e '}$
5. Establecer ; nota eso .${\ displaystyle r \ leftarrow UOWHash ^ {\ prime \ prime \ prime} (k ', L_ {B} (N), x', {\ tilde {k}}) \ in Z}$${\ Displaystyle 0 \ leq r <2 ^ {160}}$
6. Computar , donde${\ Displaystyle y \ leftarrow h ^ {b} remN}$
   ${\ displaystyle b \ leftarrow e ^ {- 1} (ar) rem (p'q ')}$,
   
   y donde y .${\ displaystyle p '= (p-1) / 2}$${\ Displaystyle q '= (q-1) / 2}$
7. Codifique la firma:
   ${\ Displaystyle \ sigma \ leftarrow SEncode (L_ {B} (N), d, w, y, y ', {\ tilde {k}})}$.
8. Regreso ${\ Displaystyle \ sigma}$

Notas

En la definición de proceso de cifrado ACE y proceso de firma ACE se están utilizando algunas funciones auxiliares (por ejemplo, UOWHash, ESHash y algunas otras), cuya definición va más allá de este artículo. Se pueden encontrar más detalles al respecto en â.

Implementación, utilización y desempeño

El esquema de cifrado ACE es recomendado por NESSIE (Nuevos esquemas europeos para firmas, integridad y cifrado) como esquema de cifrado asimétrico. El comunicado de prensa está fechado en febrero de 2003.

Ambos esquemas se implementaron en ANSI C, con el uso de la biblioteca GNU GMP. Las pruebas se realizaron en dos plataformas: Power PC 604 modelo 43P con sistema AIX y Pentium a 266 MHz con sistema Windows NT. Tablas de resultados:

Costos de tiempo en operaciones básicas

	Power PC		Pentium
	Tamaño del operando (byte)		Tamaño del operando (byte)
	512	1024	512	1024
Multiplicación	3,5 × 10 −5  s	1,0 × 10 −4  s	4,5 × 10 −5  s	1,4 × 10 −4  s
Cuadratura	3,3 × 10 −5  s	1,0 × 10 −4  s	4,4 × 10 −5  s	1,4 × 10 −4  s
Exponenciación	1,9 × 10 −2  s	1,2 × 10 −1  s	2,6 × 10 −2  s	1,7 × 10 −1  s

Rendimiento del esquema de cifrado y esquema de firma

	Power PC		Pentium
	Costos fijos (ms)	MBit / seg	Costos fijos (ms)	MBit / seg
Cifrar	160	18	230	dieciséis
Descifrar	68	18	97	14
Firmar	48	64	62	52
Configuración de la señal	29		41
Verificar	52	sesenta y cinco	73	53

Literatura

enlaces externos

• http://www.alphaworks.ibm.com/tech/ace
• http://www.zurich.ibm.com/security/ace/
• Cartera NESSIE de primitivas criptográficas recomendadas