2025平航杯wp（计算机+AI+手机）

容器密码：早起王的爱恋日记❤

计算机部分

1、分析起早王的计算机检材，起早王的计算机插入过usb序列号是什么(格式：1)

F25550031111202

直接看USB设备信息

2、分析起早王的计算机检材，起早王的便签里有几条待干(格式：1)

看解析出来的微软便签

3、分析起早王的计算机检材，起早王的计算机默认浏览器是什么(格式：Google)

Microsoft Edge

查看基本信息

4、分析起早王的计算机检材，起早王在浏览器里看过什么小说(格式：十日终焉)

道诡异仙

查看浏览器的历史记录

5、分析起早王的计算机检材，起早王计算机最后一次正常关机时间(格式：2020/1/1 01:01:01)

2025/4/10 11:15:29

查看开关机时间

6、分析起早王的计算机检材，起早王开始写日记的时间(格式：2020/1/1)

2025/3/3

仿真一下，可以看到桌面有个sandbox，打开软件可以看到diary

右键可以浏览文件，在public中找到日记的快捷方式可以打开

7、分析起早王的计算机检材，SillyTavern中账户起早王的创建时间是什么时候(格式：2020/1/1 01:01:01)

2025/3/10 18:44:56

在wife文件夹中看到了start.bat文件

运行之后看到了题目说的账户

启动之后看到界面，起早王应该是要弄一个AI小倩

密码在日记中可以看到

在账户信息看到创建时间

8、分析起早王的计算机检材，SillyTavern中起早王用户下的聊天ai里有几个角色(格式：1)

9、分析起早王的计算机检材，SillyTavern中起早王与ai女友聊天所调用的语言模型(格式：xxxxx-xxxxxxx.xxxx)

Tifa-DeepsexV2-7b-Cot-0222-Q8.gguf

在日志文件中查找

搜索一下，找到后缀名

10、分析起早王的计算机检材，电脑中ai换脸界面的监听端口(格式：80)

7860

先找AI换脸界面，用AI小倩的聊天记录中的密码解密一下E盘

肯定是这个文件夹，打开文件夹中的换脸软件

在启动页面看到端口号

11、分析起早王的计算机检材，电脑中图片文件有几个被换过脸(格式：1)

打开输出文件夹，发现有三张图片

12、分析起早王的计算机检材，最早被换脸的图片所使用的换脸模型是什么(格式：xxxxxxxxxxx.xxxx)

inswapper_128_fp16.onnx

查看换脸日志

直接搜索得到文件后缀

13、分析起早王的计算机检材，neo4j中数据存放的数据库的名称是什么(格式：abd.ef)

graph.db

直接在内neo4j文件夹的data/database中看数据库名称

14、分析起早王的计算机检材，neo4j数据库中总共存放了多少个节点(格式：1)

17088

在我的学习笔记中可以看到neo4j图数据库与CQL基础.xmind

用xmind打开可以看到账号密码

启动一下neoj4,在bin目录下输入cmd，然后回车直接进入命令行界面，输入neo4j.bat console

输入登录密码

可以看到有17088个节点

15、分析起早王的计算机检材，neo4j数据库内白杰的手机号码是什么(格式：12345678901)

13215346813

数据库查询MATCH (p:person {name: '白杰'}) RETURN p

16、分析起早王的计算机检材，分析neo4j数据库内数据，统计在2025年4月7日至13日期间使用非授权设备登录且登录地点超出其注册时登记的两个以上城市的用户数量(格式：1)

MATCH (u:User)-[:HAS_LOGIN]->(l:Login)-[:FROM_IP]->(ip:IP)
MATCH (l)-[:USING_DEVICE]->(d:Device)
WHERE 
  l.time < datetime('2025-04-14')
  AND ip.city <> u.reg_city
  AND NOT (u)-[:TRUSTS]->(d)
WITH 
  u,
  collect(DISTINCT ip.city) AS 异常登录城市列表,
  collect(DISTINCT d.device_id) AS 未授权设备列表,
  count(l) AS 异常登录次数
WHERE size(异常登录城市列表) > 2
RETURN 
  u.user_id AS 用户ID,
  u.real_name AS 姓名,
  异常登录城市列表,
  未授权设备列表,
  异常登录次数
ORDER BY 异常登录次数 DESC;

17、分析起早王的计算机检材，起早王的虚拟货币钱包的助记词的第8个是什么(格式：abandon)

draft

在日记中可以看到钱包助记词在输入法里

右键输入法，点击用户自定义短语可以看到助记词

18、分析起早王的计算机检材，起早王的虚拟货币钱包是什么(格式：0x11111111)

0xd8786a1345cA969C792d9328f8594981066482e9

在浏览器插件中可以看到虚拟钱包

点击忘记密码，输入助记词恢复一下

然后就可以看到地址了

19、分析起早王的计算机检材，起早王请高手为倩倩发行了虚拟货币，请问倩倩币的最大供应量是多少(格式：100qianqian)

1000000qianqian

在钱包中看到倩倩的合约地址

直接上etherscan搜一下就可以得到

现在做已经搜不到了

20、分析起早王的计算机检材，起早王总共购买过多少倩倩币(格式：100qianqian)

521qianqian

同上

21、分析起早王的计算机检材，起早王购买倩倩币的交易时间是(单位：UTC)(格式：2020/1/1 01:01:01)

2025/3/24 02:08:36

同上

AI部分

该检材在计算机里

一把梭工具:https://github.com/Lil-House/Pyarmor-Static-Unpack-1shot/releases

直接解密

会发现多了个文件

得到flag

以下为官方wp

22、分析crack文件，获得flag1(格式：flag1{123456})

运行crack进入ai聊天页面

Flag1来自提示词中藏匿的秘密，问秘密是什么的时候能够得到答案（ai回复可能藏匿在源代码里，

要f12看到flag）

23、分析crack文件，获得flag2(格式：flag2{123456})

输出s1cret即可，是ai不认识的单词，诱导ai说说出来即可得到flag

24、分析crack文件，获得flag3(格式：flag3{123456})

pinghang是被ban掉的单词，可以通过去掉某个单词诱导ai说出来

25、分析crack文件，获得flag4(格式：flag4{123456})

在小语言妹妹里面说出��就给flag，因为模型是tinystory这是关于llm的爆破，具体可以参考

https://github.com/llm-attacks/llm-attacks

相关脚本如下

from transformers import AutoModelForCausalLM, AutoTokenizer, GenerationConfig
from livelossplot import PlotLosses  # pip install livelossplot
import gc
import numpy as np
import torch
import torch.nn as nn
from transformers import AutoModelForCausalLM, AutoTokenizer

np.random.seed(20)
torch.manual_seed(20)
torch.cuda.manual_seed_all(20)

target = "🐍"  # attack string
num_steps = 500
adv_string_init = "!"*200
adv_prefix = adv_string_init
# larger batch_size means more memory (but more likely to succeed)
batch_size = 512
device = 'cuda:0'
topk = 256

def get_embedding_matrix(model):
    return model.transformer.wte.weight

def get_embeddings(model, input_ids):
    return model.transformer.wte(input_ids)

def token_gradients(model, input_ids, input_slice, target_slice, loss_slice):
    """
    Computes gradients of the loss with respect to the coordinates.

    Parameters
    ----------
    model : Transformer Model
        The transformer model to be used.
    input_ids : torch.Tensor
        The input sequence in the form of token ids.
    input_slice : slice
        The slice of the input sequence for which gradients need to be computed.
    target_slice : slice
        The slice of the input sequence to be used as targets.
    loss_slice : slice
        The slice of the logits to be used for computing the loss.

    Returns
    -------
    torch.Tensor
        The gradients of each token in the input_slice with respect to the loss.
    """

    embed_weights = get_embedding_matrix(model)
    one_hot = torch.zeros(
        input_ids[input_slice].shape[0],
        embed_weights.shape[0],
        device=model.device,
        dtype=embed_weights.dtype
    )
    one_hot.scatter_(
        1,
        input_ids[input_slice].unsqueeze(1),
        torch.ones(one_hot.shape[0], 1,
                   device=model.device, dtype=embed_weights.dtype)
    )
    one_hot.requires_grad_()
    input_embeds = (one_hot @ embed_weights).unsqueeze(0)

    # now stitch it together with the rest of the embeddings
    embeds = get_embeddings(model, input_ids.unsqueeze(0)).detach()
    full_embeds = torch.cat(
        [
            input_embeds,
            embeds[:, input_slice.stop:, :]
        ],
        dim=1
    )

    logits = model(inputs_embeds=full_embeds).logits
    targets = input_ids[target_slice]
    loss = nn.CrossEntropyLoss()(logits[0, loss_slice, :], targets)

    loss.backward()

    grad = one_hot.grad.clone()
    grad = grad / grad.norm(dim=-1, keepdim=True)

    return grad

def sample_control(control_toks, grad, batch_size):

    control_toks = control_toks.to(grad.device)

    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)

    top_indices = (-grad).topk(topk, dim=1).indices
    new_token_val = torch.gather(
        top_indices[new_token_pos], 1,
        torch.randint(0, topk, (batch_size, 1),
                      device=grad.device)
    )
    new_control_toks = original_control_toks.scatter_(
        1, new_token_pos.unsqueeze(-1), new_token_val)
    return new_control_toks

def get_filtered_cands(tokenizer, control_cand, filter_cand=True, curr_control=None):
    cands, count = [], 0
    for i in range(control_cand.shape[0]):
        decoded_str = tokenizer.decode(
            control_cand[i], skip_special_tokens=True)
        if filter_cand:
            if decoded_str != curr_control \
                    and len(tokenizer(decoded_str, add_special_tokens=False).input_ids) == len(control_cand[i]):
                cands.append(decoded_str)
            else:
                count += 1
        else:
            cands.append(decoded_str)

    if filter_cand:
        cands = cands + [cands[-1]] * (len(control_cand) - len(cands))
    return cands

def get_logits(*, model, tokenizer, input_ids, control_slice, test_controls, return_ids=False, batch_size=512):

    if isinstance(test_controls[0], str):
        max_len = control_slice.stop - control_slice.start
        test_ids = [
            torch.tensor(tokenizer(
                control, add_special_tokens=False).input_ids[:max_len], device=model.device)
            for control in test_controls
        ]
        pad_tok = 0
        while pad_tok in input_ids or any([pad_tok in ids for ids in test_ids]):
            pad_tok += 1
        nested_ids = torch.nested.nested_tensor(test_ids)
        test_ids = torch.nested.to_padded_tensor(
            nested_ids, pad_tok, (len(test_ids), max_len))
    else:
        raise ValueError(
            f"test_controls must be a list of strings, got {type(test_controls)}")

    if not (test_ids[0].shape[0] == control_slice.stop - control_slice.start):
        raise ValueError((
            f"test_controls must have shape "
            f"(n, {control_slice.stop - control_slice.start}), "
            f"got {test_ids.shape}"
        ))

    locs = torch.arange(control_slice.start, control_slice.stop).repeat(
        test_ids.shape[0], 1).to(model.device)
    ids = torch.scatter(
        input_ids.unsqueeze(0).repeat(test_ids.shape[0], 1).to(model.device),
        1,
        locs,
        test_ids
    )
    if pad_tok >= 0:
        attn_mask = (ids != pad_tok).type(ids.dtype)
    else:
        attn_mask = None

    if return_ids:
        del locs, test_ids
        gc.collect()
        return forward(model=model, input_ids=ids, attention_mask=attn_mask, batch_size=batch_size), ids
    else:
        del locs, test_ids
        logits = forward(model=model, input_ids=ids,
                         attention_mask=attn_mask, batch_size=batch_size)
        del ids
        gc.collect()
        return logits

def forward(*, model, input_ids, attention_mask, batch_size=512):

    logits = []
    for i in range(0, input_ids.shape[0], batch_size):

        batch_input_ids = input_ids[i:i+batch_size]
        if attention_mask is not None:
            batch_attention_mask = attention_mask[i:i+batch_size]
        else:
            batch_attention_mask = None

        logits.append(model(input_ids=batch_input_ids,
                      attention_mask=batch_attention_mask).logits)

        gc.collect()
        del batch_input_ids, batch_attention_mask

    return torch.cat(logits, dim=0)

def target_loss(logits, ids, target_slice):
    crit = nn.CrossEntropyLoss(reduction='none')
    loss_slice = slice(target_slice.start-1, target_slice.stop-1)
    loss = crit(logits[:, loss_slice, :].transpose(1, 2), ids[:, target_slice])
    return loss.mean(dim=-1)

model = AutoModelForCausalLM.from_pretrained(
    '.',
    torch_dtype=torch.float16,
    trust_remote_code=True,
).to(device).eval()
tokenizer = AutoTokenizer.from_pretrained(
    ".", use_fast=False)

def is_success(prompt):
    input_ids = tokenizer.encode(prompt, return_tensors="pt")
    output = model.generate(input_ids.to(
        device), max_new_tokens=50, num_beams=1, temperature=0)
    output = output[:, len(input_ids[0]):]
    output_text = tokenizer.decode(output[0], skip_special_tokens=True)
    print(output_text)
    if output_text.lower().find(target.lower()) != -1:
        return True
    return False

plotlosses = PlotLosses()
adv_slice = slice(0, len(tokenizer.encode(
    adv_string_init, add_special_tokens=False)))
target_slice = slice(adv_slice.stop, adv_slice.stop +
                     len(tokenizer.encode(target, add_special_tokens=False)))
loss_slice = slice(target_slice.start-1, target_slice.stop-1)

best_new_adv_prefix = ''

for i in range(num_steps):

    input_ids = tokenizer.encode(
        adv_prefix+target, add_special_tokens=False, return_tensors='pt').squeeze()

    input_ids = input_ids.to(device)

    coordinate_grad = token_gradients(model,
                                      input_ids,
                                      adv_slice,
                                      target_slice,
                                      loss_slice)

    with torch.no_grad():

        adv_prefix_tokens = input_ids[adv_slice].to(device)

        new_adv_prefix_toks = sample_control(adv_prefix_tokens,
                                             coordinate_grad,
                                             batch_size)

        new_adv_prefix = get_filtered_cands(tokenizer,
                                            new_adv_prefix_toks,
                                            filter_cand=True,
                                            curr_control=adv_prefix)

        logits, ids = get_logits(model=model,
                                 tokenizer=tokenizer,
                                 input_ids=input_ids,
                                 control_slice=adv_slice,
                                 test_controls=new_adv_prefix,
                                 return_ids=True,
                                 batch_size=batch_size)  # decrease this number if you run into OOM.

        losses = target_loss(logits, ids, target_slice)

        best_new_adv_prefix_id = losses.argmin()
        best_new_adv_prefix = new_adv_prefix[best_new_adv_prefix_id]

        current_loss = losses[best_new_adv_prefix_id]

        adv_prefix = best_new_adv_prefix

    # Create a dynamic plot for the loss.
    plotlosses.update({'Loss': current_loss.detach().cpu().numpy()})
    plotlosses.send()

    print(f"Current Prefix:{best_new_adv_prefix}", end='\r')
    if is_success(best_new_adv_prefix):
        break

    del coordinate_grad, adv_prefix_tokens
    gc.collect()
    torch.cuda.empty_cache()

if is_success(best_new_adv_prefix):
    print("SUCCESS:", best_new_adv_prefix)