发表于 2025-08-14 更新于 2025-04-11

MISC

1 、2、3 ez_game系列

直接放进vscode审代码，观看逻辑三分钟做完

4 ezpicture

放进stegsolve，扫个二维码即可

5 mujica

首先foremost提取嘛
出来一个破损二维码图片和mujica图片，看起来就是长宽有问题

import zlib
import struct
import argparse
import itertools


parser = argparse.ArgumentParser()
parser.add_argument("-f", type=str, default=None, required=True,
                    help="输入同级目录下图片的名称")
args  = parser.parse_args()


bin_data = open(args.f, 'rb').read()
crc32key = zlib.crc32(bin_data[12:29]) # 计算crc
original_crc32 = int(bin_data[29:33].hex(), 16) # 原始crc


if crc32key == original_crc32: # 计算crc对比原始crc
    print('宽高没有问题!')
else:
    input_ = input("宽高被改了, 是否CRC爆破宽高? (Y/n):")
    if input_ not in ["Y", "y", ""]:
        exit()
    else: 
        for i, j in itertools.product(range(4095), range(4095)): # 理论上0x FF FF FF FF，但考虑到屏幕实际/cpu，0x 0F FF就差不多了，也就是4095宽度和高度
            data = bin_data[12:16] + struct.pack('>i', i) + struct.pack('>i', j) + bin_data[24:29]
            crc32 = zlib.crc32(data)
            if(crc32 == original_crc32): # 计算当图片大小为i:j时的CRC校验值，与图片中的CRC比较，当相同，则图片大小已经确定
                print(f"\nCRC32: {hex(original_crc32)}")
                print(f"宽度: {i}, hex: {hex(i)}")
                print(f"高度: {j}, hex: {hex(j)}")
                exit(0)

改出来

得到了前半部分
接着看二维码，这里先搜一下二维码基本的结构
https://www.cnblogs.com/luogi/p/15469106.html
观察方块，看出来是m2格式
去https://merri.cx/qrazybox/ 来编辑，这里一定注意，先将原画布设置为白色，默认是灰色，导致提取不出来。。。。然后根据破损图一点点填，在用tools里提取。

6 皮卡丘

打开txt有一堆的pika类似的，上网搜索库
安装pikalang库

1
2
3

import pikalang
code="""pi pi pi pi pi pi pi pi pi pi pika pipi pi pipi pi pi pi pipi pi pi pi pi pi pi pi pipi pi pi pi pi pi pi pi pi pi pi pichu pichu pichu pichu ka chu pipi pipi pipi pipi ka pikachu pi pi pi pi pi pikachu pi pikachu pi pi pi pi pi pi pi pi pi pi pi pi pi pikachu ka ka ka ka ka ka ka ka ka ka ka ka ka ka ka ka ka pikachu pi pi pi pi pi pi pi pi pi pi pi pi pi pi pi pi pi pi pi pi pi pi pikachu ka ka ka ka ka ka ka ka ka ka ka ka ka ka ka ka ka ka ka ka ka ka ka pikachu pichu pichu pi pi pi pi pi pi pi pi pi pi pi pi pi pi pi pi pi pi pikachu pipi pipi ka ka ka ka ka pikachu pi pi pi pi pi pi pi pi pi pi pi pi pi pi pi pi pi pi pi pi pi pi pi pi pi pi pikachu pichu pichu pikachu pipi pipi ka ka ka ka pikachu ka ka ka ka ka ka ka ka ka ka ka ka ka ka ka ka ka ka ka ka ka ka pikachu pi pi pi pi pi pi pi pi pi pi pi pi pi pikachu pichu pichu pi pikachu pipi pipi ka pikachu ka ka ka ka ka ka pikachu ka ka ka ka ka ka pikachu pi pi pi pi pi pi pi pi pi pi pi pi pi pi pi pi pi pikachu ka ka ka ka ka ka ka pikachu pi pi pikachu pichu ka ka ka ka ka pikachu pipi ka ka ka ka ka ka ka ka pikachu pi pi pi pi pi pikachu pi pi pi pi pi pi pi pi pi pi pi pi pi pikachu pi pi pi pi pi pi pi pi pikachu"""
print(pikalang.evaluate(code))

chive{d0_y0u_l1ke_pikAchu}None

7 压缩包的秘密

binwalk提取一下，注释发现"chive???"
掩码爆破直接chive2025
这里还有个伪加密(?)7.zip打开就没问题
flag.txt:

1	GJODMYN4IJFDLG7N7WQPDPTPJATRXR3MKRBRXTMGGCVBBE62IO======

看着像base家族，但随波逐流解不出来，后来将压缩包放进010

发现了这个，找ds写个脚本(其实搜也能搜出来)

import base64

# 自定义Base32字母表（加密时用的）
custom_key = "A2B3C4D5E6F7GJKILHMNORSPQTUVWYXZ"
# 标准Base32字母表
standard_base32 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"

# 密文
ciphertext = "GJODMYN4IJFDLG7N7WQPDPTPJATRXR3MKRBRXTMGGCVBBE62IO======"

# 将密文字符用custom_key的索引映射为标准Base32字符
translated = ""
for c in ciphertext:
    if c in custom_key:
        index = custom_key.index(c)
        translated += standard_base32[index]
    else:
        translated += c  # 保留=等符号

# Base32 解码
decoded = base64.b32decode(translated)
print(decoded.decode("utf-8"))

chive{Th1s_1s_7h3_TruE_fLa6!!!}

8 来道流量

打开wireshark 过滤dns协议

看到有一些像base编码的，收集起来
ZmxhZ3tlNjYyYWMxNTRjYTM3NmUxYzAwMWVlOGJiZTgxMzE4Yn0K
解码得到
flag{e662ac154ca376e1c001ee8bbe81318b}

9 跨越千年河流

一直以为想错了，结果还真是这么做
根据题目描述，就是提取流呗，收集rtp包电话-分析,将raw包导出，应该是有一个audio和另外一个video包，这里光收集video包即可。
搜索sdp

保存成sdp文件(注意修改c的ip，看是win还是wsl发送),放到vlc里配置，这里要下载rtptools，我这里使用的wsl看，就是要添上win的ip地址

1	rtpplay -T -f /root/4.5校长/video.rtp -v 192.168.xx.xx/4844

然后推流

看这个文章
https://blog.csdn.net/weixin_40729354/article/details/120299575

CRYPTO

1 BABYRSA

$i=pq+p+q+1$
$n=i-x-1$

import libnum

c_hex = "0x4ebbf8076700d7a9222bc93f7e18c3757844b3eec4f3b577a6775f18439a2c24b5899b2c09efd0091ef72408e5d75d1e75fc5d959ab597b566cb1fb566fade0c4ca91c0e3981a7c40a9aee400d820860f4c3a0d06b3f34c3f20e899257329f101f2466209e40442ee83f64a978329cbd0678902bbb745c51bd5bc10bde2c6a03b8371ef7cc0d827132c9e4d1f265464a9a5c8ba044401285e8a979729240d2b136413198e99a8035abc5957f946f4399c23a74aa188f016f98645cf0b131637ff198fe7399311c4a4ecf9afe99aa9aa887b774d0a4666fbffa85202325021e953b37e0ddfd5418c429f41846c8a9aae4f57836e294a4f4b0be7a93637ce46b25"
x_hex = "0x145ff16e8995b700f1c08547df4a68ff27a4941e0964f34a2c092066fe3db190d861ef4732697cb7c4aa719a0b7a6f8edf339c2026ddcc98e272c265a6ffdfb9fda2c1161ae04345e8e820b48855ca207a657b27848c509484c42f86583d61fdf2f9f6c55f99c5160be828ba0112d8e9acf49e1186af29103d81b3fc93c366f06"
i_hex = "0x67c86b964eb41f186908c7fbd2c20cffad094a71cf9e2e40028bb64d7929a81c0202e1d2b36da8ad6a833dd4c2e97f79ae50f5aaa89d5db04abfd3b39852518836af01bf656badc22929f1335e7df0454ef8d3d77a8ab4fab9e6daa4887eb02bc25715b72736129a60dc3bea75826b0bca03ff7a18c1e01caa3d0b1aed79de23fab0548332135c1243fd1debd8bcc71b29514558020cd68bf81f4eec1a2b8c147a391527d565916e53186994017c9998788860d51a0b863221e189288c94deda7956c8a18f36617c32959623c7f86b01817dac41c9f23b2de2125e34e9e64fda7164261aa65f8527fbf1b980b54ec14087e5cff4ee0838b6d47e768bb1e14fcc"
d_hex = "0x64f298bbe699c94493cba2284d345444baf27026378279e36b3b6f5c24c8a44fdb59210cc6b6cb8398de7a1fcb36199bee924e860868ce2b26c22ccc2339257cef9c10d716f1acdc20cb4138520133f510c3e8fcc05d3b810329215b9d9b27593e2f16ea9f4935e0af067a8bcb5a271a3143bb24b67cdbb50b6dda2a00c4c50407397a8db1ad834ed8f327540df04b4bd38d4101fd4dad98174fe0434ab3ff424de5b428fcb821189b02a4e12314d87d830ce5dace416295a2f778aaa6c9eff948474632e7892a75b78bae84d66a426dee01b0e79690ca12be0ad82dd51c60de7bf3e58ce03e8261a68444c92fa8ed6fc9722977beb119ee436640b48565d269"

c = int(c_hex, 16)
x = int(x_hex, 16)
i = int(i_hex, 16)
d = int(d_hex, 16)

N = i - x - 1
m = pow(c, d, N)
flag = libnum.n2s(m)
print(flag)

2 hashhh

其实没太搞懂…看的题解(但代码跑不出来)
先生成length为 $0x142857142857142857$ 的数组,生成的方法是第0位为1，第i位是 $h[i-1]*p%m$ ，然后加上i位前的某一位，然后再对m取模，最后一个数与 $flagnum$ 异或
但发现listhash（h）前一百位均为第0位，也就是加1，生成s时加上了空格使得最后一位哈希值为0

1
2
3

h=[1,(p+1)%m, (((p+1)%m+1)*p)%m, (((((p+1)%m+1)*p)%m)*p+1)%m...]
化简一下，先乘后加
h=[1%m,(p+1)%m,(p**2+p+1)%m,(p**3+p**2+p+1)%m...]

from Crypto.Util.number import long_to_bytes

p = 369944419156711147060143317175368453031918731002211
m = 15977898348258634512826613220527141251832530996721392570130087971041029999399
output = 2585445282868005908429000279352060638616081153750867519015673856624926072491

num = 0x11451441541112138
# 计算 (p^(num+1) - 1) / (p-1) mod m
numerator_mod = (p - 1) * m
pow_p = pow(p, num + 1, numerator_mod)
x = (pow_p - 1) // (p - 1)  # 使用整数除法

flagnum = output ^ x
print(long_to_bytes(flagnum))
#b'chive{D0NOT_1gN0e_Spac1}'

3 通往密码学的门票

没啥好说的，而且都给了，就是aes我怎么cyberchef跑不出来

from Crypto.Cipher import AES
import base64

cipher_b64 = "1HNbfgdgCb//dpGk12YtczYGLYmjdR7s9dCKJJfrr98="
key = b"chiveneed crypto"  
iv = b"1234567890123456"   

cipher_bytes = base64.b64decode(cipher_b64)
cipher = AES.new(key, AES.MODE_CBC, iv)
plaintext = cipher.decrypt(cipher_bytes)

print(plaintext.decode())
#chive{AES_is_Str0ng_and_secure!}

Y2hpdmV7eWVwX2Jhc2U2NF8xMTF9 chive{yep_base64_111}
nstgp{jpa_nlpdlc_222}     chive{yep_caesar_222}
cdnn3h{oko1c3}ie__1f13vu__  分为4栏时，解密结果为:chive{do_u_kno1_f1nc1_333},一定要复制全
uvejrflzayncqbrtl	
key:chive                 sowonderfulvignre
63686976657b6865785f6d61737465725f68756868687d chive{hex_master_huhhh}
https://ctf.bugku.com/tool/cvecode chive{good_boys_and_girls!!1}

4 那年12

跟有些题还挺像的，这里知道pq接近，可以采用sqrt的方式来接近,问题就是phi如何求，这里我是枚举来做的

from Crypto.Util.number import *
from gmpy2 import*
c = 14271757452507943071363474081183177541200790942660097362031513886851813587528134582572623848099972456210228075056689703678634430590797149277427115279824926442186977544324306260773649073825258375503308259966047878145831154583554477788481105294302042561339920635706483442941551205973477969173915718871915200671444481285822722729938647546992523692395422404360203948065134128667282828088223097039984276000238274553470626265301814171381825551273451184740276394592917354674905944151497783585449290941573824525838704634409122052101666001004692525883972813532885183994544943464894545185023638492085950625538360026448964484416
d = 4815495065667066088118714476427058753990743828259006517928935325112968696840430371714130163853991651023479500210542005249756415206638902683029392973565078922631633962903160240083183872850081940759280556038034304922411271717701758840032637415957285506384476648687723125050863954698306566523238177577903137128985048379343833790147660878587100123568156527088537427057806920417679112122772952688286636103079120623812415745406014703247604608247491265604106814516290321498329310376520189943315843444275641215377323721032913694774148750077107667520354091976538955228826389103068822347784629987748995327732324026601673620853
e = 65537
p_bits=1024
q_bits=1024

k_phi = e*d -1
pphi = []
for k in range(e,2,-1):
    if k_phi % k == 0:
        tmp = k_phi // k
        if int(tmp).bit_length()==p_bits+q_bits:
            pphi.append(tmp)
            
print(len(pphi))
#print(pphi)
for k in pphi:
    pp=iroot(k,2)[0]
    pp=next_prime(pp)
    for i in range(100):
        flag=long_to_bytes(pow(c,invert(e,pp-1),pp))
        print(flag)
        exit()
        pp=next_prime(pp)
#b'chive{oH_11zy_p30b1eM_Fo3_Y0u!!}'

借用bit数来判断一个正确的phi值
$mod\,n \equiv mod\,p$ 注意这个就行了， $n=p*q$

5 那年20

这个好像也没啥好说的(),搜了挺久关于padding的，也有一个比较麻烦的，但也跟这个题不一样，e=3，直接枚举跑了一会就出了(),甚至出来的时候有点不可思议(n个月前，国赛后的面试dab还问过这个)

import libnum
import gmpy2


n =130823032626799224452148019344025608061409017976462166774679992766799718357920535935980876983571254896758319726956843139212788830476913001454998545653825290696492436161214853422265879037380706290530688595244797045788241743825760099936978094114772320832692543301259855843184737423582796490936667390065449150307
c =122953105834407050979933718031703750977998186903112777777073310509698093824373690792414682116583433136436812038369540800496491082382988156675797619093789603345734749277859167497030683286993302244087972139598554357992507029495039234588959439402736613308786156913068269204559388322577936927056254222544856583113
e = 0x3

def exp(n, e, c):
    k = 0
    while 1:
        m1 = k * n + c
        m, t = gmpy2.iroot(m1, e)
        if t:
            print(m)
            print(k)
            print(libnum.n2s(int(m)))
            break
        k += 1
exp(n, e, c)
#3562371680658530203399822296834436195305530479644786679754750303845462026492117621601616961933793938207332
#345567965
#b'chive{pADddin6_1s_fUN_R1gHt}this_is_not_hard'

最后一战

显然没有很常规，这里的m3与n3-1不互素，就从网上找，这里的m相当于e比较大,找到一个类似的脚本,模素数上开 m 次幂根

from Crypto.Util.number import * 
 
q = 165338063123514818523885615737501133739
p = 20297342154853718314952219089481624063
e = 65536
n = q*p
c = 3024714280730674139248049746725214418740416860076557280072680498394712377473

for mp in Zmod(p)(c).nth_root(e, all=True):
    for mq in Zmod(q)(c).nth_root(e, all=True):
        m = crt([ZZ(mp), ZZ(mq)], [p, q])
        try:
            flag = long_to_bytes(m)
            if flag.startswith(b'flag'):
                print(flag)
                print(mp)
                print(mq)
        except:
            pass

from sage.all import *
from Crypto.Util.number import *

# === 已知数据 ===
c3 = 343867914501222774273628126718287177048192002282106212934299652875247506214865375303243826284548
m3 = 354701
n3 = 995191358912871577558833631674614669607986330666857878724182860415671438190193766871991662518891

m2 = 433393
n2 = 669465653861088292142786513664790611054135025346092499931230244815441606915128078895389965653627

m1 = 422861
n1 = 958508882983697210929286552537536183615084340675769274475367427999338264420449936341879064360869

# Step 1: c3 = c2^m3 mod n3 ⇒ 枚举所有 c2
c2_list = Zmod(n3)(c3).nth_root(m3, all=True)

for c2 in c2_list:
    c2 = int(c2)
    try:
        # Step 2: c2 = c1^m2 mod n2 ⇒ 枚举所有 c1
        c1_list = Zmod(n2)(c2).nth_root(m2, all=True)
        for c1 in c1_list:
            c1 = int(c1)
            try:
                # Step 3: c1 = c0^m1 mod n1 ⇒ 枚举所有 c0
                c0_list = Zmod(n1)(c1).nth_root(m1, all=True)
                for c0 in c0_list:
                    c0 = int(c0)
                    flag = long_to_bytes(c0)
                    if b'chive{' in flag:
                        print(f'[+] Flag Found: {flag.decode()}')
                        raise StopIteration  # 终止多重循环
            except:
                continue
    except:
        continue

[+] Flag Found: chive{De3p_s33K_1s_s0_sT3oNg!!!}

PWN

from pwn import *
import re
from time import sleep

# 连接远程服务
io = remote('chive.vaa.la', 33311)
def interactive_after_clean(timeout: int = 0.05, no_show: bool = True):
    received = io.clean(timeout)
    if not no_show:
        print(f"[$]received:\n{received}")
    io.interactive()


# 定义接收选择题的函数
def recv_until_choice():
    while True:
        try:
            line = io.recvline(timeout=5).decode().strip()
            print(f"[接收到内容]: {line}")
            if any(opt in line for opt in ['1.', '2.', '3.', '4.']):
                break
        except EOFError:
            print("[!] 远程服务断开连接！")
            io.interactive()
            break
        except Exception as e:
            print(f"[⚠️ 错误] 接收超时或其他错误: {e}")
            break

# 选择题部分
recv_until_choice()
io.sendline(b'1')  # 接受邀请
sleep(0.1)

recv_until_choice()
io.sendline(b'4')  # F5
sleep(0.1)

recv_until_choice()
io.sendline(b'1')  # Shift + F12
sleep(0.1)

recv_until_choice()
io.sendline(b'1')  # 双击函数名
sleep(0.1)

# 等待"接下来我会给你 50 道算数题"
while True:
    try:
        line = io.recvline(timeout=5).decode().strip()
        print(f"[接收到内容]: {line}")
        if "接下来我会给你 50 道算数题" in line:
            break
    except EOFError:
        print("[!] 远程服务断开连接！")
        io.interactive()
        break
    except Exception as e:
        print(f"[⚠️ 错误] 接收超时或其他错误: {e}")
        break

# 开始答题
for i in range(50):
    try:
        # 接收并处理每道算数题
        line = io.recvuntil('=').decode().strip()
        print(f"[题目{i+1}] {line}")

        # 使用正则匹配加法、减法、乘法、除法
        match = re.search(r'(\d+)\s*([+\-*/])\s*(\d+)', line)
        if match:
            a, op, b = match.groups()
            a, b = int(a), int(b)

            # 根据操作符进行运算
            if op == '+':
                answer = a + b
            elif op == '-':
                answer = a - b
            elif op == '*':
                answer = a * b
            elif op == '/':
                answer = a / b  # 这里只做了浮点运算，若需要整除可以调整

            print(f"[计算] {a} {op} {b} = {answer}")
            io.sendline(str(int(answer)).encode())  # 发送答案（若是浮点数，这里可能需要调整）
        else:
            print(f"[⚠️ 错误] 无法解析算式: {line}")

        sleep(0.1)

    except Exception as e:
        print(f"[⚠️ 错误] 解析失败: {line} 错误原因: {e}")
        io.interactive()
        break

interactive_after_clean()

好像是第一次做出来pwn题，反正用脚本写上，拿到shell cat flag就出来了

web

1 下个象棋

源代码往下翻

1	<!-- ZmxhZ3sxMTExMjIyMjMzMzM0NDQ0NTU1NTY2NjZ9 -->

直接出了

2 ezphp

ctfshow上的题

要么我hackbar有问题，自己打出不来

3 ezpop

用的php://filter，依旧ctfshow，序列化对象传进去就行了

re

1 BABYXOR

f5反汇编

一个签到题

target = [
    177, 186, 187, 164, 183, 169, 189, 186,
    191, 225, 181, 184, 179, 180, 164, 175
]

flag = ''.join(chr(b ^ 0xD2) for b in target)
print(flag)
#chive{ohm3gjafv}

2 hire

翻出来的

mobile

babykotlin

jeb打开的时候，打开成n个月前的shctf的题了，死活交不上去。。。
jeb拖进去，看见一堆函数，总之先找main函数点进去，嗯没找到什么有用的，开始挨个翻
在最底端找到stringencryptor

1
2
3

utf-8
每个字符xor 0x7f
hex输出

$ComposableSingletons$ MainActivityKt$lambda-2 $1$ 这几个函数就是轮番嵌套

1	5.1->4.1->3.1->MainActivityKt.Greeting ...

然后就是寻找greeting函数，这里善用ctrl+f搜索

在7.1底部翻到了，点进去

借助ds大人写一个脚本()

import java.nio.charset.StandardCharsets

fun main() {
    // 要解密的密文（来自 MainActivityKt 的硬编码值）
    val encryptedText = "19131e180437362b2037362b204f17204e20134f094c20064f0a02"
    
    // 调用解密函数
    val decryptedText = decryptXorHex(encryptedText)
    
    // 打印结果
    println("密文: $encryptedText")
    println("解密结果: $decryptedText")
}

/**
 * 解密 XOR + Hex 加密的字符串
 * @param encrypted 密文（十六进制字符串，如 "19131e..."）
 * @return 解密后的明文
 */
fun decryptXorHex(encrypted: String): String {
    // 1. 检查空输入
    if (encrypted.isEmpty()) return ""
    
    // 2. 将十六进制字符串按每两位分割
    val hexPairs = encrypted.chunked(2)
    
    // 3. 转换为字节数组（每个字节先转Int处理符号问题）
    val bytes = ByteArray(hexPairs.size)
    for (i in hexPairs.indices) {
        bytes[i] = hexPairs[i].toInt(16).toByte()
    }
    
    // 4. 对每个字节执行 XOR 0x7F 解密
    val decryptedBytes = ByteArray(bytes.size)
    for (i in bytes.indices) {
        decryptedBytes[i] = (bytes[i].toInt() xor 0x7F).toByte()
    }
    
    // 5. 按 UTF-8 编码转为字符串
    return String(decryptedBytes, StandardCharsets.UTF_8)
}
#密文: 19131e180437362b2037362b204f17204e20134f094c20064f0a0
#2 解密结果: flag{HIT_HIT_0h_1_l0v3_y0u}

forensics

1 zip|password

这个就很很常规的imageinfo 然后看list没有什么进程，直接过滤flag，找到了一个flag.zip，提取，发现加密，这里我是先把大部分指令都试了，又发现一个hint.txt但提取不出来，后来在cmdline

还去做了mumuzi密码的哈希值测试()，结果发现这里的带括号那一串就是密码，然后就得到flag啦

窃听风云

第一个用户密码 lsdump
但这里一开始我好像输错了，导致无法提交，耽搁了一段时间

第二个主机+ip

这个好找，出现的最多

多套几次娃，一步步跟进就ok
第三个
pslist找到

去瞅瞅cmdline

就是这个了

hardware

有点难，不是我想搜题解的()
https://www.cnblogs.com/hed10ne/p/15359854.html
复现了一下

binwalk提取，这里是squashfs的misc解，在tmp里的解压缩文件放进ida32

简单脱个壳

寻找main函数，找到这个可疑函数点进去，前面还有一个echo.byethost51.com
md5(echo.byethost51.com:36667) = 33a422c45d551ac6e4756f59812a954b然后就凑出来了()