Martchus
/
passwordfile
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Adapt to c++utilities v5

This commit is contained in:
Marius Kittler 2019-03-13 19:08:30 +01:00 committed by Martchus
parent 986ceaf567
commit 0754760b19
8 changed files with 52 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
CMakeLists.txt
View File

@ -35,29 +35,21 @@ set(META_APP_NAME "Passwordfile library")
set(META_APP_AUTHOR "Martchus") set(META_APP_AUTHOR "Martchus")
set(META_APP_URL "https://github.com/${META_APP_AUTHOR}/${META_PROJECT_NAME}") set(META_APP_URL "https://github.com/${META_APP_AUTHOR}/${META_PROJECT_NAME}")
set(META_APP_DESCRIPTION "C++ library to read/write passwords from/to encrypted files") set(META_APP_DESCRIPTION "C++ library to read/write passwords from/to encrypted files")
set(META_VERSION_MAJOR 4) set(META_VERSION_MAJOR 5)
set(META_VERSION_MINOR 0) set(META_VERSION_MINOR 0)
set(META_VERSION_PATCH 1) set(META_VERSION_PATCH 0)
set(META_PUBLIC_SHARED_LIB_DEPENDS c++utilities)
set(META_PUBLIC_STATIC_LIB_DEPENDS c++utilities_static)
set(META_ADD_DEFAULT_CPP_UNIT_TEST_APPLICATION ON) set(META_ADD_DEFAULT_CPP_UNIT_TEST_APPLICATION ON)
# find c++utilities # find c++utilities
find_package(c++utilities 4.17.0 REQUIRED) set(CONFIGURATION_PACKAGE_SUFFIX ""
use_cpp_utilities() CACHE STRING "sets the suffix for find_package() calls to packages configured via c++utilities")
find_package(c++utilities${CONFIGURATION_PACKAGE_SUFFIX} 5.0.0 REQUIRED)
use_cpp_utilities(VISIBILITY PUBLIC)
# find 3rd party libraries # find 3rd party libraries
include(3rdParty) include(3rdParty)
# zlib use_zlib()
use_external_library_from_package(z ZLIB ANY_VERSION ZLIB_INCLUDE_DIRS ZLIB_LIBRARIES AUTO_LINKAGE REQUIRED) use_crypto()
# crypto library from OpenSSL
use_external_library_from_package(crypto
OpenSSL
ANY_VERSION
OPENSSL_INCLUDE_DIR
OPENSSL_CRYPTO_LIBRARY
AUTO_LINKAGE
REQUIRED)
# include modules to apply configuration # include modules to apply configuration
include(BasicConfig) include(BasicConfig)

22
io/entry.cpp
View File

@ -176,7 +176,7 @@ void Entry::path(std::list<string> &res) const
*/ */
Entry *Entry::parse(istream &stream) Entry *Entry::parse(istream &stream)
{ {
const auto version = static_cast<byte>(stream.peek()); const auto version = static_cast<std::uint8_t>(stream.peek());
if (denotesNodeEntry(version)) { if (denotesNodeEntry(version)) {
return new NodeEntry(stream); return new NodeEntry(stream);
} else { } else {
@ -231,7 +231,7 @@ NodeEntry::NodeEntry(istream &stream)
: m_expandedByDefault(true) : m_expandedByDefault(true)
{ {
BinaryReader reader(&stream); BinaryReader reader(&stream);
const byte version = reader.readByte(); const std::uint8_t version = reader.readByte();
if (!denotesNodeEntry(version)) { if (!denotesNodeEntry(version)) {
throw ParsingException("Node entry expected."); throw ParsingException("Node entry expected.");
} }
@ -241,16 +241,16 @@ NodeEntry::NodeEntry(istream &stream)
setLabel(reader.readLengthPrefixedString()); setLabel(reader.readLengthPrefixedString());
// read extended header for version 0x1 // read extended header for version 0x1
if (version == 0x1) { if (version == 0x1) {
uint16 extendedHeaderSize = reader.readUInt16BE(); std::uint16_t extendedHeaderSize = reader.readUInt16BE();
if (extendedHeaderSize >= 1) { if (extendedHeaderSize >= 1) {
byte flags = reader.readByte(); std::uint8_t flags = reader.readByte();
m_expandedByDefault = flags & 0x80; m_expandedByDefault = flags & 0x80;
extendedHeaderSize -= 1; extendedHeaderSize -= 1;
} }
m_extendedData = reader.readString(extendedHeaderSize); m_extendedData = reader.readString(extendedHeaderSize);
} }
const uint32 childCount = reader.readUInt32BE(); const std::uint32_t childCount = reader.readUInt32BE();
for (uint32 i = 0; i != childCount; ++i) { for (std::uint32_t i = 0; i != childCount; ++i) {
Entry::parse(stream)->setParent(this); Entry::parse(stream)->setParent(this);
} }
} }
@ -400,7 +400,7 @@ void NodeEntry::make(ostream &stream) const
writer.writeLengthPrefixedString(label()); writer.writeLengthPrefixedString(label());
if (!isExpandedByDefault() || !m_extendedData.empty()) { if (!isExpandedByDefault() || !m_extendedData.empty()) {
writer.writeUInt16BE(1 + m_extendedData.size()); // extended header is 1 byte long writer.writeUInt16BE(1 + m_extendedData.size()); // extended header is 1 byte long
byte flags = 0x00; std::uint8_t flags = 0x00;
if (isExpandedByDefault()) { if (isExpandedByDefault()) {
flags |= 0x80; flags |= 0x80;
} }
@ -452,7 +452,7 @@ AccountEntry::AccountEntry(const string &label, NodeEntry *parent)
AccountEntry::AccountEntry(istream &stream) AccountEntry::AccountEntry(istream &stream)
{ {
BinaryReader reader(&stream); BinaryReader reader(&stream);
byte version = reader.readByte(); std::uint8_t version = reader.readByte();
if (denotesNodeEntry(version)) { if (denotesNodeEntry(version)) {
throw ParsingException("Account entry expected."); throw ParsingException("Account entry expected.");
} }
@ -463,12 +463,12 @@ AccountEntry::AccountEntry(istream &stream)
setLabel(reader.readLengthPrefixedString()); setLabel(reader.readLengthPrefixedString());
// read extended header for version 0x1 // read extended header for version 0x1
if (version == 0x1) { if (version == 0x1) {
const uint16 extendedHeaderSize = reader.readUInt16BE(); const std::uint16_t extendedHeaderSize = reader.readUInt16BE();
// currently there's nothing to read here // currently there's nothing to read here
m_extendedData = reader.readString(extendedHeaderSize); m_extendedData = reader.readString(extendedHeaderSize);
} }
const uint32 fieldCount = reader.readUInt32BE(); const std::uint32_t fieldCount = reader.readUInt32BE();
for (uint32 i = 0; i != fieldCount; ++i) { for (std::uint32_t i = 0; i != fieldCount; ++i) {
m_fields.push_back(Field(this, stream)); m_fields.push_back(Field(this, stream));
} }
} }

11
io/entry.h
View File

@ -3,8 +3,7 @@
#include "./field.h" #include "./field.h"
#include <c++utilities/conversion/types.h> #include <cstdint>
#include <iostream> #include <iostream>
#include <list> #include <list>
#include <string> #include <string>
@ -49,8 +48,8 @@ public:
EntryStatistics computeStatistics() const; EntryStatistics computeStatistics() const;
virtual void accumulateStatistics(EntryStatistics &stats) const = 0; virtual void accumulateStatistics(EntryStatistics &stats) const = 0;
static Entry *parse(std::istream &stream); static Entry *parse(std::istream &stream);
static bool denotesNodeEntry(byte version); static bool denotesNodeEntry(std::uint8_t version);
static constexpr EntryType denotedEntryType(byte version); static constexpr EntryType denotedEntryType(std::uint8_t version);
protected: protected:
Entry(const std::string &label = std::string(), NodeEntry *parent = nullptr); Entry(const std::string &label = std::string(), NodeEntry *parent = nullptr);
@ -158,12 +157,12 @@ inline void NodeEntry::setExpandedByDefault(bool expandedByDefault)
m_expandedByDefault = expandedByDefault; m_expandedByDefault = expandedByDefault;
} }
inline bool Entry::denotesNodeEntry(byte version) inline bool Entry::denotesNodeEntry(std::uint8_t version)
{ {
return (version & 0x80) == 0; return (version & 0x80) == 0;
} }
constexpr EntryType Entry::denotedEntryType(byte version) constexpr EntryType Entry::denotedEntryType(std::uint8_t version)
{ {
return (version & 0x80) == 0 ? EntryType::Node : EntryType::Account; return (version & 0x80) == 0 ? EntryType::Node : EntryType::Account;
} }

6
io/field.cpp
View File

@ -42,14 +42,14 @@ Field::Field(AccountEntry *tiedAccount, istream &stream)
} }
m_name = reader.readLengthPrefixedString(); m_name = reader.readLengthPrefixedString();
m_value = reader.readLengthPrefixedString(); m_value = reader.readLengthPrefixedString();
byte type = reader.readByte(); std::uint8_t type = reader.readByte();
if (!isValidType(type)) { if (!isValidType(type)) {
throw ParsingException("Field type is not supported."); throw ParsingException("Field type is not supported.");
} }
m_type = static_cast<FieldType>(type); m_type = static_cast<FieldType>(type);
// read extended header for version 0x1 // read extended header for version 0x1
if (version == 0x1) { if (version == 0x1) {
const uint16 extendedHeaderSize = reader.readUInt16BE(); const std::uint16_t extendedHeaderSize = reader.readUInt16BE();
// currently there's nothing to read here // currently there's nothing to read here
m_extendedData = reader.readString(extendedHeaderSize); m_extendedData = reader.readString(extendedHeaderSize);
} }
@ -65,7 +65,7 @@ void Field::make(ostream &stream) const
writer.writeByte(m_extendedData.empty() ? 0x0 : 0x1); // version writer.writeByte(m_extendedData.empty() ? 0x0 : 0x1); // version
writer.writeLengthPrefixedString(m_name); writer.writeLengthPrefixedString(m_name);
writer.writeLengthPrefixedString(m_value); writer.writeLengthPrefixedString(m_value);
writer.writeByte(static_cast<byte>(m_type)); writer.writeByte(static_cast<std::uint8_t>(m_type));
if (!m_extendedData.empty()) { if (!m_extendedData.empty()) {
writer.writeUInt16BE(m_extendedData.size()); writer.writeUInt16BE(m_extendedData.size());
writer.writeString(m_extendedData); writer.writeString(m_extendedData);

28
io/passwordfile.cpp
View File

@ -8,7 +8,6 @@
#include <c++utilities/conversion/stringbuilder.h> #include <c++utilities/conversion/stringbuilder.h>
#include <c++utilities/conversion/stringconversion.h> #include <c++utilities/conversion/stringconversion.h>
#include <c++utilities/io/catchiofailure.h>
#include <openssl/conf.h> #include <openssl/conf.h>
#include <openssl/err.h> #include <openssl/err.h>
@ -118,7 +117,7 @@ void PasswordFile::open(PasswordFileOpenFlags options)
{ {
close(); close();
if (m_path.empty()) { if (m_path.empty()) {
throwIoFailure("Unable to open file because path is emtpy."); throw std::ios_base::failure("Unable to open file because path is emtpy.");
} }
m_file.open( m_file.open(
m_path, options & PasswordFileOpenFlags::ReadOnly ? ios_base::in | ios_base::binary : ios_base::in | ios_base::out | ios_base::binary); m_path, options & PasswordFileOpenFlags::ReadOnly ? ios_base::in | ios_base::binary : ios_base::in | ios_base::out | ios_base::binary);
@ -135,7 +134,7 @@ void PasswordFile::opened()
{ {
m_file.seekg(0, ios_base::end); m_file.seekg(0, ios_base::end);
if (m_file.tellg() == 0) { if (m_file.tellg() == 0) {
throwIoFailure("File is empty."); throw std::ios_base::failure("File is empty.");
} else { } else {
m_file.seekg(0); m_file.seekg(0);
} }
@ -159,7 +158,7 @@ void PasswordFile::create()
{ {
close(); close();
if (m_path.empty()) { if (m_path.empty()) {
throwIoFailure("Unable to create file because path is empty."); throw std::ios_base::failure("Unable to create file because path is empty.");
} }
m_file.open(m_path, fstream::out | fstream::trunc | fstream::binary); m_file.open(m_path, fstream::out | fstream::trunc | fstream::binary);
} }
@ -216,7 +215,7 @@ void PasswordFile::load()
// (the extended header might be used in further versions to // (the extended header might be used in further versions to
// add additional information without breaking compatibility) // add additional information without breaking compatibility)
if (m_version >= 0x4U) { if (m_version >= 0x4U) {
uint16 extendedHeaderSize = m_freader.readUInt16BE(); std::uint16_t extendedHeaderSize = m_freader.readUInt16BE();
m_extendedHeader = m_freader.readString(extendedHeaderSize); m_extendedHeader = m_freader.readString(extendedHeaderSize);
} else { } else {
m_extendedHeader.clear(); m_extendedHeader.clear();
@ -362,12 +361,11 @@ void PasswordFile::load()
m_encryptedExtendedHeader.clear(); m_encryptedExtendedHeader.clear();
} }
m_rootEntry.reset(new NodeEntry(decryptedStream)); m_rootEntry.reset(new NodeEntry(decryptedStream));
} catch (...) { } catch (const std::ios_base::failure &failure) {
const char *const what = catchIoFailure();
if (decryptedStream.eof()) { if (decryptedStream.eof()) {
throw ParsingException("The file seems to be truncated."); throw ParsingException("The file seems to be truncated.");
} }
throw ParsingException(argsToString("An IO error occurred when reading internal buffer: ", what)); throw ParsingException(argsToString("An IO error occurred when reading internal buffer: ", failure.what()));
} }
} }
@ -375,7 +373,7 @@ void PasswordFile::load()
* \brief Returns the minimum file version required to write the current instance with the specified \a options. * \brief Returns the minimum file version required to write the current instance with the specified \a options.
* \remarks This version will be used by save() and write() when passing the same \a options. * \remarks This version will be used by save() and write() when passing the same \a options.
*/ */
uint32 PasswordFile::mininumVersion(PasswordFileSaveFlags options) const std::uint32_t PasswordFile::mininumVersion(PasswordFileSaveFlags options) const
{ {
if (options & PasswordFileSaveFlags::PasswordHashing) { if (options & PasswordFileSaveFlags::PasswordHashing) {
return 0x6U; // password hashing requires at least version 6 return 0x6U; // password hashing requires at least version 6
@ -434,7 +432,7 @@ void PasswordFile::write(PasswordFileSaveFlags options)
m_fwriter.writeUInt32LE(version); m_fwriter.writeUInt32LE(version);
// write flags // write flags
byte flags = 0x00; std::uint8_t flags = 0x00;
if (options & PasswordFileSaveFlags::Encryption) { if (options & PasswordFileSaveFlags::Encryption) {
flags |= 0x80 | 0x40; flags |= 0x80 | 0x40;
} }
@ -445,10 +443,10 @@ void PasswordFile::write(PasswordFileSaveFlags options)
// write extened header // write extened header
if (version >= 0x4U) { if (version >= 0x4U) {
if (m_extendedHeader.size() > numeric_limits<uint16>::max()) { if (m_extendedHeader.size() > numeric_limits<std::uint16_t>::max()) {
throw runtime_error("Extended header exceeds maximum size."); throw runtime_error("Extended header exceeds maximum size.");
} }
m_fwriter.writeUInt16BE(static_cast<uint16>(m_extendedHeader.size())); m_fwriter.writeUInt16BE(static_cast<std::uint16_t>(m_extendedHeader.size()));
m_fwriter.writeString(m_extendedHeader); m_fwriter.writeString(m_extendedHeader);
} }
@ -458,11 +456,11 @@ void PasswordFile::write(PasswordFileSaveFlags options)
// write encrypted extened header // write encrypted extened header
if (version >= 0x5U) { if (version >= 0x5U) {
if (m_encryptedExtendedHeader.size() > numeric_limits<uint16>::max()) { if (m_encryptedExtendedHeader.size() > numeric_limits<std::uint16_t>::max()) {
throw runtime_error("Encrypted extended header exceeds maximum size."); throw runtime_error("Encrypted extended header exceeds maximum size.");
} }
BinaryWriter buffstrWriter(&buffstr); BinaryWriter buffstrWriter(&buffstr);
buffstrWriter.writeUInt16BE(static_cast<uint16>(m_encryptedExtendedHeader.size())); buffstrWriter.writeUInt16BE(static_cast<std::uint16_t>(m_encryptedExtendedHeader.size()));
buffstrWriter.writeString(m_encryptedExtendedHeader); buffstrWriter.writeString(m_encryptedExtendedHeader);
} }
m_rootEntry->make(buffstr); m_rootEntry->make(buffstr);
@ -479,7 +477,7 @@ void PasswordFile::write(PasswordFileSaveFlags options)
if (options & PasswordFileSaveFlags::Compression) { if (options & PasswordFileSaveFlags::Compression) {
uLongf compressedSize = compressBound(size); uLongf compressedSize = compressBound(size);
encryptedData.resize(8 + compressedSize); encryptedData.resize(8 + compressedSize);
ConversionUtilities::LE::getBytes(static_cast<uint64>(size), encryptedData.data()); ConversionUtilities::LE::getBytes(static_cast<std::uint64_t>(size), encryptedData.data());
switch ( switch (
compress(reinterpret_cast<Bytef *>(encryptedData.data() + 8), &compressedSize, reinterpret_cast<Bytef *>(decryptedData.data()), size)) { compress(reinterpret_cast<Bytef *>(encryptedData.data() + 8), &compressedSize, reinterpret_cast<Bytef *>(decryptedData.data()), size)) {
case Z_MEM_ERROR: case Z_MEM_ERROR:

13
io/passwordfile.h
View File

@ -7,6 +7,7 @@
#include <c++utilities/io/binarywriter.h> #include <c++utilities/io/binarywriter.h>
#include <c++utilities/io/nativefilestream.h> #include <c++utilities/io/nativefilestream.h>
#include <cstdint>
#include <fstream> #include <fstream>
#include <iostream> #include <iostream>
#include <memory> #include <memory>
@ -16,7 +17,7 @@ namespace Io {
class NodeEntry; class NodeEntry;
enum class PasswordFileOpenFlags : uint64 { enum class PasswordFileOpenFlags : std::uint64_t {
None = 0, None = 0,
ReadOnly = 1, ReadOnly = 1,
Default = None, Default = None,
@ -42,7 +43,7 @@ constexpr bool operator&(PasswordFileOpenFlags lhs, PasswordFileOpenFlags rhs)
static_cast<std::underlying_type<PasswordFileOpenFlags>::type>(lhs) & static_cast<std::underlying_type<PasswordFileOpenFlags>::type>(rhs)); static_cast<std::underlying_type<PasswordFileOpenFlags>::type>(lhs) & static_cast<std::underlying_type<PasswordFileOpenFlags>::type>(rhs));
} }
enum class PasswordFileSaveFlags : uint64 { enum class PasswordFileSaveFlags : std::uint64_t {
None = 0, None = 0,
Encryption = 1, Encryption = 1,
Compression = 2, Compression = 2,
@ -84,7 +85,7 @@ public:
void create(); void create();
void close(); void close();
void load(); void load();
uint32 mininumVersion(PasswordFileSaveFlags options) const; std::uint32_t mininumVersion(PasswordFileSaveFlags options) const;
void save(PasswordFileSaveFlags options = PasswordFileSaveFlags::Default); void save(PasswordFileSaveFlags options = PasswordFileSaveFlags::Default);
void write(PasswordFileSaveFlags options = PasswordFileSaveFlags::Default); void write(PasswordFileSaveFlags options = PasswordFileSaveFlags::Default);
void clearEntries(); void clearEntries();
@ -108,7 +109,7 @@ public:
std::string &encryptedExtendedHeader(); std::string &encryptedExtendedHeader();
const std::string &encryptedExtendedHeader() const; const std::string &encryptedExtendedHeader() const;
std::size_t size(); std::size_t size();
uint32 version() const; std::uint32_t version() const;
PasswordFileOpenFlags openOptions() const; PasswordFileOpenFlags openOptions() const;
PasswordFileSaveFlags saveOptions() const; PasswordFileSaveFlags saveOptions() const;
std::string summary(PasswordFileSaveFlags saveOptions) const; std::string summary(PasswordFileSaveFlags saveOptions) const;
@ -122,7 +123,7 @@ private:
IoUtilities::NativeFileStream m_file; IoUtilities::NativeFileStream m_file;
IoUtilities::BinaryReader m_freader; IoUtilities::BinaryReader m_freader;
IoUtilities::BinaryWriter m_fwriter; IoUtilities::BinaryWriter m_fwriter;
uint32 m_version; std::uint32_t m_version;
PasswordFileOpenFlags m_openOptions; PasswordFileOpenFlags m_openOptions;
PasswordFileSaveFlags m_saveOptions; PasswordFileSaveFlags m_saveOptions;
}; };
@ -228,7 +229,7 @@ inline const std::string &PasswordFile::encryptedExtendedHeader() const
* \brief Returns the file version used the last time when saving the file (the version of the file as it is on the disk). * \brief Returns the file version used the last time when saving the file (the version of the file as it is on the disk).
* \remarks The version might change when re-saving with different options. See mininumVersion(). * \remarks The version might change when re-saving with different options. See mininumVersion().
*/ */
inline uint32 PasswordFile::version() const inline std::uint32_t PasswordFile::version() const
{ {
return m_version; return m_version;
} }

6
tests/passwordfiletests.cpp
View File

@ -124,17 +124,17 @@ void PasswordFileTests::testReading(const string &context, const string &testfil
const NodeEntry *const rootEntry2 = file.rootEntry(); const NodeEntry *const rootEntry2 = file.rootEntry();
if (testfilesMod) { if (testfilesMod) {
if (extendedHeaderMod) { if (extendedHeaderMod) {
CPPUNIT_ASSERT_EQUAL_MESSAGE(context, static_cast<uint32>(6), file.version()); CPPUNIT_ASSERT_EQUAL_MESSAGE(context, static_cast<std::uint32_t>(6), file.version());
CPPUNIT_ASSERT_EQUAL_MESSAGE(context, "encryption, password hashing"s, flagsToString(file.saveOptions())); CPPUNIT_ASSERT_EQUAL_MESSAGE(context, "encryption, password hashing"s, flagsToString(file.saveOptions()));
} else { } else {
CPPUNIT_ASSERT_EQUAL_MESSAGE(context, static_cast<uint32>(3), file.version()); CPPUNIT_ASSERT_EQUAL_MESSAGE(context, static_cast<std::uint32_t>(3), file.version());
CPPUNIT_ASSERT_EQUAL_MESSAGE(context, "encryption"s, flagsToString(file.saveOptions())); CPPUNIT_ASSERT_EQUAL_MESSAGE(context, "encryption"s, flagsToString(file.saveOptions()));
} }
CPPUNIT_ASSERT_EQUAL_MESSAGE(context, "testfile2 - modified"s, rootEntry2->label()); CPPUNIT_ASSERT_EQUAL_MESSAGE(context, "testfile2 - modified"s, rootEntry2->label());
CPPUNIT_ASSERT_EQUAL_MESSAGE(context, 2_st, rootEntry2->children().size()); CPPUNIT_ASSERT_EQUAL_MESSAGE(context, 2_st, rootEntry2->children().size());
CPPUNIT_ASSERT_EQUAL_MESSAGE(context, "newAccount"s, rootEntry2->children()[1]->label()); CPPUNIT_ASSERT_EQUAL_MESSAGE(context, "newAccount"s, rootEntry2->children()[1]->label());
} else { } else {
CPPUNIT_ASSERT_EQUAL_MESSAGE(context, static_cast<uint32>(3), file.version()); CPPUNIT_ASSERT_EQUAL_MESSAGE(context, static_cast<std::uint32_t>(3), file.version());
CPPUNIT_ASSERT_EQUAL_MESSAGE(context, "testfile2"s, rootEntry2->label()); CPPUNIT_ASSERT_EQUAL_MESSAGE(context, "testfile2"s, rootEntry2->label());
CPPUNIT_ASSERT_EQUAL_MESSAGE(context, 1_st, rootEntry2->children().size()); CPPUNIT_ASSERT_EQUAL_MESSAGE(context, 1_st, rootEntry2->children().size());
} }

5
util/opensslrandomdevice.h
View File

@ -3,15 +3,14 @@
#include "../global.h" #include "../global.h"
#include <c++utilities/conversion/types.h> #include <cstdint>
#include <limits> #include <limits>
namespace Util { namespace Util {
class PASSWORD_FILE_EXPORT OpenSslRandomDevice { class PASSWORD_FILE_EXPORT OpenSslRandomDevice {
public: public:
using result_type = uint32; using result_type = std::uint32_t;
OpenSslRandomDevice(); OpenSslRandomDevice();
result_type operator()() const; result_type operator()() const;