87_数字取证高级技术：现代数据恢复与文件重建实战指南——从存储原理到高级恢复技术的全面剖析

# 使用dd工具备份损坏的超级块（Linux ext4示例）
sudo dd if=/dev/sda1 of=superblock_backup bs=1024 count=1 skip=32768

# 使用testdisk工具恢复分区表
sudo testdisk /dev/sda

# 使用photorec进行文件签名扫描恢复
photorec /dev/sda

# 简单的文件签名扫描Python示例
import os

def scan_for_file_signatures(disk_image, signatures, output_dir):
    # 定义常见文件签名
    file_signatures = {
        'JPEG': (b'\xFF\xD8\xFF', '.jpg'),
        'PNG': (b'\x89\x50\x4E\x47', '.png'),
        'PDF': (b'%PDF-', '.pdf'),
        'ZIP': (b'PK\x03\x04', '.zip'),
        'DOCX': (b'PK\x03\x04', '.docx'),  # 与ZIP相同，需要进一步验证
    }
    
    # 读取磁盘镜像
    with open(disk_image, 'rb') as f:
        data = f.read()
    
    # 扫描签名
    for file_type, (signature, extension) in file_signatures.items():
        pos = 0
        while True:
            pos = data.find(signature, pos)
            if pos == -1:
                break
            
            # 提取文件（简化版）
            output_file = os.path.join(output_dir, f'found_{file_type}_{pos:08x}{extension}')
            
            # 找到下一个签名位置作为文件结束（简化处理）
            next_pos = data.find(signature, pos + len(signature))
            if next_pos == -1:
                next_pos = len(data)
            
            # 提取文件内容
            with open(output_file, 'wb') as out:
                out.write(data[pos:next_pos])
            
            print(f'Found {file_type} at position {pos:08x}, saved to {output_file}')
            pos = next_pos

# 调用示例
scan_for_file_signatures('disk_image.dd', None, 'recovered_files')

# 使用PhotoRec高级选项进行选择性恢复
photorec /d recovered_files /cmd disk_image.dd ext2 undelete,keep_carved_file

# 使用R-Linux进行智能文件恢复
r-linux --scan-level=deep --recover-options=intelligent /dev/sda

# 使用ddrescue进行扇区级恢复
ddrescue -d -r3 /dev/sda disk_image.dd ddrescue.log

# 使用Autopsy分析文件元数据
autopsy --port 9999 --no-browser

# 使用Sleuth Kit提取文件元数据
ils -a disk_image.dd

# 使用fls列出已删除文件
fls -r -d disk_image.dd

# 使用smartctl分析硬盘健康状态
sudo smartctl -a /dev/sda

# 使用badblocks检测坏道
sudo badblocks -v /dev/sda > bad_blocks.txt

# 使用ddrescue创建镜像，跳过错误
ddrescue -n /dev/sda disk_image.dd rescue.log  # 快速模式

# 尝试恢复坏块数据
ddrescue -r3 /dev/sda disk_image.dd rescue.log  # 重试3次

# 使用nvme-cli工具分析NVMe SSD

# 查看设备信息
sudo nvme list

# 查看SMART信息
sudo nvme smart-log /dev/nvme0

# 读取命名空间信息
sudo nvme id-ns /dev/nvme0n1

# 创建NVMe SSD镜像（谨慎操作）
sudo dd if=/dev/nvme0n1 of=nvme_image.dd bs=4M status=progress

# 使用dd创建存储卡镜像
sudo dd if=/dev/mmcblk0 of=sdcard_image.dd bs=4M status=progress

# 分析Android设备分区结构（已获取root权限）
su -c 'ls -la /dev/block/'
su -c 'cat /proc/partitions'

# 使用ADB备份Android设备（需要授权）
adb backup -f android_backup.ab -noapk -shared -all

# 使用dd创建光盘镜像
sudo dd if=/dev/cdrom of=cd_image.iso bs=2048 status=progress

# 使用cdparanoia提取CD音频数据
cdparanoia -B

# 使用dvdisaster创建光盘数据恢复映像
dvdisaster -c -i cd_image.iso -o cd_image.ecc

# 使用ddrescue从损伤光盘提取数据
ddrescue -n -b 2048 /dev/cdrom cd_image.iso rescue.log

# 恢复Windows回收站文件（Linux环境）
fls -r -d -p disk_image.dd | grep "Recycle" > recycle_bin_items.txt

# 分析NTFS MFT记录
ntfsls -l -a /dev/sda1

# 使用TestDisk恢复已删除文件
testdisk /dev/sda

# 使用extundelete恢复Linux已删除文件
extundelete /dev/sda1 --restore-all

# 使用TestDisk恢复格式化的分区
testdisk /dev/sda

# 使用PhotoRec从格式化磁盘恢复文件
photorec /dev/sda

# 使用foremost进行基于签名的恢复
foremost -t jpg,pdf,doc,xls -i /dev/sda -o recovered_files

# 扫描分区表备份
fdisk -l /dev/sda > partition_table.txt

# 简化的数据覆盖检测分析（Python示例）
def analyze_overwritten_sectors(disk_image, sector_size=512, sample_size=10000):
    import os
    import numpy as np
    
    file_size = os.path.getsize(disk_image)
    sectors = file_size // sector_size
    
    # 读取随机样本扇区
    samples = min(sample_size, sectors)
    random_indices = np.random.choice(sectors, samples, replace=False)
    
    # 分析扇区熵值（简化版）
    low_entropy_sectors = 0
    zero_sectors = 0
    
    with open(disk_image, 'rb') as f:
        for idx in random_indices:
            f.seek(idx * sector_size)
            sector_data = f.read(sector_size)
            
            # 检查全零扇区
            if all(b == 0 for b in sector_data):
                zero_sectors += 1
                continue
            
            # 简化的熵计算
            byte_counts = {}
            for b in sector_data:
                byte_counts[b] = byte_counts.get(b, 0) + 1
            
            # 计算熵（简化版）
            entropy = 0
            for count in byte_counts.values():
                p = count / sector_size
                entropy -= p * np.log2(p)
            
            # 低熵值可能表示被覆盖或填充的数据
            if entropy < 4.0:  # 经验阈值
                low_entropy_sectors += 1
    
    results = {
        'total_samples': samples,
        'zero_sectors': zero_sectors,
        'low_entropy_sectors': low_entropy_sectors,
        'zero_percentage': (zero_sectors / samples) * 100,
        'low_entropy_percentage': (low_entropy_sectors / samples) * 100
    }
    
    return results

# 调用示例
# results = analyze_overwritten_sectors('disk_image.dd')
# print(f"零扇区: {results['zero_percentage']:.2f}%")
# print(f"低熵扇区: {results['low_entropy_percentage']:.2f}%")

# 分析SQLite数据库文件
file database.sqlite

# 尝试恢复损坏的SQLite数据库
sqlite3 corrupted.db ".restore backup.db"

# 修复MySQL表
mysqlcheck -r database_name table_name

# 使用mdbtools分析Microsoft Access数据库
mdb-tables database.mdb

# 使用jpeginfo检查JPEG文件完整性
jpeginfo -c *.jpg

# 尝试修复损坏的JPEG文件
jpegtran -copy none -outfile fixed.jpg corrupted.jpg

# 修复MP3文件
mp3val -f corrupted.mp3

# 提取视频文件中的音频流
ffmpeg -i corrupted.mp4 -vn -acodec copy extracted_audio.aac

# 修复损坏的ZIP文件
zip -FF corrupted.zip --out fixed.zip

# 尝试从损坏的RAR文件中提取
unrar x -r corrupted.rar

# 修复损坏的PDF文件
pdftk corrupted.pdf output fixed.pdf

# 提取Office文档内容（作为ZIP文件处理）
unzip document.docx -d document_contents

# 使用hashcat进行密码哈希破解
hashcat -m 13100 -a 0 hash.txt wordlist.txt

# 使用John the Ripper进行Office文档破解
john --wordlist=wordlist.txt --format=office document.docx

# 使用BitCracker尝试恢复BitLocker密钥
bitcracker -i bitlocker_image.dd -o keyfile.txt -w 4 -b 1024

# 使用VeraCrypt密码恢复工具
veracrypt-recovery-tool container.vc

# 使用ddrescue创建受损硬盘镜像（外部设备）
ddrescue -n -c 1024 /dev/sdb disk_image.dd rescue.log

# 使用badblocks检测坏道（只读模式）
badblocks -n -v /dev/sdb > bad_blocks.txt

# 使用smartctl分析硬盘健康状态
smartctl -x /dev/sdb > smart_report.txt

# 使用hdparm检测硬盘参数

# 检查Windows卷影副本
vssadmin list shadows

# 挂载卷影副本（使用ShadowExplorer工具）
# 或通过命令行
mklink /d C:\shadow_copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy1\

# 使用ransomware解密工具（如No More Ransom项目）
# https://www.nomoreransom.org/zh/index.html

# 恢复Windows系统文件
chkdsk /f /r C:

# 使用mdadm分析Linux软件RAID
mdadm --examine /dev/sda /dev/sdb /dev/sdc

# 尝试重组RAID阵列
mdadm --assemble --scan

# 使用dmraid分析硬件RAID

# 数据恢复操作日志记录示例脚本
#!/bin/bash

# 创建时间戳
TIMESTAMP=$(date +"%Y%m%d_%H%M%S")
LOG_FILE="recovery_log_$TIMESTAMP.txt"

# 记录开始操作
echo "===== 数据恢复操作日志 =====" >> $LOG_FILE
echo "开始时间: $(date)" >> $LOG_FILE
echo "操作人员: $(whoami)" >> $LOG_FILE
echo "介质标识: $1" >> $LOG_FILE
echo "操作类型: $2" >> $LOG_FILE
echo "目标路径: $3" >> $LOG_FILE
echo "" >> $LOG_FILE

# 执行操作并记录（示例）
echo "执行操作: $4" >> $LOG_FILE
echo "" >> $LOG_FILE

# 记录完成时间
echo "" >> $LOG_FILE
echo "完成时间: $(date)" >> $LOG_FILE
echo "操作结果: $5" >> $LOG_FILE
echo "===== 日志结束 =====" >> $LOG_FILE

echo "日志已保存至: $LOG_FILE"

# 数据恢复工具整合示例（Python脚本框架）
import os
import subprocess
import time
import logging

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    filename='recovery_process.log'
)

class RecoveryToolchain:
    def __init__(self, source_device, output_dir):
        self.source = source_device
        self.output_dir = output_dir
        self.tools = {
            'ddrescue': '/usr/bin/ddrescue',
            'testdisk': '/usr/bin/testdisk',
            'photorec': '/usr/bin/photorec',
            'foremost': '/usr/bin/foremost'
        }
        self.image_file = os.path.join(output_dir, 'disk_image.dd')
        self.log_file = os.path.join(output_dir, 'recovery.log')
    
    def create_image(self):
        """使用ddrescue创建磁盘镜像"""
        logging.info(f"开始创建磁盘镜像: {self.source} -> {self.image_file}")
        try:
            command = [
                self.tools['ddrescue'],
                '-n', '-c', '1024',  # 快速模式，块大小1024
                self.source,
                self.image_file,
                self.log_file
            ]
            subprocess.run(command, check=True)
            logging.info("磁盘镜像创建成功")
            return True
        except Exception as e:
            logging.error(f"创建磁盘镜像失败: {str(e)}")
            return False
    
    def partition_recovery(self):
        """使用TestDisk尝试恢复分区"""
        logging.info("开始使用TestDisk恢复分区")
        try:
            # 注意：TestDisk通常是交互式的，这里仅作为示例
            # 实际使用时可能需要创建配置文件或使用其他方法
            command = [
                self.tools['testdisk'],
                '/log',
                '/dev/null',  # 关闭输出
                self.source
            ]
            # 此命令实际不会在后台运行，需要特殊处理
            # subprocess.run(command, check=True)
            logging.info("TestDisk分区恢复完成")
            return True
        except Exception as e:
            logging.error(f"分区恢复失败: {str(e)}")
            return False
    
    def file_signature_recovery(self):
        """使用PhotoRec进行基于签名的文件恢复"""
        photorec_output = os.path.join(self.output_dir, 'photorec_recovered')
        os.makedirs(photorec_output, exist_ok=True)
        
        logging.info(f"开始使用PhotoRec恢复文件到: {photorec_output}")
        try:
            command = [
                self.tools['photorec'],
                '/d', photorec_output,
                '/cmd', self.source, 'ext2', 'undelete,keep_carved_file'
            ]
            subprocess.run(command, check=True)
            logging.info("PhotoRec文件恢复完成")
            return True
        except Exception as e:
            logging.error(f"文件恢复失败: {str(e)}")
            return False
    
    def custom_signature_recovery(self, signature_file=None):
        """使用Foremost进行自定义签名恢复"""
        foremost_output = os.path.join(self.output_dir, 'foremost_recovered')
        os.makedirs(foremost_output, exist_ok=True)
        
        logging.info(f"开始使用Foremost恢复文件到: {foremost_output}")
        try:
            command = [
                self.tools['foremost'],
                '-i', self.source,
                '-o', foremost_output
            ]
            
            if signature_file:
                command.extend(['-c', signature_file])
            else:
                command.extend(['-t', 'jpg,pdf,doc,xls,ppt,zip,rar'])
            
            subprocess.run(command, check=True)
            logging.info("Foremost文件恢复完成")
            return True
        except Exception as e:
            logging.error(f"自定义签名恢复失败: {str(e)}")
            return False
    
    def run_full_recovery(self):
        """运行完整的恢复流程"""
        logging.info("开始完整恢复流程")
        results = {}
        
        # 1. 创建镜像
        results['imaging'] = self.create_image()
        
        # 2. 尝试分区恢复
        results['partition_recovery'] = self.partition_recovery()
        
        # 3. 使用PhotoRec进行签名恢复
        results['photorec'] = self.file_signature_recovery()
        
        # 4. 使用Foremost进行自定义签名恢复
        results['foremost'] = self.custom_signature_recovery()
        
        # 生成摘要报告
        self.generate_report(results)
        
        logging.info("完整恢复流程结束")
        return results
    
    def generate_report(self, results):
        """生成恢复结果报告"""
        report_file = os.path.join(self.output_dir, 'recovery_report.txt')
        
        with open(report_file, 'w') as f:
            f.write("===== 数据恢复结果报告 =====\n")
            f.write(f"生成时间: {time.strftime('%Y-%m-%d %H:%M:%S')}\n")
            f.write(f"源设备: {self.source}\n")
            f.write("\n操作结果:\n")
            
            for operation, success in results.items():
                status = "成功" if success else "失败"
                f.write(f"- {operation}: {status}\n")
            
            f.write("\n恢复文件统计:\n")
            # 添加文件统计代码
            
            f.write("\n建议操作:\n")
            # 添加基于结果的建议
        
        logging.info(f"恢复报告已生成: {report_file}")

# 使用示例
# if __name__ == "__main__":
#     rt = RecoveryToolchain("/dev/sdb", "/mnt/recovery")
#     rt.run_full_recovery()

# 文件完整性验证脚本示例
#!/bin/bash

# 递归计算目录中所有文件的SHA256哈希值并保存
function compute_hashes() {
  local dir=$1
  local output_file=$2
  
  echo "计算 $dir 中所有文件的哈希值..."
  find "$dir" -type f -exec sha256sum {} \; > "$output_file"
  echo "哈希值计算完成，已保存到 $output_file"
}

# 验证文件哈希值
function verify_hashes() {
  local hash_file=$1
  
  echo "验证哈希值..."
  sha256sum -c "$hash_file"
  local result=$?
  
  if [ $result -eq 0 ]; then
    echo "验证成功：所有文件完整性完好"
  else
    echo "验证失败：部分文件可能已损坏"
  fi
  
  return $result
}

# 生成文件类型统计报告
function generate_file_report() {
  local dir=$1
  local report_file=$2
  
  echo "生成文件类型统计报告..."
  find "$dir" -type f | file --mime-type -f - | cut -d: -f2 | sort | uniq -c | sort -nr > "$report_file"
  echo "报告已生成：$report_file"
}

# 批量测试文件可读性
function test_file_readability() {
  local dir=$1
  local log_file=$2
  
  echo "开始测试文件可读性..."
  echo "文件可读性测试日志" > "$log_file"
  echo "====================" >> "$log_file"
  echo "时间: $(date)" >> "$log_file"
  echo "目录: $dir" >> "$log_file"
  echo "====================" >> "$log_file"
  
  # 测试常见文件类型
  local success=0
  local failure=0
  
  # 测试文档文件
  for doc in "$dir"/*.{pdf,doc,docx,xls,xlsx,ppt,pptx} 2>/dev/null; do
    if [ -f "$doc" ]; then
      if file "$doc" | grep -q "corrupt\|damaged"; then
        echo "失败: $doc (文件损坏)" >> "$log_file"
        ((failure++))
      else
        echo "成功: $doc" >> "$log_file"
        ((success++))
      fi
    fi
  done
  
  # 测试图像文件
  for img in "$dir"/*.{jpg,jpeg,png,gif,bmp} 2>/dev/null; do
    if [ -f "$img" ]; then
      if file "$img" | grep -q "corrupt\|damaged"; then
        echo "失败: $img (文件损坏)" >> "$log_file"
        ((failure++))
      else
        echo "成功: $img" >> "$log_file"
        ((success++))
      fi
    fi
  done
  
  # 测试音频视频文件
  for media in "$dir"/*.{mp3,wav,mp4,avi,mkv} 2>/dev/null; do
    if [ -f "$media" ]; then
      if file "$media" | grep -q "corrupt\|damaged"; then
        echo "失败: $media (文件损坏)" >> "$log_file"
        ((failure++))
      else
        echo "成功: $media" >> "$log_file"
        ((success++))
      fi
    fi
  done
  
  echo "====================" >> "$log_file"
  echo "成功: $success 文件" >> "$log_file"
  echo "失败: $failure 文件" >> "$log_file"
  echo "成功率: $((success * 100 / (success + failure)))%" >> "$log_file"
  
  echo "文件可读性测试完成，日志已保存到 $log_file"
}

# 主程序
if [ $# -lt 2 ]; then
  echo "用法: $0 <恢复目录> <输出前缀>"
  exit 1
fi

RECOVERY_DIR=$1
OUTPUT_PREFIX=$2

# 创建输出目录
OUTPUT_DIR="${OUTPUT_PREFIX}_verification"
mkdir -p "$OUTPUT_DIR"

# 执行验证
compute_hashes "$RECOVERY_DIR" "$OUTPUT_DIR/hashes.txt"
generate_file_report "$RECOVERY_DIR" "$OUTPUT_DIR/file_types.txt"
test_file_readability "$RECOVERY_DIR" "$OUTPUT_DIR/readability_test.txt"

# 生成总结报告
echo "生成验证总结报告..."
SUMMARY_FILE="$OUTPUT_DIR/verification_summary.txt"
echo "===== 数据恢复验证总结报告 =====" > "$SUMMARY_FILE"
echo "生成时间: $(date)" >> "$SUMMARY_FILE"
echo "恢复目录: $RECOVERY_DIR" >> "$SUMMARY_FILE"
echo "" >> "$SUMMARY_FILE"
echo "文件统计:" >> "$SUMMARY_FILE"
find "$RECOVERY_DIR" -type f | wc -l >> "$SUMMARY_FILE"
echo "" >> "$SUMMARY_FILE"
echo "文件类型分布: 见 file_types.txt" >> "$SUMMARY_FILE"
echo "文件哈希值: 见 hashes.txt" >> "$SUMMARY_FILE"
echo "可读性测试结果: 见 readability_test.txt" >> "$SUMMARY_FILE"
echo "" >> "$SUMMARY_FILE"
echo "===== 报告结束 =====" >> "$SUMMARY_FILE"

echo "验证完成！总结报告已生成: $SUMMARY_FILE"

# AI辅助文件类型识别示例（简化框架）
import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Conv1D, MaxPooling1D, Flatten

def create_file_signature_model(input_shape, num_classes):
    """创建用于文件签名识别的CNN模型"""
    model = Sequential([
        Conv1D(64, kernel_size=3, activation='relu', input_shape=input_shape),
        MaxPooling1D(pool_size=2),
        Conv1D(128, kernel_size=3, activation='relu'),
        MaxPooling1D(pool_size=2),
        Flatten(),
        Dense(256, activation='relu'),
        Dropout(0.5),
        Dense(num_classes, activation='softmax')
    ])
    
    model.compile(
        optimizer='adam',
        loss='categorical_crossentropy',
        metrics=['accuracy']
    )
    
    return model

def preprocess_file_data(file_path, max_length=4096):
    """预处理文件数据用于模型输入"""
    try:
        with open(file_path, 'rb') as f:
            data = f.read(max_length)
        
        # 转换为numpy数组并填充到固定长度
        arr = np.frombuffer(data, dtype=np.uint8)
        if len(arr) < max_length:
            arr = np.pad(arr, (0, max_length - len(arr)), 'constant')
        
        # 重塑为模型输入形状
        return arr.reshape(1, max_length, 1)
    except Exception as e:
        print(f"文件预处理错误: {str(e)}")
        return None

def predict_file_type(model, file_path, class_names):
    """预测文件类型"""
    preprocessed_data = preprocess_file_data(file_path)
    if preprocessed_data is None:
        return "无法处理"
    
    prediction = model.predict(preprocessed_data)
    class_index = np.argmax(prediction)
    confidence = prediction[0][class_index]
    
    return {
        'type': class_names[class_index],
        'confidence': float(confidence)
    }

# 训练模型示例（简化）
def train_file_classifier(training_data, labels, epochs=10, batch_size=32):
    """训练文件分类器"""
    # 假设training_data是预处理后的numpy数组
    # labels是one-hot编码的标签
    
    input_shape = (training_data.shape[1], 1)
    num_classes = labels.shape[1]
    
    model = create_file_signature_model(input_shape, num_classes)
    
    history = model.fit(
        training_data,
        labels,
        epochs=epochs,
        batch_size=batch_size,
        validation_split=0.2
    )
    
    return model, history