ReDyne

A Production-Grade iOS Decompiler & Reverse Engineering Suite

Deep Mach-O analysis, ARM64/x86_64 disassembly, control flow graphs, and advanced reverse engineering tools — all native on iOS.

Features · Installation · Usage · Architecture · Contributing

Note: This is a fork of speedyfriend433/ReDyne with additional enhancements and features. We are grateful to speedyfriend433 for creating the original project and continue to build upon their excellent work.

🎯 Overview

ReDyne is a sophisticated, native iOS application for reverse engineering and analyzing Mach-O binaries (dylibs, frameworks, executables). Built from the ground up with production-grade C/Objective-C/Swift, it brings desktop-class decompilation capabilities to iOS devices.

Why ReDyne?

🚀 Production-Grade: Fully functional decompiler with enterprise-level code quality
📱 Native iOS: Optimized for iOS with a beautiful, intuitive interface
⚡ High Performance: C-based parsing engines for blazing-fast analysis
🔍 Comprehensive: 11+ analysis modules covering every aspect of Mach-O binaries
🎨 Modern UI: Clean, adaptive interface with Dark Mode support
📊 Visual Analysis: Interactive control flow graphs with zoom and pan
🔐 Secure: Security-scoped bookmarks for persistent file access

✨ Features

📦 Mach-O Binary Analysis

Universal Binary Support: Automatic fat/thin binary detection
Multi-Architecture: ARM64, ARM64e, x86_64 support
Architecture Selection: Pick specific slice from universal binaries
Magic Number Detection: Comprehensive format validation
Load Commands: Complete parsing of all LC_* commands
Segments & Sections: Detailed segment/section analysis with flags

🔍 Disassembly Engine

ARM64 Disassembler: Production-grade decoder with 100+ instruction types
- Data Processing (ADD, SUB, MOV, MOVZ, MOVN, MOVK)
- Load/Store (LDR, STR, LDP, STP, LDUR, STUR)
- Branches (B, BL, BR, BLR, RET, B.cond, CBZ, CBNZ, TBZ, TBNZ)
- Logical Operations (AND, ORR, EOR, BIC, ORN, EON)
- Multiply/Divide (MUL, MADD, MSUB, UDIV, SDIV)
- Compare (CMP, CMN, TST, CCMP)
- Shifts (LSL, LSR, ASR, ROR)
- SIMD/FP Operations
- System Instructions (MSR, MRS, NOP, WFE, WFI, barriers)
x86_64 Disassembler: Full support with ModR/M, SIB, REX prefixes
Register Tracking: Reads/writes analysis for data flow
Branch Detection: Automatic identification of control flow changes

🔗 Cross-Reference Analysis

Call Graphs: 586+ calls detected per binary
Jump Analysis: 277+ jumps/branches tracked
Data References: Symbol and address resolution
Symbolic Execution: ADRP+ADD pattern recognition
Page-Aligned Addresses: Proper ARM64 address computation

📊 Control Flow Graphs (CFG)

Hierarchical Layout: BFS-based level assignment
Basic Block Analysis: Automatic BB detection and splitting
Edge Classification: True/false branches, loop-backs, calls, returns
Dominance Analysis: Proper loop detection with back-edge identification
Interactive Visualization: Pinch-to-zoom (0.05x-3.0x), pan, auto-fit
Dynamic Sizing: Handles 1-158+ nodes without clipping
Color-Coded: Entry (blue), exit (red), conditional (orange)

🧬 Symbol Analysis

Symbol Table Parsing: Complete nlist/nlist_64 support
Symbol Types: Functions, objects, sections, undefined
Dynamic Symbols: Import/export detection
Name Demangling: Swift/C++ symbol demangling
Address Resolution: Virtual-to-file offset mapping
Function Name Import: Load JSON mappings and override function names by address

🎯 Objective-C Runtime

Class Extraction: Parse __objc_classlist sections
Method Discovery: Instance and class methods
Property Analysis: @property declarations
Instance Variables: ivar layouts
Categories: Category parsing with methods/properties
Protocols: Protocol conformance detection

📥 Import/Export Tables

Dyld Bind Info: All 12 bind opcodes (DONE, SET_, DO_BIND_)
Dyld Rebase Info: All 9 rebase opcodes
Export Trie: Recursive traversal with ULEB128 decoding
Weak Imports: Weak binding detection
Lazy Bindings: Lazy symbol resolution tracking
Library Dependencies: Full dylib dependency tree

🔐 Code Signature Inspector

SuperBlob Parsing: Proper blob index structure parsing
CodeDirectory: CDHash, Team ID, Signing ID extraction
Entitlements: XML entitlement parsing and formatting
Requirements: Code requirement validation
Signature Type: Ad-hoc vs Full signing detection
Certificate Chain: Signing authority tracking

🔢 Hex Viewer

Hexadecimal Display: View raw binary data in hex format with ASCII representation
Address Navigation: Jump to specific addresses, functions, or sections
Smart Annotations: Display section names and data type information
Context Menus: Long-press for quick actions (copy address, go to hex viewer)
Visual Filters: Filter by code sections, data sections, or show all
Export Capability: Export hex dumps in text or binary format
Interactive Selection: Tap rows to view detailed address information
Search Support: Search by hexadecimal address notation

🎨 Export Formats

TXT: Clean, readable text format
JSON: Structured JSON with full metadata
HTML: Styled HTML with syntax highlighting
PDF: Multi-page PDF with professional typography
Share Sheet: Native iOS sharing integration

🧾 Class Dump & Types

Class Dump Headers: Generate Objective-C style headers from binaries
Type Reconstruction: Infer types and surface reconstructed metadata

🗂️ String Analysis

C-String Extraction: ASCII/UTF-8 string detection
Minimum Length Filter: Configurable string size
Section-Aware: Extract from __cstring, __text, etc.
Encoding Detection: Automatic charset recognition

💾 Recent Files

Security-Scoped Bookmarks: Persistent file access
Automatic Cleanup: Stale bookmark refresh
Swipe to Delete: Easy management
Path Display: Full file path shown

🏗️ Architecture

Technology Stack

Core Parsing (C)

MachOParser.c - Mach-O header/command parsing
DisassemblyEngine.c - ARM64/x86_64 instruction decoding
SymbolTable.c - Symbol table parsing
DyldInfo.c - Dyld bind/rebase/export parsing
ObjCParser.c - Objective-C runtime analysis
CodeSignature.c - Code signature parsing
ControlFlowGraph.c - CFG construction and analysis
StringExtractor.c - String extraction

Services (Objective-C)

MachOParserService.m - Swift bridge for Mach-O parsing
DisassemblerService.m - Disassembly service with pseudocode
ObjCParserBridge.m - ObjC runtime bridge

Analysis (Swift)

CFGAnalyzer.swift - Control flow graph analysis
XrefAnalyzer.swift - Cross-reference analysis with symbolic execution
CFGModels.swift - Graph layout algorithms

UI (Swift + UIKit)

FilePickerViewController - File selection and recents
DecompileViewController - Main analysis orchestration
ResultsViewController - Multi-tab results display
CFGViewController - Interactive CFG visualization
CFGGraphView - Custom Core Graphics rendering

Design Patterns

Bridge Pattern: C ↔ Objective-C ↔ Swift interop
Service Layer: Decoupled parsing and analysis
MVVM: Clean separation of data and presentation
Delegates: UITableView, UIDocumentPicker protocols
Factory Pattern: Model object creation
Strategy Pattern: Multiple export formats

Performance Optimizations

C-Based Parsers: Maximum performance for binary parsing
Lazy Loading: Parse on-demand for large binaries
Efficient Memory: RAII patterns, proper cleanup
Background Processing: Async analysis with DispatchQueue
View Recycling: UITableView cell reuse
Dynamic Layout: Adaptive CFG sizing

📋 Requirements

iOS: 16.0 or later
Device: iPhone or iPad
Storage: ~50 MB app + space for analyzed files
Architectures: ARM64 (device), x86_64 (simulator)

🚀 Installation

Building from Source

Clone the Repository

git clone https://github.com/IntervalMedia/ReDyne.git
cd ReDyne

Open in Xcode
```
open ReDyne.xcodeproj
```
Configure Signing
- Select your development team in Xcode
- Update bundle identifier if needed
Build and Run
- Select your target device/simulator
- Press Cmd+R to build and run

Requirements for Building

Xcode 16.0+
macOS 15.0+
Active Apple Developer account (for device testing)

Alternative: VSCode + GitHub Actions

You can develop and build ReDyne without a local Xcode setup:

Code in VSCode
- Use VS Code or any editor to modify Swift/Objective-C/C source files
- The project includes a .code-workspace file for VS Code integration
- Leverage language servers and extensions for syntax highlighting
Build with GitHub Actions
- Fork the repository and push your changes to GitHub
- GitHub Actions workflow automatically builds the project
- Produces an unsigned IPA file artifact
Sign the IPA
- Download the unsigned IPA from GitHub Actions artifacts
- Use a signing service (e.g., AltStore, Sideloadly, iOS App Signer) to sign it
- Obtain a free Apple Developer certificate from developer.apple.com
- Install the signed IPA on your device via Xcode, AltStore, or similar tools

This workflow is ideal for contributors without macOS or those who prefer cloud-based CI/CD.

📖 Usage

Quick Start

Launch ReDyne on your iOS device
Tap "Select Mach-O File" to open the file picker
Choose a dylib/framework to analyze
Wait for analysis (typically 2-10 seconds)
Explore results across 11 tabs:
- File Info: Basic file metadata
- Mach-O Header: Magic, CPU type, file type, flags
- Segments: Segment/section analysis
- Symbols: Symbol table entries
- Disassembly: Annotated ARM64/x86_64 code
- Strings: Extracted string constants
- Functions: Detected function boundaries
- Xref: Cross-reference analysis
- ObjC Classes: Objective-C runtime data
- Imports/Exports: Dyld binding information
- Code Signature: Signing details and entitlements
- CFG: Interactive control flow graphs

Advanced Features

Hex Viewer

View binary data in hexadecimal format with ASCII representation
Navigate to specific addresses or functions
Filter by code/data sections
Toggle annotations to show section information
Export hex dumps in text or binary format
Long-press on rows to access context menu
Search for specific addresses using hex notation (0x...)

Control Flow Graphs

Tap any function to visualize its CFG
Pinch to zoom in/out (0.05x to 3.0x)
Drag to pan across large graphs
Tap nodes to inspect basic blocks

Export Data

Tap the share button in any tab
Choose format: TXT, JSON, HTML, or PDF
Share via AirDrop, Messages, Mail, etc.

Recent Files

Files automatically saved to recents
Swipe left to delete entries
Tap to re-open (works even after app restart!)

Universal Binary Selection

For fat binaries, choose specific architecture
ARM64, ARM64e, x86_64 options shown
Analysis tailored to selected slice

🧪 Technical Details

Instruction Decoding

ReDyne implements production-grade instruction decoders with priority-based pattern matching:

ARM64 Decoder Priority:

B/BL (immediate branches)
RET/BR/BLR (register branches)
STP/LDP (stack operations)
Data Processing (arithmetic, logical)
Load/Store (memory access)
Conditional branches
SIMD/FP operations

Decoding Features:

Precise bit-field extraction
Operand formatting (registers, immediates, addresses)
Branch target calculation
PC-relative address resolution
Register usage tracking

CFG Construction

Algorithm:

Basic Block Detection: Split at branches, calls, returns
Level Assignment: BFS traversal for hierarchical layout
Node Positioning: Center-based coordinate system
Edge Classification: Analyze branch types
Loop Detection: Dominance-based back-edge identification
Bounds Calculation: Include node + edge dimensions
Dynamic Sizing: Content-aware canvas growth

Layout Features:

Automatic spacing adjustment
Edge overlap prevention
Node size adaptation
Loop-back edge handling

Security-Scoped Bookmarks

ReDyne uses iOS security-scoped bookmarks for persistent file access:

// On file pick
let bookmarkData = try url.bookmarkData(options: .minimalBookmark)
UserDefaults.standard.saveFileBookmark(bookmarkData, for: path)

// On file access
let url = try URL(resolvingBookmarkData: bookmarkData, options: .withoutUI)
url.startAccessingSecurityScopedResource()
// ... use file
url.stopAccessingSecurityScopedResource()

This allows files to be accessed even after app restart or device reboot.

🤝 Contributing

Contributions are welcome! Here's how you can help:

Bug Reports

Use GitHub Issues
Include iOS version, device model
Provide sample binary (if possible)
Describe expected vs actual behavior

Feature Requests

Open a GitHub Issue with [Feature Request] tag
Describe use case and benefit
Link to relevant documentation/specs

Pull Requests

Fork the repository
Create a feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

Code Style

Follow existing patterns
C code: RAII, clear ownership
Swift: camelCase, clear types
Comments for complex logic
Update README if adding features

📝 License

This project is licensed under the MIT License - see the LICENSE file for details.

MIT License

Copyright (c) 2025 speedyfriend433 (Original Project)
Copyright (c) 2025 IntervalMedia (Fork)

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

👤 Authors

IntervalMedia (Fork Maintainer)

GitHub: @IntervalMedia

speedyfriend433 (Original Author)

GitHub: @speedyfriend433
Email: speedyfriend433@gmail.com

🙏 Acknowledgments

speedyfriend433 - Original creator of ReDyne
ARM Architecture Reference Manual - Instruction encoding specifications
Apple Mach-O Documentation - File format details
iOS Developer Community - Testing and feedback
Open Source Contributors - Issue reports and PRs

📊 Statistics

Codebase:

~15,000 lines of C/Objective-C/Swift
11 analysis modules
100+ ARM64 instruction types
50+ x86_64 instruction types
12 dyld bind opcodes
9 dyld rebase opcodes

Capabilities:

Analyze 500KB dylib in ~3 seconds
Disassemble 485,000+ instructions
Generate CFGs with 158+ nodes
Detect 863+ cross-references
Parse 143+ exports per binary

🗺️ Roadmap

Planned Features:

📸 Screenshots

🐛 Known Issues

⚠️ Very large binaries (>100MB) may cause memory pressure
⚠️ Some complex ObjC runtime structures not yet parsed
⚠️ x86_64 coverage is not 100% (ARM64 prioritized)

See Issues for full list.

💬 Support

Questions? Open a GitHub Discussion
Bug? File an Issue
Original Project: speedyfriend433/ReDyne

⭐ Star this repo if you find it useful! ⭐

Made with ❤️ for the iOS reverse engineering community

Name		Name	Last commit message	Last commit date
Latest commit History 15 Commits
.github		.github
Documentation		Documentation
ReDyne.xcodeproj		ReDyne.xcodeproj
ReDyne		ReDyne
ReDyneTests		ReDyneTests
ReDyneUITests		ReDyneUITests
Tests/Fixtures		Tests/Fixtures
plan		plan
.gitignore		.gitignore
2026-02-26T07:09:33.1453120Z Current run.log		2026-02-26T07:09:33.1453120Z Current run.log
BUILD_FIXES.md		BUILD_FIXES.md
BUILD_GUIDE.md		BUILD_GUIDE.md
CHANGELOG.md		CHANGELOG.md
CONTRIBUTING.md		CONTRIBUTING.md
LICENSE.md		LICENSE.md
README.md		README.md
ReDyne.code-workspace		ReDyne.code-workspace

Folders and files

Latest commit

History

Repository files navigation