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 ディレクトリ内に配置されます。
syn は構造を自然に変更し、ファイルには1行で書き込まれるため、難読化コードには Rust フォーマッタの使用を推奨します。
オプションフラグ
--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 ---