Newsgroup: it.comp.lang.c
Titolo: decompilatore

Buongiorno a tutti gente......volevo chiedervi se qualcuno può darmi il link
di un decompilatore.....nn molto difficile da usare  :)
Grazie 1000

Decompilatore come Windasm32 o come WinIce?
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 ha scritto nel messaggio
news:e1fbc5116f06c05eda8...@mygate.mailgate.org...


 
Decompilatori facili da utilizzare non credo ne esistano, se non altro
per la difficolta' di dare nomi sensati alle variabili, per il fatto
che un certo risultato puo' essere ottenuto in piu' modi e per il fatto
che ultimamente c'e' la simpatica abitudine di comprimere e criptare
gli eseguibili (o almeno una certa classe di eseguibili).
Il migliore (a detta di chi lo conosce) e' IDA ma, oltre ad essere a
pagamento, non credo sia tanto frendly.
http://www.datarescue.com/idabase/ida.htm
In parole povere, scordati di risalire al sorgente (in maniera facile)
a partire dall'eseguibile.
HTH
C:\>iao Angelo


 penso di si...ma decompilano in linguaggio C...???
Dunque.. durante il processo di compilazione tutte le direttive di
preprocessore vengono espanse, i nomi di variabili vengono persi, a volte
anche i nomi delle funzioni, per ottimizzare le prestazioni in genere il
compilatore snellisce e rimodella il codice a suo piacimento, esistono
decine di modi diversi di compilare un semplice ciclo while.. e che cosa
dovrebbe tirarti fuori mai questo fantomatico decompilatore ?
L'unico decompilatore che esiste č un deassemblatore; ogni altro software
che si spaccia per decompilatore C tira fuori un risultato che č cosě
vicino all'assembly che diventa piů semplice analizzare il sorgente
assembly direttamente.
Ciau

Mmm...se il tuo scopo è quello di "capire" un codice eseguibile(il cosidetto
reverse engeniering), il decompilatore serve a ben poco.
Dovresti, studiare invece la relazione tra codice assembly, il quale può
essere ottenuto con dei semplici tool,e il  corrispondente codice C.
Vi è una relazione :  perchè il compilatore segue delle regole per tradurre
un sorgente in un oggetto-eseguibile.
Mi spiego meglio con un esempio tratto dal libro Computer System di Bryant &
O'Hallaron.
Supponiamo di avere nel file raf.c la seguente cosa :
1    int accum =0;
2
3     int sum(int x,int y)     {
4
5    int t = x + y;
6    accum += t;
7    return t;
8    }
compiliamo sotto unix con il seguente comando :
gcc -O2 -c code code.c
Verrà generato un file oggetto : code.o , esso avrà questa sequenza di byte
:
corrispondenti alle instruzioni macchina(moltoo semplici) per eseguire il
codice raf.c ;
essendo incomprensibile il formato binario si usa (sempre) l'assembly(dà una
forma "testuale" al codice macchina),
per riportare il codice oggetto in un codice assembly si usano i
disassemblatori(objdump oppure gdb);
objdump -d code.o
il risultato è :
Disassembly of function sum in file code.o
1 00000000 <sum>:
    Offset     Bytes                 Equivalent assembly language
2     0:         55                     push %ebp
3     1:         89 e5                  mov %esp,%ebp
4     3:         8b 45 0c               mov 0xc(%ebp),%eax
5     6:         03 45 08               add 0x8(%ebp),%eax
6     9:         01 05 00 00 00 00      add %eax,0x0
7     f:         89 ec                  mov %ebp,%esp
8     11:        5d                     pop %ebp
9     12:        c3                     ret
10    13:        90                     nop
che è <<quasi>> (su questo "quasi"; ci vorrebbero mesi per spiegarlo) uguale
al codice assembly originario(non quello disassemblato) :
ottenuto da questo comando
gcc -O2 -S code.c
mi dà il codice assembly code.s(attenzione viene usata la SINTASSI DEL
GAS..non quella dell'intel)
sum:
    pushl %ebp                 stack set-up
    movl %esp,%ebp             stack set -up
    movl 12(%ebp),%eax         Get y
    addl 8(%ebp),%eax          t= x+y
    addl %eax,accum            accum+=accum + x;
    movl %ebp,%esp            stack finish
    popl %ebp                stack finish
    ret                        ritorna funzione
cerchiamo di spiegare semplicemente questo codice :
tralasciamo le prime 2 operazioni e le ultime 2 (riguardano lo stack...),
la 3° operazione copia il parametro formale y nel registro %eax
la 4° addizziona i due parametri formali x e y e lo mette il risultato nel
registro %eax
la 5° addizziona t con il contenuto della memoria
all'indirizzo --accum --(label)
il registro %eax è per convenzione il registro dove si mette il contenuto
del valore di ritorno della funzione
Spero di aver risposto in parte alla tua curiosità......
ah Appello per tutti :
Esistono persone che vogliono capire l'assembly ?
---capire non SCRIVERLO..
esistono newsgroup a tale riguardo?

 penso di si...ma decompilano in linguaggio C...???
Trovare in giro un decompilatore exe -> C/C++ e' una cosa virtualmente
impossibile per due semplici ragioni:
 1) il codice assembly creato dai compilatori dipendono (in parte a
volte) dal processore su cui/dal quale avviene la compilazione
 2) e' discretamente difficile (per i motivi che alcuni hanno gia'
spiegato in questo thread) e quindi nessuno mai si metterebbe a scrivere
un programma ad hoc. Ovviamente si potrebbe e si puo' fare, ma quello
che ne viene fuori e' un codice che, comparato al semplice assebly
secondo me sarebbe molto piu' incomprensibile!
L'unica cosa che puoi fare con semplicita' e relativa sicurezza che la
decompilazione e' andata "a buon fine" e' quella di ottenere il codice
assembly.. e studiarti quello.
Tra l'altro, poiche' le persone che realizzano software a volte non sono
stupide, puoi trovare - insito nel codice exe - delle parti che servono
per "ingannare" dei decompilatori (tipo cicli infiniti che in realta'
non verranno mai eseguiti ma che mandano in tilt alcuni decompilatori,
tipo istruzioni non lecite e cosi' via).
Trattazione a parte meritano i debugger (come WinIce). Qui esistono
altre tecniche per impedire il debug - ma sarebbe troppo lungo e non
inerente al post spiegarlo qui.
NB: l'unico linguaggio che so che si puo' decompilare risalendo al
codice sorgente e' Java! e questo dice tutto..


 codice sorgente e' Java! e questo dice tutto..
In realta` anche il Python. Suppongo quindi anche Perl (ma qui non sono
sicuro).
-- 
RiK0
[ non credo negli schemi non vincenti ]
[     two is an odd prime number.     ]

Ho scaricato Ida, il programma x disassemblare....ho provato a disassemblare
un programmino (stupido fra l'altro che stampava solo una scritta con
printf!!!!!!) e nn ci ho capito niente!!!!
Cavolo...era un casino!!!
mi piacerebbe tanto capire che cosa significano ttt quelle cose....ma forseè
meglio che mi ridedichi a scrivere programmi che a disassemblarli....


In effetti la tua ultima idea mi sembra la piu' brillante. In ogni caso 
perche' volevi disassemblarli?
Come ultima nota: per capire quello che leggi, ti basta seguire qualche 
corso di assembly (IA32, immagino).
-- 
Mat/tia Belletti - Undergraduate student @ 
cs.unibo.it
ICQ: 33292311    - email: 
mbel...@cs.unibo.it
IRC: RedGlow     - site(s): 
http://mbellett.web.cs.unibo.it/
Jabber: RedGlow  - Linux registered user 299762 @ machine 213003

 meglio che mi ridedichi a scrivere programmi che a disassemblarli....
Mai disperarsi alla prima difficolta' che si incontra!! se non capisci
una cosa affrontala e vincila! magari ci vorranno mesi, magari anni per
capire a fondo, ma alla fine potrai dire: ce l'ho fatta!
Ti consiglio di riprovarci, anche perche' capire come il compilatore
crea il codice macchina aiuta molto ad ottimizzare il codice ad alto
livello che si vuole scrivere. Oltre ad essere un 'must' se vuoi
scrivere programmi veramente real-time...
E' un po' come leggere il dna delle persone e cercare di capire come
sono fatte.
E' un po' come leggere direttamente il codice di Matrix e capire come va
il mondo in cui viviamo.
E' un po' come penetrare al di sotto delle particelle elementari e
accorgersi che non e' la materia,ma qualcos'altro.
E' un po' come...
:)


 sicuro).
Ma il Python non e' simile, come linguaggio, al C++? mi stupisco che non
si crei direttamente un eseguibile ma un compilato da interpretare...
Forse e' la versione portabile di C++? una sorta di cugino di Java?


 ---capire non SCRIVERLO..
Esistono persone che scrivono DIRETTAMENTE in Assembly...


 ha scritto nel messaggio
news:931e186210899bac99e...@mygate.mailgate.org...


 Forse e' la versione portabile di C++? una sorta di cugino di Java?
F/UP su ng appropriato.
No. Python non e` simile al C++, a meno che non definisci la
similitudine con 'linguaggio orientato agli oggetti'. Sono entrambi
orientati agli oggetti ed entrambi supportano l'ereditarieta` multipla.
Python in buona sostanza genera un bytecode. C++ e` compilato per una
specifica macchina. Il bytecode e` portabile. Comunque per quanto ho
visto io si danno direttamente i files che si fa prima.
Python puo` anche subire cose ulteriori tipo py2exe, ma e` altro. Non
sono informatissimo, non mi interessa.
C++ e` portabile e` fatto apposta. Pero` la scelta progettuale e`
sostanzialmente di tagliare quello che non e` portabile. In pratica il
Python ha una libreria standard che fa molte piu` cose di quella del C++
(per esempio ha dentro moduli per gestire filesystem, espressioni
regolari, threads e chi piu` ne ha piu` ne metta). Python e` chiaramente
portabile.
Non e` nemmeno cugino di Java. Anche perche` non capisco cosa voglia
dire che un linguaggio e` cugino di un altro linguaggio.
-- 
RiK0
Non credo negli schemi non vincenti.

 Esistono persone che scrivono DIRETTAMENTE in Assembly...
Di masochisti e' pieno il mondo, per carita'...
Non sto dicendo che sia inutile l'assembly, tutt'altro. Pero', gli 
ambiti sono ristretti a:
- motivo didattico. Avere una _infarinatura_ del linguaggio, delle 
convenzioni di chiamata, e magari anche di particolari avanzati come 
costrutti atomici a' la' test-and-swap (utili per costruire costrutti di 
concorrenza in sistemi SMP) e' senz'altro una cosa buona e giusta, per 
ogni informatico che si rispetti.
- progettazione a basso livello. Anch'io mi sono trovato a scrivere 
assembly, ma l'unica volta in cui mi e' stato utile e' per la parte 
iniziale del mio progetto di sistemi operativi (... ok, anche per la 
tesi che sto finendo di scrivere ora, in cui lo sto martoriando quel 
povero microkernel ;P). Non ho mai dovuto tirar fuori fino all'ultimo 
ciclo di processore di un sistema embedded, quindi non posso dire, ma in 
genere con il C si puo' creare codice _molto_ efficiente, sapendo come 
mettere le mani. Il che puo' sicuramente includere il punto precedente...
D'altronde, per il primo punto, esistono un fantabilione di lucidi di 
corsi di assembly che si trovano online cercando un po'. Per il 
secondo... ammettiamolo, e' abbastanza raro :)


 Di masochisti e' pieno il mondo, per carita'...
Ne' motivi didattici ne' progettazione a basso libello, io scrivo in
assembly quando voglio codice veramente efficiente e soprattutto corto.
Della serie che non serve a nulla installare 500+ mega per una
applicazione come Word (che ha dentro anche cose inutili tipo Quake)
quando se lo fai in assembly ti occupa meno di un decimo. Poi,
ovviamente, sono scelte che uno fa: per programmi grossi e' ovvio usare
linguaggi piu' ad alto livello (senno' ti spari).
L'assembly lo uso - quando non il C++ - per fare cose molto carine come
creare finestre, bottoni, liste, etc etc in meno di 10K... oltre a
decompilare & "modificare" programmi e altre cose... :p
Di masochisti e' pieno il mondo, e' vero!


ASM puro (e altra roba che non mi ricordo):
http://oopweb.com/Assembly/Documents/ArtOfAssembly/Volume/toc.html
http://www.azillionmonkeys.com/qed/asmexample.html
http://vx.netlux.org/lib.shtml
http://z0mbie.host.sk
http://29a.host.sk
Win32:
http://www.win32asm.cjb.net
http://win32assembly.online.fr
... e altri in giro per il web (ce ne sono una valangata! basta cercare
su Gooooooooooogle o un motore analogo)
Se ti serve qualche chiarimento o altri indirizzi non esitare, io sono
"sempre" qui. :)


 Decompilatore come Windasm32 o come WinIce?
Mi correggo, scusate, non e' WinIce, bensi' SoftIce!
I beg pardon (^_^)\


 dire che un linguaggio e` cugino di un altro linguaggio.
Parente... sempre in merito alla spiegazione di cui sopra. C++ e Java
non sono proprio uguali e, sinceramente, preferisco il C++. L'unica cosa
degna di nota che mi viene in mente adesso e' la gestione dei file in
Java che credo sia fatta veramente bene, anche se troppo incapsulata a
volte...


 volte...
Anche io preferisco il C++ a Java. Ritengo il C++ un buon linguaggio
tutto sommato, anche se spesso mi chiedo se non ci fossero stati dei
modi piu` 'facili' di far fare le cose. 
Ci sono anche alcune piccole sovrapposizioni... ma vabbe` :))
Complessivamente C++ ha tante cose carine. E` comodo (specie per
sviluppare a medio basso livello, dal mio punto di vista).
E cosa intendi per 'la gestione dei file di Java'. Cosa ha quella del
C++ che non va bene. Gli streams sinceramente a me piacciono molto.


 Cosa ha quella del C++ che non va bene. Gli streams sinceramente a me piacciono molto.
Assolutamente niente! ho solo detto che preferisco leggermente di piu'
quelli di Java.
