6052601502

Committed 01 Sep 2023 03:07AM UTC coverage: 91.704% (-0.004%) from 91.708%

Build # 6052601502

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #3673 from falko-strenzke/refact-sha3

Refactoring SHA3: based on new permutation keccak-fips

Run Details

78576 of 85684 relevant lines covered (91.7%)

8473544.9 hits per line

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

94.44

/src/lib/hash/shake/shake.cpp

/*
* SHAKE-128/256 as a hash
* (C) 2016 Jack Lloyd
*
* Botan is released under the Simplified BSD License (see license.txt)
*/

#include <botan/internal/shake.h>

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

namespace Botan {

SHAKE_128::SHAKE_128(size_t output_bits) : m_keccak(256, 0xF, 4), m_output_bits(output_bits) {
   if(output_bits % 8 != 0) {
      throw Invalid_Argument(fmt("SHAKE_128: Invalid output length {}", output_bits));
   }
}

std::string SHAKE_128::name() const {
   return fmt("SHAKE-128({})", m_output_bits);
}

std::unique_ptr<HashFunction> SHAKE_128::new_object() const {
   return std::make_unique<SHAKE_128>(m_output_bits);
}

std::unique_ptr<HashFunction> SHAKE_128::copy_state() const {
   return std::make_unique<SHAKE_128>(*this);
}

void SHAKE_128::add_data(const uint8_t input[], size_t length) {
   m_keccak.absorb({input, length});
}

void SHAKE_128::final_result(uint8_t output[]) {
   m_keccak.finish();
   m_keccak.squeeze({output, output_length()});
   clear();
}

SHAKE_256::SHAKE_256(size_t output_bits) : m_keccak(512, 0xF, 4), m_output_bits(output_bits) {
   if(output_bits % 8 != 0) {
      throw Invalid_Argument(fmt("SHAKE_256: Invalid output length {}", output_bits));
   }
}

std::string SHAKE_256::name() const {
   return fmt("SHAKE-256({})", m_output_bits);
}

std::unique_ptr<HashFunction> SHAKE_256::new_object() const {
   return std::make_unique<SHAKE_256>(m_output_bits);
}

std::unique_ptr<HashFunction> SHAKE_256::copy_state() const {
   return std::make_unique<SHAKE_256>(*this);
}

void SHAKE_256::add_data(const uint8_t input[], size_t length) {
   m_keccak.absorb({input, length});
}

void SHAKE_256::final_result(uint8_t output[]) {
   m_keccak.finish();
   m_keccak.squeeze({output, output_length()});
   clear();
}

}  // namespace Botan

1	/*
2	* SHAKE-128/256 as a hash
3	* (C) 2016 Jack Lloyd
4	*
5	* Botan is released under the Simplified BSD License (see license.txt)
6	*/
7
8	#include <botan/internal/shake.h>
9
10	#include <botan/exceptn.h>
11	#include <botan/internal/fmt.h>
12
13	namespace Botan {
14
15	SHAKE_128::SHAKE_128(size_t output_bits) : m_keccak(256, 0xF, 4), m_output_bits(output_bits) {	1,061✔
16	if(output_bits % 8 != 0) {	1,061✔
17	throw Invalid_Argument(fmt("SHAKE_128: Invalid output length {}", output_bits));	×
18	}
19	}	1,061✔
20
21	std::string SHAKE_128::name() const {	642✔
22	return fmt("SHAKE-128({})", m_output_bits);	642✔
23	}
24
25	std::unique_ptr<HashFunction> SHAKE_128::new_object() const {	426✔
26	return std::make_unique<SHAKE_128>(m_output_bits);	426✔
27	}
28
29	std::unique_ptr<HashFunction> SHAKE_128::copy_state() const {	207✔
30	return std::make_unique<SHAKE_128>(*this);	207✔
31	}
32
33	void SHAKE_128::add_data(const uint8_t input[], size_t length) {	57,150,985✔
34	m_keccak.absorb({input, length});	57,150,985✔
35	}	57,150,985✔
36
37	void SHAKE_128::final_result(uint8_t output[]) {	14,288,338✔
38	m_keccak.finish();	14,288,338✔
39	m_keccak.squeeze({output, output_length()});	14,288,338✔
40	clear();	14,288,338✔
41	}	14,288,338✔
42
43	SHAKE_256::SHAKE_256(size_t output_bits) : m_keccak(512, 0xF, 4), m_output_bits(output_bits) {	37,652✔
44	if(output_bits % 8 != 0) {	37,652✔
45	throw Invalid_Argument(fmt("SHAKE_256: Invalid output length {}", output_bits));	×
46	}
47	}	37,652✔
48
49	std::string SHAKE_256::name() const {	12✔
50	return fmt("SHAKE-256({})", m_output_bits);	12✔
51	}
52
53	std::unique_ptr<HashFunction> SHAKE_256::new_object() const {	1,277✔
54	return std::make_unique<SHAKE_256>(m_output_bits);	1,277✔
55	}
56
57	std::unique_ptr<HashFunction> SHAKE_256::copy_state() const {	3✔
58	return std::make_unique<SHAKE_256>(*this);	3✔
59	}
60
61	void SHAKE_256::add_data(const uint8_t input[], size_t length) {	255,948,840✔
62	m_keccak.absorb({input, length});	255,948,840✔
63	}	255,948,840✔
64
65	void SHAKE_256::final_result(uint8_t output[]) {	67,194,862✔
66	m_keccak.finish();	67,194,862✔
67	m_keccak.squeeze({output, output_length()});	67,194,862✔
68	clear();	134,389,724✔
69	}	67,194,862✔
70
71	} // namespace Botan

randombit / botan / 6052601502

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