Projeto de Engenharia Reversa do Rosetta 2

Um esforço abrangente de engenharia reversa para entender e documentar a tecnologia de tradução binária Rosetta 2 da Apple.

Índice

1. Contexto
2. O que é Rosetta?
3. O que é Rosetta 2?
4. Como a Apple Distribui o Rosetta 2 no macOS
5. Arquitetura Técnica
6. Este Projeto
7. Estrutura de Arquivos
8. Uso
9. Progresso
10. Referências

Contexto

A Transição de Arquitetura

Em novembro de 2020, a Apple anunciou seus primeiros Macs com Apple Silicon, marcando uma transição histórica dos processadores Intel x86_64 para seus próprios chips M1 baseados em ARM. Esta foi a terceira grande transição de arquitetura da Apple:

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

Cada transição exigiu uma solução de tradução binária para executar o software existente durante o período de migração. O Rosetta 2 é o sistema de tradução binária mais sofisticado da Apple até agora.

O que é Rosetta?

Rosetta (2006-2011) foi o primeiro software de tradução binária dinâmica da Apple, permitindo que aplicativos PowerPC rodassem em Macs baseados em Intel.

Principais Características:

• Tradução Dinâmica: Traduzia código PowerPC para x86_64 em tempo de execução
• Integração com o SO: Incorporado no Mac OS X 10.4 (Tiger) até o 10.6 (Snow Leopard)
• Operação Transparente: Usuários abriam aplicativos PowerPC normalmente
• Overhead de Desempenho: Tipicamente 20-50% mais lento que o código nativo

O Rosetta foi removido no Mac OS X 10.7 (Lion), completando a transição para Intel.

O que é Rosetta 2?

Rosetta 2 é a tecnologia avançada de tradução binária dinâmica da Apple que permite que aplicativos compilados para Intel x86_64 em Macs rodem em Macs Apple Silicon (ARM64).

Visão Geral da Arquitetura```

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

### Tecnologias Chave

1. **Tradução Antecipada (AOT)**
   - Traduz binários x86_64 para ARM64 no momento da instalação
   - Armazena código traduzido em um cache para inicializações subsequentes mais rápidas
   - Reduz a sobrecarga em tempo de execução em comparação com a tradução JIT pura

2. **Tradução Just-in-Time (JIT)**
   - Traduz blocos de código sob demanda durante a execução
   - Lida com código carregado dinamicamente e código automodificável
   - Mantém cache de tradução para eficiência

3. **Tradução de Conjunto de Instruções**
   - Mapeamento de instruções x86_64 -> ARM64
   - Tradução de instruções vetoriais SSE/AVX -> NEON
   - Flags x86_64 -> Códigos de condição ARM64

4. **Tradução de Chamadas de Sistema**
   - Traduz chamadas de sistema x86_64 do macOS para equivalentes ARM64
   - Lida com diferentes convenções de chamada
   - Gerencia o estado dos registradores entre limites de chamadas de sistema

5. **Suporte em Tempo de Execução**
   - Emulação de detecção de recursos da CPU
   - Manipulação de armazenamento local de thread
   - Manipulação de sinais e exceções

---

## Como a Apple entrega o Rosetta 2 no macOS

### Local de Instalação

Rosetta 2 está localizado em:```
/Library/Apple/usr/libexec/oah/
├── rosetta        # Main translator binary
├── rosettad       # Rosetta daemon
└── librosetta.*   # Runtime libraries

O diretório oah significa "Hardware de Arquitetura Antiga" - uma continuação da era de transição PowerPC.

Instalação Automática

Em Macs com Apple Silicon, o Rosetta 2 não é instalado por padrão. Ele é ativado de duas maneiras:

1. Primeira Solicitação de Inicialização ``` 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. Instalação via Linha de Comando ```bash softwareupdate --install-rosetta --agree-to-license
   root@kitploit:~

Componentes Entregues

Integração com macOS

1. Integração com launchd: O daemon Rosetta executa como um serviço do sistema
2. Assinatura de Código: Binários traduzidos são assinados automaticamente
3. Gatekeeper: Aplicativos traduzidos pelo Rosetta passam em verificações de segurança
4. Proteção de Integridade do Sistema: Protegido contra modificações

Arquitetura Técnica

Processo de Tradução```

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

### Desafios Principais de Tradução

1. **Mapeamento de Registradores**
   - x86_64 possui 16 GPRs; ARM64 possui 31 GPRs
   - Registrador de flags do x86_64 -> Flags NZCV do ARM64
   - Emulação de RIP (ponteiro de instrução)

2. **Ordenação de Memória**
   - x86_64: Ordenação forte de memória (TSO)
   - ARM64: Ordenação fraca de memória
   - Requer barreiras de memória para correção

3. **Instruções Vetoriais**
   - SSE (128 bits) -> Mapeamento direto para NEON (128 bits)
   - AVX (256 bits) -> Emulação de par NEON
   - Tratamento de exceções diferente para SIMD

4. **Convenções de Chamada**
   - x86_64: Primeiros 6 argumentos em registradores (RDI, RSI, RDX, RCX, R8, R9)
   - ARM64: Primeiros 8 argumentos em registradores (X0-X7)
   - Diferentes layouts de quadro de pilha

---

## Este Projeto

Este repositório contém implementações com engenharia reversa de funções dos binários do Rosetta 2. Através de análise cuidadosa e descompilação, identificamos e documentamos o propósito semântico de centenas de funções.

### Objetivos

1. **Educacional**: Entender como o Rosetta 2 funciona internamente
2. **Documentação**: Criar documentação abrangente das técnicas de tradução
3. **Implementação**: Fornecer implementações C limpas e bem documentadas
4. **Comunidade**: Compartilhar conhecimento com a comunidade de engenharia reversa

### O Que Conquistamos

- **828 funções** identificadas e nomeadas no binário principal `rosetta`
- **612 funções** totalmente implementadas com código C limpo
- **66 categorias** de funcionalidade documentadas
- Mapeamentos completos de nomes de funções com nomes semânticos

### Categorias de Funções

| Categoria | Funções | Descrição |
|-----------|---------|-----------|
| Ponto de Entrada | 1 | Inicialização do Rosetta |
| Operações de Ponto Flutuante/Vetoriais | ~20 | Gerenciamento de estado de ponto flutuante e SIMD |
| Operações de Memória SIMD | ~10 | memchr, memcmp, memcpy com SIMD |
| Operações Vetoriais | ~30 | Aritmética vetorial NEON, comparação |
| Tradução Binária | ~50 | Tradução de instruções x86_64 -> ARM64 |
| Manipuladores de Syscall | ~60 | Tradução e encaminhamento de chamadas de sistema |
| Gerenciamento de Memória | ~20 | Wrappers de malloc, free, mmap |
| Funções Hash | ~5 | Hash de endereços para cache de tradução |
| Operações de Strings | ~30 | Funções de string otimizadas com SIMD |
| Extensões Criptográficas | ~30 | Passthrough de AES, SHA, CRC32 |
| Análise de ELF | ~15 | Suporte a formato binário Linux |
| Cache de Tradução | ~20 | Gerenciamento de cache AOT/JIT |

---

## Estrutura de Arquivos

### Arquivos Principais```
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)

Infraestrutura de Tradução Modular (56 arquivos C + 65 arquivos H)

A infraestrutura de tradução é totalmente modularizada em 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 Funcionais

Módulos de infraestrutura e suporte principais:```
├── 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/Vetoriais

Módulos de operações SIMD e vetoriais:``` ├── 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

Guest syscall handling and translation:```
├── 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 Adicionais

Módulos adicionais de tradução e suporte:``` ├── 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

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

Total: 50+ arquivos fonte, ~150.000+ linhas de código

Sistema de Compilação

Pré-requisitos

• GCC ou Clang com suporte a C11
• macOS ou Linux (sistema compatível com POSIX)

Compilando a Biblioteca```bash

Build static library using modular Makefile

make -f Makefile.modular all

This creates librosetta.a static library

### Construindo Componentes Individuais```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

Executando Testes```bash

Build and run JIT tests

make -f Makefile.modular test_jit

Build and run translation tests

make -f Makefile.modular test_translate

### Usando 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álise do Ficheiro de Código Fonte Decompilado

O ficheiro decompilado original rosetta_decomp.c contém literais de string que revelam a estrutura do código fonte original. Estes nomes de ficheiro aparecem em mensagens de asserção/erro ao longo do binário.

Nota: O código refatorado utiliza uma estrutura diferente, mais modular, do que o original.

Ficheiros de Cabeçalho (.h)

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

Ficheiros de Código Fonte 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

Ficheiros de Cabeçalho C++ (.hpp)

• AssemblerBase.hpp
• TranslatorBase.hpp

Progresso

Estado Atual

Arquitetura Modular (Completa)

A infraestrutura de tradução está totalmente modularizada nos seguintes componentes:

Total: 40+ componentes modulares

Cobertura de Tradução

Sessões Recentes

Referências

Documentação Oficial da Apple

• Porting Your macOS Apps to Apple Silicon
• Addressing Architecture Differences

Recursos Técnicos

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

Projetos Relacionados

• FEX-Emu - Emulador Linux x86_64 em ARM64
• QEMU - Emulador de máquina genérico
• Rosetta Linux - Projeto de investigação comunitário

Aviso Legal

Este projeto destina-se apenas a fins educacionais e de investigação.

• Rosetta 2 é software proprietário da Apple
• Este projeto não distribui binários da Apple
• Todo o código neste repositório foi escrito por Claude Code com Qwen 3.5.
• Não utilize este projeto para contornar as medidas de segurança da Apple

Licença

Licença MIT - Consulte o ficheiro LICENSE para mais detalhes.

Contribuir

Contribuições são bem-vindas! Áreas de interesse:

1. Implementar as funções restantes
2. Melhorar a documentação
3. Adicionar casos de teste
4. Análise de desempenho
5. Diagramas de arquitetura

Última atualização: fevereiro de 2026