classes.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 classes.hpp
// @brief This is an important file, since classes manage all the magic
// behind the DEX files. Classes will contain all the encoded data
// (methods, fields, etc), as well as all the information about them
// two Classes are important here: `ClassDefsStruct` and `ClassDataItem`.
// `ClassDefsStruct` contains ids and offsets of the other information.
// while `ClassDataItem` contains all the items.
 
#ifndef KUNAI_DEX_PARSER_CLASSES_HPP
#define KUNAI_DEX_PARSER_CLASSES_HPP
 
#include "Kunai/DEX/parser/encoded.hpp"
#include "Kunai/DEX/parser/annotations.hpp"
 
#include <iostream>
#include <vector>
#include <unordered_map>
 
namespace KUNAI
{
namespace DEX
{
    class ClassDataItem
    {
        std::vector<encodedfield_t> static_fields;
        std::unordered_map<std::uint64_t, EncodedField*> static_fields_by_id;
 
        std::vector<encodedfield_t> instance_fields;
        std::unordered_map<std::uint64_t, EncodedField*> instance_fields_by_id;
 
        std::vector<encodedmethod_t> direct_methods;
        std::unordered_map<std::uint64_t, EncodedMethod*> direct_methods_by_id;
 
        std::vector<encodedmethod_t> virtual_methods;
        std::unordered_map<std::uint64_t, EncodedMethod*> virtual_methods_by_id;
 
        std::vector<EncodedField*> fields;
        std::vector<EncodedMethod*> methods;
        
 
    public:
        ClassDataItem() = default;
        ~ClassDataItem() = default;
 
        void parse_class_data_item(
            stream::KunaiStream* stream,
            Fields* fields,
            Methods* methods,
            Types* types
        );
 
        std::size_t get_number_of_static_fields() const
        {
            return static_fields.size();
        }
 
        std::size_t get_number_of_instance_fields() const
        {
            return instance_fields.size();
        }
 
        std::size_t get_number_of_direct_methods() const
        {
            return direct_methods.size();
        }
 
        std::size_t get_number_of_virtual_methods() const
        {
            return virtual_methods.size();
        }
 
        EncodedField* get_static_field_by_order(std::uint32_t ord);
 
        EncodedField* get_static_field_by_id(std::uint32_t id);
 
        EncodedField* get_instance_field_by_order(std::uint32_t ord);
 
        EncodedField* get_instance_field_by_id(std::uint32_t id);
 
        EncodedMethod* get_direct_method_by_order(std::uint32_t ord);
 
        EncodedMethod* get_direct_method_by_id(std::uint32_t id);
 
        EncodedMethod* get_virtual_method_by_order(std::uint32_t ord);
 
        EncodedMethod* get_virtual_method_by_id(std::uint32_t id); 
 
        std::vector<EncodedField*>& get_fields(); 
 
        std::vector<EncodedMethod*>& get_methods();
    };
 
    class ClassDef
    {
    public:
#pragma pack(1)
        struct classdefstruct_t
        {
            std::uint32_t class_idx;            
            std::uint32_t access_flags;         
            std::uint32_t superclass_idx;       
            std::uint32_t interfaces_off;       
            std::uint32_t source_file_idx;      
            std::uint32_t annotations_off;      
            std::uint32_t class_data_off;       
            std::uint32_t static_values_off;    
        };
#pragma pack()
 
    private:
        classdefstruct_t classdefstruct;
        DVMClass* class_idx;
        DVMClass* superclass_idx;
        std::string source_file;
 
        std::vector<DVMClass*> interfaces;
 
        AnnotationDirectoryItem annotation_directory;
 
        ClassDataItem class_data_item;
 
        std::vector<encodedarray_t> static_values;
    public:
        ClassDef() = default;
        ~ClassDef() = default;
 
        void parse_class_def(stream::KunaiStream* stream,
                             Strings* strings,
                             Types* types,
                             Fields* fields,
                             Methods* methods);
 
        const classdefstruct_t& get_class_def_struct() const
        {
            return classdefstruct;
        }
 
        classdefstruct_t& get_class_def_struct()
        {
            return classdefstruct;
        }
 
        DVMClass * get_class_idx()
        {
            return class_idx;
        }
 
        TYPES::access_flags get_access_flags() const
        {
            return static_cast<TYPES::access_flags>(classdefstruct.access_flags);
        }
 
        DVMClass * get_superclass()
        {
            return superclass_idx;
        }
 
        const std::string& get_source_file() const
        {
            return source_file;
        }
 
        const std::vector<DVMClass*>& get_interfaces() const
        {
            return interfaces;
        }
 
        std::vector<DVMClass*>& get_interfaces()
        {
            return interfaces;
        }
 
        const ClassDataItem& get_class_data_item() const
        {
            return class_data_item;
        }
 
        ClassDataItem& get_class_data_item()
        {
            return class_data_item;
        }
    
 
    };
 
    using classdef_t = std::unique_ptr<ClassDef>;
 
    class Classes
    {
        std::vector<classdef_t> class_defs;
        std::uint32_t number_of_classes;
    public:
        Classes() = default;
        ~Classes() = default;
        void parse_classes(
            stream::KunaiStream* stream,
            std::uint32_t number_of_classes,
            std::uint32_t offset,
            Strings* strings,
            Types* types,
            Fields* fields,
            Methods* methods 
        );
 
        std::uint32_t get_number_of_classes() const
        {
            return number_of_classes;
        }
 
        const std::vector<classdef_t>& get_classdefs() const
        {
            return class_defs;
        }
 
        std::vector<classdef_t>& get_classdefs()
        {
            return class_defs;
        }
 
        friend std::ostream& operator<<(std::ostream& os, const Classes& entry);
    };
} // namespace DEX
} // namespace KUNAI
 
 
#endif