_ Git - dnssec-prover/blob - src/crypto/hash.rs

   1 //! Simple wrapper around various hash options to provide a single enum which can calculate
   2 //! different hashes.
   3
   4 use bitcoin_hashes::Hash;
   5 use bitcoin_hashes::HashEngine as _;
   6 use bitcoin_hashes::sha1::Hash as Sha1;
   7 use bitcoin_hashes::sha256::Hash as Sha256;
   8 use bitcoin_hashes::sha384::Hash as Sha384;
   9 use bitcoin_hashes::sha512::Hash as Sha512;
  10
  11 pub(crate) enum Hasher {
  12         Sha1(<Sha1 as Hash>::Engine),
  13         Sha256(<Sha256 as Hash>::Engine),
  14         Sha384(<Sha384 as Hash>::Engine),
  15         #[allow(unused)]
  16         Sha512(<Sha512 as Hash>::Engine),
  17 }
  18
  19 pub(crate) enum HashResult {
  20         Sha1(Sha1),
  21         Sha256(Sha256),
  22         Sha384(Sha384),
  23         Sha512(Sha512),
  24 }
  25
  26 impl AsRef<[u8]> for HashResult {
  27         fn as_ref(&self) -> &[u8] {
  28                 match self {
  29                         HashResult::Sha1(hash) => hash.as_ref(),
  30                         HashResult::Sha256(hash) => hash.as_ref(),
  31                         HashResult::Sha384(hash) => hash.as_ref(),
  32                         HashResult::Sha512(hash) => hash.as_ref(),
  33                 }
  34         }
  35 }
  36
  37 impl Hasher {
  38         pub(crate) fn sha1() -> Hasher { Hasher::Sha1(Sha1::engine()) }
  39         pub(crate) fn sha256() -> Hasher { Hasher::Sha256(Sha256::engine()) }
  40         pub(crate) fn sha384() -> Hasher { Hasher::Sha384(Sha384::engine()) }
  41         #[allow(unused)]
  42         pub(crate) fn sha512() -> Hasher { Hasher::Sha512(Sha512::engine()) }
  43
  44         pub(crate) fn update(&mut self, buf: &[u8]) {
  45                 match self {
  46                         Hasher::Sha1(hasher) => hasher.input(buf),
  47                         Hasher::Sha256(hasher) => hasher.input(buf),
  48                         Hasher::Sha384(hasher) => hasher.input(buf),
  49                         Hasher::Sha512(hasher) => hasher.input(buf),
  50                 }
  51         }
  52
  53         pub(crate) fn finish(self) -> HashResult {
  54                 match self {
  55                         Hasher::Sha1(hasher) => HashResult::Sha1(Sha1::from_engine(hasher)),
  56                         Hasher::Sha256(hasher) => HashResult::Sha256(Sha256::from_engine(hasher)),
  57                         Hasher::Sha384(hasher) => HashResult::Sha384(Sha384::from_engine(hasher)),
  58                         Hasher::Sha512(hasher) => HashResult::Sha512(Sha512::from_engine(hasher)),
  59                 }
  60         }
  61 }
  62