Existe um desmontador + depurador para java (ala OllyDbg / SoftICE para assembler)?

Existe um utilitário semelhante ao OllyDbg / SoftICE para java? Ou seja, executar class (do jar / com caminho de class) e, sem código-fonte, mostrar a desassembly do código intermediário com a capacidade de percorrer / pesquisar / pesquisar referências / editar código intermediário específico na memory / aplicar edição ao arquivo. .

Se não, é possível escrever algo assim (assumindo que estamos dispostos a viver sem hotspot para a duração do debug)?

Edit: Eu não estou falando de JAD ou JD ou Cavaj. Estes são bons decompiladores, mas eu não quero um descompilador por várias razões, o mais notável é que sua saída é incorreta (na melhor das hipóteses, às vezes simplesmente errada). Eu não estou procurando por um mágico “compilado bytes para código java” – Eu quero ver os bytes reais que estão prestes a ser executado. Além disso, gostaria de poder alterar esses bytes (como em um depurador de assembly) e, esperançosamente, gravar a parte alterada novamente no arquivo de class.

Edit2: Eu sei que o javap existe – mas faz apenas um caminho (e sem qualquer tipo de análise). Exemplo (código retirado da documentação vmspec): A partir do código java, usamos “javac” para compilar isso:

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

para um arquivo java .class. Usando o javap -c, posso obter esta saída:

  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 

Isso é bom para a parte de desassembly (não muito boa sem análise – “campo # 4 é Example.i”), mas não consigo encontrar as outras duas “ferramentas”:

  1. Um depurador que analisa as instruções em si (com pilha, despejos de memory, etc.), permitindo-me examinar o código e o ambiente reais.
  2. Uma maneira de reverter o processo – edite o código desmontado e recrie o arquivo .class (com o código editado).

Eu não acho que isso é realmente uma resposta completa, mas alguns indicadores que podem fornecer algo viável:

(1) Em termos de visualização e trabalho direto com bytecode, o antigo BCEL Class Construction Kit pode ser útil (é o único editor de GUI para o bytecode que eu conheço).

(2) Em termos de debugging e passagem pelo bytecode, esse plug-in do Eclipse , que se integra ao depurador do Eclipse, pode atender às suas necessidades.

Não tenho conhecimento de quaisquer utilitários que combinem esses resources e permitam manipular o bytecode enquanto o código está sendo executado (pelo menos da mesma maneira que você pode no OllyDbg, etc.). No entanto, a API do depurador Java deve ser capaz de suportar a manipulação do código em tempo de execução (embora, dada a natureza do HotSpot e do JIT em geral, não sei se seria possível rewrite uma instrução antes de ser invocada – – o código de operação bytecode atualmente em execução é realmente uma abstração de como o interpretador escolhe implementar o op, diferentemente do código nativo onde o opcode desmontado é, de fato, a instrução enviada para a CPU). Como alternativa, você poderia examinar a API de Instrumentação Java, que fornece uma maneira de redefinir o código de bytes no tempo de execução. E, é claro, qualquer uma das várias bibliotecas de manipulação de códigos de código aberto pode ajudar ou fornecer inspiração.

E, claro, há sempre a opção de contornar toda a infraestrutura da JVM e simplesmente append um depurador ao processo da JVM. Há alguma discussão sobre isso nesta questão e nesta página ligada a essa pergunta .

A linha inferior, no entanto, é que o que você parece estar tentando realizar, enquanto lugar-comum no mundo do código nativo, não é uma prática tão comum no mundo Java (parte da razão para usar o Java é a abstração de todos os detalhes sangrentos). Isso, e a natureza relativamente trivial da descompilation de código de bytes (comparada com, digamos, C ++) levou a uma situação em que esse tipo de requisito é escasso e esse é o tipo de ferramenta.

Dê uma olhada no JAD Decomplier para descompilar o código Java. Em seguida, você pode executar o depurador interno de um IDE usando fonts produzidas. IDE pode ser IntelliJ, Eclipse ou NetBeans. Essa abordagem não é totalmente automática, mas deve fazer o trabalho.