音乐控制/解密

This commit is contained in:
LFeng committed 2026-09-28 00:21:12 +08:00
1 parent 9e6d73e191
commit ff1d5cd517
41 files changed
+10827 -4

No files matched your search

+324
View File
@@ -0,0 +1,324 @@
//! 音乐模块 · 本地解密的 Tauri 命令层。
//!
//! 与下载链路同构:命令只做参数校验 + 扫描 + 登记任务,立即返回;进度经
//! `music-decrypt-event` 推送。前端 `decryptStore` 常驻监听。
//!
//! 登记位置见 `MUSIC_DECRYPT_PLAN.md` §4.1——**共 3 处**:
//! `music/mod.rs` re-export、`lib.rs` 的 `collect_commands![]` 与 `generate_handler![]`。
use std::path::{Path, PathBuf};
use tauri::{AppHandle, State};
use super::scan;
use super::spawn_batch;
use crate::music::MusicManager;
/// 启动一批本地解密任务。
///
/// 两种输入方式(二选一,`folder` 优先):
/// - `folder`:**文件夹批量**。递归扫描该目录下所有可解密的加密音乐
/// (内容判定优先,见 `scan::route`),并按 `root` 还原相对目录结构。
/// - `files`:显式文件列表(散选场景)。
///
/// `in_place = true` 时产物与源文件同目录同名——文件夹批量推荐这样用,
/// 符合"就地解出来"的直觉;`false` 则统一输出到 `out_dir`。
///
/// 返回 `Ok(())` 表示任务已登记并开始执行;逐文件结果走事件。
#[tauri::command]
#[specta::specta]
pub fn music_decrypt_run(
state: State<'_, MusicManager>,
app: AppHandle,
task_id: String,
files: Option<Vec<String>>,
folder: Option<String>,
root: Option<String>,
out_dir: Option<String>,
in_place: Option<bool>,
) -> Result<(), String> {
if task_id.trim().is_empty() {
return Err("缺少任务 id".into());
}
let in_place = in_place.unwrap_or(false);
let out_dir = resolve_out_dir(out_dir)?;
// ---- 收集待处理文件 ----
let scanned: Vec<scan::ScannedFile> = match folder.as_deref().map(str::trim) {
Some(dir) if !dir.is_empty() => {
let folder_path = PathBuf::from(dir);
let root_path = root
.as_deref()
.map(str::trim)
.filter(|r| !r.is_empty())
.map(PathBuf::from)
.unwrap_or_else(|| folder_path.clone());
let found = scan::scan(&folder_path, Some(&root_path))?;
if found.is_empty() {
return Err(format!(
"{} 里没有找到可解密的加密音乐文件(支持网易云 .ncm 与 QQ音乐 QMC 系列)",
folder_path.display()
));
}
found
}
_ => {
let list = files.unwrap_or_default();
if list.is_empty() {
return Err("未选择任何文件或文件夹".into());
}
// 散选:保留用户给的路径,不做递归;引擎按内容/后缀判定。
// 认不出的文件也建条目,让 worker 回报 unsupported(用户能看到原因)。
list.into_iter()
.map(|f| {
let path = PathBuf::from(&f);
let name = path
.file_name()
.map(|n| n.to_string_lossy().to_string())
.unwrap_or_else(|| f.clone());
// 先算引擎再移动 `path`(否则所有权已转移)
let engine = scan::route(&path).unwrap_or(scan::Engine::Ncm);
scan::ScannedFile {
path,
rel_parent: None,
name,
// 默认为网易云引擎;真实平台由解密器在 worker 内报错说明
engine,
}
})
.collect()
}
};
// ---- 输入输出相交保护(仅非就地模式;就地模式本来就写在源目录)----
let scanned = if in_place {
scanned
} else {
let kept = retain_outside(scanned, &out_dir);
if kept.is_empty() {
return Err("所选文件都位于输出目录内,已全部跳过(可改用「就地解密」)".into());
}
kept
};
if scanned.is_empty() {
return Err("没有可处理的文件".into());
}
let tasks = state.decrypt_tasks();
spawn_batch(app, tasks, task_id, scanned, out_dir, in_place);
Ok(())
}
/// 请求取消一个解密任务。
///
/// 队列级语义(与 `music_download_cancel` 一致):**当前文件会做完**,
/// 剩余文件不再开始处理,随后发一个带 `cancelled` 计数的 `finished` 事件。
/// 返回是否命中了一个在跑的任务(false 通常表示任务已结束)。
#[tauri::command]
#[specta::specta]
pub fn music_decrypt_cancel(
state: State<'_, MusicManager>,
task_id: String,
) -> Result<bool, String> {
Ok(state.decrypt_tasks().cancel(&task_id))
}
/// 扫描一个文件夹,返回可解密文件的数量与平台分布(**不解密**)。
///
/// 给 UI 做预览:用户选完文件夹先看到"找到 N 个(网易云 x / QQ音乐 y)",
/// 而不是直接开跑一个可能包含几千首的任务。
#[tauri::command]
#[specta::specta]
pub fn music_decrypt_scan(folder: String, root: Option<String>) -> Result<ScanSummary, String> {
let root_path = root
.as_deref()
.map(str::trim)
.filter(|r| !r.is_empty())
.map(PathBuf::from);
let found = scan::scan(Path::new(folder.trim()), root_path.as_deref())?;
let ncm = found
.iter()
.filter(|f| f.engine == scan::Engine::Ncm)
.count();
Ok(ScanSummary {
total: found.len(),
ncm,
qmc: found.len() - ncm,
})
}
/// `music_decrypt_scan` 的返回(前端零手写类型)
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, specta::Type)]
#[serde(rename_all = "camelCase")]
pub struct ScanSummary {
pub total: usize,
pub ncm: usize,
pub qmc: usize,
}
/// 探测 QQ 音乐**在线取密钥**能力(新版 musicex 文件解密的前置条件)。
///
/// 只读本机信息,不发网络请求:读 `QQMusicServiceConfig.ini` 的 `uin`,
/// 再从运行中的 `QQMusic.exe` 内存里找 `authst`。
///
/// `authst` **不会**返回给前端(只在后端用于调接口),前端拿到的只有 QQ 号与状态。
#[tauri::command]
#[specta::specta]
pub fn music_decrypt_qq_status() -> Result<super::qq_online::QqOnlineStatus, String> {
Ok(super::qq_online::probe_status())
}
/// 过滤掉位于 `out_dir` 内的输入文件。
///
/// 为什么需要:把输出目录选在输入目录内(或直接选输入目录)时,下一次运行会把
/// 上一次的产物再当输入解一遍,产出 `_1`、`_2` 无限膨胀。
///
/// 路径比较用 `canonicalize`,因此能正确处理 `..`、大小写差异与短路径;
/// **无法规范化(文件不存在/无权限)的路径一律保留**——让 worker 去报"读取失败",
/// 比在这里静默丢弃更好(用户能看到原因)。
fn retain_outside(files: Vec<scan::ScannedFile>, out_dir: &Path) -> Vec<scan::ScannedFile> {
let Ok(out_canon) = out_dir.canonicalize() else {
// 输出目录都规范化不了(理论上不会:resolve_out_dir 刚创建过它),
// 此时放弃这层保护而不是误杀全部输入
return files;
};
files
.into_iter()
.filter(|f| match f.path.canonicalize() {
Ok(abs) => !abs.starts_with(&out_canon),
Err(_) => true,
})
.collect()
}
/// 解析输出目录:显式传入优先,否则回退到应用数据目录下的 `music/decrypted`。
fn resolve_out_dir(out_dir: Option<String>) -> Result<PathBuf, String> {
if let Some(d) = out_dir {
let d = d.trim();
if !d.is_empty() {
let p = PathBuf::from(d);
std::fs::create_dir_all(&p)
.map_err(|e| format!("无法创建输出目录 {}:{e}", p.display()))?;
return Ok(p);
}
}
// 兜底:{app_data}/music/decrypted(前端正常都会传 savedir/decrypted)
let base = dirs::data_dir()
.ok_or_else(|| "无法定位应用数据目录".to_string())?
.join("thing")
.join("music")
.join("decrypted");
std::fs::create_dir_all(&base)
.map_err(|e| format!("无法创建输出目录 {}:{e}", base.display()))?;
Ok(base)
}
#[cfg(test)]
mod tests {
use super::*;
fn tmpdir(tag: &str) -> PathBuf {
let d = std::env::temp_dir().join(format!("dec_cmd_{tag}_{}", std::process::id()));
let _ = std::fs::remove_dir_all(&d);
std::fs::create_dir_all(&d).unwrap();
d
}
fn fake_ncm() -> Vec<u8> {
let mut v = b"CTENFDAM".to_vec();
v.extend_from_slice(&[0x02, 0x00, 0, 0, 0, 0]);
v
}
fn entry(path: PathBuf, rel: Option<&str>) -> scan::ScannedFile {
scan::ScannedFile {
name: path.file_name().unwrap().to_string_lossy().to_string(),
path,
rel_parent: rel.map(PathBuf::from),
engine: scan::Engine::Ncm,
}
}
#[test]
fn retain_outside_drops_inputs_inside_output_dir() {
let root = tmpdir("retain");
let out = root.join("decrypted");
std::fs::create_dir_all(&out).unwrap();
let inside = out.join("a.ncm");
let outside = root.join("b.ncm");
std::fs::write(&inside, fake_ncm()).unwrap();
std::fs::write(&outside, fake_ncm()).unwrap();
let kept = retain_outside(vec![entry(inside, None), entry(outside, None)], &out);
assert_eq!(kept.len(), 1, "应只保留输出目录外的文件");
assert!(kept[0].path.ends_with("b.ncm"));
let _ = std::fs::remove_dir_all(&root);
}
#[test]
fn retain_outside_drops_nested_paths() {
let root = tmpdir("nested");
let out = root.join("decrypted");
let deep = out.join("2026").join("07");
std::fs::create_dir_all(&deep).unwrap();
let f = deep.join("c.ncm");
std::fs::write(&f, fake_ncm()).unwrap();
let kept = retain_outside(vec![entry(f, None)], &out);
assert!(kept.is_empty(), "输出目录的子目录也应视为相交");
let _ = std::fs::remove_dir_all(&root);
}
#[test]
fn retain_outside_keeps_unresolvable_paths() {
let root = tmpdir("unresolvable");
let out = root.join("decrypted");
std::fs::create_dir_all(&out).unwrap();
let ghost = root.join("not-here").join("ghost.ncm");
let kept = retain_outside(vec![entry(ghost, None)], &out);
assert_eq!(kept.len(), 1, "不存在的输入不应被静默丢弃");
let _ = std::fs::remove_dir_all(&root);
}
#[test]
fn resolve_out_dir_uses_explicit_value() {
let root = tmpdir("outdir");
let target = root.join("my").join("out");
let got = resolve_out_dir(Some(target.to_string_lossy().to_string())).unwrap();
assert_eq!(got, target);
assert!(target.is_dir(), "输出目录应被创建");
let fallback = resolve_out_dir(Some(" ".into())).unwrap();
assert!(fallback.ends_with("decrypted"));
assert!(fallback.is_dir());
let _ = std::fs::remove_dir_all(&root);
}
/// 文件夹扫描的汇总(UI 预览用)
#[test]
fn scan_summary_counts_per_engine() {
let root = tmpdir("summary");
std::fs::write(root.join("a.ncm"), fake_ncm()).unwrap();
std::fs::write(root.join("b.qmcflac"), vec![0x22u8; 4096]).unwrap();
std::fs::write(root.join("c.mgg"), vec![0x22u8; 4096]).unwrap();
std::fs::write(root.join("d.mp3"), vec![0x44u8; 1024]).unwrap();
let found = scan::scan(&root, None).unwrap();
let ncm = found
.iter()
.filter(|f| f.engine == scan::Engine::Ncm)
.count();
assert_eq!(found.len(), 3, "mp3 不应被计入");
assert_eq!(ncm, 1);
assert_eq!(found.len() - ncm, 2);
let _ = std::fs::remove_dir_all(&root);
}
}
+266
View File
@@ -0,0 +1,266 @@
//! 本地解密的**统一错误类型与公共格式探测**。
//!
//! 两个引擎([`super::ncm`] 网易云 / [`super::qmc`] QQ音乐)各自的内部错误不同,
//! 但调度层只关心「可读的中文原因」,因此都收敛到 [`DecryptError`]。
//!
//! 输出扩展名统一由 [`detect_format`] 按**音频首帧魔数**判定——
//! 两个平台都不信任容器里声明的格式字段(详见 `MUSIC_DECRYPT_PLAN.md` §3.1⑥ / §3.2 末)。
use std::fmt;
use std::path::PathBuf;
/// 解密失败原因。全部经 `to_string()` 上报为 per-file 失败,**不 panic**
/// (否则一个坏文件会带走整批任务)。
#[derive(Debug)]
pub enum DecryptError {
Io(String),
/// 文件不属于本引擎认得的加密格式
NotEncrypted(String),
/// 容器/尾部结构残缺
Broken(String),
/// 缺少解密密钥(QQ QMC2 的 ekey 情况),文案要能给用户下一步动作
KeyRequired(String),
/// 输出失败
Output(String),
}
impl fmt::Display for DecryptError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
DecryptError::Io(e) => write!(f, "读取失败:{e}"),
DecryptError::NotEncrypted(e) => write!(f, "{e}"),
DecryptError::Broken(e) => write!(f, "文件结构损坏:{e}"),
DecryptError::KeyRequired(e) => write!(f, "{e}"),
DecryptError::Output(e) => write!(f, "输出失败:{e}"),
}
}
}
impl std::error::Error for DecryptError {}
impl From<std::io::Error> for DecryptError {
fn from(e: std::io::Error) -> Self {
DecryptError::Io(e.to_string())
}
}
pub type Result<T> = std::result::Result<T, DecryptError>;
/// 解密产物(两引擎统一形状)
#[derive(Debug, Clone)]
pub struct Outcome {
pub output: PathBuf,
/// 落盘用的扩展名(由首帧魔数判定)
pub format: String,
/// 单独落盘的封面(没有则为 None)
pub cover: Option<PathBuf>,
/// 音频明文字节数
pub audio_bytes: u64,
/// 给 UI 的一行备注(平台 / 密钥形态 / 元数据摘要)。
///
/// 结构化元数据目前只用来拼这一行——P2 做标签回填时再把 `NcmMeta` 提升到
/// `Outcome` 上,不要提前加一个没人读的字段。
pub note: String,
}
/// 按音频首帧魔数判定输出扩展名。
///
/// **这是权威来源**:ncm 的 `format` 字段、QMC 的输入后缀都只是声明,
/// 不可信(QKKDecrypt 同样以内容探测为准)。
pub fn detect_format(head: &[u8]) -> &'static str {
detect_format_opt(head).unwrap_or("flac")
}
/// 同上,但认不出时返回 `None`(调用方可据此决定是否回退到后缀/声明格式)。
pub fn detect_format_opt(head: &[u8]) -> Option<&'static str> {
let starts = |m: &[u8]| head.len() >= m.len() && &head[..m.len()] == m;
if starts(b"fLaC") {
Some("flac")
} else if starts(b"OggS") {
Some("ogg")
} else if starts(b"ID3") || (head.len() >= 2 && head[0] == 0xFF && head[1] & 0xE0 == 0xE0) {
// ID3 标签,或无标签 MP3 的帧同步字(0xFFEx / 0xFFFx)
Some("mp3")
} else if starts(b"RIFF") && head.len() >= 12 && &head[8..12] == b"WAVE" {
Some("wav")
} else if head.len() >= 12 && &head[4..8] == b"ftyp" {
Some("m4a")
} else if starts(b"wvpk") {
Some("wv")
} else {
None
}
}
/// 图片扩展名(按魔数)
pub fn image_ext(data: &[u8]) -> &'static str {
const PNG: &[u8] = &[0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A];
if data.len() >= 8 && &data[..8] == PNG {
"png"
} else {
"jpg"
}
}
/// 确保输出目录存在并返回「按相对目录展开后」的目标目录。
///
/// 文件夹批量模式要保留原目录结构(`Pop/a.mflac` → `out/Pop/a.flac`),
/// 否则不同子目录的同名文件会在输出根目录里互相挤兑(虽然去重逻辑会让位成
/// `_1`,但产物与源的对应关系就丢了)。
pub fn ensure_subdir(
dir: &std::path::Path,
rel_parent: Option<&std::path::Path>,
) -> Result<PathBuf> {
let target = match rel_parent {
Some(rel) if !rel.as_os_str().is_empty() => dir.join(rel),
_ => dir.to_path_buf(),
};
std::fs::create_dir_all(&target)?;
Ok(target)
}
/// 在 `dir` 下为 `stem` + `ext` 找一个不冲突的输出路径。
///
/// 不同来源的同名文件若直接扁平落盘会**互相覆盖**,故占用时追加 `_1`/`_2`…
/// `reserved` 是本批次内已占用的名字(磁盘上尚不存在的也算)。
pub fn unique_output(
dir: &std::path::Path,
stem: &str,
ext: &str,
reserved: &mut std::collections::HashSet<String>,
) -> Result<PathBuf> {
let mut candidate = dir.join(format!("{stem}.{ext}"));
let mut n = 1;
loop {
let key = candidate.to_string_lossy().to_lowercase();
if !candidate.exists() && !reserved.contains(&key) {
reserved.insert(key);
return Ok(candidate);
}
candidate = dir.join(format!("{stem}_{n}.{ext}"));
n += 1;
if n > 9999 {
return Err(DecryptError::Output(format!(
"无法为 {stem} 找到不冲突的输出名"
)));
}
}
}
/// 读满 `buf` 或读到 EOF,返回实际字节数。
///
/// 与 `Read::read` 的关键区别:**只有 EOF 才会提前返回**,不会因为底层缓冲的
/// 短读而返回半个块。流密码解密的块边界必须与加密侧严格一致,
/// 否则相位错位、文件中途变噪声(`MUSIC_DECRYPT_PLAN.md` §6.24)。
pub fn read_full(r: &mut impl std::io::Read, buf: &mut [u8]) -> Result<usize> {
let mut filled = 0usize;
while filled < buf.len() {
match r.read(&mut buf[filled..]) {
Ok(0) => break,
Ok(n) => filled += n,
Err(e) if e.kind() == std::io::ErrorKind::Interrupted => continue,
Err(e) => return Err(DecryptError::Io(e.to_string())),
}
}
Ok(filled)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn detect_format_by_magic() {
assert_eq!(detect_format(b"fLaC\x00\x00\x00\x22"), "flac");
assert_eq!(detect_format(b"OggS\x00\x02"), "ogg");
assert_eq!(detect_format(b"ID3\x04\x00"), "mp3");
assert_eq!(detect_format(&[0xFF, 0xFB, 0x90, 0x00]), "mp3");
assert_eq!(detect_format(b"RIFF\x00\x00\x00\x00WAVEfmt "), "wav");
assert_eq!(detect_format(b"\x00\x00\x00\x20ftypM4A "), "m4a");
assert_eq!(detect_format(b"wvpk\x00\x00"), "wv");
assert_eq!(detect_format(b"\x00\x01\x02\x03"), "flac");
}
#[test]
fn image_ext_by_magic() {
assert_eq!(
image_ext(&[0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]),
"png"
);
assert_eq!(image_ext(&[0xFF, 0xD8, 0xFF, 0xE0]), "jpg");
}
#[test]
fn unique_output_appends_suffix_on_collision() {
let dir = std::env::temp_dir().join(format!("dec_unique_{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let mut reserved = std::collections::HashSet::new();
let a = unique_output(&dir, "song", "flac", &mut reserved).unwrap();
assert_eq!(a.file_name().unwrap(), "song.flac");
let b = unique_output(&dir, "song", "flac", &mut reserved).unwrap();
assert_eq!(b.file_name().unwrap(), "song_1.flac");
let c = unique_output(&dir, "song", "mp3", &mut reserved).unwrap();
assert_eq!(c.file_name().unwrap(), "song.mp3");
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn ensure_subdir_preserves_relative_structure() {
let root = std::env::temp_dir().join(format!("dec_subdir_{}", std::process::id()));
let _ = std::fs::remove_dir_all(&root);
std::fs::create_dir_all(&root).unwrap();
// 无相对目录 → 输出根
let flat = ensure_subdir(&root, None).unwrap();
assert_eq!(flat, root);
// 有相对目录 → 逐级创建
let nested = ensure_subdir(
&root,
Some(std::path::Path::new("Pop").join("2026").as_path()),
)
.unwrap();
assert!(nested.is_dir());
assert!(nested.ends_with("Pop/2026") || nested.ends_with(r"Pop\2026"));
let _ = std::fs::remove_dir_all(&root);
}
#[test]
fn read_full_returns_whole_buffer() {
// 一个每次只吐 3 字节的 reader:read_full 必须凑满整个 buf
struct Drip {
data: Vec<u8>,
pos: usize,
}
impl std::io::Read for Drip {
fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
if self.pos >= self.data.len() {
return Ok(0);
}
let n = buf.len().min(3).min(self.data.len() - self.pos);
buf[..n].copy_from_slice(&self.data[self.pos..self.pos + n]);
self.pos += n;
Ok(n)
}
}
let src: Vec<u8> = (0..100u8).collect();
let mut r = Drip {
data: src.clone(),
pos: 0,
};
let mut buf = [0u8; 64];
let n = read_full(&mut r, &mut buf).unwrap();
assert_eq!(n, 64, "短读 reader 也必须凑满整块");
assert_eq!(&buf[..], &src[..64]);
// 末尾不足一块时返回实际长度
let n2 = read_full(&mut r, &mut buf).unwrap();
assert_eq!(n2, 36);
let n3 = read_full(&mut r, &mut buf).unwrap();
assert_eq!(n3, 0, "EOF 返回 0");
}
}
+624
View File
@@ -0,0 +1,624 @@
//! 音乐模块 · 本地解密(`music/decrypt/`)。
//!
//! 挂靠音乐模块的「解密」页签,与下载链路同构:命令先回一个 `taskId`,
//! 之后所有进度经 `music-decrypt-event` 推送(前端 `decryptStore` 常驻监听,
//! 页签切换卸载组件也不影响任务)。
//!
//! ## 分工
//!
//! - [`ncm`]:网易云 `.ncm` 的**纯 Rust 离线**引擎(P0 全部范围)。
//! - `qq`(P1,未实施):QQ 音乐三层路由(内嵌 ekey 离线 → musicex API → Frida 兜底)。
//! 见 `MUSIC_DECRYPT_PLAN.md` §3.2。
//! - [`commands`]:Tauri 命令层(run / cancel)。
//!
//! ## 为什么事件在独立线程里发
//!
//! 解密是 CPU + 磁盘密集的同步流程,每读一块就要回报进度。把它放在
//! `spawn_blocking` 里再逐块 `emit` 会阻塞 tokio 的工作线程;
//! 这里改为「`std::thread` 干活 + `mpsc` 回传事件 + 异步任务节流转发」,
//! 读盘线程最多被 `mpsc::send` 短暂挡住,不碰 tokio 运行时。
//!
//! 进度**按时间节流**([`PROGRESS_INTERVAL`]):单个大文件有成千上万个 32KB 块,
//! 不节流会把 WebView 的事件通道打满。
pub mod commands;
pub mod common;
pub mod ncm;
pub mod probe;
pub mod qmc;
pub mod qq_credentials;
pub mod qq_ekey;
pub mod qq_footer;
pub mod qq_online;
pub mod scan;
/// QQ 音乐进程内存扫描:纯 Win32 实现,非 Windows 平台不编译。
#[cfg(windows)]
pub mod qq_memscan;
use std::collections::HashMap;
use std::path::PathBuf;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{mpsc, Arc, Mutex};
use std::time::{Duration, Instant};
use serde::{Deserialize, Serialize};
use specta::Type;
use tauri::{AppHandle, Emitter};
use common::DecryptError;
/// 进度事件的最小间隔
pub const PROGRESS_INTERVAL: Duration = Duration::from_millis(300);
/// 单文件处理结果的三个状态
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "lowercase")]
pub enum FileStatus {
/// 解密成功
Ok,
/// 失败(`message` 为可读原因)
Error,
/// 该文件不属于本平台/本阶段支持范围
Unsupported,
}
/// 推送给前端的事件负载(与 `src/lib/bindings.ts` / `decryptStore.ts` 对应)。
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[serde(tag = "type", rename_all = "kebab-case")]
pub enum DecryptEvent {
/// 批次开始,`total` 为待处理文件数
Start { task_id: String, total: usize },
/// 单个文件处理完毕
File {
task_id: String,
/// 0-based 序号,与任务表行一一对应
index: usize,
name: String,
status: FileStatus,
/// 失败原因,或成功时的备注(平台 / 密钥形态)
message: Option<String>,
/// 主产物路径
output: Option<String>,
/// 单独落盘的封面(网易云 ncm 带内嵌封面时才有)
cover: Option<String>,
},
/// 进度(节流后)
Progress {
task_id: String,
done: usize,
total: usize,
/// 当前文件已处理字节数 / 总字节数(0 表示未知)
bytes_done: u64,
bytes_total: u64,
name: String,
},
/// 批次结束
Finished {
task_id: String,
ok: usize,
failed: usize,
/// 被取消时尚未处理的文件数
cancelled: usize,
},
}
/// 任务表条目。只存「是否被要求取消」,不存进度——
/// 进度的权威在前端 store(事件即真相),Rust 侧不需要镜像状态。
pub struct DecryptTasks {
inner: Mutex<HashMap<String, Arc<AtomicBool>>>,
}
impl Default for DecryptTasks {
fn default() -> Self {
Self::new()
}
}
impl DecryptTasks {
pub fn new() -> Self {
Self {
inner: Mutex::new(HashMap::new()),
}
}
/// 登记一个任务并返回它的取消标志
pub fn register(&self, task_id: &str) -> Arc<AtomicBool> {
let flag = Arc::new(AtomicBool::new(false));
if let Ok(mut m) = self.inner.lock() {
m.insert(task_id.to_string(), flag.clone());
}
flag
}
/// 请求取消;返回是否命中了一个在跑的任务
pub fn cancel(&self, task_id: &str) -> bool {
match self.inner.lock() {
Ok(m) => match m.get(task_id) {
Some(flag) => {
flag.store(true, Ordering::SeqCst);
true
}
None => false,
},
Err(_) => false,
}
}
pub fn finish(&self, task_id: &str) {
if let Ok(mut m) = self.inner.lock() {
m.remove(task_id);
}
}
}
/// 线程 → 异步任务的事件通道消息
enum Msg {
Progress {
bytes_done: u64,
bytes_total: u64,
name: String,
},
File {
index: usize,
name: String,
status: FileStatus,
message: Option<String>,
output: Option<String>,
cover: Option<String>,
},
/// 批次结束。**必须走通道**——否则它会在转发线程尚未冲出积压的
/// `File` 事件之前就被 `emit`,前端会先看到"完成"再看到最后几个文件的结果。
Finished {
ok: usize,
failed: usize,
cancelled: usize,
},
}
/// 该文件是否是「需要联网取密钥」的形态(musicex)。
///
/// 只读尾部 192 字节,代价可忽略;用作"离线失败后要不要转在线"的判据,
/// 避免对普通失败(如尾部损坏)也去发起网络请求。
fn needs_online(path: &std::path::Path) -> bool {
use std::io::{Read, Seek, SeekFrom};
let Ok(mut f) = std::fs::File::open(path) else {
return false;
};
let Ok(size) = f.metadata().map(|m| m.len()) else {
return false;
};
let take = (qq_footer::MUSICEX_FOOTER_LEN as u64).min(size) as usize;
if take < 8 || f.seek(SeekFrom::End(-(take as i64))).is_err() {
return false;
}
let mut buf = vec![0u8; take];
if f.read_exact(&mut buf).is_err() {
return false;
}
qq_footer::is_musicex_tail(&buf)
}
/// 启动一个解密批次:登记任务 → 起工作线程 → 异步转发事件。
///
/// 调用方(`commands::music_decrypt_run`)已完成参数校验与目录扫描;本函数只负责调度。
///
/// `in_place = true` 时**忽略 `out_dir`**,产物与源文件同目录同名(扩展名按格式改)。
/// 这是文件夹批量的默认方式——用户的期望是"就地解出来",而不是去另一个目录找。
pub fn spawn_batch(
app: AppHandle,
tasks: Arc<DecryptTasks>,
task_id: String,
files: Vec<scan::ScannedFile>,
out_dir: PathBuf,
in_place: bool,
) {
let flag = tasks.register(&task_id);
let (tx, rx) = mpsc::channel::<Msg>();
let total_files = files.len();
// ---- 工作线程:逐文件解密 ----
let worker_task_id = task_id.clone();
let worker_tasks = tasks.clone();
std::thread::Builder::new()
.name(format!("music-decrypt-{task_id}"))
.spawn(move || {
let total = files.len();
// 批次内已占用的输出名(防同名互相覆盖,见 common::unique_output)
let mut reserved = std::collections::HashSet::new();
let mut ok = 0usize;
let mut failed = 0usize;
let mut cancelled = 0usize;
let mut done = 0usize;
for (index, job) in files.iter().enumerate() {
if flag.load(Ordering::SeqCst) {
cancelled = total - done;
break;
}
// 输出目录:就地模式与源文件同目录;否则按相对目录还原结构
let target_dir = if in_place {
job.path
.parent()
.map(|p| p.to_path_buf())
.unwrap_or_else(|| out_dir.clone())
} else {
common::ensure_subdir(&out_dir, job.rel_parent.as_deref())
.unwrap_or_else(|_| out_dir.clone())
};
// 进度回调:只在文件内部回报,节流交给接收端
let tx_progress = tx.clone();
let name = job.name.clone();
// 「网易云 / QQ音乐」前缀由调度层给出——引擎自己不该知道路由结果
let label = job.engine.label();
let mut progress_cb = |bytes_done: u64, bytes_total: u64| {
let _ = tx_progress.send(Msg::Progress {
bytes_done,
bytes_total,
name: name.clone(),
});
};
let result = match job.engine {
scan::Engine::Ncm => ncm::decrypt_file(
&job.path,
&target_dir,
label,
&mut reserved,
&mut progress_cb,
),
// musicex 的 ekey 不在文件里,离线路径会返回明确的 KeyRequired;
// 命中该形态时改走「本机凭据 → 在线取密钥」。
scan::Engine::Qmc => {
let offline = qmc::decrypt_file(
&job.path,
&target_dir,
label,
&mut reserved,
&mut progress_cb,
);
match offline {
Err(DecryptError::KeyRequired(_)) if needs_online(&job.path) => {
qq_online::decrypt_musicex(
&job.path,
&target_dir,
label,
&mut progress_cb,
)
}
other => other,
}
}
};
done += 1;
match result {
Ok(res) => {
ok += 1;
crate::logger::log_info(
"music-decrypt",
&format!(
"{} → {}({},{} 字节)",
job.path.display(),
res.output.display(),
res.format,
res.audio_bytes
),
);
let _ = tx.send(Msg::File {
index,
name: job.name.clone(),
status: FileStatus::Ok,
// 成功时把备注(平台/密钥形态)与产物一起回报
message: Some(res.note),
output: Some(res.output.to_string_lossy().to_string()),
cover: res.cover.map(|c| c.to_string_lossy().to_string()),
});
}
Err(e) => {
failed += 1;
crate::logger::log_warn(
"music-decrypt",
&format!("{} 解密失败:{e}", job.path.display()),
);
let _ = tx.send(Msg::File {
index,
name: job.name.clone(),
status: FileStatus::Error,
message: Some(e.to_string()),
output: None,
cover: None,
});
}
}
// 文件收尾时必推一次,保证进度条不因节流停在中间
let _ = tx.send(Msg::Progress {
bytes_done: done as u64,
bytes_total: total as u64,
name: job.name.clone(),
});
}
// 通道关闭 → 接收端读完剩余消息后收尾
let _ = tx.send(Msg::Finished {
ok,
failed,
cancelled,
});
drop(tx);
worker_tasks.finish(&worker_task_id);
})
.expect("无法创建解密工作线程");
// ---- 异步转发:节流 + 顺序保证 ----
//
// 语义:
// - `File` 事件(含文件收尾的那次 Progress)**立即转发**,否则结果会看起来卡在末尾。
// - 文件内部的逐块 Progress 只保留最新一条,按 [`PROGRESS_INTERVAL`] 最多发一次,
// 避免单个大文件的成千上万个块把 WebView 事件通道打满。
tauri::async_runtime::spawn(async move {
let mut last_progress: Option<Msg> = None;
let mut last_emit = Instant::now() - PROGRESS_INTERVAL;
let mut current_index = 0usize;
// 批内文件总数:与下面 Start 事件取同一份来源
let current_total = total_files;
// Start 先发:它必须在任何 Progress/File 之前到达,前端据此建行。
let _ = app.emit(
crate::constants::events::MUSIC_DECRYPT_EVENT,
&DecryptEvent::Start {
task_id: task_id.clone(),
total: total_files,
},
);
loop {
// 单次 recv_timeout 同时兼顾「有消息就收」和「到点就 flush」
let msg = match rx.recv_timeout(PROGRESS_INTERVAL) {
Ok(m) => Some(m),
Err(mpsc::RecvTimeoutError::Timeout) => None,
Err(mpsc::RecvTimeoutError::Disconnected) => break,
};
match msg {
Some(Msg::Progress {
bytes_done,
bytes_total,
name,
}) => {
// 攒着;下面的 flush 决定何时真正发出
last_progress = Some(Msg::Progress {
bytes_done,
bytes_total,
name,
});
}
Some(Msg::File {
index,
name,
status,
message,
output,
cover,
}) => {
// 结果事件优先:先把攒住的进度冲掉,再发结果,保证顺序自然
flush_progress(
&app,
&task_id,
&mut last_progress,
&mut last_emit,
current_index,
current_total,
);
let _ = app.emit(
crate::constants::events::MUSIC_DECRYPT_EVENT,
&DecryptEvent::File {
task_id: task_id.clone(),
index,
name,
status,
message,
output,
cover,
},
);
current_index = index + 1;
}
Some(Msg::Finished {
ok,
failed,
cancelled,
}) => {
// 收尾前把攒住的进度冲掉,再发 Finished,保证前端不丢最后一格进度
last_emit = Instant::now() - PROGRESS_INTERVAL;
flush_progress(
&app,
&task_id,
&mut last_progress,
&mut last_emit,
current_index,
current_total,
);
let _ = app.emit(
crate::constants::events::MUSIC_DECRYPT_EVENT,
&DecryptEvent::Finished {
task_id: task_id.clone(),
ok,
failed,
cancelled,
},
);
// 通道随后关闭,循环自然退出
}
None => { /* 超时,走下面的 flush */ }
}
flush_progress(
&app,
&task_id,
&mut last_progress,
&mut last_emit,
current_index,
current_total,
);
}
});
}
/// 到点则把攒下的最新一条进度发出(最多每 [`PROGRESS_INTERVAL`] 一次)。
fn flush_progress(
app: &AppHandle,
task_id: &str,
pending: &mut Option<Msg>,
last_emit: &mut Instant,
index: usize,
total: usize,
) {
if pending.is_none() || last_emit.elapsed() < PROGRESS_INTERVAL {
return;
}
if let Some(Msg::Progress {
bytes_done,
bytes_total,
name,
}) = pending.take()
{
*last_emit = Instant::now();
let _ = app.emit(
crate::constants::events::MUSIC_DECRYPT_EVENT,
&DecryptEvent::Progress {
task_id: task_id.to_string(),
// index = 当前正在处理的文件序号(已完成的文件数)
done: index,
total,
bytes_done,
bytes_total,
name,
},
);
}
}
#[cfg(test)]
mod tests {
use super::*;
/// **跨端契约**:事件的实际 JSON 形状是前端 `decryptStore.ts` 里 `RawEvent`
/// 的镜像。曾经打算写 camelCase(`taskId`),但枚举上只有 `tag` 带了
/// `rename_all`,**字段名仍是 snake_case**——两边不一致时不会编译报错,
/// 只会表现为「任务建好了但进度永远不动」。这个测试把形状钉死。
#[test]
fn event_json_contract() {
let start = serde_json::to_value(DecryptEvent::Start {
task_id: "t1".into(),
total: 3,
})
.unwrap();
assert_eq!(
start,
serde_json::json!({ "type": "start", "task_id": "t1", "total": 3 })
);
let file = serde_json::to_value(DecryptEvent::File {
task_id: "t1".into(),
index: 2,
name: "a.ncm".into(),
status: FileStatus::Error,
message: Some("坏了".into()),
output: None,
cover: None,
})
.unwrap();
assert_eq!(
file,
serde_json::json!({
"type": "file", "task_id": "t1", "index": 2, "name": "a.ncm",
"status": "error", "message": "坏了", "output": null, "cover": null
})
);
let progress = serde_json::to_value(DecryptEvent::Progress {
task_id: "t1".into(),
done: 1,
total: 3,
bytes_done: 10,
bytes_total: 100,
name: "a.ncm".into(),
})
.unwrap();
assert_eq!(
progress,
serde_json::json!({
"type": "progress", "task_id": "t1", "done": 1, "total": 3,
"bytes_done": 10, "bytes_total": 100, "name": "a.ncm"
})
);
let finished = serde_json::to_value(DecryptEvent::Finished {
task_id: "t1".into(),
ok: 2,
failed: 1,
cancelled: 0,
})
.unwrap();
assert_eq!(
finished,
serde_json::json!({
"type": "finished", "task_id": "t1", "ok": 2, "failed": 1, "cancelled": 0
})
);
}
/// `FileStatus` 的三个取值必须是前端 `DecryptFileStatus` 认得的字面量
#[test]
fn file_status_variants_are_lowercase() {
let j = |s| serde_json::to_string(&s).unwrap();
assert_eq!(j(FileStatus::Ok), "\"ok\"");
assert_eq!(j(FileStatus::Error), "\"error\"");
assert_eq!(j(FileStatus::Unsupported), "\"unsupported\"");
}
/// 平台路由见 `scan::route`(内容优先于后缀)——这里只验证单测覆盖到的路径。
#[test]
fn engine_route_by_content_and_extension() {
use scan::Engine;
let dir = std::env::temp_dir().join(format!("dec_route_{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
// 网易云:只看魔数,后缀随便
let ncm = dir.join("x.bin");
let mut bytes = b"CTENFDAM".to_vec();
bytes.extend_from_slice(&[0x02, 0x00, 0, 0, 0, 0]);
std::fs::write(&ncm, &bytes).unwrap();
assert_eq!(scan::route(&ncm), Some(Engine::Ncm));
// QQ:后缀在家族里
let qmc = dir.join("y.qmcflac");
std::fs::write(&qmc, vec![0x22u8; 4096]).unwrap();
assert_eq!(scan::route(&qmc), Some(Engine::Qmc));
// 普通音频文件不应被认领
let mp3 = dir.join("z.mp3");
std::fs::write(&mp3, vec![0x44u8; 4096]).unwrap();
assert_eq!(scan::route(&mp3), None);
let _ = std::fs::remove_dir_all(&dir);
}
#[test]
fn task_registry_register_cancel_finish() {
let tasks = DecryptTasks::new();
let flag = tasks.register("t1");
assert!(!flag.load(Ordering::SeqCst));
// 取消命中
assert!(tasks.cancel("t1"));
assert!(flag.load(Ordering::SeqCst));
// 未登记的任务取消不报错、返回 false
assert!(!tasks.cancel("nope"));
tasks.finish("t1");
assert!(!tasks.cancel("t1"), "已结束的任务不应再被取消");
}
}
+734
View File
@@ -0,0 +1,734 @@
//! 网易云音乐 `.ncm` 离线解密引擎(纯 Rust,无外部依赖、无运行时前置)。
//!
//! 算法对照 **MIT 协议** 的 `taurusxin/ncmdump`(`src/ncmcrypt.cpp`)独立重写。
//! 下面每个常量与分支都对应容器里的一个实际字段,注释里标了「为什么」——
//! 这几处正是最容易写错的地方,改动前请先读 `MUSIC_DECRYPT_PLAN.md` §3.1。
//!
//! ## 容器结构
//!
//! ```text
//! 0x00 magic 8B "CTENFDAM"
//! 0x08 2B 固定跳过
//! 0x0A key_len 4B LE
//! key_data XOR 0x64 → AES-128-ECB → 跳 17B → RC4 密钥盒种子
//! meta_len 4B LE
//! meta_data XOR 0x63 → 去 22B 前缀 → base64 → AES-128-ECB → 去 6B 前缀 → JSON
//! 5B 固定跳过(CRC32 4B + 图片版本 1B)
//! cover_len 4B LE / img_len 4B LE / img_data → 跳 cover_len - img_len
//! audio 剩余全部(RC4 变体,按 0x8000 分块)
//! ```
//!
//! 两段 XOR 常量不同(`0x64` / `0x63`)、AES 收尾是 PKCS#7 风格 padding、
//! 密钥盒 KSA 带 `last_byte` 累加——任一写错都会全量解错,
//! 且不会报错,只会产出乱码音频。
use std::fs::File;
use std::io::{BufReader, BufWriter, Read, Write};
use std::path::Path;
use aes::cipher::generic_array::GenericArray;
use aes::cipher::{BlockDecrypt, KeyInit};
use aes::Aes128;
use super::common::{self, DecryptError};
/// 头部魔数(ASCII `CTENFDAM`)
const MAGIC: &[u8; 8] = b"CTENFDAM";
/// key 段的 XOR 常量
const XOR_KEY: u8 = 0x64;
/// meta 段的 XOR 常量(**与 key 段不同**)
const XOR_META: u8 = 0x63;
/// key 段解密后需跳过的前缀:ASCII `neteasecloudmusic`(17 字节,含结尾 NUL)
const CORE_KEY: &[u8; 17] = b"neteasecloudmusic";
/// key 段 **AES 密钥**:ASCII `neteasecloudmusi`——`CORE_KEY` 的前 16 字节。
///
/// 注意与上面 17 字节的「前缀」区分:前缀(`neteasecloudmusic\0`,17B)是解密后
/// 要从明文里剥掉的,AES 密钥(16B)是用来解密的。`aes::Aes128` 只吃 16 字节。
const CORE_AES_KEY: &[u8; 16] = b"neteasecloudmusi";
/// meta 段 AES 密钥:ASCII `#14ljk_!\]&0U<'(`(**与 CORE_KEY 不同**,别复用)
///
/// 注意是 16 字节而非 17——`aes::Aes128` 的密钥长度就是 16。
const MODIFY_KEY: &[u8; 16] = b"#14ljk_!\\]&0U<'(";
/// meta 段 base64 之前的字面量前缀
const META_PREFIX: &[u8] = b"163 key(Don't modify):";
/// meta 段 AES 解密后的字面量前缀
const META_JSON_PREFIX: &[u8] = b"music:";
/// 音频段分块大小。**块之间不额外跳字节**——这个值只是读写块大小。
const CHUNK: usize = 0x8000;
/// ncm 内嵌元数据(meta 段 JSON 的子集)
#[derive(Debug, Clone, Default)]
pub struct NcmMeta {
pub name: Option<String>,
pub artist: Option<String>,
pub album: Option<String>,
pub bitrate: Option<u64>,
pub duration: Option<u64>,
/// 容器内声明的格式。**不用于决定输出扩展名**(那只认音频首帧魔数)。
pub format: Option<String>,
}
/// 本模块的错误类型 = 公共错误类型([`DecryptError`]),
/// 便于调度层对两个引擎用同一套 `?` 与文案处理。
pub type NcmError = DecryptError;
type Result<T> = std::result::Result<T, DecryptError>;
/// AES-128-ECB 解密 + PKCS#7 风格去 padding。
///
/// `aes` crate 只提供块原语(且本项目依赖树里**没有** `ecb` crate),
/// 故这里手写块循环。收尾不是「去前缀」而是取最后一字节当 padding 长度——
/// 这一点在 `MUSIC_DECRYPT_PLAN.md` §3.1③ 有说明。
fn aes_ecb_decrypt(key: &[u8], data: &[u8]) -> Result<Vec<u8>> {
if key.len() != 16 {
return Err(NcmError::Broken(format!(
"AES 密钥长度应为 16,实为 {}",
key.len()
)));
}
if data.is_empty() || data.len() % 16 != 0 {
return Err(NcmError::Broken(format!(
"AES 密文长度 {} 不是 16 的正整数倍",
data.len()
)));
}
let cipher = Aes128::new(GenericArray::from_slice(key));
let blocks = data.len() / 16;
let mut out = Vec::with_capacity(data.len());
let mut buf = [0u8; 16];
for i in 0..blocks {
let block = GenericArray::from_slice(&data[i * 16..i * 16 + 16]);
cipher.decrypt_block_b2b(block, GenericArray::from_mut_slice(&mut buf));
// 最后一块按 padding 截断:末字节即填充长度,>16 视为无填充
if i == blocks - 1 {
let pad = if buf[15] > 16 { 0 } else { buf[15] as usize };
out.extend_from_slice(&buf[..16 - pad.min(16)]);
} else {
out.extend_from_slice(&buf);
}
}
Ok(out)
}
/// 密钥盒构造(KSA)。
///
/// 对照 `ncmdump` `src/ncmcrypt.cpp::buildKeyBox`——**单循环**,但每轮多累加一个
/// `last_byte`(上一轮的 `c`):
///
/// ```text
/// c = (swap + last_byte + key[key_offset]) & 0xff
/// ```
///
/// 这个式子在模 256 下恰好化简为标准 RC4(实测两者密钥盒逐字节相同),
/// 所以**它既不是「关键差异」,也不能靠与标准 RC4 比对来验证**——
/// 验证只能靠固定向量,见单测 `key_box_matches_reference_vectors`。
/// `key_offset` 触 keyLen 归零——即循环取 key。
fn build_key_box(key: &[u8]) -> [u8; 256] {
let mut key_box = [0u8; 256];
for (i, b) in key_box.iter_mut().enumerate() {
*b = i as u8;
}
if key.is_empty() {
return key_box;
}
let mut last_byte: u8 = 0;
let mut key_offset = 0usize;
for i in 0..256usize {
let swap = key_box[i];
let c = swap.wrapping_add(last_byte).wrapping_add(key[key_offset]);
key_offset += 1;
if key_offset >= key.len() {
key_offset = 0;
}
key_box[i] = key_box[c as usize];
key_box[c as usize] = swap;
last_byte = c;
}
key_box
}
/// 原地解密一个音频块。
///
/// 对照 `ncmdump` `src/ncmcrypt.cpp::Dump`——`i` 是**块内下标**,`j = (i + 1) & 0xff`:
///
/// ```text
/// buf[i] ^= mKeyBox[(mKeyBox[j] + mKeyBox[(mKeyBox[j] + j) & 0xff]) & 0xff];
/// ```
///
/// 块与块之间不重置密钥盒、也不额外跳字节(`0x8000` 只是块大小)。
/// 该式只依赖 `i` 与密钥盒,故分块与整体解密结果一致(见单测)。
fn decrypt_audio_chunk(key_box: &[u8; 256], buf: &mut [u8]) {
for i in 0..buf.len() {
let j = (i + 1) & 0xff;
let k = key_box
[key_box[j].wrapping_add(key_box[key_box[j].wrapping_add(j as u8) as usize]) as usize];
buf[i] ^= k;
}
}
/// 封面/标签用的图片扩展名(按魔数,不按 ncm 的说法)
fn image_ext(data: &[u8]) -> &'static str {
common::image_ext(data)
}
/// 读满一块(短读不算块边界)——实现见 [`common::read_full`]。
fn read_full(r: &mut impl Read, buf: &mut [u8]) -> Result<usize> {
common::read_full(r, buf)
}
fn read_u32(r: &mut impl Read) -> Result<u32> {
let mut b = [0u8; 4];
r.read_exact(&mut b)
.map_err(|_| NcmError::Broken("读取长度字段时提前结束".into()))?;
Ok(u32::from_le_bytes(b))
}
fn read_n(r: &mut impl Read, n: usize) -> Result<Vec<u8>> {
let mut buf = vec![0u8; n];
r.read_exact(&mut buf)
.map_err(|_| NcmError::Broken(format!("读取 {n} 字节时提前结束")))?;
Ok(buf)
}
/// 解析 meta JSON 为 `NcmMeta`。
///
/// `artist` 是二维数组(`[["名字", id], ...]`),取每项第 0 个元素并用 `/` 连接。
fn parse_meta(json: &str) -> NcmMeta {
let Ok(v) = serde_json::from_str::<serde_json::Value>(json) else {
return NcmMeta::default();
};
let s = |k: &str| v.get(k).and_then(|x| x.as_str()).map(|x| x.to_string());
let n = |k: &str| v.get(k).and_then(|x| x.as_u64());
let artist = v.get("artist").and_then(|a| a.as_array()).map(|arr| {
arr.iter()
.filter_map(|item| {
item.as_array()
.and_then(|inner| inner.first())
.and_then(|name| name.as_str())
})
.collect::<Vec<_>>()
.join("/")
});
NcmMeta {
name: s("musicName"),
artist: artist.filter(|a| !a.is_empty()),
album: s("album"),
bitrate: n("bitrate"),
duration: n("duration"),
format: s("format"),
}
}
/// 解析头部 + key 段 + meta 段 + 封面,返回 (密钥盒, meta, 封面字节)。
fn read_header(r: &mut impl Read) -> Result<([u8; 256], NcmMeta, Option<Vec<u8>>)> {
// 0x00 magic 8B
let magic = read_n(r, 8)?;
if &magic != MAGIC {
return Err(NcmError::NotEncrypted(
"不是网易云加密文件(头部魔数不是 CTENFDAM)".into(),
));
}
// 0x08 固定 2 字节(读取权重仅为推进游标)
let _ = read_n(r, 2)?;
// ---- key 段 ----
let key_len = read_u32(r)? as usize;
if key_len == 0 {
return Err(NcmError::Broken("key 段长度为 0".into()));
}
let mut key_data = read_n(r, key_len)?;
for b in key_data.iter_mut() {
*b ^= XOR_KEY;
}
let key_plain = aes_ecb_decrypt(CORE_AES_KEY, &key_data)?;
if key_plain.len() <= CORE_KEY.len() {
return Err(NcmError::Broken(format!(
"key 段解密后仅 {} 字节,不足以剥离前缀",
key_plain.len()
)));
}
// 剥离 "neteasecloudmusic\0" 前缀,其余即密钥盒种子
let rc4_key = &key_plain[CORE_KEY.len()..];
let key_box = build_key_box(rc4_key);
// ---- meta 段 ----
let meta_len = read_u32(r)? as usize;
let mut meta = NcmMeta::default();
if meta_len > 0 {
let mut meta_data = read_n(r, meta_len)?;
for b in meta_data.iter_mut() {
*b ^= XOR_META;
}
// 第一层前缀:literal,先剥掉再 base64
if meta_data.len() > META_PREFIX.len() {
let body = &meta_data[META_PREFIX.len()..];
use base64::Engine;
if let Ok(decoded) = base64::engine::general_purpose::STANDARD.decode(body) {
if let Ok(plain) = aes_ecb_decrypt(MODIFY_KEY, &decoded) {
// 第二层前缀:"music:"
let json = if plain.len() > META_JSON_PREFIX.len() {
&plain[META_JSON_PREFIX.len()..]
} else {
&plain[..]
};
// 元数据非 UTF-8 或非 JSON 都不致命:放弃标签即可
if let Ok(s) = std::str::from_utf8(json) {
meta = parse_meta(s);
}
}
}
}
}
// ---- 封面段 ----
// 跳 5 字节:CRC32(4) + 图片版本(1)
let mut five = [0u8; 5];
r.read_exact(&mut five)
.map_err(|_| NcmError::Broken("读取 CRC32/图片版本时提前结束".into()))?;
let cover_frame_len = read_u32(r)? as usize;
let img_len = read_u32(r)? as usize;
let cover = if img_len > 0 {
Some(read_n(r, img_len)?)
} else {
None
};
// 跳到 key 帧末尾
if cover_frame_len > img_len {
let mut discard = vec![0u8; cover_frame_len - img_len];
let _ = r.read_exact(&mut discard);
}
Ok((key_box, meta, cover))
}
/// 判断文件是否为网易云 `.ncm`(只读 8 字节魔数)。
pub fn sniff(path: &Path) -> bool {
let Ok(mut f) = File::open(path) else {
return false;
};
let mut magic = [0u8; 8];
std::io::Read::read_exact(&mut f, &mut magic).is_ok() && &magic == MAGIC
}
/// 解密一个 `.ncm` 文件到 `out_dir`,返回产物信息。
///
/// `progress` 每处理一块回调一次(已处理字节数,总字节数),供上层节流后推事件。
/// `platform_label` 由调度层给出(如「网易云」),用于产物备注。
pub fn decrypt_file<F>(
input: &Path,
out_dir: &Path,
platform_label: &str,
reserved: &mut std::collections::HashSet<String>,
mut progress: F,
) -> Result<common::Outcome>
where
F: FnMut(u64, u64),
{
let total = std::fs::metadata(input).map(|m| m.len()).unwrap_or(0);
let file = File::open(input)?;
let mut reader = BufReader::with_capacity(CHUNK, file);
let (key_box, meta, cover) = read_header(&mut reader)?;
std::fs::create_dir_all(out_dir)?;
// 先写临时文件:格式要等第一块解出来才知道,而输出名又依赖格式。
// 定稿后再 rename —— 中途失败不会留下半个音频冒充成品。
let tmp = out_dir.join(format!(
".dec_part_{}_{}.tmp",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_nanos())
.unwrap_or(0)
));
let mut buf = vec![0u8; CHUNK];
let mut done: u64 = 0;
let mut format: Option<&'static str> = None;
let mut audio_bytes: u64 = 0;
let write_result = (|| -> Result<()> {
let out = File::create(&tmp)?;
let mut writer = BufWriter::with_capacity(CHUNK, out);
loop {
// **必须读满一个块**(或读到 EOF),不能用 `read` 的短读结果当块边界。
// 解密式依赖「块内偏移 i」,块边界一漂移密钥盒相位就错位——
// 表现为文件从中间某处起全是噪声、前面对得上,极难排查(§6.24)。
let n = read_full(&mut reader, &mut buf)?;
if n == 0 {
break;
}
decrypt_audio_chunk(&key_box, &mut buf[..n]);
if format.is_none() {
format = Some(common::detect_format(&buf[..n]));
}
writer.write_all(&buf[..n])?;
done += n as u64;
audio_bytes += n as u64;
progress(done, total);
}
writer.flush()?;
Ok(())
})();
if let Err(e) = write_result {
let _ = std::fs::remove_file(&tmp);
return Err(e);
}
let format = format.ok_or_else(|| {
let _ = std::fs::remove_file(&tmp);
NcmError::Broken("音频段为空".into())
})?;
let stem = input
.file_stem()
.map(|s| s.to_string_lossy().to_string())
.unwrap_or_else(|| "output".to_string());
let target = common::unique_output(out_dir, &stem, format, reserved)?;
std::fs::rename(&tmp, &target).map_err(|e| {
let _ = std::fs::remove_file(&tmp);
NcmError::Output(format!("重命名产物失败:{e}"))
})?;
// 封面单独落盘(标签回填留 P2:需要 lofty 且要按容器分派)
let cover_path = match cover {
Some(data) if !data.is_empty() => {
let ext = image_ext(&data);
let path = common::unique_output(out_dir, &format!("{stem}.cover"), ext, reserved)?;
std::fs::write(&path, &data)?;
Some(path)
}
_ => None,
};
// 标签信息汇总成一行备注(P2 回填标签前,这是元数据唯一的出口)
let mut note = format!("{platform_label} ncm");
if let Some(n) = meta.name.as_deref() {
note.push_str(&format!(" · {n}"));
}
if let Some(a) = meta.artist.as_deref() {
note.push_str(&format!(" - {a}"));
}
// 位率/时长/专辑:解析成本已经付过,顺手带进备注(也避免字段闲置)
let mut bits: Vec<String> = Vec::new();
if let Some(b) = meta.bitrate {
if b > 0 {
bits.push(format!("{} kbps", b / 1000));
}
}
if let Some(d) = meta.duration {
if d > 0 {
let secs = d / 1000;
bits.push(format!("{}:{:02}", secs / 60, secs % 60));
}
}
if let Some(al) = meta.album.as_deref() {
bits.push(format!("专辑《{al}》"));
}
if let Some(f) = meta.format.as_deref() {
bits.push(format!("声明格式 {f}"));
}
if !bits.is_empty() {
note.push_str(&format!("({})", bits.join(" · ")));
}
Ok(common::Outcome {
output: target,
format: format.to_string(),
cover: cover_path,
audio_bytes,
note,
})
}
#[cfg(test)]
mod tests {
use super::*;
use aes::cipher::BlockEncrypt;
const ZERO_KEY: [u8; 16] = [0u8; 16];
/// AES 正向加密(测试用),与 `aes_ecb_decrypt` 互逆。
fn aes_ecb_encrypt(key: &[u8; 16], data: &[u8]) -> Vec<u8> {
let cipher = Aes128::new(GenericArray::from_slice(key));
let mut out = Vec::with_capacity(data.len());
let mut buf = [0u8; 16];
for chunk in data.chunks(16) {
let block = GenericArray::from_slice(chunk);
cipher.encrypt_block_b2b(block, GenericArray::from_mut_slice(&mut buf));
out.extend_from_slice(&buf);
}
out
}
fn pkcs7_pad(data: &[u8]) -> Vec<u8> {
let pad = 16 - (data.len() % 16);
let mut out = data.to_vec();
out.extend(std::iter::repeat(pad as u8).take(pad));
out
}
#[test]
fn aes_ecb_roundtrip_with_pkcs7() {
let plain = b"CTENFDAM-test-payload-1234";
let padded = pkcs7_pad(plain);
assert_eq!(padded.len() % 16, 0);
let enc = aes_ecb_encrypt(&ZERO_KEY, &padded);
let dec = aes_ecb_decrypt(&ZERO_KEY, &enc).expect("decrypt");
assert_eq!(dec, plain);
}
#[test]
fn aes_ecb_rejects_non_block_multiple() {
assert!(aes_ecb_decrypt(&ZERO_KEY, &[0u8; 17]).is_err());
assert!(aes_ecb_decrypt(&ZERO_KEY, &[]).is_err());
}
/// 空 key 时密钥盒必须是恒等置换(KSA 的边界行为)
#[test]
fn key_box_identity_for_empty_key() {
let kb = build_key_box(&[]);
for i in 0..256 {
assert_eq!(kb[i], i as u8);
}
}
/// 已知答案向量:由参考实现(`ncmdump` 的 `buildKeyBox`)独立算出的值。
///
/// 注意**不能**用「与标准 RC4 比对」来验证——`last_byte` 在模 256 下是恒等变形,
/// 两者逐字节相同。只能靠固定向量锁行为。
#[test]
fn key_box_matches_reference_vectors() {
let kb = build_key_box(b"0123456789abcdef");
assert_eq!(
&kb[..8],
&[0x88, 0x62, 0x96, 0xcc, 0x79, 0x85, 0x7a, 0x21],
"密钥盒前 8 字节与参考实现不符"
);
assert_eq!(
&kb[8..16],
&[0x15, 0x49, 0xa5, 0x91, 0x3d, 0xc6, 0x65, 0xda],
"密钥盒第 8..16 字节与参考实现不符"
);
}
/// 已知答案向量:全零明文的密钥流(即 PRGA 输出)前 24 字节。
#[test]
fn keystream_matches_reference_vector() {
let kb = build_key_box(b"0123456789abcdef");
let mut data = [0u8; 24];
decrypt_audio_chunk(&kb, &mut data);
assert_eq!(
data,
[
0x1d, 0xaf, 0xd7, 0x79, 0xfa, 0xce, 0x0c, 0x2b, 0xab, 0xc4, 0x8c, 0xeb, 0x0d, 0xc3,
0x6a, 0x5c, 0xc6, 0x07, 0x79, 0x63, 0x92, 0x72, 0x69, 0x1b
],
"密钥流与参考实现不符"
);
}
/// 密钥必须循环取用满 256 轮:`key_offset` 归零逻辑要正确。
#[test]
fn key_box_cycles_key_correctly() {
let a = vec![7u8; 300];
let mut b = vec![7u8; 300];
b[250] = 8;
assert_ne!(
build_key_box(&a),
build_key_box(&b),
"密钥第 250 字节未参与运算——key_offset 取模有误"
);
// 短密钥(1 字节)也不能 panic,且是合法置换
let kb = build_key_box(&[0x42]);
let mut seen = [false; 256];
for &x in kb.iter() {
seen[x as usize] = true;
}
assert!(seen.iter().all(|&v| v));
}
/// 加密→解密往返:验证 `decrypt_audio_chunk` 与自身一致,
/// 且块边界不改变结果(`i` 是块内下标这一设计的关键性质)。
#[test]
fn audio_chunk_roundtrip_and_block_boundary_invariance() {
let kb = build_key_box(b"0123456789abcdef");
let plain: Vec<u8> = (0..(CHUNK + 777)).map(|i| (i % 251) as u8).collect();
let mut whole = plain.clone();
decrypt_audio_chunk(&kb, &mut whole);
assert_ne!(whole, plain, "解密未改变数据,密钥盒或 XOR 有误");
let mut chunked = plain.clone();
for c in chunked.chunks_mut(CHUNK) {
decrypt_audio_chunk(&kb, c);
}
assert_eq!(chunked, whole, "分块解密与整体解密结果不一致");
decrypt_audio_chunk(&kb, &mut chunked);
assert_eq!(chunked, plain);
}
#[test]
fn parse_meta_reads_nested_artist() {
let json = r#"{"musicName":"歌","album":"专辑","bitrate":999000,
"duration":215000,"format":"flac",
"artist":[["歌手甲",1],["歌手乙",2]]}"#;
let m = parse_meta(json);
assert_eq!(m.name.as_deref(), Some("歌"));
assert_eq!(m.album.as_deref(), Some("专辑"));
assert_eq!(m.artist.as_deref(), Some("歌手甲/歌手乙"));
assert_eq!(m.bitrate, Some(999000));
assert_eq!(m.duration, Some(215000));
assert_eq!(m.format.as_deref(), Some("flac"));
}
#[test]
fn parse_meta_tolerates_garbage() {
let m = parse_meta("not json at all");
assert!(m.name.is_none() && m.artist.is_none());
}
#[test]
fn not_ncm_file_is_rejected() {
let dir = std::env::temp_dir().join(format!("ncm_bad_{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
let p = dir.join("fake.ncm");
std::fs::write(&p, b"NOTNCM!!\x02\x00\x00\x00\x00").unwrap();
let mut reserved = std::collections::HashSet::new();
let err = decrypt_file(&p, &dir, "网易云", &mut reserved, |_, _| {}).unwrap_err();
assert!(
matches!(err, NcmError::NotEncrypted(_)),
"期望 NotEncrypted,实得 {err:?}"
);
assert!(!sniff(&p), "魔数不符的文件 sniff 应为 false");
let _ = std::fs::remove_dir_all(&dir);
}
/// **正向构造**一个合法 ncm 容器,再解回来。
/// 这样无需把真实音乐样本(体积大、有版权)放进仓库,仍能覆盖:
/// 两段 XOR 常量、两层 meta 前缀、封面段偏移、分块解密、魔数定格式、输出命名。
#[test]
fn synthetic_ncm_roundtrip() {
let dir = std::env::temp_dir().join(format!("ncm_rt_{}", std::process::id()));
let out = dir.join("out");
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
// 与密钥盒用例共用的固定种子
let seed: &[u8] = b"0123456789abcdef";
// 音频明文:以 fLaC 开头,长度跨块边界多一点
let mut plain = b"fLaC".to_vec();
plain.extend((0..(CHUNK + 123)).map(|i| (i % 253) as u8));
// 用它"加密"音频(XOR 自逆)。加密必须与解密用同样的块大小,
// 否则 PRGA 相位错位(这正是 read_full 存在的原因)。
let kb = build_key_box(seed);
let mut cipher_audio = plain.clone();
for c in cipher_audio.chunks_mut(CHUNK) {
decrypt_audio_chunk(&kb, c);
}
// key 段:**必须**是 CORE_KEY 前缀 + 种子——解密端会剥掉这 17 字节前缀,
// 少了它就会拿到错误的种子。
let mut key_plain = CORE_KEY.to_vec();
key_plain.extend_from_slice(seed);
let mut key_seg = aes_ecb_encrypt(CORE_AES_KEY, &pkcs7_pad(&key_plain));
for b in key_seg.iter_mut() {
*b ^= XOR_KEY;
}
// meta 段:META_PREFIX + base64(AES(META_JSON_PREFIX + json)),再 XOR 0x63
let json = r#"{"musicName":"合成曲","album":"合成专辑","bitrate":320000,"duration":1000,"format":"flac","artist":[["测试歌手",1]]}"#;
let mut meta_plain = META_JSON_PREFIX.to_vec();
meta_plain.extend_from_slice(json.as_bytes());
let meta_enc = aes_ecb_encrypt(MODIFY_KEY, &pkcs7_pad(&meta_plain));
use base64::Engine;
let meta_b64 = base64::engine::general_purpose::STANDARD.encode(&meta_enc);
let mut meta_seg = META_PREFIX.to_vec();
meta_seg.extend_from_slice(meta_b64.as_bytes());
for b in meta_seg.iter_mut() {
*b ^= XOR_META;
}
// 封面段:PNG 魔数 + 一点数据;cover_len 故意大于 img_len 以覆盖"跳过尾部"
let img: Vec<u8> = [
&[0x89u8, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A][..],
&[7u8; 40],
]
.concat();
let cover_padding = [0u8; 9];
let cover_frame_len = (img.len() + cover_padding.len()) as u32;
let mut container = Vec::new();
container.extend_from_slice(MAGIC);
container.extend_from_slice(&[0x02, 0x00]); // 固定 2B
container.extend_from_slice(&(key_seg.len() as u32).to_le_bytes());
container.extend_from_slice(&key_seg);
container.extend_from_slice(&(meta_seg.len() as u32).to_le_bytes());
container.extend_from_slice(&meta_seg);
container.extend_from_slice(&[0xAA, 0xBB, 0xCC, 0xDD, 0x01]); // CRC32 + 图片版本
container.extend_from_slice(&cover_frame_len.to_le_bytes());
container.extend_from_slice(&(img.len() as u32).to_le_bytes());
container.extend_from_slice(&img);
container.extend_from_slice(&cover_padding);
container.extend_from_slice(&cipher_audio);
let src = dir.join("测试 曲目.ncm");
std::fs::write(&src, &container).unwrap();
assert!(sniff(&src), "合法容器的 sniff 应为 true");
let mut reserved = std::collections::HashSet::new();
let mut ticks = 0usize;
let res = decrypt_file(&src, &out, "网易云", &mut reserved, |_, _| ticks += 1)
.expect("解密应成功");
assert_eq!(res.format, "flac");
assert_eq!(res.audio_bytes, plain.len() as u64);
assert!(ticks >= 2, "进度回调应至少触发两次(跨块),实得 {ticks}");
// 用长度 + 位置比较,避免 assert_eq! 在失败时倾倒几十万字节
let got = std::fs::read(&res.output).unwrap();
assert_eq!(got.len(), plain.len(), "音频长度不一致");
let first_diff = got.iter().zip(plain.iter()).position(|(a, b)| a != b);
assert!(
got == plain,
"音频明文不一致:第一个不同处在第 {:?} 字节",
first_diff
);
// 元数据不再单独暴露,而是拼进 note——所以直接验 note 里带上了它
assert!(res.note.contains("合成曲"), "note 应含曲名:{}", res.note);
assert!(res.note.contains("测试歌手"), "note 应含歌手:{}", res.note);
assert!(res.note.contains("合成专辑"), "note 应含专辑:{}", res.note);
// 位率 320000 → 320 kbps
assert!(res.note.contains("320 kbps"), "note 应含位率:{}", res.note);
let cover = res.cover.expect("应提取出封面");
let cover_bytes = std::fs::read(&cover).unwrap();
assert_eq!(cover_bytes.len(), img.len(), "封面长度不一致");
assert!(cover_bytes == img, "封面字节不一致");
assert_eq!(cover.extension().unwrap(), "png");
// 中文文件名 + 中文输出路径:产物名应保留原名
assert_eq!(
res.output.file_name().unwrap().to_string_lossy(),
"测试 曲目.flac"
);
// 再解一次:同名必须让位而不是覆盖
let res2 =
decrypt_file(&src, &out, "网易云", &mut reserved, |_, _| {}).expect("二次解密应成功");
assert_eq!(
res2.output.file_name().unwrap().to_string_lossy(),
"测试 曲目_1.flac"
);
let _ = std::fs::remove_dir_all(&dir);
}
}
+113
View File
@@ -0,0 +1,113 @@
//! **开发探针**:不落盘地跑完「musicex 尾部 → 凭据 → 在线取密钥 → 解密」并回传结果。
//!
//! 存在的唯一理由:musicex 这条路径的**真实响应字段**只能靠真机样本验证,
//! 而跑起整个 Tauri 应用再手点一遍成本太高、也没法在命令行里复现。
//! 它不参与产品逻辑——调度层走的是 [`super::qq_online::decrypt_musicex`]。
//!
//! 2026-09-27 用它跑通了首个真机样本(197MB `.mflac`,192kHz/24bit):
//! ekey 704 字符 → 派生 512 字节密钥 → RC4 变体解密 → `fLaC` 头。
//! **这条验证顺带推翻了一个错误假设**:该样本的密文头是 `51 74 03 75`,
//! 并非文档里提到的 `#!Qk`,所以密文头不能当守卫(见 `qq_online` 的注释)。
//!
//! 用法见 `src-tauri/examples/decrypt_musicex_probe.rs`:
//! ```text
//! cargo run --example decrypt_musicex_probe -- "C:\path\to\sample.mflac" [输出目录]
//! ```
use std::io::Read;
use std::path::Path;
use super::common::DecryptError;
use super::qmc;
use super::qq_credentials;
use super::qq_ekey::{self, EvkeyRequest};
use super::qq_footer::{self, MusiCexTail};
/// 探针结果(都是"结论性"字段,便于一眼判断链路是否通了)
pub struct ProbeOutcome {
pub ekey_len: usize,
pub key_len: usize,
pub raw_key_bytes: Vec<u8>,
/// 密文头部 4 字节(应是 `#!Qk`,即 QMC2 魔术)
pub cipher_magic: Vec<u8>,
/// 解密后头部 16 字节(FLAC 应为 `fLaC`)
pub plain_magic: Vec<u8>,
pub decrypted_bytes: usize,
pub guessed_format: String,
pub expiration_secs: i64,
}
/// 对给定样本跑完整链路(**读内存、发网络请求、解密,但不写任何文件**)
pub fn probe_musicex(input: &Path) -> Result<ProbeOutcome, DecryptError> {
let total = std::fs::metadata(input).map(|m| m.len()).unwrap_or(0);
if total < qq_footer::MUSICEX_FOOTER_LEN as u64 {
return Err(DecryptError::Broken("文件太小,不可能是 musicex".into()));
}
// 1) 尾部
let tail: MusiCexTail = read_tail(input)?;
let audio_len = tail.audio_len(total);
// 2) 凭据
let creds = qq_credentials::read_credentials();
let (Some(uin), Some(authst)) = (creds.uin.as_deref(), creds.authst.as_deref()) else {
return Err(DecryptError::KeyRequired(format!(
"凭据不可用:{}",
creds.status_text()
)));
};
// 3) 取 ekey(真实网络请求)
let req = EvkeyRequest::from_tail(&tail, uin, authst)?;
let client = reqwest::Client::builder()
.timeout(std::time::Duration::from_secs(25))
.build()
.map_err(|e| DecryptError::KeyRequired(format!("构建 HTTP 客户端失败:{e}")))?;
let (ekey, expiration_secs) =
tauri::async_runtime::block_on(qq_ekey::fetch_ekey(&client, &req))?;
// 4) ekey → 原始密钥
let raw = qmc::parse_ekey(&ekey)?;
// 5) 解密音频段(探针只验证单文件,全量读入内存即可)
let mut audio = read_audio(input, audio_len)?;
let cipher_magic = audio[..4.min(audio.len())].to_vec();
qmc::decrypt_with_raw_key(&raw, &mut audio);
let plain_magic = audio[..16.min(audio.len())].to_vec();
let guessed_format = super::common::detect_format_opt(&audio)
.unwrap_or("unknown")
.to_string();
Ok(ProbeOutcome {
ekey_len: ekey.len(),
key_len: raw.len(),
raw_key_bytes: raw,
cipher_magic,
plain_magic,
decrypted_bytes: audio.len(),
guessed_format,
expiration_secs,
})
}
/// 读文件末尾的 musicex 尾部
fn read_tail(input: &Path) -> Result<MusiCexTail, DecryptError> {
use std::io::{Seek, SeekFrom};
let mut f = std::fs::File::open(input)?;
let size = f.metadata()?.len();
let take = (qq_footer::MUSICEX_FOOTER_LEN as u64).min(size) as usize;
f.seek(SeekFrom::End(-(take as i64)))?;
let mut buf = vec![0u8; take];
f.read_exact(&mut buf)?;
qq_footer::parse_musicex_tail(&buf)
.ok_or_else(|| DecryptError::Broken("musicex 尾部解析失败".into()))
}
/// 只读音频段
fn read_audio(input: &Path, audio_len: u64) -> Result<Vec<u8>, DecryptError> {
let mut f = std::fs::File::open(input)?;
let mut buf = vec![0u8; audio_len as usize];
f.read_exact(&mut buf)?;
Ok(buf)
}
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,285 @@
//! QQ音乐本机凭据读取(`uin` + `authst`)。
//!
//! ## 为什么要读进程内存
//!
//! Windows 版 QQ 音乐**没有持久化 `authst`**:`uin` 能从
//! `%APPDATA%\Tencent\QQMusic\QQMusicServiceConfig.ini` 明文读到,但 `authst`
//! 只作为 JSON 字符串存在于运行中的 `QQMusic.exe` 内存里(有效期约 22.3 小时)。
//! 所以「在线取 ekey」的前置条件是:**QQ 音乐正在运行且已登录**。
//!
//! 这里只做**只读**内存访问(`OpenProcess` + `VirtualQueryEx` + `ReadProcessMemory`),
//! 不注入、不改写任何东西——这是它与 Frida 兜底方案的本质区别,
//! 也是它通常不会被安全软件拦截的原因。
//!
//! ## 结构
//!
//! - [`parse_ini_uin`]:纯函数,可跨平台单测;
//! - [`find_authst`]:纯函数,在给定字节里找 `"authst":"<token>"`,可单测;
//! - [`read_credentials`]:平台相关的胶水(Windows 实现 / 其他平台的空实现)。
/// 从 QQ 音乐的 INI 文本里取 `[Account] Uin`。
///
/// 该文件很小(实测 27 字节)且是**纯文本**,格式固定:
///
/// ```ini
/// [Account]
/// Uin=1154027699
/// ```
///
/// 解析上刻意宽松:允许前导空白、大小写不敏感、允许 `Uin` 出现在任意段里
/// (不同版本段名可能变),但**只认第一处**出现的非空 Uin。
pub fn parse_ini_uin(text: &str) -> Option<String> {
for line in text.lines() {
let line = line.trim();
if line.is_empty() || line.starts_with(';') || line.starts_with('#') {
continue;
}
let Some((key, value)) = line.split_once('=') else {
continue;
};
if !key.trim().eq_ignore_ascii_case("uin") {
continue;
}
let v = value.trim().trim_matches('"');
// 必须是纯数字(QQ 号),排除 `Uin=` 之类的空值或占位
if !v.is_empty() && v.bytes().all(|b| b.is_ascii_digit()) {
return Some(v.to_string());
}
}
None
}
/// `authst` 在内存里的 JSON 形态:`"authst":"<base64url-ish>"`。
const AUTHST_KEY: &[u8] = b"\"authst\":\"";
/// 在一段内存字节里查找 `authst` 的值(从 0 开始)。
///
/// 生产路径用 [`find_authst_from`](分块扫描需要偏移),这个薄封装给测试用。
#[cfg_attr(not(test), allow(dead_code))]
pub fn find_authst(haystack: &[u8]) -> Option<String> {
find_authst_from(haystack, 0)
}
/// 从 `start` 起查找(供分块扫描时避免重复命中同一处)
pub fn find_authst_from(haystack: &[u8], start: usize) -> Option<String> {
let mut pos = start;
while pos + AUTHST_KEY.len() <= haystack.len() {
let Some(rel) = find_subslice(&haystack[pos..], AUTHST_KEY) else {
return None;
};
let val_start = pos + rel + AUTHST_KEY.len();
// token 到下一个双引号结束
let Some(end_rel) = haystack[val_start..].iter().position(|&b| b == b'"') else {
return None;
};
let token = &haystack[val_start..val_start + end_rel];
if is_plausible_token(token) {
return Some(String::from_utf8_lossy(token).to_string());
}
// 命中但是假阳性:从下一个字节继续找
pos = val_start;
}
None
}
fn find_subslice(haystack: &[u8], needle: &[u8]) -> Option<usize> {
if needle.is_empty() || haystack.len() < needle.len() {
return None;
}
haystack.windows(needle.len()).position(|w| w == needle)
}
fn is_plausible_token(token: &[u8]) -> bool {
token.len() >= 16
&& token.iter().all(|&b| {
b.is_ascii_alphanumeric()
|| b == b'-'
|| b == b'_'
|| b == b'='
|| b == b'+'
|| b == b'/'
})
}
/// 凭据读取结果
#[derive(Debug, Clone, Default)]
pub struct QqCredentials {
/// QQ 号(来自 INI)
pub uin: Option<String>,
/// 运行期认证令牌(来自进程内存)
pub authst: Option<String>,
}
impl QqCredentials {
/// 是否可用于调用 `GetEVkey`
pub fn usable(&self) -> bool {
self.uin.is_some() && self.authst.is_some()
}
/// 给 UI 的简短状态(三态,供状态卡渲染)
pub fn status_text(&self) -> &'static str {
match (self.uin.is_some(), self.authst.is_some()) {
(true, true) => "已就绪",
(true, false) => "QQ 音乐未运行或未登录",
(false, _) => "未找到本机 QQ 音乐账号",
}
}
}
/// `QQMusic.exe` 的进程名(枚举时用大小写不敏感的子串匹配)
pub const QQ_PROCESS_HINT: &str = "qqmusic";
/// QQ 音乐配置 INI 的路径(Windows)
#[cfg(windows)]
pub fn config_ini_path() -> Option<std::path::PathBuf> {
let appdata = std::env::var_os("APPDATA")?;
Some(
std::path::PathBuf::from(appdata)
.join("Tencent")
.join("QQMusic")
.join("QQMusicServiceConfig.ini"),
)
}
#[cfg(not(windows))]
pub fn config_ini_path() -> Option<std::path::PathBuf> {
None
}
/// 读凭据:`uin` 从 INI,`authst` 扫进程内存。
///
/// 任何一步失败都只是 `None`(并记日志),不返回错误——调用方据
/// [`QqCredentials::usable`] 决定是走在线取 ekey 还是给出引导。
pub fn read_credentials() -> QqCredentials {
let uin = config_ini_path()
.and_then(|p| std::fs::read_to_string(&p).ok())
.and_then(|t| parse_ini_uin(&t))
.or_else(|| {
// 兜底:文件读不到时,从进程内存里找 "uin":"..." 形态
scan_authst_in_process().1
});
let (authst, uin_from_mem) = match uin {
// 有 uin 时只需要 authst
Some(_) => (scan_authst_in_process().0, None),
// 没 uin 时一次扫描同时拿两者
None => {
let (a, u) = scan_authst_in_process();
(a, u)
}
};
QqCredentials {
uin: uin.or(uin_from_mem),
authst,
}
}
#[cfg(windows)]
fn scan_authst_in_process() -> (Option<String>, Option<String>) {
match crate::music::decrypt::qq_memscan::scan_qq_process() {
Ok(found) => (found.authst, found.uin),
Err(e) => {
crate::logger::log_warn("music-decrypt", &format!("扫描 QQ 音乐进程内存失败:{e}"));
(None, None)
}
}
}
#[cfg(not(windows))]
fn scan_authst_in_process() -> (Option<String>, Option<String>) {
(None, None)
}
#[cfg(test)]
mod tests {
use super::*;
// ============ INI 解析 ============
#[test]
fn parses_real_ini_shape() {
// 本机实测就是这个形状(27 字节)
let text = "[Account]\r\nUin=1154027699\r\n";
assert_eq!(parse_ini_uin(text).as_deref(), Some("1154027699"));
}
#[test]
fn parses_ini_leniently() {
// 大小写、空白、引号、注释、其他段
let text = "\u{feff}; comment\r\n[Other]\r\nx=1\r\n\r\n uin = \"123456\" \r\n";
assert_eq!(parse_ini_uin(text).as_deref(), Some("123456"));
}
#[test]
fn ignores_non_numeric_or_empty_uin() {
assert!(parse_ini_uin("Uin=\r\n").is_none());
assert!(parse_ini_uin("Uin=abc\r\n").is_none());
assert!(parse_ini_uin("Uin=12a45\r\n").is_none());
assert!(parse_ini_uin("").is_none());
assert!(parse_ini_uin("[Account]\nFoo=1\n").is_none());
}
// ============ authst 提取 ============
#[test]
fn finds_authst_in_memory_blob() {
let token = "AbCd_-1234567890AbCd_-1234567890";
let blob = format!("junk{{\"uin\":\"1154027699\",\"authst\":\"{token}\",\"other\":1}}tail");
assert_eq!(find_authst(blob.as_bytes()).as_deref(), Some(token));
}
#[test]
fn rejects_implausible_authst() {
// 太短
assert!(find_authst(b"\"authst\":\"short\"").is_none());
// 含非法字符(像模板/日志)
assert!(find_authst(b"\"authst\":\"this is not a token at all\"").is_none());
// 没有值
assert!(find_authst(b"\"authst\":\"\"").is_none());
// 完全没有
assert!(find_authst(b"nothing here").is_none());
}
/// 第一处是假阳性时,应继续往后找真 token
#[test]
fn skips_false_positive_and_keeps_searching() {
let token = "RealToken_1234567890abcdef";
let blob = format!("\"authst\":\"x\"...\"authst\":\"{token}\"");
assert_eq!(find_authst(blob.as_bytes()).as_deref(), Some(token));
}
/// 跨缓冲区边界不会误判(分块扫描用 find_authst_from)
#[test]
fn find_from_offset_advances() {
let blob = b"aaaa\"authst\":\"AAAAAAAAAAAAAAAA\"";
let first = find_authst_from(blob, 0).unwrap();
assert_eq!(first, "AAAAAAAAAAAAAAAA");
// 从命中处之后继续找应该没有第二个
let key_at = 4 + AUTHST_KEY.len();
assert!(find_authst_from(blob, key_at).is_none());
}
// ============ 状态文案 ============
#[test]
fn credentials_status_text_covers_three_states() {
let none = QqCredentials::default();
assert!(!none.usable());
assert!(none.status_text().contains("未找到"));
let uin_only = QqCredentials {
uin: Some("1".into()),
authst: None,
};
assert!(!uin_only.usable());
assert!(uin_only.status_text().contains("未运行"));
let full = QqCredentials {
uin: Some("1".into()),
authst: Some("t".into()),
};
assert!(full.usable());
assert_eq!(full.status_text(), "已就绪");
}
}
+342
View File
@@ -0,0 +1,342 @@
//! 通过 QQ 音乐官方接口取 ekey(`music.vkey.GetEVkey`)。
//!
//! ## 前置条件(必须让用户知道)
//!
//! 新版 musicex 文件**不包含 ekey**,只能拿本机已登录的凭据向 QQ 音乐服务器换取:
//!
//! 1. 本机装有 QQ 音乐客户端;
//! 2. **QQ 音乐正在运行且已登录**(`authst` 只存在于运行期内存,见
//! [`super::qq_credentials`]);
//! 3. 文件本身的尾部要有 `media_mid` 与 `filename`(musicex 尾部提供)。
//!
//! ## 接口契约里三个"必须"
//!
//! 对照 `MUSIC_DECRYPT_PLAN.md` §3.2 与 qmc-decoder 的协议文档:
//!
//! - `param.filename` **必须带扩展名**(`.mgg` / `.mflac`),否则返回 `104005`;
//! - `param.songtype` **必须为 `1`**(表示请求加密资源的 ekey;为 0 只回 vkey);
//! - `module` 必须是 **`music.vkey.GetEVkey`**(不是 `GetVkey`,后者不返回 ekey)。
//!
//! 另外 `authst` 约 **22.3 小时**过期,失败文案要给出"重新登录 QQ 音乐"的出口。
use serde::{Deserialize, Serialize};
use super::common::DecryptError;
use super::qq_footer::MusiCexTail;
/// 取 ekey 的接口地址
pub const EVKEY_ENDPOINT: &str = "https://u.y.qq.com/cgi-bin/musicu.fcg";
/// PC 端的 platform 标识(Windows)
pub const PLATFORM_WINDOWS: &str = "27";
/// 组装 `GetEVkey` 请求体。
///
/// 抽成纯函数是为了能单测那三个"必须"——它们是这个接口最容易踩的坑。
pub fn build_evkey_request(
uin: &str,
authst: &str,
media_mid: &str,
filename: &str,
login_type: u32,
) -> serde_json::Value {
serde_json::json!({
"comm": {
"authst": authst,
"ct": "19",
"cv": "1859",
"uin": uin,
"tmeLoginType": login_type.to_string(),
},
"req_1": {
"module": "music.vkey.GetEVkey",
"method": "CgiGetEVkey",
"param": {
"filename": [filename],
"guid": "10000",
"songmid": [media_mid],
"songtype": [1],
"uin": uin,
"loginflag": 1,
"platform": PLATFORM_WINDOWS,
"ctx": 1,
}
}
})
}
/// `GetEVkey` 的响应(只声明用得到的字段)
#[derive(Debug, Clone, Deserialize)]
pub struct EvkeyResponse {
#[serde(default)]
pub code: i64,
#[serde(default)]
pub req_1: Option<EvkeyReq1>,
}
#[derive(Debug, Clone, Deserialize)]
pub struct EvkeyReq1 {
#[serde(default)]
pub code: i64,
#[serde(default)]
pub data: Option<EvkeyData>,
}
#[derive(Debug, Clone, Deserialize)]
pub struct EvkeyData {
#[serde(default)]
pub midurlinfo: Vec<EvkeyItem>,
/// ekey 有效期(秒),实测约 80400
#[serde(default)]
pub expiration: i64,
}
#[derive(Debug, Clone, Deserialize)]
pub struct EvkeyItem {
#[serde(default)]
pub ekey: String,
#[serde(default)]
pub result: i64,
#[serde(default)]
pub subcode: i64,
}
/// 把响应解读为 `(ekey, 有效期秒数)` 或一个**可读的**失败原因。
///
/// 这里集中处理错误码,是为了让 UI 能给出下一步动作,而不是丢一个数字出去。
/// 有效期一并返回:`authst` 过期是这条链路最常见的失败原因,把"还能用多久"
/// 讲清楚比让用户猜要好。
pub fn parse_evkey_response(resp: &EvkeyResponse) -> Result<(String, i64), DecryptError> {
let req = resp
.req_1
.as_ref()
.ok_or_else(|| DecryptError::KeyRequired("服务器响应缺少 req_1".into()))?;
let data = req
.data
.as_ref()
.ok_or_else(|| DecryptError::KeyRequired("服务器响应缺少 data".into()))?;
let item = data
.midurlinfo
.first()
.ok_or_else(|| DecryptError::KeyRequired("服务器未返回任何资源信息".into()))?;
if item.ekey.is_empty() {
let hint = match item.result {
104005 => {
"该资源的密钥需要 VIP 或当前账号无权访问(错误码 104005);也可能文件名缺少扩展名"
}
0 => "服务器返回了空 ekey,通常是登录态已过期——请在 QQ 音乐里重新登录后重试",
_ => "服务器未返回 ekey",
};
return Err(DecryptError::KeyRequired(format!(
"{hint}(result={}, subcode={}, code={}/{}/{})",
item.result, item.subcode, resp.code, req.code, item.result
)));
}
Ok((item.ekey.clone(), data.expiration))
}
/// 从响应 JSON 文本解析出 ekey。
///
/// 生产路径走 [`fetch_ekey`](它需要有效期),这个薄封装主要给测试用,
/// 也作为该接口对外的最小 API。
#[cfg_attr(not(test), allow(dead_code))]
pub fn extract_ekey(body: &str) -> Result<String, DecryptError> {
let resp: EvkeyResponse = serde_json::from_str(body)
.map_err(|e| DecryptError::KeyRequired(format!("解析服务器响应失败:{e}")))?;
parse_evkey_response(&resp).map(|(ekey, _)| ekey)
}
/// 在线取 ekey 的入参(把"要什么"与"怎么取"分开,便于测试与日志)
#[derive(Debug, Clone, Serialize)]
pub struct EvkeyRequest {
pub uin: String,
pub authst: String,
pub media_mid: String,
pub filename: String,
pub login_type: u32,
}
impl EvkeyRequest {
/// 从 musicex 尾部 + 凭据构造
pub fn from_tail(tail: &MusiCexTail, uin: &str, authst: &str) -> Result<Self, DecryptError> {
if tail.media_mid.is_empty() {
return Err(DecryptError::Broken(
"musicex 尾部缺少 media_mid,无法向服务器索取密钥".into(),
));
}
if tail.filename.is_empty() {
return Err(DecryptError::Broken(
"musicex 尾部缺少文件名,无法向服务器索取密钥".into(),
));
}
// 接口要求 filename 必须带扩展名
if !tail.filename.contains('.') {
return Err(DecryptError::Broken(
"musicex 尾部文件名没有扩展名,服务器会拒绝(104005)".into(),
));
}
Ok(Self {
uin: uin.to_string(),
authst: authst.to_string(),
media_mid: tail.media_mid.clone(),
filename: tail.filename.clone(),
// 默认按 QQ 登录;微信登录是 3,两者都能用 authst,不影响取 ekey
login_type: 1,
})
}
pub fn body(&self) -> serde_json::Value {
build_evkey_request(
&self.uin,
&self.authst,
&self.media_mid,
&self.filename,
self.login_type,
)
}
}
/// 实际发请求(异步),返回 `(ekey, 有效期秒数)`。
pub async fn fetch_ekey(
client: &reqwest::Client,
req: &EvkeyRequest,
) -> Result<(String, i64), DecryptError> {
let body = req.body();
let resp = tokio::time::timeout(
std::time::Duration::from_secs(20),
client.post(EVKEY_ENDPOINT).json(&body).send(),
)
.await
.map_err(|_| DecryptError::KeyRequired("请求 QQ 音乐服务器超时".into()))?
.map_err(|e| DecryptError::KeyRequired(format!("请求 QQ 音乐服务器失败:{e}")))?;
let status = resp.status();
let text = resp
.text()
.await
.map_err(|e| DecryptError::KeyRequired(format!("读取服务器响应失败:{e}")))?;
if !status.is_success() {
return Err(DecryptError::KeyRequired(format!(
"QQ 音乐服务器返回 HTTP {status}:{}",
text.chars().take(200).collect::<String>()
)));
}
parse_evkey_response(
&serde_json::from_str(&text)
.map_err(|e| DecryptError::KeyRequired(format!("解析服务器响应失败:{e}")))?,
)
}
#[cfg(test)]
mod tests {
use super::*;
fn tail() -> MusiCexTail {
MusiCexTail {
song_id: 1,
media_mid: "0012ABCDEF".into(),
filename: "O4M00012ABCDEF.mgg".into(),
footer_size: 192,
version: 1,
..Default::default()
}
}
/// 接口契约的三个"必须"——写错了不会报错,只会静默拿不到 ekey
#[test]
fn request_body_satisfies_api_contract() {
let req = EvkeyRequest::from_tail(&tail(), "1154027699", "TOKEN").unwrap();
let body = req.body();
assert_eq!(body["req_1"]["module"], "music.vkey.GetEVkey");
assert_eq!(body["req_1"]["method"], "CgiGetEVkey");
let param = &body["req_1"]["param"];
// songtype 必须为 1(加密资源)
assert_eq!(param["songtype"][0], 1);
// filename 必须带扩展名
assert_eq!(param["filename"][0], "O4M00012ABCDEF.mgg");
assert!(param["filename"][0].as_str().unwrap().contains('.'));
// songmid 来自 media_mid
assert_eq!(param["songmid"][0], "0012ABCDEF");
// platform = 27(Windows)
assert_eq!(param["platform"], "27");
// comm 里要带 authst / uin
assert_eq!(body["comm"]["authst"], "TOKEN");
assert_eq!(body["comm"]["uin"], "1154027699");
}
#[test]
fn from_tail_rejects_incomplete_tail() {
let mut t = tail();
t.media_mid.clear();
assert!(EvkeyRequest::from_tail(&t, "1", "T").is_err());
let mut t = tail();
t.filename.clear();
assert!(EvkeyRequest::from_tail(&t, "1", "T").is_err());
// 没有扩展名的文件名会被服务器拒绝,提前拦下
let mut t = tail();
t.filename = "O4M00012ABCDEF".into();
let err = EvkeyRequest::from_tail(&t, "1", "T").unwrap_err();
assert!(err.to_string().contains("扩展名"));
}
#[test]
fn parses_successful_response() {
let body = r#"{
"code": 0,
"req_1": { "code": 0, "data": {
"midurlinfo": [{ "ekey": "REAL_EKEY", "result": 0, "subcode": 0 }],
"expiration": 80400
}}
}"#;
assert_eq!(extract_ekey(body).unwrap(), "REAL_EKEY");
}
/// 104005:要么需要 VIP,要么 filename 没带扩展名——文案必须点出这两条
#[test]
fn error_104005_is_actionable() {
let body = r#"{
"code": 0,
"req_1": { "code": 0, "data": {
"midurlinfo": [{ "ekey": "", "result": 104005, "subcode": 0 }]
}}
}"#;
let err = extract_ekey(body).unwrap_err();
let msg = err.to_string();
assert!(msg.contains("104005"), "应带错误码:{msg}");
assert!(msg.contains("VIP"), "应提示 VIP:{msg}");
assert!(msg.contains("扩展名"), "应提示文件名要求:{msg}");
}
/// result=0 但 ekey 为空 → 登录态过期
#[test]
fn empty_ekey_with_result_zero_suggests_relogin() {
let body = r#"{
"code": 0,
"req_1": { "code": 0, "data": {
"midurlinfo": [{ "ekey": "", "result": 0, "subcode": 0 }]
}}
}"#;
let msg = extract_ekey(body).unwrap_err().to_string();
assert!(msg.contains("重新登录"), "应提示重新登录:{msg}");
}
#[test]
fn missing_sections_are_reported() {
assert!(extract_ekey(r#"{"code":0}"#).is_err());
assert!(extract_ekey(r#"{"code":0,"req_1":{"code":0}}"#).is_err());
assert!(extract_ekey(r#"{"code":0,"req_1":{"code":0,"data":{"midurlinfo":[]}}}"#).is_err());
}
#[test]
fn malformed_json_is_reported() {
let err = extract_ekey("not json").unwrap_err();
assert!(err.to_string().contains("解析"));
}
}
+231
View File
@@ -0,0 +1,231 @@
//! QQ音乐 **musicex** 尾部解析(QQ 客户端 ≥ 19.57 / Windows 22.x)。
//!
//! 新版客户端不再把 ekey 写进文件,只在末尾留 192 字节元数据,ekey 必须联网取。
//! 这个模块只做**纯解析**(无 IO、无网络),因此可以完整单测。
//!
//! ## 尾部布局(对照 `MUSIC_DECRYPT_PLAN.md` §3.2 与 qmc-decoder 的格式文档)
//!
//! ```text
//! +0x00 [4B] song_id uint32 LE
//! +0x04 [4B] quality_type1 uint32 LE
//! +0x08 [4B] quality_type2 uint32 LE
//! +0x0C [60B] media_mid UTF-16LE(可能以 NUL 结尾)
//! +0x48 [68B] filename UTF-16LE(含扩展名,如 O4M0xxxx.mgg)
//! +0x8C [48B] padding
//! +0xC0 [4B] footer_size uint32 LE(= 0xC0 = 192)
//! +0xC4 [4B] version uint32 LE(= 1)
//! +0xC8 [8B] magic "musicex\0"
//! ```
//!
//! 因此**音频段 = 文件大小 − footer_size**,且 footer 一定在文件末尾。
/// musicex 尾部魔术(含结尾 NUL)
pub const MUSICEX_MAGIC: &[u8; 8] = b"musicex\0";
/// 尾部固定长度(也是 footer_size 字段的期望值)
pub const MUSICEX_FOOTER_LEN: usize = 0xC0;
/// 解析出的 musicex 元数据
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct MusiCexTail {
pub song_id: u32,
pub quality_type1: u32,
pub quality_type2: u32,
/// 歌曲 mid(取 ekey 需要)
pub media_mid: String,
/// 资源文件名(**必须含扩展名**,否则 API 返回 104005)
pub filename: String,
/// 尾部声明的长度(正常为 192)
pub footer_size: u32,
pub version: u32,
}
impl MusiCexTail {
/// 音频段长度(文件总大小 − 尾部长度)
pub fn audio_len(&self, file_size: u64) -> u64 {
file_size.saturating_sub(self.footer_size as u64)
}
/// 给 UI 的一行说明
pub fn note(&self) -> String {
if self.filename.is_empty() {
format!("musicex(songId={})", self.song_id)
} else {
format!("musicex · {}", self.filename)
}
}
}
/// 判断一段**文件尾部字节**是否是 musicex 尾部。
pub fn is_musicex_tail(buf: &[u8]) -> bool {
buf.len() >= 8 && &buf[buf.len() - 8..] == MUSICEX_MAGIC
}
/// 从文件末尾字节解析 musicex 尾部。
///
/// `buf` 必须至少包含整个尾部([`MUSICEX_FOOTER_LEN`] 字节),否则返回 `None`。
pub fn parse_musicex_tail(buf: &[u8]) -> Option<MusiCexTail> {
if !is_musicex_tail(buf) {
return None;
}
let n = buf.len();
let footer_size = le_u32(buf, n - 16)?;
let version = le_u32(buf, n - 12)?;
// footer_size 是尾部总长;它必须落在缓冲区里才谈得上解析字段
let footer_size_usize = footer_size as usize;
if footer_size_usize < MUSICEX_FOOTER_LEN || footer_size_usize > n {
return None;
}
let start = n - footer_size_usize;
Some(MusiCexTail {
song_id: le_u32(buf, start)?,
quality_type1: le_u32(buf, start + 4)?,
quality_type2: le_u32(buf, start + 8)?,
media_mid: utf16le_at(buf, start + 0x0C, 60)?,
filename: utf16le_at(buf, start + 0x48, 68)?,
footer_size,
version,
})
}
fn le_u32(b: &[u8], at: usize) -> Option<u32> {
let end = at.checked_add(4)?;
let s = b.get(at..end)?;
Some(u32::from_le_bytes([s[0], s[1], s[2], s[3]]))
}
/// 读取定长 UTF-16LE 字段并去掉结尾的 NUL。
///
/// 字段是定长补齐的,未用部分为 0;也可能不补 NUL 而恰好占满,故两种都要容忍。
fn utf16le_at(buf: &[u8], at: usize, byte_len: usize) -> Option<String> {
let end = at.checked_add(byte_len)?;
let s = buf.get(at..end)?;
let mut units: Vec<u16> = s
.chunks_exact(2)
.map(|c| u16::from_le_bytes([c[0], c[1]]))
.collect();
while units.last() == Some(&0) {
units.pop();
}
Some(String::from_utf16_lossy(&units))
}
#[cfg(test)]
mod tests {
use super::*;
/// 构造一个合法的 musicex 尾部
fn build_tail(song_id: u32, mid: &str, filename: &str) -> Vec<u8> {
let mut tail = vec![0u8; MUSICEX_FOOTER_LEN];
tail[0..4].copy_from_slice(&song_id.to_le_bytes());
tail[4..8].copy_from_slice(&2u32.to_le_bytes());
tail[8..12].copy_from_slice(&2u32.to_le_bytes());
write_utf16(&mut tail[0x0C..0x0C + 60], mid);
write_utf16(&mut tail[0x48..0x48 + 68], filename);
let n = tail.len();
tail[n - 16..n - 12].copy_from_slice(&(MUSICEX_FOOTER_LEN as u32).to_le_bytes());
tail[n - 12..n - 8].copy_from_slice(&1u32.to_le_bytes());
tail[n - 8..].copy_from_slice(MUSICEX_MAGIC);
tail
}
fn write_utf16(dst: &mut [u8], s: &str) {
for (i, unit) in s.encode_utf16().enumerate() {
let at = i * 2;
if at + 2 > dst.len() {
break;
}
dst[at..at + 2].copy_from_slice(&unit.to_le_bytes());
}
}
#[test]
fn parses_valid_footer() {
let tail = build_tail(0x0C27ABCD, "0012ABCDEF", "O4M00012ABCDEF.mgg");
let parsed = parse_musicex_tail(&tail).expect("应解析成功");
assert_eq!(parsed.song_id, 0x0C27ABCD);
assert_eq!(parsed.quality_type1, 2);
assert_eq!(parsed.quality_type2, 2);
assert_eq!(parsed.media_mid, "0012ABCDEF");
assert_eq!(parsed.filename, "O4M00012ABCDEF.mgg");
assert_eq!(parsed.footer_size, 192);
assert_eq!(parsed.version, 1);
}
/// 尾部前面还有音频数据时,解析结果不受影响(按 footer_size 定位)
#[test]
fn parses_footer_with_audio_prefix() {
let tail = build_tail(7, "mid123", "F00000mid123.mflac");
let mut file = vec![0xAAu8; 5000];
file.extend_from_slice(&tail);
let parsed = parse_musicex_tail(&file).expect("应解析成功");
assert_eq!(parsed.filename, "F00000mid123.mflac");
assert_eq!(parsed.audio_len(file.len() as u64), 5000);
}
/// 字段恰好占满、没有 NUL 终止符时也要能读全
#[test]
fn parses_full_width_field_without_nul() {
let name = "A".repeat(34); // 68 字节 = 34 个 UTF-16 单元,正好占满
let tail = build_tail(1, "M", &name);
let parsed = parse_musicex_tail(&tail).expect("应解析成功");
assert_eq!(parsed.filename, name);
}
/// 中文文件名(UTF-16LE)要能正确还原
#[test]
fn parses_cjk_filename() {
let tail = build_tail(1, "mid", "歌曲 名.mgg");
let parsed = parse_musicex_tail(&tail).unwrap();
assert_eq!(parsed.filename, "歌曲 名.mgg");
}
#[test]
fn rejects_non_musicex() {
assert!(!is_musicex_tail(b"not a magic at all"));
assert!(parse_musicex_tail(&[0u8; 192]).is_none());
// 魔术对但长度不合理
let mut bad = vec![0u8; 192];
let n = bad.len();
bad[n - 8..].copy_from_slice(MUSICEX_MAGIC);
bad[n - 16..n - 12].copy_from_slice(&0xFFFFu32.to_le_bytes());
assert!(parse_musicex_tail(&bad).is_none(), "footer_size 越界应拒绝");
}
#[test]
fn rejects_truncated_buffer() {
// 只有 16 字节,放不下 192 字节的尾部结构
let mut short = vec![0u8; 16];
let n = short.len();
short[n - 8..].copy_from_slice(MUSICEX_MAGIC);
short[n - 16..n - 12].copy_from_slice(&192u32.to_le_bytes());
assert!(parse_musicex_tail(&short).is_none());
}
#[test]
fn audio_len_saturates() {
let t = MusiCexTail {
footer_size: 192,
..Default::default()
};
assert_eq!(t.audio_len(1000), 808);
// 文件比尾部还小:不能下溢
assert_eq!(t.audio_len(10), 0);
}
#[test]
fn note_includes_filename_when_present() {
let t = MusiCexTail {
filename: "a.mgg".into(),
song_id: 5,
..Default::default()
};
assert!(t.note().contains("a.mgg"));
let empty = MusiCexTail {
song_id: 9,
..Default::default()
};
assert!(empty.note().contains("9"));
}
}
+216
View File
@@ -0,0 +1,216 @@
//! `QQMusic.exe` 进程内存扫描(**只读**)。
//!
//! Windows 版 QQ 音乐把 `authst` 只放在运行期内存里,因此联网取 ekey 必须先把它捞出来。
//! 这是纯 Win32 胶水层:真正的解析逻辑([`super::qq_credentials::find_authst`] /
//! [`super::qq_credentials::parse_ini_uin`])是跨平台纯函数,已单独单测。
//!
//! ## 实现要点(踩过的坑)
//!
//! 1. **`MEMORY_BASIC_INFORMATION` 的 `PartitionId`**:Windows 10 1803+ 在
//! `AllocationProtect` 与 `RegionSize` 之间插入了 2 字节。结构体里**必须**包含它,
//! 否则 `RegionSize`/`State`/`Protect` 全部从错误偏移读取——症状是
//! `VirtualQueryEx` 返回的 `State` 读成了 `Protect` 的值(如 `PAGE_READWRITE=0x04`
//! 而不是 `MEM_COMMIT=0x1000`),于是**所有内存区域都被跳过**、永远扫不到。
//! `windows-sys` 的定义已经包含该字段,这里直接用官方结构体。
//! 2. **只扫 `MEM_COMMIT` 且可读的区域**,并跳过 `PAGE_GUARD` / `PAGE_NOACCESS`。
//! 3. **分块读取**(1 MB),避免一次 `ReadProcessMemory` 大区域时中途失败整块丢。
//! 4. 跨块保留 `AUTHST_KEY.len() - 1` 字节的重叠,防止 token 恰好横跨块边界。
use std::ffi::c_void;
use windows_sys::Win32::Foundation::{CloseHandle, INVALID_HANDLE_VALUE};
use windows_sys::Win32::System::Diagnostics::Debug::ReadProcessMemory;
use windows_sys::Win32::System::Diagnostics::ToolHelp::{
CreateToolhelp32Snapshot, Process32FirstW, Process32NextW, PROCESSENTRY32W, TH32CS_SNAPPROCESS,
};
use windows_sys::Win32::System::Memory::{
VirtualQueryEx, MEMORY_BASIC_INFORMATION, MEM_COMMIT, PAGE_GUARD, PAGE_NOACCESS,
};
use windows_sys::Win32::System::Threading::{
OpenProcess, PROCESS_QUERY_INFORMATION, PROCESS_VM_READ,
};
use super::qq_credentials::{find_authst_from, QQ_PROCESS_HINT};
/// 单次读取的块大小
const CHUNK: usize = 1024 * 1024;
/// 跨块重叠长度(`"authst":"` 的长度 - 1,防止 token 横跨块边界)
const OVERLAP: usize = 16;
/// 扫描上限:避免异常进程占用过久(每个进程最多读这么多字节)
const MAX_SCAN_BYTES: usize = 512 * 1024 * 1024;
/// 扫描结果
#[derive(Debug, Clone, Default)]
pub struct Found {
pub authst: Option<String>,
pub uin: Option<String>,
}
/// 按进程名(大小写不敏感子串)找 PID
pub fn find_process_pid(hint: &str) -> Option<u32> {
unsafe {
let snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
if snapshot == INVALID_HANDLE_VALUE {
return None;
}
let mut entry: PROCESSENTRY32W = std::mem::zeroed();
entry.dwSize = std::mem::size_of::<PROCESSENTRY32W>() as u32;
// 提前小写化,避免在进程列表里反复分配(进程数可达数百)
let needle = hint.to_lowercase();
let mut pid: Option<u32> = None;
if Process32FirstW(snapshot, &mut entry) != 0 {
loop {
let name_len = entry
.szExeFile
.iter()
.position(|&c| c == 0)
.unwrap_or(entry.szExeFile.len());
let name = String::from_utf16_lossy(&entry.szExeFile[..name_len]);
if name.to_lowercase().contains(&needle) {
pid = Some(entry.th32ProcessID);
break;
}
if Process32NextW(snapshot, &mut entry) == 0 {
break;
}
}
}
CloseHandle(snapshot);
pid
}
}
/// QQ 音乐是否在运行
pub fn is_qqmusic_running() -> bool {
find_process_pid(QQ_PROCESS_HINT).is_some()
}
/// 扫描 QQ 音乐进程内存,捞出 `authst`(顺带尝试 `"uin":"..."`)。
pub fn scan_qq_process() -> Result<Found, String> {
let pid = find_process_pid(QQ_PROCESS_HINT).ok_or("未找到 QQMusic.exe 进程")?;
// windows-sys 0.52 的 HANDLE 是 isize(0 表示失败)
let handle = unsafe { OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, 0, pid) };
if handle == 0 {
return Err("无法打开 QQMusic.exe(权限不足;请尝试以管理员身份运行本应用)".to_string());
}
let result = unsafe { scan_handle(handle) };
unsafe { CloseHandle(handle) };
result
}
unsafe fn scan_handle(handle: isize) -> Result<Found, String> {
let mut found = Found::default();
let mut address: usize = 0;
let mut buf = vec![0u8; CHUNK];
let mut scanned: usize = 0;
while address < usize::MAX {
let mut mbi: MEMORY_BASIC_INFORMATION = std::mem::zeroed();
let written = VirtualQueryEx(
handle,
address as *const c_void,
&mut mbi,
std::mem::size_of::<MEMORY_BASIC_INFORMATION>(),
);
if written == 0 {
break;
}
let region_size = mbi.RegionSize;
let base = mbi.BaseAddress as usize;
// 只读「已提交、且不是 guard/noaccess」的区域
let readable = mbi.State == MEM_COMMIT
&& (mbi.Protect & PAGE_GUARD) == 0
&& (mbi.Protect & PAGE_NOACCESS) == 0
&& mbi.Protect != 0;
if readable && region_size > 0 {
let mut offset = 0usize;
while offset < region_size && scanned < MAX_SCAN_BYTES {
let want = CHUNK.min(region_size - offset);
// 末尾留出重叠,保证 token 不因分块被截断
let read_len = want.min(buf.len());
let mut got = 0usize;
let ok = ReadProcessMemory(
handle,
(base + offset) as *const c_void,
buf.as_mut_ptr() as *mut c_void,
read_len,
&mut got,
);
if ok != 0 && got > 0 {
scanned += got;
let slice = &buf[..got];
if found.authst.is_none() {
if let Some(t) = find_authst_from(slice, 0) {
found.authst = Some(t);
}
}
if found.uin.is_none() {
found.uin = find_json_string(slice, b"\"uin\":\"");
}
if found.authst.is_some() && found.uin.is_some() {
return Ok(found);
}
}
// 前进:整块减去重叠,避免漏掉跨块的匹配
if want <= OVERLAP {
break;
}
offset += want - OVERLAP;
}
}
// 前进到下一个区域;RegionSize 为 0 时强制前进,防止死循环
let step = if region_size == 0 {
0x1000
} else {
region_size
};
match address.checked_add(step) {
Some(next) if next > address => address = next,
_ => break,
}
}
Ok(found)
}
/// 在字节里找 `"<key>":"<value>"` 形态的字符串值(用于 uin)
unsafe fn find_json_string(haystack: &[u8], key: &[u8]) -> Option<String> {
let mut pos = 0usize;
while pos + key.len() <= haystack.len() {
let rel = haystack[pos..].windows(key.len()).position(|w| w == key)?;
let start = pos + rel + key.len();
let end = haystack[start..].iter().position(|&b| b == b'"')?;
let val = &haystack[start..start + end];
if !val.is_empty() && val.iter().all(|b| b.is_ascii_digit()) {
return Some(String::from_utf8_lossy(val).to_string());
}
pos = start;
}
None
}
#[cfg(test)]
mod tests {
use super::*;
/// 「QQ 在不在运行」必须能在本机跑通且不 panic
/// (本机装了 QQ 音乐,结果可能是 true 或 false,取决于是否启动)
#[test]
fn process_detection_does_not_panic() {
let running = is_qqmusic_running();
// 只要求"不 panic 且能给出结论";不假设本机是否开着 QQ 音乐
eprintln!("QQMusic running = {running}");
}
/// 不存在的进程名必须返回 None,而不是卡住或 panic
#[test]
fn unknown_process_returns_none() {
assert!(find_process_pid("definitely-not-a-real-process-xyzzy").is_none());
}
}
+361
View File
@@ -0,0 +1,361 @@
//! QQ音乐解密的**编排层**:把「尾部形态 → 密钥来源 → 流密码」串起来。
//!
//! 密钥来源按 `MUSIC_DECRYPT_PLAN.md` §3.2 分层:
//!
//! | 尾部 | 密钥来源 | 需要联网 |
//! |---|---|---|
//! | QMC1 | 内置静态表 | 否 |
//! | QTag / V1 | 尾部内嵌 ekey | 否 |
//! | musicex | **本机已登录凭据 → `GetEVkey`** | 是 |
//!
//! 之所以单开一个模块而不是塞进 `qmc.rs`:联网那一路牵涉 HTTP 客户端、
//! 凭据与工作线程里的运行时,与纯算法拆开后 `qmc.rs` 可以保持零 IO 依赖。
use std::path::Path;
use super::common::{self, DecryptError};
use super::qmc;
use super::qq_credentials;
use super::qq_ekey::{self, EvkeyRequest};
use super::qq_footer::{self, MusiCexTail};
/// 在线能力状态(给 UI 状态卡用)
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, specta::Type)]
#[serde(rename_all = "camelCase")]
pub struct QqOnlineStatus {
/// QQMusic.exe 是否在运行
pub running: bool,
/// 是否取到了 authst(= 已登录且能读到内存)
pub logged_in: bool,
/// 本机读到的 QQ 号(仅用于展示;没有则为 None)
pub uin: Option<String>,
/// 是否具备在线取 ekey 的能力
pub ready: bool,
/// 给用户的一句话状态
pub message: String,
/// 需要用户照做的步骤(ready 时为一条"无需额外设置")
pub steps: Vec<String>,
}
/// 探测在线能力(**只读**:读 INI + 扫进程内存,不发网络请求)
pub fn probe_status() -> QqOnlineStatus {
let running = qq_memscan_running();
let creds = qq_credentials::read_credentials();
let ready = creds.usable();
let message = if ready {
"已就绪:可直接解密 QQ 音乐新版 musicex 文件".to_string()
} else if !running {
"QQ 音乐未运行——新版 musicex 文件的密钥只在登录后存在于内存中".to_string()
} else if creds.uin.is_none() {
"QQ 音乐在运行,但没读到本机账号(可能尚未登录)".to_string()
} else {
"QQ 音乐在运行,但未取到登录令牌(authst),请确认已登录".to_string()
};
let steps = if ready {
vec!["无需额外设置;QMC1 与尾部内嵌 ekey 的文件本来就不需要登录。".to_string()]
} else {
vec![
"1. 在电脑上启动 QQ 音乐客户端(Windows 版)。".to_string(),
"2. 用它登录你的账号(扫码或账号密码均可),并保持客户端开着。".to_string(),
"3. 回到本页点「重新检测」;状态变为「已就绪」后即可解密 musicex 文件。".to_string(),
"4. 若显示未取到登录令牌:先播放任意一首歌触发一次网络请求,再重新检测。".to_string(),
"5. 若仍失败,试过以管理员身份运行本应用(读取进程内存可能受权限限制)。".to_string(),
"6. 登录令牌约 22.3 小时过期;过期后重新检测即可。".to_string(),
]
};
QqOnlineStatus {
running,
logged_in: creds.authst.is_some(),
uin: creds.uin.clone(),
ready,
message,
steps,
}
}
fn qq_memscan_running() -> bool {
#[cfg(windows)]
{
super::qq_memscan::is_qqmusic_running()
}
#[cfg(not(windows))]
{
false
}
}
/// musicex 的联网取密钥 + 解密。
///
/// `client` 用于发请求;调用方负责给它一个带超时的实例。整个流程会在
/// 当前线程上建一个最小 tokio 运行时来 `block_on`——调度层本来就是
/// 独立工作线程,不占 tokio 的工作线程。
pub fn decrypt_musicex<F>(
input: &Path,
out_dir: &Path,
platform_label: &str,
mut progress: F,
) -> Result<common::Outcome, DecryptError>
where
F: FnMut(u64, u64),
{
let total = std::fs::metadata(input).map(|m| m.len()).unwrap_or(0);
if total < qq_footer::MUSICEX_FOOTER_LEN as u64 {
return Err(DecryptError::Broken("文件太小,不可能是 musicex".into()));
}
// 1) 解析尾部
let tail = read_musicex_tail(input)?;
let audio_len = tail.audio_len(total);
// 2) 取凭据
let creds = qq_credentials::read_credentials();
let (uin, authst) = match (creds.uin.as_deref(), creds.authst.as_deref()) {
(Some(u), Some(a)) => (u, a),
_ => {
return Err(DecryptError::KeyRequired(format!(
"{}。请在电脑上启动并登录 QQ 音乐客户端后重试,或在「解密」页点「重新检测」查看当前状态。",
creds.status_text()
)))
}
};
// 3) 请求 ekey
let req = EvkeyRequest::from_tail(&tail, uin, authst)?;
let client = reqwest::Client::builder()
.timeout(std::time::Duration::from_secs(25))
.build()
.map_err(|e| DecryptError::KeyRequired(format!("构建 HTTP 客户端失败:{e}")))?;
let (ekey, expiration) = block_on(fetch_ekey_async(&client, &req))?;
// 4) ekey → 原始密钥
let raw = qmc::parse_ekey(&ekey)?;
if raw.len() < 16 || raw.len() > 4096 {
return Err(DecryptError::KeyRequired(format!(
"服务器返回的密钥长度异常({} 字节),已放弃以免解出噪声",
raw.len()
)));
}
// 5) 解密音频段
let audio = read_audio_segment(input, audio_len)?;
// 用**解密结果**判定密钥是否正确,而不是猜密文头。
//
// 曾经的写法是"密文必须以 `#!Qk` 开头,否则拒绝"——**这个假设是错的**:
// 真机样本(Avicii - Heaven,musicex)的密文头是 `51 74 03 75`,
// 按那条守卫会把完全合法的文件误拒。QMC2 密文头没有稳定魔术,
// 而"用取到的密钥解出的前 16 字节是不是已知音频魔术"才可靠:
// 密钥错时它是随机噪声,几乎不可能凑成 `fLaC` / `OggS` / `ID3` / `ftyp`。
let mut plaintext = audio;
qmc::decrypt_with_raw_key(&raw, &mut plaintext);
let Some(format) = super::common::detect_format_opt(&plaintext) else {
return Err(DecryptError::KeyRequired(format!(
"取到的密钥没能解出可识别的音频头(前 16 字节 {:02x?})——可能是该资源的 ekey \
与文件不匹配,或登录态已过期;请重新检测后重试",
&plaintext[..16.min(plaintext.len())]
)));
};
let decrypted = plaintext;
let stem = input
.file_stem()
.map(|s| s.to_string_lossy().to_string())
.unwrap_or_else(|| "output".to_string());
std::fs::create_dir_all(out_dir)?;
let mut reserved = std::collections::HashSet::new();
let target = super::common::unique_output(out_dir, &stem, format, &mut reserved)?;
std::fs::write(&target, &decrypted)?;
progress(decrypted.len() as u64, decrypted.len() as u64);
Ok(common::Outcome {
output: target,
format: format.to_string(),
cover: None,
audio_bytes: decrypted.len() as u64,
note: format!(
"{platform_label} · {} · 在线取密钥解密(密钥有效期约 {} 小时)",
tail.note(),
// expiration 单位为秒(实测约 80400 ≈ 22.3 小时)
if expiration > 0 {
format!("{:.1}", expiration as f64 / 3600.0)
} else {
"未知".to_string()
}
),
})
}
/// 读文件末尾的 musicex 尾部
fn read_musicex_tail(input: &Path) -> Result<MusiCexTail, DecryptError> {
use std::io::{Read, Seek, SeekFrom};
let mut f = std::fs::File::open(input)?;
let size = f.metadata()?.len();
let take = (qq_footer::MUSICEX_FOOTER_LEN as u64).min(size) as usize;
f.seek(SeekFrom::End(-(take as i64)))?;
let mut buf = vec![0u8; take];
f.read_exact(&mut buf)?;
// 注意:这里只读了尾部 192 字节,而 footer_size 可能 > 192(版本变化)——
// 那就退化成"按已知长度解析",字段偏移仍以文件末尾为基准。
qq_footer::parse_musicex_tail(&buf)
.ok_or_else(|| DecryptError::Broken("musicex 尾部解析失败(魔术或长度字段异常)".into()))
}
/// 只读音频段(musicex 场景下文件不大,但依然按大小一次读入以便就地解密)
fn read_audio_segment(input: &Path, audio_len: u64) -> Result<Vec<u8>, DecryptError> {
use std::io::Read;
let mut f = std::fs::File::open(input)?;
let mut buf = vec![0u8; audio_len as usize];
f.read_exact(&mut buf)?;
Ok(buf)
}
/// 在**当前线程**上跑一个最小 tokio 运行时。
///
/// 调度层用独立 `std::thread` 干活,所以这里 `block_on` 是安全的
/// (不会在 tokio 的 worker 线程里嵌套)。
fn block_on<F: std::future::Future>(fut: F) -> F::Output {
match tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
{
Ok(rt) => rt.block_on(fut),
Err(_) => {
// 极端情况下退化为全局运行时(项目里已有 rt-multi-thread)
tauri::async_runtime::block_on(fut)
}
}
}
async fn fetch_ekey_async(
client: &reqwest::Client,
req: &EvkeyRequest,
) -> Result<(String, i64), DecryptError> {
qq_ekey::fetch_ekey(client, req).await
}
#[cfg(test)]
mod tests {
use super::*;
/// 状态探测必须能跑通且文案自洽(不假设本机 QQ 是否开着)
#[test]
fn probe_status_is_self_consistent() {
let s = probe_status();
assert_eq!(s.ready, s.running && s.logged_in);
assert!(!s.message.is_empty());
assert!(!s.steps.is_empty());
if s.ready {
assert!(s.steps.len() == 1, "就绪时只应给一条说明");
} else {
assert!(s.steps.len() >= 3, "未就绪时步骤要能照做");
}
}
/// 把本机真实探测结果打出来,便于人工核对「在线能力」是否按预期工作。
/// 不加断言(依赖本机是否开着 QQ 音乐),只在 `--nocapture` 时可见。
#[test]
fn probe_status_reports_machine_state() {
let s = probe_status();
eprintln!(
"[qq-online] running={} logged_in={} uin={:?} ready={}\n message: {}\n steps: {}",
s.running,
s.logged_in,
s.uin,
s.ready,
s.message,
s.steps.len()
);
}
/// musicex 文件必须被**离线路径**判为「需要密钥」,并且在有凭据时被识别为
/// 「该走在线路径」。
///
/// 刻意**不**真的发网络请求:单元测试不该依赖 QQ 服务器可达性与账号状态,
/// 否则本机登录后测试就会变慢、变脆。
#[test]
fn musicex_routes_to_online_path() {
let dir = std::env::temp_dir().join(format!("qq_online_{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
// 造一个 musicex 文件:尾部合法(含 media_mid / filename)。
// 音频段的内容无所谓——这条只验证"路由与入参构造",不发网络请求。
let mut file = vec![0u8; 4096];
let n = file.len();
let tail_start = n - qq_footer::MUSICEX_FOOTER_LEN;
write_utf16(
&mut file[tail_start + 0x0C..tail_start + 0x0C + 60],
"0012ABCDEF",
);
write_utf16(
&mut file[tail_start + 0x48..tail_start + 0x48 + 68],
"O4M00012ABCDEF.mgg",
);
file[n - 16..n - 12].copy_from_slice(&(qq_footer::MUSICEX_FOOTER_LEN as u32).to_le_bytes());
file[n - 12..n - 8].copy_from_slice(&1u32.to_le_bytes());
file[n - 8..].copy_from_slice(qq_footer::MUSICEX_MAGIC);
let src = dir.join("a.mgg");
std::fs::write(&src, &file).unwrap();
// 1) 尾部能被解析出取密钥所需的两个字段
let tail = read_musicex_tail(&src).expect("尾部应解析成功");
assert_eq!(tail.media_mid, "0012ABCDEF");
assert_eq!(tail.filename, "O4M00012ABCDEF.mgg");
assert_eq!(tail.audio_len(file.len() as u64), (tail_start) as u64);
// 2) 离线路径必须明确报「需要密钥」,而不是解出噪声
let offline = super::super::qmc::sniff_tail(&src).unwrap();
assert_eq!(offline.kind, super::super::qmc::TailKind::MusiCex);
// 3) 请求能从尾部正确构造(这正是联网那一步的入参)
let req = EvkeyRequest::from_tail(&tail, "1154027699", "TOKEN").unwrap();
assert_eq!(req.media_mid, "0012ABCDEF");
assert_eq!(req.filename, "O4M00012ABCDEF.mgg");
let _ = std::fs::remove_dir_all(&dir);
}
/// 密钥错误时不应产出"看起来成功"的垃圾:
/// 判据是**解密结果**能否识别成已知音频魔术。
///
/// 这条同时固化一个真机结论:QMC2 的**密文头没有稳定魔术**
/// (真机 musicex 样本头为 `51 74 03 75`,而 MIT/Apache 文档里提到的
/// `#!Qk` 并不适用于它),所以**不能**用密文头做守卫。
#[test]
fn wrong_key_yields_unrecognizable_header() {
// 用一段随机数据当"密文",配一个随便的密钥
let mut data = vec![0x51u8, 0x74, 0x03, 0x75];
data.extend((0..4092).map(|i| (i * 7 % 251) as u8));
let key: Vec<u8> = (0..64).map(|i| (i * 3 + 1) as u8).collect();
super::super::qmc::decrypt_with_raw_key(&key, &mut data);
// 解出来必须是"认不出",才会走到 KeyRequired 那条错误分支
assert!(
super::super::common::detect_format_opt(&data).is_none(),
"随机数据不应被识别成音频"
);
}
/// `#!Qk` 是 QMC2 的一种形态,但**不是** musicex 的头部——这里留一条记录性断言,
/// 防止后人再次把它当成通用守卫。
#[test]
fn qmc2_ciphertext_header_is_not_a_reliable_magic() {
assert_ne!(b"#!Qk", &[0x51u8, 0x74, 0x03, 0x75]);
// 真机样本的头就是后者;`detect_format_opt` 对两者都不应误判成音频
assert!(super::super::common::detect_format_opt(b"#!Qk\x00\x00\x00\x00").is_none());
}
/// 把一个定长 UTF-16LE 字段写进缓冲区(测试辅助)
fn write_utf16(dst: &mut [u8], s: &str) {
for (i, unit) in s.encode_utf16().enumerate() {
let at = i * 2;
if at + 2 > dst.len() {
break;
}
dst[at..at + 2].copy_from_slice(&unit.to_le_bytes());
}
}
}
+249
View File
@@ -0,0 +1,249 @@
//! 文件夹批量:递归扫描 + 平台路由。
//!
//! 用户要的是「以文件夹为单位处理」,所以这里的判定原则是:
//!
//! 1. **内容优先于后缀**。同一个曲库里 `.ncm` / `.mflac` / `.qmcflac` / `.mgg` 混放是常态,
//! 而后者还有 `.mgg0`、`.mflac0` 这类后缀变体;靠后缀枚举会漏。
//! 因此先看头部魔数(网易云 `CTENFDAM`),再看尾部形态(QMC 家族)。
//! 2. **只扫一次、只走一层递归**。目录树遍历用 `walkdir`,过滤在遍历中完成,
//! 不把整个目录列表灌进内存(几万首的曲库会很难看)。
//! 3. 扫描结果按**路径排序**,保证同一目录每次处理的顺序稳定(进度条与任务表可预期)。
use std::path::{Path, PathBuf};
use walkdir::WalkDir;
use super::{ncm, qmc};
/// 一个待处理的文件
#[derive(Debug, Clone)]
pub struct ScannedFile {
/// 绝对路径
pub path: PathBuf,
/// 相对扫描根的父目录(用于在输出目录里还原目录结构);根目录下的文件为 None
pub rel_parent: Option<PathBuf>,
/// 文件名(含后缀),给 UI 显示
pub name: String,
/// 该用哪个引擎
pub engine: Engine,
}
/// 引擎路由结果
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Engine {
/// 网易云 ncm
Ncm,
/// QQ音乐 QMC 家族
Qmc,
}
impl Engine {
pub fn label(self) -> &'static str {
match self {
Engine::Ncm => "网易云",
Engine::Qmc => "QQ音乐",
}
}
}
/// 单文件路由:读 8 字节魔数 + 4KB 尾部即可判定,不做全文件读。
///
/// 返回 `None` 表示这个文件不是我们认得的加密音乐(目录扫描时直接跳过,
/// 用户显式选中的文件则会得到一条 `unsupported` 结果)。
pub fn route(path: &Path) -> Option<Engine> {
if ncm::sniff(path) {
return Some(Engine::Ncm);
}
// QMC:尾部能判出形态就算认得
if qmc::sniff_tail(path).is_ok() {
// 后缀也在 QMC 家族里、或尾部形态明确(非纯 QMC1 兜底)时才算
let ext = path
.extension()
.map(|e| e.to_string_lossy().to_string())
.unwrap_or_default();
if qmc::is_qmc_extension(&ext) {
return Some(Engine::Qmc);
}
// 后缀不认识时,只有明确的尾部形态(QTag/V1/musicex)才认;
// 否则任何末尾凑巧不是 QTag 的文件都会被判成"QMC1",噪声太大。
if let Ok(tail) = qmc::sniff_tail(path) {
if tail.kind != qmc::TailKind::Qmc1 {
return Some(Engine::Qmc);
}
}
}
None
}
/// 递归扫描 `folder`,返回所有可解密的加密音乐文件。
///
/// `root` 用于计算相对路径(输出时还原目录结构)。`folder == root` 时即
/// 「以这个文件夹为单位处理」。传 `root = None` 则所有文件平铺。
///
/// 排序保证稳定;`max_depth` 为 `None` 时递归全部层级。
pub fn scan(folder: &Path, root: Option<&Path>) -> Result<Vec<ScannedFile>, String> {
if !folder.is_dir() {
return Err(format!("{} 不是文件夹", folder.display()));
}
let root = root.unwrap_or(folder);
let mut out = Vec::new();
for entry in WalkDir::new(folder)
.follow_links(false)
.into_iter()
.filter_map(|e| e.ok())
{
if !entry.file_type().is_file() {
continue;
}
let path = entry.path();
let Some(engine) = route(path) else {
continue;
};
let rel_parent = path
.parent()
.and_then(|p| p.strip_prefix(root).ok())
.filter(|p| !p.as_os_str().is_empty())
.map(|p| p.to_path_buf());
let name = path
.file_name()
.map(|n| n.to_string_lossy().to_string())
.unwrap_or_else(|| path.display().to_string());
out.push(ScannedFile {
path: path.to_path_buf(),
rel_parent,
name,
engine,
});
}
// 稳定排序:按相对目录 + 文件名,处理顺序可预期
out.sort_by(|a, b| {
a.rel_parent
.cmp(&b.rel_parent)
.then_with(|| a.name.to_lowercase().cmp(&b.name.to_lowercase()))
});
Ok(out)
}
#[cfg(test)]
mod tests {
use super::*;
use std::fs;
fn tmpdir(tag: &str) -> PathBuf {
let d = std::env::temp_dir().join(format!("dec_scan_{tag}_{}", std::process::id()));
let _ = fs::remove_dir_all(&d);
fs::create_dir_all(&d).unwrap();
d
}
/// 构造一个最小合法 ncm 头(只需魔数即可被 route 认出来)
fn fake_ncm() -> Vec<u8> {
let mut v = b"CTENFDAM".to_vec();
v.extend_from_slice(&[0x02, 0x00, 0, 0, 0, 0]);
v
}
#[test]
fn route_detects_ncm_by_magic_not_extension() {
let dir = tmpdir("route");
// 后缀故意起错,内容是对的 → 应按内容识别
let p = dir.join("mystery.bin");
fs::write(&p, fake_ncm()).unwrap();
assert_eq!(route(&p), Some(Engine::Ncm));
// 后缀像 ncm 但内容不对 → 不应识别(尾部判成 QMC1 但后缀不在家族里)
let q = dir.join("wrong.ncm");
fs::write(&q, vec![0x11u8; 1024]).unwrap();
assert_eq!(route(&q), None);
let _ = fs::remove_dir_all(&dir);
}
/// QMC1 靠后缀识别(尾部形态是兜底,不做主判据)
#[test]
fn route_detects_qmc_by_extension() {
let dir = tmpdir("qmc");
let p = dir.join("a.qmcflac");
fs::write(&p, vec![0x22u8; 4096]).unwrap();
assert_eq!(route(&p), Some(Engine::Qmc));
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn scan_is_recursive_and_preserves_relative_dirs() {
let dir = tmpdir("scan");
fs::create_dir_all(dir.join("Pop").join("2026")).unwrap();
fs::create_dir_all(dir.join("Rock")).unwrap();
fs::write(dir.join("root.ncm"), fake_ncm()).unwrap();
fs::write(dir.join("Pop").join("a.qmcflac"), vec![0x22u8; 512]).unwrap();
fs::write(dir.join("Pop").join("2026").join("b.ncm"), fake_ncm()).unwrap();
fs::write(dir.join("Rock").join("c.txt"), b"not audio").unwrap();
let files = scan(&dir, Some(&dir)).unwrap();
assert_eq!(files.len(), 3, "应找到 3 个加密文件(txt 被跳过)");
// 排序稳定:先根目录,再 Pop,再 Pop/2026
assert_eq!(files[0].name, "root.ncm");
assert!(
files[0].rel_parent.is_none(),
"根目录文件 rel_parent 应为 None"
);
let a = files.iter().find(|f| f.name == "a.qmcflac").unwrap();
assert_eq!(a.rel_parent.as_deref(), Some(Path::new("Pop")));
assert_eq!(a.engine, Engine::Qmc);
let b = files.iter().find(|f| f.name == "b.ncm").unwrap();
assert_eq!(
b.rel_parent.as_deref(),
Some(Path::new("Pop").join("2026").as_path())
);
assert_eq!(b.engine, Engine::Ncm);
let _ = fs::remove_dir_all(&dir);
}
/// 以子目录为根时,相对路径相对**子目录**而不是父目录
#[test]
fn scan_uses_given_root_for_relative_paths() {
let dir = tmpdir("root");
let sub = dir.join("Album");
fs::create_dir_all(sub.join("Disc1")).unwrap();
fs::write(sub.join("Disc1").join("x.qmc0"), vec![0x33u8; 512]).unwrap();
// 以子目录为 root:Disc1 在 root 内 → rel_parent = Disc1
let files = scan(&sub, Some(&sub)).unwrap();
assert_eq!(files.len(), 1);
assert_eq!(files[0].rel_parent.as_deref(), Some(Path::new("Disc1")));
// 以上级为 root:rel_parent = Album/Disc1
let files2 = scan(&sub, Some(&dir)).unwrap();
assert_eq!(
files2[0].rel_parent.as_deref(),
Some(Path::new("Album").join("Disc1").as_path())
);
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn scan_rejects_non_directory() {
let dir = tmpdir("notdir");
let f = dir.join("a.txt");
fs::write(&f, b"x").unwrap();
assert!(scan(&f, None).is_err());
let _ = fs::remove_dir_all(&dir);
}
#[test]
fn scan_on_empty_dir_returns_empty() {
let dir = tmpdir("empty");
let files = scan(&dir, None).unwrap();
assert!(files.is_empty());
let _ = fs::remove_dir_all(&dir);
}
}