Công cụ Radare2 và Demo sử dụng

TÌM HIỂU CƠNG CỤ RADARE2


Mụ c lụ c
Mở đầu. .....................................................................................................................3
1.1. Giới thiệu sơ lược về Reverse Engineering (theo Wikipedia). ....................... 3
1.2. Các công cụ hỗ trợ Reverse Engineering. ...................................................... 3

1. Giới thiệu. .......................................................................................................4
2. Lịch sử hình thành. .........................................................................................5
3. Hướng dẫn cài đặt. .........................................................................................6
4. Hướng dẫn gỡ cài đặt. ....................................................................................7
5. Hướng dẫn sử dụng. ......................................................................................7
6.1. Các tùy chọn Radare2 cung cấp. .................................................................... 7
6.2. Định dạng lệnh................................................................................................ 9
6.3. Các biểu thức. ............................................................................................... 14
6.4. Debug cơ bản. ............................................................................................... 15
6.5. Các lệnh cơ bản............................................................................................. 16
6.5.1. Seeking. ................................................................................................ 16
6.5.2. Block size. ............................................................................................ 18
6.5.3. Section. ................................................................................................. 19
6.5.4. Print Modes. ......................................................................................... 19
6.5.5. Flags. .................................................................................................... 25
6.5.6. Write Data. ........................................................................................... 27
6.6. Phân tích (Analysis). .................................................................................... 31
6.6.1. (Phân tích mã) Code Analysis. ............................................................. 31
6.6.2. Biến (Variables). .................................................................................. 36

6. Bài lab, kịch bản demo. ............................................................................... 38
7.1. Lab 1: Thực hiện dịch ngược chương trình để tìm password....................... 38
7.2. Lab 2: Thực hiện dịch ngược file binary code. ............................................ 45

7. So sánh, đánh giá, kết luận. ......................................................................... 66
8.1. So sánh, đánh giá. ......................................................................................... 66
8.2. Kết luận......................................................................................................... 66

8. Tài liệu tham khảo. ...................................................................................... 66


1. Mở đầu.
1.1. Giới thiệu sơ lược về Reverse Engineering (theo Wikipedia).
Kỹ nghệ đảo ngược (hay công nghệ đảo ngược, kỹ thuật đảo ngược) (tiếng Anh:
Reverse Engineering) là quá trình tìm ra các nguyên lý kỹ thuật của một phần mềm
ứng dụng hay thiết bị cơ khí qua việc phân tích cấu trúc, chức năng và hoạt động của
nó. Trong quá trình này, người ta thường phải tháo dỡ đối tượng (ví dụ một thiết bị cơ
khí, một thành phần điện tử, một phần mềm) thành từng phần và phân tích chi tiết hoạt
động của nó, thường là với mục đích xây dựng một thiết bị hoặc phần mềm mới hoạt
động giống hệt nhưng không sao chép bất cứ thứ gì từ đối tượng ngun bản.
Có rất nhiều mục đích để thực hiện kỹ nghệ đảo ngược trong nhiều lĩnh vực. Nó được
biết đến trong việc phân tích phần cứng phục vụ cho mục đích thương mại và quân sự.
Tuy vậy, công việc kỹ nghệ đảo ngược không ảnh hưởng tới việc sao chép hoặc thay
đổi hiện vật theo một cách nào đó mà chỉ là cơng cụ phân tích để suy ra các tính năng
có sẵn của sản phẩm thơng qua rất ít hoặc khơng có kiến thức về quá trình sản xuất
ban đầu của chúng .
Trong phạm trù phần mềm, quy trình đảo ngược giúp tăng sự thơng hiểu về mã nguồn
của phần mềm đó trong việc bảo trì và cải tiến. Thơng tin liên quan có thể được trích
xuất nhằm đưa ra góc nhìn và quan điểm khác về mã nguồn. Điều đó có thể giúp ta
phát hiện được lỗi phần mềm hoặc lỗ hổng phần mềm.
Đối với những người phát triển phần mềm ác ý, họ sử dụng kỹ nghệ đảo ngược để tìm
lỗ hổng của hệ điều hành để tạo ra virus máy tính. Ngồi ra, ngành phân tích mật mã
cũng cần kỹ nghệ đảo ngược để tìm lỗ hổng trong thay thế cipher, thuật tốn key đối

xứng, hoặc mã hóa public-key.
1.2. Các cơng cụ hỗ trợ Reverse Engineering.
Khoảng mười năm trở lại đây, những người làm trong lĩnh vực an ninh thông tin và cả
những hacker đều đang dành nhiều sự quan tâm hơn tới việc sử dụng các kỹ thuật


Reverse Engineering để thực hiện các tác vụ an ninh mạng. Để đáp ứng nhu cầu thiết
yếu đó, các cơng cụ đắc lực trợ giúp Reverse Engineering đã ra đời. Trong đó, có một
vài cơng cụ nổi bật hơn cả như:
❖ IDA PRO.
❖ Ghidra.
❖ Binary Ninja.
❖ Hopper.
❖ Radare2.
Các công cụ này đều rất mạnh, đều rất đáng để bỏ công sức ra học cách sử dụng. Tuy
nhiên, các công cụ Reverse Engineering đều có điểm chung là khá khó sử dụng đối
với người mới bắt đầu, đặc biệt là công cụ Radare2. Chính vì vậy, em sẽ đi tìm hiểu
chi tiết về công cụ Radare2 và mong muốn được mang những gì mình tìm hiểu được
đóng góp tới cộng đồng qua bài hướng dẫn này.

2. Giới thiệu.
Radare2 là một open-source framework dành cho kỹ thuật đảo ngược và phân tích nhị
phân, triển khai giao diện dòng lệnh phong phú để bóc tách, phân tích dữ liệu, vá các
tệp nhị phân, so sánh dữ liệu, tìm kiếm, thay thế, trực quan hóa và hơn thế nữa. Nó
chạy trên tất cả các nền tảng chính (GNU / Linux, Windows, * BSD, iOS, OSX,
Solaris…) và nó hỗ trợ rất nhiều kiến trúc và định dạng tệp.
Radare2 là là một open-source framework có thể:
• Tháo rời (và lắp ráp cho) nhiều kiến trúc khác nhau
• Gỡ lỗi với trình gỡ lỗi gốc và từ xa cục bộ (gdb, rap, webui, r2pipe, winedbg,
Windbg).

• Triển khai giao diện dịng lệnh phong phú để bóc tách, phân tích dữ liệu
• Chạy trên Linux, * BSD, Windows, OSX, Android, iOS, Solaris và Haiku.
• Hỗ trợ điều tra số.
• Được viết kịch bản bằng Python, Javascript, Go và hơn thế nữa.
• Hỗ trợ phân tích hợp tác bằng cách sử dụng máy chủ web nhúng.
• Trực quan hóa cấu trúc dữ liệu của một số loại tệp.
• Vá các lỗ hổng.
• Sử dụng khả năng phân tích mạnh mẽ để tăng tốc độ đảo chiều.
• Hỗ trợ khai thác phần mềm.
• Hỗ trợ đa dạng các kiến trúc: 6502, 8051, CRIS, H8 / 300, LH5801, T8200,
arc, arm, avr, bf, blackfin, xap, dalvik, dcpu16, gameboy, i386, i4004, i8080,
m68k, malbolge, mips , powerpc, rar, sh, snes, sparc, tms320 (c54x c55x c55
+), V810, x86-64, zimg, risc-v.
• Hỗ trợ nhiều định dạng tệp: ELF, Mach-O, Fatmach-O, PE, PE +, MZ, COFF,
OMF, TE, XBE, BIOS / UEFI, Dyldcache, DEX, ART, CGC, lớp Java, hình


ảnh khởi động Android, thực thi Plan9, ZIMG, MBN / Bộ tải khởi động SBL,
ELF coredump, MDMP (Windows minidump), WASM (WebAssugging
binary), trình giả lập Commodore VICE, Game Boy (Advance), Nintendo DS
ROM và Nintendo 3DS FIRM, các hệ thống tập tin khác nhau.
• Một điểm cộng lớn nữa của radare2 là nó hồn tồn miễn phí.
Mặc dù có nhiều ưu điểm, nhưng số lượng người sử dụng Radare2 không
nhiều, nguyên nhân chính có lẽ là Radare2 khơng phải là một cơng cụ dễ sử dụng,
việc học cách sử dụng thực sự khá khó nhưng một khi bạn biết cách sử dụng thì nó sẽ
trở thành một cơng cụ thực sự hữu dụng. Nền tảng radare2 được hình thành bởi nhiều
cơng cụ nhỏ như r2, Rabin, rasm hoặc rax.
Mỗi công cụ nhỏ này cho phép bạn thực hiện nhiều việc khác nhau. Ví dụ, với radare2
bạn có thể kiểm tra shell codes, reverse engineer mã nguồn nhị phân từ các nền tảng
khác nhau như pe, elf, match0 và dex hoặc các lớp java, phân tích ảnh đĩa để thực hiện

điều tra số (forensic), tìm kiếm các gadget để xây dựng payload ROP (Return Oriented
Programming ), debug mã nguồn nhị phân, so sánh sự khác biệt giữa các tập tin nhị
phân (bindiffing) hay patch binaries.
Tất cả điều này đều có thể mở rộng khả năng xử lý thông qua các plugins mà bạn tự
lập trình bằng ngơn ngữ Python, Go, Perl, Javascript ...

3. Lịch sử hình thành.
Năm 2006, Sergi Àlvarez (hay cịn gọi là pancake) đang làm việc với tư cách là một
nhà phân tích điều tra kỹ thuật số. Vì khơng được phép sử dụng phần mềm của công
ty cho các nhu cầu cá nhân của mình, anh ấy đã quyết định viết một cơng cụ nhỏ - một
trình soạn thảo hệ thập lục phân.
Công cụ này ban đầu được thiết kế để khơi phục tệp đã xóa khỏi phân vùng HFS +.
Sau đó, pancake đã quyết định mở rộng cơng cụ để có thể can thiệp vào các tiến trình
và triển khai các chức năng của trình gỡ lỗi, hỗ trợ nhiều kiến trúc và phân tích mã.
Kể từ đó, dự án đã phát triển để cung cấp một khung (Framework) hồn chỉnh để phân
tích nhị phân, đồng thời sử dụng các khái niệm UNIX cơ bản. Trong đó, bao gồm một
số khái niệm nổi tiếng như: "everything is a file", "small programs that interact using
stdin/stdout", và "keep it simple"...
Nhu cầu về tập lệnh cho thấy sự mỏng manh của thiết kế ban đầu: một cơng cụ
ngun khối khiến API khó sử dụng và do đó cần phải tái cấu trúc sâu.


Radare1 sau một thời gian được các chuyên gia bảo mật đánh giá, đã bộc lộ ra một số
hạn chế tương đối nghiêm trọng trong khâu thiết kế, do đó Pancake đã quyết định tái
cấu trúc sâu công cụ này.
Năm 2009, Radare2 (viết tắt là R2) ra đời như một phiên bản cải tiến của Radare1.
Tính linh hoạt của phiên bản này được cải thiện rõ rệt, điều này cho phép tích hợp tốt
hơn nhiều, mở đường để sử dụng Radare2 từ các ngơn ngữ lập trình khác nhau. Sau
đó, API r2pipe cho phép truy cập vào radare2 thông qua các pepline từ bất kỳ ngôn
ngữ nào.

Dự án bắt đầu với chỉ một người, nhưng sau một thời gian nó phát triển thành một dự
án lớn dựa trên cộng đồng vào khoảng năm 2014.
Dự án vẫn đang hoạt động cho tới thời điểm hiện tại (2021). Bên cạnh đó, các nhà
phát triển cũng đã khởi động một số dự án phụ như: Giao diện đồ họa (Cutter), Trình
dịch ngược (r2dec, radeco), Tích hợp Frida (r2frida), Yara, Unicorn,....
Cộng đồng Radare2 đã phát triển lớn mạnh nhanh chóng. Kể từ năm 2016, cộng đồng
tụ tập mỗi năm một lần tại r2con, một đại hội xung quanh radare2 diễn ra ở Barcelona.

4. Hướng dẫn cài đặt.
Radare2 thường được cài đặt sẵn trong các phiên bản Kali Linux. Tuy nhiên, nếu nó
chưa được cài đặt, thì dưới đây là cách cài đặt cơng cụ này: [1]
Bước 1: Download Radare2:
Cách download đơn giản nhất là sử dụng câu lệnh dưới đây để clone Radare2
trên github về máy:
$ git clone />Bước 2: Truy cập vào thư mục Radare2:
$ cd radare2
Bước 3: Chạy câu lệnh dưới đây để cập nhật và tiến hành cài đặt Radare2:
$ sys/install.sh
Đây là cách đơn giản nhất để cài đặt Radare2, nó vẫn hoạt động tốt cho đến thời điểm
hiện tại (2021) trên hệ điều hành Kali Linux (Version 2021.4). Tuy nhiên, nếu thời
điểm bạn đọc tài liệu này, cách cài đặt trên khơng cịn hoạt động được hoặc xảy ra bất
cứ một tình huống nào khác thì có 2 nguồn mà bạn nên tham khảo:
1. />2. />

Đây là 2 nguồn tài liệu được cung cấp bởi các nhà phát triển Radare2. Nó bao gồm
hầu hết các trường hợp có thể xảy ra khi cài đặt. Hi vọng, nó sẽ giúp bạn cài đặt thành
cơng cơng cụ hữu ích này.

5. Hướng dẫn gỡ cài đặt.
Là một hướng dẫn sử dụng Radare2, thật lạ lùng khi tôi hướng dẫn bạn gỡ cài đặt nó.

Tuy nhiên, nếu bạn muốn, thì chỉ cần thực hiện 2 lệnh dưới đây là đủ:
make uninstall
make purge

6. Hướng dẫn sử dụng.
Trước khi bắt đầu học cách sử dụng, chúng ta nên quan sát R2 Learning Curve (R2 là
viết tắt của Radare2) để hình dung được độ khó thay đổi như thế nào trong quá trình
tìm hiểu cơng cụ này:

Như ta thấy, Radare2 khơng q khó khi bắt đầu tiếp cận. Tuy nhiên, độ khó sẽ thực
sự tăng lên khi chúng ta học cách sử dụng các tính năng nâng cao.
Điều này là bình thường bởi hầu hết các tool Reverse Engineering đều khá phức tạp,
do đó việc nắm vững tồn bộ các tính năng không phải là điều đơn giản. Mặc dù vậy,
nhiều chuyên gia cũng cho rằng 80% công việc trong thực tế có thể được giải quyết
chỉ với những tính năng cơ bản. Do đó, việc bắt đầu từ những điều cơ bản nhất khi
học bất cứ thứ gì mới là một chiến thuật tốt.
6.1. Các tùy chọn Radare2 cung cấp.
Như hầu hết các tiện ích dịng lệnh, cách nhanh nhất để hiển thị danh sách các đối số
là thực thi chương trình với cờ -h (help).


$ radare2 -h
Usage: r2 [-ACdfLMnNqStuvwzX] [-P patch] [-p prj] [-a arch] [-b bits] [-i
file]
[-s addr] [-B baddr] [-m maddr] [-c cmd] [-e k=v] file|pid|-|--|=
-Chạy radare2 mà không cần mở bất cứ tệp nào
Tương tự 'r2 malloc://512'
=
Đọc tệp từ stdin (sử dụng -i và -c để chạy cmds)
-=

perform !=! command to run all commands remotely
-0
In \x00 sau mọi lệnh
-2
Đóng bộ mơ tả tệp stderr (thông báo cảnh báo im lặng)
-a [arch]
Thiết lập asm.arch
-A
Chạy lệnh 'aaa' để phân tích tất cả mã được tham chiếu.
-b [bits]
Thiết lập asm.bits
-B [baddr]
Chỉ định địa chỉ cơ sở sẽ được sử dụng khi tải tệp nhị phân
mới
-c 'cmd..'
Thực hiện lệnh đã cho trước
-C
Tệp là host:port (bí danh cho -c+=http://%s/cmd/)
-d
Thực thi với chế độ gỡ lỗi (debug).
-D [backend] Bật chế độ gỡ lỗi. Đặt cfg.debug = true
-e k=v
Đặt cấu hình eval biến key=value. Ví dụ -e scr.color = false
-f
Blocksize = kích thước tệp
-F [binplug] Buộc phải sử dụng plugin rbin đó
-h, -hh
Hiển thị trợ giúp, -hh tương tự -h nhưng chi tiết hơn
-H ([var])
Hiển thị biến

-i [file]
Thực thi tập lệnh
-I [file]
Thực thi tập lệnh mà không cần mở nó trước
-k [OS/kern] Thiết lập asm.os (linux, macos, w32, netbsd, ...)
-l [lib]
Tải tệp plugin
-L
Liệt kê các plugin IO được hỗ trợ
-m [addr]
Ánh xạ tệp tới địa chỉ đã cho (loadaddr)
-M
do not demangle symbol names
-n, -nn
Không tải thông tin RBin (-nn chỉ tải cấu trúc bin)
-N
Không thực hiện bất kỳ phân tích nào (Rbin). Chỉ tải tệp thơ
-q
Chế độ im lặng (khơng có lời nhắc) và thốt sau lệnh -i
-Q
Chế độ im lặng (khơng có lời nhắc) và thốt nhanh hơn
-p [prj]
Sử dụng dự án, liệt kê nếu khơng có đối số, tải nếu khơng có
tệp
-P [file]
Áp dụng tệp rapatch và thốt
-r [rarun2] Chỉ định cấu hình rarun2 để tải (giống như -e dbg.profile = X)
-R [rr2rule] Đặc tả lệnh rarun2 tùy chỉnh.
-s [addr]
Sử dụng để điều hướng tới vị trí addr

-S
Khởi động Radare2 ở trong mơi trường sandbox.
-t
Tải thơng tin rabin2 trong luồng
-u
Thiết lập bin.filter=false để lấy tên sym/sec/cls thô
-v, -V
Hiển thị phiên bản radare2 (-V hiển thị phiên bản thư viện)
-w
Mở tệp ở chế độ ghi
-x
Mở mà không cần cờ thực thi - exec-flag (asm.emu will not
work)


-X
-z, -zz

Tương tự -e bin.usextr=false (hữu ích cho dyldcache)
Khơng tải các chuỗi ngay cả khi chúng ở dạng thô

Như ta thấy, có rất nhiều cấu trúc lệnh, tuy nhiên có một số cấu trúc được sử dụng phổ
biến hơn cả. Chúng ta nên ghi nhớ những cấu trúc lệnh này để thuận tiện sử dụng.
1. Nhanh chóng truy cập vào r2 shell mà không cần mở bất kỳ tệp nào.
$ r2 2.

Đặt asm.arch.

$ r2 -a [arch]
3.

Chạy lệnh 'aaa' để phân tích tất cả mã được tham chiếu.

$ r2 -A
4.

Đặt asm.bits.

$ r2 -b [bits]
5.

Đặt địa chỉ cơ sở cho mã nhị phân PIE

$ r2 -B [baddr]
6.

Thực hiện lệnh radare.

$ r2 -c 'cmd..'
7.

Gỡ lỗi file thực thi hoặc tiến trình đang chạy "pid".

$ r2 -d
8.

Chạy tập lệnh.

$ r2 -i [file]
9.

Đặt asm.os (linux, macos, w32, netbsd, ...).

$ r2 -k [OS/kern]
10.

Tải plugin file.

$ r2 -l [lib]
11.

Sử dụng project đã có.

$ r2 -p [prj]
12.

Mở file ở chế độ ghi.

$ r2 -w
6.2. Định dạng lệnh.
Định dạng chung cho các lệnh radare2 như sau:


[.][times][cmd][~grep][@[@iter]addr!size][|>pipe] ;
Bạn có thể cài đặt số lần thực hiện của 1 lệnh bằng cách đặt tiền tố của lệnh đó bằng 1
số:
px # chạy px
3px # chạy lệnh px 3 lần
Tiền tố “!” được sử dụng để thực thi một lệnh trong ngữ cảnh shell. Nếu bạn muốn sử
dụng lệnh cmd callback từ plugin I / O, bạn phải đặt tiền tố bằng “= !” [1].

Lưu ý rằng một dấu chấm than duy nhất sẽ chạy lệnh và in đầu ra thơng qua API
RCons. Điều này có nghĩa là q trình thực thi sẽ bị chặn và khơng tương tác. Sử dụng
dấu chấm than kép - !! - để chạy một lệnh gọi hệ thống tiêu chuẩn [1].
Lưu ý: Tất cả các API socket, hệ thống tệp và thực thi có thể bị hạn chế với biến cấu
hình cfg.sandbox.
Dưới đây là 1 vài ví dụ:
ds
px
pc
wx
px

200 @ esp
> file.c
90 @@ sym.*
2; d 3; pv 4

;
;
;
;
;

Gọi lệnh “step" của trình gỡ lỗi
Hiển thị 200 bytes hex ở esp
kết xuất bộ đệm dưới dạng một mảng byte C vào tệp.c
Viết 1 lệnh kèm theo các đối số đi kèm
Cách viết nhiều lệnh trên 1 dịng (Phân cách bởi dấu “;”)

Ngồi ra có một dạng lệnh cực kỳ hữu ích đặc biệt là với người mới. Đó là dạng lệnh

help. Bất cứ khi nào cần tìm 1 lệnh chỉ cần gõ dấu “?”:
[0xabcd..ef]> ?


Radare2 sẽ hiển thị cho chúng ta các tập lệnh mà nó hỗ trợ:
Để xem thơng tin các lệnh con trong các tập lệnh, chỉ cần chọn 1 ký tự tương ứng với
tập lệnh mong muốn và kèm theo sau đó là dấu “?”:


Như vậy, thông tin về các lệnh con đều đã được liệt kê ra. Như bạn thấy ở trên, các
lệnh con của tập lệnh “d” vẫn có thể nhận đối số là dấu “?”, như vậy có nghĩa là, trong
các lệnh con vẫn có thể bao gồm các lệnh con nhỏ hơn.


Như bạn thấy, khi ta truy cập vào tập lệnh “dr” thì có rất nhiều lệnh con khác. Và ngay
cả các lệnh con của “dr” như “drl”, “drp”, … chúng vẫn nhận đối số là dấu “?”. Tóm
lại, bất cứ khi nào ta thấy một lệnh nào đó có thể nhận đối số là dấu “?” tức là trong nó
vẫn bao gồm các lệnh con nhỏ hơn [1] [2].
Ngoài ra, 2 ký hiệu “@” và “@@” rất hay được sử dụng.
Ký hiệu “@” được sử dụng để chỉ định một offset tạm thời mà tại đó lệnh ở bên trái
của nó sẽ được thực thi. Sau khi thực hiện lệnh xong, Radare2 sẽ điều hướng về vị trí
trước đó mà nó đứng. Ví dụ:
pd 5 @ 0x100000fce
Câu lệnh này dùng để disassemble 5 câu lệnh bắt đầu từ vị trí 0x100000fce.
Ký hiệu “@@” thì hoạt động tương tự như câu lệnh foreach trong lập trình, tức là nó
dùng để duyệt toàn bộ các phần tử trong một tập hợp hay một danh sách nào đó.
Ví dụ:
axt @@ str.*
Nơm na, câu lệnh này sẽ duyệt lần lượt toàn bộ các cờ có tiền tố là “str.”.

6.3. Các biểu thức.
Biểu thức là biểu diễn toán học của các giá trị số 64 bit (64-bit numerical values).
Chúng có thể được hiển thị ở các định dạng khác nhau, được so sánh hoặc sử dụng với
tất cả các lệnh chấp nhận đối số. Biểu thức có thể sử dụng các phép toán số học truyền
thống, các phép toán trên trường nhị phân và đại số boolean. Để tính tốn các biểu
thức tốn học, ta đặt dấu “?” phía trước các biểu thức cần tính:
[0xb7f9d810]> ?vi 0x8048000
134512640
[0xv7f9d810]> ?vi 0x8048000+34
134512674
[0xb7f9d810]> ?vi 0x8048000+0x34
134512692
[0xb7f9d810]> ? 1+2+3-4*3
hex 0xfffffffffffffffa
octal 01777777777777777777772
unit 17179869184.0G
segment fffff000:0ffa
int64 -6
string "\xfa\xff\xff\xff\xff\xff\xff\xff"
binary
0b1111111111111111111111111111111111111111111111111111111111111010
fvalue: -6.0
float: nanf
double: nan
trits 0t11112220022122120101211020120210210211201
Như đã đề cập ở trên, hầu hết các phép toán hay dùng đều được hỗ trợ.
+
*
/

%
>>
<<

: Phép cộng.
: Phép trừ.
: Phép nhân.
: Phép chia.
: Phép modulo (Chia dư).
: Phép dịch phải.
: Phép dịch trái.

Ví dụ:
[0x00000000]> ?vi 1*2+3%4
5


Lưu ý: Để sử dụng các toán tử OR… ta nên để chúng vào trong ngoặc kép vì tốn tử
OR ký hiệu là “|” trùng với cú pháp một số lệnh khác của Radare2 nên ta để biểu thức
vào trong ngoặc kép để tránh câu lệnh bị hiện tượng đa nghĩa [2].
[0x00000000]> "? 1 | 2"
hex 0x3
octal 03
unit 3
segment 0000:0003
int32 3
string "\x03"
binary 0b00000011
fvalue: 2.0
float: 0.000000f

double: 0.000000
trits 0t10
Radare2 cũng hỗ trợ biểu diễn số ở một số dạng:
0x033
3334
10K
10M

: hexadecimal can be displayed
: decimal
: KBytes 10*1024
: MBytes 10*1024*1024

Bạn cũng có thể sử dụng các biến để xây dựng các biểu thức phức tạp hơn. Ví dụ:
[0x4A13B8C0]> ? $m + $l
140293837812900 0x7f98b45df4a4 03771426427372244 130658.0G
8b45d000:04a4 140293837812900 10100100 140293837812900.0 -0.000000
6.4. Debug cơ bản.
Để debug một chương trình, hãy bắt đầu Radare2 với tùy chọn -d. Lưu ý rằng bạn có
thể đính kèm vào một quy trình đang chạy bằng cách chỉ định PID của nó hoặc bạn có
thể bắt đầu một chương trình mới bằng cách chỉ định tên và các tham số của nó [3]
[4]:
$ pidof mc
32220
$ r2 -d 32220
$ r2 -d /bin/ls
$ r2 -a arm -b 16 -d gdb://192.168.1.43:9090
...
Lưu ý rằng, debug là một vấn đề rất phức tạp, Radare2 cũng cung cấp các tính năng
Debug nâng cao. Nhưng để hiểu được các tính năng đó thì ta cịn cần nắm chắc nhiều

mảng kiến thức liên quan khác ngồi Radare2. Điều đó thực sự khó với hầu hết mọi
người. Bên cạnh đó, mục tiêu của bài hướng dẫn này là giúp chúng ta có thể dễ dàng
tiếp cận và sử dụng được Radare2 ở mức độ cơ bản. Chính vì vậy, tơi sẽ chỉ đề cập tới
những câu lệnh debug cơ bản và thông dụng nhất:
> d?
; Nhận thông tin trợ giúp về các lệnh phục vụ Debug
> ds 3
; Thực hiện 3 lần
> db 0x8048920 ; Tạo 1 break-point
> db -0x8048920 ; Loại bỏ breakpoint
> dc
; Tiếp tục thực thi tiến trình
> dcs
; Tiếp tục cho đến khi syscall
> dd
; Thao tác với file descriptors
> dm
; Hiển thị các tiến trình
> dmp A S rwx ; Thay đổi quyền của trang tại A và size S
> dr eax=33
; Đặt giá trị thanh ghi. eax = 33

6.5. Các lệnh cơ bản.
6.5.1. Seeking.
Để di chuyển tới các vị trí trong tệp tin, ta cần sử dụng các lệnh điều hướng (Seeking).
Lệnh seeking trong Radare2 được viết tắt dưới dạng ký tự “s". Và để lựa chọn cách
điều hướng sao cho phù hợp với mục đích, ta cần lựa chọn 1 trong các lệnh Seeking
mà Radare2 cung cấp dưới đây. Sử dụng, lệnh “s?” để hiển thị các lệnh Seeking có thể

sử dụng:


Dưới đây là 1 số ví dụ sử dụng câu lệnh Seeking:
[0x00000000]> s 0x10
[0x00000010]> s+4
[0x00000014]> s[0x00000010]> s+
[0x00000014]>
Hãy để ý sau mỗi lần thực hiện Seeking thì địa chỉ đã thay đổi như thế nào.
Lưu ý: Thay vì chỉ sử dụng các con số, chúng ta cũng có thể sử dụng các biểu thức
phức tạp, hoặc các phép toán số học cơ bản để biểu diễn địa chỉ cần tìm [4].
Ngồi ra, có một lệnh hay được sử dụng nhưng khơng xuất hiện trong hình trên. Đó là
lệnh:
s*
Lệnh này sẽ hiển thị lịch sử các lần thực hiện Seeking.


6.5.2. Block size.
Kích thước khối xác định bao nhiêu byte lệnh mà Radare2 sẽ xử lý khi không đưa ra
đối số kích thước rõ ràng. Bạn có thể tạm thời thay đổi kích thước khối bằng cách chỉ
định đối số số cho các lệnh in. Ví dụ: px 20 [4].
Để xem cách lệnh Block size ta sử dụng lệnh:
b?

Như ta thấy, lệnh “b” được sử dụng để thay đổi kích thước khối. Ví dụ:
[0x00000000]> b 0x100 # block size = 0x100
[0x00000000]> b+16 # block size = 0x110
[0x00000000]> b-32 # block size = 0xf0
Lệnh bf được sử dụng để thay đổi kích thước khối thành giá trị được chỉ định bởi cờ.
Ví dụ, đối với các biểu tượng, kích thước khối của cờ đại diện cho kích thước của

hàm. Để thực hiện cơng việc đó, bạn phải chạy hàm phân tích af (được bao gồm trong
aa) hoặc điều hướng và xác định một số hàm theo cách thủ cơng, ví dụ:
[0x00000000]> bf sym.main
# block size = sizeof(sym.main)
[0x00000000]> pD @ sym.main # disassemble sym.main
Mặt khác, bạn cũng có thể kết hợp hai thao tác trong một lệnh pdf. Ngoại trừ pdf
không sử dụng cũng như khơng ảnh hưởng đến kích thước khối toàn cục.
[0x00000000]> pdf @ sym.main # disassemble sym.main


Một cách khác là sử dụng các biến đặc biệt $ FB và $ FS biểu thị điểm bắt đầu và
kích thước của hàm tại lần điều hướng hiện tại.
[0x00000000]> s sym.main + 0x04
[0x00001ec9]> pD @ $FB !$FS # disassemble current function
╭ 211: int main (int argc, char **argv, char **envp);
│
0x00001ec5
55
push rbp
│
0x00001ec6
4889e5
mov rbp, rsp
│
0x00001ec9
4881ecc0000000 sub rsp, 0xc0
...
╰
0x00001f97
c3

ret
6.5.3. Section.
Khái niệm về các section được gắn với thơng tin được trích xuất từ hệ nhị phân.
Chúng ta có thể hiển thị thơng tin này bằng cách sử dụng lệnh iS.
[0x00005310]> iS
[Sections]
00 0x00000000
0 0x00000000
01 0x00000238
28 0x00000238
02 0x00000254
32 0x00000254
03 0x00000278
176 0x00000278
04 0x00000328 3000 0x00000328
05 0x00000ee0 1412 0x00000ee0
06 0x00001464
250 0x00001464
07 0x00001560
112 0x00001560
08 0x000015d0 4944 0x000015d0
09 0x00002920 2448 0x00002920
10 0x000032b0
23 0x000032b0
...

0
28
32
176

3000
1412
250
112
4944
2448
23

----r--r--r--r--r--r--r--r--r--r-x

.interp
.note.ABI_tag
.gnu.hash
.dynsym
.dynstr
.gnu.version
.gnu.version_r
.rela.dyn
.rela.plt
.init

6.5.4. Print Modes.
Một trong những tính năng chính của Radare2 là hiển thị thơng tin ở nhiều định dạng.
Mục đích là đưa ra nhiều lựa chọn hiển thị để diễn giải dữ liệu nhị phân theo cách tốt
nhất có thể [4].
Dữ liệu nhị phân có thể được biểu diễn dưới dạng integer, short, long, float,
timestamps, chuỗi hexpair hoặc các định dạng phức tạp hơn như C structures,
disassembly listings, decompilation listing… [4]
Dưới đây là danh sách các chế độ in khả dụng được liệt kê:

Tips: Khi lựa chọn biểu diễn dữ liệu dưới dạng json, bạn có thể thêm dấu ~ {} vào
cuối lệnh để có thể in ra theo format chuẩn, giúp chúng ta dễ dàng quan sát hơn [4]:


Thực sự thì trong Radare2, dấu ~ có thể làm được nhiều điều thú vị. Tuy nhiên, đây
không phải là vấn đề mà mình đang muốn tập trung khai thác. Vì vậy, nếu các bạn
muốn tìm hiểu thêm thì ở đây chính là nơi các bạn muốn đến.
Tiếp theo, mình muốn nhắc đến một số chế độ xem (View/Print modes) điển hình có
trong Radare2:
Hexadecimal View

Date/Time Formats

Có sẵn các chế độ in cho tất cả các loại cơ bản. Nếu bạn quan tâm đến một cấu trúc
phức tạp hơn, hãy nhập 1 trong 2 lệnh sau đây:
pf??
pf???

- Để tìm các ký tự đại diện cho các loại định dạng.
- Đưa ra ví dụ có các loại định dạng trên.


High-level Languages Views
Để đầu ra hiển thị dưới dạng ngôn ngữ lập trình bậc cao (C, Java, …). Ta làm như sau.


Dùng lệnh pc? để xem các ngôn ngữ mà Radare2 hỗ trợ:

Như chúng ta thấy, Radare2 hỗ trợ hầu hết các ngơn ngữ thơng dụng. Và chúng ta có

thể lựa chọn 1 trong số chúng.
Ba ví dụ dưới đây sử dụng lần lượt C, Java và Python.


Strings
Tầm quan trọng của Strings là không cần bàn cãi, vì thế Radare2 cũng cung cấp cho
chúng ta nhiều định dạng chuỗi khác nhau để có thể sử dụng trong nhiều trường hợp:


Ví dụ:

6.5.5. Flags.
Cờ (Flag) về mặt khái niệm tương tự như dấu trang. Họ liên kết một tên với một
offsets đã cho trong một tệp. Các cờ có thể được nhóm thành 'khơng gian cờ' (Flag
Spaces). Khơng gian cờ là khơng gian tên cho các cờ có đặc điểm hoặc kiểu tương tự
lại với nhau [4]. Ví dụ cho khơng gian cờ: sections, registers, symbols….
Để tạo 1 cờ, ta dùng cú pháp lệnh như sau:
[0x4A13B8C0]> f flag_name @ offset

Bạn có thể xóa cờ bằng cách thêm ký tự “-” vào lệnh.
[0x4A13B8C0]> f-flag_name
Lưu ý: Hầu hết các lệnh đều chấp nhận “-” dưới dạng tiền tố đối số như một dấu hiệu
để xóa một cái gì đó.
Để biết các thao tác nào có thể thực hiện với các khơng gian cờ, hãy sử dụng lệnh
dưới đây:
fs?