ingeniería inversa
 

Holas amigos de este foro:

Tengo una aplicación hecha en Delphi 7, pero no tengo sus fuentes. Hay alguna posibilidad de usar algo asi como ingeniería inversa .. no se es que necesito conocer algunas de sus rutinas.

Alguien me pudiera ayudar.

Gracias de antemano .
Ledian

¿Obtener el código fuente de un ejecutable delphi?, no.

Como te ha dicho Casimiro es muy dificil obtener el código fuente de un ejecutable, pero de todas manera puedes hecharle un vistazo a éste hilo y sacar tus propias conclusiones.;)
Saludos...:)

imposible, es como buscar agua en el sol.
...te imaginas? sacarle el codigo fuente a los super programas de valen miles de $?
:D

Da igual que cuesten miles de dólares o sean gratis, el ejecutable se crea igual para todos.

Por cierto, bienvenido a clubdelphi, Philip_ :)

Difícil no es la palabra adecuada en este caso, creo que la palabra es imposible.:D:D:D

Delphi genera programas/aplicaciones compiladas y linkadas; Es decir, que el código que escribimos, posteriormente se traduce a código máquina (utilizando un compilador).

Los de-compiladores pueden devolver código máquina, pero nunca pueden hacer la traducción inversa.

Es como si alguien escribiera una redacción y luego otra persona la traduce y la lee en inglés.
¿Hay alguien capaz (de-compilador) de escuchar esa traducción y "deducir" de forma exacta la redacción original?
No, imposible, porque una misma frase en Inglés se puede traducir de muchas formas al castellano y quien ha escuchado la traducción en inglés no puede saber cual fue la forma que se usó originalmente.

Con los programas compilados pasa igual. Un de-compilador que ve lenguaje máquina no puede saber "exactamente" qué sentencias exactas se usaron en Delphi para generas las que él está viendo.

Llegados a este punto, tenemos claro que el código fuente del programa compilado (diferente sería si fuera lenguaje interpretado), no lo vas a poder obtener.

Los decompiladores, sí pueden obtener etiquetas, nombres de variables, constantes, incluso nombres de los procedimietos que se han utilizado. Alguno incluso, "intenta" (pero sólo lo intenta, no quiere decir que lo consiga) obtener lo que podría ser la traducción de código máquina a código de alto nivel; En esos casos puedes obtener algo así:

Por ejemplo, el intento de traducir el código del evento: imgSalirClick devolvería esto:

//------------------------------------------------------------------
004DA3F4 55 push ebp
004DA3F5 8BEC mov ebp, esp
004DA3F7 83C4F8 add esp, -$08
004DA3FA 8955F8 mov [ebp-$08], edx
004DA3FD 8945FC mov [ebp-$04], eax

* Reference to FormMain
|
004DA400 8B45FC mov eax, [ebp-$04]

* Reference to: Forms.TCustomForm.Close(TCustomForm);
|
004DA403 E854A6F8FF call 00464A5C
004DA408 59 pop ecx
004DA409 59 pop ecx
004DA40A 5D pop ebp
004DA40B C3 ret
//------------------------------------------------------------------

O la traducción del evento actionCargarFicheroCopiaExecute devolvería algo así:

//------------------------------------------------------------------
004DC1DC 55 push ebp
004DC1DD 8BEC mov ebp, esp
004DC1DF B905000000 mov ecx, $00000005
004DC1E4 6A00 push $00
004DC1E6 6A00 push $00
004DC1E8 49 dec ecx
004DC1E9 75F9 jnz 004DC1E4
004DC1EB 53 push ebx
004DC1EC 8955F0 mov [ebp-$10], edx
004DC1EF 8945FC mov [ebp-$04], eax
004DC1F2 33C0 xor eax, eax
004DC1F4 55 push ebp

* Possible String Reference to: 'é¥|òÿëÛ[‹å]Ã'
|
004DC1F5 68BEC34D00 push $004DC3BE

***** TRY
|
004DC1FA 64FF30 push dword ptr fs:[eax]
004DC1FD 648920 mov fs:[eax], esp
004DC200 8D55E8 lea edx, [ebp-$18]

* Reference to FormMain
|
004DC203 8B45FC mov eax, [ebp-$04]

* Reference to control TFormMain.edtSourceCopy : TEdit
|
004DC206 8B806C040000 mov eax, [eax+$046C]

* Reference to: Controls.TControl.GetText(TControl):TCaption;
|
004DC20C E85BB5F6FF call 0044776C
004DC211 8B45E8 mov eax, [ebp-$18]
004DC214 8D55EC lea edx, [ebp-$14]

* Reference to: Unit_004080C0.Proc_00408FCC
|
004DC217 E8B0CDF2FF call 00408FCC
004DC21C 837DEC00 cmp dword ptr [ebp-$14], +$00
004DC220 752B jnz 004DC24D
004DC222 6A00 push $00
004DC224 668B0DCCC34D00 mov cx, word ptr [$004DC3CC]
004DC22B 33D2 xor edx, edx

* Possible String Reference to: 'Debe rellenar el fichero con la lis
| ta de archivos a copiar.'
|
004DC22D B8D8C34D00 mov eax, $004DC3D8

* Reference to: Dialogs.Proc_0044086C
|
004DC232 E83546F6FF call 0044086C
...
//------------------------------------------------------------------

La verdad, es que tal vez puede servir para darte alguna pista, pero dudo que sirva para recuperar el código.;)

Lo que sí podrás obtener, son otro tipo de cosas que se almacenan en el ejecutable y que no se traducen a odigo máquina, como son los recursos, los formularios,...

Espero haberte aclarado alguna cosa.

Un saludo.

Como te han dicho, por ingeniería inversa, solamente los formularios con sus componentes abstractos más comunes y primitivos, es decir, si usan un componente como rxLib solamente aparecerá el botón del cual está basado, no su forma final, y al igual que ello, los eventos y código, no viene en lenguaje de alto nivel, sino en máquina, si es que el decompilador te lo saca.

Coincido con neftalí, el proceso de generar un ejecutable siempre implica convertir un código fuente en código máquina. Es como si encontramos una traducción de x lenguaje al inglés y queremos saber de que lenguaje fue traducido. Es imposible. Lo que en algunas ocasiones sí es posible es desensamblar el código, y obtener código en lenguaje ensamblador el cual alguien bien entendido sí es capaz de modificar para que haga otra cosa. Pero de ahí a obtener un código fuente completo, hay un mundo.