PyVEX

PyVEX è un binding Python per il VEX IR.

Link del progetto

Repository del progetto: https://github.com/angr/pyvex

Documentazione: https://api.angr.io/projects/pyvex/en/latest/

Installazione di PyVEX

PyVEX può essere installato tramite pip:

pip install pyvex

Utilizzo di PyVEX

import pyvex
import archinfo

# translate an AMD64 basic block (of nops) at 0x400400 into VEX
irsb = pyvex.lift(b"\x90\x90\x90\x90\x90", 0x400400, archinfo.ArchAMD64())

# pretty-print the basic block
irsb.pp()

# this is the IR Expression of the jump target of the unconditional exit at the end of the basic block
print(irsb.next)

# this is the type of the unconditional exit (i.e., a call, ret, syscall, etc)
print(irsb.jumpkind)

# you can also pretty-print it
irsb.next.pp()

# iterate through each statement and print all the statements
for stmt in irsb.statements:
    stmt.pp()

# pretty-print the IR expression representing the data, and the *type* of that IR expression written by every store statement
import pyvex
for stmt in irsb.statements:
    if isinstance(stmt, pyvex.IRStmt.Store):
        print("Data:", end="")
        stmt.data.pp()
        print("")

        print("Type:", end="")
        print(stmt.data.result_type)
        print("")

# pretty-print the condition and jump target of every conditional exit from the basic block
for stmt in irsb.statements:
    if isinstance(stmt, pyvex.IRStmt.Exit):
        print("Condition:", end="")
        stmt.guard.pp()
        print("")

        print("Target:", end="")
        stmt.dst.pp()
        print("")

# these are the types of every temp in the IRSB
print(irsb.tyenv.types)

# here is one way to get the type of temp 0
print(irsb.tyenv.types[0])

Tieni presente che questa è una rappresentazione sintattica di un basic block. Ovvero, ti dirà cosa significa il blocco, ma non hai alcun contesto per dire, ad esempio, quali dati effettivi vengano scritti da un'istruzione di store.

Rappresentazione Intermedia VEX

Per gestire architetture molto diverse tra loro, è utile eseguire analisi su una rappresentazione intermedia. Una IR astrae diverse differenze architetturali quando si ha a che fare con architetture diverse, consentendo di eseguire una singola analisi su tutte:

• Nomi dei registri. La quantità e i nomi dei registri differiscono tra le architetture, ma i moderni design delle CPU mantengono un tema comune: ogni CPU contiene diversi registri di uso generale, un registro per contenere lo stack pointer, un insieme di registri per memorizzare i flag di condizione, e così via. La IR fornisce un'interfaccia coerente e astratta ai registri su piattaforme diverse. Nello specifico, VEX modella i registri come uno spazio di memoria separato, con offset interi (ad esempio, rax di AMD64 è memorizzato a partire dall'indirizzo 16 in questo spazio di memoria).
• Accesso alla memoria. Architetture diverse accedono alla memoria in modi diversi. Ad esempio, ARM può accedere alla memoria sia in modalità little-endian che big-endian. La IR deve astrarre queste differenze.
• Segmentazione della memoria. Alcune architetture, come x86, supportano la segmentazione della memoria tramite l'uso di registri di segmento speciali. La IR comprende tali meccanismi di accesso alla memoria.
• Effetti collaterali delle istruzioni. La maggior parte delle istruzioni ha effetti collaterali. Ad esempio, la maggior parte delle operazioni in modalità Thumb su ARM aggiorna i flag di condizione, e le istruzioni di push/pop sullo stack aggiornano lo stack pointer. Tracciare questi effetti collaterali in modo ad hoc nell'analisi sarebbe folle, quindi la IR rende espliciti questi effetti.

Ci sono molte scelte per una IR. Noi usiamo VEX, poiché il lifting del codice binario in VEX è supportato piuttosto bene. VEX è una rappresentazione agnostica rispetto all'architettura e priva di effetti collaterali di numerosi linguaggi macchina target. Astrae il codice macchina in una rappresentazione progettata per rendere più semplice l'analisi dei programmi. Questa rappresentazione ha cinque classi principali di oggetti:

• Espressioni. Le IR Expression rappresentano un valore calcolato o costante. Questo include caricamenti dalla memoria, letture di registri e risultati di operazioni aritmetiche.
• Operazioni. Le IR Operation descrivono una modifica delle IR Expression. Questo include aritmetica intera, aritmetica in virgola mobile, operazioni sui bit e così via. Un'IR Operation applicata a IR Expression produce come risultato un'IR Expression.
• Variabili temporanee. VEX usa variabili temporanee come registri interni: le IR Expression vengono memorizzate in variabili temporanee tra un uso e l'altro. Il contenuto di una variabile temporanea può essere recuperato usando un'IR Expression. Queste variabili temporanee sono numerate, a partire da t0. Queste variabili temporanee sono fortemente tipizzate (ad esempio, "intero a 64 bit" o "float a 32 bit").
• Statement. Gli IR Statement modellano i cambiamenti nello stato della macchina target, come l'effetto di store in memoria e scritture su registri. Gli IR Statement usano IR Expression per i valori di cui possono aver bisogno. Ad esempio, un IR Statement di store in memoria usa un'IR Expression per l'indirizzo target della scrittura, e un'altra IR Expression per il contenuto.
• Blocchi. Un IR Block è una raccolta di IR Statement, che rappresenta un basic block esteso (chiamato "IR Super Block" o "IRSB") nell'architettura target. Un blocco può avere diverse uscite. Per le uscite condizionali dal mezzo di un basic block, viene usato uno speciale Exit IR Statement. Un'IR Expression viene usata per rappresentare il target dell'uscita incondizionata alla fine del blocco.

Il VEX IR è in realtà piuttosto ben documentato nel file libvex_ir.h (https://github.com/angr/vex/blob/dev/pub/libvex_ir.h) nel repository VEX. Per i pigri, dettaglieremo alcune parti di VEX con cui probabilmente interagirai abbastanza frequentemente. Per iniziare, ecco alcune IR Expression:

IR Expression	Valore Valutato	Esempio di Output VEX
Constant	Un valore costante.	0x4:I32
Read Temp	Il valore memorizzato in una variabile temporanea VEX.	RdTmp(t10)
Get Register	Il valore memorizzato in un registro.	GET:I32(16)
Load Memory	Il valore memorizzato a un indirizzo di memoria, con l'indirizzo specificato da un'altra IR Expression.	LDle:I32 / LDbe:I64
Operation	Un risultato di una specificata IR Operation, applicata a specificati argomenti IR Expression.	Add32
If-Then-Else	Se una data IR Expression restituisce 0, restituisce un'IR Expression. Altrimenti, ne restituisce un'altra.	ITE
Helper Function	VEX usa funzioni helper C per certe operazioni, come il calcolo dei registri dei flag di condizione di certe architetture. Queste funzioni restituiscono IR Expression.	function_name()

Queste espressioni vengono poi, a loro volta, usate negli IR Statement. Ecco alcuni comuni: