Botan 3.8.1
Crypto and TLS for C&
lion.cpp
Go to the documentation of this file.
1/*
2* Lion
3* (C) 1999-2007,2014 Jack Lloyd
4*
5* Botan is released under the Simplified BSD License (see license.txt)
6*/
7
8#include <botan/internal/lion.h>
9
10#include <botan/exceptn.h>
11#include <botan/mem_ops.h>
12#include <botan/internal/fmt.h>
13
14namespace Botan {
15
16/*
17* Lion Encryption
18*/
19void Lion::encrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const {
21
22 const size_t LEFT_SIZE = left_size();
23 const size_t RIGHT_SIZE = right_size();
24
25 secure_vector<uint8_t> buffer_vec(LEFT_SIZE);
26 uint8_t* buffer = buffer_vec.data();
27
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);
32
33 m_hash->update(out + LEFT_SIZE, RIGHT_SIZE);
34 m_hash->final(buffer);
35 xor_buf(out, in, buffer, LEFT_SIZE);
36
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);
40
41 in += m_block_size;
42 out += m_block_size;
43 }
44}
45
46/*
47* Lion Decryption
48*/
49void Lion::decrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const {
51
52 const size_t LEFT_SIZE = left_size();
53 const size_t RIGHT_SIZE = right_size();
54
55 secure_vector<uint8_t> buffer_vec(LEFT_SIZE);
56 uint8_t* buffer = buffer_vec.data();
57
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);
62
63 m_hash->update(out + LEFT_SIZE, RIGHT_SIZE);
64 m_hash->final(buffer);
65 xor_buf(out, in, buffer, LEFT_SIZE);
66
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);
70
71 in += m_block_size;
72 out += m_block_size;
73 }
74}
75
77 return !m_key1.empty() && !m_key2.empty();
78}
79
80/*
81* Lion Key Schedule
82*/
83void Lion::key_schedule(std::span<const uint8_t> key) {
84 clear();
85
86 const size_t half = key.size() / 2;
87
88 m_key1.resize(left_size());
89 m_key2.resize(left_size());
90 clear_mem(m_key1.data(), m_key1.size());
91 clear_mem(m_key2.data(), m_key2.size());
92 copy_mem(m_key1.data(), key.data(), half);
93 copy_mem(m_key2.data(), key.subspan(half, half).data(), half);
94}
95
96/*
97* Return the name of this type
98*/
99std::string Lion::name() const {
100 return fmt("Lion({},{},{})", m_hash->name(), m_cipher->name(), block_size());
101}
102
103std::unique_ptr<BlockCipher> Lion::new_object() const {
104 return std::make_unique<Lion>(m_hash->new_object(), m_cipher->new_object(), block_size());
105}
106
107/*
108* Clear memory of sensitive data
109*/
111 zap(m_key1);
112 zap(m_key2);
113 m_hash->clear();
114 m_cipher->clear();
115}
116
117/*
118* Lion Constructor
119*/
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) {
125 throw Invalid_Argument(fmt("Block size {} is too small for {}", m_block_size, name()));
126 }
127
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()));
130 }
131}
132
133} // namespace Botan
std::unique_ptr< BlockCipher > new_object() const override
Definition lion.cpp:103
bool has_keying_material() const override
Definition lion.cpp:76
void clear() override
Definition lion.cpp:110
size_t block_size() const override
Definition lion.h:30
Lion(std::unique_ptr< HashFunction > hash, std::unique_ptr< StreamCipher > cipher, size_t block_size)
Definition lion.cpp:120
std::string name() const override
Definition lion.cpp:99
void decrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const override
Definition lion.cpp:49
void encrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const override
Definition lion.cpp:19
void assert_key_material_set() const
Definition sym_algo.h:141
void zap(std::vector< T, Alloc > &vec)
Definition secmem.h:124
std::string fmt(std::string_view format, const T &... args)
Definition fmt.h:53
constexpr void xor_buf(ranges::contiguous_output_range< uint8_t > auto &&out, ranges::contiguous_range< uint8_t > auto &&in)
Definition mem_ops.h:344
std::vector< T, secure_allocator< T > > secure_vector
Definition secmem.h:65
constexpr void copy_mem(T *out, const T *in, size_t n)
Definition mem_ops.h:149
constexpr void clear_mem(T *ptr, size_t n)
Definition mem_ops.h:123