🌐 Język

Rust-Obfuscator

rust-obfuscator to zestaw narzędzi zaprojektowanych do automatycznego zaciemniania kodu źródłowego Rust poprzez wstawianie makr proceduralnych lub (opcjonalnie) bezpośrednie zaciemnianie w kodzie źródłowym. Dla bardziej szczegółowego zaciemniania dostępna jest także biblioteka makr proceduralnych cryptify.

Aktualnie wspierane

szyfrowanie literałów tekstowych
zaciemnianie przepływu sterowania
zaciemnianie przepływu sterowania (kod źródłowy)
zmiana nazw zmiennych (kod źródłowy)

Funkcje

Szyfrowanie ciągów znaków: Automatycznie szyfruje literały ciągów znaków przypisane do zmiennych lokalnych podczas kompilacji.
Może być również używane do sformatowanych ciągów znaków, ale obecnie wymaga ręcznego umieszczenia

        println!("{}", cryptify::encrypt_string!("hello!"));
    ``
Zaciemnianie przepływu sterowania: Wprowadza fikcyjne pętle kompilacyjne i losowe zmienne.
Konfigurowalne zaciemnianie: Oferuje elastyczność w włączaniu lub wyłączaniu konkretnych funkcji zaciemniania w zależności od potrzeb.
Zmiana nazw zmiennych: Zaciemnianie kodu źródłowego bezpośrednio, jeśli chcesz rozprowadzać kod lub po prostu sprawić, by wyglądał gorzej.
UWAGA: zmiana nazw zmiennych nie działa w pełni poprawnie w wersji 1.1.1, trwają prace nad pełnym wsparciem, ponieważ niektóre przypadki nie są jeszcze obsłużone. Nadal można korzystać z narzędzia i poprawić odpowiednie błędy kompilatora.
Instalacja
Dodaj cryptify do swojego pliku Cargo.toml jako zależność:

toml
[dependencies]
cryptify = "3.2.1"
Aby zainstalować rust-obfuscator, sklonuj repozytorium i zbuduj narzędzie za pomocą Cargo z katalogu głównego:

cargo build --release --bin rust-obfuscator
Plik binarny można następnie znaleźć w katalogu /target/release, możesz go skopiować do katalogu głównego projektu w następujący sposób
cp ./target/release/rust-obfuscator .

Użycie
Ustaw zmienną środowiskową CRYPTIFY_KEY dla własnego szyfrowania, w przeciwnym razie zostanie użyty domyślnie zdefiniowany stały klucz
Dodaj do kodu źródłowego, który chcesz zmodyfikowaćrs
use cryptify;
Plik binarny może być używany zarówno na pliku, jak i katalogu. Jeśli zostanie podany katalog, zmodyfikuje tylko pliki źródłowe Rust znajdujące się w tym katalogu, a nie w podkatalogach.sh
./rust-obfuscator path/to/your_project 
- Cały kod zaciemniony będzie znajdował się w katalogu obfuscated_code, który zostanie utworzony w katalogu, z którego uruchomiono narzędzie.
Zaleca się użycie formatera Rust dla kodu zaciemnionego, ponieważ syn naturalnie modyfikuje strukturę i kod zostanie zapisany do pliku jako jedna linia
Flagi opcji
--no_string: Wyłącza zaciemnianie ciągów znaków.
--no_flow: Wyłącza zaciemnianie przepływu sterowania.
--disable_macro: Używa bezpośredniej manipulacji kodem źródłowym do zaciemniania przepływu zamiast proceduralnych makr.
--var: Włącza zaciemnianie kodu źródłowego poprzez zmianę nazw zmiennych.
Przykład użycia z flagąsh
rust-obfuscator path/to/your_project --no_flow 
(wyłącza zaciemnianie przepływu)
Wejście
-uruchamianie narzędzia bez konfiguracjirs
use cryptify;
mod word_counter;
use std::env;
use std::fs;
use word_counter::count_words;
fn main() {
    let b = "Hello World";
    println!("{}", b);
    let args: Vec = env::args().collect();
    if args.len() < 2 {
        eprintln!("Usage: {} ", args[0]);
        return;
    }
    let filename = &args[1];
    let content = fs::read_to_string(filename).expect("Could not read file");
    let word_counts = count_words(&content);
    for (word, count) in word_counts.iter() {
        println!("{}: {}", word, count);
    }
}
fn dummy() {
    let a = 1;
    let b = 2;
    let c = a + b;
    println!("{}", c);
}
fn calc_sum(a: i32, b: i32) -> i32 {
    cryptify::flow_stmt!();
    let c = a + b;
    c
}
fn helloooo(){
    println!("hi");
}
# Wyjściers
fn main() {
    cryptify::flow_stmt!();
    let b = cryptify::encrypt_string!("Hello World");
    println!("{}", b);
    let args: Vec = env::args().collect();
    if args.len() < 2 {
        eprintln!("Usage: {} ", args[0]);
        return;
    }
    let filename = &args[1];
    let content = fs::read_to_string(filename).expect("Could not read file");
    let word_counts = count_words(&content);
    for (word, count) in word_counts.iter() {
        println!("{}: {}", word, count);
    }
}
fn dummy() {
    cryptify::flow_stmt!();
    let a = 1;
    let b = 2;
    let c = a + b;
    println!("{}", c);
}
fn calc_sum(a: i32, b: i32) -> i32 {
    cryptify::flow_stmt!();
    let c = a + b;
    c
}
fn helloooo() {
    println!("hi");
}
## Rozszerzone wyjściers
fn main() {
    {
        let _is_dummy_145 = true;
        let mut _dummy_counter = std::hint::black_box(4i32 as i32);
        let _dummy_increment = std::hint::black_box(1i32 as i32);
        let _dummy_upper_bound = std::hint::black_box(53i32 as i32);
        loop {
            if std::hint::black_box(_dummy_counter)
                > std::hint::black_box(_dummy_upper_bound)
            {
                break;
            }
            _dummy_counter = std::hint::black_box(
                std::hint::black_box(_dummy_counter)
                    + std::hint::black_box(_dummy_increment),
            );
        }
    };
    match (&1, &1) {
        (left_val, right_val) => {
            if !(left_val == right_val) {
                let kind = ::core::panicking::AssertKind::Eq;
                ::core::panicking::assert_failed(
                    kind,
                    &*left_val,
                    &*right_val,
                    ::core::option::Option::None,
                );
            }
        }
    };
}
fn dummy() {
    {
        let _is_dummy_145 = true;
        let mut _dummy_counter = 4i32;
        let _dummy_upper_bound = 100;
        let _dummy_increment = 3i32;
        loop {
            if _dummy_counter > _dummy_upper_bound {
                break;
            }
            unsafe {
                std::ptr::write_volatile(
                    &mut _dummy_counter,
                    _dummy_counter + _dummy_increment,
                );
            }
        }
    };
    let a = 1;
    let b = 2;
    let c = a + b;
    {
        ::std::io::_print(format_args!("{0}\n", c));
    };
}
fn calc_sum(a: i32, b: i32) -> i32 {
    {
        let _is_dummy_145 = true;
        let mut _dummy_counter = 8i32;
        let _dummy_increment = 3i32;
        let _extra_dummy_var = 4i32;
        let _dummy_upper_bound = 100;
        loop {
            if _dummy_counter > _dummy_upper_bound {
                break;
            }
            unsafe {
                std::ptr::write_volatile(
                    &mut _dummy_counter,
                    _dummy_counter + _dummy_increment,
                );
            }
        }
    };
    let c = a + b;
    c
}
fn helloooo() {
    {
        ::std::io::_print(format_args!("hi\n"));
    };
}

Licencja

rust-obfuscator jest licencjonowany na warunkach licencji MIT – szczegóły znajdziesz w pliku LICENSE.

--- Tranlated By Open Ai Tx | Last indexed: 2026-03-21 ---