dvm_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 dvm_types.hpp
// @brief Useful types for working with the DVM
#ifndef KUNAI_DEX_DVM_DVM_TYPES_HPP
#define KUNAI_DEX_DVM_DVM_TYPES_HPP
 
#include <iostream>
#include <unordered_map>
 
namespace KUNAI
{
    namespace DEX
    {
        static const std::uint32_t ENDIAN_CONSTANT = 0x12345678;
        static const std::uint32_t REVERSE_ENDIAN_CONSTANT = 0x78563412;
        static const std::uint32_t NO_INDEX = 0xFFFFFFFF;
 
        static const std::uint8_t dex_magic[] = {'d', 'e', 'x', '\n'};
        static const std::uint8_t dex_magic_035[] = {'d', 'e', 'x', '\n', '0', '3', '5', '\0'};
        static const std::uint8_t dex_magic_037[] = {'d', 'e', 'x', '\n', '0', '3', '7', '\0'};
        static const std::uint8_t dex_magic_038[] = {'d', 'e', 'x', '\n', '0', '3', '8', '\0'};
        static const std::uint8_t dex_magic_039[] = {'d', 'e', 'x', '\n', '0', '3', '9', '\0'};
 
        namespace TYPES
        {
            enum REF_TYPE
            {
                REF_NEW_INSTANCE = 0x22,
                REF_CLASS_USAGE = 0x1c,
                INVOKE_VIRTUAL = 0x6e,
                INVOKE_SUPER = 0x6f,
                INVOKE_DIRECT = 0x70,
                INVOKE_STATIC = 0x71,
                INVOKE_INTERFACE = 0x72,
                INVOKE_VIRTUAL_RANGE = 0x74,
                INVOKE_SUPER_RANGE = 0x75,
                INVOKE_DIRECT_RANGE = 0x76,
                INVOKE_STATIC_RANGE = 0x77,
                INVOKE_INTERFACE_RANGE = 0x78
            };
 
            enum class Kind
            {
                METH = 0,          
                STRING = 1,        
                FIELD = 2,         
                TYPE = 3,          
                PROTO = 9,         
                METH_PROTO = 10,   
                CALL_SITE = 11,    
                VARIES = 4,        
                INLINE_METHOD = 5, 
                VTABLE_OFFSET = 6, 
                FIELD_OFFSET = 7,  
                RAW_STRING = 8,    
                NONE_KIND = 99,    
            };
 
            enum class Operation
            {
                CONDITIONAL_BRANCH_DVM_OPCODE = 0, 
                UNCONDITIONAL_BRANCH_DVM_OPCODE,   
                RET_BRANCH_DVM_OPCODE,             
                MULTI_BRANCH_DVM_OPCODE,           
                CALL_DVM_OPCODE,                   
                DATA_MOVEMENT_DVM_OPCODE,          
                FIELD_READ_DVM_OPCODE,             
                FIELD_WRITE_DVM_OPCODE,            
                NONE_OPCODE = 99                   
            };
 
            enum class Operand
            {
                REGISTER = 0, 
                LITERAL = 1,  
                RAW = 2,      
                OFFSET = 3,   
 
                KIND = 0x100, 
            };
 
            enum access_flags
            {
                NONE = 0x0,                         
                ACC_PUBLIC = 0x1,                   
                ACC_PRIVATE = 0x2,                  
                ACC_PROTECTED = 0x4,                
                ACC_STATIC = 0x8,                   
                ACC_FINAL = 0x10,                   
                ACC_SYNCHRONIZED = 0x20,            
                ACC_VOLATILE = 0x40,                
                ACC_BRIDGE = 0x40,                  
                ACC_TRANSIENT = 0x80,               
                ACC_VARARGS = 0x80,                 
                ACC_NATIVE = 0x100,                 
                ACC_INTERFACE = 0x200,              
                ACC_ABSTRACT = 0x400,               
                ACC_STRICT = 0x800,                 
                ACC_SYNTHETIC = 0x1000,             
                ACC_ANNOTATION = 0x2000,            
                ACC_ENUM = 0x4000,                  
                UNUSED = 0x8000,                    
                ACC_CONSTRUCTOR = 0x10000,          
                ACC_DECLARED_SYNCHRONIZED = 0x20000 
            };
 
            enum class value_format
            {
                VALUE_BYTE = 0x0,           
                VALUE_SHORT = 0x2,          
                VALUE_CHAR = 0x3,           
                VALUE_INT = 0x4,            
                VALUE_LONG = 0x6,           
                VALUE_FLOAT = 0x10,         
                VALUE_DOUBLE = 0x11,        
                VALUE_METHOD_TYPE = 0x15,   
                VALUE_METHOD_HANDLE = 0x16, 
                VALUE_STRING = 0x17,        
                VALUE_TYPE = 0x18,          
                VALUE_FIELD = 0x19,         
                VALUE_METHOD = 0x1A,        
                VALUE_ENUM = 0x1B,          
                VALUE_ARRAY = 0x1C,         
                VALUE_ANNOTATION = 0x1D,    
                VALUE_NULL = 0x1E,          
                VALUE_BOOLEAN = 0x1F        
            };
 
            enum opcodes
            {
#define OPCODE(ID, VAL) \
    ID = VAL,
#include "Kunai/DEX/DVM/definitions/dvm_types.def"
            };
 
            static const std::unordered_map<Kind, std::string> KindString =
                {
                    {Kind::METH, "METH"},
                    {Kind::STRING, "STRING"},
                    {Kind::TYPE, "TYPE"},
                    {Kind::PROTO, "PROTO"},
                    {Kind::METH_PROTO, "METH_PROTO"},
                    {Kind::CALL_SITE, "CALL_SITE"},
                    {Kind::VARIES, "VARIES"},
                    {Kind::INLINE_METHOD, "INLINE_METHOD"},
                    {Kind::VTABLE_OFFSET, "VTABLE_OFFSET"},
                    {Kind::FIELD_OFFSET, "FIELD_OFFSET"},
                    {Kind::RAW_STRING, "RAW_STRING"},
                    {Kind::NONE_KIND, "NONE"}};
 
            static const std::unordered_map<access_flags, std::string> ACCESS_FLAGS_STR =
                {
                    {access_flags::ACC_PUBLIC, "public"},
                    {access_flags::ACC_PRIVATE, "private"},
                    {access_flags::ACC_PROTECTED, "protected"},
                    {access_flags::ACC_STATIC, "static"},
                    {access_flags::ACC_FINAL, "final"},
                    {access_flags::ACC_SYNCHRONIZED, "synchronized"},
                    {access_flags::ACC_BRIDGE, "bridge"},
                    {access_flags::ACC_VARARGS, "varargs"},
                    {access_flags::ACC_NATIVE, "native"},
                    {access_flags::ACC_INTERFACE, "interface"},
                    {access_flags::ACC_ABSTRACT, "abstract"},
                    {access_flags::ACC_STRICT, "strictfp"},
                    {access_flags::ACC_SYNTHETIC, "synthetic"},
                    {access_flags::ACC_ENUM, "enum"},
                    {access_flags::UNUSED, "unused"},
                    {access_flags::ACC_CONSTRUCTOR, "constructor"},
                    {access_flags::ACC_DECLARED_SYNCHRONIZED, "synchronized"}};
 
            static const std::unordered_map<char, std::string> type_descriptor_map =
                {
                    {'V', "void"},
                    {'Z', "boolean"},
                    {'B', "byte"},
                    {'S', "short"},
                    {'C', "char"},
                    {'I', "int"},
                    {'J', "long"},
                    {'F', "float"},
                    {'D', "double"}};
        } // namespace TYPES
 
    } // namespace DEX
 
} // namespace KUNAI
 
#endif