101_隐写术实战：基本图像LSB隐写技术深度解析——从像素位操作到数据隐藏的完整指南

隐写术与密码学对比:
┌────────────┐ ┌────────────┐
│   隐写术   │ │   密码学   │
├────────────┤ ├────────────┤
│ 隐藏存在性 │ │ 保护内容   │
│ 不可见通信 │ │ 加密数据   │
│ 载体+消息  │ │ 密钥+算法  │
└────────────┘ └────────────┘

# 安装Pillow库，用于图像处理
pip install Pillow

# 安装numpy库，用于数组操作（可选但推荐）
pip install numpy

from PIL import Image
import numpy as np

def text_to_bits(text):
    """将文本转换为比特串"""
    # 首先将文本转换为字节
    ascii_bytes = text.encode('utf-8')
    # 然后将每个字节转换为8位二进制字符串
    bits = []
    for byte in ascii_bytes:
        # 格式化为8位二进制，去掉'0b'前缀
        bits.append(format(byte, '08b'))
    # 连接所有比特
    return ''.join(bits)

def bits_to_text(bits):
    """将比特串转换回文本"""
    # 确保比特数是8的倍数
    if len(bits) % 8 != 0:
        raise ValueError("比特数必须是8的倍数")
    
    text = []
    # 每8位一组处理
    for i in range(0, len(bits), 8):
        byte_str = bits[i:i+8]
        # 转换为整数
        byte = int(byte_str, 2)
        # 转换为字符
        text.append(chr(byte))
    
    return ''.join(text)

def embed_lsb(image_path, message, output_path, num_lsb=1):
    """
    使用LSB隐写将消息嵌入图像
    
    参数:
    image_path: 载体图像路径
    message: 要隐藏的消息
    output_path: 输出隐写图像路径
    num_lsb: 使用的最低有效位数量（默认为1）
    """
    # 打开图像
    image = Image.open(image_path)
    # 转换为RGB模式（如果不是的话）
    if image.mode != 'RGB':
        image = image.convert('RGB')
    
    # 获取图像数据
    width, height = image.size
    pixels = np.array(image)
    
    # 计算最大可隐藏的比特数
    max_bits = width * height * 3 * num_lsb
    
    # 将消息转换为比特
    message_bits = text_to_bits(message)
    # 添加消息结束标记（8个0）
    message_bits += '00000000'
    
    # 检查消息是否太大
    if len(message_bits) > max_bits:
        raise ValueError(f"消息太大，最大可隐藏 {max_bits//8} 字节")
    
    # 准备嵌入消息
    bit_index = 0
    # 遍历图像的每个像素
    for i in range(height):
        for j in range(width):
            # 遍历RGB三个通道
            for c in range(3):
                # 如果还有比特需要嵌入
                if bit_index < len(message_bits):
                    # 获取当前像素值
                    pixel_value = pixels[i, j, c]
                    
                    # 对每个LSB位平面进行处理
                    for lsb_pos in range(num_lsb):
                        if bit_index < len(message_bits):
                            # 获取要嵌入的比特
                            bit = int(message_bits[bit_index])
                            # 清除该位置的比特
                            pixel_value &= ~(1 << lsb_pos)
                            # 设置为新的比特值
                            pixel_value |= (bit << lsb_pos)
                            bit_index += 1
                    
                    # 更新像素值
                    pixels[i, j, c] = pixel_value
                else:
                    break
            else:
                continue
            break
        else:
            continue
        break
    
    # 创建新图像
    stego_image = Image.fromarray(pixels)
    # 保存图像
    stego_image.save(output_path)
    print(f"消息已成功嵌入到 {output_path}")
    print(f"嵌入的比特数: {bit_index}")
    print(f"使用的LSB位数: {num_lsb}")

def extract_lsb(image_path, num_lsb=1):
    """
    从LSB隐写图像中提取消息
    
    参数:
    image_path: 隐写图像路径
    num_lsb: 使用的最低有效位数量（默认为1）
    
    返回:
    提取的消息
    """
    # 打开图像
    image = Image.open(image_path)
    # 转换为RGB模式
    if image.mode != 'RGB':
        image = image.convert('RGB')
    
    # 获取图像数据
    pixels = np.array(image)
    
    # 提取比特
    bits = []
    # 遍历图像的每个像素
    for i in range(pixels.shape[0]):
        for j in range(pixels.shape[1]):
            # 遍历RGB三个通道
            for c in range(3):
                # 对每个LSB位平面进行处理
                for lsb_pos in range(num_lsb):
                    # 提取该位置的比特
                    bit = (pixels[i, j, c] >> lsb_pos) & 1
                    bits.append(str(bit))
    
    # 将比特列表转换为字符串
    bit_string = ''.join(bits)
    
    # 查找消息结束标记
    end_index = bit_string.find('00000000')
    if end_index != -1:
        # 提取到结束标记为止的比特
        message_bits = bit_string[:end_index]
    else:
        # 如果没有找到结束标记，取所有比特（可能不完整）
        # 确保比特数是8的倍数
        message_bits = bit_string[:len(bit_string) - (len(bit_string) % 8)]
    
    # 将比特转换回文本
    try:
        message = bits_to_text(message_bits)
        return message
    except Exception as e:
        print(f"提取失败: {e}")
        return ""

import argparse

def main():
    parser = argparse.ArgumentParser(description='LSB隐写工具')
    
    # 添加子命令
    subparsers = parser.add_subparsers(dest='mode', help='操作模式')
    
    # 嵌入模式
    embed_parser = subparsers.add_parser('embed', help='嵌入消息到图像')
    embed_parser.add_argument('--image', '-i', required=True, help='载体图像路径')
    embed_parser.add_argument('--message', '-m', required=True, help='要隐藏的消息')
    embed_parser.add_argument('--output', '-o', required=True, help='输出图像路径')
    embed_parser.add_argument('--lsb', '-l', type=int, default=1, help='使用的LSB位数（默认1）')
    
    # 提取模式
    extract_parser = subparsers.add_parser('extract', help='从图像提取消息')
    extract_parser.add_argument('--image', '-i', required=True, help='隐写图像路径')
    extract_parser.add_argument('--lsb', '-l', type=int, default=1, help='使用的LSB位数（默认1）')
    
    args = parser.parse_args()
    
    if args.mode == 'embed':
        try:
            embed_lsb(args.image, args.message, args.output, args.lsb)
        except Exception as e:
            print(f"嵌入失败: {e}")
    elif args.mode == 'extract':
        try:
            message = extract_lsb(args.image, args.lsb)
            print(f"提取的消息: {message}")
        except Exception as e:
            print(f"提取失败: {e}")
    else:
        parser.print_help()

if __name__ == "__main__":
    main()

import matplotlib.pyplot as plt

def plot_histogram(image_path, title):
    """绘制图像直方图"""
    image = Image.open(image_path).convert('RGB')
    pixels = np.array(image)
    
    plt.figure(figsize=(12, 6))
    
    # 绘制RGB三个通道的直方图
    colors = ['r', 'g', 'b']
    channels = ['Red', 'Green', 'Blue']
    
    for i, (color, channel) in enumerate(zip(colors, channels)):
        plt.subplot(1, 3, i+1)
        plt.hist(pixels[:,:,i].ravel(), bins=256, color=color, alpha=0.5)
        plt.title(f'{channel} Channel')
        plt.xlabel('Pixel Value')
        plt.ylabel('Frequency')
    
    plt.suptitle(title)
    plt.tight_layout()
    plt.savefig(f'{title}_histogram.png')
    plt.close()

def compare_histograms(original_path, stego_path):
    """比较原始图像和隐写图像的直方图"""
    original = Image.open(original_path).convert('RGB')
    stego = Image.open(stego_path).convert('RGB')
    
    original_pixels = np.array(original)
    stego_pixels = np.array(stego)
    
    plt.figure(figsize=(15, 10))
    
    # 对每个通道进行比较
    channels = ['Red', 'Green', 'Blue']
    for i in range(3):
        plt.subplot(3, 1, i+1)
        
        # 原始图像直方图
        plt.hist(original_pixels[:,:,i].ravel(), bins=256, alpha=0.5, label='Original')
        # 隐写图像直方图
        plt.hist(stego_pixels[:,:,i].ravel(), bins=256, alpha=0.5, label='Stego')
        
        plt.title(f'{channels[i]} Channel Comparison')
        plt.xlabel('Pixel Value')
        plt.ylabel('Frequency')
        plt.legend()
    
    plt.tight_layout()
    plt.savefig('histogram_comparison.png')
    plt.close()

def extract_bit_plane(image_path, bit_position):
    """提取指定的位平面"""
    image = Image.open(image_path).convert('L')  # 转换为灰度图像
    pixels = np.array(image)
    
    # 提取指定位平面（0为LSB，7为MSB）
    bit_plane = (pixels >> bit_position) & 1
    # 将位平面值从0-1映射到0-255以可视化
    bit_plane = bit_plane * 255
    
    return Image.fromarray(bit_plane.astype(np.uint8))

def visualize_all_bit_planes(image_path, output_prefix):
    """可视化所有位平面"""
    plt.figure(figsize=(16, 10))
    
    for i in range(8):
        bit_plane = extract_bit_plane(image_path, i)
        plt.subplot(2, 4, i+1)
        plt.imshow(bit_plane, cmap='gray')
        plt.title(f'Bit Plane {i}')
        plt.axis('off')
    
    plt.tight_layout()
    plt.savefig(f'{output_prefix}_bit_planes.png')
    plt.close()

def rs_detection(image_path, block_size=8):
    """
    RS检测算法的简化实现
    
    参数:
    image_path: 图像路径
    block_size: 分块大小
    
    返回:
    检测分数（值越大越可能包含隐写）
    """
    image = Image.open(image_path).convert('L')  # 转换为灰度图像
    pixels = np.array(image)
    
    height, width = pixels.shape
    scores = []
    
    # 遍历每个块
    for i in range(0, height, block_size):
        for j in range(0, width, block_size):
            # 获取块区域
            block = pixels[i:i+block_size, j:j+block_size]
            
            # 计算块内的正则性得分
            regular_count = 0
            singular_count = 0
            
            # 遍历块内的像素（除了边界）
            for x in range(1, block.shape[0]-1):
                for y in range(1, block.shape[1]-1):
                    center = block[x, y]
                    neighbors = [
                        block[x-1, y], block[x+1, y],  # 上下
                        block[x, y-1], block[x, y+1]   # 左右
                    ]
                    
                    # 判断是否为正则点或奇异点
                    is_min = all(center < n for n in neighbors)
                    is_max = all(center > n for n in neighbors)
                    
                    if is_min or is_max:
                        singular_count += 1
                    else:
                        regular_count += 1
            
            # 计算该块的RS分数
            if regular_count + singular_count > 0:
                score = singular_count / (regular_count + singular_count)
                scores.append(score)
    
    # 返回平均RS分数
    return sum(scores) / len(scores) if scores else 0

def chi_square_detection(image_path):
    """
    卡方检测算法实现
    
    返回卡方统计量，值越大越可能包含隐写
    """
    image = Image.open(image_path).convert('L')  # 转换为灰度图像
    pixels = np.array(image)
    
    # 计算像素值对的频率
    pairs = {}
    for i in range(256):
        pairs[(i, i^1)] = 0  # (偶数, 奇数)对
    
    # 统计像素值对
    for row in pixels:
        for pixel in row:
            # 获取像素值的配对值
            paired_value = pixel ^ 1  # 翻转最低位
            if (pixel, paired_value) in pairs:
                pairs[(pixel, paired_value)] += 1
            elif (paired_value, pixel) in pairs:
                pairs[(paired_value, pixel)] += 1
    
    # 计算卡方统计量
    chi_square = 0
    for (a, b), count in pairs.items():
        # 对于(a,b)对，理论上a和b的出现次数应该相等
        # 这里使用实际观察到的总数的一半作为期望值
        if a != b and count > 0:
            # 计算a和b的实际出现次数
            count_a = 0
            count_b = 0
            for row in pixels:
                count_a += np.sum(row == a)
                count_b += np.sum(row == b)
            
            total = count_a + count_b
            expected = total / 2
            
            if expected > 0:
                chi_square += (count_a - expected)**2 / expected + (count_b - expected)**2 / expected
    
    return chi_square

def sample_pair_analysis(image_path):
    """
    样本对分析的简化实现
    
    返回检测分数
    """
    image = Image.open(image_path).convert('L')
    pixels = np.array(image)
    
    # 计算样本对
    pairs = []
    # 使用水平相邻像素作为样本对
    for row in pixels:
        for i in range(len(row) - 1):
            pairs.append((row[i], row[i+1]))
    
    # 分类样本对
    type1 = 0  # 类型1：a和b都是偶数或都是奇数
    type2 = 0  # 类型2：a是偶数，b是奇数
    type3 = 0  # 类型3：a是奇数，b是偶数
    
    for a, b in pairs:
        if a % 2 == b % 2:
            type1 += 1
        elif a % 2 == 0:
            type2 += 1
        else:
            type3 += 1
    
    # 计算检测分数
    # 对于原始图像，type2和type3的数量应该大致相等
    # 隐写会破坏这种平衡
    total = type2 + type3
    if total > 0:
        score = abs(type2 - type3) / total
        return score
    return 0

def random_lsb_substitution(image_path, message, output_path, embedding_rate=0.5):
    """
    随机LSB替换隐写
    
    参数:
    image_path: 载体图像路径
    message: 要隐藏的消息
    output_path: 输出图像路径
    embedding_rate: 嵌入率（0-1之间，表示用于嵌入的像素比例）
    """
    image = Image.open(image_path).convert('RGB')
    pixels = np.array(image)
    
    width, height = image.size
    total_pixels = width * height * 3
    # 计算要使用的像素数量
    used_pixels = int(total_pixels * embedding_rate)
    
    # 生成随机像素位置
    random.seed(42)  # 固定种子以便复现，实际使用时应移除
    positions = random.sample(range(total_pixels), used_pixels)
    
    # 转换消息为比特
    message_bits = text_to_bits(message) + '00000000'
    
    if len(message_bits) > used_pixels:
        raise ValueError(f"消息太大，在嵌入率{embedding_rate}下只能嵌入{used_pixels//8}字节")
    
    # 嵌入消息
    bit_index = 0
    for pos in positions:
        if bit_index >= len(message_bits):
            break
            
        y = pos // (width * 3)
        x = (pos % (width * 3)) // 3
        channel = pos % 3
        
        bit = int(message_bits[bit_index])
        pixels[y, x, channel] &= ~1  # 清除LSB
        pixels[y, x, channel] |= bit  # 设置新的LSB
        
        bit_index += 1
    
    # 保存图像
    stego_image = Image.fromarray(pixels)
    stego_image.save(output_path)
    print(f"随机LSB替换隐写完成，嵌入率: {embedding_rate}")

def calculate_complexity(pixels, x, y, size=3):
    """
    计算图像中某点的复杂度（使用局部方差）
    """
    h, w = pixels.shape[:2]
    # 确保在图像范围内
    x_start = max(0, x - size//2)
    x_end = min(w, x + size//2 + 1)
    y_start = max(0, y - size//2)
    y_end = min(h, y + size//2 + 1)
    
    # 获取局部区域
    region = pixels[y_start:y_end, x_start:x_end]
    
    # 计算方差作为复杂度度量
    if len(region) > 0:
        return np.var(region)
    return 0

def adaptive_lsb_embedding(image_path, message, output_path, threshold=100):
    """
    自适应LSB隐写
    
    参数:
    image_path: 载体图像路径
    message: 要隐藏的消息
    output_path: 输出图像路径
    threshold: 复杂度阈值，高于此值的位置可用于嵌入
    """
    image = Image.open(image_path).convert('RGB')
    pixels = np.array(image)
    
    # 转换为灰度图用于计算复杂度
    gray = np.array(image.convert('L'))
    
    width, height = image.size
    
    # 转换消息为比特
    message_bits = text_to_bits(message) + '00000000'
    bit_index = 0
    
    # 遍历图像，寻找合适的嵌入位置
    for y in range(height):
        for x in range(width):
            # 计算当前位置的复杂度
            complexity = calculate_complexity(gray, x, y)
            
            # 如果复杂度足够高，且还有消息需要嵌入
            if complexity > threshold and bit_index < len(message_bits):
                # 在RGB三个通道中嵌入
                for channel in range(3):
                    if bit_index < len(message_bits):
                        bit = int(message_bits[bit_index])
                        pixels[y, x, channel] &= ~1  # 清除LSB
                        pixels[y, x, channel] |= bit  # 设置新的LSB
                        bit_index += 1
    
    # 保存图像
    stego_image = Image.fromarray(pixels)
    stego_image.save(output_path)
    print(f"自适应LSB隐写完成，嵌入比特数: {bit_index}")

from cryptography.fernet import Fernet
import base64
import os

def generate_key():
    """生成加密密钥"""
    return Fernet.generate_key()

def encrypt_message(message, key):
    """使用Fernet加密消息"""
    cipher_suite = Fernet(key)
    encrypted_message = cipher_suite.encrypt(message.encode())
    # 将二进制密文转换为可嵌入的字符串
    return base64.b64encode(encrypted_message).decode('utf-8')

def decrypt_message(encrypted_message, key):
    """解密消息"""
    # 将字符串转回二进制密文
    encrypted_bytes = base64.b64decode(encrypted_message)
    cipher_suite = Fernet(key)
    decrypted_message = cipher_suite.decrypt(encrypted_bytes)
    return decrypted_message.decode('utf-8')

def secure_stego_system(original_image, message, output_image, password=None):
    """
    安全隐写系统：结合加密和隐写技术
    
    参数:
    original_image: 原始图像路径
    message: 要隐藏的消息
    output_image: 输出图像路径
    password: 用户密码（可选），如果不提供则生成新密钥
    """
    # 生成或使用密钥
    if password:
        # 从密码派生密钥
        key = base64.urlsafe_b64encode(password.encode()[:32])
    else:
        key = generate_key()
        print(f"生成的密钥（请保存）: {key.decode()}")
    
    # 加密消息
    encrypted_message = encrypt_message(message, key)
    print(f"加密后的消息长度: {len(encrypted_message)} 字符")
    
    # 使用高级LSB隐写
    try:
        # 首先尝试自适应嵌入
        adaptive_lsb_embedding(original_image, encrypted_message, output_image)
        print(f"安全隐写完成，消息已加密并隐藏到: {output_image}")
        return True, key
    except Exception as e:
        print(f"自适应嵌入失败: {e}")
        try:
            # 如果自适应嵌入失败，使用密钥增强的LSB隐写
            if password:
                embed_lsb_with_key(original_image, encrypted_message, password, output_image)
                print(f"密钥增强隐写完成，消息已加密并隐藏到: {output_image}")
                return True, key
            else:
                print("需要密码进行密钥增强隐写")
                return False, None
        except Exception as e2:
            print(f"密钥增强隐写也失败: {e2}")
            return False, None

def secure_stego_extraction(stego_image, password=None, key=None):
    """
    从安全隐写图像中提取并解密消息
    
    参数:
    stego_image: 隐写图像路径
    password: 用户密码（可选）
    key: 加密密钥（可选）
    
    返回:
    解密后的消息
    """
    # 提取加密消息
    encrypted_message = None
    
    try:
        # 首先尝试常规提取（假设是自适应嵌入）
        encrypted_message = extract_lsb(stego_image)
    except Exception:
        try:
            # 如果失败，尝试使用密码提取
            if password:
                encrypted_message = extract_lsb_with_key(stego_image, password)
        except Exception:
            print("无法提取加密消息")
            return None
    
    if not encrypted_message:
        print("未找到加密消息")
        return None
    
    # 解密消息
    try:
        if password:
            used_key = base64.urlsafe_b64encode(password.encode()[:32])
        elif key:
            used_key = key if isinstance(key, bytes) else key.encode()
        else:
            print("需要密码或密钥进行解密")
            return None
        
        decrypted_message = decrypt_message(encrypted_message, used_key)
        print("消息解密成功")
        return decrypted_message
    except Exception as e:
        print(f"消息解密失败: {e}")
        return None

# 加密并隐藏消息
original_img = "nature.jpg"
secret_msg = "这是一条需要安全传递的秘密信息。包含重要的机密数据。"
output_img = "nature_stego.png"
user_password = "my_secure_password123"

# 执行安全隐写
success, key = secure_stego_system(original_img, secret_msg, output_img, user_password)

# 提取并解密消息
if success:
    extracted_message = secure_stego_extraction(output_img, user_password)
    print(f"\n提取的原始消息: {extracted_message}")

def create_watermark(owner_info, timestamp=True):
    """
    创建包含版权信息的水印
    
    参数:
    owner_info: 所有者信息
    timestamp: 是否包含时间戳
    
    返回:
    水印文本
    """
    import datetime
    watermark = f"© {owner_info}"
    if timestamp:
        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        watermark += f" | {now}"
    return watermark

def watermark_image(image_path, output_path, owner_info, check_watermark=False):
    """
    为图像添加数字水印
    
    参数:
    image_path: 原始图像路径
    output_path: 输出图像路径
    owner_info: 所有者信息
    check_watermark: 是否检查水印是否成功嵌入
    
    返回:
    是否成功
    """
    # 创建水印
    watermark = create_watermark(owner_info)
    
    try:
        # 嵌入水印
        embed_lsb(image_path, watermark, output_path)
        print(f"水印已添加到图像: {output_path}")
        
        # 检查水印
        if check_watermark:
            extracted = extract_lsb(output_path)
            if owner_info in extracted:
                print("水印检查通过，可成功提取")
                return True
            else:
                print("水印检查失败，提取的内容不匹配")
                return False
        return True
    except Exception as e:
        print(f"添加水印失败: {e}")
        return False

def detect_watermark(image_path):
    """
    尝试从图像中提取水印
    
    参数:
    image_path: 要检测的图像路径
    
    返回:
    提取的水印（如果有）
    """
    try:
        watermark = extract_lsb(image_path)
        # 检查是否包含版权标记
        if "©" in watermark:
            print(f"检测到水印: {watermark}")
            return watermark
        else:
            print("未检测到明显的水印")
            # 返回提取的内容以供检查
            return watermark if len(watermark) > 0 else None
    except Exception as e:
        print(f"提取水印失败: {e}")
        return None

def batch_watermark(directory, owner_info):
    """
    批量为目录中的图像添加水印
    
    参数:
    directory: 图像目录
    owner_info: 所有者信息
    
    返回:
    处理统计信息
    """
    import os
    success_count = 0
    fail_count = 0
    supported_formats = ['.jpg', '.jpeg', '.png', '.bmp']
    
    # 创建输出目录
    output_dir = os.path.join(directory, "watermarked")
    os.makedirs(output_dir, exist_ok=True)
    
    # 处理目录中的所有图像
    for filename in os.listdir(directory):
        # 检查文件格式
        ext = os.path.splitext(filename)[1].lower()
        if ext in supported_formats:
            image_path = os.path.join(directory, filename)
            output_path = os.path.join(output_dir, filename)
            
            print(f"\n处理: {filename}")
            if watermark_image(image_path, output_path, owner_info):
                success_count += 1
            else:
                fail_count += 1
    
    print(f"\n批量水印处理完成:")
    print(f"成功: {success_count}")
    print(f"失败: {fail_count}")
    
    return {
        "success": success_count,
        "failed": fail_count,
        "total": success_count + fail_count,
        "output_directory": output_dir
    }

# 单图像处理
original_image = "photo.jpg"
watermarked_image = "photo_watermarked.jpg"
owner = "Security Lab 2025"
watermark_image(original_image, watermarked_image, owner, check_watermark=True)

# 批量处理
# photos_dir = "path/to/photos"
# stats = batch_watermark(photos_dir, owner)

# 检测水印
extracted_watermark = detect_watermark(watermarked_image)
print(f"提取的水印: {extracted_watermark}")

import pandas as pd
import matplotlib.pyplot as plt

def comprehensive_stego_analysis(original_path, suspicious_path=None, output_report="stego_analysis_report.html"):
    """
    综合隐写分析
    
    参数:
    original_path: 原始图像路径（用于比较）
    suspicious_path: 可疑图像路径（如果为None，则只分析原始图像）
    output_report: 输出报告文件路径
    
    返回:
    分析结果
    """
    print("开始综合隐写分析...")
    
    # 初始化结果字典
    results = {}
    
    # 分析可疑图像（如果提供）
    if suspicious_path:
        print(f"分析可疑图像: {suspicious_path}")
        
        # 计算安全指标
        metrics = evaluate_stego_security(original_path, suspicious_path)
        results['security_metrics'] = metrics
        
        # 比较直方图
        compare_histograms(original_path, suspicious_path)
        print("已生成直方图比较图: histogram_comparison.png")
        
        # 可视化位平面
        visualize_all_bit_planes(original_path, "original")
        visualize_all_bit_planes(suspicious_path, "suspicious")
        print("已生成位平面可视化图")
        
        # 生成检测报告
        generate_analysis_report(results, original_path, suspicious_path, output_report)
        
        # 给出检测结论
        conclusion = analyze_detection_results(metrics)
        results['conclusion'] = conclusion
        print(f"\n检测结论: {conclusion}")
        
    else:
        print("只分析单张图像模式")
        # 对原始图像进行位平面分析
        visualize_all_bit_planes(original_path, "single_image")
        
        # 尝试提取隐藏信息
        print("尝试提取可能的隐藏信息...")
        extracted = extract_lsb(original_path)
        if extracted and len(extracted.strip()) > 0:
            print(f"提取到可能的隐藏内容: {extracted[:100]}..." if len(extracted) > 100 else f"提取到可能的隐藏内容: {extracted}")
            results['extracted_content'] = extracted
        else:
            print("未提取到明显的隐藏内容")
    
    print(f"\n分析完成! 详细报告已保存至: {output_report}")
    return results

def analyze_detection_results(metrics):
    """
    根据检测指标给出结论
    
    参数:
    metrics: 检测指标字典
    
    返回:
    分析结论
    """
    # 定义阈值（这些阈值是经验值，需要根据实际情况调整）
    thresholds = {
        'RS_Score': 0.15,
        'Chi_Square': 1000,
        'SPA_Score': 0.1
    }
    
    # 统计异常指标
    suspicious_metrics = []
    
    if metrics['RS_Score'] > thresholds['RS_Score']:
        suspicious_metrics.append(f"RS分数过高 ({metrics['RS_Score']:.4f})")
    
    if metrics['Chi_Square'] > thresholds['Chi_Square']:
        suspicious_metrics.append(f"卡方统计量过高 ({metrics['Chi_Square']:.2f})")
    
    if metrics['SPA_Score'] > thresholds['SPA_Score']:
        suspicious_metrics.append(f"SPA分数过高 ({metrics['SPA_Score']:.4f})")
    
    # 生成结论
    if not suspicious_metrics:
        return "未检测到明显的隐写痕迹，图像可能是原始的。"
    elif len(suspicious_metrics) == 1:
        return f"轻度可疑: {suspicious_metrics[0]}，可能存在隐写或图像处理操作。"
    else:
        reasons = "; ".join(suspicious_metrics)
        return f"高度可疑: {reasons}，强烈提示存在隐写内容。"

def generate_analysis_report(results, original_path, suspicious_path, output_path):
    """
    生成HTML格式的分析报告
    """
    html_content = f"""
    <!DOCTYPE html>
    <html>
    <head>
        <meta charset="UTF-8">
        <title>隐写分析报告</title>
        <style>
            body {{ font-family: Arial, sans-serif; margin: 40px; }}
            h1 {{ color: #333366; }}
            h2 {{ color: #336699; margin-top: 30px; }}
            table {{ border-collapse: collapse; width: 100%; margin: 20px 0; }}
            th, td {{ border: 1px solid #ddd; padding: 8px 12px; text-align: left; }}
            th {{ background-color: #f2f2f2; }}
            tr:nth-child(even) {{ background-color: #f9f9f9; }}
            .conclusion {{ margin: 30px 0; padding: 20px; border-radius: 5px; }}
            .conclusion.low {{ background-color: #e8f5e8; border: 1px solid #c3e6cb; }}
            .conclusion.medium {{ background-color: #fff3cd; border: 1px solid #ffeaa7; }}
            .conclusion.high {{ background-color: #f8d7da; border: 1px solid #f5c6cb; }}
            .images {{ margin: 30px 0; }}
            .image-container {{ margin-bottom: 20px; }}
            .image-container img {{ max-width: 100%; height: auto; border: 1px solid #ddd; }}
        </style>
    </head>
    <body>
        <h1>隐写分析报告</h1>
        
        <h2>分析概要</h2>
        <table>
            <tr><th>项目</th><th>值</th></tr>
            <tr><td>原始图像</td><td>{original_path}</td></tr>
            <tr><td>可疑图像</td><td>{suspicious_path}</td></tr>
            <tr><td>分析时间</td><td>{pd.Timestamp.now().strftime('%Y-%m-%d %H:%M:%S')}</td></tr>
        </table>
        
        <h2>安全指标</h2>
        <table>
            <tr><th>指标</th><th>值</th><th>解释</th></tr>
        """
    
    if 'security_metrics' in results:
        metrics = results['security_metrics']
        html_content += f"""
            <tr><td>MSE</td><td>{metrics['MSE']:.4f}</td><td>均方误差（越低越好）</td></tr>
            <tr><td>PSNR (dB)</td><td>{metrics['PSNR']:.2f}</td><td>峰值信噪比（越高越好）</td></tr>
            <tr><td>SSIM</td><td>{metrics['SSIM']:.4f}</td><td>结构相似性（越接近1越好）</td></tr>
            <tr><td>RS分数</td><td>{metrics['RS_Score']:.4f}</td><td>RS检测分数（越低越好）</td></tr>
            <tr><td>卡方统计量</td><td>{metrics['Chi_Square']:.2f}</td><td>卡方检测值（越低越好）</td></tr>
            <tr><td>SPA分数</td><td>{metrics['SPA_Score']:.4f}</td><td>样本对分析分数（越低越好）</td></tr>
        """
    
    html_content += """
        </table>
        
        <h2>分析结论</h2>
        <div class="conclusion {conclusion_class}">
            <p><strong>{conclusion_text}</strong></p>
        </div>
        
        <h2>可视化结果</h2>
        <div class="images">
            <div class="image-container">
                <h3>直方图比较</h3>
                <p>原始图像与可疑图像的直方图对比可用于识别像素值分布的异常变化。</p>
            </div>
            
            <div class="image-container">
                <h3>位平面分析</h3>
                <p>位平面分析可揭示LSB操作引起的统计异常。注意最低位平面的模式变化。</p>
            </div>
        </div>
        
        <h2>建议</h2>
        <ul>
            <li>如果图像被判定为可疑，建议使用专业工具进行进一步分析</li>
            <li>可尝试提取可能的隐藏内容，即使没有明确的隐写痕迹</li>
            <li>对于敏感应用，应考虑使用更先进的隐写检测技术</li>
        </ul>
    </body>
    </html>
    """
    
    # 设置结论样式
    if 'conclusion' in results:
        conclusion = results['conclusion']
        if "未检测到" in conclusion:
            conclusion_class = "low"
        elif "轻度可疑" in conclusion:
            conclusion_class = "medium"
        else:
            conclusion_class = "high"
        
        html_content = html_content.replace("{conclusion_class}", conclusion_class)
        html_content = html_content.replace("{conclusion_text}", conclusion)
    else:
        html_content = html_content.replace("{conclusion_class}", "low")
        html_content = html_content.replace("{conclusion_text}", "无法生成明确结论")
    
    # 保存HTML报告
    with open(output_path, 'w', encoding='utf-8') as f:
        f.write(html_content)

# 分析可疑图像
original_img = "landscape_original.jpg"
suspicious_img = "landscape_suspicious.jpg"
results = comprehensive_stego_analysis(original_img, suspicious_img)

# 检查是否有隐藏内容
if 'extracted_content' in results:
    print(f"发现隐藏内容: {results['extracted_content']}")

# 单图像分析
# single_results = comprehensive_stego_analysis("mystery_image.jpg")