luac_common.h File Reference

#include <rz_bin.h>
#include <rz_lib.h>
#include <rz_list.h>

Go to the source code of this file.

Classes
struct	lua_proto_ex
	Store valuable info when parsing. Treat luac file body as a main function. More...
struct	lua_constant_entry
	Store constant type, data, and offset of this constant in luac file. More...
struct	lua_upvalue_entry
	Store upvalue attributes. More...
struct	lua_lineinfo_entry
	Store line info attributes. More...
struct	lua_abs_lineinfo_entry
	Store line info attributes. More...
struct	lua_local_var_entry
	Store local var names and other info. More...
struct	lua_dbg_upvalue_entry
	Store upvalue's debug info. More...
struct	luac_bin_info

Macros
#define	LUAC_MAGIC_OFFSET   0x00
#define	LUAC_MAGIC_SIZE   4
#define	LUAC_VERSION_OFFSET   0x04
#define	LUAC_VERSION_SIZE   1
#define	LUAC_MAGIC   "\x1b\x4c\x75\x61"
#define	makevariant(t, v)   ((t) | ((v) << 4))
#define	LUA_TNIL   0
#define	LUA_TBOOLEAN   1
#define	LUA_TNUMBER   3
#define	LUA_TSTRING   4
#define	LUA_VNIL   makevariant(LUA_TNIL, 0)
#define	LUA_VFALSE   makevariant(LUA_TBOOLEAN, 0)
#define	LUA_VTRUE   makevariant(LUA_TBOOLEAN, 1)
#define	LUA_VNUMINT   makevariant(LUA_TNUMBER, 0) /* integer numbers */
#define	LUA_VNUMFLT   makevariant(LUA_TNUMBER, 1) /* float numbers */
#define	LUA_VSHRSTR   makevariant(LUA_TSTRING, 0) /* short strings */
#define	LUA_VLNGSTR   makevariant(LUA_TSTRING, 1) /* long strings */
#define	lua_check_error_offset(offset)
#define	lua_check_error_offset_proto(offset, proto)
#define	lua_return_if_null(proto)

Typedefs
typedef ut32	LUA_INSTRUCTION
typedef struct lua_proto_ex	LuaProtoHeavy
typedef LuaProtoHeavy	LuaProto
typedef struct lua_constant_entry	LuaConstEntry
typedef struct lua_upvalue_entry	LuaUpvalueEntry
typedef struct LuaProto	LuaProtoEntry
typedef struct lua_lineinfo_entry	LuaLineinfoEntry
typedef struct lua_abs_lineinfo_entry	LuaAbsLineinfoEntry
typedef struct lua_local_var_entry	LuaLocalVarEntry
typedef struct lua_dbg_upvalue_entry	LuaDbgUpvalueEntry
typedef struct luac_bin_info	LuacBinInfo

Functions
LuaDbgUpvalueEntry *	lua_new_dbg_upvalue_entry ()
LuaLocalVarEntry *	lua_new_local_var_entry ()
LuaAbsLineinfoEntry *	lua_new_abs_lineinfo_entry ()
LuaLineinfoEntry *	lua_new_lineinfo_entry ()
LuaUpvalueEntry *	lua_new_upvalue_entry ()
LuaConstEntry *	lua_new_const_entry ()
LuaProto *	lua_new_proto_entry ()
void	lua_free_dbg_upvalue_entry (LuaDbgUpvalueEntry *)
void	lua_free_local_var_entry (LuaLocalVarEntry *)
void	lua_free_const_entry (LuaConstEntry *)
void	lua_free_proto_entry (LuaProto *)
void	luac_add_section (RzList *section_list, char *name, ut64 offset, ut32 size, bool is_func)
void	luac_add_symbol (RzList *symbol_list, char *name, ut64 offset, ut64 size, const char *type)
void	luac_add_entry (RzList *entry_list, ut64 offset, int entry_type)
void	luac_add_string (RzList *string_list, char *string, ut64 offset, ut64 size)
LuacBinInfo *	luac_build_info (LuaProto *proto)
void	_luac_build_info (LuaProto *proto, LuacBinInfo *info)
RzBinInfo *	lua_parse_header_54 (RzBinFile *bf, st32 major, st32 minor)
LuaProto *	lua_parse_body_54 (RzBuffer *buffer, ut64 offset, ut64 data_size)
RzBinInfo *	lua_parse_header_53 (RzBinFile *bf, st32 major, st32 minor)
LuaProto *	lua_parse_body_53 (RzBuffer *buffer, ut64 offset, ut64 data_size)

Macro Definition Documentation

lua_check_error_offset

#define lua_check_error_offset

(

offset

)

Value:

    if ((offset) == 0) { \
        return 0; \
    }

Definition at line 208 of file luac_common.h.

lua_check_error_offset_proto

#define lua_check_error_offset_proto	(		offset,
			proto
	)

Value:

    if ((offset) == 0) { \
        lua_free_proto_entry((proto)); \
        return NULL; \
    }

Definition at line 212 of file luac_common.h.

lua_return_if_null

#define lua_return_if_null

(

proto

)

Value:

    if ((proto) == NULL) { \
        return 0; \
    }

Definition at line 217 of file luac_common.h.

LUA_TBOOLEAN

#define LUA_TBOOLEAN   1

Definition at line 27 of file luac_common.h.

LUA_TNIL

#define LUA_TNIL   0

Definition at line 26 of file luac_common.h.

LUA_TNUMBER

#define LUA_TNUMBER   3

Definition at line 28 of file luac_common.h.

LUA_TSTRING

#define LUA_TSTRING   4

Definition at line 29 of file luac_common.h.

LUA_VFALSE

#define LUA_VFALSE   makevariant(LUA_TBOOLEAN, 0)

Definition at line 32 of file luac_common.h.

LUA_VLNGSTR

#define LUA_VLNGSTR   makevariant(LUA_TSTRING, 1) /* long strings */

Definition at line 37 of file luac_common.h.

LUA_VNIL

#define LUA_VNIL   makevariant(LUA_TNIL, 0)

Definition at line 31 of file luac_common.h.

LUA_VNUMFLT

#define LUA_VNUMFLT   makevariant(LUA_TNUMBER, 1) /* float numbers */

Definition at line 35 of file luac_common.h.

LUA_VNUMINT

#define LUA_VNUMINT   makevariant(LUA_TNUMBER, 0) /* integer numbers */

Definition at line 34 of file luac_common.h.

LUA_VSHRSTR

#define LUA_VSHRSTR   makevariant(LUA_TSTRING, 0) /* short strings */

Definition at line 36 of file luac_common.h.

LUA_VTRUE

#define LUA_VTRUE   makevariant(LUA_TBOOLEAN, 1)

Definition at line 33 of file luac_common.h.

LUAC_MAGIC

#define LUAC_MAGIC   "\x1b\x4c\x75\x61"

Definition at line 21 of file luac_common.h.

LUAC_MAGIC_OFFSET

#define LUAC_MAGIC_OFFSET   0x00

Definition at line 16 of file luac_common.h.

LUAC_MAGIC_SIZE

#define LUAC_MAGIC_SIZE   4

Definition at line 17 of file luac_common.h.

LUAC_VERSION_OFFSET

#define LUAC_VERSION_OFFSET   0x04

Definition at line 18 of file luac_common.h.

LUAC_VERSION_SIZE

#define LUAC_VERSION_SIZE   1

Definition at line 19 of file luac_common.h.

makevariant

#define makevariant	(		t,
			v
	)		((t) | ((v) << 4))

Definition at line 24 of file luac_common.h.

Typedef Documentation

LUA_INSTRUCTION

typedef ut32 LUA_INSTRUCTION

Definition at line 13 of file luac_common.h.

LuaAbsLineinfoEntry

typedef struct lua_abs_lineinfo_entry LuaAbsLineinfoEntry

LuacBinInfo

typedef struct luac_bin_info LuacBinInfo

LuaConstEntry

typedef struct lua_constant_entry LuaConstEntry

LuaDbgUpvalueEntry

typedef struct lua_dbg_upvalue_entry LuaDbgUpvalueEntry

LuaLineinfoEntry

typedef struct lua_lineinfo_entry LuaLineinfoEntry

LuaLocalVarEntry

typedef struct lua_local_var_entry LuaLocalVarEntry

LuaProto

typedef LuaProtoHeavy LuaProto

Definition at line 87 of file luac_common.h.

LuaProtoEntry

typedef struct LuaProto LuaProtoEntry

Definition at line 87 of file luac_common.h.

LuaProtoHeavy

typedef struct lua_proto_ex LuaProtoHeavy

LuaUpvalueEntry

typedef struct lua_upvalue_entry LuaUpvalueEntry

Function Documentation

_luac_build_info()

void _luac_build_info	(	LuaProto *	proto,
		LuacBinInfo *	info
	)

Definition at line 225 of file luac_bin.c.

                                                          {
    /* process proto header info */
    char *section_name;
    char *symbol_name;
    char *proto_name;
    RzListIter *iter;
 
    ut64 current_offset;
    ut64 current_size;
 
    int i = 0; // iter
 
    // 0. check if stripped (proto name is lost)
    if (proto->name_size == 0 || proto->proto_name == NULL) {
        // replace name with current offset
        proto_name = rz_str_newf("fcn.%08llx", proto->offset);
    } else {
        proto_name = rz_str_new((char *)proto->proto_name);
    }
 
    // 1.1 set section name as function_name.header
    current_offset = proto->offset;
    current_size = proto->size;
    section_name = rz_str_newf("%s.header", proto_name);
    luac_add_section(info->section_list, section_name, current_offset, current_size, false);
    RZ_FREE(section_name);
 
    // 1.2 set section name as function_name.code
    current_offset = proto->code_offset;
    current_size = proto->code_size;
    section_name = rz_str_newf("%s.code", proto_name);
    luac_add_section(info->section_list, section_name, current_offset, current_size, true);
    RZ_FREE(section_name);
 
    // 1.3 set const section
    current_offset = proto->const_offset;
    current_size = proto->const_size;
    section_name = rz_str_newf("%s.const", proto_name);
    luac_add_section(info->section_list, section_name, current_offset, current_size, false);
    RZ_FREE(section_name);
 
    // 1.4 upvalue section
    current_offset = proto->upvalue_offset;
    current_size = proto->upvalue_size;
    section_name = rz_str_newf("%s.upvalues", proto_name);
    luac_add_section(info->section_list, section_name, current_offset, current_size, false);
    RZ_FREE(section_name);
 
    // 1.5 inner protos section
    current_offset = proto->inner_proto_offset;
    current_size = proto->inner_proto_size;
    section_name = rz_str_newf("%s.protos", proto_name);
    luac_add_section(info->section_list, section_name, current_offset, current_size, false);
    RZ_FREE(section_name);
 
    // 1.6 debug section
    current_offset = proto->debug_offset;
    current_size = proto->debug_size;
    section_name = rz_str_newf("%s.debug", proto_name);
    luac_add_section(info->section_list, section_name, current_offset, current_size, false);
    RZ_FREE(section_name);
 
    // 2.1 parse local var info
    LuaLocalVarEntry *local_var_entry;
    rz_list_foreach (proto->local_var_info_entries, iter, local_var_entry) {
        luac_add_string(
            info->string_list,
            (char *)local_var_entry->varname,
            local_var_entry->offset,
            local_var_entry->varname_len);
    }
 
    // 2.2 parse debug_upvalues
    char **upvalue_names;
    int real_upvalue_cnt;
    LuaDbgUpvalueEntry *debug_upv_entry;
    real_upvalue_cnt = rz_list_length(proto->upvalue_entries);
    upvalue_names = RZ_NEWS0(char *, real_upvalue_cnt);
    if (!upvalue_names) {
        return;
    }
    rz_list_foreach (proto->dbg_upvalue_entries, iter, debug_upv_entry) {
        upvalue_names[i] = (char *)debug_upv_entry->upvalue_name;
        luac_add_string(
            info->string_list,
            upvalue_names[i],
            debug_upv_entry->offset,
            debug_upv_entry->name_len);
    }
 
    // 3.1 construct constant symbols
    LuaConstEntry *const_entry;
    rz_list_foreach (proto->const_entries, iter, const_entry) {
        symbol_name = get_constant_symbol_name(proto_name, const_entry);
        luac_add_symbol(
            info->symbol_list,
            symbol_name,
            const_entry->offset,
            const_entry->data_len,
            get_tag_string(const_entry->tag));
        if (const_entry->tag == LUA_VLNGSTR || const_entry->tag == LUA_VSHRSTR) {
            luac_add_string(
                info->string_list,
                (char *)const_entry->data,
                const_entry->offset,
                const_entry->data_len);
        }
        RZ_FREE(symbol_name);
    }
 
    // 3.2 construct upvalue symbols
    LuaUpvalueEntry *upvalue_entry;
    i = 0;
    rz_list_foreach (proto->upvalue_entries, iter, upvalue_entry) {
        symbol_name = get_upvalue_symbol_name(proto_name, upvalue_entry, upvalue_names[i++]);
        luac_add_symbol(
            info->symbol_list,
            symbol_name,
            upvalue_entry->offset,
            3,
            "UPVALUE");
        RZ_FREE(symbol_name);
    }
 
    // 4. parse sub proto
    LuaProto *sub_proto;
    rz_list_foreach (proto->proto_entries, iter, sub_proto) {
        _luac_build_info(sub_proto, info);
    }
 
    RZ_FREE(proto_name);
}

References lua_proto_ex::code_offset, lua_proto_ex::code_size, lua_proto_ex::const_entries, lua_proto_ex::const_offset, lua_proto_ex::const_size, lua_constant_entry::data, lua_constant_entry::data_len, lua_proto_ex::dbg_upvalue_entries, lua_proto_ex::debug_offset, lua_proto_ex::debug_size, get_constant_symbol_name(), get_tag_string(), get_upvalue_symbol_name(), i, info(), lua_proto_ex::inner_proto_offset, lua_proto_ex::inner_proto_size, lua_proto_ex::local_var_info_entries, LUA_VLNGSTR, LUA_VSHRSTR, luac_add_section(), luac_add_string(), luac_add_symbol(), lua_dbg_upvalue_entry::name_len, lua_proto_ex::name_size, NULL, lua_proto_ex::offset, lua_constant_entry::offset, lua_upvalue_entry::offset, lua_local_var_entry::offset, lua_dbg_upvalue_entry::offset, lua_proto_ex::proto_entries, lua_proto_ex::proto_name, RZ_FREE, rz_list_length(), RZ_NEWS0, rz_str_new(), rz_str_newf(), lua_proto_ex::size, lua_constant_entry::tag, lua_proto_ex::upvalue_entries, lua_dbg_upvalue_entry::upvalue_name, lua_proto_ex::upvalue_offset, lua_proto_ex::upvalue_size, ut64(), lua_local_var_entry::varname, and lua_local_var_entry::varname_len.

Referenced by luac_build_info().

lua_free_const_entry()

void lua_free_const_entry

(

LuaConstEntry *

entry

)

Definition at line 111 of file luac_common.c.

                                                {
    if (!entry) {
        return;
    }
    free(entry->data);
    free(entry);
}

References free().

Referenced by lua_new_proto_entry().

lua_free_dbg_upvalue_entry()

void lua_free_dbg_upvalue_entry

(

LuaDbgUpvalueEntry *

entry

)

Definition at line 94 of file luac_common.c.

                                                           {
    if (!entry) {
        return;
    }
    free(entry->upvalue_name);
    // leave entry to rz_list_free
    free(entry);
}

References free().

Referenced by lua_new_proto_entry().

lua_free_local_var_entry()

void lua_free_local_var_entry

(

LuaLocalVarEntry *

entry

)

Definition at line 103 of file luac_common.c.

                                                       {
    if (!entry) {
        return;
    }
    free(entry->varname);
    free(entry);
}

References free().

Referenced by lua_new_proto_entry().

lua_free_proto_entry()

void lua_free_proto_entry

(

LuaProto *

proto

)

Definition at line 119 of file luac_common.c.

                                           {
    if (!proto) {
        return;
    }
 
    /* free constants entries */
    rz_list_free(proto->const_entries);
 
    /* free upvalue entries */
    rz_list_free(proto->upvalue_entries);
 
    /* free debug */
    rz_list_free(proto->line_info_entries);
    rz_list_free(proto->abs_line_info_entries);
    rz_list_free(proto->local_var_info_entries);
    rz_list_free(proto->dbg_upvalue_entries);
 
    /* recursively free protos */
    rz_list_free(proto->proto_entries);
 
    free(proto->proto_name);
    free(proto);
}

References lua_proto_ex::abs_line_info_entries, lua_proto_ex::const_entries, lua_proto_ex::dbg_upvalue_entries, free(), lua_proto_ex::line_info_entries, lua_proto_ex::local_var_info_entries, lua_proto_ex::proto_entries, lua_proto_ex::proto_name, rz_list_free(), and lua_proto_ex::upvalue_entries.

Referenced by load_buffer(), lua_new_proto_entry(), lua_parse_body_53(), and lua_parse_body_54().

lua_new_abs_lineinfo_entry()

LuaAbsLineinfoEntry* lua_new_abs_lineinfo_entry

(

)

Definition at line 18 of file luac_common.c.

                                                  {
    LuaAbsLineinfoEntry *entry = RZ_NEW0(LuaAbsLineinfoEntry);
    return entry;
}

References RZ_NEW0.

Referenced by lua_parse_debug().

lua_new_const_entry()

LuaConstEntry* lua_new_const_entry

(

)

Definition at line 33 of file luac_common.c.

                                     {
    LuaConstEntry *entry = RZ_NEW0(LuaConstEntry);
    return entry;
}

References RZ_NEW0.

Referenced by lua_parse_const_entry().

lua_new_dbg_upvalue_entry()

LuaDbgUpvalueEntry* lua_new_dbg_upvalue_entry

(

)

Definition at line 8 of file luac_common.c.

                                                {
    LuaDbgUpvalueEntry *entry = RZ_NEW0(LuaDbgUpvalueEntry);
    return entry;
}

References RZ_NEW0.

Referenced by lua_parse_debug().

lua_new_lineinfo_entry()

LuaLineinfoEntry* lua_new_lineinfo_entry

(

)

Definition at line 23 of file luac_common.c.

                                           {
    LuaLineinfoEntry *entry = RZ_NEW0(LuaLineinfoEntry);
    return entry;
}

References RZ_NEW0.

Referenced by lua_parse_debug().

lua_new_local_var_entry()

LuaLocalVarEntry* lua_new_local_var_entry

(

)

Definition at line 13 of file luac_common.c.

                                            {
    LuaLocalVarEntry *entry = RZ_NEW0(LuaLocalVarEntry);
    return entry;
}

References RZ_NEW0.

Referenced by lua_parse_debug().

lua_new_proto_entry()

LuaProto* lua_new_proto_entry

(

)

Definition at line 38 of file luac_common.c.

                                {
    LuaProto *proto = RZ_NEW0(LuaProto);
    if (!proto) {
        RZ_LOG_ERROR("Cannot allocate LuaProto\n");
        return NULL;
    }
 
    proto->const_entries = rz_list_newf((RzListFree)lua_free_const_entry);
    if (!proto->const_entries) {
        RZ_LOG_ERROR("Cannot allocate Const Entry List\n");
        goto fail;
    }
 
    proto->upvalue_entries = rz_list_newf(free);
    if (!proto->upvalue_entries) {
        RZ_LOG_ERROR("Cannot allocate Upvalue Entry List\n");
        goto fail;
    }
 
    proto->proto_entries = rz_list_newf((RzListFree)lua_free_proto_entry);
    if (!proto->proto_entries) {
        RZ_LOG_ERROR("Cannot allocate Proto Entry List\n");
        goto fail;
    }
 
    proto->line_info_entries = rz_list_newf(free);
    if (!proto->line_info_entries) {
        RZ_LOG_ERROR("Cannot allocate Debug Line Info\n");
        goto fail;
    }
 
    proto->abs_line_info_entries = rz_list_newf(free);
    if (!proto->abs_line_info_entries) {
        RZ_LOG_ERROR("Cannot allocate Abs Line Info\n");
        goto fail;
    }
 
    proto->local_var_info_entries = rz_list_newf((RzListFree)lua_free_local_var_entry);
    if (!proto->local_var_info_entries) {
        RZ_LOG_ERROR("Cannot allocate Local Var\n");
        goto fail;
    }
 
    proto->dbg_upvalue_entries = rz_list_newf((RzListFree)lua_free_dbg_upvalue_entry);
    if (!proto->dbg_upvalue_entries) {
        RZ_LOG_ERROR("Cannot allocate Debug Upvalues\n");
        goto fail;
    }
 
    return proto;
 
fail:
    lua_free_proto_entry(proto);
    return NULL;
}

References lua_proto_ex::abs_line_info_entries, lua_proto_ex::const_entries, lua_proto_ex::dbg_upvalue_entries, fail, free(), lua_proto_ex::line_info_entries, lua_proto_ex::local_var_info_entries, lua_free_const_entry(), lua_free_dbg_upvalue_entry(), lua_free_local_var_entry(), lua_free_proto_entry(), NULL, lua_proto_ex::proto_entries, rz_list_newf(), RZ_LOG_ERROR, RZ_NEW0, and lua_proto_ex::upvalue_entries.

Referenced by lua_parse_body_53(), and lua_parse_body_54().

lua_new_upvalue_entry()

LuaUpvalueEntry* lua_new_upvalue_entry

(

)

Definition at line 28 of file luac_common.c.

                                         {
    LuaUpvalueEntry *entry = RZ_NEW0(LuaUpvalueEntry);
    return entry;
}

References RZ_NEW0.

Referenced by lua_parse_upvalue_entry().

lua_parse_body_53()

LuaProto* lua_parse_body_53	(	RzBuffer *	buffer,
		ut64	offset,
		ut64	data_size
	)

Definition at line 407 of file parse_53.c.

                                                                                {
    ut64 offset;
    ut64 delta_offset;
 
    LuaProto *ret_proto = lua_new_proto_entry();
    if (!ret_proto) {
        return NULL;
    }
 
    // start parsing
    offset = base_offset;
 
    // record offset of main proto
    ret_proto->offset = offset;
 
    // parse proto name
    delta_offset = lua_parse_name(ret_proto, buffer, offset, data_size);
    lua_check_error_offset_proto(delta_offset, ret_proto);
    offset += delta_offset;
 
    /* parse line defined info */
    delta_offset = lua_parse_line_defined(ret_proto, buffer, offset, data_size);
    lua_check_error_offset_proto(delta_offset, ret_proto);
    offset += delta_offset;
 
    /* parse num params max_stack_size */
    if (offset + 3 > data_size) {
        lua_free_proto_entry(ret_proto);
        return NULL;
    }
    if (!rz_buf_read8_at(buffer, offset + 0, &ret_proto->num_params) ||
        !rz_buf_read8_at(buffer, offset + 1, &ret_proto->is_vararg) ||
        !rz_buf_read8_at(buffer, offset + 2, &ret_proto->max_stack_size)) {
        lua_free_proto_entry(ret_proto);
        return NULL;
    }
    offset += 3;
 
    /* parse code */
    ret_proto->code_offset = offset;
    delta_offset = lua_parse_code(ret_proto, buffer, offset, data_size);
    lua_check_error_offset_proto(delta_offset, ret_proto);
    offset += delta_offset;
 
    /* parse constants */
    ret_proto->const_offset = offset;
    delta_offset = lua_parse_consts(ret_proto, buffer, offset, data_size);
    lua_check_error_offset_proto(delta_offset, ret_proto);
    offset += delta_offset;
 
    /* parse upvalues */
    ret_proto->upvalue_offset = offset;
    delta_offset = lua_parse_upvalues(ret_proto, buffer, offset, data_size);
    lua_check_error_offset_proto(delta_offset, ret_proto);
    offset += delta_offset;
 
    /* parse inner protos */
    ret_proto->inner_proto_offset = offset;
    delta_offset = lua_parse_protos(ret_proto, buffer, offset, data_size);
    lua_check_error_offset_proto(delta_offset, ret_proto);
    offset += delta_offset;
 
    /* specially handle recursive protos size */
    ret_proto->inner_proto_size = offset - ret_proto->inner_proto_offset;
 
    /* parse debug */
    ret_proto->debug_offset = offset;
    delta_offset = lua_parse_debug(ret_proto, buffer, offset, data_size);
    lua_check_error_offset_proto(delta_offset, ret_proto);
    offset += delta_offset;
 
    ret_proto->size = offset - base_offset + 1;
 
    return ret_proto;
}

References lua_proto_ex::code_offset, lua_proto_ex::const_offset, lua_proto_ex::debug_offset, lua_proto_ex::inner_proto_offset, lua_proto_ex::inner_proto_size, lua_proto_ex::is_vararg, lua_check_error_offset_proto, lua_free_proto_entry(), lua_new_proto_entry(), lua_parse_code(), lua_parse_consts(), lua_parse_debug(), lua_parse_line_defined(), lua_parse_name(), lua_parse_protos(), lua_parse_upvalues(), lua_proto_ex::max_stack_size, NULL, lua_proto_ex::num_params, lua_proto_ex::offset, rz_buf_read8_at(), lua_proto_ex::size, lua_proto_ex::upvalue_offset, and ut64().

Referenced by load_buffer(), and lua_parse_protos().

lua_parse_body_54()

LuaProto* lua_parse_body_54	(	RzBuffer *	buffer,
		ut64	offset,
		ut64	data_size
	)

Definition at line 410 of file parse_54.c.

                                                                                {
    LuaProto *ret_proto; /* construted proto for return */
    ut64 offset; /* record offset */
    ut64 delta_offset;
    rz_return_val_if_fail((ret_proto = lua_new_proto_entry()), NULL);
 
    // start parsing
    offset = base_offset;
 
    /* record offset of main proto */
    ret_proto->offset = offset;
 
    /* parse proto name of main proto */
    delta_offset = lua_parse_name(ret_proto, buffer, offset, data_size);
    lua_check_error_offset_proto(delta_offset, ret_proto);
    offset += delta_offset;
 
    /* parse line defined info */
    delta_offset = lua_parse_line_defined(ret_proto, buffer, offset, data_size);
    lua_check_error_offset_proto(delta_offset, ret_proto);
    offset += delta_offset;
 
    /* parse num params max_stack_size */
    if (offset + 3 > data_size) {
        lua_free_proto_entry(ret_proto);
        return NULL;
    }
 
    if (!rz_buf_read8_at(buffer, offset + 0, &ret_proto->num_params) ||
        !rz_buf_read8_at(buffer, offset + 1, &ret_proto->is_vararg) ||
        !rz_buf_read8_at(buffer, offset + 2, &ret_proto->max_stack_size)) {
        lua_free_proto_entry(ret_proto);
        return NULL;
    }
    offset += 3;
 
    /* parse code */
    ret_proto->code_offset = offset;
    delta_offset = lua_parse_code(ret_proto, buffer, offset, data_size);
    lua_check_error_offset_proto(delta_offset, ret_proto);
    offset += delta_offset;
 
    /* parse constants */
    ret_proto->const_offset = offset;
    delta_offset = lua_parse_consts(ret_proto, buffer, offset, data_size);
    lua_check_error_offset_proto(delta_offset, ret_proto);
    offset += delta_offset;
 
    /* parse upvalues */
    ret_proto->upvalue_offset = offset;
    delta_offset = lua_parse_upvalues(ret_proto, buffer, offset, data_size);
    lua_check_error_offset_proto(delta_offset, ret_proto);
    offset += delta_offset;
 
    /* parse inner protos */
    ret_proto->inner_proto_offset = offset;
    delta_offset = lua_parse_protos(ret_proto, buffer, offset, data_size);
    lua_check_error_offset_proto(delta_offset, ret_proto);
    offset += delta_offset;
 
    /* specially handle recursive protos size */
    ret_proto->inner_proto_size = offset - ret_proto->inner_proto_offset;
 
    /* parse debug */
    ret_proto->debug_offset = offset;
    delta_offset = lua_parse_debug(ret_proto, buffer, offset, data_size);
    lua_check_error_offset_proto(delta_offset, ret_proto);
    offset += delta_offset;
 
    ret_proto->size = offset - base_offset + 1;
 
    return ret_proto;
}

References lua_proto_ex::code_offset, lua_proto_ex::const_offset, lua_proto_ex::debug_offset, lua_proto_ex::inner_proto_offset, lua_proto_ex::inner_proto_size, lua_proto_ex::is_vararg, lua_check_error_offset_proto, lua_free_proto_entry(), lua_new_proto_entry(), lua_parse_code(), lua_parse_consts(), lua_parse_debug(), lua_parse_line_defined(), lua_parse_name(), lua_parse_protos(), lua_parse_upvalues(), lua_proto_ex::max_stack_size, NULL, lua_proto_ex::num_params, lua_proto_ex::offset, rz_buf_read8_at(), rz_return_val_if_fail, lua_proto_ex::size, lua_proto_ex::upvalue_offset, and ut64().

Referenced by load_buffer(), and lua_parse_protos().

lua_parse_header_53()

RzBinInfo* lua_parse_header_53	(	RzBinFile *	bf,
		st32	major,
		st32	minor
	)

Definition at line 483 of file parse_53.c.

                                                                      {
    RzBinInfo *ret = NULL;
    RzBuffer *buffer;
 
    st64 reat = bf->size;
    if (reat < LUAC_53_HDRSIZE) {
        RZ_LOG_ERROR("Truncated header\n");
        return NULL;
    }
    buffer = bf->buf;
 
    /* read header members from work buffer */
    ut8 luac_format;
    if (!rz_buf_read8_at(buffer, LUAC_53_FORMAT_OFFSET, &luac_format)) {
        return NULL;
    }
    ut8 int_size;
    if (!rz_buf_read8_at(buffer, LUAC_53_INT_SIZE_OFFSET, &int_size)) {
        return NULL;
    }
    ut8 sizet_size;
    if (!rz_buf_read8_at(buffer, LUAC_53_SIZET_SIZE_OFFSET, &sizet_size)) {
        return NULL;
    }
    ut8 instruction_size;
    if (!rz_buf_read8_at(buffer, LUAC_53_INSTRUCTION_SIZE_OFFSET, &instruction_size)) {
        return NULL;
    }
    ut8 integer_size;
    if (!rz_buf_read8_at(buffer, LUAC_53_INTEGER_SIZE_OFFSET, &integer_size)) {
        return NULL;
    }
    ut8 number_size;
    if (!rz_buf_read8_at(buffer, LUAC_53_NUMBER_SIZE_OFFSET, &number_size)) {
        return NULL;
    }
    ut64 integer_valid = lua_load_integer(buffer, LUAC_53_INTEGER_VALID_OFFSET);
    double number_valid = lua_load_number(buffer, LUAC_53_NUMBER_VALID_OFFSET);
 
    /* Common Ret */
    if (!(ret = RZ_NEW0(RzBinInfo))) {
        return NULL;
    }
    ret->file = rz_str_new(bf->file);
    ret->type = rz_str_newf("Lua %c.%c compiled file", major + '0', minor + '0');
    ret->bclass = rz_str_new("Lua compiled file");
    ret->rclass = rz_str_new("luac");
    ret->arch = rz_str_new("luac");
    ret->machine = rz_str_newf("Lua %c.%c VM", major + '0', minor + '0');
    ret->os = rz_str_newf("%c.%c", major + '0', minor + '0');
    ret->cpu = rz_str_newf("%c.%c", major + '0', minor + '0');
    ret->bits = 8;
 
    /* official format ? */
    if (luac_format != LUAC_54_FORMAT) {
        ret->compiler = rz_str_new("Unofficial Lua Compiler");
        return ret;
    }
    ret->compiler = rz_str_new("Official Lua Compiler");
 
    /* Check Size */
    // TODO : remove this check and process different compiler options
    if ((instruction_size != sizeof(LUA_INSTRUCTION)) ||
        (integer_size != sizeof(LUA_INTEGER)) ||
        (number_size != sizeof(LUA_NUMBER)) ||
        (int_size != sizeof(LUA_INT)) ||
        (sizet_size != sizeof(size_t))) {
        RZ_LOG_ERROR("Size definition does not match with the expected size\n");
        return ret;
    }
 
    /* Check endian */
    if (integer_valid != LUAC_53_INT_VALIDATION) {
        RZ_LOG_ERROR("Integer format does not match with the expected integer\n");
        return ret;
    } else if (number_valid != LUAC_53_NUMBER_VALIDATION) {
        RZ_LOG_ERROR("Number format does not match with the expected number\n");
        return ret;
    }
 
    /* parse source file name */
    char *src_file_name = NULL;
    int name_len;
    lua_parse_string(buffer, ((ut8 **)&(src_file_name)), &name_len, LUAC_FILENAME_OFFSET, bf->size);
 
    /* put source file info into GUID */
    ret->guid = rz_str_new(src_file_name ? src_file_name : "stripped");
    free(src_file_name);
 
    return ret;
}

References rz_bin_info_t::arch, rz_bin_info_t::bclass, rz_bin_info_t::bits, rz_bin_file_t::buf, rz_bin_info_t::compiler, rz_bin_info_t::cpu, rz_bin_info_t::file, rz_bin_file_t::file, free(), rz_bin_info_t::guid, lua_load_integer(), lua_load_number(), lua_parse_string(), LUAC_53_FORMAT_OFFSET, LUAC_53_HDRSIZE, LUAC_53_INSTRUCTION_SIZE_OFFSET, LUAC_53_INT_SIZE_OFFSET, LUAC_53_INT_VALIDATION, LUAC_53_INTEGER_SIZE_OFFSET, LUAC_53_INTEGER_VALID_OFFSET, LUAC_53_NUMBER_SIZE_OFFSET, LUAC_53_NUMBER_VALID_OFFSET, LUAC_53_NUMBER_VALIDATION, LUAC_53_SIZET_SIZE_OFFSET, LUAC_54_FORMAT, LUAC_FILENAME_OFFSET, rz_bin_info_t::machine, major, minor, NULL, rz_bin_info_t::os, rz_bin_info_t::rclass, rz_buf_read8_at(), RZ_LOG_ERROR, RZ_NEW0, rz_str_new(), rz_str_newf(), rz_bin_file_t::size, st64, rz_bin_info_t::type, and ut64().

Referenced by load_buffer().

lua_parse_header_54()

RzBinInfo* lua_parse_header_54	(	RzBinFile *	bf,
		st32	major,
		st32	minor
	)

Definition at line 484 of file parse_54.c.

                                                                      {
    RzBinInfo *ret = NULL;
    RzBuffer *buffer;
 
    st64 reat = bf->size;
    if (reat < LUAC_54_HDRSIZE) {
        RZ_LOG_ERROR("Truncated Header\n");
        return NULL;
    }
    buffer = bf->buf;
 
    /* read header members from work buffer */
    ut8 luac_format;
    if (!rz_buf_read8_at(buffer, LUAC_54_FORMAT_OFFSET, &luac_format)) {
        return NULL;
    }
 
    ut8 instruction_size;
    if (!rz_buf_read8_at(buffer, LUAC_54_INSTRUCTION_SIZE_OFFSET, &instruction_size)) {
        return NULL;
    }
 
    ut8 integer_size;
    if (!rz_buf_read8_at(buffer, LUAC_54_INTEGER_SIZE_OFFSET, &integer_size)) {
        return NULL;
    }
 
    ut8 number_size;
    if (!rz_buf_read8_at(buffer, LUAC_54_NUMBER_SIZE_OFFSET, &number_size)) {
        return NULL;
    }
 
    ut64 int_valid = lua_load_integer(buffer, LUAC_54_INTEGER_VALID_OFFSET);
    double number_valid = lua_load_number(buffer, LUAC_54_NUMBER_VALID_OFFSET);
 
    /* Common Ret */
    if (!(ret = RZ_NEW0(RzBinInfo))) {
        return NULL;
    }
    ret->file = rz_str_new(bf->file);
    ret->type = rz_str_newf("Lua %c.%c compiled file", major + '0', minor + '0');
    ret->bclass = rz_str_new("Lua compiled file");
    ret->rclass = rz_str_new("luac");
    ret->arch = rz_str_new("luac");
    ret->machine = rz_str_newf("Lua %c.%c VM", major + '0', minor + '0');
    ret->os = rz_str_newf("%c.%c", major + '0', minor + '0');
    ret->cpu = rz_str_newf("%c.%c", major + '0', minor + '0');
    ret->bits = 8;
 
    /* official format ? */
    if (luac_format != LUAC_54_FORMAT) {
        ret->compiler = rz_str_new("Unofficial Lua Compiler");
        return ret;
    }
    ret->compiler = rz_str_new("Official Lua Compiler");
 
    /* Check Size */
    if ((instruction_size != sizeof(LUA_INSTRUCTION)) ||
        (integer_size != sizeof(LUA_INTEGER)) ||
        (number_size != sizeof(LUA_NUMBER))) {
        RZ_LOG_ERROR("Size definition does not match with the expected size\n");
        return ret;
    }
 
    /* Check endian */
    if (int_valid != LUAC_54_INT_VALIDATION) {
        RZ_LOG_ERROR("Integer format does not match with the expected integer\n");
        return ret;
    } else if (number_valid != LUAC_54_NUMBER_VALIDATION) {
        RZ_LOG_ERROR("Number format does not match with the expected number\n");
        return ret;
    }
 
    /* parse source file name */
    char *src_file_name = NULL;
    int name_len;
    lua_parse_string(buffer, ((ut8 **)&(src_file_name)), &name_len, LUAC_FILENAME_OFFSET, bf->size);
 
    /* put source file info into GUID */
    ret->guid = rz_str_new(src_file_name ? src_file_name : "stripped");
    free(src_file_name);
 
    return ret;
}

References rz_bin_info_t::arch, rz_bin_info_t::bclass, rz_bin_info_t::bits, rz_bin_file_t::buf, rz_bin_info_t::compiler, rz_bin_info_t::cpu, rz_bin_info_t::file, rz_bin_file_t::file, free(), rz_bin_info_t::guid, lua_load_integer(), lua_load_number(), lua_parse_string(), LUAC_54_FORMAT, LUAC_54_FORMAT_OFFSET, LUAC_54_HDRSIZE, LUAC_54_INSTRUCTION_SIZE_OFFSET, LUAC_54_INT_VALIDATION, LUAC_54_INTEGER_SIZE_OFFSET, LUAC_54_INTEGER_VALID_OFFSET, LUAC_54_NUMBER_SIZE_OFFSET, LUAC_54_NUMBER_VALID_OFFSET, LUAC_54_NUMBER_VALIDATION, LUAC_FILENAME_OFFSET, rz_bin_info_t::machine, major, minor, NULL, rz_bin_info_t::os, rz_bin_info_t::rclass, rz_buf_read8_at(), RZ_LOG_ERROR, RZ_NEW0, rz_str_new(), rz_str_newf(), rz_bin_file_t::size, st64, rz_bin_info_t::type, and ut64().

Referenced by load_buffer().

luac_add_entry()

void luac_add_entry	(	RzList *	entry_list,
		ut64	offset,
		int	entry_type
	)

Definition at line 44 of file luac_bin.c.

                                                                     {
    RzBinAddr *entry = RZ_NEW0(RzBinAddr);
    if (!entry) {
        return;
    }
 
    entry->vaddr = offset;
    entry->paddr = offset;
    entry->type = entry_type;
 
    rz_list_append(entry_list, entry);
}

References rz_list_append(), and RZ_NEW0.

Referenced by luac_build_info().

luac_add_section()

void luac_add_section	(	RzList *	section_list,
		char *	name,
		ut64	offset,
		ut32	size,
		bool	is_func
	)

Definition at line 6 of file luac_bin.c.

                                                                                              {
    RzBinSection *bin_sec = RZ_NEW0(RzBinSection);
    if (!bin_sec) {
        return;
    }
 
    bin_sec->name = rz_str_new(name);
    bin_sec->vaddr = bin_sec->paddr = offset;
    bin_sec->size = bin_sec->vsize = size;
    bin_sec->is_data = false;
    bin_sec->bits = is_func ? sizeof(LUA_INSTRUCTION) * 8 : 8;
    // bin_sec->has_strings = !is_func;
    bin_sec->has_strings = false;
    bin_sec->arch = rz_str_new("luac");
 
    if (is_func) {
        bin_sec->perm = RZ_PERM_R | RZ_PERM_X;
    } else {
        bin_sec->perm = RZ_PERM_R;
    }
 
    rz_list_append(section_list, bin_sec);
}

References rz_bin_section_t::arch, rz_bin_section_t::bits, rz_bin_section_t::has_strings, rz_bin_section_t::is_data, rz_bin_section_t::name, rz_bin_section_t::paddr, rz_bin_section_t::perm, rz_list_append(), RZ_NEW0, RZ_PERM_R, RZ_PERM_X, rz_str_new(), rz_bin_section_t::size, rz_bin_section_t::vaddr, and rz_bin_section_t::vsize.

Referenced by _luac_build_info().

luac_add_string()

void luac_add_string	(	RzList *	string_list,
		char *	string,
		ut64	offset,
		ut64	size
	)

Definition at line 57 of file luac_bin.c.

                                                                                {
    RzBinString *bin_string = RZ_NEW0(RzBinString);
    if (!bin_string) {
        return;
    }
 
    bin_string->paddr = offset;
    bin_string->vaddr = offset;
    bin_string->size = size;
    bin_string->length = size;
    bin_string->string = rz_str_new(string);
    bin_string->type = RZ_STRING_ENC_UTF8;
 
    rz_list_append(string_list, bin_string);
}

References rz_bin_string_t::length, rz_bin_string_t::paddr, rz_list_append(), RZ_NEW0, rz_str_new(), RZ_STRING_ENC_UTF8, rz_bin_string_t::size, rz_bin_string_t::string, rz_bin_string_t::type, and rz_bin_string_t::vaddr.

Referenced by _luac_build_info().

luac_add_symbol()

void luac_add_symbol	(	RzList *	symbol_list,
		char *	name,
		ut64	offset,
		ut64	size,
		const char *	type
	)

Definition at line 30 of file luac_bin.c.

                                                                                                {
    RzBinSymbol *bin_sym = RZ_NEW0(RzBinSymbol);
    if (!bin_sym) {
        return;
    }
 
    bin_sym->name = rz_str_new(name);
    bin_sym->vaddr = bin_sym->paddr = offset;
    bin_sym->size = size;
    bin_sym->type = type;
 
    rz_list_append(symbol_list, bin_sym);
}

References rz_bin_symbol_t::name, rz_bin_symbol_t::paddr, rz_list_append(), RZ_NEW0, rz_str_new(), rz_bin_symbol_t::size, type, rz_bin_symbol_t::type, and rz_bin_symbol_t::vaddr.

Referenced by _luac_build_info().

luac_build_info()

LuacBinInfo* luac_build_info

(

LuaProto *

proto

)

Definition at line 114 of file luac_bin.c.

                                              {
    if (!proto) {
        RZ_LOG_ERROR("Invalid luac file\n");
        return NULL;
    }
 
    LuacBinInfo *ret = RZ_NEW0(LuacBinInfo);
    if (!ret) {
        return NULL;
    }
 
    ret->entry_list = rz_list_newf((RzListFree)free_rz_addr);
    ret->symbol_list = rz_list_newf((RzListFree)rz_bin_symbol_free);
    ret->section_list = rz_list_newf((RzListFree)free_rz_section);
    ret->string_list = rz_list_newf((RzListFree)free_rz_string);
 
    if (!(ret->entry_list && ret->symbol_list && ret->section_list && ret->string_list)) {
        try_free_empty_list(ret->entry_list);
        try_free_empty_list(ret->symbol_list);
        try_free_empty_list(ret->section_list);
        try_free_empty_list(ret->string_list);
    }
 
    _luac_build_info(proto, ret);
 
    // add entry of main
    ut64 main_entry_offset;
    main_entry_offset = proto->code_offset + proto->code_skipped;
    luac_add_entry(ret->entry_list, main_entry_offset, RZ_BIN_ENTRY_TYPE_PROGRAM);
 
    return ret;
}

References _luac_build_info(), lua_proto_ex::code_offset, lua_proto_ex::code_skipped, luac_bin_info::entry_list, free_rz_addr(), free_rz_section(), free_rz_string(), luac_add_entry(), NULL, RZ_BIN_ENTRY_TYPE_PROGRAM, rz_bin_symbol_free(), rz_list_newf(), RZ_LOG_ERROR, RZ_NEW0, luac_bin_info::section_list, luac_bin_info::string_list, luac_bin_info::symbol_list, try_free_empty_list(), and ut64().

Referenced by load_buffer().