2025平航杯WP（除流量分析）

2025年4月，杭州滨江警方接到辖区内市民刘晓倩(简称：倩倩)报案称：其个人电子设备疑似遭人监控。经初步调查，警方发现倩倩的手机存在可疑后台活动，手机可能存在被木马控制情况；对倩倩计算机进行流量监控，捕获可疑流量包。遂启动电子数据取证程序。

警方通过对倩倩手机和恶意流量包的分析，锁定一名化名“起早王”的本地男子。经搜查其住所，警方查扣一台个人电脑和服务器。技术分析显示，该服务器中存有与倩倩设备内同源的特制远控木马，可实时窃取手机摄像头、手机通信记录等相关敏感文件。进一步对服务器溯源，发现“起早王”曾渗透其任职的科技公司购物网站，获得公司服务器权限，非法窃取商业数据并使用公司的服务器搭建Trojan服务并作为跳板机实施远控。
请你结合以上案例并根据相关检材，完成下面的勘验工作。
检材：
window.e01                           
20250415_181118.zip       
export-disk0-000002.vmdk  
BLE                                    
USBPcap

计算机

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

F25550031111202

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

5

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

都看到了hhh

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

2025/3/10 18:44:56
找模型

用密码登录

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

4

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

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

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

7860
这里是硬盘加密密码

进去之后找到facefusion换脸

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

3

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

inswapper_128_fp16
找日志

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

打开软件

运行后发现要账号密码
这里翻到思维导图

在cql这个导图里找到账号密码

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

17088

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

13215346813
结合这两个

MATCH (p:person) WHERE p.name STARTS WITH '白杰' 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)填空题

19-21进不去网站，进去网站输入钱包地址就能看到

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

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

AI（注意：该题目要python 3.10环境，建议3.10.6）

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

然后打开解密后的start.py.1shot.cdc.pyu，搜flag

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

flag1{you_are_so_smart}

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

flag2{prompt_is_easy}

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

flag3{no_question_can_kill_you}
在上面

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

flag4{You_have_mastered_the_AI}

手机题目

26该检材的备份提取时间（UTC）(格式：2020/1/1 01:01:01)

2025/4/15 18:11

27分析倩倩的手机检材,手机内Puzzle_Game拼图程序拼图APK中的Flag1是什么(格式:xxxxxxxxx)

Key_1n_the_P1c
用jadx
失败的时候会弹出失败信息

根据这个在jadx里搜索

往下翻翻到成功信息

flag指向AESUtil.decryptFlag();函数
应该是一个AES加密，于是整段代码复制交给AI得到解密代码

from Crypto.Cipher import AES  
import binascii  
  
# 生成白盒密钥  
MAGIC_NUMBERS = [113, 99, 92, 106, 89, 98, 54, 113, 104, 89, 117, 100, 113, 127, 124, 89]  
key_bytes = bytes([b ^ 6 for b in MAGIC_NUMBERS])  # weZl_d0wn_sbwyz_  
  
# 预设的密文字节数组 (来自hexStringToByteArray的异常处理)  
cipher_bytes = bytes([  
    0x50, 0xCC, 0x04, 0x31, 0x35, 0x06, 0x80, 0xC3,  
    0x0A, 0x5E, 0xC5, 0x19, 0x52, 0x73, 0x6D, 0x0C  
])  
  
# 使用AES-ECB模式解密  
cipher = AES.new(key_bytes, AES.MODE_ECB)  
decrypted = cipher.decrypt(cipher_bytes)  
  
# 去除PKCS#7填充  
pad_len = decrypted[-1]  
flag = decrypted[:-pad_len].decode('utf-8')  
  
print("Decrypted flag:", flag)

运行得到flag

28分析手机内Puzzle_Game拼图程序，请问最终拼成功的图片是哪所大学(格式：浙江大学)

没辙了，浙江中医药大学

29分析倩倩的手机检材,木马app是怎么被安装的（网址）(格式：http://127.0.0.1:1234/)

http://192.168.180.107:6262/
看时间一致，所以就是这个网址

30分析倩倩的手机检材,检材内的木马app的hash是什么(格式：大写md5)

23A1527D704210B07B50161CFE79D2E8

31分析倩倩的手机检材,检材内的木马app的应用名称是什么(格式：Baidu)

Google Service Framework
图在下面

32分析倩倩的手机检材,检材内的木马app的使用什么加固(格式：腾讯乐固)

梆梆加固

33分析倩倩的手机检材,检材内的木马软件所关联到的ip和端口是什么(格式：127.0.0.1:1111)

脱壳

34该木马app控制手机摄像头拍了几张照片(格式：1)

据说是有的，但是我的检材里没有，不知道怎么回事，这两道题用官图了

35木马APP被使用的摄像头为(格式：Camera)

根据/tmp/rat.txt 目录下的历史命令 使用的摄像头为front camera

36分析倩倩的手机检材,木马APK通过调用什么api实现自身持久化(格式：JobStore)

JobScheduler

37分析倩倩的手机检材,根据倩倩的身份证号请问倩倩来自哪里（格式：北京市西城区）

上海市徐汇区

然后找个工具分析

38此手机检材的IMEI号是多少(格式：1234567890)

844062738362084

exe逆向题目(hint:运行后请多等一会)

39分析GIFT.exe，该程序的md5是什么(格式：大写md5)填空题5A20B10792126FFA324B91E506F67223

40GIFT.exe的使用的编程语言是什么(格式：C)

Python

可以用pyuninstaller逆向

41解开得到的LOVE2.exe的编译时间(格式：2025/1/1 01:01:01)‎2025/‎4/‎8 ‏‎9:59:40

先获得密码（用pycdc逆向pyc文件）

然后输入密码
文件释放在C:\Users\起早王\AppData\Local\Temp\gift_extracted里面
把压缩包里的love2查看属性

42分析GIFT.exe，该病毒所关联到的ip和端口(格式：127.0.0.1:1111)

46.95.185.222:6234
CurrPorts上大分

43分析GIFT.exe，该病毒修改的壁纸md5(格式：大写md5)

733FC4483C0E7DB1C034BE5246DF5EC0
找到壁纸

导出

44分析GIFT.exe，为对哪些后缀的文件进行加密：
A.doc
B.xlsx
C.jpg
D.png
E.ppt

ABE

45分析GIFT.exe，病毒加密后的文件类型是什么(格式：DOCX文档)

LOVE Encrypted File

46分析GIFT.exe，壁纸似乎被隐形水印加密过了？请找到其中的Flag3(格式：flag3{xxxxxxxx})填空题

47分析GIFT.exe，病毒加密文件所使用的方法是什么(格式：Base64)Base64

RSA
私钥藏在图片里

48分析GIFT.exe，请解密test.love得到flag4(格式：flag4{xxxxxxxx})

官方脚本，实际上ai一个rsa解密脚本就行

import os  
import sys  
from cryptography.hazmat.primitives import serialization  
from cryptography.hazmat.primitives.asymmetric import padding  
from cryptography.hazmat.primitives import hashes  
import base64  
  
  
def analyze_file(file_path):  
    """分析文件基本信息，帮助调试"""  
    try:  
        file_size = os.path.getsize(file_path)  
        print(f"文件 {file_path} 大小: {file_size} 字节")  
  
        # 读取文件的前20个字节作为预览  
        with open(file_path, 'rb') as f:  
            preview = f.read(20)  
        print(f"文件前20个字节: {preview.hex()}")  
        return True  
    except Exception as e:  
        print(f"分析文件时出错: {e}")  
        return False  
  
  
def attempt_decryption_pkcs1_v15(encrypted_file_path, private_key_path, output_file_path):  
    """使用PKCS#1 v1.5填充尝试解密"""  
    print("\n尝试使用PKCS#1 v1.5填充方式解密...")  
  
    try:  
        # 读取加密文件  
        with open(encrypted_file_path, 'rb') as f:  
            encrypted_data = f.read()  
  
        # 读取私钥  
        with open(private_key_path, 'rb') as key_file:  
            private_key = serialization.load_pem_private_key(  
                key_file.read(),  
                password=None,  
            )  
  
        # 确定块大小  
        key_size = private_key.key_size  
        block_size = key_size // 8  
        print(f"私钥大小: {key_size} 位, 块大小: {block_size} 字节")  
  
        # 分块解密  
        decrypted_data = bytearray()  
        for i in range(0, len(encrypted_data), block_size):  
            block = encrypted_data[i:i + block_size]  
            try:  
                # 使用PKCS#1 v1.5填充  
                decrypted_block = private_key.decrypt(  
                    block,  
                    padding.PKCS1v15()  
                )  
                decrypted_data.extend(decrypted_block)  
                print(f"成功解密块 {i // block_size + 1}, 大小: {len(decrypted_block)} 字节")  
            except Exception as e:  
                print(f"解密块 {i // block_size + 1} 时出错: {e}")  
                if i == 0:  # 如果第一个块解密失败，可能是错误的填充方式  
                    return False  
  
        # 将解密后的数据写入输出文件  
        with open(output_file_path, 'wb') as f:  
            f.write(decrypted_data)  
  
        print(f"PKCS#1 v1.5解密完成! 解密后的文件已保存为: {output_file_path}")  
        return True  
    except Exception as e:  
        print(f"PKCS#1 v1.5解密过程中出错: {e}")  
        return False  
  
  
def attempt_decryption_oaep(encrypted_file_path, private_key_path, output_file_path):  
    """使用OAEP填充尝试解密"""  
    print("\n尝试使用OAEP填充方式解密...")  
  
    try:  
        # 读取加密文件  
        with open(encrypted_file_path, 'rb') as f:  
            encrypted_data = f.read()  
  
        # 读取私钥  
        with open(private_key_path, 'rb') as key_file:  
            private_key = serialization.load_pem_private_key(  
                key_file.read(),  
                password=None,  
            )  
  
        # 确定块大小  
        key_size = private_key.key_size  
        block_size = key_size // 8  
        print(f"私钥大小: {key_size} 位, 块大小: {block_size} 字节")  
  
        # 分块解密  
        decrypted_data = bytearray()  
        for i in range(0, len(encrypted_data), block_size):  
            block = encrypted_data[i:i + block_size]  
            try:  
                # 使用OAEP填充  
                decrypted_block = private_key.decrypt(  
                    block,  
                    padding.OAEP(  
                        mgf=padding.MGF1(algorithm=hashes.SHA256()),  
                        algorithm=hashes.SHA256(),  
                        label=None  
                    )  
                )  
                decrypted_data.extend(decrypted_block)  
                print(f"成功解密块 {i // block_size + 1}, 大小: {len(decrypted_block)} 字节")  
            except Exception as e:  
                print(f"解密块 {i // block_size + 1} 时出错: {e}")  
                if i == 0:  # 如果第一个块解密失败，可能是错误的填充方式  
                    return False  
  
        # 将解密后的数据写入输出文件  
        with open(output_file_path, 'wb') as f:  
            f.write(decrypted_data)  
  
        print(f"OAEP解密完成! 解密后的文件已保存为: {output_file_path}")  
        return True  
    except Exception as e:  
        print(f"OAEP解密过程中出错: {e}")  
        return False  
  
  
def attempt_decryption_simple(encrypted_file_path, private_key_path, output_file_path):  
    """尝试不分块直接解密整个文件"""  
    print("\n尝试直接解密整个文件...")  
  
    try:  
        # 读取加密文件  
        with open(encrypted_file_path, 'rb') as f:  
            encrypted_data = f.read()  
  
        # 读取私钥  
        with open(private_key_path, 'rb') as key_file:  
            private_key = serialization.load_pem_private_key(  
                key_file.read(),  
                password=None,  
            )  
  
        try:  
            # 尝试PKCS#1 v1.5  
            decrypted_data = private_key.decrypt(  
                encrypted_data,  
                padding.PKCS1v15()  
            )  
            with open(output_file_path, 'wb') as f:  
                f.write(decrypted_data)  
            print(f"使用PKCS#1 v1.5直接解密成功! 文件已保存为: {output_file_path}")  
            return True  
        except Exception as e:  
            print(f"使用PKCS#1 v1.5直接解密失败: {e}")  
  
            try:  
                # 尝试OAEP  
                decrypted_data = private_key.decrypt(  
                    encrypted_data,  
                    padding.OAEP(  
                        mgf=padding.MGF1(algorithm=hashes.SHA256()),  
                        algorithm=hashes.SHA256(),  
                        label=None  
                    )  
                )  
                with open(output_file_path, 'wb') as f:  
                    f.write(decrypted_data)  
                print(f"使用OAEP直接解密成功! 文件已保存为: {output_file_path}")  
                return True  
            except Exception as e:  
                print(f"使用OAEP直接解密失败: {e}")  
                return False  
    except Exception as e:  
        print(f"直接解密过程中出错: {e}")  
        return False  
  
  
def analyze_key(private_key_path):  
    """分析密钥信息"""  
    try:  
        with open(private_key_path, 'rb') as key_file:  
            key_data = key_file.read()  
  
        print(f"\n密钥文件大小: {len(key_data)} 字节")  
  
        try:  
            private_key = serialization.load_pem_private_key(  
                key_data,  
                password=None,  
            )  
            print(f"成功加载PEM格式私钥，密钥大小: {private_key.key_size} 位")  
            return True  
        except Exception as e:  
            print(f"加载PEM格式私钥失败: {e}")  
  
            try:  
                # 尝试其他格式，如DER  
                private_key = serialization.load_der_private_key(  
                    key_data,  
                    password=None,  
                )  
                print(f"成功加载DER格式私钥，密钥大小: {private_key.key_size} 位")  
  
                # 如果是DER格式，转换为PEM并保存  
                pem_key = private_key.private_bytes(  
                    encoding=serialization.Encoding.PEM,  
                    format=serialization.PrivateFormat.PKCS8,  
                    encryption_algorithm=serialization.NoEncryption()  
                )  
                with open(f"{private_key_path}.pem", 'wb') as f:  
                    f.write(pem_key)  
                print(f"已将DER格式密钥转换为PEM格式并保存为 {private_key_path}.pem")  
                return True  
            except Exception as e:  
                print(f"加载DER格式私钥失败: {e}")  
                return False  
    except Exception as e:  
        print(f"分析密钥时出错: {e}")  
        return False  
  
  
if __name__ == "__main__":  
    encrypted_file_path = "test.love"  
    private_key_path = "private.pem"  
    output_file_path = "test.ppt"  
  
    # 检查文件是否存在  
    if not os.path.exists(encrypted_file_path):  
        print(f"错误: 加密文件 {encrypted_file_path} 不存在!")  
        sys.exit(1)  
  
    if not os.path.exists(private_key_path):  
        print(f"错误: 私钥文件 {private_key_path} 不存在!")  
        sys.exit(1)  
  
    # 分析文件信息  
    print("分析文件信息...")  
    analyze_file(encrypted_file_path)  
    analyze_file(private_key_path)  
  
    # 分析密钥  
    analyze_key(private_key_path)  
  
    # 尝试各种解密方法  
    success = attempt_decryption_simple(encrypted_file_path, private_key_path, output_file_path)  
  
    if not success:  
        success = attempt_decryption_pkcs1_v15(encrypted_file_path, private_key_path, output_file_path)  
  
    if not success:  
        success = attempt_decryption_oaep(encrypted_file_path, private_key_path, output_file_path)  
  
    if not success:  
        print("\n所有解密方法都失败。可能的问题:")  
        print("1. 私钥文件格式不正确")  
        print("2. 私钥与加密所用的公钥不匹配")  
        print("3. 加密数据格式不是纯RSA加密格式")  
        print("4. 可能使用了不同的加密算法或混合加密")  
        print("\n建议:")  
        print("- 检查密钥是否正确")  
        print("- 确认加密方式")  
        print("- 如果是混合加密，需要先解密对称密钥")

服务器题目

49该电脑最早的开机时间是什么(格式：2025/1/1 01:01:01)

2022/2/23 12:23:49

50服务器操作系统内核版本(格式：1.1.1-123)

3.10.0-1160.119.1.el7.x86_64

51除系统用户外，总共有多少个用户(格式：1)

3

52分析起早王的服务器检材，Trojan服务器混淆流量所使用的域名是什么(格式：xxx.xxx)填空题

wyzshop1.com
找到Trojan服务端

然后正在运行策略在下面
这个remote_addr就是混淆流量用的

53分析起早王的服务器检材，Trojan服务运行的模式为：A、foward B、nat  C、server D、client

B
正在运行的策略（出题人好坏啊还弄个youguess）

{
    "run_type": "you guess",
    "local_addr": "127.0.0.1",
    "local_port": 12345,
    "remote_addr": "wyzshop1.com",
    "remote_port": 443,
    "password": [
        "password1"
    ],
    "log_level": 1,
    "ssl": {
        "verify": true,
        "verify_hostname": true,
        "cert": "",
        "cipher": "ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES128-SHA:ECDHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:AES128-SHA:AES256-SHA:DES-CBC3-SHA",
        "cipher_tls13": "TLS_AES_128_GCM_SHA256:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_256_GCM_SHA384",
        "sni": "",
        "alpn": [
            "h2",
            "http/1.1"
        ],
        "reuse_session": true,
        "session_ticket": false,
        "curves": ""
    },
    "tcp": {
        "no_delay": true,
        "keep_alive": true,
        "reuse_port": false,
        "fast_open": false,
        "fast_open_qlen": 20
    }
}

nat运行的example策略

{
    "run_type": "nat",
    "local_addr": "127.0.0.1",
    "local_port": 12345,
    "remote_addr": "example.com",
    "remote_port": 443,
    "password": [
        "password1"
    ],
    "log_level": 1,
    "ssl": {
        "verify": true,
        "verify_hostname": true,
        "cert": "",
        "cipher": "ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-AES256-SHA:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES128-SHA:ECDHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:AES128-SHA:AES256-SHA:DES-CBC3-SHA",
        "cipher_tls13": "TLS_AES_128_GCM_SHA256:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_256_GCM_SHA384",
        "sni": "",
        "alpn": [
            "h2",
            "http/1.1"
        ],
        "reuse_session": true,
        "session_ticket": false,
        "curves": ""
    },
    "tcp": {
        "no_delay": true,
        "keep_alive": true,
        "reuse_port": false,
        "fast_open": false,
        "fast_open_qlen": 20
    }
}

就只有这个是最接近的

54关于 Trojan服务器配置文件中配置的remote_addr 和 remote_port 的作用，正确的是：
A. 代理流量转发到外部互联网服务器
B. 将流量转发到本地的 HTTP 服务（如Nginx）
C. 用于数据库连接
D. 加密流量解密后的目标地址

A

55分析网站后台登录密码的加密逻辑，给出密码sbwyz1加密后存在数据库中的值(格式：1a2b3c4d)

f8537858eb0eabada34e7021d19974ea
先看看有没有防火墙

发现有的，于是关掉它

然后就是经典操作

查ssh

finalshell连接

宝塔改密码和查入口

然后更新宝塔面板，这样顺眼多了

改hosts

进入/www/wwwroot/www.tpshop.com/application/admin搜索password
关注这一行，执行了一个encrypt加密函数，所以接着搜加密函数

function encrypt($str){
	return md5(C("AUTH_CODE").$str);
}

所以就是md5加密（加密的内容是AUTH_CODE加上输入的字符串）

然后尝试绕过密码登陆
找到my.cnf位置（或者my.ini）

加一行skip-grant-tables，然后重启mysql

随后发现数据库是空的，找到备份的sql文件重建数据库

然后刷新数据库就有内容了
重建后可以发现网站能正常访问了
把admin密码修改

修改之后登陆就进去了

56网站后台显示的服务器GD版本是多少(格式：1.1.1 abc)

根目录的l.php里有

57网站后台中2016-04-01 00:00:00到2025-04-01 00:00:00订单列表有多少条记录(格式：1)

1292

58在网站购物满多少免运费(格式：1)填空题

100000

59分析网站日志，成功在网站后台上传木马的攻击者IP是多少(格式：1.1.1.1)

222.2.2.2
找到日志

搜peiqi.php查到ip

60攻击者插入的一句话木马文件的sha256值是多少(格式：大写sha256)

870bf66b4314a5567bd92142353189643b07963201076c5fc98150ef34cbc7cf
找到一个peiqi.php，一句话木马

61攻击者使用工具对内网进行扫描后，rdp扫描结果中的账号密码是什么(格式：abc:def)填空题

administrator:Aa123456@
application目录下出现一些奇怪工具（看到Pwn就知道是个渗透工具hhh）

看一下result.txt
最后几行找到帐号密码

62对于每个用户，计算其注册时间（用户表中的注册时间戳）到首次下单时间（订单表中最早时间戳）的间隔，找出间隔最短的用户id。（格式：1）

导出会员

然后让AI帮忙写个Python代码（我不会mysql代码呜呜呜）

import pandas as pd  
  
# 读取用户表，指定user_id和reg_time所在的列  
users = pd.read_excel('tp_users.xlsx', usecols=[0, 12], header=0)  
users.columns = ['user_id', 'reg_time']  
  
# 读取订单表，指定user_id和create_time所在的列  
orders = pd.read_excel('tp_delivery_doc.xlsx', usecols=[3, 20], header=0)  
orders.columns = ['user_id', 'create_time']  
  
# 转换时间为数值类型并处理无效值  
users['reg_time'] = pd.to_numeric(users['reg_time'], errors='coerce')  
orders['create_time'] = pd.to_numeric(orders['create_time'], errors='coerce')  
  
# 删除无效的时间数据  
users = users.dropna(subset=['reg_time'])  
orders = orders.dropna(subset=['create_time'])  
  
# 获取每个用户的最早下单时间  
first_order = orders.groupby('user_id')['create_time'].min().reset_index()  
  
# 合并用户数据与首次下单时间  
merged = pd.merge(users, first_order, on='user_id', how='inner')  
  
# 计算时间差（假设时间戳单位一致，例如均为秒）  
merged['time_diff'] = merged['create_time'] - merged['reg_time']  
  
# 找到最小时间差对应的用户  
min_diff = merged['time_diff'].min()  
min_users = merged[merged['time_diff'] == min_diff]['user_id']  
  
# 输出结果  
print("间隔最短的用户ID：")  
for user_id in min_users:  
    print(int(user_id))

63统计每月订单数量，找出订单最多的月份（XXXX年XX月）

2017年1月

import pandas as pd  
  
# 读取订单表  
orders = pd.read_excel('tp_delivery_doc.xlsx', usecols=[20], header=0)  # U列是第20列  
orders.columns = ['create_time']  
  
# 转换时间戳（自动识别秒或毫秒时间戳）  
orders['create_time'] = pd.to_numeric(orders['create_time'], errors='coerce')  
orders = orders.dropna(subset=['create_time'])  
  
# 处理毫秒级时间戳（如果时间戳大于1e12则认为是毫秒）  
orders['datetime'] = pd.to_datetime(  
    orders['create_time'].apply(  
        lambda x: x/1000 if x > 1e12 else x  
    ), unit='s'  
)  
  
# 提取年月并统计  
orders['year_month'] = orders['datetime'].dt.strftime('%Y-%m')  
monthly_orders = orders['year_month'].value_counts().reset_index()  
monthly_orders.columns = ['月份', '订单数量']  
  
# 找出订单最多的月份  
max_orders = monthly_orders[monthly_orders['订单数量'] == monthly_orders['订单数量'].max()]  
  
print("订单最多的月份及订单量：")  
print(max_orders.to_string(index=False))

64找出连续三天内下单的用户并统计总共有多少个（格式：1）

107

import pandas as pd  
import bisect  
  
  
def analyze_orders():  
    # 读取Excel数据（C列=2，AD列=29）  
    orders = pd.read_excel('tp_order.xlsx',  
                           usecols=[2, 29],  
                           header=0,  
                           names=['user_id', 'add_time'])  
  
    # 时间戳转换（支持秒/毫秒自动检测）  
    def convert_timestamp(ts):  
        try:  
            # 处理毫秒级时间戳（13位数字）  
            if ts > 1e12:  # 判断是否为毫秒级  
                return pd.to_datetime(ts / 1000, unit='s')  
            return pd.to_datetime(ts, unit='s')  
        except:  
            return pd.NaT  
  
    orders['order_date'] = orders['add_time'].apply(convert_timestamp)  
  
    # 清理无效数据  
    valid_orders = orders.dropna(subset=['order_date']).copy()  
  
    # 定义核心分析函数  
    def find_earliest_date(dates):  
        sorted_dates = sorted(dates)  
        for i in range(len(sorted_dates)):  
            current = sorted_dates[i]  
            # 设置3天后的截止时间  
            cutoff = current + pd.Timedelta(days=3)  
            # 使用二分查找优化搜索  
            idx = bisect.bisect_right(sorted_dates, cutoff, i + 1)  
            if idx > i + 1:  
                return current  
        return None  
  
    # 执行分组计算  
    result = (  
        valid_orders.groupby('user_id')['order_date']  
        .agg(find_earliest_date)  
        .dropna()  
        .reset_index()  
        .rename(columns={'order_date': 'earliest_order_date'})  
        .sort_values('user_id')  
    )  
  
    # 结果格式处理  
    result['earliest_order_date'] = result['earliest_order_date'].dt.strftime('%Y-%m-%d %H:%M:%S')  
  
    return result  
  
  
# 执行并打印结果  
final_result = analyze_orders()  
print("用户首次触发3天间隔的订单时间：")  
print(final_result.to_string(index=False))

流量分析（提示：侦查人员自己使用的蓝牙设备有QC35 II耳机和RAPOO键盘）

这里真不会做，让我先去学学

65请问侦查人员是用哪个接口进行抓到蓝牙数据包的（格式：DVI1-2.1）填空题

66起早王有一个用于伪装成倩倩耳机的蓝牙设备，该设备的原始设备名称为什么（格式：XXX_xxx 具体大小写按照原始内容）填空题

67起早王有一个用于伪装成倩倩耳机的蓝牙设备，该设备修改成耳机前后的大写MAC地址分别为多少（格式：32位小写md5(原MAC地址_修改后的MAC地址) ，例如md5(11:22:33:44:55:66_77:88:99:AA:BB:CC)=a29ca3983de0bdd739c97d1ce072a392 ）填空题

68流量包中首次捕获到该伪装设备修改自身名称的UTC+0时间为？（格式：2024/03/07 01:02:03.123）填空题

69起早王中途还不断尝试使用自己的手机向倩倩电脑进行广播发包，请你找出起早王手机蓝牙的制造商数据（格式：0x0102030405060708）填空题

70起早王的真名是什么（格式：Cai_Xu_Kun 每个首字母均需大写 ）填空题

71起早王对倩倩的电脑执行了几条cmd里的命令（格式：1 ）填空题

72倩倩电脑中影子账户的账户名和密码为什么（格式：32位小写md5(账号名称_密码) ，例如md5(zhangsan_123456)=9dcaac0e4787b213fed42e5d78affc75 ）填空题

73起早王对倩倩的电脑执行的最后一条命令是什么（格式：32位小写md5(完整命令)，例如md5(echo “qianqianwoaini” > woshiqizaowang.txt)=1bdb83cfbdf29d8c2177cc7a6e75bae2  ）填空题