Der RC4-Stream-Verschlüsselungsalgorithmus (1987 von Ron Rivest entwickelt) ist ein Klassiker auf seinem Gebiet, geriet jedoch kürzlich aufgrund seiner Anfälligkeit in WEP und TLS in die Kritik. Eine sorgfältige Analyse zeigt jedoch, dass in diesen Fällen nicht RC4 selbst angreifbar war, sondern seine erfolglose Kombination mit den angegebenen Protokollen. Wer möchte, kann selbst in die Details eintauchen, wir möchten hier jedoch nur anmerken, dass die in der kryptologischen Literatur beschriebenen RC4-Schwachstellen im Zusammenhang mit WEP und TLS nichts mit unserem System zu tun haben, da die Lücken, durch die der Hack durchgeführt wurde, dort liegen fehlen völlig in Extra Systems Cypher Net fehlen.
Die Implementierung des RC4-Stream-Verschlüsselungsalgorithmus in unserem System erfolgt wie folgt:
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);
}
Der Aufruf der Prozedur encrypt_buffer in der Prozedur make_crypt_key_table zum „Kodieren“ des rc4_trash-Puffers mit der Größe RC4_SKIP_TRASH Bytes ignoriert tatsächlich eine bestimmte Anzahl der Anfangsbytes der RC4-Verschlüsselung, die in der modernen Kryptographie als „nicht stark genug“ gelten. Obwohl wir diese Überlegungen nicht für schwerwiegend halten (insbesondere aufgrund des Vorhandenseins eines leistungsstarken Vorkodierungsmoduls in unserem System), haben wir uns dennoch entschieden, dieses Zugeständnis derzeit zur dominierenden Position unter Kryptografen zu machen. Wir veröffentlichen den spezifischen Wert von RC4_SKIP_TRASH nicht, zumal er sich je nach den Wünschen eines bestimmten Kunden ändern kann.
Die zufällige Variation der Anzahl der verworfenen Anfangsbytes der RC4-Verschlüsselung durch die Summierung kryptografisch zufälliger Bytes des RC4-Schlüssels Modulo 256 (unsigned char x variable) bietet zusätzlichen Schutz vor Hackern, die die von diesem Modul bereitgestellte Stream-Verschlüsselung der Kommunikationssitzung brechen. Da der RC4-Schlüssel in jeder neuen Kommunikationssitzung unterschiedlich ist, ist auch die Anzahl der verworfenen Schlüsselstrombytes jedes Mal unterschiedlich.
Unser Ausblenden der spezifischen Werte von RC4_SKIP_TRASH und RC4_SKIP_EXTRA in diesem Modul widerspricht nicht dem Kerkhoffs-Prinzip, da sich diese Parameter nicht auf den Code beziehen (der hier vollständig veröffentlicht wird), sondern nach unserem Verständnis Schlüsseldaten sind. Das Verbergen dieser Werte schafft zusätzliche Probleme für Hacker, in unser System einzudringen, und genau das versuchen wir zu erreichen. Um die kryptografische Stärke unseres Produkts durch unabhängige Experten zu bewerten, halten wir es für ausreichend, anzugeben, dass der Wert von RC4_SKIP_TRASH in unserem Produkt immer die Zahl 500 überschreitet und der Wert von RC4_SKIP_EXTRA immer größer als 0 und immer kleiner als 255 ist.
Der Inhalt dieser Seite ist auch in Englisch, Französisch, Portugiesisch, Spanisch, Italienisch, Ukrainisch und Russisch verfügbar.
| © Extra Systems, 2024 |
|