Rosetta 2 Reverse Engineering Project

Apple의 Rosetta 2 바이너리 변환 기술을 이해하고 문서화하기 위한 포괄적인 리버스 엔지니어링 프로젝트입니다.

목차

1. 배경
2. Rosetta란?
3. Rosetta 2란?
4. Apple이 macOS에서 Rosetta 2를 제공하는 방식
5. 기술 아키텍처
6. 이 프로젝트
7. 파일 구조
8. 사용 방법
9. 진행 상황
10. 참고 자료

배경

아키텍처 전환

2020년 11월, Apple은 첫 Apple Silicon Mac을 발표하며 Intel x86_64 프로세서에서 자체 ARM 기반 M1 칩으로의 역사적인 전환을 알렸습니다. 이는 Apple의 세 번째 주요 아키텍처 전환이었습니다:

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

각 전환 과정에서는 마이그레이션 기간 동안 기존 소프트웨어를 실행할 수 있는 바이너리 변환 솔루션이 필요했습니다. Rosetta 2는 현재까지 Apple의 가장 정교한 바이너리 변환 시스템입니다.

Rosetta란?

Rosetta(2006~2011)는 Apple의 첫 동적 바이너리 변환 소프트웨어로, PowerPC 애플리케이션이 Intel 기반 Mac에서 실행될 수 있도록 해주었습니다.

주요 기능:

• 동적 변환: PowerPC 코드를 런타임에 x86_64로 변환
• OS 통합: Mac OS X 10.4(Tiger)부터 10.6(Snow Leopard)까지 내장
• 투명한 작동: 사용자가 PowerPC 앱을 일반적으로 실행
• 성능 오버헤드: 일반적으로 네이티브 코드보다 20~50% 느림

Rosetta는 Mac OS X 10.7(Lion)에서 제거되어 Intel 전환이 완료되었습니다.

Rosetta 2란?

Rosetta 2는 Intel x86_64 Mac용으로 컴파일된 애플리케이션이 Apple Silicon(ARM64) Mac에서 실행될 수 있도록 해주는 Apple의 고급 동적 바이너리 변환 기술입니다.

아키텍처 개요```

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

### 주요 기술

1. **Ahead-of-Time (AOT) 변환**
   - 설치 시 x86_64 바이너리를 ARM64로 변환합니다
   - 번역된 코드를 캐시에 저장하여 이후 실행 속도를 높입니다
   - 순수 JIT 변환에 비해 런타임 오버헤드를 줄입니다

2. **Just-in-Time (JIT) 변환**
   - 실행 중 필요에 따라 코드 블록을 변환합니다
   - 동적 로드 코드와 자가 수정 코드를 처리합니다
   - 효율성을 위해 변환 캐시를 유지합니다

3. **명령어 집합 변환**
   - x86_64 → ARM64 명령어 매핑
   - SSE/AVX → NEON 벡터 명령어 변환
   - x86_64 플래그 → ARM64 조건 코드

4. **시스템 호출 변환**
   - x86_64 macOS 시스템 호출을 ARM64 해당 호출로 변환합니다
   - 서로 다른 호출 규칙을 처리합니다
   - 시스템 호출 경계를 넘어 레지스터 상태를 관리합니다

5. **런타임 지원**
   - CPU 기능 감지 에뮬레이션
   - 스레드 지역 저장소 처리
   - 시그널 및 예외 처리

---

## Apple이 macOS에서 Rosetta 2를 제공하는 방법

### 설치 위치

Rosetta 2는 다음 위치에 있습니다:```
/Library/Apple/usr/libexec/oah/
├── rosetta        # Main translator binary
├── rosettad       # Rosetta daemon
└── librosetta.*   # Runtime libraries

oah 디렉토리는 "Old Architecture Hardware"(구형 아키텍처 하드웨어)를 의미하며, PowerPC 전환 시대에서 이어진 용어입니다.

자동 설치

Apple Silicon Mac에서 Rosetta 2는 기본적으로 설치되지 않습니다. 다음 두 가지 방식으로 설치가 시작됩니다:

1. 최초 실행 프롬프트 ``` 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. 명령줄 설치 ```bash softwareupdate --install-rosetta --agree-to-license
   root@kitploit:~

제공되는 구성 요소

macOS와의 통합

1. launchd 통합: Rosetta 데몬이 시스템 서비스로 실행됩니다
2. 코드 서명: 번역된 바이너리가 자동으로 코드 서명됩니다
3. Gatekeeper: Rosetta로 번역된 앱이 보안 검사를 통과합니다
4. System Integrity Protection: 수정으로부터 보호됩니다

기술 아키텍처

번역 프로세스```

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

### 주요 변환 과제

1. **레지스터 매핑**
   - x86_64는 16개의 GPR을 가지고, ARM64는 31개의 GPR을 가짐
   - x86_64 플래그 레지스터 -> ARM64 NZCV 플래그
   - RIP (명령어 포인터) 에뮬레이션

2. **메모리 순서**
   - x86_64: 강한 메모리 순서 (TSO)
   - ARM64: 약한 메모리 순서
   - 정확성을 위해 메모리 배리어 필요

3. **벡터 명령어**
   - SSE (128비트) -> NEON (128비트) 직접 매핑
   - AVX (256비트) -> NEON 쌍 에뮬레이션
   - SIMD에 대한 예외 처리 방식이 다름

4. **호출 규약**
   - x86_64: 처음 6개 인자를 레지스터로 전달 (RDI, RSI, RDX, RCX, R8, R9)
   - ARM64: 처음 8개 인자를 레지스터로 전달 (X0-X7)
   - 스택 프레임 배치 방식이 다름

---

## 이 프로젝트

이 저장소는 Rosetta 2 바이너리에서 추출한 함수들의 역공학 구현체를 포함합니다. 세심한 분석과 디컴파일을 통해 수백 개의 함수에 대한 의미론적 목적을 식별하고 문서화했습니다.

### 목표

1. **교육**: Rosetta 2가 내부적으로 어떻게 작동하는지 이해
2. **문서화**: 변환 기술에 대한 포괄적인 문서 작성
3. **구현**: 깔끔하고 잘 문서화된 C 구현체 제공
4. **커뮤니티**: 역공학 커뮤니티와 지식 공유

### 우리가 이룬 성과

- **828개 함수** 식별 및 주요 `rosetta` 바이너리에서 이름 부여
- **612개 함수** 깔끔한 C 코드로 완전히 구현
- **66개 범주**의 기능 문서화
- 의미론적 이름이 포함된 완전한 함수 이름 매핑

### 함수 범주

| 범주 | 함수 수 | 설명 |
|----------|-----------|-------------|
| 진입점 | 1 | Rosetta 초기화 |
| 부동소수점/벡터 연산 | ~20 | 부동소수점 및 SIMD 상태 관리 |
| SIMD 메모리 연산 | ~10 | SIMD를 사용한 memchr, memcmp, memcpy |
| 벡터 연산 | ~30 | NEON 벡터 산술, 비교 |
| 이진 변환 | ~50 | x86_64 -> ARM64 명령어 변환 |
| 시스템 콜 핸들러 | ~60 | 시스템 콜 변환 및 전달 |
| 메모리 관리 | ~20 | malloc, free, mmap 래퍼 |
| 해시 함수 | ~5 | 변환 캐시를 위한 주소 해싱 |
| 문자열 연산 | ~30 | SIMD 최적화 문자열 함수 |
| 암호화 확장 | ~30 | AES, SHA, CRC32 통과 |
| ELF 파싱 | ~15 | 리눅스 바이너리 형식 지원 |
| 변환 캐시 | ~20 | AOT/JIT 캐시 관리 |

---

## 파일 구조

### 핵심 파일```
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)

모듈식 변환 인프라 (56 C files + 65 H files)

변환 인프라는 분류된 구성 요소들로 완전히 모듈화되어 있습니다:``` ├── 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

### 기능 모듈

핵심 인프라 및 지원 모듈:```
├── 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

SIMD 및 벡터 연산 모듈:``` ├── 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

게스트 Syscall 처리 및 변환:```
├── rosetta_syscalls.h/.c          # Syscall translation core
├── rosetta_syscalls_impl.h/.c     # Syscall implementations
└── rosetta_crypto.h/.c            # Crypto instructions (AES, SHA, CRC32)

추가 모듈

추가 번역 및 지원 모듈:``` ├── 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

### 테스트 파일```
├── test_jit.c                     # JIT unit tests (737 lines)
└── test_translate.c               # Translation tests (1,059 lines)

총계: 50개 이상의 소스 파일, 약 150,000줄 이상의 코드

빌드 시스템

필수 조건

• C11을 지원하는 GCC 또는 Clang
• macOS 또는 Linux (POSIX 호환 시스템)

라이브러리 빌드```bash

Build static library using modular Makefile

make -f Makefile.modular all

This creates librosetta.a static library

### 개별 컴포넌트 빌드```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

테스트 실행```bash

Build and run JIT tests

make -f Makefile.modular test_jit

Build and run translation tests

make -f Makefile.modular test_translate

### 라이브러리로 사용하기```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

디컴파일된 소스 파일 분석

원래 디컴파일된 파일 rosetta_decomp.c에는 원본 소스 코드 구조를 드러내는 문자열 리터럴이 포함되어 있습니다. 이러한 파일 이름은 바이너리 전체의 단언/오류 메시지에 나타납니다.

참고: 리팩터링된 코드는 원본과 다른, 더 모듈화된 구조를 사용합니다.

헤더 파일 (.h)

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

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

C++ 헤더 파일 (.hpp)

• AssemblerBase.hpp
• TranslatorBase.hpp

진행 상황

현재 상태

모듈형 아키텍처 (완료)

번역 인프라는 다음 구성 요소로 완전히 모듈화되었습니다.

총: 40개 이상의 모듈화 구성 요소

변환 범위

최근 세션

참고 자료

공식 Apple 문서

• macOS 앱을 Apple Silicon으로 포팅
• 아키텍처 차이점 해결

기술 자료

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

관련 프로젝트

• FEX-Emu - Linux x86_64 on ARM64 에뮬레이터
• QEMU - 범용 머신 에뮬레이터
• Rosetta Linux - 커뮤니티 연구 프로젝트

면책 조항

이 프로젝트는 교육 및 연구 목적으로만 제공됩니다.

• Rosetta 2는 Apple의 독점 소프트웨어입니다.
• 이 프로젝트는 Apple의 바이너리를 배포하지 않습니다.
• 이 저장소의 모든 코드는 Claude Code와 Qwen 3.5로 작성되었습니다.
• Apple의 보안 조치를 우회하기 위해 이 프로젝트를 사용하지 마십시오.

라이선스

MIT 라이선스 - 자세한 내용은 LICENSE 파일을 참조하십시오.

기여하기

기여를 환영합니다! 관심 분야:

1. 나머지 함수 구현
2. 문서 개선
3. 테스트 케이스 추가
4. 성능 분석
5. 아키텍처 다이어그램

마지막 업데이트: 2026년 2월