arne
/
cryptopp
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Remove unneeded Doxygen directive

pull/546/head
Jeffrey Walton 2018-01-19 14:31:20 -05:00
parent 24a9466e54
commit befd04312d
No known key found for this signature in database
GPG Key ID: B36AB348921B1838
105 changed files with 0 additions and 568 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
3way.h
View File

@ -12,19 +12,16 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class ThreeWay_Info
/// \brief ThreeWay block cipher information /// \brief ThreeWay block cipher information
struct ThreeWay_Info : public FixedBlockSize<12>, public FixedKeyLength<12>, public VariableRounds<11> struct ThreeWay_Info : public FixedBlockSize<12>, public FixedKeyLength<12>, public VariableRounds<11>
{ {
CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "3-Way";} CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "3-Way";}
}; };
/// \class ThreeWay
/// \brief ThreeWay block cipher /// \brief ThreeWay block cipher
/// \sa <a href="http://www.cryptopp.com/wiki/3-Way">3-Way</a> /// \sa <a href="http://www.cryptopp.com/wiki/3-Way">3-Way</a>
class ThreeWay : public ThreeWay_Info, public BlockCipherDocumentation class ThreeWay : public ThreeWay_Info, public BlockCipherDocumentation
{ {
/// \class Base
/// \brief Class specific implementation and overrides used to operate the cipher. /// \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 /// \details Implementations and overrides in \p Base apply to both \p ENCRYPTION and \p DECRYPTION directions
class CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<ThreeWay_Info> class CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<ThreeWay_Info>
@ -37,7 +34,6 @@ class ThreeWay : public ThreeWay_Info, public BlockCipherDocumentation
FixedSizeSecBlock<word32, 3> m_k; FixedSizeSecBlock<word32, 3> m_k;
}; };
/// \class Enc
/// \brief Class specific methods used to operate the cipher in the forward direction. /// \brief Class specific methods used to operate the cipher in the forward direction.
/// \details Implementations and overrides in \p Enc apply to \p ENCRYPTION. /// \details Implementations and overrides in \p Enc apply to \p ENCRYPTION.
class CRYPTOPP_NO_VTABLE Enc : public Base class CRYPTOPP_NO_VTABLE Enc : public Base
@ -46,7 +42,6 @@ class ThreeWay : public ThreeWay_Info, public BlockCipherDocumentation
void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const; void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
}; };
/// \class Dec
/// \brief Class specific methods used to operate the cipher in the reverse direction. /// \brief Class specific methods used to operate the cipher in the reverse direction.
/// \details Implementations and overrides in \p Dec apply to \p DECRYPTION. /// \details Implementations and overrides in \p Dec apply to \p DECRYPTION.
class CRYPTOPP_NO_VTABLE Dec : public Base class CRYPTOPP_NO_VTABLE Dec : public Base

1
aes.h
View File

@ -14,7 +14,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class AES
/// \brief AES block cipher (Rijndael) /// \brief AES block cipher (Rijndael)
/// \details AES is a typdef for Rijndael classes. All key sizes are supported. /// \details AES is a typdef for Rijndael classes. All key sizes are supported.
/// The library only provides Rijndael with 128-bit blocks, and not 192-bit or 256-bit blocks /// The library only provides Rijndael with 128-bit blocks, and not 192-bit or 256-bit blocks

7
algparam.h
View File

@ -26,7 +26,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class ConstByteArrayParameter
/// \brief Used to pass byte array input as part of a NameValuePairs object /// \brief Used to pass byte array input as part of a NameValuePairs object
class ConstByteArrayParameter class ConstByteArrayParameter
{ {
@ -101,7 +100,6 @@ private:
SecByteBlock m_block; SecByteBlock m_block;
}; };
/// \class ByteArrayParameter
/// \brief Used to pass byte array input as part of a NameValuePairs object /// \brief Used to pass byte array input as part of a NameValuePairs object
class ByteArrayParameter class ByteArrayParameter
{ {
@ -129,7 +127,6 @@ private:
size_t m_size; size_t m_size;
}; };
/// \class CombinedNameValuePairs
/// \brief Combines two sets of NameValuePairs /// \brief Combines two sets of NameValuePairs
/// \details CombinedNameValuePairs allows you to provide two sets of of NameValuePairs. /// \details CombinedNameValuePairs allows you to provide two sets of of NameValuePairs.
/// If a name is not found in the first set, then the second set is searched for the /// If a name is not found in the first set, then the second set is searched for the
@ -308,12 +305,10 @@ CRYPTOPP_DLL bool AssignIntToInteger(const std::type_info &valueType, void *pInt
CRYPTOPP_DLL const std::type_info & CRYPTOPP_API IntegerTypeId(); CRYPTOPP_DLL const std::type_info & CRYPTOPP_API IntegerTypeId();
/// \class AlgorithmParametersBase
/// \brief Base class for AlgorithmParameters /// \brief Base class for AlgorithmParameters
class CRYPTOPP_DLL AlgorithmParametersBase class CRYPTOPP_DLL AlgorithmParametersBase
{ {
public: public:
/// \class ParameterNotUsed
/// \brief Exception thrown when an AlgorithmParameter is unused /// \brief Exception thrown when an AlgorithmParameter is unused
class ParameterNotUsed : public Exception class ParameterNotUsed : public Exception
{ {
@ -370,7 +365,6 @@ protected:
member_ptr<AlgorithmParametersBase> m_next; member_ptr<AlgorithmParametersBase> m_next;
}; };
/// \class AlgorithmParametersTemplate
/// \brief Template base class for AlgorithmParameters /// \brief Template base class for AlgorithmParameters
/// \tparam T the class or type /// \tparam T the class or type
template <class T> template <class T>
@ -423,7 +417,6 @@ CRYPTOPP_DLL_TEMPLATE_CLASS AlgorithmParametersTemplate<bool>;
CRYPTOPP_DLL_TEMPLATE_CLASS AlgorithmParametersTemplate<int>; CRYPTOPP_DLL_TEMPLATE_CLASS AlgorithmParametersTemplate<int>;
CRYPTOPP_DLL_TEMPLATE_CLASS AlgorithmParametersTemplate<ConstByteArrayParameter>; CRYPTOPP_DLL_TEMPLATE_CLASS AlgorithmParametersTemplate<ConstByteArrayParameter>;
/// \class AlgorithmParameters
/// \brief An object that implements NameValuePairs /// \brief An object that implements NameValuePairs
/// \note A NameValuePairs object containing an arbitrary number of name value pairs may be constructed by /// \note A NameValuePairs object containing an arbitrary number of name value pairs may be constructed by
/// repeatedly using operator() on the object returned by MakeParameters, for example: /// repeatedly using operator() on the object returned by MakeParameters, for example:

4
arc4.h
View File

@ -15,7 +15,6 @@ NAMESPACE_BEGIN(CryptoPP)
namespace Weak1 { namespace Weak1 {
/// \class ARC4_Base
/// \brief ARC4 base class /// \brief ARC4 base class
/// \details Implementations and overrides in \p Base apply to both \p ENCRYPTION and \p DECRYPTION directions /// \details Implementations and overrides in \p Base apply to both \p ENCRYPTION and \p DECRYPTION directions
/// \since Crypto++ 1.0 /// \since Crypto++ 1.0
@ -46,13 +45,11 @@ protected:
byte m_x, m_y; byte m_x, m_y;
}; };
/// \class ARC4
/// \brief Alleged RC4 /// \brief Alleged RC4
/// \sa <a href="http://www.cryptopp.com/wiki/RC4">Alleged RC4</a> /// \sa <a href="http://www.cryptopp.com/wiki/RC4">Alleged RC4</a>
/// \since Crypto++ 1.0 /// \since Crypto++ 1.0
DOCUMENTED_TYPEDEF(SymmetricCipherFinal<ARC4_Base>, ARC4) DOCUMENTED_TYPEDEF(SymmetricCipherFinal<ARC4_Base>, ARC4)
/// \class MARC4_Base
/// \brief MARC4 base class /// \brief MARC4 base class
/// \details Implementations and overrides in \p Base apply to both \p ENCRYPTION and \p DECRYPTION directions /// \details Implementations and overrides in \p Base apply to both \p ENCRYPTION and \p DECRYPTION directions
/// \details MARC4 discards the first 256 bytes of keystream, which may be weaker than the rest /// \details MARC4 discards the first 256 bytes of keystream, which may be weaker than the rest
@ -68,7 +65,6 @@ protected:
unsigned int GetDefaultDiscardBytes() const {return 256;} unsigned int GetDefaultDiscardBytes() const {return 256;}
}; };
/// \class MARC4
/// \brief Modified Alleged RC4 /// \brief Modified Alleged RC4
/// \sa <a href="http://www.cryptopp.com/wiki/RC4">Alleged RC4</a> /// \sa <a href="http://www.cryptopp.com/wiki/RC4">Alleged RC4</a>
/// \since Crypto++ 1.0 /// \since Crypto++ 1.0

2
aria.h
View File

@ -19,7 +19,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class ARIA_Info
/// \brief ARIA block cipher information /// \brief ARIA block cipher information
/// \since Crypto++ 6.0 /// \since Crypto++ 6.0
struct ARIA_Info : public FixedBlockSize<16>, public VariableKeyLength<16, 16, 32, 8> struct ARIA_Info : public FixedBlockSize<16>, public VariableKeyLength<16, 16, 32, 8>
@ -27,7 +26,6 @@ struct ARIA_Info : public FixedBlockSize<16>, public VariableKeyLength<16, 16, 3
CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "ARIA";} CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "ARIA";}
}; };
/// \class ARIA
/// \brief ARIA block cipher /// \brief ARIA block cipher
/// \details The Crypto++ ARIA implementation is based on the 32-bit implementation by Aaram Yun /// \details The Crypto++ ARIA implementation is based on the 32-bit implementation by Aaram Yun
/// from the National Security Research Institute, KOREA. Aaram Yun's implementation is based on /// from the National Security Research Institute, KOREA. Aaram Yun's implementation is based on

1
authenc.h
View File

@ -25,7 +25,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class AuthenticatedSymmetricCipherBase
/// \brief Base class for authenticated encryption modes of operation /// \brief Base class for authenticated encryption modes of operation
/// \details AuthenticatedSymmetricCipherBase() serves as a base implementation for one direction /// \details AuthenticatedSymmetricCipherBase() serves as a base implementation for one direction
/// (encryption or decryption) of a stream cipher or block cipher mode with authentication. /// (encryption or decryption) of a stream cipher or block cipher mode with authentication.

4
base32.h
View File

@ -12,7 +12,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class Base32Encoder
/// \brief Base32 encodes data using DUDE encoding /// \brief Base32 encodes data using DUDE encoding
/// \details Converts data to base32 using DUDE encoding. The default code is based on <A HREF="http://www.ietf.org/proceedings/51/I-D/draft-ietf-idn-dude-02.txt">Differential Unicode Domain Encoding (DUDE) (draft-ietf-idn-dude-02.txt)</A>. /// \details Converts data to base32 using DUDE encoding. The default code is based on <A HREF="http://www.ietf.org/proceedings/51/I-D/draft-ietf-idn-dude-02.txt">Differential Unicode Domain Encoding (DUDE) (draft-ietf-idn-dude-02.txt)</A>.
/// \sa Base32Encoder, Base32Decoder, Base32HexEncoder and Base32HexDecoder /// \sa Base32Encoder, Base32Decoder, Base32HexEncoder and Base32HexDecoder
@ -57,7 +56,6 @@ public:
void IsolatedInitialize(const NameValuePairs &parameters); void IsolatedInitialize(const NameValuePairs &parameters);
}; };
/// \class Base32Decoder
/// \brief Base32 decodes data using DUDE encoding /// \brief Base32 decodes data using DUDE encoding
/// \details Converts data from base32 using DUDE encoding. The default code is based on <A HREF="http://www.ietf.org/proceedings/51/I-D/draft-ietf-idn-dude-02.txt">Differential Unicode Domain Encoding (DUDE) (draft-ietf-idn-dude-02.txt)</A>. /// \details Converts data from base32 using DUDE encoding. The default code is based on <A HREF="http://www.ietf.org/proceedings/51/I-D/draft-ietf-idn-dude-02.txt">Differential Unicode Domain Encoding (DUDE) (draft-ietf-idn-dude-02.txt)</A>.
/// \sa Base32Encoder, Base32Decoder, Base32HexEncoder and Base32HexDecoder /// \sa Base32Encoder, Base32Decoder, Base32HexEncoder and Base32HexDecoder
@ -94,7 +92,6 @@ private:
static const int * CRYPTOPP_API GetDefaultDecodingLookupArray(); static const int * CRYPTOPP_API GetDefaultDecodingLookupArray();
}; };
/// \class Base32HexEncoder
/// \brief Base32 encodes data using extended hex /// \brief Base32 encodes data using extended hex
/// \details Converts data to base32 using extended hex alphabet. The alphabet is different than Base32Encoder. /// \details Converts data to base32 using extended hex alphabet. The alphabet is different than Base32Encoder.
/// \sa Base32Encoder, Base32Decoder, Base32HexEncoder and Base32HexDecoder, <A HREF="http://tools.ietf.org/html/rfc4648#page-10">RFC 4648, Base 32 Encoding with Extended Hex Alphabet</A>. /// \sa Base32Encoder, Base32Decoder, Base32HexEncoder and Base32HexDecoder, <A HREF="http://tools.ietf.org/html/rfc4648#page-10">RFC 4648, Base 32 Encoding with Extended Hex Alphabet</A>.
@ -130,7 +127,6 @@ public:
void IsolatedInitialize(const NameValuePairs &parameters); void IsolatedInitialize(const NameValuePairs &parameters);
}; };
/// \class Base32HexDecoder
/// \brief Base32 decodes data using extended hex /// \brief Base32 decodes data using extended hex
/// \details Converts data from base32 using extended hex alphabet. The alphabet is different than Base32Decoder. /// \details Converts data from base32 using extended hex alphabet. The alphabet is different than Base32Decoder.
/// \sa Base32Encoder, Base32Decoder, Base32HexEncoder and Base32HexDecoder, <A HREF="http://tools.ietf.org/html/rfc4648#page-10">RFC 4648, Base 32 Encoding with Extended Hex Alphabet</A>. /// \sa Base32Encoder, Base32Decoder, Base32HexEncoder and Base32HexDecoder, <A HREF="http://tools.ietf.org/html/rfc4648#page-10">RFC 4648, Base 32 Encoding with Extended Hex Alphabet</A>.

4
base64.h
View File

@ -11,7 +11,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class Base64Encoder
/// \brief Base64 encodes data using DUDE /// \brief Base64 encodes data using DUDE
/// \details Base64 encodes data per <A HREF="http://tools.ietf.org/html/rfc4648#section-4">RFC 4648, Base 64 Encoding</A>. /// \details Base64 encodes data per <A HREF="http://tools.ietf.org/html/rfc4648#section-4">RFC 4648, Base 64 Encoding</A>.
class Base64Encoder : public SimpleProxyFilter class Base64Encoder : public SimpleProxyFilter
@ -53,7 +52,6 @@ public:
void IsolatedInitialize(const NameValuePairs &parameters); void IsolatedInitialize(const NameValuePairs &parameters);
}; };
/// \class Base64Decoder
/// \brief Base64 decodes data using DUDE /// \brief Base64 decodes data using DUDE
/// \details Base64 encodes data per <A HREF="http://tools.ietf.org/html/rfc4648#section-4">RFC 4648, Base 64 Encoding</A>. /// \details Base64 encodes data per <A HREF="http://tools.ietf.org/html/rfc4648#section-4">RFC 4648, Base 64 Encoding</A>.
class Base64Decoder : public BaseN_Decoder class Base64Decoder : public BaseN_Decoder
@ -90,7 +88,6 @@ private:
static const int * CRYPTOPP_API GetDecodingLookupArray(); static const int * CRYPTOPP_API GetDecodingLookupArray();
}; };
/// \class Base64URLEncoder
/// \brief Base64 encodes data using a web safe alphabet /// \brief Base64 encodes data using a web safe alphabet
/// \details Base64 encodes data per <A HREF="http://tools.ietf.org/html/rfc4648#section-5">RFC 4648, Base 64 Encoding /// \details Base64 encodes data per <A HREF="http://tools.ietf.org/html/rfc4648#section-5">RFC 4648, Base 64 Encoding
/// with URL and Filename Safe Alphabet</A>. /// with URL and Filename Safe Alphabet</A>.
@ -128,7 +125,6 @@ public:
void IsolatedInitialize(const NameValuePairs &parameters); void IsolatedInitialize(const NameValuePairs &parameters);
}; };
/// \class Base64URLDecoder
/// \brief Base64 decodes data using a web safe alphabet /// \brief Base64 decodes data using a web safe alphabet
/// \details Base64 encodes data per <A HREF="http://tools.ietf.org/html/rfc4648#section-5">RFC 4648, Base 64 Encoding /// \details Base64 encodes data per <A HREF="http://tools.ietf.org/html/rfc4648#section-5">RFC 4648, Base 64 Encoding
/// with URL and Filename Safe Alphabet</A>. /// with URL and Filename Safe Alphabet</A>.

3
basecode.h
View File

@ -13,7 +13,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class BaseN_Encoder
/// \brief Encoder for bases that are a power of 2 /// \brief Encoder for bases that are a power of 2
class CRYPTOPP_DLL BaseN_Encoder : public Unflushable<Filter> class CRYPTOPP_DLL BaseN_Encoder : public Unflushable<Filter>
{ {
@ -53,7 +52,6 @@ private:
SecByteBlock m_outBuf; SecByteBlock m_outBuf;
}; };
/// \class BaseN_Decoder
/// \brief Decoder for bases that are a power of 2 /// \brief Decoder for bases that are a power of 2
class CRYPTOPP_DLL BaseN_Decoder : public Unflushable<Filter> class CRYPTOPP_DLL BaseN_Decoder : public Unflushable<Filter>
{ {
@ -105,7 +103,6 @@ private:
SecByteBlock m_outBuf; SecByteBlock m_outBuf;
}; };
/// \class Grouper
/// \brief Filter that breaks input stream into groups of fixed size /// \brief Filter that breaks input stream into groups of fixed size
class CRYPTOPP_DLL Grouper : public Bufferless<Filter> class CRYPTOPP_DLL Grouper : public Bufferless<Filter>
{ {

4
blake2.h
View File

@ -23,7 +23,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class BLAKE2_Info
/// \brief BLAKE2 hash information /// \brief BLAKE2 hash information
/// \tparam T_64bit flag indicating 64-bit /// \tparam T_64bit flag indicating 64-bit
/// \since Crypto++ 5.6.4 /// \since Crypto++ 5.6.4
@ -43,7 +42,6 @@ struct BLAKE2_Info : public VariableKeyLength<(T_64bit ? 64 : 32),0,(T_64bit ? 6
CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return (T_64bit ? "BLAKE2b" : "BLAKE2s");} CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return (T_64bit ? "BLAKE2b" : "BLAKE2s");}
}; };
/// \class BLAKE2_ParameterBlock
/// \brief BLAKE2 parameter block /// \brief BLAKE2 parameter block
/// \tparam T_64bit flag indicating 64-bit /// \tparam T_64bit flag indicating 64-bit
/// \details BLAKE2b uses BLAKE2_ParameterBlock<true>, while BLAKE2s /// \details BLAKE2b uses BLAKE2_ParameterBlock<true>, while BLAKE2s
@ -124,7 +122,6 @@ struct CRYPTOPP_NO_VTABLE BLAKE2_ParameterBlock<false>
byte personalization[PERSONALIZATIONSIZE]; byte personalization[PERSONALIZATIONSIZE];
}; };
/// \class BLAKE2_State
/// \brief BLAKE2 state information /// \brief BLAKE2 state information
/// \tparam W word type /// \tparam W word type
/// \tparam T_64bit flag indicating 64-bit /// \tparam T_64bit flag indicating 64-bit
@ -150,7 +147,6 @@ struct CRYPTOPP_NO_VTABLE BLAKE2_State
size_t length; size_t length;
}; };
/// \class BLAKE2_Base
/// \brief BLAKE2 hash implementation /// \brief BLAKE2 hash implementation
/// \tparam W word type /// \tparam W word type
/// \tparam T_64bit flag indicating 64-bit /// \tparam T_64bit flag indicating 64-bit

3
blowfish.h
View File

@ -11,7 +11,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class Blowfish_Info
/// \brief Blowfish block cipher information /// \brief Blowfish block cipher information
struct Blowfish_Info : public FixedBlockSize<8>, public VariableKeyLength<16, 4, 56>, public FixedRounds<16> struct Blowfish_Info : public FixedBlockSize<8>, public VariableKeyLength<16, 4, 56>, public FixedRounds<16>
{ {
@ -20,12 +19,10 @@ struct Blowfish_Info : public FixedBlockSize<8>, public VariableKeyLength<16, 4,
// <a href="http://www.cryptopp.com/wiki/Blowfish">Blowfish</a> // <a href="http://www.cryptopp.com/wiki/Blowfish">Blowfish</a>
/// \class Blowfish
/// \brief Blowfish block cipher /// \brief Blowfish block cipher
/// \since Crypto++ 1.0 /// \since Crypto++ 1.0
class Blowfish : public Blowfish_Info, public BlockCipherDocumentation class Blowfish : public Blowfish_Info, public BlockCipherDocumentation
{ {
/// \class Base
/// \brief Class specific implementation and overrides used to operate the cipher. /// \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 /// \details Implementations and overrides in \p Base apply to both \p ENCRYPTION and \p DECRYPTION directions
class CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<Blowfish_Info> class CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<Blowfish_Info>

2
camellia.h
View File

@ -12,14 +12,12 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class Camellia_Info
/// \brief Camellia block cipher information /// \brief Camellia block cipher information
struct Camellia_Info : public FixedBlockSize<16>, public VariableKeyLength<16, 16, 32, 8> struct Camellia_Info : public FixedBlockSize<16>, public VariableKeyLength<16, 16, 32, 8>
{ {
CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "Camellia";} CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "Camellia";}
}; };
/// \class Camellia
/// \brief Camellia block cipher /// \brief Camellia block cipher
/// \sa <a href="http://www.cryptopp.com/wiki/Camellia">Camellia</a> /// \sa <a href="http://www.cryptopp.com/wiki/Camellia">Camellia</a>
class Camellia : public Camellia_Info, public BlockCipherDocumentation class Camellia : public Camellia_Info, public BlockCipherDocumentation

9
cast.h
View File

@ -11,7 +11,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class CAST
/// \brief CAST block cipher base /// \brief CAST block cipher base
class CAST class CAST
{ {
@ -19,19 +18,16 @@ protected:
static const word32 S[8][256]; static const word32 S[8][256];
}; };
/// \class CAST128_Info
/// \brief CAST128 block cipher information /// \brief CAST128 block cipher information
struct CAST128_Info : public FixedBlockSize<8>, public VariableKeyLength<16, 5, 16> struct CAST128_Info : public FixedBlockSize<8>, public VariableKeyLength<16, 5, 16>
{ {
CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "CAST-128";} CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "CAST-128";}
}; };
/// \class CAST128
/// \brief CAST128 block cipher /// \brief CAST128 block cipher
/// \sa <a href="http://www.cryptopp.com/wiki/CAST-128">CAST-128</a> /// \sa <a href="http://www.cryptopp.com/wiki/CAST-128">CAST-128</a>
class CAST128 : public CAST128_Info, public BlockCipherDocumentation class CAST128 : public CAST128_Info, public BlockCipherDocumentation
{ {
/// \class Base
/// \brief CAST128 block cipher default operation /// \brief CAST128 block cipher default operation
class CRYPTOPP_NO_VTABLE Base : public CAST, public BlockCipherImpl<CAST128_Info> class CRYPTOPP_NO_VTABLE Base : public CAST, public BlockCipherImpl<CAST128_Info>
{ {
@ -43,7 +39,6 @@ class CAST128 : public CAST128_Info, public BlockCipherDocumentation
FixedSizeSecBlock<word32, 32> K; FixedSizeSecBlock<word32, 32> K;
}; };
/// \class Enc
/// \brief CAST128 block cipher encryption operation /// \brief CAST128 block cipher encryption operation
class CRYPTOPP_NO_VTABLE Enc : public Base class CRYPTOPP_NO_VTABLE Enc : public Base
{ {
@ -51,7 +46,6 @@ class CAST128 : public CAST128_Info, public BlockCipherDocumentation
void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const; void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
}; };
/// \class Dec
/// \brief CAST128 block cipher decryption operation /// \brief CAST128 block cipher decryption operation
class CRYPTOPP_NO_VTABLE Dec : public Base class CRYPTOPP_NO_VTABLE Dec : public Base
{ {
@ -64,19 +58,16 @@ public:
typedef BlockCipherFinal<DECRYPTION, Dec> Decryption; typedef BlockCipherFinal<DECRYPTION, Dec> Decryption;
}; };
/// \class CAST256_Info
/// \brief CAST256 block cipher information /// \brief CAST256 block cipher information
struct CAST256_Info : public FixedBlockSize<16>, public VariableKeyLength<16, 16, 32, 4> struct CAST256_Info : public FixedBlockSize<16>, public VariableKeyLength<16, 16, 32, 4>
{ {
CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "CAST-256";} CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "CAST-256";}
}; };
/// \class CAST256
/// \brief CAST256 block cipher /// \brief CAST256 block cipher
/// \sa <a href="http://www.cryptopp.com/wiki/CAST-256">CAST-256</a> /// \sa <a href="http://www.cryptopp.com/wiki/CAST-256">CAST-256</a>
class CAST256 : public CAST256_Info, public BlockCipherDocumentation class CAST256 : public CAST256_Info, public BlockCipherDocumentation
{ {
/// \class Base
/// \brief CAST256 block cipher default operation /// \brief CAST256 block cipher default operation
class CRYPTOPP_NO_VTABLE Base : public CAST, public BlockCipherImpl<CAST256_Info> class CRYPTOPP_NO_VTABLE Base : public CAST, public BlockCipherImpl<CAST256_Info>
{ {

3
ccm.h
View File

@ -12,7 +12,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class CCM_Base
/// \brief CCM block cipher base implementation /// \brief CCM block cipher base implementation
/// \details Base implementation of the AuthenticatedSymmetricCipher interface /// \details Base implementation of the AuthenticatedSymmetricCipher interface
/// \since Crypto++ 5.6.0 /// \since Crypto++ 5.6.0
@ -81,7 +80,6 @@ protected:
CTR_Mode_ExternalCipher::Encryption m_ctr; CTR_Mode_ExternalCipher::Encryption m_ctr;
}; };
/// \class CCM_Final
/// \brief CCM block cipher final implementation /// \brief CCM block cipher final implementation
/// \tparam T_BlockCipher block cipher /// \tparam T_BlockCipher block cipher
/// \tparam T_DefaultDigestSize default digest size, in bytes /// \tparam T_DefaultDigestSize default digest size, in bytes
@ -102,7 +100,6 @@ private:
typename T_BlockCipher::Encryption m_cipher; typename T_BlockCipher::Encryption m_cipher;
}; };
/// \class CCM
/// \brief CCM block cipher mode of operation /// \brief CCM block cipher mode of operation
/// \tparam T_BlockCipher block cipher /// \tparam T_BlockCipher block cipher
/// \tparam T_DefaultDigestSize default digest size, in bytes /// \tparam T_DefaultDigestSize default digest size, in bytes

5
chacha.h
View File

@ -18,7 +18,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class ChaCha_Info
/// \brief ChaCha stream cipher information /// \brief ChaCha stream cipher information
/// \since Crypto++ 5.6.4 /// \since Crypto++ 5.6.4
template <unsigned int R> template <unsigned int R>
@ -29,7 +28,6 @@ struct ChaCha_Info : public VariableKeyLength<32, 16, 32, 16, SimpleKeyingInterf
} }
}; };
/// \class ChaCha_Policy
/// \brief ChaCha stream cipher implementation /// \brief ChaCha stream cipher implementation
/// \since Crypto++ 5.6.4 /// \since Crypto++ 5.6.4
template <unsigned int R> template <unsigned int R>
@ -49,7 +47,6 @@ protected:
FixedSizeAlignedSecBlock<word32, 16> m_state; FixedSizeAlignedSecBlock<word32, 16> m_state;
}; };
/// \class ChaCha8
/// \brief ChaCha8 stream cipher /// \brief ChaCha8 stream cipher
/// \sa <a href="http://cr.yp.to/chacha/chacha-20080128.pdf">ChaCha, a variant of Salsa20</a> (2008.01.28). /// \sa <a href="http://cr.yp.to/chacha/chacha-20080128.pdf">ChaCha, a variant of Salsa20</a> (2008.01.28).
/// \since Crypto++ 5.6.4 /// \since Crypto++ 5.6.4
@ -59,7 +56,6 @@ struct ChaCha8 : public ChaCha_Info<8>, public SymmetricCipherDocumentation
typedef Encryption Decryption; typedef Encryption Decryption;
}; };
/// \class ChaCha12
/// \brief ChaCha12 stream cipher /// \brief ChaCha12 stream cipher
/// \details Bernstein and ECRYPT's ChaCha is _slightly_ different from the TLS working group's implementation for /// \details Bernstein and ECRYPT's ChaCha is _slightly_ different from the TLS working group's implementation for
/// cipher suites <tt>TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256</tt>, /// cipher suites <tt>TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256</tt>,
@ -72,7 +68,6 @@ struct ChaCha12 : public ChaCha_Info<12>, public SymmetricCipherDocumentation
typedef Encryption Decryption; typedef Encryption Decryption;
}; };
/// \class ChaCha20
/// \brief ChaCha20 stream cipher /// \brief ChaCha20 stream cipher
/// \sa <a href="http://cr.yp.to/chacha/chacha-20080128.pdf">ChaCha, a variant of Salsa20</a> (2008.01.28). /// \sa <a href="http://cr.yp.to/chacha/chacha-20080128.pdf">ChaCha, a variant of Salsa20</a> (2008.01.28).
/// \details Bernstein and ECRYPT's ChaCha is _slightly_ different from the TLS working group's implementation for /// \details Bernstein and ECRYPT's ChaCha is _slightly_ different from the TLS working group's implementation for

1
cmac.h
View File

@ -12,7 +12,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class CMAC_Base
/// \brief CMAC base implementation /// \brief CMAC base implementation
/// \since Crypto++ 5.6.0 /// \since Crypto++ 5.6.0
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CMAC_Base : public MessageAuthenticationCode class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CMAC_Base : public MessageAuthenticationCode

1
cryptlib.cpp
View File

@ -331,7 +331,6 @@ void RandomNumberGenerator::GenerateIntoBufferedTransformation(BufferedTransform
} }
} }
/// \class ClassNullRNG
/// \brief Random Number Generator that does not produce random numbers /// \brief Random Number Generator that does not produce random numbers
/// \details ClassNullRNG can be used for functions that require a RandomNumberGenerator /// \details ClassNullRNG can be used for functions that require a RandomNumberGenerator
/// but don't actually use it. The class throws NotImplemented when a generation function is called. /// but don't actually use it. The class throws NotImplemented when a generation function is called.

26
cryptlib.h
View File

@ -149,7 +149,6 @@ typedef EnumToType<ByteOrder, LITTLE_ENDIAN_ORDER> LittleEndian;
/// \brief Provides a constant for BigEndian /// \brief Provides a constant for BigEndian
typedef EnumToType<ByteOrder, BIG_ENDIAN_ORDER> BigEndian; typedef EnumToType<ByteOrder, BIG_ENDIAN_ORDER> BigEndian;
/// \class Exception
/// \brief Base class for all exceptions thrown by the library /// \brief Base class for all exceptions thrown by the library
/// \details All library exceptions directly or indirectly inherit from the Exception class. /// \details All library exceptions directly or indirectly inherit from the Exception class.
/// The Exception class itself inherits from std::exception. The library does not use /// The Exception class itself inherits from std::exception. The library does not use
@ -250,7 +249,6 @@ protected:
int m_errorCode; int m_errorCode;
}; };
/// \class DecodingResult
/// \brief Returns a decoding results /// \brief Returns a decoding results
struct CRYPTOPP_DLL DecodingResult struct CRYPTOPP_DLL DecodingResult
{ {
@ -278,7 +276,6 @@ struct CRYPTOPP_DLL DecodingResult
size_t messageLength; size_t messageLength;
}; };
/// \class NameValuePairs
/// \brief Interface for retrieving values given their names /// \brief Interface for retrieving values given their names
/// \details This class is used to safely pass a variable number of arbitrarily typed arguments to functions /// \details This class is used to safely pass a variable number of arbitrarily typed arguments to functions
/// and to read values from keys and crypto parameters. /// and to read values from keys and crypto parameters.
@ -296,7 +293,6 @@ class NameValuePairs
public: public:
virtual ~NameValuePairs() {} virtual ~NameValuePairs() {}
/// \class ValueTypeMismatch
/// \brief Thrown when an unexpected type is encountered /// \brief Thrown when an unexpected type is encountered
/// \details Exception thrown when trying to retrieve a value using a different type than expected /// \details Exception thrown when trying to retrieve a value using a different type than expected
class CRYPTOPP_DLL ValueTypeMismatch : public InvalidArgument class CRYPTOPP_DLL ValueTypeMismatch : public InvalidArgument
@ -454,7 +450,6 @@ public:
CRYPTOPP_DLL virtual bool GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const =0; CRYPTOPP_DLL virtual bool GetVoidValue(const char *name, const std::type_info &valueType, void *pValue) const =0;
}; };
/// \class NullNameValuePairs
/// \brief Interface for retrieving values given their names /// \brief Interface for retrieving values given their names
/// \details This class is used when no names or values are present. Typically a program uses /// \details This class is used when no names or values are present. Typically a program uses
/// g_nullNameValuePairs rather than creating its own NullNameValuePairs object. /// g_nullNameValuePairs rather than creating its own NullNameValuePairs object.
@ -560,7 +555,6 @@ DOCUMENTED_NAMESPACE_END
// ******************************************************** // ********************************************************
/// \class Clonable
/// \brief Interface for cloning objects /// \brief Interface for cloning objects
/// \note this is \a not implemented by most classes /// \note this is \a not implemented by most classes
/// \sa ClonableImpl, NotCopyable /// \sa ClonableImpl, NotCopyable
@ -577,7 +571,6 @@ public:
virtual Clonable* Clone() const {throw NotImplemented("Clone() is not implemented yet.");} // TODO: make this =0 virtual Clonable* Clone() const {throw NotImplemented("Clone() is not implemented yet.");} // TODO: make this =0
}; };
/// \class Algorithm
/// \brief Interface for all crypto algorithms /// \brief Interface for all crypto algorithms
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE Algorithm : public Clonable class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE Algorithm : public Clonable
{ {
@ -603,7 +596,6 @@ public:
virtual std::string AlgorithmName() const {return "unknown";} virtual std::string AlgorithmName() const {return "unknown";}
}; };
/// \class SimpleKeyingInterface
/// \brief Interface for algorithms that take byte strings as keys /// \brief Interface for algorithms that take byte strings as keys
/// \sa FixedKeyLength(), VariableKeyLength(), SameKeyLengthAs(), SimpleKeyingInterfaceImpl() /// \sa FixedKeyLength(), VariableKeyLength(), SameKeyLengthAs(), SimpleKeyingInterfaceImpl()
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE SimpleKeyingInterface class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE SimpleKeyingInterface
@ -902,7 +894,6 @@ public:
inline CipherDir GetCipherDirection() const {return IsForwardTransformation() ? ENCRYPTION : DECRYPTION;} inline CipherDir GetCipherDirection() const {return IsForwardTransformation() ? ENCRYPTION : DECRYPTION;}
}; };
/// \class StreamTransformation
/// \brief Interface for the data processing portion of stream ciphers /// \brief Interface for the data processing portion of stream ciphers
/// \sa StreamTransformationFilter() /// \sa StreamTransformationFilter()
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE StreamTransformation : public Algorithm class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE StreamTransformation : public Algorithm
@ -1064,7 +1055,6 @@ public:
virtual bool IsForwardTransformation() const =0; virtual bool IsForwardTransformation() const =0;
}; };
/// \class HashTransformation
/// \brief Interface for hash functions and data processing part of MACs /// \brief Interface for hash functions and data processing part of MACs
/// \details HashTransformation objects are stateful. They are created in an initial state, /// \details HashTransformation objects are stateful. They are created in an initial state,
/// change state as Update() is called, and return to the initial /// change state as Update() is called, and return to the initial
@ -1257,7 +1247,6 @@ protected:
const Algorithm & GetAlgorithm() const {return *this;} const Algorithm & GetAlgorithm() const {return *this;}
}; };
/// \class AuthenticatedSymmetricCipher
/// \brief Interface for authenticated encryption modes of operation /// \brief Interface for authenticated encryption modes of operation
/// \details AuthenticatedSymmetricCipher() provides the interface for one direction /// \details AuthenticatedSymmetricCipher() provides the interface for one direction
/// (encryption or decryption) of a stream cipher or block cipher mode with authentication. The /// (encryption or decryption) of a stream cipher or block cipher mode with authentication. The
@ -1332,7 +1321,6 @@ protected:
{CRYPTOPP_UNUSED(headerLength); CRYPTOPP_UNUSED(messageLength); CRYPTOPP_UNUSED(footerLength);} {CRYPTOPP_UNUSED(headerLength); CRYPTOPP_UNUSED(messageLength); CRYPTOPP_UNUSED(footerLength);}
}; };
/// \class RandomNumberGenerator
/// \brief Interface for random number generators /// \brief Interface for random number generators
/// \details The library provides a number of random number generators, from software based to hardware based generators. /// \details The library provides a number of random number generators, from software based to hardware based generators.
/// \details All generated values are uniformly distributed over the range specified. /// \details All generated values are uniformly distributed over the range specified.
@ -1428,9 +1416,7 @@ public:
/// \sa ClassNullRNG, PK_SignatureScheme::IsProbabilistic() /// \sa ClassNullRNG, PK_SignatureScheme::IsProbabilistic()
CRYPTOPP_DLL RandomNumberGenerator & CRYPTOPP_API NullRNG(); CRYPTOPP_DLL RandomNumberGenerator & CRYPTOPP_API NullRNG();
/// \class WaitObjectContainer
class WaitObjectContainer; class WaitObjectContainer;
/// \class CallStack
class CallStack; class CallStack;
/// \brief Interface for objects that can be waited on. /// \brief Interface for objects that can be waited on.
@ -1605,7 +1591,6 @@ public:
virtual size_t PutModifiable2(byte *inString, size_t length, int messageEnd, bool blocking) virtual size_t PutModifiable2(byte *inString, size_t length, int messageEnd, bool blocking)
{return Put2(inString, length, messageEnd, blocking);} {return Put2(inString, length, messageEnd, blocking);}
/// \class BlockingInputOnly
/// \brief Exception thrown by objects that have \a not implemented nonblocking input processing /// \brief Exception thrown by objects that have \a not implemented nonblocking input processing
/// \details BlockingInputOnly inherits from NotImplemented /// \details BlockingInputOnly inherits from NotImplemented
struct BlockingInputOnly : public NotImplemented struct BlockingInputOnly : public NotImplemented
@ -2168,7 +2153,6 @@ private:
/// \return a reference to a BufferedTransformation object that discards all input /// \return a reference to a BufferedTransformation object that discards all input
CRYPTOPP_DLL BufferedTransformation & TheBitBucket(); CRYPTOPP_DLL BufferedTransformation & TheBitBucket();
/// \class CryptoMaterial
/// \brief Interface for crypto material, such as public and private keys, and crypto parameters /// \brief Interface for crypto material, such as public and private keys, and crypto parameters
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CryptoMaterial : public NameValuePairs class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CryptoMaterial : public NameValuePairs
{ {
@ -2281,7 +2265,6 @@ public:
#endif #endif
}; };
/// \class GeneratableCryptoMaterial
/// \brief Interface for generatable crypto material, such as private keys and crypto parameters /// \brief Interface for generatable crypto material, such as private keys and crypto parameters
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE GeneratableCryptoMaterial : virtual public CryptoMaterial class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE GeneratableCryptoMaterial : virtual public CryptoMaterial
{ {
@ -2457,7 +2440,6 @@ public:
virtual size_t FixedMaxPlaintextLength() const {return 0;} virtual size_t FixedMaxPlaintextLength() const {return 0;}
}; };
/// \class PK_Encryptor
/// \brief Interface for public-key encryptors /// \brief Interface for public-key encryptors
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_Encryptor : public PK_CryptoSystem, public PublicKeyAlgorithm class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_Encryptor : public PK_CryptoSystem, public PublicKeyAlgorithm
{ {
@ -2493,7 +2475,6 @@ public:
BufferedTransformation *attachment=NULLPTR, const NameValuePairs &parameters = g_nullNameValuePairs) const; BufferedTransformation *attachment=NULLPTR, const NameValuePairs &parameters = g_nullNameValuePairs) const;
}; };
/// \class PK_Decryptor
/// \brief Interface for public-key decryptors /// \brief Interface for public-key decryptors
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_Decryptor : public PK_CryptoSystem, public PrivateKeyAlgorithm class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_Decryptor : public PK_CryptoSystem, public PrivateKeyAlgorithm
{ {
@ -2544,14 +2525,12 @@ public:
{return Decrypt(rng, ciphertext, FixedCiphertextLength(), plaintext, parameters);} {return Decrypt(rng, ciphertext, FixedCiphertextLength(), plaintext, parameters);}
}; };
/// \class PK_SignatureScheme
/// \brief Interface for public-key signers and verifiers /// \brief Interface for public-key signers and verifiers
/// \details This class provides an interface common to signers and verifiers for querying scheme properties /// \details This class provides an interface common to signers and verifiers for querying scheme properties
/// \sa DL_SignatureSchemeBase, TF_SignatureSchemeBase, DL_SignerBase, TF_SignerBase /// \sa DL_SignatureSchemeBase, TF_SignatureSchemeBase, DL_SignerBase, TF_SignerBase
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_SignatureScheme class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_SignatureScheme
{ {
public: public:
/// \class InvalidKeyLength
/// \brief Exception throw when the private or public key has a length that can't be used /// \brief Exception throw when the private or public key has a length that can't be used
/// \details InvalidKeyLength() may be thrown by any function in this class if the private /// \details InvalidKeyLength() may be thrown by any function in this class if the private
/// or public key has a length that can't be used /// or public key has a length that can't be used
@ -2561,7 +2540,6 @@ public:
InvalidKeyLength(const std::string &message) : Exception(OTHER_ERROR, message) {} InvalidKeyLength(const std::string &message) : Exception(OTHER_ERROR, message) {}
}; };
/// \class KeyTooShort
/// \brief Exception throw when the private or public key is too short to sign or verify /// \brief Exception throw when the private or public key is too short to sign or verify
/// \details KeyTooShort() may be thrown by any function in this class if the private or public /// \details KeyTooShort() may be thrown by any function in this class if the private or public
/// key is too short to sign or verify anything /// key is too short to sign or verify anything
@ -2623,7 +2601,6 @@ public:
virtual bool RecoverablePartFirst() const =0; virtual bool RecoverablePartFirst() const =0;
}; };
/// \class PK_MessageAccumulator
/// \brief Interface for accumulating messages to be signed or verified /// \brief Interface for accumulating messages to be signed or verified
/// \details Only Update() should be called from the PK_MessageAccumulator() class. No other functions /// \details Only Update() should be called from the PK_MessageAccumulator() class. No other functions
/// inherited from HashTransformation, like DigestSize() and TruncatedFinal(), should be called. /// inherited from HashTransformation, like DigestSize() and TruncatedFinal(), should be called.
@ -2642,7 +2619,6 @@ public:
} }
}; };
/// \class PK_Signer
/// \brief Interface for public-key signers /// \brief Interface for public-key signers
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_Signer : public PK_SignatureScheme, public PrivateKeyAlgorithm class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE PK_Signer : public PK_SignatureScheme, public PrivateKeyAlgorithm
{ {
@ -2702,7 +2678,6 @@ public:
const byte *nonrecoverableMessage, size_t nonrecoverableMessageLength, byte *signature) const; const byte *nonrecoverableMessage, size_t nonrecoverableMessageLength, byte *signature) const;
}; };
/// \class PK_Verifier
/// \brief Interface for public-key signature verifiers /// \brief Interface for public-key signature verifiers
/// \details The Recover* functions throw NotImplemented if the signature scheme does not support /// \details The Recover* functions throw NotImplemented if the signature scheme does not support
/// message recovery. /// message recovery.
@ -2776,7 +2751,6 @@ public:
const byte *signature, size_t signatureLength) const; const byte *signature, size_t signatureLength) const;
}; };
/// \class SimpleKeyAgreementDomain
/// \brief Interface for domains of simple key agreement protocols /// \brief Interface for domains of simple key agreement protocols
/// \details A key agreement domain is a set of parameters that must be shared /// \details A key agreement domain is a set of parameters that must be shared
/// by two parties in a key agreement protocol, along with the algorithms /// by two parties in a key agreement protocol, along with the algorithms

16
default.h
View File

@ -30,7 +30,6 @@ typedef SHA256 DefaultHashModule;
/// \brief Default HMAC for use withDefaultEncryptorWithMAC and DefaultDecryptorWithMAC /// \brief Default HMAC for use withDefaultEncryptorWithMAC and DefaultDecryptorWithMAC
typedef HMAC<DefaultHashModule> DefaultMAC; typedef HMAC<DefaultHashModule> DefaultMAC;
/// \class DataDecryptorErr
/// \brief Exception thrown when LegacyDecryptorWithMAC or DefaultDecryptorWithMAC decryption error is encountered /// \brief Exception thrown when LegacyDecryptorWithMAC or DefaultDecryptorWithMAC decryption error is encountered
class DataDecryptorErr : public Exception class DataDecryptorErr : public Exception
{ {
@ -39,7 +38,6 @@ public:
: Exception(DATA_INTEGRITY_CHECK_FAILED, s) {} : Exception(DATA_INTEGRITY_CHECK_FAILED, s) {}
}; };
/// \class KeyBadErr
/// \brief Exception thrown when a bad key is encountered in DefaultDecryptorWithMAC and LegacyDecryptorWithMAC /// \brief Exception thrown when a bad key is encountered in DefaultDecryptorWithMAC and LegacyDecryptorWithMAC
class KeyBadErr : public DataDecryptorErr class KeyBadErr : public DataDecryptorErr
{ {
@ -47,7 +45,6 @@ class KeyBadErr : public DataDecryptorErr
: DataDecryptorErr("DataDecryptor: cannot decrypt message with this passphrase") {} : DataDecryptorErr("DataDecryptor: cannot decrypt message with this passphrase") {}
}; };
/// \class MACBadErr
/// \brief Exception thrown when an incorrect MAC is encountered in DefaultDecryptorWithMAC and LegacyDecryptorWithMAC /// \brief Exception thrown when an incorrect MAC is encountered in DefaultDecryptorWithMAC and LegacyDecryptorWithMAC
class MACBadErr : public DataDecryptorErr class MACBadErr : public DataDecryptorErr
{ {
@ -55,7 +52,6 @@ class MACBadErr : public DataDecryptorErr
: DataDecryptorErr("DataDecryptorWithMAC: MAC check failed") {} : DataDecryptorErr("DataDecryptorWithMAC: MAC check failed") {}
}; };
/// \class DataParametersInfo
/// \brief Algorithm information for password-based encryptors and decryptors /// \brief Algorithm information for password-based encryptors and decryptors
template <unsigned int BlockSize, unsigned int KeyLength, unsigned int DigestSize, unsigned int SaltSize, unsigned int Iterations> template <unsigned int BlockSize, unsigned int KeyLength, unsigned int DigestSize, unsigned int SaltSize, unsigned int Iterations>
struct DataParametersInfo struct DataParametersInfo
@ -70,7 +66,6 @@ struct DataParametersInfo
typedef DataParametersInfo<LegacyBlockCipher::BLOCKSIZE, LegacyBlockCipher::DEFAULT_KEYLENGTH, LegacyHashModule::DIGESTSIZE, 8, 200> LegacyParametersInfo; typedef DataParametersInfo<LegacyBlockCipher::BLOCKSIZE, LegacyBlockCipher::DEFAULT_KEYLENGTH, LegacyHashModule::DIGESTSIZE, 8, 200> LegacyParametersInfo;
typedef DataParametersInfo<DefaultBlockCipher::BLOCKSIZE, DefaultBlockCipher::DEFAULT_KEYLENGTH, DefaultHashModule::DIGESTSIZE, 8, 2500> DefaultParametersInfo; typedef DataParametersInfo<DefaultBlockCipher::BLOCKSIZE, DefaultBlockCipher::DEFAULT_KEYLENGTH, DefaultHashModule::DIGESTSIZE, 8, 2500> DefaultParametersInfo;
/// \class DataEncryptor
/// \brief Password-based Encryptor /// \brief Password-based Encryptor
/// \tparam BC BlockCipher based class used for encryption /// \tparam BC BlockCipher based class used for encryption
/// \tparam H HashTransformation based class used for mashing /// \tparam H HashTransformation based class used for mashing
@ -109,7 +104,6 @@ private:
typename CBC_Mode<BC>::Encryption m_cipher; typename CBC_Mode<BC>::Encryption m_cipher;
}; };
/// \class DataDecryptor
/// \brief Password-based Decryptor /// \brief Password-based Decryptor
/// \tparam BC BlockCipher based class used for encryption /// \tparam BC BlockCipher based class used for encryption
/// \tparam H HashTransformation based class used for mashing /// \tparam H HashTransformation based class used for mashing
@ -160,7 +154,6 @@ private:
}; };
/// \class DataEncryptorWithMAC
/// \brief Password-based encryptor with MAC /// \brief Password-based encryptor with MAC
/// \tparam BC BlockCipher based class used for encryption /// \tparam BC BlockCipher based class used for encryption
/// \tparam H HashTransformation based class used for mashing /// \tparam H HashTransformation based class used for mashing
@ -206,7 +199,6 @@ private:
}; };
/// \class DataDecryptorWithMAC
/// \brief Password-based decryptor with MAC /// \brief Password-based decryptor with MAC
/// \tparam BC BlockCipher based class used for encryption /// \tparam BC BlockCipher based class used for encryption
/// \tparam H HashTransformation based class used for mashing /// \tparam H HashTransformation based class used for mashing
@ -259,49 +251,41 @@ private:
}; };
#if defined(CRYPTOPP_DOXYGEN_PROCESSING) #if defined(CRYPTOPP_DOXYGEN_PROCESSING)
/// \class LegacyEncryptor
/// \brief Password-based encryptor (deprecated) /// \brief Password-based encryptor (deprecated)
/// \details Crypto++ 5.6.5 and earlier used the legacy algorithms, including DES_EDE2 and SHA1. /// \details Crypto++ 5.6.5 and earlier used the legacy algorithms, including DES_EDE2 and SHA1.
/// Crypto++ 5.7 switched to AES and SHA256. The updated algorithms are available with the /// Crypto++ 5.7 switched to AES and SHA256. The updated algorithms are available with the
/// <tt>Default*</tt> classes, and the old algorithms are available with the <tt>Legacy*</tt> classes. /// <tt>Default*</tt> classes, and the old algorithms are available with the <tt>Legacy*</tt> classes.
struct LegacyEncryptor : public DataEncryptor<LegacyBlockCipher,LegacyHashModule,LegacyParametersInfo> {}; struct LegacyEncryptor : public DataEncryptor<LegacyBlockCipher,LegacyHashModule,LegacyParametersInfo> {};
/// \class LegacyDecryptor
/// \brief Password-based decryptor (deprecated) /// \brief Password-based decryptor (deprecated)
/// \details Crypto++ 5.6.5 and earlier used the legacy algorithms, including DES_EDE2 and SHA1. /// \details Crypto++ 5.6.5 and earlier used the legacy algorithms, including DES_EDE2 and SHA1.
/// Crypto++ 5.7 switched to AES and SHA256. The updated algorithms are available with the /// Crypto++ 5.7 switched to AES and SHA256. The updated algorithms are available with the
/// <tt>Default*</tt> classes, and the old algorithms are available with the <tt>Legacy*</tt> classes. /// <tt>Default*</tt> classes, and the old algorithms are available with the <tt>Legacy*</tt> classes.
struct LegacyDecryptor : public DataDecryptor<LegacyBlockCipher,LegacyHashModule,LegacyParametersInfo> {}; struct LegacyDecryptor : public DataDecryptor<LegacyBlockCipher,LegacyHashModule,LegacyParametersInfo> {};
/// \class DefaultEncryptor
/// \brief Password-based encryptor /// \brief Password-based encryptor
/// \details Crypto++ 5.6.5 and earlier used the legacy algorithms, including DES_EDE2 and SHA1. /// \details Crypto++ 5.6.5 and earlier used the legacy algorithms, including DES_EDE2 and SHA1.
/// Crypto++ 5.7 switched to AES and SHA256. The updated algorithms are available with the /// Crypto++ 5.7 switched to AES and SHA256. The updated algorithms are available with the
/// <tt>Default*</tt> classes, and the old algorithms are available with the <tt>Legacy*</tt> classes. /// <tt>Default*</tt> classes, and the old algorithms are available with the <tt>Legacy*</tt> classes.
struct DefaultEncryptor : public DataEncryptor<DefaultBlockCipher,DefaultHashModule,DefaultParametersInfo> {}; struct DefaultEncryptor : public DataEncryptor<DefaultBlockCipher,DefaultHashModule,DefaultParametersInfo> {};
/// \class DefaultDecryptor
/// \brief Password-based decryptor /// \brief Password-based decryptor
/// \details Crypto++ 5.6.5 and earlier used the legacy algorithms, including DES_EDE2 and SHA1. /// \details Crypto++ 5.6.5 and earlier used the legacy algorithms, including DES_EDE2 and SHA1.
/// Crypto++ 5.7 switched to AES and SHA256. The updated algorithms are available with the /// Crypto++ 5.7 switched to AES and SHA256. The updated algorithms are available with the
/// <tt>Default*</tt> classes, and the old algorithms are available with the <tt>Legacy*</tt> classes. /// <tt>Default*</tt> classes, and the old algorithms are available with the <tt>Legacy*</tt> classes.
struct DefaultDecryptor : public DataDecryptor<DefaultBlockCipher,DefaultHashModule,DefaultParametersInfo> {}; struct DefaultDecryptor : public DataDecryptor<DefaultBlockCipher,DefaultHashModule,DefaultParametersInfo> {};
/// \class LegacyEncryptorWithMAC
/// \brief Password-based encryptor with MAC (deprecated) /// \brief Password-based encryptor with MAC (deprecated)
/// \details Crypto++ 5.6.5 and earlier used the legacy algorithms, including DES_EDE2 and SHA1. /// \details Crypto++ 5.6.5 and earlier used the legacy algorithms, including DES_EDE2 and SHA1.
/// Crypto++ 5.7 switched to AES and SHA256. The updated algorithms are available with the /// Crypto++ 5.7 switched to AES and SHA256. The updated algorithms are available with the
/// <tt>Default*</tt> classes, and the old algorithms are available with the <tt>Legacy*</tt> classes. /// <tt>Default*</tt> classes, and the old algorithms are available with the <tt>Legacy*</tt> classes.
struct LegacyEncryptorWithMAC : public DataEncryptorWithMAC<LegacyBlockCipher,LegacyHashModule,DefaultMAC,LegacyParametersInfo> {}; struct LegacyEncryptorWithMAC : public DataEncryptorWithMAC<LegacyBlockCipher,LegacyHashModule,DefaultMAC,LegacyParametersInfo> {};
/// \class LegacyDecryptorWithMAC
/// \brief Password-based decryptor with MAC (deprecated) /// \brief Password-based decryptor with MAC (deprecated)
/// \details Crypto++ 5.6.5 and earlier used the legacy algorithms, including DES_EDE2 and SHA1. /// \details Crypto++ 5.6.5 and earlier used the legacy algorithms, including DES_EDE2 and SHA1.
/// Crypto++ 5.7 switched to AES and SHA256. The updated algorithms are available with the /// Crypto++ 5.7 switched to AES and SHA256. The updated algorithms are available with the
/// <tt>Default*</tt> classes, and the old algorithms are available with the <tt>Legacy*</tt> classes. /// <tt>Default*</tt> classes, and the old algorithms are available with the <tt>Legacy*</tt> classes.
struct LegacyDecryptorWithMAC : public DataDecryptorWithMAC<LegacyBlockCipher,LegacyHashModule,DefaultMAC,LegacyParametersInfo> {}; struct LegacyDecryptorWithMAC : public DataDecryptorWithMAC<LegacyBlockCipher,LegacyHashModule,DefaultMAC,LegacyParametersInfo> {};
/// \class DefaultEncryptorWithMAC
/// \brief Password-based encryptor with MAC /// \brief Password-based encryptor with MAC
/// \details Crypto++ 5.6.5 and earlier used the legacy algorithms, including DES_EDE2 and SHA1. /// \details Crypto++ 5.6.5 and earlier used the legacy algorithms, including DES_EDE2 and SHA1.
/// Crypto++ 5.7 switched to AES and SHA256. The updated algorithms are available with the /// Crypto++ 5.7 switched to AES and SHA256. The updated algorithms are available with the
/// <tt>Default*</tt> classes, and the old algorithms are available with the <tt>Legacy*</tt> classes. /// <tt>Default*</tt> classes, and the old algorithms are available with the <tt>Legacy*</tt> classes.
struct DefaultEncryptorWithMAC : public DataEncryptorWithMAC<DefaultBlockCipher,DefaultHashModule,DefaultMAC,DefaultParametersInfo> {}; struct DefaultEncryptorWithMAC : public DataEncryptorWithMAC<DefaultBlockCipher,DefaultHashModule,DefaultMAC,DefaultParametersInfo> {};
/// \class DefaultDecryptorWithMAC
/// \brief Password-based decryptor with MAC /// \brief Password-based decryptor with MAC
/// \details Crypto++ 5.6.5 and earlier used the legacy algorithms, including DES_EDE2 and SHA1. /// \details Crypto++ 5.6.5 and earlier used the legacy algorithms, including DES_EDE2 and SHA1.
/// Crypto++ 5.7 switched to AES and SHA256. The updated algorithms are available with the /// Crypto++ 5.7 switched to AES and SHA256. The updated algorithms are available with the

13
des.h
View File

@ -11,7 +11,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class RawDES
/// \brief DES block cipher base class /// \brief DES block cipher base class
class CRYPTOPP_DLL RawDES class CRYPTOPP_DLL RawDES
{ {
@ -25,7 +24,6 @@ protected:
FixedSizeSecBlock<word32, 32> k; FixedSizeSecBlock<word32, 32> k;
}; };
/// \class DES_Info
/// \brief DES block cipher information /// \brief DES block cipher information
struct DES_Info : public FixedBlockSize<8>, public FixedKeyLength<8> struct DES_Info : public FixedBlockSize<8>, public FixedKeyLength<8>
{ {
@ -33,7 +31,6 @@ struct DES_Info : public FixedBlockSize<8>, public FixedKeyLength<8>
CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "DES";} CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "DES";}
}; };
/// \class DES
/// \brief DES block cipher /// \brief DES block cipher
/// \details The DES implementation in Crypto++ ignores the parity bits /// \details The DES implementation in Crypto++ ignores the parity bits
/// (the least significant bits of each byte) in the key. However you can use CheckKeyParityBits() /// (the least significant bits of each byte) in the key. However you can use CheckKeyParityBits()
@ -42,7 +39,6 @@ struct DES_Info : public FixedBlockSize<8>, public FixedKeyLength<8>
/// \since Crypto++ 1.0 /// \since Crypto++ 1.0
class DES : public DES_Info, public BlockCipherDocumentation class DES : public DES_Info, public BlockCipherDocumentation
{ {
/// \class Base
/// \brief DES block cipher default operation /// \brief DES block cipher default operation
class CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<DES_Info>, public RawDES class CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<DES_Info>, public RawDES
{ {
@ -61,20 +57,17 @@ public:
typedef BlockCipherFinal<DECRYPTION, Base> Decryption; typedef BlockCipherFinal<DECRYPTION, Base> Decryption;
}; };
/// \class DES_EDE2_Info
/// \brief 2-key TripleDES block cipher information /// \brief 2-key TripleDES block cipher information
struct DES_EDE2_Info : public FixedBlockSize<8>, public FixedKeyLength<16> struct DES_EDE2_Info : public FixedBlockSize<8>, public FixedKeyLength<16>
{ {
CRYPTOPP_DLL static const char * CRYPTOPP_API StaticAlgorithmName() {return "DES-EDE2";} CRYPTOPP_DLL static const char * CRYPTOPP_API StaticAlgorithmName() {return "DES-EDE2";}
}; };
/// \class DES_EDE2
/// \brief 2-key TripleDES block cipher /// \brief 2-key TripleDES block cipher
/// \sa <a href="http://www.cryptopp.com/wiki/TripleDES">DES-EDE2</a> /// \sa <a href="http://www.cryptopp.com/wiki/TripleDES">DES-EDE2</a>
/// \since Crypto++ 1.0 /// \since Crypto++ 1.0
class DES_EDE2 : public DES_EDE2_Info, public BlockCipherDocumentation class DES_EDE2 : public DES_EDE2_Info, public BlockCipherDocumentation
{ {
/// \class Base
/// \brief DES_EDE2 block cipher default operation /// \brief DES_EDE2 block cipher default operation
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<DES_EDE2_Info> class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<DES_EDE2_Info>
{ {
@ -91,20 +84,17 @@ public:
typedef BlockCipherFinal<DECRYPTION, Base> Decryption; typedef BlockCipherFinal<DECRYPTION, Base> Decryption;
}; };
/// \class DES_EDE3_Info
/// \brief 3-key TripleDES block cipher information /// \brief 3-key TripleDES block cipher information
struct DES_EDE3_Info : public FixedBlockSize<8>, public FixedKeyLength<24> struct DES_EDE3_Info : public FixedBlockSize<8>, public FixedKeyLength<24>
{ {
CRYPTOPP_DLL static const char * CRYPTOPP_API StaticAlgorithmName() {return "DES-EDE3";} CRYPTOPP_DLL static const char * CRYPTOPP_API StaticAlgorithmName() {return "DES-EDE3";}
}; };
/// \class DES_EDE3
/// \brief 3-key TripleDES block cipher /// \brief 3-key TripleDES block cipher
/// \sa <a href="http://www.cryptopp.com/wiki/TripleDES">DES-EDE3</a> /// \sa <a href="http://www.cryptopp.com/wiki/TripleDES">DES-EDE3</a>
/// \since Crypto++ 1.0 /// \since Crypto++ 1.0
class DES_EDE3 : public DES_EDE3_Info, public BlockCipherDocumentation class DES_EDE3 : public DES_EDE3_Info, public BlockCipherDocumentation
{ {
/// \class Base
/// \brief DES_EDE3 block cipher default operation /// \brief DES_EDE3 block cipher default operation
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<DES_EDE3_Info> class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<DES_EDE3_Info>
{ {
@ -121,20 +111,17 @@ public:
typedef BlockCipherFinal<DECRYPTION, Base> Decryption; typedef BlockCipherFinal<DECRYPTION, Base> Decryption;
}; };
/// \class DES_XEX3_Info
/// \brief DESX block cipher information /// \brief DESX block cipher information
struct DES_XEX3_Info : public FixedBlockSize<8>, public FixedKeyLength<24> struct DES_XEX3_Info : public FixedBlockSize<8>, public FixedKeyLength<24>
{ {
CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "DES-XEX3";} CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "DES-XEX3";}
}; };
/// \class DES_XEX3
/// \brief DESX block cipher /// \brief DESX block cipher
/// \sa <a href="http://www.cryptopp.com/wiki/TripleDES">DES-XEX3</a>, AKA DESX /// \sa <a href="http://www.cryptopp.com/wiki/TripleDES">DES-XEX3</a>, AKA DESX
/// \since Crypto++ 1.0 /// \since Crypto++ 1.0
class DES_XEX3 : public DES_XEX3_Info, public BlockCipherDocumentation class DES_XEX3 : public DES_XEX3_Info, public BlockCipherDocumentation
{ {
/// \class Base
/// \brief DES_XEX3 block cipher default operation /// \brief DES_XEX3 block cipher default operation
class CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<DES_XEX3_Info> class CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<DES_XEX3_Info>
{ {

1
dh.h
View File

@ -12,7 +12,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class DH_Domain
/// \brief Diffie-Hellman domain /// \brief Diffie-Hellman domain
/// \tparam GROUP_PARAMETERS group parameters /// \tparam GROUP_PARAMETERS group parameters
/// \tparam COFACTOR_OPTION cofactor multiplication option /// \tparam COFACTOR_OPTION cofactor multiplication option

1
dh2.h
View File

@ -10,7 +10,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class DH2
/// \brief Unified Diffie-Hellman in GF(p) /// \brief Unified Diffie-Hellman in GF(p)
/// \details A Diffie-Hellman domain is a set of parameters that must be shared /// \details A Diffie-Hellman domain is a set of parameters that must be shared
/// by two parties in a key agreement protocol, along with the algorithms /// by two parties in a key agreement protocol, along with the algorithms

2
dmac.h
View File

@ -11,7 +11,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class DMAC_Base
/// \brief DMAC message authentication code base class /// \brief DMAC message authentication code base class
/// \tparam T class derived from BlockCipherDocumentation /// \tparam T class derived from BlockCipherDocumentation
template <class T> template <class T>
@ -39,7 +38,6 @@ private:
unsigned int m_counter; unsigned int m_counter;
}; };
/// \class DMAC
/// \brief DMAC message authentication code /// \brief DMAC message authentication code
/// \tparam T class derived from BlockCipherDocumentation /// \tparam T class derived from BlockCipherDocumentation
/// \sa <A HREF="https://eprint.iacr.org/1997/010">CBC MAC for Real-Time Data Sources (08.15.1997)</A> /// \sa <A HREF="https://eprint.iacr.org/1997/010">CBC MAC for Real-Time Data Sources (08.15.1997)</A>

3
drbg.h
View File

@ -16,7 +16,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class NIST_DRBG
/// \brief Interface for NIST DRBGs from SP 800-90A /// \brief Interface for NIST DRBGs from SP 800-90A
/// \details NIST_DRBG is the base class interface for NIST DRBGs from SP 800-90A Rev 1 (June 2015) /// \details NIST_DRBG is the base class interface for NIST DRBGs from SP 800-90A Rev 1 (June 2015)
/// \sa <A HREF="http://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-90Ar1.pdf">Recommendation /// \sa <A HREF="http://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-90Ar1.pdf">Recommendation
@ -146,7 +145,6 @@ protected:
// ************************************************************* // *************************************************************
/// \class Hash_DRBG
/// \tparam HASH NIST approved hash derived from HashTransformation /// \tparam HASH NIST approved hash derived from HashTransformation
/// \tparam STRENGTH security strength, in bytes /// \tparam STRENGTH security strength, in bytes
/// \tparam SEEDLENGTH seed length, in bytes /// \tparam SEEDLENGTH seed length, in bytes
@ -261,7 +259,6 @@ private:
// ************************************************************* // *************************************************************
/// \class HMAC_DRBG
/// \tparam HASH NIST approved hash derived from HashTransformation /// \tparam HASH NIST approved hash derived from HashTransformation
/// \tparam STRENGTH security strength, in bytes /// \tparam STRENGTH security strength, in bytes
/// \tparam SEEDLENGTH seed length, in bytes /// \tparam SEEDLENGTH seed length, in bytes

3
eax.h
View File

@ -12,7 +12,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class EAX_Base
/// \brief EAX block cipher base implementation /// \brief EAX block cipher base implementation
/// \details Base implementation of the AuthenticatedSymmetricCipher interface /// \details Base implementation of the AuthenticatedSymmetricCipher interface
/// \since Crypto++ 5.6.0 /// \since Crypto++ 5.6.0
@ -67,7 +66,6 @@ protected:
CTR_Mode_ExternalCipher::Encryption m_ctr; CTR_Mode_ExternalCipher::Encryption m_ctr;
}; };
/// \class EAX_Final
/// \brief EAX block cipher final implementation /// \brief EAX block cipher final implementation
/// \tparam T_BlockCipher block cipher /// \tparam T_BlockCipher block cipher
/// \tparam T_IsEncryption direction in which to operate the cipher /// \tparam T_IsEncryption direction in which to operate the cipher
@ -90,7 +88,6 @@ private:
#undef EAX #undef EAX
#endif #endif
/// \class EAX
/// \brief EAX block cipher mode of operation /// \brief EAX block cipher mode of operation
/// \tparam T_BlockCipher block cipher /// \tparam T_BlockCipher block cipher
/// \details \p EAX provides the \p Encryption and \p Decryption typedef. See EAX_Base /// \details \p EAX provides the \p Encryption and \p Decryption typedef. See EAX_Base

3
ec2n.h
View File

@ -24,7 +24,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class EC2N
/// \brief Elliptic Curve over GF(2^n) /// \brief Elliptic Curve over GF(2^n)
class CRYPTOPP_DLL EC2N : public AbstractGroup<EC2NPoint>, public EncodedPoint<EC2NPoint> class CRYPTOPP_DLL EC2N : public AbstractGroup<EC2NPoint>, public EncodedPoint<EC2NPoint>
{ {
@ -97,12 +96,10 @@ private:
CRYPTOPP_DLL_TEMPLATE_CLASS DL_FixedBasePrecomputationImpl<EC2N::Point>; CRYPTOPP_DLL_TEMPLATE_CLASS DL_FixedBasePrecomputationImpl<EC2N::Point>;
CRYPTOPP_DLL_TEMPLATE_CLASS DL_GroupPrecomputation<EC2N::Point>; CRYPTOPP_DLL_TEMPLATE_CLASS DL_GroupPrecomputation<EC2N::Point>;
/// \class EcPrecomputation
/// \brief Elliptic Curve precomputation /// \brief Elliptic Curve precomputation
/// \tparam EC elliptic curve field /// \tparam EC elliptic curve field
template <class EC> class EcPrecomputation; template <class EC> class EcPrecomputation;
/// \class EcPrecomputation<EC2N>
/// \brief EC2N precomputation specialization /// \brief EC2N precomputation specialization
/// \details Implementation of <tt>DL_GroupPrecomputation<EC2N::Point></tt> /// \details Implementation of <tt>DL_GroupPrecomputation<EC2N::Point></tt>
/// \sa DL_GroupPrecomputation /// \sa DL_GroupPrecomputation

20
eccrypto.h
View File

@ -168,7 +168,6 @@ protected:
mutable bool m_compress, m_encodeAsOID; // presentation details mutable bool m_compress, m_encodeAsOID; // presentation details
}; };
/// \class DL_PublicKey_EC
/// \brief Elliptic Curve Discrete Log (DL) public key /// \brief Elliptic Curve Discrete Log (DL) public key
/// \tparam EC elliptic curve field /// \tparam EC elliptic curve field
template <class EC> template <class EC>
@ -200,7 +199,6 @@ public:
void DEREncodePublicKey(BufferedTransformation &bt) const; void DEREncodePublicKey(BufferedTransformation &bt) const;
}; };
/// \class DL_PrivateKey_EC
/// \brief Elliptic Curve Discrete Log (DL) private key /// \brief Elliptic Curve Discrete Log (DL) private key
/// \tparam EC elliptic curve field /// \tparam EC elliptic curve field
template <class EC> template <class EC>
@ -256,7 +254,6 @@ public:
template<class EC> template<class EC>
DL_PrivateKey_EC<EC>::~DL_PrivateKey_EC() {} DL_PrivateKey_EC<EC>::~DL_PrivateKey_EC() {}
/// \class ECDH
/// \brief Elliptic Curve Diffie-Hellman /// \brief Elliptic Curve Diffie-Hellman
/// \tparam EC elliptic curve field /// \tparam EC elliptic curve field
/// \tparam COFACTOR_OPTION cofactor multiplication option /// \tparam COFACTOR_OPTION cofactor multiplication option
@ -267,7 +264,6 @@ struct ECDH
typedef DH_Domain<DL_GroupParameters_EC<EC>, COFACTOR_OPTION> Domain; typedef DH_Domain<DL_GroupParameters_EC<EC>, COFACTOR_OPTION> Domain;
}; };
/// \class ECMQV
/// \brief Elliptic Curve Menezes-Qu-Vanstone /// \brief Elliptic Curve Menezes-Qu-Vanstone
/// \tparam EC elliptic curve field /// \tparam EC elliptic curve field
/// \tparam COFACTOR_OPTION cofactor multiplication option /// \tparam COFACTOR_OPTION cofactor multiplication option
@ -278,7 +274,6 @@ struct ECMQV
typedef MQV_Domain<DL_GroupParameters_EC<EC>, COFACTOR_OPTION> Domain; typedef MQV_Domain<DL_GroupParameters_EC<EC>, COFACTOR_OPTION> Domain;
}; };
/// \class ECHMQV
/// \brief Hashed Elliptic Curve Menezes-Qu-Vanstone /// \brief Hashed Elliptic Curve Menezes-Qu-Vanstone
/// \tparam EC elliptic curve field /// \tparam EC elliptic curve field
/// \tparam COFACTOR_OPTION cofactor multiplication option /// \tparam COFACTOR_OPTION cofactor multiplication option
@ -296,7 +291,6 @@ typedef ECHMQV< ECP, DL_GroupParameters_EC< ECP >::DefaultCofactorOption, SHA256
typedef ECHMQV< ECP, DL_GroupParameters_EC< ECP >::DefaultCofactorOption, SHA384 >::Domain ECHMQV384; typedef ECHMQV< ECP, DL_GroupParameters_EC< ECP >::DefaultCofactorOption, SHA384 >::Domain ECHMQV384;
typedef ECHMQV< ECP, DL_GroupParameters_EC< ECP >::DefaultCofactorOption, SHA512 >::Domain ECHMQV512; typedef ECHMQV< ECP, DL_GroupParameters_EC< ECP >::DefaultCofactorOption, SHA512 >::Domain ECHMQV512;
/// \class ECFHMQV
/// \brief Fully Hashed Elliptic Curve Menezes-Qu-Vanstone /// \brief Fully Hashed Elliptic Curve Menezes-Qu-Vanstone
/// \tparam EC elliptic curve field /// \tparam EC elliptic curve field
/// \tparam COFACTOR_OPTION cofactor multiplication option /// \tparam COFACTOR_OPTION cofactor multiplication option
@ -315,7 +309,6 @@ typedef ECFHMQV< ECP, DL_GroupParameters_EC< ECP >::DefaultCofactorOption, SHA25
typedef ECFHMQV< ECP, DL_GroupParameters_EC< ECP >::DefaultCofactorOption, SHA384 >::Domain ECFHMQV384; typedef ECFHMQV< ECP, DL_GroupParameters_EC< ECP >::DefaultCofactorOption, SHA384 >::Domain ECFHMQV384;
typedef ECFHMQV< ECP, DL_GroupParameters_EC< ECP >::DefaultCofactorOption, SHA512 >::Domain ECFHMQV512; typedef ECFHMQV< ECP, DL_GroupParameters_EC< ECP >::DefaultCofactorOption, SHA512 >::Domain ECFHMQV512;
/// \class DL_Keys_EC
/// \brief Elliptic Curve Discrete Log (DL) keys /// \brief Elliptic Curve Discrete Log (DL) keys
/// \tparam EC elliptic curve field /// \tparam EC elliptic curve field
template <class EC> template <class EC>
@ -329,7 +322,6 @@ struct DL_Keys_EC
template <class EC, class H> template <class EC, class H>
struct ECDSA; struct ECDSA;
/// \class DL_Keys_ECDSA
/// \brief Elliptic Curve DSA keys /// \brief Elliptic Curve DSA keys
/// \tparam EC elliptic curve field /// \tparam EC elliptic curve field
template <class EC> template <class EC>
@ -339,7 +331,6 @@ struct DL_Keys_ECDSA
typedef DL_PrivateKey_WithSignaturePairwiseConsistencyTest<DL_PrivateKey_EC<EC>, ECDSA<EC, SHA256> > PrivateKey; typedef DL_PrivateKey_WithSignaturePairwiseConsistencyTest<DL_PrivateKey_EC<EC>, ECDSA<EC, SHA256> > PrivateKey;
}; };
/// \class DL_Algorithm_ECDSA
/// \brief Elliptic Curve DSA (ECDSA) signature algorithm /// \brief Elliptic Curve DSA (ECDSA) signature algorithm
/// \tparam EC elliptic curve field /// \tparam EC elliptic curve field
template <class EC> template <class EC>
@ -349,7 +340,6 @@ public:
CRYPTOPP_STATIC_CONSTEXPR const char* CRYPTOPP_API StaticAlgorithmName() {return "ECDSA";} CRYPTOPP_STATIC_CONSTEXPR const char* CRYPTOPP_API StaticAlgorithmName() {return "ECDSA";}
}; };
/// \class DL_Algorithm_ECDSA_RFC6979
/// \brief Elliptic Curve DSA (ECDSA) signature algorithm based on RFC 6979 /// \brief Elliptic Curve DSA (ECDSA) signature algorithm based on RFC 6979
/// \tparam EC elliptic curve field /// \tparam EC elliptic curve field
/// \sa <a href="http://tools.ietf.org/rfc/rfc6979.txt">RFC 6979, Deterministic Usage of the /// \sa <a href="http://tools.ietf.org/rfc/rfc6979.txt">RFC 6979, Deterministic Usage of the
@ -362,7 +352,6 @@ public:
CRYPTOPP_STATIC_CONSTEXPR const char* CRYPTOPP_API StaticAlgorithmName() {return "ECDSA-RFC6979";} CRYPTOPP_STATIC_CONSTEXPR const char* CRYPTOPP_API StaticAlgorithmName() {return "ECDSA-RFC6979";}
}; };
/// \class DL_Algorithm_ECNR
/// \brief Elliptic Curve NR (ECNR) signature algorithm /// \brief Elliptic Curve NR (ECNR) signature algorithm
/// \tparam EC elliptic curve field /// \tparam EC elliptic curve field
template <class EC> template <class EC>
@ -372,7 +361,6 @@ public:
CRYPTOPP_STATIC_CONSTEXPR const char* CRYPTOPP_API StaticAlgorithmName() {return "ECNR";} CRYPTOPP_STATIC_CONSTEXPR const char* CRYPTOPP_API StaticAlgorithmName() {return "ECNR";}
}; };
/// \class ECDSA
/// \brief Elliptic Curve DSA (ECDSA) signature scheme /// \brief Elliptic Curve DSA (ECDSA) signature scheme
/// \tparam EC elliptic curve field /// \tparam EC elliptic curve field
/// \tparam H HashTransformation derived class /// \tparam H HashTransformation derived class
@ -382,7 +370,6 @@ struct ECDSA : public DL_SS<DL_Keys_ECDSA<EC>, DL_Algorithm_ECDSA<EC>, DL_Signat
{ {
}; };
/// \class ECDSA_RFC6979
/// \brief Elliptic Curve DSA (ECDSA) deterministic signature scheme /// \brief Elliptic Curve DSA (ECDSA) deterministic signature scheme
/// \tparam EC elliptic curve field /// \tparam EC elliptic curve field
/// \tparam H HashTransformation derived class /// \tparam H HashTransformation derived class
@ -399,7 +386,6 @@ struct ECDSA_RFC6979 : public DL_SS<
static std::string CRYPTOPP_API StaticAlgorithmName() {return std::string("ECDSA-RFC6979/") + H::StaticAlgorithmName();} static std::string CRYPTOPP_API StaticAlgorithmName() {return std::string("ECDSA-RFC6979/") + H::StaticAlgorithmName();}
}; };
/// \class ECNR
/// \brief Elliptic Curve NR (ECNR) signature scheme /// \brief Elliptic Curve NR (ECNR) signature scheme
/// \tparam EC elliptic curve field /// \tparam EC elliptic curve field
/// \tparam H HashTransformation derived class /// \tparam H HashTransformation derived class
@ -415,7 +401,6 @@ class DL_PublicKey_ECGDSA_ISO15946;
template <class EC> template <class EC>
class DL_PrivateKey_ECGDSA_ISO15946; class DL_PrivateKey_ECGDSA_ISO15946;
/// \class DL_PrivateKey_ECGDSA_ISO15946
/// \brief Elliptic Curve German DSA key for ISO/IEC 15946 /// \brief Elliptic Curve German DSA key for ISO/IEC 15946
/// \tparam EC elliptic curve field /// \tparam EC elliptic curve field
/// \sa ECGDSA_ISO15946 /// \sa ECGDSA_ISO15946
@ -498,7 +483,6 @@ public:
void DEREncodePrivateKey(BufferedTransformation &bt) const; void DEREncodePrivateKey(BufferedTransformation &bt) const;
}; };
/// \class DL_PublicKey_ECGDSA_ISO15946
/// \brief Elliptic Curve German DSA key for ISO/IEC 15946 /// \brief Elliptic Curve German DSA key for ISO/IEC 15946
/// \tparam EC elliptic curve field /// \tparam EC elliptic curve field
/// \sa ECGDSA_ISO15946 /// \sa ECGDSA_ISO15946
@ -551,7 +535,6 @@ public:
void DEREncodePublicKey(BufferedTransformation &bt) const; void DEREncodePublicKey(BufferedTransformation &bt) const;
}; };
/// \class DL_Keys_ECGDSA_ISO15946
/// \brief Elliptic Curve German DSA keys for ISO/IEC 15946 /// \brief Elliptic Curve German DSA keys for ISO/IEC 15946
/// \tparam EC elliptic curve field /// \tparam EC elliptic curve field
/// \sa ECGDSA_ISO15946 /// \sa ECGDSA_ISO15946
@ -563,7 +546,6 @@ struct DL_Keys_ECGDSA_ISO15946
typedef DL_PrivateKey_ECGDSA_ISO15946<EC> PrivateKey; typedef DL_PrivateKey_ECGDSA_ISO15946<EC> PrivateKey;
}; };
/// \class DL_Algorithm_ECGDSA_ISO15946
/// \brief Elliptic Curve German DSA signature algorithm /// \brief Elliptic Curve German DSA signature algorithm
/// \tparam EC elliptic curve field /// \tparam EC elliptic curve field
/// \sa ECGDSA_ISO15946 /// \sa ECGDSA_ISO15946
@ -575,7 +557,6 @@ public:
CRYPTOPP_STATIC_CONSTEXPR const char* CRYPTOPP_API StaticAlgorithmName() {return "ECGDSA";} CRYPTOPP_STATIC_CONSTEXPR const char* CRYPTOPP_API StaticAlgorithmName() {return "ECGDSA";}
}; };
/// \class ECGDSA
/// \brief Elliptic Curve German Digital Signature Algorithm signature scheme /// \brief Elliptic Curve German Digital Signature Algorithm signature scheme
/// \tparam EC elliptic curve field /// \tparam EC elliptic curve field
/// \tparam H HashTransformation derived class /// \tparam H HashTransformation derived class
@ -595,7 +576,6 @@ struct ECGDSA : public DL_SS<
// ****************************************** // ******************************************
/// \class ECIES
/// \brief Elliptic Curve Integrated Encryption Scheme /// \brief Elliptic Curve Integrated Encryption Scheme
/// \tparam COFACTOR_OPTION cofactor multiplication option /// \tparam COFACTOR_OPTION cofactor multiplication option
/// \tparam HASH HashTransformation derived class used for key drivation and MAC computation /// \tparam HASH HashTransformation derived class used for key drivation and MAC computation

3
ecp.h
View File

@ -22,7 +22,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class ECP
/// \brief Elliptic Curve over GF(p), where p is prime /// \brief Elliptic Curve over GF(p), where p is prime
class CRYPTOPP_DLL ECP : public AbstractGroup<ECPPoint>, public EncodedPoint<ECPPoint> class CRYPTOPP_DLL ECP : public AbstractGroup<ECPPoint>, public EncodedPoint<ECPPoint>
{ {
@ -104,12 +103,10 @@ private:
CRYPTOPP_DLL_TEMPLATE_CLASS DL_FixedBasePrecomputationImpl<ECP::Point>; CRYPTOPP_DLL_TEMPLATE_CLASS DL_FixedBasePrecomputationImpl<ECP::Point>;
CRYPTOPP_DLL_TEMPLATE_CLASS DL_GroupPrecomputation<ECP::Point>; CRYPTOPP_DLL_TEMPLATE_CLASS DL_GroupPrecomputation<ECP::Point>;
/// \class EcPrecomputation
/// \brief Elliptic Curve precomputation /// \brief Elliptic Curve precomputation
/// \tparam EC elliptic curve field /// \tparam EC elliptic curve field
template <class EC> class EcPrecomputation; template <class EC> class EcPrecomputation;
/// \class EcPrecomputation<ECP>
/// \brief ECP precomputation specialization /// \brief ECP precomputation specialization
/// \details Implementation of <tt>DL_GroupPrecomputation<ECP::Point></tt> with input and output /// \details Implementation of <tt>DL_GroupPrecomputation<ECP::Point></tt> with input and output
/// conversions for Montgomery modular multiplication. /// conversions for Montgomery modular multiplication.

3
ecpoint.h
View File

@ -15,7 +15,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class ECPPoint
/// \brief Elliptical Curve Point over GF(p), where p is prime /// \brief Elliptical Curve Point over GF(p), where p is prime
/// \since Crypto++ 2.0 /// \since Crypto++ 2.0
struct CRYPTOPP_DLL ECPPoint struct CRYPTOPP_DLL ECPPoint
@ -49,7 +48,6 @@ struct CRYPTOPP_DLL ECPPoint
CRYPTOPP_DLL_TEMPLATE_CLASS AbstractGroup<ECPPoint>; CRYPTOPP_DLL_TEMPLATE_CLASS AbstractGroup<ECPPoint>;
/// \class EC2NPoint
/// \brief Elliptical Curve Point over GF(2^n) /// \brief Elliptical Curve Point over GF(2^n)
/// \since Crypto++ 2.0 /// \since Crypto++ 2.0
struct CRYPTOPP_DLL EC2NPoint struct CRYPTOPP_DLL EC2NPoint
@ -83,7 +81,6 @@ struct CRYPTOPP_DLL EC2NPoint
CRYPTOPP_DLL_TEMPLATE_CLASS AbstractGroup<EC2NPoint>; CRYPTOPP_DLL_TEMPLATE_CLASS AbstractGroup<EC2NPoint>;
/// \class EncodedPoint
/// \brief Abstract class for encoding and decoding ellicptic curve points /// \brief Abstract class for encoding and decoding ellicptic curve points
/// \tparam Point ellicptic curve point /// \tparam Point ellicptic curve point
/// \details EncodedPoint is an interface for encoding and decoding elliptic curve points. /// \details EncodedPoint is an interface for encoding and decoding elliptic curve points.

4
elgamal.h
View File

@ -16,7 +16,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class ElGamalBase
/// \brief ElGamal key agreement and encryption schemes base class /// \brief ElGamal key agreement and encryption schemes base class
/// \since Crypto++ 1.0 /// \since Crypto++ 1.0
class CRYPTOPP_NO_VTABLE ElGamalBase : public DL_KeyAgreementAlgorithm_DH<Integer, NoCofactorMultiplication>, class CRYPTOPP_NO_VTABLE ElGamalBase : public DL_KeyAgreementAlgorithm_DH<Integer, NoCofactorMultiplication>,
@ -93,7 +92,6 @@ public:
virtual const DL_GroupParameters_GFP & GetGroupParameters() const =0; virtual const DL_GroupParameters_GFP & GetGroupParameters() const =0;
}; };
/// \class ElGamalObjectImpl
/// \brief ElGamal key agreement and encryption schemes default implementation /// \brief ElGamal key agreement and encryption schemes default implementation
/// \since Crypto++ 1.0 /// \since Crypto++ 1.0
template <class BASE, class SCHEME_OPTIONS, class KEY> template <class BASE, class SCHEME_OPTIONS, class KEY>
@ -116,7 +114,6 @@ protected:
const DL_SymmetricEncryptionAlgorithm & GetSymmetricEncryptionAlgorithm() const {return *this;} const DL_SymmetricEncryptionAlgorithm & GetSymmetricEncryptionAlgorithm() const {return *this;}
}; };
/// \class ElGamalKeys
/// \brief ElGamal key agreement and encryption schemes keys /// \brief ElGamal key agreement and encryption schemes keys
/// \details The ElGamalKeys class used DL_PrivateKey_GFP_OldFormat and DL_PublicKey_GFP_OldFormat /// \details The ElGamalKeys class used DL_PrivateKey_GFP_OldFormat and DL_PublicKey_GFP_OldFormat
/// for the PrivateKey and PublicKey typedef from about Crypto++ 1.0 through Crypto++ 5.6.5. /// for the PrivateKey and PublicKey typedef from about Crypto++ 1.0 through Crypto++ 5.6.5.
@ -129,7 +126,6 @@ struct ElGamalKeys
typedef DL_CryptoKeys_GFP::PublicKey PublicKey; typedef DL_CryptoKeys_GFP::PublicKey PublicKey;
}; };
/// \class ElGamal
/// \brief ElGamal encryption scheme with non-standard padding /// \brief ElGamal encryption scheme with non-standard padding
/// \since Crypto++ 1.0 /// \since Crypto++ 1.0
struct ElGamal struct ElGamal

4
emsa2.h
View File

@ -17,7 +17,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class EMSA2HashId
/// \brief EMSA2 hash identifier /// \brief EMSA2 hash identifier
/// \tparam H HashTransformation derived class /// \tparam H HashTransformation derived class
/// \since Crypto++ 5.0 /// \since Crypto++ 5.0
@ -27,7 +26,6 @@ public:
static const byte id; static const byte id;
}; };
/// \class EMSA2Pad
/// \brief EMSA2 padding method /// \brief EMSA2 padding method
/// \tparam BASE Message encoding method /// \tparam BASE Message encoding method
/// \since Crypto++ 5.0 /// \since Crypto++ 5.0
@ -68,7 +66,6 @@ template<> const byte EMSA2HashId<SHA384>::id;
template<> const byte EMSA2HashId<SHA512>::id; template<> const byte EMSA2HashId<SHA512>::id;
#endif #endif
/// \class EMSA2Pad
/// \brief EMSA2 padding method /// \brief EMSA2 padding method
/// \since Crypto++ 5.0 /// \since Crypto++ 5.0
class CRYPTOPP_DLL EMSA2Pad : public EMSA2HashIdLookup<PK_DeterministicSignatureMessageEncodingMethod> class CRYPTOPP_DLL EMSA2Pad : public EMSA2HashIdLookup<PK_DeterministicSignatureMessageEncodingMethod>
@ -91,7 +88,6 @@ public:
// \skip EMSA2HashId can be instantiated // \skip EMSA2HashId can be instantiated
// \until end of list // \until end of list
/// \class P1363_EMSA2
/// \brief EMSA2/P1363 padding method /// \brief EMSA2/P1363 padding method
/// \details Use with RWSS and RSA_ISO /// \details Use with RWSS and RSA_ISO
/// \since Crypto++ 5.0 /// \since Crypto++ 5.0

6
esign.h
View File

@ -15,7 +15,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class ESIGNFunction
/// \brief ESIGN trapdoor function using the public key /// \brief ESIGN trapdoor function using the public key
/// \since Crypto++ 5.0 /// \since Crypto++ 5.0
class ESIGNFunction : public TrapdoorFunction, public ASN1CryptoMaterial<PublicKey> class ESIGNFunction : public TrapdoorFunction, public ASN1CryptoMaterial<PublicKey>
@ -58,7 +57,6 @@ protected:
Integer m_n, m_e; Integer m_n, m_e;
}; };
/// \class InvertibleESIGNFunction
/// \brief ESIGN trapdoor function using the private key /// \brief ESIGN trapdoor function using the private key
/// \since Crypto++ 5.0 /// \since Crypto++ 5.0
class InvertibleESIGNFunction : public ESIGNFunction, public RandomizedTrapdoorFunctionInverse, public PrivateKey class InvertibleESIGNFunction : public ESIGNFunction, public RandomizedTrapdoorFunctionInverse, public PrivateKey
@ -115,7 +113,6 @@ protected:
Integer m_p, m_q; Integer m_p, m_q;
}; };
/// \class EMSA5Pad
/// \brief EMSA5 padding method /// \brief EMSA5 padding method
/// \tparam T Mask Generation Function /// \tparam T Mask Generation Function
/// \since Crypto++ 5.0 /// \since Crypto++ 5.0
@ -142,7 +139,6 @@ public:
} }
}; };
/// \class P1363_EMSA5
/// \brief EMSA5 padding method, for use with ESIGN /// \brief EMSA5 padding method, for use with ESIGN
/// \since Crypto++ 5.0 /// \since Crypto++ 5.0
struct P1363_EMSA5 : public SignatureStandard struct P1363_EMSA5 : public SignatureStandard
@ -150,7 +146,6 @@ struct P1363_EMSA5 : public SignatureStandard
typedef EMSA5Pad<P1363_MGF1> SignatureMessageEncodingMethod; typedef EMSA5Pad<P1363_MGF1> SignatureMessageEncodingMethod;
}; };
/// \class ESIGN_Keys
/// \brief ESIGN keys /// \brief ESIGN keys
/// \since Crypto++ 5.0 /// \since Crypto++ 5.0
struct ESIGN_Keys struct ESIGN_Keys
@ -160,7 +155,6 @@ struct ESIGN_Keys
typedef InvertibleESIGNFunction PrivateKey; typedef InvertibleESIGNFunction PrivateKey;
}; };
/// \class ESIGN
/// \brief ESIGN signature scheme, IEEE P1363a /// \brief ESIGN signature scheme, IEEE P1363a
/// \tparam H HashTransformation derived class /// \tparam H HashTransformation derived class
/// \tparam STANDARD Signature encoding method /// \tparam STANDARD Signature encoding method

4
factory.h
View File

@ -12,7 +12,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class ObjectFactory
/// \brief Object factory interface for registering objects /// \brief Object factory interface for registering objects
/// \tparam AbstractClass Base class interface of the object /// \tparam AbstractClass Base class interface of the object
template <class AbstractClass> template <class AbstractClass>
@ -23,7 +22,6 @@ public:
virtual AbstractClass * CreateObject() const =0; virtual AbstractClass * CreateObject() const =0;
}; };
/// \class DefaultObjectFactory
/// \brief Object factory for registering objects /// \brief Object factory for registering objects
/// \tparam AbstractClass Base class interface of the object /// \tparam AbstractClass Base class interface of the object
/// \tparam ConcreteClass Class object /// \tparam ConcreteClass Class object
@ -37,7 +35,6 @@ public:
} }
}; };
/// \class ObjectFactoryRegistry
/// \brief Object factory registry /// \brief Object factory registry
/// \tparam AbstractClass Base class interface of the object /// \tparam AbstractClass Base class interface of the object
/// \tparam instance unique identifier /// \tparam instance unique identifier
@ -105,7 +102,6 @@ ObjectFactoryRegistry<AbstractClass, instance> & ObjectFactoryRegistry<AbstractC
return s_registry; return s_registry;
} }
/// \class RegisterDefaultFactoryFor
/// \brief Object factory registry helper /// \brief Object factory registry helper
/// \tparam AbstractClass Base class interface of the object /// \tparam AbstractClass Base class interface of the object
/// \tparam ConcreteClass Class object /// \tparam ConcreteClass Class object

3
files.h
View File

@ -17,7 +17,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class FileStore
/// \brief Implementation of Store interface /// \brief Implementation of Store interface
/// \details file-based implementation of Store interface /// \details file-based implementation of Store interface
class CRYPTOPP_DLL FileStore : public Store, private FilterPutSpaceHelper, public NotCopyable class CRYPTOPP_DLL FileStore : public Store, private FilterPutSpaceHelper, public NotCopyable
@ -78,7 +77,6 @@ private:
bool m_waiting; bool m_waiting;
}; };
/// \class FileSource
/// \brief Implementation of Store interface /// \brief Implementation of Store interface
/// \details file-based implementation of Store interface /// \details file-based implementation of Store interface
class CRYPTOPP_DLL FileSource : public SourceTemplate<FileStore> class CRYPTOPP_DLL FileSource : public SourceTemplate<FileStore>
@ -123,7 +121,6 @@ public:
std::istream* GetStream() {return m_store.GetStream();} std::istream* GetStream() {return m_store.GetStream();}
}; };
/// \class FileSink
/// \brief Implementation of Store interface /// \brief Implementation of Store interface
/// \details file-based implementation of Sink interface /// \details file-based implementation of Sink interface
class CRYPTOPP_DLL FileSink : public Sink, public NotCopyable class CRYPTOPP_DLL FileSink : public Sink, public NotCopyable

32
filters.h
View File

@ -24,7 +24,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class Filter
/// \brief Implementation of BufferedTransformation's attachment interface /// \brief Implementation of BufferedTransformation's attachment interface
/// \details Filter is a cornerstone of the Pipeline trinitiy. Data flows from /// \details Filter is a cornerstone of the Pipeline trinitiy. Data flows from
/// Sources, through Filters, and then terminates in Sinks. The difference /// Sources, through Filters, and then terminates in Sinks. The difference
@ -155,7 +154,6 @@ protected:
int m_continueAt; int m_continueAt;
}; };
/// \class FilterPutSpaceHelper
/// \brief Create a working space in a BufferedTransformation /// \brief Create a working space in a BufferedTransformation
struct CRYPTOPP_DLL FilterPutSpaceHelper struct CRYPTOPP_DLL FilterPutSpaceHelper
{ {
@ -213,7 +211,6 @@ struct CRYPTOPP_DLL FilterPutSpaceHelper
SecByteBlock m_tempSpace; SecByteBlock m_tempSpace;
}; };
/// \class MeterFilter
/// \brief Measure how many bytes and messages pass through the filter /// \brief Measure how many bytes and messages pass through the filter
/// \details measure how many bytes and messages pass through the filter. The filter also serves as valve by /// \details measure how many bytes and messages pass through the filter. The filter also serves as valve by
/// maintaining a list of ranges to skip during processing. /// maintaining a list of ranges to skip during processing.
@ -285,7 +282,6 @@ private:
size_t m_length; size_t m_length;
}; };
/// \class TransparentFilter
/// \brief A transparent MeterFilter /// \brief A transparent MeterFilter
/// \sa MeterFilter, OpaqueFilter /// \sa MeterFilter, OpaqueFilter
class CRYPTOPP_DLL TransparentFilter : public MeterFilter class CRYPTOPP_DLL TransparentFilter : public MeterFilter
@ -296,7 +292,6 @@ public:
TransparentFilter(BufferedTransformation *attachment=NULLPTR) : MeterFilter(attachment, true) {} TransparentFilter(BufferedTransformation *attachment=NULLPTR) : MeterFilter(attachment, true) {}
}; };
/// \class OpaqueFilter
/// \brief A non-transparent MeterFilter /// \brief A non-transparent MeterFilter
/// \sa MeterFilter, TransparentFilter /// \sa MeterFilter, TransparentFilter
class CRYPTOPP_DLL OpaqueFilter : public MeterFilter class CRYPTOPP_DLL OpaqueFilter : public MeterFilter
@ -307,7 +302,6 @@ public:
OpaqueFilter(BufferedTransformation *attachment=NULLPTR) : MeterFilter(attachment, false) {} OpaqueFilter(BufferedTransformation *attachment=NULLPTR) : MeterFilter(attachment, false) {}
}; };
/// \class FilterWithBufferedInput
/// \brief Divides an input stream into discrete blocks /// \brief Divides an input stream into discrete blocks
/// \details FilterWithBufferedInput divides the input stream into a first block, a number of /// \details FilterWithBufferedInput divides the input stream into a first block, a number of
/// middle blocks, and a last block. First and last blocks are optional, and middle blocks may /// middle blocks, and a last block. First and last blocks are optional, and middle blocks may
@ -425,7 +419,6 @@ protected:
BlockQueue m_queue; BlockQueue m_queue;
}; };
/// \class FilterWithInputQueue
/// \brief A filter that buffers input using a ByteQueue /// \brief A filter that buffers input using a ByteQueue
/// \details FilterWithInputQueue will buffer input using a ByteQueue. When the filter receives /// \details FilterWithInputQueue will buffer input using a ByteQueue. When the filter receives
/// a \ref BufferedTransformation::MessageEnd() "MessageEnd()" signal it will pass the data /// a \ref BufferedTransformation::MessageEnd() "MessageEnd()" signal it will pass the data
@ -498,7 +491,6 @@ struct BlockPaddingSchemeDef
}; };
}; };
/// \class StreamTransformationFilter
/// \brief Filter wrapper for StreamTransformation /// \brief Filter wrapper for StreamTransformation
/// \details StreamTransformationFilter() is a filter wrapper for StreamTransformation(). It is used when /// \details StreamTransformationFilter() is a filter wrapper for StreamTransformation(). It is used when
/// pipelining data for stream ciphers and confidentiality-only block ciphers. The filter will optionally /// pipelining data for stream ciphers and confidentiality-only block ciphers. The filter will optionally
@ -553,7 +545,6 @@ protected:
bool m_isSpecial; bool m_isSpecial;
}; };
/// \class HashFilter
/// \brief Filter wrapper for HashTransformation /// \brief Filter wrapper for HashTransformation
/// \since Crypto++ 1.0 /// \since Crypto++ 1.0
class CRYPTOPP_DLL HashFilter : public Bufferless<Filter>, private FilterPutSpaceHelper class CRYPTOPP_DLL HashFilter : public Bufferless<Filter>, private FilterPutSpaceHelper
@ -583,7 +574,6 @@ private:
std::string m_messagePutChannel, m_hashPutChannel; std::string m_messagePutChannel, m_hashPutChannel;
}; };
/// \class HashVerificationFilter
/// \brief Filter wrapper for HashTransformation /// \brief Filter wrapper for HashTransformation
/// \since Crypto++ 4.0 /// \since Crypto++ 4.0
class CRYPTOPP_DLL HashVerificationFilter : public FilterWithBufferedInput class CRYPTOPP_DLL HashVerificationFilter : public FilterWithBufferedInput
@ -591,7 +581,6 @@ class CRYPTOPP_DLL HashVerificationFilter : public FilterWithBufferedInput
public: public:
virtual ~HashVerificationFilter() {} virtual ~HashVerificationFilter() {}
/// \class HashVerificationFailed
/// \brief Exception thrown when a data integrity check failure is encountered /// \brief Exception thrown when a data integrity check failure is encountered
class HashVerificationFailed : public Exception class HashVerificationFailed : public Exception
{ {
@ -647,7 +636,6 @@ private:
SecByteBlock m_expectedHash; SecByteBlock m_expectedHash;
}; };
/// \class AuthenticatedEncryptionFilter
/// \brief Filter wrapper for encrypting with AuthenticatedSymmetricCipher /// \brief Filter wrapper for encrypting with AuthenticatedSymmetricCipher
/// \details AuthenticatedEncryptionFilter() is a wrapper for encrypting with AuthenticatedSymmetricCipher(), /// \details AuthenticatedEncryptionFilter() is a wrapper for encrypting with AuthenticatedSymmetricCipher(),
/// optionally handling padding/unpadding when needed. /// optionally handling padding/unpadding when needed.
@ -689,7 +677,6 @@ protected:
HashFilter m_hf; HashFilter m_hf;
}; };
/// \class AuthenticatedDecryptionFilter
/// \brief Filter wrapper for decrypting with AuthenticatedSymmetricCipher /// \brief Filter wrapper for decrypting with AuthenticatedSymmetricCipher
/// \details AuthenticatedDecryptionFilter() is a wrapper for decrypting with AuthenticatedSymmetricCipher(), /// \details AuthenticatedDecryptionFilter() is a wrapper for decrypting with AuthenticatedSymmetricCipher(),
/// optionally handling padding/unpadding when needed. /// optionally handling padding/unpadding when needed.
@ -751,7 +738,6 @@ protected:
StreamTransformationFilter m_streamFilter; StreamTransformationFilter m_streamFilter;
}; };
/// \class SignerFilter
/// \brief Filter wrapper for PK_Signer /// \brief Filter wrapper for PK_Signer
/// \since Crypto++ 4.0 /// \since Crypto++ 4.0
class CRYPTOPP_DLL SignerFilter : public Unflushable<Filter> class CRYPTOPP_DLL SignerFilter : public Unflushable<Filter>
@ -780,7 +766,6 @@ private:
SecByteBlock m_buf; SecByteBlock m_buf;
}; };
/// \class SignatureVerificationFilter
/// \brief Filter wrapper for PK_Verifier /// \brief Filter wrapper for PK_Verifier
/// \details This filter was formerly named <tt>VerifierFilter</tt>. The name changed at Crypto++ 5.0. /// \details This filter was formerly named <tt>VerifierFilter</tt>. The name changed at Crypto++ 5.0.
/// \since Crypto++ 4.0 /// \since Crypto++ 4.0
@ -843,7 +828,6 @@ private:
bool m_verified; bool m_verified;
}; };
/// \class Redirector
/// \brief Redirect input to another BufferedTransformation without owning it /// \brief Redirect input to another BufferedTransformation without owning it
/// \since Crypto++ 4.0 /// \since Crypto++ 4.0
class CRYPTOPP_DLL Redirector : public CustomSignalPropagation<Sink> class CRYPTOPP_DLL Redirector : public CustomSignalPropagation<Sink>
@ -938,7 +922,6 @@ private:
word32 m_behavior; word32 m_behavior;
}; };
/// \class OutputProxy
/// \brief Filter class that is a proxy for a sink /// \brief Filter class that is a proxy for a sink
/// \details Used By ProxyFilter /// \details Used By ProxyFilter
/// \since Crypto++ 4.0 /// \since Crypto++ 4.0
@ -988,7 +971,6 @@ private:
bool m_passSignal; bool m_passSignal;
}; };
/// \class ProxyFilter
/// \brief Base class for Filter classes that are proxies for a chain of other filters /// \brief Base class for Filter classes that are proxies for a chain of other filters
/// \since Crypto++ 4.0 /// \since Crypto++ 4.0
class CRYPTOPP_DLL ProxyFilter : public FilterWithBufferedInput class CRYPTOPP_DLL ProxyFilter : public FilterWithBufferedInput
@ -1015,7 +997,6 @@ protected:
member_ptr<BufferedTransformation> m_filter; member_ptr<BufferedTransformation> m_filter;
}; };
/// \class SimpleProxyFilter
/// \brief Proxy filter that doesn't modify the underlying filter's input or output /// \brief Proxy filter that doesn't modify the underlying filter's input or output
/// \since Crypto++ 5.0 /// \since Crypto++ 5.0
class CRYPTOPP_DLL SimpleProxyFilter : public ProxyFilter class CRYPTOPP_DLL SimpleProxyFilter : public ProxyFilter
@ -1044,7 +1025,6 @@ public:
{CRYPTOPP_UNUSED(inString), CRYPTOPP_UNUSED(length); m_filter->MessageEnd();} {CRYPTOPP_UNUSED(inString), CRYPTOPP_UNUSED(length); m_filter->MessageEnd();}
}; };
/// \class PK_EncryptorFilter
/// \brief Filter wrapper for PK_Encryptor /// \brief Filter wrapper for PK_Encryptor
/// \details PK_DecryptorFilter is a proxy for the filter created by PK_Encryptor::CreateEncryptionFilter. /// \details PK_DecryptorFilter is a proxy for the filter created by PK_Encryptor::CreateEncryptionFilter.
/// This class provides symmetry with VerifierFilter. /// This class provides symmetry with VerifierFilter.
@ -1060,7 +1040,6 @@ public:
: SimpleProxyFilter(encryptor.CreateEncryptionFilter(rng), attachment) {} : SimpleProxyFilter(encryptor.CreateEncryptionFilter(rng), attachment) {}
}; };
/// \class PK_DecryptorFilter
/// \brief Filter wrapper for PK_Decryptor /// \brief Filter wrapper for PK_Decryptor
/// \details PK_DecryptorFilter is a proxy for the filter created by PK_Decryptor::CreateDecryptionFilter. /// \details PK_DecryptorFilter is a proxy for the filter created by PK_Decryptor::CreateDecryptionFilter.
/// This class provides symmetry with SignerFilter. /// This class provides symmetry with SignerFilter.
@ -1076,7 +1055,6 @@ public:
: SimpleProxyFilter(decryptor.CreateDecryptionFilter(rng), attachment) {} : SimpleProxyFilter(decryptor.CreateDecryptionFilter(rng), attachment) {}
}; };
/// \class StringSinkTemplate
/// \brief Append input to a string object /// \brief Append input to a string object
/// \tparam T std::basic_string<char> type /// \tparam T std::basic_string<char> type
/// \details StringSinkTemplate is a StringSinkTemplate typedef /// \details StringSinkTemplate is a StringSinkTemplate typedef
@ -1114,7 +1092,6 @@ private:
T *m_output; T *m_output;
}; };
/// \class StringSink
/// \brief Append input to a string object /// \brief Append input to a string object
/// \details StringSink is a typedef for StringSinkTemplate<std::string>. /// \details StringSink is a typedef for StringSinkTemplate<std::string>.
/// \sa ArraySink, ArrayXorSink /// \sa ArraySink, ArrayXorSink
@ -1122,7 +1099,6 @@ private:
DOCUMENTED_TYPEDEF(StringSinkTemplate<std::string>, StringSink) DOCUMENTED_TYPEDEF(StringSinkTemplate<std::string>, StringSink)
CRYPTOPP_DLL_TEMPLATE_CLASS StringSinkTemplate<std::string>; CRYPTOPP_DLL_TEMPLATE_CLASS StringSinkTemplate<std::string>;
/// \class RandomNumberSink
/// \brief Incorporates input into RNG as additional entropy /// \brief Incorporates input into RNG as additional entropy
/// \since Crypto++ 4.0 /// \since Crypto++ 4.0
class RandomNumberSink : public Bufferless<Sink> class RandomNumberSink : public Bufferless<Sink>
@ -1146,7 +1122,6 @@ private:
RandomNumberGenerator *m_rng; RandomNumberGenerator *m_rng;
}; };
/// \class ArraySink
/// \brief Copy input to a memory buffer /// \brief Copy input to a memory buffer
/// \details ArraySink wraps a fixed size buffer. The buffer is full once Put returns non-0. /// \details ArraySink wraps a fixed size buffer. The buffer is full once Put returns non-0.
/// When used in a pipleline, ArraySink silently discards input if the buffer is full. /// When used in a pipleline, ArraySink silently discards input if the buffer is full.
@ -1189,7 +1164,6 @@ protected:
lword m_total; lword m_total;
}; };
/// \class ArrayXorSink
/// \brief Xor input to a memory buffer /// \brief Xor input to a memory buffer
/// \details ArrayXorSink wraps a fixed size buffer. The buffer is full once Put returns non-0. /// \details ArrayXorSink wraps a fixed size buffer. The buffer is full once Put returns non-0.
/// When used in a pipleline, ArrayXorSink silently discards input if the buffer is full. /// When used in a pipleline, ArrayXorSink silently discards input if the buffer is full.
@ -1212,7 +1186,6 @@ public:
byte * CreatePutSpace(size_t &size) {return BufferedTransformation::CreatePutSpace(size);} byte * CreatePutSpace(size_t &size) {return BufferedTransformation::CreatePutSpace(size);}
}; };
/// \class StringStore
/// \brief String-based implementation of Store interface /// \brief String-based implementation of Store interface
/// \since Crypto++ 4.0 /// \since Crypto++ 4.0
class StringStore : public Store class StringStore : public Store
@ -1245,7 +1218,6 @@ private:
size_t m_length, m_count; size_t m_length, m_count;
}; };
/// \class RandomNumberStore
/// \brief RNG-based implementation of Source interface /// \brief RNG-based implementation of Source interface
/// \since Crypto++ 4.0 /// \since Crypto++ 4.0
class CRYPTOPP_DLL RandomNumberStore : public Store class CRYPTOPP_DLL RandomNumberStore : public Store
@ -1292,7 +1264,6 @@ private:
lword m_size; lword m_size;
}; };
/// \class Source
/// \brief Implementation of BufferedTransformation's attachment interface /// \brief Implementation of BufferedTransformation's attachment interface
/// \details Source is a cornerstone of the Pipeline trinitiy. Data flows from /// \details Source is a cornerstone of the Pipeline trinitiy. Data flows from
/// Sources, through Filters, and then terminates in Sinks. The difference /// Sources, through Filters, and then terminates in Sinks. The difference
@ -1372,7 +1343,6 @@ protected:
} }
}; };
/// \class SourceTemplate
/// \brief Transform a Store into a Source /// \brief Transform a Store into a Source
/// \tparam T the class or type /// \tparam T the class or type
/// \since Crypto++ 5.0 /// \since Crypto++ 5.0
@ -1405,7 +1375,6 @@ protected:
T m_store; T m_store;
}; };
/// \class SourceTemplate
/// \brief String-based implementation of the Source interface /// \brief String-based implementation of the Source interface
/// \since Crypto++ 4.0 /// \since Crypto++ 4.0
class CRYPTOPP_DLL StringSource : public SourceTemplate<StringStore> class CRYPTOPP_DLL StringSource : public SourceTemplate<StringStore>
@ -1439,7 +1408,6 @@ public:
: SourceTemplate<StringStore>(attachment) {SourceInitialize(pumpAll, MakeParameters("InputBuffer", ConstByteArrayParameter(string)));} : SourceTemplate<StringStore>(attachment) {SourceInitialize(pumpAll, MakeParameters("InputBuffer", ConstByteArrayParameter(string)));}
}; };
/// \class ArraySource
/// \brief Pointer-based implementation of the Source interface /// \brief Pointer-based implementation of the Source interface
/// \details ArraySource is a typedef for StringSource. Use the third constructor for an array source. /// \details ArraySource is a typedef for StringSource. Use the third constructor for an array source.
/// The third constructor takes a pointer and length. /// The third constructor takes a pointer and length.

1
fips140.h
View File

@ -16,7 +16,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class SelfTestFailure
/// Exception thrown when a crypto algorithm is used after a self test fails /// Exception thrown when a crypto algorithm is used after a self test fails
/// \details The self tests for an algorithm are performed by Algortihm class /// \details The self tests for an algorithm are performed by Algortihm class
/// when CRYPTOPP_ENABLE_COMPLIANCE_WITH_FIPS_140_2 is defined. /// when CRYPTOPP_ENABLE_COMPLIANCE_WITH_FIPS_140_2 is defined.

3
gcm.h
View File

@ -20,7 +20,6 @@ enum GCM_TablesOption {
/// \brief Use a table with 64K entries /// \brief Use a table with 64K entries
GCM_64K_Tables}; GCM_64K_Tables};
/// \class GCM_Base
/// \brief GCM block cipher base implementation /// \brief GCM block cipher base implementation
/// \details Base implementation of the AuthenticatedSymmetricCipher interface /// \details Base implementation of the AuthenticatedSymmetricCipher interface
/// \since Crypto++ 5.6.0 /// \since Crypto++ 5.6.0
@ -91,7 +90,6 @@ protected:
enum {REQUIRED_BLOCKSIZE = 16, HASH_BLOCKSIZE = 16}; enum {REQUIRED_BLOCKSIZE = 16, HASH_BLOCKSIZE = 16};
}; };
/// \class GCM_Final
/// \brief GCM block cipher final implementation /// \brief GCM block cipher final implementation
/// \tparam T_BlockCipher block cipher /// \tparam T_BlockCipher block cipher
/// \tparam T_TablesOption table size, either \p GCM_2K_Tables or \p GCM_64K_Tables /// \tparam T_TablesOption table size, either \p GCM_2K_Tables or \p GCM_64K_Tables
@ -112,7 +110,6 @@ private:
typename T_BlockCipher::Encryption m_cipher; typename T_BlockCipher::Encryption m_cipher;
}; };
/// \class GCM
/// \brief GCM block cipher mode of operation /// \brief GCM block cipher mode of operation
/// \tparam T_BlockCipher block cipher /// \tparam T_BlockCipher block cipher
/// \tparam T_TablesOption table size, either \p GCM_2K_Tables or \p GCM_64K_Tables /// \tparam T_TablesOption table size, either \p GCM_2K_Tables or \p GCM_64K_Tables

20
gfpcrypt.h
View File

@ -30,7 +30,6 @@ NAMESPACE_BEGIN(CryptoPP)
CRYPTOPP_DLL_TEMPLATE_CLASS DL_GroupParameters<Integer>; CRYPTOPP_DLL_TEMPLATE_CLASS DL_GroupParameters<Integer>;
/// \class DL_GroupParameters_IntegerBased
/// \brief Integer-based GroupParameters specialization /// \brief Integer-based GroupParameters specialization
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE DL_GroupParameters_IntegerBased : public ASN1CryptoMaterial<DL_GroupParameters<Integer> > class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE DL_GroupParameters_IntegerBased : public ASN1CryptoMaterial<DL_GroupParameters<Integer> >
{ {
@ -113,7 +112,6 @@ private:
Integer m_q; Integer m_q;
}; };
/// \class DL_GroupParameters_IntegerBasedImpl
/// \brief Integer-based GroupParameters default implementation /// \brief Integer-based GroupParameters default implementation
/// \tparam GROUP_PRECOMP group parameters precomputation specialization /// \tparam GROUP_PRECOMP group parameters precomputation specialization
/// \tparam BASE_PRECOMP base class precomputation specialization /// \tparam BASE_PRECOMP base class precomputation specialization
@ -154,7 +152,6 @@ public:
CRYPTOPP_DLL_TEMPLATE_CLASS DL_GroupParameters_IntegerBasedImpl<ModExpPrecomputation>; CRYPTOPP_DLL_TEMPLATE_CLASS DL_GroupParameters_IntegerBasedImpl<ModExpPrecomputation>;
/// \class DL_GroupParameters_GFP
/// \brief GF(p) group parameters /// \brief GF(p) group parameters
class CRYPTOPP_DLL DL_GroupParameters_GFP : public DL_GroupParameters_IntegerBasedImpl<ModExpPrecomputation> class CRYPTOPP_DLL DL_GroupParameters_GFP : public DL_GroupParameters_IntegerBasedImpl<ModExpPrecomputation>
{ {
@ -179,7 +176,6 @@ protected:
int GetFieldType() const {return 1;} int GetFieldType() const {return 1;}
}; };
/// \class DL_GroupParameters_GFP
/// \brief GF(p) group parameters that default to safe primes /// \brief GF(p) group parameters that default to safe primes
class CRYPTOPP_DLL DL_GroupParameters_GFP_DefaultSafePrime : public DL_GroupParameters_GFP class CRYPTOPP_DLL DL_GroupParameters_GFP_DefaultSafePrime : public DL_GroupParameters_GFP
{ {
@ -192,7 +188,6 @@ protected:
unsigned int GetDefaultSubgroupOrderSize(unsigned int modulusSize) const {return modulusSize-1;} unsigned int GetDefaultSubgroupOrderSize(unsigned int modulusSize) const {return modulusSize-1;}
}; };
/// \class DL_Algorithm_GDSA
/// \brief GDSA algorithm /// \brief GDSA algorithm
/// \tparam T FieldElement type or class /// \tparam T FieldElement type or class
template <class T> template <class T>
@ -226,7 +221,6 @@ public:
} }
}; };
/// \class DL_Algorithm_DSA_RFC6979
/// \brief DSA signature algorithm based on RFC 6979 /// \brief DSA signature algorithm based on RFC 6979
/// \tparam T FieldElement type or class /// \tparam T FieldElement type or class
/// \tparam H HashTransformation derived class /// \tparam H HashTransformation derived class
@ -384,7 +378,6 @@ private:
mutable HMAC<H> m_hmac; mutable HMAC<H> m_hmac;
}; };
/// \class DL_Algorithm_GDSA_ISO15946
/// \brief German Digital Signature Algorithm /// \brief German Digital Signature Algorithm
/// \tparam T FieldElement type or class /// \tparam T FieldElement type or class
/// \details The Digital Signature Scheme ECGDSA does not define the algorithm over integers. Rather, the /// \details The Digital Signature Scheme ECGDSA does not define the algorithm over integers. Rather, the
@ -431,7 +424,6 @@ CRYPTOPP_DLL_TEMPLATE_CLASS DL_Algorithm_DSA_RFC6979<Integer, SHA256>;
CRYPTOPP_DLL_TEMPLATE_CLASS DL_Algorithm_DSA_RFC6979<Integer, SHA384>; CRYPTOPP_DLL_TEMPLATE_CLASS DL_Algorithm_DSA_RFC6979<Integer, SHA384>;
CRYPTOPP_DLL_TEMPLATE_CLASS DL_Algorithm_DSA_RFC6979<Integer, SHA512>; CRYPTOPP_DLL_TEMPLATE_CLASS DL_Algorithm_DSA_RFC6979<Integer, SHA512>;
/// \class DL_Algorithm_NR
/// \brief NR algorithm /// \brief NR algorithm
/// \tparam T FieldElement type or class /// \tparam T FieldElement type or class
template <class T> template <class T>
@ -461,7 +453,6 @@ public:
} }
}; };
/// \class DL_PublicKey_GFP
/// \brief Discrete Log (DL) public key in GF(p) groups /// \brief Discrete Log (DL) public key in GF(p) groups
/// \tparam GP GroupParameters derived class /// \tparam GP GroupParameters derived class
/// \details DSA public key format is defined in 7.3.3 of RFC 2459. The private key format is defined in 12.9 of PKCS #11 v2.10. /// \details DSA public key format is defined in 7.3.3 of RFC 2459. The private key format is defined in 12.9 of PKCS #11 v2.10.
@ -499,7 +490,6 @@ public:
{this->GetPublicElement().DEREncode(bt);} {this->GetPublicElement().DEREncode(bt);}
}; };
/// \class DL_PrivateKey_GFP
/// \brief Discrete Log (DL) private key in GF(p) groups /// \brief Discrete Log (DL) private key in GF(p) groups
/// \tparam GP GroupParameters derived class /// \tparam GP GroupParameters derived class
template <class GP> template <class GP>
@ -564,7 +554,6 @@ public:
template <class GP> template <class GP>
DL_PrivateKey_GFP<GP>::~DL_PrivateKey_GFP() {} DL_PrivateKey_GFP<GP>::~DL_PrivateKey_GFP() {}
/// \class DL_SignatureKeys_GFP
/// \brief Discrete Log (DL) signing/verification keys in GF(p) groups /// \brief Discrete Log (DL) signing/verification keys in GF(p) groups
struct DL_SignatureKeys_GFP struct DL_SignatureKeys_GFP
{ {
@ -573,7 +562,6 @@ struct DL_SignatureKeys_GFP
typedef DL_PrivateKey_GFP<GroupParameters> PrivateKey; typedef DL_PrivateKey_GFP<GroupParameters> PrivateKey;
}; };
/// \class DL_CryptoKeys_GFP
/// \brief Discrete Log (DL) encryption/decryption keys in GF(p) groups /// \brief Discrete Log (DL) encryption/decryption keys in GF(p) groups
struct DL_CryptoKeys_GFP struct DL_CryptoKeys_GFP
{ {
@ -582,7 +570,6 @@ struct DL_CryptoKeys_GFP
typedef DL_PrivateKey_GFP<GroupParameters> PrivateKey; typedef DL_PrivateKey_GFP<GroupParameters> PrivateKey;
}; };
/// \class GDSA
/// \brief DSA signature scheme /// \brief DSA signature scheme
/// \tparam H HashTransformation derived class /// \tparam H HashTransformation derived class
/// \sa <a href="http://www.weidai.com/scan-mirror/sig.html#DSA-1363">DSA-1363</a> /// \sa <a href="http://www.weidai.com/scan-mirror/sig.html#DSA-1363">DSA-1363</a>
@ -596,7 +583,6 @@ struct GDSA : public DL_SS<
{ {
}; };
/// \class NR
/// \brief NR signature scheme /// \brief NR signature scheme
/// \tparam H HashTransformation derived class /// \tparam H HashTransformation derived class
/// \sa <a href="http://www.weidai.com/scan-mirror/sig.html#NR">NR</a> /// \sa <a href="http://www.weidai.com/scan-mirror/sig.html#NR">NR</a>
@ -609,7 +595,6 @@ struct NR : public DL_SS<
{ {
}; };
/// \class DL_GroupParameters_DSA
/// \brief DSA group parameters /// \brief DSA group parameters
/// \details These are GF(p) group parameters that are allowed by the DSA standard /// \details These are GF(p) group parameters that are allowed by the DSA standard
/// \sa DL_Keys_DSA /// \sa DL_Keys_DSA
@ -633,7 +618,6 @@ public:
template <class H> template <class H>
class DSA2; class DSA2;
/// \class DL_Keys_DSA
/// \brief DSA keys /// \brief DSA keys
/// \sa DL_GroupParameters_DSA /// \sa DL_GroupParameters_DSA
struct DL_Keys_DSA struct DL_Keys_DSA
@ -642,7 +626,6 @@ struct DL_Keys_DSA
typedef DL_PrivateKey_WithSignaturePairwiseConsistencyTest<DL_PrivateKey_GFP<DL_GroupParameters_DSA>, DSA2<SHA1> > PrivateKey; typedef DL_PrivateKey_WithSignaturePairwiseConsistencyTest<DL_PrivateKey_GFP<DL_GroupParameters_DSA>, DSA2<SHA1> > PrivateKey;
}; };
/// \class DSA2
/// \brief DSA signature scheme /// \brief DSA signature scheme
/// \tparam H HashTransformation derived class /// \tparam H HashTransformation derived class
/// \details The class is named DSA2 instead of DSA for backwards compatibility because DSA was a non-template class. /// \details The class is named DSA2 instead of DSA for backwards compatibility because DSA was a non-template class.
@ -660,7 +643,6 @@ public:
static std::string CRYPTOPP_API StaticAlgorithmName() {return "DSA/" + (std::string)H::StaticAlgorithmName();} static std::string CRYPTOPP_API StaticAlgorithmName() {return "DSA/" + (std::string)H::StaticAlgorithmName();}
}; };
/// \class DSA_RFC6979
/// \brief DSA deterministic signature scheme /// \brief DSA deterministic signature scheme
/// \tparam H HashTransformation derived class /// \tparam H HashTransformation derived class
/// \sa <a href="http://www.weidai.com/scan-mirror/sig.html#DSA-1363">DSA-1363</a> /// \sa <a href="http://www.weidai.com/scan-mirror/sig.html#DSA-1363">DSA-1363</a>
@ -683,7 +665,6 @@ CRYPTOPP_DLL_TEMPLATE_CLASS DL_PublicKey_GFP<DL_GroupParameters_DSA>;
CRYPTOPP_DLL_TEMPLATE_CLASS DL_PrivateKey_GFP<DL_GroupParameters_DSA>; CRYPTOPP_DLL_TEMPLATE_CLASS DL_PrivateKey_GFP<DL_GroupParameters_DSA>;
CRYPTOPP_DLL_TEMPLATE_CLASS DL_PrivateKey_WithSignaturePairwiseConsistencyTest<DL_PrivateKey_GFP<DL_GroupParameters_DSA>, DSA2<SHA1> >; CRYPTOPP_DLL_TEMPLATE_CLASS DL_PrivateKey_WithSignaturePairwiseConsistencyTest<DL_PrivateKey_GFP<DL_GroupParameters_DSA>, DSA2<SHA1> >;
/// \class DL_EncryptionAlgorithm_Xor
/// \brief P1363 based XOR Encryption Method /// \brief P1363 based XOR Encryption Method
/// \tparam MAC MessageAuthenticationCode derived class used for MAC computation /// \tparam MAC MessageAuthenticationCode derived class used for MAC computation
/// \tparam DHAES_MODE flag indicating DHAES mode /// \tparam DHAES_MODE flag indicating DHAES mode
@ -808,7 +789,6 @@ public:
} }
}; };
/// \class DLIES
/// \brief Discrete Log Integrated Encryption Scheme /// \brief Discrete Log Integrated Encryption Scheme
/// \tparam COFACTOR_OPTION cofactor multiplication option /// \tparam COFACTOR_OPTION cofactor multiplication option
/// \tparam HASH HashTransformation derived class used for key drivation and MAC computation /// \tparam HASH HashTransformation derived class used for key drivation and MAC computation

5
gost.h
View File

@ -11,19 +11,16 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class GOST_Info
/// \brief GOST block cipher information /// \brief GOST block cipher information
struct GOST_Info : public FixedBlockSize<8>, public FixedKeyLength<32> struct GOST_Info : public FixedBlockSize<8>, public FixedKeyLength<32>
{ {
CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "GOST";} CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "GOST";}
}; };
/// \class GOST
/// \brief GOST block cipher /// \brief GOST block cipher
/// \sa <a href="http://www.cryptopp.com/wiki/GOST">GOST</a> /// \sa <a href="http://www.cryptopp.com/wiki/GOST">GOST</a>
class GOST : public GOST_Info, public BlockCipherDocumentation class GOST : public GOST_Info, public BlockCipherDocumentation
{ {
/// \class Base
/// \brief GOST block cipher default operation /// \brief GOST block cipher default operation
class CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<GOST_Info> class CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<GOST_Info>
{ {
@ -40,7 +37,6 @@ class GOST : public GOST_Info, public BlockCipherDocumentation
FixedSizeSecBlock<word32, 8> m_key; FixedSizeSecBlock<word32, 8> m_key;
}; };
/// \class Enc
/// \brief GOST block cipher encryption operation /// \brief GOST block cipher encryption operation
class CRYPTOPP_NO_VTABLE Enc : public Base class CRYPTOPP_NO_VTABLE Enc : public Base
{ {
@ -48,7 +44,6 @@ class GOST : public GOST_Info, public BlockCipherDocumentation
void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const; void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
}; };
/// \class Dec
/// \brief GOST block cipher decryption operation /// \brief GOST block cipher decryption operation
class CRYPTOPP_NO_VTABLE Dec : public Base class CRYPTOPP_NO_VTABLE Dec : public Base
{ {

6
gzip.h
View File

@ -13,7 +13,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class Gzip
/// \brief GZIP Compression (RFC 1952) /// \brief GZIP Compression (RFC 1952)
class Gzip : public Deflator class Gzip : public Deflator
{ {
@ -77,23 +76,18 @@ protected:
std::string m_comment; std::string m_comment;
}; };
/// \class Gunzip
/// \brief GZIP Decompression (RFC 1952) /// \brief GZIP Decompression (RFC 1952)
class Gunzip : public Inflator class Gunzip : public Inflator
{ {
public: public:
typedef Inflator::Err Err; typedef Inflator::Err Err;
/// \class HeaderErr
/// \brief Exception thrown when a header decoding error occurs /// \brief Exception thrown when a header decoding error occurs
class HeaderErr : public Err {public: HeaderErr() : Err(INVALID_DATA_FORMAT, "Gunzip: header decoding error") {}}; class HeaderErr : public Err {public: HeaderErr() : Err(INVALID_DATA_FORMAT, "Gunzip: header decoding error") {}};
/// \class TailErr
/// \brief Exception thrown when the tail is too short /// \brief Exception thrown when the tail is too short
class TailErr : public Err {public: TailErr() : Err(INVALID_DATA_FORMAT, "Gunzip: tail too short") {}}; class TailErr : public Err {public: TailErr() : Err(INVALID_DATA_FORMAT, "Gunzip: tail too short") {}};
/// \class CrcErr
/// \brief Exception thrown when a CRC error occurs /// \brief Exception thrown when a CRC error occurs
class CrcErr : public Err {public: CrcErr() : Err(DATA_INTEGRITY_CHECK_FAILED, "Gunzip: CRC check error") {}}; class CrcErr : public Err {public: CrcErr() : Err(DATA_INTEGRITY_CHECK_FAILED, "Gunzip: CRC check error") {}};
/// \class LengthErr
/// \brief Exception thrown when a length error occurs /// \brief Exception thrown when a length error occurs
class LengthErr : public Err {public: LengthErr() : Err(DATA_INTEGRITY_CHECK_FAILED, "Gunzip: length check error") {}}; class LengthErr : public Err {public: LengthErr() : Err(DATA_INTEGRITY_CHECK_FAILED, "Gunzip: length check error") {}};

2
hex.h
View File

@ -11,7 +11,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class HexEncoder
/// \brief Converts given data to base 16 /// \brief Converts given data to base 16
class CRYPTOPP_DLL HexEncoder : public SimpleProxyFilter class CRYPTOPP_DLL HexEncoder : public SimpleProxyFilter
{ {
@ -31,7 +30,6 @@ public:
void IsolatedInitialize(const NameValuePairs &parameters); void IsolatedInitialize(const NameValuePairs &parameters);
}; };
/// \class HexDecoder
/// \brief Decode base 16 data back to bytes /// \brief Decode base 16 data back to bytes
class CRYPTOPP_DLL HexDecoder : public BaseN_Decoder class CRYPTOPP_DLL HexDecoder : public BaseN_Decoder
{ {

2
hmac.h
View File

@ -11,7 +11,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class HMAC_Base
/// \brief HMAC information /// \brief HMAC information
/// \details HMAC_Base derives from VariableKeyLength and MessageAuthenticationCode /// \details HMAC_Base derives from VariableKeyLength and MessageAuthenticationCode
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE HMAC_Base : public VariableKeyLength<16, 0, INT_MAX>, public MessageAuthenticationCode class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE HMAC_Base : public VariableKeyLength<16, 0, INT_MAX>, public MessageAuthenticationCode
@ -40,7 +39,6 @@ private:
bool m_innerHashKeyed; bool m_innerHashKeyed;
}; };
/// \class HMAC
/// \brief HMAC /// \brief HMAC
/// \tparam T HashTransformation derived class /// \tparam T HashTransformation derived class
/// \details HMAC derives from MessageAuthenticationCodeImpl. It calculates the HMAC using /// \details HMAC derives from MessageAuthenticationCodeImpl. It calculates the HMAC using

2
hrtimer.h
View File

@ -15,7 +15,6 @@ NAMESPACE_BEGIN(CryptoPP)
typedef clock_t TimerWord; typedef clock_t TimerWord;
#endif #endif
/// \class TimerBase
/// \brief Base class for timers /// \brief Base class for timers
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TimerBase class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TimerBase
{ {
@ -40,7 +39,6 @@ private:
TimerWord m_start, m_last; TimerWord m_start, m_last;
}; };
/// \class ThreadUserTimer
/// \brief Measure CPU time spent executing instructions of this thread (if supported by OS) /// \brief Measure CPU time spent executing instructions of this thread (if supported by OS)
/// \note ThreadUserTimer only works correctly on Windows NT or later desktops and servers. /// \note ThreadUserTimer only works correctly on Windows NT or later desktops and servers.
/// On Unix-based it reports process time. On Windows Phone and Windows Store it reports wall /// On Unix-based it reports process time. On Windows Phone and Windows Store it reports wall

5
ida.h
View File

@ -16,7 +16,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class RawIDA
/// \brief Secret sharing and information dispersal base class /// \brief Secret sharing and information dispersal base class
/// \since Crypto++ 1.0 /// \since Crypto++ 1.0
class RawIDA : public AutoSignaling<Unflushable<Multichannel<Filter> > > class RawIDA : public AutoSignaling<Unflushable<Multichannel<Filter> > >
@ -63,7 +62,6 @@ protected:
SecBlock<word32> m_u, m_w, m_y; SecBlock<word32> m_u, m_w, m_y;
}; };
/// \class SecretSharing
/// \brief Shamir's Secret Sharing Algorithm /// \brief Shamir's Secret Sharing Algorithm
/// \details SecretSharing is a variant of Shamir's secret sharing algorithm /// \details SecretSharing is a variant of Shamir's secret sharing algorithm
/// \sa SecretRecovery, SecretRecovery, InformationDispersal, InformationRecovery /// \sa SecretRecovery, SecretRecovery, InformationDispersal, InformationRecovery
@ -89,7 +87,6 @@ protected:
bool m_pad; bool m_pad;
}; };
/// \class SecretRecovery
/// \brief Shamir's Secret Sharing Algorithm /// \brief Shamir's Secret Sharing Algorithm
/// \details SecretSharing is a variant of Shamir's secret sharing algorithm /// \details SecretSharing is a variant of Shamir's secret sharing algorithm
/// \sa SecretRecovery, SecretRecovery, InformationDispersal, InformationRecovery /// \sa SecretRecovery, SecretRecovery, InformationDispersal, InformationRecovery
@ -113,7 +110,6 @@ protected:
/// a variant of Rabin's Information Dispersal Algorithm /// a variant of Rabin's Information Dispersal Algorithm
/// \class InformationDispersal
/// \brief Rabin's Information Dispersal Algorithm /// \brief Rabin's Information Dispersal Algorithm
/// \details InformationDispersal is a variant of Rabin's information dispersal algorithm /// \details InformationDispersal is a variant of Rabin's information dispersal algorithm
/// \sa SecretRecovery, SecretRecovery, InformationDispersal, InformationRecovery /// \sa SecretRecovery, SecretRecovery, InformationDispersal, InformationRecovery
@ -139,7 +135,6 @@ protected:
unsigned int m_nextChannel; unsigned int m_nextChannel;
}; };
/// \class InformationRecovery
/// \brief Rabin's Information Dispersal Algorithm /// \brief Rabin's Information Dispersal Algorithm
/// \details InformationDispersal is a variant of Rabin's information dispersal algorithm /// \details InformationDispersal is a variant of Rabin's information dispersal algorithm
/// \sa SecretRecovery, SecretRecovery, InformationDispersal, InformationRecovery /// \sa SecretRecovery, SecretRecovery, InformationDispersal, InformationRecovery

2
idea.h
View File

@ -11,7 +11,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class IDEA_Info
/// \brief IDEA block cipher information /// \brief IDEA block cipher information
/// \since Crypto++ 1.0 /// \since Crypto++ 1.0
struct IDEA_Info : public FixedBlockSize<8>, public FixedKeyLength<16>, public FixedRounds<8> struct IDEA_Info : public FixedBlockSize<8>, public FixedKeyLength<16>, public FixedRounds<8>
@ -19,7 +18,6 @@ struct IDEA_Info : public FixedBlockSize<8>, public FixedKeyLength<16>, public F
CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "IDEA";} CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "IDEA";}
}; };
/// \class IDEA
/// \brief IDEA block cipher /// \brief IDEA block cipher
/// \sa <a href="http://www.cryptopp.com/wiki/IDEA">IDEA</a> /// \sa <a href="http://www.cryptopp.com/wiki/IDEA">IDEA</a>
/// \since Crypto++ 1.0 /// \since Crypto++ 1.0

4
iterhash.h
View File

@ -18,7 +18,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class HashInputTooLong
/// \brief Exception thrown when trying to hash more data than is allowed by a hash function /// \brief Exception thrown when trying to hash more data than is allowed by a hash function
class CRYPTOPP_DLL HashInputTooLong : public InvalidDataFormat class CRYPTOPP_DLL HashInputTooLong : public InvalidDataFormat
{ {
@ -27,7 +26,6 @@ public:
: InvalidDataFormat("IteratedHashBase: input data exceeds maximum allowed by hash function " + alg) {} : InvalidDataFormat("IteratedHashBase: input data exceeds maximum allowed by hash function " + alg) {}
}; };
/// \class IteratedHashBase
/// \brief Iterated hash base class /// \brief Iterated hash base class
/// \tparam T Hash word type /// \tparam T Hash word type
/// \tparam BASE HashTransformation derived class /// \tparam BASE HashTransformation derived class
@ -99,7 +97,6 @@ private:
T m_countLo, m_countHi; T m_countLo, m_countHi;
}; };
/// \class IteratedHash
/// \brief Iterated hash base class /// \brief Iterated hash base class
/// \tparam T_HashWordType Hash word type /// \tparam T_HashWordType Hash word type
/// \tparam T_Endianness Endianness type of hash /// \tparam T_Endianness Endianness type of hash
@ -146,7 +143,6 @@ protected:
FixedSizeSecBlock<T_HashWordType, T_BlockSize/sizeof(T_HashWordType)> m_data; FixedSizeSecBlock<T_HashWordType, T_BlockSize/sizeof(T_HashWordType)> m_data;
}; };
/// \class IteratedHashWithStaticTransform
/// \brief Iterated hash with a static transformation function /// \brief Iterated hash with a static transformation function
/// \tparam T_HashWordType Hash word type /// \tparam T_HashWordType Hash word type
/// \tparam T_Endianness Endianness type of hash /// \tparam T_Endianness Endianness type of hash

4
kalyna.h
View File

@ -20,7 +20,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class Kalyna128_Info
/// \brief Kalyna-128 block cipher information /// \brief Kalyna-128 block cipher information
/// \since Crypto++ 6.0 /// \since Crypto++ 6.0
struct CRYPTOPP_NO_VTABLE Kalyna128_Info : public FixedBlockSize<16>, VariableKeyLength<16, 16, 32> struct CRYPTOPP_NO_VTABLE Kalyna128_Info : public FixedBlockSize<16>, VariableKeyLength<16, 16, 32>
@ -32,7 +31,6 @@ struct CRYPTOPP_NO_VTABLE Kalyna128_Info : public FixedBlockSize<16>, VariableKe
} }
}; };
/// \class Kalyna256_Info
/// \brief Kalyna-256 block cipher information /// \brief Kalyna-256 block cipher information
/// \since Crypto++ 6.0 /// \since Crypto++ 6.0
struct CRYPTOPP_NO_VTABLE Kalyna256_Info : public FixedBlockSize<32>, VariableKeyLength<32, 32, 64> struct CRYPTOPP_NO_VTABLE Kalyna256_Info : public FixedBlockSize<32>, VariableKeyLength<32, 32, 64>
@ -44,7 +42,6 @@ struct CRYPTOPP_NO_VTABLE Kalyna256_Info : public FixedBlockSize<32>, VariableKe
} }
}; };
/// \class Kalyna512_Info
/// \brief Kalyna-512 block cipher information /// \brief Kalyna-512 block cipher information
/// \since Crypto++ 6.0 /// \since Crypto++ 6.0
struct CRYPTOPP_NO_VTABLE Kalyna512_Info : public FixedBlockSize<64>, FixedKeyLength<64> struct CRYPTOPP_NO_VTABLE Kalyna512_Info : public FixedBlockSize<64>, FixedKeyLength<64>
@ -56,7 +53,6 @@ struct CRYPTOPP_NO_VTABLE Kalyna512_Info : public FixedBlockSize<64>, FixedKeyLe
} }
}; };
/// \class Kalyna
/// \brief Kalyna block cipher /// \brief Kalyna block cipher
/// \since Crypto++ 6.0 /// \since Crypto++ 6.0
class CRYPTOPP_NO_VTABLE Kalyna_Base class CRYPTOPP_NO_VTABLE Kalyna_Base

2
keccak.h
View File

@ -17,7 +17,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class Keccak
/// \brief Keccak message digest base class /// \brief Keccak message digest base class
/// \details The Crypto++ Keccak implementation uses F1600 with XOF d=0x01. /// \details The Crypto++ Keccak implementation uses F1600 with XOF d=0x01.
/// FIPS 202 conformance (XOF d=0x06) is available in SHA3 classes. /// FIPS 202 conformance (XOF d=0x06) is available in SHA3 classes.
@ -66,7 +65,6 @@ protected:
unsigned int m_digestSize, m_counter; unsigned int m_digestSize, m_counter;
}; };
/// \class Keccak_Final
/// \brief Keccak message digest template /// \brief Keccak message digest template
/// \tparam T_DigestSize the size of the digest, in bytes /// \tparam T_DigestSize the size of the digest, in bytes
/// \since Crypto++ 6.0 /// \since Crypto++ 6.0

2
lubyrack.h
View File

@ -11,7 +11,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class LR_Info
/// \brief Luby-Rackoff block cipher information /// \brief Luby-Rackoff block cipher information
template <class T> template <class T>
struct LR_Info : public VariableKeyLength<16, 0, 2*(INT_MAX/2), 2>, public FixedBlockSize<2*T::DIGESTSIZE> struct LR_Info : public VariableKeyLength<16, 0, 2*(INT_MAX/2), 2>, public FixedBlockSize<2*T::DIGESTSIZE>
@ -19,7 +18,6 @@ struct LR_Info : public VariableKeyLength<16, 0, 2*(INT_MAX/2), 2>, public Fixed
static std::string StaticAlgorithmName() {return std::string("LR/")+T::StaticAlgorithmName();} static std::string StaticAlgorithmName() {return std::string("LR/")+T::StaticAlgorithmName();}
}; };
/// \class LR
/// \brief Luby-Rackoff block cipher /// \brief Luby-Rackoff block cipher
template <class T> template <class T>
class LR : public LR_Info<T>, public BlockCipherDocumentation class LR : public LR_Info<T>, public BlockCipherDocumentation

4
luc.h
View File

@ -209,7 +209,6 @@ private:
Integer m_g; Integer m_g;
}; };
/// \class DL_GroupParameters_LUC
/// \brief LUC GroupParameters specialization /// \brief LUC GroupParameters specialization
class DL_GroupParameters_LUC : public DL_GroupParameters_IntegerBasedImpl<DL_GroupPrecomputation_LUC, DL_BasePrecomputation_LUC> class DL_GroupParameters_LUC : public DL_GroupParameters_IntegerBasedImpl<DL_GroupPrecomputation_LUC, DL_BasePrecomputation_LUC>
{ {
@ -240,7 +239,6 @@ private:
int GetFieldType() const {return 2;} int GetFieldType() const {return 2;}
}; };
/// \class DL_GroupParameters_LUC_DefaultSafePrime
/// \brief GF(p) group parameters that default to safe primes /// \brief GF(p) group parameters that default to safe primes
class DL_GroupParameters_LUC_DefaultSafePrime : public DL_GroupParameters_LUC class DL_GroupParameters_LUC_DefaultSafePrime : public DL_GroupParameters_LUC
{ {
@ -251,7 +249,6 @@ protected:
unsigned int GetDefaultSubgroupOrderSize(unsigned int modulusSize) const {return modulusSize-1;} unsigned int GetDefaultSubgroupOrderSize(unsigned int modulusSize) const {return modulusSize-1;}
}; };
/// \class DL_Algorithm_LUC_HMP
/// \brief LUC HMP signature algorithm /// \brief LUC HMP signature algorithm
class DL_Algorithm_LUC_HMP : public DL_ElgamalLikeSignatureAlgorithm<Integer> class DL_Algorithm_LUC_HMP : public DL_ElgamalLikeSignatureAlgorithm<Integer>
{ {
@ -293,7 +290,6 @@ struct DL_CryptoKeys_LUC
typedef DL_PrivateKey_GFP<GroupParameters> PrivateKey; typedef DL_PrivateKey_GFP<GroupParameters> PrivateKey;
}; };
/// \class LUC_IES
/// \brief LUC Integrated Encryption Scheme /// \brief LUC Integrated Encryption Scheme
/// \tparam COFACTOR_OPTION cofactor multiplication option /// \tparam COFACTOR_OPTION cofactor multiplication option
/// \tparam HASH HashTransformation derived class used for key drivation and MAC computation /// \tparam HASH HashTransformation derived class used for key drivation and MAC computation

2
mars.h
View File

@ -11,14 +11,12 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class MARS_Info
/// \brief MARS block cipher information /// \brief MARS block cipher information
struct MARS_Info : public FixedBlockSize<16>, public VariableKeyLength<16, 16, 56, 8> struct MARS_Info : public FixedBlockSize<16>, public VariableKeyLength<16, 16, 56, 8>
{ {
CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "MARS";} CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "MARS";}
}; };
/// \class MARS
/// \brief MARS block cipher /// \brief MARS block cipher
/// \sa <a href="http://www.cryptopp.com/wiki/MARS">MARS</a> /// \sa <a href="http://www.cryptopp.com/wiki/MARS">MARS</a>
class MARS : public MARS_Info, public BlockCipherDocumentation class MARS : public MARS_Info, public BlockCipherDocumentation

1
md5.h
View File

@ -7,7 +7,6 @@ NAMESPACE_BEGIN(CryptoPP)
namespace Weak1 { namespace Weak1 {
/// \class MD5
/// \brief MD5 message digest /// \brief MD5 message digest
/// \sa <a href="http://www.cryptolounge.org/wiki/MD5">MD5</a> /// \sa <a href="http://www.cryptolounge.org/wiki/MD5">MD5</a>
/// \since Crypto++ 1.0 /// \since Crypto++ 1.0

2
mdc.h
View File

@ -12,7 +12,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class MDC_Info
/// \tparam B BlockCipher derived class /// \tparam B BlockCipher derived class
/// \brief MDC_Info cipher information /// \brief MDC_Info cipher information
template <class B> template <class B>
@ -28,7 +27,6 @@ struct MDC_Info : public FixedBlockSize<B::DIGESTSIZE>, public FixedKeyLength<B:
template <class H> template <class H>
class MDC : public MDC_Info<H> class MDC : public MDC_Info<H>
{ {
/// \class Enc
/// \brief MDC cipher encryption operation /// \brief MDC cipher encryption operation
class CRYPTOPP_NO_VTABLE Enc : public BlockCipherImpl<MDC_Info<H> > class CRYPTOPP_NO_VTABLE Enc : public BlockCipherImpl<MDC_Info<H> >
{ {

3
mersenne.h
View File

@ -14,7 +14,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class MersenneTwister
/// \brief Mersenne Twister class for Monte-Carlo simulations /// \brief Mersenne Twister class for Monte-Carlo simulations
/// \tparam K Magic constant /// \tparam K Magic constant
/// \tparam M Period parameter /// \tparam M Period parameter
@ -200,7 +199,6 @@ private:
word32 m_idx; word32 m_idx;
}; };
/// \class MT19937
/// \brief Original MT19937 generator provided in the ACM paper. /// \brief Original MT19937 generator provided in the ACM paper.
/// \details MT19937 uses 4537 as default initial seed. /// \details MT19937 uses 4537 as default initial seed.
/// \sa MT19937ar, <A HREF="http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/ARTICLES/mt.pdf">Mersenne twister: /// \sa MT19937ar, <A HREF="http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/ARTICLES/mt.pdf">Mersenne twister:
@ -212,7 +210,6 @@ class MT19937 : public MersenneTwister<0x9908B0DF /*2567483615*/, 397, 624, 0x10
typedef MersenneTwister<0x9908B0DF /*2567483615*/, 397, 624, 0x10DCD /*69069*/, 4537> MT19937; typedef MersenneTwister<0x9908B0DF /*2567483615*/, 397, 624, 0x10DCD /*69069*/, 4537> MT19937;
#endif #endif
/// \class MT19937ar
/// \brief Updated MT19937 generator adapted to provide an array for initialization. /// \brief Updated MT19937 generator adapted to provide an array for initialization.
/// \details MT19937 uses 5489 as default initial seed. Use this generator when interoperating with C++11's /// \details MT19937 uses 5489 as default initial seed. Use this generator when interoperating with C++11's
/// mt19937 class. /// mt19937 class.

9
misc.h
View File

@ -210,7 +210,6 @@ class CRYPTOPP_NO_VTABLE ThreeBases : public BASE1, public BASE2, public BASE3
}; };
#endif // CRYPTOPP_DOXYGEN_PROCESSING #endif // CRYPTOPP_DOXYGEN_PROCESSING
/// \class ObjectHolder
/// \tparam T class or type /// \tparam T class or type
/// \brief Uses encapsulation to hide an object in derived classes /// \brief Uses encapsulation to hide an object in derived classes
/// \details The object T is declared as protected. /// \details The object T is declared as protected.
@ -221,7 +220,6 @@ protected:
T m_object; T m_object;
}; };
/// \class NotCopyable
/// \brief Ensures an object is not copyable /// \brief Ensures an object is not copyable
/// \details NotCopyable ensures an object is not copyable by making the /// \details NotCopyable ensures an object is not copyable by making the
/// copy constructor and assignment operator private. Deleters are not /// copy constructor and assignment operator private. Deleters are not
@ -236,7 +234,6 @@ private:
void operator=(const NotCopyable &); void operator=(const NotCopyable &);
}; };
/// \class NewObject
/// \brief An object factory function /// \brief An object factory function
/// \tparam T class or type /// \tparam T class or type
/// \details NewObject overloads operator()(). /// \details NewObject overloads operator()().
@ -2303,7 +2300,6 @@ inline void PutWord(bool assumeAligned, ByteOrder order, byte *block, T value, c
#endif #endif
} }
/// \class GetBlock
/// \brief Access a block of memory /// \brief Access a block of memory
/// \tparam T class or type /// \tparam T class or type
/// \tparam B enumeration indicating endianness /// \tparam B enumeration indicating endianness
@ -2345,7 +2341,6 @@ private:
const byte *m_block; const byte *m_block;
}; };
/// \class PutBlock
/// \brief Access a block of memory /// \brief Access a block of memory
/// \tparam T class or type /// \tparam T class or type
/// \tparam B enumeration indicating endianness /// \tparam B enumeration indicating endianness
@ -2390,7 +2385,6 @@ private:
byte *m_block; byte *m_block;
}; };
/// \class BlockGetAndPut
/// \brief Access a block of memory /// \brief Access a block of memory
/// \tparam T class or type /// \tparam T class or type
/// \tparam B enumeration indicating endianness /// \tparam B enumeration indicating endianness
@ -2436,7 +2430,6 @@ T StringToWord(const std::string &str, ByteOrder order = BIG_ENDIAN_ORDER)
// ************** help remove warning on g++ *************** // ************** help remove warning on g++ ***************
/// \class SafeShifter
/// \brief Safely shift values when undefined behavior could occur /// \brief Safely shift values when undefined behavior could occur
/// \tparam overflow boolean flag indicating if overflow is present /// \tparam overflow boolean flag indicating if overflow is present
/// \details SafeShifter safely shifts values when undefined behavior could occur under C/C++ rules. /// \details SafeShifter safely shifts values when undefined behavior could occur under C/C++ rules.
@ -2445,7 +2438,6 @@ T StringToWord(const std::string &str, ByteOrder order = BIG_ENDIAN_ORDER)
/// \sa SafeShifter<true>, SafeShifter<false> /// \sa SafeShifter<true>, SafeShifter<false>
template <bool overflow> struct SafeShifter; template <bool overflow> struct SafeShifter;
/// \class SafeShifter<true>
/// \brief Shifts a value in the presence of overflow /// \brief Shifts a value in the presence of overflow
/// \details the true template parameter indicates overflow would occur. /// \details the true template parameter indicates overflow would occur.
/// In this case, SafeShifter clamps the value and returns 0. /// In this case, SafeShifter clamps the value and returns 0.
@ -2476,7 +2468,6 @@ template<> struct SafeShifter<true>
} }
}; };
/// \class SafeShifter<false>
/// \brief Shifts a value in the absence of overflow /// \brief Shifts a value in the absence of overflow
/// \details the false template parameter indicates overflow would not occur. /// \details the false template parameter indicates overflow would not occur.
/// In this case, SafeShifter returns the shfted value. /// In this case, SafeShifter returns the shfted value.

2
modarith.h
View File

@ -25,7 +25,6 @@ CRYPTOPP_DLL_TEMPLATE_CLASS AbstractGroup<Integer>;
CRYPTOPP_DLL_TEMPLATE_CLASS AbstractRing<Integer>; CRYPTOPP_DLL_TEMPLATE_CLASS AbstractRing<Integer>;
CRYPTOPP_DLL_TEMPLATE_CLASS AbstractEuclideanDomain<Integer>; CRYPTOPP_DLL_TEMPLATE_CLASS AbstractEuclideanDomain<Integer>;
/// \class ModularArithmetic
/// \brief Ring of congruence classes modulo n /// \brief Ring of congruence classes modulo n
/// \details This implementation represents each congruence class as the smallest /// \details This implementation represents each congruence class as the smallest
/// non-negative integer in that class. /// non-negative integer in that class.
@ -263,7 +262,6 @@ protected:
// const ModularArithmetic::RandomizationParameter ModularArithmetic::DefaultRandomizationParameter = 0 ; // const ModularArithmetic::RandomizationParameter ModularArithmetic::DefaultRandomizationParameter = 0 ;
/// \class MontgomeryRepresentation
/// \brief Performs modular arithmetic in Montgomery representation for increased speed /// \brief Performs modular arithmetic in Montgomery representation for increased speed
/// \details The Montgomery representation represents each congruence class <tt>[a]</tt> as /// \details The Montgomery representation represents each congruence class <tt>[a]</tt> as
/// <tt>a*r\%n</tt>, where <tt>r</tt> is a convenient power of 2. /// <tt>a*r\%n</tt>, where <tt>r</tt> is a convenient power of 2.

29
modes.h
View File

@ -30,7 +30,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class CipherModeDocumentation
/// \brief Block cipher mode of operation information /// \brief Block cipher mode of operation information
/// \details Each class derived from this one defines two types, Encryption and Decryption, /// \details Each class derived from this one defines two types, Encryption and Decryption,
/// both of which implement the SymmetricCipher interface. /// both of which implement the SymmetricCipher interface.
@ -46,7 +45,6 @@ struct CipherModeDocumentation : public SymmetricCipherDocumentation
{ {
}; };
/// \class CipherModeBase
/// \brief Block cipher mode of operation information /// \brief Block cipher mode of operation information
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CipherModeBase : public SymmetricCipher class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CipherModeBase : public SymmetricCipher
{ {
@ -95,7 +93,6 @@ protected:
AlignedSecByteBlock m_register; AlignedSecByteBlock m_register;
}; };
/// \class ModePolicyCommonTemplate
/// \brief Block cipher mode of operation common operations /// \brief Block cipher mode of operation common operations
/// \tparam POLICY_INTERFACE common operations /// \tparam POLICY_INTERFACE common operations
template <class POLICY_INTERFACE> template <class POLICY_INTERFACE>
@ -114,7 +111,6 @@ void ModePolicyCommonTemplate<POLICY_INTERFACE>::CipherSetKey(const NameValuePai
SetFeedbackSize(feedbackSize); SetFeedbackSize(feedbackSize);
} }
/// \class CFB_ModePolicy
/// \brief CFB block cipher mode of operation /// \brief CFB block cipher mode of operation
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CFB_ModePolicy : public ModePolicyCommonTemplate<CFB_CipherAbstractPolicy> class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CFB_ModePolicy : public ModePolicyCommonTemplate<CFB_CipherAbstractPolicy>
{ {
@ -149,7 +145,6 @@ inline void CopyOrZero(void *dest, size_t d, const void *src, size_t s)
memset(dest, 0, d); memset(dest, 0, d);
} }
/// \class OFB_ModePolicy
/// \brief OFB block cipher mode of operation /// \brief OFB block cipher mode of operation
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE OFB_ModePolicy : public ModePolicyCommonTemplate<AdditiveCipherAbstractPolicy> class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE OFB_ModePolicy : public ModePolicyCommonTemplate<AdditiveCipherAbstractPolicy>
{ {
@ -166,7 +161,6 @@ private:
void CipherResynchronize(byte *keystreamBuffer, const byte *iv, size_t length); void CipherResynchronize(byte *keystreamBuffer, const byte *iv, size_t length);
}; };
/// \class CTR_ModePolicy
/// \brief CTR block cipher mode of operation /// \brief CTR block cipher mode of operation
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CTR_ModePolicy : public ModePolicyCommonTemplate<AdditiveCipherAbstractPolicy> class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CTR_ModePolicy : public ModePolicyCommonTemplate<AdditiveCipherAbstractPolicy>
{ {
@ -192,7 +186,6 @@ protected:
AlignedSecByteBlock m_counterArray; AlignedSecByteBlock m_counterArray;
}; };
/// \class BlockOrientedCipherModeBase
/// \brief Block cipher mode of operation default implementation /// \brief Block cipher mode of operation default implementation
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE BlockOrientedCipherModeBase : public CipherModeBase class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE BlockOrientedCipherModeBase : public CipherModeBase
{ {
@ -212,7 +205,6 @@ protected:
SecByteBlock m_buffer; SecByteBlock m_buffer;
}; };
/// \class ECB_OneWay
/// \brief ECB block cipher mode of operation default implementation /// \brief ECB block cipher mode of operation default implementation
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE ECB_OneWay : public BlockOrientedCipherModeBase class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE ECB_OneWay : public BlockOrientedCipherModeBase
{ {
@ -226,7 +218,6 @@ public:
void ProcessData(byte *outString, const byte *inString, size_t length); void ProcessData(byte *outString, const byte *inString, size_t length);
}; };
/// \class CBC_ModeBase
/// \brief CBC block cipher mode of operation default implementation /// \brief CBC block cipher mode of operation default implementation
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CBC_ModeBase : public BlockOrientedCipherModeBase class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CBC_ModeBase : public BlockOrientedCipherModeBase
{ {
@ -238,7 +229,6 @@ public:
unsigned int MinLastBlockSize() const {return 0;} unsigned int MinLastBlockSize() const {return 0;}
}; };
/// \class CBC_Encryption
/// \brief CBC block cipher mode of operation encryption operation /// \brief CBC block cipher mode of operation encryption operation
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CBC_Encryption : public CBC_ModeBase class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CBC_Encryption : public CBC_ModeBase
{ {
@ -246,7 +236,6 @@ public:
void ProcessData(byte *outString, const byte *inString, size_t length); void ProcessData(byte *outString, const byte *inString, size_t length);
}; };
/// \class CBC_CTS_Encryption
/// \brief CBC-CTS block cipher mode of operation encryption operation /// \brief CBC-CTS block cipher mode of operation encryption operation
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CBC_CTS_Encryption : public CBC_Encryption class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CBC_CTS_Encryption : public CBC_Encryption
{ {
@ -267,7 +256,6 @@ protected:
byte *m_stolenIV; byte *m_stolenIV;
}; };
/// \class CBC_Decryption
/// \brief CBC block cipher mode of operation decryption operation /// \brief CBC block cipher mode of operation decryption operation
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CBC_Decryption : public CBC_ModeBase class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CBC_Decryption : public CBC_ModeBase
{ {
@ -281,7 +269,6 @@ protected:
AlignedSecByteBlock m_temp; AlignedSecByteBlock m_temp;
}; };
/// \class CBC_CTS_Decryption
/// \brief CBC-CTS block cipher mode of operation decryption operation /// \brief CBC-CTS block cipher mode of operation decryption operation
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CBC_CTS_Decryption : public CBC_Decryption class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CBC_CTS_Decryption : public CBC_Decryption
{ {
@ -290,7 +277,6 @@ public:
size_t ProcessLastBlock(byte *outString, size_t outLength, const byte *inString, size_t inLength); size_t ProcessLastBlock(byte *outString, size_t outLength, const byte *inString, size_t inLength);
}; };
/// \class CipherModeFinalTemplate_CipherHolder
/// \brief Block cipher mode of operation aggregate /// \brief Block cipher mode of operation aggregate
template <class CIPHER, class BASE> template <class CIPHER, class BASE>
class CipherModeFinalTemplate_CipherHolder : protected ObjectHolder<CIPHER>, public AlgorithmImpl<BASE, CipherModeFinalTemplate_CipherHolder<CIPHER, BASE> > class CipherModeFinalTemplate_CipherHolder : protected ObjectHolder<CIPHER>, public AlgorithmImpl<BASE, CipherModeFinalTemplate_CipherHolder<CIPHER, BASE> >
@ -321,7 +307,6 @@ public:
} }
}; };
/// \class CipherModeFinalTemplate_ExternalCipher
/// \tparam BASE CipherModeFinalTemplate_CipherHolder base class /// \tparam BASE CipherModeFinalTemplate_CipherHolder base class
/// \details Base class for external mode cipher combinations /// \details Base class for external mode cipher combinations
template <class BASE> template <class BASE>
@ -342,7 +327,6 @@ CRYPTOPP_DLL_TEMPLATE_CLASS CFB_CipherTemplate<AbstractPolicyHolder<CFB_CipherAb
CRYPTOPP_DLL_TEMPLATE_CLASS CFB_EncryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, CFB_ModePolicy> >; CRYPTOPP_DLL_TEMPLATE_CLASS CFB_EncryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, CFB_ModePolicy> >;
CRYPTOPP_DLL_TEMPLATE_CLASS CFB_DecryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, CFB_ModePolicy> >; CRYPTOPP_DLL_TEMPLATE_CLASS CFB_DecryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, CFB_ModePolicy> >;
/// \class CFB_Mode
/// \brief CFB block cipher mode of operation /// \brief CFB block cipher mode of operation
/// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A> /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
/// on the Crypto++ wiki. /// on the Crypto++ wiki.
@ -353,7 +337,6 @@ struct CFB_Mode : public CipherModeDocumentation
typedef CipherModeFinalTemplate_CipherHolder<typename CIPHER::Encryption, ConcretePolicyHolder<Empty, CFB_DecryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, CFB_ModePolicy> > > > Decryption; typedef CipherModeFinalTemplate_CipherHolder<typename CIPHER::Encryption, ConcretePolicyHolder<Empty, CFB_DecryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, CFB_ModePolicy> > > > Decryption;
}; };
/// \class CFB_Mode_ExternalCipher
/// \brief CFB mode, external cipher. /// \brief CFB mode, external cipher.
/// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A> /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
/// on the Crypto++ wiki. /// on the Crypto++ wiki.
@ -363,7 +346,6 @@ struct CFB_Mode_ExternalCipher : public CipherModeDocumentation
typedef CipherModeFinalTemplate_ExternalCipher<ConcretePolicyHolder<Empty, CFB_DecryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, CFB_ModePolicy> > > > Decryption; typedef CipherModeFinalTemplate_ExternalCipher<ConcretePolicyHolder<Empty, CFB_DecryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, CFB_ModePolicy> > > > Decryption;
}; };
/// \class CFB_FIPS_Mode
/// \brief CFB block cipher mode of operation providing FIPS validated cryptography. /// \brief CFB block cipher mode of operation providing FIPS validated cryptography.
/// \details Requires full block plaintext according to FIPS 800-38A /// \details Requires full block plaintext according to FIPS 800-38A
/// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A> /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
@ -375,7 +357,6 @@ struct CFB_FIPS_Mode : public CipherModeDocumentation
typedef CipherModeFinalTemplate_CipherHolder<typename CIPHER::Encryption, ConcretePolicyHolder<Empty, CFB_RequireFullDataBlocks<CFB_DecryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, CFB_ModePolicy> > > > > Decryption; typedef CipherModeFinalTemplate_CipherHolder<typename CIPHER::Encryption, ConcretePolicyHolder<Empty, CFB_RequireFullDataBlocks<CFB_DecryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, CFB_ModePolicy> > > > > Decryption;
}; };
/// \class CFB_FIPS_Mode_ExternalCipher
/// \brief CFB mode, external cipher, providing FIPS validated cryptography. /// \brief CFB mode, external cipher, providing FIPS validated cryptography.
/// \details Requires full block plaintext according to FIPS 800-38A /// \details Requires full block plaintext according to FIPS 800-38A
/// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A> /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
@ -388,7 +369,6 @@ struct CFB_FIPS_Mode_ExternalCipher : public CipherModeDocumentation
CRYPTOPP_DLL_TEMPLATE_CLASS AdditiveCipherTemplate<AbstractPolicyHolder<AdditiveCipherAbstractPolicy, OFB_ModePolicy> >; CRYPTOPP_DLL_TEMPLATE_CLASS AdditiveCipherTemplate<AbstractPolicyHolder<AdditiveCipherAbstractPolicy, OFB_ModePolicy> >;
/// \class OFB_Mode
/// \brief OFB block cipher mode of operation /// \brief OFB block cipher mode of operation
/// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A> /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
/// on the Crypto++ wiki. /// on the Crypto++ wiki.
@ -399,7 +379,6 @@ struct OFB_Mode : public CipherModeDocumentation
typedef Encryption Decryption; typedef Encryption Decryption;
}; };
/// \class OFB_Mode_ExternalCipher
/// \brief OFB mode, external cipher. /// \brief OFB mode, external cipher.
/// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A> /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
/// on the Crypto++ wiki. /// on the Crypto++ wiki.
@ -412,7 +391,6 @@ struct OFB_Mode_ExternalCipher : public CipherModeDocumentation
CRYPTOPP_DLL_TEMPLATE_CLASS AdditiveCipherTemplate<AbstractPolicyHolder<AdditiveCipherAbstractPolicy, CTR_ModePolicy> >; CRYPTOPP_DLL_TEMPLATE_CLASS AdditiveCipherTemplate<AbstractPolicyHolder<AdditiveCipherAbstractPolicy, CTR_ModePolicy> >;
CRYPTOPP_DLL_TEMPLATE_CLASS CipherModeFinalTemplate_ExternalCipher<ConcretePolicyHolder<Empty, AdditiveCipherTemplate<AbstractPolicyHolder<AdditiveCipherAbstractPolicy, CTR_ModePolicy> > > >; CRYPTOPP_DLL_TEMPLATE_CLASS CipherModeFinalTemplate_ExternalCipher<ConcretePolicyHolder<Empty, AdditiveCipherTemplate<AbstractPolicyHolder<AdditiveCipherAbstractPolicy, CTR_ModePolicy> > > >;
/// \class CTR_Mode
/// \brief CTR block cipher mode of operation /// \brief CTR block cipher mode of operation
/// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A> /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
/// on the Crypto++ wiki. /// on the Crypto++ wiki.
@ -423,7 +401,6 @@ struct CTR_Mode : public CipherModeDocumentation
typedef Encryption Decryption; typedef Encryption Decryption;
}; };
/// \class CTR_Mode_ExternalCipher
/// \brief CTR mode, external cipher. /// \brief CTR mode, external cipher.
/// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A> /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
/// on the Crypto++ wiki. /// on the Crypto++ wiki.
@ -433,7 +410,6 @@ struct CTR_Mode_ExternalCipher : public CipherModeDocumentation
typedef Encryption Decryption; typedef Encryption Decryption;
}; };
/// \class ECB_Mode
/// \brief ECB block cipher mode of operation /// \brief ECB block cipher mode of operation
/// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A> /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
/// on the Crypto++ wiki. /// on the Crypto++ wiki.
@ -446,7 +422,6 @@ struct ECB_Mode : public CipherModeDocumentation
CRYPTOPP_DLL_TEMPLATE_CLASS CipherModeFinalTemplate_ExternalCipher<ECB_OneWay>; CRYPTOPP_DLL_TEMPLATE_CLASS CipherModeFinalTemplate_ExternalCipher<ECB_OneWay>;
/// \class ECB_Mode_ExternalCipher
/// \brief ECB mode, external cipher. /// \brief ECB mode, external cipher.
/// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A> /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
/// on the Crypto++ wiki. /// on the Crypto++ wiki.
@ -456,7 +431,6 @@ struct ECB_Mode_ExternalCipher : public CipherModeDocumentation
typedef Encryption Decryption; typedef Encryption Decryption;
}; };
/// \class CBC_Mode
/// \brief CBC block cipher mode of operation /// \brief CBC block cipher mode of operation
/// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A> /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
/// on the Crypto++ wiki. /// on the Crypto++ wiki.
@ -470,7 +444,6 @@ struct CBC_Mode : public CipherModeDocumentation
CRYPTOPP_DLL_TEMPLATE_CLASS CipherModeFinalTemplate_ExternalCipher<CBC_Encryption>; CRYPTOPP_DLL_TEMPLATE_CLASS CipherModeFinalTemplate_ExternalCipher<CBC_Encryption>;
CRYPTOPP_DLL_TEMPLATE_CLASS CipherModeFinalTemplate_ExternalCipher<CBC_Decryption>; CRYPTOPP_DLL_TEMPLATE_CLASS CipherModeFinalTemplate_ExternalCipher<CBC_Decryption>;
/// \class CBC_Mode_ExternalCipher
/// \brief CBC mode, external cipher /// \brief CBC mode, external cipher
/// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A> /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
/// on the Crypto++ wiki. /// on the Crypto++ wiki.
@ -480,7 +453,6 @@ struct CBC_Mode_ExternalCipher : public CipherModeDocumentation
typedef CipherModeFinalTemplate_ExternalCipher<CBC_Decryption> Decryption; typedef CipherModeFinalTemplate_ExternalCipher<CBC_Decryption> Decryption;
}; };
/// \class CBC_CTS_Mode
/// \brief CBC-CTS block cipher mode of operation /// \brief CBC-CTS block cipher mode of operation
/// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A> /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
/// on the Crypto++ wiki. /// on the Crypto++ wiki.
@ -494,7 +466,6 @@ struct CBC_CTS_Mode : public CipherModeDocumentation
CRYPTOPP_DLL_TEMPLATE_CLASS CipherModeFinalTemplate_ExternalCipher<CBC_CTS_Encryption>; CRYPTOPP_DLL_TEMPLATE_CLASS CipherModeFinalTemplate_ExternalCipher<CBC_CTS_Encryption>;
CRYPTOPP_DLL_TEMPLATE_CLASS CipherModeFinalTemplate_ExternalCipher<CBC_CTS_Decryption>; CRYPTOPP_DLL_TEMPLATE_CLASS CipherModeFinalTemplate_ExternalCipher<CBC_CTS_Decryption>;
/// \class CBC_CTS_Mode_ExternalCipher
/// \brief CBC mode with ciphertext stealing, external cipher /// \brief CBC mode with ciphertext stealing, external cipher
/// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A> /// \sa <A HREF="http://www.cryptopp.com/wiki/Modes_of_Operation">Modes of Operation</A>
/// on the Crypto++ wiki. /// on the Crypto++ wiki.

1
mqv.h
View File

@ -15,7 +15,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class MQV_Domain
/// \brief MQV domain for performing authenticated key agreement /// \brief MQV domain for performing authenticated key agreement
/// \tparam GROUP_PARAMETERS doamin parameters /// \tparam GROUP_PARAMETERS doamin parameters
/// \tparam COFACTOR_OPTION cofactor option /// \tparam COFACTOR_OPTION cofactor option

2
nbtheory.h
View File

@ -75,7 +75,6 @@ CRYPTOPP_DLL bool CRYPTOPP_API IsPrime(const Integer &p);
/// level is greater than 1, then 10 round RabinMillerTest() primality testing is performed. /// level is greater than 1, then 10 round RabinMillerTest() primality testing is performed.
CRYPTOPP_DLL bool CRYPTOPP_API VerifyPrime(RandomNumberGenerator &rng, const Integer &p, unsigned int level = 1); CRYPTOPP_DLL bool CRYPTOPP_API VerifyPrime(RandomNumberGenerator &rng, const Integer &p, unsigned int level = 1);
/// \class PrimeSelector
/// \brief Application callback to signal suitability of a cabdidate prime /// \brief Application callback to signal suitability of a cabdidate prime
class CRYPTOPP_DLL PrimeSelector class CRYPTOPP_DLL PrimeSelector
{ {
@ -143,7 +142,6 @@ CRYPTOPP_DLL unsigned int CRYPTOPP_API FactoringWorkFactor(unsigned int bitlengt
// ******************************************************** // ********************************************************
/// \class PrimeAndGenerator
/// \brief Generator of prime numbers of special forms /// \brief Generator of prime numbers of special forms
class CRYPTOPP_DLL PrimeAndGenerator class CRYPTOPP_DLL PrimeAndGenerator
{ {

7
osrng.h
View File

@ -20,7 +20,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class OS_RNG_Err
/// \brief Exception thrown when an operating system error is encountered /// \brief Exception thrown when an operating system error is encountered
class CRYPTOPP_DLL OS_RNG_Err : public Exception class CRYPTOPP_DLL OS_RNG_Err : public Exception
{ {
@ -33,7 +32,6 @@ public:
#ifdef NONBLOCKING_RNG_AVAILABLE #ifdef NONBLOCKING_RNG_AVAILABLE
#ifdef CRYPTOPP_WIN32_AVAILABLE #ifdef CRYPTOPP_WIN32_AVAILABLE
/// \class MicrosoftCryptoProvider
/// \brief Wrapper for Microsoft crypto service provider /// \brief Wrapper for Microsoft crypto service provider
/// \sa \def USE_MS_CRYPTOAPI, \def USE_MS_CNGAPI /// \sa \def USE_MS_CRYPTOAPI, \def USE_MS_CNGAPI
class CRYPTOPP_DLL MicrosoftCryptoProvider class CRYPTOPP_DLL MicrosoftCryptoProvider
@ -80,7 +78,6 @@ private:
#endif // CRYPTOPP_WIN32_AVAILABLE #endif // CRYPTOPP_WIN32_AVAILABLE
/// \class NonblockingRng
/// \brief Wrapper class for /dev/random and /dev/srandom /// \brief Wrapper class for /dev/random and /dev/srandom
/// \details Encapsulates CryptoAPI's CryptGenRandom() or CryptoNG's BCryptGenRandom() /// \details Encapsulates CryptoAPI's CryptGenRandom() or CryptoNG's BCryptGenRandom()
/// on Windows, or /dev/urandom on Unix and compatibles. /// on Windows, or /dev/urandom on Unix and compatibles.
@ -112,7 +109,6 @@ protected:
#if defined(BLOCKING_RNG_AVAILABLE) || defined(CRYPTOPP_DOXYGEN_PROCESSING) #if defined(BLOCKING_RNG_AVAILABLE) || defined(CRYPTOPP_DOXYGEN_PROCESSING)
/// \class BlockingRng
/// \brief Wrapper class for /dev/random and /dev/srandom /// \brief Wrapper class for /dev/random and /dev/srandom
/// \details Encapsulates /dev/random on Linux, OS X and Unix; and /dev/srandom on the BSDs. /// \details Encapsulates /dev/random on Linux, OS X and Unix; and /dev/srandom on the BSDs.
/// \note On Linux the /dev/random interface is effectively deprecated. According to the /// \note On Linux the /dev/random interface is effectively deprecated. According to the
@ -153,7 +149,6 @@ protected:
/// by way of BlockingRng, if available. /// by way of BlockingRng, if available.
CRYPTOPP_DLL void CRYPTOPP_API OS_GenerateRandomBlock(bool blocking, byte *output, size_t size); CRYPTOPP_DLL void CRYPTOPP_API OS_GenerateRandomBlock(bool blocking, byte *output, size_t size);
/// \class AutoSeededRandomPool
/// \brief Automatically Seeded Randomness Pool /// \brief Automatically Seeded Randomness Pool
/// \details This class seeds itself using an operating system provided RNG. /// \details This class seeds itself using an operating system provided RNG.
/// AutoSeededRandomPool was suggested by Leonard Janke. /// AutoSeededRandomPool was suggested by Leonard Janke.
@ -178,7 +173,6 @@ public:
void Reseed(bool blocking = false, unsigned int seedSize = 32); void Reseed(bool blocking = false, unsigned int seedSize = 32);
}; };
/// \class AutoSeededX917RNG
/// \tparam BLOCK_CIPHER a block cipher /// \tparam BLOCK_CIPHER a block cipher
/// \brief Automatically Seeded X9.17 RNG /// \brief Automatically Seeded X9.17 RNG
/// \details AutoSeededX917RNG is from ANSI X9.17 Appendix C, seeded using an OS provided RNG. /// \details AutoSeededX917RNG is from ANSI X9.17 Appendix C, seeded using an OS provided RNG.
@ -262,7 +256,6 @@ void AutoSeededX917RNG<BLOCK_CIPHER>::Reseed(bool blocking, const byte *input, s
CRYPTOPP_DLL_TEMPLATE_CLASS AutoSeededX917RNG<AES>; CRYPTOPP_DLL_TEMPLATE_CLASS AutoSeededX917RNG<AES>;
#if defined(CRYPTOPP_DOXYGEN_PROCESSING) #if defined(CRYPTOPP_DOXYGEN_PROCESSING)
/// \class DefaultAutoSeededRNG
/// \brief A typedef providing a default generator /// \brief A typedef providing a default generator
/// \details DefaultAutoSeededRNG is a typedef of either AutoSeededX917RNG<AES> or AutoSeededRandomPool. /// \details DefaultAutoSeededRNG is a typedef of either AutoSeededX917RNG<AES> or AutoSeededRandomPool.
/// If CRYPTOPP_ENABLE_COMPLIANCE_WITH_FIPS_140_2 is defined, then DefaultAutoSeededRNG is /// If CRYPTOPP_ENABLE_COMPLIANCE_WITH_FIPS_140_2 is defined, then DefaultAutoSeededRNG is

6
panama.h
View File

@ -33,7 +33,6 @@ protected:
}; };
namespace Weak { namespace Weak {
/// \class PanamaHash
/// \brief Panama hash /// \brief Panama hash
/// \sa <a href="http://www.weidai.com/scan-mirror/md.html#Panama">Panama Hash</a> /// \sa <a href="http://www.weidai.com/scan-mirror/md.html#Panama">Panama Hash</a>
template <class B = LittleEndian> template <class B = LittleEndian>
@ -54,7 +53,6 @@ protected:
}; };
} }
/// \class HermeticHashFunctionMAC
/// \brief MAC construction using a hermetic hash function /// \brief MAC construction using a hermetic hash function
template <class T_Hash, class T_Info = T_Hash> template <class T_Hash, class T_Info = T_Hash>
class HermeticHashFunctionMAC : public AlgorithmImpl<SimpleKeyingInterfaceImpl<TwoBases<MessageAuthenticationCode, VariableKeyLength<32, 0, INT_MAX> > >, T_Info> class HermeticHashFunctionMAC : public AlgorithmImpl<SimpleKeyingInterfaceImpl<TwoBases<MessageAuthenticationCode, VariableKeyLength<32, 0, INT_MAX> > >, T_Info>
@ -111,7 +109,6 @@ protected:
}; };
namespace Weak { namespace Weak {
/// \class PanamaMAC
/// \brief Panama message authentication code /// \brief Panama message authentication code
template <class B = LittleEndian> template <class B = LittleEndian>
class PanamaMAC : public HermeticHashFunctionMAC<PanamaHash<B> > class PanamaMAC : public HermeticHashFunctionMAC<PanamaHash<B> >
@ -123,7 +120,6 @@ public:
}; };
} }
/// \class PanamaCipherInfo
/// \brief Panama stream cipher information /// \brief Panama stream cipher information
template <class B> template <class B>
struct PanamaCipherInfo : public FixedKeyLength<32, SimpleKeyingInterface::UNIQUE_IV, 32> struct PanamaCipherInfo : public FixedKeyLength<32, SimpleKeyingInterface::UNIQUE_IV, 32>
@ -131,7 +127,6 @@ struct PanamaCipherInfo : public FixedKeyLength<32, SimpleKeyingInterface::UNIQU
CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return B::ToEnum() == BIG_ENDIAN_ORDER ? "Panama-BE" : "Panama-LE";} CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return B::ToEnum() == BIG_ENDIAN_ORDER ? "Panama-BE" : "Panama-LE";}
}; };
/// \class PanamaCipherPolicy
/// \brief Panama stream cipher operation /// \brief Panama stream cipher operation
template <class B> template <class B>
class PanamaCipherPolicy : public AdditiveCipherConcretePolicy<word32, 8>, class PanamaCipherPolicy : public AdditiveCipherConcretePolicy<word32, 8>,
@ -148,7 +143,6 @@ protected:
FixedSizeSecBlock<word32, 8> m_key; FixedSizeSecBlock<word32, 8> m_key;
}; };
/// \class PanamaCipher
/// \brief Panama stream cipher /// \brief Panama stream cipher
/// \sa <a href="http://www.cryptolounge.org/wiki/PANAMA">Panama Stream Cipher</a> /// \sa <a href="http://www.cryptolounge.org/wiki/PANAMA">Panama Stream Cipher</a>
template <class B = LittleEndian> template <class B = LittleEndian>

3
pkcspad.h
View File

@ -18,7 +18,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class PKCS_EncryptionPaddingScheme
/// \brief PKCS #1 v1.5 Encryption Padding Scheme /// \brief PKCS #1 v1.5 Encryption Padding Scheme
/// \sa <a href="http://www.weidai.com/scan-mirror/ca.html#cem_PKCS1-1.5">EME-PKCS1-v1_5</a> /// \sa <a href="http://www.weidai.com/scan-mirror/ca.html#cem_PKCS1-1.5">EME-PKCS1-v1_5</a>
class PKCS_EncryptionPaddingScheme : public PK_EncryptionMessageEncodingMethod class PKCS_EncryptionPaddingScheme : public PK_EncryptionMessageEncodingMethod
@ -31,7 +30,6 @@ public:
DecodingResult Unpad(const byte *padded, size_t paddedLength, byte *raw, const NameValuePairs &parameters) const; DecodingResult Unpad(const byte *padded, size_t paddedLength, byte *raw, const NameValuePairs &parameters) const;
}; };
/// \class PKCS_DigestDecoration
/// \brief PKCS #1 decoration data structure /// \brief PKCS #1 decoration data structure
template <class H> class PKCS_DigestDecoration template <class H> class PKCS_DigestDecoration
{ {
@ -84,7 +82,6 @@ template<> const byte PKCS_DigestDecoration<Weak1::MD5>::decoration[];
template<> const unsigned int PKCS_DigestDecoration<Weak1::MD5>::length; template<> const unsigned int PKCS_DigestDecoration<Weak1::MD5>::length;
#endif #endif
/// \class PKCS1v15_SignatureMessageEncodingMethod
/// \brief PKCS #1 v1.5 Signature Encoding Scheme /// \brief PKCS #1 v1.5 Signature Encoding Scheme
/// \sa <a href="http://www.weidai.com/scan-mirror/sig.html#sem_PKCS1-1.5">EMSA-PKCS1-v1_5</a> /// \sa <a href="http://www.weidai.com/scan-mirror/sig.html#sem_PKCS1-1.5">EMSA-PKCS1-v1_5</a>
class CRYPTOPP_DLL PKCS1v15_SignatureMessageEncodingMethod : public PK_DeterministicSignatureMessageEncodingMethod class CRYPTOPP_DLL PKCS1v15_SignatureMessageEncodingMethod : public PK_DeterministicSignatureMessageEncodingMethod

2
poly1305.h
View File

@ -52,7 +52,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class Poly1305_Base
/// \brief Poly1305 message authentication code base class /// \brief Poly1305 message authentication code base class
/// \tparam T class derived from BlockCipherDocumentation with 16-byte key and 16-byte blocksize /// \tparam T class derived from BlockCipherDocumentation with 16-byte key and 16-byte blocksize
/// \since Crypto++ 6.0 /// \since Crypto++ 6.0
@ -100,7 +99,6 @@ protected:
bool m_used; bool m_used;
}; };
/// \class Poly1305
/// \brief Poly1305 message authentication code /// \brief Poly1305 message authentication code
/// \tparam T class derived from BlockCipherDocumentation with 16-byte key and 16-byte blocksize /// \tparam T class derived from BlockCipherDocumentation with 16-byte key and 16-byte blocksize
/// \details Poly1305-AES is a state-of-the-art message-authentication code suitable for a wide /// \details Poly1305-AES is a state-of-the-art message-authentication code suitable for a wide

37
pubkey.h
View File

@ -60,7 +60,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class TrapdoorFunctionBounds
/// \brief Provides range for plaintext and ciphertext lengths /// \brief Provides range for plaintext and ciphertext lengths
/// \details A trapdoor function is a function that is easy to compute in one direction, /// \details A trapdoor function is a function that is easy to compute in one direction,
/// but difficult to compute in the opposite direction without special knowledge. /// but difficult to compute in the opposite direction without special knowledge.
@ -93,7 +92,6 @@ public:
virtual Integer MaxImage() const {return --ImageBound();} virtual Integer MaxImage() const {return --ImageBound();}
}; };
/// \class RandomizedTrapdoorFunction
/// \brief Applies the trapdoor function, using random data if required /// \brief Applies the trapdoor function, using random data if required
/// \details ApplyFunction() is the foundation for encrypting a message under a public key. /// \details ApplyFunction() is the foundation for encrypting a message under a public key.
/// Derived classes will override it at some point. /// Derived classes will override it at some point.
@ -119,7 +117,6 @@ public:
virtual bool IsRandomized() const {return true;} virtual bool IsRandomized() const {return true;}
}; };
/// \class TrapdoorFunction
/// \brief Applies the trapdoor function /// \brief Applies the trapdoor function
/// \details ApplyFunction() is the foundation for encrypting a message under a public key. /// \details ApplyFunction() is the foundation for encrypting a message under a public key.
/// Derived classes will override it at some point. /// Derived classes will override it at some point.
@ -149,7 +146,6 @@ public:
virtual Integer ApplyFunction(const Integer &x) const =0; virtual Integer ApplyFunction(const Integer &x) const =0;
}; };
/// \class RandomizedTrapdoorFunctionInverse
/// \brief Applies the inverse of the trapdoor function, using random data if required /// \brief Applies the inverse of the trapdoor function, using random data if required
/// \details CalculateInverse() is the foundation for decrypting a message under a private key /// \details CalculateInverse() is the foundation for decrypting a message under a private key
/// in a public key cryptosystem. Derived classes will override it at some point. /// in a public key cryptosystem. Derived classes will override it at some point.
@ -174,7 +170,6 @@ public:
virtual bool IsRandomized() const {return true;} virtual bool IsRandomized() const {return true;}
}; };
/// \class TrapdoorFunctionInverse
/// \brief Applies the inverse of the trapdoor function /// \brief Applies the inverse of the trapdoor function
/// \details CalculateInverse() is the foundation for decrypting a message under a private key /// \details CalculateInverse() is the foundation for decrypting a message under a private key
/// in a public key cryptosystem. Derived classes will override it at some point. /// in a public key cryptosystem. Derived classes will override it at some point.
@ -209,7 +204,6 @@ public:
// ******************************************************** // ********************************************************
/// \class PK_EncryptionMessageEncodingMethod
/// \brief Message encoding method for public key encryption /// \brief Message encoding method for public key encryption
class CRYPTOPP_NO_VTABLE PK_EncryptionMessageEncodingMethod class CRYPTOPP_NO_VTABLE PK_EncryptionMessageEncodingMethod
{ {
@ -229,7 +223,6 @@ public:
// ******************************************************** // ********************************************************
/// \class TF_Base
/// \brief The base for trapdoor based cryptosystems /// \brief The base for trapdoor based cryptosystems
/// \tparam TFI trapdoor function interface derived class /// \tparam TFI trapdoor function interface derived class
/// \tparam MEI message encoding interface derived class /// \tparam MEI message encoding interface derived class
@ -250,7 +243,6 @@ protected:
// ******************************************************** // ********************************************************
/// \class PK_FixedLengthCryptoSystemImpl
/// \brief Public key trapdoor function default implementation /// \brief Public key trapdoor function default implementation
/// \tparam BASE public key cryptosystem with a fixed length /// \tparam BASE public key cryptosystem with a fixed length
template <class BASE> template <class BASE>
@ -268,7 +260,6 @@ public:
virtual size_t FixedCiphertextLength() const =0; virtual size_t FixedCiphertextLength() const =0;
}; };
/// \class TF_CryptoSystemBase
/// \brief Trapdoor function cryptosystem base class /// \brief Trapdoor function cryptosystem base class
/// \tparam INTFACE public key cryptosystem base interface /// \tparam INTFACE public key cryptosystem base interface
/// \tparam BASE public key cryptosystem implementation base /// \tparam BASE public key cryptosystem implementation base
@ -288,7 +279,6 @@ protected:
size_t PaddedBlockBitLength() const {return SaturatingSubtract(this->GetTrapdoorFunctionBounds().PreimageBound().BitCount(),1U);} size_t PaddedBlockBitLength() const {return SaturatingSubtract(this->GetTrapdoorFunctionBounds().PreimageBound().BitCount(),1U);}
}; };
/// \class TF_DecryptorBase
/// \brief Trapdoor function cryptosystems decryption base class /// \brief Trapdoor function cryptosystems decryption base class
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TF_DecryptorBase : public TF_CryptoSystemBase<PK_Decryptor, TF_Base<TrapdoorFunctionInverse, PK_EncryptionMessageEncodingMethod> > class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TF_DecryptorBase : public TF_CryptoSystemBase<PK_Decryptor, TF_Base<TrapdoorFunctionInverse, PK_EncryptionMessageEncodingMethod> >
{ {
@ -298,7 +288,6 @@ public:
DecodingResult Decrypt(RandomNumberGenerator &rng, const byte *ciphertext, size_t ciphertextLength, byte *plaintext, const NameValuePairs &parameters = g_nullNameValuePairs) const; DecodingResult Decrypt(RandomNumberGenerator &rng, const byte *ciphertext, size_t ciphertextLength, byte *plaintext, const NameValuePairs &parameters = g_nullNameValuePairs) const;
}; };
/// \class TF_EncryptorBase
/// \brief Trapdoor function cryptosystems encryption base class /// \brief Trapdoor function cryptosystems encryption base class
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TF_EncryptorBase : public TF_CryptoSystemBase<PK_Encryptor, TF_Base<RandomizedTrapdoorFunction, PK_EncryptionMessageEncodingMethod> > class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TF_EncryptorBase : public TF_CryptoSystemBase<PK_Encryptor, TF_Base<RandomizedTrapdoorFunction, PK_EncryptionMessageEncodingMethod> >
{ {
@ -313,7 +302,6 @@ public:
// Typedef change due to Clang, http://github.com/weidai11/cryptopp/issues/300 // Typedef change due to Clang, http://github.com/weidai11/cryptopp/issues/300
typedef std::pair<const byte *, unsigned int> HashIdentifier; typedef std::pair<const byte *, unsigned int> HashIdentifier;
/// \class PK_SignatureMessageEncodingMethod
/// \brief Interface for message encoding method for public key signature schemes. /// \brief Interface for message encoding method for public key signature schemes.
/// \details PK_SignatureMessageEncodingMethod provides interfaces for message /// \details PK_SignatureMessageEncodingMethod provides interfaces for message
/// encoding method for public key signature schemes. The methods support both /// encoding method for public key signature schemes. The methods support both
@ -397,7 +385,6 @@ public:
}; };
}; };
/// \class PK_DeterministicSignatureMessageEncodingMethod
/// \brief Interface for message encoding method for public key signature schemes. /// \brief Interface for message encoding method for public key signature schemes.
/// \details PK_DeterministicSignatureMessageEncodingMethod provides interfaces /// \details PK_DeterministicSignatureMessageEncodingMethod provides interfaces
/// for message encoding method for public key signature schemes. /// for message encoding method for public key signature schemes.
@ -409,7 +396,6 @@ public:
byte *representative, size_t representativeBitLength) const; byte *representative, size_t representativeBitLength) const;
}; };
/// \class PK_RecoverableSignatureMessageEncodingMethod
/// \brief Interface for message encoding method for public key signature schemes. /// \brief Interface for message encoding method for public key signature schemes.
/// \details PK_RecoverableSignatureMessageEncodingMethod provides interfaces /// \details PK_RecoverableSignatureMessageEncodingMethod provides interfaces
/// for message encoding method for public key signature schemes. /// for message encoding method for public key signature schemes.
@ -421,7 +407,6 @@ public:
byte *representative, size_t representativeBitLength) const; byte *representative, size_t representativeBitLength) const;
}; };
/// \class DL_SignatureMessageEncodingMethod_DSA
/// \brief Interface for message encoding method for public key signature schemes. /// \brief Interface for message encoding method for public key signature schemes.
/// \details DL_SignatureMessageEncodingMethod_DSA provides interfaces /// \details DL_SignatureMessageEncodingMethod_DSA provides interfaces
/// for message encoding method for DSA. /// for message encoding method for DSA.
@ -434,7 +419,6 @@ public:
byte *representative, size_t representativeBitLength) const; byte *representative, size_t representativeBitLength) const;
}; };
/// \class DL_SignatureMessageEncodingMethod_NR
/// \brief Interface for message encoding method for public key signature schemes. /// \brief Interface for message encoding method for public key signature schemes.
/// \details DL_SignatureMessageEncodingMethod_NR provides interfaces /// \details DL_SignatureMessageEncodingMethod_NR provides interfaces
/// for message encoding method for Nyberg-Rueppel. /// for message encoding method for Nyberg-Rueppel.
@ -448,7 +432,6 @@ public:
}; };
#if 0 #if 0
/// \class DL_SignatureMessageEncodingMethod_SM2
/// \brief Interface for message encoding method for public key signature schemes. /// \brief Interface for message encoding method for public key signature schemes.
/// \details DL_SignatureMessageEncodingMethod_SM2 provides interfaces /// \details DL_SignatureMessageEncodingMethod_SM2 provides interfaces
/// for message encoding method for SM2. /// for message encoding method for SM2.
@ -462,7 +445,6 @@ public:
}; };
#endif #endif
/// \class PK_MessageAccumulatorBase
/// \brief Interface for message encoding method for public key signature schemes. /// \brief Interface for message encoding method for public key signature schemes.
/// \details PK_MessageAccumulatorBase provides interfaces /// \details PK_MessageAccumulatorBase provides interfaces
/// for message encoding method. /// for message encoding method.
@ -484,7 +466,6 @@ public:
bool m_empty; bool m_empty;
}; };
/// \class PK_MessageAccumulatorImpl
/// \brief Interface for message encoding method for public key signature schemes. /// \brief Interface for message encoding method for public key signature schemes.
/// \details PK_MessageAccumulatorBase provides interfaces /// \details PK_MessageAccumulatorBase provides interfaces
/// for message encoding method. /// for message encoding method.
@ -495,7 +476,6 @@ public:
HashTransformation & AccessHash() {return this->m_object;} HashTransformation & AccessHash() {return this->m_object;}
}; };
/// \class TF_SignatureSchemeBase
/// \brief Trapdoor Function (TF) Signature Scheme base class /// \brief Trapdoor Function (TF) Signature Scheme base class
/// \tparam INTFACE interface /// \tparam INTFACE interface
/// \tparam BASE base class /// \tparam BASE base class
@ -527,7 +507,6 @@ protected:
virtual size_t GetDigestSize() const =0; virtual size_t GetDigestSize() const =0;
}; };
/// \class TF_SignerBase
/// \brief Trapdoor Function (TF) Signer base class /// \brief Trapdoor Function (TF) Signer base class
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TF_SignerBase : public TF_SignatureSchemeBase<PK_Signer, TF_Base<RandomizedTrapdoorFunctionInverse, PK_SignatureMessageEncodingMethod> > class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TF_SignerBase : public TF_SignatureSchemeBase<PK_Signer, TF_Base<RandomizedTrapdoorFunctionInverse, PK_SignatureMessageEncodingMethod> >
{ {
@ -538,7 +517,6 @@ public:
size_t SignAndRestart(RandomNumberGenerator &rng, PK_MessageAccumulator &messageAccumulator, byte *signature, bool restart=true) const; size_t SignAndRestart(RandomNumberGenerator &rng, PK_MessageAccumulator &messageAccumulator, byte *signature, bool restart=true) const;
}; };
/// \class TF_VerifierBase
/// \brief Trapdoor Function (TF) Verifier base class /// \brief Trapdoor Function (TF) Verifier base class
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TF_VerifierBase : public TF_SignatureSchemeBase<PK_Verifier, TF_Base<TrapdoorFunction, PK_SignatureMessageEncodingMethod> > class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE TF_VerifierBase : public TF_SignatureSchemeBase<PK_Verifier, TF_Base<TrapdoorFunction, PK_SignatureMessageEncodingMethod> >
{ {
@ -552,7 +530,6 @@ public:
// ******************************************************** // ********************************************************
/// \class TF_CryptoSchemeOptions
/// \brief Trapdoor Function (TF) scheme options /// \brief Trapdoor Function (TF) scheme options
/// \tparam T1 algorithm info class /// \tparam T1 algorithm info class
/// \tparam T2 keys class with public and private key /// \tparam T2 keys class with public and private key
@ -567,7 +544,6 @@ struct TF_CryptoSchemeOptions
typedef T3 MessageEncodingMethod; typedef T3 MessageEncodingMethod;
}; };
/// \class TF_SignatureSchemeOptions
/// \brief Trapdoor Function (TF) signature scheme options /// \brief Trapdoor Function (TF) signature scheme options
/// \tparam T1 algorithm info class /// \tparam T1 algorithm info class
/// \tparam T2 keys class with public and private key /// \tparam T2 keys class with public and private key
@ -579,7 +555,6 @@ struct TF_SignatureSchemeOptions : public TF_CryptoSchemeOptions<T1, T2, T3>
typedef T4 HashFunction; typedef T4 HashFunction;
}; };
/// \class TF_ObjectImplBase
/// \brief Trapdoor Function (TF) base implementation /// \brief Trapdoor Function (TF) base implementation
/// \tparam BASE base class /// \tparam BASE base class
/// \tparam SCHEME_OPTIONS scheme options class /// \tparam SCHEME_OPTIONS scheme options class
@ -635,7 +610,6 @@ protected:
} }
}; };
/// \class TF_ObjectImplExtRef
/// \brief Trapdoor Function (TF) signature with external reference /// \brief Trapdoor Function (TF) signature with external reference
/// \tparam BASE base class /// \tparam BASE base class
/// \tparam SCHEME_OPTIONS scheme options class /// \tparam SCHEME_OPTIONS scheme options class
@ -657,7 +631,6 @@ private:
const KEY * m_pKey; const KEY * m_pKey;
}; };
/// \class TF_ObjectImpl
/// \brief Trapdoor Function (TF) signature scheme options /// \brief Trapdoor Function (TF) signature scheme options
/// \tparam BASE base class /// \tparam BASE base class
/// \tparam SCHEME_OPTIONS scheme options class /// \tparam SCHEME_OPTIONS scheme options class
@ -678,7 +651,6 @@ private:
KeyClass m_trapdoorFunction; KeyClass m_trapdoorFunction;
}; };
/// \class TF_DecryptorImpl
/// \brief Trapdoor Function (TF) decryptor options /// \brief Trapdoor Function (TF) decryptor options
/// \tparam SCHEME_OPTIONS scheme options class /// \tparam SCHEME_OPTIONS scheme options class
template <class SCHEME_OPTIONS> template <class SCHEME_OPTIONS>
@ -686,7 +658,6 @@ class TF_DecryptorImpl : public TF_ObjectImpl<TF_DecryptorBase, SCHEME_OPTIONS,
{ {
}; };
/// \class TF_EncryptorImpl
/// \brief Trapdoor Function (TF) encryptor options /// \brief Trapdoor Function (TF) encryptor options
/// \tparam SCHEME_OPTIONS scheme options class /// \tparam SCHEME_OPTIONS scheme options class
template <class SCHEME_OPTIONS> template <class SCHEME_OPTIONS>
@ -694,7 +665,6 @@ class TF_EncryptorImpl : public TF_ObjectImpl<TF_EncryptorBase, SCHEME_OPTIONS,
{ {
}; };
/// \class TF_SignerImpl
/// \brief Trapdoor Function (TF) encryptor options /// \brief Trapdoor Function (TF) encryptor options
/// \tparam SCHEME_OPTIONS scheme options class /// \tparam SCHEME_OPTIONS scheme options class
template <class SCHEME_OPTIONS> template <class SCHEME_OPTIONS>
@ -702,7 +672,6 @@ class TF_SignerImpl : public TF_ObjectImpl<TF_SignerBase, SCHEME_OPTIONS, typena
{ {
}; };
/// \class TF_VerifierImpl
/// \brief Trapdoor Function (TF) encryptor options /// \brief Trapdoor Function (TF) encryptor options
/// \tparam SCHEME_OPTIONS scheme options class /// \tparam SCHEME_OPTIONS scheme options class
template <class SCHEME_OPTIONS> template <class SCHEME_OPTIONS>
@ -712,7 +681,6 @@ class TF_VerifierImpl : public TF_ObjectImpl<TF_VerifierBase, SCHEME_OPTIONS, ty
// ******************************************************** // ********************************************************
/// \class MaskGeneratingFunction
/// \brief Mask generation function interface /// \brief Mask generation function interface
class CRYPTOPP_NO_VTABLE MaskGeneratingFunction class CRYPTOPP_NO_VTABLE MaskGeneratingFunction
{ {
@ -742,7 +710,6 @@ public:
/// \param counterStart starting counter value used in generation function /// \param counterStart starting counter value used in generation function
CRYPTOPP_DLL void CRYPTOPP_API P1363_MGF1KDF2_Common(HashTransformation &hash, byte *output, size_t outputLength, const byte *input, size_t inputLength, const byte *derivationParams, size_t derivationParamsLength, bool mask, unsigned int counterStart); CRYPTOPP_DLL void CRYPTOPP_API P1363_MGF1KDF2_Common(HashTransformation &hash, byte *output, size_t outputLength, const byte *input, size_t inputLength, const byte *derivationParams, size_t derivationParamsLength, bool mask, unsigned int counterStart);
/// \class P1363_MGF1
/// \brief P1363 mask generation function /// \brief P1363 mask generation function
class P1363_MGF1 : public MaskGeneratingFunction class P1363_MGF1 : public MaskGeneratingFunction
{ {
@ -756,7 +723,6 @@ public:
// ******************************************************** // ********************************************************
/// \class MaskGeneratingFunction
/// \brief P1363 key derivation function /// \brief P1363 key derivation function
/// \tparam H hash function used in the derivation /// \tparam H hash function used in the derivation
template <class H> template <class H>
@ -1673,7 +1639,6 @@ protected:
} }
}; };
/// \class DL_VerifierBase
/// \brief Discret Log (DL) Verifier base class /// \brief Discret Log (DL) Verifier base class
/// \tparam T Field element /// \tparam T Field element
template <class T> template <class T>
@ -2256,7 +2221,6 @@ public:
typedef PK_FinalTemplate<TF_EncryptorImpl<SchemeOptions> > Encryptor; typedef PK_FinalTemplate<TF_EncryptorImpl<SchemeOptions> > Encryptor;
}; };
/// \class TF_SS
/// \brief Trapdoor Function (TF) Signature Scheme /// \brief Trapdoor Function (TF) Signature Scheme
/// \tparam STANDARD standard /// \tparam STANDARD standard
/// \tparam H hash function /// \tparam H hash function
@ -2282,7 +2246,6 @@ public:
typedef PK_FinalTemplate<TF_VerifierImpl<SchemeOptions> > Verifier; typedef PK_FinalTemplate<TF_VerifierImpl<SchemeOptions> > Verifier;
}; };
/// \class DL_SS
/// \brief Discrete Log (DL) signature scheme /// \brief Discrete Log (DL) signature scheme
/// \tparam KEYS keys used in the signature scheme /// \tparam KEYS keys used in the signature scheme
/// \tparam SA signature algorithm /// \tparam SA signature algorithm

2
queue.h
View File

@ -13,7 +13,6 @@ NAMESPACE_BEGIN(CryptoPP)
class ByteQueueNode; class ByteQueueNode;
/// \class ByteQueue
/// \brief Data structure used to store byte strings /// \brief Data structure used to store byte strings
/// \details The queue is implemented as a linked list of byte arrays /// \details The queue is implemented as a linked list of byte arrays
class CRYPTOPP_DLL ByteQueue : public Bufferless<BufferedTransformation> class CRYPTOPP_DLL ByteQueue : public Bufferless<BufferedTransformation>
@ -73,7 +72,6 @@ public:
byte operator[](lword i) const; byte operator[](lword i) const;
void swap(ByteQueue &rhs); void swap(ByteQueue &rhs);
/// \class Walker
/// \brief A ByteQueue iterator /// \brief A ByteQueue iterator
class Walker : public InputRejecting<BufferedTransformation> class Walker : public InputRejecting<BufferedTransformation>
{ {

2
rabin.h
View File

@ -13,7 +13,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class RabinFunction
/// \brief Rabin trapdoor function using the public key /// \brief Rabin trapdoor function using the public key
/// \since Crypto++ 2.0 /// \since Crypto++ 2.0
class RabinFunction : public TrapdoorFunction, public PublicKey class RabinFunction : public TrapdoorFunction, public PublicKey
@ -52,7 +51,6 @@ protected:
Integer m_n, m_r, m_s; Integer m_n, m_r, m_s;
}; };
/// \class InvertibleRabinFunction
/// \brief Rabin trapdoor function using the private key /// \brief Rabin trapdoor function using the private key
/// \since Crypto++ 2.0 /// \since Crypto++ 2.0
class InvertibleRabinFunction : public RabinFunction, public TrapdoorFunctionInverse, public PrivateKey class InvertibleRabinFunction : public RabinFunction, public TrapdoorFunctionInverse, public PrivateKey

2
randpool.h
View File

@ -26,7 +26,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class RandomPool
/// \brief Randomness Pool based on AES-256 /// \brief Randomness Pool based on AES-256
/// \details RandomPool can be used to generate cryptographic quality pseudorandom bytes /// \details RandomPool can be used to generate cryptographic quality pseudorandom bytes
/// after seeding the pool with IncorporateEntropy(). Internally, the generator uses /// after seeding the pool with IncorporateEntropy(). Internally, the generator uses
@ -56,7 +55,6 @@ private:
bool m_keySet; bool m_keySet;
}; };
/// \class OldRandomPool
/// \brief Randomness Pool based on PGP 2.6.x with MDC /// \brief Randomness Pool based on PGP 2.6.x with MDC
/// \details If you need the pre-Crypto++ 5.5 generator then use OldRandomPool class. The /// \details If you need the pre-Crypto++ 5.5 generator then use OldRandomPool class. The
/// OldRandomPool class is always available so you dont need to define /// OldRandomPool class is always available so you dont need to define

7
rc2.h
View File

@ -12,7 +12,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class RC2_Info
/// \brief RC2 block cipher information /// \brief RC2 block cipher information
struct RC2_Info : public FixedBlockSize<8>, public VariableKeyLength<16, 1, 128> struct RC2_Info : public FixedBlockSize<8>, public VariableKeyLength<16, 1, 128>
{ {
@ -21,12 +20,10 @@ struct RC2_Info : public FixedBlockSize<8>, public VariableKeyLength<16, 1, 128>
CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "RC2";} CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "RC2";}
}; };
/// \class RC2
/// \brief RC2 block cipher /// \brief RC2 block cipher
/// \sa <a href="http://www.cryptopp.com/wiki/RC2">RC2</a> on the Crypto Lounge. /// \sa <a href="http://www.cryptopp.com/wiki/RC2">RC2</a> on the Crypto Lounge.
class RC2 : public RC2_Info, public BlockCipherDocumentation class RC2 : public RC2_Info, public BlockCipherDocumentation
{ {
/// \class Base
/// \brief Class specific methods used to operate the cipher. /// \brief Class specific methods used to operate the cipher.
/// \details Implementations and overrides in \p Base apply to both \p ENCRYPTION and \p DECRYPTION directions /// \details Implementations and overrides in \p Base apply to both \p ENCRYPTION and \p DECRYPTION directions
class CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<RC2_Info> class CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<RC2_Info>
@ -39,7 +36,6 @@ class RC2 : public RC2_Info, public BlockCipherDocumentation
FixedSizeSecBlock<word16, 64> K; // expanded key table FixedSizeSecBlock<word16, 64> K; // expanded key table
}; };
/// \class Enc
/// \brief Class specific methods used to operate the cipher in the forward direction. /// \brief Class specific methods used to operate the cipher in the forward direction.
/// \details Implementations and overrides in \p Enc apply to \p ENCRYPTION. /// \details Implementations and overrides in \p Enc apply to \p ENCRYPTION.
class CRYPTOPP_NO_VTABLE Enc : public Base class CRYPTOPP_NO_VTABLE Enc : public Base
@ -48,7 +44,6 @@ class RC2 : public RC2_Info, public BlockCipherDocumentation
void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const; void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
}; };
/// \class Dec
/// \brief Class specific methods used to operate the cipher in the reverse direction. /// \brief Class specific methods used to operate the cipher in the reverse direction.
/// \details Implementations and overrides in \p Dec apply to \p DECRYPTION. /// \details Implementations and overrides in \p Dec apply to \p DECRYPTION.
class CRYPTOPP_NO_VTABLE Dec : public Base class CRYPTOPP_NO_VTABLE Dec : public Base
@ -59,7 +54,6 @@ class RC2 : public RC2_Info, public BlockCipherDocumentation
public: public:
/// \class Encryption
/// \brief Class specific methods used to operate the cipher in the forward direction. /// \brief Class specific methods used to operate the cipher in the forward direction.
/// \details Implementations and overrides in \p Encryption apply to \p ENCRYPTION. /// \details Implementations and overrides in \p Encryption apply to \p ENCRYPTION.
class Encryption : public BlockCipherFinal<ENCRYPTION, Enc> class Encryption : public BlockCipherFinal<ENCRYPTION, Enc>
@ -72,7 +66,6 @@ public:
{SetKey(key, keyLen, MakeParameters("EffectiveKeyLength", effectiveKeyLen));} {SetKey(key, keyLen, MakeParameters("EffectiveKeyLength", effectiveKeyLen));}
}; };
/// \class Decryption
/// \brief Class specific methods used to operate the cipher in the reverse direction. /// \brief Class specific methods used to operate the cipher in the reverse direction.
/// \details Implementations and overrides in \p Decryption apply to \p DECRYPTION. /// \details Implementations and overrides in \p Decryption apply to \p DECRYPTION.
class Decryption : public BlockCipherFinal<DECRYPTION, Dec> class Decryption : public BlockCipherFinal<DECRYPTION, Dec>

2
rc5.h
View File

@ -11,7 +11,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class RC5_Info
/// \brief RC5 block cipher information /// \brief RC5 block cipher information
/// \since Crypto++ 1.0 /// \since Crypto++ 1.0
struct RC5_Info : public FixedBlockSize<8>, public VariableKeyLength<16, 0, 255>, public VariableRounds<16> struct RC5_Info : public FixedBlockSize<8>, public VariableKeyLength<16, 0, 255>, public VariableRounds<16>
@ -20,7 +19,6 @@ struct RC5_Info : public FixedBlockSize<8>, public VariableKeyLength<16, 0, 255>
typedef word32 RC5_WORD; typedef word32 RC5_WORD;
}; };
/// \class RC5
/// \brief RC5 block cipher /// \brief RC5 block cipher
/// \sa <a href="http://www.cryptopp.com/wiki/RC5">RC5</a> /// \sa <a href="http://www.cryptopp.com/wiki/RC5">RC5</a>
/// \since Crypto++ 1.0 /// \since Crypto++ 1.0

2
rc6.h
View File

@ -11,7 +11,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class RC6_Info
/// \brief RC6 block cipher information /// \brief RC6 block cipher information
struct RC6_Info : public FixedBlockSize<16>, public VariableKeyLength<16, 16, 32, 8>, public VariableRounds<20> struct RC6_Info : public FixedBlockSize<16>, public VariableKeyLength<16, 16, 32, 8>, public VariableRounds<20>
{ {
@ -19,7 +18,6 @@ struct RC6_Info : public FixedBlockSize<16>, public VariableKeyLength<16, 16, 32
typedef word32 RC6_WORD; typedef word32 RC6_WORD;
}; };
/// \class RC6
/// \brief RC6 block cipher /// \brief RC6 block cipher
/// \sa <a href="http://www.cryptopp.com/wiki/RC6">RC6</a> /// \sa <a href="http://www.cryptopp.com/wiki/RC6">RC6</a>
class RC6 : public RC6_Info, public BlockCipherDocumentation class RC6 : public RC6_Info, public BlockCipherDocumentation

4
ripemd.h
View File

@ -10,7 +10,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class RIPEMD160
/// \brief RIPEMD-160 message digest /// \brief RIPEMD-160 message digest
/// \details Digest size is 160-bits. /// \details Digest size is 160-bits.
/// \sa <a href="http://www.weidai.com/scan-mirror/md.html#RIPEMD-160">RIPEMD-160</a> /// \sa <a href="http://www.weidai.com/scan-mirror/md.html#RIPEMD-160">RIPEMD-160</a>
@ -22,7 +21,6 @@ public:
CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "RIPEMD-160";} CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "RIPEMD-160";}
}; };
/// \class RIPEMD320
/// \brief RIPEMD-320 message digest /// \brief RIPEMD-320 message digest
/// \details Digest size is 320-bits. /// \details Digest size is 320-bits.
/// \sa <a href="http://www.weidai.com/scan-mirror/md.html#RIPEMD-320">RIPEMD-320</a> /// \sa <a href="http://www.weidai.com/scan-mirror/md.html#RIPEMD-320">RIPEMD-320</a>
@ -34,7 +32,6 @@ public:
CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "RIPEMD-320";} CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "RIPEMD-320";}
}; };
/// \class RIPEMD128
/// \brief RIPEMD-128 message digest /// \brief RIPEMD-128 message digest
/// \details Digest size is 128-bits. /// \details Digest size is 128-bits.
/// \warning RIPEMD-128 is considered insecure, and should not be used unless you absolutely need it for compatibility. /// \warning RIPEMD-128 is considered insecure, and should not be used unless you absolutely need it for compatibility.
@ -47,7 +44,6 @@ public:
CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "RIPEMD-128";} CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "RIPEMD-128";}
}; };
/// \class RIPEMD256
/// \brief RIPEMD-256 message digest /// \brief RIPEMD-256 message digest
/// \details Digest size is 256-bits. /// \details Digest size is 256-bits.
/// \warning RIPEMD-256 is considered insecure, and should not be used unless you absolutely need it for compatibility. /// \warning RIPEMD-256 is considered insecure, and should not be used unless you absolutely need it for compatibility.

2
rng.h
View File

@ -40,7 +40,6 @@ private:
static const word16 r; static const word16 r;
}; };
/// \class X917RNG
/// \brief ANSI X9.17 RNG /// \brief ANSI X9.17 RNG
/// \details X917RNG is from ANSI X9.17 Appendix C, and it uses a 64-bit block cipher, like TripleDES. /// \details X917RNG is from ANSI X9.17 Appendix C, and it uses a 64-bit block cipher, like TripleDES.
/// If you use a 128-bit block cipher, like AES, then you are effectively using an ANSI X9.31 generator. /// If you use a 128-bit block cipher, like AES, then you are effectively using an ANSI X9.31 generator.
@ -75,7 +74,6 @@ private:
SecByteBlock m_randseed, m_lastBlock, m_deterministicTimeVector; SecByteBlock m_randseed, m_lastBlock, m_deterministicTimeVector;
}; };
/// \class MaurerRandomnessTest
/// \brief Maurer's Universal Statistical Test for Random Bit Generators /// \brief Maurer's Universal Statistical Test for Random Bit Generators
/// \details This class implements Maurer's Universal Statistical Test for /// \details This class implements Maurer's Universal Statistical Test for
/// Random Bit Generators. It is intended for measuring the randomness of /// Random Bit Generators. It is intended for measuring the randomness of

9
rsa.h
View File

@ -18,7 +18,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class RSAFunction
/// \brief RSA trapdoor function using the public key /// \brief RSA trapdoor function using the public key
/// \since Crypto++ 1.0 /// \since Crypto++ 1.0
class CRYPTOPP_DLL RSAFunction : public TrapdoorFunction, public X509PublicKey class CRYPTOPP_DLL RSAFunction : public TrapdoorFunction, public X509PublicKey
@ -58,7 +57,6 @@ protected:
Integer m_n, m_e; Integer m_n, m_e;
}; };
/// \class InvertibleRSAFunction
/// \brief RSA trapdoor function using the private key /// \brief RSA trapdoor function using the private key
/// \since Crypto++ 1.0 /// \since Crypto++ 1.0
class CRYPTOPP_DLL InvertibleRSAFunction : public RSAFunction, public TrapdoorFunctionInverse, public PKCS8PrivateKey class CRYPTOPP_DLL InvertibleRSAFunction : public RSAFunction, public TrapdoorFunctionInverse, public PKCS8PrivateKey
@ -139,7 +137,6 @@ protected:
Integer m_d, m_p, m_q, m_dp, m_dq, m_u; Integer m_d, m_p, m_q, m_dp, m_dq, m_u;
}; };
/// \class RSAFunction_ISO
/// \brief RSA trapdoor function using the public key /// \brief RSA trapdoor function using the public key
/// \since Crypto++ 1.0 /// \since Crypto++ 1.0
class CRYPTOPP_DLL RSAFunction_ISO : public RSAFunction class CRYPTOPP_DLL RSAFunction_ISO : public RSAFunction
@ -149,7 +146,6 @@ public:
Integer PreimageBound() const {return ++(m_n>>1);} Integer PreimageBound() const {return ++(m_n>>1);}
}; };
/// \class InvertibleRSAFunction_ISO
/// \brief RSA trapdoor function using the private key /// \brief RSA trapdoor function using the private key
/// \since Crypto++ 1.0 /// \since Crypto++ 1.0
class CRYPTOPP_DLL InvertibleRSAFunction_ISO : public InvertibleRSAFunction class CRYPTOPP_DLL InvertibleRSAFunction_ISO : public InvertibleRSAFunction
@ -159,7 +155,6 @@ public:
Integer PreimageBound() const {return ++(m_n>>1);} Integer PreimageBound() const {return ++(m_n>>1);}
}; };
/// \class RSA
/// \brief RSA algorithm /// \brief RSA algorithm
/// \since Crypto++ 1.0 /// \since Crypto++ 1.0
struct CRYPTOPP_DLL RSA struct CRYPTOPP_DLL RSA
@ -169,7 +164,6 @@ struct CRYPTOPP_DLL RSA
typedef InvertibleRSAFunction PrivateKey; typedef InvertibleRSAFunction PrivateKey;
}; };
/// \class RSAES
/// \brief RSA encryption algorithm /// \brief RSA encryption algorithm
/// \tparam STANDARD signature standard /// \tparam STANDARD signature standard
/// \sa <a href="http://www.weidai.com/scan-mirror/ca.html#RSA">RSA cryptosystem</a> /// \sa <a href="http://www.weidai.com/scan-mirror/ca.html#RSA">RSA cryptosystem</a>
@ -179,7 +173,6 @@ struct RSAES : public TF_ES<RSA, STANDARD>
{ {
}; };
/// \class RSASS
/// \brief RSA signature algorithm /// \brief RSA signature algorithm
/// \tparam STANDARD signature standard /// \tparam STANDARD signature standard
/// \tparam H hash transformation /// \tparam H hash transformation
@ -191,7 +184,6 @@ struct RSASS : public TF_SS<RSA, STANDARD, H>
{ {
}; };
/// \class RSA_ISO
/// \brief RSA algorithm /// \brief RSA algorithm
/// \since Crypto++ 1.0 /// \since Crypto++ 1.0
struct CRYPTOPP_DLL RSA_ISO struct CRYPTOPP_DLL RSA_ISO
@ -201,7 +193,6 @@ struct CRYPTOPP_DLL RSA_ISO
typedef InvertibleRSAFunction_ISO PrivateKey; typedef InvertibleRSAFunction_ISO PrivateKey;
}; };
/// \class RSASS_ISO
/// \brief RSA signature algorithm /// \brief RSA signature algorithm
/// \tparam H hash transformation /// \tparam H hash transformation
/// \since Crypto++ 1.0 /// \since Crypto++ 1.0

2
rw.h
View File

@ -17,7 +17,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class RWFunction
/// \brief Rabin-Williams trapdoor function using the public key /// \brief Rabin-Williams trapdoor function using the public key
/// \since Crypto++ 2.0, Tweaked roots using <em>e</em> and <em>f</em> since Crypto++ 5.6.4 /// \since Crypto++ 2.0, Tweaked roots using <em>e</em> and <em>f</em> since Crypto++ 5.6.4
class CRYPTOPP_DLL RWFunction : public TrapdoorFunction, public PublicKey class CRYPTOPP_DLL RWFunction : public TrapdoorFunction, public PublicKey
@ -54,7 +53,6 @@ protected:
Integer m_n; Integer m_n;
}; };
/// \class InvertibleRWFunction
/// \brief Rabin-Williams trapdoor function using the private key /// \brief Rabin-Williams trapdoor function using the private key
/// \since Crypto++ 2.0, Tweaked roots using <em>e</em> and <em>f</em> since Crypto++ 5.6.4 /// \since Crypto++ 2.0, Tweaked roots using <em>e</em> and <em>f</em> since Crypto++ 5.6.4
class CRYPTOPP_DLL InvertibleRWFunction : public RWFunction, public TrapdoorFunctionInverse, public PrivateKey class CRYPTOPP_DLL InvertibleRWFunction : public RWFunction, public TrapdoorFunctionInverse, public PrivateKey

9
safer.h
View File

@ -11,12 +11,10 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class SAFER
/// \brief SAFER block cipher /// \brief SAFER block cipher
class SAFER class SAFER
{ {
public: public:
/// \class Base
/// \brief SAFER block cipher default operation /// \brief SAFER block cipher default operation
class CRYPTOPP_NO_VTABLE Base : public BlockCipher class CRYPTOPP_NO_VTABLE Base : public BlockCipher
{ {
@ -32,7 +30,6 @@ public:
static const byte log_tab[256]; static const byte log_tab[256];
}; };
/// \class Enc
/// \brief SAFER block cipher encryption operation /// \brief SAFER block cipher encryption operation
class CRYPTOPP_NO_VTABLE Enc : public Base class CRYPTOPP_NO_VTABLE Enc : public Base
{ {
@ -40,7 +37,6 @@ public:
void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const; void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
}; };
/// \class Dec
/// \brief SAFER block cipher decryption operation /// \brief SAFER block cipher decryption operation
class CRYPTOPP_NO_VTABLE Dec : public Base class CRYPTOPP_NO_VTABLE Dec : public Base
{ {
@ -49,7 +45,6 @@ public:
}; };
}; };
/// \class SAFER_Impl
/// \brief SAFER block cipher default implementation /// \brief SAFER block cipher default implementation
/// \tparam BASE SAFER::Enc or SAFER::Dec derived base class /// \tparam BASE SAFER::Enc or SAFER::Dec derived base class
/// \tparam INFO SAFER_Info derived class /// \tparam INFO SAFER_Info derived class
@ -62,14 +57,12 @@ protected:
bool Strengthened() const {return STR;} bool Strengthened() const {return STR;}
}; };
/// \class SAFER_K_Info
/// \brief SAFER-K block cipher information /// \brief SAFER-K block cipher information
struct SAFER_K_Info : public FixedBlockSize<8>, public VariableKeyLength<16, 8, 16, 8>, public VariableRounds<10, 1, 13> struct SAFER_K_Info : public FixedBlockSize<8>, public VariableKeyLength<16, 8, 16, 8>, public VariableRounds<10, 1, 13>
{ {
CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "SAFER-K";} CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "SAFER-K";}
}; };
/// \class SAFER_K
/// \brief SAFER-K block cipher /// \brief SAFER-K block cipher
/// \sa <a href="http://www.cryptopp.com/wiki/SAFER-K">SAFER-K</a> /// \sa <a href="http://www.cryptopp.com/wiki/SAFER-K">SAFER-K</a>
class SAFER_K : public SAFER_K_Info, public SAFER, public BlockCipherDocumentation class SAFER_K : public SAFER_K_Info, public SAFER, public BlockCipherDocumentation
@ -79,14 +72,12 @@ public:
typedef BlockCipherFinal<DECRYPTION, SAFER_Impl<Dec, SAFER_K_Info, false> > Decryption; typedef BlockCipherFinal<DECRYPTION, SAFER_Impl<Dec, SAFER_K_Info, false> > Decryption;
}; };
/// \class SAFER_SK_Info
/// \brief SAFER-SK block cipher information /// \brief SAFER-SK block cipher information
struct SAFER_SK_Info : public FixedBlockSize<8>, public VariableKeyLength<16, 8, 16, 8>, public VariableRounds<10, 1, 13> struct SAFER_SK_Info : public FixedBlockSize<8>, public VariableKeyLength<16, 8, 16, 8>, public VariableRounds<10, 1, 13>
{ {
CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "SAFER-SK";} CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "SAFER-SK";}
}; };
/// \class SAFER_SK
/// \brief SAFER-SK block cipher /// \brief SAFER-SK block cipher
/// \sa <a href="http://www.cryptopp.com/wiki/SAFER-SK">SAFER-SK</a> /// \sa <a href="http://www.cryptopp.com/wiki/SAFER-SK">SAFER-SK</a>
class SAFER_SK : public SAFER_SK_Info, public SAFER, public BlockCipherDocumentation class SAFER_SK : public SAFER_SK_Info, public SAFER, public BlockCipherDocumentation

6
salsa.h
View File

@ -16,14 +16,12 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class Salsa20_Info
/// \brief Salsa20 stream cipher information /// \brief Salsa20 stream cipher information
struct Salsa20_Info : public VariableKeyLength<32, 16, 32, 16, SimpleKeyingInterface::UNIQUE_IV, 8> struct Salsa20_Info : public VariableKeyLength<32, 16, 32, 16, SimpleKeyingInterface::UNIQUE_IV, 8>
{ {
static std::string StaticAlgorithmName() {return "Salsa20";} static std::string StaticAlgorithmName() {return "Salsa20";}
}; };
/// \class Salsa20_Policy
/// \brief Salsa20 stream cipher operation /// \brief Salsa20 stream cipher operation
class CRYPTOPP_NO_VTABLE Salsa20_Policy : public AdditiveCipherConcretePolicy<word32, 16> class CRYPTOPP_NO_VTABLE Salsa20_Policy : public AdditiveCipherConcretePolicy<word32, 16>
{ {
@ -42,7 +40,6 @@ protected:
int m_rounds; int m_rounds;
}; };
/// \class Salsa20
/// \brief Salsa20 stream cipher /// \brief Salsa20 stream cipher
/// \details Salsa20 provides a variable number of rounds: 8, 12 or 20. The default number of rounds is 20. /// \details Salsa20 provides a variable number of rounds: 8, 12 or 20. The default number of rounds is 20.
/// \sa <a href="http://www.cryptolounge.org/wiki/XSalsa20">XSalsa20</a> /// \sa <a href="http://www.cryptolounge.org/wiki/XSalsa20">XSalsa20</a>
@ -52,14 +49,12 @@ struct Salsa20 : public Salsa20_Info, public SymmetricCipherDocumentation
typedef Encryption Decryption; typedef Encryption Decryption;
}; };
/// \class XSalsa20_Info
/// \brief XSalsa20 stream cipher information /// \brief XSalsa20 stream cipher information
struct XSalsa20_Info : public FixedKeyLength<32, SimpleKeyingInterface::UNIQUE_IV, 24> struct XSalsa20_Info : public FixedKeyLength<32, SimpleKeyingInterface::UNIQUE_IV, 24>
{ {
static std::string StaticAlgorithmName() {return "XSalsa20";} static std::string StaticAlgorithmName() {return "XSalsa20";}
}; };
/// \class XSalsa20_Policy
/// \brief XSalsa20 stream cipher operation /// \brief XSalsa20 stream cipher operation
class CRYPTOPP_NO_VTABLE XSalsa20_Policy : public Salsa20_Policy class CRYPTOPP_NO_VTABLE XSalsa20_Policy : public Salsa20_Policy
{ {
@ -71,7 +66,6 @@ protected:
FixedSizeSecBlock<word32, 8> m_key; FixedSizeSecBlock<word32, 8> m_key;
}; };
/// \class XSalsa20
/// \brief XSalsa20 stream cipher /// \brief XSalsa20 stream cipher
/// \details XSalsa20 provides a variable number of rounds: 8, 12 or 20. The default number of rounds is 20. /// \details XSalsa20 provides a variable number of rounds: 8, 12 or 20. The default number of rounds is 20.
/// \sa <a href="http://www.cryptolounge.org/wiki/XSalsa20">XSalsa20</a> /// \sa <a href="http://www.cryptolounge.org/wiki/XSalsa20">XSalsa20</a>

3
seal.h
View File

@ -11,7 +11,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class SEAL_Info
/// \brief SEAL stream cipher information /// \brief SEAL stream cipher information
/// \tparam B Endianness of the stream cipher /// \tparam B Endianness of the stream cipher
template <class B = BigEndian> template <class B = BigEndian>
@ -20,7 +19,6 @@ struct SEAL_Info : public FixedKeyLength<20, SimpleKeyingInterface::INTERNALLY_G
CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return B::ToEnum() == LITTLE_ENDIAN_ORDER ? "SEAL-3.0-LE" : "SEAL-3.0-BE";} CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return B::ToEnum() == LITTLE_ENDIAN_ORDER ? "SEAL-3.0-LE" : "SEAL-3.0-BE";}
}; };
/// \class SEAL_Policy
/// \brief SEAL stream cipher operation /// \brief SEAL stream cipher operation
/// \tparam B Endianness of the stream cipher /// \tparam B Endianness of the stream cipher
template <class B = BigEndian> template <class B = BigEndian>
@ -42,7 +40,6 @@ private:
word32 m_outsideCounter, m_insideCounter; word32 m_outsideCounter, m_insideCounter;
}; };
/// \class SEAL
/// \brief SEAL stream cipher /// \brief SEAL stream cipher
/// \tparam B Endianness of the stream cipher /// \tparam B Endianness of the stream cipher
/// \sa <a href="http://www.cryptopp.com/wiki/SEAL-3.0-BE">SEAL</a> /// \sa <a href="http://www.cryptopp.com/wiki/SEAL-3.0-BE">SEAL</a>

11
secblock.h
View File

@ -22,7 +22,6 @@ NAMESPACE_BEGIN(CryptoPP)
// ************** secure memory allocation *************** // ************** secure memory allocation ***************
/// \class AllocatorBase
/// \brief Base class for all allocators used by SecBlock /// \brief Base class for all allocators used by SecBlock
/// \tparam T the class or type /// \tparam T the class or type
template<class T> template<class T>
@ -160,7 +159,6 @@ typename A::pointer StandardReallocate(A& alloc, T *oldPtr, typename A::size_typ
} }
} }
/// \class AllocatorWithCleanup
/// \brief Allocates a block of memory with cleanup /// \brief Allocates a block of memory with cleanup
/// \tparam T class or type /// \tparam T class or type
/// \tparam T_Align16 boolean that determines whether allocations should be aligned on a 16-byte boundary /// \tparam T_Align16 boolean that determines whether allocations should be aligned on a 16-byte boundary
@ -273,7 +271,6 @@ CRYPTOPP_DLL_TEMPLATE_CLASS AllocatorWithCleanup<word128, true>; // for Integer
CRYPTOPP_DLL_TEMPLATE_CLASS AllocatorWithCleanup<word, true>; // for Integer CRYPTOPP_DLL_TEMPLATE_CLASS AllocatorWithCleanup<word, true>; // for Integer
#endif #endif
/// \class NullAllocator
/// \brief NULL allocator /// \brief NULL allocator
/// \tparam T class or type /// \tparam T class or type
/// \details A NullAllocator is useful for fixed-size, stack based allocations /// \details A NullAllocator is useful for fixed-size, stack based allocations
@ -307,7 +304,6 @@ public:
//LCOV_EXCL_STOP //LCOV_EXCL_STOP
}; };
/// \class FixedSizeAllocatorWithCleanup
/// \brief Static secure memory block with cleanup /// \brief Static secure memory block with cleanup
/// \tparam T class or type /// \tparam T class or type
/// \tparam S fixed-size of the stack-based memory block, in elements /// \tparam S fixed-size of the stack-based memory block, in elements
@ -451,7 +447,6 @@ private:
bool m_allocated; bool m_allocated;
}; };
/// \class SecBlock
/// \brief Secure memory block with allocator and cleanup /// \brief Secure memory block with allocator and cleanup
/// \tparam T a class or type /// \tparam T a class or type
/// \tparam A AllocatorWithCleanup derived class for allocation and cleanup /// \tparam A AllocatorWithCleanup derived class for allocation and cleanup
@ -823,13 +818,10 @@ protected:
}; };
#ifdef CRYPTOPP_DOXYGEN_PROCESSING #ifdef CRYPTOPP_DOXYGEN_PROCESSING
/// \class SecByteBlock
/// \brief \ref SecBlock "SecBlock<byte>" typedef. /// \brief \ref SecBlock "SecBlock<byte>" typedef.
class SecByteBlock : public SecBlock<byte> {}; class SecByteBlock : public SecBlock<byte> {};
/// \class SecWordBlock
/// \brief \ref SecBlock "SecBlock<word>" typedef. /// \brief \ref SecBlock "SecBlock<word>" typedef.
class SecWordBlock : public SecBlock<word> {}; class SecWordBlock : public SecBlock<word> {};
/// \class AlignedSecByteBlock
/// \brief SecBlock using \ref AllocatorWithCleanup "AllocatorWithCleanup<byte, true>" typedef /// \brief SecBlock using \ref AllocatorWithCleanup "AllocatorWithCleanup<byte, true>" typedef
class AlignedSecByteBlock : public SecBlock<byte, AllocatorWithCleanup<byte, true> > {}; class AlignedSecByteBlock : public SecBlock<byte, AllocatorWithCleanup<byte, true> > {};
#else #else
@ -841,7 +833,6 @@ typedef SecBlock<byte, AllocatorWithCleanup<byte, true> > AlignedSecByteBlock;
// No need for move semantics on derived class *if* the class does not add any // No need for move semantics on derived class *if* the class does not add any
// data members; see http://stackoverflow.com/q/31755703, and Rule of {0|3|5}. // data members; see http://stackoverflow.com/q/31755703, and Rule of {0|3|5}.
/// \class FixedSizeSecBlock
/// \brief Fixed size stack-based SecBlock /// \brief Fixed size stack-based SecBlock
/// \tparam T class or type /// \tparam T class or type
/// \tparam S fixed-size of the stack-based memory block, in elements /// \tparam S fixed-size of the stack-based memory block, in elements
@ -854,7 +845,6 @@ public:
explicit FixedSizeSecBlock() : SecBlock<T, A>(S) {} explicit FixedSizeSecBlock() : SecBlock<T, A>(S) {}
}; };
/// \class FixedSizeAlignedSecBlock
/// \brief Fixed size stack-based SecBlock with 16-byte alignment /// \brief Fixed size stack-based SecBlock with 16-byte alignment
/// \tparam T class or type /// \tparam T class or type
/// \tparam S fixed-size of the stack-based memory block, in elements /// \tparam S fixed-size of the stack-based memory block, in elements
@ -864,7 +854,6 @@ class FixedSizeAlignedSecBlock : public FixedSizeSecBlock<T, S, FixedSizeAllocat
{ {
}; };
/// \class SecBlockWithHint
/// \brief Stack-based SecBlock that grows into the heap /// \brief Stack-based SecBlock that grows into the heap
/// \tparam T class or type /// \tparam T class or type
/// \tparam S fixed-size of the stack-based memory block, in elements /// \tparam S fixed-size of the stack-based memory block, in elements

14
seckey.h
View File

@ -33,7 +33,6 @@ inline CipherDir ReverseCipherDir(CipherDir dir)
return (dir == ENCRYPTION) ? DECRYPTION : ENCRYPTION; return (dir == ENCRYPTION) ? DECRYPTION : ENCRYPTION;
} }
/// \class FixedBlockSize
/// \brief Inherited by algorithms with fixed block size /// \brief Inherited by algorithms with fixed block size
/// \tparam N the blocksize of the algorithm /// \tparam N the blocksize of the algorithm
template <unsigned int N> template <unsigned int N>
@ -69,7 +68,6 @@ public:
// ************** rounds *************** // ************** rounds ***************
/// \class FixedRounds
/// \brief Inherited by algorithms with fixed number of rounds /// \brief Inherited by algorithms with fixed number of rounds
/// \tparam R the number of rounds used by the algorithm /// \tparam R the number of rounds used by the algorithm
template <unsigned int R> template <unsigned int R>
@ -80,7 +78,6 @@ public:
CRYPTOPP_CONSTANT(ROUNDS = R) CRYPTOPP_CONSTANT(ROUNDS = R)
}; };
/// \class VariableRounds
/// \brief Inherited by algorithms with variable number of rounds /// \brief Inherited by algorithms with variable number of rounds
/// \tparam D Default number of rounds /// \tparam D Default number of rounds
/// \tparam N Minimum number of rounds /// \tparam N Minimum number of rounds
@ -140,7 +137,6 @@ protected:
// ************** key length *************** // ************** key length ***************
/// \class FixedKeyLength
/// \brief Inherited by keyed algorithms with fixed key length /// \brief Inherited by keyed algorithms with fixed key length
/// \tparam N Default key length, in bytes /// \tparam N Default key length, in bytes
/// \tparam IV_REQ the \ref SimpleKeyingInterface::IV_Requirement "IV requirements" /// \tparam IV_REQ the \ref SimpleKeyingInterface::IV_Requirement "IV requirements"
@ -179,7 +175,6 @@ public:
} }
}; };
/// \class VariableKeyLength
/// \brief Inherited by keyed algorithms with variable key length /// \brief Inherited by keyed algorithms with variable key length
/// \tparam D Default key length, in bytes /// \tparam D Default key length, in bytes
/// \tparam N Minimum key length, in bytes /// \tparam N Minimum key length, in bytes
@ -235,7 +230,6 @@ public:
} }
}; };
/// \class SameKeyLengthAs
/// \brief Provides key lengths based on another class's key length /// \brief Provides key lengths based on another class's key length
/// \tparam T another FixedKeyLength or VariableKeyLength class /// \tparam T another FixedKeyLength or VariableKeyLength class
/// \tparam IV_REQ the \ref SimpleKeyingInterface::IV_Requirement "IV requirements" /// \tparam IV_REQ the \ref SimpleKeyingInterface::IV_Requirement "IV requirements"
@ -275,7 +269,6 @@ public:
// ************** implementation helper for SimpleKeyingInterface *************** // ************** implementation helper for SimpleKeyingInterface ***************
/// \class SimpleKeyingInterfaceImpl
/// \brief Provides a base implementation of SimpleKeyingInterface /// \brief Provides a base implementation of SimpleKeyingInterface
/// \tparam BASE a SimpleKeyingInterface derived class /// \tparam BASE a SimpleKeyingInterface derived class
/// \tparam INFO a SimpleKeyingInterface derived class /// \tparam INFO a SimpleKeyingInterface derived class
@ -323,7 +316,6 @@ public:
{return INFO::IV_LENGTH;} {return INFO::IV_LENGTH;}
}; };
/// \class BlockCipherImpl
/// \brief Provides a base implementation of Algorithm and SimpleKeyingInterface for block ciphers /// \brief Provides a base implementation of Algorithm and SimpleKeyingInterface for block ciphers
/// \tparam INFO a SimpleKeyingInterface derived class /// \tparam INFO a SimpleKeyingInterface derived class
/// \tparam BASE a SimpleKeyingInterface derived class /// \tparam BASE a SimpleKeyingInterface derived class
@ -339,7 +331,6 @@ public:
unsigned int BlockSize() const {return this->BLOCKSIZE;} unsigned int BlockSize() const {return this->BLOCKSIZE;}
}; };
/// \class BlockCipherFinal
/// \brief Provides class member functions to key a block cipher /// \brief Provides class member functions to key a block cipher
/// \tparam DIR a CipherDir /// \tparam DIR a CipherDir
/// \tparam BASE a BlockCipherImpl derived class /// \tparam BASE a BlockCipherImpl derived class
@ -381,7 +372,6 @@ public:
bool IsForwardTransformation() const {return DIR == ENCRYPTION;} bool IsForwardTransformation() const {return DIR == ENCRYPTION;}
}; };
/// \class MessageAuthenticationCodeImpl
/// \brief Provides a base implementation of Algorithm and SimpleKeyingInterface for message authentication codes /// \brief Provides a base implementation of Algorithm and SimpleKeyingInterface for message authentication codes
/// \tparam INFO a SimpleKeyingInterface derived class /// \tparam INFO a SimpleKeyingInterface derived class
/// \tparam BASE a SimpleKeyingInterface derived class /// \tparam BASE a SimpleKeyingInterface derived class
@ -394,7 +384,6 @@ class MessageAuthenticationCodeImpl : public AlgorithmImpl<SimpleKeyingInterface
{ {
}; };
/// \class MessageAuthenticationCodeFinal
/// \brief Provides class member functions to key a message authentication code /// \brief Provides class member functions to key a message authentication code
/// \tparam BASE a BlockCipherImpl derived class /// \tparam BASE a BlockCipherImpl derived class
/// \details A default implementation for MessageAuthenticationCode /// \details A default implementation for MessageAuthenticationCode
@ -422,7 +411,6 @@ public:
// ************** documentation *************** // ************** documentation ***************
/// \class BlockCipherDocumentation
/// \brief Provides Encryption and Decryption typedefs used by derived classes to /// \brief Provides Encryption and Decryption typedefs used by derived classes to
/// implement a block cipher /// implement a block cipher
/// \details These objects usually should not be used directly. See CipherModeDocumentation /// \details These objects usually should not be used directly. See CipherModeDocumentation
@ -436,7 +424,6 @@ struct BlockCipherDocumentation
typedef BlockCipher Decryption; typedef BlockCipher Decryption;
}; };
/// \class SymmetricCipherDocumentation
/// \brief Provides Encryption and Decryption typedefs used by derived classes to /// \brief Provides Encryption and Decryption typedefs used by derived classes to
/// implement a symmetric cipher /// implement a symmetric cipher
/// \details Each class derived from this one defines two types, Encryption and Decryption, /// \details Each class derived from this one defines two types, Encryption and Decryption,
@ -452,7 +439,6 @@ struct SymmetricCipherDocumentation
typedef SymmetricCipher Decryption; typedef SymmetricCipher Decryption;
}; };
/// \class AuthenticatedSymmetricCipherDocumentation
/// \brief Provides Encryption and Decryption typedefs used by derived classes to /// \brief Provides Encryption and Decryption typedefs used by derived classes to
/// implement an authenticated encryption cipher /// implement an authenticated encryption cipher
/// \details Each class derived from this one defines two types, Encryption and Decryption, /// \details Each class derived from this one defines two types, Encryption and Decryption,

2
seed.h
View File

@ -12,7 +12,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class SEED_Info
/// \brief SEED block cipher information /// \brief SEED block cipher information
/// \since Crypto++ 5.6.0 /// \since Crypto++ 5.6.0
struct SEED_Info : public FixedBlockSize<16>, public FixedKeyLength<16>, public FixedRounds<16> struct SEED_Info : public FixedBlockSize<16>, public FixedKeyLength<16>, public FixedRounds<16>
@ -20,7 +19,6 @@ struct SEED_Info : public FixedBlockSize<16>, public FixedKeyLength<16>, public
CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "SEED";} CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "SEED";}
}; };
/// \class SEED
/// \brief SEED block cipher /// \brief SEED block cipher
/// \sa <a href="http://www.cryptolounge.org/wiki/SEED">SEED</a> /// \sa <a href="http://www.cryptolounge.org/wiki/SEED">SEED</a>
/// \since Crypto++ 5.6.0 /// \since Crypto++ 5.6.0

2
serpent.h
View File

@ -11,14 +11,12 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class Serpent_Info
/// \brief Serpent block cipher information /// \brief Serpent block cipher information
struct Serpent_Info : public FixedBlockSize<16>, public VariableKeyLength<16, 16, 32, 8>, public FixedRounds<32> struct Serpent_Info : public FixedBlockSize<16>, public VariableKeyLength<16, 16, 32, 8>, public FixedRounds<32>
{ {
CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "Serpent";} CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "Serpent";}
}; };
/// \class Serpent
/// \brief Serpent block cipher /// \brief Serpent block cipher
/// \sa <a href="http://www.cryptopp.com/wiki/Serpent">Serpent</a> /// \sa <a href="http://www.cryptopp.com/wiki/Serpent">Serpent</a>
class Serpent : public Serpent_Info, public BlockCipherDocumentation class Serpent : public Serpent_Info, public BlockCipherDocumentation

5
sha.h
View File

@ -19,7 +19,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class SHA1
/// \brief SHA-1 message digest /// \brief SHA-1 message digest
/// \sa <a href="http://www.weidai.com/scan-mirror/md.html#SHA-1">SHA-1</a> /// \sa <a href="http://www.weidai.com/scan-mirror/md.html#SHA-1">SHA-1</a>
/// \since Crypto++ 1.0, Intel SHA extensions since Crypto++ 6.0 /// \since Crypto++ 1.0, Intel SHA extensions since Crypto++ 6.0
@ -55,7 +54,6 @@ protected:
size_t HashMultipleBlocks(const HashWordType *input, size_t length); size_t HashMultipleBlocks(const HashWordType *input, size_t length);
}; };
/// \class SHA256
/// \brief SHA-256 message digest /// \brief SHA-256 message digest
/// \sa <a href="http://www.weidai.com/scan-mirror/md.html#SHA-256">SHA-256</a> /// \sa <a href="http://www.weidai.com/scan-mirror/md.html#SHA-256">SHA-256</a>
/// \since Crypto++ 4.0, Intel SHA extensions since Crypto++ 6.0 /// \since Crypto++ 4.0, Intel SHA extensions since Crypto++ 6.0
@ -91,7 +89,6 @@ protected:
size_t HashMultipleBlocks(const HashWordType *input, size_t length); size_t HashMultipleBlocks(const HashWordType *input, size_t length);
}; };
/// \class SHA224
/// \brief SHA-224 message digest /// \brief SHA-224 message digest
/// \sa <a href="http://www.weidai.com/scan-mirror/md.html#SHA-224">SHA-224</a> /// \sa <a href="http://www.weidai.com/scan-mirror/md.html#SHA-224">SHA-224</a>
/// \since Crypto++ 4.0, Intel SHA extensions since Crypto++ 6.0 /// \since Crypto++ 4.0, Intel SHA extensions since Crypto++ 6.0
@ -127,7 +124,6 @@ protected:
size_t HashMultipleBlocks(const HashWordType *input, size_t length); size_t HashMultipleBlocks(const HashWordType *input, size_t length);
}; };
/// \class SHA512
/// \brief SHA-512 message digest /// \brief SHA-512 message digest
/// \sa <a href="http://www.weidai.com/scan-mirror/md.html#SHA-512">SHA-512</a> /// \sa <a href="http://www.weidai.com/scan-mirror/md.html#SHA-512">SHA-512</a>
/// \since Crypto++ 4.0 /// \since Crypto++ 4.0
@ -160,7 +156,6 @@ public:
CRYPTOPP_STATIC_CONSTEXPR const char* CRYPTOPP_API StaticAlgorithmName() {return "SHA-512";} CRYPTOPP_STATIC_CONSTEXPR const char* CRYPTOPP_API StaticAlgorithmName() {return "SHA-512";}
}; };
/// \class SHA384
/// \brief SHA-384 message digest /// \brief SHA-384 message digest
/// \sa <a href="http://www.weidai.com/scan-mirror/md.html#SHA-384">SHA-384</a> /// \sa <a href="http://www.weidai.com/scan-mirror/md.html#SHA-384">SHA-384</a>
/// \since Crypto++ 4.0 /// \since Crypto++ 4.0

2
sha3.h
View File

@ -16,7 +16,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class SHA3
/// \brief SHA3 message digest base class /// \brief SHA3 message digest base class
/// \details The Crypto++ implementation conforms to FIPS 202 version of SHA3 using F1600 with XOF d=0x06. /// \details The Crypto++ implementation conforms to FIPS 202 version of SHA3 using F1600 with XOF d=0x06.
/// Previous behavior (XOF d=0x01) is available in Keccak classes. /// Previous behavior (XOF d=0x01) is available in Keccak classes.
@ -51,7 +50,6 @@ protected:
unsigned int m_digestSize, m_counter; unsigned int m_digestSize, m_counter;
}; };
/// \class SHA3_Final
/// \brief SHA3 message digest template /// \brief SHA3 message digest template
/// \tparam T_DigestSize the size of the digest, in bytes /// \tparam T_DigestSize the size of the digest, in bytes
/// \since Crypto++ 5.6.2 /// \since Crypto++ 5.6.2

2
shacal2.h
View File

@ -12,14 +12,12 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class SHACAL2_Info
/// \brief SHACAL2 block cipher information /// \brief SHACAL2 block cipher information
struct SHACAL2_Info : public FixedBlockSize<32>, public VariableKeyLength<16, 16, 64> struct SHACAL2_Info : public FixedBlockSize<32>, public VariableKeyLength<16, 16, 64>
{ {
CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "SHACAL-2";} CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "SHACAL-2";}
}; };
/// \class SHACAL2
/// \brief SHACAL2 block cipher /// \brief SHACAL2 block cipher
/// \since Crypto++ 5.2, Intel SHA since Crypto++ 6.0 /// \since Crypto++ 5.2, Intel SHA since Crypto++ 6.0
/// \sa <a href="http://www.cryptopp.com/wiki/SHACAL-2">SHACAL-2</a> /// \sa <a href="http://www.cryptopp.com/wiki/SHACAL-2">SHACAL-2</a>

5
shark.h
View File

@ -12,19 +12,16 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class SHARK_Info
/// \brief SHARK block cipher information /// \brief SHARK block cipher information
struct SHARK_Info : public FixedBlockSize<8>, public FixedKeyLength<16>, public VariableRounds<6, 2> struct SHARK_Info : public FixedBlockSize<8>, public FixedKeyLength<16>, public VariableRounds<6, 2>
{ {
CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "SHARK-E";} CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "SHARK-E";}
}; };
/// \class SHARK
/// \brief SHARK block cipher /// \brief SHARK block cipher
/// <a href="http://www.cryptopp.com/wiki/SHARK-E">SHARK-E</a> /// <a href="http://www.cryptopp.com/wiki/SHARK-E">SHARK-E</a>
class SHARK : public SHARK_Info, public BlockCipherDocumentation class SHARK : public SHARK_Info, public BlockCipherDocumentation
{ {
/// \class Base
/// \brief SHARK block cipher default operation /// \brief SHARK block cipher default operation
class CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<SHARK_Info> class CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<SHARK_Info>
{ {
@ -36,7 +33,6 @@ class SHARK : public SHARK_Info, public BlockCipherDocumentation
SecBlock<word64> m_roundKeys; SecBlock<word64> m_roundKeys;
}; };
/// \class Enc
/// \brief SHARK block cipher encryption operation /// \brief SHARK block cipher encryption operation
class CRYPTOPP_NO_VTABLE Enc : public Base class CRYPTOPP_NO_VTABLE Enc : public Base
{ {
@ -51,7 +47,6 @@ class SHARK : public SHARK_Info, public BlockCipherDocumentation
static const word64 cbox[8][256]; static const word64 cbox[8][256];
}; };
/// \class Dec
/// \brief SHARK block cipher decryption operation /// \brief SHARK block cipher decryption operation
class CRYPTOPP_NO_VTABLE Dec : public Base class CRYPTOPP_NO_VTABLE Dec : public Base
{ {

4
simon.h
View File

@ -26,7 +26,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class SIMON_Info
/// \brief SIMON block cipher information /// \brief SIMON block cipher information
/// \tparam L block size of the cipher, in bytes /// \tparam L block size of the cipher, in bytes
/// \tparam D default key length, in bytes /// \tparam D default key length, in bytes
@ -43,7 +42,6 @@ struct SIMON_Info : public FixedBlockSize<L>, VariableKeyLength<D, N, M>
} }
}; };
/// \class SIMON_Base
/// \brief SIMON block cipher base class /// \brief SIMON block cipher base class
/// \tparam W the word type /// \tparam W the word type
/// \details User code should use SIMON64 or SIMON128 /// \details User code should use SIMON64 or SIMON128
@ -62,7 +60,6 @@ SIMON_Base() : m_kwords(0), m_rounds(0) {}
unsigned int m_rounds; // number of rounds unsigned int m_rounds; // number of rounds
}; };
/// \class SIMON64
/// \brief SIMON 64-bit block cipher /// \brief SIMON 64-bit block cipher
/// \details Simon is a block cipher designed by Ray Beaulieu, Douglas Shors, Jason Smith, /// \details Simon is a block cipher designed by Ray Beaulieu, Douglas Shors, Jason Smith,
/// Stefan Treatman-Clark, Bryan Weeks and Louis Wingers. /// Stefan Treatman-Clark, Bryan Weeks and Louis Wingers.
@ -120,7 +117,6 @@ public:
typedef BlockCipherFinal<DECRYPTION, Dec> Decryption; typedef BlockCipherFinal<DECRYPTION, Dec> Decryption;
}; };
/// \class SIMON128
/// \brief SIMON 128-bit block cipher /// \brief SIMON 128-bit block cipher
/// \details Simon is a block cipher designed by Ray Beaulieu, Douglas Shors, Jason Smith, /// \details Simon is a block cipher designed by Ray Beaulieu, Douglas Shors, Jason Smith,
/// Stefan Treatman-Clark, Bryan Weeks and Louis Wingers. /// Stefan Treatman-Clark, Bryan Weeks and Louis Wingers.

17
simple.h
View File

@ -18,7 +18,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class ClonableImpl
/// \brief Base class for identifying alogorithm /// \brief Base class for identifying alogorithm
/// \tparam BASE base class from which to derive /// \tparam BASE base class from which to derive
/// \tparam DERIVED class which to clone /// \tparam DERIVED class which to clone
@ -29,7 +28,6 @@ public:
Clonable * Clone() const {return new DERIVED(*static_cast<const DERIVED *>(this));} Clonable * Clone() const {return new DERIVED(*static_cast<const DERIVED *>(this));}
}; };
/// \class AlgorithmImpl
/// \brief Base class information /// \brief Base class information
/// \tparam BASE an Algorithm derived class /// \tparam BASE an Algorithm derived class
/// \tparam ALGORITHM_INFO an Algorithm derived class /// \tparam ALGORITHM_INFO an Algorithm derived class
@ -50,7 +48,6 @@ public:
std::string AlgorithmName() const {return ALGORITHM_INFO::StaticAlgorithmName();} std::string AlgorithmName() const {return ALGORITHM_INFO::StaticAlgorithmName();}
}; };
/// \class InvalidKeyLength
/// \brief Exception thrown when an invalid key length is encountered /// \brief Exception thrown when an invalid key length is encountered
class CRYPTOPP_DLL InvalidKeyLength : public InvalidArgument class CRYPTOPP_DLL InvalidKeyLength : public InvalidArgument
{ {
@ -58,7 +55,6 @@ public:
explicit InvalidKeyLength(const std::string &algorithm, size_t length) : InvalidArgument(algorithm + ": " + IntToString(length) + " is not a valid key length") {} explicit InvalidKeyLength(const std::string &algorithm, size_t length) : InvalidArgument(algorithm + ": " + IntToString(length) + " is not a valid key length") {}
}; };
/// \class InvalidRounds
/// \brief Exception thrown when an invalid number of rounds is encountered /// \brief Exception thrown when an invalid number of rounds is encountered
class CRYPTOPP_DLL InvalidRounds : public InvalidArgument class CRYPTOPP_DLL InvalidRounds : public InvalidArgument
{ {
@ -66,7 +62,6 @@ public:
explicit InvalidRounds(const std::string &algorithm, unsigned int rounds) : InvalidArgument(algorithm + ": " + IntToString(rounds) + " is not a valid number of rounds") {} explicit InvalidRounds(const std::string &algorithm, unsigned int rounds) : InvalidArgument(algorithm + ": " + IntToString(rounds) + " is not a valid number of rounds") {}
}; };
/// \class InvalidBlockSize
/// \brief Exception thrown when an invalid block size is encountered /// \brief Exception thrown when an invalid block size is encountered
class CRYPTOPP_DLL InvalidBlockSize : public InvalidArgument class CRYPTOPP_DLL InvalidBlockSize : public InvalidArgument
{ {
@ -74,7 +69,6 @@ public:
explicit InvalidBlockSize(const std::string &algorithm, size_t length) : InvalidArgument(algorithm + ": " + IntToString(length) + " is not a valid block size") {} explicit InvalidBlockSize(const std::string &algorithm, size_t length) : InvalidArgument(algorithm + ": " + IntToString(length) + " is not a valid block size") {}
}; };
/// \class InvalidPersonalizationLength
/// \brief Exception thrown when an invalid personalization string length is encountered /// \brief Exception thrown when an invalid personalization string length is encountered
class CRYPTOPP_DLL InvalidPersonalizationLength : public InvalidArgument class CRYPTOPP_DLL InvalidPersonalizationLength : public InvalidArgument
{ {
@ -82,7 +76,6 @@ public:
explicit InvalidPersonalizationLength(const std::string &algorithm, size_t length) : InvalidArgument(algorithm + ": " + IntToString(length) + " is not a valid salt length") {} explicit InvalidPersonalizationLength(const std::string &algorithm, size_t length) : InvalidArgument(algorithm + ": " + IntToString(length) + " is not a valid salt length") {}
}; };
/// \class InvalidSaltLength
/// \brief Exception thrown when an invalid salt length is encountered /// \brief Exception thrown when an invalid salt length is encountered
class CRYPTOPP_DLL InvalidSaltLength : public InvalidArgument class CRYPTOPP_DLL InvalidSaltLength : public InvalidArgument
{ {
@ -92,7 +85,6 @@ public:
// ***************************** // *****************************
/// \class Bufferless
/// \brief Base class for bufferless filters /// \brief Base class for bufferless filters
/// \tparam T the class or type /// \tparam T the class or type
template <class T> template <class T>
@ -103,7 +95,6 @@ public:
{CRYPTOPP_UNUSED(hardFlush); CRYPTOPP_UNUSED(blocking); return false;} {CRYPTOPP_UNUSED(hardFlush); CRYPTOPP_UNUSED(blocking); return false;}
}; };
/// \class Unflushable
/// \brief Base class for unflushable filters /// \brief Base class for unflushable filters
/// \tparam T the class or type /// \tparam T the class or type
template <class T> template <class T>
@ -129,7 +120,6 @@ protected:
virtual bool InputBufferIsEmpty() const {return false;} virtual bool InputBufferIsEmpty() const {return false;}
}; };
/// \class InputRejecting
/// \brief Base class for input rejecting filters /// \brief Base class for input rejecting filters
/// \tparam T the class or type /// \tparam T the class or type
/// \details T should be a BufferedTransformation derived class /// \details T should be a BufferedTransformation derived class
@ -168,7 +158,6 @@ public:
//@} //@}
}; };
/// \class CustomFlushPropagation
/// \brief Interface for custom flush signals propagation /// \brief Interface for custom flush signals propagation
/// \tparam T BufferedTransformation derived class /// \tparam T BufferedTransformation derived class
template <class T> template <class T>
@ -201,7 +190,6 @@ private:
{CRYPTOPP_UNUSED(hardFlush); CRYPTOPP_UNUSED(blocking); CRYPTOPP_ASSERT(false); return false;} {CRYPTOPP_UNUSED(hardFlush); CRYPTOPP_UNUSED(blocking); CRYPTOPP_ASSERT(false); return false;}
}; };
/// \class CustomSignalPropagation
/// \brief Interface for custom flush signals /// \brief Interface for custom flush signals
/// \tparam T BufferedTransformation derived class /// \tparam T BufferedTransformation derived class
template <class T> template <class T>
@ -223,7 +211,6 @@ private:
{CRYPTOPP_UNUSED(parameters); CRYPTOPP_ASSERT(false);} {CRYPTOPP_UNUSED(parameters); CRYPTOPP_ASSERT(false);}
}; };
/// \class Multichannel
/// \brief Multiple channels support for custom signal processing /// \brief Multiple channels support for custom signal processing
/// \tparam T the class or type /// \tparam T the class or type
/// \details T should be a BufferedTransformation derived class /// \details T should be a BufferedTransformation derived class
@ -289,7 +276,6 @@ public:
virtual bool ChannelFlush(const std::string &channel, bool hardFlush, int propagation=-1, bool blocking=true) =0; virtual bool ChannelFlush(const std::string &channel, bool hardFlush, int propagation=-1, bool blocking=true) =0;
}; };
/// \class AutoSignaling
/// \brief Provides auto signaling support /// \brief Provides auto signaling support
/// \tparam T BufferedTransformation derived class /// \tparam T BufferedTransformation derived class
template <class T> template <class T>
@ -309,7 +295,6 @@ private:
int m_autoSignalPropagation; int m_autoSignalPropagation;
}; };
/// \class Store
/// \brief Acts as a Source for pre-existing, static data /// \brief Acts as a Source for pre-existing, static data
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE Store : public AutoSignaling<InputRejecting<BufferedTransformation> > class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE Store : public AutoSignaling<InputRejecting<BufferedTransformation> >
{ {
@ -333,7 +318,6 @@ protected:
bool m_messageEnd; bool m_messageEnd;
}; };
/// \class Sink
/// \brief Implementation of BufferedTransformation's attachment interface /// \brief Implementation of BufferedTransformation's attachment interface
/// \details Sink is a cornerstone of the Pipeline trinitiy. Data flows from /// \details Sink is a cornerstone of the Pipeline trinitiy. Data flows from
/// Sources, through Filters, and then terminates in Sinks. The difference /// Sources, through Filters, and then terminates in Sinks. The difference
@ -352,7 +336,6 @@ public:
{CRYPTOPP_UNUSED(target); CRYPTOPP_UNUSED(begin); CRYPTOPP_UNUSED(end); CRYPTOPP_UNUSED(channel); CRYPTOPP_UNUSED(blocking); return 0;} {CRYPTOPP_UNUSED(target); CRYPTOPP_UNUSED(begin); CRYPTOPP_UNUSED(end); CRYPTOPP_UNUSED(channel); CRYPTOPP_UNUSED(blocking); return 0;}
}; };
/// \class BitBucket
/// \brief Acts as an input discarding Filter or Sink /// \brief Acts as an input discarding Filter or Sink
/// \details The BitBucket discards all input and returns 0 to the caller /// \details The BitBucket discards all input and returns 0 to the caller
/// to indicate all data was processed. /// to indicate all data was processed.

3
siphash.h
View File

@ -32,7 +32,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class SipHash_Info
/// \brief SipHash message authentication code information /// \brief SipHash message authentication code information
/// \tparam T_128bit flag indicating 128-bit (true) versus 64-bit (false) digest size /// \tparam T_128bit flag indicating 128-bit (true) versus 64-bit (false) digest size
template <bool T_128bit> template <bool T_128bit>
@ -43,7 +42,6 @@ public:
CRYPTOPP_CONSTANT(DIGESTSIZE = (T_128bit ? 16 : 8)) CRYPTOPP_CONSTANT(DIGESTSIZE = (T_128bit ? 16 : 8))
}; };
/// \class SipHash_Base
/// \brief SipHash message authentication code base class /// \brief SipHash message authentication code base class
/// \tparam C the number of compression rounds /// \tparam C the number of compression rounds
/// \tparam D the number of finalization rounds /// \tparam D the number of finalization rounds
@ -115,7 +113,6 @@ private:
size_t m_idx; size_t m_idx;
}; };
/// \class SipHash
/// \brief SipHash message authentication code /// \brief SipHash message authentication code
/// \tparam C the number of compression rounds /// \tparam C the number of compression rounds
/// \tparam D the number of finalization rounds /// \tparam D the number of finalization rounds

5
skipjack.h
View File

@ -11,19 +11,16 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class SKIPJACK_Info
/// \brief SKIPJACK block cipher information /// \brief SKIPJACK block cipher information
struct SKIPJACK_Info : public FixedBlockSize<8>, public FixedKeyLength<10> struct SKIPJACK_Info : public FixedBlockSize<8>, public FixedKeyLength<10>
{ {
CRYPTOPP_DLL static const char * CRYPTOPP_API StaticAlgorithmName() {return "SKIPJACK";} CRYPTOPP_DLL static const char * CRYPTOPP_API StaticAlgorithmName() {return "SKIPJACK";}
}; };
/// \class SKIPJACK
/// \brief SKIPJACK block cipher /// \brief SKIPJACK block cipher
/// \sa <a href="http://www.cryptopp.com/wiki/SKIPJACK">SKIPJACK</a> /// \sa <a href="http://www.cryptopp.com/wiki/SKIPJACK">SKIPJACK</a>
class SKIPJACK : public SKIPJACK_Info, public BlockCipherDocumentation class SKIPJACK : public SKIPJACK_Info, public BlockCipherDocumentation
{ {
/// \class Base
/// \brief SKIPJACK block cipher default operation /// \brief SKIPJACK block cipher default operation
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<SKIPJACK_Info> class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<SKIPJACK_Info>
{ {
@ -37,7 +34,6 @@ class SKIPJACK : public SKIPJACK_Info, public BlockCipherDocumentation
FixedSizeSecBlock<byte, 10*256> tab; FixedSizeSecBlock<byte, 10*256> tab;
}; };
/// \class Enc
/// \brief SKIPJACK block cipher encryption operation /// \brief SKIPJACK block cipher encryption operation
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE Enc : public Base class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE Enc : public Base
{ {
@ -48,7 +44,6 @@ class SKIPJACK : public SKIPJACK_Info, public BlockCipherDocumentation
static const word32 Te[4][256]; static const word32 Te[4][256];
}; };
/// \class Dec
/// \brief SKIPJACK block cipher decryption operation /// \brief SKIPJACK block cipher decryption operation
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE Dec : public Base class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE Dec : public Base
{ {

1
sm3.h
View File

@ -19,7 +19,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class SM3
/// \brief SM3 hash function /// \brief SM3 hash function
/// \details SM3 is a hash function designed by Xiaoyun Wang, et al. The hash is part of the /// \details SM3 is a hash function designed by Xiaoyun Wang, et al. The hash is part of the
/// Chinese State Cryptography Administration portfolio. /// Chinese State Cryptography Administration portfolio.

2
sm4.h
View File

@ -17,7 +17,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class SM4_Info
/// \brief SM4 block cipher information /// \brief SM4 block cipher information
/// \since Crypto++ 6.0 /// \since Crypto++ 6.0
struct SM4_Info : public FixedBlockSize<16>, FixedKeyLength<16> struct SM4_Info : public FixedBlockSize<16>, FixedKeyLength<16>
@ -28,7 +27,6 @@ struct SM4_Info : public FixedBlockSize<16>, FixedKeyLength<16>
} }
}; };
/// \class SM4
/// \brief Classes for the SM4 block cipher /// \brief Classes for the SM4 block cipher
/// \details SM4 is a block cipher designed by Xiaoyun Wang, et al. The block cipher is part of the /// \details SM4 is a block cipher designed by Xiaoyun Wang, et al. The block cipher is part of the
/// Chinese State Cryptography Administration portfolio. The cipher was formely known as SMS4. /// Chinese State Cryptography Administration portfolio. The cipher was formely known as SMS4.

7
smartptr.h
View File

@ -12,7 +12,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class simple_ptr
/// \brief Manages resources for a single object /// \brief Manages resources for a single object
/// \tparam T class or type /// \tparam T class or type
/// \details \p simple_ptr is used frequently in the library to manage resources and /// \details \p simple_ptr is used frequently in the library to manage resources and
@ -30,7 +29,6 @@ public:
T *m_p; T *m_p;
}; };
/// \class member_ptr
/// \brief Pointer that overloads operator -> /// \brief Pointer that overloads operator ->
/// \tparam T class or type /// \tparam T class or type
/// \details member_ptr is used frequently in the library to avoid the issues related to /// \details member_ptr is used frequently in the library to avoid the issues related to
@ -73,7 +71,6 @@ template <class T> void member_ptr<T>::reset(T *p) {delete m_p; m_p = p;}
// ******************************************************** // ********************************************************
/// \class value_ptr
/// \brief Value pointer /// \brief Value pointer
/// \tparam T class or type /// \tparam T class or type
template<class T> class value_ptr : public member_ptr<T> template<class T> class value_ptr : public member_ptr<T>
@ -101,7 +98,6 @@ template <class T> value_ptr<T>& value_ptr<T>::operator=(const value_ptr<T>& rhs
// ******************************************************** // ********************************************************
/// \class clonable_ptr
/// \brief A pointer which can be copied and cloned /// \brief A pointer which can be copied and cloned
/// \tparam T class or type /// \tparam T class or type
/// \details \p T should adhere to the \p Clonable interface /// \details \p T should adhere to the \p Clonable interface
@ -126,7 +122,6 @@ template <class T> clonable_ptr<T>& clonable_ptr<T>::operator=(const clonable_pt
// ******************************************************** // ********************************************************
/// \class counted_ptr
/// \brief Reference counted pointer /// \brief Reference counted pointer
/// \tparam T class or type /// \tparam T class or type
/// \details users should declare \p m_referenceCount as <tt>std::atomic<unsigned></tt> /// \details users should declare \p m_referenceCount as <tt>std::atomic<unsigned></tt>
@ -220,7 +215,6 @@ template <class T> counted_ptr<T> & counted_ptr<T>::operator=(const counted_ptr<
// ******************************************************** // ********************************************************
/// \class vector_ptr
/// \brief Manages resources for an array of objects /// \brief Manages resources for an array of objects
/// \tparam T class or type /// \tparam T class or type
/// \details \p vector_ptr is used frequently in the library to avoid large stack allocations, /// \details \p vector_ptr is used frequently in the library to avoid large stack allocations,
@ -278,7 +272,6 @@ private:
// ******************************************************** // ********************************************************
/// \class vector_member_ptrs
/// \brief Manages resources for an array of objects /// \brief Manages resources for an array of objects
/// \tparam T class or type /// \tparam T class or type
template <class T> class vector_member_ptrs template <class T> class vector_member_ptrs

3
sosemanuk.h
View File

@ -18,7 +18,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class SosemanukInfo
/// \brief Sosemanuk stream cipher information /// \brief Sosemanuk stream cipher information
/// \since Crypto++ 5.5 /// \since Crypto++ 5.5
struct SosemanukInfo : public VariableKeyLength<16, 1, 32, 1, SimpleKeyingInterface::UNIQUE_IV, 16> struct SosemanukInfo : public VariableKeyLength<16, 1, 32, 1, SimpleKeyingInterface::UNIQUE_IV, 16>
@ -26,7 +25,6 @@ struct SosemanukInfo : public VariableKeyLength<16, 1, 32, 1, SimpleKeyingInterf
CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "Sosemanuk";} CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "Sosemanuk";}
}; };
/// \class SosemanukPolicy
/// \brief Sosemanuk stream cipher implementation /// \brief Sosemanuk stream cipher implementation
/// \since Crypto++ 5.5 /// \since Crypto++ 5.5
class SosemanukPolicy : public AdditiveCipherConcretePolicy<word32, 20>, public SosemanukInfo class SosemanukPolicy : public AdditiveCipherConcretePolicy<word32, 20>, public SosemanukInfo
@ -45,7 +43,6 @@ protected:
FixedSizeAlignedSecBlock<word32, 12> m_state; FixedSizeAlignedSecBlock<word32, 12> m_state;
}; };
/// \class Sosemanuk
/// \brief Sosemanuk stream cipher /// \brief Sosemanuk stream cipher
/// \details is a stream cipher developed by Come Berbain, Olivier Billet, Anne Canteaut, Nicolas Courtois, /// \details is a stream cipher developed by Come Berbain, Olivier Billet, Anne Canteaut, Nicolas Courtois,
/// Henri Gilbert, Louis Goubin, Aline Gouget, Louis Granboulan, Cédric Lauradoux, Marine Minier, Thomas /// Henri Gilbert, Louis Goubin, Aline Gouget, Louis Granboulan, Cédric Lauradoux, Marine Minier, Thomas

4
speck.h
View File

@ -26,7 +26,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class SPECK_Info
/// \brief SPECK block cipher information /// \brief SPECK block cipher information
/// \tparam L block size of the cipher, in bytes /// \tparam L block size of the cipher, in bytes
/// \tparam D default key length, in bytes /// \tparam D default key length, in bytes
@ -43,7 +42,6 @@ struct SPECK_Info : public FixedBlockSize<L>, VariableKeyLength<D, N, M>
} }
}; };
/// \class SPECK_Base
/// \brief SPECK block cipher base class /// \brief SPECK block cipher base class
/// \tparam W the word type /// \tparam W the word type
/// \details User code should use SPECK64 or SPECK128 /// \details User code should use SPECK64 or SPECK128
@ -62,7 +60,6 @@ struct SPECK_Base
unsigned int m_rounds; // number of rounds unsigned int m_rounds; // number of rounds
}; };
/// \class SPECK64
/// \brief SPECK 64-bit block cipher /// \brief SPECK 64-bit block cipher
/// \details Speck is a block cipher designed by Ray Beaulieu, Douglas Shors, Jason Smith, /// \details Speck is a block cipher designed by Ray Beaulieu, Douglas Shors, Jason Smith,
/// Stefan Treatman-Clark, Bryan Weeks and Louis Wingers. /// Stefan Treatman-Clark, Bryan Weeks and Louis Wingers.
@ -120,7 +117,6 @@ public:
typedef BlockCipherFinal<DECRYPTION, Dec> Decryption; typedef BlockCipherFinal<DECRYPTION, Dec> Decryption;
}; };
/// \class SPECK128
/// \brief SPECK 128-bit block cipher /// \brief SPECK 128-bit block cipher
/// \details Speck is a block cipher designed by Ray Beaulieu, Douglas Shors, Jason Smith, /// \details Speck is a block cipher designed by Ray Beaulieu, Douglas Shors, Jason Smith,
/// Stefan Treatman-Clark, Bryan Weeks and Louis Wingers. /// Stefan Treatman-Clark, Bryan Weeks and Louis Wingers.

2
square.h
View File

@ -11,14 +11,12 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class Square_Info
/// \brief Square block cipher information /// \brief Square block cipher information
struct Square_Info : public FixedBlockSize<16>, public FixedKeyLength<16>, FixedRounds<8> struct Square_Info : public FixedBlockSize<16>, public FixedKeyLength<16>, FixedRounds<8>
{ {
CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "Square";} CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "Square";}
}; };
/// \class Square
/// \brief Square block cipher /// \brief Square block cipher
/// \sa <a href="http://www.cryptopp.com/wiki/Square">Square</a> /// \sa <a href="http://www.cryptopp.com/wiki/Square">Square</a>
class Square : public Square_Info, public BlockCipherDocumentation class Square : public Square_Info, public BlockCipherDocumentation

12
strciphr.h
View File

@ -42,7 +42,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class AbstractPolicyHolder
/// \brief Access a stream cipher policy object /// \brief Access a stream cipher policy object
/// \tparam POLICY_INTERFACE class implementing AbstractPolicyHolder /// \tparam POLICY_INTERFACE class implementing AbstractPolicyHolder
/// \tparam BASE class or type to use as a base class /// \tparam BASE class or type to use as a base class
@ -58,7 +57,6 @@ protected:
virtual POLICY_INTERFACE & AccessPolicy() =0; virtual POLICY_INTERFACE & AccessPolicy() =0;
}; };
/// \class ConcretePolicyHolder
/// \brief Stream cipher policy object /// \brief Stream cipher policy object
/// \tparam POLICY class implementing AbstractPolicyHolder /// \tparam POLICY class implementing AbstractPolicyHolder
/// \tparam BASE class or type to use as a base class /// \tparam BASE class or type to use as a base class
@ -101,7 +99,6 @@ enum KeystreamOperation {
/// \brief XOR the aligned input buffer and keystream, write to the aligned output buffer /// \brief XOR the aligned input buffer and keystream, write to the aligned output buffer
XOR_KEYSTREAM_BOTH_ALIGNED = OUTPUT_ALIGNED | INPUT_ALIGNED}; XOR_KEYSTREAM_BOTH_ALIGNED = OUTPUT_ALIGNED | INPUT_ALIGNED};
/// \class AdditiveCipherAbstractPolicy
/// \brief Policy object for additive stream ciphers /// \brief Policy object for additive stream ciphers
struct CRYPTOPP_DLL CRYPTOPP_NO_VTABLE AdditiveCipherAbstractPolicy struct CRYPTOPP_DLL CRYPTOPP_NO_VTABLE AdditiveCipherAbstractPolicy
{ {
@ -175,7 +172,6 @@ struct CRYPTOPP_DLL CRYPTOPP_NO_VTABLE AdditiveCipherAbstractPolicy
{CRYPTOPP_UNUSED(iterationCount); CRYPTOPP_ASSERT(!CipherIsRandomAccess()); throw NotImplemented("StreamTransformation: this object doesn't support random access");} {CRYPTOPP_UNUSED(iterationCount); CRYPTOPP_ASSERT(!CipherIsRandomAccess()); throw NotImplemented("StreamTransformation: this object doesn't support random access");}
}; };
/// \class AdditiveCipherConcretePolicy
/// \brief Base class for additive stream ciphers /// \brief Base class for additive stream ciphers
/// \tparam WT word type /// \tparam WT word type
/// \tparam W count of words /// \tparam W count of words
@ -259,7 +255,6 @@ struct CRYPTOPP_NO_VTABLE AdditiveCipherConcretePolicy : public BASE
} \ } \
output += y; output += y;
/// \class AdditiveCipherTemplate
/// \brief Base class for additive stream ciphers with SymmetricCipher interface /// \brief Base class for additive stream ciphers with SymmetricCipher interface
/// \tparam BASE AbstractPolicyHolder base class /// \tparam BASE AbstractPolicyHolder base class
template <class BASE = AbstractPolicyHolder<AdditiveCipherAbstractPolicy, SymmetricCipher> > template <class BASE = AbstractPolicyHolder<AdditiveCipherAbstractPolicy, SymmetricCipher> >
@ -344,7 +339,6 @@ protected:
size_t m_leftOver; size_t m_leftOver;
}; };
/// \class CFB_CipherAbstractPolicy
/// \brief Policy object for feeback based stream ciphers /// \brief Policy object for feeback based stream ciphers
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CFB_CipherAbstractPolicy class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CFB_CipherAbstractPolicy
{ {
@ -396,7 +390,6 @@ public:
{CRYPTOPP_UNUSED(iv); CRYPTOPP_UNUSED(length); throw NotImplemented("SimpleKeyingInterface: this object doesn't support resynchronization");} {CRYPTOPP_UNUSED(iv); CRYPTOPP_UNUSED(length); throw NotImplemented("SimpleKeyingInterface: this object doesn't support resynchronization");}
}; };
/// \class CFB_CipherConcretePolicy
/// \brief Base class for feedback based stream ciphers /// \brief Base class for feedback based stream ciphers
/// \tparam WT word type /// \tparam WT word type
/// \tparam W count of words /// \tparam W count of words
@ -481,7 +474,6 @@ struct CRYPTOPP_NO_VTABLE CFB_CipherConcretePolicy : public BASE
}; };
}; };
/// \class CFB_CipherTemplate
/// \brief Base class for feedback based stream ciphers with SymmetricCipher interface /// \brief Base class for feedback based stream ciphers with SymmetricCipher interface
/// \tparam BASE AbstractPolicyHolder base class /// \tparam BASE AbstractPolicyHolder base class
template <class BASE> template <class BASE>
@ -544,7 +536,6 @@ protected:
size_t m_leftOver; size_t m_leftOver;
}; };
/// \class CFB_EncryptionTemplate
/// \brief Base class for feedback based stream ciphers in the forward direction with SymmetricCipher interface /// \brief Base class for feedback based stream ciphers in the forward direction with SymmetricCipher interface
/// \tparam BASE AbstractPolicyHolder base class /// \tparam BASE AbstractPolicyHolder base class
template <class BASE = AbstractPolicyHolder<CFB_CipherAbstractPolicy, SymmetricCipher> > template <class BASE = AbstractPolicyHolder<CFB_CipherAbstractPolicy, SymmetricCipher> >
@ -554,7 +545,6 @@ class CRYPTOPP_NO_VTABLE CFB_EncryptionTemplate : public CFB_CipherTemplate<BASE
void CombineMessageAndShiftRegister(byte *output, byte *reg, const byte *message, size_t length); void CombineMessageAndShiftRegister(byte *output, byte *reg, const byte *message, size_t length);
}; };
/// \class CFB_DecryptionTemplate
/// \brief Base class for feedback based stream ciphers in the reverse direction with SymmetricCipher interface /// \brief Base class for feedback based stream ciphers in the reverse direction with SymmetricCipher interface
/// \tparam BASE AbstractPolicyHolder base class /// \tparam BASE AbstractPolicyHolder base class
template <class BASE = AbstractPolicyHolder<CFB_CipherAbstractPolicy, SymmetricCipher> > template <class BASE = AbstractPolicyHolder<CFB_CipherAbstractPolicy, SymmetricCipher> >
@ -564,7 +554,6 @@ class CRYPTOPP_NO_VTABLE CFB_DecryptionTemplate : public CFB_CipherTemplate<BASE
void CombineMessageAndShiftRegister(byte *output, byte *reg, const byte *message, size_t length); void CombineMessageAndShiftRegister(byte *output, byte *reg, const byte *message, size_t length);
}; };
/// \class CFB_RequireFullDataBlocks
/// \brief Base class for feedback based stream ciphers with a mandatory block size /// \brief Base class for feedback based stream ciphers with a mandatory block size
/// \tparam BASE CFB_EncryptionTemplate or CFB_DecryptionTemplate base class /// \tparam BASE CFB_EncryptionTemplate or CFB_DecryptionTemplate base class
template <class BASE> template <class BASE>
@ -574,7 +563,6 @@ public:
unsigned int MandatoryBlockSize() const {return this->OptimalBlockSize();} unsigned int MandatoryBlockSize() const {return this->OptimalBlockSize();}
}; };
/// \class SymmetricCipherFinal
/// \brief SymmetricCipher implementation /// \brief SymmetricCipher implementation
/// \tparam BASE AbstractPolicyHolder derived base class /// \tparam BASE AbstractPolicyHolder derived base class
/// \tparam INFO AbstractPolicyHolder derived information class /// \tparam INFO AbstractPolicyHolder derived information class

15
tea.h
View File

@ -12,19 +12,16 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class TEA_Info
/// \brief TEA block cipher information /// \brief TEA block cipher information
struct TEA_Info : public FixedBlockSize<8>, public FixedKeyLength<16>, public VariableRounds<32> struct TEA_Info : public FixedBlockSize<8>, public FixedKeyLength<16>, public VariableRounds<32>
{ {
CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "TEA";} CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "TEA";}
}; };
/// \class TEA
/// \brief TEA block cipher /// \brief TEA block cipher
/// \sa <a href="http://www.cryptopp.com/wiki/TEA">TEA</a> /// \sa <a href="http://www.cryptopp.com/wiki/TEA">TEA</a>
class TEA : public TEA_Info, public BlockCipherDocumentation class TEA : public TEA_Info, public BlockCipherDocumentation
{ {
/// \class Base
/// \brief TEA block cipher default operation /// \brief TEA block cipher default operation
class CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<TEA_Info> class CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<TEA_Info>
{ {
@ -36,7 +33,6 @@ class TEA : public TEA_Info, public BlockCipherDocumentation
word32 m_limit; word32 m_limit;
}; };
/// \class Enc
/// \brief TEA block cipher encryption operation /// \brief TEA block cipher encryption operation
class CRYPTOPP_NO_VTABLE Enc : public Base class CRYPTOPP_NO_VTABLE Enc : public Base
{ {
@ -44,7 +40,6 @@ class TEA : public TEA_Info, public BlockCipherDocumentation
void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const; void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
}; };
/// \class Dec
/// \brief TEA block cipher decryption operation /// \brief TEA block cipher decryption operation
class CRYPTOPP_NO_VTABLE Dec : public Base class CRYPTOPP_NO_VTABLE Dec : public Base
{ {
@ -60,19 +55,16 @@ public:
typedef TEA::Encryption TEAEncryption; typedef TEA::Encryption TEAEncryption;
typedef TEA::Decryption TEADecryption; typedef TEA::Decryption TEADecryption;
/// \class XTEA_Info
/// \brief XTEA block cipher information /// \brief XTEA block cipher information
struct XTEA_Info : public FixedBlockSize<8>, public FixedKeyLength<16>, public VariableRounds<32> struct XTEA_Info : public FixedBlockSize<8>, public FixedKeyLength<16>, public VariableRounds<32>
{ {
CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "XTEA";} CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "XTEA";}
}; };
/// \class XTEA
/// \brief XTEA block cipher /// \brief XTEA block cipher
/// \sa <a href="http://www.cryptopp.com/wiki/TEA">XTEA</a> /// \sa <a href="http://www.cryptopp.com/wiki/TEA">XTEA</a>
class XTEA : public XTEA_Info, public BlockCipherDocumentation class XTEA : public XTEA_Info, public BlockCipherDocumentation
{ {
/// \class Base
/// \brief XTEA block cipher default operation /// \brief XTEA block cipher default operation
class CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<XTEA_Info> class CRYPTOPP_NO_VTABLE Base : public BlockCipherImpl<XTEA_Info>
{ {
@ -84,7 +76,6 @@ class XTEA : public XTEA_Info, public BlockCipherDocumentation
word32 m_limit; word32 m_limit;
}; };
/// \class Enc
/// \brief XTEA block cipher encryption operation /// \brief XTEA block cipher encryption operation
class CRYPTOPP_NO_VTABLE Enc : public Base class CRYPTOPP_NO_VTABLE Enc : public Base
{ {
@ -92,7 +83,6 @@ class XTEA : public XTEA_Info, public BlockCipherDocumentation
void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const; void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
}; };
/// \class Dec
/// \brief XTEA block cipher decryption operation /// \brief XTEA block cipher decryption operation
class CRYPTOPP_NO_VTABLE Dec : public Base class CRYPTOPP_NO_VTABLE Dec : public Base
{ {
@ -105,20 +95,17 @@ public:
typedef BlockCipherFinal<DECRYPTION, Dec> Decryption; typedef BlockCipherFinal<DECRYPTION, Dec> Decryption;
}; };
/// \class BTEA_Info
/// \brief BTEA block cipher information /// \brief BTEA block cipher information
struct BTEA_Info : public FixedKeyLength<16> struct BTEA_Info : public FixedKeyLength<16>
{ {
CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "BTEA";} CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "BTEA";}
}; };
/// \class BTEA
/// \brief BTEA block cipher /// \brief BTEA block cipher
/// \details Corrected Block TEA as described in "xxtea". This class hasn't been tested yet. /// \details Corrected Block TEA as described in "xxtea". This class hasn't been tested yet.
/// \sa <a href="http://www.cryptopp.com/wiki/TEA">Corrected Block TEA</a>. /// \sa <a href="http://www.cryptopp.com/wiki/TEA">Corrected Block TEA</a>.
class BTEA : public BTEA_Info, public BlockCipherDocumentation class BTEA : public BTEA_Info, public BlockCipherDocumentation
{ {
/// \class Base
/// \brief BTEA block cipher default operation /// \brief BTEA block cipher default operation
class CRYPTOPP_NO_VTABLE Base : public AlgorithmImpl<SimpleKeyingInterfaceImpl<BlockCipher, BTEA_Info>, BTEA_Info>, public BTEA_Info class CRYPTOPP_NO_VTABLE Base : public AlgorithmImpl<SimpleKeyingInterfaceImpl<BlockCipher, BTEA_Info>, BTEA_Info>, public BTEA_Info
{ {
@ -137,7 +124,6 @@ class BTEA : public BTEA_Info, public BlockCipherDocumentation
unsigned int m_blockSize; unsigned int m_blockSize;
}; };
/// \class Enc
/// \brief BTEA block cipher encryption operation /// \brief BTEA block cipher encryption operation
class CRYPTOPP_NO_VTABLE Enc : public Base class CRYPTOPP_NO_VTABLE Enc : public Base
{ {
@ -145,7 +131,6 @@ class BTEA : public BTEA_Info, public BlockCipherDocumentation
void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const; void ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const;
}; };
/// \class Dec
/// \brief BTEA block cipher decryption operation /// \brief BTEA block cipher decryption operation
class CRYPTOPP_NO_VTABLE Dec : public Base class CRYPTOPP_NO_VTABLE Dec : public Base
{ {

5
threefish.h
View File

@ -18,7 +18,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class Threefish_Info
/// \brief Threefish block cipher information /// \brief Threefish block cipher information
/// \tparam BS block size of the cipher, in bytes /// \tparam BS block size of the cipher, in bytes
/// \since Crypto++ 6.0 /// \since Crypto++ 6.0
@ -32,7 +31,6 @@ struct Threefish_Info : public FixedBlockSize<BS>, FixedKeyLength<BS>
} }
}; };
/// \class Threefish_Base
/// \brief Threefish block cipher base class /// \brief Threefish block cipher base class
/// \tparam BS block size of the cipher, in bytes /// \tparam BS block size of the cipher, in bytes
/// \details User code should use Threefish256, Threefish512, Threefish1024 /// \details User code should use Threefish256, Threefish512, Threefish1024
@ -66,7 +64,6 @@ struct CRYPTOPP_NO_VTABLE Threefish_Base
AlignedSecBlock64 m_tweak; AlignedSecBlock64 m_tweak;
}; };
/// \class Threefish256
/// \brief Threefish 256-bit block cipher /// \brief Threefish 256-bit block cipher
/// \details Threefish256 provides 256-bit block size. The valid key size is 256-bit. /// \details Threefish256 provides 256-bit block size. The valid key size is 256-bit.
/// \note Crypto++ provides a byte oriented implementation /// \note Crypto++ provides a byte oriented implementation
@ -111,7 +108,6 @@ public:
typedef Threefish256::Encryption Threefish256Encryption; typedef Threefish256::Encryption Threefish256Encryption;
typedef Threefish256::Decryption Threefish256Decryption; typedef Threefish256::Decryption Threefish256Decryption;
/// \class Threefish512
/// \brief Threefish 512-bit block cipher /// \brief Threefish 512-bit block cipher
/// \details Threefish512 provides 512-bit block size. The valid key size is 512-bit. /// \details Threefish512 provides 512-bit block size. The valid key size is 512-bit.
/// \note Crypto++ provides a byte oriented implementation /// \note Crypto++ provides a byte oriented implementation
@ -156,7 +152,6 @@ public:
typedef Threefish512::Encryption Threefish512Encryption; typedef Threefish512::Encryption Threefish512Encryption;
typedef Threefish512::Decryption Threefish512Decryption; typedef Threefish512::Decryption Threefish512Decryption;
/// \class Threefish1024
/// \brief Threefish 1024-bit block cipher /// \brief Threefish 1024-bit block cipher
/// \details Threefish1024 provides 1024-bit block size. The valid key size is 1024-bit. /// \details Threefish1024 provides 1024-bit block size. The valid key size is 1024-bit.
/// \note Crypto++ provides a byte oriented implementation /// \note Crypto++ provides a byte oriented implementation

2
ttmac.h
View File

@ -12,7 +12,6 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class TTMAC_Base
/// \brief TTMAC message authentication code information /// \brief TTMAC message authentication code information
class CRYPTOPP_NO_VTABLE TTMAC_Base : public FixedKeyLength<20>, public IteratedHash<word32, LittleEndian, 64, MessageAuthenticationCode> class CRYPTOPP_NO_VTABLE TTMAC_Base : public FixedKeyLength<20>, public IteratedHash<word32, LittleEndian, 64, MessageAuthenticationCode>
{ {
@ -34,7 +33,6 @@ protected:
FixedSizeSecBlock<word32, 5> m_key; FixedSizeSecBlock<word32, 5> m_key;
}; };
/// \class TTMAC
/// \brief Two-Track-MAC message authentication code /// \brief Two-Track-MAC message authentication code
/// \tparam T HashTransformation class /// \tparam T HashTransformation class
/// \details 160-bit MAC with 160-bit key /// \details 160-bit MAC with 160-bit key

2
twofish.h
View File

@ -11,14 +11,12 @@
NAMESPACE_BEGIN(CryptoPP) NAMESPACE_BEGIN(CryptoPP)
/// \class Twofish_Info
/// \brief Twofish block cipher information /// \brief Twofish block cipher information
struct Twofish_Info : public FixedBlockSize<16>, public VariableKeyLength<16, 16, 32, 8>, FixedRounds<16> struct Twofish_Info : public FixedBlockSize<16>, public VariableKeyLength<16, 16, 32, 8>, FixedRounds<16>
{ {
CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "Twofish";} CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "Twofish";}
}; };
/// \class Twofish
/// \brief Twofish block cipher /// \brief Twofish block cipher
//~ \sa <a href="http://www.cryptopp.com/wiki/Twofish">Twofish</a> //~ \sa <a href="http://www.cryptopp.com/wiki/Twofish">Twofish</a>
class Twofish : public Twofish_Info, public BlockCipherDocumentation class Twofish : public Twofish_Info, public BlockCipherDocumentation

Some files were not shown because too many files have changed in this diff Show More