Crypto++ 8.7
Free C++ class library of cryptographic schemes
kalyna.h
Go to the documentation of this file.
1// kalyna.h - written and placed in the public domain by Jeffrey Walton
2// Based on public domain code by Keru Kuro.
3
4/// \file kalyna.h
5/// \brief Classes for the Kalyna block cipher
6/// \details The Crypto++ implementation relied upon three sources. First was Oliynykov, Gorbenko, Kazymyrov,
7/// Ruzhentsev, Kuznetsov, Gorbenko, Dyrda, Dolgov, Pushkaryov, Mordvinov and Kaidalov's "A New Encryption
8/// Standard of Ukraine: The Kalyna Block Cipher" (http://eprint.iacr.org/2015/650.pdf). Second was Roman
9/// Oliynykov and Oleksandr Kazymyrov's GitHub with the reference implementation
10/// (http://github.com/Roman-Oliynykov/Kalyna-reference). The third resource was Keru Kuro's implementation
11/// of Kalyna in CppCrypto (http://sourceforge.net/projects/cppcrypto/). Kuro has an outstanding
12/// implementation that performed better than the reference implementation and our initial attempts.
13
14#ifndef CRYPTOPP_KALYNA_H
15#define CRYPTOPP_KALYNA_H
16
17#include "config.h"
18#include "seckey.h"
19#include "secblock.h"
20
21NAMESPACE_BEGIN(CryptoPP)
22
23/// \brief Kalyna-128 block cipher information
24/// \since Crypto++ 6.0
25struct CRYPTOPP_NO_VTABLE Kalyna128_Info : public FixedBlockSize<16>, VariableKeyLength<16, 16, 32>
26{
27 static const char* StaticAlgorithmName()
28 {
29 // Format is Cipher-Blocksize(Keylength)
30 return "Kalyna-128";
31 }
32};
33
34/// \brief Kalyna-256 block cipher information
35/// \since Crypto++ 6.0
36struct CRYPTOPP_NO_VTABLE Kalyna256_Info : public FixedBlockSize<32>, VariableKeyLength<32, 32, 64>
37{
38 static const char* StaticAlgorithmName()
39 {
40 // Format is Cipher-Blocksize(Keylength)
41 return "Kalyna-256";
42 }
43};
44
45/// \brief Kalyna-512 block cipher information
46/// \since Crypto++ 6.0
47struct CRYPTOPP_NO_VTABLE Kalyna512_Info : public FixedBlockSize<64>, FixedKeyLength<64>
48{
49 static const char* StaticAlgorithmName()
50 {
51 // Format is Cipher-Blocksize(Keylength)
52 return "Kalyna-512";
53 }
54};
55
56/// \brief Kalyna block cipher base class
57/// \since Crypto++ 6.0
58class CRYPTOPP_NO_VTABLE Kalyna_Base
59{
60public:
61 virtual ~Kalyna_Base() {}
62
63protected:
65 mutable AlignedSecBlock64 m_wspace; // work space
66 AlignedSecBlock64 m_mkey; // master key
67 AlignedSecBlock64 m_rkeys; // round keys
68 unsigned int m_kl, m_nb, m_nk; // number 64-bit blocks and keys
69};
70
71/// \brief Kalyna 128-bit block cipher
72/// \details Kalyna128 provides 128-bit block size. The valid key sizes are 128-bit and 256-bit.
73/// \since Crypto++ 6.0
75{
76public:
77 class CRYPTOPP_NO_VTABLE Base : public Kalyna_Base, public BlockCipherImpl<Kalyna128_Info>
78 {
79 public:
80 /// \brief Provides the name of this algorithm
81 /// \return the standard algorithm name
82 /// \details If the object is unkeyed, then the generic name "Kalyna" is returned
83 /// to the caller. If the algorithm is keyed, then a two or three part name is
84 /// returned to the caller. The name follows DSTU 7624:2014, where block size is
85 /// provided first and then key length. The library uses a dash to identify block size
86 /// and parenthesis to identify key length. For example, Kalyna-128(256) is Kalyna
87 /// with a 128-bit block size and a 256-bit key length. If a mode is associated
88 /// with the object, then it follows as expected. For example, Kalyna-128(256)/ECB.
89 /// DSTU is a little more complex with more parameters, dashes, underscores, but the
90 /// library does not use the delimiters or full convention.
91 std::string AlgorithmName() const {
92 return std::string("Kalyna-128") + "(" + IntToString(m_kl*8) + ")";
93 }
94
95 /// \brief Provides input and output data alignment for optimal performance.
96 /// \return the input data alignment that provides optimal performance
97 /// \sa GetAlignment() and OptimalBlockSize()
98 unsigned int OptimalDataAlignment() const {
99 return GetAlignmentOf<word64>();
100 }
101
102 protected:
103 void UncheckedSetKey(const byte *key, unsigned int keylen, const NameValuePairs &params);
104 void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
105
106 protected:
107 void SetKey_22(const word64 key[2]);
108 void SetKey_24(const word64 key[4]);
109 void ProcessBlock_22(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
110 void ProcessBlock_24(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
111 };
112
113 typedef BlockCipherFinal<ENCRYPTION, Base> Encryption;
114 typedef BlockCipherFinal<DECRYPTION, Base> Decryption;
115};
116
117/// \brief Kalyna 256-bit block cipher
118/// \details Kalyna256 provides 256-bit block size. The valid key sizes are 256-bit and 512-bit.
119/// \since Crypto++ 6.0
121{
122public:
123 class CRYPTOPP_NO_VTABLE Base : public Kalyna_Base, public BlockCipherImpl<Kalyna256_Info>
124 {
125 public:
126 /// \brief Provides the name of this algorithm
127 /// \return the standard algorithm name
128 /// \details If the object is unkeyed, then the generic name "Kalyna" is returned
129 /// to the caller. If the algorithm is keyed, then a two or three part name is
130 /// returned to the caller. The name follows DSTU 7624:2014, where block size is
131 /// provided first and then key length. The library uses a dash to identify block size
132 /// and parenthesis to identify key length. For example, Kalyna-128(256) is Kalyna
133 /// with a 128-bit block size and a 256-bit key length. If a mode is associated
134 /// with the object, then it follows as expected. For example, Kalyna-128(256)/ECB.
135 /// DSTU is a little more complex with more parameters, dashes, underscores, but the
136 /// library does not use the delimiters or full convention.
137 std::string AlgorithmName() const {
138 return std::string("Kalyna-256") + "(" + IntToString(m_kl*8) + ")";
139 }
140
141 /// \brief Provides input and output data alignment for optimal performance.
142 /// \return the input data alignment that provides optimal performance
143 /// \sa GetAlignment() and OptimalBlockSize()
144 unsigned int OptimalDataAlignment() const {
145 return GetAlignmentOf<word64>();
146 }
147
148 protected:
149 void UncheckedSetKey(const byte *key, unsigned int keylen, const NameValuePairs &params);
150 void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
151
152 protected:
153 void SetKey_44(const word64 key[4]);
154 void SetKey_48(const word64 key[8]);
155 void ProcessBlock_44(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
156 void ProcessBlock_48(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
157 };
158
159 typedef BlockCipherFinal<ENCRYPTION, Base> Encryption;
160 typedef BlockCipherFinal<DECRYPTION, Base> Decryption;
161};
162
163/// \brief Kalyna 512-bit block cipher
164/// \details Kalyna512 provides 512-bit block size. The valid key size is 512-bit.
165/// \since Crypto++ 6.0
167{
168public:
169 class CRYPTOPP_NO_VTABLE Base : public Kalyna_Base, public BlockCipherImpl<Kalyna512_Info>
170 {
171 public:
172 /// \brief Provides the name of this algorithm
173 /// \return the standard algorithm name
174 /// \details If the object is unkeyed, then the generic name "Kalyna" is returned
175 /// to the caller. If the algorithm is keyed, then a two or three part name is
176 /// returned to the caller. The name follows DSTU 7624:2014, where block size is
177 /// provided first and then key length. The library uses a dash to identify block size
178 /// and parenthesis to identify key length. For example, Kalyna-128(256) is Kalyna
179 /// with a 128-bit block size and a 256-bit key length. If a mode is associated
180 /// with the object, then it follows as expected. For example, Kalyna-128(256)/ECB.
181 /// DSTU is a little more complex with more parameters, dashes, underscores, but the
182 /// library does not use the delimiters or full convention.
183 std::string AlgorithmName() const {
184 return std::string("Kalyna-512") + "(" + IntToString(m_kl*8) + ")";
185 }
186
187 /// \brief Provides input and output data alignment for optimal performance.
188 /// \return the input data alignment that provides optimal performance
189 /// \sa GetAlignment() and OptimalBlockSize()
190 unsigned int OptimalDataAlignment() const {
191 return GetAlignmentOf<word64>();
192 }
193
194 protected:
195 void UncheckedSetKey(const byte *key, unsigned int keylen, const NameValuePairs &params);
196 void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
197
198 protected:
199 void SetKey_88(const word64 key[8]);
200 void ProcessBlock_88(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
201 };
202
203 typedef BlockCipherFinal<ENCRYPTION, Base> Encryption;
204 typedef BlockCipherFinal<DECRYPTION, Base> Decryption;
205};
206
209
212
215
216NAMESPACE_END
217
218#endif // CRYPTOPP_KALYNA_H
Provides class member functions to key a block cipher.
Definition: seckey.h:318
Provides a base implementation of Algorithm and SimpleKeyingInterface for block ciphers.
Definition: seckey.h:306
Inherited by algorithms with fixed block size.
Definition: seckey.h:41
Inherited by keyed algorithms with fixed key length.
Definition: seckey.h:125
unsigned int OptimalDataAlignment() const
Provides input and output data alignment for optimal performance.
Definition: kalyna.h:98
std::string AlgorithmName() const
Provides the name of this algorithm.
Definition: kalyna.h:91
Kalyna 128-bit block cipher.
Definition: kalyna.h:75
unsigned int OptimalDataAlignment() const
Provides input and output data alignment for optimal performance.
Definition: kalyna.h:144
std::string AlgorithmName() const
Provides the name of this algorithm.
Definition: kalyna.h:137
Kalyna 256-bit block cipher.
Definition: kalyna.h:121
std::string AlgorithmName() const
Provides the name of this algorithm.
Definition: kalyna.h:183
unsigned int OptimalDataAlignment() const
Provides input and output data alignment for optimal performance.
Definition: kalyna.h:190
Kalyna 512-bit block cipher.
Definition: kalyna.h:167
Kalyna block cipher base class.
Definition: kalyna.h:59
Interface for retrieving values given their names.
Definition: cryptlib.h:322
Secure memory block with allocator and cleanup.
Definition: secblock.h:731
Inherited by keyed algorithms with variable key length.
Definition: seckey.h:166
Library configuration file.
unsigned long long word64
64-bit unsigned datatype
Definition: config_int.h:91
std::string IntToString(T value, unsigned int base=10)
Converts a value to a string.
Definition: misc.h:724
Crypto++ library namespace.
Classes and functions for secure memory allocations.
Classes and functions for implementing secret key algorithms.
Provides Encryption and Decryption typedefs used by derived classes to implement a block cipher.
Definition: seckey.h:399
Kalyna-128 block cipher information.
Definition: kalyna.h:26
Kalyna-256 block cipher information.
Definition: kalyna.h:37
Kalyna-512 block cipher information.
Definition: kalyna.h:48