Progetto di Reverse Engineering di Rosetta 2

Un approfondito sforzo di reverse engineering per comprendere e documentare la tecnologia di traduzione binaria Rosetta 2 di Apple.

Indice dei Contenuti

1. Contesto
2. Cos'è Rosetta?
3. Cos'è Rosetta 2?
4. Come Apple Distribuisce Rosetta 2 in macOS
5. Architettura Tecnica
6. Questo Progetto
7. Struttura dei File
8. Utilizzo
9. Progressi
10. Riferimenti

Contesto

La Transizione dell'Architettura

A novembre 2020, Apple ha annunciato i primi Mac con Apple Silicon, segnando una transizione storica dai processori Intel x86_64 ai propri chip M1 basati su ARM. È stata la terza importante transizione di architettura di Apple:

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

Ogni transizione ha richiesto una soluzione di traduzione binaria per eseguire il software esistente durante il periodo di migrazione. Rosetta 2 è il sistema di traduzione binaria più sofisticato di Apple finora.

Cos'è Rosetta?

Rosetta (2006-2011) è stato il primo software di traduzione binaria dinamica di Apple, che consentiva alle applicazioni PowerPC di funzionare sui Mac basati su Intel.

Caratteristiche Principali:

• Traduzione Dinamica: Traduceva il codice PowerPC in x86_64 in fase di esecuzione
• Integrazione nel Sistema Operativo: Integrato in Mac OS X 10.4 (Tiger) fino a 10.6 (Snow Leopard)
• Operazione Trasparente: Gli utenti lanciavano le app PowerPC normalmente
• Overhead delle Prestazioni: Tipicamente dal 20% al 50% più lento del codice nativo

Rosetta è stato rimosso in Mac OS X 10.7 (Lion), completando la transizione Intel.

Cos'è Rosetta 2?

Rosetta 2 è la tecnologia avanzata di traduzione binaria dinamica di Apple che consente alle applicazioni compilate per Intel x86_64 Mac di funzionare su Mac con Apple Silicon (ARM64).

Panoramica dell'Architettura```

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

### Tecnologie Chiave

1. **Traduzione Ahead-of-Time (AOT)**
   - Traduce i binari x86_64 in ARM64 al momento dell'installazione
   - Memorizza il codice tradotto in una cache per avvii successivi più rapidi
   - Riduce il sovraccarico di runtime rispetto alla traduzione JIT pura

2. **Traduzione Just-in-Time (JIT)**
   - Traduce blocchi di codice su richiesta durante l'esecuzione
   - Gestisce codice caricato dinamicamente e codice auto-modificante
   - Mantiene una cache di traduzione per l'efficienza

3. **Traduzione del Set di Istruzioni**
   - Mapping delle istruzioni x86_64 -> ARM64
   - Traduzione delle istruzioni vettoriali SSE/AVX -> NEON
   - Flag x86_64 -> codici di condizione ARM64

4. **Traduzione delle Chiamate di Sistema**
   - Traduce le syscall di macOS x86_64 in equivalenti ARM64
   - Gestisce diverse convenzioni di chiamata
   - Gestisce lo stato dei registri attraverso i confini delle syscall

5. **Supporto Runtime**
   - Emulazione del rilevamento delle funzionalità della CPU
   - Gestione della memoria locale del thread
   - Gestione dei segnali e delle eccezioni

---

## Come Apple Distribuisce Rosetta 2 in macOS

### Posizione di Installazione

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

oah sta per "Old Architecture Hardware" - una continuazione dell'era di transizione PowerPC.

Installazione Automatica

Su Mac con Apple Silicon, Rosetta 2 non è installato per impostazione predefinita. Viene attivato in due modi:

1. Prompt del primo avvio ``` 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. Installazione da riga di comando ```bash softwareupdate --install-rosetta --agree-to-license
   root@kitploit:~

Componenti Forniti

Integrazione con macOS

1. Integrazione con launchd: Il demone Rosetta viene eseguito come servizio di sistema
2. Firma del codice: I binari tradotti vengono firmati automaticamente
3. Gatekeeper: Le app tradotte con Rosetta superano i controlli di sicurezza
4. System Integrity Protection: Protetto da modifiche

Architettura Tecnica

Processo di Traduzione```

┌──────────────────────────────────────────────────────────────────┐ │ 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 │ └──────────────────────────────────────────────────────────────────┘

### Sfide chiave della traduzione

1. **Mappatura dei registri**
   - x86_64 ha 16 GPR; ARM64 ha 31 GPR
   - Registro flag x86_64 -> flag NZCV di ARM64
   - Emulazione di RIP (instruction pointer)

2. **Ordinamento della memoria**
   - x86_64: Ordinamento forte della memoria (TSO)
   - ARM64: Ordinamento debole della memoria
   - Richiede barriere di memoria per la correttezza

3. **Istruzioni vettoriali**
   - SSE (128 bit) -> mappatura diretta NEON (128 bit)
   - AVX (256 bit) -> emulazione a coppie NEON
   - Gestione delle eccezioni diversa per SIMD

4. **Convenzioni di chiamata**
   - x86_64: Primi 6 argomenti in registri (RDI, RSI, RDX, RCX, R8, R9)
   - ARM64: Primi 8 argomenti in registri (X0-X7)
   - Diversi layout dello stack frame

---

## Questo Progetto

Questo repository contiene implementazioni reverse-engineered di funzioni dai binari di Rosetta 2. Attraverso un'attenta analisi e decompilazione, abbiamo identificato e documentato lo scopo semantico di centinaia di funzioni.

### Obiettivi

1. **Educativo**: Comprendere come funziona Rosetta 2 internamente
2. **Documentazione**: Creare documentazione completa delle tecniche di traduzione
3. **Implementazione**: Fornire implementazioni C pulite e ben documentate
4. **Community**: Condividere la conoscenza con la comunità del reverse engineering

### Cosa Abbiamo Realizzato

- **828 funzioni** identificate e nominate nel binario principale `rosetta`
- **612 funzioni** completamente implementate con codice C pulito
- **66 categorie** di funzionalità documentate
- Mappature complete dei nomi delle funzioni con nomi semantici

### Categorie di Funzioni

| Categoria | Funzioni | Descrizione |
|-----------|----------|-------------|
| Punto di ingresso | 1 | Inizializzazione di Rosetta |
| Operazioni FP/Vettoriali | ~20 | Gestione dello stato di virgola mobile e SIMD |
| Operazioni di memoria SIMD | ~10 | memchr, memcmp, memcpy con SIMD |
| Operazioni vettoriali | ~30 | Aritmetica vettoriale NEON, confronto |
| Traduzione binaria | ~50 | Traduzione di istruzioni da x86_64 a ARM64 |
| Gestori di syscall | ~60 | Traduzione e inoltro delle chiamate di sistema |
| Gestione memoria | ~20 | Wrapper per malloc, free, mmap |
| Funzioni hash | ~5 | Hashing degli indirizzi per la cache di traduzione |
| Operazioni su stringhe | ~30 | Funzioni stringa ottimizzate con SIMD |
| Estensioni crittografiche | ~30 | Pass-through di AES, SHA, CRC32 |
| Parsing ELF | ~15 | Supporto per formato binario Linux |
| Cache di traduzione | ~20 | Gestione cache AOT/JIT |

---

## Struttura dei file

### File principali```
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)

Infrastruttura di traduzione modulare (56 file C + 65 file H)

L'infrastruttura di traduzione è completamente modularizzata in componenti categorizzati:``` ├── 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

### Moduli funzionali

Moduli di infrastruttura e supporto principali:```
├── 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

Moduli SIMD/Vettoriali

Moduli di operazioni SIMD e vettoriali:``` ├── 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

### Moduli di syscall

Gestione e traduzione delle syscall guest:```
├── rosetta_syscalls.h/.c          # Syscall translation core
├── rosetta_syscalls_impl.h/.c     # Syscall implementations
└── rosetta_crypto.h/.c            # Crypto instructions (AES, SHA, CRC32)

Moduli aggiuntivi

Moduli aggiuntivi di traduzione e supporto:``` ├── 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

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

Totale: 50+ file sorgente, ~150.000+ righe di codice

Sistema di Build

Prerequisiti

• GCC o Clang con supporto C11
• macOS o Linux (sistema compatibile POSIX)

Compilazione della Libreria```bash

Build static library using modular Makefile

make -f Makefile.modular all

This creates librosetta.a static library

### Costruzione dei singoli componenti```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

Esecuzione dei test```bash

Build and run JIT tests

make -f Makefile.modular test_jit

Build and run translation tests

make -f Makefile.modular test_translate

### Utilizzo come libreria```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

Analisi del file sorgente decompilato

Il file decompilato originale rosetta_decomp.c contiene stringhe letterali che rivelano la struttura del codice sorgente originale. Questi nomi di file compaiono nei messaggi di asserzione/errore in tutto il binario.

Nota: Il codice rifattorizzato utilizza una struttura diversa, più modulare, rispetto all'originale.

File di intestazione (.h)

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

File sorgente C++ (.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

File di intestazione C++ (.hpp)

• AssemblerBase.hpp
• TranslatorBase.hpp

Avanzamento

Stato attuale

Architettura modulare (completa)

L'infrastruttura di traduzione è completamente modularizzata nei seguenti componenti:

Totale: 40+ componenti modulari

Copertura della traduzione

Sessioni recenti

Riferimenti

Documentazione ufficiale Apple

• Portare le tue app macOS su Apple Silicon
• Affrontare le differenze architetturali

Risorse tecniche

• ABI System V ARM64
• Manuale dello sviluppatore Intel® 64 e IA-32
• Manuale di architettura ARM

Progetti correlati

• FEX-Emu - Emulatore Linux x86_64 su ARM64
• QEMU - Emulatore generico di macchine
• Rosetta Linux - Progetto di ricerca community

Disclaimer

Questo progetto è solo a scopo educativo e di ricerca.

• Rosetta 2 è un software proprietario di Apple
• Questo progetto non distribuisce i binari di Apple
• Tutto il codice in questo repository è scritto da Claude Code con Qwen 3.5.
• Non utilizzare questo progetto per aggirare le misure di sicurezza di Apple

Licenza

Licenza MIT - Vedere il file LICENSE per i dettagli.

Contributi

I contributi sono benvenuti! Aree di interesse:

1. Implementazione delle funzioni rimanenti
2. Miglioramento della documentazione
3. Aggiunta di casi di test
4. Analisi delle prestazioni
5. Diagrammi architetturali

Ultimo aggiornamento: febbraio 2026