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 ...
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.
virtual lword MaxMessageLength() const =0
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)
this function only needs to be called if NeedsPrespecifiedDataLengths() returns true ...
Crypto++ library namespace.
Interface for retrieving values given their names.