mirror of
https://github.com/nimbold/Firelink.git
synced 2026-08-08 18:33:39 +00:00
NimBold
735 lines
26 KiB
Rust
735 lines
26 KiB
Rust
use sha1::{Digest, Sha1};
|
|
use std::collections::{BTreeMap, HashSet};
|
|
use std::path::PathBuf;
|
|
|
|
use tauri::Manager;
|
|
|
|
use crate::ipc::{TorrentFile, TorrentMetadata};
|
|
|
|
pub const MAX_TORRENT_BYTES: usize = 16 * 1024 * 1024;
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct ParsedTorrent {
|
|
pub name: String,
|
|
pub total_bytes: u64,
|
|
pub files: Vec<TorrentFile>,
|
|
pub info_hash: String,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
enum BencodeValue {
|
|
Integer(i64),
|
|
Bytes(Vec<u8>),
|
|
List(Vec<BencodeValue>),
|
|
Dict(BTreeMap<Vec<u8>, BencodeValue>),
|
|
}
|
|
|
|
struct Parser<'a> {
|
|
input: &'a [u8],
|
|
position: usize,
|
|
depth: usize,
|
|
}
|
|
|
|
impl<'a> Parser<'a> {
|
|
fn new(input: &'a [u8]) -> Self {
|
|
Self { input, position: 0, depth: 0 }
|
|
}
|
|
|
|
fn parse(mut self) -> Result<BencodeValue, String> {
|
|
let value = self.parse_value()?;
|
|
if self.position != self.input.len() {
|
|
return Err("torrent metadata has trailing data".to_string());
|
|
}
|
|
Ok(value)
|
|
}
|
|
|
|
fn parse_value(&mut self) -> Result<BencodeValue, String> {
|
|
if self.depth >= 128 {
|
|
return Err("torrent metadata nesting is too deep".to_string());
|
|
}
|
|
let byte = *self
|
|
.input
|
|
.get(self.position)
|
|
.ok_or_else(|| "torrent metadata is truncated".to_string())?;
|
|
match byte {
|
|
b'i' => self.parse_integer(),
|
|
b'l' => self.parse_list(),
|
|
b'd' => self.parse_dict(),
|
|
b'0'..=b'9' => self.parse_bytes(),
|
|
_ => Err("torrent metadata contains an invalid bencode value".to_string()),
|
|
}
|
|
}
|
|
|
|
fn parse_integer(&mut self) -> Result<BencodeValue, String> {
|
|
self.position += 1;
|
|
let start = self.position;
|
|
while let Some(byte) = self.input.get(self.position) {
|
|
if *byte == b'e' {
|
|
break;
|
|
}
|
|
self.position += 1;
|
|
}
|
|
if self.input.get(self.position) != Some(&b'e') {
|
|
return Err("torrent integer is truncated".to_string());
|
|
}
|
|
let raw = std::str::from_utf8(&self.input[start..self.position])
|
|
.map_err(|_| "torrent integer is not valid UTF-8".to_string())?;
|
|
if raw.is_empty() || (raw.starts_with('0') && raw.len() > 1) || raw == "-0" {
|
|
return Err("torrent integer has invalid encoding".to_string());
|
|
}
|
|
let value = raw
|
|
.parse::<i64>()
|
|
.map_err(|_| "torrent integer is outside the supported range".to_string())?;
|
|
self.position += 1;
|
|
Ok(BencodeValue::Integer(value))
|
|
}
|
|
|
|
fn parse_bytes(&mut self) -> Result<BencodeValue, String> {
|
|
let start = self.position;
|
|
while let Some(byte) = self.input.get(self.position) {
|
|
if *byte == b':' {
|
|
break;
|
|
}
|
|
if !byte.is_ascii_digit() {
|
|
return Err("torrent byte string has an invalid length".to_string());
|
|
}
|
|
self.position += 1;
|
|
}
|
|
if self.input.get(self.position) != Some(&b':') {
|
|
return Err("torrent byte string is truncated".to_string());
|
|
}
|
|
let length = std::str::from_utf8(&self.input[start..self.position])
|
|
.map_err(|_| "torrent byte string length is invalid".to_string())?
|
|
.to_owned();
|
|
if (length.starts_with('0') && length.len() > 1) || length.is_empty() {
|
|
return Err("torrent byte string has invalid length encoding".to_string());
|
|
}
|
|
let length = length
|
|
.parse::<usize>()
|
|
.map_err(|_| "torrent byte string length is too large".to_string())?;
|
|
self.position += 1;
|
|
let end = self
|
|
.position
|
|
.checked_add(length)
|
|
.ok_or_else(|| "torrent byte string length overflowed".to_string())?;
|
|
if end > self.input.len() {
|
|
return Err("torrent byte string is truncated".to_string());
|
|
}
|
|
let value = self.input[self.position..end].to_vec();
|
|
self.position = end;
|
|
Ok(BencodeValue::Bytes(value))
|
|
}
|
|
|
|
fn parse_list(&mut self) -> Result<BencodeValue, String> {
|
|
self.position += 1;
|
|
self.depth += 1;
|
|
let mut values = Vec::new();
|
|
while self.input.get(self.position) != Some(&b'e') {
|
|
if self.input.get(self.position).is_none() {
|
|
self.depth -= 1;
|
|
return Err("torrent list is truncated".to_string());
|
|
}
|
|
values.push(self.parse_value()?);
|
|
}
|
|
self.position += 1;
|
|
self.depth -= 1;
|
|
Ok(BencodeValue::List(values))
|
|
}
|
|
|
|
fn parse_dict(&mut self) -> Result<BencodeValue, String> {
|
|
self.position += 1;
|
|
self.depth += 1;
|
|
let mut values = BTreeMap::new();
|
|
let mut previous_key: Option<Vec<u8>> = None;
|
|
while self.input.get(self.position) != Some(&b'e') {
|
|
if self.input.get(self.position).is_none() {
|
|
self.depth -= 1;
|
|
return Err("torrent dictionary is truncated".to_string());
|
|
}
|
|
let key = match self.parse_bytes()? {
|
|
BencodeValue::Bytes(key) => key,
|
|
_ => unreachable!(),
|
|
};
|
|
if previous_key.as_ref().is_some_and(|previous| previous >= &key) {
|
|
self.depth -= 1;
|
|
return Err("torrent dictionary keys are not sorted".to_string());
|
|
}
|
|
previous_key = Some(key.clone());
|
|
values.insert(key, self.parse_value()?);
|
|
}
|
|
self.position += 1;
|
|
self.depth -= 1;
|
|
Ok(BencodeValue::Dict(values))
|
|
}
|
|
}
|
|
|
|
fn encode(value: &BencodeValue, output: &mut Vec<u8>) {
|
|
match value {
|
|
BencodeValue::Integer(value) => output.extend_from_slice(format!("i{value}e").as_bytes()),
|
|
BencodeValue::Bytes(value) => {
|
|
output.extend_from_slice(value.len().to_string().as_bytes());
|
|
output.push(b':');
|
|
output.extend_from_slice(value);
|
|
}
|
|
BencodeValue::List(values) => {
|
|
output.push(b'l');
|
|
for value in values {
|
|
encode(value, output);
|
|
}
|
|
output.push(b'e');
|
|
}
|
|
BencodeValue::Dict(values) => {
|
|
output.push(b'd');
|
|
for (key, value) in values {
|
|
encode(&BencodeValue::Bytes(key.clone()), output);
|
|
encode(value, output);
|
|
}
|
|
output.push(b'e');
|
|
}
|
|
}
|
|
}
|
|
|
|
fn bytes_text(value: Option<&BencodeValue>, field: &str) -> Result<String, String> {
|
|
let bytes = match value {
|
|
Some(BencodeValue::Bytes(bytes)) => bytes,
|
|
_ => return Err(format!("torrent metadata is missing {field}")),
|
|
};
|
|
String::from_utf8(bytes.clone()).map_err(|_| format!("torrent {field} is not valid UTF-8"))
|
|
}
|
|
|
|
fn positive_length(value: Option<&BencodeValue>, field: &str) -> Result<u64, String> {
|
|
match value {
|
|
Some(BencodeValue::Integer(value)) if *value >= 0 => Ok(*value as u64),
|
|
_ => Err(format!("torrent {field} is invalid")),
|
|
}
|
|
}
|
|
|
|
fn safe_path_component(value: &str, field: &str) -> Result<String, String> {
|
|
let value = value.trim();
|
|
if value.is_empty() || value == "." || value == ".." || value.contains(['/', '\\', '\0']) {
|
|
return Err(format!("torrent {field} contains an unsafe path"));
|
|
}
|
|
Ok(crate::download_ownership::canonical_download_filename(value))
|
|
}
|
|
|
|
fn parse_info(info: &BencodeValue) -> Result<ParsedTorrent, String> {
|
|
let info_dict = match info {
|
|
BencodeValue::Dict(value) => value,
|
|
_ => return Err("torrent info dictionary is invalid".to_string()),
|
|
};
|
|
let name = info_dict
|
|
.get(b"name.utf-8".as_slice())
|
|
.or_else(|| info_dict.get(b"name".as_slice()))
|
|
.map(|value| bytes_text(Some(value), "name"))
|
|
.transpose()?
|
|
.ok_or_else(|| "torrent metadata is missing name".to_string())?;
|
|
let name = crate::download_ownership::canonical_download_filename(&safe_path_component(&name, "name")?);
|
|
|
|
let mut files = Vec::new();
|
|
let total_bytes = if let Some(files_value) = info_dict.get(b"files".as_slice()) {
|
|
let entries = match files_value {
|
|
BencodeValue::List(entries) => entries,
|
|
_ => return Err("torrent files field is invalid".to_string()),
|
|
};
|
|
let mut total = 0u64;
|
|
let mut paths = HashSet::new();
|
|
for (position, entry) in entries.iter().enumerate() {
|
|
let entry = match entry {
|
|
BencodeValue::Dict(value) => value,
|
|
_ => return Err(format!("torrent file entry {} is invalid", position + 1)),
|
|
};
|
|
let path_value = entry
|
|
.get(b"path.utf-8".as_slice())
|
|
.or_else(|| entry.get(b"path".as_slice()))
|
|
.ok_or_else(|| format!("torrent file entry {} has no path", position + 1))?;
|
|
let path_parts = match path_value {
|
|
BencodeValue::List(parts) => parts
|
|
.iter()
|
|
.map(|part| bytes_text(Some(part), "file path"))
|
|
.collect::<Result<Vec<_>, _>>()?,
|
|
_ => return Err(format!("torrent file entry {} path is invalid", position + 1)),
|
|
};
|
|
if path_parts.is_empty() {
|
|
return Err(format!("torrent file entry {} path is empty", position + 1));
|
|
}
|
|
let path = path_parts
|
|
.iter()
|
|
.map(|part| safe_path_component(part, "file path"))
|
|
.collect::<Result<Vec<_>, _>>()?
|
|
.join("/");
|
|
if !paths.insert(path.clone()) {
|
|
return Err("torrent contains duplicate output paths".to_string());
|
|
}
|
|
let length = positive_length(entry.get(b"length".as_slice()), "file length")?;
|
|
total = total
|
|
.checked_add(length)
|
|
.ok_or_else(|| "torrent total size is too large".to_string())?;
|
|
files.push(TorrentFile {
|
|
index: (position + 1) as u32,
|
|
path,
|
|
length,
|
|
});
|
|
}
|
|
if files.is_empty() {
|
|
return Err("torrent has no files".to_string());
|
|
}
|
|
total
|
|
} else {
|
|
let length = positive_length(info_dict.get(b"length".as_slice()), "length")?;
|
|
files.push(TorrentFile {
|
|
index: 1,
|
|
path: name.clone(),
|
|
length,
|
|
});
|
|
length
|
|
};
|
|
|
|
let mut encoded = Vec::new();
|
|
encode(info, &mut encoded);
|
|
let digest = Sha1::digest(encoded);
|
|
let info_hash = digest.iter().map(|byte| format!("{byte:02x}")).collect();
|
|
|
|
Ok(ParsedTorrent { name, total_bytes, files, info_hash })
|
|
}
|
|
|
|
fn canonical_btih(value: &str) -> Option<String> {
|
|
let normalized = value.trim().to_ascii_lowercase();
|
|
if normalized.len() == 40 && normalized.bytes().all(|byte| byte.is_ascii_hexdigit()) {
|
|
return Some(normalized);
|
|
}
|
|
if normalized.len() != 32 {
|
|
return None;
|
|
}
|
|
|
|
let mut decoded = Vec::with_capacity(20);
|
|
let mut accumulator = 0u64;
|
|
let mut bits = 0u8;
|
|
for byte in normalized.bytes() {
|
|
let value = match byte {
|
|
b'a'..=b'z' => byte - b'a',
|
|
b'2'..=b'7' => byte - b'2' + 26,
|
|
_ => return None,
|
|
} as u64;
|
|
accumulator = (accumulator << 5) | value;
|
|
bits += 5;
|
|
while bits >= 8 {
|
|
bits -= 8;
|
|
decoded.push(((accumulator >> bits) & 0xff) as u8);
|
|
}
|
|
if bits == 0 {
|
|
accumulator = 0;
|
|
} else {
|
|
accumulator &= (1u64 << bits) - 1;
|
|
}
|
|
}
|
|
if bits != 0 || decoded.len() != 20 {
|
|
return None;
|
|
}
|
|
|
|
Some(decoded.iter().map(|byte| format!("{byte:02x}")).collect())
|
|
}
|
|
|
|
pub fn validate_info_hash(expected: Option<&str>, actual: &str) -> Result<(), String> {
|
|
let Some(expected) = expected else {
|
|
return Ok(());
|
|
};
|
|
let expected = canonical_btih(expected)
|
|
.ok_or_else(|| "torrent metadata has an invalid expected info hash".to_string())?;
|
|
if expected != actual {
|
|
return Err("torrent metadata changed before it was queued".to_string());
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub fn parse_torrent_bytes(bytes: &[u8]) -> Result<ParsedTorrent, String> {
|
|
if bytes.is_empty() || bytes.len() > MAX_TORRENT_BYTES {
|
|
return Err(format!("torrent metadata must be between 1 byte and {MAX_TORRENT_BYTES} bytes"));
|
|
}
|
|
let root = Parser::new(bytes).parse()?;
|
|
let root = match root {
|
|
BencodeValue::Dict(value) => value,
|
|
_ => return Err("torrent root is not a dictionary".to_string()),
|
|
};
|
|
let info = root
|
|
.get(b"info".as_slice())
|
|
.ok_or_else(|| "torrent metadata is missing info".to_string())?;
|
|
parse_info(info)
|
|
}
|
|
|
|
fn magnet_metadata(source: &str) -> Result<ParsedTorrent, String> {
|
|
let parsed = url::Url::parse(source).map_err(|_| "invalid magnet URI".to_string())?;
|
|
if parsed.scheme() != "magnet" {
|
|
return Err("unsupported torrent source".to_string());
|
|
}
|
|
let info_hash = parsed
|
|
.query_pairs()
|
|
.find_map(|(key, value)| {
|
|
if key != "xt" {
|
|
return None;
|
|
}
|
|
let value = value.strip_prefix("urn:btih:")?;
|
|
canonical_btih(value)
|
|
})
|
|
.ok_or_else(|| "magnet URI has no valid BitTorrent info hash".to_string())?;
|
|
let name = parsed
|
|
.query_pairs()
|
|
.find_map(|(key, value)| (key == "dn").then_some(value.into_owned()))
|
|
.filter(|value| !value.trim().is_empty())
|
|
.map(|value| crate::download_ownership::canonical_download_filename(&value))
|
|
.unwrap_or_else(|| format!("torrent-{info_hash}"));
|
|
Ok(ParsedTorrent { name, total_bytes: 0, files: Vec::new(), info_hash })
|
|
}
|
|
|
|
fn local_torrent_path(source: &str) -> Result<PathBuf, String> {
|
|
let path = match url::Url::parse(source) {
|
|
Ok(parsed) if parsed.scheme() == "file" => parsed
|
|
.to_file_path()
|
|
.map_err(|_| "invalid local torrent path".to_string())?,
|
|
_ => PathBuf::from(source),
|
|
};
|
|
if !path.is_absolute() {
|
|
return Err("torrent source is not an absolute local file".to_string());
|
|
}
|
|
let path = std::fs::canonicalize(&path)
|
|
.map_err(|error| format!("could not resolve torrent file: {error}"))?;
|
|
if path.extension().and_then(|extension| extension.to_str()).map(|extension| extension.eq_ignore_ascii_case("torrent")) != Some(true) {
|
|
return Err("torrent files must use the .torrent extension".to_string());
|
|
}
|
|
Ok(path)
|
|
}
|
|
|
|
pub fn inspect_source(source: &str) -> Result<ParsedTorrent, String> {
|
|
if source.trim_start().to_ascii_lowercase().starts_with("magnet:") {
|
|
return magnet_metadata(source.trim());
|
|
}
|
|
let path = local_torrent_path(source)?;
|
|
let bytes = std::fs::read(&path).map_err(|error| format!("could not read torrent file: {error}"))?;
|
|
parse_torrent_bytes(&bytes)
|
|
}
|
|
|
|
pub fn to_metadata(parsed: ParsedTorrent, torrent_path: Option<String>) -> TorrentMetadata {
|
|
TorrentMetadata {
|
|
name: parsed.name,
|
|
total_bytes: parsed.total_bytes,
|
|
files: parsed.files,
|
|
info_hash: parsed.info_hash,
|
|
torrent_path,
|
|
}
|
|
}
|
|
|
|
/// Aria2's BitTorrent output is controlled by `index-out`, not `out`. Keep
|
|
/// these values derived from the validated, canonical paths so the daemon's
|
|
/// actual files stay aligned with Firelink's ownership registry.
|
|
pub fn aria2_index_outputs(parsed: &ParsedTorrent) -> Vec<String> {
|
|
parsed
|
|
.files
|
|
.iter()
|
|
.map(|file| {
|
|
let output = if parsed.files.len() == 1 {
|
|
file.path.clone()
|
|
} else {
|
|
format!("{}/{}", parsed.name, file.path)
|
|
};
|
|
format!("{}={output}", file.index)
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
pub fn aria2_output_paths(parsed: &ParsedTorrent, selected: Option<&[u32]>) -> Vec<String> {
|
|
parsed
|
|
.files
|
|
.iter()
|
|
.filter(|file| selected.is_none_or(|indices| indices.contains(&file.index)))
|
|
.map(|file| {
|
|
if parsed.files.len() == 1 {
|
|
file.path.clone()
|
|
} else {
|
|
format!("{}/{}", parsed.name, file.path)
|
|
}
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
pub fn managed_torrent_path<R: tauri::Runtime>(
|
|
app_handle: &tauri::AppHandle<R>,
|
|
id: &str,
|
|
) -> Result<PathBuf, String> {
|
|
if id.is_empty() || !id.bytes().all(|byte| byte.is_ascii_alphanumeric() || byte == b'-' || byte == b'_') {
|
|
return Err("invalid torrent download id".to_string());
|
|
}
|
|
let root = managed_torrent_storage_root(app_handle)?;
|
|
Ok(root.join(format!("{id}.torrent")))
|
|
}
|
|
|
|
pub fn managed_torrent_storage_root<R: tauri::Runtime>(
|
|
app_handle: &tauri::AppHandle<R>,
|
|
) -> Result<PathBuf, String> {
|
|
let root = app_handle
|
|
.path()
|
|
.app_data_dir()
|
|
.map_err(|error| format!("could not resolve torrent storage: {error}"))?
|
|
.join("torrents");
|
|
Ok(root)
|
|
}
|
|
|
|
pub fn remove_orphaned_probe_dirs<R: tauri::Runtime>(
|
|
app_handle: &tauri::AppHandle<R>,
|
|
) -> Result<usize, String> {
|
|
let root = managed_torrent_storage_root(app_handle)?;
|
|
let entries = match std::fs::read_dir(&root) {
|
|
Ok(entries) => entries,
|
|
Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(0),
|
|
Err(error) => return Err(format!("could not inspect torrent probe storage: {error}")),
|
|
};
|
|
let mut removed = 0;
|
|
for entry in entries {
|
|
let entry = entry.map_err(|error| format!("could not inspect torrent probe storage: {error}"))?;
|
|
let is_probe = entry
|
|
.file_name()
|
|
.to_str()
|
|
.is_some_and(|name| name.starts_with(".probe-"));
|
|
if !is_probe || !entry
|
|
.file_type()
|
|
.map_err(|error| format!("could not inspect torrent probe entry: {error}"))?
|
|
.is_dir()
|
|
{
|
|
continue;
|
|
}
|
|
std::fs::remove_dir_all(entry.path())
|
|
.map_err(|error| format!("could not remove orphaned torrent probe: {error}"))?;
|
|
removed += 1;
|
|
}
|
|
Ok(removed)
|
|
}
|
|
|
|
pub fn remove_orphaned_cached_torrents<R: tauri::Runtime>(
|
|
app_handle: &tauri::AppHandle<R>,
|
|
retained_ids: &HashSet<String>,
|
|
) -> Result<usize, String> {
|
|
let root = managed_torrent_storage_root(app_handle)?;
|
|
let entries = match std::fs::read_dir(&root) {
|
|
Ok(entries) => entries,
|
|
Err(error) if error.kind() == std::io::ErrorKind::NotFound => return Ok(0),
|
|
Err(error) => return Err(format!("could not inspect torrent metadata storage: {error}")),
|
|
};
|
|
let mut removed = 0;
|
|
for entry in entries {
|
|
let entry = entry.map_err(|error| format!("could not inspect torrent metadata storage: {error}"))?;
|
|
let file_type = entry
|
|
.file_type()
|
|
.map_err(|error| format!("could not inspect torrent metadata entry: {error}"))?;
|
|
if !file_type.is_file() || entry.path().extension().and_then(|ext| ext.to_str()) != Some("torrent") {
|
|
continue;
|
|
}
|
|
let path = entry.path();
|
|
let Some(id) = path.file_stem().and_then(|stem| stem.to_str()) else {
|
|
continue;
|
|
};
|
|
if retained_ids.contains(id) {
|
|
continue;
|
|
}
|
|
std::fs::remove_file(path)
|
|
.map_err(|error| format!("could not remove orphaned torrent metadata: {error}"))?;
|
|
removed += 1;
|
|
}
|
|
Ok(removed)
|
|
}
|
|
|
|
pub fn validate_selected_indices(
|
|
selected: Option<&[u32]>,
|
|
file_count: usize,
|
|
) -> Result<Option<Vec<u32>>, String> {
|
|
let Some(selected) = selected else {
|
|
return Ok(None);
|
|
};
|
|
if selected.is_empty() || selected.iter().any(|index| *index == 0 || *index as usize > file_count) {
|
|
return Err("torrent file selection is invalid".to_string());
|
|
}
|
|
let mut normalized = selected.to_vec();
|
|
normalized.sort_unstable();
|
|
normalized.dedup();
|
|
Ok(Some(normalized))
|
|
}
|
|
|
|
pub async fn prepare_local_torrent<R: tauri::Runtime>(
|
|
app_handle: &tauri::AppHandle<R>,
|
|
source: &str,
|
|
id: &str,
|
|
) -> Result<(ParsedTorrent, String), String> {
|
|
let source_path = local_torrent_path(source)?;
|
|
let file_metadata = tokio::fs::metadata(&source_path)
|
|
.await
|
|
.map_err(|error| format!("could not inspect torrent file: {error}"))?;
|
|
if file_metadata.len() == 0 || file_metadata.len() > MAX_TORRENT_BYTES as u64 {
|
|
return Err(format!(
|
|
"torrent metadata must be between 1 byte and {MAX_TORRENT_BYTES} bytes"
|
|
));
|
|
}
|
|
let bytes = tokio::fs::read(&source_path)
|
|
.await
|
|
.map_err(|error| format!("could not read torrent file: {error}"))?;
|
|
let parsed = parse_torrent_bytes(&bytes)?;
|
|
let destination = cache_torrent_bytes(app_handle, id, &bytes).await?;
|
|
Ok((parsed, destination))
|
|
}
|
|
|
|
pub async fn cache_torrent_bytes<R: tauri::Runtime>(
|
|
app_handle: &tauri::AppHandle<R>,
|
|
id: &str,
|
|
bytes: &[u8],
|
|
) -> Result<String, String> {
|
|
if bytes.is_empty() || bytes.len() > MAX_TORRENT_BYTES {
|
|
return Err(format!(
|
|
"torrent metadata must be between 1 byte and {MAX_TORRENT_BYTES} bytes"
|
|
));
|
|
}
|
|
let destination = managed_torrent_path(app_handle, id)?;
|
|
if let Some(parent) = destination.parent() {
|
|
tokio::fs::create_dir_all(parent)
|
|
.await
|
|
.map_err(|error| format!("could not create torrent storage: {error}"))?;
|
|
}
|
|
tokio::fs::write(&destination, bytes)
|
|
.await
|
|
.map_err(|error| format!("could not cache torrent metadata: {error}"))?;
|
|
Ok(destination.to_string_lossy().to_string())
|
|
}
|
|
|
|
pub fn validate_managed_torrent_path<R: tauri::Runtime>(
|
|
app_handle: &tauri::AppHandle<R>,
|
|
id: &str,
|
|
path: &str,
|
|
) -> Result<PathBuf, String> {
|
|
let expected = managed_torrent_path(app_handle, id)?;
|
|
let candidate = std::fs::canonicalize(path)
|
|
.map_err(|error| format!("could not access cached torrent metadata: {error}"))?;
|
|
let expected_parent = expected
|
|
.parent()
|
|
.and_then(|parent| std::fs::canonicalize(parent).ok())
|
|
.ok_or_else(|| "cached torrent storage is unavailable".to_string())?;
|
|
if candidate.parent() != Some(expected_parent.as_path()) || candidate.file_name() != expected.file_name() {
|
|
return Err("cached torrent metadata path is invalid".to_string());
|
|
}
|
|
Ok(candidate)
|
|
}
|
|
|
|
pub async fn remove_managed_torrent<R: tauri::Runtime>(
|
|
app_handle: &tauri::AppHandle<R>,
|
|
id: &str,
|
|
) {
|
|
if let Ok(path) = managed_torrent_path(app_handle, id) {
|
|
let _ = tokio::fs::remove_file(path).await;
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn parses_single_file_torrent_and_hashes_info_dictionary() {
|
|
let parsed = parse_torrent_bytes(b"d4:infod6:lengthi5e4:name4:testee")
|
|
.expect("single-file torrent should parse");
|
|
assert_eq!(parsed.name, "test");
|
|
assert_eq!(parsed.total_bytes, 5);
|
|
assert_eq!(parsed.files[0].index, 1);
|
|
assert_eq!(parsed.files[0].path, "test");
|
|
assert_eq!(parsed.info_hash.len(), 40);
|
|
}
|
|
|
|
#[test]
|
|
fn parses_multi_file_torrent_and_rejects_traversal() {
|
|
let parsed = parse_torrent_bytes(
|
|
b"d4:infod5:filesld6:lengthi2e4:pathl4:root5:a.txteed6:lengthi3e4:pathl4:root5:b.bineee4:name4:rootee",
|
|
)
|
|
.expect("multi-file torrent should parse");
|
|
assert_eq!(parsed.total_bytes, 5);
|
|
assert_eq!(parsed.files.len(), 2);
|
|
assert_eq!(parsed.files[1].path, "root/b.bin");
|
|
|
|
let error = parse_torrent_bytes(
|
|
b"d4:infod5:filesld6:lengthi1e4:pathl2:..4:evileee4:name4:rootee",
|
|
)
|
|
.expect_err("path traversal must be rejected");
|
|
assert!(error.contains("unsafe path"));
|
|
}
|
|
|
|
#[test]
|
|
fn parses_magnet_identity_without_logging_or_persisting_tracker_data() {
|
|
let parsed = inspect_source(
|
|
"magnet:?xt=urn:btih:0123456789abcdef0123456789abcdef01234567&dn=Example%20Torrent&tr=https%3A%2F%2Ftracker.invalid%2Fsecret",
|
|
)
|
|
.expect("magnet should parse");
|
|
assert_eq!(parsed.name, "Example Torrent");
|
|
assert_eq!(parsed.info_hash, "0123456789abcdef0123456789abcdef01234567");
|
|
assert!(parsed.files.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn canonicalizes_base32_magnet_hashes_to_hex() {
|
|
let parsed = inspect_source(
|
|
"magnet:?xt=urn:btih:AERUKZ4JVPG66AJDIVTYTK6N54ASGRLH&dn=Base32",
|
|
)
|
|
.expect("a valid Base32 hash should parse");
|
|
assert_eq!(parsed.info_hash, "0123456789abcdef0123456789abcdef01234567");
|
|
}
|
|
|
|
#[test]
|
|
fn validates_expected_hashes_across_hex_and_base32_encodings() {
|
|
validate_info_hash(
|
|
Some("AERUKZ4JVPG66AJDIVTYTK6N54ASGRLH"),
|
|
"0123456789abcdef0123456789abcdef01234567",
|
|
)
|
|
.expect("equivalent Base32 and hexadecimal hashes should match");
|
|
assert!(validate_info_hash(
|
|
Some("0123456789abcdef0123456789abcdef01234567"),
|
|
"fedcba9876543210fedcba9876543210fedcba98",
|
|
)
|
|
.is_err());
|
|
validate_info_hash(None, "not-used").expect("missing legacy identity should remain compatible");
|
|
}
|
|
|
|
#[test]
|
|
fn rejects_malformed_base32_magnet_hashes() {
|
|
let error = inspect_source(
|
|
"magnet:?xt=urn:btih:0123456789abcdef0123456789abcde!&dn=Invalid",
|
|
)
|
|
.expect_err("a 32-character hash with non-base32 characters must be rejected");
|
|
assert!(error.contains("valid BitTorrent info hash"));
|
|
|
|
let error = inspect_source(
|
|
"magnet:?xt=urn:btih:00000000000000000000000000000000&dn=Invalid",
|
|
)
|
|
.expect_err("characters outside RFC 4648 Base32 must be rejected");
|
|
assert!(error.contains("valid BitTorrent info hash"));
|
|
}
|
|
|
|
#[test]
|
|
fn normalizes_and_bounds_selected_file_indices() {
|
|
assert_eq!(
|
|
validate_selected_indices(Some(&[3, 1, 3]), 3).unwrap(),
|
|
Some(vec![1, 3])
|
|
);
|
|
assert!(validate_selected_indices(Some(&[0]), 3).is_err());
|
|
assert!(validate_selected_indices(Some(&[4]), 3).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn maps_validated_torrent_files_to_aria2_index_outputs() {
|
|
let parsed = parse_torrent_bytes(
|
|
b"d4:infod5:filesld6:lengthi2e4:pathl4:root5:a.txteed6:lengthi3e4:pathl4:root5:b.bineee4:name4:rootee",
|
|
)
|
|
.expect("multi-file torrent should parse");
|
|
assert_eq!(
|
|
aria2_index_outputs(&parsed),
|
|
vec!["1=root/root/a.txt".to_string(), "2=root/root/b.bin".to_string()]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn rejects_noncanonical_lengths_and_invalid_files_field() {
|
|
assert!(parse_torrent_bytes(b"d4:infod6:lengthi5e4:name04:testee").is_err());
|
|
assert!(parse_torrent_bytes(b"d4:infod5:filesi1e6:lengthi5e4:name4:testee").is_err());
|
|
}
|
|
}
|