Arquitetura SoLoader e Realocações
Mecânica de baixo nível para carregar binários ELF32 na memória executável do PS Vita, análise de cabeçalhos de programa, resolução de realocações ARM e hooking dinâmico.
O coração de qualquer port de Android para o PlayStation Vita reside no carregador dinâmico de binários ELF (so_util.c ou dynlib.c). Este módulo substitui em espaço de usuário o carregador dinâmico do Linux (/system/bin/linker).
🏗️ Como o ELF é Carregado na Memória¶
Arquivos .so do Android NDK são binários no formato ELF32 padrão para a arquitetura ARM.
flowchart TD
A["Ler arquivo .so em ux0:data/"] --> B["Validar Cabeçalho ELF (Elf32_Ehdr)"]
B --> C["Calcular Pegada de Memória (Segmentos PT_LOAD)"]
C --> D["Alocar Bloco de Memória RWX com sceKernelAllocMemBlock"]
D --> E["Copiar Segmentos para a Memória & Zerar BSS"]
E --> F["Processar Realocações (.rel.dyn e .rel.plt)"]
F --> G["Vincular Símbolos Importados (Hooking)"]
G --> H["Limpar Cache de Instruções (sceKernelSyncCacheRange)"]
H --> I["Pronto para Execução"]
1. Validação do Cabeçalho ELF (Elf32_Ehdr)¶
O carregador verifica os bytes mágicos e a arquitetura alvo:
- Magic: 0x7F 'E' 'L' 'F'
- Classe: ELFCLASS32 (1)
- Endianness: ELFDATA2LSB (1)
- Máquina: EM_ARM (40)
2. Alocação de Memória Executável no VitaOS¶
O carregador lê os Program Headers (Elf32_Phdr), encontra os segmentos PT_LOAD, calcula o tamanho alinhado e aloca um bloco contíguo:
SceUID memid = sceKernelAllocMemBlock(
"game_code_block",
SCE_KERNEL_MEMBLOCK_TYPE_USER_RWX, // Permissões de Leitura, Escrita e Execução
aligned_total_size,
NULL
);
void *base_addr;
sceKernelGetMemBlockBase(memid, &base_addr);
[!NOTE] A alocação de blocos
USER_RWXrequer o plugin de kernel kubridge. Sem ele, o VitaOS rejeita a criação de páginas de memória simultaneamente graváveis e executáveis.
🔄 O Motor de Realocações ARM¶
Bibliotecas compartilhadas são compiladas com código independente de posição (PIC/PIE), de modo que ponteiros internos precisam ser recalculados somando o endereço base onde a biblioteca foi carregada (base_addr).
O carregador itera sobre as seções .rel.dyn e .rel.plt:
typedef struct {
Elf32_Addr r_offset; // Endereço de memória a ser ajustado
Elf32_Word r_info; // Tipo de realocação e índice do símbolo
} Elf32_Rel;
#define ELF32_R_SYM(val) ((val) >> 8)
#define ELF32_R_TYPE(val) ((val) & 0xff)
Tipos Fundamentais de Realocação ARM:¶
| Código | Nome Simbólico | Ação Executada pelo Carregador |
|---|---|---|
| 23 | R_ARM_RELATIVE |
*(uint32_t*)(base + r_offset) += (uint32_t)base; Ajusta ponteiros absolutos internos somando o novo endereço base. |
| 21 | R_ARM_GLOB_DAT |
Localiza o símbolo na tabela de strings (.dynstr), resolve seu endereço real e escreve em *(uint32_t*)(base + r_offset). |
| 22 | R_ARM_JUMP_SLOT |
Usado na tabela PLT (Procedure Linkage Table). Escreve o ponteiro de salto da função. |
| 2 | R_ARM_ABS32 |
Soma o valor do símbolo ao endereço presente no offset. |
🪝 Interceptação de Símbolos (Symbol Hooking)¶
Quando o jogo chama funções padrão da libc ou OpenGL ES, o carregador as redireciona para as implementações do VitaSDK ou vitaGL:
typedef struct {
const char *symbol;
uintptr_t func;
} DynLibSymbol;
static const DynLibSymbol dynlib_symbols[] = {
// Funções da libc
{ "malloc", (uintptr_t)&malloc },
{ "free", (uintptr_t)&free },
{ "memcpy", (uintptr_t)&memcpy },
{ "memset", (uintptr_t)&memset },
// I/O de arquivos redirecionado
{ "fopen", (uintptr_t)&vita_fopen },
{ "fclose", (uintptr_t)&fclose },
// Gráficos (vitaGL)
{ "glViewport", (uintptr_t)&glViewport },
{ "glClear", (uintptr_t)&glClear },
{ "glDrawElements", (uintptr_t)&glDrawElements },
// Log do Android redirecionado
{ "__android_log_print", (uintptr_t)&vita_log_print },
{ NULL, 0 }
};
🩹 Patches em Memória e Sincronização de Cache¶
Para neutralizar verificações de pirataria da Google Play ou serviços de telemetria:
Patch de Retorno Imediato (BX LR):¶
- Modo Thumb: Escreva
movs r0, #0(0x2000) ebx lr(0x4770): - Modo ARM (32 bits): Escreva
mov r0, #0(0xe3a00000) ebx lr(0xe12fff1e).
Sincronização Obrigatória de Cache¶
Após aplicar patches ou processar realocações, a memória é atualizada na cache de dados (D-Cache), mas a cache de instruções (I-Cache) pode manter o código desatualizado.
[!CRITICAL] Sempre limpe e sincronize a cache após alterar instruções na memória: