Crypto++ 8.9
Free C++ class library of cryptographic schemes
lsh.h
Go to the documentation of this file.
1// lsh.h - written and placed in the public domain by Jeffrey Walton
2// Based on the specification and source code provided by
3// Korea Internet & Security Agency (KISA) website. Also
4// see https://seed.kisa.or.kr/kisa/algorithm/EgovLSHInfo.do
5// and https://seed.kisa.or.kr/kisa/Board/22/detailView.do.
6
7// We are hitting some sort of GCC bug in the LSH AVX2 code path.
8// Clang is OK on the AVX2 code path. We believe it is GCC Issue
9// 82735, https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82735. It
10// makes using zeroupper a little tricky.
11
12/// \file lsh.h
13/// \brief Classes for the LSH hash functions
14/// \since Crypto++ 8.6
15/// \sa <A HREF="https://seed.kisa.or.kr/kisa/algorithm/EgovLSHInfo.do">LSH</A>
16/// on the Korea Internet & Security Agency (KISA) website.
17#ifndef CRYPTOPP_LSH_H
18#define CRYPTOPP_LSH_H
19
20#include "cryptlib.h"
21#include "secblock.h"
22
23// Enable SSE2 and AVX2 for 64-bit machines.
24// 32-bit machines slow down with SSE2.
25#if (CRYPTOPP_BOOL_X32) || (CRYPTOPP_BOOL_X64)
26# define CRYPTOPP_ENABLE_64BIT_SSE 1
27#endif
28
29NAMESPACE_BEGIN(CryptoPP)
30
31/// \brief LSH-224 and LSH-256 hash base class
32/// \details LSH256_Base is the base class for both LSH-224 and LSH-256
33/// \since Crypto++ 8.6
35{
36public:
37 /// \brief Block size, in bytes
38 /// \details LSH_256 uses LSH256_MSG_BLK_BYTE_LEN for block size, which is 128
39 CRYPTOPP_CONSTANT(BLOCKSIZE = 128);
40
41 virtual ~LSH256_Base() {}
42
43 unsigned int BlockSize() const { return BLOCKSIZE; }
44 unsigned int DigestSize() const { return m_digestSize; }
45 unsigned int OptimalDataAlignment() const { return GetAlignmentOf<word32>(); }
46
47 void Restart();
48 void Update(const byte *input, size_t size);
49 void TruncatedFinal(byte *hash, size_t size);
50
51 std::string AlgorithmProvider() const;
52
53protected:
54 LSH256_Base(unsigned int algType, unsigned int digestSize)
55 : m_digestSize(digestSize) { m_state[80] = algType; }
56
57protected:
58 // Working state is:
59 // * cv_l = 8 32-bit words
60 // * cv_r = 8 32-bit words
61 // * submsg_e_l = 8 32-bit words
62 // * submsg_e_r = 8 32-bit words
63 // * submsg_o_l = 8 32-bit words
64 // * submsg_o_r = 8 32-bit words
65 // * last_block = 32 32-bit words (128 bytes)
66 // * algType
67 // * remainingBitLength
69 // word32 m_algType, m_remainingBitLength;
70 word32 m_digestSize;
71};
72
73/// \brief LSH-224 hash function
74/// \sa <A HREF="https://seed.kisa.or.kr/kisa/algorithm/EgovLSHInfo.do">LSH</A>
75/// on the Korea Internet & Security Agency (KISA) website.
76/// \since Crypto++ 8.6
77class LSH224 : public LSH256_Base
78{
79public:
80 /// \brief Digest size, in bytes
81 /// \details LSH_256 uses LSH_GET_HASHBYTE(algType) for digest size, which is 28
82 CRYPTOPP_CONSTANT(DIGESTSIZE = 28);
83 /// \brief Block size, in bytes
84 /// \details LSH_256 uses LSH256_MSG_BLK_BYTE_LEN for block size, which is 128
85 CRYPTOPP_CONSTANT(BLOCKSIZE = LSH256_Base::BLOCKSIZE);
86
87 /// \brief The algorithm's name
88 /// \return the standard algorithm name
89 /// \details The standard algorithm name can be a name like <tt>AES</tt> or <tt>AES/GCM</tt>.
90 /// Some algorithms do not have standard names yet. For example, there is no standard
91 /// algorithm name for Shoup's ECIES.
92 /// \note StaticAlgorithmName is not universally implemented yet.
93 static std::string StaticAlgorithmName() { return "LSH-224"; }
94
95 /// \brief Construct a LSH-224
96 /// \details LSH_TYPE_224 is the magic value 0x000001C defined in lsh.cpp.
97 LSH224() : LSH256_Base(0x000001C, DIGESTSIZE) { Restart(); }
98
99 std::string AlgorithmName() const { return StaticAlgorithmName(); }
100};
101
102/// \brief LSH-256 hash function
103/// \sa <A HREF="https://seed.kisa.or.kr/kisa/algorithm/EgovLSHInfo.do">LSH</A>
104/// on the Korea Internet & Security Agency (KISA) website.
105/// \since Crypto++ 8.6
106class LSH256 : public LSH256_Base
107{
108public:
109 /// \brief Digest size, in bytes
110 /// \details LSH_256 uses LSH_GET_HASHBYTE(algType) for digest size, which is 32
111 CRYPTOPP_CONSTANT(DIGESTSIZE = 32);
112 /// \brief Block size, in bytes
113 /// \details LSH_256 uses LSH256_MSG_BLK_BYTE_LEN for block size, which is 128
114 CRYPTOPP_CONSTANT(BLOCKSIZE = LSH256_Base::BLOCKSIZE);
115
116 /// \brief The algorithm's name
117 /// \return the standard algorithm name
118 /// \details The standard algorithm name can be a name like <tt>AES</tt> or <tt>AES/GCM</tt>.
119 /// Some algorithms do not have standard names yet. For example, there is no standard
120 /// algorithm name for Shoup's ECIES.
121 /// \note StaticAlgorithmName is not universally implemented yet.
122 static std::string StaticAlgorithmName() { return "LSH-256"; }
123
124 /// \brief Construct a LSH-256
125 /// \details LSH_TYPE_256 is the magic value 0x0000020 defined in lsh.cpp.
126 LSH256() : LSH256_Base(0x0000020, DIGESTSIZE) { Restart(); }
127
128 std::string AlgorithmName() const { return StaticAlgorithmName(); }
129};
130
131/// \brief LSH-384 and LSH-512 hash base class
132/// \details LSH512_Base is the base class for both LSH-384 and LSH-512
133/// \since Crypto++ 8.6
135{
136public:
137 /// \brief Block size, in bytes
138 /// \details LSH_512 uses LSH512_MSG_BLK_BYTE_LEN for block size, which is 256
139 CRYPTOPP_CONSTANT(BLOCKSIZE = 256);
140
141 virtual ~LSH512_Base() {}
142
143 unsigned int BlockSize() const { return BLOCKSIZE; }
144 unsigned int DigestSize() const { return m_digestSize; }
145 unsigned int OptimalDataAlignment() const { return GetAlignmentOf<word64>(); }
146
147 void Restart();
148 void Update(const byte *input, size_t size);
149 void TruncatedFinal(byte *hash, size_t size);
150
151 std::string AlgorithmProvider() const;
152
153protected:
154 LSH512_Base(unsigned int algType, unsigned int digestSize)
155 : m_digestSize(digestSize) { m_state[80] = algType; }
156
157protected:
158 // Working state is:
159 // * cv_l = 8 64-bit words
160 // * cv_r = 8 64-bit words
161 // * submsg_e_l = 8 64-bit words
162 // * submsg_e_r = 8 64-bit words
163 // * submsg_o_l = 8 64-bit words
164 // * submsg_o_r = 8 64-bit words
165 // * last_block = 32 64-bit words (256 bytes)
166 // * algType
167 // * remainingBitLength
169 // word32 m_algType, m_remainingBitLength;
170 word32 m_digestSize;
171};
172
173/// \brief LSH-384 hash function
174/// \sa <A HREF="https://seed.kisa.or.kr/kisa/algorithm/EgovLSHInfo.do">LSH</A>
175/// on the Korea Internet & Security Agency (KISA) website.
176/// \since Crypto++ 8.6
177class LSH384 : public LSH512_Base
178{
179public:
180 /// \brief Digest size, in bytes
181 /// \details LSH_512 uses LSH_GET_HASHBYTE(algType) for digest size, which is 48
182 CRYPTOPP_CONSTANT(DIGESTSIZE = 48);
183 /// \brief Block size, in bytes
184 /// \details LSH_512 uses LSH512_MSG_BLK_BYTE_LEN for block size, which is 256
185 CRYPTOPP_CONSTANT(BLOCKSIZE = LSH512_Base::BLOCKSIZE);
186
187 /// \brief The algorithm's name
188 /// \return the standard algorithm name
189 /// \details The standard algorithm name can be a name like <tt>AES</tt> or <tt>AES/GCM</tt>.
190 /// Some algorithms do not have standard names yet. For example, there is no standard
191 /// algorithm name for Shoup's ECIES.
192 /// \note StaticAlgorithmName is not universally implemented yet.
193 static std::string StaticAlgorithmName() { return "LSH-384"; }
194
195 /// \brief Construct a LSH-384
196 /// \details LSH_TYPE_384 is the magic value 0x0010030 defined in lsh.cpp.
197 LSH384() : LSH512_Base(0x0010030, DIGESTSIZE) { Restart(); }
198
199 std::string AlgorithmName() const { return StaticAlgorithmName(); }
200};
201
202/// \brief LSH-512 hash function
203/// \sa <A HREF="https://seed.kisa.or.kr/kisa/algorithm/EgovLSHInfo.do">LSH</A>
204/// on the Korea Internet & Security Agency (KISA) website.
205/// \since Crypto++ 8.6
206class LSH512 : public LSH512_Base
207{
208public:
209 /// \brief Digest size, in bytes
210 /// \details LSH_512 uses LSH_GET_HASHBYTE(algType) for digest size, which is 64
211 CRYPTOPP_CONSTANT(DIGESTSIZE = 64);
212 /// \brief Block size, in bytes
213 /// \details LSH_512 uses LSH512_MSG_BLK_BYTE_LEN for block size, which is 256
214 CRYPTOPP_CONSTANT(BLOCKSIZE = LSH512_Base::BLOCKSIZE);
215
216 /// \brief The algorithm's name
217 /// \return the standard algorithm name
218 /// \details The standard algorithm name can be a name like <tt>AES</tt> or <tt>AES/GCM</tt>.
219 /// Some algorithms do not have standard names yet. For example, there is no standard
220 /// algorithm name for Shoup's ECIES.
221 /// \note StaticAlgorithmName is not universally implemented yet.
222 static std::string StaticAlgorithmName() { return "LSH-512"; }
223
224 /// \brief Construct a LSH-512
225 /// \details LSH_TYPE_512 is the magic value 0x0010040 defined in lsh.cpp.
226 LSH512() : LSH512_Base(0x0010040, DIGESTSIZE) { Restart(); }
227
228 std::string AlgorithmName() const { return StaticAlgorithmName(); }
229};
230
231/// \brief LSH-512-256 hash function
232/// \sa <A HREF="https://seed.kisa.or.kr/kisa/algorithm/EgovLSHInfo.do">LSH</A>
233/// on the Korea Internet & Security Agency (KISA) website.
234/// \since Crypto++ 8.6
236{
237public:
238 /// \brief Digest size, in bytes
239 /// \details LSH_512 uses LSH_GET_HASHBYTE(algType) for digest size, which is 32
240 CRYPTOPP_CONSTANT(DIGESTSIZE = 32);
241 /// \brief Block size, in bytes
242 /// \details LSH_512 uses LSH512_MSG_BLK_BYTE_LEN for block size, which is 256
243 CRYPTOPP_CONSTANT(BLOCKSIZE = LSH512_Base::BLOCKSIZE);
244
245 /// \brief The algorithm's name
246 /// \return the standard algorithm name
247 /// \details The standard algorithm name can be a name like <tt>AES</tt> or <tt>AES/GCM</tt>.
248 /// Some algorithms do not have standard names yet. For example, there is no standard
249 /// algorithm name for Shoup's ECIES.
250 /// \note StaticAlgorithmName is not universally implemented yet.
251 static std::string StaticAlgorithmName() { return "LSH-512-256"; }
252
253 /// \brief Construct a LSH-512-256
254 /// \details LSH_TYPE_512_256 is the magic value 0x0010020 defined in lsh.cpp.
256
257 std::string AlgorithmName() const { return StaticAlgorithmName(); }
258};
259
260NAMESPACE_END
261
262#endif // CRYPTOPP_LSH_H
Fixed size stack-based SecBlock.
Definition secblock.h:1246
Interface for hash functions and data processing part of MACs.
Definition cryptlib.h:1118
LSH-224 hash function.
Definition lsh.h:78
static const int BLOCKSIZE
Block size, in bytes.
Definition lsh.h:85
static const int DIGESTSIZE
Digest size, in bytes.
Definition lsh.h:82
static std::string StaticAlgorithmName()
The algorithm's name.
Definition lsh.h:93
LSH224()
Construct a LSH-224.
Definition lsh.h:97
std::string AlgorithmName() const
Provides the name of this algorithm.
Definition lsh.h:99
LSH-224 and LSH-256 hash base class.
Definition lsh.h:35
void TruncatedFinal(byte *hash, size_t size)
Computes the hash of the current message.
static const int BLOCKSIZE
Block size, in bytes.
Definition lsh.h:39
std::string AlgorithmProvider() const
Retrieve the provider of this algorithm.
void Update(const byte *input, size_t size)
Updates a hash with additional input.
unsigned int OptimalDataAlignment() const
Provides input and output data alignment for optimal performance.
Definition lsh.h:45
void Restart()
Restart the hash.
unsigned int BlockSize() const
Provides the block size of the compression function.
Definition lsh.h:43
unsigned int DigestSize() const
Provides the digest size of the hash.
Definition lsh.h:44
LSH-256 hash function.
Definition lsh.h:107
static const int BLOCKSIZE
Block size, in bytes.
Definition lsh.h:114
static const int DIGESTSIZE
Digest size, in bytes.
Definition lsh.h:111
static std::string StaticAlgorithmName()
The algorithm's name.
Definition lsh.h:122
LSH256()
Construct a LSH-256.
Definition lsh.h:126
std::string AlgorithmName() const
Provides the name of this algorithm.
Definition lsh.h:128
LSH-384 hash function.
Definition lsh.h:178
LSH384()
Construct a LSH-384.
Definition lsh.h:197
static const int DIGESTSIZE
Digest size, in bytes.
Definition lsh.h:182
static const int BLOCKSIZE
Block size, in bytes.
Definition lsh.h:185
std::string AlgorithmName() const
Provides the name of this algorithm.
Definition lsh.h:199
static std::string StaticAlgorithmName()
The algorithm's name.
Definition lsh.h:193
LSH-512-256 hash function.
Definition lsh.h:236
static const int BLOCKSIZE
Block size, in bytes.
Definition lsh.h:243
std::string AlgorithmName() const
Provides the name of this algorithm.
Definition lsh.h:257
LSH512_256()
Construct a LSH-512-256.
Definition lsh.h:255
static std::string StaticAlgorithmName()
The algorithm's name.
Definition lsh.h:251
static const int DIGESTSIZE
Digest size, in bytes.
Definition lsh.h:240
LSH-384 and LSH-512 hash base class.
Definition lsh.h:135
static const int BLOCKSIZE
Block size, in bytes.
Definition lsh.h:139
unsigned int OptimalDataAlignment() const
Provides input and output data alignment for optimal performance.
Definition lsh.h:145
void Restart()
Restart the hash.
unsigned int DigestSize() const
Provides the digest size of the hash.
Definition lsh.h:144
std::string AlgorithmProvider() const
Retrieve the provider of this algorithm.
void TruncatedFinal(byte *hash, size_t size)
Computes the hash of the current message.
void Update(const byte *input, size_t size)
Updates a hash with additional input.
unsigned int BlockSize() const
Provides the block size of the compression function.
Definition lsh.h:143
LSH-512 hash function.
Definition lsh.h:207
LSH512()
Construct a LSH-512.
Definition lsh.h:226
std::string AlgorithmName() const
Provides the name of this algorithm.
Definition lsh.h:228
static std::string StaticAlgorithmName()
The algorithm's name.
Definition lsh.h:222
static const int BLOCKSIZE
Block size, in bytes.
Definition lsh.h:214
static const int DIGESTSIZE
Digest size, in bytes.
Definition lsh.h:211
unsigned int word32
32-bit unsigned datatype
Definition config_int.h:72
Abstract base classes that provide a uniform interface to this library.
Crypto++ library namespace.
Classes and functions for secure memory allocations.