encoded.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 encoded.hpp
// @brief This file contains all the information from encoded data
// these classes are for annotations, arrays, fields, try-catch
// information, etc.
 
#ifndef KUNAI_DEX_PARSER_ENCODED_HPP
#define KUNAI_DEX_PARSER_ENCODED_HPP
 
#include "Kunai/DEX/parser/strings.hpp"
#include "Kunai/DEX/parser/fields.hpp"
#include "Kunai/DEX/parser/fields.hpp"
#include "Kunai/DEX/parser/methods.hpp"
#include "Kunai/DEX/DVM/dvm_types.hpp"
#include "Kunai/Utils/kunaistream.hpp"
 
#include <iostream>
#include <vector>
 
namespace KUNAI
{
namespace DEX
{
    class EncodedValue;
    using encodedvalue_t = std::unique_ptr<EncodedValue>;
 
    class EncodedArray
    {
        std::uint64_t array_size;
        std::vector<encodedvalue_t> values;
    public:
        EncodedArray() = default;
        ~EncodedArray() = default;
 
        void parse_encoded_array(stream::KunaiStream* stream,
                                Types* types,
                                Strings* strings);
 
        std::uint64_t get_array_size() const
        {
            return array_size;
        }
 
        const std::vector<encodedvalue_t>& get_values() const
        {
            return values;
        }
 
        std::vector<encodedvalue_t>& get_values()
        {
            return values;
        }
    };
 
    using encodedarray_t = std::unique_ptr<EncodedArray>;
 
    class AnnotationElement
    {
        std::string& name;
        encodedvalue_t value;
    public:
        AnnotationElement(std::string& name, encodedvalue_t value)
            : name(name), value(std::move(value))
        {}
 
        ~AnnotationElement() = default;
 
        std::string& get_name()
        {
            return name;
        }
 
        EncodedValue* get_value()
        {
            return value.get();
        }
    };
 
    using annotationelement_t = std::unique_ptr<AnnotationElement>;
 
    class EncodedAnnotation
    {
        DVMType* type;
        std::uint64_t size;
        std::vector<annotationelement_t> elements;
    public:
        EncodedAnnotation() = default;
        ~EncodedAnnotation() = default;
        
        void parse_encoded_annotation(
            stream::KunaiStream* stream,
            Types* types,
            Strings* strings
        );
 
        DVMType* get_annotation_type()
        {
            return type;
        }
 
        std::uint64_t get_size() const
        {
            return size;
        }
 
        const std::vector<annotationelement_t>& get_annotations() const
        {
            return elements;
        }
 
        std::vector<annotationelement_t>& get_annotations()
        {
            return elements;
        }
 
        AnnotationElement* get_annotation_by_pos(std::uint32_t pos);
    };
 
    class EncodedValue
    {
        TYPES::value_format value_type;
        std::uint8_t value_args;
        std::vector<std::uint8_t> values;
        EncodedArray array_data;
        EncodedAnnotation annotation;
    
    public:
        EncodedValue() = default;
        ~EncodedValue() = default;
 
        void parse_encoded_value(stream::KunaiStream* stream,
                                Types* types,
                                Strings* strings);
 
        TYPES::value_format get_value_type() const
        {
            return value_type;
        }
 
        std::uint8_t size_of_value() const
        {
            return value_args;
        }
 
        const std::vector<std::uint8_t>& get_values() const
        {
            return values;
        }
 
        std::vector<std::uint8_t>& get_values()
        {
            return values;
        }
 
        const EncodedArray& get_array() const
        {
            return array_data;
        }
 
        EncodedArray& get_array()
        {
            return array_data;
        }
 
        const EncodedAnnotation& get_annotation() const
        {
            return annotation;
        }
 
        EncodedAnnotation& get_annotation()
        {
            return annotation;
        }
    };
 
    class EncodedField
    {
        FieldID * field_idx;
        TYPES::access_flags flags;
        EncodedArray* initial_value;
    public:
        EncodedField(FieldID * field_idx, TYPES::access_flags flags)
            : field_idx(field_idx), flags(flags)
        {
            this->field_idx->set_encoded_field(this);
        }
 
        ~EncodedField() = default;
 
        const FieldID* get_field() const
        {
            return field_idx;
        }
 
        FieldID* get_field()
        {
            return field_idx;
        }
 
        TYPES::access_flags  get_access_flags() const
        {
            return flags;
        }
 
        void set_initial_value(EncodedArray* initial_value)
        {
            this->initial_value = initial_value;
        }
 
        EncodedArray* get_initial_value()
        {
            return initial_value;
        }
    };
 
    using encodedfield_t = std::unique_ptr<EncodedField>;
 
    class EncodedTypePair
    {
        DVMType * type;
        std::uint64_t addr;
    public:
        EncodedTypePair(DVMType * type, std::uint64_t addr)
            : type(type), addr(addr)
        {}
        ~EncodedTypePair() = default;
 
        std::uint64_t get_addr() const
        {
            return addr;
        }
 
        const DVMType* get_exception_type() const
        {
            return type;
        }
 
        DVMType* get_exception_type()
        {
            return type;
        }
    };
 
    using encodedtypepair_t = std::unique_ptr<EncodedTypePair>;
 
    class EncodedCatchHandler
    {
        std::int64_t size;
        std::vector<encodedtypepair_t> handlers;
        std::uint64_t catch_all_addr = 0;
        std::uint64_t offset;
    public:
        EncodedCatchHandler() = default;
        ~EncodedCatchHandler() = default;
 
        void parse_encoded_catch_handler(stream::KunaiStream* stream,
                                         Types* types);
 
        bool has_explicit_typed_catches() const
        {
            if (size >= 0)
                return true; // user should check size of handlers
            return false;
        }
 
        std::int64_t get_size() const
        {
            return size;
        }
 
        std::uint64_t get_catch_all_addr() const
        {
            return catch_all_addr;
        }
 
        const std::vector<encodedtypepair_t>& get_handlers() const
        {
            return handlers;
        }
 
        std::vector<encodedtypepair_t>& get_handlers()
        {
            return handlers;
        }
 
        std::uint64_t get_offset() const
        {
            return offset;
        }
 
        EncodedTypePair *get_handler_by_pos(std::uint64_t pos);
    };
 
    using encodedcatchhandler_t = std::unique_ptr<EncodedCatchHandler>;
 
    class TryItem
    {
    public:
#pragma pack(0)
        struct try_item_struct_t
        {
            std::uint32_t start_addr;   
            std::uint16_t insn_count;   
            std::uint16_t handler_off;  
        };
#pragma pack()
 
    private:
        try_item_struct_t try_item_struct;
 
    public:
        TryItem() = default;
        ~TryItem() = default;
        void parse_try_item(stream::KunaiStream* stream);
 
        std::uint32_t get_start_addr() const
        {
            return try_item_struct.start_addr;
        }
 
        std::uint16_t get_insn_count() const
        {
            return try_item_struct.insn_count;
        }
 
        std::uint16_t get_handler_off() const
        {
            return try_item_struct.handler_off;
        }
    };
 
    using tryitem_t = std::unique_ptr<TryItem>;
 
    class CodeItemStruct
    {
    public:
        struct code_item_struct_t
        {
            std::uint16_t registers_size;       
            std::uint16_t ins_size;             
            std::uint16_t outs_size;            
            std::uint16_t tries_size;           
            std::uint32_t debug_info_off;       
            std::uint32_t insns_size;           
        };
    private:
        code_item_struct_t code_item;
        std::vector<std::uint8_t> instructions_raw;
        std::vector<tryitem_t> try_items;
        std::uint64_t encoded_catch_handler_list_offset;
        std::uint64_t encoded_catch_handler_size;
        std::vector<encodedcatchhandler_t> encoded_catch_handlers;
    public:
        CodeItemStruct() = default;
        ~CodeItemStruct() = default;
 
        void parse_code_item_struct(
            stream::KunaiStream* stream,
            Types* types
        );
        std::uint16_t get_registers_size() const
        {
            return code_item.registers_size;
        }
 
        std::uint16_t get_incomings_args() const
        {
            return code_item.ins_size;
        }
 
        std::uint16_t get_outgoing_args() const
        {
            return code_item.outs_size;
        }
 
        std::uint16_t get_number_try_items() const
        {
            return code_item.tries_size;
        }
 
        std::uint16_t get_offset_to_debug_info() const
        {
            return code_item.debug_info_off;
        }
 
        std::uint16_t get_instructions_size() const
        {
            return code_item.insns_size;
        }
 
        const std::vector<std::uint8_t>& get_bytecode() const
        {
            return instructions_raw;
        }
 
        std::vector<std::uint8_t>& get_bytecode()
        {
            return instructions_raw;
        }
    
        const std::vector<tryitem_t>& get_try_items() const
        {
            return try_items;
        }
 
        std::vector<tryitem_t>& get_try_items()
        {
            return try_items;
        }
 
        std::uint64_t get_encoded_catch_handler_offset()
        {
            return encoded_catch_handler_list_offset;
        }
 
        const std::vector<encodedcatchhandler_t>& get_encoded_catch_handlers() const
        {
            return encoded_catch_handlers;
        }
 
        std::vector<encodedcatchhandler_t>& get_encoded_catch_handlers()
        {
            return encoded_catch_handlers;
        }
    };
 
    using codeitemstruct_t = std::unique_ptr<CodeItemStruct>;
    
    class EncodedMethod
    {
        MethodID* method_id;
        TYPES::access_flags access_flags;
        CodeItemStruct code_item;
    public:
        EncodedMethod(MethodID* method_id, TYPES::access_flags access_flags)
            : method_id(method_id), access_flags(access_flags)
        {
            this->method_id->set_encoded_method(this);
        }
 
        ~EncodedMethod() = default;
 
        void parse_encoded_method(stream::KunaiStream* stream,
                                  std::uint64_t code_off,
                                  Types* types);
        
        const MethodID* getMethodID() const
        {
            return method_id;
        }
 
        MethodID* getMethodID()
        {
            return method_id;
        }
 
        TYPES::access_flags get_access_flags() const
        {
            return access_flags;
        }
 
        const CodeItemStruct& get_code_item() const
        {
            return code_item;
        }
 
        CodeItemStruct& get_code_item()
        {
            return code_item;
        }
    };
 
    using encodedmethod_t = std::unique_ptr<EncodedMethod>;
} // namespace DEX
} // namespace KUNAI
 
 
#endif