Botan::TPM2::HashFunction Class Reference

#include <tpm2_hash.h>

Inheritance diagram for Botan::TPM2::HashFunction:

Public Member Functions
void	clear () override
HashFunction *	clone () const
std::unique_ptr< Botan::HashFunction >	copy_state () const override
template<concepts::resizable_byte_buffer T = secure_vector<uint8_t>>
T	final ()
void	final (std::span< uint8_t > out)
template<concepts::resizable_byte_buffer T>
void	final (T &out)
void	final (uint8_t out[])
std::vector< uint8_t >	final_stdvec ()
std::pair< unique_esys_ptr< TPM2B_DIGEST >, unique_esys_ptr< TPMT_TK_HASHCHECK > >	final_with_ticket ()
virtual size_t	hash_block_size () const
	HashFunction (std::shared_ptr< Context > ctx, std::string_view algorithm, TPMI_RH_HIERARCHY hierarchy=ESYS_TR_RH_NULL, SessionBundle sessions={})
std::string	name () const override
std::unique_ptr< Botan::HashFunction >	new_object () const override
size_t	output_length () const override
template<concepts::resizable_byte_buffer T = secure_vector<uint8_t>>
T	process (const uint8_t in[], size_t length)
template<concepts::resizable_byte_buffer T = secure_vector<uint8_t>>
T	process (std::span< const uint8_t > in)
template<concepts::resizable_byte_buffer T = secure_vector<uint8_t>>
T	process (std::string_view in)
virtual std::string	provider () const
TPMI_ALG_HASH	type () const
void	update (const uint8_t in[], size_t length)
void	update (std::span< const uint8_t > in)
void	update (std::string_view str)
void	update (uint8_t in)
void	update_be (uint16_t val)
void	update_be (uint32_t val)
void	update_be (uint64_t val)
void	update_le (uint16_t val)
void	update_le (uint32_t val)
void	update_le (uint64_t val)

Static Public Member Functions
static std::unique_ptr< HashFunction >	create (std::string_view algo_spec, std::string_view provider="")
static std::unique_ptr< HashFunction >	create_or_throw (std::string_view algo_spec, std::string_view provider="")
static std::vector< std::string >	providers (std::string_view algo_spec)

Detailed Description

Exposes the hashing capability of a TPM 2.0 device as a Botan::HashFunction. Typically this is used to obtain a TPMT_TK_HASHCHECK ticket after the hash operation has been completed. Otherwise, the HashFunction behaves like any other Botan::HashFunction.

Definition at line 29 of file tpm2_hash.h.

Constructor & Destructor Documentation

HashFunction()

Botan::TPM2::HashFunction::HashFunction	(	std::shared_ptr< Context >	ctx,
		std::string_view	algorithm,
		TPMI_RH_HIERARCHY	hierarchy = ESYS_TR_RH_NULL,
		SessionBundle	sessions = {} )

Definition at line 19 of file tpm2_hash.cpp.

                                                   :
      m_hash_type(get_tpm2_hash_type(algorithm)),
      m_hierarchy(hierarchy),
      m_handle(std::move(ctx)),
      m_sessions(std::move(sessions)) {
   // When creating a new hash object we assume that the call will use it to
   // hash data and therefore setup the hash object immediately.
   lazy_setup();
}

References Botan::TPM2::get_tpm2_hash_type().

Member Function Documentation

clear()

void Botan::TPM2::HashFunction::clear ( )

overridevirtual

Reset the state.

Implements Botan::HashFunction.

Definition at line 55 of file tpm2_hash.cpp.

                         {
   m_handle._reset();
}

clone()

HashFunction * Botan::HashFunction::clone ( ) const

inlineinherited

Returns

new object representing the same algorithm as *this

Definition at line 85 of file hash.h.

{ return this->new_object().release(); }

References new_object().

copy_state()

std::unique_ptr< Botan::HashFunction > Botan::TPM2::HashFunction::copy_state ( ) const

overridevirtual

Exceptions

Not_Implemented

as copying state is not supported within the TPM

Implements Botan::HashFunction.

Definition at line 59 of file tpm2_hash.cpp.

                                                                {
   throw Not_Implemented("TPM 2.0 hash functions do not support copy_state");
}

create()

std::unique_ptr< HashFunction > Botan::HashFunction::create ( std::string_view algo_spec, std::string_view provider = "" )

staticinherited

Create an instance based on a name, or return null if the algo/provider combination cannot be found. If provider is empty then best available is chosen.

Definition at line 107 of file hash.cpp.

                                                                                                  {
#if defined(BOTAN_HAS_COMMONCRYPTO)
   if(provider.empty() || provider == "commoncrypto") {
      if(auto hash = make_commoncrypto_hash(algo_spec))
         return hash;
 
      if(!provider.empty())
         return nullptr;
   }
#endif
 
   if(provider.empty() == false && provider != "base") {
      return nullptr;  // unknown provider
   }
 
#if defined(BOTAN_HAS_SHA1)
   if(algo_spec == "SHA-1") {
      return std::make_unique<SHA_1>();
   }
#endif
 
#if defined(BOTAN_HAS_SHA2_32)
   if(algo_spec == "SHA-224") {
      return std::make_unique<SHA_224>();
   }
 
   if(algo_spec == "SHA-256") {
      return std::make_unique<SHA_256>();
   }
#endif
 
#if defined(BOTAN_HAS_SHA2_64)
   if(algo_spec == "SHA-384") {
      return std::make_unique<SHA_384>();
   }
 
   if(algo_spec == "SHA-512") {
      return std::make_unique<SHA_512>();
   }
 
   if(algo_spec == "SHA-512-256") {
      return std::make_unique<SHA_512_256>();
   }
#endif
 
#if defined(BOTAN_HAS_RIPEMD_160)
   if(algo_spec == "RIPEMD-160") {
      return std::make_unique<RIPEMD_160>();
   }
#endif
 
#if defined(BOTAN_HAS_WHIRLPOOL)
   if(algo_spec == "Whirlpool") {
      return std::make_unique<Whirlpool>();
   }
#endif
 
#if defined(BOTAN_HAS_MD5)
   if(algo_spec == "MD5") {
      return std::make_unique<MD5>();
   }
#endif
 
#if defined(BOTAN_HAS_MD4)
   if(algo_spec == "MD4") {
      return std::make_unique<MD4>();
   }
#endif
 
#if defined(BOTAN_HAS_GOST_34_11)
   if(algo_spec == "GOST-R-34.11-94" || algo_spec == "GOST-34.11") {
      return std::make_unique<GOST_34_11>();
   }
#endif
 
#if defined(BOTAN_HAS_ADLER32)
   if(algo_spec == "Adler32") {
      return std::make_unique<Adler32>();
   }
#endif
 
#if defined(BOTAN_HAS_CRC24)
   if(algo_spec == "CRC24") {
      return std::make_unique<CRC24>();
   }
#endif
 
#if defined(BOTAN_HAS_CRC32)
   if(algo_spec == "CRC32") {
      return std::make_unique<CRC32>();
   }
#endif
 
#if defined(BOTAN_HAS_STREEBOG)
   if(algo_spec == "Streebog-256") {
      return std::make_unique<Streebog>(256);
   }
   if(algo_spec == "Streebog-512") {
      return std::make_unique<Streebog>(512);
   }
#endif
 
#if defined(BOTAN_HAS_SM3)
   if(algo_spec == "SM3") {
      return std::make_unique<SM3>();
   }
#endif
 
   const SCAN_Name req(algo_spec);
 
#if defined(BOTAN_HAS_SKEIN_512)
   if(req.algo_name() == "Skein-512") {
      return std::make_unique<Skein_512>(req.arg_as_integer(0, 512), req.arg(1, ""));
   }
#endif
 
#if defined(BOTAN_HAS_BLAKE2B)
   if(req.algo_name() == "Blake2b" || req.algo_name() == "BLAKE2b") {
      return std::make_unique<BLAKE2b>(req.arg_as_integer(0, 512));
   }
#endif
 
#if defined(BOTAN_HAS_BLAKE2S)
   if(req.algo_name() == "Blake2s" || req.algo_name() == "BLAKE2s") {
      return std::make_unique<BLAKE2s>(req.arg_as_integer(0, 256));
   }
#endif
 
#if defined(BOTAN_HAS_KECCAK)
   if(req.algo_name() == "Keccak-1600") {
      return std::make_unique<Keccak_1600>(req.arg_as_integer(0, 512));
   }
#endif
 
#if defined(BOTAN_HAS_SHA3)
   if(req.algo_name() == "SHA-3") {
      return std::make_unique<SHA_3>(req.arg_as_integer(0, 512));
   }
#endif
 
#if defined(BOTAN_HAS_SHAKE)
   if(req.algo_name() == "SHAKE-128" && req.arg_count() == 1) {
      return std::make_unique<SHAKE_128>(req.arg_as_integer(0));
   }
   if(req.algo_name() == "SHAKE-256" && req.arg_count() == 1) {
      return std::make_unique<SHAKE_256>(req.arg_as_integer(0));
   }
#endif
 
#if defined(BOTAN_HAS_PARALLEL_HASH)
   if(req.algo_name() == "Parallel") {
      std::vector<std::unique_ptr<HashFunction>> hashes;
 
      for(size_t i = 0; i != req.arg_count(); ++i) {
         auto h = HashFunction::create(req.arg(i));
         if(!h) {
            return nullptr;
         }
         hashes.push_back(std::move(h));
      }
 
      return std::make_unique<Parallel>(hashes);
   }
#endif
 
#if defined(BOTAN_HAS_TRUNCATED_HASH)
   if(req.algo_name() == "Truncated" && req.arg_count() == 2) {
      auto hash = HashFunction::create(req.arg(0));
      if(!hash) {
         return nullptr;
      }
 
      return std::make_unique<Truncated_Hash>(std::move(hash), req.arg_as_integer(1));
   }
#endif
 
#if defined(BOTAN_HAS_COMB4P)
   if(req.algo_name() == "Comb4P" && req.arg_count() == 2) {
      auto h1 = HashFunction::create(req.arg(0));
      auto h2 = HashFunction::create(req.arg(1));
 
      if(h1 && h2) {
         return std::make_unique<Comb4P>(std::move(h1), std::move(h2));
      }
   }
#endif
 
   return nullptr;
}

References Botan::SCAN_Name::algo_name(), Botan::SCAN_Name::arg(), Botan::SCAN_Name::arg_as_integer(), Botan::SCAN_Name::arg_count(), create(), Botan::make_commoncrypto_hash(), and provider().

Referenced by botan_hash_init(), Botan::BlockCipher::create(), Botan::EME::create(), create(), Botan::KDF::create(), Botan::MessageAuthenticationCode::create(), Botan::PasswordHashFamily::create(), Botan::PBKDF::create(), Botan::SignaturePaddingScheme::create(), create_or_throw(), Botan::Certificate_Store_In_Memory::find_cert_by_pubkey_sha1(), and Botan::Certificate_Store_In_Memory::find_cert_by_raw_subject_dn_sha256().

create_or_throw()

std::unique_ptr< HashFunction > Botan::HashFunction::create_or_throw ( std::string_view algo_spec, std::string_view provider = "" )

staticinherited

Create an instance based on a name If provider is empty then best available is chosen.

Parameters

algo_spec	algorithm name
provider	provider implementation to use Throws Lookup_Error if not found.

Definition at line 298 of file hash.cpp.

                                                                                                      {
   if(auto hash = HashFunction::create(algo, provider)) {
      return hash;
   }
   throw Lookup_Error("Hash", algo, provider);
}

References create(), and provider().

Referenced by botan_pubkey_fingerprint(), botan_pubkey_sm2_compute_za(), Botan::OCSP::CertID::CertID(), Botan::create_hex_fingerprint(), Botan::Sodium::crypto_hash_sha256(), Botan::Sodium::crypto_hash_sha512(), Botan::Bcrypt_PBKDF::derive_key(), Botan::ed25519_gen_keypair(), Botan::ed25519_sign(), Botan::ed25519_verify(), Botan::expand_message_xmd(), Botan::TLS::Handshake_Hash::final(), Botan::generate_dsa_primes(), Botan::LMOTS_Params::hash(), Botan::LMS_Params::hash(), Botan::Classic_McEliece_Parameters::hash_func(), Botan::OCSP::CertID::is_id_for(), Botan::TLS::make_hello_random(), Botan::Roughtime::nonce_from_blind(), Botan::PKCS1v15_Raw_SignaturePaddingScheme::PKCS1v15_Raw_SignaturePaddingScheme(), Botan::TLS::Transcript_Hash_State::set_algorithm(), Botan::RTSS_Share::split(), Botan::srp6_client_agree(), Botan::srp6_generate_verifier(), Botan::SRP6_Server_Session::step1(), Botan::SRP6_Server_Session::step2(), Botan::Cert_Extension::Subject_Key_ID::Subject_Key_ID(), and Botan::PK_Ops::Verification_with_Hash::Verification_with_Hash().

final() [1/4]

template<concepts::resizable_byte_buffer T = secure_vector<uint8_t>>

T Botan::Buffered_Computation::final ( )

inlineinherited

Complete the computation and retrieve the final result as a container of your choice.

Returns

a contiguous container holding the result

Definition at line 77 of file buf_comp.h.

                {
         T output(output_length());
         final_result(output);
         return output;
      }

References output_length().

final() [2/4]

void Botan::Buffered_Computation::final ( std::span< uint8_t > out )

inherited

Definition at line 54 of file buf_comp.cpp.

                                                     {
   BOTAN_ARG_CHECK(out.size() >= output_length(), "provided output buffer has insufficient capacity");
   final_result(out);
}

References BOTAN_ARG_CHECK, and output_length().

final() [3/4]

template<concepts::resizable_byte_buffer T>

void Botan::Buffered_Computation::final ( T & out )

inlineinherited

Definition at line 88 of file buf_comp.h.

                         {
         out.resize(output_length());
         final_result(out);
      }

References output_length().

final() [4/4]

void Botan::Buffered_Computation::final ( uint8_t out[] )

inlineinherited

Complete the computation and retrieve the final result.

Parameters

out	The byte array to be filled with the result. Must be of length output_length()

Definition at line 69 of file buf_comp.h.

{ final_result({out, output_length()}); }

References output_length().

Referenced by final_stdvec(), Botan::PseudorandomKeyGeneration::gen(), Botan::TPM2::Verification_Operation::is_valid_signature(), Botan::mgf1_mask(), Botan::KMAC::operator=(), Botan::pbkdf2(), Botan::Sphincs_Hash_Functions_Sha2::PRF_msg(), process(), process(), process(), Botan::TPM2::Signature_Operation::sign(), and Botan::sm2_compute_za().

final_stdvec()

std::vector< uint8_t > Botan::Buffered_Computation::final_stdvec ( )

inlineinherited

Definition at line 83 of file buf_comp.h.

{ return final<std::vector<uint8_t>>(); }

References final().

final_with_ticket()

std::pair< unique_esys_ptr< TPM2B_DIGEST >, unique_esys_ptr< TPMT_TK_HASHCHECK > > Botan::TPM2::HashFunction::final_with_ticket

(

)

Finalize the hash operation and return the digest and the ticket as TSS2 structures.

Returns

A pair of TPM2B_DIGEST and TPMT_TK_HASHCHECK

Definition at line 102 of file tpm2_hash.cpp.

                                                                                                           {
   BOTAN_STATE_CHECK(m_handle.has_transient_handle());
 
   std::pair<unique_esys_ptr<TPM2B_DIGEST>, unique_esys_ptr<TPMT_TK_HASHCHECK>> result;
 
   const auto nodata = init_empty<TPM2B_MAX_BUFFER>();
   check_rc("Esys_SequenceComplete",
            Esys_SequenceComplete(*m_handle.context(),
                                  m_handle.transient_handle(),
                                  m_sessions[0],
                                  m_sessions[1],
                                  m_sessions[2],
                                  &nodata,
                                  m_hierarchy,
                                  out_ptr(result.first),
                                  out_ptr(result.second)));
   BOTAN_ASSERT_NONNULL(result.first);
 
   // Esys_SequenceComplete() destroys the underlying transient object
   // so we need to disengage it's RAII wrapper.
   m_handle._disengage();
 
   return result;
}

References BOTAN_ASSERT_NONNULL, BOTAN_STATE_CHECK, Botan::TPM2::check_rc(), Botan::TPM2::init_empty(), and Botan::out_ptr().

hash_block_size()

virtual size_t Botan::HashFunction::hash_block_size ( ) const

inlinevirtualinherited

Returns

hash block size as defined for this algorithm

Reimplemented in Botan::BLAKE2b, Botan::BLAKE2s, Botan::Comb4P, Botan::GOST_34_11, Botan::Keccak_1600, Botan::MD4, Botan::MD5, Botan::RIPEMD_160, Botan::SHA_1, Botan::SHA_224, Botan::SHA_256, Botan::SHA_384, Botan::SHA_3, Botan::SHA_512, Botan::SHA_512_256, Botan::SHAKE_128, Botan::SHAKE_256, Botan::Skein_512, Botan::SM3, Botan::Streebog, and Botan::Whirlpool.

Definition at line 64 of file hash.h.

{ return 0; }

name()

std::string Botan::TPM2::HashFunction::name ( ) const

overridevirtual

Returns

the hash function name

Implements Botan::HashFunction.

Definition at line 32 of file tpm2_hash.cpp.

                                   {
   return get_botan_hash_name(m_hash_type);
}

References Botan::TPM2::get_botan_hash_name().

Referenced by new_object().

new_object()

std::unique_ptr< Botan::HashFunction > Botan::TPM2::HashFunction::new_object ( ) const

overridevirtual

Returns

new object representing the same algorithm as *this

Implements Botan::HashFunction.

Definition at line 63 of file tpm2_hash.cpp.

                                                                {
   return std::make_unique<HashFunction>(m_handle.context(), name(), m_hierarchy, m_sessions);
}

References name().

output_length()

size_t Botan::TPM2::HashFunction::output_length ( ) const

overridevirtual

Returns

length of the output of this function in bytes

Implements Botan::Buffered_Computation.

Definition at line 36 of file tpm2_hash.cpp.

                                         {
   switch(m_hash_type) {
      case TPM2_ALG_SHA1:
         return 20;
      case TPM2_ALG_SHA256:
      case TPM2_ALG_SHA3_256:
      case TPM2_ALG_SM3_256:
         return 32;
      case TPM2_ALG_SHA384:
      case TPM2_ALG_SHA3_384:
         return 48;
      case TPM2_ALG_SHA512:
      case TPM2_ALG_SHA3_512:
         return 64;
      default:
         throw Invalid_State("TPM 2.0 hash object with unexpected hash type");
   }
}

process() [1/3]

template<concepts::resizable_byte_buffer T = secure_vector<uint8_t>>

T Botan::Buffered_Computation::process ( const uint8_t in[], size_t length )

inlineinherited

Update and finalize computation. Does the same as calling update() and final() consecutively.

Parameters

in	the input to process as a byte array
length	the length of the byte array

Returns

the result of the call to final()

Definition at line 101 of file buf_comp.h.

                                                   {
         update(in, length);
         return final<T>();
      }

References final(), and update().

Referenced by Botan::Kyber_Symmetric_Primitives::H(), Botan::Kyber_Symmetric_Primitives::H(), and Botan::Kyber_Symmetric_Primitives::H().

process() [2/3]

template<concepts::resizable_byte_buffer T = secure_vector<uint8_t>>

T Botan::Buffered_Computation::process ( std::span< const uint8_t > in )

inlineinherited

Update and finalize computation. Does the same as calling update() and final() consecutively.

Parameters

in	the input to process as a contiguous container

Returns

the result of the call to final()

Definition at line 125 of file buf_comp.h.

                                           {
         update(in);
         return final<T>();
      }

References final(), and update().

process() [3/3]

template<concepts::resizable_byte_buffer T = secure_vector<uint8_t>>

T Botan::Buffered_Computation::process ( std::string_view in )

inlineinherited

Update and finalize computation. Does the same as calling update() and final() consecutively.

Parameters

in	the input to process as a string

Returns

the result of the call to final()

Definition at line 113 of file buf_comp.h.

                                   {
         update(in);
         return final<T>();
      }

References final(), and update().

provider()

virtual std::string Botan::HashFunction::provider ( ) const

inlinevirtualinherited

Returns

provider information about this implementation. Default is "base", might also return "sse2", "avx2", "openssl", or some other arbitrary string.

Reimplemented in Botan::Keccak_1600, Botan::SHA_1, Botan::SHA_224, Botan::SHA_256, Botan::SHA_384, Botan::SHA_3, Botan::SHA_512, Botan::SHA_512_256, Botan::SHAKE_128, and Botan::SHAKE_256.

Definition at line 49 of file hash.h.

{ return "base"; }

Referenced by create(), and create_or_throw().

providers()

std::vector< std::string > Botan::HashFunction::providers ( std::string_view algo_spec )

staticinherited

Returns

list of available providers for this algorithm, empty if not available

Parameters

algo_spec

algorithm name

Definition at line 305 of file hash.cpp.

                                                                     {
   return probe_providers_of<HashFunction>(algo_spec, {"base", "commoncrypto"});
}

References Botan::probe_providers_of().

type()

TPMI_ALG_HASH Botan::TPM2::HashFunction::type ( ) const

inline

Returns

The hash algorithm identifier as TSS2's TPMI_ALG_HASH

Definition at line 45 of file tpm2_hash.h.

{ return m_hash_type; }

update() [1/4]

void Botan::Buffered_Computation::update ( const uint8_t in[], size_t length )

inlineinherited

Add new input to process.

Parameters

in	the input to process as a byte array
length	of param in in bytes

Definition at line 34 of file buf_comp.h.

{ add_data({in, length}); }

Referenced by Botan::PseudorandomKeyGeneration::gen(), Botan::LMOTS_Public_Key::LMOTS_Public_Key(), Botan::mgf1_mask(), Botan::pbkdf2(), Botan::Sphincs_Hash_Functions_Sha2::PRF_msg(), process(), process(), process(), Botan::TLS::TLS_NULL_HMAC_AEAD_Mode::set_associated_data_n(), and Botan::sm2_compute_za().

update() [2/4]

void Botan::Buffered_Computation::update ( std::span< const uint8_t > in )

inlineinherited

Add new input to process.

Parameters

in	the input to process as a contiguous data range

Definition at line 40 of file buf_comp.h.

{ add_data(in); }

update() [3/4]

void Botan::Buffered_Computation::update ( std::string_view str )

inherited

Add new input to process.

Parameters

str	the input to process as a std::string_view. Will be interpreted as a byte array based on the strings encoding.

Definition at line 14 of file buf_comp.cpp.

                                                    {
   add_data(as_span_of_bytes(str));
}

References Botan::as_span_of_bytes().

update() [4/4]

void Botan::Buffered_Computation::update ( uint8_t in )

inlineinherited

Process a single byte.

Parameters

in	the byte to process

Definition at line 61 of file buf_comp.h.

{ add_data({&in, 1}); }

update_be() [1/3]

void Botan::Buffered_Computation::update_be ( uint16_t val )

inherited

Definition at line 18 of file buf_comp.cpp.

                                                 {
   uint8_t inb[sizeof(val)];
   store_be(val, inb);
   add_data({inb, sizeof(inb)});
}

References Botan::store_be().

Referenced by Botan::mgf1_mask(), and Botan::pbkdf2().

update_be() [2/3]

void Botan::Buffered_Computation::update_be ( uint32_t val )

inherited

Definition at line 24 of file buf_comp.cpp.

                                                 {
   uint8_t inb[sizeof(val)];
   store_be(val, inb);
   add_data({inb, sizeof(inb)});
}

References Botan::store_be().

update_be() [3/3]

void Botan::Buffered_Computation::update_be ( uint64_t val )

inherited

Definition at line 30 of file buf_comp.cpp.

                                                 {
   uint8_t inb[sizeof(val)];
   store_be(val, inb);
   add_data({inb, sizeof(inb)});
}

References Botan::store_be().

update_le() [1/3]

void Botan::Buffered_Computation::update_le ( uint16_t val )

inherited

Definition at line 36 of file buf_comp.cpp.

                                                 {
   uint8_t inb[sizeof(val)];
   store_le(val, inb);
   add_data({inb, sizeof(inb)});
}

References Botan::store_le().

update_le() [2/3]

void Botan::Buffered_Computation::update_le ( uint32_t val )

inherited

Definition at line 42 of file buf_comp.cpp.

                                                 {
   uint8_t inb[sizeof(val)];
   store_le(val, inb);
   add_data({inb, sizeof(inb)});
}

References Botan::store_le().

update_le() [3/3]

void Botan::Buffered_Computation::update_le ( uint64_t val )

inherited

Definition at line 48 of file buf_comp.cpp.

                                                 {
   uint8_t inb[sizeof(val)];
   store_le(val, inb);
   add_data({inb, sizeof(inb)});
}

References Botan::store_le().

---

The documentation for this class was generated from the following files:

• src/lib/prov/tpm2/tpm2_hash.h
• src/lib/prov/tpm2/tpm2_hash.cpp