picca/src/core/hashers.rs

use ascon_hash::{AsconHash256, ExtendableOutput};
use belt_hash::BeltHash;
use blake2::{Blake2b512, Blake2s256};
use blake3::Hasher as Blake3;
use fsb::{Fsb160, Fsb224, Fsb256, Fsb384, Fsb512};
use gost94::Gost94CryptoPro;
use groestl::{Groestl224, Groestl256, Groestl384, Groestl512};
use jh::{Jh224, Jh256, Jh384, Jh512};
use k12::KangarooTwelve;
use md2::Md2;
use md4::Md4;
use md5::Md5;
use ripemd::{Ripemd128, Ripemd160, Ripemd256, Ripemd320};
use sha1::Sha1;
use sha2::{Digest as _, Sha224, Sha256, Sha384, Sha512};
use sha3::{Sha3_224, Sha3_256, Sha3_384, Sha3_512, Shake128, Shake256};
use shabal::{Shabal192, Shabal224, Shabal256, Shabal384, Shabal512};
use skein::{Skein256, Skein512, Skein1024, consts::U32};
use sm3::Sm3;
use std::io::{self, Write};
use std::{fs::File, io::Read};
use streebog::{Streebog256, Streebog512};
use tiger::Tiger;
use whirlpool::Whirlpool;

pub fn hash_streebog256(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Streebog256::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_streebog512(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Streebog512::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_tiger(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Tiger::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_whirlpool(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Whirlpool::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_sha224(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Sha224::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_sm3(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Sm3::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_sha3_224(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Sha3_224::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_sha3_256(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Sha3_256::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_sha3_384(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Sha3_384::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_sha3_512(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Sha3_512::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_shake128(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Shake128::default();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    _ = hasher.write_fmt(format_args!("{}", stdin.unwrap()));
  }

  let mut result = String::new();
  let mut finalized = hasher.finalize_xof();
  _ = finalized.read_to_string(&mut result);

  return format!("{}", result);
}

pub fn hash_shake256(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Shake256::default();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    _ = hasher.write_fmt(format_args!("{}", stdin.unwrap()));
  }

  let mut result = String::new();
  let mut finalized = hasher.finalize_xof();
  _ = finalized.read_to_string(&mut result);

  return format!("{}", result);
}

pub fn hash_shabal192(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Shabal192::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_shabal224(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Shabal224::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_shabal256(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Shabal256::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_shabal384(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Shabal384::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_shabal512(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Shabal512::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_skein256(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Skein256::<U32>::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_skein512(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Skein512::<U32>::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_skein1024(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Skein1024::<U32>::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_gost94(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Gost94CryptoPro::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_groestl224(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Groestl224::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_groestl256(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Groestl256::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_groestl384(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Groestl384::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_groestl512(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Groestl512::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_jh224(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Jh224::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_jh256(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Jh256::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_jh384(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Jh384::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_jh512(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Jh512::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_k12(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = KangarooTwelve::default();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    _ = hasher.write_fmt(format_args!("{}", stdin.unwrap()));
  }

  let mut result = String::new();
  let mut finalized = hasher.finalize_xof();
  _ = finalized.read_to_string(&mut result);

  return format!("{}", result);
}

pub fn hash_md2(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Md2::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_md4(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Md4::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_ripemd128(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Ripemd128::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_ripemd160(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Ripemd160::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_ripemd256(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Ripemd256::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_ripemd320(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Ripemd320::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_ascon(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = AsconHash256::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_belt(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = BeltHash::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_blake3(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Blake3::default();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    _ = hasher.write_fmt(format_args!("{}", stdin.unwrap()));
  }

  return format!("{}", hasher.finalize().to_hex());
}

pub fn hash_blake2b512(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Blake2b512::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_blake2s256(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Blake2s256::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_fsb160(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Fsb160::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_fsb224(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Fsb224::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_fsb256(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Fsb256::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_fsb384(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Fsb384::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_fsb512(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Fsb512::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_md5(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Md5::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_sha1(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Sha1::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_sha256(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Sha256::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_sha384(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Sha384::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}

pub fn hash_sha512(file: Option<File>, stdin: Option<String>) -> String {
  let mut hasher = Sha512::new();
  if file.is_some() {
    _ = io::copy(&mut file.unwrap(), &mut hasher);
  } else if stdin.is_some() {
    hasher.update(stdin.unwrap());
  }

  return format!("{:x}", hasher.finalize());
}