http-signature-normalization/http-signature-normalization-actix/src/digest/sha3.rs

use sha3::{
    Digest as _, Keccak224, Keccak256, Keccak256Full, Keccak384, Keccak512, Sha3_224, Sha3_256,
    Sha3_384, Sha3_512,
};

use super::{DigestCreate, DigestPart, DigestVerify};

impl DigestCreate for Sha3_224 {
    const NAME: &'static str = "sha3-224";

    fn compute(&mut self, input: &[u8]) -> String {
        self.input(input);
        base64::encode(&self.result_reset())
    }
}

impl DigestVerify for Sha3_224 {
    fn verify(&mut self, parts: &[DigestPart], bytes: &[u8]) -> bool {
        if let Some(part) = parts
            .iter()
            .find(|p| p.algorithm == <Self as DigestCreate>::NAME)
        {
            self.input(bytes);
            let digest = base64::encode(&self.result_reset());

            return part.digest == digest;
        }

        false
    }
}

impl DigestCreate for Sha3_256 {
    const NAME: &'static str = "sha3-256";

    fn compute(&mut self, input: &[u8]) -> String {
        self.input(input);
        base64::encode(&self.result_reset())
    }
}

impl DigestVerify for Sha3_256 {
    fn verify(&mut self, parts: &[DigestPart], bytes: &[u8]) -> bool {
        if let Some(part) = parts
            .iter()
            .find(|p| p.algorithm == <Self as DigestCreate>::NAME)
        {
            self.input(bytes);
            let digest = base64::encode(&self.result_reset());

            return part.digest == digest;
        }

        false
    }
}

impl DigestCreate for Sha3_384 {
    const NAME: &'static str = "sha3-384";

    fn compute(&mut self, input: &[u8]) -> String {
        self.input(input);
        base64::encode(&self.result_reset())
    }
}

impl DigestVerify for Sha3_384 {
    fn verify(&mut self, parts: &[DigestPart], bytes: &[u8]) -> bool {
        if let Some(part) = parts
            .iter()
            .find(|p| p.algorithm == <Self as DigestCreate>::NAME)
        {
            self.input(bytes);
            let digest = base64::encode(&self.result_reset());

            return part.digest == digest;
        }

        false
    }
}

impl DigestCreate for Sha3_512 {
    const NAME: &'static str = "sha3-512";

    fn compute(&mut self, input: &[u8]) -> String {
        self.input(input);
        base64::encode(&self.result_reset())
    }
}

impl DigestVerify for Sha3_512 {
    fn verify(&mut self, parts: &[DigestPart], bytes: &[u8]) -> bool {
        if let Some(part) = parts
            .iter()
            .find(|p| p.algorithm == <Self as DigestCreate>::NAME)
        {
            self.input(bytes);
            let digest = base64::encode(&self.result_reset());

            return part.digest == digest;
        }

        false
    }
}

impl DigestCreate for Keccak224 {
    const NAME: &'static str = "keccak-224";

    fn compute(&mut self, input: &[u8]) -> String {
        self.input(input);
        base64::encode(&self.result_reset())
    }
}

impl DigestVerify for Keccak224 {
    fn verify(&mut self, parts: &[DigestPart], bytes: &[u8]) -> bool {
        if let Some(part) = parts
            .iter()
            .find(|p| p.algorithm == <Self as DigestCreate>::NAME)
        {
            self.input(bytes);
            let digest = base64::encode(&self.result_reset());

            return part.digest == digest;
        }

        false
    }
}

impl DigestCreate for Keccak256 {
    const NAME: &'static str = "keccak-256";

    fn compute(&mut self, input: &[u8]) -> String {
        self.input(input);
        base64::encode(&self.result_reset())
    }
}

impl DigestVerify for Keccak256 {
    fn verify(&mut self, parts: &[DigestPart], bytes: &[u8]) -> bool {
        if let Some(part) = parts
            .iter()
            .find(|p| p.algorithm == <Self as DigestCreate>::NAME)
        {
            self.input(bytes);
            let digest = base64::encode(&self.result_reset());

            return part.digest == digest;
        }

        false
    }
}

impl DigestCreate for Keccak256Full {
    const NAME: &'static str = "keccak-256-full";

    fn compute(&mut self, input: &[u8]) -> String {
        self.input(input);
        base64::encode(&self.result_reset())
    }
}

impl DigestVerify for Keccak256Full {
    fn verify(&mut self, parts: &[DigestPart], bytes: &[u8]) -> bool {
        if let Some(part) = parts
            .iter()
            .find(|p| p.algorithm == <Self as DigestCreate>::NAME)
        {
            self.input(bytes);
            let digest = base64::encode(&self.result_reset());

            return part.digest == digest;
        }

        false
    }
}

impl DigestCreate for Keccak384 {
    const NAME: &'static str = "keccak-384";

    fn compute(&mut self, input: &[u8]) -> String {
        self.input(input);
        base64::encode(&self.result_reset())
    }
}

impl DigestVerify for Keccak384 {
    fn verify(&mut self, parts: &[DigestPart], bytes: &[u8]) -> bool {
        if let Some(part) = parts
            .iter()
            .find(|p| p.algorithm == <Self as DigestCreate>::NAME)
        {
            self.input(bytes);
            let digest = base64::encode(&self.result_reset());

            return part.digest == digest;
        }

        false
    }
}

impl DigestCreate for Keccak512 {
    const NAME: &'static str = "keccak-512";

    fn compute(&mut self, input: &[u8]) -> String {
        self.input(input);
        base64::encode(&self.result_reset())
    }
}

impl DigestVerify for Keccak512 {
    fn verify(&mut self, parts: &[DigestPart], bytes: &[u8]) -> bool {
        if let Some(part) = parts
            .iter()
            .find(|p| p.algorithm == <Self as DigestCreate>::NAME)
        {
            self.input(bytes);
            let digest = base64::encode(&self.result_reset());

            return part.digest == digest;
        }

        false
    }
}