, T_Transform> >
{
public:
- CRYPTOPP_CONSTANT(DIGESTSIZE = T_DigestSize ? T_DigestSize : T_StateSize)
;
+ CRYPTOPP_CONSTANT(DIGESTSIZE = T_DigestSize ? T_DigestSize : T_StateSize);
virtual ~IteratedHashWithStaticTransform() {}
diff --git a/keccak.h b/keccak.h
index 05800969..61e0290d 100644
--- a/keccak.h
+++ b/keccak.h
@@ -30,7 +30,7 @@ NAMESPACE_BEGIN(CryptoPP)
/// Keccack_192 : public Keccack
/// {
/// public:
-/// CRYPTOPP_CONSTANT(DIGESTSIZE = 24)
;
+/// CRYPTOPP_CONSTANT(DIGESTSIZE = 24);
/// Keccack_192() : Keccack(DIGESTSIZE) {}
/// };
///
@@ -72,8 +72,8 @@ template
class Keccak_Final : public Keccak
{
public:
- CRYPTOPP_CONSTANT(DIGESTSIZE = T_DigestSize)
;
- CRYPTOPP_CONSTANT(BLOCKSIZE = 200 - 2 * DIGESTSIZE)
;
+ CRYPTOPP_CONSTANT(DIGESTSIZE = T_DigestSize);
+ CRYPTOPP_CONSTANT(BLOCKSIZE = 200 - 2 * DIGESTSIZE);
static std::string StaticAlgorithmName()
{ return "Keccak-" + IntToString(DIGESTSIZE * 8); }
@@ -99,19 +99,19 @@ private:
/// \brief Keccak-224 message digest
/// \since Crypto++ 5.6.4
-DOCUMENTED_TYPEDEF(Keccak_Final<28>, Keccak_224);
;
+DOCUMENTED_TYPEDEF(Keccak_Final<28>, Keccak_224);;
/// \brief Keccak-256 message digest
/// \since Crypto++ 5.6.4
-DOCUMENTED_TYPEDEF(Keccak_Final<32>, Keccak_256);
;
+DOCUMENTED_TYPEDEF(Keccak_Final<32>, Keccak_256);;
/// \brief Keccak-384 message digest
/// \since Crypto++ 5.6.4
-DOCUMENTED_TYPEDEF(Keccak_Final<48>, Keccak_384);
;
+DOCUMENTED_TYPEDEF(Keccak_Final<48>, Keccak_384);;
/// \brief Keccak-512 message digest
/// \since Crypto++ 5.6.4
-DOCUMENTED_TYPEDEF(Keccak_Final<64>, Keccak_512);
;
+DOCUMENTED_TYPEDEF(Keccak_Final<64>, Keccak_512);;
NAMESPACE_END
diff --git a/lubyrack.h b/lubyrack.h
index 8751f05d..a5d6a18d 100644
--- a/lubyrack.h
+++ b/lubyrack.h
@@ -37,7 +37,7 @@ class LR : public LR_Info, public BlockCipherDocumentation
}
protected:
- CRYPTOPP_CONSTANT(S=T::DIGESTSIZE)
;
+ CRYPTOPP_CONSTANT(S=T::DIGESTSIZE);
unsigned int L; // key length / 2
SecByteBlock key;
diff --git a/md2.h b/md2.h
index 5076be31..3b8d3ef3 100644
--- a/md2.h
+++ b/md2.h
@@ -27,8 +27,8 @@ public:
unsigned int BlockSize() const {return BLOCKSIZE;}
CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "MD2";}
- CRYPTOPP_CONSTANT(DIGESTSIZE = 16)
;
- CRYPTOPP_CONSTANT(BLOCKSIZE = 16)
;
+ CRYPTOPP_CONSTANT(DIGESTSIZE = 16);
+ CRYPTOPP_CONSTANT(BLOCKSIZE = 16);
private:
void Transform();
diff --git a/mersenne.h b/mersenne.h
index 9bd97341..b49d4032 100644
--- a/mersenne.h
+++ b/mersenne.h
@@ -225,4 +225,3 @@ typedef MersenneTwister<0x9908B0DF /*2567483615*/, 397, 624, 0x6C078965 /*181243
NAMESPACE_END
#endif // CRYPTOPP_MERSENNE_TWISTER_H
-
diff --git a/naclite.h b/naclite.h
index f9d14d41..b9d4d670 100644
--- a/naclite.h
+++ b/naclite.h
@@ -64,85 +64,85 @@ NAMESPACE_BEGIN(NaCl)
/// \brief Hash size in bytes
/// \sa NaCl crypto_hash documentation
-CRYPTOPP_CONSTANT(crypto_hash_BYTES = 64)
;
+CRYPTOPP_CONSTANT(crypto_hash_BYTES = 64);
/// \brief Key size in bytes
/// \sa NaCl crypto_stream documentation
-CRYPTOPP_CONSTANT(crypto_stream_KEYBYTES = 32)
;
+CRYPTOPP_CONSTANT(crypto_stream_KEYBYTES = 32);
/// \brief Nonce size in bytes
/// \sa NaCl crypto_stream documentation
-CRYPTOPP_CONSTANT(crypto_stream_NONCEBYTES = 24)
;
+CRYPTOPP_CONSTANT(crypto_stream_NONCEBYTES = 24);
/// \brief Key size in bytes
/// \sa NaCl crypto_auth documentation
-CRYPTOPP_CONSTANT(crypto_auth_KEYBYTES = 32)
;
+CRYPTOPP_CONSTANT(crypto_auth_KEYBYTES = 32);
/// \brief Tag size in bytes
/// \sa NaCl crypto_auth documentation
-CRYPTOPP_CONSTANT(crypto_auth_BYTES = 16)
;
+CRYPTOPP_CONSTANT(crypto_auth_BYTES = 16);
/// \brief Key size in bytes
/// \sa NaCl crypto_onetimeauth documentation
-CRYPTOPP_CONSTANT(crypto_onetimeauth_KEYBYTES = 32)
;
+CRYPTOPP_CONSTANT(crypto_onetimeauth_KEYBYTES = 32);
/// \brief Tag size in bytes
/// \sa NaCl crypto_onetimeauth documentation
-CRYPTOPP_CONSTANT(crypto_onetimeauth_BYTES = 16)
;
+CRYPTOPP_CONSTANT(crypto_onetimeauth_BYTES = 16);
/// \brief Key size in bytes
/// \sa NaCl crypto_secretbox documentation
-CRYPTOPP_CONSTANT(crypto_secretbox_KEYBYTES = 32)
;
+CRYPTOPP_CONSTANT(crypto_secretbox_KEYBYTES = 32);
/// \brief Nonce size in bytes
/// \sa NaCl crypto_secretbox documentation
-CRYPTOPP_CONSTANT(crypto_secretbox_NONCEBYTES = 24)
;
+CRYPTOPP_CONSTANT(crypto_secretbox_NONCEBYTES = 24);
/// \brief Zero-padded message prefix in bytes
/// \sa NaCl crypto_secretbox documentation
-CRYPTOPP_CONSTANT(crypto_secretbox_ZEROBYTES = 32)
;
+CRYPTOPP_CONSTANT(crypto_secretbox_ZEROBYTES = 32);
/// \brief Zero-padded message prefix in bytes
/// \sa NaCl crypto_secretbox documentation
-CRYPTOPP_CONSTANT(crypto_secretbox_BOXZEROBYTES = 16)
;
+CRYPTOPP_CONSTANT(crypto_secretbox_BOXZEROBYTES = 16);
/// \brief Private key size in bytes
/// \sa NaCl crypto_box documentation
-CRYPTOPP_CONSTANT(crypto_box_SECRETKEYBYTES = 32)
;
+CRYPTOPP_CONSTANT(crypto_box_SECRETKEYBYTES = 32);
/// \brief Public key size in bytes
/// \sa NaCl crypto_box documentation
-CRYPTOPP_CONSTANT(crypto_box_PUBLICKEYBYTES = 32)
;
+CRYPTOPP_CONSTANT(crypto_box_PUBLICKEYBYTES = 32);
/// \brief Nonce size in bytes
/// \sa NaCl crypto_box documentation
-CRYPTOPP_CONSTANT(crypto_box_NONCEBYTES = 24)
;
+CRYPTOPP_CONSTANT(crypto_box_NONCEBYTES = 24);
/// \brief Message 0-byte prefix in bytes
/// \sa NaCl crypto_box documentation
-CRYPTOPP_CONSTANT(crypto_box_ZEROBYTES = 32)
;
+CRYPTOPP_CONSTANT(crypto_box_ZEROBYTES = 32);
/// \brief Open box 0-byte prefix in bytes
/// \sa NaCl crypto_box documentation
-CRYPTOPP_CONSTANT(crypto_box_BOXZEROBYTES = 16)
;
+CRYPTOPP_CONSTANT(crypto_box_BOXZEROBYTES = 16);
/// \brief Precomputation 0-byte prefix in bytes in bytes
/// \sa NaCl crypto_box documentation
-CRYPTOPP_CONSTANT(crypto_box_BEFORENMBYTES = 32)
;
+CRYPTOPP_CONSTANT(crypto_box_BEFORENMBYTES = 32);
/// \brief MAC size in bytes
/// \details crypto_box_MACBYTES was missing from tweetnacl.h. Its is defined as
/// crypto_box_curve25519xsalsa20poly1305_MACBYTES, which is defined as 16U.
/// \sa NaCl crypto_box documentation
-CRYPTOPP_CONSTANT(crypto_box_MACBYTES = 16)
;
+CRYPTOPP_CONSTANT(crypto_box_MACBYTES = 16);
/// \brief Private key size in bytes
/// \sa NaCl crypto_sign documentation
-CRYPTOPP_CONSTANT(crypto_sign_SECRETKEYBYTES = 64)
;
+CRYPTOPP_CONSTANT(crypto_sign_SECRETKEYBYTES = 64);
/// \brief Public key size in bytes
/// \sa NaCl crypto_sign documentation
-CRYPTOPP_CONSTANT(crypto_sign_PUBLICKEYBYTES = 32)
;
+CRYPTOPP_CONSTANT(crypto_sign_PUBLICKEYBYTES = 32);
/// \brief Seed size in bytes
/// \sa NaCl crypto_sign documentation
-CRYPTOPP_CONSTANT(crypto_sign_SEEDBYTES = 32)
;
+CRYPTOPP_CONSTANT(crypto_sign_SEEDBYTES = 32);
/// \brief Signature size in bytes
/// \sa NaCl crypto_sign documentation
-CRYPTOPP_CONSTANT(crypto_sign_BYTES = 64)
;
+CRYPTOPP_CONSTANT(crypto_sign_BYTES = 64);
/// \brief Group element size in bytes
/// \sa NaCl crypto_scalarmult documentation
-CRYPTOPP_CONSTANT(crypto_scalarmult_BYTES = 32)
;
+CRYPTOPP_CONSTANT(crypto_scalarmult_BYTES = 32);
/// \brief Integer size in bytes
/// \sa NaCl crypto_scalarmult documentation
-CRYPTOPP_CONSTANT(crypto_scalarmult_SCALARBYTES = 32)
;
+CRYPTOPP_CONSTANT(crypto_scalarmult_SCALARBYTES = 32);
/// \brief Encrypt and authenticate a message
/// \param c output byte buffer
diff --git a/panama.h b/panama.h
index 776e6958..b3d50a04 100644
--- a/panama.h
+++ b/panama.h
@@ -32,7 +32,7 @@ public:
protected:
typedef word32 Stage[8];
- CRYPTOPP_CONSTANT(STAGES = 32)
;
+ CRYPTOPP_CONSTANT(STAGES = 32);
FixedSizeAlignedSecBlock m_state;
};
@@ -44,7 +44,7 @@ template
class PanamaHash : protected Panama, public AlgorithmImpl, PanamaHash >
{
public:
- CRYPTOPP_CONSTANT(DIGESTSIZE = 32)
;
+ CRYPTOPP_CONSTANT(DIGESTSIZE = 32);
virtual ~PanamaHash() {}
PanamaHash() {Panama::Reset();}
unsigned int DigestSize() const {return DIGESTSIZE;}
diff --git a/poly1305.h b/poly1305.h
index 90940415..0745d935 100644
--- a/poly1305.h
+++ b/poly1305.h
@@ -48,8 +48,8 @@ class CRYPTOPP_NO_VTABLE Poly1305_Base : public FixedKeyLength<32, SimpleKeyingI
public:
static std::string StaticAlgorithmName() {return std::string("Poly1305(") + T::StaticAlgorithmName() + ")";}
- CRYPTOPP_CONSTANT(DIGESTSIZE=T::BLOCKSIZE)
;
- CRYPTOPP_CONSTANT(BLOCKSIZE=T::BLOCKSIZE)
;
+ CRYPTOPP_CONSTANT(DIGESTSIZE=T::BLOCKSIZE);
+ CRYPTOPP_CONSTANT(BLOCKSIZE=T::BLOCKSIZE);
virtual ~Poly1305_Base() {}
Poly1305_Base() : m_idx(0), m_used(true) {}
@@ -136,7 +136,7 @@ template
class Poly1305 : public MessageAuthenticationCodeFinal >
{
public:
- CRYPTOPP_CONSTANT(DEFAULT_KEYLENGTH=Poly1305_Base::DEFAULT_KEYLENGTH)
;
+ CRYPTOPP_CONSTANT(DEFAULT_KEYLENGTH=Poly1305_Base::DEFAULT_KEYLENGTH);
/// \brief Construct a Poly1305
Poly1305() {}
@@ -165,8 +165,8 @@ class Poly1305TLS_Base : public FixedKeyLength<32>, public MessageAuthentication
{
public:
static std::string StaticAlgorithmName() {return std::string("Poly1305TLS");}
- CRYPTOPP_CONSTANT(DIGESTSIZE=16)
;
- CRYPTOPP_CONSTANT(BLOCKSIZE=16)
;
+ CRYPTOPP_CONSTANT(DIGESTSIZE=16);
+ CRYPTOPP_CONSTANT(BLOCKSIZE=16);
virtual ~Poly1305TLS_Base() {}
Poly1305TLS_Base() {}
@@ -234,7 +234,7 @@ protected:
/// \since Crypto++ 8.1
/// \sa MessageAuthenticationCode(), RFC
/// 8439, ChaCha20 and Poly1305 for IETF Protocols
-DOCUMENTED_TYPEDEF(MessageAuthenticationCodeFinal, Poly1305TLS)
;
+DOCUMENTED_TYPEDEF(MessageAuthenticationCodeFinal, Poly1305TLS);
NAMESPACE_END
diff --git a/rc2.h b/rc2.h
index ec0c03fa..50a39ae8 100644
--- a/rc2.h
+++ b/rc2.h
@@ -17,8 +17,8 @@ NAMESPACE_BEGIN(CryptoPP)
/// \since Crypto++ 3.0
struct RC2_Info : public FixedBlockSize<8>, public VariableKeyLength<16, 1, 128>
{
- CRYPTOPP_CONSTANT(DEFAULT_EFFECTIVE_KEYLENGTH = 1024)
;
- CRYPTOPP_CONSTANT(MAX_EFFECTIVE_KEYLENGTH = 1024)
;
+ CRYPTOPP_CONSTANT(DEFAULT_EFFECTIVE_KEYLENGTH = 1024);
+ CRYPTOPP_CONSTANT(MAX_EFFECTIVE_KEYLENGTH = 1024);
CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "RC2";}
};
@@ -88,4 +88,3 @@ typedef RC2::Decryption RC2Decryption;
NAMESPACE_END
#endif
-
diff --git a/rsa.h b/rsa.h
index d0918b96..62c1111e 100644
--- a/rsa.h
+++ b/rsa.h
@@ -203,17 +203,17 @@ struct RSASS_ISO : public TF_SS
/// \brief \ref RSAES "RSAES::Decryptor" typedef
/// \details RSA encryption scheme defined in PKCS #1 v2.0
-DOCUMENTED_TYPEDEF(RSAES::Decryptor, RSAES_PKCS1v15_Decryptor)
;
+DOCUMENTED_TYPEDEF(RSAES::Decryptor, RSAES_PKCS1v15_Decryptor);
/// \brief \ref RSAES "RSAES::Encryptor" typedef
/// \details RSA encryption scheme defined in PKCS #1 v2.0
-DOCUMENTED_TYPEDEF(RSAES::Encryptor, RSAES_PKCS1v15_Encryptor)
;
+DOCUMENTED_TYPEDEF(RSAES::Encryptor, RSAES_PKCS1v15_Encryptor);
/// \brief \ref RSAES "RSAES>::Decryptor" typedef
/// \details RSA encryption scheme defined in PKCS #1 v2.0
-DOCUMENTED_TYPEDEF(RSAES >::Decryptor, RSAES_OAEP_SHA_Decryptor)
;
+DOCUMENTED_TYPEDEF(RSAES >::Decryptor, RSAES_OAEP_SHA_Decryptor);
/// \brief \ref RSAES "RSAES>::Encryptor" typedef
/// \details RSA encryption scheme defined in PKCS #1 v2.0
-DOCUMENTED_TYPEDEF(RSAES >::Encryptor, RSAES_OAEP_SHA_Encryptor)
;
+DOCUMENTED_TYPEDEF(RSAES >::Encryptor, RSAES_OAEP_SHA_Encryptor);
#ifdef CRYPTOPP_DOXYGEN_PROCESSING
/// \brief \ref RSASS "RSASS::Signer" typedef
diff --git a/seckey.h b/seckey.h
index fe6f04d3..5367e254 100644
--- a/seckey.h
+++ b/seckey.h
@@ -41,7 +41,7 @@ class FixedBlockSize
{
public:
/// \brief The block size of the algorithm provided as a constant.
- CRYPTOPP_CONSTANT(BLOCKSIZE = N)
;
+ CRYPTOPP_CONSTANT(BLOCKSIZE = N);
};
// ************** rounds ***************
@@ -53,7 +53,7 @@ class FixedRounds
{
public:
/// \brief The number of rounds for the algorithm provided as a constant.
- CRYPTOPP_CONSTANT(ROUNDS = R)
;
+ CRYPTOPP_CONSTANT(ROUNDS = R);
};
/// \brief Inherited by algorithms with variable number of rounds
@@ -65,11 +65,11 @@ class VariableRounds
{
public:
/// \brief The default number of rounds for the algorithm provided as a constant.
- CRYPTOPP_CONSTANT(DEFAULT_ROUNDS = D)
;
+ CRYPTOPP_CONSTANT(DEFAULT_ROUNDS = D);
/// \brief The minimum number of rounds for the algorithm provided as a constant.
- CRYPTOPP_CONSTANT(MIN_ROUNDS = N)
;
+ CRYPTOPP_CONSTANT(MIN_ROUNDS = N);
/// \brief The maximum number of rounds for the algorithm provided as a constant.
- CRYPTOPP_CONSTANT(MAX_ROUNDS = M)
;
+ CRYPTOPP_CONSTANT(MAX_ROUNDS = M);
/// \brief The default number of rounds for the algorithm based on key length
/// provided by a static function.
/// \param keylength the size of the key, in bytes
@@ -126,23 +126,23 @@ class FixedKeyLength
public:
/// \brief The default key length used by the algorithm provided as a constant
/// \details KEYLENGTH is provided in bytes, not bits
- CRYPTOPP_CONSTANT(KEYLENGTH=N)
;
+ CRYPTOPP_CONSTANT(KEYLENGTH=N);
/// \brief The minimum key length used by the algorithm provided as a constant
/// \details MIN_KEYLENGTH is provided in bytes, not bits
- CRYPTOPP_CONSTANT(MIN_KEYLENGTH=N)
;
+ CRYPTOPP_CONSTANT(MIN_KEYLENGTH=N);
/// \brief The maximum key length used by the algorithm provided as a constant
/// \details MAX_KEYLENGTH is provided in bytes, not bits
- CRYPTOPP_CONSTANT(MAX_KEYLENGTH=N)
;
+ CRYPTOPP_CONSTANT(MAX_KEYLENGTH=N);
/// \brief The default key length used by the algorithm provided as a constant
/// \details DEFAULT_KEYLENGTH is provided in bytes, not bits
- CRYPTOPP_CONSTANT(DEFAULT_KEYLENGTH=N)
;
+ CRYPTOPP_CONSTANT(DEFAULT_KEYLENGTH=N);
/// \brief The default IV requirements for the algorithm provided as a constant
/// \details The default value is NOT_RESYNCHRONIZABLE. See IV_Requirement
/// in cryptlib.h for allowed values.
- CRYPTOPP_CONSTANT(IV_REQUIREMENT = IV_REQ)
;
+ CRYPTOPP_CONSTANT(IV_REQUIREMENT = IV_REQ);
/// \brief The default IV length used by the algorithm provided as a constant
/// \details IV_LENGTH is provided in bytes, not bits. The default implementation uses 0.
- CRYPTOPP_CONSTANT(IV_LENGTH = IV_L)
;
+ CRYPTOPP_CONSTANT(IV_LENGTH = IV_L);
/// \brief The default key length for the algorithm provided by a static function.
/// \param keylength the size of the key, in bytes
/// \details The default implementation returns KEYLENGTH. keylength is unused
@@ -175,23 +175,23 @@ class VariableKeyLength
public:
/// \brief The minimum key length used by the algorithm provided as a constant
/// \details MIN_KEYLENGTH is provided in bytes, not bits
- CRYPTOPP_CONSTANT(MIN_KEYLENGTH=N)
;
+ CRYPTOPP_CONSTANT(MIN_KEYLENGTH=N);
/// \brief The maximum key length used by the algorithm provided as a constant
/// \details MAX_KEYLENGTH is provided in bytes, not bits
- CRYPTOPP_CONSTANT(MAX_KEYLENGTH=M)
;
+ CRYPTOPP_CONSTANT(MAX_KEYLENGTH=M);
/// \brief The default key length used by the algorithm provided as a constant
/// \details DEFAULT_KEYLENGTH is provided in bytes, not bits
- CRYPTOPP_CONSTANT(DEFAULT_KEYLENGTH=D)
;
+ CRYPTOPP_CONSTANT(DEFAULT_KEYLENGTH=D);
/// \brief The key length multiple used by the algorithm provided as a constant
/// \details MAX_KEYLENGTH is provided in bytes, not bits
- CRYPTOPP_CONSTANT(KEYLENGTH_MULTIPLE=Q)
;
+ CRYPTOPP_CONSTANT(KEYLENGTH_MULTIPLE=Q);
/// \brief The default IV requirements for the algorithm provided as a constant
/// \details The default value is NOT_RESYNCHRONIZABLE. See IV_Requirement
/// in cryptlib.h for allowed values.
- CRYPTOPP_CONSTANT(IV_REQUIREMENT=IV_REQ)
;
+ CRYPTOPP_CONSTANT(IV_REQUIREMENT=IV_REQ);
/// \brief The default initialization vector length for the algorithm provided as a constant
/// \details IV_LENGTH is provided in bytes, not bits. The default implementation uses 0.
- CRYPTOPP_CONSTANT(IV_LENGTH=IV_L)
;
+ CRYPTOPP_CONSTANT(IV_LENGTH=IV_L);
/// \brief Provides a valid key length for the algorithm provided by a static function.
/// \param keylength the size of the key, in bytes
/// \details If keylength is less than MIN_KEYLENGTH, then the function returns
@@ -219,20 +219,20 @@ class SameKeyLengthAs
public:
/// \brief The minimum key length used by the algorithm provided as a constant
/// \details MIN_KEYLENGTH is provided in bytes, not bits
- CRYPTOPP_CONSTANT(MIN_KEYLENGTH=T::MIN_KEYLENGTH)
;
+ CRYPTOPP_CONSTANT(MIN_KEYLENGTH=T::MIN_KEYLENGTH);
/// \brief The maximum key length used by the algorithm provided as a constant
/// \details MIN_KEYLENGTH is provided in bytes, not bits
- CRYPTOPP_CONSTANT(MAX_KEYLENGTH=T::MAX_KEYLENGTH)
;
+ CRYPTOPP_CONSTANT(MAX_KEYLENGTH=T::MAX_KEYLENGTH);
/// \brief The default key length used by the algorithm provided as a constant
/// \details MIN_KEYLENGTH is provided in bytes, not bits
- CRYPTOPP_CONSTANT(DEFAULT_KEYLENGTH=T::DEFAULT_KEYLENGTH)
;
+ CRYPTOPP_CONSTANT(DEFAULT_KEYLENGTH=T::DEFAULT_KEYLENGTH);
/// \brief The default IV requirements for the algorithm provided as a constant
/// \details The default value is NOT_RESYNCHRONIZABLE. See IV_Requirement
/// in cryptlib.h for allowed values.
- CRYPTOPP_CONSTANT(IV_REQUIREMENT=IV_REQ)
;
+ CRYPTOPP_CONSTANT(IV_REQUIREMENT=IV_REQ);
/// \brief The default initialization vector length for the algorithm provided as a constant
/// \details IV_LENGTH is provided in bytes, not bits. The default implementation uses 0.
- CRYPTOPP_CONSTANT(IV_LENGTH=IV_L)
;
+ CRYPTOPP_CONSTANT(IV_LENGTH=IV_L);
/// \brief Provides a valid key length for the algorithm provided by a static function.
/// \param keylength the size of the key, in bytes
/// \details If keylength is less than MIN_KEYLENGTH, then the function returns
diff --git a/sha3.h b/sha3.h
index 05b296fe..f02b7d44 100644
--- a/sha3.h
+++ b/sha3.h
@@ -60,8 +60,8 @@ template
class SHA3_Final : public SHA3
{
public:
- CRYPTOPP_CONSTANT(DIGESTSIZE = T_DigestSize)
;
- CRYPTOPP_CONSTANT(BLOCKSIZE = 200 - 2 * DIGESTSIZE)
;
+ CRYPTOPP_CONSTANT(DIGESTSIZE = T_DigestSize);
+ CRYPTOPP_CONSTANT(BLOCKSIZE = 200 - 2 * DIGESTSIZE);
static std::string StaticAlgorithmName()
{ return "SHA3-" + IntToString(DIGESTSIZE * 8); }
diff --git a/shake.h b/shake.h
index 698215b2..0eaab43b 100644
--- a/shake.h
+++ b/shake.h
@@ -66,8 +66,8 @@ template
class SHAKE_Final : public SHAKE
{
public:
- CRYPTOPP_CONSTANT(DIGESTSIZE = (T_Strength == 128 ? 32 : 64))
;
- CRYPTOPP_CONSTANT(BLOCKSIZE = (T_Strength == 128 ? 1344/8 : 1088/8))
;
+ CRYPTOPP_CONSTANT(DIGESTSIZE = (T_Strength == 128 ? 32 : 64));
+ CRYPTOPP_CONSTANT(BLOCKSIZE = (T_Strength == 128 ? 1344/8 : 1088/8));
static std::string StaticAlgorithmName()
{ return "SHAKE-" + IntToString(T_Strength); }
diff --git a/siphash.h b/siphash.h
index 938bbe3a..76dcccf6 100644
--- a/siphash.h
+++ b/siphash.h
@@ -39,7 +39,7 @@ class SipHash_Info : public FixedKeyLength<16>
{
public:
CRYPTOPP_STATIC_CONSTEXPR const char* StaticAlgorithmName() {return "SipHash";}
- CRYPTOPP_CONSTANT(DIGESTSIZE = (T_128bit ? 16 : 8))
;
+ CRYPTOPP_CONSTANT(DIGESTSIZE = (T_128bit ? 16 : 8));
};
/// \brief SipHash message authentication code base class
diff --git a/strciphr.h b/strciphr.h
index 2b096a6f..3e88012d 100644
--- a/strciphr.h
+++ b/strciphr.h
@@ -208,7 +208,7 @@ struct CRYPTOPP_NO_VTABLE AdditiveCipherConcretePolicy : public BASE
/// For example, ChaCha uses 16 each word32, and the value of
/// BYTES_PER_ITERATION is 64. Each invocation of the ChaCha block function
/// produces 64 bytes of keystream.
- CRYPTOPP_CONSTANT(BYTES_PER_ITERATION = sizeof(WordType) * W)
;
+ CRYPTOPP_CONSTANT(BYTES_PER_ITERATION = sizeof(WordType) * W);
virtual ~AdditiveCipherConcretePolicy() {}
diff --git a/ttmac.h b/ttmac.h
index 89b99395..d50b0038 100644
--- a/ttmac.h
+++ b/ttmac.h
@@ -17,7 +17,7 @@ class CRYPTOPP_NO_VTABLE TTMAC_Base : public FixedKeyLength<20>, public Iterated
{
public:
static std::string StaticAlgorithmName() {return std::string("Two-Track-MAC");}
- CRYPTOPP_CONSTANT(DIGESTSIZE=20)
;
+ CRYPTOPP_CONSTANT(DIGESTSIZE=20);
unsigned int DigestSize() const {return DIGESTSIZE;};
void UncheckedSetKey(const byte *userKey, unsigned int keylength, const NameValuePairs ¶ms);
@@ -37,7 +37,7 @@ protected:
/// \tparam T HashTransformation class
/// \details 160-bit MAC with 160-bit key
/// \sa MessageAuthenticationCode(), Two-Track-MAC
-DOCUMENTED_TYPEDEF(MessageAuthenticationCodeFinal, TTMAC)
;
+DOCUMENTED_TYPEDEF(MessageAuthenticationCodeFinal, TTMAC);
NAMESPACE_END
diff --git a/xed25519.h b/xed25519.h
index e11eace4..b4f96497 100644
--- a/xed25519.h
+++ b/xed25519.h
@@ -56,13 +56,13 @@ class x25519 : public SimpleKeyAgreementDomain, public CryptoParameters, public
public:
/// \brief Size of the private key
/// \details SECRET_KEYLENGTH is the size of the private key, in bytes.
- CRYPTOPP_CONSTANT(SECRET_KEYLENGTH = 32)
;
+ CRYPTOPP_CONSTANT(SECRET_KEYLENGTH = 32);
/// \brief Size of the public key
/// \details PUBLIC_KEYLENGTH is the size of the public key, in bytes.
- CRYPTOPP_CONSTANT(PUBLIC_KEYLENGTH = 32)
;
+ CRYPTOPP_CONSTANT(PUBLIC_KEYLENGTH = 32);
/// \brief Size of the shared key
/// \details SHARED_KEYLENGTH is the size of the shared key, in bytes.
- CRYPTOPP_CONSTANT(SHARED_KEYLENGTH = 32)
;
+ CRYPTOPP_CONSTANT(SHARED_KEYLENGTH = 32);
virtual ~x25519() {}
@@ -277,8 +277,8 @@ protected:
/// message digest supplied by an attacker.
struct ed25519_MessageAccumulator : public PK_MessageAccumulator
{
- CRYPTOPP_CONSTANT(RESERVE_SIZE=2048+64)
;
- CRYPTOPP_CONSTANT(SIGNATURE_LENGTH=64)
;
+ CRYPTOPP_CONSTANT(RESERVE_SIZE=2048+64);
+ CRYPTOPP_CONSTANT(SIGNATURE_LENGTH=64);
/// \brief Create a message accumulator
ed25519_MessageAccumulator() {
@@ -356,15 +356,15 @@ struct ed25519PrivateKey : public PKCS8PrivateKey
{
/// \brief Size of the private key
/// \details SECRET_KEYLENGTH is the size of the private key, in bytes.
- CRYPTOPP_CONSTANT(SECRET_KEYLENGTH = 32)
;
+ CRYPTOPP_CONSTANT(SECRET_KEYLENGTH = 32);
/// \brief Size of the public key
/// \details PUBLIC_KEYLENGTH is the size of the public key, in bytes.
- CRYPTOPP_CONSTANT(PUBLIC_KEYLENGTH = 32)
;
+ CRYPTOPP_CONSTANT(PUBLIC_KEYLENGTH = 32);
/// \brief Size of the siganture
/// \details SIGNATURE_LENGTH is the size of the signature, in bytes.
/// ed25519 is a DL-based signature scheme. The signature is the
/// concatenation of r || s.
- CRYPTOPP_CONSTANT(SIGNATURE_LENGTH = 64)
;
+ CRYPTOPP_CONSTANT(SIGNATURE_LENGTH = 64);
// CryptoMaterial
bool Validate(RandomNumberGenerator &rng, unsigned int level) const;
@@ -497,15 +497,15 @@ struct ed25519Signer : public PK_Signer
{
/// \brief Size of the private key
/// \details SECRET_KEYLENGTH is the size of the private key, in bytes.
- CRYPTOPP_CONSTANT(SECRET_KEYLENGTH = 32)
;
+ CRYPTOPP_CONSTANT(SECRET_KEYLENGTH = 32);
/// \brief Size of the public key
/// \details PUBLIC_KEYLENGTH is the size of the public key, in bytes.
- CRYPTOPP_CONSTANT(PUBLIC_KEYLENGTH = 32)
;
+ CRYPTOPP_CONSTANT(PUBLIC_KEYLENGTH = 32);
/// \brief Size of the siganture
/// \details SIGNATURE_LENGTH is the size of the signature, in bytes.
/// ed25519 is a DL-based signature scheme. The signature is the
/// concatenation of r || s.
- CRYPTOPP_CONSTANT(SIGNATURE_LENGTH = 64)
;
+ CRYPTOPP_CONSTANT(SIGNATURE_LENGTH = 64);
typedef Integer Element;
virtual ~ed25519Signer() {}
@@ -626,7 +626,7 @@ struct ed25519PublicKey : public X509PublicKey
{
/// \brief Size of the public key
/// \details PUBLIC_KEYLENGTH is the size of the public key, in bytes.
- CRYPTOPP_CONSTANT(PUBLIC_KEYLENGTH = 32)
;
+ CRYPTOPP_CONSTANT(PUBLIC_KEYLENGTH = 32);
typedef Integer Element;
OID GetAlgorithmID() const {
@@ -700,8 +700,8 @@ protected:
/// \since Crypto++ 8.0
struct ed25519Verifier : public PK_Verifier
{
- CRYPTOPP_CONSTANT(PUBLIC_KEYLENGTH = 32)
;
- CRYPTOPP_CONSTANT(SIGNATURE_LENGTH = 64)
;
+ CRYPTOPP_CONSTANT(PUBLIC_KEYLENGTH = 32);
+ CRYPTOPP_CONSTANT(SIGNATURE_LENGTH = 64);
typedef Integer Element;
virtual ~ed25519Verifier() {}