Agent skill · Audited from source
code-obfuscation-deobfuscation
skill · yaklang/hack-skillsMIT licenceAudited 14 Nov 2026 · source a6bc8e8fefb6
Is it safe? Yes — SAFE, grade B (89/100). We read this skill's source at commit a6bc8e8fefb6 and found no filesystem, network or shell access and no hard-coded secrets. What it does: Code obfuscation analysis and deobfuscation playbook. Use when reversing binaries protected by junk code, opaque predicates, self-modifying code, control flow flattening, VM protection, or string encryption.
Cite
Cite this page
ModelsAtlas. “code-obfuscation-deobfuscation (yaklang/hack-skills)”. Retrieved 14 Nov 2026. https://modelsatlas.com/skills/yaklang/code-obfuscation-deobfuscation
Trust audit
Audit 0.4.1 · source read 14 Nov 2026
SAFE means nothing in the source contradicts what the skill says it does. Grade B is shared by 17,406 of 18,389 audited skills.
What the source does
- FilesystemNone observedNo reads or writes in the source
- NetworkNone observedNo outbound calls in the source
- ShellNone observedNo commands run in the source
- DependenciesPinnedNothing floats
- SecretsNone foundNo keys in source
Five audit layers
| Layer | What we check | Result | Findings |
|---|---|---|---|
L0 Provenance | Repo owner, licence, archive status, activity | PASS | 0 |
L1 Static source | Secrets, path traversal, supply chain, hidden code | NA | 0 |
L2 Instructions | Prompt injection, authority framing, hidden directives | PASS | 0 |
L3 Inventory | The files and declarations match the source | PASS | 0 |
L4 Sandbox | Run in isolation and watch behaviour | SKIPPED why | 0 |
Gates applied: no behavioural pass.
Findings (0)
No findings at any severity. We re-audit when the source changes.
Audit 0.4.1 · source sha a6bc8e8fefb6 · 14 Nov 2026Report an issue or request a re-scan
Provenance
Who published it, and what the verdict is pinned to
- Publisheryaklang GitHub organizationOwner of the repository this skill is read from
- Source folderyaklang/hack-skills/skills/code-obfuscation-deobfuscationThe exact folder we audited
- LicenceMITAs the repository states it
- Commit pinned for this verdicta6bc8e8fefb6A new audit runs when the source changes
- Repository statusNot archivedLast push 61 days ago
- Sandboxed runNot runSkills are read, not executed; layer L4 is skipped
What it tells the agent
Full source on GitHub ↗Its description: Code obfuscation analysis and deobfuscation playbook. Use when reversing binaries protected by junk code, opaque predicates, self-modifying code, control flow flattening, VM protection, or string encryption.
---
name: code-obfuscation-deobfuscation
description: >-
Code obfuscation analysis and deobfuscation playbook. Use when reversing
binaries protected by junk code, opaque predicates, self-modifying code,
control flow flattening, VM protection, or string encryption.
---
# SKILL: Code Obfuscation & Deobfuscation — Expert Analysis Playbook
> **AI LOAD INSTRUCTION**: Expert techniques for identifying, classifying, and defeating code obfuscation in native binaries. Covers junk code, opaque predicates, SMC, control flow flattening, movfuscator, VM protectors (VMProtect/Themida/Code Virtualizer), string encryption, import hiding, and anti-disassembly tricks. Base models often conflate packing with obfuscation and miss the distinction between static and dynamic deobfuscation strategies.
## 0. RELATED ROUTING
- [anti-debugging-techniques](../anti-debugging-techniques/SKILL.md) when the obfuscated binary also has anti-debug layers
- [symbolic-execution-tools](../symbolic-execution-tools/SKILL.md) when using angr/Z3 for automated deobfuscation
- [vm-and-bytecode-reverse](../vm-and-bytecode-reverse/SKILL.md) for deep VM protector bytecode analysis
### Quick identification picks
| Symptom in IDA/Ghidra | Likely Obfuscation | Start With |
|---|---|---|
| Flat CFG, single giant switch | Control flow flattening | Symbolic execution to recover CFG |
| Only `mov` instructions | movfuscator | demovfuscation / trace-based lifting |
| pushad/pushfd → VM entry | VM protector | Handler table extraction |
| XOR loop before code execution | SMC / string encryption | Dynamic analysis, breakpoint after decode |
| Impossible conditions (opaque predicates) | Junk code insertion | Pattern-based removal |
| All strings unreadable | String encryption | Hook decryption routine, or emulate |
| No imports in IAT | Import hiding | Trace GetProcAddress / hash resolution |
---
## 1. JUNK CODE & OPAQUE PREDICATES
### 1.1 Junk Code Insertion
Dead code that never affects program output, added to increase analysis time.
**Identification**:
- Instructions that write to registers/memory never read afterward
- Function calls whose return values are discarded and have no side effects
- Loops with invariant bounds that compute unused results
**Removal strategy**:
1. Compute def-use chains (IDA/Ghidra data flow analysis)
2. Mark instructions with no downstream use as dead
3. Verify removal doesn't change program behavior (trace comparison)
### 1.2 Opaque Predicates
Conditional branches where the condition is always true or always false, but this is non-obvious.
| Type | Example | Always Evaluates To |
|---|---|---|
| Arithmetic | `x2 ≥ 0` | True |
| Number theory | `x*(x+1) % 2 == 0` | True (product of consecutive ints) |
| Pointer-based | `ptr == ptr` after aliasing | True |
| Hash-based | `CRC32(constant) == known_value` | True |
**Deobfuscation**:
- Abstract interpretation: prove the condition is constant
- Symbolic execution: Z3 proves `∀x: predicate(x) = True`
- Pattern matching: recognize known opaque predicate families
- Dynamic: trace and observe the branch is never taken / always taken
```python
import z3
x = z3.BitVec('x', 32)
s = z3.Solver()
s.add(x * (x + 1) % 2 != 0)
print(s.check()) # unsat → always true
```
---
## 2. SELF-MODIFYING CODE (SMC)
Runtime code patching: encrypted code is decrypted just before execution.
### 2.1 XOR Decryption Loop (Most Common)
```asm
lea esi, [encrypted_code]
mov ecx, code_length
mov al, xor_key
decrypt_loop:
xor byte [esi], al
inc esi
loop decrypt_loop
jmp encrypted_code ; now decrypted
```
### 2.2 Analysis Strategy
```
1. Identify the decryption routine (look for XOR/ADD/SUB in loops writing to .text)
2. Set breakpoint AFTER the loop completes
3. At breakpoint: dump the decrypted memory region
4. Re-analyze the dumped code in IDA/Ghidra
5. For multi-layer: repeat for each decryption stage
```
### 2.3 Automated Unpacking via Emulation
```python
from unicorn import *
from unicorn.x86_const import *
mu = Uc(UC_ARCH_X86, UC_MODE_32)
mu.mem_map(0x400000, 0x10000)
mu.mem_write(0x400000, binary_code)
mu.emu_start(decrypt_entry, decrypt_end)
decrypted = mu.mem_read(code_start, code_length)
```
---
## 3. CONTROL FLOW FLATTENING (CFF)
### 3.1 Structure
Original sequential blocks are transformed into a dispatcher loop:
```
Original: A → B → C → D
Flattened: ┌──────────────────┐
│ dispatcher │
│ switch(state) │◄─────┐
├──────────────────┤ │
│ case 1: block A │──────┤
│ case 2: block B │──────┤
│ case 3: block C │──────┤
│ case 4: block D │──────┘
└──────────────────┘
```
Each block sets `state = next_state` before jumping back to the dispatcher.
### 3.2 Recovery Techniques
| Technique | Tool | Effectiveness |
|---|---|---|
| Symbolic execution | angr, Triton, miasm | High — traces all state transitions |
| Trace-based recovery | Pin/DynamoRIO trace → reconstruct CFG | Medium — covers executed paths only |
| Pattern matching | Custom IDA/Ghidra script | Medium — works for known flatteners |
| D-810 (IDA plugin) | IDA Pro | High — specifically designed for CFF |
### 3.3 Symbolic Deflattening (angr approach)
```python
import angr, claripy
proj = angr.Project('./obfuscated')
cfg = proj.analyses.CFGFast()
# Find dispatcher block (highest in-degree basic block)
dispatcher = max(cfg.graph.nodes(), key=lambda n: cfg.graph.in_degree(n))
# For each case block, symbolically determine successor
for block in case_blocks:
state = proj.factory.blank_state(addr=block.addr)
# ... solve state variable to find real successor
```
---
## 4. MOVFUSCATOR
### 4.1 Concept
All computation reduced to `mov` instructions only (Turing-complete via memory-mapped computation tables). Created by Christopher Domas.
### 4.2 Identification
- Function contains only `mov` instructions (no add, sub, xor, jmp, call)
- Excerpt, first 6,000 characters of SKILL.md, verbatim from the audited commit. It is text from someone else’s repository, quoted so you can judge it before your agent reads it.
Install
Pinned to the audited commit a6bc8e8
git clone https://github.com/yaklang/hack-skills git -C hack-skills checkout a6bc8e8fefb6
The author documents no install command, so this uses the repository directly. Our verdict covers commit a6bc8e8fefb6 only.
Works in
The author has not said which agents this skill supports, and we have not tested it in any.
Audit history
Every audit, every source change
- ✓SAFE B 89 / 100
first audit · source
a6bc8e8fefb6
README badge
For maintainers · shows the latest audit
[](https://modelsatlas.com/skills/yaklang/code-obfuscation-deobfuscation/)
The badge shows our verdict and grade for this skill, and links back to this page. It changes when the audit does.
Similar skills
mattpocock/skills
Implement a piece of work based on a spec or set of tickets.
mattpocock/skills
Compact the current conversation into a handoff document for another agent to pick up.
mattpocock/skills
Pursue a long-running goal in a single session by co-ordinating subagents.
Add this badge to your README
[](https://modelsatlas.com/skills/yaklang/code-obfuscation-deobfuscation/)
<a href="https://modelsatlas.com/skills/yaklang/code-obfuscation-deobfuscation/"><img src="https://modelsatlas.com/skills/yaklang/code-obfuscation-deobfuscation/badge.svg" alt="ModelsAtlas: SAFE B"></a>
Questions about code-obfuscation-deobfuscation
What does the code-obfuscation-deobfuscation skill do?
Is code-obfuscation-deobfuscation safe to install?
What can code-obfuscation-deobfuscation access on my machine?
How current is this page?
Sources
- github.com/yaklang/hack-skills/tree/main/skills/code-obfuscation — the audited source at commit a6bc8e8fefb6 and every finding aboveObserved · 14 Nov 2026
Spotted something wrong? Report a correction · Methodology
Keep going in your AI
Opens with this page as the source. We add nothing else to the prompt.
- What does the code-obfuscation-deobfuscation skill do?
- Is code-obfuscation-deobfuscation safe to install?
- What can code-obfuscation-deobfuscation access on my machine?