lsh.h

Go to the documentation of this file.

// lsh.h - written and placed in the public domain by Jeffrey Walton
//         Based on the specification and source code provided by
//         Korea Internet & Security Agency (KISA) website. Also
//         see https://seed.kisa.or.kr/kisa/algorithm/EgovLSHInfo.do
//         and https://seed.kisa.or.kr/kisa/Board/22/detailView.do.
 
// We are hitting some sort of GCC bug in the LSH AVX2 code path.
// Clang is OK on the AVX2 code path. We believe it is GCC Issue
// 82735, https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82735. It
// makes using zeroupper a little tricky.
 
#ifndef CRYPTOPP_LSH_H
#define CRYPTOPP_LSH_H
 
#include "cryptlib.h"
#include "secblock.h"
 
// Enable SSE2 and AVX2 for 64-bit machines.
// 32-bit machines slow down with SSE2.
#if (CRYPTOPP_BOOL_X32) || (CRYPTOPP_BOOL_X64)
# define CRYPTOPP_ENABLE_64BIT_SSE 1
#endif
 
NAMESPACE_BEGIN(CryptoPP)
 
 
class LSH256_Base : public HashTransformation
{
public:
        CRYPTOPP_CONSTANT(BLOCKSIZE = 128);
 
        virtual ~LSH256_Base() {}
 
        unsigned int BlockSize() const { return BLOCKSIZE; }
        unsigned int DigestSize() const { return m_digestSize; }
        unsigned int OptimalDataAlignment() const { return GetAlignmentOf<word32>(); }
 
        void Restart();
        void Update(const byte *input, size_t size);
        void TruncatedFinal(byte *hash, size_t size);
 
        std::string AlgorithmProvider() const;
 
protected:
        LSH256_Base(unsigned int algType, unsigned int digestSize)
                : m_digestSize(digestSize) { m_state[80] = algType; }
 
protected:
        // Working state is:
        //   * cv_l = 8 32-bit words
        //   * cv_r = 8 32-bit words
        //   * submsg_e_l = 8 32-bit words
        //   * submsg_e_r = 8 32-bit words
        //   * submsg_o_l = 8 32-bit words
        //   * submsg_o_r = 8 32-bit words
        //   * last_block = 32 32-bit words (128 bytes)
        //   * algType
        //   * remainingBitLength
        FixedSizeSecBlock<word32, 80+2> m_state;
        // word32 m_algType, m_remainingBitLength;
        word32 m_digestSize;
};
 
class LSH224 : public LSH256_Base
{
public:
        CRYPTOPP_CONSTANT(DIGESTSIZE = 28);
        CRYPTOPP_CONSTANT(BLOCKSIZE = LSH256_Base::BLOCKSIZE);
 
        static std::string StaticAlgorithmName() { return "LSH-224"; }
 
        LSH224() : LSH256_Base(0x000001C, DIGESTSIZE) { Restart(); }
 
        std::string AlgorithmName() const { return StaticAlgorithmName(); }
};
 
class LSH256 : public LSH256_Base
{
public:
        CRYPTOPP_CONSTANT(DIGESTSIZE = 32);
        CRYPTOPP_CONSTANT(BLOCKSIZE = LSH256_Base::BLOCKSIZE);
 
        static std::string StaticAlgorithmName() { return "LSH-256"; }
 
        LSH256() : LSH256_Base(0x0000020, DIGESTSIZE) { Restart(); }
 
        std::string AlgorithmName() const { return StaticAlgorithmName(); }
};
 
class LSH512_Base : public HashTransformation
{
public:
        CRYPTOPP_CONSTANT(BLOCKSIZE = 256);
 
        virtual ~LSH512_Base() {}
 
        unsigned int BlockSize() const { return BLOCKSIZE; }
        unsigned int DigestSize() const { return m_digestSize; }
        unsigned int OptimalDataAlignment() const { return GetAlignmentOf<word64>(); }
 
        void Restart();
        void Update(const byte *input, size_t size);
        void TruncatedFinal(byte *hash, size_t size);
 
        std::string AlgorithmProvider() const;
 
protected:
        LSH512_Base(unsigned int algType, unsigned int digestSize)
                : m_digestSize(digestSize) { m_state[80] = algType; }
 
protected:
        // Working state is:
        //   * cv_l = 8 64-bit words
        //   * cv_r = 8 64-bit words
        //   * submsg_e_l = 8 64-bit words
        //   * submsg_e_r = 8 64-bit words
        //   * submsg_o_l = 8 64-bit words
        //   * submsg_o_r = 8 64-bit words
        //   * last_block = 32 64-bit words (256 bytes)
        //   * algType
        //   * remainingBitLength
        FixedSizeSecBlock<word64, 80+2> m_state;
        // word32 m_algType, m_remainingBitLength;
        word32 m_digestSize;
};
 
class LSH384 : public LSH512_Base
{
public:
        CRYPTOPP_CONSTANT(DIGESTSIZE = 48);
        CRYPTOPP_CONSTANT(BLOCKSIZE = LSH512_Base::BLOCKSIZE);
 
        static std::string StaticAlgorithmName() { return "LSH-384"; }
 
        LSH384() : LSH512_Base(0x0010030, DIGESTSIZE) { Restart(); }
 
        std::string AlgorithmName() const { return StaticAlgorithmName(); }
};
 
class LSH512 : public LSH512_Base
{
public:
        CRYPTOPP_CONSTANT(DIGESTSIZE = 64);
        CRYPTOPP_CONSTANT(BLOCKSIZE = LSH512_Base::BLOCKSIZE);
 
        static std::string StaticAlgorithmName() { return "LSH-512"; }
 
        LSH512() : LSH512_Base(0x0010040, DIGESTSIZE) { Restart(); }
 
        std::string AlgorithmName() const { return StaticAlgorithmName(); }
};
 
class LSH512_256 : public LSH512_Base
{
public:
        CRYPTOPP_CONSTANT(DIGESTSIZE = 32);
        CRYPTOPP_CONSTANT(BLOCKSIZE = LSH512_Base::BLOCKSIZE);
 
        static std::string StaticAlgorithmName() { return "LSH-512-256"; }
 
        LSH512_256() : LSH512_Base(0x0010020, DIGESTSIZE) { Restart(); }
 
        std::string AlgorithmName() const { return StaticAlgorithmName(); }
};
 
NAMESPACE_END
 
#endif  // CRYPTOPP_LSH_H