Projet de Rétro-ingénierie Rosetta 2

Un effort complet de rétro-ingénierie pour comprendre et documenter la technologie de traduction binaire Rosetta 2 d'Apple.

Table des matières

1. Contexte
2. Qu'est-ce que Rosetta ?
3. Qu'est-ce que Rosetta 2 ?
4. Comment Apple livre Rosetta 2 dans macOS
5. Architecture technique
6. Ce projet
7. Structure des fichiers
8. Utilisation
9. Progression
10. Références

Contexte

La transition d'architecture

En novembre 2020, Apple a annoncé leurs premiers Mac Apple Silicon, marquant une transition historique des processeurs Intel x86_64 vers leurs propres puces M1 basées sur ARM. Il s'agissait de la troisième transition majeure d'architecture d'Apple :

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

Chaque transition a nécessité une solution de traduction binaire pour faire fonctionner les logiciels existants pendant la période de migration. Rosetta 2 est le système de traduction binaire le plus sophistiqué d'Apple à ce jour.

Qu'est-ce que Rosetta ?

Rosetta (2006-2011) était le premier logiciel de traduction binaire dynamique d'Apple, permettant aux applications PowerPC de fonctionner sur les Mac Intel.

Caractéristiques principales :

• Traduction dynamique : traduisait le code PowerPC en x86_64 à l'exécution
• Intégration OS : intégré dans Mac OS X 10.4 (Tiger) jusqu'à 10.6 (Snow Leopard)
• Opération transparente : les utilisateurs lançaient les applications PowerPC normalement
• Surcharge de performance : généralement 20 à 50 % plus lent que le code natif

Rosetta a été supprimée dans Mac OS X 10.7 (Lion), achevant la transition Intel.

Qu'est-ce que Rosetta 2 ?

Rosetta 2 est la technologie avancée de traduction binaire dynamique d'Apple qui permet aux applications compilées pour les Mac Intel x86_64 de fonctionner sur les Mac Apple Silicon (ARM64).

Aperçu de l'architecture```

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

### Technologies clés

1. **Traduction Ahead-of-Time (AOT)**
   - Traduit les binaires x86_64 en ARM64 lors de l'installation
   - Stocke le code traduit dans un cache pour des lancements ultérieurs plus rapides
   - Réduit la surcharge d'exécution par rapport à la traduction JIT pure

2. **Traduction Just-in-Time (JIT)**
   - Traduit les blocs de code à la demande pendant l'exécution
   - Gère le code chargé dynamiquement et le code auto-modifiant
   - Maintient un cache de traduction pour l'efficacité

3. **Traduction du jeu d'instructions**
   - Correspondance des instructions x86_64 -> ARM64
   - Traduction des instructions vectorielles SSE/AVX -> NEON
   - Drapeaux x86_64 -> codes de condition ARM64

4. **Traduction des appels système**
   - Traduit les appels système macOS x86_64 en équivalents ARM64
   - Gère les différentes conventions d'appel
   - Gère l'état des registres entre les appels système

5. **Prise en charge de l'exécution**
   - Émulation de la détection des fonctionnalités du processeur
   - Gestion du stockage local de thread
   - Gestion des signaux et des exceptions

---

## Comment Apple livre Rosetta 2 dans macOS

### Emplacement de l'installation

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

Le répertoire oah signifie "Old Architecture Hardware" - une continuité de l'époque de la transition PowerPC.

Installation automatique

Sur les Mac Apple Silicon, Rosetta 2 n'est pas installé par défaut. Il est déclenché de deux manières :

1. Invite de première ouverture ``` 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. Installation en ligne de commande ```bash softwareupdate --install-rosetta --agree-to-license
   root@kitploit:~

Composants livrés

Intégration avec macOS

1. Intégration launchd : le daemon Rosetta s'exécute comme service système
2. Signature de code : les binaires traduits sont automatiquement signés
3. Gatekeeper : les applications traduites par Rosetta passent les contrôles de sécurité
4. Protection de l'intégrité du système : protégé contre les modifications

Architecture technique

Processus de traduction```

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

### Défis Clés de la Traduction

1. **Correspondance des Registres**
   - x86_64 possède 16 GPR ; ARM64 en possède 31
   - Registre de flags x86_64 -> Flags NZCV ARM64
   - Émulation du RIP (pointeur d'instruction)

2. **Ordonnancement Mémoire**
   - x86_64 : Ordonnancement mémoire fort (TSO)
   - ARM64 : Ordonnancement mémoire faible
   - Nécessite des barrières mémoire pour la correction

3. **Instructions Vectorielles**
   - SSE (128 bits) -> Correspondance directe NEON (128 bits)
   - AVX (256 bits) -> Émulation par paires NEON
   - Gestion d'exceptions différente pour le SIMD

4. **Conventions d'Appel**
   - x86_64 : 6 premiers arguments dans des registres (RDI, RSI, RDX, RCX, R8, R9)
   - ARM64 : 8 premiers arguments dans des registres (X0-X7)
   - Dispositions de pile différentes

---

## Ce Projet

Ce dépôt contient des implémentations rétro-conçues de fonctions issues des binaires de Rosetta 2. Grâce à une analyse minutieuse et à la décompilation, nous avons identifié et documenté le but sémantique de centaines de fonctions.

### Objectifs

1. **Pédagogique** : Comprendre le fonctionnement interne de Rosetta 2
2. **Documentation** : Créer une documentation complète des techniques de traduction
3. **Implémentation** : Fournir des implémentations C propres et bien documentées
4. **Communauté** : Partager les connaissances avec la communauté de l'ingénierie inverse

### Ce Que Nous Avons Accompli

- **828 fonctions** identifiées et nommées dans le binaire principal `rosetta`
- **612 fonctions** entièrement implémentées avec un code C propre
- **66 catégories** de fonctionnalités documentées
- Correspondances complètes des noms de fonctions avec des noms sémantiques

### Catégories de Fonctions

| Catégorie | Fonctions | Description |
|-----------|-----------|-------------|
| Point d'entrée | 1 | Initialisation de Rosetta |
| Opérations FP/Vecteurs | ~20 | Gestion de l'état flottant et SIMD |
| Opérations Mémoire SIMD | ~10 | memchr, memcmp, memcpy avec SIMD |
| Opérations Vectorielles | ~30 | Arithmétique vectorielle NEON, comparaison |
| Traduction Binaire | ~50 | Traduction d'instructions x86_64 -> ARM64 |
| Gestionnaires d'Appels Système | ~60 | Traduction et transmission des appels système |
| Gestion Mémoire | ~20 | Wrappers pour malloc, free, mmap |
| Fonctions de Hachage | ~5 | Hachage d'adresse pour le cache de traduction |
| Opérations sur Chaînes | ~30 | Fonctions chaînes optimisées SIMD |
| Extensions Cryptographiques | ~30 | Passage direct AES, SHA, CRC32 |
| Analyse ELF | ~15 | Support du format binaire Linux |
| Cache de Traduction | ~20 | Gestion du cache AOT/JIT |

---

## Structure des Fichiers

### Fichiers Principaux```
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)

Infrastructure de traduction modulaire (56 fichiers C + 65 fichiers H)

L'infrastructure de traduction est entièrement modulaire et organisée en composants catégorisés :``` ├── 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

### Modules fonctionnels

Modules d'infrastructure de base et de support :```
├── 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/Vector Modules

Modules d'opérations SIMD et vectorielles :``` ├── 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 Modules

Gestion et traduction des syscalls invités :```
├── rosetta_syscalls.h/.c          # Syscall translation core
├── rosetta_syscalls_impl.h/.c     # Syscall implementations
└── rosetta_crypto.h/.c            # Crypto instructions (AES, SHA, CRC32)

Modules supplémentaires

Modules de traduction et de support supplémentaires :``` ├── 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

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

Total : 50+ fichiers sources, ~150 000+ lignes de code

Système de construction

Prérequis

• GCC ou Clang avec support C11
• macOS ou Linux (système compatible POSIX)

Construction de la bibliothèque```bash

Build static library using modular Makefile

make -f Makefile.modular all

This creates librosetta.a static library

### Construction de composants individuels```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

Exécution des tests```bash

Build and run JIT tests

make -f Makefile.modular test_jit

Build and run translation tests

make -f Makefile.modular test_translate

### Utilisation en tant que bibliothèque```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 du fichier source décompilé

Le fichier décompilé original rosetta_decomp.c contient des littéraux de chaîne qui révèlent la structure du code source original. Ces noms de fichiers apparaissent dans les messages d'assertion/erreur dans tout le binaire.

Remarque : Le code refactorisé utilise une structure différente, plus modulaire que l'original.

Fichiers d'en-tête (.h)

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

Fichiers source 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

Fichiers d'en-tête C++ (.hpp)

• AssemblerBase.hpp
• TranslatorBase.hpp

Progression

Statut actuel

Architecture modulaire (Terminée)

L'infrastructure de traduction est entièrement modularisée en les composants suivants :

Total: 40+ composants modulaires

Couverture de traduction

Sessions récentes

Références

Documentation officielle Apple

• Portage de vos applications macOS vers Apple Silicon
• Traitement des différences d'architecture

Ressources techniques

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

Projets connexes

• FEX-Emu - Émulateur Linux x86_64 sur ARM64
• QEMU - Émulateur générique de machines
• Rosetta Linux - Projet de recherche communautaire

Avertissement

Ce projet est à des fins éducatives et de recherche uniquement.

• Rosetta 2 est un logiciel propriétaire d'Apple
• Ce projet ne distribue pas les binaires d'Apple
• Tout le code de ce dépôt est écrit par Claude Code avec Qwen 3.5.
• N'utilisez pas ce projet pour contourner les mesures de sécurité d'Apple

Licence

Licence MIT - Voir le fichier LICENSE pour plus de détails.

Contribution

Les contributions sont les bienvenues ! Domaines d'intérêt :

1. Implémentation des fonctions restantes
2. Amélioration de la documentation
3. Ajout de cas de test
4. Analyse des performances
5. Diagrammes d'architecture

Dernière mise à jour : Février 2026