PyVEX

PyVEX são bindings Python para a IR VEX.

Links do Projeto

Repositório do projeto: https://github.com/angr/pyvex

Documentação: https://api.angr.io/projects/pyvex/en/latest/

Instalando o PyVEX

O PyVEX pode ser instalado via pip:

pip install pyvex

Usando o 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])

Tenha em mente que esta é uma representação sintática de um bloco básico. Ou seja, ela informará o que o bloco significa, mas você não tem contexto para dizer, por exemplo, quais dados reais são escritos por uma instrução de store.

Representação Intermediária VEX

Para lidar com arquiteturas amplamente diversas, é útil realizar análises sobre uma representação intermediária. Uma IR abstrai várias diferenças de arquitetura ao lidar com arquiteturas diferentes, permitindo que uma única análise seja executada em todas elas:

• Nomes de registradores. A quantidade e os nomes dos registradores diferem entre arquiteturas, mas os projetos modernos de CPU mantêm um tema comum: cada CPU contém vários registradores de uso geral, um registrador para armazenar o ponteiro de pilha, um conjunto de registradores para armazenar flags de condição, e assim por diante. A IR fornece uma interface consistente e abstraída para registradores em diferentes plataformas. Especificamente, o VEX modela os registradores como um espaço de memória separado, com deslocamentos inteiros (ou seja, o rax do AMD64 é armazenado começando no endereço 16 nesse espaço de memória).
• Acesso à memória. Diferentes arquiteturas acessam a memória de maneiras diferentes. Por exemplo, ARM pode acessar a memória tanto em modo little-endian quanto big-endian. A IR deve abstrair essas diferenças.
• Segmentação de memória. Algumas arquiteturas, como x86, suportam segmentação de memória através do uso de registradores de segmento especiais. A IR compreende tais mecanismos de acesso à memória.
• Efeitos colaterais de instruções. A maioria das instruções tem efeitos colaterais. Por exemplo, a maioria das operações em modo Thumb no ARM atualiza as flags de condição, e instruções de push/pop na pilha atualizam o ponteiro de pilha. Rastrear esses efeitos colaterais de forma ad hoc na análise seria uma loucura, então a IR torna esses efeitos explícitos.

Há muitas escolhas para uma IR. Usamos o VEX, pois a elevação de código binário para VEX é bastante bem suportada. O VEX é uma representação agnóstica de arquitetura e livre de efeitos colaterais de várias linguagens de máquina alvo. Ele abstrai o código de máquina em uma representação projetada para facilitar a análise de programas. Essa representação tem cinco classes principais de objetos:

• Expressões. Expressões IR representam um valor calculado ou constante. Isso inclui cargas de memória, leituras de registradores e resultados de operações aritméticas.
• Operações. Operações IR descrevem uma modificação de Expressões IR. Isso inclui aritmética inteira, aritmética de ponto flutuante, operações de bits, e assim por diante. Uma Operação IR aplicada a Expressões IR produz uma Expressão IR como resultado.
• Variáveis temporárias. O VEX usa variáveis temporárias como registradores internos: Expressões IR são armazenadas em variáveis temporárias entre usos. O conteúdo de uma variável temporária pode ser recuperado usando uma Expressão IR. Essas temporárias são numeradas, começando em t0. Essas temporárias são fortemente tipadas (ou seja, "inteiro de 64 bits" ou "float de 32 bits").
• Statements. Statements IR modelam mudanças no estado da máquina alvo, como o efeito de stores de memória e escritas em registradores. Statements IR usam Expressões IR para valores que possam precisar. Por exemplo, um Statement IR de store de memória usa uma Expressão IR para o endereço alvo da escrita, e outra Expressão IR para o conteúdo.
• Blocos. Um Bloco IR é uma coleção de Statements IR, representando um bloco básico estendido (chamado "IR Super Block" ou "IRSB") na arquitetura alvo. Um bloco pode ter várias saídas. Para saídas condicionais do meio de um bloco básico, um Statement IR especial de Exit é usado. Uma Expressão IR é usada para representar o alvo da saída incondicional no final do bloco.

A IR VEX é, na verdade, bastante bem documentada no arquivo libvex_ir.h (https://github.com/angr/vex/blob/dev/pub/libvex_ir.h) no repositório VEX. Para os preguiçosos, detalharemos algumas partes do VEX com as quais você provavelmente interagirá com bastante frequência. Para começar, aqui estão algumas Expressões IR:

Expressão IR	Valor Avaliado	Exemplo de Saída VEX
Constant	Um valor constante.	0x4:I32
Read Temp	O valor armazenado em uma variável temporária VEX.	RdTmp(t10)
Get Register	O valor armazenado em um registrador.	GET:I32(16)
Load Memory	O valor armazenado em um endereço de memória, com o endereço especificado por outra Expressão IR.	LDle:I32 / LDbe:I64
Operation	Um resultado de uma Operação IR especificada, aplicada a argumentos de Expressão IR especificados.	Add32
If-Then-Else	Se uma dada Expressão IR for avaliada como 0, retorna uma Expressão IR. Caso contrário, retorna outra.	ITE
Helper Function	O VEX usa funções auxiliares em C para certas operações, como calcular os registradores de flags de condição de certas arquiteturas. Essas funções retornam Expressões IR.	function_name()

Essas expressões são então, por sua vez, usadas em Statements IR. Aqui estão alguns comuns: