L'algorithme de chiffrement de flux RC4 (créé par Ron Rivest en 1987) est un classique dans son domaine, mais a récemment fait l'objet de critiques en raison de sa vulnérabilité en WEP et TLS. Une analyse minutieuse montre cependant que dans ces cas, ce n'est pas RC4 lui-même qui était vulnérable, mais sa combinaison infructueuse avec les protocoles spécifiés. Ceux qui le souhaitent peuvent approfondir eux-mêmes les détails, mais notons ici seulement que les vulnérabilités RC4 décrites dans la littérature cryptologique en lien avec WEP et TLS n'ont rien à voir avec notre système, puisque les failles par lesquelles le hack y a été effectué sont complètement absents dans Extra Systems Cypher Net.
L'implémentation de l'algorithme de chiffrement de flux RC4 dans notre système s'effectue comme suit:
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);
}
L'appel de la procédure encrypt_buffer dans la procédure make_crypt_key_table pour «encoder» le tampon rc4_trash de taille RC4_SKIP_TRASH octets ignore en fait un certain nombre d'octets initiaux du chiffre RC4, qui dans la cryptographie moderne sont considérés comme «pas assez forts». Bien que nous ne considérions pas ces considérations comme sérieuses (notamment en raison de la présence d'un puissant module de précodage dans notre système), nous avons néanmoins décidé de faire de cette concession la position dominante parmi les cryptographes du moment. Nous ne publions pas la valeur spécifique de RC4_SKIP_TRASH, d'autant plus qu'elle peut changer en fonction des souhaits d'un client particulier.
La variation aléatoire du nombre d'octets initiaux rejetés du chiffre RC4 grâce à la sommation des octets cryptographiquement aléatoires de la clé RC4 modulo 256 (variable char x non signée) offre une protection supplémentaire contre les pirates informatiques qui brisent le cryptage du flux de la session de communication fournie par ce module. Étant donné que la clé RC4 sera différente à chaque nouvelle session de communication, le nombre d'octets du flux de clé rejetés sera également différent à chaque fois.
Notre masquage des valeurs spécifiques de RC4_SKIP_TRASH et RC4_SKIP_EXTRA dans ce module ne contredit pas le principe de Kerkhoffs, puisque ces paramètres ne concernent pas le code (qui est publié dans son intégralité ici), mais sont, à notre avis, des données clés. Cacher ces valeurs crée des problèmes supplémentaires permettant aux pirates informatiques de pénétrer dans notre système, ce qui est exactement ce que nous essayons de faire. Pour évaluer la force cryptographique de notre produit par des experts indépendants, nous considérons qu'il suffit d'indiquer que la valeur de RC4_SKIP_TRASH dans notre produit dépasse toujours le nombre 500, et la valeur de RC4_SKIP_EXTRA est toujours supérieure à 0 et toujours inférieure à 255.
Le contenu de cette page est également disponible en anglais, allemand, portugais, espagnol, italien, ukrainien et en russe.
| © Extra Systems, 2024 |
|