Esiste un disassembler + debugger per Java (ala OllyDbg / SoftICE per assembler)?

Question

C'è un programma di utilità simile a OllyDbg / SoftICE per Java? Cioè esecuzione di classe (dal vaso / con il percorso di classe) e, senza codice sorgente, mostrare lo smontaggio del codice intermedio con la possibilità di passare in rassegna / scavalcare / ricerca di riferimenti / modificare codice intermedio specifico in memoria / apply modifica di file ...

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

Edit: io non sto parlando di JAD o JD o Cavaj. Questi sono decompilatori bene, ma io non voglio un decompilatore per diversi motivi, più notevole è che la loro produzione non è corretta (nella migliore delle ipotesi, a volte semplicemente sbagliato). Io non sto cercando un magici "byte compilato in codice Java" - Voglio vedere i byte reali che sono in procinto di essere giustiziato. Inoltre, mi piacerebbe la possibilità di modificare tali byte (proprio come in un debugger di montaggio) e, si spera, scrivere la parte cambiato di nuovo al file di classe.

Edit2: So che esiste javap - 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

Questa è OK 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 pila, dump di memoria, ecc), che mi permette di esaminare il codice vero e proprio e l'ambiente.
2. Un modo per invertire il processo - 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 a lavorare con il vecchio bytecode BCEL Classe Construction Kit può essere utile (è l'unico editor GUI per bytecode io sappia).

(2) In termini di debug e passando attraverso il bytecode, questo plugin Eclipse , che si integra con il debugger di Eclipse possono soddisfare le vostre esigenze.

Io non sono a conoscenza di programmi di utilità che unisse queste caratteristiche e consentono di manipolare bytecode durante l'esecuzione del codice (almeno nello stesso modo si può in OllyDbg, etc.). Tuttavia, il Java debugger API dovrebbe essere in grado di supportare la manipolazione del codice in fase di esecuzione (anche se, data la natura di HotSpot e JIT, in generale, non so se sarebbe stato possibile riscrivere un'istruzione appena prima che viene richiamato --- attualmente in esecuzione bytecode codice operativo è davvero un'astrazione per come l'interprete sceglie di implementare l'op, a differenza di codice nativo in cui il codice operativo smontato è, infatti, l'istruzione ha inviato alla CPU). In alternativa, si potrebbe esaminare la Strumentazione API che fornisce un modo per ridefinire codice byte in fase di esecuzione. E, naturalmente, qualsiasi delle varie librerie open source di manipolazione bytecode può essere in grado di aiutare o fornire ispirazione.

E, naturalmente, c'è sempre la possibilità di eludere l'intera infrastruttura JVM e semplicemente collegare un debugger al processo JVM. C'è qualche discussione di questo in questa domanda e su questa pagina collegata da quella domanda .

La linea di fondo, tuttavia, è che quello che ti sembra di essere cercando di realizzare, mentre il luogo comune nel mondo del codice nativo, non è poi così comune una pratica nel mondo Java (parte della ragione per l'utilizzo Java è l'astrazione da tutti i dettagli scabrosi). Questo, e la natura relativamente banale di codice byte decompilazione (rispetto, ad esempio C ++) ha portato ad una situazione in cui questo tipo di requisito è scarsa e quindi è questo tipo di utensili.

Answer 2

Date un'occhiata a JAD Decomplier per decompilazione del codice Java. È quindi possibile eseguire debugger integrato di un IDE utilizzando fonti prodotte. IDE può essere IntelliJ, Eclipse o NetBeans. Questo approccio non è completamente automatico, ma dovrebbe fare il lavoro.