context.hpp

Go to the documentation of this file.

 
/*
**  Copyright (C) - Triton
**
**  This program is under the terms of the Apache License 2.0.
*/
 
#ifndef TRITON_CONTEXT_H
#define TRITON_CONTEXT_H
 
#include <triton/architecture.hpp>
#include <triton/ast.hpp>
#include <triton/astContext.hpp>
#include <triton/astRepresentation.hpp>
#include <triton/basicBlock.hpp>
#include <triton/callbacks.hpp>
#include <triton/dllexport.hpp>
#include <triton/immediate.hpp>
#include <triton/instruction.hpp>
#include <triton/irBuilder.hpp>
#include <triton/liftingEngine.hpp>
#include <triton/memoryAccess.hpp>
#include <triton/modes.hpp>
#include <triton/operandWrapper.hpp>
#include <triton/register.hpp>
#include <triton/shortcutRegister.hpp>
#include <triton/solverEngine.hpp>
#include <triton/solverEnums.hpp>
#include <triton/symbolicEngine.hpp>
#include <triton/synthesizer.hpp>
#include <triton/taintEngine.hpp>
#include <triton/tritonTypes.hpp>
 
 
 
namespace triton {
    class Context {
      private:
        inline void checkArchitecture(void) const;
 
        inline void checkIrBuilder(void) const;
 
        inline void checkSymbolic(void) const;
 
        inline void checkSolver(void) const;
 
        inline void checkTaint(void) const;
 
        inline void checkLifting(void) const;
 
 
      protected:
        triton::callbacks::Callbacks callbacks;
 
        triton::arch::Architecture arch;
 
        triton::modes::SharedModes modes;
 
        triton::engines::lifters::LiftingEngine* lifting = nullptr;
 
        triton::engines::taint::TaintEngine* taint = nullptr;
 
        triton::engines::symbolic::SymbolicEngine* symbolic = nullptr;
 
        triton::engines::solver::SolverEngine* solver = nullptr;
 
        triton::ast::SharedAstContext astCtxt;
 
        triton::arch::IrBuilder* irBuilder = nullptr;
 
 
      public:
        triton::arch::ShortcutRegister registers;
 
        TRITON_EXPORT Context();
 
        TRITON_EXPORT Context(triton::arch::architecture_e arch);
 
        TRITON_EXPORT ~Context();
 
 
 
        /* Architecture API ============================================================================== */
 
        TRITON_EXPORT bool isArchitectureValid(void) const;
 
        TRITON_EXPORT triton::arch::architecture_e getArchitecture(void) const;
 
        TRITON_EXPORT triton::arch::endianness_e getEndianness(void) const;
 
        TRITON_EXPORT triton::arch::CpuInterface* getCpuInstance(void);
 
        TRITON_EXPORT void setArchitecture(triton::arch::architecture_e arch);
 
        TRITON_EXPORT void clearArchitecture(void);
 
        TRITON_EXPORT bool isFlag(triton::arch::register_e regId) const;
 
        TRITON_EXPORT bool isFlag(const triton::arch::Register& reg) const;
 
        TRITON_EXPORT bool isRegister(triton::arch::register_e regId) const;
 
        TRITON_EXPORT bool isRegister(const triton::arch::Register& reg) const;
 
        TRITON_EXPORT const triton::arch::Register& getRegister(triton::arch::register_e id) const;
 
        TRITON_EXPORT const triton::arch::Register& getRegister(const std::string& name) const;
 
        TRITON_EXPORT const triton::arch::Register& getParentRegister(const triton::arch::Register& reg) const;
 
        TRITON_EXPORT const triton::arch::Register& getParentRegister(triton::arch::register_e id) const;
 
        TRITON_EXPORT bool isRegisterValid(triton::arch::register_e regId) const;
 
        TRITON_EXPORT bool isRegisterValid(const triton::arch::Register& reg) const;
 
        TRITON_EXPORT bool isThumb(void) const;
 
        TRITON_EXPORT void setThumb(bool state);
 
        TRITON_EXPORT triton::uint32 getGprBitSize(void) const;
 
        TRITON_EXPORT triton::uint32 getGprSize(void) const;
 
        TRITON_EXPORT triton::uint32 getNumberOfRegisters(void) const;
 
        TRITON_EXPORT const triton::arch::Instruction getNopInstruction(void) const;
 
        TRITON_EXPORT const std::unordered_map<triton::arch::register_e, const triton::arch::Register>& getAllRegisters(void) const;
 
        TRITON_EXPORT const std::unordered_map<triton::uint64, triton::uint8, IdentityHash<triton::uint64>>& getConcreteMemory(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, bool execCallbacks=true);
 
        TRITON_EXPORT void setConcreteMemoryValue(const triton::arch::MemoryAccess& mem, const triton::uint512& value, bool execCallbacks=true);
 
        TRITON_EXPORT void setConcreteMemoryAreaValue(triton::uint64 baseAddr, const std::vector<triton::uint8>& values, bool execCallbacks=true);
 
        TRITON_EXPORT void setConcreteMemoryAreaValue(triton::uint64 baseAddr, const void* area, triton::usize size, bool execCallbacks=true);
 
        TRITON_EXPORT void setConcreteRegisterValue(const triton::arch::Register& reg, const triton::uint512& value, bool execCallbacks=true);
 
        TRITON_EXPORT void setConcreteState(triton::arch::Architecture& other);
 
        TRITON_EXPORT bool isConcreteMemoryValueDefined(const triton::arch::MemoryAccess& mem) const;
 
        TRITON_EXPORT bool isConcreteMemoryValueDefined(triton::uint64 baseAddr, triton::usize size=1) const;
 
        TRITON_EXPORT void clearConcreteMemoryValue(const triton::arch::MemoryAccess& mem);
 
        TRITON_EXPORT void clearConcreteMemoryValue(triton::uint64 baseAddr, triton::usize size=1);
 
        TRITON_EXPORT void disassembly(triton::arch::Instruction& inst) const;
 
        TRITON_EXPORT void disassembly(triton::arch::BasicBlock& block, triton::uint64 addr=0) const;
 
        TRITON_EXPORT std::vector<triton::arch::Instruction> disassembly(triton::uint64 addr, triton::usize count) const;
 
        TRITON_EXPORT triton::arch::BasicBlock disassembly(triton::uint64 addr, bool(*filterCallback)(std::vector<triton::arch::Instruction>&)) const;
 
        TRITON_EXPORT triton::arch::BasicBlock disassembly(triton::uint64 addr) const;
 
 
 
        /* Processing API ================================================================================ */
 
        TRITON_EXPORT triton::arch::exception_e processing(triton::arch::Instruction& inst);
 
        TRITON_EXPORT triton::arch::exception_e processing(triton::arch::BasicBlock& block, triton::uint64 addr=0);
 
        TRITON_EXPORT void initEngines(void);
 
        TRITON_EXPORT void removeEngines(void);
 
        TRITON_EXPORT void reset(void);
 
 
 
        /* IR API ======================================================================================== */
 
        TRITON_EXPORT triton::arch::exception_e buildSemantics(triton::arch::Instruction& inst);
 
        TRITON_EXPORT triton::arch::exception_e buildSemantics(triton::arch::BasicBlock& block);
 
        TRITON_EXPORT triton::ast::SharedAstContext getAstContext(void);
 
 
 
        /* AST Representation API ======================================================================== */
 
        TRITON_EXPORT triton::ast::representations::mode_e getAstRepresentationMode(void) const;
 
        TRITON_EXPORT void setAstRepresentationMode(triton::ast::representations::mode_e mode);
 
 
 
        /* Callbacks API ================================================================================= */
 
        template <typename T> void addCallback(triton::callbacks::callback_e kind, T cb) {
          this->callbacks.addCallback(kind, cb);
        }
 
        template <typename T> void removeCallback(triton::callbacks::callback_e kind, T cb) {
          this->callbacks.removeCallback(kind, cb);
        }
 
        TRITON_EXPORT void clearCallbacks(void);
 
        TRITON_EXPORT triton::ast::SharedAbstractNode processCallbacks(triton::callbacks::callback_e kind, triton::ast::SharedAbstractNode node);
 
        TRITON_EXPORT void processCallbacks(triton::callbacks::callback_e kind, const triton::arch::MemoryAccess& mem);
 
        TRITON_EXPORT void processCallbacks(triton::callbacks::callback_e kind, const triton::arch::Register& reg);
 
 
 
        /* Modes API====================================================================================== */
 
        TRITON_EXPORT void setMode(triton::modes::mode_e mode, bool flag);
 
        TRITON_EXPORT bool isModeEnabled(triton::modes::mode_e mode) const;
 
        TRITON_EXPORT void clearModes(void);
 
 
 
        /* Symbolic engine API =========================================================================== */
 
        TRITON_EXPORT triton::engines::symbolic::SymbolicEngine* getSymbolicEngine(void);
 
        TRITON_EXPORT std::unordered_map<triton::arch::register_e, triton::engines::symbolic::SharedSymbolicExpression> getSymbolicRegisters(void) const;
 
        TRITON_EXPORT std::unordered_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::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::SharedSymbolicVariable newSymbolicVariable(triton::uint32 varSize, const std::string& alias="");
 
        TRITON_EXPORT void removeSymbolicExpression(const triton::engines::symbolic::SharedSymbolicExpression& expr);
 
        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& 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 simplify(const triton::ast::SharedAbstractNode& node, bool usingSolver=false, bool usingLLVM=false) const;
 
        TRITON_EXPORT triton::arch::BasicBlock simplify(const triton::arch::BasicBlock& block, bool padding=false) const;
 
        TRITON_EXPORT triton::engines::symbolic::SharedSymbolicExpression getSymbolicExpression(triton::usize symExprId) const;
 
        TRITON_EXPORT triton::engines::symbolic::SharedSymbolicVariable getSymbolicVariable(triton::usize symVarId) const;
 
        TRITON_EXPORT triton::engines::symbolic::SharedSymbolicVariable getSymbolicVariable(const std::string& symVarName) const;
 
        TRITON_EXPORT const std::vector<triton::engines::symbolic::PathConstraint>& getPathConstraints(void) const;
 
        TRITON_EXPORT std::vector<triton::engines::symbolic::PathConstraint> getPathConstraints(triton::usize start, triton::usize end) const;
 
        TRITON_EXPORT std::vector<triton::engines::symbolic::PathConstraint> getPathConstraintsOfThread(triton::uint32 threadId) const;
 
        TRITON_EXPORT triton::ast::SharedAbstractNode getPathPredicate(void);
 
        TRITON_EXPORT std::vector<triton::ast::SharedAbstractNode> getPredicatesToReachAddress(triton::uint64 addr);
 
        TRITON_EXPORT triton::usize getSizeOfPathConstraints(void) const;
 
        TRITON_EXPORT void pushPathConstraint(const triton::ast::SharedAbstractNode& node, const std::string& comment="");
 
        TRITON_EXPORT void pushPathConstraint(const triton::engines::symbolic::PathConstraint& pco);
 
        TRITON_EXPORT void popPathConstraint(void);
 
        TRITON_EXPORT void clearPathConstraints(void);
 
        TRITON_EXPORT bool isSymbolicExpressionExists(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 triton::engines::symbolic::SharedSymbolicVariable symbolizeExpression(triton::usize exprId, triton::uint32 symVarSize, const std::string& symVarAlias="");
 
        TRITON_EXPORT triton::engines::symbolic::SharedSymbolicVariable symbolizeMemory(const triton::arch::MemoryAccess& mem, const std::string& symVarAlias="");
 
        TRITON_EXPORT void symbolizeMemory(triton::uint64 addr, triton::usize size);
 
        TRITON_EXPORT triton::engines::symbolic::SharedSymbolicVariable symbolizeRegister(const triton::arch::Register& reg, const std::string& symVarAlias="");
 
        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 std::unordered_map<triton::usize, triton::engines::symbolic::SharedSymbolicExpression> sliceExpressions(const triton::engines::symbolic::SharedSymbolicExpression& expr);
 
        TRITON_EXPORT std::vector<triton::engines::symbolic::SharedSymbolicExpression> getTaintedSymbolicExpressions(void) const;
 
        TRITON_EXPORT std::unordered_map<triton::usize, triton::engines::symbolic::SharedSymbolicExpression> getSymbolicExpressions(void) const;
 
        TRITON_EXPORT std::map<triton::usize, triton::engines::symbolic::SharedSymbolicVariable> getSymbolicVariables(void) const;
 
        TRITON_EXPORT triton::uint512 getConcreteVariableValue(const triton::engines::symbolic::SharedSymbolicVariable& symVar) const;
 
        TRITON_EXPORT void setConcreteVariableValue(const triton::engines::symbolic::SharedSymbolicVariable& symVar, const triton::uint512& value);
 
 
 
        /* Solver engine API ============================================================================= */
 
        TRITON_EXPORT std::unordered_map<triton::usize, triton::engines::solver::SolverModel> getModel(const triton::ast::SharedAbstractNode& node, triton::engines::solver::status_e* status = nullptr, triton::uint32 timeout = 0, triton::uint32* solvingTime = nullptr) const;
 
        TRITON_EXPORT std::vector<std::unordered_map<triton::usize, triton::engines::solver::SolverModel>> getModels(const triton::ast::SharedAbstractNode& node, triton::uint32 limit, triton::engines::solver::status_e* status = nullptr, triton::uint32 timeout = 0, triton::uint32* solvingTime = nullptr) const;
 
        TRITON_EXPORT bool isSat(const triton::ast::SharedAbstractNode& node, triton::engines::solver::status_e* status = nullptr, triton::uint32 timeout = 0, triton::uint32* solvingTime = nullptr) const;
 
        TRITON_EXPORT triton::engines::solver::solver_e getSolver(void) const;
 
        TRITON_EXPORT const triton::engines::solver::SolverInterface* getSolverInstance(void) const;
 
        TRITON_EXPORT void setSolver(triton::engines::solver::solver_e kind);
 
        TRITON_EXPORT void setCustomSolver(triton::engines::solver::SolverInterface* customSolver);
 
        TRITON_EXPORT bool isSolverValid(void) const;
 
        TRITON_EXPORT triton::uint512 evaluateAstViaSolver(const triton::ast::SharedAbstractNode& node) const;
 
        TRITON_EXPORT triton::ast::SharedAbstractNode simplifyAstViaSolver(const triton::ast::SharedAbstractNode& node) const;
 
        TRITON_EXPORT void setSolverTimeout(triton::uint32 ms);
 
        TRITON_EXPORT void setSolverMemoryLimit(triton::uint32 limit);
 
 
 
        /* Taint engine API ============================================================================== */
 
        TRITON_EXPORT triton::engines::taint::TaintEngine* getTaintEngine(void);
 
        TRITON_EXPORT const std::unordered_set<triton::uint64>& getTaintedMemory(void) const;
 
        TRITON_EXPORT std::unordered_set<const triton::arch::Register*> getTaintedRegisters(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 taintUnion(const triton::arch::MemoryAccess& memDst, const triton::arch::Immediate& imm);
 
        TRITON_EXPORT bool taintUnion(const triton::arch::MemoryAccess& memDst, const triton::arch::MemoryAccess& memSrc);
 
        TRITON_EXPORT bool taintUnion(const triton::arch::MemoryAccess& memDst, const triton::arch::Register& regSrc);
 
        TRITON_EXPORT bool taintUnion(const triton::arch::Register& regDst, const triton::arch::Immediate& imm);
 
        TRITON_EXPORT bool taintUnion(const triton::arch::Register& regDst, const triton::arch::MemoryAccess& memSrc);
 
        TRITON_EXPORT bool taintUnion(const triton::arch::Register& regDst, const triton::arch::Register& regSrc);
 
        TRITON_EXPORT bool taintAssignment(const triton::arch::OperandWrapper& op1, const triton::arch::OperandWrapper& op2);
 
        TRITON_EXPORT bool taintAssignment(const triton::arch::MemoryAccess& memDst, const triton::arch::Immediate& imm);
 
        TRITON_EXPORT bool taintAssignment(const triton::arch::MemoryAccess& memDst, const triton::arch::MemoryAccess& memSrc);
 
        TRITON_EXPORT bool taintAssignment(const triton::arch::MemoryAccess& memDst, const triton::arch::Register& regSrc);
 
        TRITON_EXPORT bool taintAssignment(const triton::arch::Register& regDst, const triton::arch::Immediate& imm);
 
        TRITON_EXPORT bool taintAssignment(const triton::arch::Register& regDst, const triton::arch::MemoryAccess& memSrc);
 
        TRITON_EXPORT bool taintAssignment(const triton::arch::Register& regDst, const triton::arch::Register& regSrc);
 
 
 
        /* Synthesizer engine API ============================================================================== */
 
        TRITON_EXPORT triton::engines::synthesis::SynthesisResult synthesize(const triton::ast::SharedAbstractNode& node, bool constant=true, bool subexpr=true, bool opaque=false);
 
 
 
        /* Lifters engine API ================================================================================= */
 
        TRITON_EXPORT std::ostream& liftToLLVM(std::ostream& stream, const triton::ast::SharedAbstractNode& node, const char* fname="__triton", bool optimize=false);
 
        TRITON_EXPORT std::ostream& liftToLLVM(std::ostream& stream, const triton::engines::symbolic::SharedSymbolicExpression& expr, const char* fname="__triton", bool optimize=false);
 
        TRITON_EXPORT std::ostream& liftToPython(std::ostream& stream, const triton::engines::symbolic::SharedSymbolicExpression& expr, bool icomment=false);
 
        TRITON_EXPORT std::ostream& liftToSMT(std::ostream& stream, const triton::engines::symbolic::SharedSymbolicExpression& expr, bool assert_=false, bool icomment=false);
 
        TRITON_EXPORT std::ostream& liftToDot(std::ostream& stream, const triton::ast::SharedAbstractNode& node);
 
        TRITON_EXPORT std::ostream& liftToDot(std::ostream& stream, const triton::engines::symbolic::SharedSymbolicExpression& expr);
 
        TRITON_EXPORT triton::ast::SharedAbstractNode simplifyAstViaLLVM(const triton::ast::SharedAbstractNode& node) const;
    };
 
};
 
#endif /* TRITON_CONTEXT_H */