use crate::error::{Error, Result};
use crate::piece::MERKLE_BLOCK_SIZE;
use crate::torrent::{MetaVersion, TorrentInfo, V2FileMeta, V2Meta};
pub const HASH_REQUEST_PAYLOAD_LEN: usize = 32 + 4 * 4;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct HashRequest {
pub pieces_root: [u8; 32],
pub base_layer: u32,
pub index: u32,
pub length: u32,
pub proof_layers: u32,
}
impl HashRequest {
pub fn encode_payload(&self) -> [u8; HASH_REQUEST_PAYLOAD_LEN] {
let mut out = [0u8; HASH_REQUEST_PAYLOAD_LEN];
out[..32].copy_from_slice(&self.pieces_root);
out[32..36].copy_from_slice(&self.base_layer.to_be_bytes());
out[36..40].copy_from_slice(&self.index.to_be_bytes());
out[40..44].copy_from_slice(&self.length.to_be_bytes());
out[44..48].copy_from_slice(&self.proof_layers.to_be_bytes());
out
}
pub fn decode_payload(payload: &[u8]) -> Result<Self> {
if payload.len() != HASH_REQUEST_PAYLOAD_LEN {
return Err(Error::Peer(format!(
"hash request payload length {} != {HASH_REQUEST_PAYLOAD_LEN}",
payload.len()
)));
}
let mut pieces_root = [0u8; 32];
pieces_root.copy_from_slice(&payload[..32]);
Ok(Self {
pieces_root,
base_layer: u32::from_be_bytes(payload[32..36].try_into().expect("base")),
index: u32::from_be_bytes(payload[36..40].try_into().expect("index")),
length: u32::from_be_bytes(payload[40..44].try_into().expect("length")),
proof_layers: u32::from_be_bytes(payload[44..48].try_into().expect("proof")),
})
}
pub fn validate_shape(&self) -> Result<()> {
if self.length < 2 || !self.length.is_power_of_two() {
return Err(Error::Peer(
"hash request length must be >= 2 and a power of two".into(),
));
}
if self.length > 512 {
return Err(Error::Peer(
"hash request length must not exceed 512".into(),
));
}
if !self.index.is_multiple_of(self.length) {
return Err(Error::Peer(
"hash request index must be a multiple of length".into(),
));
}
Ok(())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct HashHashes {
pub request: HashRequest,
pub hashes: Vec<[u8; 32]>,
}
impl HashHashes {
pub fn encode_payload(&self) -> Vec<u8> {
let mut out = Vec::with_capacity(HASH_REQUEST_PAYLOAD_LEN + self.hashes.len() * 32);
out.extend_from_slice(&self.request.encode_payload());
for hash in &self.hashes {
out.extend_from_slice(hash);
}
out
}
pub fn decode_payload(payload: &[u8]) -> Result<Self> {
if payload.len() < HASH_REQUEST_PAYLOAD_LEN {
return Err(Error::Peer("hashes payload too short".into()));
}
if !(payload.len() - HASH_REQUEST_PAYLOAD_LEN).is_multiple_of(32) {
return Err(Error::Peer(
"hashes payload tail must be a multiple of 32".into(),
));
}
let request = HashRequest::decode_payload(&payload[..HASH_REQUEST_PAYLOAD_LEN])?;
let mut hashes = Vec::new();
for chunk in payload[HASH_REQUEST_PAYLOAD_LEN..].chunks_exact(32) {
let mut hash = [0u8; 32];
hash.copy_from_slice(chunk);
hashes.push(hash);
}
Ok(Self { request, hashes })
}
}
pub fn piece_layer_base(piece_length: u32) -> u32 {
let blocks = (piece_length.max(1) as usize) / MERKLE_BLOCK_SIZE;
if blocks <= 1 {
return 0;
}
blocks.trailing_zeros()
}
pub const V2_RESERVED_BIT: u8 = 0x10;
pub fn enable_v2(reserved: &mut [u8; 8]) {
reserved[7] |= V2_RESERVED_BIT;
}
pub fn supports_v2(reserved: &[u8; 8]) -> bool {
reserved[7] & V2_RESERVED_BIT != 0
}
fn find_file<'a>(v2: &'a V2Meta, root: &[u8; 32]) -> Option<&'a V2FileMeta> {
v2.files.iter().find(|f| &f.pieces_root == root)
}
pub fn serve_piece_layer_hashes(
info: &TorrentInfo,
request: &HashRequest,
) -> Result<Option<HashHashes>> {
request.validate_shape()?;
if info.meta_version == MetaVersion::V1 {
return Ok(None);
}
let Some(v2) = info.v2.as_ref() else {
return Ok(None);
};
let expected_base = piece_layer_base(info.piece_length);
if request.base_layer != expected_base {
return Ok(None);
}
if request.proof_layers != 0 {
return Ok(None);
}
let Some(file) = find_file(v2, &request.pieces_root) else {
return Ok(None);
};
let start = request.index as usize;
let end = start.saturating_add(request.length as usize);
if end > file.piece_hashes.len() {
return Ok(None);
}
let hashes = file.piece_hashes[start..end].to_vec();
Ok(Some(HashHashes {
request: request.clone(),
hashes,
}))
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum HashRequestAnswer {
Hashes(HashHashes),
Reject(HashRequest),
}
impl HashRequestAnswer {
pub fn resolve(info: &TorrentInfo, request: HashRequest) -> Self {
match serve_piece_layer_hashes(info, &request) {
Ok(Some(hashes)) => Self::Hashes(hashes),
Ok(None) => Self::Reject(request),
Err(err) => {
tracing::debug!(%err, "invalid hash request");
Self::Reject(request)
}
}
}
pub fn upload_bytes(&self) -> u64 {
match self {
Self::Hashes(hashes) => hashes.encode_payload().len() as u64,
Self::Reject(_) => HASH_REQUEST_PAYLOAD_LEN as u64,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::torrent::{InfoHash, V2FileMeta};
use std::path::PathBuf;
#[test]
fn hash_request_roundtrip() {
let req = HashRequest {
pieces_root: [0xAB; 32],
base_layer: 0,
index: 0,
length: 2,
proof_layers: 0,
};
let decoded = HashRequest::decode_payload(&req.encode_payload()).expect("decode");
assert_eq!(decoded, req);
}
#[test]
fn serves_piece_layer_slice() {
let hashes = vec![[1u8; 32], [2u8; 32], [3u8; 32], [4u8; 32]];
let root = crate::piece::merkle::pieces_root_from_layer(&hashes);
let info = TorrentInfo {
info_hash: InfoHash::from_bytes([0; 20]),
info_hash_v2: None,
name: "x".into(),
piece_length: MERKLE_BLOCK_SIZE as u32,
pieces: vec![[0; 20]; 4],
files: vec![(PathBuf::from("x"), 4 * MERKLE_BLOCK_SIZE as u64)],
total_len: 4 * MERKLE_BLOCK_SIZE as u64,
private: false,
meta_version: MetaVersion::Hybrid,
v2: Some(V2Meta {
files: vec![V2FileMeta {
path: PathBuf::from("x"),
length: 4 * MERKLE_BLOCK_SIZE as u64,
pieces_root: root,
piece_hashes: hashes.clone(),
}],
piece_hashes: hashes.clone(),
pieces_root: root,
}),
};
let req = HashRequest {
pieces_root: root,
base_layer: 0,
index: 0,
length: 2,
proof_layers: 0,
};
let served = serve_piece_layer_hashes(&info, &req)
.expect("serve")
.expect("some");
assert_eq!(served.hashes, hashes[..2]);
let answer = HashRequestAnswer::resolve(&info, req.clone());
assert!(matches!(answer, HashRequestAnswer::Hashes(_)));
assert_eq!(answer.upload_bytes(), (48 + 2 * 32) as u64);
let bad = HashRequest {
pieces_root: [0; 32],
base_layer: 0,
index: 0,
length: 2,
proof_layers: 0,
};
assert!(matches!(
HashRequestAnswer::resolve(&info, bad),
HashRequestAnswer::Reject(_)
));
}
}