0x2026 wp

深具传统的 ECC 之诞生

发现n是光滑的,由很多⼩因⼦组成,最⼤素因⼦也只有29bit,可以直接discrete_log做Pohlig-Hellman

from Crypto.Util.number import long_to_bytes
p = 380025560263444925282186340357451425457046895363401263284043
a = 3
G_data = (
89416635389252243162818482998273067753365476637225933437342,
246277781258250668709138589808946483685012465285148814183503
)
Q_data = (
329460413071651533403262472631632126805896556373758724864455,
299273891016902567464505544081763716760408274149519169100436
)
Gx, Gy = G_data
Qx, Qy = Q_data
b1 = (Gy^2 - Gx^3 - a * Gx) % p
b2 = (Qy^2 - Qx^3 - a * Qx) % p
assert b1 == b2
E = EllipticCurve(GF(p), [a, b1])
G = E(Gx, Gy)
Q = E(Qx, Qy)
order = G.order()
m = discrete_log(
Q,
G,
ord=order,
operation="+"
)
print(long_to_bytes(int(m)))

为美好的密码献上解密

见另一篇吧,国赛的套壳题

四⽉是你的谎⾔

第一次遇见

以前只见过选择前缀md5碰撞

也是严肃学习了一下:

哈希长度扩展攻击(Hash Length Extension Attack) 是一种针对特定哈希算法结构的设计缺陷攻击。当系统错误地使用类似 MAC = Hash(secret || message) 的方式来生成消息认证码时,攻击者可以在完全不知道 secret 的具体内容的情况下,仅凭已知的 message、MAC 和 secret 的长度,伪造出新的有效签名:

MACnew=Hash⁡(secret∥message∥padding∥extension)MAC_{new} = \operatorname{Hash}(secret \parallel message \parallel padding \parallel extension)

Merkle–Damgård 结构

MD5、SHA-1、SHA-256 等经典哈希算法均基于 Merkle–Damgård 结构:

  1. 填充(Padding): 哈希函数在处理输入前,必须将输入长度填充为特定分块大小的整数倍(以 SHA-256 为例,每块 512 bit / 64 bytes)。填充格式通常为:

    原始数据∥0x80∥0x00…0x00∥原始数据长度的 64 位整数表示\text{原始数据} \parallel \mathtt{0x80} \parallel \mathtt{0x00}\dots\mathtt{0x00} \parallel \text{原始数据长度的 64 位整数表示}

  2. 分组与压缩:

    • 算法维护一组固定的内部状态寄存器

    • 将数据切分为 M1,M2,…,MkM_1, M_2, \dots, M_k

    • 每一轮调用压缩函数 ff 更新内部状态:

      S0=IVS_0 = IV

      Si=f(Si−1,Mi)S_i = f(S_{i-1}, M_i)

  3. 输出结果: 处理完最后一个分组 MkM_k 后的内部状态 SkS_k,直接转换(按字节序排列)为最终输出的哈希值。

攻击原理与推导

假设服务端使用以下认证逻辑:

  • 服务端计算并向客户端下发:token = SHA256(secret || "user=guest")
  • 客户端提交数据与 token,服务端重新拼接 secret 校验哈希。

攻击者的已知信息

  • 原始明文 m="user=guest"m = \text{"user=guest"}
  • 原始哈希值 H=SHA256(secret∥m)H = SHA256(secret \parallel m)
  • secret 的长度(若未知,爆破长度通常只有几十种可能,成本极低)

构造攻击的两个步骤

1. 恢复内部状态(State Reconstruction)

由于 HH 本质上就是处理完 secret∥m∥pad1secret \parallel m \parallel pad_1 后的寄存器状态 SlastS_{last}:

  • 攻击者将 HH 拆解为 8 个 32-bit 的寄存器值(h0,h1,…,h7h_0, h_1, \dots, h_7),直接将其作为 SHA-256 的自定义初始向量 IV′IV'。

2. 追加拓展数据(Appending Extension)

攻击者想要伪造追加的数据为 mext="&role=admin"m_{ext} = \text{"\&role=admin"}:

  • 根据 len(secret) 和的 len(m),在本地复刻出第 1 次哈希时生成的填充块 pad1pad_1。

  • 以 SlastS_{last} 为初始状态,继续对 mextm_{ext}(以及 mextm_{ext} 对应的填充 pad2pad_2)执行压缩函数:

    H′=f(Slast,mext∥pad2)H' = f(S_{last}, m_{ext} \parallel pad_2)

  • 此时,H′H' 等于:

    SHA256(secret∥m∥pad1∥mext)SHA256(secret \parallel m \parallel pad_1 \parallel m_{ext})

    于是便实现了伪造签名

放一下ai写的exp:

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
0xGame CTF — MD5 长度扩展攻击 EXP
目标: nc1.ctfplus.cn 28799
flag: 0xGame{you lie in April}

原理:
已知 H1 = md5(key + M1)
服务端校验 compare_digest(输入, md5(key + M1 + response))
其 response 常量里含有一段按真实 keylen 手工补的 MD5 padding(glue),
于是构造 md5(key + M1 + glue + M2) 即可通过 —— 全程不需要 key。

用法:
python3 exp.py
"""
import math
import re
import socket
import struct

HOST, PORT = "nc1.ctfplus.cn", 27409
H1 = "46af62962126aa38e4f1680a6c64bc6b"
M1 = b"YOU DID LIVE IN MY HEART"
APPENDS = [
b" TOO", # ← 本题命中
b"TOO",
b"YOU DID LIVE IN MY HEART TOO",
b"YOU DID LIVE IN MY HEART",
b"",
]
FAIL_MARK = "not matter"
KEYLEN_RANGE = range(0, 65)
FLAG_RE = re.compile(r"0xGame\{[^}]*\}|flag\{[^}]*\}")

# ---------------- MD5 内部实现 ----------------
MASK = 0xFFFFFFFF
S = ([7, 12, 17, 22] * 4) + ([5, 9, 14, 20] * 4) + \
([4, 11, 16, 23] * 4) + ([6, 10, 15, 21] * 4)
K = [int(abs(math.sin(i + 1)) * 4294967296) & MASK for i in range(64)]


def _rotl(x, n):
return ((x << n) | (x >> (32 - n))) & MASK


def _compress(state, block):
"""单个 64 字节块的 MD5 压缩"""
a, b, c, d = state
M = struct.unpack("<16I", block)
A, B, C, D = a, b, c, d
for i in range(64):
if i < 16:
f = (B & C) | (~B & D)
g = i
elif i < 32:
f = (D & B) | (~D & C)
g = (5 * i + 1) % 16
elif i < 48:
f = B ^ C ^ D
g = (3 * i + 5) % 16
else:
f = C ^ (B | (~D & MASK))
g = (7 * i) % 16
f = (f + A + K[i] + M[g]) & MASK
A, D, C = D, C, B
B = (B + _rotl(f, S[i])) & MASK
return tuple((x + y) & MASK for x, y in zip((a, b, c, d), (A, B, C, D)))


def _padding(n):
"""MD5 填充: 0x80 + 0x00* + 8字节小端比特长度"""
return b"\x80" + b"\x00" * ((56 - (n + 1) % 64) % 64) + \
struct.pack("<Q", (n * 8) & 0xFFFFFFFFFFFFFFFF)


def _state_to_hex(st):
"""内部状态 -> 摘要, 必须小端打包"""
return struct.pack("<4I", *st).hex()


def forge(known_hex, m1, m2, key_len):
"""
由 md5(key+m1) 推出 md5(key+m1+glue+m2)
key_len 只用于确定 glue 的长度(即消息对齐到第几块), 不需要是真值。
"""
n = key_len + len(m1) # 填充前长度
glue = _padding(n) # 人工 glue
state = struct.unpack("<4I", bytes.fromhex(known_hex)) # 摘要 -> 中途 IV
tail = m2 + _padding(n + len(glue) + len(m2)) # 续算的尾块
assert len(tail) % 64 == 0
st = state
for off in range(0, len(tail), 64):
st = _compress(st, tail[off:off + 64])
return _state_to_hex(st)


# ---------------- 交互 ----------------
def _once(sig):
with socket.create_connection((HOST, PORT), timeout=15) as s:
s.settimeout(15)
buf = b""
while b"new longing:" not in buf:
d = s.recv(4096)
if not d:
break
buf += d
s.sendall(sig.encode() + b"\n")
out = b""
while True:
try:
d = s.recv(4096)
except (socket.timeout, TimeoutError):
break
if not d:
break
out += d
return buf + out


def submit(sig, retries=3):
"""连接 -> 等提示符 -> 提交签名 -> 读完整响应(带重试)"""
last = b""
for _ in range(retries):
try:
last = _once(sig)
except Exception:
continue
if b"new longing:" in last: # 确认拿到了正常 banner
return last.decode("latin-1")
return last.decode("latin-1")


def main():
seen = set() # 同一 64 字节块区间内的 keylen 会产生相同签名, 去重省连接
tried = 0
for m2 in APPENDS:
for keylen in KEYLEN_RANGE:
sig = forge(H1, M1, m2, keylen)
if sig in seen:
continue
seen.add(sig)
tried += 1
resp = submit(sig)
if FAIL_MARK in resp:
print("[-] M2=%-30r keylen=%-3d sig=%s" % (m2, keylen, sig))
continue
print("[+] M2=%-30r keylen=%-3d sig=%s" % (m2, keylen, sig))
print("[+] 响应:\n%s" % resp.strip())
m = FLAG_RE.search(resp)
if m:
print("\n[SUCCESS] FLAG = %s" % m.group())
return
print("[!] 未命中, 已尝试 %d 个不同签名" % tried)


if __name__ == "__main__":
main()

RSA永恒花园

感觉有点莫名奇妙的一个题

n最后缺了一位,爆破补上后去fac网站查一下n分解就能解题了

最后还要手动删一些不可打印符号

Decodeforlove

脑洞题,emoji加密,ai梭了