use anyhow::{ensure, Result};
use std::{io::Read, net::SocketAddr, time::Duration};
use wechat_media::channels::{apply_channels_prefix, channels_prefix_keystream};
pub const MAX_CHANNELS_VIDEO_BYTES: usize = super::MAX_VIDEO_DOWNLOAD_BYTES;
const VIDEO_HOST: &str = "finder.video.qq.com";
const LEGACY_HOST: &str = "wxapp.tc.qq.com";
const USER_AGENT: &str = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Safari/537.36 MicroMessenger";
const REFERER: &str = "https://channels.weixin.qq.com/";
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct ChannelsDownloadFacts {
pub advertised_bytes: Option<u64>,
pub advertised_cdn_bytes: Option<u64>,
pub content_length: Option<u64>,
pub received_bytes: u64,
pub content_type: Option<String>,
pub encoded_box: Option<String>,
pub decoded_box: Option<String>,
}
pub struct ChannelsVideo {
pub bytes: Vec<u8>,
pub facts: ChannelsDownloadFacts,
}
impl std::fmt::Debug for ChannelsVideo {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ChannelsVideo")
.field("bytes", &self.bytes.len())
.field("facts", &self.facts)
.finish()
}
}
#[derive(Debug, Clone)]
pub struct ChannelsDownloadFailure {
pub check: &'static str,
pub facts: ChannelsDownloadFacts,
}
impl std::fmt::Display for ChannelsDownloadFailure {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("channels_integrity_failed")
}
}
impl std::error::Error for ChannelsDownloadFailure {}
pub fn channels_box_type(bytes: &[u8]) -> Option<String> {
let kind = bytes.get(4..8)?;
kind.iter()
.all(|b| b.is_ascii_alphanumeric() || *b == b' ')
.then(|| String::from_utf8_lossy(kind).into_owned())
}
pub fn channels_video_url(media: &crate::ChannelsMedia) -> Result<reqwest::Url> {
let (url, token) = media.transport();
let mut address = reqwest::Url::parse(&format!("{url}{token}"))
.map_err(|_| anyhow::anyhow!("channels_unsupported_media"))?;
ensure!(
matches!(address.scheme(), "http" | "https")
&& address.username().is_empty()
&& address.password().is_none()
&& address.port().is_none()
&& address.fragment().is_none(),
"channels_unsupported_media"
);
match address.host_str() {
Some(LEGACY_HOST) => address
.set_host(Some(VIDEO_HOST))
.map_err(|_| anyhow::anyhow!("channels_unsupported_media"))?,
Some(VIDEO_HOST) => {}
_ => anyhow::bail!("channels_unsupported_media"),
}
address
.set_scheme("https")
.map_err(|_| anyhow::anyhow!("channels_unsupported_media"))?;
Ok(address)
}
pub fn fetch_channels_video(
media: &crate::ChannelsMedia,
max_bytes: usize,
progress: impl FnMut(u64, Option<u64>) -> Result<()>,
) -> Result<ChannelsVideo> {
let url = channels_video_url(media)?;
let address = super::link_thumbnail::public_address(
&url,
"channels_download_failed",
"channels_download_failed",
)?;
download_at(url, address, media, max_bytes, progress)
}
fn timeout_for(expected: Option<u64>) -> Duration {
let seconds = expected.map_or(0, |bytes| bytes / (1024 * 1024));
Duration::from_secs((120 + seconds).min(30 * 60))
}
fn download_at(
url: reqwest::Url,
address: SocketAddr,
media: &crate::ChannelsMedia,
max_bytes: usize,
mut progress: impl FnMut(u64, Option<u64>) -> Result<()>,
) -> Result<ChannelsVideo> {
let cap = max_bytes.min(MAX_CHANNELS_VIDEO_BYTES) as u64;
let advertised = [media.file_size, media.cdn_file_size];
ensure!(
advertised.iter().flatten().all(|size| *size <= cap),
"channels_media_too_large"
);
let host = url.host_str().unwrap_or_default().to_owned();
let client = reqwest::blocking::Client::builder()
.timeout(timeout_for(media.file_size.or(media.cdn_file_size)))
.connect_timeout(Duration::from_secs(15))
.redirect(reqwest::redirect::Policy::none())
.no_proxy()
.resolve(&host, address)
.build()?;
let mut response = client
.get(url)
.header("Accept-Encoding", "identity")
.header("User-Agent", USER_AGENT)
.header("Referer", REFERER)
.send()
.map_err(|_| anyhow::anyhow!("channels_download_failed"))?;
if response.status() != 200 {
anyhow::bail!("CDN HTTP status {}", response.status().as_u16());
}
let header = |name: &str| {
response
.headers()
.get(name)
.and_then(|value| value.to_str().ok())
.map(str::to_ascii_lowercase)
};
ensure!(
header("x-errno").is_none_or(|errno| errno.trim() == "0"),
"channels_download_failed"
);
ensure!(
header("content-encoding").is_none_or(|v| v == "identity"),
"channels_download_failed"
);
ensure!(
header("content-type").is_none_or(
|kind| kind.starts_with("video/") || kind.starts_with("application/octet-stream")
),
"channels_download_failed"
);
let content_type = header("content-type")
.map(|kind| kind.split(';').next().unwrap_or_default().trim().to_owned())
.filter(|kind| {
kind.len() <= 64
&& kind.contains('/')
&& kind
.bytes()
.all(|b| b.is_ascii_alphanumeric() || b"/.+-".contains(&b))
});
let total = response.content_length();
if let Some(length) = total {
ensure!(length <= cap, "channels_media_too_large");
}
let stream = channels_prefix_keystream(media.decode_key());
let mut bytes = Vec::with_capacity(total.unwrap_or(0).min(cap) as usize);
let mut chunk = vec![0u8; 64 * 1024];
let mut head = Vec::with_capacity(8);
loop {
progress(bytes.len() as u64, total)?;
let n = response
.read(&mut chunk)
.map_err(|_| anyhow::anyhow!("channels_download_failed"))?;
if n == 0 {
break;
}
ensure!((bytes.len() + n) as u64 <= cap, "channels_media_too_large");
if head.len() < 8 {
let wanted = (8 - head.len()).min(n);
head.extend_from_slice(&chunk[..wanted]);
}
let offset = bytes.len() as u64;
apply_channels_prefix(&mut chunk[..n], offset, &stream);
bytes.extend_from_slice(&chunk[..n]);
}
let facts = ChannelsDownloadFacts {
advertised_bytes: media.file_size,
advertised_cdn_bytes: media.cdn_file_size,
content_length: total,
received_bytes: bytes.len() as u64,
content_type,
encoded_box: channels_box_type(&head),
decoded_box: channels_box_type(&bytes),
};
let check = if bytes.is_empty() {
Some("empty")
} else if total.is_some_and(|n| n != facts.received_bytes) {
Some("length")
} else {
None
};
if let Some(check) = check {
return Err(ChannelsDownloadFailure { check, facts }.into());
}
Ok(ChannelsVideo { bytes, facts })
}
#[cfg(test)]
mod tests {
use super::*;
use std::{io::Write, net::TcpListener};
use wechat_media::channels::CHANNELS_PREFIX_BYTES;
fn media(url: &str, token: &str, key: u64, size: Option<u64>) -> crate::ChannelsMedia {
crate::ChannelsMedia::for_tests(url, token, key, size)
}
#[test]
fn download_address_appends_the_token_and_moves_to_the_video_host() {
let url = channels_video_url(&media(
"http://wxapp.tc.qq.com/251/20302/stodownload?encfilekey=a%2Bb&idx=1",
"&token=t%3D1&web=1",
1,
None,
))
.unwrap();
assert_eq!(
url.as_str(),
"https://finder.video.qq.com/251/20302/stodownload?encfilekey=a%2Bb&idx=1&token=t%3D1&web=1"
);
for bad in [
"http://example.invalid/251/stodownload?x=1",
"http://wxapp.tc.qq.com:8080/x",
"http://user@wxapp.tc.qq.com/x",
"ftp://wxapp.tc.qq.com/x",
"not a url",
] {
assert!(
channels_video_url(&media(bad, "", 1, None)).is_err(),
"{bad}"
);
}
}
fn serve(
head: String,
body: Vec<u8>,
) -> (reqwest::Url, SocketAddr, std::thread::JoinHandle<String>) {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let address = listener.local_addr().unwrap();
let server = std::thread::spawn(move || {
let (mut stream, _) = listener.accept().unwrap();
stream
.set_read_timeout(Some(Duration::from_secs(2)))
.unwrap();
let mut request = vec![];
let mut byte = [0];
while !request.ends_with(b"\r\n\r\n") {
stream.read_exact(&mut byte).unwrap();
request.push(byte[0]);
}
let _ = stream.write_all(head.as_bytes());
let _ = stream.write_all(&body);
String::from_utf8(request).unwrap()
});
let url =
reqwest::Url::parse(&format!("http://127.0.0.1:{}/video?x=1", address.port())).unwrap();
(url, address, server)
}
#[test]
fn decodes_the_prefix_and_checks_length_type_and_redirects() {
let mut plain: Vec<u8> = (0..CHANNELS_PREFIX_BYTES + 1000)
.map(|i| (i % 253) as u8)
.collect();
plain[..8].copy_from_slice(&[0, 0, 0, 32, b'f', b't', b'y', b'p']);
let mut encrypted = plain.clone();
let stream = channels_prefix_keystream(42);
apply_channels_prefix(&mut encrypted, 0, &stream);
let ok = format!(
"HTTP/1.1 200 OK\r\nConnection: close\r\nContent-Type: video/mp4\r\nX-ErrNo: 0\r\nContent-Length: {}\r\n\r\n",
encrypted.len()
);
let (url, address, server) = serve(ok.clone(), encrypted.clone());
let size = Some(encrypted.len() as u64);
let mut seen = 0;
let video = download_at(
url,
address,
&media("u", "", 42, size),
usize::MAX,
|done, _| {
seen = done;
Ok(())
},
)
.unwrap();
assert_eq!(video.bytes, plain);
assert_eq!(video.facts.received_bytes, plain.len() as u64);
assert_eq!(video.facts.content_length, size);
assert_eq!(video.facts.content_type.as_deref(), Some("video/mp4"));
assert_eq!(video.facts.decoded_box.as_deref(), Some("ftyp"));
assert_ne!(video.facts.encoded_box.as_deref(), Some("ftyp"));
assert_eq!(seen, plain.len() as u64);
let request = server.join().unwrap();
assert!(
request.contains("referer: https://channels.weixin.qq.com/\r\n")
|| request.contains("Referer: https://channels.weixin.qq.com/\r\n")
);
let cases = [
("HTTP/1.1 302 Found\r\nConnection: close\r\nLocation: http://127.0.0.1/x\r\nContent-Length: 0\r\n\r\n".to_string(), vec![], size, "CDN HTTP status 302"),
("HTTP/1.1 403 Forbidden\r\nConnection: close\r\nContent-Length: 0\r\n\r\n".to_string(), vec![], size, "CDN HTTP status 403"),
("HTTP/1.1 200 OK\r\nConnection: close\r\nContent-Type: text/html\r\nContent-Length: 4\r\n\r\n".to_string(), b"<ht>".to_vec(), None, "channels_download_failed"),
("HTTP/1.1 200 OK\r\nConnection: close\r\nX-ErrNo: -5103144\r\nContent-Length: 4\r\n\r\n".to_string(), b"abcd".to_vec(), None, "channels_download_failed"),
("HTTP/1.1 200 OK\r\nConnection: close\r\nContent-Type: video/mp4\r\n\r\n".to_string(), vec![1; 64], Some(32), "channels_media_too_large"),
];
for (head, body, advertised, expected) in cases {
let cap = if expected == "channels_media_too_large" {
32
} else {
usize::MAX
};
let (url, address, server) = serve(head, body);
let error = download_at(url, address, &media("u", "", 1, advertised), cap, |_, _| {
Ok(())
})
.unwrap_err();
assert_eq!(error.to_string(), expected);
let _ = server.join();
}
}
#[test]
fn a_different_advertised_size_is_recorded_and_a_short_body_is_a_length_failure() {
let head = "HTTP/1.1 200 OK\r\nConnection: close\r\nContent-Type: video/mp4\r\nContent-Length: 16\r\n\r\n";
let (url, address, server) = serve(head.into(), vec![7; 16]);
let video = download_at(
url,
address,
&media("u", "", 1, Some(99)),
usize::MAX,
|_, _| Ok(()),
)
.unwrap();
let _ = server.join();
assert_eq!(video.facts.advertised_bytes, Some(99));
assert_eq!(video.facts.received_bytes, 16);
let (url, address, server) = serve(
"HTTP/1.1 200 OK\r\nConnection: close\r\nContent-Type: video/mp4\r\n\r\n".into(),
vec![],
);
let error = download_at(
url,
address,
&media("u", "", 1, None),
usize::MAX,
|_, _| Ok(()),
)
.unwrap_err();
let _ = server.join();
let failure = error.downcast_ref::<ChannelsDownloadFailure>().unwrap();
assert_eq!(failure.check, "empty");
assert_eq!(error.to_string(), "channels_integrity_failed");
}
#[test]
fn an_oversized_advertised_size_fails_before_connecting() {
let address: SocketAddr = "127.0.0.1:9".parse().unwrap();
let url = reqwest::Url::parse("http://127.0.0.1:9/v").unwrap();
let error = download_at(url, address, &media("u", "", 1, Some(100)), 99, |_, _| {
Ok(())
})
.unwrap_err();
assert_eq!(error.to_string(), "channels_media_too_large");
}
}