Botan: Botan::Lion Class Reference

Botan 1.10.17

Public Member Functions | List of all members
Botan::Lion Class Reference

`#include <lion.h>`

Inheritance diagram for Botan::Lion:

## Public Member Functions
size_t | block_size () const
void | clear ()
BlockCipher * | clone () const
void | decrypt (const byte in[], byte out[]) const
void | decrypt (byte block[]) const
void | decrypt_n (const byte in[], byte out[], size_t blocks) const
void | encrypt (const byte in[], byte out[]) const
void | encrypt (byte block[]) const
void | encrypt_n (const byte in[], byte out[], size_t blocks) const
Key_Length_Specification | key_spec () const
| Lion (HashFunction *hash, StreamCipher *cipher, size_t block_size)
size_t | maximum_keylength () const
size_t | minimum_keylength () const
std::string | name () const
size_t | parallel_bytes () const
virtual size_t | parallelism () const
void | set_key (const SymmetricKey &key)
void | set_key (const byte key[], size_t length)
bool | valid_keylength (size_t length) const
| ~Lion ()

## Detailed Description

Lion is a block cipher construction designed by Ross Anderson and Eli Biham, described in "Two Practical and Provably Secure Block Ciphers: BEAR and LION". It has a variable block size and is designed to encrypt very large blocks (up to a megabyte)

http://www.cl.cam.ac.uk/~rja14/Papers/bear-lion.pdf

Definition at line 25 of file lion.h.

## Constructor & Destructor Documentation

## ◆ Lion()

Botan::Lion::Lion | ( | HashFunction * | hash,
|  | StreamCipher * | cipher,
|  | size_t | block_size
| ) |  |

Parameters

  hash | the hash to use internally
  cipher | the stream cipher to use internally
  block_size | the size of the block to use

Definition at line 111 of file lion.cpp.

References name(), Botan::MemoryRegion< T >::resize(), and Botan::SymmetricAlgorithm::valid_keylength().

Referenced by clone().

111 :
112 BLOCK_SIZE(std::max<size_t>(2*hash_in->output_length() + 1, block_len)),
113 LEFT_SIZE(hash_in->output_length()),
114 RIGHT_SIZE(BLOCK_SIZE - LEFT_SIZE),
115 hash(hash_in),
116 cipher(sc_in)
117 {
118 if(2*LEFT_SIZE + 1 > BLOCK_SIZE)
119 throw Invalid_Argument(name() + ": Chosen block size is too small");
120
121 if(!cipher->valid_keylength(LEFT_SIZE))
122 throw Invalid_Argument(name() + ": This stream/hash combo is invalid");
123
124 key1.resize(LEFT_SIZE);
125 key2.resize(LEFT_SIZE);
126 }
Botan::MemoryRegion::resize
void resize(size_t n)
Definition: secmem.h:217
Botan::Invalid_Argument
std::invalid_argument Invalid_Argument
Definition: exceptn.h:20
Botan::SymmetricAlgorithm::valid_keylength
bool valid_keylength(size_t length) const
Definition: sym_algo.h:51
Botan::Lion::name
std::string name() const
Definition: lion.cpp:82

## ◆ ~Lion()

Botan::Lion::~Lion | ( |  | ) |
| inline

Definition at line 51 of file lion.h.

51 { delete hash; delete cipher; }

## Member Function Documentation

## ◆ block_size()

size_t Botan::Lion::block_size | ( |  | ) | const
| inlinevirtual

Returns
  block size of this algorithm

Implements Botan::BlockCipher.

Definition at line 31 of file lion.h.

31 { return BLOCK_SIZE; }

## ◆ clear()

void Botan::Lion::clear | ( |  | ) |
| virtual

Zeroize internal state

Implements Botan::Algorithm.

Definition at line 100 of file lion.cpp.

References Botan::Algorithm::clear(), and Botan::zeroise().

101 {
102 hash->clear();
103 cipher->clear();
104 zeroise(key1);
105 zeroise(key2);
106 }
Botan::Algorithm::clear
virtual void clear()=0
Botan::zeroise
void zeroise(MemoryRegion< T > &vec)
Definition: secmem.h:428

## ◆ clone()

BlockCipher * Botan::Lion::clone | ( |  | ) | const
| virtual

Get a new object representing the same algorithm as *this

Implements Botan::BlockCipher.

Definition at line 92 of file lion.cpp.

References Botan::HashFunction::clone(), Botan::StreamCipher::clone(), and Lion().

93 {
94 return new Lion(hash->clone(), cipher->clone(), BLOCK_SIZE);
95 }
Botan::HashFunction::clone
virtual HashFunction * clone() const =0
Botan::StreamCipher::clone
virtual StreamCipher * clone() const =0
Botan::Lion::Lion
Lion(HashFunction *hash, StreamCipher *cipher, size_t block_size)
Definition: lion.cpp:111

## ◆ decrypt() [1/2]

void Botan::BlockCipher::decrypt | ( | const byte | in[],
|  | byte | out[]
| ) |  | const
| inlineinherited

Decrypt a block.

Parameters

  in | The ciphertext block to be decypted as a byte array. Must be of length block_size().
  out | The byte array designated to hold the decrypted block. Must be of length block_size().

Definition at line 57 of file block_cipher.h.

Referenced by Botan::DESX::decrypt_n().

58 { decrypt_n(in, out, 1); }
Botan::BlockCipher::decrypt_n
virtual void decrypt_n(const byte in[], byte out[], size_t blocks) const =0

## ◆ decrypt() [2/2]

void Botan::BlockCipher::decrypt | ( | byte | block[] | ) | const
| inlineinherited

Decrypt a block.

Parameters

  block | the ciphertext block to be decrypted Must be of length block_size(). Will hold the result when the function has finished.

Definition at line 74 of file block_cipher.h.

74 { decrypt_n(block, block, 1); }
Botan::BlockCipher::decrypt_n
virtual void decrypt_n(const byte in[], byte out[], size_t blocks) const =0

## ◆ decrypt_n()

void Botan::Lion::decrypt_n | ( | const byte | in[],
|  | byte | out[],
|  | size_t | blocks
| ) |  | const
| virtual

Decrypt one or more blocks

Parameters

  in | the input buffer (multiple of block_size())
  out | the output buffer (same size as in)
  blocks | the number of blocks to process

Implements Botan::BlockCipher.

Definition at line 44 of file lion.cpp.

References Botan::StreamCipher::cipher(), Botan::StreamCipher::cipher1(), Botan::Buffered_Computation::final(), Botan::SymmetricAlgorithm::set_key(), Botan::Buffered_Computation::update(), and Botan::xor_buf().

45 {
46 SecureVector<byte> buffer_vec(LEFT_SIZE);
47 byte* buffer = &buffer_vec[0];
48
49 for(size_t i = 0; i != blocks; ++i)
50 {
51 xor_buf(buffer, in, &key2[0], LEFT_SIZE);
52 cipher->set_key(buffer, LEFT_SIZE);
53 cipher->cipher(in + LEFT_SIZE, out + LEFT_SIZE, RIGHT_SIZE);
54
55 hash->update(out + LEFT_SIZE, RIGHT_SIZE);
56 hash->final(buffer);
57 xor_buf(out, in, buffer, LEFT_SIZE);
58
59 xor_buf(buffer, out, &key1[0], LEFT_SIZE);
60 cipher->set_key(buffer, LEFT_SIZE);
61 cipher->cipher1(out + LEFT_SIZE, RIGHT_SIZE);
62
63 in += BLOCK_SIZE;
64 out += BLOCK_SIZE;
65 }
66 }
Botan::StreamCipher::cipher1
void cipher1(byte buf[], size_t len)
Definition: stream_cipher.h:34
Botan::byte
unsigned char byte
Definition: types.h:22
Botan::SymmetricAlgorithm::set_key
void set_key(const SymmetricKey &key)
Definition: sym_algo.h:60
Botan::Buffered_Computation::update
void update(const byte in[], size_t length)
Definition: buf_comp.h:33
Botan::StreamCipher::cipher
virtual void cipher(const byte in[], byte out[], size_t len)=0
Botan::Buffered_Computation::final
void final(byte out[])
Definition: buf_comp.h:80
Botan::xor_buf
void xor_buf(byte out[], const byte in[], size_t length)
Definition: xor_buf.h:21

## ◆ encrypt() [1/2]

void Botan::BlockCipher::encrypt | ( | const byte | in[],
|  | byte | out[]
| ) |  | const
| inlineinherited

Encrypt a block.

Parameters

  in | The plaintext block to be encrypted as a byte array. Must be of length block_size().
  out | The byte array designated to hold the encrypted block. Must be of length block_size().

Definition at line 47 of file block_cipher.h.

Referenced by Botan::aont_unpackage(), Botan::OFB::cipher(), Botan::DESX::encrypt_n(), Botan::OFB::set_iv(), Botan::CFB_Encryption::set_iv(), Botan::XTS_Encryption::set_iv(), Botan::CFB_Decryption::set_iv(), and Botan::XTS_Decryption::set_iv().

48 { encrypt_n(in, out, 1); }
Botan::BlockCipher::encrypt_n
virtual void encrypt_n(const byte in[], byte out[], size_t blocks) const =0

## ◆ encrypt() [2/2]

void Botan::BlockCipher::encrypt | ( | byte | block[] | ) | const
| inlineinherited

Encrypt a block.

Parameters

  block | the plaintext block to be encrypted Must be of length block_size(). Will hold the result when the function has finished.

Definition at line 66 of file block_cipher.h.

66 { encrypt_n(block, block, 1); }
Botan::BlockCipher::encrypt_n
virtual void encrypt_n(const byte in[], byte out[], size_t blocks) const =0

## ◆ encrypt_n()

void Botan::Lion::encrypt_n | ( | const byte | in[],
|  | byte | out[],
|  | size_t | blocks
| ) |  | const
| virtual

Encrypt one or more blocks

Parameters

  in | the input buffer (multiple of block_size())
  out | the output buffer (same size as in)
  blocks | the number of blocks to process

Implements Botan::BlockCipher.

Definition at line 17 of file lion.cpp.

References Botan::StreamCipher::cipher(), Botan::StreamCipher::cipher1(), Botan::Buffered_Computation::final(), Botan::SymmetricAlgorithm::set_key(), Botan::Buffered_Computation::update(), and Botan::xor_buf().

18 {
19 SecureVector<byte> buffer_vec(LEFT_SIZE);
20 byte* buffer = &buffer_vec[0];
21
22 for(size_t i = 0; i != blocks; ++i)
23 {
24 xor_buf(buffer, in, &key1[0], LEFT_SIZE);
25 cipher->set_key(buffer, LEFT_SIZE);
26 cipher->cipher(in + LEFT_SIZE, out + LEFT_SIZE, RIGHT_SIZE);
27
28 hash->update(out + LEFT_SIZE, RIGHT_SIZE);
29 hash->final(buffer);
30 xor_buf(out, in, buffer, LEFT_SIZE);
31
32 xor_buf(buffer, out, &key2[0], LEFT_SIZE);
33 cipher->set_key(buffer, LEFT_SIZE);
34 cipher->cipher1(out + LEFT_SIZE, RIGHT_SIZE);
35
36 in += BLOCK_SIZE;
37 out += BLOCK_SIZE;
38 }
39 }
Botan::StreamCipher::cipher1
void cipher1(byte buf[], size_t len)
Definition: stream_cipher.h:34
Botan::byte
unsigned char byte
Definition: types.h:22
Botan::SymmetricAlgorithm::set_key
void set_key(const SymmetricKey &key)
Definition: sym_algo.h:60
Botan::Buffered_Computation::update
void update(const byte in[], size_t length)
Definition: buf_comp.h:33
Botan::StreamCipher::cipher
virtual void cipher(const byte in[], byte out[], size_t len)=0
Botan::Buffered_Computation::final
void final(byte out[])
Definition: buf_comp.h:80
Botan::xor_buf
void xor_buf(byte out[], const byte in[], size_t length)
Definition: xor_buf.h:21

## ◆ key_spec()

Key_Length_Specification Botan::Lion::key_spec | ( |  | ) | const
| inlinevirtual

Returns
  object describing limits on key size

Implements Botan::SymmetricAlgorithm.

Definition at line 33 of file lion.h.

34 {
35 return Key_Length_Specification(2, 2*hash->output_length(), 2);
36 }
Botan::Buffered_Computation::output_length
virtual size_t output_length() const =0

## ◆ maximum_keylength()

size_t Botan::SymmetricAlgorithm::maximum_keylength | ( |  | ) | const
| inlineinherited

Returns
  minimum allowed key length

Definition at line 33 of file sym_algo.h.

34 {
35 return key_spec().maximum_keylength();
36 }
Botan::Key_Length_Specification::maximum_keylength
size_t maximum_keylength() const
Definition: key_spec.h:69
Botan::SymmetricAlgorithm::key_spec
virtual Key_Length_Specification key_spec() const =0

## ◆ minimum_keylength()

size_t Botan::SymmetricAlgorithm::minimum_keylength | ( |  | ) | const
| inlineinherited

Returns
  maxmium allowed key length

Definition at line 41 of file sym_algo.h.

42 {
43 return key_spec().minimum_keylength();
44 }
Botan::SymmetricAlgorithm::key_spec
virtual Key_Length_Specification key_spec() const =0
Botan::Key_Length_Specification::minimum_keylength
size_t minimum_keylength() const
Definition: key_spec.h:61

## ◆ name()

std::string Botan::Lion::name | ( |  | ) | const
| virtual

Returns
  name of this algorithm

Implements Botan::Algorithm.

Definition at line 82 of file lion.cpp.

References Botan::Algorithm::name(), and Botan::to_string().

Referenced by Lion().

83 {
84 return "Lion(" + hash->name() + "," +
85 cipher->name() + "," +
86 to_string(BLOCK_SIZE) + ")";
87 }
Botan::Algorithm::name
virtual std::string name() const =0
Botan::to_string
std::string to_string(u64bit n, size_t min_len)
Definition: parsing.cpp:42

## ◆ parallel_bytes()

size_t Botan::BlockCipher::parallel_bytes | ( |  | ) | const
| inlineinherited

Returns
  prefererred parallelism of this cipher in bytes

Definition at line 35 of file block_cipher.h.

36 {
37 return parallelism() * block_size() * BOTAN_BLOCK_CIPHER_PAR_MULT;
38 }
Botan::BlockCipher::parallelism
virtual size_t parallelism() const
Definition: block_cipher.h:30
Botan::BlockCipher::block_size
virtual size_t block_size() const =0

## ◆ parallelism()

virtual size_t Botan::BlockCipher::parallelism | ( |  | ) | const
| inlinevirtualinherited

Returns
  native parallelism of this cipher in blocks

Reimplemented in Botan::AES_256_NI, Botan::AES_192_NI, Botan::AES_128_NI, Botan::IDEA_SSE2, Botan::Noekeon_SIMD, Botan::Serpent_SIMD, and Botan::XTEA_SIMD.

Definition at line 30 of file block_cipher.h.

30 { return 1; }

## ◆ set_key() [1/2]

void Botan::SymmetricAlgorithm::set_key | ( | const SymmetricKey & | key | ) |
| inlineinherited

Set the symmetric key of this object.

Parameters

  key | the SymmetricKey to be set.

Definition at line 60 of file sym_algo.h.

References Botan::OctetString::begin(), and Botan::OctetString::length().

Referenced by Botan::aont_unpackage(), decrypt_n(), Botan::PKCS5_PBKDF2::derive_key(), Botan::ECB_Decryption::ECB_Decryption(), Botan::ECB_Encryption::ECB_Encryption(), encrypt_n(), Botan::HMAC_RNG::HMAC_RNG(), Botan::MAC_Filter::MAC_Filter(), Botan::HMAC_RNG::reseed(), Botan::XTS_Encryption::set_key(), Botan::EAX_Base::set_key(), Botan::XTS_Decryption::set_key(), Botan::Record_Writer::set_keys(), Botan::Record_Reader::set_keys(), and Botan::StreamCipher_Filter::StreamCipher_Filter().

61 { set_key(key.begin(), key.length()); }
Botan::SymmetricAlgorithm::set_key
void set_key(const SymmetricKey &key)
Definition: sym_algo.h:60

## ◆ set_key() [2/2]

void Botan::SymmetricAlgorithm::set_key | ( | const byte | key[],
|  | size_t | length
| ) |  |
| inlineinherited

Set the symmetric key of this object.

Parameters

  key | the to be set as a byte array.
  length | in bytes of key param

Definition at line 68 of file sym_algo.h.

69 {
70 if(!valid_keylength(length))
71 throw Invalid_Key_Length(name(), length);
72 key_schedule(key, length);
73 }
Botan::SymmetricAlgorithm::valid_keylength
bool valid_keylength(size_t length) const
Definition: sym_algo.h:51
Botan::Algorithm::name
virtual std::string name() const =0

## ◆ valid_keylength()

bool Botan::SymmetricAlgorithm::valid_keylength | ( | size_t | length | ) | const
| inlineinherited

Check whether a given key length is valid for this algorithm.

Parameters

  length | the key length to be checked.

Returns
  true if the key length is valid.

Definition at line 51 of file sym_algo.h.

Referenced by Botan::aont_unpackage(), Botan::HMAC_RNG::HMAC_RNG(), and Lion().

52 {
53 return key_spec().valid_keylength(length);
54 }
Botan::Key_Length_Specification::valid_keylength
bool valid_keylength(size_t length) const
Definition: key_spec.h:51
Botan::SymmetricAlgorithm::key_spec
virtual Key_Length_Specification key_spec() const =0

The documentation for this class was generated from the following files:

- src/block/lion/lion.h
- src/block/lion/lion.cpp