Proyecto de Ingeniería Inversa de Rosetta 2

Un esfuerzo exhaustivo de ingeniería inversa para comprender y documentar la tecnología de traducción binaria Rosetta 2 de Apple.

Tabla de Contenidos

1. Antecedentes
2. ¿Qué es Rosetta?
3. ¿Qué es Rosetta 2?
4. Cómo Apple distribuye Rosetta 2 en macOS
5. Arquitectura técnica
6. Este proyecto
7. Estructura de archivos
8. Uso
9. Progreso
10. Referencias

Antecedentes

La transición de arquitectura

En noviembre de 2020, Apple anunció sus primeras Mac con Apple Silicon, marcando una transición histórica de los procesadores Intel x86_64 a sus propios chips M1 basados en ARM. Esta fue la tercera gran transición de arquitectura de Apple:

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

Cada transición requirió una solución de traducción binaria para ejecutar el software existente durante el período de migración. Rosetta 2 es el sistema de traducción binaria más sofisticado de Apple hasta ahora.

¿Qué es Rosetta?

Rosetta (2006-2011) fue el primer software de traducción binaria dinámica de Apple, que permitía ejecutar aplicaciones PowerPC en Mac basadas en Intel.

Características principales:

• Traducción dinámica: Traducía código PowerPC a x86_64 en tiempo de ejecución
• Integración en el sistema operativo: Integrado en Mac OS X 10.4 (Tiger) hasta 10.6 (Snow Leopard)
• Operación transparente: Los usuarios lanzaban aplicaciones PowerPC normalmente
• Sobrecarga de rendimiento: Típicamente 20-50% más lento que el código nativo

Rosetta se eliminó en Mac OS X 10.7 (Lion), completando la transición a Intel.

¿Qué es Rosetta 2?

Rosetta 2 es la tecnología avanzada de traducción binaria dinámica de Apple que permite que las aplicaciones compiladas para Macs Intel x86_64 se ejecuten en Macs con Apple Silicon (ARM64).

Resumen de la arquitectura```

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

### Tecnologías Clave

1. **Traducción Anticipada (AOT)**
   - Traduce binarios x86_64 a ARM64 durante la instalación
   - Almacena el código traducido en una caché para lanzamientos posteriores más rápidos
   - Reduce la sobrecarga en tiempo de ejecución en comparación con la traducción JIT pura

2. **Traducción Justo a Tiempo (JIT)**
   - Traduce bloques de código bajo demanda durante la ejecución
   - Maneja código cargado dinámicamente y código automodificable
   - Mantiene una caché de traducción para mayor eficiencia

3. **Traducción del Conjunto de Instrucciones**
   - Mapeo de instrucciones de x86_64 a ARM64
   - Traducción de instrucciones vectoriales SSE/AVX a NEON
   - Banderas de x86_64 a códigos de condición de ARM64

4. **Traducción de Llamadas al Sistema**
   - Traduce las syscalls de macOS x86_64 a sus equivalentes ARM64
   - Maneja diferentes convenciones de llamada
   - Gestiona el estado de los registros a través de los límites de las syscalls

5. **Soporte en Tiempo de Ejecución**
   - Emulación de detección de características de la CPU
   - Manejo de almacenamiento local de hilos
   - Manejo de señales y excepciones

---

## Cómo Apple entrega Rosetta 2 en macOS

### Ubicación de Instalación

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

El directorio oah significa "Old Architecture Hardware" - una continuación de la era de transición de PowerPC.

Instalación Automática

En las Mac con Apple Silicon, Rosetta 2 no está instalado de forma predeterminada. Se activa de dos maneras:

1. Aviso de Primer Inicio ``` 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. Instalación por línea de comandos ```bash softwareupdate --install-rosetta --agree-to-license
   root@kitploit:~

Componentes Entregados

Integración con macOS

1. Integración con launchd: El demonio de Rosetta se ejecuta como un servicio del sistema
2. Firma de código: Los binarios traducidos se firman automáticamente
3. Gatekeeper: Las aplicaciones traducidas por Rosetta pasan las comprobaciones de seguridad
4. Protección de integridad del sistema: Protegido contra modificaciones

Arquitectura Técnica

Proceso de Traducción```

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

### Desafíos Clave de Traducción

1. **Mapeo de Registros**
   - x86_64 tiene 16 GPRs; ARM64 tiene 31 GPRs
   - Registro de banderas de x86_64 -> Banderas NZCV de ARM64
   - Emulación de RIP (puntero de instrucción)

2. **Ordenamiento de Memoria**
   - x86_64: Ordenamiento de memoria fuerte (TSO)
   - ARM64: Ordenamiento de memoria débil
   - Requiere barreras de memoria para la corrección

3. **Instrucciones Vectoriales**
   - SSE (128 bits) -> Mapeo directo a NEON (128 bits)
   - AVX (256 bits) -> Emulación con pares NEON
   - Manejo de excepciones diferente para SIMD

4. **Convenciones de Llamada**
   - x86_64: Primeros 6 argumentos en registros (RDI, RSI, RDX, RCX, R8, R9)
   - ARM64: Primeros 8 argumentos en registros (X0-X7)
   - Diferentes diseños de marco de pila

---

## Este Proyecto

Este repositorio contiene implementaciones de ingeniería inversa de funciones de los binarios de Rosetta 2. Mediante un cuidadoso análisis y descompilación, hemos identificado y documentado el propósito semántico de cientos de funciones.

### Objetivos

1. **Educativo**: Entender cómo funciona Rosetta 2 internamente
2. **Documentación**: Crear documentación exhaustiva de las técnicas de traducción
3. **Implementación**: Proporcionar implementaciones en C limpias y bien documentadas
4. **Comunidad**: Compartir conocimiento con la comunidad de ingeniería inversa

### Lo Que Hemos Logrado

- **828 funciones** identificadas y nombradas en el binario principal `rosetta`
- **612 funciones** completamente implementadas con código C limpio
- **66 categorías** de funcionalidad documentadas
- Mapeos completos de nombres de funciones con nombres semánticos

### Categorías de Funciones

| Categoría | Funciones | Descripción |
|-----------|-----------|-------------|
| Punto de Entrada | 1 | Inicialización de Rosetta |
| Operaciones de FP/Vectoriales | ~20 | Gestión de estado de coma flotante y SIMD |
| Operaciones de Memoria SIMD | ~10 | memchr, memcmp, memcpy con SIMD |
| Operaciones Vectoriales | ~30 | Aritmética vectorial NEON, comparación |
| Traducción Binaria | ~50 | Traducción de instrucciones x86_64 -> ARM64 |
| Manejadores de Syscall | ~60 | Traducción y reenvío de llamadas al sistema |
| Gestión de Memoria | ~20 | Envoltorios de malloc, free, mmap |
| Funciones Hash | ~5 | Hashing de direcciones para caché de traducción |
| Operaciones de Cadenas | ~30 | Funciones de cadenas optimizadas con SIMD |
| Extensiones Criptográficas | ~30 | PASSTHROUGH de AES, SHA, CRC32 |
| Análisis de ELF | ~15 | Soporte de formato binario Linux |
| Caché de Traducción | ~20 | Gestión de caché AOT/JIT |

---

## Estructura de Archivos

### Archivos Principales```
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)

Infraestructura de Traducción Modular (56 C files + 65 H files)

La infraestructura de traducción está completamente modularizada en componentes categorizados:``` ├── 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

### Módulos funcionales

Módulos de infraestructura principal y soporte:```
├── 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

Módulos SIMD/Vectoriales

Módulos de operaciones SIMD y vectoriales:``` ├── 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

### Módulos de Syscall

Manejo y traducción de syscall del invitado:```
├── rosetta_syscalls.h/.c          # Syscall translation core
├── rosetta_syscalls_impl.h/.c     # Syscall implementations
└── rosetta_crypto.h/.c            # Crypto instructions (AES, SHA, CRC32)

Módulos adicionales

Módulos adicionales de traducción y soporte:``` ├── 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

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

Total: 50+ archivos fuente, ~150,000+ líneas de código

Sistema de compilación

Requisitos previos

• GCC o Clang con soporte para C11
• macOS o Linux (sistema compatible con POSIX)

Compilando la biblioteca```bash

Build static library using modular Makefile

make -f Makefile.modular all

This creates librosetta.a static library

### Construyendo Componentes Individuales```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

Ejecutando Pruebas```bash

Build and run JIT tests

make -f Makefile.modular test_jit

Build and run translation tests

make -f Makefile.modular test_translate

### Uso como biblioteca```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

Análisis del Archivo Fuente Descompilado

El archivo descompilado original rosetta_decomp.c contiene literales de cadena que revelan la estructura del código fuente original. Estos nombres de archivo aparecen en mensajes de aserción/error a lo largo del binario.

Nota: El código refactorizado utiliza una estructura diferente, más modular que la original.

Archivos de Encabezado (.h)

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

Archivos Fuente de 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

Archivos de Encabezado de C++ (.hpp)

• AssemblerBase.hpp
• TranslatorBase.hpp

Progreso

Estado Actual

Arquitectura Modular (Completa)

La infraestructura de traducción está completamente modularizada en los siguientes componentes:

Total: más de 40 componentes modulares

Cobertura de Traducción

Sesiones Recientes

Referencias

Documentación Oficial de Apple

• Portando tus apps de macOS a Apple Silicon
• Abordando las Diferencias de Arquitectura

Recursos Técnicos

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

Proyectos Relacionados

• FEX-Emu - Emulador de Linux x86_64 en ARM64
• QEMU - Emulador de máquina genérico
• Rosetta Linux - Proyecto de investigación comunitario

Descargo de Responsabilidad

Este proyecto es solo para fines educativos y de investigación.

• Rosetta 2 es software propietario de Apple
• Este proyecto no distribuye los binarios de Apple
• Todo el código en este repositorio fue escrito por Claude Code con Qwen 3.5.
• No utilices este proyecto para eludir las medidas de seguridad de Apple

Licencia

Licencia MIT - Consulta el archivo LICENSE para más detalles.

Contribuciones

¡Las contribuciones son bienvenidas! Áreas de interés:

1. Implementar las funciones restantes
2. Mejorar la documentación
3. Añadir casos de prueba
4. Análisis de rendimiento
5. Diagramas de arquitectura

Última actualización: febrero de 2026