HowTo :: Patch em binários no Linux

Date: 2019-01-14

Last Modified: 2026-02-01

Reading Time: 7 mins

Section: HowTo

Categories: howto

Tags: assembly nasm dev glibc linux userland exploitation

Introdução

Aprenda a aplicar patches em arquivos binários diretamente sem código-fonte usando edição hexadecimal e ferramentas de diff binário; essencial para corrigir bugs, aplicar patches de segurança ou modificar executáveis.

O Que é Patching de Binários?

Patching de binários é o processo de modificar arquivos executáveis compilados sem acesso ao seu código-fonte. Esta técnica é útil para:

Corrigir bugs em binários de produção quando recompilação não é possível
Aplicar patches de segurança em sistemas legados
Engenharia reversa e compreensão de como programas funcionam
Desafios de CTF e pesquisa de vulnerabilidades
Modificar comportamento de aplicações closed-source
Criar diffs binários para distribuir patches

Em vez de editar código-fonte de alto nível e recompilar, você modifica diretamente os bytes de código de máquina no arquivo executável. Isso requer compreensão de representação hexadecimal e formatos de arquivo executável.

Nota Importante

Patching de binários deve ser realizado apenas em arquivos que você possui ou tem permissão explícita para modificar. Modificar software com direitos autorais sem permissão pode violar acordos de licenciamento ou leis.

O Que Você Vai Precisar

Pré-requisitos

Antes de aplicar patches em binários, certifique-se de ter:

xxd - Ferramenta de dump hexadecimal (incluída na maioria das distribuições Linux com vim-common)
diff - Ferramenta de comparação de texto (padrão em todos os sistemas Linux)
bsdiff - Ferramenta de diff/patch binário (instalar separadamente: apt install bsdiff)
Cópias de backup de quaisquer arquivos que você planeja modificar
Conhecimento básico de hexadecimal - Compreensão de representação hexadecimal (0x00-0xFF)

Método 1: Usando xxd (Edição Hexadecimal)

O comando xxd cria representações hexadecimais de arquivos binários que você pode editar com editores de texto, e então converter de volta para binário.

Passo 1: Converter Binário para Hex

Primeiro, crie dumps hexadecimais dos arquivos binários com os quais você quer trabalhar:

1
xxd prog1.bin > b1.hex

Isso converte prog1.bin em um formato hexadecimal legível salvo em b1.hex.

Exemplo de formato de saída:

1
2
00000000: 7f45 4c46 0201 0100 0000 0000 0000 0000  .ELF............
00000010: 0200 3e00 0100 0000 7010 4000 0000 0000  ..>.....p.@.....

Cada linha mostra:

Offset de byte (esquerda): Posição no arquivo
Valores hexadecimais (meio): Os bytes reais em hexadecimal
Representação ASCII (direita): Caracteres imprimíveis (pontos para não-imprimíveis)

Entendendo a Saída do xxd

A coluna da esquerda mostra o offset do arquivo em hexadecimal. A seção do meio mostra 16 bytes por linha em formato hexadecimal. A seção da direita mostra interpretação ASCII onde . representa caracteres não-imprimíveis.

Passo 2: Editar o Arquivo Hex

Agora você pode editar b1.hex com qualquer editor de texto. Modifique os valores hexadecimais nas colunas do meio:

1
2
3
vim b1.hex
# Ou use seu editor preferido
nano b1.hex

Exemplo de modificação: Altere opcodes de instrução, valores de string, ou endereços de salto editando os bytes hexadecimais.

Edite com Cuidado

Modifique apenas os valores hexadecimais nas colunas do meio. Não altere:

Os offsets de byte (coluna da esquerda)
A estrutura de linha ou espaçamento
A representação ASCII (coluna da direita) - ela é auto-gerada

Até um pequeno erro pode corromper o binário e torná-lo inexecutável.

Passo 3: Converter Hex de Volta para Binário

Após editar, converta o arquivo hexadecimal de volta para binário:

1
xxd -r b1.hex new_prog1.bin

A flag -r diz ao xxd para reverter a conversão (hex para binário).

Passo 4: Comparar Binários Usando Diffs Hexadecimais

Para ver o que mudou entre duas versões, crie dumps hexadecimais de ambas e compare:

1
2
3
xxd prog1.bin > original.hex
xxd new_prog1.bin > modified.hex
diff original.hex modified.hex

Ou use vimdiff para comparação visual:

1
vimdiff original.hex modified.hex

Isso mostra exatamente quais bytes mudaram, facilitando documentar ou reverter suas modificações.

Alternativa de Diff Binário

Para uma comparação binária mais concisa, você também pode usar:

1
cmp -l prog1.bin new_prog1.bin

Isso mostra posições de bytes e valores que diferem entre os dois arquivos.

Método 2: Usando bsdiff (Patches Binários)

A ferramenta bsdiff cria e aplica arquivos de patch binários, úteis para distribuir modificações sem compartilhar binários inteiros.

Passo 1: Instalar bsdiff

Se ainda não estiver instalado:

1
2
sudo apt install bsdiff      # Debian/Ubuntu
sudo yum install bsdiff      # Fedora/RHEL

Passo 2: Criar um Patch Binário

Gere um arquivo de patch de uma versão antiga e nova de um binário:

1
bsdiff old_prog.bin new_prog.bin patch.bin

Isso cria patch.bin, que contém apenas as diferenças entre os dois arquivos; muito menor que distribuir o novo binário inteiro.

O que isso faz:

Analisa diferenças entre old_prog.bin e new_prog.bin
Cria arquivo de patch comprimido contendo apenas bytes alterados
Arquivo de patch pode ser distribuído separadamente do binário completo

Tamanho do Patch

Arquivos de patch são tipicamente muito menores que binários completos. Por exemplo, um binário de 1MB com algumas mudanças de bytes pode produzir um arquivo de patch de apenas alguns KB.

Passo 3: Aplicar um Patch Binário

Para aplicar um arquivo de patch ao binário original:

1
bspatch old_prog.bin output.bin patch.bin

Isso aplica as modificações de patch.bin a old_prog.bin, criando output.bin que corresponde a new_prog.bin.

Casos de uso:

Distribuir correções de segurança sem compartilhar executáveis inteiros
Aplicar patches da comunidade a jogos ou aplicações
Controle de versão para arquivos binários
Minimizar tamanhos de download para atualizações

Passo 4: Verificar o Resultado

Sempre verifique que o binário com patch corresponde às expectativas:

1
2
3
4
5
6
7
8
# Comparar tamanhos de arquivo
ls -lh old_prog.bin output.bin new_prog.bin

# Verificar integridade do arquivo se você tiver checksums
sha256sum old_prog.bin output.bin new_prog.bin

# Testar funcionalidade
./output.bin --version

Exemplo Prático: Aplicando Patch em um Binário Simples

Aqui está um fluxo de trabalho completo para aplicar patch em um binário para mudar uma string:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
# 1. Criar backup
cp myprogram.bin myprogram.bin.backup

# 2. Converter para hex
xxd myprogram.bin > myprogram.hex

# 3. Procurar a string que você quer mudar
grep -n "Hello" myprogram.hex

# 4. Editar o arquivo hex (mudar os bytes)
vim myprogram.hex
# Encontre a linha com "Hello" e mude para "Hallo" (ou o que couber)

# 5. Converter de volta para binário
xxd -r myprogram.hex myprogram_patched.bin

# 6. Tornar executável
chmod +x myprogram_patched.bin

# 7. Testar
./myprogram_patched.bin

Comprimento da String Importa

Ao substituir strings em binários, a substituição deve ter o mesmo comprimento ou ser mais curta que a original. Strings mais longas sobrescreverão dados adjacentes e provavelmente farão o programa crashar. Preencha strings mais curtas com bytes nulos (00) se necessário.

Solução de Problemas

Problemas Comuns

Problema: Binário com patch crasha ou não executa Solução:

Verifique se o arquivo hex não foi corrompido durante a edição
Verifique que você não modificou offsets ou estrutura do arquivo
Certifique-se de permissões de execução: chmod +x patched.bin
Compare com o original para identificar mudanças inesperadas

Problema: bspatch falha com “corrupt patch” Solução:

Certifique-se de que o arquivo de patch não foi corrompido durante transferência
Verifique que você está usando a versão correta do binário original
Verifique permissões de arquivo em todos os arquivos envolvidos

Problema: Substituição de string causa crashes Solução:

Strings de substituição devem ter o mesmo comprimento ou serem mais curtas
Preencha com bytes nulos (00) se for mais curta
Verifique por terminadores nulos (00) no fim das strings

Problema: Mudanças não parecem ter efeito Solução:

Limpe quaisquer versões em cache: rm -f versao_em_cache
Verifique que você está executando o binário com patch, não o original
Verifique se o binário tem anti-tampering ou verificação de assinatura

Melhores Práticas

Dicas de Patching de Binários

Sempre faça backup de arquivos originais antes de aplicar patches
Documente mudanças que você faz para referência futura
Teste minuciosamente após aplicar patches
Use controle de versão para os próprios arquivos de patch
Verifique checksums após aplicar patches
Mantenha arquivos de patch pequenos modificando apenas bytes necessários
Considere implicações legais antes de modificar binários

Próximos Passos

Agora que você entende patching de binários:

Aprenda assembly: Leia Syscalls do Linux em Assembly para entender o que você está modificando
Domine o GDB: Use GDB para inspecionar binários e encontrar locais de patch
Estude formato ELF: Aprenda sobre estrutura de arquivo executável para aplicar patches com segurança
Pratique com CTFs: Desafios Capture The Flag frequentemente requerem habilidades de patching de binários

Ferramentas Avançadas

Para modificação binária mais sofisticada:

radare2 - Framework de engenharia reversa com capacidades de patching
Binary Ninja - Plataforma comercial de análise binária
Ghidra - Ferramenta gratuita de engenharia reversa da NSA
objcopy - Ferramenta GNU para modificar arquivos objeto

Veja Também

Começando com GDB - Depure e inspecione binários para encontrar locais de patch
Syscalls do Linux em Assembly - Entenda execução de programas em baixo nível
Cheat Sheet de Compilação GCC - Aprenda sobre compilação e linkagem
Manual do xxd - Documentação completa do xxd
Documentação do bsdiff - Documentação oficial do bsdiff