Camelia (algoritmo)

Camelia
Creador mitsubishi
Creado 2000
publicado 2000
Tamaño de clave 128, 192 o 256 bits
Tamaño de bloque 128 bits
Número de rondas 18 o 24
Tipo de Red Feistel

Camellia es un algoritmo de cifrado de bloques simétricos (tamaño de bloque 128 bits, clave 128, 192, 256 bits ), uno de los finalistas del concurso europeo NESSIE (junto con AES y Shacal-2 ), desarrollado por las empresas japonesas Nippon Telegraph y Telephone Corporation y Mitsubishi Electric Corporation (presentada el 10 de marzo de 2000 ). Certificado por la organización japonesa CRYPTREC como algoritmo recomendado para uso industrial y gubernamental.

Camellia es un desarrollo posterior del algoritmo de encriptación E2 , uno de los algoritmos presentados a la competencia AES y que utiliza elementos del algoritmo MISTY1 .

La estructura del algoritmo se basa en la cadena clásica de Feistel con blanqueamiento preliminar y final . La función de bucle utiliza una transformación no lineal (cajas S), un bloque de dispersión lineal cada 16 ciclos (operación XOR byte a byte ) y una permutación de byte.

Según la longitud de la clave, tiene 18 ciclos (clave de 128 bits) o 24 ciclos (claves de 192 y 256 bits).

El soporte para el algoritmo Camellia se introdujo en 2008 en Mozilla Firefox 3, pero se deshabilitó en 2014 en Mozilla Firefox 33 [1] . El algoritmo está patentado, pero se distribuye bajo varias licencias gratuitas, en particular, es parte del proyecto OpenSSL .

Descripción

Generación de claves auxiliares

Designacion Sentido
& Bit a bit Y (Y)
| Bit a bit O (O)
^ OR exclusivo bit a bit (XOR)
<< Desplazamiento lógico a la izquierda
>> Desplazamiento lógico a la derecha
<<< Girar a la izquierda
~y inversión
Constante Sentido
MÁSCARA8 0xff
MÁSCARA32 0xffffffff
MÁSCARA64 0xffffffffffffffff
MÁSCARA128 0xffffffffffffffffffffffffffffffffff
C1 0xA09E667F3BCC908B
C2 0xB67AE8584CAA73B2
C3 0xC6EF372FE94F82BE
C4 0x54FF53A5F1D36F1C
C5 0x10E527FADE682D1D
C6 0xB05688C2B3E6C1FD
1. La clave (K) se divide en 2 partes de 128 bits KL y KR.
Llave KL CR
128 k 0
192 K >> 64 ((K & MASK64) << 64) | (~(K&MASK64))
256 K >> 128 K&MASK128
2. Calcula números de 128 bits KA y KB (ver diagrama). Las variables D1 y D2 son de 64 bits. D1 = (KL ^ KR) >> 64; D2=(KL^KR)&MÁSCARA64; D2 = D2 ^ F(D1, C1); D1 = D1 ^ F(D2, C2); D1=D1^(KL>>64); D2=D2^(KL&MASK64); D2 = D2 ^ F(D1, C3); D1 = D1 ^ F(D2, C4); KA = (D1 << 64) | D2; D1 = (KA ^ KR) >> 64; D2=(KA^KR)&MÁSCARA64; D2 = D2 ^ F(D1, C5); D1 = D1 ^ F(D2, C6); KB = (D1 << 64) | D2; 3. Calcule las claves auxiliares de 64 bits kw1, ..., kw4, k1, ..., k24, ke1, ..., ke6 según el tamaño de la clave:
128 bits

kw1 = (KL <<< 0) >> 64;

kw2 = (KL <<< 0) & MASK64; k1 = (KA <<< 0) >> 64; k2 = (KA <<< 0) & MASCARA64; k3 = (KL <<< 15) >> 64; k4 = (KL <<< 15) & MASCARA64; k5 = (KA <<< 15) >> 64; k6 = (KA <<< 15) & MASCARA64; ke1 = (KA <<< 30) >> 64; ke2 = (KA <<< 30) & MASK64; k7 = (KL <<< 45) >> 64; k8 = (KL <<< 45) & MASCARA64; k9 = (KA <<< 45) >> 64; k10 = (KL <<< 60) & MASCARA64; k11 = (KA <<< 60) >> 64; k12 = (KA <<< 60) & MASCARA64; ke3 = (KL <<< 77) >> 64; ke4 = (KL <<< 77) & MASK64; k13 = (KL <<< 94) >> 64; k14 = (KL <<< 94) & MASCARA64; k15 = (KA <<< 94) >> 64; k16 = (KA <<< 94) & MASCARA64; k17 = (KL <<< 111) >> 64; k18 = (KL <<< 111) & MASCARA64; kw3 = (KA <<< 111) >> 64; kw4 = (KA <<< 111) & MASK64;
192 y 256 bits

kw1 = (KL <<< 0) >> 64;

kw2 = (KL <<< 0) & MASK64; k1 = (KB <<< 0) >> 64; k2 = (KB <<< 0) & MASCARA64; k3 = (KR <<< 15) >> 64; k4 = (KR <<< 15) & MASCARA64; k5 = (KA <<< 15) >> 64; k6 = (KA <<< 15) & MASCARA64; ke1 = (KR <<< 30) >> 64; ke2 = (KR <<< 30) & MASCARA64; k7 = (KB <<< 30) >> 64; k8 = (KB <<< 30) & MASCARA64; k9 = (KL <<< 45) >> 64; k10 = (KL <<< 45) & MASCARA64; k11 = (KA <<< 45) >> 64; k12 = (KA <<< 45) & MASCARA64; ke3 = (KL <<< 60) >> 64; ke4 = (KL <<< 60) & MASCARA64; k13 = (KR <<< 60) >> 64; k14 = (KR <<< 60) & MASCARA64; k15 = (KB <<< 60) >> 64; k16 = (KB <<< 60) & MASCARA64; k17 = (KL <<< 77) >> 64; k18 = (KL <<< 77) & MASCARA64; ke5 = (KA <<< 77) >> 64; ke6 = (KA <<< 77) & MASCARA64; k19 = (KR <<< 94) >> 64; k20 = (KR <<< 94) & MASCARA64; k21 = (KA <<< 94) >> 64; k22 = (KA <<< 94) & MASCARA64; k23 = (KL <<< 111) >> 64; k24 = (KL <<< 111) & MASCARA64; kw3 = (KB <<< 111) >> 64; kw4 = (KB <<< 111) & MASK64;

Cifrado

El cifrado se produce según el esquema de Feistel con 18 etapas para una clave de 128 bits y 24 etapas para claves de 192 y 256 bits. Cada 6 pasos se aplican las funciones FL y FLINV.

128 bits

D1 = M >> 64; // El mensaje cifrado se divide en dos partes de 64 bits

D2=M&MÁSCARA64; D1 = D1^kw1; // Pre-blanqueamiento D2 = D2^kw2; D2 = D2 ^ F(D1, k1); D1 = D1 ^ F(D2, k2); D2 = D2 ^ F(D1, k3); D1 = D1 ^ F(D2, k4); D2 = D2 ^ F(D1, k5); D1 = D1 ^ F(D2, k6); D1 = FL(D1, ke1); // Florida D2 = DISTR.FLIN(D2, ke2); // FLINV D2 = D2 ^ F(D1, k7); D1 = D1 ^ F(D2, k8); D2 = D2 ^ F(D1, k9); D1 = D1 ^ F(D2, k10); D2 = D2 ^ F(D1, k11); D1 = D1 ^ F(D2, k12); D1 = FL(D1, ke3); // Florida D2 = FLINV(D2, ke4); // FLINV D2 = D2 ^ F(D1, k13); D1 = D1 ^ F(D2, k14); D2 = D2 ^ F(D1, k15); D1 = D1 ^ F(D2, k16); D2 = D2 ^ F(D1, k17); D1 = D1 ^ F(D2, k18); D2 = D2^kw3; // Blanqueamiento final D1=D1^kw4; C = (D2 << 64) | D1;
192 y 256 bits

D1 = M >> 64; // El mensaje cifrado se divide en dos partes de 64 bits

D2=M&MÁSCARA64; D1 = D1^kw1; // Pre-blanqueamiento D2 = D2^kw2; D2 = D2 ^ F(D1, k1); D1 = D1 ^ F(D2, k2); D2 = D2 ^ F(D1, k3); D1 = D1 ^ F(D2, k4); D2 = D2 ^ F(D1, k5); D1 = D1 ^ F(D2, k6); D1 = FL(D1, ke1); // Florida D2 = DISTR.FLIN(D2, ke2); // FLINV D2 = D2 ^ F(D1, k7); D1 = D1 ^ F(D2, k8); D2 = D2 ^ F(D1, k9); D1 = D1 ^ F(D2, k10); D2 = D2 ^ F(D1, k11); D1 = D1 ^ F(D2, k12); D1 = FL(D1, ke3); // Florida D2 = FLINV(D2, ke4); // FLINV D2 = D2 ^ F(D1, k13); D1 = D1 ^ F(D2, k14); D2 = D2 ^ F(D1, k15); D1 = D1 ^ F(D2, k16); D2 = D2 ^ F(D1, k17); D1 = D1 ^ F(D2, k18); D1 = FL(D1, ke5); // Florida D2 = FLINV(D2, ke6); // FLINV D2 = D2 ^ F(D1, k19); D1 = D1 ^ F(D2, k20); D2 = D2 ^ F(D1, k21); D1 = D1 ^ F(D2, k22); D2 = D2 ^ F(D1, k23); D1 = D1 ^ F(D2, k24); D2 = D2^kw3; // Blanqueamiento final D1=D1^kw4; C = (D2 << 64) | D1;

Funciones auxiliares F, FL, FLINV

Las funciones F, FL y FLINV reciben 2 parámetros de 64 bits como entrada: datos F_IN y tecla KE.
La función F utiliza 16 variables de 8 bits t1, ..., t8, y1, ..., y8 y 1 variable de 64 bits. La salida de la función es un número de 64 bits.
Las funciones FL y FLINV utilizan 4 variables de 32 bits x1,x2,k1,k2. La salida de la función es un número de 64 bits. Función FLINV - inversa a FL

función f

x = F_IN^KE;

t1 = x >> 56; t2 = (x >> 48) & MASCARA8; t3 = (x >> 40) &MÁSCARA8; t4 = (x >> 32) &MÁSCARA8; t5 = (x >> 24) & MASCARA8; t6 = (x >> 16) &MÁSCARA8; t7 = (x >> 8) &MÁSCARA8; t8=x&MASCARA8; t1 = SBOX1[t1]; t2 = SBOX2[t2]; t3 = SBOX3[t3]; t4 = SBOX4[t4]; t5 = SBOX2[t5]; t6 = SBOX3[t6]; t7 = SBOX4[t7]; t8 = SBOX1[t8]; y1 = t1 ^ t3 ^ t4 ^ t6 ^ t7 ^ t8; y2 = t1^t2^t4^t5^t7^t8; y3 = t1^t2^t3^t5^t6^t8; y4 = t2^t3^t4^t5^t6^t7; y5 = t1^t2^t6^t7^t8; y6 = t2^t3^t5^t7^t8; y7 = t3^t4^t5^t6^t8; y8 = t1^t4^t5^t6^t7; F_SALIDA = (y1 << 56) | (y2 << 48) | (y3 << 40) | (y4 << 32)| (y5 << 24) | (y6 << 16) | (y7 << 8) | y8;
Función FL

var x1, x2 como entero sin signo de 32 bits;

var k1, k2 como entero sin signo de 32 bits; x1 = FL_IN >> 32; x2 = FL_IN&MASK32; k1 = EC >> 32; k2=KE&MÁSCARA32; x2 = x2^((x1 & k1) <<< 1); x1 = x1^(x2|k2); FL_SALIDA = (x1 << 32) | x2;
función FLINV

var y1, y2 como entero sin signo de 32 bits;

var k1, k2 como entero sin signo de 32 bits; y1 = FLINV_IN >> 32; y2 = FLINV_IN&MASK32; k1 = EC >> 32; k2=KE&MÁSCARA32; y1 = y1^(y2|k2); y2 = y2 ^ ((y1 & k1) <<< 1); FLINV_SALIDA = (y1 << 32) | y2;

Bloques S

El valor de la función SBOX1 se determina a partir de la siguiente tabla:

0 una 2 3 cuatro 5 6 7 ocho 9 a b C d mi F
0 112 130 44 236 179 39 192 229 228 133 87 53 234 12 174 sesenta y cinco
una 35 239 107 147 69 25 165 33 237 catorce 79 78 29 101 146 189
2 134 184 175 143 124 235 31 206 62 48 220 95 94 197 once 26
3 166 225 57 202 213 71 93 61 217 una 90 214 81 86 108 77
cuatro 139 13 154 102 251 204 176 45 116 Dieciocho 43 32 240 177 132 153
5 223 76 203 194 52 126 118 5 109 183 169 49 209 23 cuatro 215
6 veinte 88 58 97 222 27 17 28 cincuenta quince 156 22 83 24 242 34
7 254 68 207 178 195 181 122 145 36 ocho 232 168 96 252 105 80
ocho 170 208 160 125 161 137 98 151 84 91 treinta 149 224 255 100 210
9 dieciséis 196 0 72 163 247 117 219 138 3 230 218 9 63 221 148
a 135 92 131 2 205 74 144 51 115 103 246 243 157 127 191 226
b 82 155 216 38 200 55 198 59 129 150 111 75 19 190 99 46
C 233 121 167 140 159 110 188 142 41 245 249 182 47 253 180 89
d 120 152 6 106 231 70 113 186 212 37 171 66 136 162 141 250
mi 114 7 185 85 248 238 172 diez 54 73 42 104 60 56 241 164
F 64 40 211 123 187 201 67 193 21 227 173 244 119 199 128 158

Por ejemplo: SBOX1(0x7a)=232.
SBOX2, SBOX3 y SBOX4 se definen a partir de SBOX1 de la siguiente manera:

SBOX2[x] = SBOX1[x] <<< 1; SBOX3[x] = SBOX1[x] <<< 7; SBOX4[x] = SBOX1[x <<< 1];

Descifrado

El algoritmo de desencriptación es idéntico al de encriptación, con la única diferencia de que las claves auxiliares se intercambian según el siguiente esquema, dependiendo de la longitud de la clave original:

Tamaño de clave
128 bits 192 o 256 bits
kw1 <-> kw3 kw1 <-> kw3
kw2 <-> kw4 kw2 <-> kw4
k1 <-> k18 k1 <-> k24
k2 <-> k17 k2 <-> k23
k3 <-> k16 k3 <-> k22
k4 <-> k15 k4 <-> k21
k5 <-> k14 k5 <-> k20
k6 <-> k13 k6 <-> k19
k7 <-> k12 k7 <-> k18
k8 <-> k11 k8 <-> k17
k9 <-> k10 k9 <-> k16
k10 <-> k15
k11 <-> k14
k12 <-> k13
ke1 <-> ke4 ke1 <-> ke6
ke2 <-> ke3 ke2 <-> ke5
ke3 <-> ke4



Ejemplo de cifrado

Clave: 0123456789abcdeffedcba9876543210

Mensaje cifrado: 0123456789abcdefeffedcba9876543210

Mensaje cifrado: 67673138549669730857065648eabe43

Llaves

k[1]=ae71c3d55ba6bf1d

k[2]=169240a795f89256 k[3]=a2b3c4d5e6f7ff6e k[4]=5d4c3b2a19080091 k[5]=e1eaadd35f8e8b49 k[6]=2053cafc492b5738 k[7]=79bdffdb97530eca k[8]=8642002468acf135 k[9]=d7e3a2d24814f2bf k[10]=00123456789abcde k[11]=d169240a795f8ukv k[12]=6ae71c3d55ba6bf1 k[13]=1d950c840048d159 k[14]=e26af37bffb72ea6 k[15]=e57e2495ab9c70f5 k[16]=56e9afc745a49029 kw[1]=0123456789abcdef kw[2]=fedcba9876543210 kw[3]=492b5738e1eaadd3 kw[4]=5f8e8b492053cafc ke[1]=56e9afc745a49029 ke[2]=e57e2495ab9c70f5 ke[3]=97530eca86420024 ke[4]=68acf13579bdffdb

Seguridad

Según los autores del algoritmo:

Hemos demostrado que el éxito del criptoanálisis diferencial [2] y lineal [3] es casi imposible contra un ciclo Camellia completo de 18 rondas. Además, Camellia se diseñó para soportar ataques criptográficos más sofisticados, como ataques diferenciales de alto orden [4] [5] , ataques de interpolación [6] [7] , ataques de "clave vinculada" [8] [9] , ataques diferenciales acortados [10] [11] y otros

Texto original  (inglés)[ mostrarocultar] Confirmamos que es extremadamente improbable que los ataques diferenciales y lineales tengan éxito contra la Camellia completa de 18 asaltos. Además, Camellia se diseñó para ofrecer seguridad contra otros ataques criptoanalíticos avanzados, incluidos ataques diferenciales de orden superior, ataques de interpolación, ataques de clave relacionada, ataques diferenciales truncados, etc.

Aplicación

Se agregó soporte para Camellia en la versión final de Mozilla Firefox 3 en 2008 [12] . Más tarde ese año, el equipo de desarrollo de FreeBSD anunció que la compatibilidad con este cifrado también se incluía en FreeBSD 6.4-RELEASE. En septiembre de 2009, GNU Privacy Guard agregó soporte para Camellia en la versión 1.4.10. Además, muchas bibliotecas de seguridad populares como Crypto++, GnuTLS, PolarSSL y OpenSSL [13] también incluyen soporte para Camellia.

Comparación con sus pares

Algoritmo Número de elementos lógicos Tiempo de cálculo clave, ns Tiempo de cifrado/descifrado, ns Ancho de banda, MB/s
Cifrado/descifrado Llaves Cantidad total
DES 42.204 12.201 54.405 - 55.11 1161.31
Triple-DES 124.888 23.207 128.147 - 157.09 407.40
MARTE 690.654 2,245,096 2,935,754 1740.99 567.49 225.55
RC6 741.641 901.382 1,643,037 2112.26 627.57 203.96
Rijndael 518.508 93.708 612.834 57.39 65.64 1950.03
Serpiente 298.533 205.096 503.770 114.07 137.40 931.58
Dos peces 200.165 231.682 431.857 16.38 324.80 394.08
Camelia 216.911 55.907 272.819 24.36 109.35 1170.55

[catorce]

Desarrolladores

Véase también

Notas

  1. ↑ Error 1036765: deshabilite los conjuntos de cifrado que no están en la propuesta "Browser Cipher Suite" que aún están habilitados . Consultado el 18 de septiembre de 2015. Archivado desde el original el 3 de febrero de 2018.
  2. ↑ M. Matsui , Método de criptoanálisis lineal para DES Cipher - Apuntes de conferencias sobre informática, págs. 386–397, Springer-Verlag, 1994
  3. ↑ E. Biham y A. Shamir , Método de criptoanálisis lineal para DES Cipher - Criptoanálisis diferencial del estándar de cifrado de datos, Springer-Verlag, 1994
  4. ↑ LRKnudsen , "Diferenciales truncados y de orden superior", Cifrado de software rápido - Segundo taller internacional, Lecture Notes in ComputerScience 1008, pp.196–211, Springer-Verlag, 1995.
  5. ↑ T. Jakobsen y LR Knudsen , The Interpolation Attack on Block Ciphers, Fast Software Encryption, FSE'97, Lecture Notes in Computer Science 1267, pp.28–40, Springer-Verlag, 1997.
  6. ↑ T. Jakobsen y LR Knudsen , The Interpolation Attack on Block Ciphers, Fast Software Encryption, FSE'97, Lecture Notes in Computer Science 1267, pp.28–40, Springer-Verlag, 1997.
  7. ↑ K. Aoki , "Evaluación práctica de la seguridad contra ataques de interpolación generalizados", Transacciones de IEICE sobre fundamentos de electrónica, comunicaciones e informática (Japón), Vol. E83-A, No.1, pp.33–38, 2000.
  8. ↑ E. Biham , Nuevos tipos de ataques criptoanalíticos usando claves relacionadas, Journal of Cryptology, Vol.7, No.4, pp.229–246, Springer-Verlag, 1994.
  9. ↑ J.Kelsey, B.Schneier y D.Wagner , "Cryptoanálisis de programa clave de IDEA, G-DES, GOST, SAFER y Triple-DES", Avances en criptología - CRYPTO'96, Lecture Notes in Computer Science 1109, págs. 237–251, Springer-Verlag, 1996.
  10. ↑ LRKnudsen , Diferenciales truncados y de orden superior, Cifrado de software rápido - Segundo taller internacional, Lecture Notes in Computer Science 1008, pp.196–211, Springer-Verlag, 1995.
  11. ↑ M. Matsui y T. Tokita , Criptoanálisis de una versión reducida del Block Cipher E2, Fast Software Encryption - 6th International Workshop, FSE'99, Lecture Notes in Computer Science 1636, pp.71–80, Springer-Verlag, 1999 .
  12. ↑ Cifrado Camellia agregado a Firefox (enlace descendente) . Mozilla Asia . Mozilla (30 de julio de 2009). Archivado desde el original el 29 de febrero de 2012. 
  13. ↑ NTT (2006-11-08). El proyecto OpenSSL de la comunidad de código abierto adopta el cifrado estándar internacional de próxima generación "Camellia" desarrollado en Japón . Comunicado de prensa . Archivado desde el original el 8 de marzo de 2008. Consultado el 29 de febrero de 2008 .
  14. ↑ Kazumaro Aoki, Tetsuya Ichikawa, Masayuki Kanda, Mitsuru Matsui, Shiho Moriai, Junko Nakajima y Toshio Tokita Camellia: un cifrado de bloque de 128 bits adecuado para múltiples plataformas: diseño y análisis

Enlaces

 Criptosistemas simétricos
Cifrados de flujo
Red Feistel
red SP
Otro