音乐控制/解密
This commit is contained in:
1 parent
9e6d73e191
commit
ff1d5cd517
41 files changed
+10827
-4
No files matched your search
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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");
|
||||
}
|
||||
}
|
||||
@@ -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"), "已结束的任务不应再被取消");
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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(), "已就绪");
|
||||
}
|
||||
}
|
||||
@@ -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("解析"));
|
||||
}
|
||||
}
|
||||
@@ -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"));
|
||||
}
|
||||
}
|
||||
@@ -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());
|
||||
}
|
||||
}
|
||||
@@ -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());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user