🌐 語言

Rust-Obfuscator

rust-obfuscator 是一套設計用來自動混淆 Rust 原始碼的工具，可通過插入程序巨集或（可選）直接在原始碼中提供混淆功能。如需更細緻的混淆，亦提供程序巨集函式庫 cryptify。

目前支援功能

字串常值加密
控制流程混淆
控制流程混淆（原始碼）
變數重新命名（原始碼）

功能

字串加密：在編譯時自動加密分配給區域變數的字串常值。
也可用於格式化字串，但目前需要手動放置

        println!("{}", cryptify::encrypt_string!("hello!"));
    ``
控制流程混淆：引入編譯階段虛擬迴圈和隨機變數。
可自訂混淆：可根據需求靈活啟用或停用特定的混淆功能。
變數重新命名：直接對原始碼進行混淆，如果你想發佈原始碼或只是想讓你的程式碼難以閱讀。
注意：變數重新命名在 1.1.1 版本尚未完全支援，部分情況尚未涵蓋，仍可使用工具並修正相應的編譯錯誤。
安裝
在你的 Cargo.toml 檔案中新增 cryptify 作為依賴項：

toml
[dependencies]
cryptify = "3.2.1"
要安裝 rust-obfuscator，請從根目錄複製存儲庫並使用 Cargo 建構該工具：

cargo build --release --bin rust-obfuscator
二進位檔案可以在 /target/release 下找到，您可以像這樣將它複製到專案根目錄
cp ./target/release/rust-obfuscator .

使用方法
設定 CRYPTIFY_KEY 環境變數以自訂加密，否則將使用預設的固定金鑰
將其新增到您想要修改的原始碼中rs
use cryptify;
該可執行檔可以用於檔案或目錄。如果提供的是目錄，則只會修改該目錄中的 Rust 原始檔案，而不會修改任何子目錄。sh
./rust-obfuscator path/to/your_project 
- 所有混淆後的程式碼將會位於從執行工具的目錄下建立的 obfuscated_code 目錄中。
建議對混淆後的程式碼使用 Rust 格式化工具，因為 syn 會自然地修改結構，且程式碼會以單行形式寫入檔案
選項旗標
--no_string：停用字串混淆。
--no_flow：停用控制流程混淆。
--disable_macro：針對流程混淆使用直接的原始碼操作，而非程序巨集。
--var：啟用變數重新命名的原始碼混淆。
搭配旗標的範例用法sh
rust-obfuscator path/to/your_project --no_flow 
（禁用流程混淆）
輸入
-在沒有設定檔的情況下執行工具rs
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");
}
# 輸出rs
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");
}
## 擴展輸出rs
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"));
    };
}

授權

rust-obfuscator 採用 MIT 授權條款，詳情請參閱 LICENSE 文件。

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