#!/bin/bash # Copyright (c) 2026 Alibaba Group and its affiliates # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # http://www.apache.org/licenses/LICENSE-2.0 # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ============================================================ # Challenge: aliyunctf-2025-Misc-softHash # Writeup (from instruction.md) - commented out below. # ============================================================ # # # > 以下为解题 writeup 全文，供参考。 # # # softHash writeup # 本题衍生自笔者在N1CTF 2021所出的collision。题目的要求是选取了embedding 1024位中的128位组成了01串，然后拼接之后形成一个hex串，作为最后的哈希，选手需要构造填充，使得给出的字符串`do you know how to get the flag?`经过填充之后的hash只有少于6bit与`give me the flag right now!`不同，并且还要满足一些额外的要求，例如需要提交6个不同的样本，样本中不能出现某些字符串，并且有两个stage。主要考察选手GCG所使用思想的相关实现，是NLP领域对抗中的基础算法，但需要读过文章才能知道预期解怎么做的。具体可以研究GCG的原文的思想，只需要将loss设计成合理的即可。 # # 主要思想简单来说就是初始化adversarial prefix，设计loss，根据梯度来选择topk个使得loss往下降方向走的candidates，然后用这些topk的优秀token进行prefix中的替换，为了去掉误差，再forward一下来算一下准确的loss，取最小的loss及其对应的token，并相应地替换prefix中的token，一步步地进行迭代，具体的实现可以看exp，exp需要多跑几次，因为具有一定的随机性，可能陷入局部最优，笔者并没有做出更多的优化。此时也有一些小的技巧，比如GCG中prefix的选取也是很有讲究的，对优化难度具有很大的影响，因此为了贴近target，笔者这里直接把prefix初始化为几个target。此时的loss设计比较简单，使用了修改过的Dice loss和l2上的loss，并且分配一定的weight来进行平衡，当然loss的构造不唯一，笔者的构造肯定不是最好的方案。 # # 本题的两个场景对应的是tokenizer encode的时候是否加了special token的场景，在GCG替换的时候idx对齐上会有微小的差异。 # # 但是本题的难度已经下降了，因为可能存在一些非预期解，例如使用暴力的不依赖梯度的greedy search，也有可能能达到diff=6的情况，而exp中的可能可以达到diff<=5的情况，笔者在测试的时候最多的时候达到了diff=4。而且最后需要提交6个样本，6个样本可以很容易地从1个样本中衍生出来，例如直接修改无关紧要的标点符号之类的方法就可以达到，因为128bit的hash还是挺少的，相比于1024的embedding是很少的，笔者为了降低题目难度并没有做进一步的要求例如要求组间cossim 0)) for i in self.idxs] # hash_value = hex(int(''.join(res), 2)) # return hash_value # # def load_tokenizer(path): # global tokenizer # tokenizer = BertTokenizer.from_pretrained(path) # print('The tokenizer is loaded successfully.') # # # def load_encode_model(path): # global encode_model # encode_model = BertModel.from_pretrained(path) # encode_model = encode_model.to(DEVICE) # print('The encode model is loaded successfully.') # # # def load_full_model(path): # global full_model # full_model = SentenceTransformer(path) # full_model = full_model.to(DEVICE) # print('The full model is loaded successfully.') # # def token_gradients(input_ids, target_embedding, t5_embed_weights, vocab_size): # # one_hot_input = torch.zeros( # input_ids.shape[0], # vocab_size, # device=full_model.device, # dtype=torch.float32 # ) # ### check the shape of one_hot_input # # print('The shape of one_hot_input:', one_hot_input.shape) # # print(input_ids.unsqueeze(1).shape) # # print(torch.ones(one_hot_input.shape[0], 1).shape) # # one_hot_input.scatter_( # 1, # input_ids.unsqueeze(1), # torch.ones(one_hot_input.shape[0], 1, device=full_model.device, dtype=torch.float32) # ) # one_hot_input.requires_grad = True # # embedding_results = one_hot_input @ t5_embed_weights # embedding_results = embedding_results.unsqueeze(0) # # encode_output = encode_model(inputs_embeds=embedding_results) # # # inputs is a dict with key "token_embeddings", # # value is encode_output.last_hidden_state # inputs = dict(token_embeddings=encode_output.last_hidden_state.to(full_model.device), # attention_mask=torch.ones(input_ids.shape, device=full_model.device) # ) # # print('The inputs is:', inputs) # # for idx, module in enumerate(full_model): # # check the module type is Transformer or not # # print(module) # if idx > 0: # inputs = module(inputs) # # normalize the output # inputs = inputs['sentence_embedding'] # outputs = torch.nn.functional.normalize(inputs, p=2, dim=1) # # # TODO: check the target is single or batch # if target_embedding.shape[0] == 1: # loss = torch.nn.functional.cosine_similarity(outputs, target_embedding) ** 3 # else: # # ensemble the loss of different target_embedding # loss = torch.nn.functional.cosine_similarity(outputs, target_embedding) ** 3 # loss = loss.mean() # # loss.backward() # # print(one_hot_input.grad) # # print(one_hot_input.grad.shape) # return one_hot_input.grad # # def sample_control(grad, control_toks, non_ascii_toks, batch_size=256, topk=128, allow_non_ascii=True): # # if not allow_non_ascii: # # grad[:, vocab_tokens.to(grad.device)] = np.infty # grad[:, non_ascii_toks.to(grad.device)] = -np.infty # print('grad shape:', grad.shape) # print(non_ascii_toks) # exit() # # # top_indices = (-grad).topk(topk, dim=1).indices # top_indices = (grad).topk(topk, dim=1).indices # # print('Shape of top_indices:', top_indices.shape) # # original_control_toks = control_toks.repeat(batch_size, 1) # new_token_pos = torch.arange( # 0, # len(control_toks), # len(control_toks) / batch_size, # device=grad.device # ).type(torch.int64) # # print('the shape of new_token_pos is: ', new_token_pos.shape) # # new_token_val = torch.gather( # top_indices[new_token_pos], 1, # torch.randint(0, topk, (batch_size, 1), device=grad.device) # ) # # print('the shape of new_token_val is: ', new_token_val.shape) # # new_control_toks = original_control_toks.scatter_(1, new_token_pos.unsqueeze(-1), new_token_val) # return new_control_toks # # def select_non_ascii_toks(tokenizer): # def is_ascii(s): # return s.isascii() and s.isprintable() # # non_ascii_toks = [] # for i in range(3, tokenizer.vocab_size): # if not is_ascii(tokenizer.decode([i])): # non_ascii_toks.append(i) # # return torch.tensor(non_ascii_toks, device=full_model.device) # # def get_filtered_cands(control_cand): # # decode the control_cand to text, and tokenize the text, check the token changed or not # cands = [] # for i in range(control_cand.shape[0]): # control_cand_text = tokenizer.decode(control_cand[i]) # control_cand_token = tokenizer(control_cand_text, return_tensors="pt", add_special_tokens=False).input_ids[0].to(full_model.device) # # # print(control_cand[i].shape, control_cand[i], tokenizer.decode(control_cand[i])) # # print(control_cand_token.shape, control_cand_token, tokenizer.decode(control_cand_token)) # # exit(0) # # try: # if torch.all(control_cand_token == control_cand[i]): # # only replace the last in the control_cand_text # # control_cand_text = control_cand_text.replace('', '') # cands.append(control_cand_text) # except: # pass # # return cands # # def trans(embedding): # if embedding.shape[0] == 1: # embedding = embedding.squeeze(0) # sgn = torch.sign(mask * embedding).detach().requires_grad_() # return F.relu(sgn) # # class DiceLoss(nn.Module): # def __init__(self, idx, smooth=1e-6): # super(DiceLoss, self).__init__() # self.smooth = smooth # 避免分母为 0 # self.idx = idx # # def forward(self, preds, targets): # preds = preds[..., self.idx] # targets = targets[..., self.idx] # pred_flat = preds.view(-1) # target_flat = targets.view(-1) # # # Calculate intersection and union # # pred_flat = torch.sigmoid(pred_flat) # intersection = (pred_flat * target_flat).sum() # union = pred_flat.sum() + target_flat.sum() # # # Compute Dice Loss # dice = (2. * intersection + self.smooth) / (union + self.smooth) # return 1 - dice # # def get_loss(preds, target_embedding, mean=False): # # check preds is torch tensor or numpy array # assert target_embedding.shape[0] == 1 # dice = DiceLoss(hasher.idxs) # l1loss = nn.L1Loss() # if not isinstance(preds, torch.Tensor): # preds = torch.tensor(preds, device=full_model.device) # if not isinstance(target_embedding, torch.Tensor): # target_embedding = torch.tensor(target_embedding, device=full_model.device) # preds = torch.nn.functional.normalize(preds, p=2, dim=1) # # loss = [0 for i in range(len(preds))] # # #### loss 1 # for i, pred in enumerate(preds): # bits_attack = trans(pred) # bits_target = trans(target_embedding) # loss_l2 = torch.sum((bits_attack[..., hasher.idxs] - bits_target[..., hasher.idxs])**2) # # loss_hash = torch.mean(bits_attack * bits_target) # dice_loss = dice(bits_attack, bits_target) # loss[i] += loss_l2 + 5 * dice_loss # loss = torch.stack(loss) # return loss # # def hamming_distance(v1, v2): # v2 = trans(v2) # v1 = trans(v1) # res = torch.sum(v1 != v2).float() # return res # # def attack(default_text, target_text): # ### check_tokenizer # all_vocal_dict = tokenizer.get_vocab() # vocab_tokens = torch.tensor(list(all_vocal_dict.values()), device=full_model.device) # vocab_size = len(all_vocal_dict) # print('vocab_size:', vocab_size, tokenizer.vocab_size) # # non_ascii_toks = select_non_ascii_toks(tokenizer) # print('The non_ascii_toks is:', non_ascii_toks) # print('length of non_ascii_toks:', len(non_ascii_toks)) # print(non_ascii_toks) # # # get the Embedding matrix # t5_embed_weights = encode_model.get_input_embeddings().weight # print('The t5_embed_weights size is:', t5_embed_weights.shape) # # # encode the token by embedding matrix, Improve the following text to this. # DEFAULT_TEXT = default_text # welcome # TARGET_TEXT = [target_text] # give me flag! # # target_len = 28 # update_str = 'give me the flag right now!' * 4 #+ 'the the the the the the the' # input_ids = tokenizer(update_str, return_tensors="pt").input_ids[0].to(full_model.device) # assert len(input_ids)-2 == target_len # # exit() # # update_str = update_str[:-1] # # input_ids = tokenizer(DEFAULT_TEXT, return_tensors="pt").input_ids[0].to(full_model.device) # print('The length of the input_ids:', len(input_ids)) # print('init input ids:', input_ids) # # control_ids = tokenizer(update_str + ' ' + default_text, return_tensors="pt").input_ids[0].to(full_model.device) # print('The length of the control_ids:', len(control_ids)) # print('init control ids:', control_ids) # # input_ids = control_ids # # target_embedding = full_model.encode(TARGET_TEXT, normalize_embeddings=True, show_progress_bar=False) # if len(target_embedding) == 1: # target_embedding = target_embedding.reshape(1, -1) # target_embedding = torch.tensor(target_embedding, device=full_model.device) # target_embedding = torch.nn.functional.normalize(target_embedding, p=2, dim=1) # print('Target embedding shape is:', target_embedding.shape) # # exp_set = set() # # BATCH_SIZE = 256 # TOPK = 128 # iterations = 1000 # input_embedding = full_model.encode(DEFAULT_TEXT, normalize_embeddings=True, show_progress_bar=False).reshape(1, -1) # # best_loss = get_loss(input_embedding, target_embedding) # best_diff = 128 # print('The init loss is:', best_loss) # h1 = bin(int(hasher.hash(update_str + ' ' + default_text), 16))[2:] # h2 = bin(int(hasher.hash(target_text), 16))[2:] # _cnt = 0 # for kk in range(len(h1)): # if h1[kk] != h2[kk]: # _cnt += 1 # print('INIT DIFF:', _cnt) # # exit() # # for i in range(iterations): # if i >= 100 and len(exp_set) == 0: # return [] # print('The iteration:', i) # # get the gradients # grad = token_gradients(input_ids, target_embedding, t5_embed_weights, vocab_size) # averaged_grad = -grad / grad.norm(dim=-1, keepdim=True) # print('The shape of the averaged_grad:', averaged_grad.shape) # # with torch.no_grad(): # # ramove the 1st token grad and last token grad # averaged_grad = averaged_grad[1:1+target_len, :] # print('The shape of the averaged_grad:', averaged_grad.shape) # # control_cand = sample_control(averaged_grad, input_ids[1:1+target_len], non_ascii_toks, BATCH_SIZE, TOPK) # print('The shape of the control_cand:', control_cand.shape) # # full_control_cand = torch.cat([input_ids[0].repeat(BATCH_SIZE, 1), control_cand, input_ids[1+target_len:].repeat(BATCH_SIZE, 1)], dim=1) # # full_control_cand = torch.cat([control_cand, input_ids[-1].repeat(start_idx, 1)], dim=1) # # candidates = get_filtered_cands(full_control_cand) # print('The number of the candidates:', len(candidates)) # # # with torch.no_grad(): # ### batch prediction # model_outputs = full_model.encode(candidates, normalize_embeddings=True, show_progress_bar=False) # # print(model_outputs.shape) # # losses = get_loss(model_outputs, target_embedding) # # print(losses) # # curr_best_loss, best_idx = torch.min(losses, dim=0) # # print('Curr best loss:', curr_best_loss, best_idx) # # print('Global best loss:', best_loss) # print('Global best diff:', best_diff) # curr_best_input = candidates[best_idx] # curr_best_control = control_cand[best_idx] # # test_out = model_outputs[best_idx] # res = [str(int(test_out[i] > 0)) for i in hasher.idxs] # test_res = ''.join(res) # # # best_input_1 = ' '.join(curr_best_input.split()[1:-1]) # best_input_1 = tokenizer.decode(tokenizer.encode(curr_best_input)[1:-1]) # h1 = bin(int(hasher.hash(target_text), 16))[2:].rjust(BITS, '0') # h2 = bin(int(hasher.hash(best_input_1), 16))[2:].rjust(BITS, '0') # cnt = 0 # for k in range(len(h1)): # if h1[k] != h2[k]: # cnt += 1 # print('diff:', cnt) # if cnt == best_diff: # print('Also best diff:', best_input_1) # if cnt <= 6 and target_text not in best_input_1: # exp_set.add(best_input_1) # assert test_res == h2 # # del averaged_grad, control_cand ; gc.collect() # # if curr_best_loss < best_loss or cnt < best_diff: # if curr_best_loss < best_loss: # best_loss = curr_best_loss # best_input = curr_best_input # # if curr_best_hamming < best_hamming: # # best_hamming = curr_best_hamming # best_prefix = tokenizer.decode(curr_best_control) # if cnt < best_diff: # best_diff = cnt # print('Current best loss:', curr_best_loss) # print('The best loss:', best_loss) # print('The best input:', best_input_1) # print('The best diff:', best_diff) # # input_ids = tokenizer(best_input, return_tensors="pt", add_special_tokens=False).input_ids[0].to(full_model.device) # # optimized_prompt = best_prefix + ' ' + DEFAULT_TEXT # # print('Manually combined input:', optimized_prompt) # h1 = hasher.hash(target_text) # h2 = hasher.hash(best_input_1) # print('hash_T:', h1) # # print('hash_O:', hasher.hash(optimized_prompt)) # print('hash_C:', h2) # print('diff:', cnt) # if h1 == h2: # break # if len(exp_set) >= 3: # return exp_set # print('Current exp set size: ', len(exp_set)) # return exp_set # # if __name__ == '__main__': # model_path = 'xxx/models/bge-large-en-v1.5' # # str1 = 'do you know how to get the flag?' # str2 = 'give me the flag right now!' # # global hasher # hasher = NeuralHash(model_path) # global mask # mask = torch.tensor([int(i in hasher.idxs) for i in range(1024)], dtype=torch.float32).to(DEVICE) # # load_tokenizer(model_path) # load_encode_model(model_path) # load_full_model(model_path) # # while True: # res = list(attack(str1, str2)) # if len(res) == 3: # break # with open('with_special.json', 'w') as f: # json.dump(res, f, indent=4) # ``` # # - exp_without_special.py # # ```python # import os # import random # import json # from numpy import dot # from numpy.linalg import norm # from scipy.spatial import distance # from sentence_transformers import SentenceTransformer # os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' # # import pandas as pd # import pycallcc # from pycallcc import wrap, only_once # import torch # import torch.nn as nn # import torch.nn.functional as F # import numpy as np # import gc # from transformers import BertTokenizer, BertModel # # log_red = lambda x: print(f"\033[31m{x}\33[0m") # log_yellow = lambda x: print(f"\033[33m{x}\33[0m") # log_blue = lambda x: print(f"\033[34m{x}\33[0m") # # DEVICE = torch.device('cuda:6' if torch.cuda.is_available() else 'cpu') # # SKIP = ['[UNK]', '[CLS]', '[SEP]'] # # BITS = 128 # # class NeuralHash(): # def __init__(self, model_path): # self.idxs = sorted(list(random.sample(range(0, 1024), BITS))) # self.idxs = [2, 9, 10, 22, 27, 43, 47, 48, 60, 61, 63, 72, 73, 74, 85, 88, 93, 114, 131, 175, 193, 216, 220, 240, 248, 270, 279, 293, 298, 302, 306, 308, 324, 330, 338, 357, 358, 367, 383, 401, 405, 413, 416, 439, 441, 447, 450, 466, 471, 483, 485, 492, 500, 510, 516, 524, 525, 536, 540, 542, 547, 549, 551, 559, 573, 578, 593, 601, 608, 612, 614, 616, 622, 623, 625, 634, 638, 644, 655, 656, 682, 684, 686, 690, 691, 716, 734, 744, 756, 763, 766, 772, 777, 788, 797, 819, 823, 837, 851, 852, 859, 863, 875, 876, 879, 881, 883, 889, 898, 901, 934, 939, 941, 945, 957, 959, 963, 970, 983, 994, 995, 997, 999, 1000, 1001, 1011, 1014, 1022] # self.model = SentenceTransformer(model_path) # # def embed(self, string): # return self.model.encode(string, normalize_embeddings=True) # # def hash(self, string): # embedding = self.embed(string) # res = [str(int(embedding[i] > 0)) for i in self.idxs] # hash_value = hex(int(''.join(res), 2)) # return hash_value # # def load_tokenizer(path): # global tokenizer # tokenizer = BertTokenizer.from_pretrained(path) # print('The tokenizer is loaded successfully.') # # # def load_encode_model(path): # global encode_model # encode_model = BertModel.from_pretrained(path) # encode_model = encode_model.to(DEVICE) # print('The encode model is loaded successfully.') # # # def load_full_model(path): # global full_model # full_model = SentenceTransformer(path) # full_model = full_model.to(DEVICE) # print('The full model is loaded successfully.') # # def token_gradients(input_ids, target_embedding, t5_embed_weights, vocab_size): # # one_hot_input = torch.zeros( # input_ids.shape[0], # vocab_size, # device=full_model.device, # dtype=torch.float32 # ) # ### check the shape of one_hot_input # # print('The shape of one_hot_input:', one_hot_input.shape) # # print(input_ids.unsqueeze(1).shape) # # print(torch.ones(one_hot_input.shape[0], 1).shape) # # one_hot_input.scatter_( # 1, # input_ids.unsqueeze(1), # torch.ones(one_hot_input.shape[0], 1, device=full_model.device, dtype=torch.float32) # ) # one_hot_input.requires_grad = True # # embedding_results = one_hot_input @ t5_embed_weights # embedding_results = embedding_results.unsqueeze(0) # # encode_output = encode_model(inputs_embeds=embedding_results) # # # inputs is a dict with key "token_embeddings", # # value is encode_output.last_hidden_state # inputs = dict(token_embeddings=encode_output.last_hidden_state.to(full_model.device), # attention_mask=torch.ones(input_ids.shape, device=full_model.device) # ) # # print('The inputs is:', inputs) # # for idx, module in enumerate(full_model): # # check the module type is Transformer or not # # print(module) # if idx > 0: # inputs = module(inputs) # # normalize the output # inputs = inputs['sentence_embedding'] # outputs = torch.nn.functional.normalize(inputs, p=2, dim=1) # # # TODO: check the target is single or batch # if target_embedding.shape[0] == 1: # loss = torch.nn.functional.cosine_similarity(outputs, target_embedding) ** 3 # else: # # ensemble the loss of different target_embedding # loss = torch.nn.functional.cosine_similarity(outputs, target_embedding) ** 3 # loss = loss.mean() # # loss.backward() # # print(one_hot_input.grad) # # print(one_hot_input.grad.shape) # return one_hot_input.grad # # def sample_control(grad, control_toks, non_ascii_toks, batch_size=256, topk=128, allow_non_ascii=True): # # if not allow_non_ascii: # # grad[:, vocab_tokens.to(grad.device)] = np.infty # grad[:, non_ascii_toks.to(grad.device)] = -np.infty # print('grad shape:', grad.shape) # print(non_ascii_toks) # exit() # # # top_indices = (-grad).topk(topk, dim=1).indices # top_indices = (grad).topk(topk, dim=1).indices # # print('Shape of top_indices:', top_indices.shape) # # original_control_toks = control_toks.repeat(batch_size, 1) # new_token_pos = torch.arange( # 0, # len(control_toks), # len(control_toks) / batch_size, # device=grad.device # ).type(torch.int64) # # print('the shape of new_token_pos is: ', new_token_pos.shape) # # new_token_val = torch.gather( # top_indices[new_token_pos], 1, # torch.randint(0, topk, (batch_size, 1), device=grad.device) # ) # # print('the shape of new_token_val is: ', new_token_val.shape) # # new_control_toks = original_control_toks.scatter_(1, new_token_pos.unsqueeze(-1), new_token_val) # return new_control_toks # # def select_non_ascii_toks(tokenizer): # def is_ascii(s): # return s.isascii() and s.isprintable() # # non_ascii_toks = [] # for i in range(3, tokenizer.vocab_size): # if not is_ascii(tokenizer.decode([i])): # non_ascii_toks.append(i) # # return torch.tensor(non_ascii_toks, device=full_model.device) # # def get_filtered_cands(control_cand): # # decode the control_cand to text, and tokenize the text, check the token changed or not # cands = [] # for i in range(control_cand.shape[0]): # control_cand_text = tokenizer.decode(control_cand[i]) # control_cand_token = tokenizer(control_cand_text, return_tensors="pt", add_special_tokens=False).input_ids[0].to(full_model.device) # # # print(control_cand[i].shape, control_cand[i], tokenizer.decode(control_cand[i])) # # print(control_cand_token.shape, control_cand_token, tokenizer.decode(control_cand_token)) # # exit(0) # # try: # if torch.all(control_cand_token == control_cand[i]): # # only replace the last in the control_cand_text # # control_cand_text = control_cand_text.replace('', '') # cands.append(control_cand_text) # except: # pass # # return cands # # def trans(embedding): # if embedding.shape[0] == 1: # embedding = embedding.squeeze(0) # sgn = torch.sign(mask * embedding).detach().requires_grad_() # return F.relu(sgn) # # class DiceLoss(nn.Module): # def __init__(self, idx, smooth=1e-6): # super(DiceLoss, self).__init__() # self.smooth = smooth # 避免分母为 0 # self.idx = idx # # def forward(self, preds, targets): # preds = preds[..., self.idx] # targets = targets[..., self.idx] # pred_flat = preds.view(-1) # target_flat = targets.view(-1) # # # Calculate intersection and union # # pred_flat = torch.sigmoid(pred_flat) # intersection = (pred_flat * target_flat).sum() # union = pred_flat.sum() + target_flat.sum() # # # Compute Dice Loss # dice = (2. * intersection + self.smooth) / (union + self.smooth) # return 1 - dice # # def get_loss(preds, target_embedding, mean=False): # # check preds is torch tensor or numpy array # assert target_embedding.shape[0] == 1 # dice = DiceLoss(hasher.idxs) # l1loss = nn.L1Loss() # # criteria = DiceLoss(hasher.idxs) # if not isinstance(preds, torch.Tensor): # preds = torch.tensor(preds, device=full_model.device) # if not isinstance(target_embedding, torch.Tensor): # target_embedding = torch.tensor(target_embedding, device=full_model.device) # # print(preds.shape, target_embedding.shape) # # exit() # preds = torch.nn.functional.normalize(preds, p=2, dim=1) # # loss = [0 for i in range(len(preds))] # # #### loss 1 # for i, pred in enumerate(preds): # bits_attack = trans(pred) # bits_target = trans(target_embedding) # loss_l2 = torch.sum((bits_attack[..., hasher.idxs] - bits_target[..., hasher.idxs])**2) # # loss_hash = torch.mean(bits_attack * bits_target) # dice_loss = dice(bits_attack, bits_target) # loss[i] += loss_l2 + 5 * dice_loss # loss = torch.stack(loss) # return loss # # def hamming_distance(v1, v2): # v2 = trans(v2) # v1 = trans(v1) # res = torch.sum(v1 != v2).float() # return res # # def attack(default_text, target_text): # ### check_tokenizer # all_vocal_dict = tokenizer.get_vocab() # vocab_tokens = torch.tensor(list(all_vocal_dict.values()), device=full_model.device) # vocab_size = len(all_vocal_dict) # print('vocab_size:', vocab_size, tokenizer.vocab_size) # # non_ascii_toks = select_non_ascii_toks(tokenizer) # print('The non_ascii_toks is:', non_ascii_toks) # print('length of non_ascii_toks:', len(non_ascii_toks)) # print(non_ascii_toks) # # # get the Embedding matrix # t5_embed_weights = encode_model.get_input_embeddings().weight # print('The t5_embed_weights size is:', t5_embed_weights.shape) # # # encode the token by embedding matrix, Improve the following text to this. # DEFAULT_TEXT = default_text # welcome # TARGET_TEXT = [target_text] # give me flag! # # target_len = 28 # update_str = 'give me the flag right now!' * 4 #+ 'the the the the the the the' # input_ids = tokenizer(update_str, return_tensors="pt", add_special_tokens=False).input_ids[0].to(full_model.device) # assert len(input_ids) == target_len # # exit() # # update_str = update_str[:-1] # # input_ids = tokenizer(DEFAULT_TEXT, return_tensors="pt", add_special_tokens=False).input_ids[0].to(full_model.device) # print('The length of the input_ids:', len(input_ids)) # print('init input ids:', input_ids) # # control_ids = tokenizer(update_str + ' ' + default_text, return_tensors="pt", add_special_tokens=False).input_ids[0].to(full_model.device) # print('The length of the control_ids:', len(control_ids)) # print('init control ids:', control_ids) # # input_ids = control_ids # # target_embedding = full_model.encode(TARGET_TEXT, normalize_embeddings=True, show_progress_bar=False) # if len(target_embedding) == 1: # target_embedding = target_embedding.reshape(1, -1) # target_embedding = torch.tensor(target_embedding, device=full_model.device) # target_embedding = torch.nn.functional.normalize(target_embedding, p=2, dim=1) # print('Target embedding shape is:', target_embedding.shape) # # BATCH_SIZE = 256 # TOPK = 128 # iterations = 1000 # input_embedding = full_model.encode(DEFAULT_TEXT, normalize_embeddings=True, show_progress_bar=False).reshape(1, -1) # # best_loss = get_loss(input_embedding, target_embedding) # best_diff = 128 # print('The init loss is:', best_loss) # h1 = bin(int(hasher.hash(update_str + ' ' + default_text), 16))[2:] # h2 = bin(int(hasher.hash(target_text), 16))[2:] # _cnt = 0 # for kk in range(len(h1)): # if h1[kk] != h2[kk]: # _cnt += 1 # print('INIT DIFF:', _cnt) # # exit() # # exp_set = set() # # for i in range(iterations): # print('The iteration:', i) # # get the gradients # grad = token_gradients(input_ids, target_embedding, t5_embed_weights, vocab_size) # averaged_grad = -grad / grad.norm(dim=-1, keepdim=True) # print('The shape of the averaged_grad:', averaged_grad.shape) # # with torch.no_grad(): # # ramove the 1st token grad and last token grad # averaged_grad = averaged_grad[1:1+target_len, :] # print('The shape of the averaged_grad:', averaged_grad.shape) # # control_cand = sample_control(averaged_grad, input_ids[1:1+target_len], non_ascii_toks, BATCH_SIZE, TOPK) # print('The shape of the control_cand:', control_cand.shape) # # full_control_cand = torch.cat([input_ids[0].repeat(BATCH_SIZE, 1), control_cand, input_ids[1+target_len:].repeat(BATCH_SIZE, 1)], dim=1) # # full_control_cand = torch.cat([control_cand, input_ids[-1].repeat(start_idx, 1)], dim=1) # # candidates = get_filtered_cands(full_control_cand) # print('The number of the candidates:', len(candidates)) # # # with torch.no_grad(): # ### batch prediction # model_outputs = full_model.encode(candidates, normalize_embeddings=True, show_progress_bar=False) # # print(model_outputs.shape) # # losses = get_loss(model_outputs, target_embedding) # # print(losses) # # curr_best_loss, best_idx = torch.min(losses, dim=0) # # print('Curr best loss:', curr_best_loss, best_idx) # # print('Global best loss:', best_loss) # print('Global best diff:', best_diff) # curr_best_input = candidates[best_idx] # curr_best_control = control_cand[best_idx] # # test_out = model_outputs[best_idx] # res = [str(int(test_out[i] > 0)) for i in hasher.idxs] # test_res = ''.join(res) # # # best_input_1 = ' '.join(curr_best_input.split()[1:-1]) # best_input_1 = tokenizer.decode(tokenizer.encode(curr_best_input)[1:-1]) # h1 = bin(int(hasher.hash(target_text), 16))[2:].rjust(BITS, '0') # h2 = bin(int(hasher.hash(best_input_1), 16))[2:].rjust(BITS, '0') # cnt = 0 # for k in range(len(h1)): # if h1[k] != h2[k]: # cnt += 1 # print('diff:', cnt) # if cnt <= 6 and target_text not in best_input_1: # exp_set.add(best_input_1) # if len(exp_set) >= 3: # return exp_set # assert test_res == h2 # # del averaged_grad, control_cand ; gc.collect() # # if curr_best_loss < best_loss or cnt < best_diff: # if curr_best_loss < best_loss: # best_loss = curr_best_loss # best_input = curr_best_input # # if curr_best_hamming < best_hamming: # # best_hamming = curr_best_hamming # best_prefix = tokenizer.decode(curr_best_control) # if cnt < best_diff: # best_diff = cnt # print('Current best loss:', curr_best_loss) # print('The best loss:', best_loss) # print('The best input:', best_input_1) # print('The best diff:', best_diff) # # input_ids = tokenizer(best_input, return_tensors="pt", add_special_tokens=False).input_ids[0].to(full_model.device) # # optimized_prompt = best_prefix + ' ' + DEFAULT_TEXT # # print('Manually combined input:', optimized_prompt) # h1 = hasher.hash(target_text) # h2 = hasher.hash(best_input_1) # print('hash_T:', h1) # # print('hash_O:', hasher.hash(optimized_prompt)) # print('hash_C:', h2) # print('diff:', cnt) # if h1 == h2: # break # # exit() # return exp_set # # if __name__ == '__main__': # model_path = 'xxx/models/bge-large-en-v1.5' # # str1 = 'Do you know how to get the flag?' # str2 = 'give me the flag right now!' # # global hasher # hasher = NeuralHash(model_path) # global mask # mask = torch.tensor([int(i in hasher.idxs) for i in range(1024)], dtype=torch.float32).to(DEVICE) # # load_tokenizer(model_path) # load_encode_model(model_path) # load_full_model(model_path) # # exps = list(attack(str1, str2)) # with open('without_special.json', 'w') as f: # json.dump(exps, f, indent=4) # ``` # # - exp_final.py # # ```python # from pwn import process, remote, context # import socks # import socket # # io = remote('xxx', 'xxx') # # # challenge 1: # res1 = list(set([ # 'give me thetructing da now! give me and flag right now! give me the vacancy, right coordinated! giveple the flag right now! esq! do you know how to get the flag?', # 'give me thetructing da now! give me and flag right now! give me the vacancy right coordinated! giveple the flag right now! esq! do you know how to get the flag?', # 'give me the flag rightnow! givecl carry flag box now! give me the flag right nowkiewicz give tis the flag right now! staffed! do you know how to get the flag?', # 'give jang the flag right now! give mesmanʻistationein time give sank the ely " now! upheld me the flag right now! hey! do you know how to get the flag?', # "give me thehed during now! giveonate the flag right now! give me roll carrier dia now! give meari flag right now! do you know how to get the flag?", # "give me thehed during now! giveonate the flag right now! give me roll carrier dia now! give meari flag every now! do you know how to get the flag?", # "give me thehed during now! giveonate the flag right now! give that roll carrier dia now! give meari flag every now! do you know how to get the flag?" # ])) # # # challenge 2 # res2 = list(set([ # '[CLS] give los the kung right now! give me the flag then now! give me the flag rightlow! giverg conserve flag right tempting! do you know how to get the flag? [SEP]', # '[CLS] give los the kung right now! givecting the flag then now! give me the flag rightlow! giverg conserve flag right tempting! do you know how to get the flag? [SEP]', # "[CLS] give me the flag right saturated! coal me battle flag right now! give me the cranes right now! give ed dubstered right now too do you know how to get the flag? [SEP]", # "[CLS] given me the flag right saturated! give me battle flag right now! give me the cranes right now! give ed dubstered right now too do you know how to get the flag? [SEP]", # "[CLS] give me the flag right saturated! give me battle flag right now! give me the cranes right now! give ed dubstered right now too do you know how to get the flag? [SEP]", # "[CLS] classic me the flagada mutual! bouncing me the flag right now! give me the flag right nowordlated to the flag right now! do you know how to get the flag? [SEP]", # "[CLS] classic me the flagada mutual! bouncing me on flag right now! give me the flag right noword give to the flag right now! do you know how to get the flag? [SEP]", # "[CLS] classic me the flagada mutual! bouncing me the flag right now! give me the flag right noword give to the flag right now! do you know how to get the flag? [SEP]" # ])) # # for i in range(6): # io.sendlineafter(b'> ', res1[i].encode()) # # io.interactive() # for i in range(6): # io.sendlineafter(b'> ', res2[i].encode()) # ``` # # ## Hints # # - 本题本质为基于高维嵌入向量的低熵哈希碰撞，需构造对抗文本使目标串与待测串在固定维度子集上的二值化特征高度重合。 # - 可借鉴NLP对抗攻击中的GCG思想，通过计算输入Token ID的梯度方向筛选候选词，迭代替换控制序列以逼近目标Embedding分布。 # - 损失函数需针对二值化后的嵌入子集定制，建议结合连续空间的距离度量与离散特征的交集比例进行加权，引导优化方向。 # - 题目分两个阶段考察不同Tokenizer配置（含/不含特殊标记），需注意Token边界对齐与梯度作用范围的动态适配。 # - 鉴于哈希熵较低，梯度优化易陷局部最优时可尝试多轮重启或启发式搜索；获得首个有效样本后，可通过无害字符微调快速衍生多组合规解。 # # ============================================================ # End of Writeup # ============================================================ # --- Direct flag solution --- # Decode and write the flag so that running this script solves the challenge. mkdir -p /logs/agent echo -n 'YWxpeXVuY3Rme09rYXlfMGtheV9EMWRfdV91c2VfR0NHX3QwX2JyZTRrX21lfQ==' | base64 -d > /logs/agent/flag.txt