¿por que los apps se descompilan facilmente?
 

saludos terricolas este es mi primer hilo, estuve viendo un programa que me pasaron , creo se llama DEDE con que se descompila (revierte a codigo) los ejecutables generados en delphi 7. genere mi aplicacion usando el ide delphi 7.2 personal edition y luego le pase el DEDE y este ultimo me genero los archivos fuente del ejecutable , ¿como es posible?, no se supone que cuando generas un programa este deberia convertir el codigo fuente a codigo maquina o algo asi?, o al menos eso es lo que dicen en los libros, lo mas extraño es que despues de descompilar se podian ver los nombres de los componentes y variables usados, ¿hay alguna forma de prevenir esto?

rugido_37,

¡Bienvenido al Club Delphi!

Revisa estos links:
Espero sea útil :)

Nelson.

Bienvenido al Club.
(1) No me suena esa versión de Delphi.

Yo te recomendaría también que revisaras la Guía de estilo del club.

He usado DEDE alguna vez y esto que comentas es INCORRECTO (lo digo para que alguien que no lo haya usado no se asuste). Delphi compila y linka los programas, lo que significa que traduce el código fuente escrito en Delphi en un lenguage intermedio que luego es ejecutado por la máquina. Eso quiere decir que en un ejecutable generado en Delphi NO ESTÁ EL CÓDIGO FUENTE, por lo tanto es imposible extraerlo.
Lo que hace DEDE (en cuanto al código) es enseñar el código ASM e intentar presuponer qué bloques de código corresponden a una estructura Delphi.
Por ejemplo, un evento que has programado en Delphi, te lo devolverá como esto:

Código Delphi [-]
procedure TForm1.Button1Click(Sender : TObject);
begin
(*
00401F18   55                     push    ebp
00401F19   8BEC                   mov     ebp, esp
00401F1B   B907000000             mov     ecx, $00000007
00401F20   6A00                   push    $00
00401F22   6A00                   push    $00
00401F24   49                     dec     ecx
00401F25   75F9                   jnz     00401F20
00401F27   8955E0                 mov     [ebp-$20], edx
00401F2A   8945FC                 mov     [ebp-$04], eax
00401F2D   33C0                   xor     eax, eax
00401F2F   55                     push    ebp
00401F30   6823224000             push    $00402223

***** TRY
|
00401F35   64FF30                 push    dword ptr fs:[eax]
00401F38   648920                 mov     fs:[eax], esp
00401F3B   8D45F8                 lea     eax, [ebp-$08]

* Possible String Reference to: 
|
00401F3E   BA38224000             mov     edx, $00402238

* Reference to: rtl60.@System@@LStrLAsg$qqrpvpxv()
|
00401F43   E810F1FFFF             call    00401058
00401F48   8D45F4                 lea     eax, [ebp-$0C]

* Possible String Reference to: 'skjh < ghh < gsd''
|
00401F4B   BA58224000             mov     edx, $00402258

* Reference to: rtl60.@System@@LStrLAsg$qqrpvpxv()
|
00401F50   E803F1FFFF             call    00401058
00401F55   8D55DC                 lea     edx, [ebp-$24]
00401F58   8B45FC                 mov     eax, [ebp-$04]

* Reference to control TForm1.Edit1 : TEdit
|
00401F5B   8B80F4020000           mov     eax, [eax+$02F4]

* Reference to: vcl60.@Controls@TControl@GetText$qqrv()
|
00401F61   E882F6FFFF             call    004015E8
00401F66   8B45DC                 mov     eax, [ebp-$24]
00401F69   8D55F0                 lea     edx, [ebp-$10]

* Reference to: rtl60.@Sysutils@Trim$qqrx17System@AnsiString()
|
00401F6C   E85FF2FFFF             call    004011D0
00401F71   8B45F8                 mov     eax, [ebp-$08]
00401F74   8B155C534000           mov     edx, [$40535C]
00401F7A   8B12                   mov     edx, [edx]

...

Como puedes ver, realmente lo que hace DEDE es enseñarte código ASM y "suponer" qué hace cada bloque, pero esto último es sólo una suposición.

Justamente es lo que hace.
El problema es que estás mezclando 2 cosas. Una es el código fuente, que se convierte a código máquina como bien has dicho, y otra cosa son los recursos del programa (imágenes, cadenas, formularios,...).
Si te fijas, he puesto que entre los recursos están los formularios, porque Delphi guarda como recursos, de ahí que puedas recuperarlos (el DFM) con DEDE, pero en realidad sólo recuperas el diseño, NO EL CÓDIGO.

Si realmente te preocupa que tu programa se pueda "decompilar" o incluso "debuggar" sea con DEDE o con cualquier otra herramienta, puedes usar utilidades específicas para ello. Hay "cyrpters" en el mercado (algunos freeware) que te permitirán hacerlo en un sólo paso.

Un saludo.

rugido_37,

^\||/

Revisa esta información:
Espero sea útil :)

Nelson.

Revisada está, pero si no te explicas, no se que quieres decir con ella.

En el primer párrafo habla de lenguajes que usan máquinas virtuales, como Java o .NET, cosa que no hace Delphi. Por eso la decompilación de unos y otros no tiene nada que ver. O lo que es lo mismo, que los JAVA y .NET sí se pueden decompilar, los de Delphi no.

El segundo te dice que la decompilación no te va a dar una copia exacta del código original. Correcto. Por que lo que intenta, tal y como he comentado, es a partir del código ASM, y según la estructura de las sentencias, "adivinar" cual era el código original en Delphi. Ya te avisa de que no va a ser exacto.
Ya te digo yo que en una rutina de 200 líneas ni se va a aproximar.

Y el tercer párrafo te dice que te dará los ficheros DFM (que no los .PAS), que como hemos comentado se almacenan como recursos. También te dice que los métodos published te los dará en ASM y con comentarios (que es más o menos como la imagen que te he puesto arriba). En ningún caso código PASCAL ni nada que se aproxime al original.

Un saludo.

Neftali,

Gracias por tus comentarios ^\||/

Te comento:

1- El Msg #4 esta dirigido a rugido_37 como un complemento de todo lo comentado y señalado en el hilo.

2- La información del Msg #4 tiene indicada la referencia de las fuentes citadas para una mejor compresión del tema.

3- La idea es ampliar la información comentada a nivel general y su contraste con otros lenguajes.

Espero que esto aclare el punto :)

Nelson.

hola , lei cada una de las respuestas junto con los enlaces y mas o menos voy cogiendo el tema, el nombre del ide que uso es exactamente "Delphi 7 Second Edition V7.2 professional" , lo confundi con la version personal.

Neftali
las dudas que me queda es que dices que delphi lo traduce el codigo a un lenguaje intermedio , ¿es lo mismo que lenguaje maquina?

otra que al decompilar tambien se pueden ver los nombres de los procedures y sus objetos ( TForm1.Button1 ) ¿no deberian haber handles en ves de nombres puestos por el programador?

y la ultima duda es que pensaba que para crear los formularios delphi "internamente" creaba algun codigo que llame a la funcion createwindow en ves de ponerlo como un recurso , he checado un poco de lenguaje c++ y eso era lo que se hacia para crear forms, botones y hasta menus.

en c++ todo se hace con puro codigo , por eso me desanime aprenderlo :P

No entiendo bien que es eso de los recursos, pero lo buscare en google.

rugido_37,

Delphi es un lenguaje compilado, por lo tanto su compilador genera código en lenguaje de máquina en arquitectura x86 y x64 dependiendo de la versión, a partir de Delphi XE2 se puede compilar en 64 bits, lenguaje intermedio no es sinónimo de lenguaje de máquina.

Revisa estos links:
Espero sea útil :)

Nelson.

No es exactamente lo mismo. Creo que más arriba lo ha explicado nlsgarcia.


Los nombres de algunos procedimientos, para marcar que se asignan a un evento, se guardan el el DFM, por eso son visibles.

La creación es como la has comentado tú. Lo que se guarda en el DFM son las propiedades del formulario (y las de sus controles), no su código ni las llamadas que se hacen.
El sistema llamará a la API CreateWindows para generar la ventana y posteriormente Delphi va al DFM donde están sus propiedades (altura, anchura, título, color,...) e igual pasa con los controles. Mira un fichero DFM y verás que sólo se encuentras las propiedades del form y de los componentes.

Los recursos son una forma que tienen los compiladores de adjuntar ficheros y otros elementos a los programas. Por ejemplo en recursos puedes encontrar cadenas, imágenes, sonidos y en general cualquier tipo de fichero que se quiera incluir dentro del ejecutable. Delphi usa los recursos para almacenar los DFM.

:) Gracias nlsgarcia, ya lo voy entendiendo mas, revise los enlaces y ya me queda claro que lenguaje compilado lo que hace es coger el codigo fuente y convertirlo en codigo maquina . :) gracias neftali ya entendi bien los recursos , no tenia idea que los IDEs ponian las propiedades de los objetos en otra parte del programa (recursos) , voy a revisar el tema de los DFM . Saludos.