Classes for implementing stream ciphers. More...

#include "config.h"
#include "cryptlib.h"
#include "seckey.h"
#include "secblock.h"
#include "argnames.h"

Include dependency graph for strciphr.h:

This graph shows which files directly or indirectly include this file:

Classes
class	AbstractPolicyHolder< POLICY_INTERFACE, BASE >
	Access a stream cipher policy object. More...

class	ConcretePolicyHolder< POLICY, BASE, POLICY_INTERFACE >
	Stream cipher policy object. More...

class	AdditiveCipherAbstractPolicy
	Policy object for additive stream ciphers. More...

class	AdditiveCipherConcretePolicy< WT, W, X, BASE >
	Base class for additive stream ciphers. More...

class	AdditiveCipherTemplate< BASE >
	Base class for additive stream ciphers with SymmetricCipher interface. More...

class	CFB_CipherAbstractPolicy
	Policy object for feeback based stream ciphers. More...

class	CFB_CipherConcretePolicy< WT, W, BASE >
	Base class for feedback based stream ciphers. More...

struct	CFB_CipherConcretePolicy< WT, W, BASE >::RegisterOutput< B >

class	CFB_CipherTemplate< BASE >
	Base class for feedback based stream ciphers with SymmetricCipher interface. More...

class	CFB_EncryptionTemplate< BASE >
	Base class for feedback based stream ciphers in the forward direction with SymmetricCipher interface. More...

class	CFB_DecryptionTemplate< BASE >
	Base class for feedback based stream ciphers in the reverse direction with SymmetricCipher interface. More...

class	CFB_RequireFullDataBlocks< BASE >
	Base class for feedback based stream ciphers with a mandatory block size. More...

class	SymmetricCipherFinal< BASE, INFO >
	SymmetricCipher implementation. More...

Macros
#define	CRYPTOPP_KEYSTREAM_OUTPUT_WORD(x, b, i, a) PutWord(bool(x & OUTPUT_ALIGNED), b, output+isizeof(WordType), (x & INPUT_NULL) ? (a) : (a) ^ GetWord<WordType>(bool(x & INPUT_ALIGNED), b, input+isizeof(WordType)));
	Helper macro to implement OperateKeystream. More...

#define	CRYPTOPP_KEYSTREAM_OUTPUT_XMM(x, i, a)
	Helper macro to implement OperateKeystream. More...

#define	CRYPTOPP_KEYSTREAM_OUTPUT_SWITCH(x, y)
	Helper macro to implement OperateKeystream. More...

Enumerations
enum	KeystreamOperationFlags { OUTPUT_ALIGNED =1, INPUT_ALIGNED =2, INPUT_NULL = 4 }
	Keystream operation flags. More...

enum	KeystreamOperation { WRITE_KEYSTREAM = INPUT_NULL, WRITE_KEYSTREAM_ALIGNED = INPUT_NULL \| OUTPUT_ALIGNED, XOR_KEYSTREAM = 0, XOR_KEYSTREAM_INPUT_ALIGNED = INPUT_ALIGNED, XOR_KEYSTREAM_OUTPUT_ALIGNED = OUTPUT_ALIGNED, XOR_KEYSTREAM_BOTH_ALIGNED = OUTPUT_ALIGNED \| INPUT_ALIGNED }
	Keystream operation flags. More...

Variables
NAMESPACE_END 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 > >

Detailed Description

Classes for implementing stream ciphers.

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.

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:

    typedef SymmetricCipherFinal<ConcretePolicyHolder<SEAL_Policy<B>, AdditiveCipherTemplate<> > > Encryption;

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 overridden 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.

Definition in file strciphr.h.

Macro Definition Documentation

#define CRYPTOPP_KEYSTREAM_OUTPUT_SWITCH	(	x,
		y
	)

Value:

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;

Helper macro to implement OperateKeystream.

Definition at line 235 of file strciphr.h.

#define CRYPTOPP_KEYSTREAM_OUTPUT_WORD	(	x,
		b,
		i,
		a
	)	PutWord(bool(x & OUTPUT_ALIGNED), b, output+isizeof(WordType), (x & INPUT_NULL) ? (a) : (a) ^ GetWord<WordType>(bool(x & INPUT_ALIGNED), b, input+isizeof(WordType)));

Helper macro to implement OperateKeystream.

Definition at line 225 of file strciphr.h.

#define CRYPTOPP_KEYSTREAM_OUTPUT_XMM	(	x,
		i,
		a
	)

Value:

{\
        __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);}

Helper macro to implement OperateKeystream.

Definition at line 229 of file strciphr.h.

Enumeration Type Documentation

enum KeystreamOperation

Keystream operation flags.

See also: AdditiveCipherAbstractPolicy::GetBytesPerIteration(), AdditiveCipherAbstractPolicy::GetOptimalBlockSize() and AdditiveCipherAbstractPolicy::GetAlignment()

Enumerator
WRITE_KEYSTREAM	Wirte the keystream to the output buffer, input is NULL.
WRITE_KEYSTREAM_ALIGNED	Wirte the keystream to the aligned output buffer, input is NULL.
XOR_KEYSTREAM	XOR the input buffer and keystream, write to the output buffer.
XOR_KEYSTREAM_INPUT_ALIGNED	XOR the aligned input buffer and keystream, write to the output buffer.
XOR_KEYSTREAM_OUTPUT_ALIGNED	XOR the input buffer and keystream, write to the aligned output buffer.
XOR_KEYSTREAM_BOTH_ALIGNED	XOR the aligned input buffer and keystream, write to the aligned output buffer.