Descargar sleighcraft - Descargar código fuente de sleighcraft

sleighcraft

Otras categorias

1.0.0

Descargar

Trineo

Sleighcraft es uno de los proyectos BinCraft.

SleighCraft es un decodificador (o, desensamblador lineal) basado en la implementación del descompilador de Ghidra. Sleighcraft se puede usar en Rust o Python, con API de alto nivel y de bajo nivel.

En general, sleighcraft es como Capstone pero con IR y más arcos.

Características:

API basado en óxido y API de secuencias de comandos de Python.
Decodificando con IR como significado semántico.
Arcos: 110 arquitecturas.

Mostrva✔️: proporcionado

: no proporcionado

?: en construcción

?: no estoy seguro, tal vez no

Comparación con Capstone:

Característica	Trineo	Motor gordo
desmontar	✔️	✔️
IR	✔️️
C API	?	✔️
arquitectura personalizada	️✔️

Comparación de arquitecturas con Capstone (según la lista de arco de Capstone):

Nombres de arco	Trineo	Motor gordo
6502	✔️	?
6805	✔️	?
8051	✔️	?
8048	✔️	?
8085	✔️	?
68000	✔️	?
Aarch64 (ARMV8)	✔️	️Va✔️
brazo	✔️	️Va✔️
CP1600	✔️	?
CR16	✔️	?
AVR8	✔️	️️?
dalvik	✔️	?
jvm	✔️	?
mips	✔️	️Va✔️
PowerPC	✔️	️Va✔️
SPARC	✔️	️Va✔️
tricoro	✔️	?
riscv	✔️	?
z80	✔️	?
Sistema Z		✔️
xcore		✔️

Cómo instalar

Óxido

Use carga:

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

El repositorio es un poco grande para enviar en cajas (debido a archivos SLA predefinidos), pero guarde el complejo de compilar archivos de trineo usted mismo.

Pitón:

 # 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

Cómo usar

Se podría referirse a doc.rs para ver cómo se puede usar la unión de óxido.

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 ()

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

Óxido (un poco bajo):

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