Descarga de jar analyzer v1 gui - Descargar el código fuente jar analyzer v1 gui

jar analyzer v1 gui

Otras categorias

1.1

Descargar

Archivo

Jar Analyzer V2: https://github.com/jar-analyzer/jar-analyzer

Analizador de jarra

Nota

Este proyecto ya no se mantiene

Se recomienda utilizar la nueva versión Jar Analyzer V2 https://github.com/jar-analyzer/jar-analyzer

Versión de línea de comandos jar-analyzer

Versión de Jar-Analyzer CLI

introducir

Una breve introducción: https://mp.weixin.qq.com/s/rrx6x5m_28yrcqqcdxueeq

No hay documento en inglés, extranjeros, por favor, traduzca usted mismo

Una herramienta GUI para analizar paquetes jar , especialmente adecuado para auditorías de seguridad de código. Se pueden analizar varios archivos jar al mismo tiempo, y el método de destino se puede buscar fácilmente. Admite la descomposición de bytecode y construye automáticamente las relaciones entre clases y métodos para ayudar a los investigadores de seguridad de Java a trabajar de manera más eficiente.

Nota: No analice demasiado grandes o demasiados paquetes Jar , se recomienda no exceder 300M

Ir a descargar

Puede localizar con precisión el método (resaltado a la izquierda)

Puede ubicar directamente las cadenas (analizar instrucciones relacionadas con el grupo constante para lograr un posicionamiento preciso)

Puede analizar directamente los proyectos escritos por Spring Framework

¿Por qué no elegir el análisis IDEA ? Porque IDEA no admite el análisis de los paquetes JAR de código pasivo

Admite seis métodos de búsqueda:

Buscar directamente en función de la clase y el nombre del método (definición de búsqueda)
Búsqueda basada en la llamada del método (donde se llama el método)
Cadenas de búsqueda (analizar instrucciones LDC para encontrar la ubicación exacta)
Cadena de búsqueda regular (analice LDC para encontrar la ubicación exacta)
Búsqueda sin cerebro (analizar instrucciones relevantes para encontrar la ubicación exacta)
Búsqueda binaria (buscando directamente desde binario)

Admite la selección de tres métodos de descompilación:

Quiltflower (variante de Fernflower, método recomendado)
Procyon
CFR

Use la personalización de clase de componentes JSyntaxPane (no oficiales) para mostrar el código Java

(Se agrega mucha tecnología negra a la biblioteca https://code.google.com/archive/p/jsyntaxpane )

Búsqueda de expresiones

Admite una búsqueda de expresión súper fuerte, que se puede combinar a medida que desea buscar información que desee

expresión	parámetro	efecto
namecontains	Cadena	El nombre del método contiene
inicial	Cadena	Prefijo de método
fin	Cadena	Método sufijo
Classnamecontains	Cadena	El nombre de la clase contiene
returntype	Cadena	Tipo de retorno del método
paramtypeMap	int String	Correspondencia del parámetro del método
paramsnum	intencionalmente	Número de parámetros de métodos
istatic	booleano	¿Es el método estático?
issubclassof	Cadena	Cuya subclase es
issuperClassof	Cadena	Cuya clase principal es
Hasanno	Cadena	Anotación del método
Hasclassanno	Cadena	Anotación de clase
jausfield	Cadena	Campos de clase

Aviso:

returnType y paramTypeMap requieren nombres de clase completos similares, como java.lang.String , y escriben el tipo básico directamente, por ejemplo, int , int
isSubClassOf e isSuperClassOf requieren nombres de clase completa, como java.awt.Component
hasAnno y hasClassAnno no requieren el nombre completo de la clase, simplemente escríbelo directamente, por ejemplo, Controller

1. Búsqueda básica

La base de la búsqueda es el método, ¿qué método desea buscar?

Por ejemplo, quiero que el método de búsqueda comience con set y termine con value

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

Por ejemplo, quiero buscar métodos cuyo nombre de clase contiene Context y el nombre del método contiene lookup

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

Por ejemplo, quiero buscar un método que devuelva un total de 3 parámetros de tipo Process y el segundo parámetro es String

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

2. Subclase y clase matriz

Por ejemplo, queremos encontrar todas las subclases de javax.naming.spi.ObjectFactory (incluidas las subclases de subclases, etc.)

Simplemente escriba las siguientes reglas, y el programa buscará recursivamente todas las clases de padres

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

Si desea encontrar todas las clases principales de una determinada clase, simplemente use isSuperClassOf (tenga en cuenta el nombre de la clase completa)

Tenga en cuenta que lo anterior encontrará directamente todos los métodos que cumplan con los criterios, por lo que sugiero agregar algo de filtrado

Por ejemplo

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

3. Búsqueda de anotaciones

Por ejemplo, queremos encontrar todos los métodos de todas las clases anotados por @Controller

Escribe las siguientes reglas

# method
        . hasClassAnno ( "Controller" )

Por ejemplo, quiero encontrar todos los métodos de anotación @RequestMapping

# method
        . hasAnno ( "RequestMapping" )

Del mismo modo, dado que se encuentran todos los métodos que cumplen con la clase de criterios, sugiero agregar un poco más de filtrado

4. Análisis práctico

De acuerdo con las condiciones de Swing RCE proporcionadas por el maestro en línea:

Debe haber un método establecido
El método establecido debe tener solo un parámetro
Este parámetro debe ser de tipo de cadena
Esta clase debe ser Component (incluidas las subclases indirectas)

Entonces escribimos una regla

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

Resultados de la búsqueda

Comienzo rápido

IMPORTANTE: Utilice Java 8+ para ejecutar (11 se proporciona la versión recomendada y EXE de Java 11 JRE incorporado)

(Se usó una mejor fuente en Java 11 , otras versiones usan fuentes predeterminadas)

(1) Paso 1: Agregar archivo jar (admite un solo archivo jar y directorio jar )

Haga clic en el botón Select Jar File para abrir el archivo jar
Admite cargar múltiples archivos jar y análisis juntos

No se preocupe, lleva un poco de tiempo analizar el archivo JAR

Nota: Espere hasta que la barra de progreso esté llena y el análisis esté completado.

(2) Paso 2: ingrese la información que buscó

Apoyamos la entrada en tres formatos:

javax.naming.Context (por ejemplo)
javax/naming/Context
Context (buscará todas las clases *.Context )

Proporciona una forma de ingresar rápidamente

Nota: El contenido de búsqueda común aquí se puede personalizar para suplementos

Cree un nuevo archivo search.txt en el directorio actual, divida el nombre de clase y el método uno por uno con # , por ejemplo

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

La búsqueda binaria solo devolverá si existe o no, y no devolverá información específica.

(3) Paso 3: puede hacer doble clic para descompilar

El cursor apuntará exactamente a la ubicación de la llamada de método

Durante la descompilación, se construirá la relación entre los métodos

Puede hacer doble clic en cualquier lugar del panel para descompilar y construir nuevas relaciones y presentaciones de llamadas de método

Tenga en cuenta: si encuentra una situación en la que no puede descompilar, debe cargar el archivo jar correcto

Por ejemplo, no puedo descompilar javax.naming.Context porque no me uní al archivo rt.jar , si lo unes, se puede descomponer normalmente

Puede usar Ctrl+F para buscar código y editar

Puede hacer clic en cualquier opción y los detalles del método se mostrarán a continuación

Puede hacer clic derecho para enviar la opción a la cadena. Puede comprender un enlace como favorito o disco. En la cadena, también puede hacer doble clic en la descompilación y luego mostrar la nueva relación de llamadas de método, o mostrar los detalles independientes. Si una opción en la cadena es algo que no desea, puede hacer clic derecho para eliminar la opción de la cadena

Por lo tanto, puede construir una cadena de llamadas que le pertenece solo

谁调用了当前方法y当前方法调用了谁todo el método en el que la relación entre el método también se puede descomponer, haga clic para ver los detalles, haga clic con el botón derecho para unirse a la cadena

Puede ver el código de byte de clase actual con un clic

acerca de

(1) ¿Cuál es la relación entre los métodos?

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

Si el método actual es b

Quién llamó al método actual: Test el método de clase a

Quién llama al método actual: Test Clase c Método

(2) Cómo resolver el problema de la implementación de la interfaz

 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
    }
}

Ahora tenemos Demo.demo -> Test.test data, pero de hecho es Demo.demo -> TestImpl.test .

Entonces agregamos nuevas reglas: Test.test -> Test1Impl.test y Test.test -> Test2Impl.test .

Primero asegúrese de que los datos no se pierdan, entonces podemos analizar manualmente el código descompilado por nosotros mismos

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

(3) Cómo resolver la relación de herencia

 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 's bytecode es INVOKEVIRTUAL Animal.eat ()V , pero solo tenemos esta regla Zoo.run -> Animal.eat , y Zoo.run -> Dog.eat regla está

En este caso, agregamos nuevas reglas: Animal.eat -> Dog.eat y Animal.eat -> Cat.eat

Primero asegúrese de que los datos no se pierdan, entonces podemos analizar manualmente el código descompilado por nosotros mismos