#include <sm3.h>

Inheritance diagram for Botan::SM3:

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)

virtual std::string	provider () 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 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 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 = 32

Detailed Description

SM3

Definition at line 18 of file sm3.h.

Member Typedef Documentation

◆ digest_type

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

Definition at line 20 of file sm3.h.

Member Function Documentation

◆ clear()

void Botan::SM3::clear ( )

inlineoverridevirtual

Reset the state.

Implements Botan::HashFunction.

Definition at line 42 of file sm3.h.

42{ m_md.clear(); }

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

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

static

Definition at line 81 of file sm3.cpp.

                                                                                     {
   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];
   std::array<uint32_t, 16> W;
 
   BufferSlicer in(input);
 
   for(size_t i = 0; i != blocks; ++i) {
      load_be(W, in.take<block_bytes>());
 
      // clang-format off
 
      R1(A, B, C, D, E, F, G, H, 0x79CC4519, W[ 0], W[ 0] ^ W[ 4]);
      W[ 0] = SM3_E(W[ 0], W[ 7], W[13], W[ 3], W[10]);
      R1(D, A, B, C, H, E, F, G, 0xF3988A32, W[ 1], W[ 1] ^ W[ 5]);
      W[ 1] = SM3_E(W[ 1], W[ 8], W[14], W[ 4], W[11]);
      R1(C, D, A, B, G, H, E, F, 0xE7311465, W[ 2], W[ 2] ^ W[ 6]);
      W[ 2] = SM3_E(W[ 2], W[ 9], W[15], W[ 5], W[12]);
      R1(B, C, D, A, F, G, H, E, 0xCE6228CB, W[ 3], W[ 3] ^ W[ 7]);
      W[ 3] = SM3_E(W[ 3], W[10], W[ 0], W[ 6], W[13]);
      R1(A, B, C, D, E, F, G, H, 0x9CC45197, W[ 4], W[ 4] ^ W[ 8]);
      W[ 4] = SM3_E(W[ 4], W[11], W[ 1], W[ 7], W[14]);
      R1(D, A, B, C, H, E, F, G, 0x3988A32F, W[ 5], W[ 5] ^ W[ 9]);
      W[ 5] = SM3_E(W[ 5], W[12], W[ 2], W[ 8], W[15]);
      R1(C, D, A, B, G, H, E, F, 0x7311465E, W[ 6], W[ 6] ^ W[10]);
      W[ 6] = SM3_E(W[ 6], W[13], W[ 3], W[ 9], W[ 0]);
      R1(B, C, D, A, F, G, H, E, 0xE6228CBC, W[ 7], W[ 7] ^ W[11]);
      W[ 7] = SM3_E(W[ 7], W[14], W[ 4], W[10], W[ 1]);
      R1(A, B, C, D, E, F, G, H, 0xCC451979, W[ 8], W[ 8] ^ W[12]);
      W[ 8] = SM3_E(W[ 8], W[15], W[ 5], W[11], W[ 2]);
      R1(D, A, B, C, H, E, F, G, 0x988A32F3, W[ 9], W[ 9] ^ W[13]);
      W[ 9] = SM3_E(W[ 9], W[ 0], W[ 6], W[12], W[ 3]);
      R1(C, D, A, B, G, H, E, F, 0x311465E7, W[10], W[10] ^ W[14]);
      W[10] = SM3_E(W[10], W[ 1], W[ 7], W[13], W[ 4]);
      R1(B, C, D, A, F, G, H, E, 0x6228CBCE, W[11], W[11] ^ W[15]);
      W[11] = SM3_E(W[11], W[ 2], W[ 8], W[14], W[ 5]);
      R1(A, B, C, D, E, F, G, H, 0xC451979C, W[12], W[12] ^ W[ 0]);
      W[12] = SM3_E(W[12], W[ 3], W[ 9], W[15], W[ 6]);
      R1(D, A, B, C, H, E, F, G, 0x88A32F39, W[13], W[13] ^ W[ 1]);
      W[13] = SM3_E(W[13], W[ 4], W[10], W[ 0], W[ 7]);
      R1(C, D, A, B, G, H, E, F, 0x11465E73, W[14], W[14] ^ W[ 2]);
      W[14] = SM3_E(W[14], W[ 5], W[11], W[ 1], W[ 8]);
      R1(B, C, D, A, F, G, H, E, 0x228CBCE6, W[15], W[15] ^ W[ 3]);
      W[15] = SM3_E(W[15], W[ 6], W[12], W[ 2], W[ 9]);
      R2(A, B, C, D, E, F, G, H, 0x9D8A7A87, W[ 0], W[ 0] ^ W[ 4]);
      W[ 0] = SM3_E(W[ 0], W[ 7], W[13], W[ 3], W[10]);
      R2(D, A, B, C, H, E, F, G, 0x3B14F50F, W[ 1], W[ 1] ^ W[ 5]);
      W[ 1] = SM3_E(W[ 1], W[ 8], W[14], W[ 4], W[11]);
      R2(C, D, A, B, G, H, E, F, 0x7629EA1E, W[ 2], W[ 2] ^ W[ 6]);
      W[ 2] = SM3_E(W[ 2], W[ 9], W[15], W[ 5], W[12]);
      R2(B, C, D, A, F, G, H, E, 0xEC53D43C, W[ 3], W[ 3] ^ W[ 7]);
      W[ 3] = SM3_E(W[ 3], W[10], W[ 0], W[ 6], W[13]);
      R2(A, B, C, D, E, F, G, H, 0xD8A7A879, W[ 4], W[ 4] ^ W[ 8]);
      W[ 4] = SM3_E(W[ 4], W[11], W[ 1], W[ 7], W[14]);
      R2(D, A, B, C, H, E, F, G, 0xB14F50F3, W[ 5], W[ 5] ^ W[ 9]);
      W[ 5] = SM3_E(W[ 5], W[12], W[ 2], W[ 8], W[15]);
      R2(C, D, A, B, G, H, E, F, 0x629EA1E7, W[ 6], W[ 6] ^ W[10]);
      W[ 6] = SM3_E(W[ 6], W[13], W[ 3], W[ 9], W[ 0]);
      R2(B, C, D, A, F, G, H, E, 0xC53D43CE, W[ 7], W[ 7] ^ W[11]);
      W[ 7] = SM3_E(W[ 7], W[14], W[ 4], W[10], W[ 1]);
      R2(A, B, C, D, E, F, G, H, 0x8A7A879D, W[ 8], W[ 8] ^ W[12]);
      W[ 8] = SM3_E(W[ 8], W[15], W[ 5], W[11], W[ 2]);
      R2(D, A, B, C, H, E, F, G, 0x14F50F3B, W[ 9], W[ 9] ^ W[13]);
      W[ 9] = SM3_E(W[ 9], W[ 0], W[ 6], W[12], W[ 3]);
      R2(C, D, A, B, G, H, E, F, 0x29EA1E76, W[10], W[10] ^ W[14]);
      W[10] = SM3_E(W[10], W[ 1], W[ 7], W[13], W[ 4]);
      R2(B, C, D, A, F, G, H, E, 0x53D43CEC, W[11], W[11] ^ W[15]);
      W[11] = SM3_E(W[11], W[ 2], W[ 8], W[14], W[ 5]);
      R2(A, B, C, D, E, F, G, H, 0xA7A879D8, W[12], W[12] ^ W[ 0]);
      W[12] = SM3_E(W[12], W[ 3], W[ 9], W[15], W[ 6]);
      R2(D, A, B, C, H, E, F, G, 0x4F50F3B1, W[13], W[13] ^ W[ 1]);
      W[13] = SM3_E(W[13], W[ 4], W[10], W[ 0], W[ 7]);
      R2(C, D, A, B, G, H, E, F, 0x9EA1E762, W[14], W[14] ^ W[ 2]);
      W[14] = SM3_E(W[14], W[ 5], W[11], W[ 1], W[ 8]);
      R2(B, C, D, A, F, G, H, E, 0x3D43CEC5, W[15], W[15] ^ W[ 3]);
      W[15] = SM3_E(W[15], W[ 6], W[12], W[ 2], W[ 9]);
      R2(A, B, C, D, E, F, G, H, 0x7A879D8A, W[ 0], W[ 0] ^ W[ 4]);
      W[ 0] = SM3_E(W[ 0], W[ 7], W[13], W[ 3], W[10]);
      R2(D, A, B, C, H, E, F, G, 0xF50F3B14, W[ 1], W[ 1] ^ W[ 5]);
      W[ 1] = SM3_E(W[ 1], W[ 8], W[14], W[ 4], W[11]);
      R2(C, D, A, B, G, H, E, F, 0xEA1E7629, W[ 2], W[ 2] ^ W[ 6]);
      W[ 2] = SM3_E(W[ 2], W[ 9], W[15], W[ 5], W[12]);
      R2(B, C, D, A, F, G, H, E, 0xD43CEC53, W[ 3], W[ 3] ^ W[ 7]);
      W[ 3] = SM3_E(W[ 3], W[10], W[ 0], W[ 6], W[13]);
      R2(A, B, C, D, E, F, G, H, 0xA879D8A7, W[ 4], W[ 4] ^ W[ 8]);
      W[ 4] = SM3_E(W[ 4], W[11], W[ 1], W[ 7], W[14]);
      R2(D, A, B, C, H, E, F, G, 0x50F3B14F, W[ 5], W[ 5] ^ W[ 9]);
      W[ 5] = SM3_E(W[ 5], W[12], W[ 2], W[ 8], W[15]);
      R2(C, D, A, B, G, H, E, F, 0xA1E7629E, W[ 6], W[ 6] ^ W[10]);
      W[ 6] = SM3_E(W[ 6], W[13], W[ 3], W[ 9], W[ 0]);
      R2(B, C, D, A, F, G, H, E, 0x43CEC53D, W[ 7], W[ 7] ^ W[11]);
      W[ 7] = SM3_E(W[ 7], W[14], W[ 4], W[10], W[ 1]);
      R2(A, B, C, D, E, F, G, H, 0x879D8A7A, W[ 8], W[ 8] ^ W[12]);
      W[ 8] = SM3_E(W[ 8], W[15], W[ 5], W[11], W[ 2]);
      R2(D, A, B, C, H, E, F, G, 0x0F3B14F5, W[ 9], W[ 9] ^ W[13]);
      W[ 9] = SM3_E(W[ 9], W[ 0], W[ 6], W[12], W[ 3]);
      R2(C, D, A, B, G, H, E, F, 0x1E7629EA, W[10], W[10] ^ W[14]);
      W[10] = SM3_E(W[10], W[ 1], W[ 7], W[13], W[ 4]);
      R2(B, C, D, A, F, G, H, E, 0x3CEC53D4, W[11], W[11] ^ W[15]);
      W[11] = SM3_E(W[11], W[ 2], W[ 8], W[14], W[ 5]);
      R2(A, B, C, D, E, F, G, H, 0x79D8A7A8, W[12], W[12] ^ W[ 0]);
      W[12] = SM3_E(W[12], W[ 3], W[ 9], W[15], W[ 6]);
      R2(D, A, B, C, H, E, F, G, 0xF3B14F50, W[13], W[13] ^ W[ 1]);
      W[13] = SM3_E(W[13], W[ 4], W[10], W[ 0], W[ 7]);
      R2(C, D, A, B, G, H, E, F, 0xE7629EA1, W[14], W[14] ^ W[ 2]);
      W[14] = SM3_E(W[14], W[ 5], W[11], W[ 1], W[ 8]);
      R2(B, C, D, A, F, G, H, E, 0xCEC53D43, W[15], W[15] ^ W[ 3]);
      W[15] = SM3_E(W[15], W[ 6], W[12], W[ 2], W[ 9]);
      R2(A, B, C, D, E, F, G, H, 0x9D8A7A87, W[ 0], W[ 0] ^ W[ 4]);
      W[ 0] = SM3_E(W[ 0], W[ 7], W[13], W[ 3], W[10]);
      R2(D, A, B, C, H, E, F, G, 0x3B14F50F, W[ 1], W[ 1] ^ W[ 5]);
      W[ 1] = SM3_E(W[ 1], W[ 8], W[14], W[ 4], W[11]);
      R2(C, D, A, B, G, H, E, F, 0x7629EA1E, W[ 2], W[ 2] ^ W[ 6]);
      W[ 2] = SM3_E(W[ 2], W[ 9], W[15], W[ 5], W[12]);
      R2(B, C, D, A, F, G, H, E, 0xEC53D43C, W[ 3], W[ 3] ^ W[ 7]);
      W[ 3] = SM3_E(W[ 3], W[10], W[ 0], W[ 6], W[13]);
      R2(A, B, C, D, E, F, G, H, 0xD8A7A879, W[ 4], W[ 4] ^ W[ 8]);
      R2(D, A, B, C, H, E, F, G, 0xB14F50F3, W[ 5], W[ 5] ^ W[ 9]);
      R2(C, D, A, B, G, H, E, F, 0x629EA1E7, W[ 6], W[ 6] ^ W[10]);
      R2(B, C, D, A, F, G, H, E, 0xC53D43CE, W[ 7], W[ 7] ^ W[11]);
      R2(A, B, C, D, E, F, G, H, 0x8A7A879D, W[ 8], W[ 8] ^ W[12]);
      R2(D, A, B, C, H, E, F, G, 0x14F50F3B, W[ 9], W[ 9] ^ W[13]);
      R2(C, D, A, B, G, H, E, F, 0x29EA1E76, W[10], W[10] ^ W[14]);
      R2(B, C, D, A, F, G, H, E, 0x53D43CEC, W[11], W[11] ^ W[15]);
      R2(A, B, C, D, E, F, G, H, 0xA7A879D8, W[12], W[12] ^ W[ 0]);
      R2(D, A, B, C, H, E, F, G, 0x4F50F3B1, W[13], W[13] ^ W[ 1]);
      R2(C, D, A, B, G, H, E, F, 0x9EA1E762, W[14], W[14] ^ W[ 2]);
      R2(B, C, D, A, F, G, H, E, 0x3D43CEC5, W[15], W[15] ^ W[ 3]);
 
      // clang-format on
 
      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);
   }
}

References block_bytes, Botan::load_be(), and Botan::BufferSlicer::take().

◆ copy_state()

std::unique_ptr< HashFunction > Botan::SM3::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 232 of file sm3.cpp.

                                                  {
   return std::make_unique<SM3>(*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 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(), Botan::HashFunction::create(), Botan::make_commoncrypto_hash(), and Botan::HashFunction::provider().

Referenced by botan_hash_init(), Botan::BlockCipher::create(), Botan::EME::create(), Botan::EMSA::create(), Botan::HashFunction::create(), Botan::KDF::create(), Botan::MessageAuthenticationCode::create(), Botan::PasswordHashFamily::create(), Botan::PBKDF::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 298 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 78 of file buf_comp.h.

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

References T.

◆ final() [2/4]

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

inlineinherited

Definition at line 86 of file buf_comp.h.

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

References BOTAN_ARG_CHECK.

◆ final() [3/4]

template<concepts::resizable_byte_buffer T>

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

inlineinherited

Definition at line 92 of file buf_comp.h.

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

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

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

Referenced by Botan::ed25519_gen_keypair(), Botan::ed25519_sign(), Botan::ed25519_verify(), Botan::PseudorandomKeyGeneration::gen(), Botan::TPM2::Verification_Operation::is_valid_signature(), Botan::mgf1_mask(), Botan::pbkdf2(), Botan::Sphincs_Hash_Functions_Sha2::PRF_msg(), Botan::Sphincs_Hash_Functions_Shake::PRF_msg(), and Botan::TPM2::Signature_Operation::sign().

◆ final_stdvec()

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

inlineinherited

Definition at line 84 of file buf_comp.h.

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

Botan::Buffered_Computation::final

T final()

Definition buf_comp.h:78

References final.

◆ hash_block_size()

size_t Botan::SM3::hash_block_size ( ) const

inlineoverridevirtual

Returns: hash block size as defined for this algorithm

Reimplemented from Botan::HashFunction.

Definition at line 36 of file sm3.h.

36{ return block_bytes; }

References block_bytes.

◆ init()

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

static

Definition at line 223 of file sm3.cpp.

                                  {
   digest.assign(
      {0x7380166fUL, 0x4914b2b9UL, 0x172442d7UL, 0xda8a0600UL, 0xa96f30bcUL, 0x163138aaUL, 0xe38dee4dUL, 0xb0fb0e4eUL});
}

◆ name()

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

inlineoverridevirtual

Returns: the hash function name

Implements Botan::HashFunction.

Definition at line 32 of file sm3.h.

32{ return "SM3"; }

◆ new_object()

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

overridevirtual

Returns: new object representing the same algorithm as *this

Implements Botan::HashFunction.

Definition at line 228 of file sm3.cpp.

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

◆ output_length()

size_t Botan::SM3::output_length ( ) const

inlineoverridevirtual

Returns: length of the output of this function in bytes

Implements Botan::Buffered_Computation.

Definition at line 34 of file sm3.h.

34{ return output_bytes; }

Botan::SM3::output_bytes

static constexpr size_t output_bytes

Definition sm3.h:25

References output_bytes.

◆ 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 105 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 129 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 117 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.

49{ return "base"; }

Referenced by Botan::HashFunction::create(), and Botan::HashFunction::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().

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

35{ add_data({in, length}); }

Referenced by Botan::ed25519_gen_keypair(), Botan::ed25519_sign(), Botan::ed25519_verify(), Botan::PseudorandomKeyGeneration::gen(), Botan::LMOTS_Public_Key::LMOTS_Public_Key(), Botan::mgf1_mask(), Botan::pbkdf2(), Botan::Sphincs_Hash_Functions_Sha2::PRF_msg(), Botan::Sphincs_Hash_Functions_Shake::PRF_msg(), 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 41 of file buf_comp.h.

41{ add_data(in); }

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

56{ 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:273

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

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

Member Data Documentation

◆ bit_endianness

MD_Endian Botan::SM3::bit_endianness = MD_Endian::Big

staticconstexpr

Definition at line 23 of file sm3.h.

◆ block_bytes

size_t Botan::SM3::block_bytes = 64

staticconstexpr

Definition at line 24 of file sm3.h.

Referenced by compress_n(), and hash_block_size().

◆ byte_endianness

MD_Endian Botan::SM3::byte_endianness = MD_Endian::Big

staticconstexpr

Definition at line 22 of file sm3.h.

◆ ctr_bytes

size_t Botan::SM3::ctr_bytes = 8

staticconstexpr

Definition at line 26 of file sm3.h.

◆ output_bytes

size_t Botan::SM3::output_bytes = 32

staticconstexpr

Definition at line 25 of file sm3.h.

Referenced by output_length().

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

src/lib/hash/sm3/sm3.h
src/lib/hash/sm3/sm3.cpp

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Detailed Description

Member Typedef Documentation

◆ digest_type

Member Function Documentation

◆ clear()

◆ clone()

◆ compress_n()

◆ copy_state()

◆ create()

◆ create_or_throw()

◆ final() [1/4]

◆ final() [2/4]

◆ final() [3/4]

◆ final() [4/4]

◆ final_stdvec()

◆ hash_block_size()

◆ init()

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

Member Data Documentation

◆ bit_endianness

◆ block_bytes

◆ byte_endianness

◆ ctr_bytes

◆ output_bytes