Skip to content
Skills Library
Programming · Analysis

reversing-unity-il2cpp

/reversing-unity-il2cpp

Reverse engineer Unity games and apps built with IL2CPP or Mono, using Il2CppDumper, Il2CppInspector, and dnSpy. Use when an APK or IPA contains global-metadata.dat, libil2cpp.so, UnityFramework, or Assembly-CSharp.dll, when jadx shows only UnityPlayerActivity, or when the target is described as a Unity build.

Repository
secskills ↗
Licence
MIT
Last repository change
07.08.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 07.08.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Reverse engineer Unity games and apps built with IL2CPP or Mono, using Il2CppDumper, Il2CppInspector, and dnSpy. Use when an APK or IPA contains global-metadata.dat, libil2cpp.so, UnityFramework, or Assembly-CSharp.dll, when jadx shows only UnityPlayerActivity, or when the target is described as a Unity build.

Original author description

Reverse engineer Unity games and apps built with IL2CPP or Mono, using Il2CppDumper, Il2CppInspector, and dnSpy. Use when an APK or IPA contains global-metadata.dat, libil2cpp.so, UnityFramework, or Assembly-CSharp.dll, when jadx shows only UnityPlayerActivity, or when the target is described as a Unity build.

How it works

  1. When to Use
  2. When NOT to Use
  3. Identify the Build
  4. Recombining Metadata with the Binary
  5. Working the Recovered Code
  6. Security-Relevant Findings
  7. Rationalizations to Reject
  8. References
Original SKILL.md headings · 159 lines, 958 words
SKILL.md preview
---
name: reversing-unity-il2cpp
description: Reverse engineer Unity games and apps built with IL2CPP or Mono, using Il2CppDumper, Il2CppInspector, and dnSpy. Use when an APK or IPA contains global-metadata.dat, libil2cpp.so, UnityFramework, or Assembly-CSharp.dll, when jadx shows only UnityPlayerActivity, or when the target is described as a Unity build.
verified: 2026-07-27
---

# Reversing Unity IL2CPP

Unity ships in two very different shapes, and identifying which one you have
is the entire first decision. A Mono build hands you decompilable .NET
assemblies. An IL2CPP build compiles C# to C++ to native code, and the C#
metadata lives in a separate file that you must recombine with the binary
before anything is readable.

## When to Use

- The APK contains `assets/bin/Data/Managed/Metadata/global-metadata.dat` and
  `lib/arm64-v8a/libil2cpp.so`
- The APK contains `assets/bin/Data/Managed/Assembly-CSharp.dll` (Mono build)
- The IPA contains `Frameworks/UnityFramework.framework`
- `jadx` shows only `UnityPlayerActivity` and Unity plumbing
- You need to recover game or app logic, anti-cheat behaviour, or the API layer

## When NOT to Use

- **Flutter or React Native** — use `reversing-flutter-apps` or
  `reversing-react-native-apps`
- **Ordinary native apps** — use `testing-mobile-applications`
- **Desktop game binaries with no Unity markers** — use `analyzing-binaries`
- **Building cheats or bypassing anti-cheat in live multiplayer services** —
  out of scope; that is service abuse, not assessment

## Identify the Build

```bash
unzip -l target.apk | rg 'global-metadata|libil2cpp|Assembly-CSharp|libmono'
```

| Present | Build | Difficulty |
| --- | --- | --- |
| `Assembly-CSharp.dll`, `libmono*.so` | Mono | Easy — decompile the DLL directly |
| `global-metadata.dat` + `libil2cpp.so` | IL2CPP | The main path below |
| Neither, but `UnityFramework` | iOS IL2CPP | Same as IL2CPP; extract from the decrypted IPA |

**Mono builds are a short job.** Pull the assembly and open it:

```bash
unzip -j target.apk 'assets/bin/Data/Managed/Assembly-CSharp.dll' -d ./out
# dnSpy / dnSpyEx / ILSpy / dotPeek — full C# source recovery, and dnSpy can edit
ilspycmd ./out/Assembly-CSharp.dll -o ./decompiled
```

Everything below is for IL2CPP.

## Recombining Metadata with the Binary

IL2CPP splits the information: `libil2cpp.so` holds the compiled code,
`global-metadata.dat` holds the C# type system — class names, method names,
field names, string literals. Neither is useful alone. The tools' job is to
match them and produce symbols.

```bash
unzip -j target.apk 'lib/arm64-v8a/libil2cpp.so' \
                    'assets/bin/Data/Managed/Metadata/global-metadata.dat' -d ./in

# Il2CppDumper: the standard first attempt
Il2CppDumper ./in/libil2cpp.so ./in/global-metadata.dat ./out
```

Typical output and what it is for:

| Artifact | Use |
| --- | --- |
| `dump.cs` | Every class, method, and field with addresses — **read this first** |
| `DummyDll/` | Stub .NET assemblies; open in dnSpy/ILSpy to browse the type system comfortably |
| `script.json` | Symbol import for IDA/Ghidra — applies names to `libil2cpp.so` |
| `stringliteral.json` | String constants: URLs, keys, messages |

`Il2CppInspector` is the alternative when Il2CppDumper fails; it supports a
different range of Unity versions and emits Ghidra and IDA scripts plus a
richer C++ header. Try both before concluding a build is unsupported.

**Version mismatch is the usual failure.** The metadata format changes across
Unity releases; the tool asks for or infers the version. Read the Unity
version first and feed it explicitly:

```bash
strings ./in/libil2cpp.so | rg -m3 '20[0-9]{2}\.[0-9]+\.[0-9]+' 
strings ./in/global-metadata.dat | head -5
```

**Protected builds** encrypt or scramble `global-metadata.dat` — the header
magic will be wrong and the dumpers will refuse. Signs: the file does not
start with the expected metadata magic, or entropy is uniformly high. The
practical route is dynamic: let the app decrypt the metadata itself, then dump
it from memory once loaded.

```bash
# Dump the decrypted metadata from a running process
frida -U -f com.target.app -l dump-metadata.js
# Then feed the dumped file to Il2CppDumper as normal
```

That pattern — let it unpack itself, dump from memory — is the same one used
for packed malware, and it is almost always cheaper than defeating the
protection statically. See `analyzing-binaries`.

## Working the Recovered Code

1. **Read `dump.cs` for the type map.** Search for the classes that matter:
   anything named `*Manager`, `*Service`, `*Api`, `*Network`, `*Auth`,
   `*Purchase`, `*Config`.
2. **Load `script.json` into IDA or Ghidra** so `libil2cpp.so` shows C# method
   names instead of `sub_1A2B3C`. Without this step the disassembly is
   unreadable; with it, it reads like decompiled C#.
3. **Check `stringliteral.json` for endpoints and keys.** Same reasoning as
   every other framework — string constants survive everything.
4. **Hook at runtime with Frida** using the addresses from `dump.cs`. Method
   addresses are relative to the `libil2cpp.so` base, so resolve the module
   base and add the offset.

```javascript
// Pattern: resolve base, add the RVA from dump.cs, intercept
const base = Module.findBaseAddress('libil2cpp.so');
Interceptor.attach(base.add(0x1A2B3C), {
  onEnter(args) { console.log('called with', args[1]); },
  onLeave(ret)  { console.log('->', ret); }
});
```

## Security-Relevant Findings

For an assessment rather than a curiosity exercise, the recurring issues:

- **Hardcoded credentials and endpoints** in `stringliteral.json` — backend
  keys, analytics tokens, cloud storage credentials.
- **Client-authoritative logic.** Currency, entitlements, and validation done
  in C# and trusted by the server. Verify by calling the API directly.
- **Weak or absent certificate pinning.** Unity's networking layer is often
  configured permissively; check `UnityWebRequest` usage.
- **Local save and config tampering.** `PlayerPrefs` and local save files
  storing values the server trusts.
- **Receipt validation done client-side** for in-app purchases.

## Rationalizations to Reject

- *"jadx shows nothing, so it's protected."* Unity apps have almost nothing in
  the dex by design.
- *"The dumper failed, so the build can't be analyzed."* Try the other dumper,
  supply the Unity version explicitly, and if metadata is encrypted, dump it
  from memory.
- *"IL2CPP is compiled, so the logic is safe."* The metadata ships alongside
  it. That is the whole point of the format.
- *"The client validates the purchase."* Then the purchase is not validated.
- *"I'll read the raw arm64."* Apply `script.json` first. The same function is
  unreadable before and routine after.

## References

- `testing-mobile-applications` — platform storage, permissions, and native layer
- `testing-apis` — the backend, where client-authoritative logic becomes a finding
- `analyzing-binaries` — memory dumping and anti-analysis for protected builds
- Il2CppDumper, Il2CppInspector, dnSpy/ILSpy, Frida, IDA/Ghidra

Versions

The database has no other skills named reversing-unity-il2cpp.

Database snapshot: 13.11.2026 · package version c90140d29e1b (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100reversing-xamarin-maui
    Reverse engineer Xamarin and .NET MAUI mobile apps by extracting assemblies.blob and XALZ-compressed DLLs with pyxamstore, then decompiling with dnSpy or ILSpy. Use when an APK contains libmonodroid.so, libmonosgen, assemblies.blob, assemblies/*.dll, or libxamarin-app.so, when…
  • 100reversing-react-native-apps
    Reverse engineer React Native mobile apps, including Hermes bytecode bundles, using hbctool, hermes-dec, and Frida. Use when an APK contains index.android.bundle or libhermes.so, when an IPA contains main.jsbundle, when jadx shows only ReactActivity classes, or when a bundle…
  • 90inspect-unity-artifacts
    Inspect compiled Unity player, package, data, managed Mono, and IL2CPP artifacts across supported platforms. Use when Codex must identify Unity version and scripting backend; inventory player executables, UnityPlayer, managed assemblies, Assembly-CSharp, GameAssembly,…
  • 100unity-dev
    Use when implementing a Unity C# feature or fix, or when the user requests Unity architecture, implementation, review, or tests.
  • 100unity-platforms
    Unity 6 platform targeting and build guide. Use when building for specific platforms, configuring build profiles, using platform scripting defines (#if UNITY_IOS, #if UNITY_ANDROID), optimizing for mobile, WebGL, or consoles, working with Addressables/asset bundles, or choosing…
  • 100unity-csharp
    Use this skill when the user says 'unity dots', 'unity ecs', 'unity entities', 'ISystem', 'IJobEntity', 'burst compiler', 'unity job system', 'unity c# performance'. Covers Unity Entities (ECS), the C# Job System and Burst plus GC-free C# patterns for Unity gameplay code. Do NOT…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.