dex_analysis.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_analysis.hpp
// @brief This file offer all the analysis funcionality in just one class
// we will use all the utilities from analysis.hpp
 
#ifndef KUNAI_DEX_ANALYSIS_DEX_ANALYSIS_HPP
#define KUNAI_DEX_ANALYSIS_DEX_ANALYSIS_HPP
 
#include "Kunai/DEX/analysis/analysis.hpp"
#include "Kunai/DEX/DVM/dex_disassembler.hpp"
 
namespace KUNAI
{
namespace DEX
{
    class Analysis
    {
        std::vector<Parser*> parsers;
 
        std::unordered_map<std::string,
            std::unique_ptr<ClassAnalysis>> classes;
 
        std::unordered_map<std::string,
            std::unique_ptr<ExternalClass>> external_classes;
        
        std::unordered_map<std::string,
            std::unique_ptr<StringAnalysis>> strings;
        
        std::unordered_map<std::string,
            std::unique_ptr<MethodAnalysis>> methods;
 
        std::unordered_map<std::string,
            std::unique_ptr<ExternalMethod>> external_methods;
 
        std::unordered_map<std::string, MethodAnalysis*> methods_hashes;
        
        std::unordered_map<std::string,
            MethodAnalysis*> method_hashes;
 
        std::vector<FieldAnalysis*> all_fields;
        
        DexDisassembler * disassembler;
 
        bool created_xrefs = false;
 
        void _create_xrefs(ClassDef * current_class);
 
        MethodAnalysis* _resolve_method(std::string & class_name, 
            std::string & method_name, std::string & method_descriptor);
 
    public:
        Analysis(Parser * parser, DexDisassembler * disassembler, bool create_xrefs) : 
            created_xrefs(!create_xrefs), disassembler(disassembler)
        {
            if (parser)
                add(parser);
        }
 
        void add(Parser * parser);
 
        void create_xrefs();
 
        ClassAnalysis* get_class_analysis(std::string &class_name)
        {
            auto it = classes.find(class_name);
 
            if (it != classes.end())
                return it->second.get();
            
            return nullptr;
        }
 
        const std::unordered_map<std::string, std::unique_ptr<ClassAnalysis>>&
        get_classes() const
        {
            return classes;
        }
 
        std::unordered_map<std::string, std::unique_ptr<ClassAnalysis>>&
        get_classes()
        {
            return classes;
        }
 
        const std::unordered_map<std::string, std::unique_ptr<ExternalClass>>&
        get_external_classes() const
        {
            return external_classes;
        }
 
        std::unordered_map<std::string, std::unique_ptr<ExternalClass>>&
        get_external_classes()
        {
            return external_classes;
        }
    
        MethodAnalysis * get_method(std::variant<EncodedMethod*, ExternalMethod*> method)
        {
            std::string method_key;
 
            if (method.index() == 0)
                method_key = std::get<EncodedMethod*>(method)->getMethodID()->pretty_method();
            else
                method_key = std::get<ExternalMethod*>(method)->pretty_method_name();
            
            auto it = methods.find(method_key);
 
            if (it == methods.end())
                return nullptr;
            
            return it->second.get();
        }
 
        MethodAnalysis* get_method_analysis_by_name(std::string &class_name, 
            std::string &method_name, 
            std::string &method_descriptor)
        {
            std::string m_hash = class_name+method_name+method_descriptor;
 
            auto it = method_hashes.find(m_hash);
 
            if (it == method_hashes.end())
                return nullptr;
 
            return it->second;
        }
 
        MethodID* get_method_id_by_name(std::string &class_name, 
            std::string &method_name, 
            std::string &method_descriptor)
        {
            auto m_a = get_method_analysis_by_name(class_name, method_name, method_descriptor);
 
            if (m_a && (!m_a->external()))
                return std::get<EncodedMethod*>(m_a->get_encoded_method())->getMethodID();
            
            return nullptr;
        }
 
        const std::unordered_map<std::string, std::unique_ptr<MethodAnalysis>>&
        get_methods() const
        {
            return methods;
        }
 
        std::unordered_map<std::string, std::unique_ptr<MethodAnalysis>>&
        get_methods()
        {
            return methods;
        }
 
        const std::unordered_map<std::string, std::unique_ptr<ExternalMethod>>&
        get_external_methods() const
        {
            return external_methods;
        }
 
        std::unordered_map<std::string, std::unique_ptr<ExternalMethod>>&
        get_external_methods()
        {
            return external_methods;
        }
 
        FieldAnalysis* get_field_analysis(EncodedField* field)
        {
            auto class_analysis = get_class_analysis(reinterpret_cast<DVMClass*>(field->get_field()->get_class())->get_name());
 
            if (class_analysis)
                return class_analysis->get_field_analysis(field);
            
            return nullptr;
        }
 
        std::vector<FieldAnalysis*>& get_fields();
 
        const std::unordered_map<std::string,
            std::unique_ptr<StringAnalysis>>& get_string_analysis() const
        {
            return strings;
        }
 
        std::unordered_map<std::string,
            std::unique_ptr<StringAnalysis>>& get_string_analysis()
        {
            return strings;
        }
 
        std::vector<ClassAnalysis*> find_classes(std::string& name, bool no_external);
 
        std::vector<MethodAnalysis*> find_methods(std::string& class_name, 
            std::string& method_name, 
            std::string& descriptor, 
            std::string& accessflags,
            bool no_external);
 
        std::vector<StringAnalysis*> find_strings(std::string& str);
 
        std::vector<FieldAnalysis*> find_fields(std::string& class_name, 
            std::string& field_name, 
            std::string& field_type,
            std::string& accessflags);
    };
} // namespace DEX
} // namespace KUNAI
 
 
#endif