Melhorando o gafanhoto na ferrugem

Começar

Às vezes, uma solução simples e bonita é melhor do que uma correta e consistente. Talvez fosse esse o caso se tudo na vida acontecesse como nos livros didáticos. Na prática, porém, leva um longo caminho para fazer as coisas.

Partindo das letras, neste artigo quero dizer ao leitor interessado sobre a criptografia GOST, ou seja, o algoritmo Grasshopper, e sobre o fato de que vale a pena prestar atenção a novas e promissoras ferramentas - a linguagem Rust.

Chega de digressões, sugiro que você comece!

O que estará neste artigo

Rust. . . , , .

, , , - .

Rust Rust?

Rust C++, Go Rust, Rust …, , . Rust , , . , Rust , .

, Rust , , , C++. . , , . , .

, «Hello World». kuznechik:

Cargo.toml:

[dependencies]
kuznechik = "0.2.0"
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

"Hello World!":

main.rs:

fn hello_world() {
    // 
    let gamma = vec![0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xce, 0xf0, 0xa1, 0xb2, 0xc3, 0xd4, 0xe5, 0xf0, 0x01, 0x12,
                     0x23, 0x34, 0x45, 0x56, 0x67, 0x78, 0x89, 0x90, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19];

    let kuz = Kuznechik::new("  Rust").unwrap();

    let mut alg = AlgOfb::new(&kuz);
    alg.gamma = gamma.clone();

    let data = String::from("Hello World!").into_bytes();

    // 
    let enc_data = alg.encrypt(data.clone());
    println!("Encrypted data:\n{:?}", &enc_data);

    // 
    alg.gamma = gamma;
    let dec_data = alg.decrypt(enc_data);
    println!(
        "Decrypted data:\n{}",
        String::from_utf8(dec_data.clone()).unwrap()
    );

    assert_eq!(dec_data, data);
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, Kuznechik . Kuznechik::new() Sha3-256 . , Kuznechik::new_with_master_key(). 256 ( [u8; 32]).

alg.encrypt() alg.decrypt() Vec<u8>. . , .

, – , Kuznechik, , Alg- ( - AlgOfb). . Kuznechik ( ) .

( AlgEcb, AlgCtr, AlgOfb, AlgCbc, AlgCfb, AlgMac). (OFB). , alg.gamma. , .

, Rust. GitHub.

:

pub fn encrypt_block(data: &mut Block128, keys: &[Block128; 10]) {
    for i in 0..9 {
        tfm_lsx(data, &keys[i]);
    }
    tfm_x(data, &keys[9]);
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

LSX- X-. 128 16 . Block128 , u8.

LSX-. X, S, L .

fn tfm_lsx(data: &mut Block128, key: &Block128) {
    tfm_x(data, key);
    tfm_s(data);
    tfm_l(data);
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

X- 2 ( - XOR) :

fn tfm_x(data: &mut Block128, key: &Block128) {
    for i in 0..16 {
        data[i] ^= key[i];
    }
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

S- π ().

fn tfm_s(data: &mut Block128) {
    for i in 0..16 {
        data[i] = K_PI[data[i] as usize];
    }
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

L- 16 R- .

fn tfm_l(data: &mut Block128) {
    for _ in 0..16 {
        tfm_r(data);
    }
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

R-:

fn tfm_r(data: &mut Block128) {
    let temp = trf_linear(data);
    data.rotate_right(1);
    data[0] = temp;
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

. F – , 16 , .

:

L - , , , . 7 256 , ( 1 , .. ).

O(1) O(1) , 7 * 256 = 1792 , .

:

fn trf_linear(data: &Block128) -> u8 {
    // indexes:  0,  1,   2,   3,   4,   5,   6
    // values:  16, 32, 133, 148, 192, 194, 251
    let mut res = 0u8;
    res ^= MULT_TABLE[3][data[0] as usize];
    res ^= MULT_TABLE[1][data[1] as usize];
    res ^= MULT_TABLE[2][data[2] as usize];
    res ^= MULT_TABLE[0][data[3] as usize];
    res ^= MULT_TABLE[5][data[4] as usize];
    res ^= MULT_TABLE[4][data[5] as usize];
    res ^= data[6];
    res ^= MULT_TABLE[6][data[7] as usize];
    res ^= data[8];
    res ^= MULT_TABLE[4][data[9] as usize];
    res ^= MULT_TABLE[5][data[10] as usize];
    res ^= MULT_TABLE[0][data[11] as usize];
    res ^= MULT_TABLE[2][data[12] as usize];
    res ^= MULT_TABLE[1][data[13] as usize];
    res ^= MULT_TABLE[3][data[14] as usize];
    res ^= data[15];
    res
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, XOR. .

, , , . , , .

, , , . . , .

• .

  
  
  
  
  

• (, , .).

  
  
  
  
  

• .

  
  
  
  
  

• .

  
  
  
  
  

• , .

  
  
  
  
  

…

Colocar todos os seus pensamentos em um artigo, na minha opinião, seria errado. Assim, você pode se cansar rapidamente e perder o interesse pelo material. Além disso, ficaria feliz em ouvir sua opinião e considerar tópicos comuns com você.

É tudo por agora. Espero que este artigo ajude alguém a entender o algoritmo Grasshopper e a linguagem Rust. Obrigado pela atenção.

Agradecimentos especiais a Chris F pelas fotos do gafanhoto.