网鼎杯misc

青龙组

misc01

题目描述:

某单位网络遭到非法的攻击，安全人员对流量调查取证之后保存了关键证据，发现人员的定位信息存在泄露，请对其进行分析。flag为用户位置信息进行32位md5哈希值

提交的flag格式：wdflag{xxxxx}

下载附件

参考

Diameter协议摘要 - StevensFollower - 博客园

Diameter协议-CSDN博客

diameter协议

了解MME 包含用户的 E-UTRAN 小区全局标识，用于标识用户设备注册的小区

过滤diameter协议

发现location-information

md5加密

最后flag为

wdflag{daedc32bdeceb78094502e481c90c6cc}

misc02

题目描述：

小明在一次例行检查中，发现自己的计算机变得异常缓慢。经过仔细排查，他发现系统中多了一些陌生的文件，似乎是某个攻击者留下的加密代码。小明破解了多次加密的代码后，并试图恢复被删除的内容，细心地发现了部分未删除的加密代码，得到一个TXT的压缩包文件，通过解密TXT内容得到了重要信息。

提交的flag格式：wdflag{xxxxx}

下载附件

查看文件属性，发现内存很大

我勒个2G，foremost分离

查看PNG文件发现有一个png文件很大

zsteg一把梭试试

得到了部分的密码：Y3p_Ke9_1s_???

010查看文件发现藏有7z文件

导出7z文件，发现有密码

想到之前得到的密码，考虑是掩码爆破

得到密码

Y3p_Ke9_1s_29343

解压压缩包得到flag.txt，内容如下

 31         226 PUSH_NULL
            228 LOAD_NAME                8 (key_encode)
            230 LOAD_NAME                7 (key)
            232 PRECALL                  1
            236 CALL                     1
            246 STORE_NAME               7 (key)

 32         248 PUSH_NULL
            250 LOAD_NAME               10 (len)
            252 LOAD_NAME                7 (key)
            254 PRECALL                  1
            258 CALL                     1
            268 LOAD_CONST               7 (16)
            270 COMPARE_OP               2 (==)
            276 POP_JUMP_FORWARD_IF_FALSE    43 (to 364)

 33         278 PUSH_NULL
            280 LOAD_NAME                9 (sm4_encode)
            282 LOAD_NAME                7 (key)
            284 LOAD_NAME                5 (flag)
            286 PRECALL                  2
            290 CALL                     2
            300 LOAD_METHOD             11 (hex)
            322 PRECALL                  0
            326 CALL                     0
            336 STORE_NAME              12 (encrypted_data)

 34         338 PUSH_NULL
            340 LOAD_NAME                6 (print)
            342 LOAD_NAME               12 (encrypted_data)
            344 PRECALL                  1
            348 CALL                     1
            358 POP_TOP
            360 LOAD_CONST               2 (None)
            362 RETURN_VALUE

 32     >>  364 LOAD_CONST               2 (None)
            366 RETURN_VALUE

Disassembly of <code object key_encode at 0x14e048a00, file "make.py", line 10>:
 10           0 RESUME                   0

 11           2 LOAD_GLOBAL              1 (NULL + list)
             14 LOAD_FAST                0 (key)
             16 PRECALL                  1
             20 CALL                     1
             30 STORE_FAST               1 (magic_key)

 12          32 LOAD_GLOBAL              3 (NULL + range)
             44 LOAD_CONST               1 (1)
             46 LOAD_GLOBAL              5 (NULL + len)
             58 LOAD_FAST                1 (magic_key)
             60 PRECALL                  1
             64 CALL                     1
             74 PRECALL                  2
             78 CALL                     2
             88 GET_ITER
        >>   90 FOR_ITER               105 (to 302)
             92 STORE_FAST               2 (i)

 13          94 LOAD_GLOBAL              7 (NULL + str)
            106 LOAD_GLOBAL              9 (NULL + hex)
            118 LOAD_GLOBAL             11 (NULL + int)
            130 LOAD_CONST               2 ('0x')
            132 LOAD_FAST                1 (magic_key)
            134 LOAD_FAST                2 (i)
            136 BINARY_SUBSCR
            146 BINARY_OP                0 (+)
            150 LOAD_CONST               3 (16)
            152 PRECALL                  2
            156 CALL                     2
            166 LOAD_GLOBAL             11 (NULL + int)
            178 LOAD_CONST               2 ('0x')
            180 LOAD_FAST                1 (magic_key)
            182 LOAD_FAST                2 (i)
            184 LOAD_CONST               1 (1)
            186 BINARY_OP               10 (-)
            190 BINARY_SUBSCR
            200 BINARY_OP                0 (+)
            204 LOAD_CONST               3 (16)
            206 PRECALL                  2
            210 CALL                     2
            220 BINARY_OP               12 (^)
            224 PRECALL                  1
            228 CALL                     1
            238 PRECALL                  1
            242 CALL                     1
            252 LOAD_METHOD              6 (replace)
            274 LOAD_CONST               2 ('0x')
            276 LOAD_CONST               4 ('')
            278 PRECALL                  2
            282 CALL                     2
            292 LOAD_FAST                1 (magic_key)
            294 LOAD_FAST                2 (i)
            296 STORE_SUBSCR
            300 JUMP_BACKWARD          106 (to 90)

 15     >>  302 LOAD_GLOBAL              3 (NULL + range)
            314 LOAD_CONST               5 (0)
            316 LOAD_GLOBAL              5 (NULL + len)
            328 LOAD_FAST                0 (key)
            330 PRECALL                  1
            334 CALL                     1
            344 LOAD_CONST               6 (2)
            346 PRECALL                  3
            350 CALL                     3
            360 GET_ITER
        >>  362 FOR_ITER               105 (to 574)
            364 STORE_FAST               2 (i)

 16         366 LOAD_GLOBAL              7 (NULL + str)
            378 LOAD_GLOBAL              9 (NULL + hex)
            390 LOAD_GLOBAL             11 (NULL + int)
            402 LOAD_CONST               2 ('0x')
            404 LOAD_FAST                1 (magic_key)
            406 LOAD_FAST                2 (i)
            408 BINARY_SUBSCR
            418 BINARY_OP                0 (+)
            422 LOAD_CONST               3 (16)
            424 PRECALL                  2
            428 CALL                     2
            438 LOAD_GLOBAL             11 (NULL + int)
            450 LOAD_CONST               2 ('0x')
            452 LOAD_FAST                1 (magic_key)
            454 LOAD_FAST                2 (i)
            456 LOAD_CONST               1 (1)
            458 BINARY_OP                0 (+)
            462 BINARY_SUBSCR
            472 BINARY_OP                0 (+)
            476 LOAD_CONST               3 (16)
            478 PRECALL                  2
            482 CALL                     2
            492 BINARY_OP               12 (^)
            496 PRECALL                  1
            500 CALL                     1
            510 PRECALL                  1
            514 CALL                     1
            524 LOAD_METHOD              6 (replace)
            546 LOAD_CONST               2 ('0x')
            548 LOAD_CONST               4 ('')
            550 PRECALL                  2
            554 CALL                     2
            564 LOAD_FAST                1 (magic_key)
            566 LOAD_FAST                2 (i)
            568 STORE_SUBSCR
            572 JUMP_BACKWARD          106 (to 362)

 18     >>  574 LOAD_CONST               4 ('')
            576 LOAD_METHOD              7 (join)
            598 LOAD_FAST                1 (magic_key)
            600 PRECALL                  1
            604 CALL                     1
            614 STORE_FAST               1 (magic_key)

 19         616 LOAD_GLOBAL             17 (NULL + print)
            628 LOAD_FAST                1 (magic_key)
            630 PRECALL                  1
            634 CALL                     1
            644 POP_TOP

 20         646 LOAD_GLOBAL              7 (NULL + str)
            658 LOAD_GLOBAL              9 (NULL + hex)
            670 LOAD_GLOBAL             11 (NULL + int)
            682 LOAD_CONST               2 ('0x')
            684 LOAD_FAST                1 (magic_key)
            686 BINARY_OP                0 (+)
            690 LOAD_CONST               3 (16)
            692 PRECALL                  2
            696 CALL                     2
            706 LOAD_GLOBAL             11 (NULL + int)
            718 LOAD_CONST               2 ('0x')
            720 LOAD_FAST                0 (key)
            722 BINARY_OP                0 (+)
            726 LOAD_CONST               3 (16)
            728 PRECALL                  2
            732 CALL                     2
            742 BINARY_OP               12 (^)
            746 PRECALL                  1
            750 CALL                     1
            760 PRECALL                  1
            764 CALL                     1
            774 LOAD_METHOD              6 (replace)
            796 LOAD_CONST               2 ('0x')
            798 LOAD_CONST               4 ('')
            800 PRECALL                  2
            804 CALL                     2
            814 STORE_FAST               3 (wdb_key)

 21         816 LOAD_GLOBAL             17 (NULL + print)
            828 LOAD_FAST                3 (wdb_key)
            830 PRECALL                  1
            834 CALL                     1
            844 POP_TOP

 22         846 LOAD_FAST                3 (wdb_key)
            848 RETURN_VALUE

magic_key:7a107ecf29325423
encrypted_data:f2c85bd042247896b43345e589e3ad025fba1770e4ac0d274c1f7c2a670830379195aa5547d78bcee7ae649bc3b914da

逆向还原magic_key至key，再将key转为wdb_key，即SM4密钥

exp:

def key_decode(encoded_key):
    # 第一步：逆向第二次异或操作
    magic_key_list = list(encoded_key)
    for i in range(0, len(encoded_key) - 1, 2):
        magic_key_list[i] = str(hex(int(magic_key_list[i], 16) ^ int(magic_key_list[i + 1], 16))).replace('0x', '')
 
    # 第二步：逆向第一次异或操作
    for i in range(len(magic_key_list) - 1, 0, -1):
        magic_key_list[i] = str(hex(int(magic_key_list[i], 16) ^ int(magic_key_list[i - 1], 16))).replace('0x', '')
 
    # 将列表转换回字符串
    decoded_key = ''.join(magic_key_list)
    return decoded_key
 
magic_key = "7a107ecf29325423"  # 假设这是经过编码后的 magic_key
decoded_key = key_decode(magic_key)
print(decoded_key)  # 输出原始 key
 
def key_encode(key):
    magic_key = list(key)  # 将输入的key转换为列表形式
    for i in range(1, len(magic_key)):
        magic_key[i] = str(hex(int(magic_key[i], 16) ^ int(magic_key[i - 1], 16))).replace('0x', '')
 
    for i in range(0, len(key), 2):
        magic_key[i] = str(hex(int(magic_key[i], 16) ^ int(magic_key[i + 1], 16))).replace('0x', '')
    magic_key = ''.join(magic_key)  # 将列表转换为字符串
    print(magic_key)
    wdb_key = str(hex(int(magic_key, 16) ^ int(key, 16))).replace('0x', '')
    print(wdb_key)
    return wdb_key
print(key_encode(decoded_key))

运行得到

SM4解密

最后flag为

wdflag{815ad4647b0b181b994eb4b731efa8a0}

misc03

题目描述:

近日某公司服务器遭到恶意攻击，随后公司立即对流量监测系统中遭受攻击时段的流量进行了取证，但是公司某一网络安全实习生进行分析溯源后并未找到攻击者的攻击IP，于是公司决定将这个任务重新交给更具经验的你来进行，接手工作后，你立即对其进行了深入调查！

提交的flag格式：wdflag{攻击IP}

下载附件

过滤http，搜索关键字符串hacker

最后flag为

wdflag{39.168.5.60}

misc04

题目描述：

某测试人员刚刚完成了一款图像加密算法的开发，想要邀请你进行深入的分析测试。

提交的flag格式：wdflag{xxxxx}

下载附件

皮亚诺曲线

参考

皮亚诺曲线可以遍历单位正方形中的每一点该怎样理解？ - 知乎

皮亚诺曲线-CSDN博客

IrisCTF2024 | 1r0ny

exp:

from PIL import Image
from tqdm import tqdm

def peano(n):
    if n == 0:
        return [[0,0]]
    else:
        in_lst = peano(n - 1)
        lst = in_lst.copy()
        px,py = lst[-1]
        lst.extend([px - i[0], py + 1 + i[1]] for i in in_lst)
        px,py = lst[-1]
        lst.extend([px + i[0], py + 1 + i[1]] for i in in_lst)
        px,py = lst[-1]
        lst.extend([px + 1 + i[0], py - i[1]] for i in in_lst)
        px,py = lst[-1]
        lst.extend([px - i[0], py - 1 - i[1]] for i in in_lst)
        px,py = lst[-1]
        lst.extend([px + i[0], py - 1 - i[1]] for i in in_lst)
        px,py = lst[-1]
        lst.extend([px + 1 + i[0], py + i[1]] for i in in_lst)
        px,py = lst[-1]
        lst.extend([px - i[0], py + 1 + i[1]] for i in in_lst)
        px,py = lst[-1]
        lst.extend([px + i[0], py + 1 + i[1]] for i in in_lst)
        return lst

order = peano(6)

img = Image.open(r"E:\\脚本合集\\misc\\皮亚诺曲线\\1.png")

width, height = img.size

block_width = width # // 3
block_height = height # // 3

new_image = Image.new("RGB", (width, height))

for i, (x, y) in tqdm(enumerate(order)):
    # 根据列表顺序获取新的坐标
    new_x, new_y = i % width, i // width
    # 获取原图像素
    pixel = img.getpixel((x, height - 1 - y))
    # 在新图像中放置像素
    new_image.putpixel((new_x, new_y), pixel)

new_image.save("rearranged_image.jpg")  

运行得到

或者使用工具一把梭

stegsolve调整通道，扫码得到flag

最后flag为

wdflag{3f531c43-3b8b-42ab-babf-567f1216fa06}

白虎组

misc01

题目描述:

某 5G 研发单位接到 5G 系统瘫痪的告警，研究人员将其收发的流量进行监控，发现异常的报文，请对其分析。找到全部异常报文，将恶意报文中攻击者构造的 teid 按时间先后顺序进行拼接，找到全部由攻击者触发的异常报文进行拼接，所得出的拼接结果即为最终 flag，例如，若按照时间先后顺序排列的恶意报文中攻击者构造的 teid 分别为 0001 和 0002 ，则最终的 flag 值为 wdflag{00010002}。

提交的flag格式：wdflag{xxxxx}

下载附件

首先提取流量中所有的TEID

tshark -r UPF.cap -e "gtp.teid" -T fields | sed '/^s*$/d' > upf.csv

然后对出现的TEID进行统计排序，发现两处发现异常报文的TEID

接着找到对应TEID的GTP流

拼接为178262973531605730

最后flag为

wdflag{178262973531605730}

misc02

题目描述:

某通信运营商遭受到了攻击，但始终无法发现攻击过程，请你帮忙分析流量包，发现其中存在的问题。

提交的flag格式：wdflag{xxxxx}

下载附件

encrypted.py

from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend
import struct

def pad(text):
    while len(text) % 16 != 0:
        text += ' '
    return text

def encrypt(key, plaintext):
    key_bytes = struct.pack('>I', key)
    key_bytes = key_bytes.ljust(16, b'\0')
    cipher = Cipher(algorithms.AES(key_bytes), modes.ECB(), backend=default_backend())
    encryptor = cipher.encryptor()
    padded_plaintext = pad(plaintext).encode()
    encrypted = encryptor.update(padded_plaintext) + encryptor.finalize()
    return encrypted

if __name__ == "__main__":
    key = 1
    msg = "123"
    print(encrypt(key,msg))

给的加密算法脚本使用AES算法的ECB模式进行加密。使用空格进行填充，确保明文长度是16的倍数,然后估计是需要找流量的 response 包,然后看了 response 的发现密文估计就是 截掉前面和请求包重复的字节(在第 14 个 response 找到了),这里看了一下发现 key 是 TEID

exp：

from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend
import struct
def unpad(text): 
    return text.rstrip(b' ')
def decrypt(key, ciphertext):   
    key_bytes = struct.pack('>I', key)   
    key_bytes = key_bytes.ljust(16, b'\0')  
    cipher = Cipher(algorithms.AES(key_bytes), modes.ECB(),backend=default_backend())
    ecryptor = cipher.decryptor()    
    decrypted = decryptor.update(ciphertext) + decryptor.finalize()return unpad(decrypted)
return unpad(decrypted)
if __name__ == "__main__":  
    key = 0xc58e46cc   
    enc ='54ee51f3b3f4bfc7cb28ef496262e49e0389665b5eff669a237d9e71fb3acbecd73c8cd12d9314ff3473e4da6b701f4a'
    data = binascii.unhexlify(enc)
    decrypted_msg = decrypt(key, data) 
    print(decrypted_msg.decode()) 

misc04

题目描述:

一天，某单位收到一个奇怪的文件，文件中的内容让人觉得存在安全隐患，于是你迅速联系我，邀请我一同对文件进行分析

提交的flag格式：wdflag{xxxxx}

下载附件

首先合并三个文件

cat 1 2 3 > 4

合并之后用binwalk可以看到有两个压缩包文件，其中2.png为伪加密，解压之后镜像可得到后一半flag

另一个压缩包根据提示!@#QQQ0010flag进行掩码爆破爆破出后四位数字之后得到一张jpg

使用foremost分离得到一张图片

宽高一把梭

最后flag为

wdflag{5fgh576eee739dh7u904bea4860s4eg5}

朱雀组

misc01

题目描述:

在一间阴暗的地下室里，网络安全专家小张正紧盯着屏幕，刚刚截取到一批黑客通过卫星盗取的数据。数据流中杂乱的信息让他感到困惑，直到他注意到一个异常的加密信号。他开始分析这段信号，经过数小时的解密，终于提取出关键信息：一份重要的文件。他必须迅速采取行动，联系上级并确保这份信息不落入黑客手中。

提交的flag格式：wdflag{xxxxx}

下载附件

010查看文件

01转差分曼彻斯特

exp:

from libnum import *

# 读取文件内容
try:
    with open("E:\\脚本合集\\赛题脚本\\01\\data", "r", encoding="utf-8") as f:
        all_str = f.read().strip()  # 去除前后空白字符
except FileNotFoundError:
    print("文件未找到，请确认文件路径。")
    exit()

# 检查字符串长度
if len(all_str) % 2 != 0:
    print("输入字符串长度应为偶数。")
    exit()

# 计算输出字符串
out = []
n = (len(all_str) // 2) - 1

# 使用列表推导式构建输出
for i in range(n):
    out.append('0' if all_str[i*2:i*2+2] == all_str[i*2+2:i*2+4] else '1')

# 将列表转换为字符串并转换为十六进制
hex_output = hex(int(''.join(out), 2))[2:]

# 将结果写入文件
with open("E:\\脚本合集\\赛题脚本\\01\\res.txt", "w") as f:
    f.write(hex_output)

运行得到

或者使用工具

一眼zip十六字节，直接复制下来，赛博厨子一把梭

压缩包损坏，01检测发现有多余的垃圾字节，发现secret.png被分开

每22个字节去除6个多余字节，可以恢复正常文件

或者使用工具剔除字节

exp:

f = open("E:\\脚本合集\\赛题脚本\\01\\11s.zip","rb")
all_b = f.read()
f.close()
n = len(all_b)
 
for j in range(12,45):
    out = b""
    for i in range(0,n,j):
        out = out + all_b[i:i+(j-6)]
    f = open(f"E:\\脚本合集\\赛题脚本\\01\\out_{j}.zip","wb")
    f.write(out)
    f.close()

运行得到

解压压缩包

爆破密码

得到一张图片

010查看图片

发现末尾有base编码，直接base解密

PixelJihad隐写

最后flag为

wdflag{f3b32f2151a877cad089c25994e5da4a}

misc02

题目描述:

“新盲盒系列发布了，大家一起来抽奖吧！”此刻的你被这样的字样吸引，于是你决定试试！请使用jdk1.8运行本程序。

提交的flag格式：wdflag{xxxxx}

反编译查看java文件

发现AES密钥，继续找有用的东西

AES解密

最后flag为

wdflag{1b8d8a4c-5237-4ef5-86f6-d651177b33dc}

misc03

题目描述:

小李对计算机安全产生了浓厚的兴趣，他学习了一些关于隐藏文件和磁盘加密的方法。他了解到，文件隐藏和加密是保护个人数据的重要手段，因此决定实践自己的新知识。他得到了一个不错加密软件，于是邀请到你，迫不及待地想要一起测试其效果。

提交的flag格式：wdflag{xxxxx}

下载附件

foremost分离看看

一眼crc爆破

得到压缩包密码为

This_WD_005Cryptpw

解压缩，VeraCrypt挂载

查看文件secret.key

-----BEGIN ENCRYPTED PRIVATE KEY-----
MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAMPZ/6U81pHCEFuL20f1XWiCbUgVaZOcoM9nYUE22mFPdU5Tjc94zzD8wOv39UxlrAWyqJiXxsXJZqebLOpoxvLEtQo/FeghAugsZFqsXhEGDJkWnyTLcfGiZyxNjes+odWXPcFD9/h+YDfn9FLUjwCDM/KuQwcjjmbLifsZlRq/AgMBAAECgYAicopzfsLiujZ0U6ILAw4d3qrn/dQnAWqLcEx70vEQIpCoaSvNLRuMKziniGJdwJhEHEtpI3DzwtvKaRG6XRl4tHKUFtAhNXrSx3xhiS1UFpMeWIPxuloBuT5b1qi8xd5xyGMhYytAFj2FbakRWhpHsbi7Gfzs/ff9dedo//49MQJBAPtmpyEXX2CquHKarpiZqo6wPYmD6VhqnkDcJuQl41de60FKGu5C8wMjaUel3DfRHaOgK2n4yHTGx+GsEIZfK3kCQQDHbzMjOw1vWTl373Lgme5odEGH29Ims/80UwJHqJUBECdp2krZs53YNkNOi48r3OqUadosMWTLlbr827KT8DH3AkAn6+IoUBTWPeXyVPvawbQi2nu7JZZdcvjUZeFLI3UZf7ot8P2bzkfWvL3QIdd5iZyCSkH6nwX9/T7qaC9rlxtJAkAp41RFURDoU0A7zaI+RHaLn+dnpqcEFAhFMC4paOIq//6XQA86nHxJvlPyumNO3i6zD2yQnatDC2bj1y0x32BPAkEAyMdU7iZLQi3t7/v5/OZjtcR41xnjjjp1rhEBaFTxGij/7zhXjMwPW7gmKBcPuLwltSiaM3PwAuq/sByn0jusgg==
-----END ENCRYPTED PRIVATE KEY-----

Glag.txt

eeiV0y1M9ksQ43dcYml7n//RAmH4M56Dm7A4TaKQyJguU8PdVAafpXkgczJyUns2/irfEHt2Pc30MfgPWzh0ezJtlBx2VsV1NZXat7iA5tjpIgozl3SbIlZjvKvUI3dEv3u0lbp3e3kefUuP8o38LYe45kw5WfhmiGdy+cT0r3E=

rsa解密

最后flag为

wdflag{7fe9222870441b98be26c12f8a8dd658}