/src/botan/src/lib/stream/ctr/ctr.cpp
Line | Count | Source (jump to first uncovered line) |
1 | | /* |
2 | | * Counter mode |
3 | | * (C) 1999-2011,2014 Jack Lloyd |
4 | | * |
5 | | * Botan is released under the Simplified BSD License (see license.txt) |
6 | | */ |
7 | | |
8 | | #include <botan/internal/ctr.h> |
9 | | |
10 | | #include <botan/exceptn.h> |
11 | | #include <botan/internal/bit_ops.h> |
12 | | #include <botan/internal/fmt.h> |
13 | | #include <botan/internal/loadstor.h> |
14 | | |
15 | | namespace Botan { |
16 | | |
17 | | CTR_BE::CTR_BE(std::unique_ptr<BlockCipher> cipher) : |
18 | | m_cipher(std::move(cipher)), |
19 | | m_block_size(m_cipher->block_size()), |
20 | | m_ctr_size(m_block_size), |
21 | | m_ctr_blocks(m_cipher->parallel_bytes() / m_block_size), |
22 | | m_counter(m_cipher->parallel_bytes()), |
23 | | m_pad(m_counter.size()), |
24 | 0 | m_pad_pos(0) {} |
25 | | |
26 | | CTR_BE::CTR_BE(std::unique_ptr<BlockCipher> cipher, size_t ctr_size) : |
27 | | m_cipher(std::move(cipher)), |
28 | | m_block_size(m_cipher->block_size()), |
29 | | m_ctr_size(ctr_size), |
30 | | m_ctr_blocks(m_cipher->parallel_bytes() / m_block_size), |
31 | | m_counter(m_cipher->parallel_bytes()), |
32 | | m_pad(m_counter.size()), |
33 | 0 | m_pad_pos(0) { |
34 | 0 | BOTAN_ARG_CHECK(m_ctr_size >= 4 && m_ctr_size <= m_block_size, "Invalid CTR-BE counter size"); |
35 | 0 | } |
36 | | |
37 | 0 | void CTR_BE::clear() { |
38 | 0 | m_cipher->clear(); |
39 | 0 | zeroise(m_pad); |
40 | 0 | zeroise(m_counter); |
41 | 0 | zap(m_iv); |
42 | 0 | m_pad_pos = 0; |
43 | 0 | } |
44 | | |
45 | 0 | size_t CTR_BE::default_iv_length() const { return m_block_size; } |
46 | | |
47 | 0 | bool CTR_BE::valid_iv_length(size_t iv_len) const { return (iv_len <= m_block_size); } |
48 | | |
49 | 0 | size_t CTR_BE::buffer_size() const { return m_pad.size(); } |
50 | | |
51 | 0 | Key_Length_Specification CTR_BE::key_spec() const { return m_cipher->key_spec(); } |
52 | | |
53 | 0 | std::unique_ptr<StreamCipher> CTR_BE::new_object() const { |
54 | 0 | return std::make_unique<CTR_BE>(m_cipher->new_object(), m_ctr_size); |
55 | 0 | } |
56 | | |
57 | 0 | bool CTR_BE::has_keying_material() const { return m_cipher->has_keying_material(); } |
58 | | |
59 | 0 | void CTR_BE::key_schedule(const uint8_t key[], size_t key_len) { |
60 | 0 | m_cipher->set_key(key, key_len); |
61 | | |
62 | | // Set a default all-zeros IV |
63 | 0 | set_iv(nullptr, 0); |
64 | 0 | } |
65 | | |
66 | 0 | std::string CTR_BE::name() const { |
67 | 0 | if(m_ctr_size == m_block_size) { |
68 | 0 | return fmt("CTR-BE({})", m_cipher->name()); |
69 | 0 | } else { |
70 | 0 | return fmt("CTR-BE({},{})", m_cipher->name(), m_ctr_size); |
71 | 0 | } |
72 | 0 | } |
73 | | |
74 | 0 | void CTR_BE::cipher_bytes(const uint8_t in[], uint8_t out[], size_t length) { |
75 | 0 | assert_key_material_set(); |
76 | |
|
77 | 0 | const uint8_t* pad_bits = &m_pad[0]; |
78 | 0 | const size_t pad_size = m_pad.size(); |
79 | |
|
80 | 0 | if(m_pad_pos > 0) { |
81 | 0 | const size_t avail = pad_size - m_pad_pos; |
82 | 0 | const size_t take = std::min(length, avail); |
83 | 0 | xor_buf(out, in, pad_bits + m_pad_pos, take); |
84 | 0 | length -= take; |
85 | 0 | in += take; |
86 | 0 | out += take; |
87 | 0 | m_pad_pos += take; |
88 | |
|
89 | 0 | if(take == avail) { |
90 | 0 | add_counter(m_ctr_blocks); |
91 | 0 | m_cipher->encrypt_n(m_counter.data(), m_pad.data(), m_ctr_blocks); |
92 | 0 | m_pad_pos = 0; |
93 | 0 | } |
94 | 0 | } |
95 | |
|
96 | 0 | while(length >= pad_size) { |
97 | 0 | xor_buf(out, in, pad_bits, pad_size); |
98 | 0 | length -= pad_size; |
99 | 0 | in += pad_size; |
100 | 0 | out += pad_size; |
101 | |
|
102 | 0 | add_counter(m_ctr_blocks); |
103 | 0 | m_cipher->encrypt_n(m_counter.data(), m_pad.data(), m_ctr_blocks); |
104 | 0 | } |
105 | |
|
106 | 0 | xor_buf(out, in, pad_bits, length); |
107 | 0 | m_pad_pos += length; |
108 | 0 | } |
109 | | |
110 | 0 | void CTR_BE::generate_keystream(uint8_t out[], size_t length) { |
111 | 0 | assert_key_material_set(); |
112 | |
|
113 | 0 | const size_t avail = m_pad.size() - m_pad_pos; |
114 | 0 | const size_t take = std::min(length, avail); |
115 | 0 | copy_mem(out, &m_pad[m_pad_pos], take); |
116 | 0 | length -= take; |
117 | 0 | out += take; |
118 | 0 | m_pad_pos += take; |
119 | |
|
120 | 0 | while(length >= m_pad.size()) { |
121 | 0 | add_counter(m_ctr_blocks); |
122 | 0 | m_cipher->encrypt_n(m_counter.data(), out, m_ctr_blocks); |
123 | |
|
124 | 0 | length -= m_pad.size(); |
125 | 0 | out += m_pad.size(); |
126 | 0 | } |
127 | |
|
128 | 0 | if(m_pad_pos == m_pad.size()) { |
129 | 0 | add_counter(m_ctr_blocks); |
130 | 0 | m_cipher->encrypt_n(m_counter.data(), m_pad.data(), m_ctr_blocks); |
131 | 0 | m_pad_pos = 0; |
132 | 0 | } |
133 | |
|
134 | 0 | copy_mem(out, &m_pad[0], length); |
135 | 0 | m_pad_pos += length; |
136 | 0 | BOTAN_ASSERT_NOMSG(m_pad_pos < m_pad.size()); |
137 | 0 | } |
138 | | |
139 | 0 | void CTR_BE::set_iv_bytes(const uint8_t iv[], size_t iv_len) { |
140 | 0 | if(!valid_iv_length(iv_len)) { |
141 | 0 | throw Invalid_IV_Length(name(), iv_len); |
142 | 0 | } |
143 | | |
144 | 0 | m_iv.resize(m_block_size); |
145 | 0 | zeroise(m_iv); |
146 | 0 | buffer_insert(m_iv, 0, iv, iv_len); |
147 | |
|
148 | 0 | seek(0); |
149 | 0 | } |
150 | | |
151 | 0 | void CTR_BE::add_counter(const uint64_t counter) { |
152 | 0 | const size_t ctr_size = m_ctr_size; |
153 | 0 | const size_t ctr_blocks = m_ctr_blocks; |
154 | 0 | const size_t BS = m_block_size; |
155 | |
|
156 | 0 | if(ctr_size == 4) { |
157 | 0 | const size_t off = (BS - 4); |
158 | 0 | const uint32_t low32 = static_cast<uint32_t>(counter + load_be<uint32_t>(&m_counter[off], 0)); |
159 | |
|
160 | 0 | for(size_t i = 0; i != ctr_blocks; ++i) { |
161 | 0 | store_be(uint32_t(low32 + i), &m_counter[i * BS + off]); |
162 | 0 | } |
163 | 0 | } else if(ctr_size == 8) { |
164 | 0 | const size_t off = (BS - 8); |
165 | 0 | const uint64_t low64 = counter + load_be<uint64_t>(&m_counter[off], 0); |
166 | |
|
167 | 0 | for(size_t i = 0; i != ctr_blocks; ++i) { |
168 | 0 | store_be(uint64_t(low64 + i), &m_counter[i * BS + off]); |
169 | 0 | } |
170 | 0 | } else if(ctr_size == 16) { |
171 | 0 | const size_t off = (BS - 16); |
172 | 0 | uint64_t b0 = load_be<uint64_t>(&m_counter[off], 0); |
173 | 0 | uint64_t b1 = load_be<uint64_t>(&m_counter[off], 1); |
174 | 0 | b1 += counter; |
175 | 0 | b0 += (b1 < counter) ? 1 : 0; // carry |
176 | |
|
177 | 0 | for(size_t i = 0; i != ctr_blocks; ++i) { |
178 | 0 | store_be(b0, &m_counter[i * BS + off]); |
179 | 0 | store_be(b1, &m_counter[i * BS + off + 8]); |
180 | 0 | b1 += 1; |
181 | 0 | b0 += (b1 == 0); // carry |
182 | 0 | } |
183 | 0 | } else { |
184 | 0 | for(size_t i = 0; i != ctr_blocks; ++i) { |
185 | 0 | uint64_t local_counter = counter; |
186 | 0 | uint16_t carry = static_cast<uint8_t>(local_counter); |
187 | 0 | for(size_t j = 0; (carry || local_counter) && j != ctr_size; ++j) { |
188 | 0 | const size_t off = i * BS + (BS - 1 - j); |
189 | 0 | const uint16_t cnt = static_cast<uint16_t>(m_counter[off]) + carry; |
190 | 0 | m_counter[off] = static_cast<uint8_t>(cnt); |
191 | 0 | local_counter = (local_counter >> 8); |
192 | 0 | carry = (cnt >> 8) + static_cast<uint8_t>(local_counter); |
193 | 0 | } |
194 | 0 | } |
195 | 0 | } |
196 | 0 | } |
197 | | |
198 | 0 | void CTR_BE::seek(uint64_t offset) { |
199 | 0 | assert_key_material_set(); |
200 | |
|
201 | 0 | const uint64_t base_counter = m_ctr_blocks * (offset / m_counter.size()); |
202 | |
|
203 | 0 | zeroise(m_counter); |
204 | 0 | buffer_insert(m_counter, 0, m_iv); |
205 | |
|
206 | 0 | const size_t BS = m_block_size; |
207 | | |
208 | | // Set m_counter blocks to IV, IV + 1, ... IV + n |
209 | |
|
210 | 0 | if(m_ctr_size == 4 && BS >= 8) { |
211 | 0 | const uint32_t low32 = load_be<uint32_t>(&m_counter[BS - 4], 0); |
212 | |
|
213 | 0 | if(m_ctr_blocks >= 4 && is_power_of_2(m_ctr_blocks)) { |
214 | 0 | size_t written = 1; |
215 | 0 | while(written < m_ctr_blocks) { |
216 | 0 | copy_mem(&m_counter[written * BS], &m_counter[0], BS * written); |
217 | 0 | written *= 2; |
218 | 0 | } |
219 | 0 | } else { |
220 | 0 | for(size_t i = 1; i != m_ctr_blocks; ++i) { |
221 | 0 | copy_mem(&m_counter[i * BS], &m_counter[0], BS - 4); |
222 | 0 | } |
223 | 0 | } |
224 | |
|
225 | 0 | for(size_t i = 1; i != m_ctr_blocks; ++i) { |
226 | 0 | const uint32_t c = static_cast<uint32_t>(low32 + i); |
227 | 0 | store_be(c, &m_counter[(BS - 4) + i * BS]); |
228 | 0 | } |
229 | 0 | } else { |
230 | | // do everything sequentially: |
231 | 0 | for(size_t i = 1; i != m_ctr_blocks; ++i) { |
232 | 0 | buffer_insert(m_counter, i * BS, &m_counter[(i - 1) * BS], BS); |
233 | |
|
234 | 0 | for(size_t j = 0; j != m_ctr_size; ++j) { |
235 | 0 | if(++m_counter[i * BS + (BS - 1 - j)]) { |
236 | 0 | break; |
237 | 0 | } |
238 | 0 | } |
239 | 0 | } |
240 | 0 | } |
241 | |
|
242 | 0 | if(base_counter > 0) { |
243 | 0 | add_counter(base_counter); |
244 | 0 | } |
245 | |
|
246 | 0 | m_cipher->encrypt_n(m_counter.data(), m_pad.data(), m_ctr_blocks); |
247 | 0 | m_pad_pos = offset % m_counter.size(); |
248 | 0 | } |
249 | | } // namespace Botan |