8#include <botan/internal/lion.h>
10#include <botan/exceptn.h>
11#include <botan/mem_ops.h>
12#include <botan/internal/fmt.h>
22 const size_t LEFT_SIZE = left_size();
23 const size_t RIGHT_SIZE = right_size();
26 uint8_t* buffer = buffer_vec.data();
28 for(
size_t i = 0; i != blocks; ++i) {
29 xor_buf(buffer, in, m_key1.data(), LEFT_SIZE);
30 m_cipher->set_key(buffer, LEFT_SIZE);
31 m_cipher->cipher(in + LEFT_SIZE, out + LEFT_SIZE, RIGHT_SIZE);
33 m_hash->update(out + LEFT_SIZE, RIGHT_SIZE);
34 m_hash->final(buffer);
35 xor_buf(out, in, buffer, LEFT_SIZE);
37 xor_buf(buffer, out, m_key2.data(), LEFT_SIZE);
38 m_cipher->set_key(buffer, LEFT_SIZE);
39 m_cipher->cipher1(out + LEFT_SIZE, RIGHT_SIZE);
52 const size_t LEFT_SIZE = left_size();
53 const size_t RIGHT_SIZE = right_size();
56 uint8_t* buffer = buffer_vec.data();
58 for(
size_t i = 0; i != blocks; ++i) {
59 xor_buf(buffer, in, m_key2.data(), LEFT_SIZE);
60 m_cipher->set_key(buffer, LEFT_SIZE);
61 m_cipher->cipher(in + LEFT_SIZE, out + LEFT_SIZE, RIGHT_SIZE);
63 m_hash->update(out + LEFT_SIZE, RIGHT_SIZE);
64 m_hash->final(buffer);
65 xor_buf(out, in, buffer, LEFT_SIZE);
67 xor_buf(buffer, out, m_key1.data(), LEFT_SIZE);
68 m_cipher->set_key(buffer, LEFT_SIZE);
69 m_cipher->cipher1(out + LEFT_SIZE, RIGHT_SIZE);
77 return !m_key1.empty() && !m_key2.empty();
83void Lion::key_schedule(std::span<const uint8_t> key) {
86 const size_t half = key.size() / 2;
88 m_key1.resize(left_size());
89 m_key2.resize(left_size());
92 copy_mem(m_key1.data(), key.data(), half);
93 copy_mem(m_key2.data(), key.subspan(half, half).data(), half);
100 return fmt(
"Lion({},{},{})", m_hash->name(), m_cipher->name(),
block_size());
104 return std::make_unique<Lion>(m_hash->new_object(), m_cipher->new_object(),
block_size());
120Lion::Lion(std::unique_ptr<HashFunction> hash, std::unique_ptr<StreamCipher> cipher,
size_t bs) :
121 m_block_size(std::max<size_t>(2 * hash->output_length() + 1, bs)),
122 m_hash(std::move(hash)),
123 m_cipher(std::move(cipher)) {
124 if(2 * left_size() + 1 > m_block_size) {
128 if(!m_cipher->valid_keylength(left_size())) {
129 throw Invalid_Argument(
fmt(
"Lion does not support combining {} and {}", m_cipher->name(), m_hash->name()));
120Lion::Lion(std::unique_ptr<HashFunction> hash, std::unique_ptr<StreamCipher> cipher,
size_t bs) : {
…}
std::unique_ptr< BlockCipher > new_object() const override
bool has_keying_material() const override
size_t block_size() const override
Lion(std::unique_ptr< HashFunction > hash, std::unique_ptr< StreamCipher > cipher, size_t block_size)
std::string name() const override
void decrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const override
void encrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const override
void assert_key_material_set() const
void zap(std::vector< T, Alloc > &vec)
std::string fmt(std::string_view format, const T &... args)
constexpr void xor_buf(ranges::contiguous_output_range< uint8_t > auto &&out, ranges::contiguous_range< uint8_t > auto &&in)
std::vector< T, secure_allocator< T > > secure_vector
constexpr void copy_mem(T *out, const T *in, size_t n)
constexpr void clear_mem(T *ptr, size_t n)