// bench.cpp - written and placed in the public domain by Wei Dai

#include "pch.h"

#include "md2.h"
#include "md5.h"
#include "md5mac.h"
#include "hmac.h"
#include "xormac.h"
#include "sha.h"
#include "haval.h"
#include "tiger.h"
#include "ripemd.h"
#include "idea.h"
#include "des.h"
#include "rc2.h"
#include "rc5.h"
#include "blowfish.h"
#include "diamond.h"
#include "wake.h"
#include "3way.h"
#include "safer.h"
#include "gost.h"
#include "shark.h"
#include "cast.h"
#include "square.h"
#include "seal.h"
#include "rc6.h"
#include "mars.h"
#include "blumshub.h"
#include "rsa.h"
#include "elgamal.h"
#include "nr.h"
#include "dsa.h"
#include "luc.h"
#include "rabin.h"
#include "rw.h"
#include "blumgold.h"
#include "eccrypto.h"
#include "ecp.h"
#include "ec2n.h"
#include "asn.h"
#include "rng.h"
#include "files.h"
#include "hex.h"
#include "modes.h"
#include "mdc.h"
#include "lubyrack.h"
#include "sapphire.h"
#include "tea.h"
#include "dh.h"
#include "mqv.h"

#include "bench.h"

#include <time.h>
#include <iostream>
#include <iomanip>

USING_NAMESPACE(CryptoPP)
USING_NAMESPACE(std)

#ifdef CLOCKS_PER_SEC
static const float CLOCK_TICKS_PER_SECOND = (float)CLOCKS_PER_SEC;
#elif defined(CLK_TCK)
static const float CLOCK_TICKS_PER_SECOND = (float)CLK_TCK;
#else
static const float CLOCK_TICKS_PER_SECOND = 1000000.0;
#endif

static const byte *const key=(byte *)"0123456789abcdef000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000";

void BenchMark(const char *name, BlockTransformation &cipher, float timeTotal)
{
	const int BUF_SIZE = cipher.BlockSize();
	SecByteBlock buf(BUF_SIZE);
	clock_t start = clock();

	unsigned long i=0, length=BUF_SIZE;
	float timeTaken;
	do
	{
		length *= 2;
		for (; i<length; i+=BUF_SIZE)
			cipher.ProcessBlock(buf);
		timeTaken = float(clock() - start) / CLOCK_TICKS_PER_SECOND;
	}
	while (timeTaken < 2.0/3*timeTotal);

	float kbs = length / timeTaken;
	cout << "<TR><TH>" << name;
	cout << "<TD>" << length;
	cout << "<TD>" << timeTaken;
	cout << "<TD>" << (long)kbs << endl;
}

void BenchMark(const char *name, StreamCipher &cipher, float timeTotal)
{
	const int BUF_SIZE=128; // encrypt 128 bytes at a time
	SecByteBlock buf(BUF_SIZE);
	clock_t start = clock();

	unsigned long i=0, length=BUF_SIZE;
	float timeTaken;
	do
	{
		length *= 2;
		for (; i<length; i+=BUF_SIZE)
			cipher.ProcessString(buf, BUF_SIZE);
		timeTaken = float(clock() - start) / CLOCK_TICKS_PER_SECOND;
	}
	while (timeTaken < 2.0/3*timeTotal);

	float kbs = length / timeTaken;
	cout << "<TR><TH>" << name;
	cout << "<TD>" << length;
	cout << "<TD>" << timeTaken;
	cout << "<TD>" << (long)kbs << endl;
}

void BenchMark(const char *name, HashModule &hash, float timeTotal)
{
	const int BUF_SIZE=128; // update 128 bytes at a time
	SecByteBlock buf(BUF_SIZE);
	clock_t start = clock();

	unsigned long i=0, length=BUF_SIZE;
	float timeTaken;
	do
	{
		length *= 2;
		for (; i<length; i+=BUF_SIZE)
			hash.Update(buf, BUF_SIZE);
		timeTaken = float(clock() - start) / CLOCK_TICKS_PER_SECOND;
	}
	while (timeTaken < 2.0/3*timeTotal);

	float kbs = length / timeTaken;
	cout << "<TR><TH>" << name;
	cout << "<TD>" << length;
	cout << "<TD>" << timeTaken;
	cout << "<TD>" << (long)kbs << endl;
}

void BenchMark(const char *name, BufferedTransformation &bt, float timeTotal)
{
	const int BUF_SIZE=128; // update 128 bytes at a time
	SecByteBlock buf(BUF_SIZE);
	clock_t start = clock();

	unsigned long i=0, length=BUF_SIZE;
	float timeTaken;
	do
	{
		length *= 2;
		for (; i<length; i+=BUF_SIZE)
			bt.Put(buf, BUF_SIZE);
		timeTaken = float(clock() - start) / CLOCK_TICKS_PER_SECOND;
	}
	while (timeTaken < 2.0/3*timeTotal);

	float kbs = length / timeTaken;
	cout << "<TR><TH>" << name;
	cout << "<TD>" << length;
	cout << "<TD>" << timeTaken;
	cout << "<TD>" << (long)kbs << endl;
}

void BenchMarkEncryption(const char *name, PK_Encryptor &key, float timeTotal, bool pc=false)
{
	unsigned int len = 16;
	LC_RNG rng(time(NULL));
	SecByteBlock plaintext(len), ciphertext(key.CipherTextLength(len));
	rng.GetBlock(plaintext, len);

	clock_t start = clock();
	unsigned int i;
	float timeTaken;
	for (timeTaken=(float)0, i=0; timeTaken < timeTotal; timeTaken = float(clock() - start) / CLOCK_TICKS_PER_SECOND, i++)
		key.Encrypt(rng, plaintext, len, ciphertext);

	cout << "<TR><TH>" << name << " Encryption" << (pc ? " with precomputation" : "");
	cout << "<TD>" << i;
	cout << "<TD>" << setprecision(3) << timeTaken;
	cout << "<TD>" << (unsigned int)(1000*timeTaken/i) << endl;
}

void BenchMarkEncryption(const char *name, PK_WithPrecomputation<PK_FixedLengthEncryptor> &key, float timeTotal)
{
	BenchMarkEncryption(name, dynamic_cast<PK_Encryptor &>(key), timeTotal);
	key.Precompute(16);
	BenchMarkEncryption(name, dynamic_cast<PK_Encryptor &>(key), timeTotal, true);
}

void BenchMarkDecryption(const char *name, PK_Decryptor &priv, PK_Encryptor &pub, float timeTotal)
{
	unsigned int len = 16;
	LC_RNG rng(time(NULL));
	SecByteBlock ciphertext(pub.CipherTextLength(len));
	SecByteBlock plaintext(pub.MaxPlainTextLength(ciphertext.size));
	rng.GetBlock(plaintext, len);
	pub.Encrypt(rng, plaintext, len, ciphertext);

	clock_t start = clock();
	unsigned int i;
	float timeTaken;
	for (timeTaken=(float)0, i=0; timeTaken < timeTotal; timeTaken = float(clock() - start) / CLOCK_TICKS_PER_SECOND, i++)
		priv.Decrypt(ciphertext, ciphertext.size, plaintext);

	cout << "<TR><TH>" << name << " Decryption";
	cout << "<TD>" << i;
	cout << "<TD>" << setprecision(3) << timeTaken;
	cout << "<TD>" << (unsigned int)(1000*timeTaken/i) << endl;
}

void BenchMarkSigning(const char *name, PK_Signer &key, float timeTotal, bool pc=false)
{
	unsigned int len = 16;
	LC_RNG rng(time(NULL));
	SecByteBlock message(len), signature(key.SignatureLength());
	rng.GetBlock(message, len);

	clock_t start = clock();
	unsigned int i;
	float timeTaken;
	for (timeTaken=(float)0, i=0; timeTaken < timeTotal; timeTaken = float(clock() - start) / CLOCK_TICKS_PER_SECOND, i++)
		key.SignMessage(rng, message, len, signature);

	cout << "<TR><TH>" << name << " Signature" << (pc ? " with precomputation" : "");
	cout << "<TD>" << i;
	cout << "<TD>" << setprecision(3) << timeTaken;
	cout << "<TD>" << (unsigned int)(1000*timeTaken/i) << endl;
}

void BenchMarkSigning(const char *name, PK_WithPrecomputation<PK_Signer> &key, float timeTotal)
{
	BenchMarkSigning(name, dynamic_cast<PK_Signer &>(key), timeTotal);
	key.Precompute(16);
	BenchMarkSigning(name, dynamic_cast<PK_Signer &>(key), timeTotal, true);
}

void BenchMarkVerification(const char *name, PK_Signer &priv, PK_Verifier &pub, float timeTotal, bool pc=false)
{
	unsigned int len = 16;
	LC_RNG rng(time(NULL));
	SecByteBlock message(len), signature(pub.SignatureLength());
	rng.GetBlock(message, len);
	priv.SignMessage(rng, message, len, signature);

	clock_t start = clock();
	unsigned int i;
	float timeTaken;
	for (timeTaken=(float)0, i=0; timeTaken < timeTotal; timeTaken = float(clock() - start) / CLOCK_TICKS_PER_SECOND, i++)
		pub.VerifyMessage(message, len, signature);

	cout << "<TR><TH>" << name << " Verification" << (pc ? " with precomputation" : "");
	cout << "<TD>" << i;
	cout << "<TD>" << setprecision(3) << timeTaken;
	cout << "<TD>" << (unsigned int)(1000*timeTaken/i) << endl;
}

void BenchMarkVerification(const char *name, PK_Signer &priv, PK_WithPrecomputation<PK_Verifier> &pub, float timeTotal)
{
	BenchMarkVerification(name, priv, dynamic_cast<PK_Verifier &>(pub), timeTotal);
	pub.Precompute(16);
	BenchMarkVerification(name, priv, dynamic_cast<PK_Verifier &>(pub), timeTotal, true);
}

void BenchMarkKeyGen(const char *name, PK_SimpleKeyAgreementDomain &d, float timeTotal, bool pc=false)
{
	LC_RNG rng(time(NULL));
	SecByteBlock priv(d.PrivateKeyLength()), pub(d.PublicKeyLength());

	clock_t start = clock();
	unsigned int i;
	float timeTaken;
	for (timeTaken=(float)0, i=0; timeTaken < timeTotal; timeTaken = float(clock() - start) / CLOCK_TICKS_PER_SECOND, i++)
		d.GenerateKeyPair(rng, priv, pub);

	cout << "<TR><TH>" << name << " Key-Pair Generation" << (pc ? " with precomputation" : "");
	cout << "<TD>" << i;
	cout << "<TD>" << setprecision(3) << timeTaken;
	cout << "<TD>" << (unsigned int)(1000*timeTaken/i) << endl;
}

void BenchMarkKeyGen(const char *name, PK_WithPrecomputation<PK_SimpleKeyAgreementDomain> &d, float timeTotal)
{
	BenchMarkKeyGen(name, dynamic_cast<PK_SimpleKeyAgreementDomain &>(d), timeTotal);
	d.Precompute(16);
	BenchMarkKeyGen(name, dynamic_cast<PK_SimpleKeyAgreementDomain &>(d), timeTotal, true);
}

void BenchMarkKeyGen(const char *name, PK_AuthenticatedKeyAgreementDomain &d, float timeTotal, bool pc=false)
{
	LC_RNG rng(time(NULL));
	SecByteBlock priv(d.EphemeralPrivateKeyLength()), pub(d.EphemeralPublicKeyLength());

	clock_t start = clock();
	unsigned int i;
	float timeTaken;
	for (timeTaken=(float)0, i=0; timeTaken < timeTotal; timeTaken = float(clock() - start) / CLOCK_TICKS_PER_SECOND, i++)
		d.GenerateEphemeralKeyPair(rng, priv, pub);

	cout << "<TR><TH>" << name << " Key-Pair Generation" << (pc ? " with precomputation" : "");
	cout << "<TD>" << i;
	cout << "<TD>" << setprecision(3) << timeTaken;
	cout << "<TD>" << (unsigned int)(1000*timeTaken/i) << endl;
}

void BenchMarkKeyGen(const char *name, PK_WithPrecomputation<PK_AuthenticatedKeyAgreementDomain> &d, float timeTotal)