randombit/botan | Build 21753596263 | source/src/lib/modes/cfb/cfb.cpp | Coveralls

17

CFB_Mode::CFB_Mode(std::unique_ptr<BlockCipher> cipher, size_t feedback_bits) :

705✔

18

      m_cipher(std::move(cipher)),

705✔

19

      m_block_size(m_cipher->block_size()),

705✔

20

      m_feedback_bytes(feedback_bits != 0 ? feedback_bits / 8 : m_block_size) {

705✔

21

   if(feedback_bits % 8 != 0 || feedback() > m_block_size) {

705✔

24

705✔

26

void CFB_Mode::clear() {

158✔

27

   m_cipher->clear();

158✔

28

   m_keystream.clear();

158✔

29

   reset();

158✔

30

158✔

32

void CFB_Mode::reset() {

474✔

33

   m_state.clear();

474✔

34

   zeroise(m_keystream);

474✔

35

474✔

37

std::string CFB_Mode::name() const {

948✔

38

   if(feedback() == cipher().block_size()) {

948✔

39

      return fmt("{}/CFB", cipher().name());

396✔

41

      return fmt("{}/CFB({})", cipher().name(), feedback() * 8);

552✔

45

size_t CFB_Mode::output_length(size_t input_length) const {

158✔

46

   return input_length;

158✔

49

size_t CFB_Mode::update_granularity() const {

553✔

50

   return feedback();

553✔

53

size_t CFB_Mode::ideal_granularity() const {

478✔

55

   return 16 * feedback();

478✔

58

size_t CFB_Mode::minimum_final_size() const {

160✔

59

   return 0;

160✔

62

Key_Length_Specification CFB_Mode::key_spec() const {

1,090✔

63

   return cipher().key_spec();

1,090✔

66

size_t CFB_Mode::default_nonce_length() const {

466✔

67

   return block_size();

466✔

70

bool CFB_Mode::valid_nonce_length(size_t n) const {

1,880✔

71

   return (n == 0 || n == block_size());

1,850✔

74

bool CFB_Mode::has_keying_material() const {

5,042✔

75

   return m_cipher->has_keying_material();

5,042✔

78

void CFB_Mode::key_schedule(std::span<const uint8_t> key) {

784✔

79

   m_cipher->set_key(key);

784✔

80

   m_keystream.resize(m_cipher->block_size());

784✔

81

784✔

83

void CFB_Mode::start_msg(const uint8_t nonce[], size_t nonce_len) {

1,538✔

84

   if(!valid_nonce_length(nonce_len)) {

1,538✔

85

      throw Invalid_IV_Length(name(), nonce_len);

316✔

88

   assert_key_material_set();

1,380✔

90

   if(nonce_len == 0) {

1,380✔

91

      if(m_state.empty()) {

30✔

96

      m_state.assign(nonce, nonce + nonce_len);

1,350✔

97

      cipher().encrypt(m_state, m_keystream);

1,350✔

98

      m_keystream_pos = 0;

1,350✔

100

1,380✔

102

void CFB_Mode::shift_register() {

6,413✔

103

   const size_t shift = feedback();

6,413✔

104

   const size_t carryover = block_size() - shift;

6,413✔

106

   if(carryover > 0) {

6,413✔

107

      copy_mem(m_state.data(), &m_state[shift], carryover);

3,104✔

109

   copy_mem(&m_state[carryover], m_keystream.data(), shift);

6,413✔

110

   cipher().encrypt(m_state, m_keystream);

6,413✔

111

   m_keystream_pos = 0;

6,413✔

112

6,413✔

114

size_t CFB_Encryption::process_msg(uint8_t buf[], size_t sz) {

1,542✔

115

   assert_key_material_set();

1,542✔

116

   BOTAN_STATE_CHECK(m_state.empty() == false);

1,226✔

118

   const size_t shift = feedback();

1,068✔

120

   size_t left = sz;

1,068✔

122

   if(m_keystream_pos != 0) {

1,068✔

123

      const size_t take = std::min<size_t>(left, shift - m_keystream_pos);

13✔

125

      xor_buf(m_keystream.data() + m_keystream_pos, buf, take);

13✔

126

      copy_mem(buf, m_keystream.data() + m_keystream_pos, take);

13✔

128

      m_keystream_pos += take;

13✔

129

      left -= take;

13✔

130

      buf += take;

13✔

132

      if(m_keystream_pos == shift) {

13✔

133

         shift_register();

10✔

137

   while(left >= shift) {

3,757✔

138

      xor_buf(m_keystream.data(), buf, shift);

2,689✔

139

      copy_mem(buf, m_keystream.data(), shift);

2,689✔

141

      left -= shift;

2,689✔

142

      buf += shift;

2,689✔

143

      shift_register();

2,689✔

146

   if(left > 0) {

1,068✔

147

      xor_buf(m_keystream.data(), buf, left);

118✔

148

      copy_mem(buf, m_keystream.data(), left);

118✔

149

      m_keystream_pos += left;

118✔

152

   return sz;

1,068✔

155

void CFB_Encryption::finish_msg(secure_vector<uint8_t>& buffer, size_t offset) {

616✔

156

   update(buffer, offset);

616✔

157

379✔

161

inline void xor_copy(uint8_t buf[], uint8_t key_buf[], size_t len) {

3,943✔

162

   for(size_t i = 0; i != len; ++i) {

40,400✔

163

      const uint8_t k = key_buf[i];

36,457✔

164

      key_buf[i] = buf[i];

36,457✔

165

      buf[i] ^= k;

36,457✔

171

size_t CFB_Decryption::process_msg(uint8_t buf[], size_t sz) {

1,646✔

172

   assert_key_material_set();

1,646✔

173

   BOTAN_STATE_CHECK(m_state.empty() == false);

1,330✔

175

   const size_t shift = feedback();

1,172✔

177

   size_t left = sz;

1,172✔

179

   if(m_keystream_pos != 0) {

1,172✔

180

      const size_t take = std::min<size_t>(left, shift - m_keystream_pos);

13✔

182

      xor_copy(buf, m_keystream.data() + m_keystream_pos, take);

13✔

184

      m_keystream_pos += take;

13✔

185

      left -= take;

13✔

186

      buf += take;

13✔

188

      if(m_keystream_pos == shift) {

13✔

189

         shift_register();

10✔

193

   while(left >= shift) {

4,876✔

194

      xor_copy(buf, m_keystream.data(), shift);

3,704✔

195

      left -= shift;

3,704✔

196

      buf += shift;

3,704✔

197

      shift_register();

3,704✔

200

   if(left > 0) {

1,172✔

201

      xor_copy(buf, m_keystream.data(), left);

226✔

202

      m_keystream_pos += left;

226✔

205

   return sz;

1,172✔

208

void CFB_Decryption::finish_msg(secure_vector<uint8_t>& buffer, size_t offset) {

616✔

209

   update(buffer, offset);

616✔

210

379✔

randombit / botan / 21753596263

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

1	/*
2	* CFB Mode
3	* (C) 1999-2007,2013,2017 Jack Lloyd
4	* (C) 2016 Daniel Neus, Rohde & Schwarz Cybersecurity
5	*
6	* Botan is released under the Simplified BSD License (see license.txt)
7	*/
8
9	#include <botan/internal/cfb.h>
10
11	#include <botan/exceptn.h>
12	#include <botan/mem_ops.h>
13	#include <botan/internal/fmt.h>
14
15	namespace Botan {
16
17	CFB_Mode::CFB_Mode(std::unique_ptr<BlockCipher> cipher, size_t feedback_bits) :	705✔
18	m_cipher(std::move(cipher)),	705✔
19	m_block_size(m_cipher->block_size()),	705✔
20	m_feedback_bytes(feedback_bits != 0 ? feedback_bits / 8 : m_block_size) {	705✔
21	if(feedback_bits % 8 != 0 \|\| feedback() > m_block_size) {	705✔
22	throw Invalid_Argument(fmt("{} does not support feedback bits of {}", name(), feedback_bits));	×
23	}
24	}	705✔
25
26	void CFB_Mode::clear() {	158✔
27	m_cipher->clear();	158✔
28	m_keystream.clear();	158✔
29	reset();	158✔
30	}	158✔
31
32	void CFB_Mode::reset() {	474✔
33	m_state.clear();	474✔
34	zeroise(m_keystream);	474✔
35	}	474✔
36
37	std::string CFB_Mode::name() const {	948✔
38	if(feedback() == cipher().block_size()) {	948✔
39	return fmt("{}/CFB", cipher().name());	396✔
40	} else {
41	return fmt("{}/CFB({})", cipher().name(), feedback() * 8);	552✔
42	}
43	}
44
45	size_t CFB_Mode::output_length(size_t input_length) const {	158✔
46	return input_length;	158✔
47	}
48
49	size_t CFB_Mode::update_granularity() const {	553✔
50	return feedback();	553✔
51	}
52
53	size_t CFB_Mode::ideal_granularity() const {	478✔
54	// Multiplier here is arbitrary
55	return 16 * feedback();	478✔
56	}
57
58	size_t CFB_Mode::minimum_final_size() const {	160✔
59	return 0;	160✔
60	}
61
62	Key_Length_Specification CFB_Mode::key_spec() const {	1,090✔
63	return cipher().key_spec();	1,090✔
64	}
65
66	size_t CFB_Mode::default_nonce_length() const {	466✔
67	return block_size();	466✔
68	}
69
70	bool CFB_Mode::valid_nonce_length(size_t n) const {	1,880✔
71	return (n == 0 \|\| n == block_size());	1,850✔
72	}
73
74	bool CFB_Mode::has_keying_material() const {	5,042✔
75	return m_cipher->has_keying_material();	5,042✔
76	}
77
78	void CFB_Mode::key_schedule(std::span<const uint8_t> key) {	784✔
79	m_cipher->set_key(key);	784✔
80	m_keystream.resize(m_cipher->block_size());	784✔
81	}	784✔
82
83	void CFB_Mode::start_msg(const uint8_t nonce[], size_t nonce_len) {	1,538✔
84	if(!valid_nonce_length(nonce_len)) {	1,538✔
85	throw Invalid_IV_Length(name(), nonce_len);	316✔
86	}
87
88	assert_key_material_set();	1,380✔
89
90	if(nonce_len == 0) {	1,380✔
91	if(m_state.empty()) {	30✔
92	throw Invalid_State("CFB requires a non-empty initial nonce");	×
93	}
94	// No reason to encrypt state->keystream_buf, because no change
95	} else {
96	m_state.assign(nonce, nonce + nonce_len);	1,350✔
97	cipher().encrypt(m_state, m_keystream);	1,350✔
98	m_keystream_pos = 0;	1,350✔
99	}
100	}	1,380✔
101
102	void CFB_Mode::shift_register() {	6,413✔
103	const size_t shift = feedback();	6,413✔
104	const size_t carryover = block_size() - shift;	6,413✔
105
106	if(carryover > 0) {	6,413✔
107	copy_mem(m_state.data(), &m_state[shift], carryover);	3,104✔
108	}
109	copy_mem(&m_state[carryover], m_keystream.data(), shift);	6,413✔
110	cipher().encrypt(m_state, m_keystream);	6,413✔
111	m_keystream_pos = 0;	6,413✔
112	}	6,413✔
113
114	size_t CFB_Encryption::process_msg(uint8_t buf[], size_t sz) {	1,542✔
115	assert_key_material_set();	1,542✔
116	BOTAN_STATE_CHECK(m_state.empty() == false);	1,226✔
117
118	const size_t shift = feedback();	1,068✔
119
120	size_t left = sz;	1,068✔
121
122	if(m_keystream_pos != 0) {	1,068✔
123	const size_t take = std::min<size_t>(left, shift - m_keystream_pos);	13✔
124
125	xor_buf(m_keystream.data() + m_keystream_pos, buf, take);	13✔
126	copy_mem(buf, m_keystream.data() + m_keystream_pos, take);	13✔
127
128	m_keystream_pos += take;	13✔
129	left -= take;	13✔
130	buf += take;	13✔
131
132	if(m_keystream_pos == shift) {	13✔
133	shift_register();	10✔
134	}
135	}
136
137	while(left >= shift) {	3,757✔
138	xor_buf(m_keystream.data(), buf, shift);	2,689✔
139	copy_mem(buf, m_keystream.data(), shift);	2,689✔
140
141	left -= shift;	2,689✔
142	buf += shift;	2,689✔
143	shift_register();	2,689✔
144	}
145
146	if(left > 0) {	1,068✔
147	xor_buf(m_keystream.data(), buf, left);	118✔
148	copy_mem(buf, m_keystream.data(), left);	118✔
149	m_keystream_pos += left;	118✔
150	}
151
152	return sz;	1,068✔
153	}
154
155	void CFB_Encryption::finish_msg(secure_vector<uint8_t>& buffer, size_t offset) {	616✔
156	update(buffer, offset);	616✔
157	}	379✔
158
159	namespace {
160
161	inline void xor_copy(uint8_t buf[], uint8_t key_buf[], size_t len) {	3,943✔
162	for(size_t i = 0; i != len; ++i) {	40,400✔
163	const uint8_t k = key_buf[i];	36,457✔
164	key_buf[i] = buf[i];	36,457✔
165	buf[i] ^= k;	36,457✔
166	}
167	}
168
169	} // namespace
170
171	size_t CFB_Decryption::process_msg(uint8_t buf[], size_t sz) {	1,646✔
172	assert_key_material_set();	1,646✔
173	BOTAN_STATE_CHECK(m_state.empty() == false);	1,330✔
174
175	const size_t shift = feedback();	1,172✔
176
177	size_t left = sz;	1,172✔
178
179	if(m_keystream_pos != 0) {	1,172✔
180	const size_t take = std::min<size_t>(left, shift - m_keystream_pos);	13✔
181
182	xor_copy(buf, m_keystream.data() + m_keystream_pos, take);	13✔
183
184	m_keystream_pos += take;	13✔
185	left -= take;	13✔
186	buf += take;	13✔
187
188	if(m_keystream_pos == shift) {	13✔
189	shift_register();	10✔
190	}
191	}
192
193	while(left >= shift) {	4,876✔
194	xor_copy(buf, m_keystream.data(), shift);	3,704✔
195	left -= shift;	3,704✔
196	buf += shift;	3,704✔
197	shift_register();	3,704✔
198	}
199
200	if(left > 0) {	1,172✔
201	xor_copy(buf, m_keystream.data(), left);	226✔
202	m_keystream_pos += left;	226✔
203	}
204
205	return sz;	1,172✔
206	}
207
208	void CFB_Decryption::finish_msg(secure_vector<uint8_t>& buffer, size_t offset) {	616✔
209	update(buffer, offset);	616✔
210	}	379✔
211
212	} // namespace Botan

randombit / botan / 21753596263

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