00001
00002
00003 #include "bench.h"
00004 #include "rng.h"
00005 #include "files.h"
00006 #include "hex.h"
00007
00008 #include "rsa.h"
00009 #include "nr.h"
00010 #include "dsa.h"
00011 #include "luc.h"
00012 #include "rw.h"
00013 #include "eccrypto.h"
00014 #include "ecp.h"
00015 #include "ec2n.h"
00016 #include "asn.h"
00017 #include "dh.h"
00018 #include "mqv.h"
00019 #include "xtrcrypt.h"
00020 #include "esign.h"
00021 #include "pssr.h"
00022 #include "oids.h"
00023 #include "randpool.h"
00024
00025 #include <time.h>
00026 #include <math.h>
00027 #include <iostream>
00028 #include <iomanip>
00029
00030 USING_NAMESPACE(CryptoPP)
00031 USING_NAMESPACE(std)
00032
00033 void OutputResultOperations(const char *name, const char *operation, bool pc, unsigned long iterations, double timeTaken);
00034
00035 void BenchMarkEncryption(const char *name, PK_Encryptor &key, double timeTotal, bool pc=false)
00036 {
00037 unsigned int len = 16;
00038 LC_RNG rng((word32)time(NULL));
00039 SecByteBlock plaintext(len), ciphertext(key.CiphertextLength(len));
00040 rng.GenerateBlock(plaintext, len);
00041
00042 clock_t start = clock();
00043 unsigned int i;
00044 double timeTaken;
00045 for (timeTaken=(double)0, i=0; timeTaken < timeTotal; timeTaken = double(clock() - start) / CLOCK_TICKS_PER_SECOND, i++)
00046 key.Encrypt(rng, plaintext, len, ciphertext);
00047
00048 OutputResultOperations(name, "Encryption", pc, i, timeTaken);
00049
00050 if (!pc && key.GetMaterial().SupportsPrecomputation())
00051 {
00052 key.AccessMaterial().Precompute(16);
00053 BenchMarkEncryption(name, key, timeTotal, true);
00054 }
00055 }
00056
00057 void BenchMarkDecryption(const char *name, PK_Decryptor &priv, PK_Encryptor &pub, double timeTotal)
00058 {
00059 unsigned int len = 16;
00060 LC_RNG rng((word32)time(NULL));
00061 SecByteBlock ciphertext(pub.CiphertextLength(len));
00062 SecByteBlock plaintext(pub.MaxPlaintextLength(ciphertext.size()));
00063 rng.GenerateBlock(plaintext, len);
00064 pub.Encrypt(rng, plaintext, len, ciphertext);
00065
00066 clock_t start = clock();
00067 unsigned int i;
00068 double timeTaken;
00069 for (timeTaken=(double)0, i=0; timeTaken < timeTotal; timeTaken = double(clock() - start) / CLOCK_TICKS_PER_SECOND, i++)
00070 priv.Decrypt(rng, ciphertext, ciphertext.size(), plaintext);
00071
00072 OutputResultOperations(name, "Decryption", false, i, timeTaken);
00073 }
00074
00075 void BenchMarkSigning(const char *name, PK_Signer &key, double timeTotal, bool pc=false)
00076 {
00077 unsigned int len = 16;
00078 LC_RNG rng((word32)time(NULL));
00079 AlignedSecByteBlock message(len), signature(key.SignatureLength());
00080 rng.GenerateBlock(message, len);
00081
00082 clock_t start = clock();
00083 unsigned int i;
00084 double timeTaken;
00085 for (timeTaken=(double)0, i=0; timeTaken < timeTotal; timeTaken = double(clock() - start) / CLOCK_TICKS_PER_SECOND, i++)
00086 key.SignMessage(rng, message, len, signature);
00087
00088 OutputResultOperations(name, "Signature", pc, i, timeTaken);
00089
00090 if (!pc && key.GetMaterial().SupportsPrecomputation())
00091 {
00092 key.AccessMaterial().Precompute(16);
00093 BenchMarkSigning(name, key, timeTotal, true);
00094 }
00095 }
00096
00097 void BenchMarkVerification(const char *name, const PK_Signer &priv, PK_Verifier &pub, double timeTotal, bool pc=false)
00098 {
00099 unsigned int len = 16;
00100 LC_RNG rng((word32)time(NULL));
00101 AlignedSecByteBlock message(len), signature(pub.SignatureLength());
00102 rng.GenerateBlock(message, len);
00103 priv.SignMessage(rng, message, len, signature);
00104
00105 clock_t start = clock();
00106 unsigned int i;
00107 double timeTaken;
00108 for (timeTaken=(double)0, i=0; timeTaken < timeTotal; timeTaken = double(clock() - start) / CLOCK_TICKS_PER_SECOND, i++)
00109 pub.VerifyMessage(message, len, signature, signature.size());
00110
00111 OutputResultOperations(name, "Verification", pc, i, timeTaken);
00112
00113 if (!pc && pub.GetMaterial().SupportsPrecomputation())
00114 {
00115 pub.AccessMaterial().Precompute(16);
00116 BenchMarkVerification(name, priv, pub, timeTotal, true);
00117 }
00118 }
00119
00120 void BenchMarkKeyGen(const char *name, SimpleKeyAgreementDomain &d, double timeTotal, bool pc=false)
00121 {
00122 LC_RNG rng((word32)time(NULL));
00123 SecByteBlock priv(d.PrivateKeyLength()), pub(d.PublicKeyLength());
00124
00125 clock_t start = clock();
00126 unsigned int i;
00127 double timeTaken;
00128 for (timeTaken=(double)0, i=0; timeTaken < timeTotal; timeTaken = double(clock() - start) / CLOCK_TICKS_PER_SECOND, i++)
00129 d.GenerateKeyPair(rng, priv, pub);
00130
00131 OutputResultOperations(name, "Key-Pair Generation", pc, i, timeTaken);
00132
00133 if (!pc && d.GetMaterial().SupportsPrecomputation())
00134 {
00135 d.AccessMaterial().Precompute(16);
00136 BenchMarkKeyGen(name, d, timeTotal, true);
00137 }
00138 }
00139
00140 void BenchMarkKeyGen(const char *name, AuthenticatedKeyAgreementDomain &d, double timeTotal, bool pc=false)
00141 {
00142 LC_RNG rng((word32)time(NULL));
00143 SecByteBlock priv(d.EphemeralPrivateKeyLength()), pub(d.EphemeralPublicKeyLength());
00144
00145 clock_t start = clock();
00146 unsigned int i;
00147 double timeTaken;
00148 for (timeTaken=(double)0, i=0; timeTaken < timeTotal; timeTaken = double(clock() - start) / CLOCK_TICKS_PER_SECOND, i++)
00149 d.GenerateEphemeralKeyPair(rng, priv, pub);
00150
00151 OutputResultOperations(name, "Key-Pair Generation", pc, i, timeTaken);
00152
00153 if (!pc && d.GetMaterial().SupportsPrecomputation())
00154 {
00155 d.AccessMaterial().Precompute(16);
00156 BenchMarkKeyGen(name, d, timeTotal, true);
00157 }
00158 }
00159
00160 void BenchMarkAgreement(const char *name, SimpleKeyAgreementDomain &d, double timeTotal, bool pc=false)
00161 {
00162 LC_RNG rng((word32)time(NULL));
00163 SecByteBlock priv1(d.PrivateKeyLength()), priv2(d.PrivateKeyLength());
00164 SecByteBlock pub1(d.PublicKeyLength()), pub2(d.PublicKeyLength());
00165 d.GenerateKeyPair(rng, priv1, pub1);
00166 d.GenerateKeyPair(rng, priv2, pub2);
00167 SecByteBlock val(d.AgreedValueLength());
00168
00169 clock_t start = clock();
00170 unsigned int i;
00171 double timeTaken;
00172 for (timeTaken=(double)0, i=0; timeTaken < timeTotal; timeTaken = double(clock() - start) / CLOCK_TICKS_PER_SECOND, i+=2)
00173 {
00174 d.Agree(val, priv1, pub2);
00175 d.Agree(val, priv2, pub1);
00176 }
00177
00178 OutputResultOperations(name, "Key Agreement", pc, i, timeTaken);
00179 }
00180
00181 void BenchMarkAgreement(const char *name, AuthenticatedKeyAgreementDomain &d, double timeTotal, bool pc=false)
00182 {
00183 LC_RNG rng((word32)time(NULL));
00184 SecByteBlock spriv1(d.StaticPrivateKeyLength()), spriv2(d.StaticPrivateKeyLength());
00185 SecByteBlock epriv1(d.EphemeralPrivateKeyLength()), epriv2(d.EphemeralPrivateKeyLength());
00186 SecByteBlock spub1(d.StaticPublicKeyLength()), spub2(d.StaticPublicKeyLength());
00187 SecByteBlock epub1(d.EphemeralPublicKeyLength()), epub2(d.EphemeralPublicKeyLength());
00188 d.GenerateStaticKeyPair(rng, spriv1, spub1);
00189 d.GenerateStaticKeyPair(rng, spriv2, spub2);
00190 d.GenerateEphemeralKeyPair(rng, epriv1, epub1);
00191 d.GenerateEphemeralKeyPair(rng, epriv2, epub2);
00192 SecByteBlock val(d.AgreedValueLength());
00193
00194 clock_t start = clock();
00195 unsigned int i;
00196 double timeTaken;
00197 for (timeTaken=(double)0, i=0; timeTaken < timeTotal; timeTaken = double(clock() - start) / CLOCK_TICKS_PER_SECOND, i+=2)
00198 {
00199 d.Agree(val, spriv1, epriv1, spub2, epub2);
00200 d.Agree(val, spriv2, epriv2, spub1, epub1);
00201 }
00202
00203 OutputResultOperations(name, "Key Agreement", pc, i, timeTaken);
00204 }
00205
00206
00207 template <class SCHEME>
00208 void BenchMarkCrypto(const char *filename, const char *name, double timeTotal, SCHEME *x=NULL)
00209 {
00210 FileSource f(filename, true, new HexDecoder());
00211 typename SCHEME::Decryptor priv(f);
00212 typename SCHEME::Encryptor pub(priv);
00213 BenchMarkEncryption(name, pub, timeTotal);
00214 BenchMarkDecryption(name, priv, pub, timeTotal);
00215 }
00216
00217
00218 template <class SCHEME>
00219 void BenchMarkSignature(const char *filename, const char *name, double timeTotal, SCHEME *x=NULL)
00220 {
00221 FileSource f(filename, true, new HexDecoder());
00222 typename SCHEME::Signer priv(f);
00223 typename SCHEME::Verifier pub(priv);
00224 BenchMarkSigning(name, priv, timeTotal);
00225 BenchMarkVerification(name, priv, pub, timeTotal);
00226 }
00227
00228
00229 template <class D>
00230 void BenchMarkKeyAgreement(const char *filename, const char *name, double timeTotal, D *x=NULL)
00231 {
00232 FileSource f(filename, true, new HexDecoder());
00233 D d(f);
00234 BenchMarkKeyGen(name, d, timeTotal);
00235 BenchMarkAgreement(name, d, timeTotal);
00236 }
00237
00238 extern double g_hertz;
00239
00240 void BenchmarkAll2(double t, double hertz)
00241 {
00242 g_hertz = hertz;
00243
00244 cout << "<TABLE border=1><COLGROUP><COL align=left><COL align=right><COL align=right>" << endl;
00245 cout << "<THEAD><TR><TH>Operation<TH>Milliseconds/Operation" << (g_hertz ? "<TH>Megacycles/Operation" : "") << endl;
00246
00247 cout << "\n<TBODY style=\"background: yellow\">";
00248 BenchMarkCrypto<RSAES<OAEP<SHA> > >("rsa1024.dat", "RSA 1024", t);
00249 BenchMarkCrypto<LUCES<OAEP<SHA> > >("luc1024.dat", "LUC 1024", t);
00250 BenchMarkCrypto<DLIES<> >("dlie1024.dat", "DLIES 1024", t);
00251 BenchMarkCrypto<LUC_IES<> >("lucc512.dat", "LUCELG 512", t);
00252
00253 cout << "\n<TBODY style=\"background: white\">";
00254 BenchMarkCrypto<RSAES<OAEP<SHA> > >("rsa2048.dat", "RSA 2048", t);
00255 BenchMarkCrypto<LUCES<OAEP<SHA> > >("luc2048.dat", "LUC 2048", t);
00256 BenchMarkCrypto<DLIES<> >("dlie2048.dat", "DLIES 2048", t);
00257 BenchMarkCrypto<LUC_IES<> >("lucc1024.dat", "LUCELG 1024", t);
00258
00259 cout << "\n<TBODY style=\"background: yellow\">";
00260 BenchMarkSignature<RSASS<PSSR, SHA> >("rsa1024.dat", "RSA 1024", t);
00261 BenchMarkSignature<RWSS<PSSR, SHA> >("rw1024.dat", "RW 1024", t);
00262 BenchMarkSignature<LUCSS<PSSR, SHA> >("luc1024.dat", "LUC 1024", t);
00263 BenchMarkSignature<NR<SHA> >("nr1024.dat", "NR 1024", t);
00264 BenchMarkSignature<DSA>("dsa1024.dat", "DSA 1024", t);
00265 BenchMarkSignature<LUC_HMP<SHA> >("lucs512.dat", "LUC-HMP 512", t);
00266 BenchMarkSignature<ESIGN<SHA> >("esig1023.dat", "ESIGN 1023", t);
00267 BenchMarkSignature<ESIGN<SHA> >("esig1536.dat", "ESIGN 1536", t);
00268
00269 cout << "\n<TBODY style=\"background: white\">";
00270 BenchMarkSignature<RSASS<PSSR, SHA> >("rsa2048.dat", "RSA 2048", t);
00271 BenchMarkSignature<RWSS<PSSR, SHA> >("rw2048.dat", "RW 2048", t);
00272 BenchMarkSignature<LUCSS<PSSR, SHA> >("luc2048.dat", "LUC 2048", t);
00273 BenchMarkSignature<NR<SHA> >("nr2048.dat", "NR 2048", t);
00274 BenchMarkSignature<LUC_HMP<SHA> >("lucs1024.dat", "LUC-HMP 1024", t);
00275 BenchMarkSignature<ESIGN<SHA> >("esig2046.dat", "ESIGN 2046", t);
00276
00277 cout << "\n<TBODY style=\"background: yellow\">";
00278 BenchMarkKeyAgreement<XTR_DH>("xtrdh171.dat", "XTR-DH 171", t);
00279 BenchMarkKeyAgreement<XTR_DH>("xtrdh342.dat", "XTR-DH 342", t);
00280 BenchMarkKeyAgreement<DH>("dh1024.dat", "DH 1024", t);
00281 BenchMarkKeyAgreement<DH>("dh2048.dat", "DH 2048", t);
00282 BenchMarkKeyAgreement<LUC_DH>("lucd512.dat", "LUCDIF 512", t);
00283 BenchMarkKeyAgreement<LUC_DH>("lucd1024.dat", "LUCDIF 1024", t);
00284 BenchMarkKeyAgreement<MQV>("mqv1024.dat", "MQV 1024", t);
00285 BenchMarkKeyAgreement<MQV>("mqv2048.dat", "MQV 2048", t);
00286
00287 cout << "\n<TBODY style=\"background: white\">";
00288 {
00289 RandomPool rng;
00290 ECIES<ECP>::Decryptor cpriv(rng, ASN1::secp256k1());
00291 ECIES<ECP>::Encryptor cpub(cpriv);
00292 ECDSA<ECP, SHA>::Signer spriv(cpriv);
00293 ECDSA<ECP, SHA>::Verifier spub(spriv);
00294 ECDH<ECP>::Domain ecdhc(ASN1::secp256k1());
00295 ECMQV<ECP>::Domain ecmqvc(ASN1::secp256k1());
00296
00297 BenchMarkEncryption("ECIES over GF(p) 256", cpub, t);
00298 BenchMarkDecryption("ECIES over GF(p) 256", cpriv, cpub, t);
00299 BenchMarkSigning("ECNR over GF(p) 256", spriv, t);
00300 BenchMarkVerification("ECNR over GF(p) 256", spriv, spub, t);
00301 BenchMarkKeyGen("ECDHC over GF(p) 256", ecdhc, t);
00302 BenchMarkAgreement("ECDHC over GF(p) 256", ecdhc, t);
00303 BenchMarkKeyGen("ECMQVC over GF(p) 256", ecmqvc, t);
00304 BenchMarkAgreement("ECMQVC over GF(p) 256", ecmqvc, t);
00305 }
00306
00307 cout << "<TBODY style=\"background: yellow\">" << endl;
00308 {
00309 RandomPool rng;
00310 ECIES<EC2N>::Decryptor cpriv(rng, ASN1::sect233r1());
00311 ECIES<EC2N>::Encryptor cpub(cpriv);
00312 ECDSA<EC2N, SHA>::Signer spriv(cpriv);
00313 ECDSA<EC2N, SHA>::Verifier spub(spriv);
00314 ECDH<EC2N>::Domain ecdhc(ASN1::sect233r1());
00315 ECMQV<EC2N>::Domain ecmqvc(ASN1::sect233r1());
00316
00317 BenchMarkEncryption("ECIES over GF(2^n) 233", cpub, t);
00318 BenchMarkDecryption("ECIES over GF(2^n) 233", cpriv, cpub, t);
00319 BenchMarkSigning("ECNR over GF(2^n) 233", spriv, t);
00320 BenchMarkVerification("ECNR over GF(2^n) 233", spriv, spub, t);
00321 BenchMarkKeyGen("ECDHC over GF(2^n) 233", ecdhc, t);
00322 BenchMarkAgreement("ECDHC over GF(2^n) 233", ecdhc, t);
00323 BenchMarkKeyGen("ECMQVC over GF(2^n) 233", ecmqvc, t);
00324 BenchMarkAgreement("ECMQVC over GF(2^n) 233", ecmqvc, t);
00325 }
00326 cout << "</TABLE>" << endl;
00327 }