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

15

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

399✔

16

      m_cipher(std::move(cipher)),

399✔

17

      m_block_size(m_cipher->block_size()),

399✔

18

      m_feedback_bytes(feedback_bits ? feedback_bits / 8 : m_block_size) {

399✔

19

   if(feedback_bits % 8 || feedback() > m_block_size) {

399✔

22

399✔

24

void CFB_Mode::clear() {

158✔

25

   m_cipher->clear();

158✔

26

   m_keystream.clear();

158✔

27

   reset();

158✔

28

158✔

30

void CFB_Mode::reset() {

474✔

31

   m_state.clear();

474✔

32

   zeroise(m_keystream);

474✔

33

474✔

35

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

948✔

36

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

948✔

37

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

396✔

39

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

552✔

42

size_t CFB_Mode::output_length(size_t input_length) const { return input_length; }

158✔

44

size_t CFB_Mode::update_granularity() const { return feedback(); }

553✔

46

size_t CFB_Mode::ideal_granularity() const {

478✔

48

   return 16 * feedback();

478✔

51

size_t CFB_Mode::minimum_final_size() const { return 0; }

160✔

53

Key_Length_Specification CFB_Mode::key_spec() const { return cipher().key_spec(); }

478✔

55

size_t CFB_Mode::default_nonce_length() const { return block_size(); }

160✔

57

bool CFB_Mode::valid_nonce_length(size_t n) const { return (n == 0 || n == block_size()); }

1,544✔

59

bool CFB_Mode::has_keying_material() const { return m_cipher->has_keying_material(); }

4,430✔

61

void CFB_Mode::key_schedule(const uint8_t key[], size_t length) {

478✔

62

   m_cipher->set_key(key, length);

478✔

63

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

478✔

64

478✔

66

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

1,232✔

67

   if(!valid_nonce_length(nonce_len))

1,232✔

68

      throw Invalid_IV_Length(name(), nonce_len);

316✔

70

   assert_key_material_set();

1,074✔

72

   if(nonce_len == 0) {

1,074✔

73

      if(m_state.empty()) {

30✔

78

      m_state.assign(nonce, nonce + nonce_len);

1,044✔

79

      cipher().encrypt(m_state, m_keystream);

1,044✔

80

      m_keystream_pos = 0;

1,044✔

82

1,074✔

84

void CFB_Mode::shift_register() {

3,966✔

85

   const size_t shift = feedback();

3,966✔

86

   const size_t carryover = block_size() - shift;

3,966✔

88

   if(carryover > 0) {

3,966✔

89

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

3,104✔

91

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

3,966✔

92

   cipher().encrypt(m_state, m_keystream);

3,966✔

93

   m_keystream_pos = 0;

3,966✔

94

3,966✔

96

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

1,441✔

97

   assert_key_material_set();

1,441✔

98

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

1,125✔

100

   const size_t shift = feedback();

967✔

102

   size_t left = sz;

967✔

104

   if(m_keystream_pos != 0) {

967✔

105

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

13✔

107

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

13✔

108

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

13✔

110

      m_keystream_pos += take;

13✔

111

      left -= take;

13✔

112

      buf += take;

13✔

114

      if(m_keystream_pos == shift) {

13✔

115

         shift_register();

10✔

119

   while(left >= shift) {

2,940✔

120

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

1,973✔

121

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

1,973✔

123

      left -= shift;

1,973✔

124

      buf += shift;

1,973✔

125

      shift_register();

1,973✔

128

   if(left > 0) {

967✔

129

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

72✔

130

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

72✔

131

      m_keystream_pos += left;

72✔

134

   return sz;

967✔

137

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

616✔

141

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

2,058✔

142

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

9,865✔

143

      uint8_t k = key_buf[i];

7,807✔

144

      key_buf[i] = buf[i];

7,807✔

145

      buf[i] ^= k;

7,807✔

151

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

1,441✔

152

   assert_key_material_set();

1,441✔

153

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

1,125✔

155

   const size_t shift = feedback();

967✔

157

   size_t left = sz;

967✔

159

   if(m_keystream_pos != 0) {

967✔

160

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

13✔

162

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

13✔

164

      m_keystream_pos += take;

13✔

165

      left -= take;

13✔

166

      buf += take;

13✔

168

      if(m_keystream_pos == shift) {

13✔

169

         shift_register();

10✔

173

   while(left >= shift) {

2,940✔

174

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

1,973✔

175

      left -= shift;

1,973✔

176

      buf += shift;

1,973✔

177

      shift_register();

1,973✔

180

   if(left > 0) {

967✔

181

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

72✔

182

      m_keystream_pos += left;

72✔

185

   return sz;

967✔

188

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

616✔

randombit / botan / 5079590438

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/internal/fmt.h>
12
13	namespace Botan {
14
15	CFB_Mode::CFB_Mode(std::unique_ptr<BlockCipher> cipher, size_t feedback_bits) :	399✔
16	m_cipher(std::move(cipher)),	399✔
17	m_block_size(m_cipher->block_size()),	399✔
18	m_feedback_bytes(feedback_bits ? feedback_bits / 8 : m_block_size) {	399✔
19	if(feedback_bits % 8 \|\| feedback() > m_block_size) {	399✔
20	throw Invalid_Argument(fmt("{} does not support feedback bits of {}", name(), feedback_bits));	×
21	}
22	}	399✔
23
24	void CFB_Mode::clear() {	158✔
25	m_cipher->clear();	158✔
26	m_keystream.clear();	158✔
27	reset();	158✔
28	}	158✔
29
30	void CFB_Mode::reset() {	474✔
31	m_state.clear();	474✔
32	zeroise(m_keystream);	474✔
33	}	474✔
34
35	std::string CFB_Mode::name() const {	948✔
36	if(feedback() == cipher().block_size())	948✔
37	return fmt("{}/CFB", cipher().name());	396✔
38	else
39	return fmt("{}/CFB({})", cipher().name(), feedback() * 8);	552✔
40	}
41
42	size_t CFB_Mode::output_length(size_t input_length) const { return input_length; }	158✔
43
44	size_t CFB_Mode::update_granularity() const { return feedback(); }	553✔
45
46	size_t CFB_Mode::ideal_granularity() const {	478✔
47	// Multiplier here is arbitrary
48	return 16 * feedback();	478✔
49	}
50
51	size_t CFB_Mode::minimum_final_size() const { return 0; }	160✔
52
53	Key_Length_Specification CFB_Mode::key_spec() const { return cipher().key_spec(); }	478✔
54
55	size_t CFB_Mode::default_nonce_length() const { return block_size(); }	160✔
56
57	bool CFB_Mode::valid_nonce_length(size_t n) const { return (n == 0 \|\| n == block_size()); }	1,544✔
58
59	bool CFB_Mode::has_keying_material() const { return m_cipher->has_keying_material(); }	4,430✔
60
61	void CFB_Mode::key_schedule(const uint8_t key[], size_t length) {	478✔
62	m_cipher->set_key(key, length);	478✔
63	m_keystream.resize(m_cipher->block_size());	478✔
64	}	478✔
65
66	void CFB_Mode::start_msg(const uint8_t nonce[], size_t nonce_len) {	1,232✔
67	if(!valid_nonce_length(nonce_len))	1,232✔
68	throw Invalid_IV_Length(name(), nonce_len);	316✔
69
70	assert_key_material_set();	1,074✔
71
72	if(nonce_len == 0) {	1,074✔
73	if(m_state.empty()) {	30✔
74	throw Invalid_State("CFB requires a non-empty initial nonce");	×
75	}
76	// No reason to encrypt state->keystream_buf, because no change
77	} else {
78	m_state.assign(nonce, nonce + nonce_len);	1,044✔
79	cipher().encrypt(m_state, m_keystream);	1,044✔
80	m_keystream_pos = 0;	1,044✔
81	}
82	}	1,074✔
83
84	void CFB_Mode::shift_register() {	3,966✔
85	const size_t shift = feedback();	3,966✔
86	const size_t carryover = block_size() - shift;	3,966✔
87
88	if(carryover > 0) {	3,966✔
89	copy_mem(m_state.data(), &m_state[shift], carryover);	3,104✔
90	}
91	copy_mem(&m_state[carryover], m_keystream.data(), shift);	3,966✔
92	cipher().encrypt(m_state, m_keystream);	3,966✔
93	m_keystream_pos = 0;	3,966✔
94	}	3,966✔
95
96	size_t CFB_Encryption::process_msg(uint8_t buf[], size_t sz) {	1,441✔
97	assert_key_material_set();	1,441✔
98	BOTAN_STATE_CHECK(m_state.empty() == false);	1,125✔
99
100	const size_t shift = feedback();	967✔
101
102	size_t left = sz;	967✔
103
104	if(m_keystream_pos != 0) {	967✔
105	const size_t take = std::min<size_t>(left, shift - m_keystream_pos);	13✔
106
107	xor_buf(m_keystream.data() + m_keystream_pos, buf, take);	13✔
108	copy_mem(buf, m_keystream.data() + m_keystream_pos, take);	13✔
109
110	m_keystream_pos += take;	13✔
111	left -= take;	13✔
112	buf += take;	13✔
113
114	if(m_keystream_pos == shift) {	13✔
115	shift_register();	10✔
116	}
117	}
118
119	while(left >= shift) {	2,940✔
120	xor_buf(m_keystream.data(), buf, shift);	1,973✔
121	copy_mem(buf, m_keystream.data(), shift);	1,973✔
122
123	left -= shift;	1,973✔
124	buf += shift;	1,973✔
125	shift_register();	1,973✔
126	}
127
128	if(left > 0) {	967✔
129	xor_buf(m_keystream.data(), buf, left);	72✔
130	copy_mem(buf, m_keystream.data(), left);	72✔
131	m_keystream_pos += left;	72✔
132	}
133
134	return sz;	967✔
135	}
136
137	void CFB_Encryption::finish_msg(secure_vector<uint8_t>& buffer, size_t offset) { update(buffer, offset); }	616✔
138
139	namespace {
140
141	inline void xor_copy(uint8_t buf[], uint8_t key_buf[], size_t len) {	2,058✔
142	for(size_t i = 0; i != len; ++i) {	9,865✔
143	uint8_t k = key_buf[i];	7,807✔
144	key_buf[i] = buf[i];	7,807✔
145	buf[i] ^= k;	7,807✔
146	}
147	}
148
149	}
150
151	size_t CFB_Decryption::process_msg(uint8_t buf[], size_t sz) {	1,441✔
152	assert_key_material_set();	1,441✔
153	BOTAN_STATE_CHECK(m_state.empty() == false);	1,125✔
154
155	const size_t shift = feedback();	967✔
156
157	size_t left = sz;	967✔
158
159	if(m_keystream_pos != 0) {	967✔
160	const size_t take = std::min<size_t>(left, shift - m_keystream_pos);	13✔
161
162	xor_copy(buf, m_keystream.data() + m_keystream_pos, take);	13✔
163
164	m_keystream_pos += take;	13✔
165	left -= take;	13✔
166	buf += take;	13✔
167
168	if(m_keystream_pos == shift) {	13✔
169	shift_register();	10✔
170	}
171	}
172
173	while(left >= shift) {	2,940✔
174	xor_copy(buf, m_keystream.data(), shift);	1,973✔
175	left -= shift;	1,973✔
176	buf += shift;	1,973✔
177	shift_register();	1,973✔
178	}
179
180	if(left > 0) {	967✔
181	xor_copy(buf, m_keystream.data(), left);	72✔
182	m_keystream_pos += left;	72✔
183	}
184
185	return sz;	967✔
186	}
187
188	void CFB_Decryption::finish_msg(secure_vector<uint8_t>& buffer, size_t offset) { update(buffer, offset); }	616✔
189
190	}

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