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)
48 std::ostringstream out;
52 if (length < 0.0000000001f) length = 0.000001f;
53 if (timeTaken < 0.0000000001f) timeTaken = 0.000001f;
55 double mbs = length / timeTaken / (1024*1024);
56 out <<
"\n<TR><TH>" << name;
58 out << setiosflags(ios::fixed);
60 out <<
"<TD>" << setprecision(0) << setiosflags(ios::fixed) << mbs;
62 out <<
"<TD>" << setprecision(1) << setiosflags(ios::fixed) << timeTaken * g_hertz / length;
69 void OutputResultKeying(
double iterations,
double timeTaken)
72 std::ostringstream out;
76 if (iterations < 0.0000000001f) iterations = 0.000001f;
77 if (timeTaken < 0.0000000001f) timeTaken = 0.000001f;
79 out <<
"<TD>" << setprecision(3) << setiosflags(ios::fixed) << (1000*1000*timeTaken/iterations);
81 out <<
"<TD>" << setprecision(0) << setiosflags(ios::fixed) << timeTaken * g_hertz / iterations;
86 void OutputResultOperations(
const char *name,
const char *operation,
bool pc,
unsigned long iterations,
double timeTaken)
89 std::ostringstream out;
93 if (!iterations) iterations++;
94 if (timeTaken < 0.0000000001f) timeTaken = 0.000001f;
96 out <<
"\n<TR><TH>" << name <<
" " << operation << (pc ?
" with precomputation" :
"");
97 out <<
"<TD>" << setprecision(2) << setiosflags(ios::fixed) << (1000*timeTaken/iterations);
99 out <<
"<TD>" << setprecision(2) << setiosflags(ios::fixed) << timeTaken * g_hertz / iterations / 1000000;
101 logtotal += log(iterations/timeTaken);
135 clock_t start = clock();
137 unsigned long i=0, blocks=1;
142 for (; i<blocks; i++)
144 timeTaken = double(clock() - start) / CLOCK_TICKS_PER_SECOND;
146 while (timeTaken < 2.0/3*timeTotal);
148 OutputResultBytes(name,
double(blocks) * BUF_SIZE, timeTaken);
156 BenchMark(name, static_cast<StreamTransformation &>(cipher), timeTotal);
161 const int BUF_SIZE=2048U;
164 clock_t start = clock();
166 unsigned long i=0, blocks=1;
171 for (; i<blocks; i++)
173 timeTaken = double(clock() - start) / CLOCK_TICKS_PER_SECOND;
175 while (timeTaken < 2.0/3*timeTotal);
177 OutputResultBytes(name,
double(blocks) * BUF_SIZE, timeTaken);
182 const int BUF_SIZE=2048U;
185 clock_t start = clock();
187 unsigned long i=0, blocks=1;
192 for (; i<blocks; i++)
193 bt.
Put(buf, BUF_SIZE);
194 timeTaken = double(clock() - start) / CLOCK_TICKS_PER_SECOND;
196 while (timeTaken < 2.0/3*timeTotal);
198 OutputResultBytes(name,
double(blocks) * BUF_SIZE, timeTaken);
203 unsigned long iterations = 0;
204 clock_t start = clock();
208 for (
unsigned int i=0; i<1024; i++)
209 c.
SetKey(defaultKey, keyLength, params);
210 timeTaken = double(clock() - start) / CLOCK_TICKS_PER_SECOND;
213 while (timeTaken < g_allocatedTime);
215 OutputResultKeying(iterations, timeTaken);
220 template <
class T_FactoryOutput,
class T_Interface>
221 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)
223 CRYPTOPP_UNUSED(x), CRYPTOPP_UNUSED(y), CRYPTOPP_UNUSED(params);
225 std::string name(factoryName ? factoryName :
"");
229 keyLength = obj->DefaultKeyLength();
234 name +=
" (" +
IntToString(keyLength * 8) +
"-bit key)";
237 BenchMark(name.c_str(), *
static_cast<T_Interface *
>(obj.get()), g_allocatedTime);
242 template <
class T_FactoryOutput>
243 void BenchMarkByName(
const char *factoryName,
size_t keyLength = 0,
const char *displayName=NULL,
const NameValuePairs ¶ms =
g_nullNameValuePairs, T_FactoryOutput *x=NULL)
245 CRYPTOPP_UNUSED(x), CRYPTOPP_UNUSED(params);
247 BenchMarkByName2<T_FactoryOutput, T_FactoryOutput>(factoryName, keyLength, displayName, params, x, x);
253 CRYPTOPP_UNUSED(x), CRYPTOPP_UNUSED(params);
255 std::string name = factoryName;
260 BenchMark(name.c_str(), *obj, g_allocatedTime);
263 void BenchmarkAll(
double t,
double hertz)
271 const char *cpb, *cpk;
274 cpb =
"<TH>Cycles Per Byte";
275 cpk =
"<TH>Cycles to<br>Setup Key and IV";
276 cout <<
"CPU frequency of the test platform is " << g_hertz <<
" Hz.\n";
281 cout <<
"CPU frequency of the test platform was not provided.\n";
284 cout <<
"<TABLE border=1><COLGROUP><COL align=left><COL align=right><COL align=right><COL align=right><COL align=right>" << endl;
285 cout <<
"<THEAD><TR><TH>Algorithm<TH>MiB/Second" << cpb <<
"<TH>Microseconds to<br>Setup Key and IV" << cpk << endl;
287 cout <<
"\n<TBODY style=\"background: yellow\">";
288 #if CRYPTOPP_BOOL_AESNI_INTRINSICS_AVAILABLE 290 BenchMarkByName2<AuthenticatedSymmetricCipher, AuthenticatedSymmetricCipher>(
"AES/GCM", 0,
"AES/GCM");
294 BenchMarkByName2<AuthenticatedSymmetricCipher, AuthenticatedSymmetricCipher>(
"AES/GCM", 0,
"AES/GCM (2K tables)",
MakeParameters(
Name::TableSize(), 2048));
295 BenchMarkByName2<AuthenticatedSymmetricCipher, AuthenticatedSymmetricCipher>(
"AES/GCM", 0,
"AES/GCM (64K tables)",
MakeParameters(
Name::TableSize(), 64*1024));
297 BenchMarkByName2<AuthenticatedSymmetricCipher, AuthenticatedSymmetricCipher>(
"AES/CCM");
298 BenchMarkByName2<AuthenticatedSymmetricCipher, AuthenticatedSymmetricCipher>(
"AES/EAX");
300 cout <<
"\n<TBODY style=\"background: white\">";
301 #if CRYPTOPP_BOOL_AESNI_INTRINSICS_AVAILABLE 303 BenchMarkByName2<AuthenticatedSymmetricCipher, MessageAuthenticationCode>(
"AES/GCM", 0,
"GMAC(AES)");
307 BenchMarkByName2<AuthenticatedSymmetricCipher, MessageAuthenticationCode>(
"AES/GCM", 0,
"GMAC(AES) (2K tables)",
MakeParameters(
Name::TableSize(), 2048));
308 BenchMarkByName2<AuthenticatedSymmetricCipher, MessageAuthenticationCode>(
"AES/GCM", 0,
"GMAC(AES) (64K tables)",
MakeParameters(
Name::TableSize(), 64*1024));
310 BenchMarkByName<MessageAuthenticationCode>(
"VMAC(AES)-64");
311 BenchMarkByName<MessageAuthenticationCode>(
"VMAC(AES)-128");
312 BenchMarkByName<MessageAuthenticationCode>(
"HMAC(SHA-1)");
313 BenchMarkByName<MessageAuthenticationCode>(
"Two-Track-MAC");
314 BenchMarkByName<MessageAuthenticationCode>(
"CMAC(AES)");
315 BenchMarkByName<MessageAuthenticationCode>(
"DMAC(AES)");
317 cout <<
"\n<TBODY style=\"background: yellow\">";
318 BenchMarkByNameKeyLess<HashTransformation>(
"CRC32");
319 BenchMarkByNameKeyLess<HashTransformation>(
"Adler32");
320 BenchMarkByNameKeyLess<HashTransformation>(
"MD5");
321 BenchMarkByNameKeyLess<HashTransformation>(
"SHA-1");
322 BenchMarkByNameKeyLess<HashTransformation>(
"SHA-256");
323 BenchMarkByNameKeyLess<HashTransformation>(
"SHA-512");
324 BenchMarkByNameKeyLess<HashTransformation>(
"SHA-3-224");
325 BenchMarkByNameKeyLess<HashTransformation>(
"SHA-3-256");
326 BenchMarkByNameKeyLess<HashTransformation>(
"SHA-3-384");
327 BenchMarkByNameKeyLess<HashTransformation>(
"SHA-3-512");
328 BenchMarkByNameKeyLess<HashTransformation>(
"Tiger");
329 BenchMarkByNameKeyLess<HashTransformation>(
"Whirlpool");
330 BenchMarkByNameKeyLess<HashTransformation>(
"RIPEMD-160");
331 BenchMarkByNameKeyLess<HashTransformation>(
"RIPEMD-320");
332 BenchMarkByNameKeyLess<HashTransformation>(
"RIPEMD-128");
333 BenchMarkByNameKeyLess<HashTransformation>(
"RIPEMD-256");
335 cout <<
"\n<TBODY style=\"background: white\">";
336 BenchMarkByName<SymmetricCipher>(
"Panama-LE");
337 BenchMarkByName<SymmetricCipher>(
"Panama-BE");
338 BenchMarkByName<SymmetricCipher>(
"Salsa20");
341 BenchMarkByName<SymmetricCipher>(
"Sosemanuk");
342 BenchMarkByName<SymmetricCipher>(
"MARC4");
343 BenchMarkByName<SymmetricCipher>(
"SEAL-3.0-LE");
344 BenchMarkByName<SymmetricCipher>(
"WAKE-OFB-LE");
346 cout <<
"\n<TBODY style=\"background: yellow\">";
347 BenchMarkByName<SymmetricCipher>(
"AES/CTR", 16);
348 BenchMarkByName<SymmetricCipher>(
"AES/CTR", 24);
349 BenchMarkByName<SymmetricCipher>(
"AES/CTR", 32);
350 BenchMarkByName<SymmetricCipher>(
"AES/CBC", 16);
351 BenchMarkByName<SymmetricCipher>(
"AES/CBC", 24);
352 BenchMarkByName<SymmetricCipher>(
"AES/CBC", 32);
353 BenchMarkByName<SymmetricCipher>(
"AES/OFB", 16);
354 BenchMarkByName<SymmetricCipher>(
"AES/CFB", 16);
355 BenchMarkByName<SymmetricCipher>(
"AES/ECB", 16);
356 BenchMarkByName<SymmetricCipher>(
"Camellia/CTR", 16);
357 BenchMarkByName<SymmetricCipher>(
"Camellia/CTR", 32);
358 BenchMarkByName<SymmetricCipher>(
"Twofish/CTR");
359 BenchMarkByName<SymmetricCipher>(
"Serpent/CTR");
360 BenchMarkByName<SymmetricCipher>(
"CAST-256/CTR");
361 BenchMarkByName<SymmetricCipher>(
"RC6/CTR");
362 BenchMarkByName<SymmetricCipher>(
"MARS/CTR");
363 BenchMarkByName<SymmetricCipher>(
"SHACAL-2/CTR", 16);
364 BenchMarkByName<SymmetricCipher>(
"SHACAL-2/CTR", 64);
365 BenchMarkByName<SymmetricCipher>(
"DES/CTR");
366 BenchMarkByName<SymmetricCipher>(
"DES-XEX3/CTR");
367 BenchMarkByName<SymmetricCipher>(
"DES-EDE3/CTR");
368 BenchMarkByName<SymmetricCipher>(
"IDEA/CTR");
369 BenchMarkByName<SymmetricCipher>(
"RC5/CTR", 0,
"RC5 (r=16)");
370 BenchMarkByName<SymmetricCipher>(
"Blowfish/CTR");
371 BenchMarkByName<SymmetricCipher>(
"TEA/CTR");
372 BenchMarkByName<SymmetricCipher>(
"XTEA/CTR");
373 BenchMarkByName<SymmetricCipher>(
"CAST-128/CTR");
374 BenchMarkByName<SymmetricCipher>(
"SKIPJACK/CTR");
375 BenchMarkByName<SymmetricCipher>(
"SEED/CTR", 0,
"SEED/CTR (1/2 K table)");
376 cout <<
"</TABLE>" << endl;
378 BenchmarkAll2(t, hertz);
379 cout <<
"Throughput Geometric Average: " << setiosflags(ios::fixed) << exp(logtotal/(logcount ? logcount : 1)) << endl;
382 #if defined(CRYPTOPP_MSC_VERSION) 387 const time_t endTime = time(NULL);
388 err = localtime_s(&localTime, &endTime);
390 err = asctime_s(timeBuf,
sizeof(timeBuf), &localTime);
393 cout <<
"\nTest ended at " << timeBuf;
395 const time_t endTime = time(NULL);
396 cout <<
"\nTest ended at " << asctime(localtime(&endTime));
used to pass byte array input as part of a NameValuePairs object
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.
virtual void GenerateBlock(byte *output, size_t size)
Generate random array of bytes.
virtual bool NeedsPrespecifiedDataLengths() const
if this function returns true, SpecifyDataLengths() must be called before attempting to input data ...
virtual lword MaxMessageLength() const =0
the maximum length of encrypted data
Abstract base classes that provide a uniform interface to this library.
Classes for automatic resource management.
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.
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.
AlignedSecByteBlock is a SecBlock<byte, AllocatorWithCleanup<byte, true> > typedef.
Classes, functions, intrinsics and features for X86, X32 nd X64 assembly.
Implementation of BufferedTransformation's attachment interface in cryptlib.h.
const char * IV()
ConstByteArrayParameter, also accepts const byte * for backwards compatibility.
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)
this function only needs to be called if NeedsPrespecifiedDataLengths() returns true ...
Crypto++ library namespace.
Interface for retrieving values given their names.