L'algoritmo di crittografia del flusso RC4 (creato da Ron Rivest nel 1987) è un classico nel suo campo, ma recentemente è stato criticato a causa della sua vulnerabilità in WEP e TLS. Da un'analisi attenta emerge però che in questi casi non era l'RC4 in sé ad essere vulnerabile, ma la sua combinazione infruttuosa con i protocolli specificati. Chi lo desidera può approfondire da solo i dettagli, ma qui notiamo solo che le vulnerabilità RC4 descritte nella letteratura crittografica insieme a WEP e TLS non hanno nulla a che fare con il nostro sistema, poiché le scappatoie attraverso le quali è stato effettuato l'hacking lì sono completamente assenti nei sistemi Extra mancano Cypher Net.
L'implementazione dell'algoritmo di crittografia del flusso RC4 nel nostro sistema viene eseguita come segue:
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);
}
Chiamando la procedura encrypt_buffer nella procedura make_crypt_key_table per "codificare" il buffer rc4_trash di dimensioni RC4_SKIP_TRASH byte, in realtà si ignora un certo numero di byte iniziali del codice RC4, che nella crittografia moderna sono considerati "non abbastanza forti". Sebbene non consideriamo queste considerazioni serie (soprattutto a causa della presenza di un potente modulo di precodifica nel nostro sistema), abbiamo comunque deciso di fare di questa concessione la posizione dominante tra i crittografi al momento. Non pubblichiamo il valore specifico di RC4_SKIP_TRASH, soprattutto perché potrebbe cambiare a seconda dei desideri di un particolare cliente.
La variazione casuale del numero di byte iniziali scartati del codice RC4 attraverso la somma di byte crittograficamente casuali della chiave RC4 modulo 256 (variabile char x senza segno) fornisce una protezione aggiuntiva contro gli hacker che violano la crittografia del flusso della sessione di comunicazione fornita da questo modulo. Poiché la chiave RC4 sarà diversa in ogni nuova sessione di comunicazione, anche il numero di byte del flusso di chiave scartati sarà diverso ogni volta.
Il fatto che nascondiamo i valori specifici di RC4_SKIP_TRASH e RC4_SKIP_EXTRA in questo modulo non contraddice il principio di Kerkhoff, poiché questi parametri non si riferiscono al codice (che è pubblicato qui integralmente), ma sono, a nostro avviso, dati chiave. Nascondere questi valori crea ulteriori problemi affinché gli hacker possano penetrare nel nostro sistema, che è esattamente ciò che stiamo cercando di fare. Per valutare la forza crittografica del nostro prodotto da parte di esperti indipendenti, riteniamo sufficiente indicare che il valore di RC4_SKIP_TRASH nel nostro prodotto supera sempre il numero 500 e il valore di RC4_SKIP_EXTRA è sempre maggiore di 0 e sempre inferiore a 255.
Il contenuto di questa pagina è disponibile anche in inglese, francese, tedesco, portoghese, spagnolo, ucraino e russo.
| © Extra Systems, 2024 |
|