Canvas is not supported in your browser.
首页 课程 文章
无痕注入 APC注入 线程注入 读写驱动 注入技术 句柄表 进程线程 系统调用 保护模式 内存管理 远程CALL 软件调试 驱动封装 云下发 驱动开发 FPS数据 方框透视 FPS方框 FPS自瞄 CE D3DHOOK D3D绘制 Imgui绘制 DWM
内核课程 驱动出租 学习路线 聊天室 免责声明 提问技巧

CTF对抗-由两道CTF汇编题目来学习ARM和X86汇编

推荐 原创

周杰伦

文章分类 CTF对抗 阅读数 : 269 阅读时长 : 9分钟


【CTF对抗-由两道CTF汇编题目来学习ARM和X86汇编】此文章归类为：CTF对抗。

这两道题目是我朋友发给我的，题目比较简单，但是考察了二进制汇编基础。
个人觉得基础很重要，所以花了些时间来认真看这道题目，巩固自己的基础。
如果是在线下，没有GPT的帮助，此时就需要选手汇编底子，对题目进行细致的分析。
如果学习汇编有题目带着学，耐心分析，相信收获会很大的，有助于理解汇编操作的逻辑和方法。
开始今天的题目讲解，题目会打包上传
如果有错误，还请指出哈哈

1、x86汇编

原题目我就不粘出来了哈，附件里面有的，这里粘一下我注释分析后的
题目给的是AT&T风格的x86汇编，那么和我们常见的intel语法有什么不同呢？

  1. 操作数顺序不同：在AT&T语法中，操作数的顺序是“源，目的”，而在Intel语法中是“目的，源”。例如，在AT&T语法中，movl %eax, %ebx表示将eax寄存器中的值移动到ebx寄存器中，而在Intel语法中，相应的指令为mov ebx, eax。
  2. 寄存器名称不同：在AT&T语法中，寄存器名称以%开头，而在Intel语法中没有前缀。例如，在AT&T语法中，%eax表示EAX寄存器，而在Intel语法中，相应的寄存器名称为EAX。
  3. 立即数和内存地址表示不同：在AT&T语法中，立即数使用$前缀，而内存地址使用方括号[]包围。例如，movl $0x123, %eax表示将立即数0x123移动到eax寄存器中，而movl (%ebx), %eax表示将ebx寄存器指向的内存地址中的数据移动到eax寄存器中。
  4. 符号扩展不同：在AT&T语法中，符号扩展是默认进行的，而在Intel语法中需要使用movsx或movzx指令来进行。例如，在AT&T语法中，movb -1(%eax), %bl表示将eax-1地址处的字节符号扩展后移动到bl寄存器中，而在Intel语法中，相应的指令应为movsx bl, byte ptr [eax-1]。

（建议自己先看一下原题目，手动分析一下，分析完尝试自己解密，看是否能得到正确的flag）
有了上面的基础之后，开始看题目：

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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
```@定义了一些辅助信息，比如：文件名，段名称
. file   "main.c"
     .text
     .section    .rodata
     .align 32
     . type   encode, @ object
     .size   encode, 39
encode:
     .string "**************************************"
     .text
     .globl  main               @将main标记为全局可见的。
     . type   main, @function    @声明main是一个函数。
main:
.LFB0:
     .cfi_startproc  @CFI (Call Frame Information)指令，用于生成调试信息。
     endbr64         @对应特定的处理器指令，提供分支目标地址的溢出检测。
     pushq   % rbp
     .cfi_def_cfa_offset 16
     .cfi_offset 6 , - 16
     movq    % rsp, % rbp
     .cfi_def_cfa_register 6
     subq    $ 16 , % rsp     @rsp = rsp - 16
     @堆栈操作指令，用于保存和恢复寄存器的值。 上面除去CFI指令后是经典的开辟栈空间指令
     movl    $ 0 , - 4 ( % rbp)  @ [rbp - 4 ] = 0
     jmp .L2               @无条件跳转到L2处开始执行
 
@L5 由下文的分析可知道，这是个循环
.L5:
     addl    $ 1 , - 4 ( % rbp)  @[rbp - 4 ] + +
.L2:
     movl    - 4 ( % rbp), % eax      @eax = [rbp - 4 ]
     cltq                        @将eax寄存器的低 32 位符号扩展为 64 位，结果存储在rax寄存器中（在x86 - 64 中，eax是低 32 位的rax）。
     leaq    encode( % rip), % rdx  @rdx = encode[rip]  就是将flag传给rdx
     movzbl  ( % rax, % rdx), % eax   @从以rax + rdx为基址的内存地址中读取一个字节，并将其零扩展为 32 位。然后将结果存储在eax寄存器中
     movsbl  % al, % ecx           @ ECX = EAX
     movl    - 4 ( % rbp), % eax      @ eax = [rbp - 4 ]
     andl    $ 1 , % eax            @ 判断奇偶性
     testl   % eax, % eax
     je  .L3                     @ 若为偶数，则跳转到L3      
     movl    - 4 ( % rbp), % eax      @ eax = [rbp - 4 ]
     subl    $ 1 , % eax            @ eax = eax - 1
     cltq                      
     leaq    encode( % rip), % rdx  @rdx = encode[rip]
     movzbl  ( % rax, % rdx), % eax   @eax = [rax + rdx] rax相当于下标i
     movsbl  % al, % eax   
     jmp .L4
.L3:
     movl    - 4 ( % rbp), % eax   @eax = [rbp - 4 ]
.L4:
     xorl    % ecx, % eax    @eax = eax ^ ecx
     movl    % eax, % edi    @edi = eax
     call    putchar@PLT   @putchar
     movl    - 4 ( % rbp), % eax   @eax = [rbp - 4 ]
     cltq                   
     cmpq    $ 37 , % rax        @ cmp ( 37 ,rax)
     jbe .L5             @rax< 37 则跳转到L5 ，继续循环
     movl    $ 0 , % eax    @eax = 0
     leave
     .cfi_def_cfa 7 , 8
     ret
     .cfi_endproc
 
     @一些调试信息
.LFE0:
     .size   main, . - main
     .ident  "GCC: (Ubuntu 11.4.0-1ubuntu1~22.04) 11.4.0"
     .section    .note.GNU - stack,"",@progbits
     .section    .note.gnu. property , "a"
     .align 8
     . long   1f - 0f
     . long   4f - 1f
     . long   5
0 :
     .string "GNU"
1 :
     .align 8
     . long   0xc0000002
     . long   3f - 2f
2 :
     . long   0x3
3 :
     .align 8
4 :

这题有点绕的地方是[rbp-4]、eax和ecx之间的关系
这里给出完整的解题wp，crypto密文呢是题目附件给出了

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
 
 
int main() {
     char crypto[] = { 0x66 , 0x0a , 0x63 , 0x06 , 0x7f , 0x1e , 0x37 , 0x00 , 0x38 , 0x03 , 0x6f , 0x04 , 0x6e , 0x56 , 0x3d , 0x55 , 0x22 , 0x06 , 0x26 , 0x51 , 0x72 , 0x04 , 0x21 , 0x03 , 0x21 , 0x01 , 0x7c , 0x05 , 0x2b , 0x0e , 0x7c , 0x50 , 0x17 , 0x56 , 0x10 , 0x0b , 0x16 , 0x4f , 0x26 };
     for (size_t i = 0 ; i < 39 ; i + + )
     {
         if (i % 2 = = 0 ) / / 偶数
         {
             printf( "%c" , crypto[i] ^i);
         }
         else {
             char tmp = i;
             crypto[i - 1 ] = crypto[i - 1 ] ^ (i - 1 );
             printf( "%c" , crypto[i - 1 ] ^ crypto[i]);
         }
     }
 
     return 0 ;
}

2、ARM汇编

  1. 精简指令集：ARM架构以精简指令集（Reduced Instruction Set Computing，RISC）著称。它的指令集设计简洁高效，提供了基本的算术、逻辑、数据传输和流程控制等操作。
  2. 寄存器：ARM架构具有大量的通用寄存器。32位ARM架构（ARMv7和ARMv8）提供16个通用寄存器（R0-R15），用于存储常用的数据和临时计算结果。
  3. 三地址指令格式：ARM指令通常采用三地址指令格式，即指令中包含源操作数、目的操作数和要进行的操作。这使得ARM汇编相对简洁，并且减少了内存访问次数。
  4. Thumb指令集：在某些ARM处理器上，还存在Thumb指令集，它使用16位指令（相对于32位的ARM指令）来减小代码的大小。Thumb指令集可以提供更高的代码密度，适用于内存有限的嵌入式系统。
  5. 跨平台：ARM架构广泛用于移动设备、嵌入式系统和低功耗应用，包括智能手机、平板电脑、物联网设备等。由于ARM处理器家族的多样性，ARM汇编在不同的ARM处理器之间可以共享，但也会有一些差异和特定的指令。

给出注释后的题目汇编

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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
@ ARM gcc 11.1 (linux)
.Ltext0:
flag:
         .ascii  "***************************\000"
.LC0:
         .ascii  "%02x\000"
main:
.LFB0:
         @ 这是注释，表示该函数不接受任何参数，使用一个 8 字节大小的栈帧，并且需要保存现场数据。
         @ args = 0 , pretend = 0 , frame = 8
         @ frame_needed = 1 , uses_anonymous_args = 0
 
         push    {r7, lr}   @保存r7和lr寄存器的值到栈中，以便后续恢复现场使用。
         sub     sp, sp, #8 @在栈上分配8个字节的空间。
         add     r7, sp, #0 @将栈指针保存到r7寄存器中，形成一个帧指针。
.LBB2:
         movs    r3, #0
         str     r3, [r7, #4] @将0赋值给r3寄存器，并将其存储到帧指针偏移为4的位置。
         b       .L2          @无条件跳转到标签.L2处。
.L5:                         @这是一个标签，标识一个循环的开始(为什么是循环，后面分析即可)
         ldr     r3, [r7, #4]
         and     r3, r3, #1
         cmp     r3, #0
         bne     .L3         
         @从帧指针偏移为 4 的位置加载一个值到r3寄存器，并将其与 1 进行按位与运算。然后，将结果与 0 进行比较，如果不相等，跳转到标签.L3处。
         movw    r3, #:lower16:flag @将全局变量flag的低16位地址加载到r3寄存器。
         movt    r3, #:upper16:flag @将全局变量flag的高16位地址加载到r3寄存器的高16位。
         ldr     r2, [r7, #4]       @从帧指针偏移为4的位置加载一个值到r2寄存器。这个值可能是一个偏移量，用于对r3寄存器中的地址进行修正。
         add     r3, r3, r2         @将r2寄存器的值加到r3寄存器中，修正flag的地址。
         ldrb    r3, [r3]        @ zero_extendqisi2 从r3寄存器中的地址处加载一个值到r3寄存器，并进行零扩展。这个值即为flag的值。
         eor     r3, r3, #57   @将r3寄存器的值与57进行按位异或操作。
         uxtb    r3, r3        @将r3寄存器中的值零扩展为一个字节。
         mov     r1, r3        @将r3寄存器中的值复制到r1寄存器，作为printf函数的第二个参数。
         movw    r0, #:lower16:.LC0   @相同的道理，加载字符串
         movt    r0, #:upper16:.LC0
         bl      printf          @调用函数
         b       .L4            @无条件跳转
 
.L3:    @flag[i] 为奇数 ，不操作
         movw    r3, #:lower16:flag
         movt    r3, #:upper16:flag
         ldr     r2, [r7, #4]
         add     r3, r3, r2      @这里的作用，就是取下标 flag[i] 的意思
         ldrb    r3, [r3]        @ zero_extendqisi2
         mov     r1, r3          @
         movw    r0, #:lower16:.LC0
         movt    r0, #:upper16:.LC0
         bl      printf          @调用函数
 
 
.L4:    @从帧指针偏移为 4 的位置加载一个值到r3寄存器，并将其加 1 。然后将结果保存回帧指针偏移为 4 的位置
         ldr     r3, [r7, #4]
         adds    r3, r3, #1
         str     r3, [r7, #4]
 
 
.L2:    @从帧指针偏移为 4 的位置加载一个值到r3寄存器，并将其与 26 进行比较。如果r3小于等于 26 ，则跳转到标签.L5处，否则继续执行。
         ldr     r3, [r7, #4]
         cmp     r3, #26
         ble     .L5
 
 
.LBE2:  @将 0 赋值给r3寄存器，将其作为返回值存储到r0寄存器，增加帧指针的值，并将栈指针设置为帧指针
         movs    r3, #0
         mov     r0, r3
         adds    r7, r7, #8
         mov     sp, r7
         @ sp needed
         pop     {r7, pc}
.LFE0:
.Letext0:
.Ldebug_info0:
.Ldebug_abbrev0:
.Ldebug_line0:
.LASF6:
.LASF10:
.LASF0:
.LASF11:
.LASF3:
.LASF7:
.LASF9:
.LASF1:
.LASF15:
.LASF8:
.LASF12:
.LASF2:
.LASF14:
.LASF5:
.LASF13:
.LASF4:
@ 7d416a436d4642315c740c64095f7872745f6d720d315769574744

写出对应的解密脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>
 
char flag[] = { 0x7d , 0x41 , 0x6a , 0x43 , 0x6d , 0x46 , 0x42 , 0x31 , 0x5c , 0x74 , 0x0c , 0x64 , 0x09 , 0x5f , 0x78 , 0x72 , 0x74 , 0x5f , 0x6d , 0x72 , 0x0d , 0x31 , 0x57 , 0x69 , 0x57 , 0x47 , 0x44 }; / / 这里的字符串内容应该与实际代码中的 flag 相同
 
int main() {
     int i = 0 ;
     while (i < = 26 ) {
         if ((i & 1 ) ! = 0 ) { / / 如果 i 是奇数则直接输出
             printf( "%c" , flag[i]);
         } else {
             printf( "%c" , flag[i] ^ 57 );
         }
         i + + ;
     }
     return 0 ;
}

可以看到，这两道题目都判断了奇偶性，不像之前就是简单的异或或者相加相减，这样通过奇偶性判断，更加考察选手对汇编流程的理解。



更多【CTF对抗-由两道CTF汇编题目来学习ARM和X86汇编】相关视频教程：www.yxfzedu.com




相关文章推荐

记录自己的技术轨迹
文章规则：
1)：文章标题请尽量与文章内容相符
2)：严禁色情、血腥、暴力
3)：严禁发布任何形式的广告贴
4)：严禁发表关于中国的政治类话题
5)：严格遵守中国互联网法律法规
6)：有侵权,疑问可发邮件至service@yxfzedu.com
近期原创 更多
友情链接
内核结构 FAQ
免责声明
课程目录
Windows内核
游戏逆向(FPS)
技术交流QQ群
342478842 215039827 137189196
314055665 159620936
微信公众号
www.yxfzedu.com是一个分享游戏安全,游戏外挂与反外挂,游戏驱动保护的视频网站！
接各种驱动定制如：游戏读写驱动，软件内存保护，防止调试等功能定制。
出租读写驱动，调试驱动，无痕注入支持各种游戏。
邮箱：service@yxfzedu.com
QQ：851920120
特别说明：不接游戏数据分析，外挂编写，登陆协议等类似业务。