87 lines
2.2 KiB
Rust
87 lines
2.2 KiB
Rust
use anyhow::Result;
|
|
use std::io;
|
|
|
|
use lazy_static::lazy_static;
|
|
|
|
extern crate enum_map;
|
|
use enum_map::enum_map;
|
|
use enum_map::{Enum, EnumMap};
|
|
|
|
pub mod none;
|
|
pub mod program;
|
|
pub mod sha2;
|
|
|
|
use crate::digest_engine::none::DigestEngineNone;
|
|
use crate::digest_engine::program::DigestEngineProgram;
|
|
use crate::digest_engine::sha2::DigestEngineSha256;
|
|
|
|
use strum::IntoEnumIterator;
|
|
|
|
#[derive(Debug, Eq, PartialEq, Clone, strum::EnumIter, strum::Display, strum::EnumString, Enum)]
|
|
#[strum(ascii_case_insensitive)]
|
|
pub enum DigestType {
|
|
Sha256,
|
|
Md5,
|
|
None,
|
|
}
|
|
|
|
pub trait DigestEngine {
|
|
fn is_supported(&self) -> bool {
|
|
true
|
|
}
|
|
fn create(&self) -> Result<Box<dyn Write>>;
|
|
fn finalize(&mut self) -> io::Result<String>;
|
|
|
|
// Update the digest with new data
|
|
fn update(&mut self, data: &[u8]);
|
|
}
|
|
|
|
use std::io::Write;
|
|
|
|
// Writer that implements Write for the program digest engine
|
|
struct ProgramWriter {
|
|
stdin: std::process::ChildStdin,
|
|
}
|
|
|
|
impl Write for ProgramWriter {
|
|
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
|
|
self.stdin.write(buf)
|
|
}
|
|
|
|
fn flush(&mut self) -> std::io::Result<()> {
|
|
self.stdin.flush()
|
|
}
|
|
}
|
|
|
|
lazy_static! {
|
|
pub static ref DIGEST_PROGRAMS: EnumMap<DigestType, Option<DigestEngineProgram>> = enum_map! {
|
|
DigestType::Sha256 => None,
|
|
DigestType::Md5 => {
|
|
let program = DigestEngineProgram::new("bzip2", vec![]);
|
|
if program.supported { Some(program) } else { None }
|
|
}
|
|
DigestType::None => None
|
|
};
|
|
}
|
|
|
|
|
|
pub fn get_digest_engine(digest_type: DigestType) -> Box<dyn DigestEngine> {
|
|
match digest_type {
|
|
DigestType::Sha256 => Box::new(DigestEngineSha256::new()),
|
|
DigestType::Md5 => Box::new(DigestEngineProgram::new("md5sum", vec![])),
|
|
DigestType::None => Box::new(DigestEngineNone::new()),
|
|
}
|
|
}
|
|
|
|
pub fn default_digest_type() -> DigestType {
|
|
let mut default = DigestType::None;
|
|
for digest_type in DigestType::iter() {
|
|
let digest_engine = get_digest_engine(digest_type.clone());
|
|
if digest_engine.is_supported() {
|
|
default = digest_type;
|
|
break;
|
|
}
|
|
}
|
|
default
|
|
}
|