api.hpp

Go to the documentation of this file.

/*
**  Copyright (C) - Triton
**
**  This program is under the terms of the BSD License.
*/

#ifndef TRITON_API_H
#define TRITON_API_H

#include <triton/architecture.hpp>
#include <triton/ast.hpp>
#include <triton/astContext.hpp>
#include <triton/astRepresentation.hpp>
#include <triton/callbacks.hpp>
#include <triton/dllexport.hpp>
#include <triton/immediate.hpp>
#include <triton/instruction.hpp>
#include <triton/irBuilder.hpp>
#include <triton/memoryAccess.hpp>
#include <triton/modes.hpp>
#include <triton/operandWrapper.hpp>
#include <triton/register.hpp>
#include <triton/registers_e.hpp>
#include <triton/symbolicEngine.hpp>
#include <triton/taintEngine.hpp>
#include <triton/tritonTypes.hpp>
#include <triton/z3Interface.hpp>
#include <triton/z3Solver.hpp>



namespace triton {
    class API {
      protected:
        triton::callbacks::Callbacks callbacks;

        triton::arch::Architecture arch;

        triton::modes::Modes modes;

        triton::engines::taint::TaintEngine* taint = nullptr;

        triton::engines::symbolic::SymbolicEngine* symbolic = nullptr;

        triton::engines::solver::SolverInterface* solver = nullptr;

        triton::ast::AstContext astCtxt;

        triton::arch::IrBuilder* irBuilder = nullptr;

        triton::ast::Z3Interface* z3Interface = nullptr;


      public:
        TRITON_EXPORT API();

        TRITON_EXPORT ~API();


        /* Architecture API ============================================================================== */

        TRITON_EXPORT bool isArchitectureValid(void) const;

        TRITON_EXPORT triton::arch::architectures_e getArchitecture(void) const;

        TRITON_EXPORT void checkArchitecture(void) const;

        TRITON_EXPORT triton::arch::CpuInterface* getCpu(void);

        TRITON_EXPORT void setArchitecture(triton::arch::architectures_e arch);

        TRITON_EXPORT void clearArchitecture(void);

        TRITON_EXPORT bool isFlag(triton::arch::registers_e regId) const;

        TRITON_EXPORT bool isFlag(const triton::arch::Register& reg) const;

        TRITON_EXPORT bool isRegister(triton::arch::registers_e regId) const;

        TRITON_EXPORT bool isRegister(const triton::arch::Register& reg) const;

        TRITON_EXPORT const triton::arch::Register& getRegister(triton::arch::registers_e id) const;

        TRITON_EXPORT const triton::arch::Register& getParentRegister(const triton::arch::Register& reg) const;

        TRITON_EXPORT const triton::arch::Register& getParentRegister(triton::arch::registers_e id) const;

        TRITON_EXPORT bool isRegisterValid(triton::arch::registers_e regId) const;

        TRITON_EXPORT bool isRegisterValid(const triton::arch::Register& reg) const;

        TRITON_EXPORT triton::uint32 getGprBitSize(void) const;

        TRITON_EXPORT triton::uint32 getGprSize(void) const;

        TRITON_EXPORT triton::uint32 getNumberOfRegisters(void) const;

        TRITON_EXPORT const std::unordered_map<triton::arch::registers_e, const triton::arch::Register>& getAllRegisters(void) const;

        TRITON_EXPORT std::set<const triton::arch::Register*> getParentRegisters(void) const;

        TRITON_EXPORT triton::uint8 getConcreteMemoryValue(triton::uint64 addr, bool execCallbacks=true) const;

        TRITON_EXPORT triton::uint512 getConcreteMemoryValue(const triton::arch::MemoryAccess& mem, bool execCallbacks=true) const;

        TRITON_EXPORT std::vector<triton::uint8> getConcreteMemoryAreaValue(triton::uint64 baseAddr, triton::usize size, bool execCallbacks=true) const;

        TRITON_EXPORT triton::uint512 getConcreteRegisterValue(const triton::arch::Register& reg, bool execCallbacks=true) const;

        TRITON_EXPORT void setConcreteMemoryValue(triton::uint64 addr, triton::uint8 value);

        TRITON_EXPORT void setConcreteMemoryValue(const triton::arch::MemoryAccess& mem, const triton::uint512& value);

        TRITON_EXPORT void setConcreteMemoryAreaValue(triton::uint64 baseAddr, const std::vector<triton::uint8>& values);

        TRITON_EXPORT void setConcreteMemoryAreaValue(triton::uint64 baseAddr, const triton::uint8* area, triton::usize size);

        TRITON_EXPORT void setConcreteRegisterValue(const triton::arch::Register& reg, const triton::uint512& value);

        TRITON_EXPORT bool isMemoryMapped(triton::uint64 baseAddr, triton::usize size=1);

        TRITON_EXPORT void unmapMemory(triton::uint64 baseAddr, triton::usize size=1);

        TRITON_EXPORT void disassembly(triton::arch::Instruction& inst) const;



        /* Processing API ================================================================================ */

        TRITON_EXPORT bool processing(triton::arch::Instruction& inst);

        TRITON_EXPORT void initEngines(void);

        TRITON_EXPORT void removeEngines(void);

        TRITON_EXPORT void reset(void);



        /* IR API ======================================================================================== */

        TRITON_EXPORT void checkIrBuilder(void) const;

        TRITON_EXPORT bool buildSemantics(triton::arch::Instruction& inst);

        TRITON_EXPORT triton::ast::AstContext& getAstContext(void);




        /* AST Representation API ======================================================================== */

        TRITON_EXPORT triton::uint32 getAstRepresentationMode(void) const;

        TRITON_EXPORT void setAstRepresentationMode(triton::uint32 mode);



        /* Callbacks API ================================================================================= */

        TRITON_EXPORT void addCallback(triton::callbacks::getConcreteMemoryValueCallback cb);

        TRITON_EXPORT void addCallback(triton::callbacks::getConcreteRegisterValueCallback cb);

        TRITON_EXPORT void addCallback(triton::callbacks::setConcreteMemoryValueCallback cb);

        TRITON_EXPORT void addCallback(triton::callbacks::setConcreteRegisterValueCallback cb);

        TRITON_EXPORT void addCallback(triton::callbacks::symbolicSimplificationCallback cb);

        TRITON_EXPORT void removeAllCallbacks(void);

        TRITON_EXPORT void removeCallback(triton::callbacks::getConcreteMemoryValueCallback cb);

        TRITON_EXPORT void removeCallback(triton::callbacks::getConcreteRegisterValueCallback cb);

        TRITON_EXPORT void removeCallback(triton::callbacks::setConcreteMemoryValueCallback cb);

        TRITON_EXPORT void removeCallback(triton::callbacks::setConcreteRegisterValueCallback cb);

        TRITON_EXPORT void removeCallback(triton::callbacks::symbolicSimplificationCallback cb);

        TRITON_EXPORT triton::ast::SharedAbstractNode processCallbacks(triton::callbacks::callback_e kind, triton::ast::SharedAbstractNode node) const;

        TRITON_EXPORT void processCallbacks(triton::callbacks::callback_e kind, const triton::arch::MemoryAccess& mem) const;

        TRITON_EXPORT void processCallbacks(triton::callbacks::callback_e kind, const triton::arch::Register& reg) const;



        /* Modes API====================================================================================== */

        TRITON_EXPORT void checkModes(void) const;

        TRITON_EXPORT void enableMode(enum triton::modes::mode_e mode, bool flag);

        TRITON_EXPORT bool isModeEnabled(enum triton::modes::mode_e mode) const;



        /* Symbolic engine API =========================================================================== */

        TRITON_EXPORT void checkSymbolic(void) const;

        TRITON_EXPORT triton::engines::symbolic::SymbolicEngine* getSymbolicEngine(void);

        TRITON_EXPORT std::map<triton::arch::registers_e, triton::engines::symbolic::SharedSymbolicExpression> getSymbolicRegisters(void) const;

        TRITON_EXPORT std::map<triton::uint64, triton::engines::symbolic::SharedSymbolicExpression> getSymbolicMemory(void) const;

        TRITON_EXPORT triton::engines::symbolic::SharedSymbolicExpression getSymbolicMemory(triton::uint64 addr) const;

        TRITON_EXPORT const triton::engines::symbolic::SharedSymbolicExpression& getSymbolicRegister(const triton::arch::Register& reg) const;

        TRITON_EXPORT triton::uint8 getSymbolicMemoryValue(triton::uint64 address);

        TRITON_EXPORT triton::uint512 getSymbolicMemoryValue(const triton::arch::MemoryAccess& mem);

        TRITON_EXPORT std::vector<triton::uint8> getSymbolicMemoryAreaValue(triton::uint64 baseAddr, triton::usize size);

        TRITON_EXPORT triton::uint512 getSymbolicRegisterValue(const triton::arch::Register& reg);

        TRITON_EXPORT triton::engines::symbolic::SymbolicVariable* convertExpressionToSymbolicVariable(triton::usize exprId, triton::uint32 symVarSize, const std::string& symVarComment="");

        TRITON_EXPORT triton::engines::symbolic::SymbolicVariable* convertMemoryToSymbolicVariable(const triton::arch::MemoryAccess& mem, const std::string& symVarComment="");

        TRITON_EXPORT triton::engines::symbolic::SymbolicVariable* convertRegisterToSymbolicVariable(const triton::arch::Register& reg, const std::string& symVarComment="");

        TRITON_EXPORT triton::ast::SharedAbstractNode getOperandAst(const triton::arch::OperandWrapper& op);

        TRITON_EXPORT triton::ast::SharedAbstractNode getOperandAst(triton::arch::Instruction& inst, const triton::arch::OperandWrapper& op);

        TRITON_EXPORT triton::ast::SharedAbstractNode getImmediateAst(const triton::arch::Immediate& imm);

        TRITON_EXPORT triton::ast::SharedAbstractNode getImmediateAst(triton::arch::Instruction& inst, const triton::arch::Immediate& imm);

        TRITON_EXPORT triton::ast::SharedAbstractNode getMemoryAst(const triton::arch::MemoryAccess& mem);

        TRITON_EXPORT triton::ast::SharedAbstractNode getMemoryAst(triton::arch::Instruction& inst, const triton::arch::MemoryAccess& mem);

        TRITON_EXPORT triton::ast::SharedAbstractNode getRegisterAst(const triton::arch::Register& reg);

        TRITON_EXPORT triton::ast::SharedAbstractNode getRegisterAst(triton::arch::Instruction& inst, const triton::arch::Register& reg);

        TRITON_EXPORT triton::engines::symbolic::SharedSymbolicExpression newSymbolicExpression(const triton::ast::SharedAbstractNode& node, const std::string& comment="");

        TRITON_EXPORT triton::engines::symbolic::SymbolicVariable* newSymbolicVariable(triton::uint32 varSize, const std::string& comment="");

        TRITON_EXPORT void removeSymbolicExpression(triton::usize symExprId);

        TRITON_EXPORT const triton::engines::symbolic::SharedSymbolicExpression& createSymbolicExpression(triton::arch::Instruction& inst, const triton::ast::SharedAbstractNode& node, const triton::arch::OperandWrapper& dst, const std::string& comment="");

        TRITON_EXPORT const triton::engines::symbolic::SharedSymbolicExpression& createSymbolicMemoryExpression(triton::arch::Instruction& inst, const triton::ast::SharedAbstractNode& node, const triton::arch::MemoryAccess& mem, const std::string& comment="");

        TRITON_EXPORT const triton::engines::symbolic::SharedSymbolicExpression& createSymbolicRegisterExpression(triton::arch::Instruction& inst, const triton::ast::SharedAbstractNode& node, const triton::arch::Register& reg, const std::string& comment="");

        TRITON_EXPORT const triton::engines::symbolic::SharedSymbolicExpression& createSymbolicFlagExpression(triton::arch::Instruction& inst, const triton::ast::SharedAbstractNode& node, const triton::arch::Register& flag, const std::string& comment="");

        TRITON_EXPORT const triton::engines::symbolic::SharedSymbolicExpression& createSymbolicVolatileExpression(triton::arch::Instruction& inst, const triton::ast::SharedAbstractNode& node, const std::string& comment="");

        TRITON_EXPORT void assignSymbolicExpressionToMemory(const triton::engines::symbolic::SharedSymbolicExpression& se, const triton::arch::MemoryAccess& mem);

        TRITON_EXPORT void assignSymbolicExpressionToRegister(const triton::engines::symbolic::SharedSymbolicExpression& se, const triton::arch::Register& reg);

        TRITON_EXPORT triton::ast::SharedAbstractNode processSimplification(const triton::ast::SharedAbstractNode& node, bool z3=false) const;

        TRITON_EXPORT triton::engines::symbolic::SharedSymbolicExpression getSymbolicExpressionFromId(triton::usize symExprId) const;

        TRITON_EXPORT triton::engines::symbolic::SymbolicVariable* getSymbolicVariableFromId(triton::usize symVarId) const;

        TRITON_EXPORT triton::engines::symbolic::SymbolicVariable* getSymbolicVariableFromName(const std::string& symVarName) const;

        TRITON_EXPORT const std::vector<triton::engines::symbolic::PathConstraint>& getPathConstraints(void) const;

        TRITON_EXPORT triton::ast::SharedAbstractNode getPathConstraintsAst(void);

        TRITON_EXPORT void addPathConstraint(const triton::arch::Instruction& inst, const triton::engines::symbolic::SharedSymbolicExpression& expr);

        TRITON_EXPORT void clearPathConstraints(void);

        TRITON_EXPORT void enableSymbolicEngine(bool flag);

        TRITON_EXPORT bool isSymbolicEngineEnabled(void) const;

        TRITON_EXPORT bool isSymbolicExpressionIdExists(triton::usize symExprId) const;

        TRITON_EXPORT bool isMemorySymbolized(const triton::arch::MemoryAccess& mem) const;

        TRITON_EXPORT bool isMemorySymbolized(triton::uint64 addr, triton::uint32 size=1) const;

        TRITON_EXPORT bool isRegisterSymbolized(const triton::arch::Register& reg) const;

        TRITON_EXPORT void concretizeAllMemory(void);

        TRITON_EXPORT void concretizeAllRegister(void);

        TRITON_EXPORT void concretizeMemory(const triton::arch::MemoryAccess& mem);

        TRITON_EXPORT void concretizeMemory(triton::uint64 addr);

        TRITON_EXPORT void concretizeRegister(const triton::arch::Register& reg);

        TRITON_EXPORT triton::ast::SharedAbstractNode unrollAst(const triton::ast::SharedAbstractNode& node);

        TRITON_EXPORT std::map<triton::usize, triton::engines::symbolic::SharedSymbolicExpression> sliceExpressions(const triton::engines::symbolic::SharedSymbolicExpression& expr);

        TRITON_EXPORT std::list<triton::engines::symbolic::SharedSymbolicExpression> getTaintedSymbolicExpressions(void) const;

        TRITON_EXPORT std::unordered_map<triton::usize, triton::engines::symbolic::SharedSymbolicExpression> getSymbolicExpressions(void) const;

        TRITON_EXPORT const std::unordered_map<triton::usize, triton::engines::symbolic::SymbolicVariable*>& getSymbolicVariables(void) const;

        TRITON_EXPORT const triton::uint512& getConcreteVariableValue(const triton::engines::symbolic::SymbolicVariable& symVar) const;

        TRITON_EXPORT void setConcreteVariableValue(const triton::engines::symbolic::SymbolicVariable& symVar, const triton::uint512& value);



        /* Solver engine API ============================================================================= */

        TRITON_EXPORT void checkSolver(void) const;

        TRITON_EXPORT std::map<triton::uint32, triton::engines::solver::SolverModel> getModel(const triton::ast::SharedAbstractNode& node) const;

        TRITON_EXPORT std::list<std::map<triton::uint32, triton::engines::solver::SolverModel>> getModels(const triton::ast::SharedAbstractNode& node, triton::uint32 limit) const;

        TRITON_EXPORT bool isSat(const triton::ast::SharedAbstractNode& node) const;



        /* Z3 interface API ============================================================================== */

        TRITON_EXPORT void checkZ3Interface(void) const;

        TRITON_EXPORT triton::uint512 evaluateAstViaZ3(const triton::ast::SharedAbstractNode& node) const;

        TRITON_EXPORT triton::ast::SharedAbstractNode processZ3Simplification(const triton::ast::SharedAbstractNode& node) const;



        /* Taint engine API ============================================================================== */

        TRITON_EXPORT void checkTaint(void) const;

        TRITON_EXPORT triton::engines::taint::TaintEngine* getTaintEngine(void);

        TRITON_EXPORT const std::set<triton::uint64>& getTaintedMemory(void) const;

        TRITON_EXPORT std::set<const triton::arch::Register*> getTaintedRegisters(void) const;

        TRITON_EXPORT void enableTaintEngine(bool flag);

        TRITON_EXPORT bool isTaintEngineEnabled(void) const;

        TRITON_EXPORT bool isTainted(const triton::arch::OperandWrapper& op) const;

        TRITON_EXPORT bool isMemoryTainted(triton::uint64 addr, triton::uint32 size=1) const;

        TRITON_EXPORT bool isMemoryTainted(const triton::arch::MemoryAccess& mem) const;

        TRITON_EXPORT bool isRegisterTainted(const triton::arch::Register& reg) const;

        TRITON_EXPORT bool setTaint(const triton::arch::OperandWrapper& op, bool flag);

        TRITON_EXPORT bool setTaintMemory(const triton::arch::MemoryAccess& mem, bool flag);

        TRITON_EXPORT bool setTaintRegister(const triton::arch::Register& reg, bool flag);

        TRITON_EXPORT bool taintMemory(triton::uint64 addr);

        TRITON_EXPORT bool taintMemory(const triton::arch::MemoryAccess& mem);

        TRITON_EXPORT bool taintRegister(const triton::arch::Register& reg);

        TRITON_EXPORT bool untaintMemory(triton::uint64 addr);

        TRITON_EXPORT bool untaintMemory(const triton::arch::MemoryAccess& mem);

        TRITON_EXPORT bool untaintRegister(const triton::arch::Register& reg);

        TRITON_EXPORT bool taintUnion(const triton::arch::OperandWrapper& op1, const triton::arch::OperandWrapper& op2);

        TRITON_EXPORT bool taintAssignment(const triton::arch::OperandWrapper& op1, const triton::arch::OperandWrapper& op2);

        TRITON_EXPORT bool taintUnionMemoryImmediate(const triton::arch::MemoryAccess& memDst);

        TRITON_EXPORT bool taintUnionMemoryMemory(const triton::arch::MemoryAccess& memDst, const triton::arch::MemoryAccess& memSrc);

        TRITON_EXPORT bool taintUnionMemoryRegister(const triton::arch::MemoryAccess& memDst, const triton::arch::Register& regSrc);

        TRITON_EXPORT bool taintUnionRegisterImmediate(const triton::arch::Register& regDst);

        TRITON_EXPORT bool taintUnionRegisterMemory(const triton::arch::Register& regDst, const triton::arch::MemoryAccess& memSrc);

        TRITON_EXPORT bool taintUnionRegisterRegister(const triton::arch::Register& regDst, const triton::arch::Register& regSrc);

        TRITON_EXPORT bool taintAssignmentMemoryImmediate(const triton::arch::MemoryAccess& memDst);

        TRITON_EXPORT bool taintAssignmentMemoryMemory(const triton::arch::MemoryAccess& memDst, const triton::arch::MemoryAccess& memSrc);

        TRITON_EXPORT bool taintAssignmentMemoryRegister(const triton::arch::MemoryAccess& memDst, const triton::arch::Register& regSrc);

        TRITON_EXPORT bool taintAssignmentRegisterImmediate(const triton::arch::Register& regDst);

        TRITON_EXPORT bool taintAssignmentRegisterMemory(const triton::arch::Register& regDst, const triton::arch::MemoryAccess& memSrc);

        TRITON_EXPORT bool taintAssignmentRegisterRegister(const triton::arch::Register& regDst, const triton::arch::Register& regSrc);
    };

};

#endif /* TRITON_API_H */