5#ifndef CRYPTOPP_IMPORTS
10#if defined(CRYPTOPP_DEBUG)
16#if defined(CRYPTOPP_DEBUG) && !defined(CRYPTOPP_DOXYGEN_PROCESSING)
17void Modes_TestInstantiations()
19 CFB_Mode<DES>::Encryption m0;
20 CFB_Mode<DES>::Decryption m1;
21 OFB_Mode<DES>::Encryption m2;
22 CTR_Mode<DES>::Encryption m3;
23 ECB_Mode<DES>::Encryption m4;
24 CBC_Mode<DES>::Encryption m5;
28void CipherModeBase::ResizeBuffers()
30 m_register.New(m_cipher->BlockSize());
33void CFB_ModePolicy::Iterate(
byte *output,
const byte *input,
CipherDir dir,
size_t iterationCount)
41 const unsigned int s = BlockSize();
44 m_cipher->ProcessAndXorBlock(m_register, input, output);
45 if (iterationCount > 1)
46 m_cipher->AdvancedProcessBlocks(output,
PtrAdd(input,s),
PtrAdd(output,s), (iterationCount-1)*s, 0);
47 std::memcpy(m_register,
PtrAdd(output,(iterationCount-1)*s), s);
52 std::memcpy(m_temp,
PtrAdd(input,(iterationCount-1)*s), s);
53 if (iterationCount > 1)
55 m_cipher->ProcessAndXorBlock(m_register, input, output);
56 std::memcpy(m_register, m_temp, s);
60void CFB_ModePolicy::TransformRegister()
66 const ptrdiff_t updateSize = BlockSize()-m_feedbackSize;
67 m_cipher->ProcessBlock(m_register, m_temp);
68 memmove_s(m_register, m_register.size(),
PtrAdd(m_register.begin(),m_feedbackSize), updateSize);
69 memcpy_s(
PtrAdd(m_register.begin(),updateSize), m_register.size()-updateSize, m_temp, m_feedbackSize);
72void CFB_ModePolicy::CipherResynchronize(
const byte *iv,
size_t length)
77 CopyOrZero(m_register, m_register.size(), iv, length);
81void CFB_ModePolicy::SetFeedbackSize(
unsigned int feedbackSize)
83 if (feedbackSize > BlockSize())
84 throw InvalidArgument(
"CFB_Mode: invalid feedback size");
85 m_feedbackSize = feedbackSize ? feedbackSize : BlockSize();
88void CFB_ModePolicy::ResizeBuffers()
90 CipherModeBase::ResizeBuffers();
91 m_temp.New(BlockSize());
94byte* CFB_ModePolicy::GetRegisterBegin()
98 return PtrAdd(m_register.begin(), BlockSize() - m_feedbackSize);
101void OFB_ModePolicy::WriteKeystream(
byte *keystreamBuffer,
size_t iterationCount)
107 const unsigned int s = BlockSize();
108 m_cipher->ProcessBlock(m_register, keystreamBuffer);
109 if (iterationCount > 1)
110 m_cipher->AdvancedProcessBlocks(keystreamBuffer, NULLPTR,
PtrAdd(keystreamBuffer, s), s*(iterationCount-1), 0);
111 std::memcpy(m_register,
PtrAdd(keystreamBuffer, (iterationCount-1)*s), s);
114void OFB_ModePolicy::CipherResynchronize(
byte *keystreamBuffer,
const byte *iv,
size_t length)
116 CRYPTOPP_UNUSED(keystreamBuffer), CRYPTOPP_UNUSED(length);
120 CopyOrZero(m_register, m_register.size(), iv, length);
123void CTR_ModePolicy::SeekToIteration(
lword iterationCount)
126 for (
int i=BlockSize()-1; i>=0; i--)
128 unsigned int sum = m_register[i] + (
byte)iterationCount + carry;
129 m_counterArray[i] =
byte(sum & 0xff);
131 iterationCount >>= 8;
135void CTR_ModePolicy::IncrementCounterBy256()
140void CTR_ModePolicy::OperateKeystream(
KeystreamOperation ,
byte *output,
const byte *input,
size_t iterationCount)
145 const unsigned int s = BlockSize();
146 const unsigned int inputIncrement = input ? s : 0;
148 while (iterationCount)
150 const byte lsb = m_counterArray[s-1];
151 const size_t blocks =
UnsignedMin(iterationCount, 256U-lsb);
154 if ((m_counterArray[s-1] =
byte(lsb + blocks)) == 0)
155 IncrementCounterBy256();
157 output =
PtrAdd(output, blocks*s);
158 input =
PtrAdd(input, blocks*inputIncrement);
159 iterationCount -= blocks;
163void CTR_ModePolicy::CipherResynchronize(
byte *keystreamBuffer,
const byte *iv,
size_t length)
165 CRYPTOPP_UNUSED(keystreamBuffer), CRYPTOPP_UNUSED(length);
169 CopyOrZero(m_register, m_register.size(), iv, length);
170 m_counterArray.Assign(m_register.begin(), m_register.size());
175 m_cipher->SetKey(key, length, params);
180 const byte *iv = GetIVAndThrowIfInvalid(params, ivLength);
185void BlockOrientedCipherModeBase::ResizeBuffers()
187 CipherModeBase::ResizeBuffers();
188 m_buffer.New(BlockSize());
203 const unsigned int blockSize = BlockSize();
205 if (length > blockSize)
207 std::memcpy(m_register,
PtrAdd(outString, length - blockSize), blockSize);
212 CRYPTOPP_UNUSED(outLength);
213 const size_t used = inLength;
214 const unsigned int blockSize = BlockSize();
216 if (inLength <= blockSize)
219 throw InvalidArgument(
"CBC_Encryption: message is too short for ciphertext stealing");
222 std::memcpy(outString, m_register, inLength);
223 outString = m_stolenIV;
228 xorbuf(m_register, inString, blockSize);
229 m_cipher->ProcessBlock(m_register);
230 inString =
PtrAdd(inString, blockSize);
231 inLength -= blockSize;
232 std::memcpy(
PtrAdd(outString, blockSize), m_register, inLength);
236 xorbuf(m_register, inString, inLength);
237 m_cipher->ProcessBlock(m_register);
238 std::memcpy(outString, m_register, blockSize);
243void CBC_Decryption::ResizeBuffers()
245 BlockOrientedCipherModeBase::ResizeBuffers();
246 m_temp.New(BlockSize());
252 if (!length) {
return;}
255 const unsigned int blockSize = BlockSize();
256 std::memcpy(m_temp,
PtrAdd(inString, length-blockSize), blockSize);
257 if (length > blockSize)
259 m_cipher->ProcessAndXorBlock(inString, m_register, outString);
260 m_register.swap(m_temp);
265 CRYPTOPP_UNUSED(outLength);
266 const byte *pn1, *pn2;
267 const size_t used = inLength;
268 const bool stealIV = inLength <= BlockSize();
269 const unsigned int blockSize = BlockSize();
278 pn1 =
PtrAdd(inString, blockSize);
280 inLength -= blockSize;
284 std::memcpy(m_temp, pn2, blockSize);
285 m_cipher->ProcessBlock(m_temp);
286 xorbuf(m_temp, pn1, inLength);
290 std::memcpy(outString, m_temp, inLength);
294 std::memcpy(
PtrAdd(outString, blockSize), m_temp, inLength);
296 std::memcpy(m_temp, pn1, inLength);
297 m_cipher->ProcessBlock(m_temp);
298 xorbuf(outString, m_temp, m_register, blockSize);
void UncheckedSetKey(const byte *key, unsigned int length, const NameValuePairs ¶ms)
Sets the key for this object without performing parameter validation.
void Resynchronize(const byte *iv, int length=-1)
Resynchronize with an IV.
size_t ProcessLastBlock(byte *outString, size_t outLength, const byte *inString, size_t inLength)
Encrypt or decrypt the last block of data.
size_t ProcessLastBlock(byte *outString, size_t outLength, const byte *inString, size_t inLength)
Encrypt or decrypt the last block of data.
void ProcessData(byte *outString, const byte *inString, size_t length)
Encrypt or decrypt an array of bytes.
void ProcessData(byte *outString, const byte *inString, size_t length)
Encrypt or decrypt an array of bytes.
void ProcessData(byte *outString, const byte *inString, size_t length)
Encrypt or decrypt an array of bytes.
Interface for retrieving values given their names.
bool IsResynchronizable() const
Determines if the object can be resynchronized.
unsigned char byte
8-bit unsigned datatype
word64 lword
Large word type.
CipherDir
Specifies a direction for a cipher to operate.
@ ENCRYPTION
the cipher is performing encryption
Classes for DES, 2-key Triple-DES, 3-key Triple-DES and DESX.
Utility functions for the Crypto++ library.
void IncrementCounterByOne(byte *inout, unsigned int size)
Performs an addition with carry on a block of bytes.
void memcpy_s(void *dest, size_t sizeInBytes, const void *src, size_t count)
Bounds checking replacement for memcpy()
PTR PtrAdd(PTR pointer, OFF offset)
Create a pointer with an offset.
const T1 UnsignedMin(const T1 &a, const T2 &b)
Safe comparison of values that could be negative and incorrectly promoted.
void memmove_s(void *dest, size_t sizeInBytes, const void *src, size_t count)
Bounds checking replacement for memmove()
CRYPTOPP_DLL void xorbuf(byte *buf, const byte *mask, size_t count)
Performs an XOR of a buffer with a mask.
Classes for block cipher modes of operation.
void CopyOrZero(void *dest, size_t dsize, const void *src, size_t ssize)
Initialize a block of memory.
Crypto++ library namespace.
KeystreamOperation
Keystream operation flags.
#define CRYPTOPP_ASSERT(exp)
Debugging and diagnostic assertion.