Crypto++
8.6
Free C++ class library of cryptographic schemes
|
Go to the documentation of this file.
28 #ifndef CRYPTOPP_STRCIPHR_H
29 #define CRYPTOPP_STRCIPHR_H
33 #if CRYPTOPP_MSC_VERSION
34 # pragma warning(push)
35 # pragma warning(disable: 4127 4189 4231 4275)
48 template <
class POLICY_INTERFACE,
class BASE = Empty>
52 typedef POLICY_INTERFACE PolicyInterface;
56 virtual const POLICY_INTERFACE & GetPolicy()
const =0;
57 virtual POLICY_INTERFACE & AccessPolicy() =0;
63 template <
class POLICY,
class BASE,
class POLICY_INTERFACE =
typename BASE::PolicyInterface>
69 const POLICY_INTERFACE & GetPolicy()
const {
return *
this;}
70 POLICY_INTERFACE & AccessPolicy() {
return *
this;}
117 virtual unsigned int GetBytesPerIteration()
const =0;
127 virtual unsigned int GetIterationsToBuffer()
const =0;
150 {CRYPTOPP_UNUSED(operation); CRYPTOPP_UNUSED(output); CRYPTOPP_UNUSED(input);
157 virtual void CipherSetKey(
const NameValuePairs ¶ms,
const byte *key,
size_t length) =0;
164 {CRYPTOPP_UNUSED(keystreamBuffer); CRYPTOPP_UNUSED(iv); CRYPTOPP_UNUSED(length);
165 throw NotImplemented(
"SimpleKeyingInterface: this object doesn't support resynchronization");}
170 virtual bool CipherIsRandomAccess()
const =0;
175 {CRYPTOPP_UNUSED(iterationCount);
CRYPTOPP_ASSERT(!CipherIsRandomAccess());
176 throw NotImplemented(
"StreamTransformation: this object doesn't support random access");}
200 template <
typename WT,
unsigned int W,
unsigned int X = 1,
class BASE = AdditiveCipherAbstractPolicy>
211 CRYPTOPP_CONSTANT(BYTES_PER_ITERATION =
sizeof(
WordType) * W);
245 virtual void OperateKeystream(
KeystreamOperation operation,
byte *output,
const byte *input,
size_t iterationCount) =0;
253 #define CRYPTOPP_KEYSTREAM_OUTPUT_WORD(x, b, i, a) \
254 PutWord(((x & OUTPUT_ALIGNED) != 0), b, output+i*sizeof(WordType), (x & INPUT_NULL) ? (a) : (a) ^ GetWord<WordType>(((x & INPUT_ALIGNED) != 0), b, input+i*sizeof(WordType)));
260 #define CRYPTOPP_KEYSTREAM_OUTPUT_XMM(x, i, a) {\
261 __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));\
262 if (x & OUTPUT_ALIGNED) _mm_store_si128((__m128i *)output+i, t);\
263 else _mm_storeu_si128((__m128i *)output+i, t);}
266 #define CRYPTOPP_KEYSTREAM_OUTPUT_SWITCH(x, y) \
269 case WRITE_KEYSTREAM: \
270 x(EnumToInt(WRITE_KEYSTREAM)) \
272 case XOR_KEYSTREAM: \
273 x(EnumToInt(XOR_KEYSTREAM)) \
276 case XOR_KEYSTREAM_INPUT_ALIGNED: \
277 x(EnumToInt(XOR_KEYSTREAM_INPUT_ALIGNED)) \
280 case XOR_KEYSTREAM_OUTPUT_ALIGNED: \
281 x(EnumToInt(XOR_KEYSTREAM_OUTPUT_ALIGNED)) \
284 case WRITE_KEYSTREAM_ALIGNED: \
285 x(EnumToInt(WRITE_KEYSTREAM_ALIGNED)) \
287 case XOR_KEYSTREAM_BOTH_ALIGNED: \
288 x(EnumToInt(XOR_KEYSTREAM_BOTH_ALIGNED)) \
296 template <
class BASE = AbstractPolicyHolder<AdditiveCipherAbstractPolicy, SymmetricCipher> >
329 void ProcessData(
byte *outString,
const byte *inString,
size_t length);
334 void Resynchronize(
const byte *iv,
int length=-1);
369 void Seek(
lword position);
387 typedef typename BASE::PolicyInterface PolicyInterface;
390 void UncheckedSetKey(
const byte *key,
unsigned int length,
const NameValuePairs ¶ms);
392 unsigned int GetBufferByteSize(
const PolicyInterface &policy)
const {
return policy.GetBytesPerIteration() * policy.GetIterationsToBuffer();}
394 inline byte * KeystreamBufferBegin() {
return this->m_buffer.data();}
395 inline byte * KeystreamBufferEnd() {
return (
PtrAdd(this->m_buffer.data(), this->m_buffer.size()));}
412 virtual unsigned int GetAlignment()
const =0;
417 virtual unsigned int GetBytesPerIteration()
const =0;
421 virtual byte * GetRegisterBegin() =0;
424 virtual void TransformRegister() =0;
436 virtual void Iterate(
byte *output,
const byte *input,
CipherDir dir,
size_t iterationCount)
437 {CRYPTOPP_UNUSED(output); CRYPTOPP_UNUSED(input); CRYPTOPP_UNUSED(dir);
445 virtual void CipherSetKey(
const NameValuePairs ¶ms,
const byte *key,
size_t length) =0;
451 {CRYPTOPP_UNUSED(iv); CRYPTOPP_UNUSED(length);
452 throw NotImplemented(
"SimpleKeyingInterface: this object doesn't support resynchronization");}
475 template <
typename WT,
unsigned int W,
class BASE = CFB_CipherAbstractPolicy>
509 : m_output(output), m_input(input), m_dir(dir) {}
524 if (m_input == NULLPTR)
531 WordType ct = GetWord<WordType>(
false, NativeByteOrder::ToEnum(), m_input) ^ registerWord;
535 PutWord<WordType>(
false, NativeByteOrder::ToEnum(), m_output, ct);
537 m_input +=
sizeof(WordType);
538 m_output +=
sizeof(WordType);
544 WordType ct = GetWord<WordType>(
false, NativeByteOrder::ToEnum(), m_input);
547 PutWord<WordType>(
false, NativeByteOrder::ToEnum(), m_output, registerWord ^ ct);
550 m_input +=
sizeof(WordType);
551 m_output +=
sizeof(WordType);
567 template <
class BASE>
593 void ProcessData(
byte *outString,
const byte *inString,
size_t length);
598 void Resynchronize(
const byte *iv,
int length=-1);
642 typedef typename BASE::PolicyInterface PolicyInterface;
645 virtual void CombineMessageAndShiftRegister(
byte *output,
byte *reg,
const byte *message,
size_t length) =0;
647 void UncheckedSetKey(
const byte *key,
unsigned int length,
const NameValuePairs ¶ms);
656 template <
class BASE = AbstractPolicyHolder<CFB_CipherAbstractPolicy, SymmetricCipher> >
659 bool IsForwardTransformation()
const {
return true;}
660 void CombineMessageAndShiftRegister(
byte *output,
byte *reg,
const byte *message,
size_t length);
665 template <
class BASE = AbstractPolicyHolder<CFB_CipherAbstractPolicy, SymmetricCipher> >
668 bool IsForwardTransformation()
const {
return false;}
669 void CombineMessageAndShiftRegister(
byte *output,
byte *reg,
const byte *message,
size_t length);
674 template <
class BASE>
678 unsigned int MandatoryBlockSize()
const {
return this->OptimalBlockSize();}
685 template <
class BASE,
class INFO = BASE>
698 {this->SetKey(key, this->DEFAULT_KEYLENGTH);}
704 {this->SetKey(key, length);}
711 {this->SetKeyWithIV(key, length, iv);}
721 #ifdef CRYPTOPP_MANUALLY_INSTANTIATE_TEMPLATES
722 # include "strciphr.cpp"
736 #if CRYPTOPP_MSC_VERSION
737 # pragma warning(pop)
bool IsSelfInverting() const
Determines if the cipher is self inverting.
unsigned int OptimalDataAlignment() const
Provides number of ideal data alignment.
SymmetricCipherFinal(const byte *key)
Construct a stream cipher.
@ XOR_KEYSTREAM_BOTH_ALIGNED
XOR the aligned input buffer and keystream, write to the aligned output buffer.
unsigned int GetIterationsToBuffer() const
Provides buffer size based on iterations.
virtual std::string AlgorithmProvider() const
Retrieve the provider of this algorithm.
virtual void CipherResynchronize(byte *keystreamBuffer, const byte *iv, size_t length)
Resynchronize the cipher.
A method was called which was not implemented.
bool IsAlignedOn(const void *ptr, unsigned int alignment)
Determines whether ptr is aligned to a minimum value.
@ INPUT_ALIGNED
Input buffer is aligned.
unsigned int GetBytesPerIteration() const
Provides number of bytes operated upon during an iteration.
virtual unsigned int GetAlignment() const
Provides data alignment requirements.
bool IsRandomAccess() const
Flag indicating random access.
SymmetricCipher implementation.
Base class for additive stream ciphers.
void TransformRegister()
Perform one iteration in the forward direction.
bool IsRandomAccess() const
Flag indicating random access.
std::string AlgorithmProvider() const
Retrieve the provider of this algorithm.
virtual void WriteKeystream(byte *keystream, size_t iterationCount)
Generate the keystream.
Classes and functions for secure memory allocations.
Interface for one direction (encryption or decryption) of a stream cipher or cipher mode.
Interface for cloning objects.
#define CRYPTOPP_ASSERT(exp)
Debugging and diagnostic assertion.
std::string AlgorithmProvider() const
Retrieve the provider of this algorithm.
virtual void OperateKeystream(KeystreamOperation operation, byte *output, const byte *input, size_t iterationCount)
Operates the keystream.
@ ENCRYPTION
the cipher is performing encryption
RegisterOutput & operator()(WordType ®isterWord)
XOR feedback register with data.
Policy object for additive stream ciphers.
unsigned int GetOptimalNextBlockSize() const
Provides number of ideal bytes to process.
unsigned int GetOptimalNextBlockSize() const
Provides number of ideal bytes to process.
Interface for random number generators.
CipherDir
Specifies a direction for a cipher to operate.
@ XOR_KEYSTREAM_INPUT_ALIGNED
XOR the aligned input buffer and keystream, write to the output buffer.
Standard names for retrieving values by name when working with NameValuePairs.
bool CanIterate() const
Flag indicating iteration support.
@ XOR_KEYSTREAM
XOR the input buffer and keystream, write to the output buffer.
unsigned int OptimalDataAlignment() const
Provides number of ideal data alignment.
bool NativeByteOrderIs(ByteOrder order)
Determines whether order follows native byte ordering.
Base class for all exceptions thrown by the library.
Access a stream cipher policy object.
Base class for additive stream ciphers with SymmetricCipher interface.
Base class for feedback based stream ciphers with a mandatory block size.
Policy object for feedback based stream ciphers.
virtual bool CanIterate() const
Flag indicating iteration support.
unsigned int OptimalBlockSize() const
Provides number of ideal bytes to process.
@ WRITE_KEYSTREAM
Write the keystream to the output buffer, input is NULL.
KeystreamOperation
Keystream operation flags.
SymmetricCipherFinal()
Construct a stream cipher.
SymmetricCipherFinal(const byte *key, size_t length, const byte *iv)
Construct a stream cipher.
Base class for feedback based stream ciphers.
bool IsForwardTransformation() const
Determines if the cipher is a forward transformation.
Classes and functions for implementing secret key algorithms.
virtual void GenerateBlock(byte *output, size_t size)
Generate random array of bytes.
@ INPUT_NULL
Input buffer is NULL.
unsigned int GetBytesPerIteration() const
Provides number of bytes operated upon during an iteration.
virtual void CipherResynchronize(const byte *iv, size_t length)
Resynchronize the cipher.
SymmetricCipherFinal(const byte *key, size_t length)
Construct a stream cipher.
Base class for feedback based stream ciphers with SymmetricCipher interface.
word64 lword
Large word type.
Base class for feedback based stream ciphers in the reverse direction with SymmetricCipher interface.
@ OUTPUT_ALIGNED
Output buffer is aligned.
Provides alternate access to a feedback register.
KeystreamOperationFlags
Keystream operation flags.
bool IsSelfInverting() const
Determines if the cipher is self inverting.
byte ByteReverse(byte value)
Reverses bytes in a 8-bit value.
unsigned int OptimalBlockSize() const
Provides number of ideal bytes to process.
unsigned int GetAlignment() const
Provides data alignment requirements.
Crypto++ library namespace.
#define CRYPTOPP_DLL_TEMPLATE_CLASS
Instantiate templates in a dynamic library.
virtual void SeekToIteration(lword iterationCount)
Seeks to a random position in the stream.
WT WordType
Word type for the cipher.
Library configuration file.
unsigned int GetAlignment() const
Provides data alignment requirements.
PTR PtrAdd(PTR pointer, OFF offset)
Create a pointer with an offset.
@ XOR_KEYSTREAM_OUTPUT_ALIGNED
XOR the input buffer and keystream, write to the aligned output buffer.
bool CanOperateKeystream() const
Flag indicating.
SecBlock using AllocatorWithCleanup<byte, true> typedef.
@ WRITE_KEYSTREAM_ALIGNED
Write the keystream to the aligned output buffer, input is NULL.
Clonable * Clone() const
Clone a SymmetricCipher.
virtual void Iterate(byte *output, const byte *input, CipherDir dir, size_t iterationCount)
Iterate the cipher.
@ OTHER_ERROR
Some other error occurred not belonging to other categories.
virtual unsigned int GetOptimalBlockSize() const
Provides number of ideal bytes to process.
Base class for feedback based stream ciphers in the forward direction with SymmetricCipher interface.
Interface for retrieving values given their names.
Abstract base classes that provide a uniform interface to this library.
virtual std::string AlgorithmProvider() const
Retrieve the provider of this algorithm.
Stream cipher policy object.
virtual bool CanOperateKeystream() const
Flag indicating.