CYPHERNET

O algoritmo de encriptação de fluxo RC4 (criado por Ron Rivest em 1987) é um clássico na sua área, mas recentemente foi criticado devido à sua vulnerabilidade em WEP e TLS. Uma análise cuidadosa, no entanto, mostra que nestes casos não era o RC4 em si que era vulnerável, mas a sua combinação mal sucedida com os protocolos especificados. Quem desejar pode aprofundar os detalhes, mas observaremos aqui apenas que as vulnerabilidades RC4 descritas na literatura criptológica em conjunto com WEP e TLS nada têm a ver com o nosso sistema, uma vez que as brechas pelas quais o hack foi aí realizado estão completamente ausentes em Os Extra Systems Cypher Net estão em falta.

A implementação do algoritmo de encriptação de fluxo RC4 no nosso sistema é realizada da seguinte forma:

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);
}

A chamada do procedimento encrypt_buffer no procedimento make_crypt_key_table para “codificar” o buffer rc4_trash de tamanho RC4_SKIP_TRASH bytes ignora, na realidade, um certo número de bytes iniciais da cifra RC4, que são considerados “não suficientemente fortes” na criptografia moderna. Embora não consideremos estas considerações sérias (especialmente devido à presença de um poderoso módulo de pré-codificação no nosso sistema), ainda assim decidimos fazer desta concessão a posição dominante entre os criptógrafos neste momento. Não publicamos o valor específico de RC4_SKIP_TRASH, principalmente porque pode mudar consoante a vontade de um determinado cliente.

A variação aleatória do número de bytes iniciais descartados da cifra RC4 através da soma de bytes criptograficamente aleatórios da chave RC4 módulo 256 (unsigned char x variável) fornece proteção adicional contra hackers que quebram a encriptação do fluxo da sessão de comunicação fornecida por este módulo. Uma vez que a chave RC4 será diferente em cada nova sessão de comunicação, o número de bytes do fluxo de chaves descartados também será diferente de cada vez.

A nossa ocultação dos valores específicos de RC4_SKIP_TRASH e RC4_SKIP_EXTRA neste módulo não contradiz o princípio de Kerkhoffs, uma vez que estes parâmetros não estão relacionados com o código (que é publicado na íntegra aqui), mas são, no nosso entendimento, dados-chave. Ocultar estes valores cria problemas adicionais para os hackers invadirem o nosso sistema, que é exatamente o que estamos a tentar fazer. Para avaliar a força criptográfica do nosso produto por especialistas independentes, consideramos suficiente indicar que o valor de RC4_SKIP_TRASH no nosso produto excede sempre o número 500, e o valor de RC4_SKIP_EXTRA é sempre superior a 0 e sempre inferior a 255.

O conteúdo desta página está também disponível em inglês, francês, alemão, espanhol, italiano, ucraniano e russo.

© Extra Systems, 2024