#include <sha2_32.h>

Inheritance diagram for Botan::SHA_256:

Public Member Functions
void	clear () override

HashFunction *	clone () const

std::unique_ptr< 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 ()

size_t	hash_block_size () const override final

std::string	name () const override

std::unique_ptr< 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)

std::string	provider () const override

	SHA_256 ()

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 void	compress_digest (secure_vector< uint32_t > &digest, const uint8_t input[], size_t blocks)

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)

Protected Member Functions
void	add_data (const uint8_t input[], size_t length) override final

void	final_result (uint8_t output[]) override final

Detailed Description

SHA-256

Definition at line 45 of file sha2_32.h.

Constructor & Destructor Documentation

◆ SHA_256()

Botan::SHA_256::SHA_256 ( )

inline

Definition at line 59 of file sha2_32.h.

59: MDx_HashFunction(64, true, true), m_digest(8) { clear(); }

Botan::MDx_HashFunction::MDx_HashFunction

MDx_HashFunction(size_t block_length, bool big_byte_endian, bool big_bit_endian, uint8_t counter_size=8)

Definition: mdx_hash.cpp:19

Botan::SHA_256::clear

void clear() override

Definition: sha2_32.cpp:231

References clear().

Member Function Documentation

◆ add_data()

void Botan::MDx_HashFunction::add_data	(	const uint8_t	input[],
		size_t	length
	)

finaloverrideprotectedvirtualinherited

Add more data to the computation

Parameters

input	is an input buffer
length	is the length of input in bytes

Implements Botan::Buffered_Computation.

Definition at line 49 of file mdx_hash.cpp.

                                                                    {
   const size_t block_len = static_cast<size_t>(1) << m_block_bits;
 
   m_count += length;
 
   if(m_position) {
      buffer_insert(m_buffer, m_position, input, length);
 
      if(m_position + length >= block_len) {
         compress_n(m_buffer.data(), 1);
         input += (block_len - m_position);
         length -= (block_len - m_position);
         m_position = 0;
      }
   }
 
   // Just in case the compiler can't figure out block_len is a power of 2
   const size_t full_blocks = length >> m_block_bits;
   const size_t remaining = length & (block_len - 1);
 
   if(full_blocks > 0) {
      compress_n(input, full_blocks);
   }
 
   buffer_insert(m_buffer, m_position, input + full_blocks * block_len, remaining);
   m_position += remaining;
}

References Botan::buffer_insert(), and Botan::MDx_HashFunction::compress_n().

◆ clear()

void Botan::SHA_256::clear ( )

overridevirtual

Reset the state.

Reimplemented from Botan::MDx_HashFunction.

Definition at line 231 of file sha2_32.cpp.

                    {
   MDx_HashFunction::clear();
   m_digest[0] = 0x6A09E667;
   m_digest[1] = 0xBB67AE85;
   m_digest[2] = 0x3C6EF372;
   m_digest[3] = 0xA54FF53A;
   m_digest[4] = 0x510E527F;
   m_digest[5] = 0x9B05688C;
   m_digest[6] = 0x1F83D9AB;
   m_digest[7] = 0x5BE0CD19;
}

References Botan::MDx_HashFunction::clear().

Referenced by SHA_256().

◆ clone()

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

inlineinherited

Returns: new object representing the same algorithm as *this

Definition at line 87 of file hash.h.

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

Botan::HashFunction::new_object

virtual std::unique_ptr< HashFunction > new_object() const =0

◆ compress_digest()

void Botan::SHA_256::compress_digest	(	secure_vector< uint32_t > &	digest,
		const uint8_t	input[],
		size_t	blocks
	)

static

Definition at line 56 of file sha2_32.cpp.

                                                                                                   {
#if defined(BOTAN_HAS_SHA2_32_X86)
   if(CPUID::has_intel_sha()) {
      return SHA_256::compress_digest_x86(digest, input, blocks);
   }
#endif
 
#if defined(BOTAN_HAS_SHA2_32_X86_BMI2)
   if(CPUID::has_bmi2()) {
      return SHA_256::compress_digest_x86_bmi2(digest, input, blocks);
   }
#endif
 
#if defined(BOTAN_HAS_SHA2_32_ARMV8)
   if(CPUID::has_arm_sha2()) {
      return SHA_256::compress_digest_armv8(digest, input, blocks);
   }
#endif
 
   uint32_t A = digest[0], B = digest[1], C = digest[2], D = digest[3], E = digest[4], F = digest[5], G = digest[6],
            H = digest[7];
 
   for(size_t i = 0; i != blocks; ++i) {
      uint32_t W00 = load_be<uint32_t>(input, 0);
      uint32_t W01 = load_be<uint32_t>(input, 1);
      uint32_t W02 = load_be<uint32_t>(input, 2);
      uint32_t W03 = load_be<uint32_t>(input, 3);
      uint32_t W04 = load_be<uint32_t>(input, 4);
      uint32_t W05 = load_be<uint32_t>(input, 5);
      uint32_t W06 = load_be<uint32_t>(input, 6);
      uint32_t W07 = load_be<uint32_t>(input, 7);
      uint32_t W08 = load_be<uint32_t>(input, 8);
      uint32_t W09 = load_be<uint32_t>(input, 9);
      uint32_t W10 = load_be<uint32_t>(input, 10);
      uint32_t W11 = load_be<uint32_t>(input, 11);
      uint32_t W12 = load_be<uint32_t>(input, 12);
      uint32_t W13 = load_be<uint32_t>(input, 13);
      uint32_t W14 = load_be<uint32_t>(input, 14);
      uint32_t W15 = load_be<uint32_t>(input, 15);
 
      SHA2_32_F(A, B, C, D, E, F, G, H, W00, W14, W09, W01, 0x428A2F98);
      SHA2_32_F(H, A, B, C, D, E, F, G, W01, W15, W10, W02, 0x71374491);
      SHA2_32_F(G, H, A, B, C, D, E, F, W02, W00, W11, W03, 0xB5C0FBCF);
      SHA2_32_F(F, G, H, A, B, C, D, E, W03, W01, W12, W04, 0xE9B5DBA5);
      SHA2_32_F(E, F, G, H, A, B, C, D, W04, W02, W13, W05, 0x3956C25B);
      SHA2_32_F(D, E, F, G, H, A, B, C, W05, W03, W14, W06, 0x59F111F1);
      SHA2_32_F(C, D, E, F, G, H, A, B, W06, W04, W15, W07, 0x923F82A4);
      SHA2_32_F(B, C, D, E, F, G, H, A, W07, W05, W00, W08, 0xAB1C5ED5);
      SHA2_32_F(A, B, C, D, E, F, G, H, W08, W06, W01, W09, 0xD807AA98);
      SHA2_32_F(H, A, B, C, D, E, F, G, W09, W07, W02, W10, 0x12835B01);
      SHA2_32_F(G, H, A, B, C, D, E, F, W10, W08, W03, W11, 0x243185BE);
      SHA2_32_F(F, G, H, A, B, C, D, E, W11, W09, W04, W12, 0x550C7DC3);
      SHA2_32_F(E, F, G, H, A, B, C, D, W12, W10, W05, W13, 0x72BE5D74);
      SHA2_32_F(D, E, F, G, H, A, B, C, W13, W11, W06, W14, 0x80DEB1FE);
      SHA2_32_F(C, D, E, F, G, H, A, B, W14, W12, W07, W15, 0x9BDC06A7);
      SHA2_32_F(B, C, D, E, F, G, H, A, W15, W13, W08, W00, 0xC19BF174);
 
      SHA2_32_F(A, B, C, D, E, F, G, H, W00, W14, W09, W01, 0xE49B69C1);
      SHA2_32_F(H, A, B, C, D, E, F, G, W01, W15, W10, W02, 0xEFBE4786);
      SHA2_32_F(G, H, A, B, C, D, E, F, W02, W00, W11, W03, 0x0FC19DC6);
      SHA2_32_F(F, G, H, A, B, C, D, E, W03, W01, W12, W04, 0x240CA1CC);
      SHA2_32_F(E, F, G, H, A, B, C, D, W04, W02, W13, W05, 0x2DE92C6F);
      SHA2_32_F(D, E, F, G, H, A, B, C, W05, W03, W14, W06, 0x4A7484AA);
      SHA2_32_F(C, D, E, F, G, H, A, B, W06, W04, W15, W07, 0x5CB0A9DC);
      SHA2_32_F(B, C, D, E, F, G, H, A, W07, W05, W00, W08, 0x76F988DA);
      SHA2_32_F(A, B, C, D, E, F, G, H, W08, W06, W01, W09, 0x983E5152);
      SHA2_32_F(H, A, B, C, D, E, F, G, W09, W07, W02, W10, 0xA831C66D);
      SHA2_32_F(G, H, A, B, C, D, E, F, W10, W08, W03, W11, 0xB00327C8);
      SHA2_32_F(F, G, H, A, B, C, D, E, W11, W09, W04, W12, 0xBF597FC7);
      SHA2_32_F(E, F, G, H, A, B, C, D, W12, W10, W05, W13, 0xC6E00BF3);
      SHA2_32_F(D, E, F, G, H, A, B, C, W13, W11, W06, W14, 0xD5A79147);
      SHA2_32_F(C, D, E, F, G, H, A, B, W14, W12, W07, W15, 0x06CA6351);
      SHA2_32_F(B, C, D, E, F, G, H, A, W15, W13, W08, W00, 0x14292967);
 
      SHA2_32_F(A, B, C, D, E, F, G, H, W00, W14, W09, W01, 0x27B70A85);
      SHA2_32_F(H, A, B, C, D, E, F, G, W01, W15, W10, W02, 0x2E1B2138);
      SHA2_32_F(G, H, A, B, C, D, E, F, W02, W00, W11, W03, 0x4D2C6DFC);
      SHA2_32_F(F, G, H, A, B, C, D, E, W03, W01, W12, W04, 0x53380D13);
      SHA2_32_F(E, F, G, H, A, B, C, D, W04, W02, W13, W05, 0x650A7354);
      SHA2_32_F(D, E, F, G, H, A, B, C, W05, W03, W14, W06, 0x766A0ABB);
      SHA2_32_F(C, D, E, F, G, H, A, B, W06, W04, W15, W07, 0x81C2C92E);
      SHA2_32_F(B, C, D, E, F, G, H, A, W07, W05, W00, W08, 0x92722C85);
      SHA2_32_F(A, B, C, D, E, F, G, H, W08, W06, W01, W09, 0xA2BFE8A1);
      SHA2_32_F(H, A, B, C, D, E, F, G, W09, W07, W02, W10, 0xA81A664B);
      SHA2_32_F(G, H, A, B, C, D, E, F, W10, W08, W03, W11, 0xC24B8B70);
      SHA2_32_F(F, G, H, A, B, C, D, E, W11, W09, W04, W12, 0xC76C51A3);
      SHA2_32_F(E, F, G, H, A, B, C, D, W12, W10, W05, W13, 0xD192E819);
      SHA2_32_F(D, E, F, G, H, A, B, C, W13, W11, W06, W14, 0xD6990624);
      SHA2_32_F(C, D, E, F, G, H, A, B, W14, W12, W07, W15, 0xF40E3585);
      SHA2_32_F(B, C, D, E, F, G, H, A, W15, W13, W08, W00, 0x106AA070);
 
      SHA2_32_F(A, B, C, D, E, F, G, H, W00, W14, W09, W01, 0x19A4C116);
      SHA2_32_F(H, A, B, C, D, E, F, G, W01, W15, W10, W02, 0x1E376C08);
      SHA2_32_F(G, H, A, B, C, D, E, F, W02, W00, W11, W03, 0x2748774C);
      SHA2_32_F(F, G, H, A, B, C, D, E, W03, W01, W12, W04, 0x34B0BCB5);
      SHA2_32_F(E, F, G, H, A, B, C, D, W04, W02, W13, W05, 0x391C0CB3);
      SHA2_32_F(D, E, F, G, H, A, B, C, W05, W03, W14, W06, 0x4ED8AA4A);
      SHA2_32_F(C, D, E, F, G, H, A, B, W06, W04, W15, W07, 0x5B9CCA4F);
      SHA2_32_F(B, C, D, E, F, G, H, A, W07, W05, W00, W08, 0x682E6FF3);
      SHA2_32_F(A, B, C, D, E, F, G, H, W08, W06, W01, W09, 0x748F82EE);
      SHA2_32_F(H, A, B, C, D, E, F, G, W09, W07, W02, W10, 0x78A5636F);
      SHA2_32_F(G, H, A, B, C, D, E, F, W10, W08, W03, W11, 0x84C87814);
      SHA2_32_F(F, G, H, A, B, C, D, E, W11, W09, W04, W12, 0x8CC70208);
      SHA2_32_F(E, F, G, H, A, B, C, D, W12, W10, W05, W13, 0x90BEFFFA);
      SHA2_32_F(D, E, F, G, H, A, B, C, W13, W11, W06, W14, 0xA4506CEB);
      SHA2_32_F(C, D, E, F, G, H, A, B, W14, W12, W07, W15, 0xBEF9A3F7);
      SHA2_32_F(B, C, D, E, F, G, H, A, W15, W13, W08, W00, 0xC67178F2);
 
      A = (digest[0] += A);
      B = (digest[1] += B);
      C = (digest[2] += C);
      D = (digest[3] += D);
      E = (digest[4] += E);
      F = (digest[5] += F);
      G = (digest[6] += G);
      H = (digest[7] += H);
 
      input += 64;
   }
}

References Botan::load_be< uint32_t >(), and Botan::SHA2_32_F().

◆ copy_state()

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

overridevirtual

Return a new hash object with the same state as *this. This allows computing the hash of several messages with a common prefix more efficiently than would otherwise be possible.

This function should be called clone but that was already used for the case of returning an uninitialized object.

Returns: new hash object

Implements Botan::HashFunction.

Definition at line 49 of file sha2_32.cpp.

                                                      {
   return std::make_unique<SHA_256>(*this);
}

◆ 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 103 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_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(), Botan::HashFunction::create(), Botan::make_commoncrypto_hash(), and Botan::HashFunction::provider().

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

◆ 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 288 of file hash.cpp.

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

References Botan::HashFunction::create(), and Botan::HashFunction::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::EMSA_PKCS1v15_Raw::EMSA_PKCS1v15_Raw(), Botan::expand_message_xmd(), Botan::TLS::Handshake_Hash::final(), Botan::generate_dsa_primes(), Botan::OCSP::CertID::is_id_for(), Botan::TLS::make_hello_random(), Botan::Roughtime::nonce_from_blind(), 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.data());
         return output;
      }

References T.

◆ final() [2/4]

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

inlineinherited

Definition at line 85 of file buf_comp.h.

                                       {
         BOTAN_ASSERT_NOMSG(out.size() >= output_length());
         final_result(out.data());
      }

References BOTAN_ASSERT_NOMSG.

◆ final() [3/4]

template<concepts::resizable_byte_buffer T>

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

inlineinherited

Definition at line 91 of file buf_comp.h.

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

◆ 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.

69{ final_result(out); }

Referenced by Botan::ed25519_gen_keypair(), Botan::ed25519_sign(), Botan::ed25519_verify(), Botan::mgf1_mask(), Botan::pbkdf2(), Botan::Dilithium::Polynomial::poly_challenge(), Botan::Kyber_Modern_Symmetric_Primitives::PRF(), Botan::Sphincs_Hash_Functions_Sha2::PRF_msg(), Botan::Sphincs_Hash_Functions_Shake::PRF_msg(), and Botan::sm2_compute_za().

◆ final_result()

void Botan::MDx_HashFunction::final_result ( uint8_t out[] )

finaloverrideprotectedvirtualinherited

Write the final output to out

Parameters

out	is an output buffer of output_length()

Implements Botan::Buffered_Computation.

Definition at line 80 of file mdx_hash.cpp.

                                                    {
   const size_t block_len = static_cast<size_t>(1) << m_block_bits;
 
   clear_mem(&m_buffer[m_position], block_len - m_position);
   m_buffer[m_position] = m_pad_char;
 
   if(m_position >= block_len - m_counter_size) {
      compress_n(m_buffer.data(), 1);
      zeroise(m_buffer);
   }
 
   BOTAN_ASSERT_NOMSG(m_counter_size <= output_length());
   BOTAN_ASSERT_NOMSG(m_counter_size >= 8);
 
   const uint64_t bit_count = m_count * 8;
 
   if(m_count_big_endian) {
      store_be(bit_count, &m_buffer[block_len - 8]);
   } else {
      store_le(bit_count, &m_buffer[block_len - 8]);
   }
 
   compress_n(m_buffer.data(), 1);
   copy_out(output);
   clear();
}

References BOTAN_ASSERT_NOMSG, Botan::MDx_HashFunction::clear(), Botan::clear_mem(), Botan::MDx_HashFunction::compress_n(), Botan::MDx_HashFunction::copy_out(), Botan::Buffered_Computation::output_length(), Botan::store_be(), Botan::store_le(), and Botan::zeroise().

◆ final_stdvec()

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

inlineinherited

Definition at line 83 of file buf_comp.h.

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

◆ hash_block_size()

size_t Botan::MDx_HashFunction::hash_block_size ( ) const

inlinefinaloverridevirtualinherited

Returns: hash block size as defined for this algorithm

Reimplemented from Botan::HashFunction.

Definition at line 29 of file mdx_hash.h.

29{ return m_buffer.size(); }

◆ name()

std::string Botan::SHA_256::name ( ) const

inlineoverridevirtual

Returns: the hash function name

Implements Botan::HashFunction.

Definition at line 47 of file sha2_32.h.

47{ return "SHA-256"; }

◆ new_object()

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

inlineoverridevirtual

Returns: new object representing the same algorithm as *this

Implements Botan::HashFunction.

Definition at line 51 of file sha2_32.h.

51{ return std::make_unique<SHA_256>(); }

◆ output_length()

size_t Botan::SHA_256::output_length ( ) const

inlineoverridevirtual

Returns: length of the output of this function in bytes

Implements Botan::Buffered_Computation.

Definition at line 49 of file sha2_32.h.

49{ return 32; }

◆ 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 104 of file buf_comp.h.

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

References update.

Referenced by Botan::Dilithium_Symmetric_Primitives::CRH(), and Botan::Dilithium_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 128 of file buf_comp.h.

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

References 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 116 of file buf_comp.h.

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

References update.

◆ provider()

std::string Botan::SHA_256::provider ( ) const

overridevirtual

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

Reimplemented from Botan::HashFunction.

Definition at line 181 of file sha2_32.cpp.

                                  {
   return sha256_provider();
}

◆ 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 295 of file hash.cpp.

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

◆ 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.

34{ add_data(in, length); }

Referenced by Botan::ed25519_gen_keypair(), Botan::ed25519_sign(), Botan::ed25519_verify(), Botan::mgf1_mask(), Botan::pbkdf2(), Botan::Dilithium::Polynomial::poly_challenge(), Botan::Kyber_Modern_Symmetric_Primitives::PRF(), Botan::Sphincs_Hash_Functions_Sha2::PRF_msg(), Botan::Sphincs_Hash_Functions_Shake::PRF_msg(), Botan::sm2_compute_za(), and Botan::Sphincs_Hash_Functions_Shake::Sphincs_Hash_Functions_Shake().

◆ 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.

40{ add_data(in.data(), in.size()); }

◆ update() [3/4]

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

inlineinherited

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 55 of file buf_comp.h.

55{ add_data(cast_char_ptr_to_uint8(str.data()), str.size()); }

Botan::cast_char_ptr_to_uint8

const uint8_t * cast_char_ptr_to_uint8(const char *s)

Definition: mem_ops.h:177

References Botan::cast_char_ptr_to_uint8().

◆ 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.

61{ add_data(&in, 1); }

◆ update_be() [1/3]

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

inherited

Definition at line 13 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 19 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 25 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 31 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 37 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 43 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/hash/sha2_32/sha2_32.h
src/lib/hash/sha2_32/sha2_32.cpp
src/lib/hash/sha2_32/sha2_32_bmi2/sha2_32_bmi2.cpp
src/lib/hash/sha2_32/sha2_32_x86/sha2_32_x86.cpp

Public Member Functions

Static Public Member Functions

Protected Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ SHA_256()

Member Function Documentation

◆ add_data()

◆ clear()

◆ clone()

◆ compress_digest()

◆ copy_state()

◆ create()

◆ create_or_throw()

◆ final() [1/4]

◆ final() [2/4]

◆ final() [3/4]

◆ final() [4/4]

◆ final_result()

◆ final_stdvec()

◆ hash_block_size()

◆ name()

◆ new_object()

◆ output_length()

◆ process() [1/3]

◆ process() [2/3]

◆ process() [3/3]

◆ provider()

◆ providers()

◆ update() [1/4]

◆ update() [2/4]

◆ update() [3/4]

◆ update() [4/4]

◆ update_be() [1/3]

◆ update_be() [2/3]

◆ update_be() [3/3]

◆ update_le() [1/3]

◆ update_le() [2/3]

◆ update_le() [3/3]