C'è un disassemblatore + debugger per java (ala OllyDbg/SoftICE per l'assemblatore)?

Question

Esiste un'utilità simile a OllyDbg/SoftICE per java? Cioè esegui classe (da jar/con percorso classe) e, senza codice sorgente, mostra lo smontaggio del codice intermedio con possibilità di scorrere/passare sopra/cercare riferimenti/modificare codice intermedio specifico in memoria/applicare modifica a file ...

In caso contrario, è anche possibile scrivere qualcosa di simile (supponendo che siamo disposti a vivere senza hotspot per la durata del debug)?

Modifica: Non sto parlando di JAD o JD o Cavaj. Questi sono buoni decompilatori, ma non voglio un decompilatore per diversi motivi, il più notevole è che il loro output non è corretto (nella migliore delle ipotesi, a volte è semplicemente sbagliato). Non sto cercando un magico "byte compilato al codice java" - Voglio vedere i byte effettivi che stanno per essere eseguiti. Inoltre, mi piacerebbe poter modificare quei byte (proprio come in un assembly debugger) e, si spera, riportare la parte modificata al file di classe.

Edit2: So che javap esiste, ma lo fa solo in un modo (e senza alcun tipo di analisi). Esempio (codice preso dalla documentazione vmspec): da codice Java, usiamo "javac" per compilare questo:

void setIt(int value) { 
    i = value; 
} 
int getIt() { 
    return i; 
} 

in un file Java .class. Utilizzando javap -c posso ottenere questo output:

Method void setIt(int) 
    0 aload_0 
    1 iload_1 
    2 putfield #4 
    5 return 
    Method int getIt() 
    0 aload_0 
    1 getfield #4 
    4 ireturn 

Questo va bene per la parte di smontaggio (non proprio bene senza analisi - "campo # 4 è Example.i"), ma non riesco a trovare i due altri "strumenti":

1. Un debugger che va oltre le istruzioni stessi (con una pila, dump di memoria, ecc), che mi permette di esaminare il codice vero e proprio e l'ambiente.
2. Un modo per invertire la procedura: modificare il codice smontato e ricreare il file .class (con il codice modificato).

Answer 1

non credo che questo è davvero una risposta completa, ma alcune indicazioni che possono fornire qualcosa di praticabile:

(1) In termini di visione e direttamente lavorando con bytecode il vecchio BCEL Class Construction Kit può essere utile (è la Sono a conoscenza solo dell'editor GUI per bytecode).

(2) In termini di debug e passaggio attraverso il bytecode, this Eclipse plugin, che si integra con il debugger di Eclipse, è possibile soddisfare le proprie esigenze.

Non sono a conoscenza di utilità che combinano queste funzionalità e consentono di manipolare il bytecode mentre il codice viene eseguito (almeno nello stesso modo in OllyDbg, ecc.). Tuttavia, Java debugger API dovrebbe essere in grado di supportare la manipolazione del codice in fase di esecuzione (sebbene, data la natura di HotSpot e JIT in generale, non so se sarebbe possibile riscrivere un'istruzione prima che sia invocata --- l'opcode bytecode attualmente in esecuzione è in realtà un'astrazione per come l'interprete sceglie di implementare l'op, diversamente dal codice nativo in cui l'opcode disassemblato è, di fatto, l'istruzione inviata alla CPU). In alternativa, è possibile esaminare Java Instrumentation API, che fornisce un modo per ridefinire il codice byte in fase di esecuzione.E, naturalmente, any of the various open source bytecode manipulation libraries potrebbe essere in grado di aiutare o fornire ispirazione.

E, naturalmente, c'è sempre la possibilità di aggirare l'intera infrastruttura JVM e semplicemente allegare un debugger al processo JVM. C'è qualche discussione su questo in this question e su this page linked from that question.

La linea di fondo, tuttavia, è che ciò che si cerca di ottenere, mentre è comune nel mondo del codice nativo, non è una pratica comune nel mondo Java (parte della ragione per cui usare Java è astrazione da tutti i dettagli cruenti). Questo, e la natura relativamente banale della decompilazione del codice byte (rispetto a, per esempio, C++) ha portato a una situazione in cui questo tipo di requisito è scarso e così è questo tipo di strumenti.

Answer 2

Dai uno sguardo allo JAD Decomplier per la decompilazione del codice Java. È quindi possibile eseguire un debugger integrato di un IDE utilizzando le origini prodotte. IDE può essere IntelliJ, Eclipse o NetBeans. Questo approccio non è completamente automatico, ma dovrebbe fare il lavoro.