Améliorer Grasshopper dans la rouille

Démarrer

Parfois, une solution simple et belle vaut mieux qu'une solution correcte et cohérente. Ce serait peut-être le cas si tout dans la vie se passait comme dans les manuels. Dans la pratique, cependant, il faut beaucoup de chemin pour faire avancer les choses.

En partant des paroles, dans cet article, je veux parler au lecteur intéressé du cryptage GOST, à savoir l'algorithme Grasshopper, et du fait qu'il vaut la peine de prêter attention aux outils nouveaux et prometteurs - le langage Rust.

Assez de digressions, je vous suggère de commencer!

Que sera dans cet article

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. .

, , , . , , .

, , , . . , .

• .

  
  
  
  
  

• (, , .).

  
  
  
  
  

• .

  
  
  
  
  

• .

  
  
  
  
  

• , .

  
  
  
  
  

…

Placer toutes vos pensées dans un seul article, à mon avis, serait une erreur. Vous pouvez donc rapidement vous fatiguer et vous désintéresser du matériau. De plus, je serais ravi d'entendre votre opinion et d'examiner avec vous des sujets communs.

C'est tout pour le moment. J'espère que cet article aidera quelqu'un à comprendre l'algorithme Grasshopper et le langage Rust. Merci pour l'attention.

Un merci spécial à Chris F pour les photos de la sauterelle.