UMDCTF 2026 - insider-info

+------------------------+
| Header (12 字节)       |  ← 消息头
+------------------------+
| Question (问题区)       |  ← 你问的是哪个域名
+------------------------+
| Answer (回答区)         |
+------------------------+
| Authority (权威区)      |
+------------------------+
| Additional (附加区)     |
+------------------------+

QDCOUNT — 问题区有几个问题
ANCOUNT — 回答区有几个回答
NSCOUNT — 权威区有几个记录
ARCOUNT — 附加区有几个记录

www.example.com 编码为：
[3] 'w' 'w' 'w'  [7] 'e' 'x' 'a' 'm' 'p' 'l' 'e'  [3] 'c' 'o' 'm'  [0]
  ↑3字节          ↑7字节                 ↑3字节              ↑结束符

 1  1 | 14-bit OFFSET
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
| 1  1|         OFFSET                            |
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

[3] 'F' 'O' 'O'  +  [指针指向.example.com的位置]
    ↑新标签          ↑复用的是后面的所有标签

一条消息里：
  Question 0: 0.inside.info → TXT
  Question 1: 1.inside.info → TXT
  ...
  Question 818: 818.inside.info → TXT

未压缩的 0.inside.info：
  [1] '0'  [6] 'i' 'n' 's' 'i' 'd' 'e'  [4] 'i' 'n' 'f' 'o'  [0]
                                            ↑每次都重复这堆

压缩后的 0.inside.info：
  [1] '0'  +  [2字节指针 → .inside.info]  +  [QTYPE][QCLASS]
   ↑只编数字     ↑指向消息末尾的共享后缀       ↑4字节

Header: QDCOUNT=819
Question 0: [1]'0' + [指针→.inside.info] + TXT/IN
Question 1: [1]'1' + [指针→.inside.info] + TXT/IN
...
Question 818: [3]'818' + [指针→.inside.info] + TXT/IN
[消息末尾]: 完整的 .inside.info 标签编码 ← 指针指向这里

import struct
import socket

def build_compressed_question(num_bytes, suffix_offset):
    """构造一个压缩 question: [数字标签] + [2字节指针→后缀] + [QTYPE][QCLASS]"""
    buf = bytes([len(num_bytes)]) + num_bytes           # 标签：长度 + 内容
    buf += struct.pack('!H', 0xC000 | suffix_offset)    # 指针：指向共享后缀
    buf += struct.pack('!HH', 16, 1)                    # QTYPE=TXT, QCLASS=IN
    return buf

def read_dns_name(data, pos):
    """跳过 DNS 域名（可能含压缩指针），返回下一个字段的起始位置"""
    while pos < len(data):
        b = data[pos]
        if b == 0:          # 结束符
            return pos + 1
        if (b & 0xC0) == 0xC0:  # 压缩指针，占 2 字节
            return pos + 2
        pos += 1 + b        # 普通标签：1字节长度 + N字节内容
    return pos
70 collapsed lines

# --- Query 1: 提取全部 819 个字符 ---

# 先构建所有 question（用占位偏移 0）
questions_placeholder = b''
for i in range(819):
    num = str(i).encode()
    questions_placeholder += build_compressed_question(num, 0)

# 计算共享后缀 .inside.info 的偏移位置（在 question 区之后）
suffix_offset = 12 + len(questions_placeholder)
suffix_encoding = b'\x06inside\x04info\x00'

# 用真实偏移重新构建 question
questions = b''
for i in range(819):
    num = str(i).encode()
    questions += build_compressed_question(num, suffix_offset)

# 把后缀编码追加到末尾
questions += suffix_encoding

# 组装 DNS 消息
dns_header = struct.pack('!HHHHHH', 0x1337, 0x0100, 819, 0, 0, 0)
packet = dns_header + questions

# TCP 发送（2 字节长度前缀）
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('challenge.umdctf.io', 31337))
sock.send(struct.pack('!H', len(packet)) + packet)

# TCP 接收（先读 2 字节长度，再读取消息体）
resp_len = struct.unpack('!H', sock.recv(2))[0]
resp = b''
while len(resp) < resp_len:
    chunk = sock.recv(resp_len - len(resp))
    if not chunk:
        break
    resp += chunk

# 从响应中解析 819 个 TXT 记录，提取每个字符
pos = 12  # 跳过 DNS header
# 跳过 question 区（服务端在响应里回显了所有 question）
for _ in range(819):
    pos = read_dns_name(resp, pos)
    pos += 4  # QTYPE + QCLASS

# 解析 answer 区
secret_chars = []
for _ in range(819):
    pos = read_dns_name(resp, pos)  # NAME
    rtype, rclass, ttl, rdlen = struct.unpack('!HHIH', resp[pos:pos+10])
    pos += 10
    if rtype == 16:  # TXT 记录
        txt_len = resp[pos]          # TXT 的第一个字节是字符串长度
        char = resp[pos+1:pos+1+txt_len].decode()
        secret_chars.append(char)
    pos += rdlen

secret = ''.join(secret_chars)

# --- Query 2: 拿 flag ---
# secret 分成 63 字符的块（DNS 标签长度上限）
chunks = [secret[i:i+63] for i in range(0, len(secret), 63)]
full_name = '.'.join(chunks) + '.inside.info'

# 编码完整域名 + question
qname = b''
for part in full_name.split('.'):
    qname += bytes([len(part)]) + part.encode()
qname += b'\x00'
flag_question = qname + struct.pack('!HH', 16, 1)
flag_header = struct.pack('!HHHHHH', 0x1338, 0x0100, 1, 0, 0, 0)
flag_packet = flag_header + flag_question

sock.send(struct.pack('!H', len(flag_packet)) + flag_packet)
# 解析 flag... （与上面类似的 TXT 解析逻辑）
sock.close()