torrentdht 0.1.1

DHT discovery with mTLS handshake handoff; optional BitTorrent when the host opts in
Documentation
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;

/// Result of building or validating an ECC integrity image.
#[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
    }
}

/// Write manifest + RS parity sidecars for all pieces read from `content`.
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)
}

/// Validate content against torrent piece hashes and on-disk integrity sidecars.
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())
}

/// Sidecar root from host config layout (`state_dir` when set, else content hash dir).
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());
    }
}