use std::path::{Path, PathBuf};
use crate::error::{Error, Result};
use crate::integrity::{
checksum_block, encode_piece_parity, open_tracked, parity_from_bytes, parity_to_bytes,
reconstruct_piece, recover_piece, seal_tracked, verify_block_checksum,
IntegrityConfig, IntegrityManifest,
};
use crate::piece::verify_piece;
use crate::types::BlockKey;
use crate::torrent::ContentLayout;
use crate::torrent::TorrentInfo;
#[derive(Debug, Clone, Default)]
pub struct IntegrityImageReport {
pub piece_count: u32,
pub pieces_sha1_ok: u32,
pub block_count: u32,
pub blocks_crc_ok: u32,
pub parity_count: u32,
pub parity_ok: u32,
pub errors: Vec<String>,
}
impl IntegrityImageReport {
pub fn is_valid(&self) -> bool {
self.errors.is_empty()
&& self.pieces_sha1_ok == self.piece_count
&& self.blocks_crc_ok == self.block_count
&& self.parity_ok == self.parity_count
}
}
pub async fn build_integrity_image_async(
content: &ContentLayout,
info: &TorrentInfo,
sidecar_root: impl AsRef<Path>,
block_size: u32,
config: &IntegrityConfig,
) -> Result<IntegrityImageReport> {
let sidecar_root = sidecar_root.as_ref();
let sidecar_dir = IntegrityManifest::sidecar_dir(sidecar_root);
tokio::fs::create_dir_all(&sidecar_dir).await?;
let content = content.clone();
let info = info.clone();
let config = config.clone();
let sidecar_root = sidecar_root.to_path_buf();
tokio::task::spawn_blocking(move || {
build_integrity_image_sync(&content, &info, &sidecar_root, block_size, &config)
})
.await
.map_err(|err| Error::Integrity(format!("integrity image build task failed: {err}")))?
}
fn build_integrity_image_sync(
content: &ContentLayout,
info: &TorrentInfo,
sidecar_root: &Path,
block_size: u32,
config: &IntegrityConfig,
) -> Result<IntegrityImageReport> {
let piece_count = info.piece_count();
let mut manifest = IntegrityManifest::new(info.info_hash.to_hex());
let mut report = IntegrityImageReport {
piece_count,
..IntegrityImageReport::default()
};
for index in 0..piece_count {
let piece_data = content.read_piece(index, info.piece_length)?;
if verify_piece(info, index, &piece_data)? {
report.pieces_sha1_ok += 1;
} else {
report
.errors
.push(format!("piece {index} SHA1 mismatch during image build"));
}
record_piece_blocks(&mut manifest, index, &piece_data, block_size, &mut report);
if config.ecc_enabled {
let parity = encode_piece_parity(index, &piece_data, config.ecc_config())?;
let plain = parity_to_bytes(&parity);
let context = format!("parity:{index}");
let sealed = seal_tracked(config, &plain, &context)?;
crate::security::write_bytes_under_root(
sidecar_root,
&IntegrityManifest::parity_relative(index),
&sealed,
)?;
report.parity_count += 1;
report.parity_ok += 1;
}
}
report.block_count = manifest.blocks.len() as u32;
if config.verify_blocks {
report.blocks_crc_ok = report.block_count;
}
let relative = Path::new(".torrentdht").join("manifest.kdl");
let kdl = manifest.to_kdl();
let context = format!("manifest:{}", relative.display());
let sealed = seal_tracked(config, kdl.as_bytes(), &context)?;
crate::security::write_bytes_under_root(sidecar_root, &relative, &sealed)?;
Ok(report)
}
pub async fn validate_integrity_image(
content: &ContentLayout,
info: &TorrentInfo,
sidecar_root: impl AsRef<Path>,
block_size: u32,
config: &IntegrityConfig,
) -> Result<IntegrityImageReport> {
let sidecar_root = sidecar_root.as_ref();
let content = content.clone();
let info = info.clone();
let config = config.clone();
let sidecar_root = sidecar_root.to_path_buf();
tokio::task::spawn_blocking(move || {
validate_integrity_image_sync(&content, &info, &sidecar_root, block_size, &config)
})
.await
.map_err(|err| Error::Integrity(format!("integrity image validate task failed: {err}")))?
}
fn validate_integrity_image_sync(
content: &ContentLayout,
info: &TorrentInfo,
sidecar_root: &Path,
block_size: u32,
config: &IntegrityConfig,
) -> Result<IntegrityImageReport> {
let piece_count = info.piece_count();
let mut report = IntegrityImageReport {
piece_count,
..IntegrityImageReport::default()
};
let relative = Path::new(".torrentdht").join("manifest.kdl");
let stored = crate::security::read_bytes_under_root(sidecar_root, &relative).map_err(|err| {
Error::Integrity(format!(
"missing or unreadable integrity manifest under {}: {err}",
sidecar_root.display()
))
})?;
let context = format!("manifest:{}", relative.display());
let plain = crate::integrity::open_tracked(config, &stored, &context)?;
let manifest = IntegrityManifest::from_kdl(std::str::from_utf8(&plain).map_err(|_| {
Error::Integrity("manifest sidecar is not valid utf-8".into())
})?)?;
if manifest.info_hash_hex != info.info_hash.to_hex() {
report.errors.push(format!(
"manifest info-hash {} does not match torrent {}",
manifest.info_hash_hex,
info.info_hash.to_hex()
));
}
report.block_count = manifest.blocks.len() as u32;
for index in 0..piece_count {
let piece_data = content.read_piece(index, info.piece_length)?;
if verify_piece(info, index, &piece_data)? {
report.pieces_sha1_ok += 1;
} else {
report
.errors
.push(format!("piece {index} SHA1 mismatch"));
}
validate_piece_blocks(
&manifest,
index,
&piece_data,
block_size,
config,
&mut report,
);
if config.ecc_enabled {
validate_piece_parity(sidecar_root, index, &piece_data, config, &mut report)?;
}
}
Ok(report)
}
fn record_piece_blocks(
manifest: &mut IntegrityManifest,
piece: u32,
data: &[u8],
block_size: u32,
report: &mut IntegrityImageReport,
) {
let mut offset = 0u32;
while (offset as usize) < data.len() {
let len = block_size.min((data.len() - offset as usize) as u32);
let chunk = &data[offset as usize..offset as usize + len as usize];
let crc = checksum_block(chunk);
manifest.upsert_block(
BlockKey {
piece,
offset,
},
len,
crc,
);
if verify_block_checksum(chunk, crc) {
report.blocks_crc_ok += 1;
}
offset = offset.saturating_add(block_size);
}
}
fn validate_piece_blocks(
manifest: &IntegrityManifest,
piece: u32,
data: &[u8],
block_size: u32,
config: &IntegrityConfig,
report: &mut IntegrityImageReport,
) {
if !config.verify_blocks {
return;
}
let mut offset = 0u32;
while (offset as usize) < data.len() {
let len = block_size.min((data.len() - offset as usize) as u32);
let chunk = &data[offset as usize..offset as usize + len as usize];
let key = BlockKey { piece, offset };
match manifest.lookup(key) {
Some(record) if verify_block_checksum(chunk, record.crc32c) => {
report.blocks_crc_ok += 1;
}
Some(_) => report.errors.push(format!(
"block crc mismatch piece={piece} offset={offset}"
)),
None => report.errors.push(format!(
"manifest missing block piece={piece} offset={offset}"
)),
}
offset = offset.saturating_add(block_size);
}
}
fn validate_piece_parity(
sidecar_root: &Path,
piece: u32,
expected: &[u8],
config: &IntegrityConfig,
report: &mut IntegrityImageReport,
) -> Result<()> {
report.parity_count += 1;
let relative = IntegrityManifest::parity_relative(piece);
let stored = match crate::security::read_bytes_under_root(sidecar_root, &relative) {
Ok(bytes) => bytes,
Err(_) => {
report
.errors
.push(format!("missing parity sidecar for piece {piece}"));
return Ok(());
}
};
let context = format!("parity:{piece}");
let plain = match open_tracked(config, &stored, &context) {
Ok(data) => data,
Err(err) => {
report
.errors
.push(format!("parity sidecar piece {piece} auth failed: {err}"));
return Ok(());
}
};
let parity = match parity_from_bytes(&plain) {
Ok(p) => p,
Err(err) => {
report
.errors
.push(format!("parity sidecar piece {piece} parse failed: {err}"));
return Ok(());
}
};
let recovered = reconstruct_piece(&parity, config.ecc_config())
.or_else(|_| recover_piece(&parity, config.ecc_config()));
match recovered {
Ok(data) if data == expected => {
report.parity_ok += 1;
}
Ok(_) => report
.errors
.push(format!("parity sidecar piece {piece} data mismatch")),
Err(err) => report
.errors
.push(format!("parity sidecar piece {piece} recovery failed: {err}")),
}
Ok(())
}
pub fn default_sidecar_root(download_dir: impl AsRef<Path>, info: &TorrentInfo) -> PathBuf {
download_dir.as_ref().join(info.info_hash.to_hex())
}
pub fn sidecar_root_for_config(cfg: &crate::config::Config, info: &TorrentInfo) -> PathBuf {
cfg.torrent_layout(&info.info_hash.to_hex()).state_root
}
#[cfg(test)]
mod tests {
use super::*;
use crate::integrity::CipherConfig;
use crate::torrent::TorrentBuilder;
fn test_config() -> IntegrityConfig {
IntegrityConfig {
verify_blocks: true,
ecc_enabled: true,
ecc_data_shards: 4,
ecc_parity_shards: 1,
encrypt_sidecars: true,
cipher: CipherConfig::from_key([7u8; 32]),
}
}
#[tokio::test]
async fn build_and_validate_roundtrip() {
let dir = tempfile::tempdir().expect("tempdir");
std::fs::write(dir.path().join("payload.bin"), b"integrity image test data").expect("write");
let torrent = TorrentBuilder::new(dir.path().join("payload.bin"))
.piece_length(16 * 1024)
.build()
.await
.expect("build");
let layout =
ContentLayout::from_path(dir.path().join("payload.bin"), None).expect("layout");
let sidecar_root = dir.path().join("sidecar-root");
let config = test_config();
let built = build_integrity_image_async(
&layout,
&torrent.info,
&sidecar_root,
16384,
&config,
)
.await
.expect("build image");
assert!(built.is_valid());
let validated = validate_integrity_image(
&layout,
&torrent.info,
&sidecar_root,
16384,
&config,
)
.await
.expect("validate");
assert!(validated.is_valid());
}
}