【技术分享】mruby字节码逆向入门
mrb字节码格式
opcode.h查看，mruby字节码对寄存器按照函数参数、局部变量、临时寄存器的顺序进行分配。将mruby源码clone到本地并编译，在bin目录下的mirb程序是一个交互式mruby解释器，运行时加上-v参数，可以将解释器生成的字节码打印出来，方便理解。> def f(a,b)* c=a+b
* d=a-b
* return c*d
* end...
irep 0x55c104345310 nregs=4 nlocals=2 pools=0 syms=1 reps=1 iseq=14local variable names:
R1:_file: (mirb) 13 000 OP_TCLASS R2 13 002 OP_METHOD R3 I(0:0x55c104346290) 13 005 OP_DEF R2 :f
13 008 OP_LOADSYM R2 :f
13 011 OP_RETURN R2 13 013 OP_STOP
irep 0x55c104346290 nregs=9 nlocals=6 pools=0 syms=0 reps=0 iseq=36local variable names:
R1:a R2:b R3:& R4:c R5:dfile: (mirb) 13 000 OP_ENTER 2:0:0:0:0:0:0
14 004 OP_MOVE R6 R1 ; R1:a 14 007 OP_MOVE R7 R2 ; R2:b 14 010 OP_ADD R6 14 012 OP_MOVE R4 R6 ; R4:c 15 015 OP_MOVE R6 R1 ; R1:a 15 018 OP_MOVE R7 R2 ; R2:b 15 021 OP_SUB R6 15 023 OP_MOVE R5 R6 ; R5:d 16 026 OP_MOVE R6 R4 ; R4:c 16 029 OP_MOVE R7 R5 ; R5:d 16 032 OP_MUL R6 16 034 OP_RETURN R6
032 OP_MUL R6，实际上OP_MUL接受两个寄存器，R6和R7，并且总是将相乘的结果存入R6中。再例如上方的f函数声明部分：002 OP_METHOD R3 I(0:0x55c104346290)将f函数的指针放入R3，后面的005 OP_DEF R2 :f是把R(2+1)，即R3中的函数指针声明为R2中的名字，即:f。了解到这一特性之后就可以对mruby字节码进行初步的逆向了。示例：DEFCON 2021 barb-metal
THERM read day friday/THERM set night monday 90之类的指令读写数据。service程序进行逆向分析，可以发现Alarm，Thermostat，Speaker这些组件的逻辑均是用C实现，并注册为Ruby对象的成员函数。RITE0006，找到对应的mruby版本是v2.1.0，编译后用mruby -v -b payload.bin运行，dump出字节码。THERM set指令： 267 OP_MOVE R7 R5 ; R5:date
270 OP_GETIV R8 @dayofweek
273 OP_SEND R8 :size 0
277 OP_GT R7
# 此处R7是输入的date，R8是dayofweek数组长度，用来检查输入的星期是否溢出
# OP_GT R7隐含了比较的对象R8
279 OP_JMPNOT R7 306
# 若R7<R8，跳转到306，即通过验证，未通过则向下走返回
283 OP_LOADSELF R7
285 OP_STRING R8 L(5) ; "INVALID date "
288 OP_MOVE R9 R5 ; R5:date
291 OP_STRCAT R8
293 OP_STRING R9 L(3) ; ""
296 OP_STRCAT R8
298 OP_SEND R7 :putsDBG 1
302 OP_LOADNIL R7
304 OP_RETURN R7
# 输出字符串，提示越界
# OP_SEND R7 :putsDBG 1隐含一个参数R8
306 OP_GETIV R7 @therm
309 OP_MOVE R8 R4 ; R4:time
312 OP_MOVE R9 R5 ; R5:date
315 OP_MOVE R10 R6 ; R6:temp
318 OP_SEND R7 :write 3
322 OP_RETURN R6 ; R6:temp
# 验证通过，调用设备函数
# OP_SEND R7 :write 3中函数指针为R7，隐含3个参数R8-R10OP_GETIV R7 @therm即获得Thermostat组件的对象，放入R7寄存器，OP_SEND R7 :write 3意为用R7后面的3个寄存器，即R8-R10中的值作为参数，调用R7对象的write函数，此处的write函数是C注册的Thermostat组件的写入功能（sub_112CBF）。THERM set指令的第一个参数可以是day/night，也可以直接输入0/1，第二个参数星期也可以直接输入数字0-6，而上面的函数片段显示mruby只检查了data\<dayofweek.size，即输入的星期要小于7，没有检查下界，利用THERM set 0 -addr value可以实现越界写。THERM get对应的get_therm函数中： 238 OP_MOVE R6 R5 ; R5:date
241 OP_LOADI_0 R7
243 OP_LT R6
245 OP_JMPIF R6 256
# 判断date是否小于0，若小于0检查失败
249 OP_MOVE R6 R4 ; R4:time
252 OP_LOADI_1 R7
254 OP_GT R6
256 OP_JMPNOT R6 273
# 判断time是否大于1，若大于1检查失败
260 OP_LOADSELF R6
262 OP_STRING R7 L(4) ; "INVALID date"
265 OP_SEND R6 :putsDBG 1
269 OP_LOADNIL R6
271 OP_RETURN R6
273 OP_GETIV R6 @therm
276 OP_MOVE R7 R4 ; R4:time
279 OP_MOVE R8 R5 ; R5:date
282 OP_SEND R6 :read 2
286 OP_RETURN R6实战：第五空间线上赛 babyruby
RITE0200，对应mruby v3.0.0，编译运行并dump字节码，程序的main函数位于底部，开头先检查flag{xxxx}格式，括号内的x共32字节。 1796 OP_MOVE R10 R14 ; R10:wanted
1799 OP_JMP 2065
# 这里是一个for循环开始的部分，首先跳转到循环变量i的检查
1802 OP_GETCONST R14 :Cipher
1805 OP_SEND R14 :new 0
1809 OP_MOVE R11 R14 ; R11:cipher
1812 OP_MOVE R14 R3 ; R3:content
1815 OP_MOVE R15 R4 ; R4:i
1818 OP_SEND R14 :[] 1
# R14=content[i]
1822 OP_MOVE R15 R3 ; R3:content
1825 OP_MOVE R16 R4 ; R4:i
1828 OP_ADDI R16 16
1831 OP_SEND R15 :[] 1
1835 OP_ADD R14 R15
...
2011 OP_MOVE R12 R14 ; R12:cc
# R14+=content[i+16]，下面省略了一些取content数组元素的操作，
# 最终的结果是用content[i,i+8,i+16,i+24]四字节组成一个14字节的字符串放在cc里
2014 OP_MOVE R14 R11 ; R11:cipher
2017 OP_MOVE R15 R12 ; R12:cc
2020 OP_STRING R16 L(2) ; c*
2023 OP_SEND R15 :unpack 1
2027 OP_SEND R14 :hash 1
2031 OP_MOVE R13 R14 ; R13:output
# output=cipher.hash(cc.unpack("c*"))
# 将cc字符串unpack为bytes，再把bytes传给cipher的hash函数
2034 OP_MOVE R15 R10 ; R10:wanted
2037 OP_MOVE R16 R4 ; R4:i
2040 OP_SEND R15 :[] 1
# wanted=R4[i]，R4即比较对象，下文有解释
2044 OP_SEND R14 :!= 1
2048 OP_JMPNOT R14 2056
2052 OP_LOADF R14
2054 OP_RETURN_BLK R14
# if(output!=wanted){return false;}
2056 OP_MOVE R14 R4 ; R4:i
2059 OP_ADDI R14 1
2062 OP_MOVE R4 R14 ; R4:i
# i = i+1
2065 OP_MOVE R14 R4 ; R4:i
2068 OP_MOVE R15 R3 ; R3:content
2071 OP_SEND R15 :length 0
2075 OP_LOADI_4 R16
2077 OP_DIV R15 R16
2079 OP_LT R14 R15
2081 OP_JMPIF R14 1802
# if（i < content.length/8) goto 1802;
# 循环变量i从0到content.length/8，每轮循环处理4字节
2085 OP_LOADT R14
2087 OP_RETURN R14
# return true，flag正确cipher.hash函数处理后与R4数组的值进行比较，R4是一个8×64的二维数组，静态编码在mruby字节码中，可以直接提取。cipher.hash函数是一个14字节到64字节的映射，起初我认为是AES加密，但AES128的特征是前9轮是完整的四样操作，最后一轮是没有MixColumns的三样操作，我在程序中找不到仅有SubBytes，ShiftRows和AddRoundKey的尾轮操作，没法证明AES的猜想。从cipher.hash函数的名字，以及输出长度64字节，还有代码中的一些padding操作，可以推断这是Whirlpool)散列函数（Whirlpool是一种利用了AES的四种操作构造出的散列函数，其内部状态是8×8的置换排列网络。据我所知使用了AES的组件的算法有Whirlpool、ARIA、SM4、Rijndael-192和Rijndael-256，这几种算法都可以使用Intel AESNI进行加速，十分神奇）。... // 从字节码中提取出R4数组};int main() { int a, b, c, d; int i; char flag[32]; char buf[14]; memset(flag, 0xff, 32); unsigned char md[64]; for (i = 0; i < 8; i++) { printf("%d\n", i); for (a = 0; a < 80; a++) { for (b = 0; b < 80; b++) { for (c = 0; c < 80; c++) { for (d = 0; d < 80; d++) {
buf[0] = a;
buf[1] = c;
buf[2] = c;
buf[3] = b;
buf[4] = d;
buf[5] = c;
buf[6] = a;
buf[7] = c;
buf[8] = a;
buf[9] = c;
buf[10] = b;
buf[11] = c;
buf[12] = d;
buf[13] = c;
WHIRLPOOL(buf, 14, md); if (memcmp(md, h1 + 64 * i, 64) == 0) { printf("%d good\n", i);
flag[i] = a;
flag[i + 8] = b;
flag[i + 16] = c;
flag[i + 24] = d; goto done;
}
}
}
}
}
done: printf("%d done\n", i);
} for (i = 0; i < 32; i++) { printf("0x%02x,", flag[i]);
} return 0;
}//[0x16, 0x27, 0x00, 0x35, 0x32, 0x16, 0x18, 0x15, 0x22, 0x21, 0x03, 0x1a, 0x1e, 0x1d, 0x3b, 0x1a,// 0x2d, 0x38, 0x0e, 0x03, 0x28, 0x08, 0x28, 0x0e, 0x2e, 0x31, 0x39, 0x3e, 0x04, 0x1d, 0x15, 0x23]
cipher.hash的数组，在这之前该程序还对输入有一些处理： 081 OP_MOVE R15 R3 ; R3:content
084 OP_SEND R15 :length 0
088 OP_SUBI R15 1
091 OP_RANGE_INC R14
# R14=content[0:length-1]，OP_RANGE_INC用R15创建range
093 OP_BLOCK R15 I(0:0x55d31260ff20)
096 OP_SENDB R14 :each 0
# OP_BLOCK加载了一个lambda函数到R15中
# 将这个lambda函数应用到R14的每个元素上，类似python的map函数
100 OP_LOADI_1 R6 ; R6:step
102 OP_LOADI_0 R4 ; R4:i
104 OP_LOADI_0 R7 ; R7:lst
# setp=1, i=0, lst=0，初始化一个复杂的循环
106 OP_MOVE R14 R4 ; R4:i
109 OP_MOVE R15 R6 ; R6:step
112 OP_ADD R14 R15
114 OP_MOVE R4 R14 ; R4:i
117 OP_JMP 214
# i+=step，循环开始
120 OP_MOVE R14 R3 ; R3:content
123 OP_MOVE R15 R7 ; R7:lst
126 OP_SEND R14 :[] 1
130 OP_SEND R14 :ord 0
134 OP_MOVE R8 R14 ; R8:c
# c=ord(content[lst])
137 OP_MOVE R14 R7 ; R7:lst
140 OP_ADDI R14 1
143 OP_MOVE R15 R4 ; R4:i
146 OP_SUBI R15 1
149 OP_RANGE_INC R14
151 OP_BLOCK R15 I(1:0x55d31260fff0)
154 OP_SENDB R14 :each 0
# 对[lst-1:i+1]范围内的每个元素应用R15的lambda表达式
158 OP_MOVE R14 R8 ; R8:c
161 OP_MOVE R15 R7 ; R7:lst
164 OP_ADDI R15 1
167 OP_SEND R14 :^ 1
171 OP_SEND R14 :chr 0
# R14=chr(c^lst)
175 OP_MOVE R15 R3 ; R3:content
178 OP_MOVE R16 R7 ; R7:lst
181 OP_MOVE R17 R14
184 OP_SEND R15 :[]= 2
188 OP_MOVE R14 R4 ; R4:i
191 OP_MOVE R7 R14 ; R7:lst
194 OP_MOVE R14 R6 ; R6:step
197 OP_ADDI R14 1
200 OP_MOVE R6 R14 ; R6:step
203 OP_MOVE R14 R4 ; R4:i
206 OP_MOVE R15 R6 ; R6:step
209 OP_ADD R14 R15
211 OP_MOVE R4 R14 ; R4:i
# lst=i, step=step+1, i=i+step
214 OP_MOVE R14 R4 ; R4:i
217 OP_MOVE R15 R3 ; R3:content
220 OP_SEND R15 :length 0
224 OP_LT R14 R15
226 OP_JMPIF R14 120
# if(i<content.length) goto 120; 否则循环结束content是输入的32字节，循环过程中有一个lambda表达式较为复杂，通过静态分析很难找出其中的操作，于是我采用了动态调试的方法猜出其中的处理逻辑。149 OP_RANGE_INC R14，它为我们提供了一个完美的断点位置，我们只需要找出mruby虚拟机中对OP_RANGE_INC的处理，断在这里，再查看此时R3中的内容，就能看出输入的32字节经过了什么样的变换。解释器主函数位于src/vm.c：flag{whosyourdaddyISEEDEADPEOPLE10086}，这里故意避免输入连续的01234或者abcd，为了方便猜测后面的处理究竟是异或还是加减乘除四则运算。091 OP_RANGE_INC R14，查看一下mrb->c->ci->stack[3]，即R3的内容：MRB_TT_STRING，这个string就是content变量，即我们输入的32字节。再把value的p成员转换成RString，继续深入查看：s = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'v = 1t = 1l = 0p = 0while True:
a[p] ^= v for i in range(l):
a[p+1+i] ^= (v+i)
a[p+1+i] ^= a[p]
v += t
t += 1
p += 1 + l
l += 1
if l > 6: breakprint('flag{{{}}}'.format(''.join(map(lambda x: s[x], a))))
flag{Nbdn7YVDrt8PQOzAtZMQsUW7eszx4TLZ}精彩推荐【安全头条】数千克隆开源项目存在恶意代码专钓马大哈
【技术分享】剖析脏牛1_mmap如何映射内存到文件
【技术分享】A-Journey-into-Synology-NAS-系列——群晖NAS介绍