Newsgroup: it.comp.lang.c++
Titolo: [?] Decompilatori!

Salve a tutti,
scusate la domanda (forse banale) ma esistono dei decompilatori per il
linguaggio C/C++?
--
Bye
Johnny
http://digilander.iol.it/Superpork

linguaggio C/C++?
No, o almeno esistono ma non otterrai mai il codice sorgente esatto,
anzi...
-- 
                    Marco Barisione (ICQ 84277092)
Se sei interessato alla creazione di it.comp.lang (per i linguaggi di
programmazione senza un gruppo apposito e per i confronti fra i
linguaggi) partecipa alla discussione sul manifesto su it.news.gruppi.

 anzi...
e se non ci fosse l'esigenza di riottenere il codice sorgente esatto quali
sarebbero questi decompilatori?


sarebbero questi decompilatori?
Guarda che il codice sorgente sarebbe veramente molto diverso
dall'originale e molto complesso.


 dall'originale e molto complesso.
senti.... se me li vuoi dire quali sono questi decompilatori te ne sarņ
grato.....
altrimenti se sei preoccupato per me lascia perdere.....


linguaggio C/C++?
Sicuramente si', ma non c'e' modo di ottenere una copia
precisa del codice sorgente, perche' la compilazione e' una
trasformazione pressoche' irreversibile.
Tanto piu' che il C++ esegue delle operazioni particolari
quando compila (come la decorazione dei nomi, ecc...) e
rende ancor piu' difficile la risalita.
In sostanza, se ti aspetti di applicare un decompilatore
C/C++ sul codice eseguibile di una qualsiasi applicazione
scritta in uno di questi linguaggi e avere come risultato
del codice sorgente leggibile e vicino a quello originale,
c'e' poco da fare, non ci riuscirai.
-- 
The Follet

 altrimenti se sei preoccupato per me lascia perdere.....
Semplicemente: Non esistono!
In teoria č possibile farne uno che genera codice simil-C++, ma nessuno ha
mai prodotto decompilatori anche solo lontanamente utilizzabili anche perchč
non produrrebbe mai il codice scritto in origine e neanche una brutta copia
di questo, sarebbe un ingestibile listatone di vari Mb.
Mi ricordo solo di un programma EXE2C, mi pare scritto da due israeliani,
che avrebbe dovuto produrre codice C da un file EXE/COM ma allora era in
versione 0.1 (ti parlo di piů di 10 anni fa) a cui non č mai seguita nessuna
altra, ma il codice che produceva non era neanche compilabile oltre che di C
c'era poco o nulla nei sorgenti generati, un misto di C, assembler e
stringhe statiche con simboli incomprensibili (probabilmente veri blocchi da
inserire in memoria che il programma non era riuscito a tradurre).
--
Lello Mele
--
HOMEPAGE: 
http://www.lellomele.it
eMAIL   : 
v...@libero.it

Un pņ di storia sulla decompilazione e sul suddetto decompilatore EXE2C l'ho
trovata, molto semplicemente con google (spesso mi domando come si faccia ad
essere programmatori C/C++ e non si sappia usare un motore di ricerca), su
http://www.itee.uq.edu.au/~csmweb/decompilation/history.html
mentre il programma EXE2C lo l'ho trovato su
http://www.industrial.lv/oldschoolcrack/html/reverse.html
--


Semplicemente: Non esistono!
Ci credo molto poco nella sua utilita', ma ne esiste almeno
uno per il C :)
http://www.itee.uq.edu.au/~csmweb/dcc.html
dcc
The dcc decompiler decompiles .exe files from the (i386,
DOS) platform to C programs. The final C program contains
assembler code for any subroutines that are not possible to
be decompiled at a higher level than assembler. 
The analysis performed by dcc is based on traditional
compiler optimization techniques and graph theory. The
former is capable of eliminating registers and intermediate
instructions to reconstruct high-level statements; the later
is capable of determining the control structures in each
subroutine"
-- 
The Follet

 essere programmatori C/C++ e non si sappia usare un motore di ricerca)
trattandosi di un NG che riguarda il linguaggio C++ credo ritengo possa
essere considerato il luogo corretto in cui porre una domanda come la
mia.... certo che lo so usare un motore di ricerca, cosě come allora
dovrebbero saperlo usare tutti quelli che postano in questo NG.... ma non ho
mai visto nessuno rispondere che se si sapesse usare bene un motore di
ricerca si eviterebbe di postare sul NG....
postando sul NG inoltre speravo di ottenere informazioni dirette sull'uso di
questi strumenti difficilmente recuperabili dalla lettura di pagine web....


compiler optimization techniques and graph theory.
Probabilmente se un decompilatore fosse scritto appositamente per un
compilatore che si sa co ottimizza farebbe un lavoro migliore ma
comunque penso sempre molto distante dal codice C++ originale.


compilatore che si sa co ottimizza farebbe un lavoro migliore 
Difficile, anche in questo caso !
Come fai a sapere "come ottimizza" un compilatore ?
In altre parole, come fai a risalire dalla versione
ottimizzata di un codice alla sua versione non ottimizzata ?
;)
-- 
The Follet
 C`era  un  uomo che non riusciva  mai  a  terminare 
 le  cose che iniziava. Capi` che non poteva  andare 
 avanti cosi`. Percio` una mattina si alzo` e disse: 
 "Ho preso una decisione: d`ora in poi tutto  quello 
 che inizie..." 
                               Stefano Benni

ottimizzata di un codice alla sua versione non ottimizzata ?
Se sai però esattamente come funziona un compilatore è più semplice
cercare di avere un procedimento inverso, comunque è ovvio che anche
in questo caso il codice ottenuto sarà molto distante dall'originale.


 be decompiled at a higher level than assembler. "
Siccome ne io ne tu l'abbiamo visto all'opera, e non sappiamo nulla di come
decompili un programma medio/grande (e io non considero decompilatore un
programma
funzionante solo su esempi tipo il classico "Hello Word!"), non sappiamo
quanto sia grande la
portata della frase suddetta (quanto codice C non riconosce) ma possiamo
dire sicuramente
che, da quanto l'autore stesso dice in questa frase, che un decompilatore
per C non esiste.
--


 ottimizzata di un codice alla sua versione non ottimizzata ?
Marco probabilmente intendeva dire che come puoi leggere su
http://www.itee.uq.edu.au/~csmweb/decompilation/history.html
uno degli approcci storici alla decompilazione è stata proprio la
decompilazione orientata ad uno specifico compilatore. In questa maniera,
nelle intenzioni degli autori della ricerca, conoscendo in quali casi e come
uno specifico compilatore ottimizzava, poteva essere più semplice risalire
ad un codice più vicino a quello originale.
Comunque secondo me stiamo perdendo il senso della domanda originale. I
decompilatori esistono per alcuni linguaggi, tipicamente quelli che usano
pseudo-codice (p.e. per Java e Clipper). Per quelli che traducono
direttamente in codice binario, e per di più ottimizzano specificamente
(come il C/C++) cioè per linguaggi tipicamente di basso/medio livello,
questi decompilatori praticamente non esistono o comunque non producono
niente al di là di un prototipo del codice originale, solo vagamente
studiabile, e molto spesso neanche compilabile.
--


decompili un programma medio/grande
Su quella stessa pagina ci sono degli esempi di
decompilazione e mi sembra che si sia risaliti sino ad un
codice sorgente C abbastanza leggibile.
Su programmi medio/grandi non so come funzioni.


 comunque penso sempre molto distante dal codice C++ originale.
 
e' impossibile creare un decompilatore di codice C++, anche dal punto 
di vista teorico: come farebbe il decompilatore a ricavare i template?
ciao Anto
-- 
Antonio Cuni, 19 anni, studente
Brainbench C++ Master: 4.6, higher than 98% of all previous test takers.
C Language: 3.32, higher than 79% of all previous test takers.
Guida C/C++ di Programmazione.it: 
http://cpp.programmazione.it

di vista teorico: come farebbe il decompilatore a ricavare i template?
Per i template e' un altro discorso.
Formalmente un template non esiste a livello di codice da
compilare, perche' l'espansione di un template avviene prima
di compilare il sorgente, quindi (teoricamente) quello a cui
puoi arrivare, al massimo, e' il codice appena prima di
essere compilato.
-- 
The Follet

 essere compilato.
no, i template sono trattati dal compilatore e quindi dovrebbero essere 
trattati anche da un eventuale decompilatore.
I template non vengono "espansi" ma istanziati e l'istanziazione del 
template la fa il compilatore, non certo un preprocessore (come mi 
sembra di intuire dal tuo discorso).


sembra di intuire dal tuo discorso).
Bhé se un decompilatore riuscisse a riprodurmi il codice C++ originale
esclusi i template sarebbe già ottimo, il problema è che non riesce a
riprodurre anche cose molto più semplici.


sembra di intuire dal tuo discorso).
I template, non sono un esperto, quindi perdonerai la
poverta' dei termini, sempre che non abbia capito male, sono
dei modelli su cui si costruisce parte del codice sorgente.
E solo dopo che questa parte del codice sorgente e' stata
costruita si provvede alla generazione del codice oggetto.
Cio' a cui un decompilatore puo' arrivare e' il codice
sorgente appena prima che da esso si producesse il codice
oggetto.  Altre metafisiche trasformazioni sono impossibili.
-- 
The Follet

 sembra di intuire dal tuo discorso).
sicuro?
sono daccordo con te per il fatto che non e' nessun preprocessore a
utlizzare i template,
pero' penso che nel codice macchina non ci sia la benche' minima presenza
del template originario,
ma ci sia il codice delle varie istanziazioni...
quindi IMHO e' un po' duretta arrivare al template originario! :-)
--
Ciao by Allanon

 sembra di intuire dal tuo discorso).
La grossa differenza, in particolare per i template ma non solo, puo'
farla l'eventuale disponibilita' della symbol table dell'eseguibile,
cosa che sotto UNIX e simili e' relativamente comune.
In questo caso tramite demangling dovrebbe essere possibile ricostruire
i template abbastanza fedelmente. In assenza della symbol table si puo'
riuscire a ricostruire qualche cosa tramite tecniche euristiche, ma mi
pare difficile.
Ciao,
Nicola

 quindi IMHO e' un po' duretta arrivare al template originario! :-)
guarda che diciamo la stessa cosa... :-)
ciao anto


 oggetto.  Altre metafisiche trasformazioni sono impossibili.
no, la generazione del codice oggetto avviene contemporaneamente 
all'esame del sorgente.
Non credo proprio che ci sia un compilatore che fa 
copy-paste-search&replace per istanziare un template...
E cmq non basterebbe questo: pensa, ad esempio, alle specializzazioni 
dei template. A meno di non avere a disposizione la tabella dei 
simboli, come faceva notare Nicola, e' impossibile anche dal punto di 
vista teorico ricostruire il template originario con le proprie 
specializzazioni.


all'esame del sorgente.
Secondo me non e' cosi', ma di questo passo non andremo
molto oltre i "secondo me" (non credo che nessuno di noi
abbia mai scritto un compilatore C++).
Io sono del tutto convinto che ci siano operazioni
preliminari alla generazione del codice oggetto vero e
proprio e credo che una di queste operazioni sia creare le
istanze dei template.
Secondo, me, per fare un esempio, un compilatore, prima di
generare codice oggetto, trasformerebbe il seguente codice:
<CODE>
#include <iostream>
template <class T> class MyNumber
{
   T data;
public:
   MyNumber(T) ;
   void print();
};
template <class T> MyNumber<T>::MyNumber(T n)
{
   data = n;
};
void template <class T> MyNumber<T>::print()
{
    std::cout << data << std::endl;
}
int main()
{
    MyNumber<float> MyFloat(10.35);
    MyNumber<int> MyInt(45);
    MyFloat.print();
    MyInt.print();
    return 0;
}
</CODE>
in qualcosa del tipo (applicando il name mangling,
suppongo):
<CODE>
#include <iostream>
class MyNumber_int {
   int data;
public:
   MyNumber_int(int) ;
   void print();
};
MyNumber_int::MyNumber_int(int n)
{
   data = n;
};
void MyNumber_int::print()
{
    std::cout << data << std::endl;
}
class MyNumber_float {
   float data;
public:
   MyNumber_float(float) ;
   void print();
};
MyNumber_float::MyNumber_float(float n)
{
   data = n;
};
void MyNumber_float::print()
{
    std::cout << data << std::endl;
}
int main()
{
    MyNumber_float MyFloat(10.35);
    MyNumber_int MyInt(45);
    MyFloat.print();
    MyInt.print();
    char c;
    std::cin >> c;
    return 0;
}
</CODE>
...e solo dopo questa operazione genererebbe codice oggetto.
Quindi, secondo me, se un decompilatore fosse in grado di
riconoscere il metodo di decorazione dei nomi e ottenere i
nomi dei simboli originali, allora potrebbe arrivare a
generare il codice con le istanze dei template, ma non
oltre.
Come al solito, correggetemi se sbaglio...
-- 
The Follet

specializzazioni.
E' esattamente cio' che dico anch'io.
-- 
The Follet

 guarda che diciamo la stessa cosa... :-)
ehm, forse si capiva poco... :-)
o forse l'influenza mi fa sragionare... :-(
cmq direi che adesso con i post di Nicola
e The Follet le cose siano chiare x tutti!
--
Ciao by Allanon

 istanze dei template.
Non e' cosi', anzi ci sono compilatori che istanziano i template *dopo*
aver generato gli oggetti, attraverso un passo richiamato dal linker. 
Lo standard specifica l'ordine dei passi che compie il compilatore:
- sostituzione di eventuali caratteri fuori dal set di base
  (lettere, cifre e segni di interpunzione) e dei newline preceduti
  da backslash;
- suddivisione in  token di preproccessing ed eliminazione dei commenti;
- esecuzione delle direttive di preprocessing ed espansione delle macro;
- espansione delle sequenze di escape nelle stringhe e nei caratteri
  letterali e concatenazione delle stringhe adiacenti;
- Conversione in token: le manipolazioni di carattere testuale sono
  terminate!
- Analisi sintattica e semantica, e traduzione;
- Un'implementazione e' libera di generare le istanziazioni richieste
  durante la traduzione o dopo, ma e' certamente dopo che le invocazioni
  di template vengono risolte;
- linking.
Ciao,
Nicola