Téléchargement sleighcraft - Téléchargement du code source sleighcraft

sleighcraft

Autres catégories

1.0.0

Télécharger

Traîneau

Sleighcraft est l'un des projets de bincraft.

SleighCraft est un décodeur (ou, désassembleur linéaire) basé sur l'implémentation du décompilateur de Ghidra. Sleighcraft peut être utilisé dans Rust ou Python, avec une API de haut niveau et de bas niveau.

En général, sleighcraft est comme Capstone mais avec IR et plus d'arches.

Caractéristiques:

API basée sur la rouille et API de script Python.
Décodage avec IR comme sens sémantique.
Archs: 110 architectures.

Çons

: Non fourni

?: en construction

?: pas sûr, peut-être pas

Comparaison avec Capstone:

Fonctionnalité	Traîneau	Moteur de pierre angulaire
démonter	✔️	✔️
IR	✔️️
API C	?	✔️
architecture personnalisée	️✔️

Comparaison des architectures avec Capstone (selon la liste des arches de Capstone):

Noms de voûte	Traîneau	Moteur de pierre angulaire
6502	✔️	?
6805	✔️	?
8051	✔️	?
8048	✔️	?
8085	✔️	?
68000	✔️	?
AARCH64 (ARMV8)	✔️	Çons
bras	✔️	Çons
CP1600	✔️	?
CR16	✔️	?
AVR8	✔️	Çons?
dalvik	✔️	?
jvm	✔️	?
mips	✔️	Çons
powerpc	✔️	Çons
natte	✔️	Çons
Tricore	✔️	?
riscv	✔️	?
z80	✔️	?
Système Z		✔️
xcore		✔️

Comment installer

Rouiller

Utilisez la cargaison:

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

Le repo est un peu important à soumettre sur Crates-io (en raison de fichiers SLA prédéfinis), mais vous enregistrez vous-même le complexe de compilation de fichiers de traîneau.

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

Comment utiliser

On pourrait faire référence à Doc.RS pour voir comment la liaison de la rouille peut être utilisée.

Liaison 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 Besure:

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

Rust (un peu bas niveau):

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