5230455705

Committed 10 Jun 2023 02:30PM UTC coverage: 91.715% (-0.03%) from 91.746%

Build # 5230455705

Build Type

push

github

Committed by

randombit

Commit Message

Merge GH #3584 Change clang-format AllowShortFunctionsOnASingleLine config from All to Inline

Run Details

77182 of 84154 relevant lines covered (91.72%)

11975295.43 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.55

/src/lib/hash/trunc_hash/trunc_hash.cpp

/**
 * Wrapper for truncated hashes
 * (C) 2023 Jack Lloyd
 *     2023 René Meusel - Rohde & Schwarz Cybersecurity
 *
 * Botan is released under the Simplified BSD License (see license.txt)
 */

#include <botan/internal/trunc_hash.h>

#include <botan/exceptn.h>
#include <botan/internal/fmt.h>

namespace Botan {

void Truncated_Hash::add_data(const uint8_t input[], size_t length) {
   m_hash->update(input, length);
}

void Truncated_Hash::final_result(uint8_t out[]) {
   BOTAN_ASSERT_NOMSG(m_hash->output_length() * 8 >= m_output_bits);

   const auto full_output = m_hash->final();

   // truncate output to a full number of bytes
   const auto bytes = output_length();
   std::copy_n(full_output.begin(), bytes, out);

   // mask the unwanted bits in the final byte
   const uint8_t bits_in_last_byte = ((m_output_bits - 1) % 8) + 1;
   const uint8_t bitmask = ~((1 << (8 - bits_in_last_byte)) - 1);

   out[bytes - 1] &= bitmask;
}

size_t Truncated_Hash::output_length() const {
   return (m_output_bits + 7) / 8;
}

std::string Truncated_Hash::name() const {
   return fmt("Truncated({},{})", m_hash->name(), m_output_bits);
}

std::unique_ptr<HashFunction> Truncated_Hash::new_object() const {
   return std::make_unique<Truncated_Hash>(m_hash->new_object(), m_output_bits);
}

std::unique_ptr<HashFunction> Truncated_Hash::copy_state() const {
   return std::make_unique<Truncated_Hash>(m_hash->copy_state(), m_output_bits);
}

void Truncated_Hash::clear() {
   m_hash->clear();
}

Truncated_Hash::Truncated_Hash(std::unique_ptr<HashFunction> hash, size_t bits) :
      m_hash(std::move(hash)), m_output_bits(bits) {
   BOTAN_ASSERT_NONNULL(m_hash);

   if(m_output_bits == 0) {
      throw Invalid_Argument("Truncating a hash to 0 does not make sense");
   }

   if(m_hash->output_length() * 8 < m_output_bits) {
      throw Invalid_Argument("Underlying hash function does not produce enough bytes for truncation");
   }
}

}  // namespace Botan

1	/**
2	* Wrapper for truncated hashes
3	* (C) 2023 Jack Lloyd
4	* 2023 René Meusel - Rohde & Schwarz Cybersecurity
5	*
6	* Botan is released under the Simplified BSD License (see license.txt)
7	*/
8
9	#include <botan/internal/trunc_hash.h>
10
11	#include <botan/exceptn.h>
12	#include <botan/internal/fmt.h>
13
14	namespace Botan {
15
16	void Truncated_Hash::add_data(const uint8_t input[], size_t length) {	53,747,712✔
17	m_hash->update(input, length);	53,747,712✔
18	}	53,747,712✔
19
20	void Truncated_Hash::final_result(uint8_t out[]) {	13,436,822✔
21	BOTAN_ASSERT_NOMSG(m_hash->output_length() * 8 >= m_output_bits);	13,436,822✔
22
23	const auto full_output = m_hash->final();	13,436,822✔
24
25	// truncate output to a full number of bytes
26	const auto bytes = output_length();	13,436,822✔
27	std::copy_n(full_output.begin(), bytes, out);	26,873,644✔
28
29	// mask the unwanted bits in the final byte
30	const uint8_t bits_in_last_byte = ((m_output_bits - 1) % 8) + 1;	13,436,822✔
31	const uint8_t bitmask = ~((1 << (8 - bits_in_last_byte)) - 1);	13,436,822✔
32
33	out[bytes - 1] &= bitmask;	13,436,822✔
34	}	13,436,822✔
35
36	size_t Truncated_Hash::output_length() const {	27,422,940✔
37	return (m_output_bits + 7) / 8;	13,436,822✔
38	}
39
40	std::string Truncated_Hash::name() const {	21✔
41	return fmt("Truncated({},{})", m_hash->name(), m_output_bits);	21✔
42	}
43
44	std::unique_ptr<HashFunction> Truncated_Hash::new_object() const {	227✔
45	return std::make_unique<Truncated_Hash>(m_hash->new_object(), m_output_bits);	227✔
46	}
47
48	std::unique_ptr<HashFunction> Truncated_Hash::copy_state() const {	×
49	return std::make_unique<Truncated_Hash>(m_hash->copy_state(), m_output_bits);	×
50	}
51
52	void Truncated_Hash::clear() {	275✔
53	m_hash->clear();	275✔
54	}	275✔
55
56	Truncated_Hash::Truncated_Hash(std::unique_ptr<HashFunction> hash, size_t bits) :	295✔
57	m_hash(std::move(hash)), m_output_bits(bits) {	295✔
58	BOTAN_ASSERT_NONNULL(m_hash);	295✔
59
60	if(m_output_bits == 0) {	295✔
61	throw Invalid_Argument("Truncating a hash to 0 does not make sense");	1✔
62	}
63
64	if(m_hash->output_length() * 8 < m_output_bits) {	294✔
65	throw Invalid_Argument("Underlying hash function does not produce enough bytes for truncation");	1✔
66	}
67	}	295✔
68
69	} // namespace Botan

randombit / botan / 5230455705

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous