use std::fmt;
use crate::bittorrent::message::types::BtMessage;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PeerMessageCapabilityError {
FastExtensionNotNegotiated,
ExtendedMessagingNotNegotiated,
}
impl fmt::Display for PeerMessageCapabilityError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::FastExtensionNotNegotiated => {
f.write_str("peer sent a Fast Extension message without negotiating Fast Extension")
}
Self::ExtendedMessagingNotNegotiated => {
f.write_str("peer sent an extended message without negotiating extended messaging")
}
}
}
}
impl std::error::Error for PeerMessageCapabilityError {}
pub fn validate_message_capabilities(
message: &BtMessage,
supports_fast_extension: bool,
supports_extended_messaging: bool,
) -> Result<(), PeerMessageCapabilityError> {
if matches!(
message,
BtMessage::AllowedFast { .. }
| BtMessage::Reject { .. }
| BtMessage::HaveAll
| BtMessage::HaveNone
) && !supports_fast_extension
{
return Err(PeerMessageCapabilityError::FastExtensionNotNegotiated);
}
if matches!(message, BtMessage::Extended { .. }) && !supports_extended_messaging {
return Err(PeerMessageCapabilityError::ExtendedMessagingNotNegotiated);
}
Ok(())
}
pub const MAX_BLOCK_LENGTH: u32 = 64 * 1024;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum BtMessageValidationError {
IndexOutOfRange { index: u32, num_pieces: u32 },
BlockOutOfRange {
index: u32,
begin: u32,
length: u32,
piece_length: u32,
},
BitfieldLengthMismatch {
bitfield_len: usize,
expected_pieces: u32,
},
InfoHashMismatch,
InvalidBlockLength { length: u32, max_block_length: u32 },
}
impl fmt::Display for BtMessageValidationError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::IndexOutOfRange { index, num_pieces } => {
write!(
f,
"piece index {} out of range (num_pieces={})",
index, num_pieces
)
}
Self::BlockOutOfRange {
index,
begin,
length,
piece_length,
} => {
write!(
f,
"block out of range: index={}, begin={}, length={}, piece_length={}",
index, begin, length, piece_length
)
}
Self::BitfieldLengthMismatch {
bitfield_len,
expected_pieces,
} => {
let expected_bytes = (*expected_pieces as usize).div_ceil(8);
write!(
f,
"bitfield length {} does not match expected {} bytes ({} pieces)",
bitfield_len, expected_bytes, expected_pieces
)
}
Self::InfoHashMismatch => write!(f, "info-hash mismatch"),
Self::InvalidBlockLength {
length,
max_block_length,
} => {
write!(
f,
"block length {} exceeds maximum {}",
length, max_block_length
)
}
}
}
}
impl std::error::Error for BtMessageValidationError {}
#[derive(Debug, Clone)]
pub struct BtMessageValidator {
pub num_pieces: u32,
pub piece_length: u32,
pub max_block_length: u32,
pub expected_info_hash: Option<[u8; 20]>,
pub metadata_get_mode: bool,
}
impl BtMessageValidator {
pub fn new(num_pieces: u32, piece_length: u32) -> Self {
Self {
num_pieces,
piece_length,
max_block_length: MAX_BLOCK_LENGTH,
expected_info_hash: None,
metadata_get_mode: false,
}
}
pub fn with_expected_info_hash(mut self, hash: [u8; 20]) -> Self {
self.expected_info_hash = Some(hash);
self
}
pub fn with_metadata_get_mode(mut self, mode: bool) -> Self {
self.metadata_get_mode = mode;
self
}
pub fn validate(&self, msg: &BtMessage) -> Result<(), BtMessageValidationError> {
match msg {
BtMessage::Have { piece_index } => self.validate_index(*piece_index),
BtMessage::Bitfield { data } => self.validate_bitfield(data),
BtMessage::Request { request } => {
self.validate_range(request.index, request.begin, request.length)
}
BtMessage::Piece { index, begin, data } => {
self.validate_piece(*index, *begin, data.len())
}
BtMessage::Cancel { request } => {
self.validate_range(request.index, request.begin, request.length)
}
BtMessage::Reject {
index,
offset,
length,
} => self.validate_range(*index, *offset, *length),
BtMessage::AllowedFast { index } => self.validate_index(*index),
BtMessage::Suggest { index } => self.validate_index(*index),
BtMessage::KeepAlive
| BtMessage::Choke
| BtMessage::Unchoke
| BtMessage::Interested
| BtMessage::NotInterested
| BtMessage::HaveAll
| BtMessage::HaveNone
| BtMessage::Port { .. }
| BtMessage::Extended { .. } => Ok(()),
}
}
pub fn validate_index(&self, index: u32) -> Result<(), BtMessageValidationError> {
if self.metadata_get_mode {
return Ok(());
}
if index >= self.num_pieces {
return Err(BtMessageValidationError::IndexOutOfRange {
index,
num_pieces: self.num_pieces,
});
}
Ok(())
}
pub fn validate_range(
&self,
index: u32,
begin: u32,
length: u32,
) -> Result<(), BtMessageValidationError> {
if self.metadata_get_mode {
return Ok(());
}
self.validate_index(index)?;
if length == 0 {
return Err(BtMessageValidationError::BlockOutOfRange {
index,
begin,
length: 0,
piece_length: self.piece_length,
});
}
let end = begin.checked_add(length);
match end {
Some(e) if e <= self.piece_length => {}
_ => {
return Err(BtMessageValidationError::BlockOutOfRange {
index,
begin,
length,
piece_length: self.piece_length,
});
}
}
if length > self.max_block_length {
return Err(BtMessageValidationError::InvalidBlockLength {
length,
max_block_length: self.max_block_length,
});
}
Ok(())
}
pub fn validate_piece(
&self,
index: u32,
begin: u32,
data_len: usize,
) -> Result<(), BtMessageValidationError> {
if self.metadata_get_mode {
return Ok(());
}
self.validate_index(index)?;
let length = u32::try_from(data_len).unwrap_or(u32::MAX);
if length == 0 {
return Err(BtMessageValidationError::BlockOutOfRange {
index,
begin,
length: 0,
piece_length: self.piece_length,
});
}
let end = begin.checked_add(length);
match end {
Some(e) if e <= self.piece_length => {}
_ => {
return Err(BtMessageValidationError::BlockOutOfRange {
index,
begin,
length,
piece_length: self.piece_length,
});
}
}
if length > self.max_block_length {
return Err(BtMessageValidationError::InvalidBlockLength {
length,
max_block_length: self.max_block_length,
});
}
Ok(())
}
pub fn validate_bitfield(&self, data: &[u8]) -> Result<(), BtMessageValidationError> {
if self.metadata_get_mode {
return Ok(());
}
let expected_bytes = (self.num_pieces as usize).div_ceil(8);
if data.len() != expected_bytes {
return Err(BtMessageValidationError::BitfieldLengthMismatch {
bitfield_len: data.len(),
expected_pieces: self.num_pieces,
});
}
let remainder = (self.num_pieces as usize) % 8;
if remainder != 0
&& let Some(&last_byte) = data.last()
{
let mask: u8 = (1 << (8 - remainder)) - 1;
if last_byte & mask != 0 {
return Err(BtMessageValidationError::BitfieldLengthMismatch {
bitfield_len: data.len(),
expected_pieces: self.num_pieces,
});
}
}
Ok(())
}
pub fn validate_handshake(
&self,
received_hash: &[u8; 20],
) -> Result<(), BtMessageValidationError> {
if let Some(expected) = self.expected_info_hash
&& received_hash != &expected
{
return Err(BtMessageValidationError::InfoHashMismatch);
}
Ok(())
}
}
#[cfg(test)]
#[path = "message_validation_tests.rs"]
mod tests;