Quero perguntar que tipo de codificação é usada para criar arquivos executáveis ​​em linux, por exemplo, hexadecemal, binário ou qualquer outra coisa. como é convertido? Existe alguma maneira de recuperar o código original desse arquivo executável?

Aqui está um pouco do código que tenho:

ELF���������>�����%|�����@�������������������@�8��@���������������������@�������@�����7<�����7<������� ������������������f�����f���������������������� ������[�UPX!L
h�h�8����������?�E�h=��ڊ̓�N�    4���9ISloB�q�w�]ȉ.��,ς��Q䝦����#e��-�N����/�b,���d<��'��-E��6E�s�/�U���ly�V�Y2]"a��S�.�hU�|�S�J�I�2���X}
�G0�;���5d�$���.)

o que isso significa?

É binário. O código fonte foi compilado. Você pode visualizá-lo em um editor (um editor hexadecimal blesspode fazer alterações mais refinadas), mas você realmente precisa saber o que está fazendo. Provavelmente, isso só é bom para fazer alterações de string.

Para algo mais grave, você pode começar a fazer engenharia reversa do binário em código de montagem . Isso geralmente é considerado como a linguagem de computador de nível mais baixo analisável por humanos.

objdump -d helloworld | less

Mas também incluirá muitas bobagens do compilador. Por exemplo, se você compilar o mais simpleshelloworld.cpp com o G ++ e, em seguida objdump, acabar com 226 linhas (208 removidas) de eca. Você pode escrever um "olá mundo" em apenas 15 linhas de montagem , compilá-lo e criarobjdump , mas isso ainda floresce em 166 linhas (despojadas).

Se você é bom o suficiente com montagem, isso pode lhe dar acesso suficiente para entender o que está acontecendo e até mesmo deixá-lo mudar ... Mas, para responder à sua pergunta original:

Você não pode transformar o código compilado novamente no código-fonte original .

Desculpe. É uma transformação unidirecional que perde informações (comentários, formatação, conceitos de algoritmos legíveis etc.), está estaticamente vinculada a outras coisas e geralmente é otimizada de maneira a torná-la ininteligível a qualquer coisa, exceto aos melhores e mais experientes programadores.

Para lhe dar uma idéia da escala do problema, toda a idéia do software de engenharia reversa tem seu próprio site Stack Exchange .

Como não tenho pontos de reputação suficientes para comentar, é uma resposta:

Não, não é possível convertê-lo "de volta". Você mencionou upx packer, você já leu o manual do upx?

Se você perdeu a fonte ou não tem acesso ao código de outra pessoa não importa aqui, isso simplesmente não é possível.

O executável binário foi produzido com um compilador, não acredite em nada indicado neste site, basta ler o manual exatamente desse compilador. Em seguida, você pode adicionar aqui, em qual idioma o código original foi escrito, qual compilador foi usado e, em seguida, você pode observar que essas etapas (pré-processamento, compilação, vinculação, talvez empacotamento) não são revertidas como um todo, mas somente seja analisado o que o autor original possa ter pretendido e escrito.

Este é provavelmente um arquivo binário (um arquivo ELF), conforme descrito aqui:

https://en.wikipedia.org/wiki/Executable_and_Linkable_Format

Se você o alterou com um editor de texto normal e salvou suas alterações, isso não foi uma boa ideia e você pode tê-lo destruído.

Como Oli já apontou em sua resposta, você não pode obter o código fonte muito original de um executável.

Durante a compilação de um código fonte (compilação pretendida como em sua aceitação mais ampla típica, portanto, como todo o processo que "transforma" um código fonte em um executável), muitas informações são perdidas.

O pré-processador C, por exemplo, fará o seguinte (entre outras coisas):

• Interpretar, executar e remover diretivas de pré-processador ( #instruções)
• Remover comentários
• Remova espaços em branco desnecessários

Por outro lado, o que não é perdido durante a compilação do código fonte é tecnicamente reversível para um código fonte funcionalmente equivalente.

Isto é porque:

• As instruções binárias têm uma correlação 1: 1 com as instruções de montagem; a montagem de um código-fonte de montagem é apenas uma mera conversão das instruções de montagem em instruções binárias com base em uma tabela de correspondências; uma única instrução binária é sempre identificável e reversível a uma única instrução de montagem ;
• As instruções de montagem não têm uma correlação 1: 1 com as instruções C; a compilação de um código-fonte C geralmente não é apenas uma mera conversão das instruções C para as instruções de montagem com base em uma tabela de correspondências; na verdade, é muitas vezes o contrário; geralmente uma instrução C é convertida em várias instruções de montagem (geralmente diferentes com base no compilador); no entanto, padrões de várias instruções de montagem são geralmente identificáveis ​​e reversíveis para uma única instrução C ;

Existem ferramentas chamadas descompiladores cujo objetivo é tentar reverter um executável para um código-fonte funcionalmente equivalente; no entanto, o resultado geralmente é algo muito distante do código fonte muito original (e geralmente também não compilável);

Considere este programa:

#include <stdio.h>

#define MESSAGE "Literal strings will be recovered" // This preprocessor directive won't be recovered

/*

This comment and the comment above won't be recovered

*/

int main(int argc, char* argv[]) {
    printf(MESSAGE);
    return 0;
}

Compilando-o em um executável e descompilando-o em um código-fonte novamente, é mais ou menos o que você costuma receber de volta (nesse caso específico, usei gcc/ Boomerang ):

// address: 0x80483fb
int main(int argc, char **argv, char **envp) {
    printf("Literal strings will be recovered");
    return 0;
}

Como previsto:

• Diretivas de pré-processador estão ausentes
• Faltam comentários (além do // address: 0x80483fbque foi adicionado pelo decompilador)
• Falta espaço em branco desnecessário (além de novas linhas e tabulações, que foram adicionadas pelo decompilador)

Este também é um resultado muito bom; não é raro obter instruções de montagem embutidas no código:

asm("assembly_instruction");
__asm__("assembly_instruction");

A linha inferior é (como já indicado nas outras respostas): você não pode obter a fonte original de um executável *.

_{* No entanto, dependendo do executável e da sua sorte, você poderá obter algo usando um descompilador.}

Os executáveis ​​geralmente são binários se você estiver falando sobre programas compilados. Você pode encontrar mais informações usando file path/to/executable. Você pode exibir executáveis ​​binários em hexadecimal usando, por exemplo, hexdump -C path/to/executable | less(qualquer que seja o benefício). Se você quiser "convertê-lo de volta à sua forma original", você precisará usar um descompilador apropriado, consulte este post, por exemplo , embora isso lhe dê um código bastante ilegível, e não o original do qual foi compilado. Se não for um binário compilado, seria algum tipo de script executável, que deve ser facilmente legível em qualquer editor de texto. O que você nos mostrou aqui provavelmente é um executável compilado. ELF significa "Formato executável e de vinculação", que é um formato binário comum em sistemas Linux / Unix. Lá'strings path/to/executable, se é isso que você precisa.