path: root/contrib/src/boost/uuid/seed_rng.hpp

// Boost seed_rng.hpp header file  ----------------------------------------------//


// Copyright 2007 Andy Tompkins.

// Distributed under the Boost Software License, Version 1.0. (See

// accompanying file LICENSE_1_0.txt or copy at

// http://www.boost.org/LICENSE_1_0.txt)


// Revision History

//  09 Nov 2007 - Initial Revision

//  25 Feb 2008 - moved to namespace boost::uuids::detail

//  28 Nov 2009 - disabled deprecated warnings for MSVC

//  28 Jul 2014 - fixed valgrind warnings and better entropy sources for MSVC


// seed_rng models a UniformRandomNumberGenerator (see Boost.Random).

// Random number generators are hard to seed well.  This is intended to provide

// good seed values for random number generators.

// It creates random numbers from a sha1 hash of data from a variary of sources,

// all of which are standard function calls.  It produces random numbers slowly.

// Peter Dimov provided the details of sha1_random_digest_().

// see http://archives.free.net.ph/message/20070507.175609.4c4f503a.en.html


#ifndef BOOST_UUID_SEED_RNG_HPP

#define BOOST_UUID_SEED_RNG_HPP


#include <boost/config.hpp>

#include <cstring> // for memcpy

#include <limits>

#include <ctime> // for time_t, time, clock_t, clock

#include <cstdlib> // for rand

#include <cstdio> // for FILE, fopen, fread, fclose

#include <boost/core/noncopyable.hpp>

#include <boost/uuid/sha1.hpp>

//#include <boost/nondet_random.hpp> //forward declare boost::random::random_device


// can't use boost::generator_iterator since boost::random number seed(Iter&, Iter)

// functions need a last iterator

//#include <boost/generator_iterator.hpp>

# include <boost/iterator/iterator_facade.hpp>


#if defined(_MSC_VER)

#   pragma warning(push) // Save warning settings.

#   pragma warning(disable : 4996) // Disable deprecated std::fopen

#if defined(_WIN32_WCE)

#   pragma comment(lib, "coredll.lib")

#else

#   pragma comment(lib, "advapi32.lib")

#endif

#endif


#if defined(BOOST_WINDOWS)

#   include <boost/detail/winapi/crypt.hpp> // for CryptAcquireContextA, CryptGenRandom, CryptReleaseContext

#   include <boost/detail/winapi/timers.hpp>

#   include <boost/detail/winapi/get_current_process_id.hpp>

#   include <boost/detail/winapi/get_current_thread_id.hpp>

#else 

#   include <sys/time.h>  // for gettimeofday

#   include <sys/types.h> // for pid_t

#   include <unistd.h>    // for getpid()

#endif


#ifdef BOOST_NO_STDC_NAMESPACE

namespace std {
    using ::memcpy;
    using ::time_t;
    using ::time;
    using ::clock_t;
    using ::clock;
    using ::rand;
    using ::FILE;
    using ::fopen;
    using ::fread;
    using ::fclose;
} //namespace std

#endif


// forward declare random number generators

namespace boost { namespace random {
class random_device;
}} //namespace boost::random


namespace boost {
namespace uuids {
namespace detail {

// should this be part of Boost.Random?

class seed_rng: private boost::noncopyable
{
public:
    typedef unsigned int result_type;
    BOOST_STATIC_CONSTANT(bool, has_fixed_range = false);

public:
    // note: rd_ intentionally left uninitialized

    seed_rng() BOOST_NOEXCEPT
        : rd_index_(5)
        , random_(NULL)
    {
#if defined(BOOST_WINDOWS)

        if (!boost::detail::winapi::CryptAcquireContextW(
                    &random_,
                    NULL,
                    NULL,
                    boost::detail::winapi::PROV_RSA_FULL_,
                    boost::detail::winapi::CRYPT_VERIFYCONTEXT_ | boost::detail::winapi::CRYPT_SILENT_))
        {
            random_ = NULL;
        }
#else

        random_ = std::fopen( "/dev/urandom", "rb" );
#endif


        std::memset(rd_, 0, sizeof(rd_));
    }

    ~seed_rng() BOOST_NOEXCEPT
    {
        if (random_) {
#if defined(BOOST_WINDOWS)

            boost::detail::winapi::CryptReleaseContext(random_, 0);
#else

            std::fclose(random_);
#endif

        }
    }

    result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const BOOST_NOEXCEPT
    {
        return (std::numeric_limits<result_type>::min)();
    }
    result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const BOOST_NOEXCEPT
    {
        return (std::numeric_limits<result_type>::max)();
    }

    result_type operator()()
    {
        if (rd_index_ >= 5) {
            //get new digest

            sha1_random_digest_();

            rd_index_ = 0;
        }

        return rd_[rd_index_++];
    }

private:
    BOOST_STATIC_CONSTANT(std::size_t, internal_state_size = 5);
    inline void ignore_size(size_t) {}

    static unsigned int * sha1_random_digest_state_()
    {
        static unsigned int state[ internal_state_size ];
        return state;
    }

    void sha1_random_digest_()
    {
        boost::uuids::detail::sha1 sha;


        if (random_)
        {
            // intentionally left uninitialized

            unsigned char state[ 20 ];
#if defined(BOOST_WINDOWS)

            boost::detail::winapi::CryptGenRandom(random_, sizeof(state), state);
#else

            ignore_size(std::fread( state, 1, sizeof(state), random_ ));
#endif

            sha.process_bytes( state, sizeof( state ) );
        }

        {
            // Getting enropy from some system specific sources

#if defined(BOOST_WINDOWS)

            boost::detail::winapi::DWORD_ procid = boost::detail::winapi::GetCurrentProcessId();
            sha.process_bytes( (unsigned char const*)&procid, sizeof( procid ) );

            boost::detail::winapi::DWORD_ threadid = boost::detail::winapi::GetCurrentThreadId();
            sha.process_bytes( (unsigned char const*)&threadid, sizeof( threadid ) );

            boost::detail::winapi::LARGE_INTEGER_ ts;
            ts.QuadPart = 0;
            boost::detail::winapi::QueryPerformanceCounter( &ts );
            sha.process_bytes( (unsigned char const*)&ts, sizeof( ts ) );

            std::time_t tm = std::time( 0 );
            sha.process_bytes( (unsigned char const*)&tm, sizeof( tm ) );
#else

            pid_t pid = getpid();
            sha.process_bytes( (unsigned char const*)&pid, sizeof( pid ) );

            timeval ts;
            gettimeofday(&ts, NULL); // We do not use `clock_gettime` to avoid linkage with -lrt

            sha.process_bytes( (unsigned char const*)&ts, sizeof( ts ) );
#endif

        }


        unsigned int * ps = sha1_random_digest_state_();
        sha.process_bytes( ps, internal_state_size * sizeof( unsigned int ) );
        sha.process_bytes( (unsigned char const*)&ps, sizeof( ps ) );

        {
            std::clock_t ck = std::clock();
            sha.process_bytes( (unsigned char const*)&ck, sizeof( ck ) );
        }

        {
            unsigned int rn[] =
                { static_cast<unsigned int>(std::rand())
                , static_cast<unsigned int>(std::rand())
                , static_cast<unsigned int>(std::rand())
                };
            sha.process_bytes( (unsigned char const*)rn, sizeof( rn ) );
        }

        {
            unsigned int * p = new unsigned int;
            sha.process_bytes( (unsigned char const*)&p, sizeof( p ) );
            delete p;

            const seed_rng* this_ptr = this;
            sha.process_bytes( (unsigned char const*)&this_ptr, sizeof( this_ptr ) );
            sha.process_bytes( (unsigned char const*)&std::rand, sizeof( void(*)() ) );
        }

        sha.process_bytes( (unsigned char const*)rd_, sizeof( rd_ ) );

        unsigned int digest[ 5 ];
        sha.get_digest( digest );

        for( int i = 0; i < 5; ++i )
        {
            // harmless data race

            ps[ i ] ^= digest[ i ];
            rd_[ i ] ^= digest[ i ];
        }
    }

private:
    unsigned int rd_[5];
    int rd_index_;

#if defined(BOOST_WINDOWS)

    boost::detail::winapi::HCRYPTPROV_ random_;
#else

    std::FILE * random_;
#endif

};

// almost a copy of boost::generator_iterator

// but default constructor sets m_g to NULL

template <class Generator>
class generator_iterator
  : public iterator_facade<
        generator_iterator<Generator>
      , typename Generator::result_type
      , single_pass_traversal_tag
      , typename Generator::result_type const&
    >
{
    typedef iterator_facade<
        generator_iterator<Generator>
      , typename Generator::result_type
      , single_pass_traversal_tag
      , typename Generator::result_type const&
    > super_t;

 public:
    generator_iterator() : m_g(NULL), m_value(0) {}
    generator_iterator(Generator* g) : m_g(g), m_value((*m_g)()) {}

    void increment()
    {
        m_value = (*m_g)();
    }

    const typename Generator::result_type&
    dereference() const
    {
        return m_value;
    }

    bool equal(generator_iterator const& y) const
    {
        return this->m_g == y.m_g && this->m_value == y.m_value;
    }

 private:
    Generator* m_g;
    typename Generator::result_type m_value;
};

// seed() seeds a random number generator with good seed values


template <typename UniformRandomNumberGenerator>
inline void seed(UniformRandomNumberGenerator& rng)
{
    seed_rng seed_gen;
    generator_iterator<seed_rng> begin(&seed_gen);
    generator_iterator<seed_rng> end;
    rng.seed(begin, end);
}

// random_device does not / can not be seeded

template <>
inline void seed<boost::random::random_device>(boost::random::random_device&) {}

// random_device does not / can not be seeded

template <>
inline void seed<seed_rng>(seed_rng&) {}

}}} //namespace boost::uuids::detail


#if defined(_MSC_VER)

#pragma warning(pop) // Restore warnings to previous state.

#endif


#endif