CYPHERNET

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 swapByte;
     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 print_crypt_params(void)
{
	printf("Ключ шифрования RSA: %d бит\n", RSA_KEY_BITS);
	printf("Ключ шифрования RC4: %d бит\n\n", PACKED_SESSION_KEY_LENTH * 8);
}

void make_crypt_key_table(void) { prepare_rc4_key(common_key.packed, PACKED_SESSION_KEY_LENTH, &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); }

Der Inhalt dieser Seite ist auch in Englisch, Französisch, Ukrainisch und Russisch verfügbar.

© Extra Systems, 2024