strciphr.h
Go to the documentation of this file.
// strciphr.h - written and placed in the public domain by Wei Dai
//! \file strciphr.h
//! \brief Classes for implementing stream ciphers
//! \details This file contains helper classes for implementing stream ciphers.
//! All this infrastructure may look very complex compared to what's in Crypto++ 4.x,
//! but stream ciphers implementations now support a lot of new functionality,
//! including better performance (minimizing copying), resetting of keys and IVs, and methods to
//! query which features are supported by a cipher.
//! \details Here's an explanation of these classes. The word "policy" is used here to mean a class with a
//! set of methods that must be implemented by individual stream cipher implementations.
//! This is usually much simpler than the full stream cipher API, which is implemented by
//! either AdditiveCipherTemplate or CFB_CipherTemplate using the policy. So for example, an
//! implementation of SEAL only needs to implement the AdditiveCipherAbstractPolicy interface
//! (since it's an additive cipher, i.e., it xors a keystream into the plaintext).
//! See this line in seal.h:
//! <pre>
//! typedef SymmetricCipherFinal<ConcretePolicyHolder<SEAL_Policy<B>, AdditiveCipherTemplate<> > > Encryption;
//! </pre>
//! \details AdditiveCipherTemplate and CFB_CipherTemplate are designed so that they don't need
//! to take a policy class as a template parameter (although this is allowed), so that
//! their code is not duplicated for each new cipher. Instead they each
//! get a reference to an abstract policy interface by calling AccessPolicy() on itself, so
//! AccessPolicy() must be overriden to return the actual policy reference. This is done
//! by the ConceretePolicyHolder class. Finally, SymmetricCipherFinal implements the constructors and
//! other functions that must be implemented by the most derived class.
#ifndef CRYPTOPP_STRCIPHR_H
#define CRYPTOPP_STRCIPHR_H
#include "config.h"
#if CRYPTOPP_MSC_VERSION
# pragma warning(push)
# pragma warning(disable: 4127 4189)
#endif
#include "cryptlib.h"
#include "seckey.h"
#include "secblock.h"
#include "argnames.h"
NAMESPACE_BEGIN(CryptoPP)
//! \class AbstractPolicyHolder
//! \brief Access a stream cipher policy object
//! \tparam POLICY_INTERFACE class implementing AbstractPolicyHolder
//! \tparam BASE class or type to use as a base class
template <class POLICY_INTERFACE, class BASE = Empty>
class CRYPTOPP_NO_VTABLE AbstractPolicyHolder : public BASE
{
public:
typedef POLICY_INTERFACE PolicyInterface;
virtual ~AbstractPolicyHolder() {}
protected:
virtual const POLICY_INTERFACE & GetPolicy() const =0;
virtual POLICY_INTERFACE & AccessPolicy() =0;
};
//! \class ConcretePolicyHolder
//! \brief Stream cipher policy object
//! \tparam POLICY class implementing AbstractPolicyHolder
//! \tparam BASE class or type to use as a base class
template <class POLICY, class BASE, class POLICY_INTERFACE = CPP_TYPENAME BASE::PolicyInterface>
class ConcretePolicyHolder : public BASE, protected POLICY
{
public:
#ifndef CRYPTOPP_MAINTAIN_BACKWARDS_COMPATIBILITY_562
virtual ~ConcretePolicyHolder() {}
#endif
protected:
const POLICY_INTERFACE & GetPolicy() const {return *this;}
POLICY_INTERFACE & AccessPolicy() {return *this;}
};
//! \brief Keystream operation flags
//! \sa AdditiveCipherAbstractPolicy::GetBytesPerIteration(), AdditiveCipherAbstractPolicy::GetOptimalBlockSize()
//! and AdditiveCipherAbstractPolicy::GetAlignment()
enum KeystreamOperationFlags {
//! \brief Output buffer is aligned
OUTPUT_ALIGNED=1,
//! \brief Input buffer is aligned
INPUT_ALIGNED=2,
//! \brief Input buffer is NULL
INPUT_NULL = 4
};
//! \brief Keystream operation flags
//! \sa AdditiveCipherAbstractPolicy::GetBytesPerIteration(), AdditiveCipherAbstractPolicy::GetOptimalBlockSize()
//! and AdditiveCipherAbstractPolicy::GetAlignment()
enum KeystreamOperation {
//! \brief Wirte the keystream to the output buffer, input is NULL
WRITE_KEYSTREAM = INPUT_NULL,
//! \brief Wirte the keystream to the aligned output buffer, input is NULL
WRITE_KEYSTREAM_ALIGNED = INPUT_NULL | OUTPUT_ALIGNED,
//! \brief XOR the input buffer and keystream, write to the output buffer
XOR_KEYSTREAM = 0,
//! \brief XOR the aligned input buffer and keystream, write to the output buffer
XOR_KEYSTREAM_INPUT_ALIGNED = INPUT_ALIGNED,
//! \brief XOR the input buffer and keystream, write to the aligned output buffer
XOR_KEYSTREAM_OUTPUT_ALIGNED= OUTPUT_ALIGNED,
//! \brief XOR the aligned input buffer and keystream, write to the aligned output buffer
XOR_KEYSTREAM_BOTH_ALIGNED = OUTPUT_ALIGNED | INPUT_ALIGNED};
//! \class AdditiveCipherAbstractPolicy
//! \brief Policy object for additive stream ciphers
struct CRYPTOPP_DLL CRYPTOPP_NO_VTABLE AdditiveCipherAbstractPolicy
{
virtual ~AdditiveCipherAbstractPolicy() {}
//! \brief Provides data alignment requirements
//! \returns data alignment requirements, in bytes
//! \details Internally, the default implementation returns 1. If the stream cipher is implemented
//! using an SSE2 ASM or intrinsics, then the value returned is usually 16.
virtual unsigned int GetAlignment() const {return 1;}
//! \brief Provides number of bytes operated upon during an iteration
//! \returns bytes operated upon during an iteration, in bytes
//! \sa GetOptimalBlockSize()
virtual unsigned int GetBytesPerIteration() const =0;
//! \brief Provides number of ideal bytes to process
//! \returns the ideal number of bytes to process
//! \details Internally, the default implementation returns GetBytesPerIteration()
//! \sa GetBytesPerIteration()
virtual unsigned int GetOptimalBlockSize() const {return GetBytesPerIteration();}
//! \brief Provides buffer size based on iterations
//! \returns the buffer size based on iterations, in bytes
virtual unsigned int GetIterationsToBuffer() const =0;
//! \brief Generate the keystream
//! \param keystream the key stream
//! \param iterationCount the number of iterations to generate the key stream
//! \sa CanOperateKeystream(), OperateKeystream(), WriteKeystream()
virtual void WriteKeystream(byte *keystream, size_t iterationCount)
{OperateKeystream(KeystreamOperation(INPUT_NULL | (KeystreamOperationFlags)IsAlignedOn(keystream, GetAlignment())), keystream, NULL, iterationCount);}
//! \brief Flag indicating
//! \returns true if the stream can be generated independent of the transformation input, false otherwise
//! \sa CanOperateKeystream(), OperateKeystream(), WriteKeystream()
virtual bool CanOperateKeystream() const {return false;}
//! \brief Operates the keystream
//! \param operation the operation with additional flags
//! \param output the output buffer
//! \param input the input buffer
//! \param iterationCount the number of iterations to perform on the input
//! \details OperateKeystream() will attempt to operate upon GetOptimalBlockSize() buffer,
//! which will be derived from GetBytesPerIteration().
//! \sa CanOperateKeystream(), OperateKeystream(), WriteKeystream(), KeystreamOperation()
virtual void OperateKeystream(KeystreamOperation operation, byte *output, const byte *input, size_t iterationCount)
{CRYPTOPP_UNUSED(operation); CRYPTOPP_UNUSED(output); CRYPTOPP_UNUSED(input); CRYPTOPP_UNUSED(iterationCount); assert(false);}
//! \brief Key the cipher
//! \param params set of NameValuePairs use to initialize this object
//! \param key a byte array used to key the cipher
//! \param length the size of the key array
virtual void CipherSetKey(const NameValuePairs &params, const byte *key, size_t length) =0;
//! \brief Resynchronize the cipher
//! \param keystreamBuffer the keystream buffer
//! \param iv a byte array used to resynchronize the cipher
//! \param length the size of the IV array
virtual void CipherResynchronize(byte *keystreamBuffer, const byte *iv, size_t length)
{CRYPTOPP_UNUSED(keystreamBuffer); CRYPTOPP_UNUSED(iv); CRYPTOPP_UNUSED(length); throw NotImplemented("SimpleKeyingInterface: this object doesn't support resynchronization");}
//! \brief Flag indicating random access
//! \returns true if the cipher is seekable, false otherwise
//! \sa SeekToIteration()
virtual bool CipherIsRandomAccess() const =0;
//! \brief Seeks to a random position in the stream
//! \returns iterationCount
//! \sa CipherIsRandomAccess()
virtual void SeekToIteration(lword iterationCount)
{CRYPTOPP_UNUSED(iterationCount); assert(!CipherIsRandomAccess()); throw NotImplemented("StreamTransformation: this object doesn't support random access");}
};
//! \class AdditiveCipherConcretePolicy
//! \brief Base class for additive stream ciphers
//! \tparam WT word type
//! \tparam W count of words
//! \tparam X bytes per iteration count
//! \tparam BASE AdditiveCipherAbstractPolicy derived base class
template <typename WT, unsigned int W, unsigned int X = 1, class BASE = AdditiveCipherAbstractPolicy>
struct CRYPTOPP_NO_VTABLE AdditiveCipherConcretePolicy : public BASE
{
typedef WT WordType;
CRYPTOPP_CONSTANT(BYTES_PER_ITERATION = sizeof(WordType) * W)
#if !(CRYPTOPP_BOOL_X86 || CRYPTOPP_BOOL_X64)
//! \brief Provides data alignment requirements
//! \returns data alignment requirements, in bytes
//! \details Internally, the default implementation returns 1. If the stream cipher is implemented
//! using an SSE2 ASM or intrinsics, then the value returned is usually 16.
unsigned int GetAlignment() const {return GetAlignmentOf<WordType>();}
#endif
//! \brief Provides number of bytes operated upon during an iteration
//! \returns bytes operated upon during an iteration, in bytes
//! \sa GetOptimalBlockSize()
unsigned int GetBytesPerIteration() const {return BYTES_PER_ITERATION;}
//! \brief Provides buffer size based on iterations
//! \returns the buffer size based on iterations, in bytes
unsigned int GetIterationsToBuffer() const {return X;}
//! \brief Flag indicating
//! \returns true if the stream can be generated independent of the transformation input, false otherwise
//! \sa CanOperateKeystream(), OperateKeystream(), WriteKeystream()
bool CanOperateKeystream() const {return true;}
//! \brief Operates the keystream
//! \param operation the operation with additional flags
//! \param output the output buffer
//! \param input the input buffer
//! \param iterationCount the number of iterations to perform on the input
//! \details OperateKeystream() will attempt to operate upon GetOptimalBlockSize() buffer,
//! which will be derived from GetBytesPerIteration().
//! \sa CanOperateKeystream(), OperateKeystream(), WriteKeystream(), KeystreamOperation()
virtual void OperateKeystream(KeystreamOperation operation, byte *output, const byte *input, size_t iterationCount) =0;
};
//! \brief Helper macro to implement OperateKeystream
#define CRYPTOPP_KEYSTREAM_OUTPUT_WORD(x, b, i, a) \
PutWord(bool(x & OUTPUT_ALIGNED), b, output+i*sizeof(WordType), (x & INPUT_NULL) ? (a) : (a) ^ GetWord<WordType>(bool(x & INPUT_ALIGNED), b, input+i*sizeof(WordType)));
//! \brief Helper macro to implement OperateKeystream
#define CRYPTOPP_KEYSTREAM_OUTPUT_XMM(x, i, a) {\
__m128i t = (x & INPUT_NULL) ? a : _mm_xor_si128(a, (x & INPUT_ALIGNED) ? _mm_load_si128((__m128i *)input+i) : _mm_loadu_si128((__m128i *)input+i));\
if (x & OUTPUT_ALIGNED) _mm_store_si128((__m128i *)output+i, t);\
else _mm_storeu_si128((__m128i *)output+i, t);}
//! \brief Helper macro to implement OperateKeystream
#define CRYPTOPP_KEYSTREAM_OUTPUT_SWITCH(x, y) \
switch (operation) \
{ \
case WRITE_KEYSTREAM: \
x(WRITE_KEYSTREAM) \
break; \
case XOR_KEYSTREAM: \
x(XOR_KEYSTREAM) \
input += y; \
break; \
case XOR_KEYSTREAM_INPUT_ALIGNED: \
x(XOR_KEYSTREAM_INPUT_ALIGNED) \
input += y; \
break; \
case XOR_KEYSTREAM_OUTPUT_ALIGNED: \
x(XOR_KEYSTREAM_OUTPUT_ALIGNED) \
input += y; \
break; \
case WRITE_KEYSTREAM_ALIGNED: \
x(WRITE_KEYSTREAM_ALIGNED) \
break; \
case XOR_KEYSTREAM_BOTH_ALIGNED: \
x(XOR_KEYSTREAM_BOTH_ALIGNED) \
input += y; \
break; \
} \
output += y;
//! \class AdditiveCipherTemplate
//! \brief Base class for additive stream ciphers with SymmetricCipher interface
//! \tparam BASE AbstractPolicyHolder base class
template <class BASE = AbstractPolicyHolder<AdditiveCipherAbstractPolicy, SymmetricCipher> >
class CRYPTOPP_NO_VTABLE AdditiveCipherTemplate : public BASE, public RandomNumberGenerator
{
public:
//! \brief Generate random array of bytes
//! \param output the byte buffer
//! \param size the length of the buffer, in bytes
//! \details All generated values are uniformly distributed over the range specified within the
//! the contraints of a particular generator.
void GenerateBlock(byte *output, size_t size);
//! \brief Apply keystream to data
//! \param outString a buffer to write the transformed data
//! \param inString a buffer to read the data
//! \param length the size fo the buffers, in bytes
//! \details This is the primary method to operate a stream cipher. For example:
//! <pre>
//! size_t size = 30;
//! byte plain[size] = "Do or do not; there is no try";
//! byte cipher[size];
//! ...
//! ChaCha20 chacha(key, keySize);
//! chacha.ProcessData(cipher, plain, size);
//! </pre>
void ProcessData(byte *outString, const byte *inString, size_t length);
//! \brief Resynchronize the cipher
//! \param iv a byte array used to resynchronize the cipher
//! \param length the size of the IV array
void Resynchronize(const byte *iv, int length=-1);
//! \brief Provides number of ideal bytes to process
//! \returns the ideal number of bytes to process
//! \details Internally, the default implementation returns GetBytesPerIteration()
//! \sa GetBytesPerIteration() and GetOptimalNextBlockSize()
unsigned int OptimalBlockSize() const {return this->GetPolicy().GetOptimalBlockSize();}
//! \brief Provides number of ideal bytes to process
//! \returns the ideal number of bytes to process
//! \details Internally, the default implementation returns remaining unprocessed bytes
//! \sa GetBytesPerIteration() and OptimalBlockSize()
unsigned int GetOptimalNextBlockSize() const {return (unsigned int)this->m_leftOver;}
//! \brief Provides number of ideal data alignment
//! \returns the ideal data alignment, in bytes
//! \sa GetAlignment() and OptimalBlockSize()
unsigned int OptimalDataAlignment() const {return this->GetPolicy().GetAlignment();}
//! \brief Determines if the cipher is self inverting
//! \returns true if the stream cipher is self inverting, false otherwise
bool IsSelfInverting() const {return true;}
//! \brief Determines if the cipher is a forward transformation
//! \returns true if the stream cipher is a forward transformation, false otherwise
bool IsForwardTransformation() const {return true;}
//! \brief Flag indicating random access
//! \returns true if the cipher is seekable, false otherwise
//! \sa Seek()
bool IsRandomAccess() const {return this->GetPolicy().CipherIsRandomAccess();}
//! \brief Seeks to a random position in the stream
//! \param position the absolute position in the stream
//! \sa IsRandomAccess()
void Seek(lword position);
typedef typename BASE::PolicyInterface PolicyInterface;
protected:
void UncheckedSetKey(const byte *key, unsigned int length, const NameValuePairs &params);
unsigned int GetBufferByteSize(const PolicyInterface &policy) const {return policy.GetBytesPerIteration() * policy.GetIterationsToBuffer();}
inline byte * KeystreamBufferBegin() {return this->m_buffer.data();}
inline byte * KeystreamBufferEnd() {return (this->m_buffer.data() + this->m_buffer.size());}
SecByteBlock m_buffer;
size_t m_leftOver;
};
//! \class CFB_CipherAbstractPolicy
//! \brief Policy object for feeback based stream ciphers
class CRYPTOPP_DLL CRYPTOPP_NO_VTABLE CFB_CipherAbstractPolicy
{
public:
virtual ~CFB_CipherAbstractPolicy() {}
//! \brief Provides data alignment requirements
//! \returns data alignment requirements, in bytes
//! \details Internally, the default implementation returns 1. If the stream cipher is implemented
//! using an SSE2 ASM or intrinsics, then the value returned is usually 16.
virtual unsigned int GetAlignment() const =0;
//! \brief Provides number of bytes operated upon during an iteration
//! \returns bytes operated upon during an iteration, in bytes
//! \sa GetOptimalBlockSize()
virtual unsigned int GetBytesPerIteration() const =0;
//! \brief Access the feedback register
//! \returns pointer to the first byte of the feedback register
virtual byte * GetRegisterBegin() =0;
//! \brief TODO
virtual void TransformRegister() =0;
//! \brief Flag indicating iteration support
//! \returns true if the cipher supports iteration, false otherwise
virtual bool CanIterate() const {return false;}
//! \brief Iterate the cipher
//! \param output the output buffer
//! \param input the input buffer
//! \param dir the direction of the cipher
//! \param iterationCount the number of iterations to perform on the input
//! \sa IsSelfInverting() and IsForwardTransformation()
virtual void Iterate(byte *output, const byte *input, CipherDir dir, size_t iterationCount)
{CRYPTOPP_UNUSED(output); CRYPTOPP_UNUSED(input); CRYPTOPP_UNUSED(dir); CRYPTOPP_UNUSED(iterationCount);
assert(false); /*throw 0;*/ throw Exception(Exception::OTHER_ERROR, "SimpleKeyingInterface: unexpected error");}
//! \brief Key the cipher
//! \param params set of NameValuePairs use to initialize this object
//! \param key a byte array used to key the cipher
//! \param length the size of the key array
virtual void CipherSetKey(const NameValuePairs &params, const byte *key, size_t length) =0;
//! \brief Resynchronize the cipher
//! \param iv a byte array used to resynchronize the cipher
//! \param length the size of the IV array
virtual void CipherResynchronize(const byte *iv, size_t length)
{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
//! \tparam WT word type
//! \tparam W count of words
//! \tparam BASE CFB_CipherAbstractPolicy derived base class
template <typename WT, unsigned int W, class BASE = CFB_CipherAbstractPolicy>
struct CRYPTOPP_NO_VTABLE CFB_CipherConcretePolicy : public BASE
{
typedef WT WordType;
//! \brief Provides data alignment requirements
//! \returns data alignment requirements, in bytes
//! \details Internally, the default implementation returns 1. If the stream cipher is implemented
//! using an SSE2 ASM or intrinsics, then the value returned is usually 16.
unsigned int GetAlignment() const {return sizeof(WordType);}
//! \brief Provides number of bytes operated upon during an iteration
//! \returns bytes operated upon during an iteration, in bytes
//! \sa GetOptimalBlockSize()
unsigned int GetBytesPerIteration() const {return sizeof(WordType) * W;}
//! \brief Flag indicating iteration support
//! \returns true if the cipher supports iteration, false otherwise
bool CanIterate() const {return true;}
//! \brief Perform one iteration in the forward direction
void TransformRegister() {this->Iterate(NULL, NULL, ENCRYPTION, 1);}
//! \brief
//! \tparam B enumeration indicating endianess
//! \details RegisterOutput() provides alternate access to the feedback register. The
//! enumeration B is BigEndian or LittleEndian. Repeatedly applying operator()
//! results in advancing in the register.
template <class B>
struct RegisterOutput
{
RegisterOutput(byte *output, const byte *input, CipherDir dir)
: m_output(output), m_input(input), m_dir(dir) {}
//! \brief XOR feedback register with data
//! \param registerWord data represented as a word type
//! \returns reference to the next feedback register word
inline RegisterOutput& operator()(WordType &registerWord)
{
assert(IsAligned<WordType>(m_output));
assert(IsAligned<WordType>(m_input));
if (!NativeByteOrderIs(B::ToEnum()))
registerWord = ByteReverse(registerWord);
if (m_dir == ENCRYPTION)
{
if (m_input == NULL)
assert(m_output == NULL);
else
{
WordType ct = *(const WordType *)m_input ^ registerWord;
registerWord = ct;
*(WordType*)m_output = ct;
m_input += sizeof(WordType);
m_output += sizeof(WordType);
}
}
else
{
WordType ct = *(const WordType *)m_input;
*(WordType*)m_output = registerWord ^ ct;
registerWord = ct;
m_input += sizeof(WordType);
m_output += sizeof(WordType);
}
// registerWord is left unreversed so it can be xor-ed with further input
return *this;
}
byte *m_output;
const byte *m_input;
CipherDir m_dir;
};
};
//! \class CFB_CipherTemplate
//! \brief Base class for feedback based stream ciphers with SymmetricCipher interface
//! \tparam BASE AbstractPolicyHolder base class
template <class BASE>
class CRYPTOPP_NO_VTABLE CFB_CipherTemplate : public BASE
{
public:
//! \brief Apply keystream to data
//! \param outString a buffer to write the transformed data
//! \param inString a buffer to read the data
//! \param length the size fo the buffers, in bytes
//! \details This is the primary method to operate a stream cipher. For example:
//! <pre>
//! size_t size = 30;
//! byte plain[size] = "Do or do not; there is no try";
//! byte cipher[size];
//! ...
//! ChaCha20 chacha(key, keySize);
//! chacha.ProcessData(cipher, plain, size);
//! </pre>
void ProcessData(byte *outString, const byte *inString, size_t length);
//! \brief Resynchronize the cipher
//! \param iv a byte array used to resynchronize the cipher
//! \param length the size of the IV array
void Resynchronize(const byte *iv, int length=-1);
//! \brief Provides number of ideal bytes to process
//! \returns the ideal number of bytes to process
//! \details Internally, the default implementation returns GetBytesPerIteration()
//! \sa GetBytesPerIteration() and GetOptimalNextBlockSize()
unsigned int OptimalBlockSize() const {return this->GetPolicy().GetBytesPerIteration();}
//! \brief Provides number of ideal bytes to process
//! \returns the ideal number of bytes to process
//! \details Internally, the default implementation returns remaining unprocessed bytes
//! \sa GetBytesPerIteration() and OptimalBlockSize()
unsigned int GetOptimalNextBlockSize() const {return (unsigned int)m_leftOver;}
//! \brief Provides number of ideal data alignment
//! \returns the ideal data alignment, in bytes
//! \sa GetAlignment() and OptimalBlockSize()
unsigned int OptimalDataAlignment() const {return this->GetPolicy().GetAlignment();}
//! \brief Flag indicating random access
//! \returns true if the cipher is seekable, false otherwise
//! \sa Seek()
bool IsRandomAccess() const {return false;}
//! \brief Determines if the cipher is self inverting
//! \returns true if the stream cipher is self inverting, false otherwise
bool IsSelfInverting() const {return false;}
typedef typename BASE::PolicyInterface PolicyInterface;
protected:
virtual void CombineMessageAndShiftRegister(byte *output, byte *reg, const byte *message, size_t length) =0;
void UncheckedSetKey(const byte *key, unsigned int length, const NameValuePairs &params);
size_t m_leftOver;
};
//! \class CFB_EncryptionTemplate
//! \brief Base class for feedback based stream ciphers in the forward direction with SymmetricCipher interface
//! \tparam BASE AbstractPolicyHolder base class
template <class BASE = AbstractPolicyHolder<CFB_CipherAbstractPolicy, SymmetricCipher> >
class CRYPTOPP_NO_VTABLE CFB_EncryptionTemplate : public CFB_CipherTemplate<BASE>
{
bool IsForwardTransformation() const {return true;}
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
//! \tparam BASE AbstractPolicyHolder base class
template <class BASE = AbstractPolicyHolder<CFB_CipherAbstractPolicy, SymmetricCipher> >
class CRYPTOPP_NO_VTABLE CFB_DecryptionTemplate : public CFB_CipherTemplate<BASE>
{
bool IsForwardTransformation() const {return false;}
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
//! \tparam BASE CFB_EncryptionTemplate or CFB_DecryptionTemplate base class
template <class BASE>
class CFB_RequireFullDataBlocks : public BASE
{
public:
unsigned int MandatoryBlockSize() const {return this->OptimalBlockSize();}
};
//! \class SymmetricCipherFinal
//! \brief SymmetricCipher implementation
//! \tparam BASE AbstractPolicyHolder derived base class
//! \tparam INFO AbstractPolicyHolder derived information class
//! \sa Weak::ARC4, ChaCha8, ChaCha12, ChaCha20, Salsa20, SEAL, Sosemanuk, WAKE
template <class BASE, class INFO = BASE>
class SymmetricCipherFinal : public AlgorithmImpl<SimpleKeyingInterfaceImpl<BASE, INFO>, INFO>
{
public:
//! \brief Construct a stream cipher
SymmetricCipherFinal() {}
//! \brief Construct a stream cipher
//! \param key a byte array used to key the cipher
//! \details This overload uses DEFAULT_KEYLENGTH
SymmetricCipherFinal(const byte *key)
{this->SetKey(key, this->DEFAULT_KEYLENGTH);}
//! \brief Construct a stream cipher
//! \param key a byte array used to key the cipher
//! \param length the size of the key array
SymmetricCipherFinal(const byte *key, size_t length)
{this->SetKey(key, length);}
//! \brief Construct a stream cipher
//! \param key a byte array used to key the cipher
//! \param length the size of the key array
//! \param iv a byte array used as an initialization vector
SymmetricCipherFinal(const byte *key, size_t length, const byte *iv)
{this->SetKeyWithIV(key, length, iv);}
//! \brief Clone a SymmetricCipher
//! \returns a new SymmetricCipher based on this object
Clonable * Clone() const {return static_cast<SymmetricCipher *>(new SymmetricCipherFinal<BASE, INFO>(*this));}
};
NAMESPACE_END
#ifdef CRYPTOPP_MANUALLY_INSTANTIATE_TEMPLATES
#include "strciphr.cpp"
#endif
NAMESPACE_BEGIN(CryptoPP)
CRYPTOPP_DLL_TEMPLATE_CLASS AbstractPolicyHolder<AdditiveCipherAbstractPolicy, SymmetricCipher>;
CRYPTOPP_DLL_TEMPLATE_CLASS AdditiveCipherTemplate<AbstractPolicyHolder<AdditiveCipherAbstractPolicy, SymmetricCipher> >;
CRYPTOPP_DLL_TEMPLATE_CLASS CFB_CipherTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, SymmetricCipher> >;
CRYPTOPP_DLL_TEMPLATE_CLASS CFB_EncryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, SymmetricCipher> >;
CRYPTOPP_DLL_TEMPLATE_CLASS CFB_DecryptionTemplate<AbstractPolicyHolder<CFB_CipherAbstractPolicy, SymmetricCipher> >;
NAMESPACE_END
#if CRYPTOPP_MSC_VERSION
# pragma warning(pop)
#endif
#endif
AdditiveCipherTemplate::IsSelfInverting
bool IsSelfInverting() const
Determines if the cipher is self inverting.
Definition: strciphr.h:318
CFB_CipherTemplate::OptimalDataAlignment
unsigned int OptimalDataAlignment() const
Provides number of ideal data alignment.
Definition: strciphr.h:525
SymmetricCipherFinal::SymmetricCipherFinal
SymmetricCipherFinal(const byte *key)
Construct a stream cipher.
Definition: strciphr.h:591
XOR_KEYSTREAM_BOTH_ALIGNED
@ XOR_KEYSTREAM_BOTH_ALIGNED
XOR the aligned input buffer and keystream, write to the aligned output buffer.
Definition: strciphr.h:104
AdditiveCipherConcretePolicy::GetIterationsToBuffer
unsigned int GetIterationsToBuffer() const
Provides buffer size based on iterations.
Definition: strciphr.h:208
AdditiveCipherAbstractPolicy::CipherResynchronize
virtual void CipherResynchronize(byte *keystreamBuffer, const byte *iv, size_t length)
Resynchronize the cipher.
Definition: strciphr.h:166
NotImplemented
A method was called which was not implemented.
Definition: cryptlib.h:203
IsAlignedOn
bool IsAlignedOn(const void *ptr, unsigned int alignment)
Determines whether ptr is aligned to a minimum value.
Definition: misc.h:907
INPUT_ALIGNED
@ INPUT_ALIGNED
Input buffer is aligned.
Definition: strciphr.h:84
AdditiveCipherConcretePolicy::GetBytesPerIteration
unsigned int GetBytesPerIteration() const
Provides number of bytes operated upon during an iteration.
Definition: strciphr.h:204
AdditiveCipherAbstractPolicy::GetAlignment
virtual unsigned int GetAlignment() const
Provides data alignment requirements.
Definition: strciphr.h:116
CFB_CipherTemplate::IsRandomAccess
bool IsRandomAccess() const
Flag indicating random access.
Definition: strciphr.h:530
SymmetricCipherFinal
SymmetricCipher implementation.
Definition: strciphr.h:582
AdditiveCipherConcretePolicy
Base class for additive stream ciphers.
Definition: strciphr.h:188
CFB_CipherConcretePolicy::TransformRegister
void TransformRegister()
Perform one iteration in the forward direction.
Definition: strciphr.h:426
AdditiveCipherTemplate::IsRandomAccess
bool IsRandomAccess() const
Flag indicating random access.
Definition: strciphr.h:327
AdditiveCipherAbstractPolicy::WriteKeystream
virtual void WriteKeystream(byte *keystream, size_t iterationCount)
Generate the keystream.
Definition: strciphr.h:137
secblock.h
Classes and functions for secure memory allocations.
SymmetricCipher
Interface for one direction (encryption or decryption) of a stream cipher or cipher mode.
Definition: cryptlib.h:1099
SecByteBlock
SecBlock<byte> typedef.
Definition: secblock.h:731
Clonable
Interface for cloning objects.
Definition: cryptlib.h:480
AdditiveCipherAbstractPolicy::OperateKeystream
virtual void OperateKeystream(KeystreamOperation operation, byte *output, const byte *input, size_t iterationCount)
Operates the keystream.
Definition: strciphr.h:153
ENCRYPTION
@ ENCRYPTION
the cipher is performing encryption
Definition: cryptlib.h:105
CFB_CipherConcretePolicy::RegisterOutput::operator()
RegisterOutput & operator()(WordType &registerWord)
XOR feedback register with data.
Definition: strciphr.h:442
AdditiveCipherAbstractPolicy
Policy object for additive stream ciphers.
Definition: strciphr.h:108
CFB_CipherTemplate::GetOptimalNextBlockSize
unsigned int GetOptimalNextBlockSize() const
Provides number of ideal bytes to process.
Definition: strciphr.h:520
RandomNumberGenerator::GenerateBlock
virtual void GenerateBlock(byte *output, size_t size)
Generate random array of bytes.
Definition: cryptlib.cpp:330
AdditiveCipherTemplate::GetOptimalNextBlockSize
unsigned int GetOptimalNextBlockSize() const
Provides number of ideal bytes to process.
Definition: strciphr.h:309
RandomNumberGenerator
Interface for random number generators.
Definition: cryptlib.h:1186
CipherDir
CipherDir
Specifies a direction for a cipher to operate.
Definition: cryptlib.h:103
XOR_KEYSTREAM_INPUT_ALIGNED
@ XOR_KEYSTREAM_INPUT_ALIGNED
XOR the aligned input buffer and keystream, write to the output buffer.
Definition: strciphr.h:100
argnames.h
Standard names for retrieving values by name when working with NameValuePairs.
CFB_CipherConcretePolicy::CanIterate
bool CanIterate() const
Flag indicating iteration support.
Definition: strciphr.h:423
XOR_KEYSTREAM
@ XOR_KEYSTREAM
XOR the input buffer and keystream, write to the output buffer.
Definition: strciphr.h:98
AdditiveCipherTemplate::OptimalDataAlignment
unsigned int OptimalDataAlignment() const
Provides number of ideal data alignment.
Definition: strciphr.h:314
NativeByteOrderIs
bool NativeByteOrderIs(ByteOrder order)
Determines whether order follows native byte ordering.
Definition: misc.h:948
Exception
Base class for all exceptions thrown by the library.
Definition: cryptlib.h:139
AbstractPolicyHolder
Access a stream cipher policy object.
Definition: strciphr.h:50
AdditiveCipherTemplate
Base class for additive stream ciphers with SymmetricCipher interface.
Definition: strciphr.h:269
CFB_RequireFullDataBlocks
Base class for feedback based stream ciphers with a mandatory block size.
Definition: strciphr.h:570
CFB_CipherAbstractPolicy
Policy object for feeback based stream ciphers.
Definition: strciphr.h:350
CFB_CipherAbstractPolicy::CanIterate
virtual bool CanIterate() const
Flag indicating iteration support.
Definition: strciphr.h:375
CFB_CipherTemplate::OptimalBlockSize
unsigned int OptimalBlockSize() const
Provides number of ideal bytes to process.
Definition: strciphr.h:514
WRITE_KEYSTREAM
@ WRITE_KEYSTREAM
Wirte the keystream to the output buffer, input is NULL.
Definition: strciphr.h:94
KeystreamOperation
KeystreamOperation
Keystream operation flags.
Definition: strciphr.h:92
SymmetricCipherFinal::SymmetricCipherFinal
SymmetricCipherFinal()
Construct a stream cipher.
Definition: strciphr.h:586
SymmetricCipherFinal::SymmetricCipherFinal
SymmetricCipherFinal(const byte *key, size_t length, const byte *iv)
Construct a stream cipher.
Definition: strciphr.h:604
CFB_CipherConcretePolicy
Base class for feedback based stream ciphers.
Definition: strciphr.h:406
AdditiveCipherTemplate::IsForwardTransformation
bool IsForwardTransformation() const
Determines if the cipher is a forward transformation.
Definition: strciphr.h:322
seckey.h
Classes and functions for implementing secret key algorithms.
INPUT_NULL
@ INPUT_NULL
Input buffer is NULL.
Definition: strciphr.h:86
CFB_CipherConcretePolicy::GetBytesPerIteration
unsigned int GetBytesPerIteration() const
Provides number of bytes operated upon during an iteration.
Definition: strciphr.h:419
CFB_CipherAbstractPolicy::CipherResynchronize
virtual void CipherResynchronize(const byte *iv, size_t length)
Resynchronize the cipher.
Definition: strciphr.h:396
SymmetricCipherFinal::SymmetricCipherFinal
SymmetricCipherFinal(const byte *key, size_t length)
Construct a stream cipher.
Definition: strciphr.h:597
CFB_CipherTemplate
Base class for feedback based stream ciphers with SymmetricCipher interface.
Definition: strciphr.h:487
CFB_DecryptionTemplate
Base class for feedback based stream ciphers in the reverse direction with SymmetricCipher interface.
Definition: strciphr.h:560
OUTPUT_ALIGNED
@ OUTPUT_ALIGNED
Output buffer is aligned.
Definition: strciphr.h:82
CFB_CipherConcretePolicy::RegisterOutput
Definition: strciphr.h:434
KeystreamOperationFlags
KeystreamOperationFlags
Keystream operation flags.
Definition: strciphr.h:80
CFB_CipherTemplate::IsSelfInverting
bool IsSelfInverting() const
Determines if the cipher is self inverting.
Definition: strciphr.h:534
ByteReverse
byte ByteReverse(byte value)
Reverses bytes in a 8-bit value.
Definition: misc.h:1705
AdditiveCipherTemplate::OptimalBlockSize
unsigned int OptimalBlockSize() const
Provides number of ideal bytes to process.
Definition: strciphr.h:303
CFB_CipherConcretePolicy::GetAlignment
unsigned int GetAlignment() const
Provides data alignment requirements.
Definition: strciphr.h:414
CryptoPP
Crypto++ library namespace.
AdditiveCipherAbstractPolicy::SeekToIteration
virtual void SeekToIteration(lword iterationCount)
Seeks to a random position in the stream.
Definition: strciphr.h:177
config.h
Library configuration file.
AdditiveCipherConcretePolicy::GetAlignment
unsigned int GetAlignment() const
Provides data alignment requirements.
Definition: strciphr.h:198
XOR_KEYSTREAM_OUTPUT_ALIGNED
@ XOR_KEYSTREAM_OUTPUT_ALIGNED
XOR the input buffer and keystream, write to the aligned output buffer.
Definition: strciphr.h:102
AdditiveCipherConcretePolicy::CanOperateKeystream
bool CanOperateKeystream() const
Flag indicating.
Definition: strciphr.h:213
WRITE_KEYSTREAM_ALIGNED
@ WRITE_KEYSTREAM_ALIGNED
Wirte the keystream to the aligned output buffer, input is NULL.
Definition: strciphr.h:96
SymmetricCipherFinal::Clone
Clonable * Clone() const
Clone a SymmetricCipher.
Definition: strciphr.h:609
CFB_CipherAbstractPolicy::Iterate
virtual void Iterate(byte *output, const byte *input, CipherDir dir, size_t iterationCount)
Iterate the cipher.
Definition: strciphr.h:383
Exception::OTHER_ERROR
@ OTHER_ERROR
Some other error occurred not belonging to other categories.
Definition: cryptlib.h:158
AdditiveCipherAbstractPolicy::GetOptimalBlockSize
virtual unsigned int GetOptimalBlockSize() const
Provides number of ideal bytes to process.
Definition: strciphr.h:127
CFB_EncryptionTemplate
Base class for feedback based stream ciphers in the forward direction with SymmetricCipher interface.
Definition: strciphr.h:550
NameValuePairs
Interface for retrieving values given their names.
Definition: cryptlib.h:277
cryptlib.h
Abstract base classes that provide a uniform interface to this library.
AlgorithmImpl
Base class for identifying alogorithm.
Definition: simple.h:38
ConcretePolicyHolder
Stream cipher policy object.
Definition: strciphr.h:66
AdditiveCipherAbstractPolicy::CanOperateKeystream
virtual bool CanOperateKeystream() const
Flag indicating.
Definition: strciphr.h:143