Rust, Криптография, Хакинг на Rust, Шифрование

Курс — Хакинг на Rust. #24 Инструменты хакера на Rust. Криптоанализ и безопасность. Реализация и взлом алгоритмов шифрования

05.05.202505.05.2025 by Timcore

Здравствуйте, дорогие друзья.

Криптография — краеугольный камень кибербезопасности. Но даже самые надёжные алгоритмы могут быть скомпрометированы из-за ошибок реализации, слабых ключей или устаревших методов. В этой главе мы разберём, как использовать Rust для реализации шифров, анализа их уязвимостей и проведения атак, чтобы понять, как защищать системы от взлома.

8.1. Основы криптографии в Rust

Rust идеально подходит для работы с криптографией благодаря строгой системе типов, отсутствию сборщика мусора (что снижает риск утечек памяти) и гарантированной безопасности времени выполнения. Однако даже в Rust можно допустить ошибки, например, использовать небезопасные функции или предсказуемые значения соли.

Пример 1: Реализация XOR-шифра
Начнём с простого алгоритма — XOR-шифрования. Несмотря на его уязвимости, он демонстрирует базовые принципы:

fn xor_cipher(data: &[u8], key: u8) -> Vec<u8> {
    data.iter().map(|&b| b ^ key).collect()
}

fn main() {
    let original = b"secret";
    let key = 0xAA;
    let encrypted = xor_cipher(original, key);
    let decrypted = xor_cipher(&encrypted, key);
    assert_eq!(original, decrypted.as_slice());
}

fn xor_cipher(data: &[u8], key: u8) -> Vec<u8> {

data.iter().map(|&b| b ^ key).collect()

}

fn main() {

let original = b"secret";

let key = 0xAA;

let encrypted = xor_cipher(original, key);

let decrypted = xor_cipher(&encrypted, key);

assert_eq!(original, decrypted.as_slice());

}

Этот код шифрует и расшифровывает данные, но ключ длиной 1 байт легко взломать методом перебора.

8.2. Атаки на слабые генераторы случайных чисел

Многие алгоритмы полагаются на случайные числа для генерации ключей. Если источник энтропии слабый, система становится уязвимой.

Пример 2: Взлом предсказуемого ключа
Предположим, ключ генерируется с использованием rand::thread_rng(), но злоумышленник узнал seed:

use rand::{Rng, SeedableRng};
use rand::rngs::StdRng;

let seed = 42; // Предсказуемый seed
let mut rng = StdRng::seed_from_u64(seed);
let weak_key: [u8; 16] = rng.gen();

use rand::{Rng, SeedableRng};

use rand::rngs::StdRng;

let seed = 42; // Предсказуемый seed

let mut rng = StdRng::seed_from_u64(seed);

let weak_key: [u8; 16] = rng.gen();

Зная seed, можно воспроизвести ключ и расшифровать данные.

Защита : Используйте криптографически стойкие генераторы, например, rand::thread_rng() без фиксированного seed.

8.3. Взлом шифров замены (например, Caesar Cipher)

Шифр Цезаря сдвигает символы на фиксированное число позиций. Его можно взломать частотным анализом.

Пример 3: Частотный анализ на Rust

use std::collections::HashMap;

fn caesar_decrypt(ciphertext: &str, shift: u8) -> String {
    ciphertext.bytes()
        .map(|c| if c.is_ascii_alphabetic() {
            let base = if c.is_ascii_uppercase() { b'A' } else { b'a' };
            (base + (c - base + 26 - shift) % 26) as char
        } else {
            c as char
        })
        .collect()
}

fn frequency_attack(ciphertext: &str) -> String {
    let freq = ciphertext.chars()
        .filter(|c| c.is_alphabetic())
        .fold(HashMap::new(), |mut acc, c| {
            *acc.entry(c.to_ascii_uppercase()).or_insert(0) += 1;
            acc
        });

    // Находим наиболее частый символ (предположительно 'E' в английском)
    let (common_char, _) = freq.into_iter().max_by_key(|&(_, count)| count).unwrap();
    let shift = (common_char as u8 - b'E') % 26;
    caesar_decrypt(ciphertext, shift)
}

use std::collections::HashMap;

fn caesar_decrypt(ciphertext: &str, shift: u8) -> String {

ciphertext.bytes()

.map(|c| if c.is_ascii_alphabetic() {

let base = if c.is_ascii_uppercase() { b'A' } else { b'a' };

(base + (c - base + 26 - shift) % 26) as char

} else {

c as char

})

.collect()

}

fn frequency_attack(ciphertext: &str) -> String {

let freq = ciphertext.chars()

.filter(|c| c.is_alphabetic())

.fold(HashMap::new(), |mut acc, c| {

*acc.entry(c.to_ascii_uppercase()).or_insert(0) += 1;

acc

});

// Находим наиболее частый символ (предположительно 'E' в английском)

let (common_char, _) = freq.into_iter().max_by_key(|&(_, count)| count).unwrap();

let shift = (common_char as u8 - b'E') % 26;

caesar_decrypt(ciphertext, shift)

}

Этот код пытается определить сдвиг, анализируя частоту букв.

8.4. Атаки на блочные шифры (AES)

AES считается стойким, но его реализации могут содержать уязвимости. Например, использование режима ECB позволяет провести атаку по шаблонам.

Пример 4: Обнаружение ECB-режима

use aes::Aes128;
use block_modes::{BlockMode, Ecb};
use block_modes::block_padding::Pkcs7;
use hex_literal::hex;

type AesEcb = Ecb<Aes128, Pkcs7>;

fn detect_ecb(ciphertext: &[u8]) -> bool {
    // ECB создаёт повторяющиеся блоки при одинаковых входных данных
    let mut blocks = ciphertext.chunks(16).collect::<Vec<_>>();
    blocks.sort();
    blocks.windows(2).any(|w| w[0] == w[1])
}

fn main() {
    let key = hex!("2b7e151628aed2a6abf7158809cf4f3c");
    let plaintext = b"YELLOW SUBMARINEYELLOW SUBMARINE"; // Повторяющийся блок
    let cipher = AesEcb::new_from_slices(&key, Default::default()).unwrap();
    let ciphertext = cipher.encrypt_vec(plaintext);
    assert!(detect_ecb(&ciphertext));
}

use aes::Aes128;

use block_modes::{BlockMode, Ecb};

use block_modes::block_padding::Pkcs7;

use hex_literal::hex;

type AesEcb = Ecb<Aes128, Pkcs7>;

fn detect_ecb(ciphertext: &[u8]) -> bool {

// ECB создаёт повторяющиеся блоки при одинаковых входных данных

let mut blocks = ciphertext.chunks(16).collect::<Vec<_>>();

blocks.sort();

blocks.windows(2).any(|w| w[0] == w[1])

}

fn main() {

let key = hex!("2b7e151628aed2a6abf7158809cf4f3c");

let plaintext = b"YELLOW SUBMARINEYELLOW SUBMARINE"; // Повторяющийся блок

let cipher = AesEcb::new_from_slices(&key, Default::default()).unwrap();

let ciphertext = cipher.encrypt_vec(plaintext);

assert!(detect_ecb(&ciphertext));

}

Если в шифротексте есть повторяющиеся блоки, это указывает на ECB.

8.5. Многопоточный brute-force

Rust позволяет эффективно использовать многопоточность для ускорения перебора ключей.

Пример 5: Brute-force для XOR-шифра

use rayon::prelude::*;

fn crack_xor(ciphertext: &[u8]) -> u8 {
    (0..=255).into_par_iter()
        .max_by_key(|&key| {
            let text = xor_cipher(ciphertext, key);
            // Оценка "правдоподобия" текста (например, частота пробелов)
            text.iter().filter(|&&c| c == b' ').count()
        })
        .unwrap()
}

use rayon::prelude::*;

fn crack_xor(ciphertext: &[u8]) -> u8 {

(0..=255).into_par_iter()

.max_by_key(|&key| {

let text = xor_cipher(ciphertext, key);

// Оценка "правдоподобия" текста (например, частота пробелов)

text.iter().filter(|&&c| c == b' ').count()

})

.unwrap()

}

Библиотека rayon автоматически распараллеливает перебор ключей.

8.6. Атаки на RSA

RSA уязвим к малым показателям экспоненты или общим модулям.

Пример 6: Атака Хастада (Håstad’s Broadcast Attack)
Если одно и то же сообщение зашифровано с малой экспонентой e и разными модулями, его можно восстановить с помощью китайской теоремы об остатках:

use num_bigint::BigUint;
use num_traits::{One, Zero};

fn hastad_attack(ciphertexts: &[BigUint], moduli: &[BigUint], e: usize) -> BigUint {
    // Реализация китайской теоремы об остатках
    let mut result = BigUint::zero();
    for i in 0..e {
        let mut mi = moduli[i].clone();
        let mut ci = ciphertexts[i].clone();
        for j in 0..e {
            if i != j {
                mi *= &moduli[j];
                ci *= &moduli[j];
            }
        }
        result += ci * mod_inverse(&moduli[i], &mi);
    }
    result.nth_root(e)
}

use num_bigint::BigUint;

use num_traits::{One, Zero};

fn hastad_attack(ciphertexts: &[BigUint], moduli: &[BigUint], e: usize) -> BigUint {

// Реализация китайской теоремы об остатках

let mut result = BigUint::zero();

for i in 0..e {

let mut mi = moduli[i].clone();

let mut ci = ciphertexts[i].clone();

for j in 0..e {

if i != j {

mi *= &moduli[j];

ci *= &moduli[j];

}

result += ci * mod_inverse(&moduli[i], &mi);

}

result.nth_root(e)

}

Этот код работает, если e мало (например, 3), а сообщение не защищено padding’ом.

8.7. Инструменты для криптоанализа

Библиотеки : ring (криптографические примитивы), rust-crypto (устаревшая, но полезная для изучения).
Фаззинг : cargo-fuzz для обнаружения паник в шифрах.
Анализ энтропии : Проверка случайности ключей через библиотеку ent.

8.8. Этический аспект

Криптоанализ требует ответственности. Используйте полученные знания для:

Аудита собственных систем.
Участия в CTF-соревнованиях.
Разработки инструментов защиты, а не взлома.

Задачи для самостоятельного решения :

Реализуйте атаку на шифр Виженера.
Напишите скрипт для обнаружения слабых RSA-ключей.
Проведите фаззинг реализации SHA-256 на Rust.

GitHub-репозиторий : Полный код примеров доступен в репозитории книги.

Вывод : Rust не только помогает писать безопасный код, но и даёт инструменты для глубокого анализа криптографических систем. Понимание уязвимостей алгоритмов — ключевой навык для современного хакера.

На этом все. Всем хорошего дня!

Цикл статей по курсу — «Хакинг на Rust».

Свежие записи

Most Used Categories

Этичный хакинг с Михаилом Тарасовым (Timcore)