5079590438

Committed 25 May 2023 12:28PM UTC coverage: 92.228% (+0.5%) from 91.723%

Build # 5079590438

Build Type

Pull #3502

github

Pull Request Pull Request #3502: Apply clang-format to the codebase

Run Details

75589 of 81959 relevant lines covered (92.23%)

12139530.51 hits per line

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

95.16

/src/lib/stream/shake_cipher/shake_cipher.cpp

/*
 * SHAKE-128 and SHAKE-256
 * (C) 2016 Jack Lloyd
 *     2022 René Meusel, Michael Boric - Rohde & Schwarz Cybersecurity
 *
 * Botan is released under the Simplified BSD License (see license.txt)
 */

#include <botan/internal/shake_cipher.h>

#include <botan/exceptn.h>
#include <botan/internal/loadstor.h>
#include <botan/internal/sha3.h>

namespace Botan {

SHAKE_Cipher::SHAKE_Cipher(size_t shake_rate) : m_shake_rate(shake_rate), m_buf_pos(0) {
   BOTAN_ASSERT_NOMSG(shake_rate >= 72 && shake_rate <= 168);
}

void SHAKE_Cipher::clear() {
   zap(m_state);
   zap(m_buffer);
   m_buf_pos = 0;
}

void SHAKE_Cipher::set_iv_bytes(const uint8_t /*iv*/[], size_t length) {
   /*
   * This could be supported in some way (say, by treating iv as
   * a prefix or suffix of the key).
   */
   if(length != 0) {
      throw Invalid_IV_Length(name(), length);
   }
}

size_t SHAKE_Cipher::buffer_size() const { return m_shake_rate; }

void SHAKE_Cipher::seek(uint64_t /*offset*/) { throw Not_Implemented("SHAKE_Cipher::seek"); }

void SHAKE_Cipher::cipher_bytes(const uint8_t in[], uint8_t out[], size_t length) {
   assert_key_material_set();

   while(length >= m_shake_rate - m_buf_pos) {
      xor_buf(out, in, &m_buffer[m_buf_pos], m_shake_rate - m_buf_pos);
      length -= (m_shake_rate - m_buf_pos);
      in += (m_shake_rate - m_buf_pos);
      out += (m_shake_rate - m_buf_pos);

      SHA_3::permute(m_state.data());
      copy_out_le(m_buffer.data(), m_shake_rate, m_state.data());

      m_buf_pos = 0;
   }
   xor_buf(out, in, &m_buffer[m_buf_pos], length);
   m_buf_pos += length;
}

void SHAKE_Cipher::generate_keystream(uint8_t out[], size_t length) {
   assert_key_material_set();

   if(m_buf_pos > 0) {
      const size_t take = std::min(length, m_shake_rate - m_buf_pos);
      copy_mem(out, &m_buffer[m_buf_pos], take);
      out += take;
      length -= take;
      m_buf_pos += take;

      if(m_buf_pos == m_shake_rate) {
         SHA_3::permute(m_state.data());
         m_buf_pos = 0;
      }
   }

   if(length == 0)
      return;

   BOTAN_ASSERT_NOMSG(m_buf_pos == 0);

   while(length >= m_shake_rate) {
      copy_out_le(out, m_shake_rate, m_state.data());
      SHA_3::permute(m_state.data());
      length -= m_shake_rate;
      out += m_shake_rate;
   }

   copy_out_le(m_buffer.data(), m_shake_rate, m_state.data());

   copy_mem(out, &m_buffer[0], length);
   m_buf_pos += length;
}

bool SHAKE_Cipher::has_keying_material() const { return !m_state.empty(); }

void SHAKE_Cipher::key_schedule(const uint8_t key[], size_t length) {
   const size_t SHAKE_BITRATE = m_shake_rate * 8;
   m_state.resize(25);
   m_buffer.resize(m_shake_rate);
   zeroise(m_state);

   const size_t S_pos = SHA_3::absorb(SHAKE_BITRATE, m_state, 0, key, length);
   SHA_3::finish(SHAKE_BITRATE, m_state, S_pos, 0x1F, 0x80);
   copy_out_le(m_buffer.data(), m_buffer.size(), m_state.data());
   m_buf_pos = 0;
}

Key_Length_Specification SHAKE_Cipher::key_spec() const { return Key_Length_Specification(1, 160); }

SHAKE_128_Cipher::SHAKE_128_Cipher() : SHAKE_Cipher((1600 - 256) / 8) {}

SHAKE_256_Cipher::SHAKE_256_Cipher() : SHAKE_Cipher((1600 - 512) / 8) {}

}

1	/*
2	* SHAKE-128 and SHAKE-256
3	* (C) 2016 Jack Lloyd
4	* 2022 René Meusel, Michael Boric - Rohde & Schwarz Cybersecurity
5	*
6	* Botan is released under the Simplified BSD License (see license.txt)
7	*/
8
9	#include <botan/internal/shake_cipher.h>
10
11	#include <botan/exceptn.h>
12	#include <botan/internal/loadstor.h>
13	#include <botan/internal/sha3.h>
14
15	namespace Botan {
16
17	SHAKE_Cipher::SHAKE_Cipher(size_t shake_rate) : m_shake_rate(shake_rate), m_buf_pos(0) {	×
18	BOTAN_ASSERT_NOMSG(shake_rate >= 72 && shake_rate <= 168);	×
19	}	×
20
21	void SHAKE_Cipher::clear() {	2,290✔
22	zap(m_state);	2,290✔
23	zap(m_buffer);	2,290✔
24	m_buf_pos = 0;	2,290✔
25	}	2,290✔
26
27	void SHAKE_Cipher::set_iv_bytes(const uint8_t /iv/[], size_t length) {	6,870✔
28	/*
29	* This could be supported in some way (say, by treating iv as
30	* a prefix or suffix of the key).
31	*/
32	if(length != 0) {	6,870✔
33	throw Invalid_IV_Length(name(), length);	4,580✔
34	}
35	}	4,580✔
36
37	size_t SHAKE_Cipher::buffer_size() const { return m_shake_rate; }	2,290✔
38
39	void SHAKE_Cipher::seek(uint64_t /offset/) { throw Not_Implemented("SHAKE_Cipher::seek"); }	2,290✔
40
41	void SHAKE_Cipher::cipher_bytes(const uint8_t in[], uint8_t out[], size_t length) {	9,160✔
42	assert_key_material_set();	9,160✔
43
44	while(length >= m_shake_rate - m_buf_pos) {	13,832✔
45	xor_buf(out, in, &m_buffer[m_buf_pos], m_shake_rate - m_buf_pos);	92✔
46	length -= (m_shake_rate - m_buf_pos);	92✔
47	in += (m_shake_rate - m_buf_pos);	92✔
48	out += (m_shake_rate - m_buf_pos);	92✔
49
50	SHA_3::permute(m_state.data());	92✔
51	copy_out_le(m_buffer.data(), m_shake_rate, m_state.data());	92✔
52
53	m_buf_pos = 0;	92✔
54	}
55	xor_buf(out, in, &m_buffer[m_buf_pos], length);	4,580✔
56	m_buf_pos += length;	4,580✔
57	}	4,580✔
58
59	void SHAKE_Cipher::generate_keystream(uint8_t out[], size_t length) {	124,113✔
60	assert_key_material_set();	124,113✔
61
62	if(m_buf_pos > 0) {	124,113✔
63	const size_t take = std::min(length, m_shake_rate - m_buf_pos);	18,810✔
64	copy_mem(out, &m_buffer[m_buf_pos], take);	18,810✔
65	out += take;	18,810✔
66	length -= take;	18,810✔
67	m_buf_pos += take;	18,810✔
68
69	if(m_buf_pos == m_shake_rate) {	18,810✔
70	SHA_3::permute(m_state.data());	17,958✔
71	m_buf_pos = 0;	17,958✔
72	}
73	}
74
75	if(length == 0)	124,113✔
76	return;
77
78	BOTAN_ASSERT_NOMSG(m_buf_pos == 0);	123,248✔
79
80	while(length >= m_shake_rate) {	566,494✔
81	copy_out_le(out, m_shake_rate, m_state.data());	443,246✔
82	SHA_3::permute(m_state.data());	443,246✔
83	length -= m_shake_rate;	443,246✔
84	out += m_shake_rate;	443,246✔
85	}
86
87	copy_out_le(m_buffer.data(), m_shake_rate, m_state.data());	123,248✔
88
89	copy_mem(out, &m_buffer[0], length);	123,248✔
90	m_buf_pos += length;	123,248✔
91	}
92
93	bool SHAKE_Cipher::has_keying_material() const { return !m_state.empty(); }	142,433✔
94
95	void SHAKE_Cipher::key_schedule(const uint8_t key[], size_t length) {	109,631✔
96	const size_t SHAKE_BITRATE = m_shake_rate * 8;	109,631✔
97	m_state.resize(25);	109,631✔
98	m_buffer.resize(m_shake_rate);	109,631✔
99	zeroise(m_state);	109,631✔
100
101	const size_t S_pos = SHA_3::absorb(SHAKE_BITRATE, m_state, 0, key, length);	109,631✔
102	SHA_3::finish(SHAKE_BITRATE, m_state, S_pos, 0x1F, 0x80);	109,631✔
103	copy_out_le(m_buffer.data(), m_buffer.size(), m_state.data());	109,631✔
104	m_buf_pos = 0;	109,631✔
105	}	109,631✔
106
107	Key_Length_Specification SHAKE_Cipher::key_spec() const { return Key_Length_Specification(1, 160); }	114,211✔
108
109	SHAKE_128_Cipher::SHAKE_128_Cipher() : SHAKE_Cipher((1600 - 256) / 8) {}	73,414✔
110
111	SHAKE_256_Cipher::SHAKE_256_Cipher() : SHAKE_Cipher((1600 - 512) / 8) {}	25,885✔
112
113	}

randombit / botan / 5079590438

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