24 #if CRYPTOPP_GCC_DIAGNOSTIC_AVAILABLE 25 # pragma GCC diagnostic ignored "-Wdeprecated-declarations" 32 const double CLOCK_TICKS_PER_SECOND = (double)CLOCKS_PER_SEC;
33 #elif defined(CLK_TCK) 34 const double CLOCK_TICKS_PER_SECOND = (double)CLK_TCK;
36 const double CLOCK_TICKS_PER_SECOND = 1000000.0;
39 double logtotal = 0.0, g_allocatedTime = 0, g_hertz = 0;
40 unsigned int logcount = 0;
42 static const byte defaultKey[] =
"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" 43 "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";
45 void OutputResultBytes(
const char *name,
double length,
double timeTaken)
51 if (length < 0.0000000001f) length = 0.000001f;
52 if (timeTaken < 0.0000000001f) timeTaken = 0.000001f;
54 double mbs = length / timeTaken / (1024*1024);
55 cout <<
"\n<TR><TH>" << name;
57 cout << setiosflags(ios::fixed);
59 cout <<
"<TD>" << setprecision(0) << setiosflags(ios::fixed) << mbs;
61 cout <<
"<TD>" << setprecision(1) << setiosflags(ios::fixed) << timeTaken * g_hertz / length;
66 void OutputResultKeying(
double iterations,
double timeTaken)
72 if (iterations < 0.0000000001f) iterations = 0.000001f;
73 if (timeTaken < 0.0000000001f) timeTaken = 0.000001f;
75 cout <<
"<TD>" << setprecision(3) << setiosflags(ios::fixed) << (1000*1000*timeTaken/iterations);
77 cout <<
"<TD>" << setprecision(0) << setiosflags(ios::fixed) << timeTaken * g_hertz / iterations;
80 void OutputResultOperations(
const char *name,
const char *operation,
bool pc,
unsigned long iterations,
double timeTaken)
86 if (!iterations) iterations++;
87 if (timeTaken < 0.0000000001f) timeTaken = 0.000001f;
89 cout <<
"\n<TR><TH>" << name <<
" " << operation << (pc ?
" with precomputation" :
"");
90 cout <<
"<TD>" << setprecision(2) << setiosflags(ios::fixed) << (1000*timeTaken/iterations);
92 cout <<
"<TD>" << setprecision(2) << setiosflags(ios::fixed) << timeTaken * g_hertz / iterations / 1000000;
94 logtotal += log(iterations/timeTaken);
125 GlobalRNG().GenerateBlock(buf, BUF_SIZE);
126 clock_t start = clock();
128 unsigned long i=0, blocks=1;
133 for (; i<blocks; i++)
135 timeTaken = double(clock() - start) / CLOCK_TICKS_PER_SECOND;
137 while (timeTaken < 2.0/3*timeTotal);
139 OutputResultBytes(name,
double(blocks) * BUF_SIZE, timeTaken);
147 BenchMark(name, static_cast<StreamTransformation &>(cipher), timeTotal);
152 const int BUF_SIZE=2048U;
154 GlobalRNG().GenerateBlock(buf, BUF_SIZE);
155 clock_t start = clock();
157 unsigned long i=0, blocks=1;
162 for (; i<blocks; i++)
164 timeTaken = double(clock() - start) / CLOCK_TICKS_PER_SECOND;
166 while (timeTaken < 2.0/3*timeTotal);
168 OutputResultBytes(name,
double(blocks) * BUF_SIZE, timeTaken);
173 const int BUF_SIZE=2048U;
175 GlobalRNG().GenerateBlock(buf, BUF_SIZE);
176 clock_t start = clock();
178 unsigned long i=0, blocks=1;
183 for (; i<blocks; i++)
184 bt.
Put(buf, BUF_SIZE);
185 timeTaken = double(clock() - start) / CLOCK_TICKS_PER_SECOND;
187 while (timeTaken < 2.0/3*timeTotal);
189 OutputResultBytes(name,
double(blocks) * BUF_SIZE, timeTaken);
194 unsigned long iterations = 0;
195 clock_t start = clock();
199 for (
unsigned int i=0; i<1024; i++)
200 c.
SetKey(defaultKey, keyLength, params);
201 timeTaken = double(clock() - start) / CLOCK_TICKS_PER_SECOND;
204 while (timeTaken < g_allocatedTime);
206 OutputResultKeying(iterations, timeTaken);
211 template <
class T_FactoryOutput,
class T_Interface>
212 void BenchMarkByName2(
const char *factoryName,
size_t keyLength = 0,
const char *displayName=NULL,
const NameValuePairs ¶ms =
g_nullNameValuePairs, T_FactoryOutput *x=NULL, T_Interface *y=NULL)
214 CRYPTOPP_UNUSED(x), CRYPTOPP_UNUSED(y), CRYPTOPP_UNUSED(params);
216 std::string name(factoryName ? factoryName :
"");
220 keyLength = obj->DefaultKeyLength();
225 name +=
" (" +
IntToString(keyLength * 8) +
"-bit key)";
228 BenchMark(name.c_str(), *
static_cast<T_Interface *
>(obj.get()), g_allocatedTime);
233 template <
class T_FactoryOutput>
234 void BenchMarkByName(
const char *factoryName,
size_t keyLength = 0,
const char *displayName=NULL,
const NameValuePairs ¶ms =
g_nullNameValuePairs, T_FactoryOutput *x=NULL)
236 CRYPTOPP_UNUSED(x), CRYPTOPP_UNUSED(params);
238 BenchMarkByName2<T_FactoryOutput, T_FactoryOutput>(factoryName, keyLength, displayName, params, x, x);
244 CRYPTOPP_UNUSED(x), CRYPTOPP_UNUSED(params);
246 std::string name = factoryName;
251 BenchMark(name.c_str(), *obj, g_allocatedTime);
254 void BenchmarkAll(
double t,
double hertz)
262 const char *cpb, *cpk;
265 cpb =
"<TH>Cycles Per Byte";
266 cpk =
"<TH>Cycles to<br>Setup Key and IV";
267 cout <<
"CPU frequency of the test platform is " << g_hertz <<
" Hz.\n";
272 cout <<
"CPU frequency of the test platform was not provided.\n";
275 cout <<
"<TABLE border=1><COLGROUP><COL align=left><COL align=right><COL align=right><COL align=right><COL align=right>" << endl;
276 cout <<
"<THEAD><TR><TH>Algorithm<TH>MiB/Second" << cpb <<
"<TH>Microseconds to<br>Setup Key and IV" << cpk << endl;
278 cout <<
"\n<TBODY style=\"background: yellow\">";
279 #if CRYPTOPP_BOOL_AESNI_INTRINSICS_AVAILABLE 281 BenchMarkByName2<AuthenticatedSymmetricCipher, AuthenticatedSymmetricCipher>(
"AES/GCM", 0,
"AES/GCM");
285 BenchMarkByName2<AuthenticatedSymmetricCipher, AuthenticatedSymmetricCipher>(
"AES/GCM", 0,
"AES/GCM (2K tables)",
MakeParameters(
Name::TableSize(), 2048));
286 BenchMarkByName2<AuthenticatedSymmetricCipher, AuthenticatedSymmetricCipher>(
"AES/GCM", 0,
"AES/GCM (64K tables)",
MakeParameters(
Name::TableSize(), 64*1024));
288 BenchMarkByName2<AuthenticatedSymmetricCipher, AuthenticatedSymmetricCipher>(
"AES/CCM");
289 BenchMarkByName2<AuthenticatedSymmetricCipher, AuthenticatedSymmetricCipher>(
"AES/EAX");
291 cout <<
"\n<TBODY style=\"background: white\">";
292 #if CRYPTOPP_BOOL_AESNI_INTRINSICS_AVAILABLE 294 BenchMarkByName2<AuthenticatedSymmetricCipher, MessageAuthenticationCode>(
"AES/GCM", 0,
"GMAC(AES)");
298 BenchMarkByName2<AuthenticatedSymmetricCipher, MessageAuthenticationCode>(
"AES/GCM", 0,
"GMAC(AES) (2K tables)",
MakeParameters(
Name::TableSize(), 2048));
299 BenchMarkByName2<AuthenticatedSymmetricCipher, MessageAuthenticationCode>(
"AES/GCM", 0,
"GMAC(AES) (64K tables)",
MakeParameters(
Name::TableSize(), 64*1024));
301 BenchMarkByName<MessageAuthenticationCode>(
"VMAC(AES)-64");
302 BenchMarkByName<MessageAuthenticationCode>(
"VMAC(AES)-128");
303 BenchMarkByName<MessageAuthenticationCode>(
"HMAC(SHA-1)");
304 BenchMarkByName<MessageAuthenticationCode>(
"Two-Track-MAC");
305 BenchMarkByName<MessageAuthenticationCode>(
"CMAC(AES)");
306 BenchMarkByName<MessageAuthenticationCode>(
"DMAC(AES)");
307 BenchMarkByName<MessageAuthenticationCode>(
"BLAKE2s");
308 BenchMarkByName<MessageAuthenticationCode>(
"BLAKE2b");
310 cout <<
"\n<TBODY style=\"background: yellow\">";
311 BenchMarkByNameKeyLess<HashTransformation>(
"CRC32");
312 BenchMarkByNameKeyLess<HashTransformation>(
"CRC32C");
313 BenchMarkByNameKeyLess<HashTransformation>(
"Adler32");
314 BenchMarkByNameKeyLess<HashTransformation>(
"MD5");
315 BenchMarkByNameKeyLess<HashTransformation>(
"SHA-1");
316 BenchMarkByNameKeyLess<HashTransformation>(
"SHA-256");
317 BenchMarkByNameKeyLess<HashTransformation>(
"SHA-512");
318 BenchMarkByNameKeyLess<HashTransformation>(
"Keccak-224");
319 BenchMarkByNameKeyLess<HashTransformation>(
"Keccak-256");
320 BenchMarkByNameKeyLess<HashTransformation>(
"Keccak-384");
321 BenchMarkByNameKeyLess<HashTransformation>(
"Keccak-512");
322 BenchMarkByNameKeyLess<HashTransformation>(
"SHA3-224");
323 BenchMarkByNameKeyLess<HashTransformation>(
"SHA3-256");
324 BenchMarkByNameKeyLess<HashTransformation>(
"SHA3-384");
325 BenchMarkByNameKeyLess<HashTransformation>(
"SHA3-512");
326 BenchMarkByNameKeyLess<HashTransformation>(
"Tiger");
327 BenchMarkByNameKeyLess<HashTransformation>(
"Whirlpool");
328 BenchMarkByNameKeyLess<HashTransformation>(
"RIPEMD-160");
329 BenchMarkByNameKeyLess<HashTransformation>(
"RIPEMD-320");
330 BenchMarkByNameKeyLess<HashTransformation>(
"RIPEMD-128");
331 BenchMarkByNameKeyLess<HashTransformation>(
"RIPEMD-256");
332 BenchMarkByNameKeyLess<HashTransformation>(
"BLAKE2s");
333 BenchMarkByNameKeyLess<HashTransformation>(
"BLAKE2b");
335 cout <<
"\n<TBODY style=\"background: white\">";
336 BenchMarkByName<SymmetricCipher>(
"Panama-LE");
337 BenchMarkByName<SymmetricCipher>(
"Panama-BE");
338 BenchMarkByName<SymmetricCipher>(
"Salsa20");
341 BenchMarkByName<SymmetricCipher>(
"ChaCha20");
342 BenchMarkByName<SymmetricCipher>(
"ChaCha12");
343 BenchMarkByName<SymmetricCipher>(
"ChaCha8");
344 BenchMarkByName<SymmetricCipher>(
"Sosemanuk");
345 BenchMarkByName<SymmetricCipher>(
"MARC4");
346 BenchMarkByName<SymmetricCipher>(
"SEAL-3.0-LE");
347 BenchMarkByName<SymmetricCipher>(
"WAKE-OFB-LE");
349 cout <<
"\n<TBODY style=\"background: yellow\">";
350 BenchMarkByName<SymmetricCipher>(
"AES/CTR", 16);
351 BenchMarkByName<SymmetricCipher>(
"AES/CTR", 24);
352 BenchMarkByName<SymmetricCipher>(
"AES/CTR", 32);
353 BenchMarkByName<SymmetricCipher>(
"AES/CBC", 16);
354 BenchMarkByName<SymmetricCipher>(
"AES/CBC", 24);
355 BenchMarkByName<SymmetricCipher>(
"AES/CBC", 32);
356 BenchMarkByName<SymmetricCipher>(
"AES/OFB", 16);
357 BenchMarkByName<SymmetricCipher>(
"AES/CFB", 16);
358 BenchMarkByName<SymmetricCipher>(
"AES/ECB", 16);
359 BenchMarkByName<SymmetricCipher>(
"Camellia/CTR", 16);
360 BenchMarkByName<SymmetricCipher>(
"Camellia/CTR", 32);
361 BenchMarkByName<SymmetricCipher>(
"Twofish/CTR");
362 BenchMarkByName<SymmetricCipher>(
"Serpent/CTR");
363 BenchMarkByName<SymmetricCipher>(
"CAST-256/CTR");
364 BenchMarkByName<SymmetricCipher>(
"RC6/CTR");
365 BenchMarkByName<SymmetricCipher>(
"MARS/CTR");
366 BenchMarkByName<SymmetricCipher>(
"SHACAL-2/CTR", 16);
367 BenchMarkByName<SymmetricCipher>(
"SHACAL-2/CTR", 64);
368 BenchMarkByName<SymmetricCipher>(
"DES/CTR");
369 BenchMarkByName<SymmetricCipher>(
"DES-XEX3/CTR");
370 BenchMarkByName<SymmetricCipher>(
"DES-EDE3/CTR");
371 BenchMarkByName<SymmetricCipher>(
"IDEA/CTR");
372 BenchMarkByName<SymmetricCipher>(
"RC5/CTR", 0,
"RC5 (r=16)");
373 BenchMarkByName<SymmetricCipher>(
"Blowfish/CTR");
374 BenchMarkByName<SymmetricCipher>(
"TEA/CTR");
375 BenchMarkByName<SymmetricCipher>(
"XTEA/CTR");
376 BenchMarkByName<SymmetricCipher>(
"CAST-128/CTR");
377 BenchMarkByName<SymmetricCipher>(
"SKIPJACK/CTR");
378 BenchMarkByName<SymmetricCipher>(
"SEED/CTR", 0,
"SEED/CTR (1/2 K table)");
379 cout <<
"</TABLE>" << endl;
381 BenchmarkAll2(t, hertz);
382 cout <<
"Throughput Geometric Average: " << setiosflags(ios::fixed) << exp(logtotal/(logcount ? logcount : 1)) << endl;
385 #if (CRYPTOPP_MSC_VERSION >= 1400) 390 const time_t endTime = time(NULL);
391 err = localtime_s(&localTime, &endTime);
393 err = asctime_s(timeBuf,
sizeof(timeBuf), &localTime);
396 cout <<
"\nTest ended at " << timeBuf;
398 const time_t endTime = time(NULL);
399 cout <<
"\nTest ended at " << asctime(localtime(&endTime));
Used to pass byte array input as part of a NameValuePairs object.
virtual bool NeedsPrespecifiedDataLengths() const
Determines if data lengths must be specified prior to inputting data.
virtual void SetKey(const byte *key, size_t length, const NameValuePairs ¶ms=g_nullNameValuePairs)
Sets or reset the key of this object.
Interface for one direction (encryption or decryption) of a stream cipher or block cipher mode with a...
Class file for modes of operation.
Abstract base classes that provide a uniform interface to this library.
Classes for automatic resource management.
Combines two sets of NameValuePairs.
Pointer that overloads operator ->
const char * TableSize()
int, in bytes
AlgorithmParameters MakeParameters(const char *name, const T &value, bool throwIfNotUsed=true)
Create an object that implements NameValuePairs.
Classes for HexEncoder and HexDecoder.
bool HasCLMUL()
Determines Carryless Multiply availability.
Class file for the AES cipher (Rijndael)
Interface for algorithms that take byte strings as keys.
const NameValuePairs & g_nullNameValuePairs
An empty set of name-value pairs.
SecBlock using AllocatorWithCleanup<byte, true> typedef.
#define CRYPTOPP_ASSERT(exp)
Debugging and diagnostic assertion.
Functions for CPU features and intrinsics.
Implementation of BufferedTransformation's attachment interface.
const char * IV()
ConstByteArrayParameter, also accepts const byte * for backwards compatibility.
virtual lword MaxMessageLength() const =0
Provides the maximum length of encrypted data.
Classes for Blum Blum Shub generator.
std::string IntToString(T value, unsigned int base=10)
Converts a value to a string.
T1 RoundUpToMultipleOf(const T1 &n, const T2 &m)
Rounds a value up to a multiple of a second value.
void SpecifyDataLengths(lword headerLength, lword messageLength, lword footerLength=0)
Prespecifies the data lengths.
Crypto++ library namespace.
Interface for retrieving values given their names.