dex_disassembler.hpp

//--------------------------------------------------------------------*- C++ -*-
// Kunai-static-analyzer: library for doing analysis of dalvik files
// @author Farenain <kunai.static.analysis@gmail.com>
// @author Ernesto Java <javaernesto@gmail.com>
//
// @file dex_disassembler.hpp
// @brief This class holds the different disassembly algorithms for DEX
// the user can retrieve any of them and use if for disassembly of the
// methods, internally dex_disassembler will provide the algorithms with
// an object of Disassembler class
 
#ifndef KUNAI_DEX_DVM_DEX_DISASSEMBLER_HPP
#define KUNAI_DEX_DVM_DEX_DISASSEMBLER_HPP
 
#include "Kunai/DEX/parser/methods.hpp"
#include "Kunai/DEX/parser/classes.hpp"
#include "Kunai/DEX/DVM/disassembler.hpp"
#include "Kunai/DEX/DVM/linear_sweep_disassembler.hpp"
#include "Kunai/DEX/DVM/recursive_traversal_disassembler.hpp"
 
namespace KUNAI
{
namespace DEX
{
    class DexDisassembler
    {
    public:
        enum class disassembly_algorithm
        {
            LINEAR_SWEEP_ALGORITHM,
            RECURSIVE_TRAVERSAL_ALGORITHM
        };
 
        
    private:
        disassembly_algorithm algorithm = disassembly_algorithm::LINEAR_SWEEP_ALGORITHM;
        Disassembler disassembler;
 
        Parser * parser;
 
        bool disassembly_correct = false;
 
        Disassembler::instructions_t dex_instructions;
 
        LinearSweepDisassembler linear_sweep;
 
        RecursiveTraversalDisassembler recursive_traversal;
    public:
 
        DexDisassembler(Parser * parser) :
            parser(parser)
        {
            disassembler.set_parser(parser);
            linear_sweep.set_internal_disassembler(&disassembler);
            recursive_traversal.set_internal_disassembler(&disassembler);
        }
 
        void set_disassembly_algorithm(disassembly_algorithm algorithm)
        {
            this->algorithm = algorithm;
        }
 
        const Disassembler::instructions_t& get_dex_instructions() const
        {
            return dex_instructions;
        }
 
        Disassembler::instructions_t& get_dex_instructions()
        {
            return dex_instructions;
        }
 
        bool correct_disassembly() const
        {
            return disassembly_correct;
        }
 
        void add_disassembly(DexDisassembler& other);
 
        void disassembly_dex();
 
        std::vector<std::unique_ptr<Instruction>>
            disassembly_buffer(std::vector<std::uint8_t>& buffer);
 
        DexDisassembler& operator+=(DexDisassembler& other);
    };
} // namespace DEX
} // namespace KUNAI
 
 
#endif