Quiero preguntar qué tipo de codificación se utiliza para hacer que los archivos ejecutables de Linux, por ejemplo, hexadecemal, binario o cualquier otra cosa. ¿Cómo se convierte? ¿Hay alguna forma de recuperar el código original de este archivo ejecutable?

Aquí hay un poco de código que tengo:

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�$���.)

¿Qué se supone que significa?

Es binario. El código fuente ha sido compilado. Puede verlo en un editor (un editor hexadecimal como blesspodría hacer cambios más refinados) pero realmente necesita saber lo que está haciendo. Probablemente solo sea bueno para hacer cambios de cadena.

Para algo más duro, puede comenzar a realizar ingeniería inversa del binario en el código de ensamblaje . Esto a menudo se considera como el lenguaje informático analizable por humanos de nivel más bajo.

objdump -d helloworld | less

Pero también incluirá muchas tonterías del compilador. Por ejemplo, si compila lo más simplehelloworld.cpp con G ++ y luego objdump, termina con 226 líneas (208 despojadas) de yuck. Podrías escribir un "hola mundo" en solo 15 líneas de ensamblaje , compilarlo y objdumpque aún así se convierta en 166 líneas (despojado).

Si eres lo suficientemente bueno con el ensamblaje, esto puede darte suficiente acceso para comprender lo que está sucediendo e incluso permitirte cambiarlo ... Pero para responder a tu pregunta original:

No puede volver a convertir el código compilado en el código fuente original .

Lo siento. Es una transformación unidireccional que pierde información (comentarios, formato, conceptos de algoritmos legibles, etc.), está estáticamente vinculada a otras cosas y generalmente está optimizada de tal manera que la haría ininteligible para cualquier cosa que no sean los mejores y más experimentados programadores.

Para darle una idea de la magnitud del problema, toda la idea del software de ingeniería inversa tiene su propio sitio Stack Exchange .

No tengo suficientes puntos de reputación para un comentario, así que es una respuesta:

No, no es posible convertirlo "de regreso". Mencionaste upx packer, ¿alguna vez leíste el manual de upx?

Si perdió la fuente, o no tiene acceso al código de otra persona, no importa aquí, simplemente no es posible.

El ejecutable binario fue producido con un compilador, no creas nada de lo que se dice en este sitio, solo lee el manual de ese compilador. Luego, puede agregar aquí, en qué idioma se escribió el código original, qué compilador se usó, y luego podría notar que estos pasos (preprocesamiento, compilación, vinculación, tal vez empaquetar) no se invierten en su conjunto, sino que solo podrían ser analizado lo que el autor original podría haber pretendido y escrito.

Este es probablemente un archivo binario (un archivo ELF) como se describe muy bien aquí:

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

Si lo modificó con un editor de texto normal y guardó los cambios, no fue una buena idea y es posible que lo haya destruido.

Como ya señaló Oli en su respuesta, no se puede obtener el código fuente muy original de un ejecutable.

Durante la compilación de un código fuente (compilación destinada a su aceptación más amplia típica, por lo tanto, como todo el proceso que "transforma" un código fuente en un ejecutable), se pierde mucha información.

El preprocesador C, por ejemplo, hará lo siguiente (entre otras cosas):

• Interpretar, ejecutar y eliminar directivas de preprocesador ( #declaraciones)
• Eliminar comentarios
• Eliminar espacios en blanco innecesarios

Por otro lado, lo que no se pierde durante la compilación del código fuente es técnicamente reversible a un código fuente funcionalmente equivalente.

Esto es porque:

• Las instrucciones binarias tienen una correspondencia 1: 1 con las instrucciones de montaje; el ensamblaje de un código fuente de ensamblaje es solo una mera conversión de las instrucciones de ensamblaje a las instrucciones binarias basadas en una tabla de correspondencias; una sola instrucción binaria siempre es identificable y reversible a una sola instrucción de ensamblaje ;
• Las instrucciones de montaje no tienen una correspondencia 1: 1 con las instrucciones C; la compilación de un código fuente C generalmente no es solo una mera conversión de las instrucciones C a las instrucciones de ensamblaje basadas en una tabla de correspondencias, de hecho, a menudo es lo contrario; generalmente una instrucción C se convierte en instrucciones de ensamblaje múltiples (a menudo diferentes según el compilador); sin embargo, los patrones de múltiples instrucciones de ensamblaje son usualmente identificables y reversibles a una sola instrucción C ;

Hay herramientas llamadas descompiladores cuyo propósito es tratar de revertir un ejecutable a un código fuente funcionalmente equivalente; sin embargo, el resultado suele ser algo alejado del código fuente muy original (y, por lo general, también no es compatible);

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;
}

Al compilarlo en un ejecutable y descompilarlo en un código fuente nuevamente, esto es más o menos lo que generalmente obtienes (en este caso específico usé gcc/ Boomerang ):

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

Como se predijo:

• Faltan directivas de preprocesador
• Faltan comentarios (aparte de // address: 0x80483fb, que ha sido agregado por el descompilador)
• Falta un espacio en blanco innecesario (aparte de las nuevas líneas y tabulaciones, que el descompilador ha agregado)

Este también es un resultado bastante bueno; No es raro obtener instrucciones de ensamblaje en línea en el código:

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

La conclusión es (como ya se señaló en las otras respuestas): no se puede obtener la fuente original de un ejecutable *.

_{* Sin embargo, dependiendo del ejecutable y de su suerte, puede obtener algo usando un descompilador.}

Los ejecutables suelen ser binarios si se trata de programas compilados. Puede encontrar más información utilizando file path/to/executable. Puede mostrar ejecutables binarios en hexadecimal usando, por ejemplo, hexdump -C path/to/executable | less(lo que sea bueno para usted). Si desea "volver a convertirlo a su forma original", tendría que usar un descompilador adecuado. Consulte esta publicación, por ejemplo , aunque eso le daría un código bastante ilegible, no el original del que fue compilado. Si no es un binario compilado, sería algún tipo de script ejecutable, que debería ser fácilmente legible en cualquier editor de texto. Lo que nos mostró aquí es probablemente un ejecutable compilado. ELF significa "formato ejecutable y de enlace", que es un formato binario común en sistemas Linux / Unix. Allí'strings path/to/executable, si esto es lo que necesitas.