Coverage Report

Created: 2021-05-04 09:02

/src/botan/src/lib/block/lion/lion.cpp
Line
Count
Source (jump to first uncovered line)
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
#include <botan/exceptn.h>
10
11
namespace Botan {
12
13
/*
14
* Lion Encryption
15
*/
16
void Lion::encrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const
17
0
   {
18
0
   verify_key_set(m_key1.empty() == false);
19
20
0
   const size_t LEFT_SIZE = left_size();
21
0
   const size_t RIGHT_SIZE = right_size();
22
23
0
   secure_vector<uint8_t> buffer_vec(LEFT_SIZE);
24
0
   uint8_t* buffer = buffer_vec.data();
25
26
0
   for(size_t i = 0; i != blocks; ++i)
27
0
      {
28
0
      xor_buf(buffer, in, m_key1.data(), LEFT_SIZE);
29
0
      m_cipher->set_key(buffer, LEFT_SIZE);
30
0
      m_cipher->cipher(in + LEFT_SIZE, out + LEFT_SIZE, RIGHT_SIZE);
31
32
0
      m_hash->update(out + LEFT_SIZE, RIGHT_SIZE);
33
0
      m_hash->final(buffer);
34
0
      xor_buf(out, in, buffer, LEFT_SIZE);
35
36
0
      xor_buf(buffer, out, m_key2.data(), LEFT_SIZE);
37
0
      m_cipher->set_key(buffer, LEFT_SIZE);
38
0
      m_cipher->cipher1(out + LEFT_SIZE, RIGHT_SIZE);
39
40
0
      in += m_block_size;
41
0
      out += m_block_size;
42
0
      }
43
0
   }
44
45
/*
46
* Lion Decryption
47
*/
48
void Lion::decrypt_n(const uint8_t in[], uint8_t out[], size_t blocks) const
49
0
   {
50
0
   verify_key_set(m_key1.empty() == false);
51
52
0
   const size_t LEFT_SIZE = left_size();
53
0
   const size_t RIGHT_SIZE = right_size();
54
55
0
   secure_vector<uint8_t> buffer_vec(LEFT_SIZE);
56
0
   uint8_t* buffer = buffer_vec.data();
57
58
0
   for(size_t i = 0; i != blocks; ++i)
59
0
      {
60
0
      xor_buf(buffer, in, m_key2.data(), LEFT_SIZE);
61
0
      m_cipher->set_key(buffer, LEFT_SIZE);
62
0
      m_cipher->cipher(in + LEFT_SIZE, out + LEFT_SIZE, RIGHT_SIZE);
63
64
0
      m_hash->update(out + LEFT_SIZE, RIGHT_SIZE);
65
0
      m_hash->final(buffer);
66
0
      xor_buf(out, in, buffer, LEFT_SIZE);
67
68
0
      xor_buf(buffer, out, m_key1.data(), LEFT_SIZE);
69
0
      m_cipher->set_key(buffer, LEFT_SIZE);
70
0
      m_cipher->cipher1(out + LEFT_SIZE, RIGHT_SIZE);
71
72
0
      in += m_block_size;
73
0
      out += m_block_size;
74
0
      }
75
0
   }
76
77
/*
78
* Lion Key Schedule
79
*/
80
void Lion::key_schedule(const uint8_t key[], size_t length)
81
0
   {
82
0
   clear();
83
84
0
   const size_t half = length / 2;
85
86
0
   m_key1.resize(left_size());
87
0
   m_key2.resize(left_size());
88
0
   clear_mem(m_key1.data(), m_key1.size());
89
0
   clear_mem(m_key2.data(), m_key2.size());
90
0
   copy_mem(m_key1.data(), key, half);
91
0
   copy_mem(m_key2.data(), key + half, half);
92
0
   }
93
94
/*
95
* Return the name of this type
96
*/
97
std::string Lion::name() const
98
0
   {
99
0
   return "Lion(" + m_hash->name() + "," +
100
0
                    m_cipher->name() + "," +
101
0
                    std::to_string(block_size()) + ")";
102
0
   }
103
104
std::unique_ptr<BlockCipher> Lion::new_object() const
105
0
   {
106
0
   return std::make_unique<Lion>(m_hash->new_object(), m_cipher->new_object(), block_size());
107
0
   }
108
109
/*
110
* Clear memory of sensitive data
111
*/
112
void Lion::clear()
113
0
   {
114
0
   zap(m_key1);
115
0
   zap(m_key2);
116
0
   m_hash->clear();
117
0
   m_cipher->clear();
118
0
   }
119
120
/*
121
* Lion Constructor
122
*/
123
Lion::Lion(std::unique_ptr<HashFunction> hash,
124
           std::unique_ptr<StreamCipher> cipher,
125
           size_t bs) :
126
   m_block_size(std::max<size_t>(2*hash->output_length() + 1, bs)),
127
   m_hash(std::move(hash)),
128
   m_cipher(std::move(cipher))
129
0
   {
130
0
   if(2*left_size() + 1 > m_block_size)
131
0
      throw Invalid_Argument(name() + ": Chosen block size is too small");
132
133
0
   if(!m_cipher->valid_keylength(left_size()))
134
0
      throw Invalid_Argument(name() + ": This stream/hash combo is invalid");
135
0
   }
136
137
}