2025数证杯初赛

发表于2025-11-21|更新于2025-11-21

|浏览量:

服务器取证

先把检材仿真，起来，由于master和node的节点已经写好了，于是不尝试修改这几个机子的ip，直接修改nat的网段为50

可以正常连接，也可以ping通root、

1. node1节点的磁盘设备SHA256值前六位是？(字母全大写，答案格式：AAAAAA)

FC9A34

node1节点是第二个镜像，xwf计算

2. 集群配置了多少个node节点？（答案格式：1）

2

kubectl get nodes

3.嫌疑人于什么时间修改master节点的root密码？（使用双位数格式，答案格式：00:00:00）

09:35:59

.bash_history里有和修改密码相关的，但是没有时间

于是去日志中看看

得到时间

4. Docker的安装日期是？（使用双位数格式，答案格式：01月01日）

04月08日

centos的系统，在history中也能看到是用yum下载的，

直接看yum的历史记录

5. Docker通过配置守护进程以使用全局代理，该代理地址的端口是？（答案格式：1）

4780

查看守护进程的配置文件

6. 发卡网站使用的Mysql数据库对外访问端口是？（答案格式：1）

30627

kubectl get svc

K8S集群重组&网站重组

需要重构k8s集群，由上题图找到k8s的面板端口，https访问

用命令创建一个账号tokenkubectl create token dashboard-admin --namespace kube-system

登录上去

面板全红，一点点修

首先在设置中把所有的命名空间都加上

发现是83的镜像挂载问题，无法连接到共享服务

通过命令检测发现是网络问题

去83上看看怎么回事

服务正常，关闭防火墙试试，关上后正常了

但是captcha-bot还是起不来，看日志发现是无法连接到数据库

这个端口和之前看service的端口一致，但是没有启动

在root目录下能找到很多配置文件，

用apply命令添加一下mysql80-pvc.yaml(因为83那台机器里是mysql80)，再添加mysql-d，mysql-c

然后重启看情况，最终还是报错，显示连接超时

先重构一下发卡网站，有pvc，但是在Deployments中未发现发卡网站，并且pvc对应的目录下边没有网址文件，可能已经删除

但是通过查看83的命令历史记录

将 dujiaoka/目录及其所有内容打包成一个名为 dujiaoka.tar

那我们还原到原位置就好，root目录下，发现dujiaoka.tar备份，还原到对应的目录

apply配置一下

grep -r dujiaoka看一下，发现nginx的配置文件中也有这个网址的一些东西

那也需要apply一下php-nginx的

但是我发现我的node1中有配置文件需要的 webdevops/php-nginx:7.4 镜像，所以我apply后，网站就能正常进入了

7. 发卡网站部署使用的镜像名称是？（答案格式：root/root）

webdevops/php-nginx

8. 当前Telegram群管机器人使用的容器ID的前六位是？（答案格式：123abc）

8fadf5

由于重构仿真后集群会重新拉起新的容器，所以借助静态分析。拿到上一次运行的容器ID（也可以在overlay2里直接搜）

9. 发卡网站使用的缓存数据库是？（答案格式：mysql）

有redis的pods并且网站env配置中发现缓存配置

10. 集群中配置的发卡网站代码运行所在的物理目录是？（答案格式：/root/root）

/data/k8s_data/default/dujiaoka

11. Telegram群管机器人配置的API代理域名是？（答案格式：www.xxx.com）

kk.xilika.cc

12. 嫌疑人在Telegram上创建的群名称是？（答案格式：比武群）

西门庆交流群

连接上mysql数据库看看

13. 统计嫌疑人在Telegram上创建的群中2025年6月之后成功入群的人数为？（答案格式：1）

2422

分析数据库字段和数据，status为2时，没有success_time，所以成功入群是1

SELECT count(*) FROM captchabot.user_captcha_record AS ucr WHERE captcha_status = 1 AND captcha_success_time >= '2025-06-01 00:00:00';

14.据嫌疑人交代曾在发卡网上删除过一条订单数据，请找出该删除订单的订单号是？（答案格式：请按实际值填写）

4V8XNK8Q02MD5D2R

dujiaoka的表中没有删除的订单

去83的mysql80文件夹下边看看，开启了binlog

版本是8.0.43

用对应版本的mysqlbinlog恢复数据，第二个字段是订单号

mysqlbinlog --no-defaults -vv --base64-output=DECODE-ROWS F:\BaiduNetdiskDownload\数证杯\binlog.000002 > F:\BaiduNetdiskDownload\数证杯\demo.sql

15. 发卡网站上2025年6月之后订单交易成功的总金额是？忽略被删除的数据（答案格式：1）

295202.00

select sum(actual_price) from orders where status = 4 and updated_at >= "2025-06-01 00:00:00"

16. 发卡网站的后台访问路径是？（答案格式：/root）

/admin

查看网站根目录下的.env文件

17.计算出用户密码算法中Salt的值，并进行Base64编码，结果是？（答案格式：请按实际值填写）

lAID2ktDeRlGbcg=

在数据库中，找到加密后的password

丢给hashcat，看看

是bcrypt，搜一下相关文件

查看/vendor/laravel/framework/src/Illuminate/Hashing/BcryptHasher.php 文件

18. 发卡网站配置的邮件发送人地址是？（答案格式：abc@abc.com）

ituzz@qq.com

根据上题的代码文件，进行绕密修改

修改为return true或者return !parent::check($value, $hashedValue, $options);
即可实现绕密登录

19. 当前发卡网站首页仪表盘中显示的发卡网站版本为？（答案格式：1.1.1）

2.0.5

20. 当前发卡网站中绑定的订单推送Telegram用户id为（答案格式：请按实际值填写）

6213151597

流量包分析

21. 黑客攻击的目标路由器SSID为（答案格式：请按实际值填写）

laozhaoWIFI

根据第二题可以知道黑客成功捕获了WPA的协议包，因此可以过滤对应的协议EAPOL，过滤之后发现对应的wifi的mac地址，同时可以得知进行了四组有效握手

根据mac进行过滤，过滤出源地址或目的地址是该Mac的内容，在过滤出的内容中搜索SSID，可以得到对应的值为“laozhaoWIFI”

22.黑客成功捕获了WIFI中WPA协议握手包，其中有效握手包组数为(完整握手为一组)（答案格式：1）

4

有上题图可知

23.黑客爆破得出的WiFi密码为（提示：密码由小写英文字母和数字组成）（答案格式：abcd1234）

password1110

结合后面的题目，已知黑客后面获取到了路由器的管理后台，可以猜测管理后台中存在wifi的密码，我们直接追踪HTTP流量进行查看

这两个爆破包，寻找对应的响应包，第一个post请求响应为403，且其响应中有Invalid username and/or password! Please try again.第二个为302，没有Invalid username and/or password! Please try again.，所以后台的密码为password

在之后的流量包中发现wifi的密码password1110

24. 黑客成功连接Wifi后，发现路由器操作系统为？（答案格式：请按实际值填写）

ImmortalWrt

将上一题爆破成功的响应包保存下来打开发现操作系统

25. 黑客对路由器后台进行爆破攻击，该路由器后台密码为（答案格式：请按实际值填写）

password

有23题分析可得后台密码为password

26. 黑客通过修改路由器设置，将被劫持的域名为（答案格式：www.xxx.com）

www.qq.com

过滤dns之后发现黑客查询了很多的域名，如果说他劫持了一个域名，那么查询的时候应该是，响应域名存在，并且响应的域名IP为内网IP，直接过滤dns协议并且响应成功的内容

27. 黑客在路由器管理后台发现FTP服务配置，FTP登录密码为？（答案格式：请按实际值填写）

mast

28. 黑客通过FTP上传了一个压缩包文件，该文件内容为（答案格式：请按实际值填写）

code:123456789

上传了两个文件

一个flag.zip，一个zhaohong，导出flag.zip，有密码

passwarekit跑一下

29. 黑客通过路由器执行shell脚本，反弹shell的监听端口为（答案格式：1）

4445

在tcp流0中发现反弹shell的命令

30. 黑客通过反弹shell成功控制目标路由器后，总共执行了多少条命令（答案格式：1)

4

筛选对应端口的流量tcp.dstport == 4445

一共四个命令

APK程序分析

31.apk 的版本名称为？（答案格式：1.1.1）

3.0.12

32.在该APP中，调用了哪个System的方法用于获取本地系统的时间戳？（答案格式：MainActivity）

currentTimeMillis

由上图知apk被360加固了，使用在线平台56.al脱一下

33.apk 运行后 getVer() 的返回值（答案格式：1.0.0）

4.56.23

搜索getVer()

第一个定义了这个方法，第二个应该是调用了这个，对它进行 hook

Java.perform(function(){
  var v =Java.use("net.net.MainActivity").getVer();
  console.log("[getVer] " + v);
});

34.apk运行后需要通过一个http get请求才能打开第二个界面，给出该请求URL？（答案格式：http://www.xxx.com/test?a=1）

http://127.0.0.1:60723/K0pQvBZ38ykL26OzfshqYTHC2f7RUJYIgrmIF6GcORU=?hash=983f8a605d16530190c09b0884d7cef1&ver=4.56.23&ts=1727899789

定位到调用getVer()的那部分，分析一下上下文逻辑

服务器监听本地 60723 端口, 收到请求后验证, 接着启动 SecondActivity, 也就是下题的第二界面.

hook一下

Java.perform(function(){
    var app = Java.use("android.app.ActivityThread").currentApplication();
    Java.classFactory.loader = app.getClassLoader();
    var MA = Java.use("net.net.MainActivity");
    var ver = String(MA.getVer());
    var apkHash = String(MA.apkHash.value);
    var ts = String(MA.ts.value);
    var enc = String(Java.use("net.net.crypto.MultiLayerEncryption").multiLayerEncrypt("check_apk_status"));
    console.log("http://127.0.0.1:60723/" + enc + "?hash=" + apkHash + "&ver=" + ver + "&ts=" + ts);
});

35 apk 第二界面的 8 位授权码（答案格式：11111111）

84572399

可以根据答案格式写代码爆破一下

public class AuthorizationCodeCracker {
    private static final int TARGET_HASH = -711638849;
    public static void main(String[] args)  {
        for (int i = 0; i < 100000000; i++) {
            String code = String.format("%08d", i);
            if (code.hashCode() == TARGET_HASH) {
                System.out.println(code);
                return;
            }
        }
    }
}

二进制程序分析

36.安装该程序后，该恶意程序的可执行文件所在的直接父目录名称是什么为？（答案格式：root）

proxy

在虚拟机中下载程序，发现生成的快捷方式没有指向原本的程序，而是指向了/bin/proxy/v2ray.exe，所以恶意程序为v2ray.exe，其直接父目录为proxy

37.解密文件名为RnRGaWxlcy5lZGIiL的文件时所使用的key是什么？（答案格式：请按实际值填写）

1Njc2NTQ2Mzc0NTc

打开v2ray.exe文件后，在main函数中发现

程序把文件内容读取到 Buffer 缓冲区, 然后调用sub_140001BF0函数对其进行操作, 之后还调用了 sub_140001070 函数, 作用未知.

先看sub_140001BF0，根据一些特征确定为RC4加密，

然后使用a1njc2ntq2mzc0n的前16字节做为 key 对初始s表做 KSA，key的值为1Njc2NTQ2Mzc0NTc

38.解密文件RnRGaWxlcy5lZGIiL成功后，请分析并给出解密后的文件的入口点地址？（答案格式：0x180000000）

0x180002730

解密文件

VA = ImageBase + RVA，在本题中，rva为0x00002730，imagebase为0x180000000是，所以VA为0x180002730

39.加密文件名为6c051a72b91a1的文件时所使用的密钥是多少？（答案格式：请按实际值填写）

cgDSb6VOegeF7EuW

执行完加密函数后跳转到了sub_140001070里，在上一个解密函数执行完成之后, 它首先校验解密出的 PE 文件格式, 之后调用函数 sub_140001B20 在其中的导出表里查找函数 SDGHY3a9DK3t14Fg1hSGH56U，转到刚解密出的文件对应的函数中

先获取当前用户的 downloads 文件夹路径, 列出其中的所有文件和子目录

如果是文件夹，调用 sub_180001D80(&unk_180022600, path)
如果是文件，调用 sub_180001E50(path)

题目问的是文件，所以先进入1e50看看

// Hidden C++ exception states: #wind=1
__int64 __fastcall sub_180001E50(const char *p_MultiByteStr)
{
  HANDLE hFile; // rax
  void *hFile_1; // rsi
  DWORD n0x5F5E100; // ebx
  HANDLE hObject; // r14
  DWORD NumberOfBytesRead_1; // r8d
  DWORD NumberOfBytesRead_2; // ebx
  __int128 v9; // xmm6
  __int64 v10; // r8
  __int64 v11; // [rsp+40h] [rbp-C0h]
  _OWORD v12[6]; // [rsp+50h] [rbp-B0h] BYREF
  int v13; // [rsp+B0h] [rbp-50h]
  DWORD NumberOfBytesRead; // [rsp+C0h] [rbp-40h] BYREF
  DWORD NumberOfBytesWritten; // [rsp+C4h] [rbp-3Ch] BYREF
  void (__fastcall ***v16)(_QWORD, __int64); // [rsp+C8h] [rbp-38h] BYREF
  int n4; // [rsp+D0h] [rbp-30h]
  __int128 v18; // [rsp+D4h] [rbp-2Ch] BYREF
  __int128 v19; // [rsp+E4h] [rbp-1Ch]
  int v20; // [rsp+F4h] [rbp-Ch]
  _OWORD v21[6]; // [rsp+100h] [rbp+0h] BYREF
  int v22; // [rsp+160h] [rbp+60h]
  CHAR FileName[272]; // [rsp+170h] [rbp+70h] BYREF
  _BYTE Buffer[4096]; // [rsp+280h] [rbp+180h] BYREF

  sub_180001DE0((__int64)FileName, 260, "%s.1", p_MultiByteStr);
  hFile = CreateFileA(p_MultiByteStr, 0x80000000, 0, 0, 3u, 0x80u, 0);
  hFile_1 = hFile;
  if ( hFile == (HANDLE)-1LL )
  {
    sub_180001D80(&unk_1800225A8, p_MultiByteStr);
    return 0;
  }
  n0x5F5E100 = SetFilePointer(hFile, 0, 0, 2u);
  SetFilePointer(hFile_1, 0, 0, 0);
  if ( n0x5F5E100 > 0x5F5E100 )
    return 0;
  hObject = CreateFileA(FileName, 0x40000000u, 0, 0, 2u, 0x80u, 0);
  if ( hObject == (HANDLE)-1LL )
  {
    sub_180001D80(&unk_1800225C0, FileName);
    CloseHandle(hFile_1);
    return 0;
  }
  else
  {
    while ( ReadFile(hFile_1, Buffer, 0x1000u, &NumberOfBytesRead, 0) )
    {
      NumberOfBytesRead_1 = NumberOfBytesRead;
      if ( !NumberOfBytesRead )
        break;
      for ( NumberOfBytesRead_2 = 0; NumberOfBytesRead_2 < NumberOfBytesRead; NumberOfBytesRead_2 += 16 )
      {
        memset(v21, 0, sizeof(v21));
        v22 = 0;
        memset(v12, 0, sizeof(v12));
        v13 = 0;
        if ( NumberOfBytesRead_1 - NumberOfBytesRead_2 < 0x10 )
          break;
        v9 = *(_OWORD *)&Buffer[NumberOfBytesRead_2];
        v20 = 0;
        n4 = 4;
        v16 = 0;
        v18 = 0;
        v19 = 0;
        v11 = sub_1800023B0(696);
        v16 = (void (__fastcall ***)(_QWORD, __int64))sub_180001000(v11, &v18);
        v18 = xmmword_180025A80;
        sub_180001920(
          v16,
          &v18,
          v16 + 65,
          (NumberOfBytesRead_2 >> 4)
        - 11 * ((unsigned int)((3123612579u * (unsigned __int64)(NumberOfBytesRead_2 >> 4)) >> 32) >> 3));
        n4 = 3;
        v19 = xmmword_180025A70;
        v12[0] = v9;
        sub_180001A80(&v16, v12, v10, v21);
        *(_OWORD *)&Buffer[NumberOfBytesRead_2] = v21[0];
        if ( v16 )
          (**v16)(v16, 1);
        NumberOfBytesRead_1 = NumberOfBytesRead;
      }
      if ( !WriteFile(hObject, Buffer, NumberOfBytesRead_1, &NumberOfBytesWritten, 0)
        || NumberOfBytesWritten != NumberOfBytesRead )
      {
        sub_180001D80(&unk_1800225D8, FileName);
        CloseHandle(hFile_1);
        CloseHandle(hObject);
        DeleteFileA(FileName);
        return 0;
      }
    }
    CloseHandle(hFile_1);
    CloseHandle(hObject);
    return 1;
  }
}

函数会为文件创建一个同目录下的临时文件: 原名.1, 然后以 4 KB 为缓冲区逐块读取源文件, 每 16 字节为一个加密单元进行处理, 把处理后的数据写入 .1 文件

在原始程序的目录中，有6c051a72b91a1.1这个文件，我们需要解密

继续分析程序，首先sub_180001000对每一个块进行了初始处理，

__int64 __fastcall sub_180001000(__int64 a1, __int64 a2)
{
  __int64 n2; // rdx
  __int64 v5; // rax
  __int64 n2_1; // r8
  __int128 *v7; // rcx
  __int128 v8; // xmm0
  __int128 v9; // xmm1
  __int128 v10; // xmm0
  __int128 v11; // xmm1
  __int128 v12; // xmm0
  __int128 v13; // xmm1
  __int128 v14; // xmm0
  __int128 v15; // xmm1
  __int64 v16; // rcx
  __int128 *v17; // rax
  __int128 v18; // xmm0
  __int128 v19; // xmm1
  __int128 v20; // xmm0
  __int128 v21; // xmm1
  __int128 v22; // xmm0
  __int128 v23; // xmm1
  __int128 v24; // xmm0
  __int128 v25; // xmm1
  _DWORD v27[64]; // [rsp+20h] [rbp-E0h] BYREF
  _DWORD v28[64]; // [rsp+120h] [rbp+20h] BYREF

  v27[0] = 2071428195;
  *(_QWORD *)a1 = &AES::`vftable';
  v27[1] = -982553614;
  v27[2] = 728170800;
  v27[3] = 1990973438;
  v27[4] = 2110358218;
  v27[5] = -263759366;
  v27[6] = -1348283219;
  v27[7] = -1066228580;
  v27[8] = 647232951;
  v27[9] = -856211658;
  v27[10] = -236608204;
  v27[11] = 355588209;
  v27[12] = -1021065468;
  v27[13] = -1710909928;
  v27[14] = -494923257;
  v27[15] = 1974609899;
  v27[16] = 439124745;
  v27[17] = -1604686309;
  v27[18] = -1277805742;
  v27[19] = -2077236439;
  v27[20] = -318713517;
  v27[21] = 1538391072;
  v27[22] = 968805226;
  v27[23] = -816296886;
  v27[24] = -72683568;
  v27[25] = -2060235453;
  v27[26] = 2130901317;
  v27[27] = -1465959344;
  v27[28] = -1891589295;
  v27[29] = -180839022;
  v27[30] = 567981756;
  v27[31] = -755761392;
  v27[32] = -334295859;
  v27[33] = 390371167;
  v27[34] = 1031710660;
  v27[35] = 1931042148;
  v27[36] = -598769312;
  v27[37] = -2003817950;
  v27[38] = 347663942;
  v27[39] = -620011810;
  v27[40] = 171586272;
  v27[41] = 1545864777;
  v27[42] = 1655493570;
  v27[43] = 2045023633;
  v27[44] = 1832372455;
  v27[45] = -1454451315;
  v27[46] = -353085844;
  v27[47] = 145652325;
  v27[48] = 774207674;
  v27[49] = -961239524;
  v27[50] = 527752680;
  v27[51] = -1970553525;
  v27[52] = 1723154032;
  v27[53] = 251003720;
  v27[54] = -1185467039;
  v27[55] = -1642217082;
  v27[56] = 295237857;
  v27[57] = -1802577559;
  v27[58] = -377020773;
  v27[59] = -551004722;
  v27[60] = 227123596;
  v27[61] = 1749214911;
  v27[62] = 254646593;
  v27[63] = 381375664;
  v28[0] = -714471086;
  v28[1] = 950351408;
  v28[2] = -1633468225;
  v28[3] = -69733503;
  v28[4] = -2110135428;
  v28[5] = -2013319269;
  v28[6] = 1145278004;
  v28[7] = -873865532;
  v28[8] = 848591700;
  v28[9] = 1025753766;
  v28[10] = 194333934;
  v28[11] = 1321466434;
  v28[12] = 1721839112;
  n2 = 2;
  v28[13] = -1306207960;
  v5 = a1 + 8;
  v28[14] = 1235377014;
  n2_1 = 2;
  v28[15] = 634489709;
  v28[16] = 1693907058;
  v7 = (__int128 *)v27;
  v28[17] = 379086982;
  v28[18] = -866343724;
  v28[19] = -1833540259;
  v28[20] = 1346924652;
  v28[21] = -625349123;
  v28[22] = 1464210782;
  v28[23] = -2070049369;
  v28[24] = 11262096;
  v28[25] = 181648524;
  v28[26] = 89711863;
  v28[27] = 105231288;
  v28[28] = -1893847856;
  v28[29] = 34553802;
  v28[30] = 62762945;
  v28[31] = 1804210945;
  v28[32] = 1091670330;
  v28[33] = -354654385;
  v28[34] = -825232745;
  v28[35] = 1944499440;
  v28[36] = 578071702;
  v28[37] = -2060079641;
  v28[38] = -398984734;
  v28[39] = 1860138268;
  v28[40] = 1897591111;
  v28[41] = -1983567587;
  v28[42] = 241350511;
  v28[43] = 465442986;
  v28[44] = 1262376700;
  v28[45] = 544854726;
  v28[46] = -20915302;
  v28[47] = -195375752;
  v28[48] = 866704671;
  v28[49] = 835127176;
  v28[50] = 1494225585;
  v28[51] = 1609334823;
  v28[52] = -1451273888;
  v28[53] = 222999833;
  v28[54] = -1619335891;
  v28[55] = -274937453;
  v28[56] = 1295769760;
  v28[57] = -1326110034;
  v28[58] = 1018948552;
  v28[59] = 1637438339;
  v28[60] = 2114202391;
  v28[61] = 651589562;
  v28[62] = 1662282209;
  v28[63] = 2097946965;
  do
  {
    v5 += 128;
    v8 = *v7;
    v9 = v7[1];
    v7 += 8;
    *(_OWORD *)(v5 - 128) = v8;
    v10 = *(v7 - 6);
    *(_OWORD *)(v5 - 112) = v9;
    v11 = *(v7 - 5);
    *(_OWORD *)(v5 - 96) = v10;
    v12 = *(v7 - 4);
    *(_OWORD *)(v5 - 80) = v11;
    v13 = *(v7 - 3);
    *(_OWORD *)(v5 - 64) = v12;
    v14 = *(v7 - 2);
    *(_OWORD *)(v5 - 48) = v13;
    v15 = *(v7 - 1);
    *(_OWORD *)(v5 - 32) = v14;
    *(_OWORD *)(v5 - 16) = v15;
    --n2_1;
  }
  while ( n2_1 );
  v16 = a1 + 264;
  v17 = (__int128 *)v28;
  do
  {
    v16 += 128;
    v18 = *v17;
    v19 = v17[1];
    v17 += 8;
    *(_OWORD *)(v16 - 128) = v18;
    v20 = *(v17 - 6);
    *(_OWORD *)(v16 - 112) = v19;
    v21 = *(v17 - 5);
    *(_OWORD *)(v16 - 96) = v20;
    v22 = *(v17 - 4);
    *(_OWORD *)(v16 - 80) = v21;
    v23 = *(v17 - 3);
    *(_OWORD *)(v16 - 64) = v22;
    v24 = *(v17 - 2);
    *(_OWORD *)(v16 - 48) = v23;
    v25 = *(v17 - 1);
    *(_OWORD *)(v16 - 32) = v24;
    *(_OWORD *)(v16 - 16) = v25;
    --n2;
  }
  while ( n2 );
  if ( a2 )
    sub_180001920(a1, a2, (_OWORD *)(a1 + 520), 0);
  return a1;
}

这个函数构造了一个对象 AES::vftable, 在对象内布置了两组 64 × 4 bytes 的表, 很可能是 AES 加密了

其中传入的 a2 被函数 sub_180001920 调用, 而这个函数是 AES 的密钥拓展函数

__int64 __fastcall sub_180001920(__int64 a1, __int64 a2, _OWORD *a3, int a4)
{
  __int64 v4; // rdx
  __int64 v5; // r15
  char *v8; // r8
  __int64 n4; // rcx
  char v10; // al
  unsigned __int8 *v11; // r8
  __int64 n10; // rdi
  __int64 n4_1; // rax
  unsigned __int8 v14; // r9
  unsigned __int8 *v15; // rdx
  unsigned __int8 v16; // r10
  unsigned __int8 v17; // r11
  unsigned __int8 v18; // cl
  unsigned __int8 v19; // r11
  unsigned __int8 v20; // cl
  unsigned __int8 v21; // r9
  __int128 v22; // xmm1
  __int64 result; // rax
  char v24; // [rsp+1h] [rbp-29h]
  int n134480385; // [rsp+2h] [rbp-28h]
  int v26; // [rsp+6h] [rbp-24h]
  __int16 n13851; // [rsp+Ah] [rbp-20h]

  v4 = a2 + 8;
  v5 = a4;
  n134480385 = 134480385;
  v26 = -2143281136;
  v8 = (char *)a3 + 2;
  n13851 = 13851;
  n4 = 4;
  do
  {
    v10 = *(_BYTE *)(v4 - 8);
    ++v4;
    *(v8 - 2) = v10;
    v8 += 4;
    *(v8 - 5) = *(_BYTE *)(v4 - 5);
    *(v8 - 4) = *(_BYTE *)(v4 - 1);
    *(v8 - 3) = *(_BYTE *)(v4 + 3);
    --n4;
  }
  while ( n4 );
  v11 = (unsigned __int8 *)a3 + 7;
  for ( n10 = 1; n10 <= 10; ++n10 )
  {
    for ( n4_1 = 0; n4_1 < 4; ++n4_1 )
    {
      if ( n4_1 )
      {
        v14 = v11[n4_1 + 8];
        v15 = &v11[n4_1 + 9];
        v16 = v15[3];
        v17 = v15[7];
        v18 = v15[11];
      }
      else
      {
        v15 = v11 + 9;
        v14 = *(&v24 + n10) ^ *(_BYTE *)(*v11 + a1 + 8);
        v16 = *(_BYTE *)(v11[4] + a1 + 8);
        v17 = *(_BYTE *)(v11[8] + a1 + 8);
        v18 = *(_BYTE *)(*(v11 - 4) + a1 + 8);
      }
      v19 = v11[n4_1 + 1] ^ v17;
      v20 = v11[n4_1 + 5] ^ v18;
      v21 = v11[n4_1 - 7] ^ v14;
      v11[n4_1 + 13] = v11[n4_1 - 3] ^ v16;
      v11[n4_1 + 17] = v19;
      v11[n4_1 + 21] = v20;
      *v15 = v21;
    }
    v11 += 16;
  }
  v22 = *a3;
  result = 2 * v5;
  *a3 = a3[v5];
  a3[v5] = v22;
  return result;
}

这段代码将从 a2 读入 16 字节密钥, 扩展成 11 个轮函数密钥

a2由v18传入，v18=xmmword_180025A80

需要注意大小端序，得到密钥cgDSb6VOegeF7EuW

40.6c051a72b91a1.1文件解密后的md5值后六位是多少？（字母全大写，答案格式：AAAAAA）

FF74E8

同时也能得到iv

但是直接解密没法解密，可能魔改了

用代码解密

import sys
from typing import List, Tuple


# === 固定密钥与 IV（来自样本常量区） ===
KEY_BYTES = bytes([
	0x63, 0x67, 0x44, 0x53, 0x62, 0x36, 0x56, 0x4F,
	0x65, 0x67, 0x65, 0x46, 0x37, 0x45, 0x75, 0x57,
])

IV_BYTES = bytes([
	0x67, 0x23, 0x94, 0xEF, 0x4C, 0xD5, 0x2F, 0x76,
	0xFF, 0xDE, 0x7B, 0xB0, 0x6A, 0x86, 0x62, 0x5C,
])


# === AES 常量表 ===
SBOX = [
	0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
	0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
	0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
	0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
	0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
	0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
	0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
	0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
	0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
	0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
	0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
	0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
	0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
	0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
	0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
	0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16,
]

INV_SBOX = [0] * 256
for i, v in enumerate(SBOX):
	INV_SBOX[v] = i

RCON = [
	0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1B, 0x36
]


def _xtime(a: int) -> int:
	a <<= 1
	if a & 0x100:
		a ^= 0x11B
	return a & 0xFF


def _mul(a: int, b: int) -> int:
	res = 0
	for _ in range(8):
		if b & 1:
			res ^= a
		hi = a & 0x80
		a = (a << 1) & 0xFF
		if hi:
			a ^= 0x1B
		b >>= 1
	return res


def sub_word(w: int) -> int:
	return (
		(SBOX[(w >> 24) & 0xFF] << 24)
		| (SBOX[(w >> 16) & 0xFF] << 16)
		| (SBOX[(w >> 8) & 0xFF] << 8)
		| (SBOX[w & 0xFF])
	)


def rot_word(w: int) -> int:
	return ((w << 8) | (w >> 24)) & 0xFFFFFFFF


def expand_key_128(key: bytes) -> List[bytes]:
	assert len(key) == 16
	# 44 words (4-byte) -> 11 round keys
	w = [0] * 44
	for i in range(4):
		w[i] = int.from_bytes(key[4 * i: 4 * (i + 1)], 'big')
	for i in range(4, 44):
		temp = w[i - 1]
		if i % 4 == 0:
			temp = sub_word(rot_word(temp)) ^ (RCON[i // 4] << 24)
		w[i] = (w[i - 4] ^ temp) & 0xFFFFFFFF
	round_keys = []
	for r in range(11):
		rk = b''.join(w[4 * r + j].to_bytes(4, 'big') for j in range(4))
		round_keys.append(rk)
	return round_keys


def inv_mix_columns_state(state: List[int]) -> None:
	for c in range(4):
		i = 4 * c
		a0, a1, a2, a3 = state[i:i + 4]
		state[i + 0] = (
			_mul(a0, 0x0e) ^ _mul(a1, 0x0b) ^ _mul(a2, 0x0d) ^ _mul(a3, 0x09)
		)
		state[i + 1] = (
			_mul(a0, 0x09) ^ _mul(a1, 0x0e) ^ _mul(a2, 0x0b) ^ _mul(a3, 0x0d)
		)
		state[i + 2] = (
			_mul(a0, 0x0d) ^ _mul(a1, 0x09) ^ _mul(a2, 0x0e) ^ _mul(a3, 0x0b)
		)
		state[i + 3] = (
			_mul(a0, 0x0b) ^ _mul(a1, 0x0d) ^ _mul(a2, 0x09) ^ _mul(a3, 0x0e)
		)


def mix_columns_state(state: List[int]) -> None:
	for c in range(4):
		i = 4 * c
		a0, a1, a2, a3 = state[i:i + 4]
		state[i + 0] = _mul(a0, 2) ^ _mul(a1, 3) ^ a2 ^ a3
		state[i + 1] = a0 ^ _mul(a1, 2) ^ _mul(a2, 3) ^ a3
		state[i + 2] = a0 ^ a1 ^ _mul(a2, 2) ^ _mul(a3, 3)
		state[i + 3] = _mul(a0, 3) ^ a1 ^ a2 ^ _mul(a3, 2)


def add_round_key(state: List[int], rk: bytes) -> None:
	for i in range(16):
		state[i] ^= rk[i]


def inv_shift_rows(state: List[int]) -> None:
	s = state
	s[1], s[5], s[9], s[13] = s[13], s[1], s[5], s[9]
	s[2], s[6], s[10], s[14] = s[10], s[14], s[2], s[6]
	s[3], s[7], s[11], s[15] = s[7], s[11], s[15], s[3]


def shift_rows(state: List[int]) -> None:
	s = state
	s[1], s[5], s[9], s[13] = s[5], s[9], s[13], s[1]
	s[2], s[6], s[10], s[14] = s[10], s[14], s[2], s[6]
	s[3], s[7], s[11], s[15] = s[15], s[3], s[7], s[11]


def sub_bytes(state: List[int]) -> None:
	for i in range(16):
		state[i] = SBOX[state[i]]


def inv_sub_bytes(state: List[int]) -> None:
	for i in range(16):
		state[i] = INV_SBOX[state[i]]


def aes_decrypt_block_with_enc_round_keys(block: bytes, erk: List[bytes]) -> bytes:
	"""使用加密轮密钥顺序进行标准 AES-128 解密。
	- 初始：AddRoundKey(state, erk[10])
	- 中间 9 轮：InvShiftRows → InvSubBytes → AddRoundKey(state, erk[r]) → InvMixColumns
	- 最后一轮：InvShiftRows → InvSubBytes → AddRoundKey(state, erk[0])
	这里的 erk 就是常规的加密轮密钥序列（长度 11，每个 16 字节）。
	"""
	s = list(block)
	# 初始轮：XOR 最后一轮密钥
	add_round_key(s, erk[10])
	# 中间轮：9→1
	for r in range(9, 0, -1):
		inv_shift_rows(s)
		inv_sub_bytes(s)
		add_round_key(s, erk[r])
		inv_mix_columns_state(s)
	# 末轮
	inv_shift_rows(s)
	inv_sub_bytes(s)
	add_round_key(s, erk[0])
	return bytes(s)


def xor16(a: bytes, b: bytes) -> bytes:
	return bytes(x ^ y for x, y in zip(a, b))


def decrypt_bytes(
	data: bytes,
	*,
	cbc_chain_iv: bool = True,
	reset_idx_per_chunk: bool = True,
	chunk_size: int = 4096,
) -> bytes:
	"""按样本逻辑进行解密。
	- 每个16字节为一块；不足16字节的尾部保持原样。
	- 轮密钥交换：swap(erk[0], erk[idx])，其中 idx = 块序号 % 11。
	  如果 reset_idx_per_chunk=True，则块序号在每个4KB块内从0开始计算。
	- CBC：默认使用链式IV（cbc_chain_iv=True），即 prevIV 初值为常量 IV，
	  每块后 prevIV = 当前密文块；若为 False 则始终使用常量IV。
	"""
	erk_master = expand_key_128(KEY_BYTES)
	out = bytearray()

	n = len(data)
	pos = 0
	# CBC 链式的 prev_iv 需要跨 chunk 保持；固定IV则保持常量无需更新
	prev_iv = IV_BYTES
	global_block_index = 0
	while pos < n:
		chunk = data[pos: pos + chunk_size]
		pos += len(chunk)

		blocks = len(chunk) // 16
		rem = len(chunk) % 16
		for bi in range(blocks):
			cblk = chunk[16 * bi: 16 * (bi + 1)]
			idx = (bi % 11) if reset_idx_per_chunk else (global_block_index % 11)
			if idx == 0:
				erk = erk_master
			else:
				erk = erk_master.copy()
				erk[0], erk[idx] = erk[idx], erk[0]
			x = aes_decrypt_block_with_enc_round_keys(cblk, erk)
			pblk = xor16(x, prev_iv)
			out += pblk
			if cbc_chain_iv:
				prev_iv = cblk
			global_block_index += 1

		if rem:
			out += chunk[-rem:]

	return bytes(out)


def decrypt_file(in_path: str, out_path: str, *, cbc_chain_iv: bool = True, reset_idx_per_chunk: bool = True) -> None:
	with open(in_path, 'rb') as f:
		data = f.read()
	out = decrypt_bytes(data, cbc_chain_iv=cbc_chain_iv, reset_idx_per_chunk=reset_idx_per_chunk)
	with open(out_path, 'wb') as f:
		f.write(out)


def default_out_path(in_path: str) -> str:
	if in_path.endswith('.1'):
		return in_path[:-2]
	return in_path + '.dec'


def main(argv: List[str]) -> int:
	if len(argv) < 2:
		print('用法: python de.py <输入文件> [输出文件] [--fixed-iv] [--global-idx]')
		print('  --fixed-iv   : 使用固定IV（不链式），默认链式')
		print('  --global-idx : 轮密钥交换索引在全文件范围累积，默认每4KB重置')
		return 1
	in_path = argv[1]
	out_path = None
	fixed_iv = False
	global_idx = False
	for arg in argv[2:]:
		if arg == '--fixed-iv':
			fixed_iv = True
		elif arg == '--global-idx':
			global_idx = True
		else:
			out_path = arg
	if out_path is None:
		out_path = default_out_path(in_path)
	decrypt_file(in_path, out_path, cbc_chain_iv=not fixed_iv, reset_idx_per_chunk=not global_idx)
	print(f'解密完成: {out_path}')
	return 0


if __name__ == '__main__':
	sys.exit(main(sys.argv))

得到的文件格式是png

FF74E8

计算机取证分析

41.操作系统的Build版本号是？（答案格式：1）

19044

导出注册表所在目录

42. 操作系统设置的账户密码最长存留期为多少天？（答案格式：1）

68

仿真，net accounts

43. 用户2登陆密码NT哈希值后六位是？（字母全大写，答案格式：AAAAAA）

A9C708

44.蓝牙mac地址是多少？（答案格式：AA-AA-AA-AA-AA-AA

9C:B6:D0:04:C9:CC

45. SafeImager的产品序列号后四位是？（字母全大写，答案格式：AAAAAA）

09C4

手动可以去看注册表，自动就看火眼或者超级取证大师的解析结果

46. 123.VHD所处的结束扇区是？（答案格式：1 ）

27445255

XWF 中定位到文件, 切换到文件视图, 按下快捷键 Ctrl + End 跳转至文件尾, 再切换回分区视图, 即可看到文件结尾所处的扇区号

47. 用户在BitLocker加密分区最后修改的文件是?（答案格式：abcd.txt）

资料1.txt

在上题的 123.vhd 中可以找到 BitLocker 恢复密钥 625075-617309-532576-720302-040975-309232-451924-426679, 用密钥解锁该分区

48. 用户连接192.168.114.129时用的会话名称是？（答案格式：按照实际情况填写）

连接阿里云

bitlocker解密后，导出xshell的session文件夹C:\Users\Administrator\Documents\NetSarang Computer\8\Xshell1下

49. 用户创建存储虚拟币钱包地址页面的时间是？（使用双位数格式，答案格式：01月01日）

10月07日

桌面上有个软件Anytype

50. 用户的虚拟币钱包地址是？（答案格式：按照实际情况填写）

3HrdpWM8ZrBVw9yu8jx1RoNNK6BZxwsHd9

4次base64解码得到

51. 用户VC加密容器的密码是？（答案格式：按照实际情况填写）

SHUZHENGBEIctzy2025

打开桌面上的Foxmail，有两个重要的邮件

一个是一个软件分卷压缩包，一个是一个图片

直接解压发现

猜测还有其他分卷，遂去寻找

打开联系人文件，可以在文件最后找到白色字体的密码

52. 用户在生活中使用的代号是？（答案格式：按照实际情况填写）

小胖

桌面上的代号.wav用audacity打开

53. 李安东的银行卡归属哪个银行？（答案格式：农业银行）

交通银行

桌面上的公司资料文件夹中有银行卡文件

导出来passwarekit跑一下6位数字

54. 请分析某市10月6日最高气温是？（答案格式：1)

21

导出气温加密的文件

虽然显示第一个文件被加密了，但是还是尝试一下修复伪加密

55. 用户的BitLocker密码是？（答案格式：按照实际情况填写）

SZBJSJTM2025

在用户的下载目录下发现隐写分析工具

尝试解密邮件附件图片

56. 用户办公室的门禁密码是？（答案格式：按照实际情况填写）

**147963258 **

vhd中有一个secretNew文件

尝试用veracrypt和之前的密码挂载

有一个被加密的文件，尝试用软件中的软件解密

57. 用户使用的以D开头的解密程序的MD5值后六位是？（字母全大写，答案格式：AAAAAA）

3A892E

58. 木马程序运行至系统断点前加载了几个动态链接库？（答案格式：1）

5

直接拖进dbg

59. 木马产生的程序名称是什么？（答案格式：abcd.txt）

wins.exe

微步跑一下

60. 木马尝试访问的域名是什么？（答案格式：按照实际情况填写)

edu-image.nosdn.127.net

61.分析计算机内存检材，此内存镜像制作时的系统时间是？（使用双位数格式，答案格式：01月01日）

10月16日

62. 分析计算机内存检材，用户Yiyelin的用户标识后4位是？（答案格式：1111）

1002

由上图

63. 分析计算机内存检材，计算机的CPU型号是什么？（答案格式： i9-1110U）

i7-1165G7

64. 分析计算机内存检材，wps.exe的PID是？（答案格式：1）

5888

65. 分析计算机内存检材，此计算机开机自启动的远控软件名称是？（答案格式：abcd.txt）

SunloginClient.exe

物联网设备取证分析

66. 打印机的主机名称是什么？(答案格式：root)

print

67. 打印文件存储在哪个目录？(答案格式：/root/root)

在 Linux 中，CUPS（Common Unix Printing System） 是一种通用的类 Unix 打印系统，用于管理打印机、打印任务和打印队列。它是大多数现代 Linux 发行版（如 Ubuntu、Fedora、Debian 等）的默认打印系统。

看root的历史记录发现下载了cups并且修改过其配置文件

去cups-files.conf看看，得到存储文件的目录/var/spool/cups

68. 同一天，打印两份文件的用户是谁？(答案格式：root)

alice

找到打印日志/var/log/cups/page_log1

69. 分析物联网检材，木马运行后，自身产生的进程ID是多少？（答案格式：1）

2177

看一下系统日志/var/log/syslog

有一个C2 server的连接，进程是cups-helper，id为2177

70. 分析物联网检材，系统中存在一个非标定时任务，这个任务每隔多少分钟执行？（答案格式：1）

10

在定时任务的文件中发现

有一个和木马有关的程序，每隔10分钟执行

71.分析物联网检材，木马程序会窃取文档暂存在隐藏目录，这个目录的绝对路径？（/root/root/）

/tmp/.cache/

看恶意程序

72. 分析物联网检材，木马程序将数据上传到的服务器的IP地址是多少？（答案格式：1.1.1.1）

185.199.108.153

由之前的得到ip

73. 根据木马程序，它监视的关键字是什么？（答案格式：按照实际情况填写）

Project Dragonfire

移动终端取证分析

74.分析检材中微信ID:wxid_f4s0jmpvrc522对应的手机号后四位为（答案格式：1111）

8390

提取uin计算密钥并解密数据库

导出文件

解密

75. 分析检材中”华为应用市场”第一次安装日期为（使用双位数格式，答案格式：01月01日）

09月24日

找到包的按照时间戳

75.找出检材中钱包APP，请列出该APP中ETH地址后六位是（字母全大写，答案格式：AAAAAA）

3FE61F

下载了imtoken的app

打开数据库看到ETH地址0x304fEd2927f47692E50158A1148a1B65503FE61F

77.分析出检材中包含”南昌西站”的图片，计算该图片的MD5后六位？（字母全大写，答案格式：AAAAAA）

85A51D

在相册文件中找到

78.手机相册中有张”imtoken助记词1.PNG”图片被破坏，请修复该图片，列出该图片中第三个单词。（答案格式：按照实际情况填写）

boost

xfw过滤imtoken助记词*，得到1和2，1随波逐流一把梭出修复后图片

79.找出一张PNG图片，该图片上显示”助记词2”，请列出该图片上显示的第二个单词。（答案格式：按照实际情况填写）

delay

80.找出检材中显示”助记词3”的文档，列出该文档中记录的第三个助记词单词。（答案格式：按照实际情况填写）

quarter

xfw暴力搜索

82.分析出该组助记词正常顺序中最后一个单词（已知助记词1、助记词2、助记词3中的单词顺序有被调整）。（答案格式：按照实际情况填写）

segment

知道助记词和地址，可以还原助记词顺序

82. 分析出邮箱中收件人QQ号为”850563586”的姓名（答案格式：按照实际情况填写）

刘佳雨

先找到QQ的uid u_mq61uhp6gZE49O_lq9Hvtg

然后解密用户数据库

83.得知机主通过某个应用给HHshAL发送了一个文档，该应用的数据包名是什么？（答案格式：com.test）

dingtong.saichuang

在data中发现一个奇怪的app

他的数据库是加密的，根据之后的题目可以确实是这个app

84. 接上题，该应用聊天记录数据库的打开密码是什么？（答案格式：按照实际情况填写）

@1@#!aajsk1*JKJ

找到对应的apk文件

猜测为密码

85. 接上题，机主发送的这个加密文档，打开密码是什么？（答案格式：按照实际情况填写）

找到聊天记录中的密码

decode得到QWERT666

86. 厉明的身份证地址登记的门牌号是多少？？（答案格式：1）

722

过滤*身份证*

找到其对应的应用数据库，得到两个密码

解压mxt文件得到门牌号

87.分析出”important1.xlsx”文件中体现的”金达欣”银行卡后六位？（答案格式：111111）

935629

88.接上题，保存”important1.xlsx”打开密码数据的应用，该应用的启动密码是什么？（答案格式：按照实际情况填写）

1596

学习川佬2025数证杯初赛 - WXjzc - 博客园

hawk解密分析 - WXjzc - 博客园

数据分析

89.通过对检材”01-lott.sql”文件进行分析，统计庄家”188”在2021-05-10当日的电子投注总笔数（答案格式：1）

2299

t_trade_betrecord是投注记录表

90.通过对检材”01-lott.sql”文件进行分析，统计t_trade_betrecord中庄家”188”记录中彩票类型为”jnd28”且期号在t_lottery_jnd表中存在的记录数。（答案格式：1）

92842

91.通过对检材”01-lott.sql”文件进行分析，统计庄家”188”的玩家在2021-05-10当日：电子投注内容出现频率最高的电子投注内容是什么？（答案格式：按照实际情况填写）

500单

92.通过对检材”01-lott.sql”文件进行分析，关联t_trade_betrecord与t_lottery_jnd表，分析庄家”188”在2021-05-10投注”jnd28”时：当开奖结果为”大”时，玩家投注包含”小”的笔数占比（使用双位数格式，答案格式：11.11%）

44.88%

select 玩家小/总数 from (
  select
  count(Content) AS 总数,
  SUM(if(INSTR(Content,"小"),1,0)) AS 玩家小
from
  t_trade_betrecord ttb
  left join t_lottery_jnd tlj on ttb.Issue = tlj.Issue
where
  ttb.Keeper = "188"
  and DATE(ttb.CreateTime) = "2021-05-10"
  and ttb.LotteryType = "jnd28"
  and tlj.R_B_M = "大"
) a

93.通过对检材”02-crime_records.sql”分析，统计相邻两次作案时间间隔在1天之内的城市和该城市两次作案时间间隔在1天之内的案件总数量，找出案件总数最多的城市名。（答案格式：按照实际情况填写）

福州

WITH cte AS (
    SELECT
        city,
        STR_TO_DATE(crime_time, '%Y/%m/%d %H:%i') AS crime_dt,
        LAG(STR_TO_DATE(crime_time, '%Y/%m/%d %H:%i'))
            OVER (PARTITION BY city ORDER BY STR_TO_DATE(crime_time, '%Y/%m/%d %H:%i')) AS prev_crime_dt
    FROM crime_records
)
SELECT
    city,
    COUNT(*) AS within_1day_case_pairs
FROM cte
WHERE
    prev_crime_dt IS NOT NULL
    -- 这里用小时来卡 1 天内，更精确
    AND TIMESTAMPDIFF(HOUR, prev_crime_dt, crime_dt) <= 24
    AND TIMESTAMPDIFF(HOUR, prev_crime_dt, crime_dt) >= 0
GROUP BY
    city
ORDER BY
    within_1day_case_pairs DESC
LIMIT 1;

94.通过对检材”02-crime_records.sql”分析，根据案件的损失金额和伤情等级，将案件分为 “轻微案件””一般案件””重大案件””其他”四类（分类规则如下），并统计 2023 年各类型案件的数量。轻微案件：损失金额≤10000 元且无人员受伤（injury_level 为空或未提及）；一般案件：损失金额 10001-50000 元，或有轻微伤；重大案件：损失金额 > 50000 元，或有轻伤或有重伤；其他：非上述情况。（按照案件数量的降序输出答案，答案格式为：40/30/20/10）

15712/2058/1985/222

SELECT
  案件分类,
  COUNT(*) AS 案件数量
FROM (
  SELECT
    CASE
      WHEN loss_amount > 50000
           OR injury_level IN ('轻伤', '重伤') THEN '重大案件'
      WHEN loss_amount BETWEEN 10001 AND 50000
           OR injury_level = '轻微伤' THEN '一般案件'
      WHEN loss_amount <= 10000
           AND injury_level IS NULL THEN '轻微案件'
      ELSE '其他'
    END AS 案件分类
  FROM crime_records
  WHERE YEAR(STR_TO_DATE(crime_time, '%Y/%m/%d %H:%i')) = 2023
) a
GROUP BY 案件分类
ORDER BY 案件数量 DESC;

95.通过对检材”02-crime_records.sql”分析，统计 2021-2023 年期间（含2021年和2023年），每年处理结果为 “移送起诉” 的案件里，每一年中损失总额最高的案件类型对应的损失总额为？（按 2021 - 2023 年顺序连接损失总额，连接符号使用/,小数点保留2位，答案格式为：1.37/2.21/3.45）

325806042.91/344804883.98/352132431.37

select
  年份,
  max(money) AS 损失
from
  (
    select
      YEAR(crime_time) AS 年份,
      crime_type,
      sum(loss_amount) money
    from
      crime_records
    where
      handling_result = "移送起诉"
    group by
      年份,
      crime_type
  ) t
where
  年份 in ("2021", "2022", "2023")
group by
  年份
order by
  年份

文章作者: Sep

文章链接: https://sep252.github.io/2025/11/21/2025%E6%95%B0%E8%AF%81%E6%9D%AF%E5%88%9D%E8%B5%9B/

电子数据取证