il2cpp-bridge-rs 0.1.3

Rust library for Unity IL2CPP runtime introspection — resolve classes, invoke methods, and interact with the IL2CPP VM at runtime
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

//! Assembly metadata wrapper.

use crate::api::{self, cache, dump_assembly};
use crate::logger;
use crate::structs::core::Class;
use std::ffi::c_void;

use super::image::Image;

/// Represents a hydrated IL2CPP assembly.
///
/// In normal usage, values of this type come from [`crate::api::cache`] helper
/// functions such as [`crate::api::cache::csharp`].
#[derive(Debug, Clone)]
pub struct Assembly {
    /// Wrapper for the image associated with this assembly
    pub image: Image,
    /// Pointer to the internal IL2CPP assembly structure
    pub address: *mut c_void,
    /// Filename of the assembly (e.g. "Assembly-CSharp.dll")
    pub file: String,
    /// Name of the assembly (e.g. "Assembly-CSharp")
    pub name: String,
    /// List of classes defined in this assembly
    pub classes: Vec<Class>,
}

unsafe impl Send for Assembly {}
unsafe impl Sync for Assembly {}

impl std::fmt::Display for Assembly {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.fmt_assembly())
    }
}

impl Assembly {
    /// Generates a string representation of the assembly
    ///
    /// This includes the assembly name, file path, address, and a dump of all classes if any are loaded.
    ///
    /// # Returns
    /// * `String` - The formatted string representation
    fn fmt_assembly(&self) -> String {
        let mut s = format!(
            "// Assembly: {} ({}) @ {:?}\n",
            self.name, self.file, self.address
        );

        if !self.classes.is_empty() {
            for class in &self.classes {
                s.push('\n');
                s.push_str(&class.to_string());
            }
        }
        s
    }

    /// Finds a class by name within the assembly.
    ///
    /// Accepts either a fully qualified type name such as
    /// `UnityEngine.GameObject` or an unqualified name for the global
    /// namespace.
    pub fn class(&self, name: &str) -> Option<Class> {
        let (namespace, class_name) = if let Some(last_dot) = name.rfind('.') {
            (&name[..last_dot], &name[last_dot + 1..])
        } else {
            ("", name)
        };

        let namespace_cstr = std::ffi::CString::new(namespace).ok()?;
        let name_cstr = std::ffi::CString::new(class_name).ok()?;

        unsafe {
            let class_ptr = api::class_from_name(
                self.image.address,
                namespace_cstr.as_ptr(),
                name_cstr.as_ptr(),
            );

            if !class_ptr.is_null() {
                return cache::class_from_ptr(class_ptr);
            }
        }

        if let Some(class) = cache::CACHE.classes.get(name) {
            return Some((**class).clone());
        }

        None
    }

    /// Dumps this assembly into a C#-like pseudo-code file and returns `self`.
    ///
    /// This is mainly intended for debugging and offline inspection.
    pub fn dump(&self) -> &Self {
        if dump_assembly(Some(&self.name)).is_none() {
            logger::error("Failed to dump assembly");
        }
        self
    }
}