1 
//! See [`Pbkdf2`].
2 

            

        

            

                3
            

            

                
            

            

                
use digest::Digest;

            

        

            

                4
            

            

                
            

            

                
use generic_array::{typenum::Unsigned, GenericArray};

            

        

            

                5
            

            

                
            

            

                
use hmac::Hmac;

            

        

            

                6
            

            

                
            

            

                
use opaque_ke::{errors::InternalError, slow_hash::SlowHash};

            

        

            

                7
            

            

                
            

            

                
use sha2::{Sha256, Sha512};

            

        

            

                8
            

            

                
            

            

                

            

        

            

                9
            

            

                
            

            

                
use crate::config::{Pbkdf2Hash, Pbkdf2Params};

            

        

            

                10
            

            

                
            

            

                

            

        

            

                11
            

            

                
            

            

                
/// Object implementing [`SlowHash`] for [PBKDF2](pbkdf2_).

            

        

            

                12
            

            

                
            

            

                
#[derive(Default)]

            

        

            

                13
            

            

                
            

            

                
pub(crate) struct Pbkdf2(pub(crate) Pbkdf2Params);

            

        

            

                14
            

            

                
            

            

                

            

        

            

                15
            

            

                
            

            

                
impl<D: opaque_ke::hash::Hash> SlowHash<D> for Pbkdf2 {

            

        

            

                16
            

            

                216
            

            

                
	fn hash(

            

        

            

                17
            

            

                216
            

            

                
		&self,

            

        

            

                18
            

            

                216
            

            

                
		input: GenericArray<u8, <D as Digest>::OutputSize>,

            

        

            

                19
            

            

                216
            

            

                
	) -> Result<Vec<u8>, InternalError> {

            

        

            

                20
            

            

                216
            

            

                
		let mut output = vec![0; <D as Digest>::OutputSize::to_usize()];

            

        

            

                21
            

            

                
            

            

                

            

        

            

                22
            

            

                216
            

            

                
		let pbkdf2 = match self.0.hash {

            

        

            

                23
            

            

                108
            

            

                
			Pbkdf2Hash::Sha256 => pbkdf2_::pbkdf2::<Hmac<Sha256>>,

            

        

            

                24
            

            

                108
            

            

                
			Pbkdf2Hash::Sha512 => pbkdf2_::pbkdf2::<Hmac<Sha512>>,

            

        

            

                25
            

            

                
            

            

                
		};

            

        

            

                26
            

            

                
            

            

                

            

        

            

                27
            

            

                216
            

            

                
		pbkdf2(&input, &[], self.0.rounds.get(), &mut output);

            

        

            

                28
            

            

                216
            

            

                
		Ok(output)

            

        

            

                29
            

            

                216
            

            

                
	}

            

        

            

                30
            

            

                
            

            

                
}