ดาวน์โหลด sleighcraft - ดาวน์โหลดซอร์สโค้ด sleighcraft

sleighcraft

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

1.0.0

ดาวน์โหลด

หอก

Sleighcraft เป็นหนึ่งในโครงการ Bincraft

SleighCraft เป็นตัวถอดรหัส (หรือ, disassembler เชิงเส้น) ตามการใช้งาน decompiler ของ Ghidra Sleighcraft สามารถใช้ในสนิมหรืองูหลามได้ทั้ง API ระดับสูงและระดับต่ำ

โดยทั่วไปแล้ว sleighcraft ก็เหมือนกับ Capstone แต่มี IR และส่วนโค้งมากขึ้น

คุณสมบัติ:

API ที่ใช้ Rust API และ Python Scripting API
การถอดรหัสด้วย IR เป็นความหมายเชิงความหมาย
Archs: 110 สถาปัตยกรรม

️: ให้

: ไม่ได้ให้

?: ในการก่อสร้าง

?: ไม่แน่ใจอาจจะไม่

เปรียบเทียบกับ Capstone:

คุณสมบัติ	หอก	เครื่องยนต์หิน
ถอดแยกชิ้นส่วน
ir
C API	-
สถาปัตยกรรมที่กำหนดเอง

การเปรียบเทียบสถาปัตยกรรมกับ Capstone (ตามรายการ Arch Capstone):

ชื่อโค้ง	หอก	เครื่องยนต์หิน
6502		-
6805		-
8051		-
8048		-
8085		-
68000		-
Aarch64 (ARMV8)
แขน
CP1600		-
CR16		-
avr8		?
Dalvik		-
JVM		-
มัด
PowerPC
สปอร์
ทริคอร์		-
RISCV		-
Z80		-
ระบบ Z
Xcore

วิธีการติดตั้ง

สนิม

ใช้สินค้า:

 sleighcraft = { git = " https://github.com/StarCrossPortal/sleighcraft " }

repo มีขนาดใหญ่เล็กน้อยในการส่งบน Crates-io (เนื่องจากไฟล์ SLA ที่กำหนดไว้ล่วงหน้า) แต่ช่วยให้คุณประหยัดไฟล์ที่รวบรวมไฟล์เลื่อนด้วยตัวเอง

Python:

 # quick install it with pip
$ pip3 install bincraft

# or download binaries than choose the corresponding architecture
$ pip3 install bincraft-0.1.0-cp39-cp39-Arch.whl

# or manual, to do this, you need to have rust compiler installed and maturin
# better with rustup.
$ pip3 install maturin
$ maturin build
$ pip3 install bincraft-0.1.0-cp39-cp39-Arch.whl

nodejs:

 # quick install it with npm 
$ npm i bincraft

# or manual, to do this, you need to have rust compiler installed, nodejs and neon
# better with rustup.
$ npm install -g neon-cli
$ neon build

วิธีใช้

หนึ่งสามารถอ้างถึง doc.rs เพื่อดูว่าสามารถใช้การผูกสนิมได้อย่างไร

Python binding:

 from bincraft import Sleigh

code = [ 0x90 , 0x31 , 0x32 ] # code to disassemble

# init the sleigh engine Sleigh(arch, code)
sleigh = Sleigh ( "x86" , code )

# now we are prepared to disassemble!
# disasm(start_addr)
for asm in sleigh . disasm ( 0 ):
    addr = asm . addr ()
    mnem = asm . mnemonic ()
    body = asm . body ()

    # quite like capstone, right?
    print ( f'Addr: { addr } t  mnemonic: { mnem } t body: { body } ' )

    # but! we also have the IR!
    pcodes = asm . pcodes ()
    for pcode in pcodes :
        opcode = pcode . opcode ()
        vars = pcode . vars ()
        print ( f'opcode: { opcode } t vars: { vars } t ' )
    print ()

การเชื่อมโยง NodeJS:

 const Sleigh = require ( 'bincraft' ) ;
//or const Sleigh = require('.');

// init the sleigh engine Sleigh(arch, code) like python
const sleigh = new Sleigh ( "x86" , [ 0x90 , 90 ] ) ;

// disasm(start_addr) 
// - start: Default is 0
const asms = sleigh . disasm ( ) ;

asms . forEach ( asm => {
    let addr = asm . addr ( ) ;
    let mnemonic = asm . mnemonic ( ) ;
    let body = asm . body ( ) ;
    // dump instruction
    console . log ( `addr: ${ addr } t mnemonic: ${ mnemonic } t body: ${ body } ` ) ;
    
    // And we have IR！
    let pcodes = asm . pcodes ( ) ;
    pcodes . forEach ( pcode => {
        opcode = pcode . opcode ( ) ;
        vars = pcode . vars ( ) ;
        
        console . log ( `opcode: ${ opcode } t vars: ${ vars } ` ) ;
    } ) ;
} ) ;

สนิม (ระดับต่ำสุด):

 // Overall procedure:
// 1. get the spec, this is where we know how to decode anything
// 2. get a loader, this is where we fill the input bytes to the engine.
// A predefined loader is provided: `PlainLoadImage`, which sets
// the things to decode by using a single buf.
// 3. set the AssemblyEmit and PcodeEmit instance, these are two
// traits that defines the callback at the decode time.
// 4. do the decode
use sleighcraft :: * ;
let mut sleigh_builder = SleighBuilder :: default ( ) ;
let spec = arch ( "x86" ) . unwrap ( ) ;
let buf = [ 0x90 , 0x32 , 0x31 ] ;
let mut loader = PlainLoadImage :: from_buf ( & buf , 0 ) ;
sleigh_builder . loader ( & mut loader ) ;
sleigh_builder . spec ( spec ) ;
let mut asm_emit = CollectingAssemblyEmit :: default ( ) ;
let mut pcode_emit = CollectingPcodeEmit :: default ( ) ;
sleigh_builder . asm_emit ( & mut asm_emit ) ;
sleigh_builder . pcode_emit ( & mut pcode_emit ) ;
let mut sleigh = sleigh_builder . try_build ( ) . unwrap ( ) ;

sleigh . decode ( 0 ) . unwrap ( ) ;

println ! ( "{:?}" , asm_emit . asms ) ;
println ! ( "{:?}" , pcode_emit . pcode_asms ) ;