types.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 types.hpp
// @brief Class for managing all the types from the DEX file
// the types are simply storing the string with the type.
#ifndef KUNAI_DEX_PARSER_TYPES_HPP
#define KUNAI_DEX_PARSER_TYPES_HPP
 
#include "Kunai/Utils/kunaistream.hpp"
#include "Kunai/DEX/parser/strings.hpp"
 
#include <vector>
#include <unordered_map>
#include <memory>
 
namespace KUNAI
{
namespace DEX
{
    class DVMType
    {
    public:
        enum type_e
        {
            FUNDAMENTAL,    
            CLASS,          
            ARRAY,          
            UNKNOWN         
        };
    
    private:
        enum type_e type;
        std::string raw_type;
 
    public:
        DVMType(type_e type, std::string raw_type)
            : type(type), raw_type(raw_type)
        {}
 
        virtual ~DVMType() = default;
 
        virtual type_e get_type() const = 0;
 
        virtual std::string print_type() const = 0;
        
        std::string& get_raw()
        {
            return raw_type;
        }
 
        virtual const std::string& pretty_print()
        {
            return raw_type;
        }
    };
 
    using dvmtype_t = std::unique_ptr<DVMType>;
 
    class DVMFundamental : public DVMType
    {
    public:
        enum fundamental_e
        {
            BOOLEAN,
            BYTE,
            CHAR,
            DOUBLE,
            FLOAT,
            INT,
            LONG,
            SHORT,
            VOID
        };
 
    private:
        enum fundamental_e f_type;
        std::string name;
 
        const std::unordered_map<fundamental_e, std::string> fundamental_s =
        {
            {BOOLEAN, "boolean"},
            {BYTE, "byte"},
            {CHAR, "char"},
            {DOUBLE, "double"},
            {FLOAT, "float"},
            {INT, "int"},
            {LONG, "long"},
            {SHORT, "short"},
            {VOID, "void"}
        };
    public:
        DVMFundamental(fundamental_e f_type, std::string name) :
            DVMType(FUNDAMENTAL, name), f_type(f_type), name(name)
        {}
 
        ~DVMFundamental() = default;
 
        type_e get_type() const override
        {
            return FUNDAMENTAL;
        }
 
        std::string print_type() const override
        {
            return "Fundamental";
        }
 
        fundamental_e get_fundamental_type() const
        {
            return f_type;
        }
 
        const std::string& print_fundamental_type(fundamental_e type) const
        {
            return fundamental_s.at(type);
        }
 
        const std::string& get_name() const
        {
            return name;
        }
 
        const std::string& pretty_print() override
        {
            return fundamental_s.at(f_type);
        }
    };
 
    class DVMClass : public DVMType
    {
        std::string name;
        std::string pretty_name;
 
    public:
        DVMClass(std::string name) :
            DVMType(CLASS, name), name(name)
        {}
 
        ~DVMClass() = default;
 
        type_e get_type() const override
        {
            return CLASS;
        }
 
        std::string print_type() const override
        {
            return "Class";
        }
 
        const std::string& get_name() const
        {
            return name;
        }
        
        std::string& get_name()
        {
            return name;
        }
 
        const std::string& pretty_print() override;
    };
 
    class DVMArray : public DVMType
    {
        
        size_t depth;
        dvmtype_t array_type;
        std::string pretty_name;
    public:
        DVMArray(std::string raw, size_t depth, dvmtype_t& array) :
            DVMType(ARRAY, raw), depth(depth), array_type(std::move(array))
        {}
 
        ~DVMArray() = default;
 
        type_e get_type() const override
        {
            return ARRAY;
        }
 
        std::string print_type() const override
        {
            return "Array";
        }
 
        const DVMType* get_array_type() const
        {
            return array_type.get();
        }
 
        size_t get_depth() const
        {
            return depth;
        }
 
        const std::string& pretty_print() override;
    };
 
    class Unknown : public DVMType
    {
    public:
        Unknown(std::string raw) :
            DVMType(UNKNOWN, raw)
        {}
 
        ~Unknown() = default;
 
        type_e get_type() const override
        {
            return UNKNOWN;
        }
 
        std::string print_type() const override
        {
            return "Unknown";
        }
    };
 
    class Types
    {
        std::vector<dvmtype_t> ordered_types;
        std::unordered_map<std::uint32_t, DVMType*> types_by_id;
        std::uint32_t number_of_types;
        std::uint32_t offset;
    public:
        Types() = default;
        ~Types() = default;
 
        void parse_types(
            stream::KunaiStream* stream,
            Strings* strings,
            std::uint32_t number_of_types,
            std::uint32_t types_offset
        );
 
        const std::vector<dvmtype_t>& get_ordered_types() const
        {
            return ordered_types;
        }
 
        const std::unordered_map<std::uint32_t, DVMType*>& get_types_by_id() const
        {
            return types_by_id;
        }
 
        DVMType* get_type_by_id(std::uint32_t type_id);
 
        DVMType* get_type_from_order(std::uint32_t pos);
 
        std::uint32_t get_number_of_types() const
        {
            return number_of_types;
        }
 
        std::uint32_t get_offset() const
        {
            return offset;
        }
 
        friend std::ostream &operator<<(std::ostream &os, const Types &entry);
 
        void to_xml(std::ofstream& xml_file);
    private:
        dvmtype_t parse_type(std::string& name);
    };
} // namespace DEX
} // namespace KUNAI
 
 
#endif