El algoritmo de cifrado de flujo RC4 (creado por Ron Rivest en 1987) es un clásico en su campo, pero recientemente ha sido criticado debido a su vulnerabilidad en WEP y TLS. Sin embargo, un análisis cuidadoso muestra que en estos casos no era el RC4 en sí el vulnerable, sino su combinación fallida con los protocolos especificados. Quienes lo deseen pueden profundizar en los detalles ellos mismos, pero aquí solo señalaremos que las vulnerabilidades RC4 descritas en la literatura criptológica junto con WEP y TLS no tienen nada que ver con nuestro sistema, ya que esas lagunas a través de las cuales se llevó a cabo la piratería están completamente ausentes en Extra Systems Cypher Net.
La implementación del algoritmo de cifrado de flujo RC4 en nuestro sistema se realiza de la siguiente manera:
typedef struct rc4_key
{
unsigned char state[256];
unsigned char x;
unsigned char y;
} rc4_key;
void swap_byte(unsigned char *a, unsigned char *b)
{
unsigned char swapByte;
swapByte = *a;
*a = *b;
*b = swapByte;
}
void prepare_rc4_key(unsigned char *key_data_ptr, int key_data_len, rc4_key *key)
{
unsigned char index1, index2;
unsigned char* state;
short counter;
state = &key->state[0];
for(counter = 0; counter < 256; counter++) state[counter] = counter;
key->x = 0; key->y = 0;
index1 = 0; index2 = 0;
for(counter = 0; counter < 256; counter++)
{
index2 = (key_data_ptr[index1] + state[counter] + index2) % 256;
swap_byte(&state[counter], &state[index2]);
index1 = (index1 + 1) % key_data_len;
}
}
void rc4_crypt_buffer(unsigned char *buffer_ptr, int buffer_len, rc4_key *key)
{
unsigned char x, y;
unsigned char *state;
unsigned char xorIndex;
short counter;
x = key->x; y = key->y;
state = &key->state[0];
for(counter = 0; counter < buffer_len; counter++)
{
x = (x + 1) % 256;
y = (state[x] + y) % 256;
swap_byte(&state[x], &state[y]);
xorIndex = (state[x] + state[y]) % 256;
buffer_ptr[counter] ^= state[xorIndex];
}
key->x = x;
key->y = y;
}
rc4_key rc4_key_table;
void encrypt_buffer(unsigned char *buffer_ptr, int buffer_len) { rc4_crypt_buffer(buffer_ptr, buffer_len, &rc4_key_table); }
void decrypt_buffer(unsigned char *buffer_ptr, int buffer_len) { rc4_crypt_buffer(buffer_ptr, buffer_len, &rc4_key_table); }
void make_crypt_key_table(unsigned char *key_data_ptr, int key_data_len)
{
int i, buffer_len;
unsigned char x;
unsigned char rc4_trash[RC4_SKIP_TRASH + 256];
prepare_rc4_key(key_data_ptr, key_data_len, &rc4_key_table);
x = RC4_SKIP_EXTRA;
for(i = 0; i < key_data_len; i++) x = x + key_data_ptr[i];
buffer_len = RC4_SKIP_TRASH + x;
encrypt_buffer(rc4_trash, buffer_len);
}
Llamar al procedimiento encrypt_buffer en el procedimiento make_crypt_key_table para "codificar" el búfer rc4_trash de tamaño RC4_SKIP_TRASH bytes en realidad ignora una cierta cantidad de bytes iniciales del cifrado RC4, que en la criptografía moderna se consideran "no lo suficientemente fuertes". Aunque no consideramos que estas consideraciones sean serias (especialmente debido a la presencia de un potente módulo de precodificación en nuestro sistema), decidimos hacer de esta concesión la posición dominante entre los criptógrafos en este momento. No publicamos el valor específico de RC4_SKIP_TRASH, especialmente porque puede cambiar según los deseos de un cliente en particular.
La variación aleatoria en el número de bytes iniciales descartados del cifrado RC4 mediante la suma de bytes criptográficamente aleatorios del módulo de clave RC4 256 (variable char x sin firmar) proporciona protección adicional contra los piratas informáticos que rompen el cifrado de flujo de la sesión de comunicación proporcionada por este módulo. Dado que la clave RC4 será diferente en cada nueva sesión de comunicación, la cantidad de bytes del flujo de claves descartados también será diferente cada vez.
Nuestro ocultamiento de los valores específicos de RC4_SKIP_TRASH y RC4_SKIP_EXTRA en este módulo no contradice el principio de Kerkhoffs, ya que estos parámetros no se relacionan con el código (que se publica en su totalidad aquí), pero son, a nuestro entender, datos clave. Ocultar estos valores crea problemas adicionales para que los piratas informáticos entren en nuestro sistema, que es exactamente lo que estamos intentando hacer. Para evaluar la solidez criptográfica de nuestro producto por parte de expertos independientes, consideramos suficiente indicar que el valor de RC4_SKIP_TRASH en nuestro producto siempre supera el número 500, y el valor de RC4_SKIP_EXTRA es siempre mayor que 0 y siempre menor que 255.
El contenido de esta página también está disponible en inglés, francés, alemán, portugués, italiano, ucraniano y ruso.
| © Extra Systems, 2024 |
|