osrng.h

Go to the documentation of this file.

// osrng.h - originally written and placed in the public domain by Wei Dai
 
 
#ifndef CRYPTOPP_OSRNG_H
#define CRYPTOPP_OSRNG_H
 
#include "config.h"
 
#if !defined(NO_OS_DEPENDENCE) && defined(OS_RNG_AVAILABLE)
 
#include "cryptlib.h"
#include "randpool.h"
#include "smartptr.h"
#include "fips140.h"
#include "hkdf.h"
#include "rng.h"
#include "aes.h"
#include "sha.h"
 
NAMESPACE_BEGIN(CryptoPP)
 
 
class CRYPTOPP_DLL OS_RNG_Err : public Exception
{
public:
        OS_RNG_Err(const std::string &operation);
};
 
#ifdef NONBLOCKING_RNG_AVAILABLE
 
#ifdef CRYPTOPP_WIN32_AVAILABLE
class CRYPTOPP_DLL MicrosoftCryptoProvider
{
public:
        MicrosoftCryptoProvider();
        ~MicrosoftCryptoProvider();
 
// type HCRYPTPROV and BCRYPT_ALG_HANDLE, avoid #include <windows.h>
#if defined(USE_MS_CRYPTOAPI)
# if defined(__CYGWIN__) && defined(__x86_64__)
        typedef unsigned long long ProviderHandle;
# elif defined(WIN64) || defined(_WIN64)
        typedef unsigned __int64 ProviderHandle;
# else
        typedef unsigned long ProviderHandle;
# endif
#elif defined(USE_MS_CNGAPI)
        typedef void *PVOID;
        typedef PVOID ProviderHandle;
#endif // USE_MS_CRYPTOAPI or USE_MS_CNGAPI
 
        ProviderHandle GetProviderHandle() const {return m_hProvider;}
 
private:
        ProviderHandle m_hProvider;
};
 
#if defined(_MSC_VER) && defined(USE_MS_CRYPTOAPI)
# pragma comment(lib, "advapi32.lib")
#endif
 
#if defined(_MSC_VER) && defined(USE_MS_CNGAPI)
# pragma comment(lib, "bcrypt.lib")
#endif
 
#endif // CRYPTOPP_WIN32_AVAILABLE
 
class CRYPTOPP_DLL NonblockingRng : public RandomNumberGenerator
{
public:
        CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() { return "NonblockingRng"; }
 
        ~NonblockingRng();
 
        NonblockingRng();
 
        void GenerateBlock(byte *output, size_t size);
 
protected:
#ifdef CRYPTOPP_WIN32_AVAILABLE
        MicrosoftCryptoProvider m_Provider;
#else
        int m_fd;
#endif
};
 
#endif
 
#if defined(BLOCKING_RNG_AVAILABLE) || defined(CRYPTOPP_DOXYGEN_PROCESSING)
 
class CRYPTOPP_DLL BlockingRng : public RandomNumberGenerator
{
public:
        CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() { return "BlockingRng"; }
 
        ~BlockingRng();
 
        BlockingRng();
 
        void GenerateBlock(byte *output, size_t size);
 
protected:
        int m_fd;
};
 
#endif
 
CRYPTOPP_DLL void CRYPTOPP_API OS_GenerateRandomBlock(bool blocking, byte *output, size_t size);
 
class CRYPTOPP_DLL AutoSeededRandomPool : public RandomPool
{
public:
        CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() { return "AutoSeededRandomPool"; }
 
        ~AutoSeededRandomPool() {}
 
        explicit AutoSeededRandomPool(bool blocking = false, unsigned int seedSize = 32)
                {Reseed(blocking, seedSize);}
 
        void Reseed(bool blocking = false, unsigned int seedSize = 32);
};
 
template <class BLOCK_CIPHER>
class AutoSeededX917RNG : public RandomNumberGenerator, public NotCopyable
{
public:
        static std::string StaticAlgorithmName() {
                return std::string("AutoSeededX917RNG(") + BLOCK_CIPHER::StaticAlgorithmName() + std::string(")");
        }
 
        ~AutoSeededX917RNG() {}
 
        explicit AutoSeededX917RNG(bool blocking = false, bool autoSeed = true)
                {if (autoSeed) Reseed(blocking);}
 
        void Reseed(bool blocking = false, const byte *input = NULLPTR, size_t length = 0);
 
        void Reseed(const byte *key, size_t keylength, const byte *seed, const byte *timeVector);
 
        bool CanIncorporateEntropy() const {return true;}
        void IncorporateEntropy(const byte *input, size_t length) {Reseed(false, input, length);}
        void GenerateIntoBufferedTransformation(BufferedTransformation &target, const std::string &channel, lword length)
                {m_rng->GenerateIntoBufferedTransformation(target, channel, length);}
 
        std::string AlgorithmProvider() const;
 
private:
        member_ptr<RandomNumberGenerator> m_rng;
};
 
template <class BLOCK_CIPHER>
void AutoSeededX917RNG<BLOCK_CIPHER>::Reseed(const byte *key, size_t keylength, const byte *seed, const byte *timeVector)
{
        m_rng.reset(new X917RNG(new typename BLOCK_CIPHER::Encryption(key, keylength), seed, timeVector));
}
 
template <class BLOCK_CIPHER>
void AutoSeededX917RNG<BLOCK_CIPHER>::Reseed(bool blocking, const byte *input, size_t length)
{
        enum {BlockSize=BLOCK_CIPHER::BLOCKSIZE};
        enum {KeyLength=BLOCK_CIPHER::DEFAULT_KEYLENGTH};
        enum {SeedSize=EnumToInt(BlockSize)+EnumToInt(KeyLength)};
 
        SecByteBlock seed(SeedSize), temp(SeedSize);
        const byte label[] = "X9.17 key generation";
        const byte *key=NULLPTR;
 
        do
        {
                OS_GenerateRandomBlock(blocking, temp, temp.size());
 
                HKDF<SHA256> hkdf;
                hkdf.DeriveKey(
                        seed, seed.size(),  // derived secret
                        temp, temp.size(),  // instance secret
                        input, length,      // user secret
                        label, 20           // unique label
                );
 
                key = seed + BlockSize;
        }       // check that seed and key don't have same value
        while (memcmp(key, seed, STDMIN((size_t)BlockSize, (size_t)KeyLength)) == 0);
 
        Reseed(key, KeyLength, seed, NULLPTR);
}
 
template <class BLOCK_CIPHER>
std::string AutoSeededX917RNG<BLOCK_CIPHER>::AlgorithmProvider() const
{
        // Hack for now... We need to instantiate one
        typename BLOCK_CIPHER::Encryption bc;
        return bc.AlgorithmProvider();
}
 
CRYPTOPP_DLL_TEMPLATE_CLASS AutoSeededX917RNG<AES>;
 
#if defined(CRYPTOPP_DOXYGEN_PROCESSING)
class DefaultAutoSeededRNG {}
#else
// AutoSeededX917RNG<AES> in FIPS mode, otherwise it's AutoSeededRandomPool
#if CRYPTOPP_ENABLE_COMPLIANCE_WITH_FIPS_140_2
typedef AutoSeededX917RNG<AES> DefaultAutoSeededRNG;
#else
typedef AutoSeededRandomPool DefaultAutoSeededRNG;
#endif
#endif // CRYPTOPP_DOXYGEN_PROCESSING
 
NAMESPACE_END
 
#endif
 
#endif