Botan::SHA_1 Class Reference

#include <sha1.h>

Inheritance diagram for Botan::SHA_1:

Public Types
using	digest_type = secure_vector<uint32_t>

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
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
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_n (digest_type &digest, std::span< 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 void	init (digest_type &digest)
static std::vector< std::string >	providers (std::string_view algo_spec)
static void	sha1_armv8_compress_n (digest_type &digest, std::span< const uint8_t > blocks, size_t block_count)
static void	sha1_compress_x86 (digest_type &digest, std::span< const uint8_t > blocks, size_t block_count)

Static Public Attributes
static constexpr MD_Endian	bit_endianness = MD_Endian::Big
static constexpr size_t	block_bytes = 64
static constexpr MD_Endian	byte_endianness = MD_Endian::Big
static constexpr size_t	ctr_bytes = 8
static constexpr size_t	output_bytes = 20

Detailed Description

NIST's SHA-1

Definition at line 18 of file sha1.h.

Member Typedef Documentation

digest_type

using Botan::SHA_1::digest_type = secure_vector<uint32_t>

Definition at line 20 of file sha1.h.

Member Function Documentation

clear()

void Botan::SHA_1::clear ( )

inlineoverridevirtual

Reset the state.

Implements Botan::HashFunction.

Definition at line 44 of file sha1.h.

{ m_md.clear(); }

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().

compress_n()

void Botan::SHA_1::compress_n ( digest_type & digest, std::span< const uint8_t > input, size_t blocks )

static

Definition at line 24 of file sha1.cpp.

                                                                                       {
   using namespace SHA1_F;
 
#if defined(BOTAN_HAS_SHA1_X86_SHA_NI)
   if(CPUID::has(CPUID::Feature::SHA)) {
      return sha1_compress_x86(digest, input, blocks);
   }
#endif
 
#if defined(BOTAN_HAS_SHA1_ARMV8)
   if(CPUID::has(CPUID::Feature::SHA1)) {
      return sha1_armv8_compress_n(digest, input, blocks);
   }
#endif
 
#if defined(BOTAN_HAS_SHA1_AVX2)
   if(CPUID::has(CPUID::Feature::AVX2, CPUID::Feature::BMI)) {
      return avx2_compress_n(digest, input, blocks);
   }
#endif
 
#if defined(BOTAN_HAS_SHA1_SIMD_4X32)
   if(CPUID::has(CPUID::Feature::SIMD_4X32)) {
      return simd_compress_n(digest, input, blocks);
   }
#endif
 
   uint32_t A = digest[0];
   uint32_t B = digest[1];
   uint32_t C = digest[2];
   uint32_t D = digest[3];
   uint32_t E = digest[4];
   std::array<uint32_t, 80> W{};
   auto W_in = std::span{W}.first<block_bytes / sizeof(uint32_t)>();
 
   BufferSlicer in(input);
 
   for(size_t i = 0; i != blocks; ++i) {
      load_be(W_in, in.take<block_bytes>());
 
      // clang-format off
 
      for(size_t j = 16; j != 80; j += 8) {
         W[j + 0] = rotl<1>(W[j - 3] ^ W[j - 8] ^ W[j - 14] ^ W[j - 16]);
         W[j + 1] = rotl<1>(W[j - 2] ^ W[j - 7] ^ W[j - 13] ^ W[j - 15]);
         W[j + 2] = rotl<1>(W[j - 1] ^ W[j - 6] ^ W[j - 12] ^ W[j - 14]);
         W[j + 3] = rotl<1>(W[j    ] ^ W[j - 5] ^ W[j - 11] ^ W[j - 13]);
         W[j + 4] = rotl<1>(W[j + 1] ^ W[j - 4] ^ W[j - 10] ^ W[j - 12]);
         W[j + 5] = rotl<1>(W[j + 2] ^ W[j - 3] ^ W[j -  9] ^ W[j - 11]);
         W[j + 6] = rotl<1>(W[j + 3] ^ W[j - 2] ^ W[j -  8] ^ W[j - 10]);
         W[j + 7] = rotl<1>(W[j + 4] ^ W[j - 1] ^ W[j -  7] ^ W[j -  9]);
      }
 
      // clang-format on
 
      F1(A, B, C, D, E, W[0] + K1);
      F1(E, A, B, C, D, W[1] + K1);
      F1(D, E, A, B, C, W[2] + K1);
      F1(C, D, E, A, B, W[3] + K1);
      F1(B, C, D, E, A, W[4] + K1);
      F1(A, B, C, D, E, W[5] + K1);
      F1(E, A, B, C, D, W[6] + K1);
      F1(D, E, A, B, C, W[7] + K1);
      F1(C, D, E, A, B, W[8] + K1);
      F1(B, C, D, E, A, W[9] + K1);
      F1(A, B, C, D, E, W[10] + K1);
      F1(E, A, B, C, D, W[11] + K1);
      F1(D, E, A, B, C, W[12] + K1);
      F1(C, D, E, A, B, W[13] + K1);
      F1(B, C, D, E, A, W[14] + K1);
      F1(A, B, C, D, E, W[15] + K1);
      F1(E, A, B, C, D, W[16] + K1);
      F1(D, E, A, B, C, W[17] + K1);
      F1(C, D, E, A, B, W[18] + K1);
      F1(B, C, D, E, A, W[19] + K1);
 
      F2(A, B, C, D, E, W[20] + K2);
      F2(E, A, B, C, D, W[21] + K2);
      F2(D, E, A, B, C, W[22] + K2);
      F2(C, D, E, A, B, W[23] + K2);
      F2(B, C, D, E, A, W[24] + K2);
      F2(A, B, C, D, E, W[25] + K2);
      F2(E, A, B, C, D, W[26] + K2);
      F2(D, E, A, B, C, W[27] + K2);
      F2(C, D, E, A, B, W[28] + K2);
      F2(B, C, D, E, A, W[29] + K2);
      F2(A, B, C, D, E, W[30] + K2);
      F2(E, A, B, C, D, W[31] + K2);
      F2(D, E, A, B, C, W[32] + K2);
      F2(C, D, E, A, B, W[33] + K2);
      F2(B, C, D, E, A, W[34] + K2);
      F2(A, B, C, D, E, W[35] + K2);
      F2(E, A, B, C, D, W[36] + K2);
      F2(D, E, A, B, C, W[37] + K2);
      F2(C, D, E, A, B, W[38] + K2);
      F2(B, C, D, E, A, W[39] + K2);
 
      F3(A, B, C, D, E, W[40] + K3);
      F3(E, A, B, C, D, W[41] + K3);
      F3(D, E, A, B, C, W[42] + K3);
      F3(C, D, E, A, B, W[43] + K3);
      F3(B, C, D, E, A, W[44] + K3);
      F3(A, B, C, D, E, W[45] + K3);
      F3(E, A, B, C, D, W[46] + K3);
      F3(D, E, A, B, C, W[47] + K3);
      F3(C, D, E, A, B, W[48] + K3);
      F3(B, C, D, E, A, W[49] + K3);
      F3(A, B, C, D, E, W[50] + K3);
      F3(E, A, B, C, D, W[51] + K3);
      F3(D, E, A, B, C, W[52] + K3);
      F3(C, D, E, A, B, W[53] + K3);
      F3(B, C, D, E, A, W[54] + K3);
      F3(A, B, C, D, E, W[55] + K3);
      F3(E, A, B, C, D, W[56] + K3);
      F3(D, E, A, B, C, W[57] + K3);
      F3(C, D, E, A, B, W[58] + K3);
      F3(B, C, D, E, A, W[59] + K3);
 
      F4(A, B, C, D, E, W[60] + K4);
      F4(E, A, B, C, D, W[61] + K4);
      F4(D, E, A, B, C, W[62] + K4);
      F4(C, D, E, A, B, W[63] + K4);
      F4(B, C, D, E, A, W[64] + K4);
      F4(A, B, C, D, E, W[65] + K4);
      F4(E, A, B, C, D, W[66] + K4);
      F4(D, E, A, B, C, W[67] + K4);
      F4(C, D, E, A, B, W[68] + K4);
      F4(B, C, D, E, A, W[69] + K4);
      F4(A, B, C, D, E, W[70] + K4);
      F4(E, A, B, C, D, W[71] + K4);
      F4(D, E, A, B, C, W[72] + K4);
      F4(C, D, E, A, B, W[73] + K4);
      F4(B, C, D, E, A, W[74] + K4);
      F4(A, B, C, D, E, W[75] + K4);
      F4(E, A, B, C, D, W[76] + K4);
      F4(D, E, A, B, C, W[77] + K4);
      F4(C, D, E, A, B, W[78] + K4);
      F4(B, C, D, E, A, W[79] + K4);
 
      A = (digest[0] += A);
      B = (digest[1] += B);
      C = (digest[2] += C);
      D = (digest[3] += D);
      E = (digest[4] += E);
   }
}

References Botan::CPUFeature::AVX2, block_bytes, Botan::CPUFeature::BMI, Botan::CPUID::has(), Botan::load_be(), Botan::rotl(), Botan::CPUFeature::SHA, Botan::CPUFeature::SHA1, sha1_armv8_compress_n(), sha1_compress_x86(), Botan::CPUFeature::SIMD_4X32, and Botan::BufferSlicer::take().

copy_state()

std::unique_ptr< HashFunction > Botan::SHA_1::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 210 of file sha1.cpp.

                                                    {
   return std::make_unique<SHA_1>(*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 111 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_ASCON_HASH256)
   if(algo_spec == "Ascon-Hash256") {
      return std::make_unique<Ascon_Hash256>();
   }
#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::EncryptionPaddingScheme::create(), create(), Botan::KDF::create(), Botan::MessageAuthenticationCode::create(), Botan::PasswordHashFamily::create(), Botan::PBKDF::create(), Botan::SignaturePaddingScheme::create(), and create_or_throw().

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 308 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::Certificate_Store_In_Memory::find_cert_by_pubkey_sha1(), Botan::Certificate_Store_In_Memory::find_cert_by_raw_subject_dn_sha256(), 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().

hash_block_size()

size_t Botan::SHA_1::hash_block_size ( ) const

inlineoverridevirtual

Returns

hash block size as defined for this algorithm

Reimplemented from Botan::HashFunction.

Definition at line 36 of file sha1.h.

{ return block_bytes; }

References block_bytes.

init()

void Botan::SHA_1::init ( digest_type & digest )

static

Definition at line 174 of file sha1.cpp.

                                    {
   digest.assign({0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0});
}

name()

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

inlineoverridevirtual

Returns

the hash function name

Implements Botan::HashFunction.

Definition at line 32 of file sha1.h.

{ return "SHA-1"; }

new_object()

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

overridevirtual

Returns

new object representing the same algorithm as *this

Implements Botan::HashFunction.

Definition at line 206 of file sha1.cpp.

                                                    {
   return std::make_unique<SHA_1>();
}

output_length()

size_t Botan::SHA_1::output_length ( ) const

inlineoverridevirtual

Returns

length of the output of this function in bytes

Implements Botan::Buffered_Computation.

Definition at line 34 of file sha1.h.

{ return 20; }

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()

std::string Botan::SHA_1::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 178 of file sha1.cpp.

                                {
#if defined(BOTAN_HAS_SHA1_X86_SHA_NI)
   if(auto feat = CPUID::check(CPUID::Feature::SHA)) {
      return *feat;
   }
#endif
 
#if defined(BOTAN_HAS_SHA1_ARMV8)
   if(auto feat = CPUID::check(CPUID::Feature::SHA1)) {
      return *feat;
   }
#endif
 
#if defined(BOTAN_HAS_SHA1_AVX2)
   if(auto feat = CPUID::check(CPUID::Feature::AVX2, CPUID::Feature::BMI)) {
      return *feat;
   }
#endif
 
#if defined(BOTAN_HAS_SHA1_SIMD_4X32)
   if(auto feat = CPUID::check(CPUID::Feature::SIMD_4X32)) {
      return *feat;
   }
#endif
 
   return "base";
}

References Botan::CPUFeature::AVX2, Botan::CPUFeature::BMI, Botan::CPUID::check(), Botan::CPUFeature::SHA, Botan::CPUFeature::SHA1, and Botan::CPUFeature::SIMD_4X32.

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

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

References Botan::probe_providers_of().

sha1_armv8_compress_n()

void BOTAN_FN_ISA_SHA2 Botan::SHA_1::sha1_armv8_compress_n ( digest_type & digest, std::span< const uint8_t > blocks, size_t block_count )

static

Definition at line 21 of file sha1_armv8.cpp.

                                                                   {
   // Load magic constants
   const uint32x4_t C0 = vdupq_n_u32(0x5A827999);
   const uint32x4_t C1 = vdupq_n_u32(0x6ED9EBA1);
   const uint32x4_t C2 = vdupq_n_u32(0x8F1BBCDC);
   const uint32x4_t C3 = vdupq_n_u32(0xCA62C1D6);
 
   uint32x4_t ABCD = vld1q_u32(&digest[0]);  // NOLINT(*-container-data-pointer)
   uint32_t E0 = digest[4];
 
   const uint32_t* input32 = reinterpret_cast<const uint32_t*>(input8.data());
 
   while(blocks > 0) {
      // Save current hash
      const uint32x4_t ABCD_SAVED = ABCD;
      const uint32_t E0_SAVED = E0;
 
      uint32x4_t MSG0 = vld1q_u32(input32 + 0);
      uint32x4_t MSG1 = vld1q_u32(input32 + 4);
      uint32x4_t MSG2 = vld1q_u32(input32 + 8);
      uint32x4_t MSG3 = vld1q_u32(input32 + 12);
 
      MSG0 = vreinterpretq_u32_u8(vrev32q_u8(vreinterpretq_u8_u32(MSG0)));
      MSG1 = vreinterpretq_u32_u8(vrev32q_u8(vreinterpretq_u8_u32(MSG1)));
      MSG2 = vreinterpretq_u32_u8(vrev32q_u8(vreinterpretq_u8_u32(MSG2)));
      MSG3 = vreinterpretq_u32_u8(vrev32q_u8(vreinterpretq_u8_u32(MSG3)));
 
      uint32x4_t TMP0 = vaddq_u32(MSG0, C0);
      uint32x4_t TMP1 = vaddq_u32(MSG1, C0);
 
      // Rounds 0-3
      uint32_t E1 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
      ABCD = vsha1cq_u32(ABCD, E0, TMP0);
      TMP0 = vaddq_u32(MSG2, C0);
      MSG0 = vsha1su0q_u32(MSG0, MSG1, MSG2);
 
      // Rounds 4-7
      E0 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
      ABCD = vsha1cq_u32(ABCD, E1, TMP1);
      TMP1 = vaddq_u32(MSG3, C0);
      MSG0 = vsha1su1q_u32(MSG0, MSG3);
      MSG1 = vsha1su0q_u32(MSG1, MSG2, MSG3);
 
      // Rounds 8-11
      E1 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
      ABCD = vsha1cq_u32(ABCD, E0, TMP0);
      TMP0 = vaddq_u32(MSG0, C0);
      MSG1 = vsha1su1q_u32(MSG1, MSG0);
      MSG2 = vsha1su0q_u32(MSG2, MSG3, MSG0);
 
      // Rounds 12-15
      E0 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
      ABCD = vsha1cq_u32(ABCD, E1, TMP1);
      TMP1 = vaddq_u32(MSG1, C1);
      MSG2 = vsha1su1q_u32(MSG2, MSG1);
      MSG3 = vsha1su0q_u32(MSG3, MSG0, MSG1);
 
      // Rounds 16-19
      E1 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
      ABCD = vsha1cq_u32(ABCD, E0, TMP0);
      TMP0 = vaddq_u32(MSG2, C1);
      MSG3 = vsha1su1q_u32(MSG3, MSG2);
      MSG0 = vsha1su0q_u32(MSG0, MSG1, MSG2);
 
      // Rounds 20-23
      E0 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
      ABCD = vsha1pq_u32(ABCD, E1, TMP1);
      TMP1 = vaddq_u32(MSG3, C1);
      MSG0 = vsha1su1q_u32(MSG0, MSG3);
      MSG1 = vsha1su0q_u32(MSG1, MSG2, MSG3);
 
      // Rounds 24-27
      E1 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
      ABCD = vsha1pq_u32(ABCD, E0, TMP0);
      TMP0 = vaddq_u32(MSG0, C1);
      MSG1 = vsha1su1q_u32(MSG1, MSG0);
      MSG2 = vsha1su0q_u32(MSG2, MSG3, MSG0);
 
      // Rounds 28-31
      E0 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
      ABCD = vsha1pq_u32(ABCD, E1, TMP1);
      TMP1 = vaddq_u32(MSG1, C1);
      MSG2 = vsha1su1q_u32(MSG2, MSG1);
      MSG3 = vsha1su0q_u32(MSG3, MSG0, MSG1);
 
      // Rounds 32-35
      E1 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
      ABCD = vsha1pq_u32(ABCD, E0, TMP0);
      TMP0 = vaddq_u32(MSG2, C2);
      MSG3 = vsha1su1q_u32(MSG3, MSG2);
      MSG0 = vsha1su0q_u32(MSG0, MSG1, MSG2);
 
      // Rounds 36-39
      E0 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
      ABCD = vsha1pq_u32(ABCD, E1, TMP1);
      TMP1 = vaddq_u32(MSG3, C2);
      MSG0 = vsha1su1q_u32(MSG0, MSG3);
      MSG1 = vsha1su0q_u32(MSG1, MSG2, MSG3);
 
      // Rounds 40-43
      E1 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
      ABCD = vsha1mq_u32(ABCD, E0, TMP0);
      TMP0 = vaddq_u32(MSG0, C2);
      MSG1 = vsha1su1q_u32(MSG1, MSG0);
      MSG2 = vsha1su0q_u32(MSG2, MSG3, MSG0);
 
      // Rounds 44-47
      E0 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
      ABCD = vsha1mq_u32(ABCD, E1, TMP1);
      TMP1 = vaddq_u32(MSG1, C2);
      MSG2 = vsha1su1q_u32(MSG2, MSG1);
      MSG3 = vsha1su0q_u32(MSG3, MSG0, MSG1);
 
      // Rounds 48-51
      E1 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
      ABCD = vsha1mq_u32(ABCD, E0, TMP0);
      TMP0 = vaddq_u32(MSG2, C2);
      MSG3 = vsha1su1q_u32(MSG3, MSG2);
      MSG0 = vsha1su0q_u32(MSG0, MSG1, MSG2);
 
      // Rounds 52-55
      E0 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
      ABCD = vsha1mq_u32(ABCD, E1, TMP1);
      TMP1 = vaddq_u32(MSG3, C3);
      MSG0 = vsha1su1q_u32(MSG0, MSG3);
      MSG1 = vsha1su0q_u32(MSG1, MSG2, MSG3);
 
      // Rounds 56-59
      E1 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
      ABCD = vsha1mq_u32(ABCD, E0, TMP0);
      TMP0 = vaddq_u32(MSG0, C3);
      MSG1 = vsha1su1q_u32(MSG1, MSG0);
      MSG2 = vsha1su0q_u32(MSG2, MSG3, MSG0);
 
      // Rounds 60-63
      E0 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
      ABCD = vsha1pq_u32(ABCD, E1, TMP1);
      TMP1 = vaddq_u32(MSG1, C3);
      MSG2 = vsha1su1q_u32(MSG2, MSG1);
      MSG3 = vsha1su0q_u32(MSG3, MSG0, MSG1);
 
      // Rounds 64-67
      E1 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
      ABCD = vsha1pq_u32(ABCD, E0, TMP0);
      TMP0 = vaddq_u32(MSG2, C3);
      MSG3 = vsha1su1q_u32(MSG3, MSG2);
      MSG0 = vsha1su0q_u32(MSG0, MSG1, MSG2);
 
      // Rounds 68-71
      E0 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
      ABCD = vsha1pq_u32(ABCD, E1, TMP1);
      TMP1 = vaddq_u32(MSG3, C3);
 
      // Rounds 72-75
      E1 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
      ABCD = vsha1pq_u32(ABCD, E0, TMP0);
 
      // Rounds 76-79
      E0 = vsha1h_u32(vgetq_lane_u32(ABCD, 0));
      ABCD = vsha1pq_u32(ABCD, E1, TMP1);
 
      // Add state back
      E0 += E0_SAVED;
      ABCD = vaddq_u32(ABCD_SAVED, ABCD);
 
      input32 += 64 / 4;
      blocks--;
   }
 
   // Save digest
   vst1q_u32(&digest[0], ABCD);  // NOLINT(*-container-data-pointer)
   digest[4] = E0;
}

Referenced by compress_n().

sha1_compress_x86()

void BOTAN_FN_ISA_SHANI Botan::SHA_1::sha1_compress_x86 ( digest_type & digest, std::span< const uint8_t > blocks, size_t block_count )

static

Definition at line 74 of file sha1_x86.cpp.

                                                                {
   const uint8_t* input = input_span.data();
 
   SIMD_4x32 ABCD = rev_words(SIMD_4x32::load_le(&digest[0]));  // NOLINT(*-container-data-pointer)
   SIMD_4x32 E0 = SIMD_4x32(0, 0, 0, digest[4]);
 
   while(blocks > 0) {
      // Save current hash
      const auto ABCD_SAVE = ABCD;
      const auto E0_SAVE = E0;
 
      auto W0 = rev_words(SIMD_4x32::load_be(input));
      auto W1 = rev_words(SIMD_4x32::load_be(input + 16));
      auto W2 = rev_words(SIMD_4x32::load_be(input + 32));
      auto W3 = rev_words(SIMD_4x32::load_be(input + 48));
 
      sha1_x86_first8<0>(ABCD, E0, W0, W1);
      sha1_x86_rnds8<0>(ABCD, E0, W2, W3);
 
      W0 = sha1_x86_msg1(W0, W1);
      W1 = sha1_x86_msg1(W1, W2);
      W0 ^= W2;
 
      sha1_x86_next_msg(W3, W0, W1, W2);
      sha1_x86_next_msg(W0, W1, W2, W3);
      sha1_x86_rnds8<0, 1>(ABCD, E0, W0, W1);
 
      sha1_x86_next_msg(W1, W2, W3, W0);
      sha1_x86_next_msg(W2, W3, W0, W1);
      sha1_x86_rnds8<1>(ABCD, E0, W2, W3);
 
      sha1_x86_next_msg(W3, W0, W1, W2);
      sha1_x86_next_msg(W0, W1, W2, W3);
      sha1_x86_rnds8<1>(ABCD, E0, W0, W1);
 
      sha1_x86_next_msg(W1, W2, W3, W0);
      sha1_x86_next_msg(W2, W3, W0, W1);
      sha1_x86_rnds8<2>(ABCD, E0, W2, W3);
 
      sha1_x86_next_msg(W3, W0, W1, W2);
      sha1_x86_next_msg(W0, W1, W2, W3);
      sha1_x86_rnds8<2>(ABCD, E0, W0, W1);
 
      sha1_x86_next_msg(W1, W2, W3, W0);
      sha1_x86_next_msg(W2, W3, W0, W1);
      sha1_x86_rnds8<2, 3>(ABCD, E0, W2, W3);
 
      sha1_x86_next_msg(W3, W0, W1, W2);
      sha1_x86_next_msg(W0, W1, W2, W3);
      sha1_x86_rnds8<3>(ABCD, E0, W0, W1);
 
      sha1_x86_next_msg(W1, W2, W3, W0);
      sha1_x86_next_msg(W2, W3, W0, W1);
      sha1_x86_rnds8<3>(ABCD, E0, W2, W3);
 
      ABCD += ABCD_SAVE;
      E0 = sha1_x86_nexte(E0, E0_SAVE);
 
      input += 64;
      blocks--;
   }
 
   rev_words(ABCD).store_le(&digest[0]);  // NOLINT(*-container-data-pointer)
   digest[4] = _mm_extract_epi32(E0.raw(), 3);
}

References Botan::SIMD_4x32::load_be(), Botan::SIMD_4x32::load_le(), and Botan::SIMD_4x32::raw().

Referenced by compress_n().

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().

Member Data Documentation

bit_endianness

MD_Endian Botan::SHA_1::bit_endianness = MD_Endian::Big

staticconstexpr

Definition at line 23 of file sha1.h.

block_bytes

size_t Botan::SHA_1::block_bytes = 64

staticconstexpr

Definition at line 24 of file sha1.h.

Referenced by compress_n(), and hash_block_size().

byte_endianness

MD_Endian Botan::SHA_1::byte_endianness = MD_Endian::Big

staticconstexpr

Definition at line 22 of file sha1.h.

ctr_bytes

size_t Botan::SHA_1::ctr_bytes = 8

staticconstexpr

Definition at line 26 of file sha1.h.

output_bytes

size_t Botan::SHA_1::output_bytes = 20

staticconstexpr

Definition at line 25 of file sha1.h.

---

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

• src/lib/hash/sha1/sha1.h
• src/lib/hash/sha1/sha1.cpp
• src/lib/hash/sha1/sha1_armv8/sha1_armv8.cpp
• src/lib/hash/sha1/sha1_x86/sha1_x86.cpp