dotscope 0.7.0

A high-performance, cross-platform framework for analyzing and reverse engineering .NET PE executables
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

//! Benchmarks for method body parsing.
//!
//! Tests parsing performance for various method body formats:
//! - Tiny headers (1 byte, up to 63 bytes code)
//! - Fat headers (12+ bytes, complex methods)
//! - Exception handlers (try/catch/finally blocks)

extern crate dotscope;

use criterion::{criterion_group, criterion_main, Criterion, Throughput};
use dotscope::metadata::method::MethodBody;
use std::{fs, hint::black_box, path::PathBuf};

/// Benchmark parsing a tiny method header.
///
/// Tiny headers are 1 byte and can represent methods up to 63 bytes of IL code.
/// This is the fastest path for simple methods.
fn bench_parse_method_tiny(c: &mut Criterion) {
    let path =
        PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/samples/WB_METHOD_TINY_0600032D.bin");

    let data = fs::read(&path).expect("Failed to read tiny method file");
    let file_size = data.len();

    let mut group = c.benchmark_group("method_body_tiny");
    group.throughput(Throughput::Bytes(file_size as u64));
    group.bench_function("parse", |b| {
        b.iter(|| {
            let body = MethodBody::from(black_box(&data)).unwrap();
            black_box(body)
        });
    });
    group.finish();
}

/// Benchmark parsing a fat method header.
///
/// Fat headers are 12+ bytes and support complex methods with local variables,
/// exception handlers, and large code sizes.
fn bench_parse_method_fat(c: &mut Criterion) {
    let path =
        PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/samples/WB_METHOD_FAT_0600033E.bin");

    let data = fs::read(&path).expect("Failed to read fat method file");
    let file_size = data.len();

    let mut group = c.benchmark_group("method_body_fat");
    group.throughput(Throughput::Bytes(file_size as u64));
    group.bench_function("parse", |b| {
        b.iter(|| {
            let body = MethodBody::from(black_box(&data)).unwrap();
            black_box(body)
        });
    });
    group.finish();
}

/// Benchmark parsing a method with a single exception handler.
///
/// Tests the overhead of parsing exception handling sections.
fn bench_parse_method_with_exception(c: &mut Criterion) {
    let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
        .join("tests/samples/WB_METHOD_FAT_EXCEPTION_06000341.bin");

    let data = fs::read(&path).expect("Failed to read method with exception file");
    let file_size = data.len();

    let mut group = c.benchmark_group("method_body_exception_single");
    group.throughput(Throughput::Bytes(file_size as u64));
    group.bench_function("parse", |b| {
        b.iter(|| {
            let body = MethodBody::from(black_box(&data)).unwrap();
            black_box(body)
        });
    });
    group.finish();
}

/// Benchmark parsing a method with local variables and exception handlers.
///
/// Tests a more realistic complex method scenario.
fn bench_parse_method_with_locals_and_exception(c: &mut Criterion) {
    let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
        .join("tests/samples/WB_METHOD_FAT_EXCEPTION_N1_2LOCALS_060001AA.bin");

    let data = fs::read(&path).expect("Failed to read method with locals file");
    let file_size = data.len();

    let mut group = c.benchmark_group("method_body_with_locals");
    group.throughput(Throughput::Bytes(file_size as u64));
    group.bench_function("parse", |b| {
        b.iter(|| {
            let body = MethodBody::from(black_box(&data)).unwrap();
            black_box(body)
        });
    });
    group.finish();
}

/// Benchmark parsing a method with multiple exception handlers.
///
/// Tests parsing of complex exception handling with multiple try/catch/finally blocks.
fn bench_parse_method_multiple_exceptions(c: &mut Criterion) {
    let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
        .join("tests/samples/WB_METHOD_FAT_EXCEPTION_N2_06000421.bin");

    let data = fs::read(&path).expect("Failed to read method with multiple exceptions file");
    let file_size = data.len();

    let mut group = c.benchmark_group("method_body_exception_multiple");
    group.throughput(Throughput::Bytes(file_size as u64));
    group.bench_function("parse", |b| {
        b.iter(|| {
            let body = MethodBody::from(black_box(&data)).unwrap();
            black_box(body)
        });
    });
    group.finish();
}

/// Benchmark parsing another complex method with nested exception handlers.
fn bench_parse_method_complex_exceptions(c: &mut Criterion) {
    let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
        .join("tests/samples/WB_METHOD_FAT_EXCEPTION_N2_06000D54.bin");

    let data = fs::read(&path).expect("Failed to read complex exception method file");
    let file_size = data.len();

    let mut group = c.benchmark_group("method_body_exception_complex");
    group.throughput(Throughput::Bytes(file_size as u64));
    group.bench_function("parse", |b| {
        b.iter(|| {
            let body = MethodBody::from(black_box(&data)).unwrap();
            black_box(body)
        });
    });
    group.finish();
}

criterion_group!(
    benches,
    bench_parse_method_tiny,
    bench_parse_method_fat,
    bench_parse_method_with_exception,
    bench_parse_method_with_locals_and_exception,
    bench_parse_method_multiple_exceptions,
    bench_parse_method_complex_exceptions,
);
criterion_main!(benches);