jar analyzer v1 gui

Arquivo

JAR Analyzer v2: https://github.com/jar-analyzer/jar-analyzer

Analisador JAR

Observação

Este projeto não é mais mantido

Recomenda-se usar a nova versão Jar Analyzer V2 https://github.com/jar-analyzer/jar-analyzer

Versão da linha de comando jar-analisador

Versão da CLI do Jar-Analyzer

introduzir

Uma breve introdução: https://mp.weixin.qq.com/s/rrx6x5m_28yrcqqcdxueeq

Não há documento em inglês, os estrangeiros, por favor, traduza você mesmo

Uma ferramenta GUI para analisar pacotes jar , especialmente adequados para auditorias de segurança de código. Vários arquivos jar podem ser analisados ​​ao mesmo tempo, e o método de destino pode ser facilmente pesquisado. Suporta decompilar o bytecode e construir automaticamente as relações entre classes e métodos para ajudar os pesquisadores de segurança da Java a trabalhar com mais eficiência.

NOTA: Não analise pacotes Jar muito grandes ou demais, é recomendável não exceder 300M

Vá para o download

Pode localizar com precisão o método (destacado à esquerda)

Você pode localizar diretamente strings (analisar instruções relacionadas ao pool constante para obter posicionamento preciso)

Pode analisar diretamente os projetos escritos pela Spring Framework

Por que não escolher análise IDEA : porque IDEA não suporta a análise de pacotes de jar de código passivo

Suporta seis métodos de pesquisa:

• Pesquise diretamente com base no nome da classe e do método (definição de pesquisa)
• Pesquisa com base na chamada do método (onde o método é chamado)
• Strings de pesquisa (Analise as instruções LDC para encontrar o local exato)
• String de pesquisa regular (analise LDC para encontrar o local exato)
• Pesquisa sem cérebro (analise as instruções relevantes para encontrar a localização exata)
• Pesquisa binária (pesquisando diretamente do binário)

Suporta a seleção de três métodos de decomposição:

• Quiltflower (variante Fernflower, método recomendado)
• Procyon
• Cfr

Use a personalização da classe de componentes JSyntaxPane (não oficial) para mostrar o código Java

(Muita tecnologia negra é adicionada à biblioteca https://code.google.com/archive/p/jsyntaxpane )

Pesquisa de expressão

Suporta uma pesquisa de expressão super forte, que pode ser combinada como você deseja procurar informações que você deseja

expressão	parâmetro	efeito
NameContains	Corda	O nome do método contém
Startwith	Corda	Prefixo do método
ENDWITH	Corda	Sufixo do método
Classnamecontains	Corda	O nome da classe contém
ReturnType	Corda	Tipo de retorno do método
ParamtyPemap	Int String	Correspondência do parâmetro do método
paramsnum	int	Número de parâmetros de métodos
isstatic	booleano	O método é estático?
ISSUBCLASLOF	Corda	Cuja subclasse é
Issuperclassof	Corda	Cuja classe pai é essa
Hasanno	Corda	Anotação do método
Hasclassanno	Corda	Anotação de classe
Hasfield	Corda	Campos de classe

Perceber:

• returnType e paramTypeMap requerem nomes de classe completos semelhantes, como java.lang.String , e escreva o tipo básico diretamente, por exemplo, int
• isSubClassOf e isSuperClassOf requerem nomes de classe completos, como java.awt.Component
• hasAnno e hasClassAnno não exigem o nome completo da classe, apenas escreva -o diretamente, por exemplo, Controller

1. Pesquisa básica

A base da pesquisa é o método, qual método você deseja procurar

Por exemplo, quero que o método de pesquisa comece com set e termine com value

# method
        . startWith ( "set" )
        . endWith ( "value" )

Por exemplo, eu quero procurar métodos cujo nome de classe contém Context e nome do método contém lookup

# method
        . nameContains ( "lookup" )
        . classNameContains ( "Context" )

Por exemplo, quero procurar um método que retorne um total de 3 parâmetros do tipo de Process e o segundo parâmetro é String

# method
        . returnType ( "java.lang.Process" )
        . paramsNum ( 3 )
        . paramTypeMap ( 1 , "java.lang.String" )

2. Subclasse e classe pai

Por exemplo, queremos encontrar todas as subclasses de javax.naming.spi.ObjectFactory (incluindo subclasses de subclasses, etc.)

Basta escrever as seguintes regras e o programa procurará recursivamente todas as classes dos pais

# method
        . isSubClassOf ( "javax.naming.spi.ObjectFactory" )

Se você deseja encontrar todas as classes dos pais de uma determinada classe, basta usar isSuperClassOf (observe o nome da classe completa)

Observe que o exposto acima encontrará diretamente todos os métodos que atendem aos critérios, por isso sugiro adicionar alguma filtragem

Por exemplo

# method
        . isSubClassOf ( "javax.naming.spi.ObjectFactory" )
        . startWith ( "xxx" )
        . paramsNum ( 0 )

3. Pesquisa de anotação

Por exemplo, queremos encontrar todos os métodos de todas as classes anotadas por @Controller

Escreva as seguintes regras

# method
        . hasClassAnno ( "Controller" )

Por exemplo, quero encontrar todos os métodos de anotação @RequestMapping

# method
        . hasAnno ( "RequestMapping" )

Da mesma forma, como todos os métodos que atendem à aula de critérios são encontrados, sugiro adicionar um pouco mais de filtragem

4. Análise prática

De acordo com as condições Swing RCE fornecidas pelo mestre on -line:

• Deve haver um método definido
• O método de conjunto deve ter apenas um parâmetro
• Este parâmetro deve ser do tipo de string
• Esta classe deve ser Component (incluindo subclasses indiretas)

Então, escrevemos uma regra

# method
        . startWith ( "set" )
        . paramsNum ( 1 )
        . paramTypeMap ( 0 , "java.lang.String" )
        . isSubClassOf ( "java.awt.Component" )

Resultados da pesquisa

Início rápido

IMPORTANTE: Por favor, use Java 8+ para executar (11 versão recomendada e EXE do Java 11 JRE é fornecido)

(Uma fonte melhor foi usada no Java 11 , outras versões usam fontes padrão)

(1) Etapa 1: Adicione o arquivo jar (suporta o arquivo jar único e o diretório jar )

• Clique no botão Select Jar File para abrir o arquivo JAR
• Apoie o upload de vários arquivos de jar e análise juntos

Por favor, não se preocupe, leva um pouco de tempo para analisar o arquivo jar

Nota: Aguarde até que a barra de progresso esteja cheia e a análise seja concluída.

(2) Etapa 2: insira as informações que você pesquisou

Apoiamos a entrada em três formatos:

• javax.naming.Context (por exemplo)
• javax/naming/Context
• Context (procurará todas as aulas *.Context )

Fornece uma maneira de entrar rapidamente

Nota: O conteúdo comum de pesquisa aqui pode ser personalizado para suplementos

Crie um novo arquivo search.txt no diretório atual, divida o nome e o método da classe um por um com # , por exemplo

 java.lang.Runtime#getRuntime
java.lang.String#equals

A pesquisa binária retornará apenas se existe ou não, e não retornará informações específicas.

(3) Etapa 3: você pode clicar duas vezes para descompilar

O cursor apontará exatamente para a localização da chamada do método

Durante a descomposição, a relação entre métodos será construída

Você pode clicar duas vezes em qualquer lugar do painel para descompilar e criar novos relacionamentos e apresentações de chamadas de método

Observação: se você encontrar uma situação em que não pode descompilar, precisará carregar o arquivo jar correto

Por exemplo, não posso descompilar javax.naming.Context porque não entrei no arquivo rt.jar , se você se juntar a ele, ele pode ser descompilado normalmente

Você pode usar Ctrl+F para procurar código e editar

Você pode clicar em qualquer opção e os detalhes do método serão exibidos em seguida

Você pode clicar com o botão direito do mouse para enviar a opção para a cadeia. Você pode entender um link como favorito ou disco. Na cadeia, você também pode clicar duas vezes no descompile e, em seguida, exibir o novo relacionamento de chamada de método ou exibir os detalhes de forma independente. Se uma opção na cadeia é algo que você não deseja, clique com o botão direito do mouse para excluir a opção da cadeia

Portanto, você pode construir uma cadeia de chamadas que pertence apenas a você

谁调用了当前方法e当前方法调用了谁todo o método em que a relação entre o método também pode ser descompilada, clique para ver os detalhes, clique com o botão direito do mouse para ingressar na cadeia

Você pode ver o código de byte da classe atual com um clique

sobre

(1) Qual é a relação entre métodos

 class Test {
    void a (){
        new Test (). b ();
    }
    
    void b (){
        Test . c ();
    }
    
    static void c (){
        // code
    }
}

Se o método atual for b

Quem chamou o método atual: o método da classe Test a

Quem está chamando o método atual: Método da classe c Test

(2) Como resolver o problema da implementação da interface

 class Demo {
    void demo (){
        new Test (). test ();
    }
}

interface Test {
    void test ();
}

class Test1Impl implements Test {
    @ Override
    public void test () {
        // code
    }
}

class Test2Impl implements Test {
    @ Override
    public void test () {
        // code
    }
}

Agora, temos Demo.demo -> Test.test , mas na verdade é Demo.demo -> TestImpl.test .

Por isso, adicionamos novas regras: Test.test -> Test1Impl.test e Test.test -> Test2Impl.test .

Primeiro, verifique se os dados não estão perdidos, então podemos analisar manualmente o código decompilado por nós mesmos

• Demo.demo -> Test.test
• Test.test -> Test1Impl.test / Test.test -> Test2Impl.test

(3) Como resolver o relacionamento de herança

 class Zoo {
    void run (){
        Animal dog = new Dog ();
        dog . eat ();
    }
}

class Animal {
    void eat () {
        // code
    }
}

class Dog extends Animal {
    @ Override
    void eat () {
        // code
    }
}

class Cat extends Animal {
    @ Override
    void eat () {
        // code
    }
}

Zoo.run -> dog.cat é INVOKEVIRTUAL Animal.eat ()V , mas só temos essa regra Zoo.run -> Animal.eat , e Zoo.run -> Dog.eat regra está faltando

Nesse caso, adicionamos novas regras: Animal.eat -> Dog.eat e Animal.eat -> Cat.eat

Primeiro, verifique se os dados não estão perdidos, então podemos analisar manualmente o código decompilado por nós mesmos

• Zoo.run -> Animal.eat
• Animal.eat -> Dog.eat / Animal.eat -> Cat.eat

Obrigado

Este projeto é desenvolvido usando a idéia de jetbrains. Agradecemos ao JetBrains por me fornecer uma licença gratuita, o que é um forte apoio para mim.