Skip to content

Ghidrust provides a hyper fast, AI native reverse engineering platform built in Rust, inspired by Ghidra. Includes experimental GPU kernels to rapidly decompile large files, a decryption suite, and network monitor for packet to binary reverse engineering.

15.9 KB
Raw Blame
//! Unity player install inventory (assemblies, plugins, metadata, XR-related fields).

use ghidrust_core::{load_path, version_info_for_file, VersionInfo};
use ghidrust_il2cpp::{Il2CppMetadata, METADATA_MAGIC};
use serde::Serialize;
use sha2::{Digest, Sha256};
use std::fs;
use std::path::{Path, PathBuf};

pub const SCHEMA_VERSION: u32 = 1;

#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum XrVerdict {
    None,
    StockStubsOnly,
    UnityXrPackaged,
    ExternalModLikely,
    Mixed,
}

#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum Confidence {
    Low,
    Medium,
    High,
}

#[derive(Debug, Clone, Serialize)]
pub struct FileHash {
    pub path: String,
    pub sha256: String,
}

#[derive(Debug, Clone, Serialize)]
pub struct MetadataPeek {
    pub path: String,
    pub present: bool,
    pub magic: Option<String>,
    pub version: Option<i32>,
    pub encrypted_or_obfuscated: bool,
    pub note: Option<String>,
}

#[derive(Debug, Clone, Serialize)]
pub struct EngineFingerprint {
    pub il2cpp: bool,
    pub mono: bool,
    pub burst: bool,
    pub urp: bool,
    pub hdrp: bool,
}

#[derive(Debug, Clone, Serialize)]
pub struct UnityInventory {
    pub schema_version: u32,
    pub root: String,
    pub data_dir: Option<String>,
    pub app_info: Option<String>,
    pub boot_config: Option<Vec<String>>,
    pub scripting_assemblies: Vec<String>,
    pub runtime_initialize_on_loads: Option<usize>,
    pub plugins: Vec<String>,
    pub metadata: Option<MetadataPeek>,
    pub addressables_hint: bool,
    pub engine: EngineFingerprint,
    pub xr_stock_modules: Vec<String>,
    pub xr_packages: Vec<String>,
    pub xr_subsystem_manifests: Vec<String>,
    pub native_xr_imports: Vec<String>,
    pub external_vr_indicators: Vec<String>,
    pub key_hashes: Vec<FileHash>,
    /// PE VERSIONINFO for player exe / key native modules (shared inventory helpers).
    #[serde(default)]
    pub pe_versions: Vec<PeVersionRow>,
    pub verdict: XrVerdict,
    pub confidence: Confidence,
    pub notes: Vec<String>,
}

#[derive(Debug, Clone, Serialize)]
pub struct PeVersionRow {
    pub path: String,
    pub version: VersionInfo,
}

/// Inventory a Unity player directory (exe + `*_Data/` layout).
pub fn inventory_path(root: impl AsRef<Path>) -> Result<UnityInventory, String> {
    let root = root.as_ref();
    if !root.is_dir() {
        return Err(format!("not a directory: {}", root.display()));
    }
    let mut notes = Vec::new();
    let data_dir = find_data_dir(root);
    let data_dir_s = data_dir.as_ref().map(|p| p.display().to_string());

    let app_info = data_dir
        .as_ref()
        .and_then(|d| read_trimmed(d.join("app.info")));
    let boot_config = data_dir.as_ref().and_then(|d| {
        let p = d.join("boot.config");
        fs::read_to_string(p).ok().map(|s| {
            s.lines()
                .map(|l| l.trim().to_string())
                .filter(|l| !l.is_empty())
                .collect()
        })
    });

    let scripting_assemblies = data_dir
        .as_ref()
        .map(|d| read_scripting_assemblies(&d.join("ScriptingAssemblies.json")))
        .unwrap_or_default();

    let runtime_initialize_on_loads = data_dir.as_ref().and_then(|d| {
        let p = d.join("RuntimeInitializeOnLoads.json");
        fs::read_to_string(p).ok().and_then(|s| {
            serde_json::from_str::<serde_json::Value>(&s)
                .ok()
                .and_then(|v| v.as_array().map(|a| a.len()))
        })
    });

    let plugins = data_dir
        .as_ref()
        .map(|d| list_plugins(&d.join("Plugins")))
        .unwrap_or_default();

    let metadata = data_dir.as_ref().map(|d| peek_metadata(d));

    let addressables_hint = data_dir
        .as_ref()
        .map(|d| d.join("StreamingAssets").join("aa").is_dir())
        .unwrap_or(false);

    let (xr_stock_modules, xr_packages) = classify_assemblies(&scripting_assemblies);
    let xr_subsystem_manifests = data_dir
        .as_ref()
        .map(|d| find_subsystem_manifests(d))
        .unwrap_or_default();

    let mut native_xr_imports = Vec::new();
    let mut external_vr_indicators = Vec::new();
    let mut key_hashes = Vec::new();
    let mut pe_versions = Vec::new();

    // Hash player exe + GameAssembly / UnityPlayer when present.
    for name in ["GameAssembly.dll", "UnityPlayer.dll"] {
        let p = root.join(name);
        if p.is_file() {
            if let Some(h) = hash_file(&p) {
                key_hashes.push(h);
            }
            pe_versions.push(PeVersionRow {
                path: p.display().to_string(),
                version: version_info_for_file(&p),
            });
            if let Ok(prog) = load_path(&p) {
                for e in &prog.imports {
                    let dll = e.dll.to_ascii_lowercase();
                    let name = e.name.as_deref().unwrap_or("").to_ascii_lowercase();
                    if dll.contains("openxr")
                        || dll.contains("xr")
                        || name.contains("openxr")
                        || name.contains("xrgetinstance")
                    {
                        let label =
                            format!("{}!{}", e.dll, e.name.clone().unwrap_or_else(|| "?".into()));
                        if !native_xr_imports.contains(&label) {
                            native_xr_imports.push(label);
                        }
                    }
                }
            }
        }
    }
    for p in fs::read_dir(root).into_iter().flatten().flatten() {
        let path = p.path();
        let fname = path
            .file_name()
            .map(|s| s.to_string_lossy().to_ascii_lowercase())
            .unwrap_or_default();
        if fname.ends_with(".exe") {
            if let Some(h) = hash_file(&path) {
                key_hashes.push(h);
            }
            pe_versions.push(PeVersionRow {
                path: path.display().to_string(),
                version: version_info_for_file(&path),
            });
        }
        if fname.contains("inject") && fname.ends_with(".dll") {
            external_vr_indicators.push(format!("sidecar_dll:{}", path.display()));
        }
        if fname.contains("openxr") && fname.ends_with(".dll") && xr_packages.is_empty() {
            external_vr_indicators.push(format!("openxr_loader_no_xr_packages:{}", path.display()));
        }
        if fname.starts_with("dxgi") && fname.ends_with(".dll") {
            external_vr_indicators.push(format!("dxgi_proxy:{}", path.display()));
        }
    }

    if scripting_assemblies.is_empty() && data_dir.is_none() {
        notes.push("no *_Data directory or ScriptingAssemblies.json found".into());
    }

    let engine = EngineFingerprint {
        il2cpp: metadata.as_ref().is_some_and(|m| m.present)
            || root.join("GameAssembly.dll").is_file(),
        mono: scripting_assemblies.iter().any(|a| a.contains("mscorlib"))
            && !root.join("GameAssembly.dll").is_file(),
        burst: scripting_assemblies
            .iter()
            .any(|a| a.contains("Unity.Burst")),
        urp: scripting_assemblies.iter().any(|a| {
            a.contains("UniversalRenderPipeline") || a.contains("Unity.RenderPipelines.Universal")
        }),
        hdrp: scripting_assemblies.iter().any(|a| {
            a.contains("HighDefinition") || a.contains("Unity.RenderPipelines.HighDefinition")
        }),
    };

    let (verdict, confidence) = verdict(
        &xr_stock_modules,
        &xr_packages,
        &xr_subsystem_manifests,
        &native_xr_imports,
        &external_vr_indicators,
    );

    Ok(UnityInventory {
        schema_version: SCHEMA_VERSION,
        root: root.display().to_string(),
        data_dir: data_dir_s,
        app_info,
        boot_config,
        scripting_assemblies,
        runtime_initialize_on_loads,
        plugins,
        metadata,
        addressables_hint,
        engine,
        xr_stock_modules,
        xr_packages,
        xr_subsystem_manifests,
        native_xr_imports,
        external_vr_indicators,
        key_hashes,
        pe_versions,
        verdict,
        confidence,
        notes,
    })
}

fn find_data_dir(root: &Path) -> Option<PathBuf> {
    let mut dirs: Vec<PathBuf> = fs::read_dir(root)
        .ok()?
        .flatten()
        .map(|e| e.path())
        .filter(|p| {
            p.is_dir()
                && p.file_name()
                    .map(|n| n.to_string_lossy().ends_with("_Data"))
                    .unwrap_or(false)
        })
        .collect();
    dirs.sort();
    dirs.into_iter().next()
}

fn read_trimmed(path: PathBuf) -> Option<String> {
    fs::read_to_string(path)
        .ok()
        .map(|s| s.trim().to_string())
        .filter(|s| !s.is_empty())
}

fn read_scripting_assemblies(path: &Path) -> Vec<String> {
    let Ok(text) = fs::read_to_string(path) else {
        return Vec::new();
    };
    // Format: { "names": ["A.dll", ...], "types": [...] }
    if let Ok(v) = serde_json::from_str::<serde_json::Value>(&text) {
        if let Some(names) = v.get("names").and_then(|n| n.as_array()) {
            return names
                .iter()
                .filter_map(|x| x.as_str().map(|s| s.to_string()))
                .collect();
        }
    }
    Vec::new()
}

fn list_plugins(dir: &Path) -> Vec<String> {
    let mut out = Vec::new();
    if !dir.is_dir() {
        return out;
    }
    fn walk(dir: &Path, out: &mut Vec<String>) {
        let Ok(rd) = fs::read_dir(dir) else { return };
        for e in rd.flatten() {
            let p = e.path();
            if p.is_dir() {
                walk(&p, out);
            } else if p
                .extension()
                .map(|x| x.eq_ignore_ascii_case("dll") || x.eq_ignore_ascii_case("so"))
                .unwrap_or(false)
            {
                out.push(p.display().to_string());
            }
        }
    }
    walk(dir, &mut out);
    out.sort();
    out
}

fn peek_metadata(data_dir: &Path) -> MetadataPeek {
    let path = data_dir
        .join("il2cpp_data")
        .join("Metadata")
        .join("global-metadata.dat");
    let path_s = path.display().to_string();
    if !path.is_file() {
        return MetadataPeek {
            path: path_s,
            present: false,
            magic: None,
            version: None,
            encrypted_or_obfuscated: false,
            note: Some("global-metadata.dat not found".into()),
        };
    }
    let Ok(bytes) = fs::read(&path) else {
        return MetadataPeek {
            path: path_s,
            present: true,
            magic: None,
            version: None,
            encrypted_or_obfuscated: false,
            note: Some("failed to read metadata".into()),
        };
    };
    match Il2CppMetadata::peek(&bytes) {
        Ok((magic, version, _)) => MetadataPeek {
            path: path_s,
            present: true,
            magic: Some(format!("{magic:#010x}")),
            version: Some(version),
            encrypted_or_obfuscated: false,
            note: None,
        },
        Err(ghidrust_il2cpp::Error::EncryptedOrObfuscated {
            magic,
            version_field,
        }) => MetadataPeek {
            path: path_s,
            present: true,
            magic: Some(format!("{magic:#010x}")),
            version: Some(version_field),
            encrypted_or_obfuscated: true,
            note: Some(format!(
                "expected magic {METADATA_MAGIC:#010x}; treat as encrypted/obfuscated"
            )),
        },
        Err(e) => MetadataPeek {
            path: path_s,
            present: true,
            magic: None,
            version: None,
            encrypted_or_obfuscated: false,
            note: Some(e.to_string()),
        },
    }
}

fn classify_assemblies(names: &[String]) -> (Vec<String>, Vec<String>) {
    let mut stock = Vec::new();
    let mut packages = Vec::new();
    for n in names {
        let l = n.to_ascii_lowercase();
        if l.contains("unityengine.xrmodule") || l.contains("unityengine.vrmodule") {
            stock.push(n.clone());
        } else if l.contains("unity.xr.")
            || l.contains("unityengine.xr.")
            || l.contains("openxr")
            || l.contains("oculus")
            || l.contains("steamvr")
            || l.contains("openvr")
            || l.contains("xr.management")
        {
            // Stock modules already caught; remaining XR-ish → packages/providers
            if !l.contains("unityengine.xrmodule") && !l.contains("unityengine.vrmodule") {
                packages.push(n.clone());
            }
        }
    }
    (stock, packages)
}

fn find_subsystem_manifests(data_dir: &Path) -> Vec<String> {
    let mut out = Vec::new();
    let roots = [data_dir.join("StreamingAssets"), data_dir.join("Plugins")];
    for root in roots {
        if !root.exists() {
            continue;
        }
        fn walk(dir: &Path, out: &mut Vec<String>) {
            let Ok(rd) = fs::read_dir(dir) else { return };
            for e in rd.flatten() {
                let p = e.path();
                if p.is_dir() {
                    walk(&p, out);
                } else if p
                    .file_name()
                    .map(|n| n == "UnitySubsystemsManifest.json")
                    .unwrap_or(false)
                {
                    out.push(p.display().to_string());
                }
            }
        }
        walk(&root, &mut out);
    }
    out.sort();
    out
}

fn hash_file(path: &Path) -> Option<FileHash> {
    let data = fs::read(path).ok()?;
    let mut hasher = Sha256::new();
    hasher.update(&data);
    let digest = hasher.finalize();
    Some(FileHash {
        path: path.display().to_string(),
        sha256: hex::encode(digest),
    })
}

fn verdict(
    stock: &[String],
    packages: &[String],
    manifests: &[String],
    native: &[String],
    external: &[String],
) -> (XrVerdict, Confidence) {
    let has_stock = !stock.is_empty();
    let has_pkg = !packages.is_empty() || !manifests.is_empty();
    let has_ext = !external.is_empty();
    let has_native = !native.is_empty();

    if !has_stock && !has_pkg && !has_ext && !has_native {
        return (XrVerdict::None, Confidence::Medium);
    }
    if has_ext && has_pkg {
        return (XrVerdict::Mixed, Confidence::High);
    }
    if has_ext && !has_pkg {
        return (XrVerdict::ExternalModLikely, Confidence::High);
    }
    if has_pkg {
        return (XrVerdict::UnityXrPackaged, Confidence::High);
    }
    if has_stock && !has_pkg {
        let conf = if has_native {
            Confidence::Medium
        } else {
            Confidence::High
        };
        return (XrVerdict::StockStubsOnly, conf);
    }
    (XrVerdict::None, Confidence::Low)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn stock_stubs_verdict() {
        let dir = tempfile_dir("stock");
        let data = dir.join("Game_Data");
        fs::create_dir_all(&data).unwrap();
        let json = r#"{"names":["UnityEngine.dll","UnityEngine.XRModule.dll","Assembly-CSharp.dll"],"types":[0,0,0]}"#;
        fs::write(data.join("ScriptingAssemblies.json"), json).unwrap();
        let inv = inventory_path(&dir).unwrap();
        assert_eq!(inv.verdict, XrVerdict::StockStubsOnly);
        assert!(inv.xr_stock_modules.iter().any(|s| s.contains("XRModule")));
        assert!(inv.xr_packages.is_empty());
    }

    #[test]
    fn packaged_xr_verdict() {
        let dir = tempfile_dir("pkg");
        let data = dir.join("Game_Data");
        fs::create_dir_all(&data).unwrap();
        let json = r#"{"names":["Unity.XR.Management.dll","Unity.XR.OpenXR.dll"],"types":[0,0]}"#;
        fs::write(data.join("ScriptingAssemblies.json"), json).unwrap();
        let inv = inventory_path(&dir).unwrap();
        assert_eq!(inv.verdict, XrVerdict::UnityXrPackaged);
    }

    fn tempfile_dir(tag: &str) -> PathBuf {
        let mut p = std::env::temp_dir();
        p.push(format!("ghidrust_unity_inv_{}_{}", tag, std::process::id()));
        let _ = fs::remove_dir_all(&p);
        fs::create_dir_all(&p).unwrap();
        p
    }
}