Rosetta-2 Reverse-Engineering-Projekt

Ein umfassendes Reverse-Engineering-Projekt zum Verständnis und zur Dokumentation von Apples Rosetta 2-Binärübersetzungstechnologie.

Inhaltsverzeichnis

1. Hintergrund
2. Was ist Rosetta?
3. Was ist Rosetta 2?
4. Wie Apple Rosetta 2 in macOS bereitstellt
5. Technische Architektur
6. Dieses Projekt
7. Dateistruktur
8. Verwendung
9. Fortschritt
10. Referenzen

Hintergrund

Der Architekturwechsel

Im November 2020 kündigte Apple seine ersten Apple-Silicon-Macs an, was einen historischen Übergang von Intel-x86_64-Prozessoren zu den eigenen ARM-basierten M1-Chips markierte. Dies war Apples dritter großer Architekturwechsel:

1. 1994: Motorola 68000 -> PowerPC
2. 2006: PowerPC -> Intel x86_64
3. 2020: Intel x86_64 -> Apple Silicon (ARM64)

Jeder Übergang erforderte eine Binärübersetzungslösung, um vorhandene Software während der Migrationsphase ausführen zu können. Rosetta 2 ist Apples bisher ausgeklügeltstes Binärübersetzungssystem.

Was ist Rosetta?

Rosetta (2006-2011) war Apples erste dynamische Binärübersetzungssoftware, die es PowerPC-Anwendungen ermöglichte, auf Intel-basierten Macs zu laufen.

Hauptmerkmale:

• Dynamische Übersetzung: Übersetzte PowerPC-Code zur Laufzeit in x86_64
• OS-Integration: In Mac OS X 10.4 (Tiger) bis 10.6 (Snow Leopard) integriert
• Transparenter Betrieb: Benutzer starteten PowerPC-Apps normal
• Leistungsmehraufwand: Typischerweise 20-50 % langsamer als nativer Code

Rosetta wurde in Mac OS X 10.7 (Lion) entfernt, womit der Intel-Übergang abgeschlossen wurde.

Was ist Rosetta 2?

Rosetta 2 ist Apples fortschrittliche dynamische Binärübersetzungstechnologie, die es Anwendungen, die für Intel x86_64 Macs kompiliert wurden, ermöglicht, auf Apple Silicon (ARM64) Macs zu laufen.

Architekturübersicht```

┌─────────────────────────────────────────────────────────────┐ │ User Application (x86_64) │ ├─────────────────────────────────────────────────────────────┤ │ Rosetta 2 Layer │ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────┐ │ │ │ Translator │ │ Runtime │ │ System Call │ │ │ │ (AOT/JIT) │ │ Library │ │ Translation │ │ │ └─────────────┘ └─────────────┘ └─────────────────────┘ │ ├─────────────────────────────────────────────────────────────┤ │ macOS Kernel (ARM64) │ ├─────────────────────────────────────────────────────────────┤ │ Apple Silicon Hardware │ └─────────────────────────────────────────────────────────────┘

### Schlüsseltechnologien

1. **Vorausschauende (AOT) Übersetzung**
   - Übersetzt x86_64-Binärdateien zur Installationszeit in ARM64
   - Speichert übersetzten Code in einem Cache für schnellere nachfolgende Starts
   - Reduziert Laufzeit-Overhead im Vergleich zu reiner JIT-Übersetzung

2. **Just-in-Time (JIT) Übersetzung**
   - Übersetzt Codeblöcke bedarfsgesteuert während der Ausführung
   - Behandelt dynamisch geladenen Code und selbstmodifizierenden Code
   - Verwaltet Übersetzungs-Cache für Effizienz

3. **Befehlssatzübersetzung**
   - x86_64 -> ARM64 Befehlszuordnung
   - SSE/AVX -> NEON Vektorbefehlsübersetzung
   - x86_64 Flags -> ARM64 Bedingungscodes

4. **Systemaufrufübersetzung**
   - Übersetzt x86_64 macOS-Systemaufrufe in ARM64-Äquivalente
   - Behandelt unterschiedliche Aufrufkonventionen
   - Verwaltet Registerzustand über Systemaufrufgrenzen hinweg

5. **Laufzeitunterstützung**
   - CPU-Funktionserkennungsemulation
   - Thread-lokale Speicherverwaltung
   - Signal- und Ausnahmebehandlung

---

## Wie Apple Rosetta 2 in macOS bereitstellt

### Installationsort

Rosetta 2 befindet sich unter:```
/Library/Apple/usr/libexec/oah/
├── rosetta        # Main translator binary
├── rosettad       # Rosetta daemon
└── librosetta.*   # Runtime libraries

Das Verzeichnis oah steht für "Old Architecture Hardware" – eine Fortführung aus der PowerPC-Übergangszeit.

Automatische Installation

Auf Apple Silicon Macs ist Rosetta 2 standardmäßig nicht installiert. Es wird auf zwei Arten ausgelöst:

1. Erste Startaufforderung ``` The "Rosetta" software is not installed on your Mac. Rosetta translates apps from Intel-based Macs for use on Apple Silicon Macs.
   root@kitploit:~

2. Kommandozeilen-Installation ```bash softwareupdate --install-rosetta --agree-to-license
   root@kitploit:~

Gelieferte Komponenten

Integration mit macOS

1. launchd-Integration: Rosetta-Daemon läuft als Systemdienst
2. Codesignierung: Übersetzte Binärdateien werden automatisch codesigniert
3. Gatekeeper: Rosetta-übersetzte Apps bestehen Sicherheitsprüfungen
4. Systemintegritätsschutz: Geschützt vor Modifikation

Technische Architektur

Übersetzungsprozess```

┌──────────────────────────────────────────────────────────────────┐ │ Phase 1: Binary Loading │ │ ─────────────────────────────────────────────────────────────── │ │ 1. Load x86_64 Mach-O binary │ │ 2. Parse segments, sections, symbols │ │ 3. Validate code signatures │ │ 4. Map into translation context │ └──────────────────────────────────────────────────────────────────┘ │ ▼ ┌──────────────────────────────────────────────────────────────────┐ │ Phase 2: AOT Translation │ │ ─────────────────────────────────────────────────────────────── │ │ 1. Disassemble x86_64 code sections │ │ 2. Translate instructions to ARM64 │ │ 3. Apply optimizations │ │ 4. Store in translation cache (~/.oah) │ └──────────────────────────────────────────────────────────────────┘ │ ▼ ┌──────────────────────────────────────────────────────────────────┐ │ Phase 3: Runtime Execution │ │ ─────────────────────────────────────────────────────────────── │ │ 1. Load translated ARM64 code │ │ 2. Set up x86_64 emulation context │ │ 3. Handle JIT translations for dynamic code │ │ 4. Translate syscalls on-the-fly │ └──────────────────────────────────────────────────────────────────┘

### Wichtige Übersetzungsherausforderungen

1. **Registerzuordnung**
   - x86_64 hat 16 GPRs; ARM64 hat 31 GPRs
   - x86_64 Flags-Register -> ARM64 NZCV-Flags
   - RIP (Instruction Pointer) Emulation

2. **Speicherordnung**
   - x86_64: Starke Speicherordnung (TSO)
   - ARM64: Schwache Speicherordnung
   - Erfordert Speicherbarrieren für Korrektheit

3. **Vektorbefehle**
   - SSE (128-Bit) -> NEON (128-Bit) direkte Zuordnung
   - AVX (256-Bit) -> NEON-Paar-Emulation
   - Unterschiedliche Ausnahmebehandlung für SIMD

4. **Aufrufkonventionen**
   - x86_64: Erste 6 Argumente in Registern (RDI, RSI, RDX, RCX, R8, R9)
   - ARM64: Erste 8 Argumente in Registern (X0-X7)
   - Unterschiedliche Stack-Frame-Layouts

---

## Dieses Projekt

Dieses Repository enthält reverse-engineerte Implementierungen von Funktionen aus den Rosetta 2-Binärdateien. Durch sorgfältige Analyse und Dekompilierung haben wir den semantischen Zweck von Hunderten von Funktionen identifiziert und dokumentiert.

### Ziele

1. **Bildungszweck**: Verstehen, wie Rosetta 2 intern funktioniert
2. **Dokumentation**: Umfassende Dokumentation der Übersetzungstechniken erstellen
3. **Implementierung**: Saubere, gut dokumentierte C-Implementierungen bereitstellen
4. **Community**: Wissen mit der Reverse-Engineering-Community teilen

### Was wir erreicht haben

- **828 Funktionen** in der Haupt-`rosetta`-Binärdatei identifiziert und benannt
- **612 Funktionen** vollständig mit sauberem C-Code implementiert
- **66 Kategorien** von Funktionalitäten dokumentiert
- Vollständige Funktionsnamenszuordnungen mit semantischen Namen

### Kategorien von Funktionen

| Kategorie | Funktionen | Beschreibung |
|-----------|------------|--------------|
| Einstiegspunkt | 1 | Rosetta-Initialisierung |
| FP/Vektor-Operationen | ~20 | Fließkomma- und SIMD-Zustandsverwaltung |
| SIMD-Speicheroperationen | ~10 | memchr, memcmp, memcpy mit SIMD |
| Vektoroperationen | ~30 | NEON-Vektorarithmetik, Vergleich |
| Binärübersetzung | ~50 | x86_64 -> ARM64 Befehlsübersetzung |
| Syscall-Handler | ~60 | Systemaufruf-Übersetzung und -Weiterleitung |
| Speicherverwaltung | ~20 | malloc, free, mmap-Wrapper |
| Hash-Funktionen | ~5 | Adress-Hashing für Übersetzungs-Cache |
| Zeichenkettenoperationen | ~30 | SIMD-optimierte String-Funktionen |
| Kryptografische Erweiterungen | ~30 | AES, SHA, CRC32-Durchleitung |
| ELF-Parsing | ~15 | Linux-Binärformatunterstützung |
| Übersetzungs-Cache | ~20 | AOT/JIT-Cache-Verwaltung |

---

## Dateistruktur

### Kern-Dateien```
Rosetta2/
├── README.md                      # This file
├── rosetta_decomp.c               # Original decompilation (74,677 lines)
├── rosettad_decomp.c              # Daemon decompilation (44,064 lines)
├── rosetta_refactored.c           # Minimal wrapper (59 lines) - includes modular headers
├── rosetta_refactored.c.legacy    # Legacy refactored code (19,302 lines) - archived
├── rosetta_refactored.h           # Main header (1,215 lines)
├── rosetta_refactored_complete.c  # Single-file implementation (2,686 lines)
├── rosetta_function_map.h         # Function name mapping (828 functions)
├── rosettad_refactored.c          # Daemon-side refactoring
└── SESSION_*.md                   # Session logs (30+ sessions)

Modulare Übersetzungsinfrastruktur (56 C files + 65 H files)

Die Übersetzungsinfrastruktur ist vollständig modularisiert in kategorisierte Komponenten:``` ├── rosetta_types.h # Base type definitions ├── rosetta_x86_decode.h/.c # x86 decoder ├── rosetta_arm64_emit.h/.c # ARM64 emitter ├── rosetta_translate_alu.h/.c # ALU translations ├── rosetta_translate_memory.h/.c # Memory translations ├── rosetta_translate_branch.h/.c # Branch translations ├── rosetta_translate_bit.h/.c # Bit manipulation ├── rosetta_translate_string.h/.c # String operations ├── rosetta_translate_special.h/.c # Special instructions ├── rosetta_translate_block.h/.c # Block translation coordinator ├── rosetta_translate_dispatch.h/.c # Instruction dispatch ├── rosetta_trans_dispatch.h/.c # Main dispatch layer ├── rosetta_trans_alu.h/.c # ALU emulation layer ├── rosetta_trans_mem.h/.c # Memory emulation layer ├── rosetta_trans_branch.h/.c # Branch emulation layer ├── rosetta_trans_bit.h/.c # Bit emulation layer ├── rosetta_trans_string.h/.c # String emulation layer ├── rosetta_trans_special.h/.c # Special instruction emulation ├── rosetta_trans_system.h/.c # System instruction emulation ├── rosetta_trans_neon.h/.c # NEON emulation layer └── Makefile.modular # Modular build system

### Funktionsmodule

Kerninfrastruktur- und Unterstützungsmodule:```
├── rosetta_jit.h/.c               # JIT compilation infrastructure
├── rosetta_exec.h/.c              # Execution engine (NEW)
├── rosetta_init.h/.c              # Initialization & FP registers (NEW)
├── rosetta_codegen.h/.c           # Code generation primitives
├── rosetta_cache.h/.c             # Translation cache (AOT/JIT)
├── rosetta_transcache.h/.c        # Translation cache management
├── rosetta_context.h/.c           # CPU context management
├── rosetta_runtime.h/.c           # Runtime support
├── rosetta_hash.h/.c              # Address hashing
├── rosetta_memmgmt.h/.c           # Memory management
├── rosetta_memory_utils.h/.c      # Memory utilities
├── rosetta_utils.h/.c             # Utility functions
├── rosetta_string_utils.h/.c      # String utilities
├── rosetta_trans_helpers.h/.c     # Translation helpers
├── rosetta_refactored_helpers.h/.c # Refactoring helpers
└── rosetta_refactored_types.h     # Refactored type definitions

SIMD/Vektor-Module```

├── rosetta_simd.h/.c # SIMD operations ├── rosetta_simd_mem.h/.c # SIMD memory operations ├── rosetta_simd_mem_helpers.h/.c # SIMD memory helpers ├── rosetta_vector.h/.c # Vector operations ├── rosetta_refactored_vector.h/.c # Refactored vector ops ├── rosetta_jit_emit.h/.c # JIT emission ├── rosetta_jit_emit_simd.h/.c # SIMD JIT emission ├── rosetta_fp_translate.h/.c # FP translation ├── rosetta_fp_helpers.h/.c # FP helpers ├── rosetta_trans_neon.c # NEON translation └── rosetta_string_simd.c # SIMD string operations

### Syscall-Module

Gast-Syscall-Behandlung und -Übersetzung:```
├── rosetta_syscalls.h/.c          # Syscall translation core
├── rosetta_syscalls_impl.h/.c     # Syscall implementations
└── rosetta_crypto.h/.c            # Crypto instructions (AES, SHA, CRC32)

Zusätzliche Module

Zusätzliche Übersetzungs- und Unterstützungsmodule:``` ├── rosetta_translate.h/.c # Translation core ├── rosetta_translate_alu_impl.h/.c # ALU implementation details ├── rosetta_translate_memory_impl.h/.c # Memory implementation details ├── rosetta_translate_branch_impl.h/.c # Branch implementation details ├── rosetta_translate_special_impl.h/.c # Special implementation details └── rosetta_arm64_insns.h # ARM64 instruction definitions

### Testdateien```
├── test_jit.c                     # JIT unit tests (737 lines)
└── test_translate.c               # Translation tests (1,059 lines)

Gesamt: 50+ Quelldateien, ~150,000+ Codezeilen

Buildsystem

Voraussetzungen

• GCC oder Clang mit C11-Unterstützung
• macOS oder Linux (POSIX-kompatibles System)

Erstellen der Bibliothek```bash

Build static library using modular Makefile

make -f Makefile.modular all

This creates librosetta.a static library

### Erstellen einzelner Komponenten```bash
# Compile core modules
gcc -c -I. -std=c11 rosetta_types.h
gcc -c -I. -std=c11 rosetta_codegen.c
gcc -c -I. -std=c11 rosetta_jit.c
gcc -c -I. -std=c11 rosetta_x86_decode.c
gcc -c -I. -std=c11 rosetta_arm64_emit.c

# Compile translation modules
gcc -c -I. -std=c11 rosetta_translate_alu.c
gcc -c -I. -std=c11 rosetta_translate_memory.c
gcc -c -I. -std=c11 rosetta_translate_branch.c
gcc -c -I. -std=c11 rosetta_translate_block.c
gcc -c -I. -std=c11 rosetta_translate_dispatch.c

# Compile support modules
gcc -c -I. -std=c11 rosetta_cache.c
gcc -c -I. -std=c11 rosetta_context.c
gcc -c -I. -std=c11 rosetta_syscalls.c
gcc -c -I. -std=c11 rosetta_runtime.c

Tests ausführen```bash

Build and run JIT tests

make -f Makefile.modular test_jit

Build and run translation tests

make -f Makefile.modular test_translate

### Verwendung als Bibliothek```bash
# Link against the static library
gcc -o my_app my_app.c -L. -lrosetta

# Or compile with source files directly
gcc -I. -o my_app my_app.c rosetta_*.c

Analyse der dekompilierten Quelldatei

Die ursprüngliche dekompilierte Datei rosetta_decomp.c enthält Zeichenfolgenliterale, die die Struktur des ursprünglichen Quellcodes offenlegen. Diese Dateinamen erscheinen in Assertions-/Fehlermeldungen im gesamten Binärprogramm.

Hinweis: Der umgestaltete Code verwendet eine andere, modularere Struktur als das Original.

Header-Dateien (.h)

• Register.h
• TaggedPointer.h
• RedBlackTree.h
• TransactionalList.h
• Translator.h
• AssemblerBuffer.h
• BuilderBase.h
• IrBuilder_x86.h

C++-Quelldateien (.cpp)

• Repatch.cpp
• Decoder.cpp
• Fixup.cpp
• AssemblerHelpers.cpp
• Operand.cpp
• Opcode.cpp
• BasicBlock.cpp
• ThreadContextFcntl.cpp
• InitStack.cpp
• Thread.cpp
• ThreadContext.cpp
• ThreadContextRuntimeSignals.cpp
• ThreadContextVm.cpp
• VMAllocationTracker.cpp

C++-Header-Dateien (.hpp)

• AssemblerBase.hpp
• TranslatorBase.hpp

Fortschritt

Aktueller Status

Modulare Architektur (vollständig)

Die Übersetzungsinfrastruktur ist vollständig in folgende Komponenten modularisiert:

Gesamt: 40+ modulare Komponenten

Übersetzungsabdeckung

Letzte Sitzungen

Referenzen

Offizielle Apple-Dokumentation

• Portieren Ihrer macOS-Apps auf Apple Silicon
• Behandeln von Architekturunterschieden

Technische Ressourcen

• ARM64 System V ABI
• Intel 64 and IA-32 Architectures SDM
• ARM Architecture Reference Manual

Verwandte Projekte

• FEX-Emu - Linux x86_64 auf ARM64 Emulator
• QEMU - Generischer Maschinenemulator
• Rosetta Linux - Community-Forschungsprojekt

Haftungsausschluss

Dieses Projekt dient ausschließlich Bildungs- und Forschungszwecken.

• Rosetta 2 ist proprietäre Apple-Software
• Dieses Projekt vertreibt keine Apple-Binärdateien
• Sämtlicher Code in diesem Repository wurde von Claude Code mit Qwen 3.5 geschrieben.
• Verwenden Sie dieses Projekt nicht, um Apples Sicherheitsmaßnahmen zu umgehen

Lizenz

MIT-Lizenz - Siehe LICENSE-Datei für Details.

Mitwirken

Beiträge sind willkommen! Interessensgebiete:

1. Implementieren verbleibender Funktionen
2. Verbessern der Dokumentation
3. Hinzufügen von Testfällen
4. Leistungsanalyse
5. Architekturdiagramme

Zuletzt aktualisiert: Februar 2026