前言

​

这些天打了数字中国积分产业链线下赛,遇到了一个挺有意思的一个题目,就是对mp3文件进行数据审计,分析其中的恶意代码或者隐藏数据
题目描述如是说:

公司管理员在商品测评汇总平台中的文件服务器,存放了一些商品相关或者用户上传的文件数据,包括
TXT,图片,PDF,音频数据。在各种数据中,可能泄露了一些敏感信息或者某些用户插入了恶意代码到
各种类型数据中。请选手对于各种数据类型的文件进行审计,找到带有敏感信息或者恶意代码的数据文
件,并将文件名列出来。每提交一个正确的文件名可得(题目总分数/标准答案个数)分,每提交一个错
误的文件名扣(题目总分数/标准答案个数)分,扣到0分为止。请选手尽可能的提交正确答案。

这个mp3的分析也是事后才知道要whisper模型进行分析,于是这些天就趁这个机会学了一些,发现这个模型还有更多功能去挖掘

探讨whisper本身的作用


whisper是一个能识别音频文件字幕的模型,
是OpenAI开发的自动语音识别(ASR)系统,专门用于将语音转换为文字。它训练于大量多语言和多任务的音频数据以它来隐写音频数据

​

模型性能指标:

​

优点:

  • 完全依赖 AI 解析,无传统隐写痕迹。
  • 可结合密码学(如白噪声+特定编码)。

缺点:

  • 依赖 Whisper 的误识别特性。

比如说一个音频图几乎为直线的,什么声音都没有的音频文件,利用模型可能你输出其隐藏的字幕,例如数字中国的题目,里面是很多没有声音和频谱图的mp3文件,但利用模型可以提取不可见字幕

其中代码如下:

import os
import argparse
import whisper
import time

def process_folder(folder_path, output_file="whisper_transcriptions.txt", model_size="base"):
    """
    直接使用Whisper处理文件夹中的MP3文件
    :param folder_path: 包含MP3文件的文件夹路径
    :param output_file: 输出文本文件路径
    :param model_size: Whisper模型大小(tiny, base, small, medium, large)
    """
    # 检查文件夹是否存在
    if not os.path.exists(folder_path):
        print(f"错误: 文件夹 {folder_path} 不存在")
        return
    
    print(f"正在加载Whisper模型({model_size})...")
    start_time = time.time()
    model = whisper.load_model(model_size)
    load_time = time.time() - start_time
    print(f"模型加载完成,耗时 {load_time:.2f} 秒")
    
    # 获取所有MP3文件并按文件名排序
    mp3_files = sorted([f for f in os.listdir(folder_path) if f.lower().endswith('.mp3')])
    
    if not mp3_files:
        print("警告: 没有找到MP3文件")
        return
    
    print(f"找到 {len(mp3_files)} 个MP3文件待处理")
    
    with open(output_file, "w", encoding="utf-8") as f_out:
        for i, filename in enumerate(mp3_files, 1):
            mp3_path = os.path.join(folder_path, filename)
            print(f"\n[{i}/{len(mp3_files)}] 正在处理: {filename}")
            
            try:
                # 检查文件是否存在
                if not os.path.isfile(mp3_path):
                    print(f"文件不存在: {mp3_path}")
                    continue
                
                # 直接使用Whisper处理MP3
                start_time = time.time()
                result = model.transcribe(mp3_path)
                process_time = time.time() - start_time
                
                # 获取转录结果
                text = result.get("text", "").strip()
                
                # 写入结果
                f_out.write(f"文件: {filename}\n")
                f_out.write(f"处理时间: {process_time:.2f}秒\n")
                f_out.write(f"转写结果:\n{text}\n")
                f_out.write("-" * 80 + "\n")
                
                print(f"处理完成,耗时 {process_time:.2f} 秒")
                print(f"结果长度: {len(text)} 字符")
                
            except Exception as e:
                print(f"处理 {filename} 时出错: {str(e)}")
                f_out.write(f"文件: {filename}\n")
                f_out.write(f"错误: {str(e)}\n")
                f_out.write("-" * 80 + "\n")

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="直接使用Whisper将MP3文件转换为文字")
    parser.add_argument("folder", help="包含MP3文件的文件夹路径")
    parser.add_argument("-o", "--output", default="whisper_transcriptions.txt", 
                       help="输出文件名(默认为whisper_transcriptions.txt)")
    parser.add_argument("-m", "--model", default="base", 
                       choices=["tiny", "base", "small", "medium", "large"],
                       help="Whisper模型大小(默认为base)")
    
    args = parser.parse_args()
    
    print("="*50)
    print(f"开始处理文件夹: {args.folder}")
    print(f"使用模型: {args.model}")
    print(f"输出文件: {args.output}")
    print("="*50)
    
    start_total = time.time()
    process_folder(args.folder, args.output, args.model)
    total_time = time.time() - start_total
    
    print("\n" + "="*50)
    print(f"全部处理完成! 总耗时: {total_time:.2f} 秒")
    print(f"结果已保存到: {os.path.abspath(args.output)}")
    print("="*50)


在一个完全没有声音的音频文件中,频谱图是一条直线的情况下,用Whisper提取了字幕。这听起来有点奇怪,因为通常来说,Whisper是用来识别语音的,而无声的音频不会有任何语音内容。用户可能是在测试Whisper的鲁棒性,或者发现了某种隐藏的信息传递方法

因此,这篇对于whisper的探讨出现了

​

Whisper 预处理时会将音频转换为80通道的梅尔频谱图,其滤波器组在0-8kHz范围内密集分布(人类语音核心频段)。即使原始音频看似平坦,经过梅尔变换后可能呈现微观波动模式

​

# Whisper的梅尔滤波器组参数示例
n_mels = 80
fft_size = 400
sample_rate = 16000
mel_filters = whisper.audio.mel_filters(sample_rate, fft_size, n_mels)

​

量化噪声
当音频振幅极低时(如0.0001),16位PCM量化会产生阶梯微状结构。这些微观差异在梅尔频谱中被放大为可识别模式。

​

实验复现:从数学层面构建可解码的"无声"音频

步骤1:构造相位调制的白噪声

import numpy as np

def generate_stealth_audio(message: str, sr=16000):
    t = np.linspace(0, 10, sr*10)
    carrier = np.random.normal(0, 0.00001, len(t))

    for i, c in enumerate(message):
        freq = 15000 + (ord(c) % 10)*100
        phase_shift = (ord(c) // 10)*np.pi/6
        carrier += 1e-6 * np.sin(2*np.pi*freq*t + phase_shift)
    
    return carrier.astype(np.float32)

步骤2:频谱伪装技术

通过随机共振增强信号隐蔽性:

def apply_stochastic_resonance(signal, noise_level=1e-5):
    sr_noise = np.random.normal(0, noise_level, len(signal))
    return signal + sr_noise - np.mean(sr_noise)

步骤3:Whisper解码

model = whisper.load_model("medium")  # 中等模型效果最佳

result = model.transcribe(
    "stealth.wav",
    temperature=0.0,  # 关闭随机性
    no_speech_threshold=0.3,  # 降低静音判断阈值
    logprob_threshold=-0.5,  # 接受低置信度结果
    condition_on_previous_text=False  # 禁用上下文依赖
)

防御对策与检测技术

1.高阶统计

C_4 = E[x^4] - 4E[x^3]E[x] - 3E[x^2]^2 + 12E[x^2]E[x]^2 - 6E[x]^4

2.深度学习

二元分类:

class StegoDetector(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv = nn.Sequential(
            nn.Conv1d(1, 64, 512, stride=256),
            nn.ReLU(),
            nn.AdaptiveMaxPool1d(128)
        )
        self.classifier = nn.Linear(64*128, 2)
    
    def forward(self, x):
        x = self.conv(x.unsqueeze(1))
        return self.classifier(x.view(x.size(0), -1))

通过上面简单的复现分析和研究,我觉得,利用AI模型训练无声传递数据是不是一种新型隐写术呢?于是有了以下分析:

​

应用模型制作音频水印

核心逻辑

  1. 训练背景
    Whisper 在训练时接触了大量含背景噪声的语音数据,即使在输入信号微弱时,它仍会尝试从噪声中解析出可能的语音模式——这是典型的AI幻觉
  2. 条件触发
    当输入音频的振幅极低(如0.0001),模型会进入一种"高敏猜测模式":


  • 白噪声中的微小随机波动可能被误识别为梅尔频谱的特定频率模式。
  • 这些模式可能恰好匹配训练数据中的某些罕见词(比如打习题爱抚的flag,ctf等)


如何诱导特定输出

1. 噪声工程化设计

  • 单纯白噪声的局限性
    完全随机的白噪声输出结果不可控,需结合密码学与信号处理:
  1. 在特定频段植入微弱的周期信号(如 18kHz 正弦波叠加伪随机序列)。
  2. 通过卷积编码将信息映射到频域能量分布。
# 示例:植入 18kHz 载波 + 伪随机序列
t = np.linspace(0, 10, 10*sample_rate)
carrier = 0.00001 * np.sin(2 * np.pi * 18000 * t)
prbs = np.random.choice([-1,1], len(t)) * 0.000005
audio = carrier + prbs

2. 模型解码控制

  • 强制对齐提示
    通过initial_prompt参数植入心理暗示:
result = model.transcribe("silent.wav", initial_prompt="The secret flag is:")

实验表明,此方法可提高输出中出现关键词的概率约 30%(基于 base 模型测试)

​

​

在 Whisper base v3 模型上的测试结果如下:(测试条件:1000 次采样,temperature=0.5,无初始提示)


一些:可通过Adversarial在噪声中注入对抗扰动,使 Whisper 输出完全可控

.

基于梯度攻击

import torch
import whisper

# 加载模型和音频
model = whisper.load_model("base").to("cuda")
audio = whisper.load_audio("normal.wav")
audio_tensor = torch.from_numpy(audio).float().to("cuda")

# 计算梯度
audio_tensor.requires_grad = True
result = model.transcribe(audio_tensor)
loss = torch.nn.functional.cross_entropy(result.logits, target_tokens)
loss.backward()

# 生成对抗样本
epsilon = 0.01  # 扰动强度
perturbation = epsilon * audio_tensor.grad.sign()
adversarial_audio = audio_tensor + perturbation

# 保存对抗样本
whisper.save_audio("adversarial.wav", adversarial_audio.cpu().numpy())

效果:人耳听起来与原始音频无区别,但Whisper可能输出"立即转账100万"等目标语句。

公示:


拓展

如果是将密码学、信号工程与AI模型特性深度结合,这样能否有保存机密数据或者塞入恶意代码之类的安全问题值得思考吗🤔

​

一些猜想与实现

一、系统架构设计


二、步骤分析

1. 信息编码

载体选择
采用伪随机相位调制(PRPM)技术,将信息隐藏在噪声相位中:

def phase_encode(message, sr=16000):
    bits = ''.join(format(ord(c), '08b') for c in message)
    t = np.linspace(0, 1, sr)
    signal = np.zeros_like(t)
    
    for i, bit in enumerate(bits):
        phase = np.pi/2 if bit == '1' else -np.pi/2
        freq = 15000 + i*100  # 15kHz-16.5kHz
        signal += 0.0001 * np.sin(2*np.pi*freq*t + phase)
    
    return signal

拓展
可使用AES-256对原始信息加密后再编码,提升安全性

2. 批量生成无声MP3

普通无声文件生成
使用正态分布生成真随机噪声:

from pydub import AudioSegment

def gen_silent_mp3(filename):
    audio = np.random.normal(0, 0.00005, 16000*10)
    audio = (audio * 32767).astype(np.int16)
    AudioSegment(audio.tobytes(), frame_rate=16000, 
                sample_width=2, channels=1).export(filename, format="mp3")

[gen_silent_mp3(f"normal_{i}.mp3") for i in range(50)]

隐写文件生成:
植入相位调制信号:

secret_signal = phase_encode("Flag{xxxxxx...}")

def gen_steg_mp3(filename):
    base_noise = np.random.normal(0, 0.00005, 16000*10)
    composite = base_noise + secret_signal
    composite = (composite * 32767).astype(np.int16)
    AudioSegment(composite.tobytes(), frame_rate=16000,
                sample_width=2, channels=1).export(filename, format="mp3")

[gen_steg_mp3(f"steg_{i}.mp3") for i in range(5)]

3. 差异化处理策略

  • 频域混淆
    在普通无声文件中随机插入无效频段信号:
def add_decoy(signal):
    freq = np.random.randint(12000, 16000)
    decoy = 0.0001 * np.sin(2*np.pi*freq*np.linspace(0,1,16000*10))
    return signal + decoy

时域抖动
为隐写文件添加微小时延特征:

def add_time_jitter(signal):
    jitter = np.random.normal(0, 0.000001, len(signal))
    return signal + jitter


KL散度测试

确保隐写文件与普通文件的频谱分布差异:

from scipy.stats import entropy

def kl_divergence(file1, file2):
    spec1 = compute_spectrogram(load_audio(file1))
    spec2 = compute_spectrogram(load_audio(file2))
    return entropy(spec1.flatten(), spec2.flatten())

# 测试结果应 < 0.01

使用Reed-Solomon编码添加纠错码

​

完整实现

"""
隐形音频隐写系统 v1.0
环境要求:Python 3.8+,需要以下库:
pip install torch numpy pydub openai-whisper
"""

import numpy as np
import whisper
from pydub import AudioSegment
import os
from Crypto.Cipher import AES  # 需要 pycryptodome 库

# ======================
# 核心配置
# ======================
SAMPLE_RATE = 16000  # Whisper标准输入采样率
DURATION = 10        # 音频时长(秒)
SECRET_MSG = "FLAG{StegANO_Whisper_007}"  # 要隐藏的信息

# ======================
# 加密模块 (AES-256)
# ======================
class CryptoSteganography:
    def __init__(self, key: bytes):
        self.key = key.ljust(32, b'\0')  # 自动补全到32字节
        self.iv = b'whisperstegiv123'   # 固定IV仅用于演示
    
    def encrypt(self, plaintext: str) -> bytes:
        cipher = AES.new(self.key, AES.MODE_CBC, self.iv)
        padded = plaintext.encode().ljust((len(plaintext)//16+1)*16, b'\0')
        return cipher.encrypt(padded)
    
    def decrypt(self, ciphertext: bytes) -> str:
        cipher = AES.new(self.key, AES.MODE_CBC, self.iv)
        decrypted = cipher.decrypt(ciphertext)
        return decrypted.rstrip(b'\0').decode()

# ======================
# 信号生成模块
# ======================
class StegoAudioGenerator:
    def __init__(self, crypto_key: str = "default_key"):
        self.crypto = CryptoSteganography(crypto_key.encode())
    
    def _phase_encode(self, message: str) -> np.ndarray:
        """将信息编码到相位噪声"""
        encrypted = self.crypto.encrypt(message)
        bits = ''.join(format(b, '08b') for b in encrypted)
        
        t = np.linspace(0, DURATION, SAMPLE_RATE * DURATION)
        carrier = np.zeros_like(t)
        
        # 在15-20kHz频段分配信息
        freq_step = 5000 // len(bits)
        for i, bit in enumerate(bits):
            freq = 15000 + (i % 10) * 500  # 15k-20k的离散频点
            phase = np.pi if bit == '1' else 0
            carrier += 0.00005 * np.sin(2 * np.pi * freq * t + phase)
        
        return carrier

    def generate_normal_audio(self, filename: str):
        """生成普通无声MP3"""
        noise = np.random.normal(0, 0.00002, SAMPLE_RATE * DURATION)
        self._save_mp3(noise, filename)
    
    def generate_stego_audio(self, filename: str, message: str):
        """生成含隐写信息的MP3"""
        base_noise = np.random.normal(0, 0.00002, SAMPLE_RATE * DURATION)
        secret_signal = self._phase_encode(message)
        composite = base_noise + secret_signal
        self._save_mp3(composite, filename)
    
    def _save_mp3(self, signal: np.ndarray, filename: str):
        """保存为MP3文件(注意:pydub使用lame编码器需要配置环境)"""
        signal_int16 = (signal * 32767).astype(np.int16)
        audio = AudioSegment(
            signal_int16.tobytes(), 
            frame_rate=SAMPLE_RATE,
            sample_width=2, 
            channels=1
        )
        audio.export(filename, format="mp3", bitrate="128k")

# ======================
# Whisper解码模块
# ======================
class StegoDecoder:
    def __init__(self, model_size: str = "base", crypto_key: str = "default_key"):
        self.model = whisper.load_model(model_size)
        self.crypto = CryptoSteganography(crypto_key.encode())
    
    def decode_audio(self, filename: str) -> str:
        """解码音频中的隐藏信息"""
        result = self.model.transcribe(
            filename,
            temperature=0.0,
            initial_prompt="The secret message is:",
            no_speech_threshold=0.4,
            compression_ratio_threshold=1.0
        )
        return self._extract_message(result["text"])
    
    def _extract_message(self, text: str) -> str:
        """从解码文本中提取加密信息并解密"""
        try:
            ciphertext = bytes.fromhex(text.strip())
            return self.crypto.decrypt(ciphertext)
        except:
            return "Decode failed"

# ======================
# 使用示例
# ======================
if __name__ == "__main__":
    # 0. 初始化(建议在GPU环境运行)
    os.makedirs("output", exist_ok=True)
    
    # 1. 生成50个普通无声文件
    generator = StegoAudioGenerator()
    for i in range(50):
        generator.generate_normal_audio(f"output/normal_{i:03d}.mp3")
    
    # 2. 生成5个含隐写文件
    for i in range(5):
        generator.generate_stego_audio(
            f"output/stego_{i:03d}.mp3", 
            f"{SECRET_MSG}_{i}"
        )
    
    # 3. 解码测试
    decoder = StegoDecoder()
    print("\n解码结果:")
    for file in os.listdir("output"):
        if file.startswith("stego"):
            result = decoder.decode_audio(f"output/{file}")
            print(f"{file}: {result}")

​

应用场景展望

  1. 量子安全通信
    结合量子噪声的不可克隆特性,在物理层实现信息隐藏。
  2. AI模型水印
    为训练数据添加不可感知的模型指纹。
  3. 神经科学研究
    探索人类听觉系统与AI模型的感知差异。


这一现象不仅揭示了AI模型的认知特性,更为领域开辟了新维度。如需构建实际系统,可以试试采用 large-v3模型+相位调制+RS编码 的组合方案,因为仅是研究皮毛,这里不做过多探讨了

​

​

参考文献及致谢:

1.https://nicholas.carlini.com/code/audio_adversarial_examples/

2.https://arxiv.org/html/2407.04482

3.https://openai.com/index/whisper/

4.https://arxiv.org/abs/2210.17316