95 lines
2.8 KiB
Rust
95 lines
2.8 KiB
Rust
use crate::model::{Piece, PieceIndex};
|
|
|
|
/// Represents a checksum value together with its algorithm family.
|
|
#[derive(Clone, Debug, Eq, PartialEq)]
|
|
pub enum Checksum {
|
|
/// SHA-1 checksum encoded as lowercase hexadecimal text.
|
|
Sha1(String),
|
|
/// SHA-256 checksum encoded as lowercase hexadecimal text.
|
|
Sha256(String),
|
|
/// MD5 checksum encoded as lowercase hexadecimal text.
|
|
Md5(String),
|
|
/// Adler-32 checksum encoded as lowercase hexadecimal text.
|
|
Adler32(String),
|
|
/// CRC-32 checksum encoded as lowercase hexadecimal text.
|
|
Crc32(String),
|
|
}
|
|
|
|
/// Identifies a supported hashing algorithm.
|
|
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
|
pub enum HashAlgorithm {
|
|
/// SHA-1.
|
|
Sha1,
|
|
/// SHA-256.
|
|
Sha256,
|
|
/// MD5.
|
|
Md5,
|
|
/// Adler-32.
|
|
Adler32,
|
|
/// CRC-32.
|
|
Crc32,
|
|
}
|
|
|
|
/// Stores a finalized digest value.
|
|
#[derive(Clone, Debug, Eq, PartialEq)]
|
|
pub struct HashDigest {
|
|
/// Digest algorithm.
|
|
pub algorithm: HashAlgorithm,
|
|
/// Digest bytes rendered as hexadecimal text.
|
|
pub value_hex: String,
|
|
}
|
|
|
|
/// Reports the result of comparing actual and expected digests.
|
|
#[derive(Clone, Debug, Eq, PartialEq)]
|
|
pub enum VerificationResult {
|
|
/// The calculated digest matched the expected value.
|
|
Match,
|
|
/// The calculated digest differed from the expected value.
|
|
Mismatch {
|
|
/// Digest that was expected by the caller.
|
|
expected: HashDigest,
|
|
/// Digest that was actually calculated from the payload.
|
|
actual: HashDigest,
|
|
},
|
|
/// The requested algorithm is unsupported by the verifier.
|
|
Unsupported(HashAlgorithm),
|
|
}
|
|
|
|
/// Builds algorithm-specific checksum verifiers.
|
|
pub trait HasherFactory {
|
|
/// Concrete verifier type produced by the factory.
|
|
type Hasher: ChecksumVerifier;
|
|
|
|
/// Creates a verifier for the requested algorithm when supported.
|
|
fn create(&self, algorithm: HashAlgorithm) -> Option<Self::Hasher>;
|
|
}
|
|
|
|
/// Incrementally computes a digest for a byte stream.
|
|
pub trait ChecksumVerifier {
|
|
/// Returns the digest algorithm used by this verifier.
|
|
fn algorithm(&self) -> HashAlgorithm;
|
|
/// Feeds another payload chunk into the verifier.
|
|
fn update(&mut self, chunk: &[u8]);
|
|
/// Finalizes and returns the calculated digest.
|
|
fn finish(&mut self) -> HashDigest;
|
|
}
|
|
|
|
/// Verifies piece payloads against expected digests.
|
|
pub trait PieceHashVerifier {
|
|
/// Verifies the supplied piece payload against an expected digest.
|
|
fn verify_piece(
|
|
&self,
|
|
piece: &Piece,
|
|
payload: &[u8],
|
|
expected: &HashDigest,
|
|
) -> VerificationResult;
|
|
|
|
/// Verifies a piece payload when only the piece index is available.
|
|
fn verify_by_index(
|
|
&self,
|
|
index: PieceIndex,
|
|
payload: &[u8],
|
|
expected: &HashDigest,
|
|
) -> VerificationResult;
|
|
}
|