Rust-Obfuscator

Name: rust-obfuscator
Rating: 5 (326 reviews)
Author: dronavallipranav

rust-obfuscator 是一组工具，旨在通过插入过程宏或（可选地）直接在源代码中提供混淆，自动混淆 Rust 源代码。为了实现更细粒度的混淆，还提供了一个过程宏库 cryptify。

当前支持

字符串字面量加密
控制流混淆
控制流混淆（源代码）
变量重命名（源代码）

特性

字符串加密：在编译时自动加密分配给局部变量的字符串字面量。
也可以用于格式化字符串，但目前需要手动放置

        println!("{}", cryptify::encrypt_string!("hello!"));
    ``
控制流混淆：引入编译时的假循环和随机变量。  
可定制混淆：根据您的需求灵活启用或禁用特定的混淆功能。  
变量重命名：直接对源代码进行混淆，如果您想发布代码或只是想让代码看起来更难懂。  
注意：变量重命名在1.1.1版本中尚未完全支持，正在开发完整支持，因为某些情况尚未涵盖。仍然可以使用该工具并修复相应的编译错误。  
安装  
将 cryptify 添加到您的 Cargo.toml 依赖项中：

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