Download sleighcraft - Download sleighcraft Quellcode

sleighcraft

Andere Kategorien

1.0.0

Herunterladen

Schlittencraft

Schlittencraft ist eines der Bincraft -Projekte.

SleighCraft ist ein Decoder (oder linearer Disassembler), der auf Ghidras Dekompiler -Implementierung basiert. Sleighcraft kann in Rost oder Python mit hochrangiger und niedriger API verwendet werden.

Im Allgemeinen ist sleighcraft genau wie Capstone, aber mit IR und mehr Bogen.

Merkmale:

Rostbasierte API- und Python -Skript -API.
Dekodieren mit IR als semantische Bedeutung.
Bogen: 110 Architekturen.

️️✔️: bereitgestellt

: nicht bereitgestellt

?: im Bau

?: nicht sicher, vielleicht nicht

Vergleich mit Capstone:

Besonderheit	Schlittencraft	Capstone -Motor
zerlegt	✔️	✔️
Ir	✔️️
C API	?	✔️
benutzerdefinierte Architektur	️✔️

Architekturen Vergleich mit Capstone (gemäß Capstone Arch List):

Bogennamen	Schlittencraft	Capstone -Motor
6502	✔️	?
6805	✔️	?
8051	✔️	?
8048	✔️	?
8085	✔️	?
68000	✔️	?
AArch64 (ARMV8)	✔️	️B
Arm	✔️	️B
CP1600	✔️	?
CR16	✔️	?
AVR8	✔️	Euten?
Dalvik	✔️	?
JVM	✔️	?
MIPS	✔️	️B
Powerpc	✔️	️B
Sparc	✔️	️B
Tricore	✔️	?
RISCV	✔️	?
Z80	✔️	?
System z		✔️
xcore		✔️

So installieren

Rost

Verwenden Sie Fracht:

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

Das Repo ist etwas groß, um auf Kisten-IO (wegen vordefinierter SLA-Dateien) einzureichen. Speichern Sie jedoch den Komplex, Schlittendateien selbst zu kompilieren.

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

Wie man benutzt

Man könnte sich auf Doc.rs beziehen, um zu sehen, wie Rostbindung verwendet werden kann.

Python -Bindung:

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

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

Rost (irgendwie niedrig):

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