第二次參加HKcert，體驗感拉滿，只能說今年的題，比去年難太多了Orz😵💫
附上今年的戰績
Misc
Get Flag Yourself (50 points)
大约 12 分钟
Misc
谍影重重5.0
题目内容：
我国某部门已经连续三年对间谍张纪星进行秘密监控，最近其网络流量突然出现大量的神秘数据，为防止其向境外传送我国机密数据，我们已将其流量保存，请你协助我们分析其传输的秘密信息。 附件
大约 5 分钟
根据题目，猜想应该是跟图像相关对抗网络
查看 train.py,根据经验直到应该是梯度攻击
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.transforms as transforms
import numpy as np
from PIL import Image
import torch.nn.functional as F
class tanji_model(nn.Module):
def __init__(self):
super(tanji_model, self).__init__()
self.classifier = nn.Sequential(
nn.Linear(31 * 31, 512),
nn.ReLU(),
nn.Linear(512, 128),
nn.ReLU(),
nn.Linear(128, 1),
)
def forward(self, x):
x = torch.flatten(x, 1)
y = self.classifier(x)
return torch.sigmoid(y)
# 加载与训练模型文件model.pth
tanji = tanji_model().cpu()
tanji.load_state_dict(torch.load('model.pth'))
tanji.eval()
print(tanji)
# 创建一个跟flag一样的空白图片
flag_size = (31, 31)
img = torch.zeros((1, 1, * flag_size), requires_grad = True)
# 设置优化器
optimizer = optim.Adam([img], lr=0.001)
for i in range(10000):
# 把梯度置零
optimizer.zero_grad()
output = tanji(img)
# 计算损失 _ 最小化负对数似然损失
loss = -torch.log(F.sigmoid(output))
# 反向传播
loss.backward()
# 更新参数
optimizer.step()
with torch.no_grad():
img.clamp_(0, 1)
if i % 100 == 0:
print(f'Iteration {i}, Loss: {loss.item()}')
# 保存图片
optimized_image = transforms.ToPILImage()(img.squeeze(0))
# optimized_image = transforms.ToPILImage()(img[0].cpu()).save('flag.png')
optimized_image.show()
optimized_image.save('flag.png')
大约 2 分钟
Introduction
使用清华大学 OpenAttack 库中的 PWWS（概率加权词显著性攻击方法对类似 BERT 的语言模型执行对抗性攻击。
BERT （Bidirectional Encoder Representations from Transformers）： BERT 是由 Google 开发的一种强大的语言模型，它显着提高了各种 NLP 任务的最新技术水平。它使用 Transformer 架构，并在大型文本语料库上进行了预训练，以双向理解句子中单词的上下文。
大约 3 分钟
How to encrypt
exp:
import torch
import torch.nn as nn
import numpy as np
# 解决报错：OMP: Error #15: Initializing libiomp5md.dll, but found libiomp5md.dll already initialized.
import os
os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
# 读取文件并解析密文数据
ch = []
with open('ciphertext.txt', 'r') as file:
for line in file:
try:
line_numbers = line.strip().split()
ch.append([float(num) for num in line_numbers])
except ValueError:
print(f"Ignored non-numeric line: {line}")
print(len(ch))
n = len(ch)-1
# 定义加密网络
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.linear = nn.Linear(n, n*n)
self.conv = nn.Conv2d(1, 1, (2, 2), stride=1, padding=1)
def forward(self, x):
x = self.linear(x)
x = x.view(1, 1, n, n)
x = self.conv(x)
return x
# 加载训练好的模型参数
mynet=Net()
mynet.load_state_dict(torch.load('model.pth'))
conv_weight = mynet.conv.weight.data.tolist()[0][0]
print(conv_weight)
conv_bias = mynet.conv.bias.data.tolist()
print(conv_bias)
linear_weight = mynet.linear.weight.data.tolist()
print(linear_weight[0])
linear_bias = mynet.linear.bias.data.tolist()
print(len(linear_bias))
# 解密
'''
初始化 flag 数组，用于存储解密后的数据
遍历 ch 中的每个元素，通过逆向操作计算出原始数据。具体操作包括减去卷积层的偏置和加权值，然后除以卷积核的权重。
逆卷积操作
对于卷积层，卷积核的大小为 2x2，并且在正向操作中，卷积公式为：
output[i][j]=conv_weight[0][0]×input[i][j]+conv_weight[0][1]×input[i][j+1]+conv_weight[1][0]×input[i+1][j]+conv_weight[1][1]×input[i+1][j+1]+conv_bias
将 flag 转换为适当的形状，并减去全连接层的偏置。
使用全连接层权重的伪逆矩阵对 flag 进行矩阵运算，得到解密后的数据。
将解密后的数据转换为字符并打印出来，形成解密后的文本。
'''
flag = [[0]*n for _ in range(n)]
for i in range(n):
for j in range(n):
x = 0
y = 0
z = 0
if i>0:
y = flag[i-1][j]
if j>0:
x = flag[i-1][j-1]
if j>0:
z = flag[i][j-1]
# 减去卷积层的偏置 conv_bias[0] 和邻近元素的加权和，再除以卷积核 conv_weight[1][1]。
flag[i][j]=ch[i][j]-conv_bias[0]-(conv_weight[0][0]*x+conv_weight[0][1]*y+conv_weight[1][0]*z)
flag[i][j]/=conv_weight[1][1]
# 转换和偏置调整
'''
将 flag 转换为一维数组。
减去全连接层的偏置 linear_bias。
将 flag 重新调整为 (n*n, 1) 的形状。
'''
flag = np.array(flag).reshape(n*n)
flag = flag-linear_bias
flag = flag.reshape(n*n,1)
print(flag.shape)
print(np.array(linear_weight).shape)
print(np.linalg.pinv(linear_weight).shape)
# 使用全连接层权重 linear_weight 的伪逆矩阵对 flag 进行矩阵运算，得到解密后的数据。
flag = np.linalg.pinv(linear_weight).dot(flag)
for i in flag:
print(chr(round(i[0])),end='')
大约 2 分钟
Alice's Challenge —— 梯度泄露
什么是梯度泄露攻击
为了执行攻击，我们首先随机生成一对伪输入和标签，然后执行通常的前向和反向传播。在从伪数据推导出伪梯度后，不像典型训练中那样优化模型权重，而是优化伪输入和标签，以最小化伪梯度和真实梯度之间的距离，通过匹配梯度使虚拟数据接近原始的数据。当整个优化过程完成后，私有的数据（包括样本和标签）就会被恢复。
创建虚假的图片，虚假的标签，送入模型获取虚假的梯度。以虚假的梯度与用户的梯度计算L2损失，更新虚假的图片与虚假的标签。最终虚假的图片和虚假的标签将收敛于十分接近用户原始数据。
大约 7 分钟
Alice's warm up —— pytorch / 搜索
题目描述
“Welcome to the XCTF-*CTF2022, I’m Alice and interested in AI security. I prepared a easy warm-up for you before you enjoy those pure AI security challenges.
Like humans, AI also needs to warm up before running. Can you find something strange in these initialized parameters?”
大约 3 分钟
DeepDarkFantasy
先放到python里想查看.pth文件网络结构，但打不开 根据提示： Simple XOR | 1. print 2. Bottleneck 3. input tensor == output tensor
文件应该是经过xor加密，
exp1：解密获得decrypted.pth文件
import binascii
data = b''
with open('encrypted.pth', 'rb') as f:
data = f.read()
#每位异0xde后保存
for i in range(256):
print(binascii.hexlify(data[:2]).decode('utf-8'))
if data[0]^i==0x50 and data[1]^i==0x4B:
print('key:', hex(i))
data = bytes([j ^ i for j in data])
# 判断文件头十六进制是否为50 4B
with open('decrypted.pth', 'wb') as f:
f.write(data)
break
大约 3 分钟
CNIS_2024 MISC WP
第一天_Tough_DNS
通过脚本 exp1:
from scapy.all import rdpcap,DNSQR,DNS
def extract_txt_records(pcap_file):
packets = rdpcap(pcap_file)
dns_queries = []
for packet in packets:
if packet.haslayer(DNS):
dns_layer = packet[DNS]
if isinstance(dns_layer.qd, DNSQR):
dns_queries.append(dns_layer.qd.qname.decode('utf-8'))
return dns_queries
pcap_file = 'Tough_DNS.pcapng'
queries = extract_txt_records(pcap_file)
print(queries)
大约 2 分钟