第二届“数证杯”电子数据取证分析大赛-计算机取证wp

题

开局给到一个什么后缀也不是文件，也没说使用啥打开，这里简单讲一下，怎么将环境运行起来，在进行做题。

首先用这vera加载下载到的镜像文件，密码已经给了。

容器密码：GQ7aXryvOCM8qGeXa19K9g&jtHSGtrimps@QxaYt4oRwwKHeN0A$#EPv*u

此时就会给电脑挂载一个盘

这里就会看到个个，文件，随便打开一个 这里会看到所有检材，这里可以看到

文件都是E01的后缀，用ftk捣鼓了半天，挂载上，vm打不开，最后试了一下Arsenal Image Mounter，没问题。

这样挂载到盘上后，新建一个虚拟机，这里看到

这个是是物理磁盘3，一会会用到

管理员打开vmware 然后创建一个虚拟机，机器类型选对即可，然后这个磁盘的时候用物理磁盘，

选择你点那个盘号，其他默认即可。

好，接下来就可以看到熟悉的界面了，

这个时候我们会发现，并没用给我们密码，赛事找了一圈，也没有找到密码，登不上去的话，只能用工具取证了，此时我们回到ftk，ftk 能找到。file->add evidence item ->image file选择你的镜像文件即可

然后点这个很多mb的文件

就可以看到机器相关目录了。接下来，找到网上文章mimikatz离线导出hash，路径在C:\Windows\System32\config，需要两个文件，SAM,SYSTEM

PS D:\tools\Neiwang\mimikatz_trunk\x64> .\mimikatz.exe

文件放到mimikatz下，lsadump::sam /sam:sam /system:system

即可获取到hash

计算机取证分析
请根据计算机检材和内存检材，回答以下问题：

41、

操作系统的Build版本号是？（答案格式：1）（ ）
考生答案：
请输入答案

42、

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

43、

用户2登陆密码NT哈希值后六位是？（字母全大写，答案格式：AAAAAA）（ ）
考生答案：
请输入答案
mimikatz中已获取到，

44、

蓝牙mac地址是多少？（答案格式：AA-AA-AA-AA-AA-AA）（ ）
考生答案：
这里看了下其他同学的答案都是从取证工具中获取的，这里也可以从设备管理器中获取。打开设备管理器，查看隐藏的设备，软件设备中有一个蓝牙，属性查看设备实力路径就是了
未保存

45、

SafeImager的产品序列号后四位是？（字母全大写，答案格式：AAAAAA）（ ）
考生答案：
请输入答案

46、

123.VHD所处的结束扇区是？（答案格式：1 ）（ ）
考生答案：
请输入答案

47、

用户在BitLocker加密分区最后修改的文件是?（答案格式：abcd.txt）（ ）
考生答案：
请输入答案
这里需要先解bitlocker ，密码在上面的 vhd中，直接双击这个,会挂载一个盘，

进到backup中，可以看到bitlocker恢复密钥文件，复制里面密钥。这里先不要在虚拟机里解，需要现在物理机解，不然会报错，因为挂载盘的软件识别不了，

解开后，就可以访问盘了 资料1.txt

48、

用户连接192.168.114.129时用的会话名称是？（答案格式：按照实际情况填写）（ ）
考生答案：
请输入答案
在我们登录到电脑上的时候会发现 xshell和foxmail都是 白色的快捷方式，说明在d盘中，d盘被加密了，所以读取不到文件，我们解开后，打开xshell即可得到连接名

49、

用户创建存储虚拟币钱包地址页面的时间是？（使用双位数格式，答案格式：01月01日）（ ）
考生答案：
请输入答案
anytype是相当于记事本的东西，这里直接可以打开可以看到相关信息

10月07日

50、

用户的虚拟币钱包地址是？（答案格式：按照实际情况填写）（ ）
考生答案：
请输入答案
VkZSQ2IyVldjRWxSYkdoVlZrZG9hRmt5ZEV0V01sSTJZa1JXYTFaSGFIaGFWVkpIVlRKSmQwNVZPVlJsYkhCRVZqSTFiMDB5VFhkaFIzUlFWVlF3T1E9PQ==

四次base64即可，

51、

用户VC加密容器的密码是？（答案格式：按照实际情况填写）（ ）
考生答案：
请输入答案

解密软件的时候会报

肯定是还有碎片，5在用户2上，登不上去？直接提也可以 ，公司资料里给了密码

软件4死活提不出来，最后分析发现

其实还是在机器上的，我们分析公司资料里的文件

其实是有密码的，在用户1里面发现part4在垃圾桶里，裂开

什么 你说mimikatz都抓出ntlm了，直接解不就可以了，显然

没钱寸步难行。

没事 记一下，f37055ca991018adfcc9cfedcfe39e58:2025szb

到这里你会发现，还是提取不了，为什么呢，仔细看，这里你会发现part4为zip，但是所有的其他part都是rar，且切片大小也不一样，有可能需要解压缩啥的，或者隐写么，笔者这里尝试了都，发现还是不对，那么还是回到机器里，这个可能是假的，那么，我们直接下载一个everything 搜

终于在这个路径发现了，到这里五个分片也就找到了，直接解压即可。这个路径是 VMware 的拖放（Drag and Drop）临时文件夹 路径。也就是说part4有一个是假的，这个路径的为真。解压出来为一个docx和decrypto.exe，用这个exe解docx报错，直接打开docx即可，往下拖文章有一个空页，经典misc隐写，白色字体，转成其他颜色即可。

52、

用户在生活中使用的代号是？（答案格式：按照实际情况填写）（ ）
考生答案：
请输入答案
桌面上就有个代号，但是听不出来什么，直接拖到au里看频谱图即可，经典音频杂项

53、

李安东的银行卡归属哪个银行？（答案格式：农业银行）（ ）
考生答案：
请输入答案
公司资料里有银行卡密码，给了提示，需要爆破6位数字

这里可以看到爆破这个密码100w的xlsx密码需要5个小时之多，而比赛总共的时间也就五个小时，所以还是感觉爆破是不可能的，那么笔者这里研究，刚刚解开的的part里面有一个程序没有用到，但是是一个解密的文件，刚好是可以解密的

但是 解出来后打开乱码，是一个dec的文件，那么就看看这个exe有没有什么可以用到的，一看就是python的exe，解就可以了

import os
import sys
import tkinter as tk
from tkinter import filedialog, messagebox
from Crypto.Cipher import AES
import hashlib
import time
import random

class DecryptionToolDebug:
    def __init__(self):
        self._generate_key()

    def _log(self, *args):
        print(*args)  # 控制台打印

    def _generate_key(self):
        seed_values = [(19, 7, 83), (5, 31, 69), (13, 11, 86), (41, 3, 76),
                       (2, 57, 55), (23, 5, 96), (17, 13, 58), (29, 7, 94),
                       (11, 19, 102), (7, 17, 42), (43, 3, 48), (37, 11, 51),
                       (3, 43, 52), (59, 7, 53), (47, 5, 54)]
        key_parts = []
        for idx, (a, b, base) in enumerate(seed_values):
            val = (a * b % 60 + base) % 256
            val = (val + 13) % 256 if val % 2 == 0 else (val + 7) % 256
            key_parts.append(chr(val))
            self._log(f"[_generate_key] idx={idx} a={a} b={b} base={base} val={val} char={repr(chr(val))}")

        indices = [3, 7, 2, 12, 0, 11, 5, 14, 9, 1, 6, 4, 10, 8, 13]
        scrambled = [key_parts[i] for i in indices]
        raw_key = ''.join(scrambled)
        self._log("[_generate_key] scrambled chars:", scrambled)
        self._log("[_generate_key] raw_key:", repr(raw_key))

        timestamp = int(time.time()) % 1000
        random_val = random.randint(1, 255)
        entropy = chr(timestamp % 256) + chr(random_val)
        self._log("[_generate_key] timestamp:", timestamp, "random_val:", random_val, "entropy:", repr(entropy))

        temp_key = hashlib.sha256((raw_key + entropy).encode()).digest()
        self._log("[_generate_key] temp_key sha256:", temp_key.hex())
        self._descramble_key(temp_key)

    def _descramble_key(self, temp_key):
        mixed_base = b''.join([bytes([b ^ 42]) for b in temp_key[:10]])
        self._log("[_descramble_key] mixed_base:", mixed_base.hex())
        actual_key = 'SecureKey123456'
        self._log("[_descramble_key] actual_key:", actual_key)
        self.enhanced_key = self.enhance_key(actual_key)

    def enhance_key(self, key):
        self._log("[enhance_key] input key:", repr(key))
        round1 = self._add_salt(key)
        self._log("[enhance_key] round1 (_add_salt):", repr(round1))
        round2 = self._ascii_transform(round1)
        self._log("[enhance_key] round2 (_ascii_transform):", repr(round2))
        round3 = self._xor_transform(round2)
        self._log("[enhance_key] round3 (_xor_transform):", repr(round3))
        round4 = round3[::-1]
        self._log("[enhance_key] round4 (reversed):", repr(round4))
        final_key = hashlib.md5(round4.encode()).digest()
        self._log("[enhance_key] final_key md5:", final_key.hex())
        return final_key

    def _add_salt(self, key):
        return key + 'salt_value'

    def _ascii_transform(self, text):
        result = ''
        for i, ch in enumerate(text):
            ascii_val = ord(ch)
            if i % 3 == 0:
                new_val = (ascii_val + 7) % 256
            elif i % 3 == 1:
                new_val = (ascii_val ^ 15) % 256
            else:
                new_val = (ascii_val * 5) % 256
            result += chr(new_val)
            self._log(f"[_ascii_transform] i={i} orig={ascii_val} new={new_val} char={repr(chr(new_val))}")
        return result

    def _xor_transform(self, text):
        xor_keys = ['XorKey123456789', 'AnotherKey987654']
        result = text
        for ridx, xor_key in enumerate(xor_keys):
            temp = ''
            for i, ch in enumerate(result):
                new_val = ord(ch) ^ ord(xor_key[i % len(xor_key)])
                temp += chr(new_val)
                if i < 5:
                    self._log(f"[_xor_transform] round={ridx} i={i} new_val={new_val} char={repr(chr(new_val))}")
            result = temp
            self._log(f"[_xor_transform] after round {ridx} sample ords:", [ord(c) for c in result[:10]])
        return result

    def unpad_data(self, data):
        padding_length = data[-1]
        self._log("[unpad_data] padding_length:", padding_length)
        return data[:-padding_length]

    def decrypt_file(self, input_file, output_file=None):
        if not output_file:
            output_file = input_file[:-4] if input_file.endswith('.enc') else input_file + '.dec'
        try:
            with open(input_file, 'rb') as f:
                file_data = f.read()
            self._log("[decrypt_file] input_file:", input_file, "len:", len(file_data))
            iv = file_data[:16]
            encrypted_data = file_data[16:]
            self._log("[decrypt_file] iv:", iv.hex())
            self._log("[decrypt_file] encrypted_data sample (first 64 bytes):", encrypted_data[:64].hex())
            self._log("[decrypt_file] enhanced_key:", self.enhanced_key.hex())
            cipher = AES.new(self.enhanced_key, AES.MODE_CBC, iv=iv)
            decrypted_padded = cipher.decrypt(encrypted_data)
            self._log("[decrypt_file] decrypted_padded sample:", decrypted_padded[:128].hex())
            decrypted = self.unpad_data(decrypted_padded)
            self._log("[decrypt_file] decrypted sample:", decrypted[:256].hex())
            with open(output_file, 'wb') as f:
                f.write(decrypted)
            self._log("[decrypt_file] written output:", output_file)
            return True, output_file
        except Exception as e:
            self._log("[decrypt_file] Exception:", str(e))
            return False, str(e)

class DecryptionGUI:
    def __init__(self, root):
        self.root = root
        self.root.title('File Decryption Tool Debug')
        self.root.geometry('500x300')
        self.root.resizable(False, False)
        self.decryptor = DecryptionToolDebug()
        self.setup_ui()

    def setup_ui(self):
        file_frame = tk.Frame(self.root, pady=20)
        file_frame.pack(fill='x')
        tk.Label(file_frame, text='Select File to Decrypt:').pack(side='left', padx=10)
        self.file_path = tk.StringVar()
        tk.Entry(file_frame, textvariable=self.file_path, width=30).pack(side='left', padx=5)
        tk.Button(file_frame, text='Browse', command=self.browse_file).pack(side='left', padx=5)

        action_frame = tk.Frame(self.root, pady=20)
        action_frame.pack()
        tk.Button(action_frame, text='Decrypt File', command=self.decrypt_file, bg='#2196F3', fg='white', width=15, height=2).pack(pady=10)

        status_frame = tk.Frame(self.root, pady=10)
        status_frame.pack(fill='x')
        self.status_var = tk.StringVar()
        self.status_var.set('Ready')
        tk.Label(status_frame, textvariable=self.status_var, bd=1, relief=tk.SUNKEN, anchor=tk.W).pack(fill='x', padx=10)

    def browse_file(self):
        filename = filedialog.askopenfilename(title='Select File to Decrypt')
        if filename:
            self.file_path.set(filename)

    def decrypt_file(self):
        file_path = self.file_path.get()
        if not file_path:
            messagebox.showerror('Error', 'Please select a file first!')
            return
        self.status_var.set('Decrypting...')
        self.root.update()
        success, result = self.decryptor.decrypt_file(file_path)
        if success:
            self.status_var.set(f'Decryption complete! Output: {result}')
            messagebox.showinfo('Success', f'File decrypted successfully!\nOutput: {result}')
        else:
            self.status_var.set(f'Decryption failed: {result}')
            messagebox.showerror('Error', f'Decryption failed: {result}')

def main():
    root = tk.Tk()
    app = DecryptionGUI(root)
    root.mainloop()

if __name__ == '__main__':
    main()

代码就是上方的，这里笔者加了调试

也没找到任何相关密码，所以 不太清楚怎么找到的这个数字了，但是笔者感觉99.87%不是爆破出来的。先放到这里吧。在说一点，这个代码在第三届盘古石杯 初赛出现过（苹果应用取证 macOS Apps Forensics）。抄大师傅的一个688561

54、

请分析某市10月6日最高气温是？（答案格式：1）（ ）
考生答案：
请输入答案
公司资料里有

09扣成00保存即可。

55、

用户的BitLocker密码是？（答案格式：按照实际情况填写）（ ）
考生答案：
请输入答案
邮箱里有一个邮件图片没有用到，

zsteg -a ,5202MTJSJBZS 即可 反过来，正解应该是用下载里的那个文件解密。

56、

用户办公室的门禁密码是？（答案格式：按照实际情况填写）（ ）
考生答案：
请输入答案

57、

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

还是那个exe

致谢

最后感谢您读到现在，这篇文章匆忙构成肯定有不周到或描述不正确的地方，期待业界师傅们用各种方式指正勘误。如果您感觉文章写的不错或者工具用起来还行，帮笔者点点stars、给公众号点点关注，先谢谢大家了。

参考

https://mp.weixin.qq.com/s/t0xMaHwgXW_8zAEd_PihrQ
https://blog.csdn.net/xcellencw/article/details/154254103
https://www.cnblogs.com/WXjzc/p/19190900
https://blog.csdn.net/m0_37867238/article/details/154353116
https://www.cnblogs.com/zzpu213/p/19185599

emmm 太菜了
一直在路上

本文章只包含计算机取证部分，很快将更新其他部分。