Unduh sleighcraft - Unduh Kode Sumber sleighcraft

sleighcraft

Kategori lainnya

1.0.0

Unduh

Giring

Sleighcraft adalah salah satu proyek Bincraft.

SleighCraft adalah dekoder (atau, linear disassembler) berdasarkan implementasi dekompiler Ghidra. Giring dapat digunakan dalam karat atau python, dengan API tingkat tinggi dan tingkat rendah.

Secara umum, sleighcraft seperti batu penjuru tetapi dengan IR dan lebih banyak lengkungan.

Fitur:

API Berbasis Rust dan Python Scripting API.
Decoding dengan IR sebagai makna semantik.
Archs: 110 Arsitektur.

️️✔️: Disediakan

: tidak disediakan

?: dalam konstruksi

?: tidak yakin, mungkin tidak

Perbandingan dengan Capstone:

Fitur	Giring	Mesin batu penjuru
membongkar	✔️	✔️
Ir	✔️️
C API	?	✔️
Arsitektur Kustom	️✔️

Perbandingan Arsitektur dengan Capstone (menurut daftar lengkungan Capstone):

Nama lengkungan	Giring	Mesin batu penjuru
6502	✔️	?
6805	✔️	?
8051	✔️	?
8048	✔️	?
8085	✔️	?
68000	✔️	?
Aarch64 (ARMV8)	✔️	️️✔️
lengan	✔️	️️✔️
CP1600	✔️	?
CR16	✔️	?
AVR8	✔️	️ -?
Dalvik	✔️	?
jvm	✔️	?
mips	✔️	️️✔️
powerpc	✔️	️️✔️
sparc	✔️	️️✔️
Tricore	✔️	?
riscv	✔️	?
Z80	✔️	?
Sistem Z.		✔️
xcore		✔️

Cara menginstal

Karat

Gunakan kargo:

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

Repo ini agak besar untuk dikirimkan pada Crates-OO (karena file SLA yang telah ditentukan), tetapi menyimpan Anda kompleks untuk menyusun file giring sendiri.

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

Cara menggunakan

Orang bisa merujuk ke Doc.rs untuk melihat bagaimana pengikatan karat dapat digunakan.

Ikatan Python:

 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 Binding:

 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 } ` ) ;
    } ) ;
} ) ;

Karat (agak rendah):

 // 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 ) ;