shake.h

Go to the documentation of this file.

// shake.h - written and placed in the public domain by Jeffrey Walton
 
 
#ifndef CRYPTOPP_SHAKE_H
#define CRYPTOPP_SHAKE_H
 
#include "cryptlib.h"
#include "secblock.h"
 
NAMESPACE_BEGIN(CryptoPP)
 
 
class SHAKE : public HashTransformation
{
protected:
    SHAKE(unsigned int digestSize) : m_digestSize(digestSize) {Restart();}
 
public:
    unsigned int DigestSize() const {return m_digestSize;}
    unsigned int OptimalDataAlignment() const {return GetAlignmentOf<word64>();}
 
    void Update(const byte *input, size_t length);
    void Restart();
    void TruncatedFinal(byte *hash, size_t size);
 
protected:
    inline unsigned int r() const {return BlockSize();}
 
    // SHAKE-128 and SHAKE-256 effectively allow unlimited
    // output length. However, we use an unsigned int so
    // we are limited in practice to UINT_MAX.
    void ThrowIfInvalidTruncatedSize(size_t size) const;
 
    FixedSizeSecBlock<word64, 25> m_state;
    unsigned int m_digestSize, m_counter;
};
 
template<unsigned int T_Strength>
class SHAKE_Final : public SHAKE
{
public:
    CRYPTOPP_CONSTANT(DIGESTSIZE = (T_Strength == 128 ? 32 : 64));
    CRYPTOPP_CONSTANT(BLOCKSIZE = (T_Strength == 128 ? 1344/8 : 1088/8));
    static std::string StaticAlgorithmName()
        { return "SHAKE-" + IntToString(T_Strength); }
 
    SHAKE_Final(unsigned int outputSize=DIGESTSIZE) : SHAKE(outputSize) {}
 
    unsigned int BlockSize() const { return BLOCKSIZE; }
 
    std::string AlgorithmName() const { return StaticAlgorithmName(); }
 
private:
#if !defined(__BORLANDC__)
    // ensure there was no underflow in the math
    CRYPTOPP_COMPILE_ASSERT(BLOCKSIZE < 200);
#endif
};
 
class SHAKE128 : public SHAKE_Final<128>
{
public:
    SHAKE128() {}
 
    SHAKE128(unsigned int outputSize) : SHAKE_Final<128>(outputSize) {}
};
 
class SHAKE256 : public SHAKE_Final<256>
{
public:
    SHAKE256() {}
 
    SHAKE256(unsigned int outputSize) : SHAKE_Final<256>(outputSize) {}
};
 
NAMESPACE_END
 
#endif