arion.hpp

Go to the documentation of this file.

#ifndef ARION_ARION_HPP
#define ARION_ARION_HPP
 
#include <arion/archs/x86/gdt_manager.hpp>
#include <arion/capstone/capstone.h>
#include <arion/common/arch_manager.hpp>
#include <arion/common/baremetal_manager.hpp>
#include <arion/common/code_tracer.hpp>
#include <arion/common/config.hpp>
#include <arion/common/context_manager.hpp>
#include <arion/common/file_system_manager.hpp>
#include <arion/common/global_defs.hpp>
#include <arion/common/hooks_manager.hpp>
#include <arion/common/logger.hpp>
#include <arion/common/memory_manager.hpp>
#include <arion/common/signal_manager.hpp>
#include <arion/common/socket_manager.hpp>
#include <arion/common/threading_manager.hpp>
#include <arion/keystone/keystone.h>
#include <arion/platforms/linux/elf_loader.hpp>
#include <arion/platforms/linux/elf_parser.hpp>
#include <arion/platforms/linux/lnx_syscall_manager.hpp>
#include <arion/unicorn/unicorn.h>
#include <exception>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
namespace arion
{
extern std::map<CPU_ARCH, std::pair<uc_arch, uc_mode>> ARION_TO_UC_ARCH;
extern std::map<CPU_ARCH, std::vector<std::pair<ks_arch, ks_mode>>> ARION_TO_KS_ARCH;
extern std::map<CPU_ARCH, std::vector<std::pair<cs_arch, cs_mode>>> ARION_TO_CS_ARCH;
 
class ARION_EXPORT ArionGroup : public std::enable_shared_from_this<ArionGroup>
{
  private:
    bool trigger_stop;
    pid_t next_pid = ARION_PROCESS_PID;
    pid_t curr_pid = ARION_PROCESS_PID;
    std::map<pid_t, std::shared_ptr<Arion>> instances;
 
  public:
    size_t ARION_EXPORT count_arion_instances();
    std::map<pid_t, std::shared_ptr<Arion>> ARION_EXPORT get_arion_instances();
    bool ARION_EXPORT has_arion_instance(pid_t pid);
    std::shared_ptr<Arion> ARION_EXPORT get_arion_instance(pid_t pid);
    void ARION_EXPORT add_arion_instance(std::shared_ptr<Arion> arion, std::optional<pid_t> pid = std::nullopt,
                                         std::optional<pid_t> pgid = std::nullopt);
    void ARION_EXPORT remove_arion_instance(pid_t pid);
    void ARION_EXPORT run();
    void ARION_EXPORT stop();
    void ARION_EXPORT stop_curr();
    pid_t ARION_EXPORT get_curr_pid();
    void set_curr_pid(pid_t pid);
    pid_t get_next_pid();
    void set_next_pid(pid_t pid);
};
 
class ARION_EXPORT Arion : public std::enable_shared_from_this<Arion>
{
  private:
    std::vector<std::string> program_args;
    std::vector<std::string> program_env;
    std::weak_ptr<ArionGroup> group;
    std::weak_ptr<Arion> parent;
    std::vector<std::weak_ptr<Arion>> children;
    std::exception_ptr uc_exception = nullptr;
    bool afl_mode = false;
    std::vector<int> afl_signals;
    std::optional<ADDR> start = std::nullopt;
    std::optional<ADDR> end = std::nullopt;
    bool running = false;
    bool sync = false;
    bool stopped = false;
    bool zombie = false;
    pid_t pid = 0;
    pid_t pgid = 0;
    uint32_t sid = 0;
    uint32_t uid = 0;
    uint32_t gid = 0;
    uint32_t euid = 0;
    uint32_t egid = 0;
    static void new_instance_common_init(std::shared_ptr<Arion> arion, std::string fs_path = "/",
                                         std::vector<std::string> program_env = std::vector<std::string>(),
                                         std::string cwd = "",
                                         std::unique_ptr<Config> config = std::move(std::make_unique<Config>()));
    static void new_instance_common_finish(std::shared_ptr<Arion> arion, CPU_ARCH arch);
    void init_engines(CPU_ARCH arch);
    void init_file_program(std::shared_ptr<ExecutableParser> prog_parser);
    void init_baremetal_program();
    void init_dynamic_program(std::shared_ptr<ExecutableParser> prog_parser);
    void init_static_program(std::shared_ptr<ExecutableParser> prog_parser);
    void close_engines();
 
  public:
    std::unique_ptr<ArchManager> arch;
    std::unique_ptr<BaremetalManager> baremetal;
    std::unique_ptr<MemoryManager> mem;
    std::unique_ptr<FileSystemManager> fs;
    std::unique_ptr<SocketManager> sock;
    std::unique_ptr<HooksManager> hooks;
    std::unique_ptr<ThreadingManager> threads;
    std::unique_ptr<SignalManager> signals;
    std::unique_ptr<ContextManager> context;
    std::unique_ptr<LinuxSyscallManager> syscalls;
    std::unique_ptr<GdtManager> gdt_manager;
    std::unique_ptr<CodeTracer> tracer;
    std::unique_ptr<Logger> logger;
    std::unique_ptr<Config> config;
    std::unique_ptr<LNX_LOADER_PARAMS> loader_params;
    std::vector<std::shared_ptr<SIGNAL>> pending_signals;
    uc_engine *uc;
    std::vector<ks_engine *> ks;
    std::vector<csh *> cs;
    static std::shared_ptr<Arion> ARION_EXPORT
    new_instance(std::vector<std::string> program_args, std::string fs_path = "/",
                 std::vector<std::string> program_env = std::vector<std::string>(), std::string cwd = "",
                 std::unique_ptr<Config> config = std::move(std::make_unique<Config>()));
    static std::shared_ptr<Arion> ARION_EXPORT
    new_instance(std::unique_ptr<BaremetalManager> baremetal, std::string fs_path = "/",
                 std::vector<std::string> program_env = std::vector<std::string>(), std::string cwd = "",
                 std::unique_ptr<Config> config = std::move(std::make_unique<Config>()));
    ~Arion();
    void ARION_EXPORT set_run_bounds(std::optional<ADDR> start = std::nullopt, std::optional<ADDR> end = std::nullopt);
    void ARION_EXPORT set_run_start(std::optional<ADDR> start);
    void ARION_EXPORT set_run_end(std::optional<ADDR> end);
    bool run_current();
    void ARION_EXPORT stop();
    void crash(std::exception_ptr exception);
    void ARION_EXPORT sync_threads();
    bool ARION_EXPORT is_running();
    void init_afl_mode(std::vector<int> signals);
    void stop_afl_mode();
    std::shared_ptr<Arion> copy();
    bool ARION_EXPORT has_parent();
    std::shared_ptr<Arion> ARION_EXPORT get_parent();
    std::vector<std::shared_ptr<Arion>> ARION_EXPORT get_children();
    std::vector<std::shared_ptr<Arion>> ARION_EXPORT get_pgid_children(pid_t pgid);
    pid_t ARION_EXPORT add_child(std::shared_ptr<Arion> child);
    bool ARION_EXPORT has_child(pid_t child_pid);
    bool ARION_EXPORT is_child_of(pid_t parent_pid);
    std::shared_ptr<Arion> ARION_EXPORT get_child(pid_t child_pid);
    void ARION_EXPORT replace_child(pid_t child_pid, std::shared_ptr<Arion> child);
    void ARION_EXPORT remove_child(pid_t child_pid);
    void ARION_EXPORT clear_children();
    void execve(std::string file_path, std::vector<std::string> argv, std::vector<std::string> envp);
    std::vector<std::string> ARION_EXPORT get_program_args();
    std::vector<std::string> ARION_EXPORT get_program_env();
    pid_t ARION_EXPORT get_pid();
    void ARION_EXPORT set_pid(pid_t pid);
    pid_t ARION_EXPORT get_pgid();
    void ARION_EXPORT set_pgid(pid_t pgid);
    uint32_t ARION_EXPORT get_sid();
    void ARION_EXPORT set_sid(uint32_t sid);
    uint32_t ARION_EXPORT get_uid();
    void ARION_EXPORT set_uid(uint32_t uid);
    uint32_t ARION_EXPORT get_gid();
    void ARION_EXPORT set_gid(uint32_t gid);
    uint32_t ARION_EXPORT get_euid();
    void ARION_EXPORT set_euid(uint32_t euid);
    uint32_t ARION_EXPORT get_egid();
    void ARION_EXPORT set_egid(uint32_t egid);
    bool ARION_EXPORT has_group();
    std::shared_ptr<ArionGroup> ARION_EXPORT get_group();
    void set_group(std::shared_ptr<ArionGroup> group);
    void reset_group();
    bool is_stopped();
    void set_stopped();
    void set_resumed();
    bool is_zombie();
    void set_zombie();
    void ARION_EXPORT send_signal(pid_t source_pid, int signo);
    void ARION_EXPORT run_gdbserver(uint32_t port);
};
 
}; // namespace arion
 
#endif // ARION_ARION_HPP