Verbesserung der Heuschrecke in Rost

Start

Manchmal ist eine einfache und schöne Lösung besser als eine korrekte und konsistente. Vielleicht wäre dies der Fall, wenn alles im Leben wie in Lehrbüchern geschehen würde. In der Praxis ist es jedoch ein langer Weg, um die Dinge zu erledigen.

Ausgehend von den Texten möchte ich in diesem Artikel dem interessierten Leser etwas über die GOST-Verschlüsselung, nämlich den Grasshopper-Algorithmus, und darüber erzählen, dass es sich lohnt, auf neue und vielversprechende Tools zu achten - die Rust-Sprache.

Genug Abschweifungen, ich schlage vor, Sie fangen an!

Was wird in diesem Artikel sein

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

, , , . , , .

, , , . . , .

• .

  
  
  
  
  

• (, , .).

  
  
  
  
  

• .

  
  
  
  
  

• .

  
  
  
  
  

• , .

  
  
  
  
  

…

Alle Ihre Gedanken in einem Artikel zu platzieren, wäre meiner Meinung nach falsch. So können Sie schnell müde werden und das Interesse an dem Material verlieren. Darüber hinaus würde ich mich freuen, Ihre Meinung zu hören und gemeinsame Themen mit Ihnen zu besprechen.

Das ist alles für jetzt. Hoffe, dieser Artikel hilft jemandem, den Grasshopper-Algorithmus und die Rust-Sprache zu verstehen. Vielen Dank für Ihre Aufmerksamkeit.

Besonderer Dank geht an Chris F für die Fotos der Heuschrecke.