(this)->AccessSymmetricCipher();};
+
+ virtual SymmetricCipher & AccessSymmetricCipher() =0;
+ virtual bool AuthenticationIsOnPlaintext() const =0;
+ virtual unsigned int AuthenticationBlockSize() const =0;
+ virtual void SetKeyWithoutResync(const byte *userKey, size_t keylength, const NameValuePairs ¶ms) =0;
+ virtual void Resync(const byte *iv, size_t len) =0;
+ virtual size_t AuthenticateBlocks(const byte *data, size_t len) =0;
+ virtual void AuthenticateLastHeaderBlock() =0;
+ virtual void AuthenticateLastConfidentialBlock() {}
+ virtual void AuthenticateLastFooterBlock(byte *mac, size_t macSize) =0;
+
+ enum State {State_Start, State_KeySet, State_IVSet, State_AuthUntransformed, State_AuthTransformed, State_AuthFooter};
+ State m_state;
+ unsigned int m_bufferedDataLength;
+ lword m_totalHeaderLength, m_totalMessageLength, m_totalFooterLength;
+ AlignedSecByteBlock m_buffer;
+};
+
+NAMESPACE_END
+
+#endif
diff --git a/libs/win_crypto++/include/base32.h b/libs/win_crypto++/include/base32.h
new file mode 100644
index 0000000..c740f68
--- /dev/null
+++ b/libs/win_crypto++/include/base32.h
@@ -0,0 +1,96 @@
+// base32.h - written and placed in the public domain by Frank Palazzolo, based on hex.cpp by Wei Dai
+
+//! \file
+//! \brief Classes for Base32Encoder and Base32Decoder
+
+#ifndef CRYPTOPP_BASE32_H
+#define CRYPTOPP_BASE32_H
+
+#include "cryptlib.h"
+#include "basecode.h"
+
+NAMESPACE_BEGIN(CryptoPP)
+
+//! \class Base32Encoder
+//! \brief Base32 encodes data
+//! \details Converts data to base32. The default code is based on Differential Unicode Domain Encoding (DUDE) (draft-ietf-idn-dude-02.txt).
+class Base32Encoder : public SimpleProxyFilter
+{
+public:
+ //! \brief Construct a Base32Encoder
+ //! \param attachment a BufferedTrasformation to attach to this object
+ //! \param uppercase a flag indicating uppercase output
+ //! \param groupSize the size of the grouping
+ //! \param separator the separator to use between groups
+ //! \param terminator the terminator appeand after processing
+ //! \details Base32Encoder() constructs a default encoder. The constructor lacks fields for padding and
+ //! line breaks. You must use IsolatedInitialize() to change the default padding character or suppress it.
+ //! \sa IsolatedInitialize() for an example of modifying a Base32Encoder after construction.
+ Base32Encoder(BufferedTransformation *attachment = NULL, bool uppercase = true, int groupSize = 0, const std::string &separator = ":", const std::string &terminator = "")
+ : SimpleProxyFilter(new BaseN_Encoder(new Grouper), attachment)
+ {
+ IsolatedInitialize(MakeParameters(Name::Uppercase(), uppercase)(Name::GroupSize(), groupSize)(Name::Separator(), ConstByteArrayParameter(separator))(Name::Terminator(), ConstByteArrayParameter(terminator)));
+ }
+
+ //! \brief Initialize or reinitialize this object, without signal propagation
+ //! \param parameters a set of NameValuePairs used to initialize this object
+ //! \details IsolatedInitialize() is used to initialize or reinitialize an object using a variable
+ //! number of arbitrarily typed arguments. IsolatedInitialize() does not call Initialize() on attached
+ //! transformations. If initialization should be propagated, then use the Initialize() function.
+ //! \details The following code modifies the padding and line break parameters for an encoder:
+ //!
+ //! Base32Encoder encoder;
+ //! AlgorithmParameters params = MakeParameters(Pad(), false)(InsertLineBreaks(), false);
+ //! encoder.IsolatedInitialize(params);
+ //! \details You can change the encoding to RFC 4648, Base
+ //! 32 Encoding with Extended Hex Alphabet by performing the following:
+ //!
+ //! Base32Encoder encoder;
+ //! const byte ALPHABET[] = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
+ //! AlgorithmParameters params = MakeParameters(Name::EncodingLookupArray(),(const byte *)ALPHABET);
+ //! encoder.IsolatedInitialize(params);
+ //! \details If you change the encoding alphabet, then you will need to change the decoding alphabet \a and
+ //! the decoder's lookup table.
+ //! \sa Base32Decoder::IsolatedInitialize() for an example of changing a Base32Decoder's lookup table.
+ void IsolatedInitialize(const NameValuePairs ¶meters);
+};
+
+//! \class Base32Decoder
+//! \brief Base32 decodes data
+//! \details Decode base32 data. The default code is based on Differential Unicode Domain Encoding (DUDE) (draft-ietf-idn-dude-02.txt).
+class Base32Decoder : public BaseN_Decoder
+{
+public:
+ //! \brief Construct a Base32Decoder
+ //! \param attachment a BufferedTrasformation to attach to this object
+ //! \sa IsolatedInitialize() for an example of modifying a Base32Decoder after construction.
+ Base32Decoder(BufferedTransformation *attachment = NULL)
+ : BaseN_Decoder(GetDefaultDecodingLookupArray(), 5, attachment) {}
+
+ //! \brief Initialize or reinitialize this object, without signal propagation
+ //! \param parameters a set of NameValuePairs used to initialize this object
+ //! \details IsolatedInitialize() is used to initialize or reinitialize an object using a variable
+ //! number of arbitrarily typed arguments. IsolatedInitialize() does not call Initialize() on attached
+ //! transformations. If initialization should be propagated, then use the Initialize() function.
+ //! \details You can change the encoding to RFC 4648, Base
+ //! 32 Encoding with Extended Hex Alphabet by performing the following:
+ //!
+ //! int lookup[256];
+ //! const byte ALPHABET[] = "0123456789ABCDEFGHIJKLMNOPQRSTUV";
+ //! Base32Decoder::InitializeDecodingLookupArray(lookup, ALPHABET, 32, true /*insensitive*/);
+ //!
+ //! Base32Decoder decoder;
+ //! AlgorithmParameters params = MakeParameters(Name::DecodingLookupArray(),(const int *)lookup);
+ //! decoder.IsolatedInitialize(params);
+ //! \sa Base32Encoder::IsolatedInitialize() for an example of changing a Base32Encoder's alphabet.
+ void IsolatedInitialize(const NameValuePairs ¶meters);
+
+private:
+ //! \brief Provides the default decoding lookup table
+ //! \return default decoding lookup table
+ static const int * CRYPTOPP_API GetDefaultDecodingLookupArray();
+};
+
+NAMESPACE_END
+
+#endif
diff --git a/libs/win_crypto++/include/base64.h b/libs/win_crypto++/include/base64.h
new file mode 100644
index 0000000..c179a8f
--- /dev/null
+++ b/libs/win_crypto++/include/base64.h
@@ -0,0 +1,162 @@
+// base64.h - written and placed in the public domain by Wei Dai
+
+//! \file base64.h
+//! \brief Classes for the Base64Encoder, Base64Decoder, Base64URLEncoder and Base64URLDecoder
+
+#ifndef CRYPTOPP_BASE64_H
+#define CRYPTOPP_BASE64_H
+
+#include "cryptlib.h"
+#include "basecode.h"
+
+NAMESPACE_BEGIN(CryptoPP)
+
+//! \class Base64Encoder
+//! \brief Base64 encodes data
+//! \details Base64 encodes data per RFC 4648, Base 64 Encoding.
+class Base64Encoder : public SimpleProxyFilter
+{
+public:
+ //! \brief Construct a Base64Encoder
+ //! \param attachment a BufferedTrasformation to attach to this object
+ //! \param insertLineBreaks a BufferedTrasformation to attach to this object
+ //! \param maxLineLength the lenght of a line if line breaks are used
+ //! \details Base64Encoder constructs a default encoder. The constructor lacks a parameter for padding, and you must
+ //! use IsolatedInitialize() to modify the Base64Encoder after construction.
+ //! \sa IsolatedInitialize() for an example of modifying an encoder after construction.
+ Base64Encoder(BufferedTransformation *attachment = NULL, bool insertLineBreaks = true, int maxLineLength = 72)
+ : SimpleProxyFilter(new BaseN_Encoder(new Grouper), attachment)
+ {
+ IsolatedInitialize(MakeParameters(Name::InsertLineBreaks(), insertLineBreaks)(Name::MaxLineLength(), maxLineLength));
+ }
+
+ //! \brief Initialize or reinitialize this object, without signal propagation
+ //! \param parameters a set of NameValuePairs used to initialize this object
+ //! \details IsolatedInitialize() is used to initialize or reinitialize an object using a variable
+ //! number of arbitrarily typed arguments. IsolatedInitialize() does not call Initialize() on attached
+ //! transformations. If initialization should be propagated, then use the Initialize() function.
+ //! \details The following code modifies the padding and line break parameters for an encoder:
+ //!
+ //! Base64Encoder encoder;
+ //! AlgorithmParameters params = MakeParameters(Pad(), false)(InsertLineBreaks(), false);
+ //! encoder.IsolatedInitialize(params);
+ //! \details You can change the encoding to RFC 4648 web safe alphabet by performing the following:
+ //!
+ //! Base64Encoder encoder;
+ //! const byte ALPHABET[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+ //! AlgorithmParameters params = MakeParameters(Name::EncodingLookupArray(),(const byte *)ALPHABET);
+ //! encoder.IsolatedInitialize(params);
+ //! \details If you change the encoding alphabet, then you will need to change the decoding alphabet \a and
+ //! the decoder's lookup table.
+ //! \sa Base64URLEncoder for an encoder that provides the web safe alphabet, and Base64Decoder::IsolatedInitialize()
+ //! for an example of modifying a decoder's lookup table after construction.
+ void IsolatedInitialize(const NameValuePairs ¶meters);
+};
+
+//! \class Base64Decoder
+//! \brief Base64 decodes data
+//! \details Base64 encodes data per RFC 4648, Base 64 Encoding.
+class Base64Decoder : public BaseN_Decoder
+{
+public:
+ //! \brief Construct a Base64Decoder
+ //! \param attachment a BufferedTrasformation to attach to this object
+ //! \sa IsolatedInitialize() for an example of modifying an encoder after construction.
+ Base64Decoder(BufferedTransformation *attachment = NULL)
+ : BaseN_Decoder(GetDecodingLookupArray(), 6, attachment) {}
+
+ //! \brief Initialize or reinitialize this object, without signal propagation
+ //! \param parameters a set of NameValuePairs used to initialize this object
+ //! \details IsolatedInitialize() is used to initialize or reinitialize an object using a variable
+ //! number of arbitrarily typed arguments. IsolatedInitialize() does not call Initialize() on attached
+ //! transformations. If initialization should be propagated, then use the Initialize() function.
+ //! \details The default decoding alpahbet is RFC 4868. You can change the to RFC 4868 web safe alphabet
+ //! by performing the following:
+ //!
+ //! int lookup[256];
+ //! const byte ALPHABET[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+ //! Base64Decoder::InitializeDecodingLookupArray(lookup, ALPHABET, 64, false);
+ //!
+ //! Base64Decoder decoder;
+ //! AlgorithmParameters params = MakeParameters(Name::DecodingLookupArray(),(const int *)lookup);
+ //! decoder.IsolatedInitialize(params);
+ //! \sa Base64URLDecoder for a decoder that provides the web safe alphabet, and Base64Encoder::IsolatedInitialize()
+ //! for an example of modifying an encoder's alphabet after construction.
+ void IsolatedInitialize(const NameValuePairs ¶meters);
+
+private:
+ //! \brief Provides the default decoding lookup table
+ //! \return default decoding lookup table
+ static const int * CRYPTOPP_API GetDecodingLookupArray();
+};
+
+//! \class Base64URLEncoder
+//! \brief Base64 encodes data using a web safe alphabet
+//! \details Base64 encodes data per RFC 4648, Base 64 Encoding
+//! with URL and Filename Safe Alphabet.
+class Base64URLEncoder : public SimpleProxyFilter
+{
+public:
+ //! \brief Construct a Base64URLEncoder
+ //! \param attachment a BufferedTrasformation to attach to this object
+ //! \param insertLineBreaks a BufferedTrasformation to attach to this object
+ //! \param maxLineLength the lenght of a line if line breaks are used
+ //! \details Base64URLEncoder() constructs a default encoder using a web safe alphabet. The constructor ignores
+ //! insertLineBreaks and maxLineLength because the web and URL safe specifications don't use them. They are
+ //! present in the constructor for API compatibility with Base64Encoder so it is a drop-in replacement. The
+ //! constructor also disables padding on the encoder for the same reason.
+ //! \details If you need line breaks or padding, then you must use IsolatedInitialize() to set them
+ //! after constructing a Base64URLEncoder.
+ //! \sa Base64Encoder for an encoder that provides a classic alphabet, and Base64URLEncoder::IsolatedInitialize
+ //! for an example of modifying an encoder after construction.
+ Base64URLEncoder(BufferedTransformation *attachment = NULL, bool insertLineBreaks = false, int maxLineLength = -1)
+ : SimpleProxyFilter(new BaseN_Encoder(new Grouper), attachment)
+ {
+ CRYPTOPP_UNUSED(insertLineBreaks), CRYPTOPP_UNUSED(maxLineLength);
+ IsolatedInitialize(MakeParameters(Name::InsertLineBreaks(), false)(Name::MaxLineLength(), -1)(Name::Pad(),false));
+ }
+
+ //! \details IsolatedInitialize() is used to initialize or reinitialize an object using a variable
+ //! number of arbitrarily typed arguments. IsolatedInitialize() does not call Initialize() on attached
+ //! transformations. If initialization should be propagated, then use the Initialize() function.
+ //! \details The following code modifies the padding and line break parameters for an encoder:
+ //!
+ //! Base64URLEncoder encoder;
+ //! AlgorithmParameters params = MakeParameters(Name::Pad(), true)(Name::InsertLineBreaks(), true);
+ //! encoder.IsolatedInitialize(params);
+ //! \sa Base64Encoder for an encoder that provides a classic alphabet.
+ void IsolatedInitialize(const NameValuePairs ¶meters);
+};
+
+//! \class Base64URLDecoder
+//! \brief Base64 decodes data using a web safe alphabet
+//! \details Base64 encodes data per RFC 4648, Base 64 Encoding
+//! with URL and Filename Safe Alphabet.
+class Base64URLDecoder : public BaseN_Decoder
+{
+public:
+ //! \brief Construct a Base64URLDecoder
+ //! \param attachment a BufferedTrasformation to attach to this object
+ //! \details Base64URLDecoder() constructs a default decoder using a web safe alphabet.
+ //! \sa Base64Decoder for a decoder that provides a classic alphabet.
+ Base64URLDecoder(BufferedTransformation *attachment = NULL)
+ : BaseN_Decoder(GetDecodingLookupArray(), 6, attachment) {}
+
+ //! \brief Initialize or reinitialize this object, without signal propagation
+ //! \param parameters a set of NameValuePairs used to initialize this object
+ //! \details IsolatedInitialize() is used to initialize or reinitialize an object using a variable
+ //! number of arbitrarily typed arguments. IsolatedInitialize() does not call Initialize() on
+ //! attached transformations. If initialization should be propagated, then use the Initialize() function.
+ //! \sa Base64Decoder for a decoder that provides a classic alphabet, and Base64URLEncoder::IsolatedInitialize
+ //! for an example of modifying an encoder after construction.
+ void IsolatedInitialize(const NameValuePairs ¶meters);
+
+private:
+ //! \brief Provides the default decoding lookup table
+ //! \return default decoding lookup table
+ static const int * CRYPTOPP_API GetDecodingLookupArray();
+};
+
+NAMESPACE_END
+
+#endif
diff --git a/libs/win_crypto++/include/basecode.h b/libs/win_crypto++/include/basecode.h
new file mode 100644
index 0000000..782cdc0
--- /dev/null
+++ b/libs/win_crypto++/include/basecode.h
@@ -0,0 +1,142 @@
+// basecode.h - written and placed in the public domain by Wei Dai
+
+//! \file
+//! \brief Base classes for working with encoders and decoders.
+
+#ifndef CRYPTOPP_BASECODE_H
+#define CRYPTOPP_BASECODE_H
+
+#include "cryptlib.h"
+#include "filters.h"
+#include "algparam.h"
+#include "argnames.h"
+
+NAMESPACE_BEGIN(CryptoPP)
+
+//! \class BaseN_Encoder
+//! \brief Encoder for bases that are a power of 2
+class CRYPTOPP_DLL BaseN_Encoder : public Unflushable
+{
+public:
+ //! \brief Construct a BaseN_Encoder
+ //! \param attachment a BufferedTransformation to attach to this object
+ BaseN_Encoder(BufferedTransformation *attachment=NULL)
+ : m_alphabet(NULL), m_padding(0), m_bitsPerChar(0)
+ , m_outputBlockSize(0), m_bytePos(0), m_bitPos(0)
+ {Detach(attachment);}
+
+ //! \brief Construct a BaseN_Encoder
+ //! \param alphabet table of ASCII characters to use as the alphabet
+ //! \param log2base the log2base
+ //! \param attachment a BufferedTransformation to attach to this object
+ //! \param padding the character to use as padding
+ //! \pre log2base must be between 1 and 7 inclusive
+ //! \throws InvalidArgument if log2base is not between 1 and 7
+ BaseN_Encoder(const byte *alphabet, int log2base, BufferedTransformation *attachment=NULL, int padding=-1)
+ : m_alphabet(NULL), m_padding(0), m_bitsPerChar(0)
+ , m_outputBlockSize(0), m_bytePos(0), m_bitPos(0)
+ {
+ Detach(attachment);
+ IsolatedInitialize(MakeParameters(Name::EncodingLookupArray(), alphabet)
+ (Name::Log2Base(), log2base)
+ (Name::Pad(), padding != -1)
+ (Name::PaddingByte(), byte(padding)));
+ }
+
+ void IsolatedInitialize(const NameValuePairs ¶meters);
+ size_t Put2(const byte *begin, size_t length, int messageEnd, bool blocking);
+
+private:
+ const byte *m_alphabet;
+ int m_padding, m_bitsPerChar, m_outputBlockSize;
+ int m_bytePos, m_bitPos;
+ SecByteBlock m_outBuf;
+};
+
+//! \class BaseN_Decoder
+//! \brief Decoder for bases that are a power of 2
+class CRYPTOPP_DLL BaseN_Decoder : public Unflushable
+{
+public:
+ //! \brief Construct a BaseN_Decoder
+ //! \param attachment a BufferedTransformation to attach to this object
+ //! \details padding is set to -1, which means use default padding. If not
+ //! required, then the value must be set via IsolatedInitialize().
+ BaseN_Decoder(BufferedTransformation *attachment=NULL)
+ : m_lookup(0), m_padding(0), m_bitsPerChar(0)
+ , m_outputBlockSize(0), m_bytePos(0), m_bitPos(0)
+ {Detach(attachment);}
+
+ //! \brief Construct a BaseN_Decoder
+ //! \param lookup table of values
+ //! \param log2base the log2base
+ //! \param attachment a BufferedTransformation to attach to this object
+ //! \details log2base is the exponent (like 5 in 25), and not
+ //! the number of elements (like 32).
+ //! \details padding is set to -1, which means use default padding. If not
+ //! required, then the value must be set via IsolatedInitialize().
+ BaseN_Decoder(const int *lookup, int log2base, BufferedTransformation *attachment=NULL)
+ : m_lookup(0), m_padding(0), m_bitsPerChar(0)
+ , m_outputBlockSize(0), m_bytePos(0), m_bitPos(0)
+ {
+ Detach(attachment);
+ IsolatedInitialize(MakeParameters(Name::DecodingLookupArray(), lookup)(Name::Log2Base(), log2base));
+ }
+
+ void IsolatedInitialize(const NameValuePairs ¶meters);
+ size_t Put2(const byte *begin, size_t length, int messageEnd, bool blocking);
+
+ //! \brief Intializes BaseN lookup array
+ //! \param lookup table of values
+ //! \param alphabet table of ASCII characters
+ //! \param base the base for the encoder
+ //! \param caseInsensitive flag indicating whether the alpabet is case sensitivie
+ //! \pre COUNTOF(lookup) == 256
+ //! \pre COUNTOF(alphabet) == base
+ //! \details Internally, the function sets the first 256 elements in the lookup table to
+ //! their value from the alphabet array or -1. base is the number of element (like 32),
+ //! and not an exponent (like 5 in 25)
+ static void CRYPTOPP_API InitializeDecodingLookupArray(int *lookup, const byte *alphabet, unsigned int base, bool caseInsensitive);
+
+private:
+ const int *m_lookup;
+ int m_padding, m_bitsPerChar, m_outputBlockSize;
+ int m_bytePos, m_bitPos;
+ SecByteBlock m_outBuf;
+};
+
+//! \class Grouper
+//! \brief Filter that breaks input stream into groups of fixed size
+class CRYPTOPP_DLL Grouper : public Bufferless
+{
+public:
+ //! \brief Construct a Grouper
+ //! \param attachment a BufferedTransformation to attach to this object
+ Grouper(BufferedTransformation *attachment=NULL)
+ : m_groupSize(0), m_counter(0) {Detach(attachment);}
+
+ //! \brief Construct a Grouper
+ //! \param groupSize the size of the grouping
+ //! \param separator the separator to use between groups
+ //! \param terminator the terminator appeand after processing
+ //! \param attachment a BufferedTransformation to attach to this object
+ Grouper(int groupSize, const std::string &separator, const std::string &terminator, BufferedTransformation *attachment=NULL)
+ : m_groupSize(0), m_counter(0)
+ {
+ Detach(attachment);
+ IsolatedInitialize(MakeParameters(Name::GroupSize(), groupSize)
+ (Name::Separator(), ConstByteArrayParameter(separator))
+ (Name::Terminator(), ConstByteArrayParameter(terminator)));
+ }
+
+ void IsolatedInitialize(const NameValuePairs ¶meters);
+ size_t Put2(const byte *begin, size_t length, int messageEnd, bool blocking);
+
+private:
+ SecByteBlock m_separator, m_terminator;
+ size_t m_groupSize, m_counter;
+};
+
+NAMESPACE_END
+
+#endif
diff --git a/libs/win_crypto++/include/bench.h b/libs/win_crypto++/include/bench.h
new file mode 100644
index 0000000..5dfb6d4
--- /dev/null
+++ b/libs/win_crypto++/include/bench.h
@@ -0,0 +1,13 @@
+// bench.h - written and placed in the public domain by Wei Dai
+
+#ifndef CRYPTOPP_BENCH_H
+#define CRYPTOPP_BENCH_H
+
+#include "cryptlib.h"
+
+extern const double CLOCK_TICKS_PER_SECOND;
+
+void BenchmarkAll(double t, double hertz);
+void BenchmarkAll2(double t, double hertz);
+
+#endif
diff --git a/libs/win_crypto++/include/blake2.h b/libs/win_crypto++/include/blake2.h
new file mode 100644
index 0000000..8baa0c2
--- /dev/null
+++ b/libs/win_crypto++/include/blake2.h
@@ -0,0 +1,314 @@
+// blake2.h - written and placed in the public domain by Jeffrey Walton and Zooko
+// Wilcox-O'Hearn. Copyright assigned to the Crypto++ project.
+// Based on Aumasson, Neves, Wilcox-O'Hearn and Winnerlein's reference BLAKE2
+// implementation at http://github.com/BLAKE2/BLAKE2.
+
+//! \file blake2.h
+//! \brief Classes for BLAKE2b and BLAKE2s message digests and keyed message digests
+//! \details This implmentation follows Aumasson, Neves, Wilcox-O'Hearn and Winnerlein's
+//! BLAKE2: simpler, smaller, fast as MD5 (2013.01.29).
+//! Static algorithm name return either "BLAKE2b" or "BLAKE2s". An object algorithm name follows
+//! the naming described in RFC 7693, The
+//! BLAKE2 Cryptographic Hash and Message Authentication Code (MAC).
+//! \details The library provides specialized SSE2, SSE4 and NEON version of the BLAKE2 compression
+//! function. For best results under ARM NEON, specify both an architecture and cpu. For example:
+//! CXXFLAGS="-DNDEBUG -march=armv8-a+crc -mcpu=cortex-a53 ..."
+//! \since Crypto++ 5.6.4
+
+#ifndef CRYPTOPP_BLAKE2_H
+#define CRYPTOPP_BLAKE2_H
+
+#include "cryptlib.h"
+#include "secblock.h"
+#include "seckey.h"
+
+NAMESPACE_BEGIN(CryptoPP)
+
+//! \class BLAKE2_Info
+//! \brief BLAKE2 hash information
+//! \tparam T_64bit flag indicating 64-bit
+//! \since Crypto++ 5.6.4
+template
+struct BLAKE2_Info : public VariableKeyLength<(T_64bit ? 64 : 32),0,(T_64bit ? 64 : 32),1,SimpleKeyingInterface::NOT_RESYNCHRONIZABLE>
+{
+ typedef VariableKeyLength<(T_64bit ? 64 : 32),0,(T_64bit ? 64 : 32),1,SimpleKeyingInterface::NOT_RESYNCHRONIZABLE> KeyBase;
+ CRYPTOPP_CONSTANT(MIN_KEYLENGTH = KeyBase::MIN_KEYLENGTH)
+ CRYPTOPP_CONSTANT(MAX_KEYLENGTH = KeyBase::MAX_KEYLENGTH)
+ CRYPTOPP_CONSTANT(DEFAULT_KEYLENGTH = KeyBase::DEFAULT_KEYLENGTH)
+
+ CRYPTOPP_CONSTANT(BLOCKSIZE = (T_64bit ? 128 : 64))
+ CRYPTOPP_CONSTANT(DIGESTSIZE = (T_64bit ? 64 : 32))
+ CRYPTOPP_CONSTANT(SALTSIZE = (T_64bit ? 16 : 8))
+ CRYPTOPP_CONSTANT(PERSONALIZATIONSIZE = (T_64bit ? 16 : 8))
+
+ CRYPTOPP_CONSTEXPR static const char *StaticAlgorithmName() {return (T_64bit ? "BLAKE2b" : "BLAKE2s");}
+};
+
+//! \class BLAKE2_ParameterBlock
+//! \brief BLAKE2 parameter block
+//! \tparam T_64bit flag indicating 64-bit
+//! \details BLAKE2b uses BLAKE2_ParameterBlock, while BLAKE2s
+//! uses BLAKE2_ParameterBlock.
+//! \since Crypto++ 5.6.4
+template
+struct CRYPTOPP_NO_VTABLE BLAKE2_ParameterBlock
+{
+};
+
+//! \brief BLAKE2b parameter block specialization
+template<>
+struct CRYPTOPP_NO_VTABLE BLAKE2_ParameterBlock
+{
+ CRYPTOPP_CONSTANT(SALTSIZE = BLAKE2_Info::SALTSIZE)
+ CRYPTOPP_CONSTANT(DIGESTSIZE = BLAKE2_Info::DIGESTSIZE)
+ CRYPTOPP_CONSTANT(PERSONALIZATIONSIZE = BLAKE2_Info::PERSONALIZATIONSIZE)
+
+ BLAKE2_ParameterBlock()
+ {
+ memset(this, 0x00, sizeof(*this));
+ digestLength = DIGESTSIZE;
+ fanout = depth = 1;
+ }
+
+ BLAKE2_ParameterBlock(size_t digestSize)
+ {
+ CRYPTOPP_ASSERT(digestSize <= DIGESTSIZE);
+ memset(this, 0x00, sizeof(*this));
+ digestLength = (byte)digestSize;
+ fanout = depth = 1;
+ }
+
+ BLAKE2_ParameterBlock(size_t digestSize, size_t keyLength, const byte* salt, size_t saltLength,
+ const byte* personalization, size_t personalizationLength);
+
+ byte digestLength;
+ byte keyLength, fanout, depth;
+ byte leafLength[4];
+ byte nodeOffset[8];
+ byte nodeDepth, innerLength, rfu[14];
+ byte salt[SALTSIZE];
+ byte personalization[PERSONALIZATIONSIZE];
+};
+
+//! \brief BLAKE2s parameter block specialization
+template<>
+struct CRYPTOPP_NO_VTABLE BLAKE2_ParameterBlock
+{
+ CRYPTOPP_CONSTANT(SALTSIZE = BLAKE2_Info::SALTSIZE)
+ CRYPTOPP_CONSTANT(DIGESTSIZE = BLAKE2_Info::DIGESTSIZE)
+ CRYPTOPP_CONSTANT(PERSONALIZATIONSIZE = BLAKE2_Info::PERSONALIZATIONSIZE)
+
+ BLAKE2_ParameterBlock()
+ {
+ memset(this, 0x00, sizeof(*this));
+ digestLength = DIGESTSIZE;
+ fanout = depth = 1;
+ }
+
+ BLAKE2_ParameterBlock(size_t digestSize)
+ {
+ CRYPTOPP_ASSERT(digestSize <= DIGESTSIZE);
+ memset(this, 0x00, sizeof(*this));
+ digestLength = (byte)digestSize;
+ fanout = depth = 1;
+ }
+
+ BLAKE2_ParameterBlock(size_t digestSize, size_t keyLength, const byte* salt, size_t saltLength,
+ const byte* personalization, size_t personalizationLength);
+
+ byte digestLength;
+ byte keyLength, fanout, depth;
+ byte leafLength[4];
+ byte nodeOffset[6];
+ byte nodeDepth, innerLength;
+ byte salt[SALTSIZE];
+ byte personalization[PERSONALIZATIONSIZE];
+};
+
+//! \class BLAKE2_State
+//! \brief BLAKE2 state information
+//! \tparam W word type
+//! \tparam T_64bit flag indicating 64-bit
+//! \details BLAKE2b uses BLAKE2_State, while BLAKE2s
+//! uses BLAKE2_State.
+//! \since Crypto++ 5.6.4
+template
+struct CRYPTOPP_NO_VTABLE BLAKE2_State
+{
+ CRYPTOPP_CONSTANT(BLOCKSIZE = BLAKE2_Info::BLOCKSIZE)
+
+ BLAKE2_State()
+ {
+ // Set all members except scratch buffer[]
+ h[0]=h[1]=h[2]=h[3]=h[4]=h[5]=h[6]=h[7] = 0;
+ t[0]=t[1]=f[0]=f[1] = 0;
+ length = 0;
+ }
+
+ // SSE2, SSE4 and NEON depend upon t[] and f[] being side-by-side
+ W h[8], t[2], f[2];
+ byte buffer[BLOCKSIZE];
+ size_t length;
+};
+
+//! \class BLAKE2_Base
+//! \brief BLAKE2 hash implementation
+//! \tparam W word type
+//! \tparam T_64bit flag indicating 64-bit
+//! \details BLAKE2b uses BLAKE2_Base, while BLAKE2s
+//! uses BLAKE2_Base.
+//! \since Crypto++ 5.6.4
+template
+class BLAKE2_Base : public SimpleKeyingInterfaceImpl >
+{
+public:
+ CRYPTOPP_CONSTANT(DEFAULT_KEYLENGTH = BLAKE2_Info::DEFAULT_KEYLENGTH)
+ CRYPTOPP_CONSTANT(MIN_KEYLENGTH = BLAKE2_Info::MIN_KEYLENGTH)
+ CRYPTOPP_CONSTANT(MAX_KEYLENGTH = BLAKE2_Info::MAX_KEYLENGTH)
+
+ CRYPTOPP_CONSTANT(DIGESTSIZE = BLAKE2_Info::DIGESTSIZE)
+ CRYPTOPP_CONSTANT(BLOCKSIZE = BLAKE2_Info::BLOCKSIZE)
+ CRYPTOPP_CONSTANT(SALTSIZE = BLAKE2_Info::SALTSIZE)
+ CRYPTOPP_CONSTANT(PERSONALIZATIONSIZE = BLAKE2_Info::PERSONALIZATIONSIZE)
+
+ typedef BLAKE2_State State;
+ typedef BLAKE2_ParameterBlock ParameterBlock;
+ typedef SecBlock > AlignedState;
+ typedef SecBlock > AlignedParameterBlock;
+
+ virtual ~BLAKE2_Base() {}
+
+ //! \brief Retrieve the static algorithm name
+ //! \returns the algorithm name (BLAKE2s or BLAKE2b)
+ CRYPTOPP_CONSTEXPR static const char *StaticAlgorithmName() {return BLAKE2_Info::StaticAlgorithmName();}
+
+ //! \brief Retrieve the object's name
+ //! \returns the object's algorithm name following RFC 7693
+ //! \details Object algorithm name follows the naming described in
+ //! RFC 7693, The BLAKE2 Cryptographic Hash and
+ //! Message Authentication Code (MAC). For example, "BLAKE2b-512" and "BLAKE2s-256".
+ std::string AlgorithmName() const {return std::string(StaticAlgorithmName()) + "-" + IntToString(this->DigestSize()*8);}
+
+ unsigned int DigestSize() const {return m_digestSize;}
+ unsigned int OptimalDataAlignment() const {return (CRYPTOPP_BOOL_ALIGN16 ? 16 : GetAlignmentOf());}
+
+ void Update(const byte *input, size_t length);
+ void Restart();
+
+ //! \brief Restart a hash with parameter block and counter
+ //! \param block paramter block
+ //! \param counter counter array
+ //! \details Parameter block is persisted across calls to Restart().
+ void Restart(const BLAKE2_ParameterBlock& block, const W counter[2]);
+
+ //! \brief Set tree mode
+ //! \param mode the new tree mode
+ //! \details BLAKE2 has two finalization flags, called State::f[0] and State::f[1].
+ //! If treeMode=false (default), then State::f[1] is never set. If
+ //! treeMode=true, then State::f[1] is set when State::f[0] is set.
+ //! Tree mode is persisted across calls to Restart().
+ void SetTreeMode(bool mode) {m_treeMode=mode;}
+
+ //! \brief Get tree mode
+ //! \returns the current tree mode
+ //! \details Tree mode is persisted across calls to Restart().
+ bool GetTreeMode() const {return m_treeMode;}
+
+ void TruncatedFinal(byte *hash, size_t size);
+
+protected:
+ BLAKE2_Base();
+ BLAKE2_Base(bool treeMode, unsigned int digestSize);
+ BLAKE2_Base(const byte *key, size_t keyLength, const byte* salt, size_t saltLength,
+ const byte* personalization, size_t personalizationLength,
+ bool treeMode, unsigned int digestSize);
+
+ // Operates on state buffer and/or input. Must be BLOCKSIZE, final block will pad with 0's.
+ void Compress(const byte *input);
+ inline void IncrementCounter(size_t count=BLOCKSIZE);
+
+ void UncheckedSetKey(const byte* key, unsigned int length, const CryptoPP::NameValuePairs& params);
+
+private:
+ AlignedState m_state;
+ AlignedParameterBlock m_block;
+ AlignedSecByteBlock m_key;
+ word32 m_digestSize;
+ bool m_treeMode;
+};
+
+//! \brief The BLAKE2b cryptographic hash function
+//! \details BLAKE2b can function as both a hash and keyed hash. If you want only the hash,
+//! then use the BLAKE2b constructor that accepts no parameters or digest size. If you
+//! want a keyed hash, then use the constuctor that accpts the key as a parameter.
+//! Once a key and digest size are selected, its effectively immutable. The Restart()
+//! method that accepts a ParameterBlock does not allow you to change it.
+//! \sa Aumasson, Neves, Wilcox-O'Hearn and Winnerlein's
+//! BLAKE2: simpler, smaller, fast as MD5 (2013.01.29).
+//! \since Crypto++ 5.6.4
+class BLAKE2b : public BLAKE2_Base
+{
+public:
+ typedef BLAKE2_Base ThisBase; // Early Visual Studio workaround
+ typedef BLAKE2_ParameterBlock ParameterBlock;
+ CRYPTOPP_COMPILE_ASSERT(sizeof(ParameterBlock) == 64);
+
+ //! \brief Construct a BLAKE2b hash
+ //! \param digestSize the digest size, in bytes
+ //! \param treeMode flag indicating tree mode
+ BLAKE2b(bool treeMode=false, unsigned int digestSize = DIGESTSIZE) : ThisBase(treeMode, digestSize) {}
+
+ //! \brief Construct a BLAKE2b hash
+ //! \param key a byte array used to key the cipher
+ //! \param keyLength the size of the byte array
+ //! \param salt a byte array used as salt
+ //! \param saltLength the size of the byte array
+ //! \param personalization a byte array used as prsonalization string
+ //! \param personalizationLength the size of the byte array
+ //! \param treeMode flag indicating tree mode
+ //! \param digestSize the digest size, in bytes
+ BLAKE2b(const byte *key, size_t keyLength, const byte* salt = NULL, size_t saltLength = 0,
+ const byte* personalization = NULL, size_t personalizationLength = 0,
+ bool treeMode=false, unsigned int digestSize = DIGESTSIZE)
+ : ThisBase(key, keyLength, salt, saltLength, personalization, personalizationLength, treeMode, digestSize) {}
+};
+
+//! \brief The BLAKE2s cryptographic hash function
+//! \details BLAKE2s can function as both a hash and keyed hash. If you want only the hash,
+//! then use the BLAKE2s constructor that accepts no parameters or digest size. If you
+//! want a keyed hash, then use the constuctor that accpts the key as a parameter.
+//! Once a key and digest size are selected, its effectively immutable. The Restart()
+//! method that accepts a ParameterBlock does not allow you to change it.
+//! \sa Aumasson, Neves, Wilcox-O'Hearn and Winnerlein's
+//! BLAKE2: simpler, smaller, fast as MD5 (2013.01.29).
+//! \since Crypto++ 5.6.4
+class BLAKE2s : public BLAKE2_Base
+{
+public:
+ typedef BLAKE2_Base ThisBase; // Early Visual Studio workaround
+ typedef BLAKE2_ParameterBlock ParameterBlock;
+ CRYPTOPP_COMPILE_ASSERT(sizeof(ParameterBlock) == 32);
+
+ //! \brief Construct a BLAKE2s hash
+ //! \param digestSize the digest size, in bytes
+ //! \param treeMode flag indicating tree mode
+ BLAKE2s(bool treeMode=false, unsigned int digestSize = DIGESTSIZE) : ThisBase(treeMode, digestSize) {}
+
+ //! \brief Construct a BLAKE2s hash
+ //! \param key a byte array used to key the cipher
+ //! \param keyLength the size of the byte array
+ //! \param salt a byte array used as salt
+ //! \param saltLength the size of the byte array
+ //! \param personalization a byte array used as prsonalization string
+ //! \param personalizationLength the size of the byte array
+ //! \param treeMode flag indicating tree mode
+ //! \param digestSize the digest size, in bytes
+ BLAKE2s(const byte *key, size_t keyLength, const byte* salt = NULL, size_t saltLength = 0,
+ const byte* personalization = NULL, size_t personalizationLength = 0,
+ bool treeMode=false, unsigned int digestSize = DIGESTSIZE)
+ : ThisBase(key, keyLength, salt, saltLength, personalization, personalizationLength, treeMode, digestSize) {}
+};
+
+NAMESPACE_END
+
+#endif
diff --git a/libs/win_crypto++/include/blowfish.h b/libs/win_crypto++/include/blowfish.h
new file mode 100644
index 0000000..c543651
--- /dev/null
+++ b/libs/win_crypto++/include/blowfish.h
@@ -0,0 +1,56 @@
+// blowfish.h - written and placed in the public domain by Wei Dai
+
+//! \file blowfish.h
+//! \brief Classes for the Blowfish block cipher
+
+#ifndef CRYPTOPP_BLOWFISH_H
+#define CRYPTOPP_BLOWFISH_H
+
+#include "seckey.h"
+#include "secblock.h"
+
+NAMESPACE_BEGIN(CryptoPP)
+
+//! \class Blowfish_Info
+//! \brief Blowfish block cipher information
+struct Blowfish_Info : public FixedBlockSize<8>, public VariableKeyLength<16, 4, 56>, public FixedRounds<16>
+{
+ CRYPTOPP_CONSTEXPR static const char *StaticAlgorithmName() {return "Blowfish";}
+};
+
+// Blowfish
+
+//! \class Blowfish_Info
+//! \brief Blowfish block cipher
+class Blowfish : public Blowfish_Info, public BlockCipherDocumentation
+{
+ //! \class Base
+ //! \brief Class specific implementation and overrides used to operate the cipher.
+ //! \details Implementations and overrides in \p Base apply to both \p ENCRYPTION and \p DECRYPTION directions
+ class CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl
+ {
+ public:
+ void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
+ void UncheckedSetKey(const byte *key_string, unsigned int keylength, const NameValuePairs ¶ms);
+
+ private:
+ void crypt_block(const word32 in[2], word32 out[2]) const;
+
+ static const word32 p_init[ROUNDS+2];
+ static const word32 s_init[4*256];
+
+ FixedSizeSecBlock pbox;
+ FixedSizeSecBlock sbox;
+ };
+
+public:
+ typedef BlockCipherFinal Encryption;
+ typedef BlockCipherFinal Decryption;
+};
+
+typedef Blowfish::Encryption BlowfishEncryption;
+typedef Blowfish::Decryption BlowfishDecryption;
+
+NAMESPACE_END
+
+#endif
diff --git a/libs/win_crypto++/include/blumshub.h b/libs/win_crypto++/include/blumshub.h
new file mode 100644
index 0000000..df43d83
--- /dev/null
+++ b/libs/win_crypto++/include/blumshub.h
@@ -0,0 +1,63 @@
+// blumshub.h - written and placed in the public domain by Wei Dai
+
+//! \file
+//! \headerfile blumshub.h
+//! \brief Classes for Blum Blum Shub generator
+
+#ifndef CRYPTOPP_BLUMSHUB_H
+#define CRYPTOPP_BLUMSHUB_H
+
+#include "cryptlib.h"
+#include "modarith.h"
+#include "integer.h"
+
+NAMESPACE_BEGIN(CryptoPP)
+
+//! BlumBlumShub without factorization of the modulus
+class PublicBlumBlumShub : public RandomNumberGenerator,
+ public StreamTransformation
+{
+public:
+ PublicBlumBlumShub(const Integer &n, const Integer &seed);
+
+ unsigned int GenerateBit();
+ byte GenerateByte();
+ void GenerateBlock(byte *output, size_t size);
+ void ProcessData(byte *outString, const byte *inString, size_t length);
+
+ bool IsSelfInverting() const {return true;}
+ bool IsForwardTransformation() const {return true;}
+
+#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
+ virtual ~PublicBlumBlumShub() {}
+#endif
+
+protected:
+ ModularArithmetic modn;
+ Integer current;
+ word maxBits, bitsLeft;
+};
+
+//! BlumBlumShub with factorization of the modulus
+class BlumBlumShub : public PublicBlumBlumShub
+{
+public:
+ // Make sure p and q are both primes congruent to 3 mod 4 and at least 512 bits long,
+ // seed is the secret key and should be about as big as p*q
+ BlumBlumShub(const Integer &p, const Integer &q, const Integer &seed);
+
+ bool IsRandomAccess() const {return true;}
+ void Seek(lword index);
+
+#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
+ virtual ~BlumBlumShub() {}
+#endif
+
+protected:
+ const Integer p, q;
+ const Integer x0;
+};
+
+NAMESPACE_END
+
+#endif
diff --git a/libs/win_crypto++/include/camellia.h b/libs/win_crypto++/include/camellia.h
new file mode 100644
index 0000000..0e0dc42
--- /dev/null
+++ b/libs/win_crypto++/include/camellia.h
@@ -0,0 +1,51 @@
+// camellia.h - written and placed in the public domain by Wei Dai
+
+//! \file camellia.h
+//! \brief Classes for the Cameliia block cipher
+
+#ifndef CRYPTOPP_CAMELLIA_H
+#define CRYPTOPP_CAMELLIA_H
+
+#include "config.h"
+#include "seckey.h"
+#include "secblock.h"
+
+NAMESPACE_BEGIN(CryptoPP)
+
+//! \class Camellia_Info
+//! \brief Camellia block cipher information
+struct Camellia_Info : public FixedBlockSize<16>, public VariableKeyLength<16, 16, 32, 8>
+{
+ CRYPTOPP_CONSTEXPR static const char *StaticAlgorithmName() {return "Camellia";}
+};
+
+//! \class Camellia
+//! \brief Camellia block cipher
+//! \sa Camellia
+class Camellia : public Camellia_Info, public BlockCipherDocumentation
+{
+ class CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl
+ {
+ public:
+ void UncheckedSetKey(const byte *key, unsigned int keylen, const NameValuePairs ¶ms);
+ void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
+
+ protected:
+ CRYPTOPP_ALIGN_DATA(4) static const byte s1[256];
+ static const word32 SP[4][256];
+
+ unsigned int m_rounds;
+ SecBlock m_key;
+ };
+
+public:
+ typedef BlockCipherFinal Encryption;
+ typedef BlockCipherFinal Decryption;
+};
+
+typedef Camellia::Encryption CamelliaEncryption;
+typedef Camellia::Decryption CamelliaDecryption;
+
+NAMESPACE_END
+
+#endif
diff --git a/libs/win_crypto++/include/cast.h b/libs/win_crypto++/include/cast.h
new file mode 100644
index 0000000..86a5a63
--- /dev/null
+++ b/libs/win_crypto++/include/cast.h
@@ -0,0 +1,109 @@
+// cast.h - written and placed in the public domain by Wei Dai
+
+//! \file cast.h
+//! \brief Classes for the CAST-128 and CAST-256 block ciphers
+
+#ifndef CRYPTOPP_CAST_H
+#define CRYPTOPP_CAST_H
+
+#include "seckey.h"
+#include "secblock.h"
+
+NAMESPACE_BEGIN(CryptoPP)
+
+//! \class CAST
+//! \brief CAST block cipher base
+class CAST
+{
+protected:
+ static const word32 S[8][256];
+};
+
+//! \class CAST128_Info
+//! \brief CAST128 block cipher information
+struct CAST128_Info : public FixedBlockSize<8>, public VariableKeyLength<16, 5, 16>
+{
+ CRYPTOPP_CONSTEXPR static const char *StaticAlgorithmName() {return "CAST-128";}
+};
+
+//! \class CAST128
+//! \brief CAST128 block cipher
+//! \sa CAST-128
+class CAST128 : public CAST128_Info, public BlockCipherDocumentation
+{
+ //! \class Base
+ //! \brief CAST128 block cipher default operation
+ class CRYPTOPP_NO_VTABLE Base : public CAST, public BlockCipherImpl
+ {
+ public:
+ void UncheckedSetKey(const byte *userKey, unsigned int length, const NameValuePairs ¶ms);
+
+ protected:
+ bool reduced;
+ FixedSizeSecBlock K;
+ };
+
+ //! \class Enc
+ //! \brief CAST128 block cipher encryption operation
+ class CRYPTOPP_NO_VTABLE Enc : public Base
+ {
+ public:
+ void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
+ };
+
+ //! \class Dec
+ //! \brief CAST128 block cipher decryption operation
+ class CRYPTOPP_NO_VTABLE Dec : public Base
+ {
+ public:
+ void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
+ };
+
+public:
+ typedef BlockCipherFinal Encryption;
+ typedef BlockCipherFinal Decryption;
+};
+
+//! \class CAST256_Info
+//! \brief CAST256 block cipher information
+struct CAST256_Info : public FixedBlockSize<16>, public VariableKeyLength<16, 16, 32, 4>
+{
+ CRYPTOPP_CONSTEXPR static const char *StaticAlgorithmName() {return "CAST-256";}
+};
+
+//! \class CAST256
+//! \brief CAST256 block cipher
+//! \sa CAST-256
+class CAST256 : public CAST256_Info, public BlockCipherDocumentation
+{
+ //! \class Base
+ //! \brief CAST256 block cipher default operation
+ class CRYPTOPP_NO_VTABLE Base : public CAST, public BlockCipherImpl
+ {
+ public:
+ void UncheckedSetKey(const byte *userKey, unsigned int length, const NameValuePairs ¶ms);
+ void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
+
+ protected:
+ static const word32 t_m[8][24];
+ static const unsigned int t_r[8][24];
+
+ static void Omega(int i, word32 kappa[8]);
+
+ FixedSizeSecBlock K;
+ };
+
+public:
+ typedef BlockCipherFinal Encryption;
+ typedef BlockCipherFinal Decryption;
+};
+
+typedef CAST128::Encryption CAST128Encryption;
+typedef CAST128::Decryption CAST128Decryption;
+
+typedef CAST256::Encryption CAST256Encryption;
+typedef CAST256::Decryption CAST256Decryption;
+
+NAMESPACE_END
+
+#endif
diff --git a/libs/win_crypto++/include/cbcmac.h b/libs/win_crypto++/include/cbcmac.h
new file mode 100644
index 0000000..38c75b7
--- /dev/null
+++ b/libs/win_crypto++/include/cbcmac.h
@@ -0,0 +1,56 @@
+// cbcmac.h - written and placed in the public domain by Wei Dai
+
+//! \file
+//! \headerfile cbcmac.h
+//! \brief Classes for CBC MAC
+
+#ifndef CRYPTOPP_CBCMAC_H
+#define CRYPTOPP_CBCMAC_H
+
+#include "seckey.h"
+#include "secblock.h"
+
+NAMESPACE_BEGIN(CryptoPP)
+
+//! _
+class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CBC_MAC_Base : public MessageAuthenticationCode
+{
+public:
+ CBC_MAC_Base() : m_counter(0) {}
+
+ void UncheckedSetKey(const byte *key, unsigned int length, const NameValuePairs ¶ms);
+ void Update(const byte *input, size_t length);
+ void TruncatedFinal(byte *mac, size_t size);
+ unsigned int DigestSize() const {return const_cast(this)->AccessCipher().BlockSize();}
+
+protected:
+ virtual BlockCipher & AccessCipher() =0;
+
+private:
+ void ProcessBuf();
+ SecByteBlock m_reg;
+ unsigned int m_counter;
+};
+
+//! CBC-MAC
+/*! Compatible with FIPS 113. T should be a class derived from BlockCipherDocumentation.
+ Secure only for fixed length messages. For variable length messages use CMAC or DMAC.
+*/
+template
+class CBC_MAC : public MessageAuthenticationCodeImpl >, public SameKeyLengthAs
+{
+public:
+ CBC_MAC() {}
+ CBC_MAC(const byte *key, size_t length=SameKeyLengthAs::DEFAULT_KEYLENGTH)
+ {this->SetKey(key, length);}
+
+ static std::string StaticAlgorithmName() {return std::string("CBC-MAC(") + T::StaticAlgorithmName() + ")";}
+
+private:
+ BlockCipher & AccessCipher() {return m_cipher;}
+ typename T::Encryption m_cipher;
+};
+
+NAMESPACE_END
+
+#endif
diff --git a/libs/win_crypto++/include/ccm.h b/libs/win_crypto++/include/ccm.h
new file mode 100644
index 0000000..2ecee0d
--- /dev/null
+++ b/libs/win_crypto++/include/ccm.h
@@ -0,0 +1,122 @@
+// ccm.h - written and placed in the public domain by Wei Dai
+
+//! \file ccm.h
+//! \brief CCM block cipher mode of operation
+//! \since Crypto++ 5.6.0
+
+#ifndef CRYPTOPP_CCM_H
+#define CRYPTOPP_CCM_H
+
+#include "authenc.h"
+#include "modes.h"
+
+NAMESPACE_BEGIN(CryptoPP)
+
+//! \class CCM_Base
+//! \brief CCM block cipher base implementation
+//! \details Base implementation of the AuthenticatedSymmetricCipher interface
+//! \since Crypto++ 5.6.0
+class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CCM_Base : public AuthenticatedSymmetricCipherBase
+{
+public:
+ CCM_Base()
+ : m_digestSize(0), m_L(0), m_messageLength(0), m_aadLength(0) {}
+
+ // AuthenticatedSymmetricCipher
+ std::string AlgorithmName() const
+ {return GetBlockCipher().AlgorithmName() + std::string("/CCM");}
+ size_t MinKeyLength() const
+ {return GetBlockCipher().MinKeyLength();}
+ size_t MaxKeyLength() const
+ {return GetBlockCipher().MaxKeyLength();}
+ size_t DefaultKeyLength() const
+ {return GetBlockCipher().DefaultKeyLength();}
+ size_t GetValidKeyLength(size_t n) const
+ {return GetBlockCipher().GetValidKeyLength(n);}
+ bool IsValidKeyLength(size_t n) const
+ {return GetBlockCipher().IsValidKeyLength(n);}
+ unsigned int OptimalDataAlignment() const
+ {return GetBlockCipher().OptimalDataAlignment();}
+ IV_Requirement IVRequirement() const
+ {return UNIQUE_IV;}
+ unsigned int IVSize() const
+ {return 8;}
+ unsigned int MinIVLength() const
+ {return 7;}
+ unsigned int MaxIVLength() const
+ {return 13;}
+ unsigned int DigestSize() const
+ {return m_digestSize;}
+ lword MaxHeaderLength() const
+ {return W64LIT(0)-1;}
+ lword MaxMessageLength() const
+ {return m_L<8 ? (W64LIT(1)<<(8*m_L))-1 : W64LIT(0)-1;}
+ bool NeedsPrespecifiedDataLengths() const
+ {return true;}
+ void UncheckedSpecifyDataLengths(lword headerLength, lword messageLength, lword footerLength);
+
+protected:
+ // AuthenticatedSymmetricCipherBase
+ bool AuthenticationIsOnPlaintext() const
+ {return true;}
+ unsigned int AuthenticationBlockSize() const
+ {return GetBlockCipher().BlockSize();}
+ void SetKeyWithoutResync(const byte *userKey, size_t keylength, const NameValuePairs ¶ms);
+ void Resync(const byte *iv, size_t len);
+ size_t AuthenticateBlocks(const byte *data, size_t len);
+ void AuthenticateLastHeaderBlock();
+ void AuthenticateLastConfidentialBlock();
+ void AuthenticateLastFooterBlock(byte *mac, size_t macSize);
+ SymmetricCipher & AccessSymmetricCipher() {return m_ctr;}
+
+ virtual BlockCipher & AccessBlockCipher() =0;
+ virtual int DefaultDigestSize() const =0;
+
+ const BlockCipher & GetBlockCipher() const {return const_cast(this)->AccessBlockCipher();};
+ byte *CBC_Buffer() {return m_buffer+REQUIRED_BLOCKSIZE;}
+
+ enum {REQUIRED_BLOCKSIZE = 16};
+ int m_digestSize, m_L;
+ word64 m_messageLength, m_aadLength;
+ CTR_Mode_ExternalCipher::Encryption m_ctr;
+};
+
+//! \class CCM_Final
+//! \brief CCM block cipher final implementation
+//! \tparam T_BlockCipher block cipher
+//! \tparam T_DefaultDigestSize default digest size, in bytes
+//! \tparam T_IsEncryption direction in which to operate the cipher
+//! \since Crypto++ 5.6.0
+template
+class CCM_Final : public CCM_Base
+{
+public:
+ static std::string StaticAlgorithmName()
+ {return T_BlockCipher::StaticAlgorithmName() + std::string("/CCM");}
+ bool IsForwardTransformation() const
+ {return T_IsEncryption;}
+
+private:
+ BlockCipher & AccessBlockCipher() {return m_cipher;}
+ int DefaultDigestSize() const {return T_DefaultDigestSize;}
+ typename T_BlockCipher::Encryption m_cipher;
+};
+
+//! \class CCM
+//! \brief CCM block cipher mode of operation
+//! \tparam T_BlockCipher block cipher
+//! \tparam T_DefaultDigestSize default digest size, in bytes
+//! \details \p CCM provides the \p Encryption and \p Decryption typedef. See GCM_Base
+//! and GCM_Final for the AuthenticatedSymmetricCipher implementation.
+//! \sa CCM at the Crypto Lounge
+//! \since Crypto++ 5.6.0
+template
+struct CCM : public AuthenticatedSymmetricCipherDocumentation
+{
+ typedef CCM_Final Encryption;
+ typedef CCM_Final Decryption;
+};
+
+NAMESPACE_END
+
+#endif
diff --git a/libs/win_crypto++/include/chacha.h b/libs/win_crypto++/include/chacha.h
new file mode 100644
index 0000000..5ac1ec5
--- /dev/null
+++ b/libs/win_crypto++/include/chacha.h
@@ -0,0 +1,91 @@
+// chacha.h - written and placed in the public domain by Jeffrey Walton.
+// Copyright assigned to the Crypto++ project.
+// Based on Wei Dai's Salsa20 and Bernstein's reference ChaCha
+// family implementation at http://cr.yp.to/chacha.html.
+
+//! \file chacha.h
+//! \brief Classes for ChaCha8, ChaCha12 and ChaCha20 stream ciphers
+//! \details Crypto++ provides Bernstein and ECRYPT's ChaCha from ChaCha,
+//! a variant of Salsa20 (2008.01.28). Bernstein's implementation is _slightly_ different from the TLS working group's
+//! implementation for cipher suites TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
+//! TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256, and TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256.
+//! \since Crypto++ 5.6.4
+
+#ifndef CRYPTOPP_CHACHA_H
+#define CRYPTOPP_CHACHA_H
+
+#include "strciphr.h"
+#include "secblock.h"
+
+NAMESPACE_BEGIN(CryptoPP)
+
+//! \class ChaCha_Info
+//! \brief ChaCha stream cipher information
+//! \since Crypto++ 5.6.4
+template
+struct ChaCha_Info : public VariableKeyLength<32, 16, 32, 16, SimpleKeyingInterface::UNIQUE_IV, 8>, public FixedRounds
+{
+ CRYPTOPP_CONSTEXPR static const char *StaticAlgorithmName() {
+ return (R==8?"ChaCha8":(R==12?"ChaCha12":(R==20?"ChaCha20":"ChaCha")));
+ }
+};
+
+//! \class ChaCha_Policy
+//! \brief ChaCha stream cipher implementation
+//! \since Crypto++ 5.6.4
+template
+class CRYPTOPP_NO_VTABLE ChaCha_Policy : public AdditiveCipherConcretePolicy
+{
+protected:
+ CRYPTOPP_CONSTANT(ROUNDS=FixedRounds::ROUNDS)
+
+ void CipherSetKey(const NameValuePairs ¶ms, const byte *key, size_t length);
+ void OperateKeystream(KeystreamOperation operation, byte *output, const byte *input, size_t iterationCount);
+ void CipherResynchronize(byte *keystreamBuffer, const byte *IV, size_t length);
+ bool CipherIsRandomAccess() const {return false;} // TODO
+ void SeekToIteration(lword iterationCount);
+ unsigned int GetAlignment() const;
+ unsigned int GetOptimalBlockSize() const;
+
+ FixedSizeAlignedSecBlock m_state;
+};
+
+//! \class ChaCha8
+//! \brief ChaCha8 stream cipher
+//! \sa ChaCha, a variant of Salsa20 (2008.01.28).
+//! \since Crypto++ 5.6.4
+struct ChaCha8 : public ChaCha_Info<8>, public SymmetricCipherDocumentation
+{
+ typedef SymmetricCipherFinal, AdditiveCipherTemplate<> >, ChaCha_Info<8> > Encryption;
+ typedef Encryption Decryption;
+};
+
+//! \class ChaCha12
+//! \brief ChaCha12 stream cipher
+//! \details Bernstein and ECRYPT's ChaCha is _slightly_ different from the TLS working group's implementation for
+//! cipher suites TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
+//! TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256, and TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256.
+//! \sa ChaCha, a variant of Salsa20 (2008.01.28).
+//! \since Crypto++ 5.6.4
+struct ChaCha12 : public ChaCha_Info<12>, public SymmetricCipherDocumentation
+{
+ typedef SymmetricCipherFinal, AdditiveCipherTemplate<> >, ChaCha_Info<12> > Encryption;
+ typedef Encryption Decryption;
+};
+
+//! \class ChaCha20
+//! \brief ChaCha20 stream cipher
+//! \sa ChaCha, a variant of Salsa20 (2008.01.28).
+//! \details Bernstein and ECRYPT's ChaCha is _slightly_ different from the TLS working group's implementation for
+//! cipher suites TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256,
+//! TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256, and TLS_DHE_RSA_WITH_CHACHA20_POLY1305_SHA256.
+//! \since Crypto++ 5.6.4
+struct ChaCha20 : public ChaCha_Info<20>, public SymmetricCipherDocumentation
+{
+ typedef SymmetricCipherFinal, AdditiveCipherTemplate<> >, ChaCha_Info<20> > Encryption;
+ typedef Encryption Decryption;
+};
+
+NAMESPACE_END
+
+#endif // CRYPTOPP_CHACHA_H
diff --git a/libs/win_crypto++/include/channels.h b/libs/win_crypto++/include/channels.h
new file mode 100644
index 0000000..a05c63e
--- /dev/null
+++ b/libs/win_crypto++/include/channels.h
@@ -0,0 +1,134 @@
+// channels.h - written and placed in the public domain by Wei Dai
+
+//! \file
+//! \headerfile channels.h
+//! \brief Classes for multiple named channels
+
+#ifndef CRYPTOPP_CHANNELS_H
+#define CRYPTOPP_CHANNELS_H
+
+#include "cryptlib.h"
+#include "simple.h"
+#include "smartptr.h"
+#include "stdcpp.h"
+
+NAMESPACE_BEGIN(CryptoPP)
+
+#if 0
+//! Route input on default channel to different and/or multiple channels based on message sequence number
+class MessageSwitch : public Sink
+{
+public:
+ void AddDefaultRoute(BufferedTransformation &destination, const std::string &channel);
+ void AddRoute(unsigned int begin, unsigned int end, BufferedTransformation &destination, const std::string &channel);
+
+ void Put(byte inByte);
+ void Put(const byte *inString, unsigned int length);
+
+ void Flush(bool completeFlush, int propagation=-1);
+ void MessageEnd(int propagation=-1);
+ void PutMessageEnd(const byte *inString, unsigned int length, int propagation=-1);
+ void MessageSeriesEnd(int propagation=-1);
+
+private:
+ typedef std::pair Route;
+ struct RangeRoute
+ {
+ RangeRoute(unsigned int begin, unsigned int end, const Route &route)
+ : begin(begin), end(end), route(route) {}
+ bool operator<(const RangeRoute &rhs) const {return begin < rhs.begin;}
+ unsigned int begin, end;
+ Route route;
+ };
+
+ typedef std::list RouteList;
+ typedef std::list DefaultRouteList;
+
+ RouteList m_routes;
+ DefaultRouteList m_defaultRoutes;
+ unsigned int m_nCurrentMessage;
+};
+#endif
+
+class ChannelSwitchTypedefs
+{
+public:
+ typedef std::pair Route;
+ typedef std::multimap RouteMap;
+
+ typedef std::pair > DefaultRoute;
+ typedef std::list DefaultRouteList;
+
+ // SunCC workaround: can't use const_iterator here
+ typedef RouteMap::iterator MapIterator;
+ typedef DefaultRouteList::iterator ListIterator;
+};
+
+class ChannelSwitch;
+
+class ChannelRouteIterator : public ChannelSwitchTypedefs
+{
+public:
+ ChannelRouteIterator(ChannelSwitch &cs) : m_cs(cs), m_useDefault(false) {}
+
+ void Reset(const std::string &channel);
+ bool End() const;
+ void Next();
+ BufferedTransformation & Destination();
+ const std::string & Channel();
+
+ ChannelSwitch& m_cs;
+ std::string m_channel;
+ bool m_useDefault;
+ MapIterator m_itMapCurrent, m_itMapEnd;
+ ListIterator m_itListCurrent, m_itListEnd;
+
+protected:
+ // Hide this to see if we break something...
+ ChannelRouteIterator();
+};
+
+//! Route input to different and/or multiple channels based on channel ID
+class CRYPTOPP_DLL ChannelSwitch : public Multichannel, public ChannelSwitchTypedefs
+{
+public:
+ ChannelSwitch() : m_it(*this), m_blocked(false) {}
+ ChannelSwitch(BufferedTransformation &destination) : m_it(*this), m_blocked(false)
+ {
+ AddDefaultRoute(destination);
+ }
+ ChannelSwitch(BufferedTransformation &destination, const std::string &outChannel) : m_it(*this), m_blocked(false)
+ {
+ AddDefaultRoute(destination, outChannel);
+ }
+
+ void IsolatedInitialize(const NameValuePairs ¶meters=g_nullNameValuePairs);
+
+ size_t ChannelPut2(const std::string &channel, const byte *begin, size_t length, int messageEnd, bool blocking);
+ size_t ChannelPutModifiable2(const std::string &channel, byte *begin, size_t length, int messageEnd, bool blocking);
+
+ bool ChannelFlush(const std::string &channel, bool completeFlush, int propagation=-1, bool blocking=true);
+ bool ChannelMessageSeriesEnd(const std::string &channel, int propagation=-1, bool blocking=true);
+
+ byte * ChannelCreatePutSpace(const std::string &channel, size_t &size);
+
+ void AddDefaultRoute(BufferedTransformation &destination);
+ void RemoveDefaultRoute(BufferedTransformation &destination);
+ void AddDefaultRoute(BufferedTransformation &destination, const std::string &outChannel);
+ void RemoveDefaultRoute(BufferedTransformation &destination, const std::string &outChannel);
+ void AddRoute(const std::string &inChannel, BufferedTransformation &destination, const std::string &outChannel);
+ void RemoveRoute(const std::string &inChannel, BufferedTransformation &destination, const std::string &outChannel);
+
+private:
+ RouteMap m_routeMap;
+ DefaultRouteList m_defaultRoutes;
+
+ ChannelRouteIterator m_it;
+ bool m_blocked;
+
+ friend class ChannelRouteIterator;
+};
+
+NAMESPACE_END
+
+#endif
diff --git a/libs/win_crypto++/include/cmac.h b/libs/win_crypto++/include/cmac.h
new file mode 100644
index 0000000..6e70d12
--- /dev/null
+++ b/libs/win_crypto++/include/cmac.h
@@ -0,0 +1,67 @@
+// cmac.h - written and placed in the public domain by Wei Dai
+
+//! \file cmac.h
+//! \brief Classes for CMAC message authentication code
+//! \since Crypto++ 5.6.0
+
+#ifndef CRYPTOPP_CMAC_H
+#define CRYPTOPP_CMAC_H
+
+#include "seckey.h"
+#include "secblock.h"
+
+NAMESPACE_BEGIN(CryptoPP)
+
+//! \class CMAC_Base
+//! \brief CMAC base implementation
+//! \since Crypto++ 5.6.0
+class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CMAC_Base : public MessageAuthenticationCode
+{
+public:
+ CMAC_Base() : m_counter(0) {}
+
+ void UncheckedSetKey(const byte *key, unsigned int length, const NameValuePairs ¶ms);
+ void Update(const byte *input, size_t length);
+ void TruncatedFinal(byte *mac, size_t size);
+ unsigned int DigestSize() const {return GetCipher().BlockSize();}
+ unsigned int OptimalBlockSize() const {return GetCipher().BlockSize();}
+ unsigned int OptimalDataAlignment() const {return GetCipher().OptimalDataAlignment();}
+
+protected:
+ friend class EAX_Base;
+
+ const BlockCipher & GetCipher() const {return const_cast(this)->AccessCipher();}
+ virtual BlockCipher & AccessCipher() =0;
+
+ void ProcessBuf();
+ SecByteBlock m_reg;
+ unsigned int m_counter;
+};
+
+//! \brief CMAC message authentication code
+//! \tparam T block cipher
+//! \details Template parameter T should be a class derived from BlockCipherDocumentation, for example AES, with a block size of 8, 16, or 32.
+//! \sa CMAC
+//! \since Crypto++ 5.6.0
+template
+class CMAC : public MessageAuthenticationCodeImpl >, public SameKeyLengthAs
+{
+public:
+ //! \brief Construct a CMAC
+ CMAC() {}
+ //! \brief Construct a CMAC
+ //! \param key the MAC key
+ //! \param length the key size, in bytes
+ CMAC(const byte *key, size_t length=SameKeyLengthAs::DEFAULT_KEYLENGTH)
+ {this->SetKey(key, length);}
+
+ static std::string StaticAlgorithmName() {return std::string("CMAC(") + T::StaticAlgorithmName() + ")";}
+
+private:
+ BlockCipher & AccessCipher() {return m_cipher;}
+ typename T::Encryption m_cipher;
+};
+
+NAMESPACE_END
+
+#endif
diff --git a/libs/win_crypto++/include/config.h b/libs/win_crypto++/include/config.h
new file mode 100644
index 0000000..82f067b
--- /dev/null
+++ b/libs/win_crypto++/include/config.h
@@ -0,0 +1,945 @@
+// config.h - written and placed in the public domain by Wei Dai
+
+//! \file config.h
+//! \brief Library configuration file
+
+#ifndef CRYPTOPP_CONFIG_H
+#define CRYPTOPP_CONFIG_H
+
+// ***************** Important Settings ********************
+
+// define this if running on a big-endian CPU
+#if !defined(IS_LITTLE_ENDIAN) && (defined(__BIG_ENDIAN__) || (defined(__s390__) || defined(__s390x__) || defined(__zarch__)) || (defined(__m68k__) || defined(__MC68K__)) || defined(__sparc) || defined(__sparc__) || defined(__hppa__) || defined(__MIPSEB__) || defined(__ARMEB__) || (defined(__MWERKS__) && !defined(__INTEL__)))
+# define IS_BIG_ENDIAN
+#endif
+
+// define this if running on a little-endian CPU
+// big endian will be assumed if IS_LITTLE_ENDIAN is not defined
+#ifndef IS_BIG_ENDIAN
+# define IS_LITTLE_ENDIAN
+#endif
+
+// Sanity checks. Some processors have more than big-, little- and bi-endian modes. PDP mode, where order results in "4312", should
+// raise red flags immediately. Additionally, mis-classified machines, like (previosuly) S/390, should raise red flags immediately.
+#if defined(IS_BIG_ENDIAN) && defined(__GNUC__) && defined(__BYTE_ORDER__) && (__BYTE_ORDER__ != __ORDER_BIG_ENDIAN__)
+# error "IS_BIG_ENDIAN is set, but __BYTE_ORDER__ does not equal __ORDER_BIG_ENDIAN__"
+#endif
+#if defined(IS_LITTLE_ENDIAN) && defined(__GNUC__) && defined(__BYTE_ORDER__) && (__BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__)
+# error "IS_LITTLE_ENDIAN is set, but __BYTE_ORDER__ does not equal __ORDER_LITTLE_ENDIAN__"
+#endif
+
+// Define this if you want to disable all OS-dependent features,
+// such as sockets and OS-provided random number generators
+// #define NO_OS_DEPENDENCE
+
+// Define this to use features provided by Microsoft's CryptoAPI.
+// Currently the only feature used is Windows random number generation.
+// This macro will be ignored if NO_OS_DEPENDENCE is defined.
+// #define USE_MS_CRYPTOAPI
+
+// Define this to use features provided by Microsoft's CryptoNG API.
+// CryptoNG API is available in Vista and above and its cross platform,
+// including desktop apps and store apps. Currently the only feature
+// used is Windows random number generation.
+// This macro will be ignored if NO_OS_DEPENDENCE is defined.
+// #define USE_MS_CNGAPI
+
+// If the user did not make a choice, then select CryptoNG if either
+// Visual Studio 2015 is available, or Windows 10 or above is available.
+#if !defined(USE_MS_CRYPTOAPI) && !defined(USE_MS_CNGAPI)
+# if (_MSC_VER >= 1900) || ((WINVER >= 0x0A00 /*_WIN32_WINNT_WIN10*/) || (_WIN32_WINNT >= 0x0A00 /*_WIN32_WINNT_WIN10*/))
+# define USE_MS_CNGAPI
+# else
+# define USE_MS_CRYPTOAPI
+# endif
+#endif
+
+// Define this to ensure C/C++ standard compliance and respect for GCC aliasing rules and other alignment fodder. If you
+// experience a break with GCC at -O3, you should try this first. Guard it in case its set on the command line (and it differs).
+#ifndef CRYPTOPP_NO_UNALIGNED_DATA_ACCESS
+# define CRYPTOPP_NO_UNALIGNED_DATA_ACCESS
+#endif
+
+// ***************** Less Important Settings ***************
+
+// Library version
+#define CRYPTOPP_VERSION 565
+
+// Define this if you want to set a prefix for TestData/ and TestVectors/
+// Be mindful of the trailing slash since its simple concatenation.
+// g++ ... -DCRYPTOPP_DATA_DIR='"/tmp/cryptopp_test/share/"'
+#ifndef CRYPTOPP_DATA_DIR
+# define CRYPTOPP_DATA_DIR ""
+#endif
+
+// define this to retain (as much as possible) old deprecated function and class names
+// #define CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY
+
+// Define this to retain (as much as possible) ABI and binary compatibility with Crypto++ 5.6.2.
+// Also see https://cryptopp.com/wiki/Config.h#Avoid_MAINTAIN_BACKWARDS_COMPATIBILITY
+// #define CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
+
+// Define this if you want or need the library's memcpy_s and memmove_s.
+// See http://github.com/weidai11/cryptopp/issues/28.
+// #if !defined(CRYPTOPP_WANT_SECURE_LIB)
+// # define CRYPTOPP_WANT_SECURE_LIB
+// #endif
+
+// File system code to write to GZIP archive.
+#if !defined(GZIP_OS_CODE)
+# define GZIP_OS_CODE 0
+#endif
+
+// Try this if your CPU has 256K internal cache or a slow multiply instruction
+// and you want a (possibly) faster IDEA implementation using log tables
+// #define IDEA_LARGECACHE
+
+// Define this if, for the linear congruential RNG, you want to use
+// the original constants as specified in S.K. Park and K.W. Miller's
+// CACM paper.
+// #define LCRNG_ORIGINAL_NUMBERS
+
+// Define this if you want Integer's operator<< to honor std::showbase (and
+// std::noshowbase). If defined, Integer will use a suffix of 'b', 'o', 'h'
+// or '.' (the last for decimal) when std::showbase is in effect. If
+// std::noshowbase is set, then the suffix is not added to the Integer. If
+// not defined, existing behavior is preserved and Integer will use a suffix
+// of 'b', 'o', 'h' or '.' (the last for decimal).
+// #define CRYPTOPP_USE_STD_SHOWBASE
+
+// choose which style of sockets to wrap (mostly useful for MinGW which has both)
+#if !defined(NO_BERKELEY_STYLE_SOCKETS) && !defined(PREFER_BERKELEY_STYLE_SOCKETS)
+# define PREFER_BERKELEY_STYLE_SOCKETS
+#endif
+
+// #if !defined(NO_WINDOWS_STYLE_SOCKETS) && !defined(PREFER_WINDOWS_STYLE_SOCKETS)
+// # define PREFER_WINDOWS_STYLE_SOCKETS
+// #endif
+
+// set the name of Rijndael cipher, was "Rijndael" before version 5.3
+#define CRYPTOPP_RIJNDAEL_NAME "AES"
+
+// CRYPTOPP_DEBUG enables the library's CRYPTOPP_ASSERT. CRYPTOPP_ASSERT
+// raises a SIGTRAP (Unix) or calls DebugBreak() (Windows). CRYPTOPP_ASSERT
+// is only in effect when CRYPTOPP_DEBUG, DEBUG or _DEBUG is defined. Unlike
+// Posix assert, CRYPTOPP_ASSERT is not affected by NDEBUG (or failure to
+// define it).
+// Also see http://github.com/weidai11/cryptopp/issues/277, CVE-2016-7420
+#if (defined(DEBUG) || defined(_DEBUG)) && !defined(CRYPTOPP_DEBUG)
+# define CRYPTOPP_DEBUG 1
+#endif
+
+// ***************** Initialization and Constructor priorities ********************
+
+// MacPorts/GCC and Solaris/GCC does not provide constructor(priority). Apple/GCC and Fink/GCC do provide it.
+// See http://cryptopp.com/wiki/Static_Initialization_Order_Fiasco
+
+// CRYPTOPP_INIT_PRIORITY attempts to manage initialization of C++ static objects.
+// Under GCC, the library uses init_priority attribute in the range
+// [CRYPTOPP_INIT_PRIORITY, CRYPTOPP_INIT_PRIORITY+100]. Under Windows,
+// CRYPTOPP_INIT_PRIORITY enlists "#pragma init_seg(lib)".
+#ifndef CRYPTOPP_INIT_PRIORITY
+# define CRYPTOPP_INIT_PRIORITY 250
+#endif
+
+// CRYPTOPP_USER_PRIORITY is for other libraries and user code that is using Crypto++
+// and managing C++ static object creation. It is guaranteed not to conflict with
+// values used by (or would be used by) the Crypto++ library.
+#if defined(CRYPTOPP_INIT_PRIORITY) && (CRYPTOPP_INIT_PRIORITY > 0)
+# define CRYPTOPP_USER_PRIORITY (CRYPTOPP_INIT_PRIORITY + 101)
+#else
+# define CRYPTOPP_USER_PRIORITY 350
+#endif
+
+// __attribute__(init_priority(250)) is supported
+#if (__GNUC__ && (CRYPTOPP_INIT_PRIORITY > 0) && ((CRYPTOPP_GCC_VERSION >= 40300) || (CRYPTOPP_LLVM_CLANG_VERSION >= 20900) || (_INTEL_COMPILER >= 300)) && !(MACPORTS_GCC_COMPILER > 0) && !defined(__sun__))
+# define HAVE_GCC_CONSTRUCTOR1 1
+#endif
+
+// __attribute__(init_priority()) is supported
+#if (__GNUC__ && (CRYPTOPP_INIT_PRIORITY > 0) && !HAVE_GCC_CONSTRUCTOR1 && !(MACPORTS_GCC_COMPILER > 0) && !defined(__sun__))
+# define HAVE_GCC_CONSTRUCTOR0 1
+#endif
+
+#if (_MSC_VER && (CRYPTOPP_INIT_PRIORITY > 0))
+# define HAVE_MSC_INIT_PRIORITY 1
+#endif
+
+// ***************** Important Settings Again ********************
+// But the defaults should be ok.
+
+// namespace support is now required
+#ifdef NO_NAMESPACE
+# error namespace support is now required
+#endif
+
+// Define this to workaround a Microsoft CryptoAPI bug where
+// each call to CryptAcquireContext causes a 100 KB memory leak.
+// Defining this will cause Crypto++ to make only one call to CryptAcquireContext.
+#define WORKAROUND_MS_BUG_Q258000
+
+#ifdef CRYPTOPP_DOXYGEN_PROCESSING
+// Document the namespce exists. Put it here before CryptoPP is undefined below.
+//! \namespace CryptoPP
+//! \brief Crypto++ library namespace
+//! \details Nearly all classes are located in the CryptoPP namespace. Within
+//! the namespace, there are two additional namespaces.
+//!
+//! - Name - namespace for names used with \p NameValuePairs and documented in argnames.h
+//!
- Weak - namespace for weak and wounded algorithms, like ARC4, MD5 and Pananma
+//!
+namespace CryptoPP { }
+// Bring in the symbols fund in the weak namespace; and fold Weak1 into Weak
+# define CRYPTOPP_ENABLE_NAMESPACE_WEAK 1
+# define Weak1 Weak
+// Avoid putting "CryptoPP::" in front of everything in Doxygen output
+# define CryptoPP
+# define NAMESPACE_BEGIN(x)
+# define NAMESPACE_END
+// Get Doxygen to generate better documentation for these typedefs
+# define DOCUMENTED_TYPEDEF(x, y) class y : public x {};
+// Make "protected" "private" so the functions and members are not documented
+# define protected private
+#else
+# define NAMESPACE_BEGIN(x) namespace x {
+# define NAMESPACE_END }
+# define DOCUMENTED_TYPEDEF(x, y) typedef x y;
+#endif
+#define ANONYMOUS_NAMESPACE_BEGIN namespace {
+#define ANONYMOUS_NAMESPACE_END }
+#define USING_NAMESPACE(x) using namespace x;
+#define DOCUMENTED_NAMESPACE_BEGIN(x) namespace x {
+#define DOCUMENTED_NAMESPACE_END }
+
+// What is the type of the third parameter to bind?
+// For Unix, the new standard is ::socklen_t (typically unsigned int), and the old standard is int.
+// Unfortunately there is no way to tell whether or not socklen_t is defined.
+// To work around this, TYPE_OF_SOCKLEN_T is a macro so that you can change it from the makefile.
+#ifndef TYPE_OF_SOCKLEN_T
+# if defined(_WIN32) || defined(__CYGWIN__)
+# define TYPE_OF_SOCKLEN_T int
+# else
+# define TYPE_OF_SOCKLEN_T ::socklen_t
+# endif
+#endif
+
+#if defined(__CYGWIN__) && defined(PREFER_WINDOWS_STYLE_SOCKETS)
+# define __USE_W32_SOCKETS
+#endif
+
+typedef unsigned char byte; // put in global namespace to avoid ambiguity with other byte typedefs
+
+NAMESPACE_BEGIN(CryptoPP)
+
+typedef unsigned short word16;
+typedef unsigned int word32;
+
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+ typedef unsigned __int64 word64;
+ #define W64LIT(x) x##ui64
+#elif (_LP64 || __LP64__)
+ typedef unsigned long word64;
+ #define W64LIT(x) x##UL
+#else
+ typedef unsigned long long word64;
+ #define W64LIT(x) x##ULL
+#endif
+
+// define large word type, used for file offsets and such
+typedef word64 lword;
+const lword LWORD_MAX = W64LIT(0xffffffffffffffff);
+
+// Clang pretends to be VC++, too.
+// See http://github.com/weidai11/cryptopp/issues/147
+#if defined(_MSC_VER) && defined(__clang__)
+# error: "Unsupported configuration"
+#endif
+
+#ifdef __GNUC__
+ #define CRYPTOPP_GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
+#endif
+
+// Apple and LLVM's Clang. Apple Clang version 7.0 roughly equals LLVM Clang version 3.7
+#if defined(__clang__ ) && !defined(__apple_build_version__)
+ #define CRYPTOPP_LLVM_CLANG_VERSION (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__)
+ #define CRYPTOPP_CLANG_INTEGRATED_ASSEMBLER 1
+#elif defined(__clang__ ) && defined(__apple_build_version__)
+ #define CRYPTOPP_APPLE_CLANG_VERSION (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__)
+ #define CRYPTOPP_CLANG_INTEGRATED_ASSEMBLER 1
+#endif
+
+#ifdef _MSC_VER
+ #define CRYPTOPP_MSC_VERSION (_MSC_VER)
+#endif
+
+// Need GCC 4.6/Clang 1.7/Apple Clang 2.0 or above due to "GCC diagnostic {push|pop}"
+#if (CRYPTOPP_GCC_VERSION >= 40600) || (CRYPTOPP_LLVM_CLANG_VERSION >= 10700) || (CRYPTOPP_APPLE_CLANG_VERSION >= 20000)
+ #define CRYPTOPP_GCC_DIAGNOSTIC_AVAILABLE 1
+#endif
+
+// Clang due to "Inline assembly operands don't work with .intel_syntax", http://llvm.org/bugs/show_bug.cgi?id=24232
+// TODO: supply the upper version when LLVM fixes it. We set it to 20.0 for compilation purposes.
+#if (defined(CRYPTOPP_LLVM_CLANG_VERSION) && CRYPTOPP_LLVM_CLANG_VERSION <= 200000) || (defined(CRYPTOPP_APPLE_CLANG_VERSION) && CRYPTOPP_APPLE_CLANG_VERSION <= 200000) || defined(CRYPTOPP_CLANG_INTEGRATED_ASSEMBLER)
+ #define CRYPTOPP_DISABLE_INTEL_ASM 1
+#endif
+
+// define hword, word, and dword. these are used for multiprecision integer arithmetic
+// Intel compiler won't have _umul128 until version 10.0. See http://softwarecommunity.intel.com/isn/Community/en-US/forums/thread/30231625.aspx
+#if (defined(_MSC_VER) && (!defined(__INTEL_COMPILER) || __INTEL_COMPILER >= 1000) && (defined(_M_X64) || defined(_M_IA64))) || (defined(__DECCXX) && defined(__alpha__)) || (defined(__INTEL_COMPILER) && defined(__x86_64__)) || (defined(__SUNPRO_CC) && defined(__x86_64__))
+ typedef word32 hword;
+ typedef word64 word;
+#else
+ #define CRYPTOPP_NATIVE_DWORD_AVAILABLE 1
+ #if defined(__alpha__) || defined(__ia64__) || defined(_ARCH_PPC64) || defined(__x86_64__) || defined(__mips64) || defined(__sparc64__)
+ #if defined(__GNUC__) && !defined(__INTEL_COMPILER) && !(CRYPTOPP_GCC_VERSION == 40001 && defined(__APPLE__)) && CRYPTOPP_GCC_VERSION >= 30400
+ // GCC 4.0.1 on MacOS X is missing __umodti3 and __udivti3
+ // mode(TI) division broken on amd64 with GCC earlier than GCC 3.4
+ typedef word32 hword;
+ typedef word64 word;
+ typedef __uint128_t dword;
+ typedef __uint128_t word128;
+ #define CRYPTOPP_WORD128_AVAILABLE 1
+ #else
+ // if we're here, it means we're on a 64-bit CPU but we don't have a way to obtain 128-bit multiplication results
+ typedef word16 hword;
+ typedef word32 word;
+ typedef word64 dword;
+ #endif
+ #else
+ // being here means the native register size is probably 32 bits or less
+ #define CRYPTOPP_BOOL_SLOW_WORD64 1
+ typedef word16 hword;
+ typedef word32 word;
+ typedef word64 dword;
+ #endif
+#endif
+#ifndef CRYPTOPP_BOOL_SLOW_WORD64
+ #define CRYPTOPP_BOOL_SLOW_WORD64 0
+#endif
+
+const unsigned int WORD_SIZE = sizeof(word);
+const unsigned int WORD_BITS = WORD_SIZE * 8;
+
+NAMESPACE_END
+
+#ifndef CRYPTOPP_L1_CACHE_LINE_SIZE
+ // This should be a lower bound on the L1 cache line size. It's used for defense against timing attacks.
+ // Also see http://stackoverflow.com/questions/794632/programmatically-get-the-cache-line-size.
+ #if defined(_M_X64) || defined(__x86_64__) || (__arm64__) || (__aarch64__)
+ #define CRYPTOPP_L1_CACHE_LINE_SIZE 64
+ #else
+ // L1 cache line size is 32 on Pentium III and earlier
+ #define CRYPTOPP_L1_CACHE_LINE_SIZE 32
+ #endif
+#endif
+
+#if defined(_MSC_VER)
+ #if _MSC_VER == 1200
+ #include
+ #endif
+ #if _MSC_VER > 1200 || defined(_mm_free)
+ #define CRYPTOPP_MSVC6PP_OR_LATER // VC 6 processor pack or later
+ #else
+ #define CRYPTOPP_MSVC6_NO_PP // VC 6 without processor pack
+ #endif
+#endif
+
+#ifndef CRYPTOPP_ALIGN_DATA
+ #if defined(CRYPTOPP_MSVC6PP_OR_LATER)
+ #define CRYPTOPP_ALIGN_DATA(x) __declspec(align(x))
+ #elif defined(__GNUC__)
+ #define CRYPTOPP_ALIGN_DATA(x) __attribute__((aligned(x)))
+ #else
+ #define CRYPTOPP_ALIGN_DATA(x)
+ #endif
+#endif
+
+#ifndef CRYPTOPP_SECTION_ALIGN16
+#if defined(__GNUC__) && !defined(__APPLE__)
+ // the alignment attribute doesn't seem to work without this section attribute when -fdata-sections is turned on
+ #define CRYPTOPP_SECTION_ALIGN16 __attribute__((section ("CryptoPP_Align16")))
+ #else
+ #define CRYPTOPP_SECTION_ALIGN16
+ #endif
+#endif
+
+// The section attribute attempts to initialize CPU flags to avoid Valgrind findings above -O1
+#if ((__MACH__ >= 1) && ((CRYPTOPP_LLVM_CLANG_VERSION >= 30600) || (CRYPTOPP_APPLE_CLANG_VERSION >= 70100) || (CRYPTOPP_GCC_VERSION >= 40300)))
+ #define CRYPTOPP_SECTION_INIT __attribute__((section ("__DATA,__data")))
+#elif ((__ELF__ >= 1) && (CRYPTOPP_GCC_VERSION >= 40300))
+ #define CRYPTOPP_SECTION_INIT __attribute__((section ("nocommon")))
+#else
+ #define CRYPTOPP_SECTION_INIT
+#endif
+
+#if defined(_MSC_VER) || defined(__fastcall)
+ #define CRYPTOPP_FASTCALL __fastcall
+#else
+ #define CRYPTOPP_FASTCALL
+#endif
+
+// VC60 workaround: it doesn't allow typename in some places
+#if defined(_MSC_VER) && (_MSC_VER < 1300)
+#define CPP_TYPENAME
+#else
+#define CPP_TYPENAME typename
+#endif
+
+// VC60 workaround: can't cast unsigned __int64 to float or double
+#if defined(_MSC_VER) && !defined(CRYPTOPP_MSVC6PP_OR_LATER)
+#define CRYPTOPP_VC6_INT64 (__int64)
+#else
+#define CRYPTOPP_VC6_INT64
+#endif
+
+#ifdef _MSC_VER
+#define CRYPTOPP_NO_VTABLE __declspec(novtable)
+#else
+#define CRYPTOPP_NO_VTABLE
+#endif
+
+#ifdef _MSC_VER
+ // 4127: conditional expression is constant
+ // 4231: nonstandard extension used : 'extern' before template explicit instantiation
+ // 4250: dominance
+ // 4251: member needs to have dll-interface
+ // 4275: base needs to have dll-interface
+ // 4505: unreferenced local function
+ // 4512: assignment operator not generated
+ // 4660: explicitly instantiating a class that's already implicitly instantiated
+ // 4661: no suitable definition provided for explicit template instantiation request
+ // 4786: identifer was truncated in debug information
+ // 4355: 'this' : used in base member initializer list
+ // 4910: '__declspec(dllexport)' and 'extern' are incompatible on an explicit instantiation
+# pragma warning(disable: 4127 4231 4250 4251 4275 4505 4512 4660 4661 4786 4355 4910)
+ // Security related, possible defects
+ // http://blogs.msdn.com/b/vcblog/archive/2010/12/14/off-by-default-compiler-warnings-in-visual-c.aspx
+# pragma warning(once: 4191 4242 4263 4264 4266 4302 4826 4905 4906 4928)
+#endif
+
+#ifdef __BORLANDC__
+// 8037: non-const function called for const object. needed to work around BCB2006 bug
+# pragma warn -8037
+#endif
+
+// [GCC Bug 53431] "C++ preprocessor ignores #pragma GCC diagnostic". Clang honors it.
+#if CRYPTOPP_GCC_DIAGNOSTIC_AVAILABLE
+# pragma GCC diagnostic ignored "-Wunknown-pragmas"
+# pragma GCC diagnostic ignored "-Wunused-function"
+#endif
+
+// You may need to force include a C++ header on Android when using STLPort to ensure
+// _STLPORT_VERSION is defined: CXXFLAGS="-DNDEBUG -g2 -O2 -std=c++11 -include iosfwd"
+// TODO: Figure out C++17 and lack of std::uncaught_exception
+#if (defined(_MSC_VER) && _MSC_VER <= 1300) || defined(__MWERKS__) || (defined(_STLPORT_VERSION) && ((_STLPORT_VERSION < 0x450) || defined(_STLP_NO_UNCAUGHT_EXCEPT_SUPPORT)))
+#define CRYPTOPP_DISABLE_UNCAUGHT_EXCEPTION
+#endif
+
+#ifndef CRYPTOPP_DISABLE_UNCAUGHT_EXCEPTION
+#define CRYPTOPP_UNCAUGHT_EXCEPTION_AVAILABLE
+#endif
+
+#ifdef CRYPTOPP_DISABLE_X86ASM // for backwards compatibility: this macro had both meanings
+#define CRYPTOPP_DISABLE_ASM
+#define CRYPTOPP_DISABLE_SSE2
+#endif
+
+// Apple's Clang prior to 5.0 cannot handle SSE2 (and Apple does not use LLVM Clang numbering...)
+#if defined(CRYPTOPP_APPLE_CLANG_VERSION) && (CRYPTOPP_APPLE_CLANG_VERSION < 50000)
+# define CRYPTOPP_DISABLE_ASM
+#endif
+
+// Sun Studio 12 provides GCC inline assembly, http://blogs.oracle.com/x86be/entry/gcc_style_asm_inlining_support
+// We can enable SSE2 for Sun Studio in the makefile with -D__SSE2__, but users may not compile with it.
+#if !defined(CRYPTOPP_DISABLE_ASM) && !defined(__SSE2__) && defined(__x86_64__) && (__SUNPRO_CC >= 0x5100)
+# define __SSE2__ 1
+#endif
+
+#if !defined(CRYPTOPP_DISABLE_ASM) && ((defined(_MSC_VER) && defined(_M_IX86)) || (defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))))
+ // C++Builder 2010 does not allow "call label" where label is defined within inline assembly
+ #define CRYPTOPP_X86_ASM_AVAILABLE
+
+ #if !defined(CRYPTOPP_DISABLE_SSE2) && (defined(CRYPTOPP_MSVC6PP_OR_LATER) || CRYPTOPP_GCC_VERSION >= 30300 || defined(__SSE2__))
+ #define CRYPTOPP_BOOL_SSE2_ASM_AVAILABLE 1
+ #else
+ #define CRYPTOPP_BOOL_SSE2_ASM_AVAILABLE 0
+ #endif
+
+ #if !defined(CRYPTOPP_DISABLE_SSE3) && (_MSC_VER >= 1500 || (defined(__SSE3__) && defined(__SSSE3__)))
+ #define CRYPTOPP_BOOL_SSSE3_ASM_AVAILABLE 1
+ #else
+ #define CRYPTOPP_BOOL_SSSE3_ASM_AVAILABLE 0
+ #endif
+#endif
+
+#if !defined(CRYPTOPP_DISABLE_ASM) && defined(_MSC_VER) && defined(_M_X64)
+ #define CRYPTOPP_X64_MASM_AVAILABLE
+#endif
+
+#if !defined(CRYPTOPP_DISABLE_ASM) && defined(__GNUC__) && defined(__x86_64__)
+ #define CRYPTOPP_X64_ASM_AVAILABLE
+#endif
+
+#if !defined(CRYPTOPP_DISABLE_ASM) && (defined(CRYPTOPP_MSVC6PP_OR_LATER) || defined(__SSE2__)) && !defined(_M_ARM)
+ #define CRYPTOPP_BOOL_SSE2_INTRINSICS_AVAILABLE 1
+#else
+ #define CRYPTOPP_BOOL_SSE2_INTRINSICS_AVAILABLE 0
+#endif
+
+// Intrinsics availible in GCC 4.3 (http://gcc.gnu.org/gcc-4.3/changes.html) and
+// MSVC 2008 (http://msdn.microsoft.com/en-us/library/bb892950%28v=vs.90%29.aspx)
+// SunCC could generate SSE4 at 12.1, but the intrinsics are missing until 12.4.
+#if !defined(CRYPTOPP_DISABLE_ASM) && !defined(CRYPTOPP_DISABLE_SSE4) && !defined(_M_ARM) && ((_MSC_VER >= 1500) || (defined(__SSE4_1__) && defined(__SSE4_2__)))
+ #define CRYPTOPP_BOOL_SSE4_INTRINSICS_AVAILABLE 1
+#else
+ #define CRYPTOPP_BOOL_SSE4_INTRINSICS_AVAILABLE 0
+#endif
+
+// Don't disgorge AES-NI from CLMUL. There will be two to four subtle breaks
+#if !defined(CRYPTOPP_DISABLE_ASM) && !defined(CRYPTOPP_DISABLE_AESNI) && !defined(_M_ARM) && (_MSC_FULL_VER >= 150030729 || __INTEL_COMPILER >= 1110 || (defined(__AES__) && defined(__PCLMUL__)))
+ #define CRYPTOPP_BOOL_AESNI_INTRINSICS_AVAILABLE 1
+#else
+ #define CRYPTOPP_BOOL_AESNI_INTRINSICS_AVAILABLE 0
+#endif
+
+// AVX2 in MSC 18.00
+#if !defined(CRYPTOPP_DISABLE_ASM) && !defined(CRYPTOPP_DISABLE_AVX) && !defined(_M_ARM) && ((_MSC_VER >= 1600) || (defined(__RDRND__) || defined(__RDSEED__) || defined(__AVX__)))
+ #define CRYPTOPP_BOOL_AVX_AVAILABLE 1
+#else
+ #define CRYPTOPP_BOOL_AVX_AVAILABLE 0
+#endif
+
+// Requires ARMv7 and ACLE 1.0. Testing shows ARMv7 is really ARMv7a under most toolchains.
+#if !defined(CRYPTOPP_BOOL_NEON_INTRINSICS_AVAILABLE) && !defined(CRYPTOPP_DISABLE_ASM)
+# if defined(__ARM_NEON__) || defined(__ARM_NEON) || defined(_M_ARM)
+# define CRYPTOPP_BOOL_NEON_INTRINSICS_AVAILABLE 1
+# endif
+#endif
+
+// Requires ARMv8 and ACLE 2.0. For GCC, requires 4.8 and above.
+// Microsoft plans to support ARM-64, but its not clear how to detect it.
+// TODO: Add MSC_VER and ARM-64 platform define when available
+#if !defined(CRYPTOPP_BOOL_ARM_CRC32_INTRINSICS_AVAILABLE) && !defined(CRYPTOPP_DISABLE_ASM)
+# if defined(__ARM_FEATURE_CRC32) || defined(_M_ARM64)
+# define CRYPTOPP_BOOL_ARM_CRC32_INTRINSICS_AVAILABLE 1
+# endif
+#endif
+
+// Requires ARMv8 and ACLE 2.0. For GCC, requires 4.8 and above.
+// Microsoft plans to support ARM-64, but its not clear how to detect it.
+// TODO: Add MSC_VER and ARM-64 platform define when available
+#if !defined(CRYPTOPP_BOOL_ARM_CRYPTO_INTRINSICS_AVAILABLE) && !defined(CRYPTOPP_DISABLE_ASM)
+# if defined(__ARM_FEATURE_CRYPTO) || defined(_M_ARM64)
+# define CRYPTOPP_BOOL_ARM_CRYPTO_INTRINSICS_AVAILABLE 1
+# endif
+#endif
+
+#if CRYPTOPP_BOOL_SSE2_INTRINSICS_AVAILABLE || CRYPTOPP_BOOL_SSE2_ASM_AVAILABLE || CRYPTOPP_BOOL_NEON_INTRINSICS_AVAILABLE || defined(CRYPTOPP_X64_MASM_AVAILABLE)
+ #define CRYPTOPP_BOOL_ALIGN16 1
+#else
+ #define CRYPTOPP_BOOL_ALIGN16 0
+#endif
+
+// how to allocate 16-byte aligned memory (for SSE2)
+#if defined(CRYPTOPP_MSVC6PP_OR_LATER)
+ #define CRYPTOPP_MM_MALLOC_AVAILABLE
+#elif defined(__APPLE__)
+ #define CRYPTOPP_APPLE_MALLOC_AVAILABLE
+#elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
+ #define CRYPTOPP_MALLOC_ALIGNMENT_IS_16
+#elif defined(__linux__) || defined(__sun__) || defined(__CYGWIN__)
+ #define CRYPTOPP_MEMALIGN_AVAILABLE
+#else
+ #define CRYPTOPP_NO_ALIGNED_ALLOC
+#endif
+
+// Apple always provides 16-byte aligned, and tells us to use calloc
+// http://developer.apple.com/library/mac/documentation/Performance/Conceptual/ManagingMemory/Articles/MemoryAlloc.html
+
+// how to disable inlining
+#if defined(_MSC_VER) && _MSC_VER >= 1300
+# define CRYPTOPP_NOINLINE_DOTDOTDOT
+# define CRYPTOPP_NOINLINE __declspec(noinline)
+#elif defined(__GNUC__)
+# define CRYPTOPP_NOINLINE_DOTDOTDOT
+# define CRYPTOPP_NOINLINE __attribute__((noinline))
+#else
+# define CRYPTOPP_NOINLINE_DOTDOTDOT ...
+# define CRYPTOPP_NOINLINE
+#endif
+
+// How to declare class constants
+// Use enum for OS X 10.5 ld, http://github.com/weidai11/cryptopp/issues/255
+#if (defined(_MSC_VER) && _MSC_VER <= 1300) || defined(__INTEL_COMPILER) || defined(__BORLANDC__)
+# define CRYPTOPP_CONSTANT(x) enum {x};
+#else
+# define CRYPTOPP_CONSTANT(x) static const int x;
+#endif
+
+// Linux provides X32, which is 32-bit integers, longs and pointers on x86_64 using the full x86_64 register set.
+// Detect via __ILP32__ (http://wiki.debian.org/X32Port). However, __ILP32__ shows up in more places than
+// the System V ABI specs calls out, like on just about any 32-bit system with Clang.
+#if ((__ILP32__ >= 1) || (_ILP32 >= 1)) && defined(__x86_64__)
+ #define CRYPTOPP_BOOL_X32 1
+#else
+ #define CRYPTOPP_BOOL_X32 0
+#endif
+
+// see http://predef.sourceforge.net/prearch.html
+#if (defined(_M_IX86) || defined(__i386__) || defined(__i386) || defined(_X86_) || defined(__I86__) || defined(__INTEL__)) && !CRYPTOPP_BOOL_X32
+ #define CRYPTOPP_BOOL_X86 1
+#else
+ #define CRYPTOPP_BOOL_X86 0
+#endif
+
+#if (defined(_M_X64) || defined(__x86_64__)) && !CRYPTOPP_BOOL_X32
+ #define CRYPTOPP_BOOL_X64 1
+#else
+ #define CRYPTOPP_BOOL_X64 0
+#endif
+
+// Undo the ASM and Intrinsic related defines due to X32.
+#if CRYPTOPP_BOOL_X32
+# undef CRYPTOPP_BOOL_X64
+# undef CRYPTOPP_X64_ASM_AVAILABLE
+# undef CRYPTOPP_X64_MASM_AVAILABLE
+#endif
+
+#if defined(__arm__) || defined(__aarch32__) || defined(_M_ARM)
+ #define CRYPTOPP_BOOL_ARM32 1
+#else
+ #define CRYPTOPP_BOOL_ARM32 0
+#endif
+
+// Microsoft plans to support ARM-64, but its not clear how to detect it.
+// TODO: Add MSC_VER and ARM-64 platform define when available
+#if defined(__arm64__) || defined(__aarch64__) || defined(_M_ARM64)
+ #define CRYPTOPP_BOOL_ARM64 1
+#else
+ #define CRYPTOPP_BOOL_ARM64 0
+#endif
+
+#if !defined(CRYPTOPP_NO_UNALIGNED_DATA_ACCESS) && !defined(CRYPTOPP_ALLOW_UNALIGNED_DATA_ACCESS)
+#if (CRYPTOPP_BOOL_X64 || CRYPTOPP_BOOL_X86 || CRYPTOPP_BOOL_X32 || defined(__powerpc__) || (__ARM_FEATURE_UNALIGNED >= 1))
+ #define CRYPTOPP_ALLOW_UNALIGNED_DATA_ACCESS
+#endif
+#endif
+
+// ***************** determine availability of OS features ********************
+
+#ifndef NO_OS_DEPENDENCE
+
+#if defined(_WIN32) || defined(__CYGWIN__)
+#define CRYPTOPP_WIN32_AVAILABLE
+#endif
+
+#if defined(__unix__) || defined(__MACH__) || defined(__NetBSD__) || defined(__sun)
+#define CRYPTOPP_UNIX_AVAILABLE
+#endif
+
+#if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
+#define CRYPTOPP_BSD_AVAILABLE
+#endif
+
+#if defined(CRYPTOPP_WIN32_AVAILABLE) || defined(CRYPTOPP_UNIX_AVAILABLE)
+# define HIGHRES_TIMER_AVAILABLE
+#endif
+
+#ifdef CRYPTOPP_WIN32_AVAILABLE
+# if !defined(WINAPI_FAMILY)
+# define THREAD_TIMER_AVAILABLE
+# elif defined(WINAPI_FAMILY)
+# if (WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP))
+# define THREAD_TIMER_AVAILABLE
+# endif
+# endif
+#endif
+
+#ifdef CRYPTOPP_UNIX_AVAILABLE
+# define HAS_BERKELEY_STYLE_SOCKETS
+# define SOCKETS_AVAILABLE
+#endif
+
+// Sockets are only available under Windows Runtime desktop partition apps (despite the MSDN literature)
+#ifdef CRYPTOPP_WIN32_AVAILABLE
+# define HAS_WINDOWS_STYLE_SOCKETS
+# if !defined(WINAPI_FAMILY)
+# define SOCKETS_AVAILABLE
+# elif defined(WINAPI_FAMILY)
+# if (WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP))
+# define SOCKETS_AVAILABLE
+# endif
+# endif
+#endif
+
+#if defined(HAS_WINDOWS_STYLE_SOCKETS) && (!defined(HAS_BERKELEY_STYLE_SOCKETS) || defined(PREFER_WINDOWS_STYLE_SOCKETS))
+# define USE_WINDOWS_STYLE_SOCKETS
+#else
+# define USE_BERKELEY_STYLE_SOCKETS
+#endif
+
+#if defined(CRYPTOPP_WIN32_AVAILABLE) && defined(SOCKETS_AVAILABLE) && !defined(USE_BERKELEY_STYLE_SOCKETS)
+# define WINDOWS_PIPES_AVAILABLE
+#endif
+
+#if defined(CRYPTOPP_UNIX_AVAILABLE) || defined(CRYPTOPP_DOXYGEN_PROCESSING)
+# define NONBLOCKING_RNG_AVAILABLE
+# define BLOCKING_RNG_AVAILABLE
+# define OS_RNG_AVAILABLE
+# define HAS_PTHREADS
+# define THREADS_AVAILABLE
+#endif
+
+#if defined(CRYPTOPP_BSD_AVAILABLE) || defined(CRYPTOPP_UNIX_AVAILABLE) || defined(__CYGWIN__)
+# define UNIX_SIGNALS_AVAILABLE 1
+#endif
+
+#ifdef CRYPTOPP_WIN32_AVAILABLE
+# if !defined(WINAPI_FAMILY)
+# define HAS_WINTHREADS
+# define THREADS_AVAILABLE
+# define NONBLOCKING_RNG_AVAILABLE
+# define OS_RNG_AVAILABLE
+# elif defined(WINAPI_FAMILY)
+# if (WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP))
+# define HAS_WINTHREADS
+# define THREADS_AVAILABLE
+# define NONBLOCKING_RNG_AVAILABLE
+# define OS_RNG_AVAILABLE
+# elif !(WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP))
+# if ((WINVER >= 0x0A00 /*_WIN32_WINNT_WIN10*/) || (_WIN32_WINNT >= 0x0A00 /*_WIN32_WINNT_WIN10*/))
+# define NONBLOCKING_RNG_AVAILABLE
+# define OS_RNG_AVAILABLE
+# endif
+# endif
+# endif
+#endif
+
+#endif // NO_OS_DEPENDENCE
+
+// ***************** DLL related ********************
+
+#if defined(CRYPTOPP_WIN32_AVAILABLE) && !defined(CRYPTOPP_DOXYGEN_PROCESSING)
+
+#ifdef CRYPTOPP_EXPORTS
+#define CRYPTOPP_IS_DLL
+#define CRYPTOPP_DLL __declspec(dllexport)
+#elif defined(CRYPTOPP_IMPORTS)
+#define CRYPTOPP_IS_DLL
+#define CRYPTOPP_DLL __declspec(dllimport)
+#else
+#define CRYPTOPP_DLL
+#endif
+
+#define CRYPTOPP_API __cdecl
+
+#else // not CRYPTOPP_WIN32_AVAILABLE
+
+#define CRYPTOPP_DLL
+#define CRYPTOPP_API
+
+#endif // CRYPTOPP_WIN32_AVAILABLE
+
+#if defined(__MWERKS__)
+#define CRYPTOPP_EXTERN_DLL_TEMPLATE_CLASS extern class CRYPTOPP_DLL
+#elif defined(__BORLANDC__) || defined(__SUNPRO_CC)
+#define CRYPTOPP_EXTERN_DLL_TEMPLATE_CLASS template class CRYPTOPP_DLL
+#else
+#define CRYPTOPP_EXTERN_DLL_TEMPLATE_CLASS extern template class CRYPTOPP_DLL
+#endif
+
+#if defined(CRYPTOPP_MANUALLY_INSTANTIATE_TEMPLATES) && !defined(CRYPTOPP_IMPORTS)
+#define CRYPTOPP_DLL_TEMPLATE_CLASS template class CRYPTOPP_DLL
+#else
+#define CRYPTOPP_DLL_TEMPLATE_CLASS CRYPTOPP_EXTERN_DLL_TEMPLATE_CLASS
+#endif
+
+#if defined(__MWERKS__)
+#define CRYPTOPP_EXTERN_STATIC_TEMPLATE_CLASS extern class
+#elif defined(__BORLANDC__) || defined(__SUNPRO_CC)
+#define CRYPTOPP_EXTERN_STATIC_TEMPLATE_CLASS template class
+#else
+#define CRYPTOPP_EXTERN_STATIC_TEMPLATE_CLASS extern template class
+#endif
+
+#if defined(CRYPTOPP_MANUALLY_INSTANTIATE_TEMPLATES) && !defined(CRYPTOPP_EXPORTS)
+#define CRYPTOPP_STATIC_TEMPLATE_CLASS template class
+#else
+#define CRYPTOPP_STATIC_TEMPLATE_CLASS CRYPTOPP_EXTERN_STATIC_TEMPLATE_CLASS
+#endif
+
+// ************** Unused variable ***************
+
+// Portable way to suppress warnings.
+// Moved from misc.h due to circular depenedencies.
+#define CRYPTOPP_UNUSED(x) ((void)(x))
+
+// ************** Deprecated ***************
+
+#if (CRYPTOPP_GCC_VERSION >= 40500) || (CRYPTOPP_LLVM_CLANG_VERSION >= 20800)
+# define CRYPTOPP_DEPRECATED(msg) __attribute__((deprecated (msg)));
+#elif (CRYPTOPP_GCC_VERSION)
+# define CRYPTOPP_DEPRECATED(msg) __attribute__((deprecated));
+#else
+# define CRYPTOPP_DEPRECATED(msg)
+#endif
+
+// ***************** C++11 related ********************
+
+// Visual Studio began at VS2010, http://msdn.microsoft.com/en-us/library/hh567368%28v=vs.110%29.aspx.
+// Intel and C++11 language features, http://software.intel.com/en-us/articles/c0x-features-supported-by-intel-c-compiler
+// GCC and C++11 language features, http://gcc.gnu.org/projects/cxx0x.html
+// Clang and C++11 language features, http://clang.llvm.org/cxx_status.html
+#if ((_MSC_VER >= 1600) || (__cplusplus >= 201103L)) && !defined(_STLPORT_VERSION)
+# define CRYPTOPP_CXX11 1
+#endif
+
+// Hack ahead. Apple's standard library does not have C++'s unique_ptr in C++11. We can't
+// test for unique_ptr directly because some of the non-Apple Clangs on OS X fail the same
+// way. However, modern standard libraries have , so we test for it instead.
+// Thanks to Jonathan Wakely for devising the clever test for modern/ancient versions.
+// TODO: test under Xcode 3, where g++ is really g++.
+#if defined(__APPLE__) && defined(__clang__)
+# if !(defined(__has_include) && __has_include())
+# undef CRYPTOPP_CXX11
+# endif
+#endif
+
+// C++11 or C++14 is available
+#if defined(CRYPTOPP_CXX11)
+
+// atomics: MS at VS2012 (17.00); GCC at 4.4; Clang at 3.1/3.2; Intel 13.0; SunCC 12.5.
+#if (CRYPTOPP_MSC_VERSION >= 1700)
+# define CRYPTOPP_CXX11_ATOMICS 1
+#elif (__INTEL_COMPILER >= 1300)
+# define CRYPTOPP_CXX11_ATOMICS 1
+#elif defined(__clang__)
+# if __has_feature(cxx_atomic)
+# define CRYPTOPP_CXX11_ATOMICS 1
+# endif
+#elif (CRYPTOPP_GCC_VERSION >= 40400)
+# define CRYPTOPP_CXX11_ATOMICS 1
+#elif (__SUNPRO_CC >= 0x5140)
+# define CRYPTOPP_CXX11_ATOMICS 1
+#endif // atomics
+
+// synchronization: MS at VS2012 (17.00); GCC at 4.4; Clang at 3.3; Xcode 5.0; Intel 12.0; SunCC 12.4.
+// TODO: verify Clang and Intel versions; find __has_feature(x) extension for Clang
+#if (CRYPTOPP_MSC_VERSION >= 1700)
+# define CRYPTOPP_CXX11_SYNCHRONIZATION 1
+#elif (__INTEL_COMPILER >= 1200)
+# define CRYPTOPP_CXX11_SYNCHRONIZATION 1
+#elif (CRYPTOPP_LLVM_CLANG_VERSION >= 30300) || (CRYPTOPP_APPLE_CLANG_VERSION >= 50000)
+# define CRYPTOPP_CXX11_SYNCHRONIZATION 1
+#elif (CRYPTOPP_GCC_VERSION >= 40400)
+# define CRYPTOPP_CXX11_SYNCHRONIZATION 1
+#elif (__SUNPRO_CC >= 0x5130)
+# define CRYPTOPP_CXX11_SYNCHRONIZATION 1
+#endif // synchronization
+
+// alignof/alignas: MS at VS2015 (19.00); GCC at 4.8; Clang at 3.3; Intel 15.0; SunCC 12.4.
+#if (CRYPTOPP_MSC_VERSION >= 1900)
+# define CRYPTOPP_CXX11_ALIGNAS 1
+# define CRYPTOPP_CXX11_ALIGNOF 1
+#elif (__INTEL_COMPILER >= 1500)
+# define CRYPTOPP_CXX11_ALIGNAS 1
+# define CRYPTOPP_CXX11_ALIGNOF 1
+#elif defined(__clang__)
+# if __has_feature(cxx_alignas)
+# define CRYPTOPP_CXX11_ALIGNAS 1
+# endif
+# if __has_feature(cxx_alignof)
+# define CRYPTOPP_CXX11_ALIGNOF 1
+# endif
+#elif (CRYPTOPP_GCC_VERSION >= 40800)
+# define CRYPTOPP_CXX11_ALIGNAS 1
+# define CRYPTOPP_CXX11_ALIGNOF 1
+#elif (__SUNPRO_CC >= 0x5130)
+# define CRYPTOPP_CXX11_ALIGNAS 1
+# define CRYPTOPP_CXX11_ALIGNOF 1
+#endif // alignof/alignas
+
+// noexcept: MS at VS2015 (19.00); GCC at 4.6; Clang at 3.0; Intel 14.0; SunCC 12.4.
+#if (CRYPTOPP_MSC_VERSION >= 1900)
+# define CRYPTOPP_CXX11_NOEXCEPT 1
+#elif (__INTEL_COMPILER >= 1400)
+# define CRYPTOPP_CXX11_NOEXCEPT 1
+#elif defined(__clang__)
+# if __has_feature(cxx_noexcept)
+# define CRYPTOPP_CXX11_NOEXCEPT 1
+# endif
+#elif (CRYPTOPP_GCC_VERSION >= 40600)
+# define CRYPTOPP_CXX11_NOEXCEPT 1
+#elif (__SUNPRO_CC >= 0x5130)
+# define CRYPTOPP_CXX11_NOEXCEPT 1
+#endif // noexcept compilers
+
+// variadic templates: MS at VS2013 (18.00); GCC at 4.3; Clang at 2.9; Intel 12.1; SunCC 12.4.
+#if (CRYPTOPP_MSC_VERSION >= 1800)
+# define CRYPTOPP_CXX11_VARIADIC_TEMPLATES 1
+#elif (__INTEL_COMPILER >= 1210)
+# define CRYPTOPP_CXX11_VARIADIC_TEMPLATES 1
+#elif defined(__clang__)
+# if __has_feature(cxx_variadic_templates)
+# define CRYPTOPP_CXX11_VARIADIC_TEMPLATES 1
+# endif
+#elif (CRYPTOPP_GCC_VERSION >= 40300)
+# define CRYPTOPP_CXX11_VARIADIC_TEMPLATES 1
+#elif (__SUNPRO_CC >= 0x5130)
+# define CRYPTOPP_CXX11_VARIADIC_TEMPLATES 1
+#endif // variadic templates
+
+// constexpr: MS at VS2015 (19.00); GCC at 4.6; Clang at 3.0; Intel 16.0; SunCC 12.4.
+// Intel has mis-supported the feature since at least ICPC 13.00
+#if (CRYPTOPP_MSC_VERSION >= 1900)
+# define CRYPTOPP_CXX11_CONSTEXPR 1
+#elif (__INTEL_COMPILER >= 1600)
+# define CRYPTOPP_CXX11_CONSTEXPR 1
+#elif defined(__clang__)
+# if __has_feature(cxx_constexpr)
+# define CRYPTOPP_CXX11_CONSTEXPR 1
+# endif
+#elif (CRYPTOPP_GCC_VERSION >= 40600)
+# define CRYPTOPP_CXX11_CONSTEXPR 1
+#elif (__SUNPRO_CC >= 0x5130)
+# define CRYPTOPP_CXX11_CONSTEXPR 1
+#endif // constexpr compilers
+
+// TODO: Emplacement, R-values and Move semantics
+// Needed because we are catching warnings with GCC and MSC
+
+#endif // CRYPTOPP_CXX11
+
+#if defined(CRYPTOPP_CXX11_NOEXCEPT)
+# define CRYPTOPP_THROW noexcept(false)
+# define CRYPTOPP_NO_THROW noexcept(true)
+#else
+# define CRYPTOPP_THROW
+# define CRYPTOPP_NO_THROW
+#endif // CRYPTOPP_CXX11_NOEXCEPT
+
+#if defined(CRYPTOPP_CXX11_CONSTEXPR)
+# define CRYPTOPP_CONSTEXPR constexpr
+#else
+# define CRYPTOPP_CONSTEXPR
+#endif // CRYPTOPP_CXX11_CONSTEXPR
+
+// Hack... CRYPTOPP_ALIGN_DATA is defined earlier, before C++11 alignas availability is determined
+#if defined(CRYPTOPP_CXX11_ALIGNAS)
+# undef CRYPTOPP_ALIGN_DATA
+# define CRYPTOPP_ALIGN_DATA(x) alignas(x)
+#endif // CRYPTOPP_CXX11_ALIGNAS
+
+// Hack... CRYPTOPP_CONSTANT is defined earlier, before C++11 constexpr availability is determined
+#if defined(CRYPTOPP_CXX11_CONSTEXPR)
+# undef CRYPTOPP_CONSTANT
+# define CRYPTOPP_CONSTANT(x) constexpr static int x;
+#endif
+
+// OK to comment the following out, but please report it so we can fix it.
+// C++17 value taken from http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4567.pdf.
+#if (defined(__cplusplus) && (__cplusplus >= 199711L) && (__cplusplus < 201402L)) && !defined(CRYPTOPP_UNCAUGHT_EXCEPTION_AVAILABLE)
+# error "std::uncaught_exception is not available. This is likely a configuration error."
+#endif
+
+#endif
diff --git a/libs/win_crypto++/include/cpu.h b/libs/win_crypto++/include/cpu.h
new file mode 100644
index 0000000..11a852c
--- /dev/null
+++ b/libs/win_crypto++/include/cpu.h
@@ -0,0 +1,597 @@
+// cpu.h - written and placed in the public domain by Wei Dai
+
+//! \file cpu.h
+//! \brief Functions for CPU features and intrinsics
+//! \details The functions are used in X86/X32/X64 and NEON code paths
+
+#ifndef CRYPTOPP_CPU_H
+#define CRYPTOPP_CPU_H
+
+#include "config.h"
+
+// ARM32/ARM64 Headers
+#if (CRYPTOPP_BOOL_ARM32 || CRYPTOPP_BOOL_ARM64)
+# if defined(__GNUC__)
+# include
+# endif
+# if CRYPTOPP_BOOL_NEON_INTRINSICS_AVAILABLE || defined(__ARM_NEON)
+# include
+# endif
+# if (CRYPTOPP_BOOL_ARM_CRYPTO_INTRINSICS_AVAILABLE || CRYPTOPP_BOOL_ARM_CRC32_INTRINSICS_AVAILABLE) || defined(__ARM_ACLE)
+# include
+# endif
+#endif // ARM32 and ARM64 Headers
+
+// X86/X64/X32 Headers
+#if CRYPTOPP_BOOL_X86 || CRYPTOPP_BOOL_X32 || CRYPTOPP_BOOL_X64
+
+// GCC X86 super-include
+#if (CRYPTOPP_GCC_VERSION >= 40800)
+# include
+#endif
+#if (CRYPTOPP_MSC_VERSION >= 1400)
+# include
+#endif
+
+// Baseline include
+#if CRYPTOPP_BOOL_SSE2_ASM_AVAILABLE || CRYPTOPP_BOOL_SSE2_INTRINSICS_AVAILABLE
+# include // __m64, __m128i, _mm_set_epi64x
+#endif
+#if CRYPTOPP_BOOL_SSSE3_ASM_AVAILABLE
+# include // _mm_shuffle_pi8, _mm_shuffle_epi8
+#endif // tmmintrin.h
+#if CRYPTOPP_BOOL_SSE4_INTRINSICS_AVAILABLE
+# include // _mm_blend_epi16
+# include // _mm_crc32_u{8|16|32}
+#endif // smmintrin.h
+#if CRYPTOPP_BOOL_AESNI_INTRINSICS_AVAILABLE
+# include // aesenc, aesdec, etc
+#endif // wmmintrin.h
+#if CRYPTOPP_BOOL_AVX_INTRINSICS_AVAILABLE
+# include