085_数字取证进阶技术：磁盘镜像分析与证据提取实战指南——从镜像获取到深度调查的全面剖析

# 创建完整磁盘镜像
sudo dd if=/dev/sdb of=/mnt/external/disk_image.dd bs=4M status=progress

# 同时计算SHA-256校验和
sudo dd if=/dev/sdb bs=4M status=progress | tee /mnt/external/disk_image.dd | sha256sum > /mnt/external/disk_image.sha256

# 目标系统上运行
sudo dd if=/dev/sda bs=4M | nc -l 1234

# 取证工作站上运行
nc target_ip 1234 > disk_image.dd

ftkimager.exe /c /d /e01 /f "D:\evidence\disk_image.e01" /i /log:"D:\evidence\imaging.log" /m SHA-256 \.\PhysicalDrive1

dd if=输入文件 of=输出文件 bs=块大小 [其他参数]

# 创建磁盘镜像并显示进度
sudo dd if=/dev/sdb of=/mnt/external/disk_image.dd bs=4M status=progress

# 同时计算MD5和SHA-256校验和
sudo dd if=/dev/sdb bs=4M status=progress | tee >(md5sum > /mnt/external/disk_image.md5) >(sha256sum > /mnt/external/disk_image.sha256) > /mnt/external/disk_image.dd

# 复制特定分区
sudo dd if=/dev/sdb1 of=/mnt/external/partition1.dd bs=4M status=progress

sudo dd if=/dev/sdb bs=4M status=progress | gzip -c > /mnt/external/disk_image.dd.gz

# 发送方
sudo dd if=/dev/sdb bs=4M | nc -l 1234

# 接收方
nc source_ip 1234 | sudo dd of=/mnt/external/disk_image.dd bs=4M status=progress

# 发送方
sudo dd if=/dev/sdb bs=4M | gzip -c | nc -l 1234

# 接收方
nc source_ip 1234 | gunzip -c | sudo dd of=/mnt/external/disk_image.dd bs=4M status=progress

# Debian/Ubuntu系统
sudo apt-get install autopsy sleuthkit

# CentOS/RHEL系统
sudo yum install autopsy sleuthkit

# 使用Homebrew安装
brew install --cask autopsy

# 查看磁盘分区表
mmls disk_image.dd

# 分析特定分区的文件系统
fsstat -o 2048 disk_image.dd

# 列出根目录内容（包括已删除文件）
fls -o 2048 -r disk_image.dd

# 从inode提取文件内容
icat -o 2048 disk_image.dd 1234 > recovered_file.txt

# 查找并恢复所有已删除的文本文件
fls -o 2048 -d -r disk_image.dd | grep "txt" | awk '{print $2}' | xargs -I {} icat -o 2048 disk_image.dd {} > recovered_{}.txt

# 在未分配空间中搜索关键词
blkls -o 2048 disk_image.dd | grep -i "password"

# 创建基本时间线
fls -o 2048 -r -m / disk_image.dd > bodyfile.txt
mactime -b bodyfile.txt > timeline.html

#!/bin/bash
# 自动化磁盘镜像分析脚本

IMAGE="disk_image.dd"
OUTPUT_DIR="analysis_results"
OFFSET=2048

# 创建输出目录
mkdir -p $OUTPUT_DIR

# 步骤1: 保存分区表信息
mmls $IMAGE > $OUTPUT_DIR/partition_table.txt

# 步骤2: 获取文件系统统计
fsstat -o $OFFSET $IMAGE > $OUTPUT_DIR/fs_stat.txt

# 步骤3: 列出所有文件（包括已删除）
fls -o $OFFSET -r -m / $IMAGE > $OUTPUT_DIR/all_files.txt

# 步骤4: 创建时间线
mactime -b $OUTPUT_DIR/all_files.txt > $OUTPUT_DIR/timeline.html

# 步骤5: 提取用户目录下的文件
mkdir -p $OUTPUT_DIR/user_files
fls -o $OFFSET -r -p -m / disk_image.dd | grep -i "home\|user" > $OUTPUT_DIR/user_files_list.txt

# 步骤6: 搜索关键词
blkls -o $OFFSET $IMAGE | grep -i "password\|secret\|key" > $OUTPUT_DIR/keywords_found.txt

echo "分析完成，结果保存在 $OUTPUT_DIR 目录"

# 基本用法
foremost -t jpg,pdf,doc -i disk_image.dd -o recovery_output

# 常用参数
# -t: 指定要恢复的文件类型
# -i: 输入镜像文件
# -o: 输出目录

# 启动交互式界面
photorec disk_image.dd

# 或使用命令行模式
photorec /log /d recovery_output disk_image.dd

# 提取所有可打印字符串
strings disk_image.dd > extracted_strings.txt

# 过滤和搜索特定字符串
strings disk_image.dd | grep -i "password\|login\|secret" > keywords.txt

# 提取长字符串，可能包含有价值信息
strings -n 10 disk_image.dd > long_strings.txt

# 分析MFT文件
MFTECmd.exe -f \path\to\$MFT -o output_directory

# 创建超级时间线
log2timeline.py timeline.plaso disk_image.dd
psort.py -o l2tcsv timeline.plaso > timeline.csv

# 提取所有类型的元数据和特征
bulk_extractor -o output_dir disk_image.dd

# 提取时间线数据
log2timeline.py timeline.plaso disk_image.dd

# 生成CSV格式时间线
psort.py -o l2tcsv timeline.plaso > timeline.csv

# 按时间顺序排序并过滤特定时间范围
psort.py -o l2tcsv -q "date >= '2025-01-01' AND date <= '2025-01-31'" timeline.plaso > filtered_timeline.csv

# 从bodyfile生成HTML时间线
mactime -b bodyfile.txt -d > timeline.html

# 生成CSV格式时间线
mactime -b bodyfile.txt -y 2 > timeline.csv

# 在Windows中使用dir命令
 dir /r

# 使用专用工具 streams
tools\streams.exe -s C:\evidence

# 在Linux中使用ntfsstreams
ntfsstreams -l /mnt/windows_volume

# 使用bulk_extractor提取Slack空间
bulk_extractor -o output_dir -S slacker=yes disk_image.dd

# 使用Autopsy的Slack空间分析功能
# 在文件视图中启用Slack空间显示

# 使用blkls提取未分配块
blkls -o 2048 disk_image.dd > unallocated_blocks.raw

# 使用strings搜索未分配空间中的字符串
strings unallocated_blocks.raw > unallocated_strings.txt

# 在Windows中使用more命令
more < file.txt:secret_data > extracted_data.txt

# 使用专用工具提取
streams -s -d C:\evidence

# 从镜像中提取浏览器历史
BrowserHistoryView.exe /LoadFromExternalDrive "E:\evidence" /scomma "output\browser_history.csv"

# 分析Chrome历史记录
log2timeline.py --parsers chrome_history timeline.plaso "E:\evidence\Users\username\AppData\Local\Google\Chrome\User Data\Default\History"

# 使用RECmd提取网络配置
RECmd.exe -f "E:\evidence\Windows\System32\config\SYSTEM" -o "output\network_config" --plugin "NetworkProfileList"

# 提取Linux网络配置
icat -o 2048 disk_image.dd 1234 > /etc/network/interfaces
cat /etc/network/interfaces

#!/usr/bin/env python3
# 网络证据自动化提取脚本

import os
import subprocess
import datetime

output_dir = f"network_evidence_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}"
os.makedirs(output_dir, exist_ok=True)

# 配置参数
disk_image = "disk_image.dd"
offset = 2048
user_profile = "Users/username"

# 提取浏览器数据
print("提取浏览器数据...")
os.makedirs(f"{output_dir}/browser_data", exist_ok=True)

# 提取Chrome历史记录
browser_history_inode = "123456"  # 需要根据实际情况调整
subprocess.run([
    "icat", "-o", str(offset), disk_image, browser_history_inode, 
    ">", f"{output_dir}/browser_data/chrome_history.db"
], shell=True)

# 提取Firefox历史记录
firefox_history_inode = "123457"  # 需要根据实际情况调整
subprocess.run([
    "icat", "-o", str(offset), disk_image, firefox_history_inode,
    ">", f"{output_dir}/browser_data/firefox_places.sqlite"
], shell=True)

# 提取网络配置文件
print("提取网络配置文件...")
os.makedirs(f"{output_dir}/network_config", exist_ok=True)

# 提取Windows网络配置
if os.path.exists("/mnt/windows"):
    subprocess.run([
        "cp", "/mnt/windows/Windows/System32/drivers/etc/hosts", 
        f"{output_dir}/network_config/hosts"
    ])

# 提取电子邮件数据
print("提取电子邮件数据...")
os.makedirs(f"{output_dir}/email_data", exist_ok=True)

# 执行Plaso分析
print("使用Plaso分析网络相关数据...")
plaso_output = f"{output_dir}/plaso_timeline.plaso"
subprocess.run([
    "log2timeline.py", "--parsers", "chrome_history,firefox_history,webhist",
    plaso_output, disk_image
])

# 生成网络相关事件时间线
subprocess.run([
    "psort.py", "-o", "l2tcsv", 
    "-q", "source_short IN ('CHROME', 'FIREFOX', 'WEBHIST')",
    plaso_output, ">", f"{output_dir}/network_events.csv"
], shell=True)

print(f"网络证据提取完成，结果保存在 {output_dir} 目录")

# 从内存中提取DLL文件哈希
volatility -f memory.dmp --profile=Win10x64 dlllist | grep -i "system32" | awk '{print $6}' > memory_dll_hashes.txt

# 计算磁盘上相应文件的哈希
find /mnt/windows/Windows/System32 -name "*.dll" -exec sha256sum {} \; > disk_dll_hashes.txt

# 比对哈希值查找差异
grep -v -f memory_dll_hashes.txt disk_dll_hashes.txt > differences.txt

# 从内存中提取网络连接
volatility -f memory.dmp --profile=Win10x64 netscan > memory_netscan.txt

# 从磁盘镜像中提取网络日志
icat -o 2048 disk_image.dd 12345 > windows_event_log.evtx

# 使用工具分析并关联这两类数据

#!/usr/bin/env python3
# 内存与磁盘关联分析脚本

import os
import subprocess
import re
from datetime import datetime

# 配置
memory_dump = "memory.dmp"
disk_image = "disk_image.dd"
offset = 2048
profile = "Win10x64"
output_dir = f"memory_disk_correlation_{datetime.now().strftime('%Y%m%d_%H%M%S')}"

os.makedirs(output_dir, exist_ok=True)

print("提取内存中的进程信息...")
# 提取进程列表
subprocess.run([
    "volatility", "-f", memory_dump, f"--profile={profile}", "pslist", 
    ">", f"{output_dir}/memory_processes.txt"
])

print("提取内存中的网络连接...")
# 提取网络连接
subprocess.run([
    "volatility", "-f", memory_dump, f"--profile={profile}", "netscan", 
    ">", f"{output_dir}/memory_network_connections.txt"
])

print("在磁盘镜像中查找相关文件...")
# 获取系统目录中的可执行文件列表
subprocess.run([
    "fls", "-o", str(offset), "-r", "-m", "/", disk_image, 
    "|", "grep", "\\\\\\\\\\\\.exe\\\\$\\\\|\\\\\\\\\\\\.dll\\\\$",
    ">", f"{output_dir}/disk_executables.txt"
], shell=True)

print("分析进程与文件关联...")
# 提取进程加载的DLL
subprocess.run([
    "volatility", "-f", memory_dump, f"--profile={profile}", "dlllist", 
    ">", f"{output_dir}/memory_dlllist.txt"
])

print("创建关联报告...")
# 这里可以添加更复杂的分析逻辑
# 例如：提取可疑进程，在磁盘中查找对应文件，计算哈希值等

print(f"分析完成，结果保存在 {output_dir} 目录")

# 挂载VMDK文件
vmware-mount.exe X: "C:\path\to\disk.vmdk"

# 卸载
vmware-mount.exe /d X:

# 转换虚拟磁盘格式
qemu-img convert -f vmdk -O raw disk.vmdk disk.raw

# 检查虚拟磁盘信息
qemu-img info disk.vmdk

# 克隆虚拟磁盘
VBoxManage clonehd disk.vdi disk_copy.vdi --format VDI

# 调整虚拟磁盘大小
VBoxManage modifyhd disk.vdi --resize 10240

#!/usr/bin/env python3
# 高级磁盘镜像分析脚本

import os
import subprocess
import json
import hashlib
from datetime import datetime

class DiskForensicsAnalyzer:
    def __init__(self, disk_image, offset=0, output_dir=None):
        self.disk_image = disk_image
        self.offset = offset
        self.timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        self.output_dir = output_dir or f"forensics_output_{self.timestamp}"
        os.makedirs(self.output_dir, exist_ok=True)
        
    def extract_partition_table(self):
        print("提取分区表信息...")
        output_path = os.path.join(self.output_dir, "partition_table.txt")
        cmd = f"mmls -o {self.offset} {self.disk_image} > {output_path}"
        subprocess.run(cmd, shell=True)
        return output_path
    
    def analyze_file_system(self, partition_offset=None):
        print("分析文件系统信息...")
        effective_offset = partition_offset or self.offset
        output_path = os.path.join(self.output_dir, f"fs_stat_offset_{effective_offset}.txt")
        cmd = f"fsstat -o {effective_offset} {self.disk_image} > {output_path}"
        subprocess.run(cmd, shell=True)
        return output_path
    
    def extract_file_list(self, partition_offset=None):
        print("提取文件列表（包括已删除文件）...")
        effective_offset = partition_offset or self.offset
        output_path = os.path.join(self.output_dir, f"file_list_offset_{effective_offset}.txt")
        cmd = f"fls -o {effective_offset} -r -m / {self.disk_image} > {output_path}"
        subprocess.run(cmd, shell=True)
        return output_path
    
    def create_timeline(self, file_list_path):
        print("创建时间线...")
        output_path = os.path.join(self.output_dir, "timeline.html")
        cmd = f"mactime -b {file_list_path} -d > {output_path}"
        subprocess.run(cmd, shell=True)
        return output_path
    
    def extract_key_files(self, patterns, partition_offset=None):
        print("提取关键文件...")
        effective_offset = partition_offset or self.offset
        key_files_dir = os.path.join(self.output_dir, "key_files")
        os.makedirs(key_files_dir, exist_ok=True)
        
        file_list_path = self.extract_file_list(effective_offset)
        results = []
        
        with open(file_list_path, 'r') as f:
            for line in f:
                for pattern in patterns:
                    if pattern.lower() in line.lower():
                        try:
                            parts = line.split('|')
                            if len(parts) >= 3:
                                inode = parts[0].strip().split()[0] if '(' in parts[0] else parts[0].strip()
                                filename = parts[2].strip()
                                # 提取文件
                                safe_filename = "_".join(filename.split(os.path.sep)).strip('_')[:100]
                                output_file = os.path.join(key_files_dir, f"inode_{inode}_{safe_filename}")
                                cmd = f"icat -o {effective_offset} {self.disk_image} {inode} > {output_file}"
                                subprocess.run(cmd, shell=True)
                                # 计算哈希
                                if os.path.exists(output_file):
                                    with open(output_file, 'rb') as f_hash:
                                        file_hash = hashlib.sha256(f_hash.read()).hexdigest()
                                    results.append({
                                        'inode': inode,
                                        'filename': filename,
                                        'extracted_path': output_file,
                                        'sha256': file_hash
                                    })
                        except Exception as e:
                            print(f"处理行时出错: {line}. 错误: {e}")
        
        # 保存结果
        results_json = os.path.join(self.output_dir, "key_files_results.json")
        with open(results_json, 'w') as f:
            json.dump(results, f, indent=2)
            
        return results_json
    
    def search_keywords(self, keywords, partition_offset=None):
        print("搜索关键词...")
        effective_offset = partition_offset or self.offset
        output_path = os.path.join(self.output_dir, "keyword_search_results.txt")
        
        # 提取未分配空间
        unallocated_path = os.path.join(self.output_dir, "unallocated.raw")
        cmd = f"blkls -o {effective_offset} {self.disk_image} > {unallocated_path}"
        subprocess.run(cmd, shell=True)
        
        # 搜索关键词
        with open(output_path, 'w') as f:
            for keyword in keywords:
                f.write(f"\n=== 搜索关键词: {keyword} ===\n")
                cmd = f"strings {unallocated_path} | grep -i '{keyword}'"
                result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
                f.write(result.stdout)
                
        return output_path
    
    def generate_report(self):
        print("生成分析报告...")
        report_path = os.path.join(self.output_dir, "forensics_report.md")
        
        with open(report_path, 'w') as f:
            f.write(f"# 磁盘镜像取证分析报告\n\n")
            f.write(f"生成时间: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
            f.write(f"分析镜像: {self.disk_image}\n\n")
            f.write(f"偏移量: {self.offset}\n\n")
            
            f.write("## 分析结果\n\n")
            
            # 列出所有生成的文件
            f.write("### 生成的文件\n\n")
            for root, _, files in os.walk(self.output_dir):
                for file in files:
                    if file != "forensics_report.md":
                        rel_path = os.path.relpath(os.path.join(root, file), self.output_dir)
                        f.write(f"- [{rel_path}]({rel_path})\n")
            
            # 可根据需要添加更多报告内容
            f.write("\n## 结论\n\n")
            f.write("本报告提供了磁盘镜像的初步分析结果。详细发现需要进一步人工审查。\n")
        
        return report_path

# 使用示例
if __name__ == "__main__":
    analyzer = DiskForensicsAnalyzer(
        disk_image="disk_image.dd",
        offset=2048
    )
    
    analyzer.extract_partition_table()
    analyzer.analyze_file_system()
    file_list = analyzer.extract_file_list()
    analyzer.create_timeline(file_list)
    
    # 提取关键文件
    key_patterns = ["password", "config", "log", "database", "certificate"]
    analyzer.extract_key_files(key_patterns)
    
    # 搜索关键词
    keywords = ["password", "secret", "admin", "login", "key"]
    analyzer.search_keywords(keywords)
    
    # 生成报告
    report = analyzer.generate_report()
    print(f"分析完成！报告保存在: {report}")

# 磁盘镜像分析PowerShell脚本

param(
    [string]$DiskImage,
    [int]$Offset = 0,
    [string]$OutputDir = $null
)

# 设置输出目录
if (-not $OutputDir) {
    $timestamp = Get-Date -Format "yyyyMMdd_HHmmss"
    $OutputDir = "forensics_output_$timestamp"
}

New-Item -ItemType Directory -Force -Path $OutputDir | Out-Null
Write-Host "输出目录: $OutputDir"

# 函数: 提取分区表
function Extract-PartitionTable {
    param(
        [string]$Image,
        [int]$ImgOffset,
        [string]$OutputPath
    )
    
    Write-Host "提取分区表信息..."
    & mmls -o $ImgOffset $Image | Out-File -FilePath $OutputPath -Encoding utf8
    return $OutputPath
}

# 函数: 提取文件列表
function Extract-FileList {
    param(
        [string]$Image,
        [int]$ImgOffset,
        [string]$OutputPath
    )
    
    Write-Host "提取文件列表..."
    & fls -o $ImgOffset -r -m / $Image | Out-File -FilePath $OutputPath -Encoding utf8
    return $OutputPath
}

# 函数: 搜索关键词
function Search-Keywords {
    param(
        [string]$Image,
        [int]$ImgOffset,
        [string[]]$Keywords,
        [string]$OutputPath
    )
    
    Write-Host "搜索关键词..."
    $unallocatedPath = Join-Path $OutputDir "unallocated.raw"
    
    # 提取未分配空间
    & blkls -o $ImgOffset $Image | Out-File -FilePath $unallocatedPath -Encoding ascii
    
    # 搜索每个关键词
    "" | Out-File -FilePath $OutputPath -Encoding utf8
    foreach ($keyword in $Keywords) {
        Write-Host "  搜索: $keyword"
        "`n=== 搜索关键词: $keyword ===" | Out-File -FilePath $OutputPath -Encoding utf8 -Append
        & strings $unallocatedPath | Select-String -Pattern $keyword -CaseSensitive:$false | 
            Out-File -FilePath $OutputPath -Encoding utf8 -Append
    }
    
    return $OutputPath
}

# 主流程
Write-Host "开始磁盘镜像分析..."

# 提取分区表
$partitionTablePath = Join-Path $OutputDir "partition_table.txt"
Extract-PartitionTable -Image $DiskImage -ImgOffset $Offset -OutputPath $partitionTablePath

# 分析文件系统
$fsStatPath = Join-Path $OutputDir "fs_stat.txt"
& fsstat -o $Offset $DiskImage | Out-File -FilePath $fsStatPath -Encoding utf8

# 提取文件列表
$fileListPath = Join-Path $OutputDir "file_list.txt"
Extract-FileList -Image $DiskImage -ImgOffset $Offset -OutputPath $fileListPath

# 创建时间线
$timelinePath = Join-Path $OutputDir "timeline.html"
Write-Host "创建时间线..."
& mactime -b $fileListPath -d | Out-File -FilePath $timelinePath -Encoding utf8

# 搜索关键词
$keywords = @("password", "secret", "admin", "login", "key")
$searchResultsPath = Join-Path $OutputDir "keyword_search_results.txt"
Search-Keywords -Image $DiskImage -ImgOffset $Offset -Keywords $keywords -OutputPath $searchResultsPath

# 生成报告
$reportPath = Join-Path $OutputDir "forensics_report.md"
Write-Host "生成分析报告..."

@"
# 磁盘镜像取证分析报告

生成时间: $(Get-Date -Format "yyyy-MM-dd HH:mm:ss")

分析镜像: $DiskImage

偏移量: $Offset

## 分析结果

### 生成的文件
"@ | Out-File -FilePath $reportPath -Encoding utf8

Get-ChildItem -Path $OutputDir -Recurse -File | Where-Object { $_.Name -ne "forensics_report.md" } | 
    ForEach-Object {
        $relPath = Resolve-Path -Path $_.FullName -Relative
        "- [$relPath]($relPath)" | Out-File -FilePath $reportPath -Encoding utf8 -Append
    }

@"

## 结论

本报告提供了磁盘镜像的初步分析结果。详细发现需要进一步人工审查。
"@ | Out-File -FilePath $reportPath -Encoding utf8 -Append

Write-Host "分析完成！报告保存在: $reportPath"

#!/bin/bash
# 磁盘镜像取证分析bash脚本

set -e

echo "磁盘镜像取证分析脚本"
echo "======================="

# 参数处理
DISK_IMAGE=""
OFFSET=0
OUTPUT_DIR=""

while getopts "i:o:f:h" opt; do
  case $opt in
    i) DISK_IMAGE="$OPTARG" ;;
    o) OFFSET="$OPTARG" ;;
    f) OUTPUT_DIR="$OPTARG" ;;
    h) echo "用法: $0 -i <磁盘镜像> -o <偏移量> -f <输出目录>" && exit 0 ;;
    *) echo "用法: $0 -i <磁盘镜像> -o <偏移量> -f <输出目录>" && exit 1 ;;
  esac
done

# 检查必要参数
if [ -z "$DISK_IMAGE" ]; then
  echo "错误: 必须指定磁盘镜像文件"
  exit 1
fi

# 设置默认输出目录
if [ -z "$OUTPUT_DIR" ]; then
  TIMESTAMP=$(date +"%Y%m%d_%H%M%S")
  OUTPUT_DIR="forensics_output_$TIMESTAMP"
fi

# 创建输出目录
mkdir -p "$OUTPUT_DIR"
echo "输出目录: $OUTPUT_DIR"

# 函数: 提取分区表
extract_partition_table() {
  local output_path="$OUTPUT_DIR/partition_table.txt"
  echo "提取分区表信息..."
  mmls -o "$OFFSET" "$DISK_IMAGE" > "$output_path"
  return 0
}

# 函数: 提取文件列表
extract_file_list() {
  local output_path="$OUTPUT_DIR/file_list.txt"
  echo "提取文件列表..."
  fls -o "$OFFSET" -r -m / "$DISK_IMAGE" > "$output_path"
  return 0
}

# 函数: 搜索关键词
search_keywords() {
  local keywords=($@)
  local output_path="$OUTPUT_DIR/keyword_search_results.txt"
  local unallocated_path="$OUTPUT_DIR/unallocated.raw"
  
  echo "搜索关键词..."
  
  # 提取未分配空间
  blkls -o "$OFFSET" "$DISK_IMAGE" > "$unallocated_path"
  
  # 清空输出文件
  > "$output_path"
  
  # 搜索每个关键词
  for keyword in "${keywords[@]}"; do
    echo "  搜索: $keyword"
    echo -e "\n=== 搜索关键词: $keyword ===" >> "$output_path"
    strings "$unallocated_path" | grep -i "$keyword" >> "$output_path"
  done
  
  return 0
}

# 主流程
echo "开始磁盘镜像分析..."

# 提取分区表
extract_partition_table

# 分析文件系统
echo "分析文件系统..."
fsstat -o "$OFFSET" "$DISK_IMAGE" > "$OUTPUT_DIR/fs_stat.txt"

# 提取文件列表
extract_file_list

# 创建时间线
echo "创建时间线..."
mactime -b "$OUTPUT_DIR/file_list.txt" -d > "$OUTPUT_DIR/timeline.html"

# 搜索关键词
search_keywords "password" "secret" "admin" "login" "key"

# 生成报告
echo "生成分析报告..."
cat > "$OUTPUT_DIR/forensics_report.md" << EOF
# 磁盘镜像取证分析报告

生成时间: $(date +"%Y-%m-%d %H:%M:%S")

分析镜像: $DISK_IMAGE

偏移量: $OFFSET

## 分析结果

### 生成的文件
EOF

# 添加文件列表
find "$OUTPUT_DIR" -type f -not -path "*forensics_report.md*" | sort | while read file; do
  rel_path=$(realpath --relative-to="$OUTPUT_DIR" "$file")
  echo "- [$rel_path]($rel_path)" >> "$OUTPUT_DIR/forensics_report.md"
done

# 添加结论
cat >> "$OUTPUT_DIR/forensics_report.md" << EOF

## 结论

本报告提供了磁盘镜像的初步分析结果。详细发现需要进一步人工审查。
EOF

echo "分析完成！报告保存在: $OUTPUT_DIR/forensics_report.md"