jar analyzer v1 gui Download - jar analyzer v1 gui Source Source Download

jar analyzer v1 gui

หมวดหมู่อื่นๆ

1.1

ดาวน์โหลด

คลังเก็บเอกสารสำคัญ

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

เครื่องวิเคราะห์ขวด

บันทึก

โครงการนี้ไม่ได้รับการดูแลอีกต่อไป

ขอแนะนำให้ใช้ Jar Analyzer V2 เวอร์ชันใหม่ https://github.com/jar-analyzer/jar-analyzer

เวอร์ชันบรรทัดคำสั่ง jar-analyzer

Jar-Analyzer CLI เวอร์ชัน

แนะนำ

คำแนะนำสั้น ๆ : https://mp.weixin.qq.com/s/rrx6x5m_28yrcqqcdxueeq

ไม่มีเอกสารภาษาอังกฤษชาวต่างชาติโปรดแปลด้วยตัวเอง

เครื่องมือ GUI สำหรับการวิเคราะห์แพ็คเกจ jar โดยเฉพาะอย่างยิ่งเหมาะสำหรับการตรวจสอบความปลอดภัยของรหัส สามารถวิเคราะห์ไฟล์ jar หลายไฟล์ในเวลาเดียวกันและวิธีการเป้าหมายสามารถค้นหาได้อย่างง่ายดาย สนับสนุนการสลายตัวของไบต์และสร้างความสัมพันธ์ระหว่างคลาสและวิธีการโดยอัตโนมัติเพื่อช่วยให้นักวิจัยด้านความปลอดภัยของ Java ทำงานได้อย่างมีประสิทธิภาพมากขึ้น

หมายเหตุ: อย่าวิเคราะห์แพ็คเกจ Jar ที่มีขนาดใหญ่เกินไปหรือมากเกินไปขอแนะนำให้ไม่เกิน 300M

ไปดาวน์โหลด

สามารถค้นหาวิธีการอย่างถูกต้อง (เน้นทางด้านซ้าย)

คุณสามารถค้นหาสตริงได้โดยตรง (วิเคราะห์คำแนะนำที่เกี่ยวข้องกับพูลคงที่เพื่อให้ได้ตำแหน่งที่แม่นยำ)

สามารถวิเคราะห์โครงการที่เขียนโดย Spring Framework โดยตรง

ทำไมไม่เลือกการวิเคราะห์ IDEA : เพราะ IDEA ไม่สนับสนุนการวิเคราะห์แพ็คเกจ Jar รหัสแบบพาสซีฟ

รองรับวิธีการค้นหาหกวิธี:

ค้นหาโดยตรงตามชื่อคลาสและเมธอด (คำจำกัดความการค้นหา)
ค้นหาตามวิธีการโทร (โดยที่วิธีการที่เรียกว่า)
Search Strings (วิเคราะห์คำแนะนำ LDC เพื่อค้นหาตำแหน่งที่แน่นอน)
สตริงการค้นหาปกติ (วิเคราะห์คำสั่ง LDC เพื่อค้นหาตำแหน่งที่แน่นอน)
การค้นหาที่ไร้สมอง (วิเคราะห์คำแนะนำที่เกี่ยวข้องเพื่อค้นหาตำแหน่งที่แน่นอน)
การค้นหาแบบไบนารี (ค้นหาโดยตรงจากไบนารี)

รองรับการเลือกวิธีการสลายสามวิธี:

Quiltflower (ตัวแปร fernflower วิธีที่แนะนำ)
ทำนาย
CFR

ใช้การปรับแต่งคลาสของส่วนประกอบ JSyntaxPane (ไม่เป็นทางการ) เพื่อแสดงรหัส Java

(มีการเพิ่มเทคโนโลยีสีดำจำนวนมากในห้องสมุด https://code.google.com/archive/p/jsyntaxpane )

การค้นหานิพจน์

รองรับการค้นหานิพจน์ที่แข็งแกร่งเป็นพิเศษซึ่งสามารถรวมกันได้ตามที่คุณต้องการค้นหาข้อมูลที่คุณต้องการ

การแสดงออก	พารามิเตอร์	ผล
นาเมคอน	สาย	ชื่อวิธีมี
เริ่มต้น	สาย	คำนำหน้าวิธี
จบลงด้วย	สาย	วิธีการต่อท้าย
classnamecontains	สาย	ชื่อคลาสประกอบด้วย
returntype	สาย	วิธีการส่งคืนวิธีการ
paramtypemap	สตริง int	วิธีการติดต่อพารามิเตอร์
paramsnum	int	จำนวนพารามิเตอร์วิธีการ
ไม่แน่นอน	บูลีน	วิธีการคงที่?
issubclassof	สาย	ซึ่งเป็น subclass คือ
issuperclassof	สาย	ซึ่งชั้นเรียนของพ่อแม่คือ
HASANNO	สาย	คำอธิบายประกอบของวิธีการ
Hasclassanno	สาย	คำอธิบายประกอบชั้นเรียน
Hasfield	สาย	ฟิลด์ชั้นเรียน

สังเกต:

returnType และ paramTypeMap ต้องการชื่อคลาสที่สมบูรณ์แบบที่คล้ายกันเช่น java.lang.String และเขียนประเภทพื้นฐานโดยตรงตัวอย่างเช่น int
isSubClassOf และ isSuperClassOf ต้องการชื่อคลาสเต็มเช่น java.awt.Component
hasAnno และ hasClassAnno ไม่ต้องการชื่อคลาสที่สมบูรณ์เพียงแค่เขียนมันโดยตรงตัวอย่างเช่น Controller

1. การค้นหาขั้นพื้นฐาน

พื้นฐานของการค้นหาคือวิธีการคุณต้องการค้นหาวิธีใด

ตัวอย่างเช่นฉันต้องการให้วิธีการค้นหาเริ่มต้นด้วย set และสิ้นสุดด้วย value

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

ตัวอย่างเช่นฉันต้องการค้นหาวิธีการที่ชื่อคลาสมีชื่อ Context และชื่อมี lookup

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

ตัวอย่างเช่นฉันต้องการค้นหาวิธีการที่ส่งคืนพารามิเตอร์ทั้งหมด 3 พารามิเตอร์ของประเภท Process และพารามิเตอร์ที่สองคือ String

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

2. คลาสย่อยและคลาสแม่

ตัวอย่างเช่นเราต้องการค้นหาคลาสย่อยทั้งหมดของ javax.naming.spi.ObjectFactory (รวมถึงคลาสย่อยของคลาสย่อย ฯลฯ )

เพียงแค่เขียนกฎต่อไปนี้และโปรแกรมจะค้นหาคลาสแม่ทั้งหมดซ้ำ

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

หากคุณต้องการค้นหาคลาสพาเรนต์ทั้งหมดของคลาสที่แน่นอนเพียงใช้ isSuperClassOf (หมายเหตุชื่อคลาสเต็ม)

โปรดทราบว่าข้างต้นจะค้นหาวิธีการทั้งหมดที่ตรงตามเกณฑ์โดยตรงดังนั้นฉันขอแนะนำให้เพิ่มการกรองบางอย่าง

ตัวอย่างเช่น

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

3. การค้นหาคำอธิบายประกอบ

ตัวอย่างเช่นเราต้องการค้นหาวิธีการทั้งหมดของคลาสทั้งหมดที่มีคำอธิบายประกอบโดย @Controller

เขียนกฎต่อไปนี้

# method
        . hasClassAnno ( "Controller" )

ตัวอย่างเช่นฉันต้องการค้นหาวิธีการทั้งหมดของคำอธิบายประกอบ @RequestMapping

# method
        . hasAnno ( "RequestMapping" )

ในทำนองเดียวกันเนื่องจากวิธีการทั้งหมดที่ตรงตามเกณฑ์ชั้นเรียนฉันขอแนะนำให้เพิ่มการกรองเพิ่มเติม

4. การวิเคราะห์เชิงปฏิบัติ

ตามเงื่อนไข Swing RCE ที่จัดทำโดยอาจารย์ออนไลน์:

จะต้องมีวิธีการตั้งค่า
วิธีการตั้งค่าจะต้องมีพารามิเตอร์เดียวเท่านั้น
พารามิเตอร์นี้ต้องเป็นประเภทสตริง
คลาสนี้จะต้องเป็นคลาสย่อย Component (รวมถึงคลาสย่อยทางอ้อม)

ดังนั้นเราจึงเขียนกฎ

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

ผลการค้นหา

เริ่มต้นอย่างรวดเร็ว

สำคัญ: โปรดใช้ Java 8+ เพื่อเรียกใช้ (11 แนะนำและ EXE เวอร์ชันของ Java 11 JRE ในตัว)

(ใช้ฟอนต์ที่ดีกว่าใน Java 11 รุ่นอื่น ๆ ใช้แบบอักษรเริ่มต้น)

(1) ขั้นตอนที่ 1: เพิ่มไฟล์ jar (รองรับไดเรกทอรีไฟล์ jar และ jar เดียว)

คลิกปุ่ม Select Jar File เพื่อเปิดไฟล์ jar
รองรับการอัปโหลดไฟล์ JAR หลายไฟล์และการวิเคราะห์ร่วมกัน

โปรดไม่ต้องกังวลใช้เวลาเล็กน้อยในการวิเคราะห์ไฟล์ jar

หมายเหตุ: โปรดรอจนกว่าแถบความคืบหน้าจะเต็มและการวิเคราะห์เสร็จสมบูรณ์

(2) ขั้นตอนที่ 2: ป้อนข้อมูลที่คุณค้นหา

เราสนับสนุนอินพุตในสามรูปแบบ:

javax.naming.Context (ตัวอย่าง)
javax/naming/Context
Context (จะค้นหาคลาส *.Context ทั้งหมด)

ให้วิธีการป้อนอย่างรวดเร็ว

หมายเหตุ: เนื้อหาการค้นหาทั่วไปที่นี่สามารถปรับแต่งสำหรับอาหารเสริม

สร้างไฟล์ search.txt ใหม่ในไดเรกทอรีปัจจุบันแยกชื่อคลาสและวิธีหนึ่งทีละหนึ่งด้วย # ตัวอย่างเช่น

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

การค้นหาแบบไบนารีจะส่งคืนไม่ว่าจะมีอยู่หรือไม่และจะไม่คืนข้อมูลเฉพาะ

(3) ขั้นตอนที่ 3: คุณสามารถดับเบิลคลิกเพื่อถอดรหัส

เคอร์เซอร์จะชี้ไปที่ตำแหน่งของการโทรอย่างแน่นอน

ในระหว่างการสลายตัวความสัมพันธ์ระหว่างวิธีการจะถูกสร้างขึ้น

คุณสามารถดับเบิลคลิกที่ใดก็ได้บนแผงควบคุมและสร้างความสัมพันธ์และการนำเสนอวิธีการใหม่

โปรดทราบ: หากคุณพบสถานการณ์ที่คุณไม่สามารถสลายได้คุณต้องโหลดไฟล์ JAR ที่ถูกต้อง

ตัวอย่างเช่นฉันไม่สามารถถอดรหัส javax.naming.Context ได้เพราะฉันไม่ได้เข้าร่วมไฟล์ rt.jar หากคุณเข้าร่วมมันสามารถถอดรหัสได้ตามปกติ

คุณสามารถใช้ Ctrl+F เพื่อค้นหารหัสและแก้ไข

คุณสามารถคลิกที่ตัวเลือกใด ๆ และรายละเอียดวิธีการจะปรากฏต่อไป

คุณสามารถคลิกขวาเพื่อส่งตัวเลือกไปยังโซ่ คุณสามารถเข้าใจลิงก์เป็นที่ชื่นชอบหรือบันทึก ในห่วงโซ่คุณยังสามารถดับเบิลคลิกที่ decompile จากนั้นแสดงความสัมพันธ์การเรียกวิธีการใหม่หรือแสดงรายละเอียดบนพื้นฐานแบบสแตนด์อโลน หากตัวเลือกในห่วงโซ่เป็นสิ่งที่คุณไม่ต้องการคุณสามารถคลิกขวาเพื่อลบตัวเลือกออกจากห่วงโซ่

ดังนั้นคุณสามารถสร้างห่วงโซ่โทรที่เป็นของคุณเท่านั้น

谁调用了当前方法และ当前方法调用了谁วิธีทั้งหมดที่ความสัมพันธ์ระหว่างวิธีนี้สามารถถอดรหัสได้คลิกเพื่อดูรายละเอียดคลิกขวาเพื่อเข้าร่วมโซ่

คุณสามารถดูรหัสไบต์คลาสปัจจุบันด้วยคลิกเดียว

เกี่ยวกับ

(1) ความสัมพันธ์ระหว่างวิธีการคืออะไร

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

หากวิธีการปัจจุบันคือ b

ใครเรียกวิธีการปัจจุบัน: วิธี Test คลาส a

ใครเรียกวิธีการปัจจุบัน: วิธี Test คลาส c

(2) วิธีแก้ปัญหาการใช้งานส่วนต่อประสาน

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

ตอนนี้เรามี Demo.demo -> Test.test data แต่ที่จริงแล้วมันคือ Demo.demo -> TestImpl.test

ดังนั้นเราจึงเพิ่มกฎใหม่: Test.test -> Test1Impl.test และ Test.test -> Test2Impl.test

ก่อนอื่นตรวจสอบให้แน่ใจว่าข้อมูลจะไม่สูญหายจากนั้นเราสามารถวิเคราะห์รหัสที่ถอดรหัสได้ด้วยตนเองด้วยตนเอง

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

(3) วิธีแก้ไขความสัมพันธ์ในการสืบทอด

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