Main Page | Namespace List | Class Hierarchy | Alphabetical List | Compound List | File List | Namespace Members | Compound Members | File Members

validat2.cpp

00001 // validat2.cpp - written and placed in the public domain by Wei Dai
00002 
00003 #include "pch.h"
00004 
00005 #include "blumshub.h"
00006 #include "rsa.h"
00007 #include "md2.h"
00008 #include "elgamal.h"
00009 #include "nr.h"
00010 #include "dsa.h"
00011 #include "dh.h"
00012 #include "mqv.h"
00013 #include "luc.h"
00014 #include "xtrcrypt.h"
00015 #include "rabin.h"
00016 #include "rw.h"
00017 #include "eccrypto.h"
00018 #include "ecp.h"
00019 #include "ec2n.h"
00020 #include "asn.h"
00021 #include "rng.h"
00022 #include "files.h"
00023 #include "hex.h"
00024 #include "oids.h"
00025 #include "esign.h"
00026 #include "osrng.h"
00027 
00028 #include <iostream>
00029 #include <iomanip>
00030 
00031 #include "validate.h"
00032 
00033 USING_NAMESPACE(CryptoPP)
00034 USING_NAMESPACE(std)
00035 
00036 class FixedRNG : public RandomNumberGenerator
00037 {
00038 public:
00039         FixedRNG(BufferedTransformation &source) : m_source(source) {}
00040 
00041         byte GenerateByte()
00042         {
00043                 byte b;
00044                 m_source.Get(b);
00045                 return b;
00046         }
00047 
00048 private:
00049         BufferedTransformation &m_source;
00050 };
00051 
00052 bool ValidateBBS()
00053 {
00054         cout << "\nBlumBlumShub validation suite running...\n\n";
00055 
00056         Integer p("212004934506826557583707108431463840565872545889679278744389317666981496005411448865750399674653351");
00057         Integer q("100677295735404212434355574418077394581488455772477016953458064183204108039226017738610663984508231");
00058         Integer seed("63239752671357255800299643604761065219897634268887145610573595874544114193025997412441121667211431");
00059         BlumBlumShub bbs(p, q, seed);
00060         bool pass = true, fail;
00061         int j;
00062 
00063         const byte output1[] = {
00064                 0x49,0xEA,0x2C,0xFD,0xB0,0x10,0x64,0xA0,0xBB,0xB9,
00065                 0x2A,0xF1,0x01,0xDA,0xC1,0x8A,0x94,0xF7,0xB7,0xCE};
00066         const byte output2[] = {
00067                 0x74,0x45,0x48,0xAE,0xAC,0xB7,0x0E,0xDF,0xAF,0xD7,
00068                 0xD5,0x0E,0x8E,0x29,0x83,0x75,0x6B,0x27,0x46,0xA1};
00069 
00070         byte buf[20];
00071 
00072         bbs.GenerateBlock(buf, 20);
00073         fail = memcmp(output1, buf, 20) != 0;
00074         pass = pass && !fail;
00075 
00076         cout << (fail ? "FAILED    " : "passed    ");
00077         for (j=0;j<20;j++)
00078                 cout << setw(2) << setfill('0') << hex << (int)buf[j];
00079         cout << endl;
00080 
00081         bbs.Seek(10);
00082         bbs.GenerateBlock(buf, 10);
00083         fail = memcmp(output1+10, buf, 10) != 0;
00084         pass = pass && !fail;
00085 
00086         cout << (fail ? "FAILED    " : "passed    ");
00087         for (j=0;j<10;j++)
00088                 cout << setw(2) << setfill('0') << hex << (int)buf[j];
00089         cout << endl;
00090 
00091         bbs.Seek(1234567);
00092         bbs.GenerateBlock(buf, 20);
00093         fail = memcmp(output2, buf, 20) != 0;
00094         pass = pass && !fail;
00095 
00096         cout << (fail ? "FAILED    " : "passed    ");
00097         for (j=0;j<20;j++)
00098                 cout << setw(2) << setfill('0') << hex << (int)buf[j];
00099         cout << endl;
00100 
00101         return pass;
00102 }
00103 
00104 bool SignatureValidate(PK_Signer &priv, PK_Verifier &pub, bool thorough = false)
00105 {
00106         bool pass = true, fail;
00107 
00108         fail = !pub.GetMaterial().Validate(GlobalRNG(), thorough ? 3 : 2) || !priv.GetMaterial().Validate(GlobalRNG(), thorough ? 3 : 2);
00109         pass = pass && !fail;
00110 
00111         cout << (fail ? "FAILED    " : "passed    ");
00112         cout << "signature key validation\n";
00113 
00114         const byte *message = (byte *)"test message";
00115         const int messageLen = 12;
00116         byte buffer[512];
00117 
00118         memset(buffer, 0, sizeof(buffer));
00119         priv.SignMessage(GlobalRNG(), message, messageLen, buffer);
00120         fail = !pub.VerifyMessage(message, messageLen, buffer);
00121         pass = pass && !fail;
00122 
00123         cout << (fail ? "FAILED    " : "passed    ");
00124         cout << "signature and verification\n";
00125 
00126         ++buffer[0];
00127         fail = pub.VerifyMessage(message, messageLen, buffer);
00128         pass = pass && !fail;
00129 
00130         cout << (fail ? "FAILED    " : "passed    ");
00131         cout << "checking invalid signature" << endl;
00132 
00133         return pass;
00134 }
00135 
00136 bool CryptoSystemValidate(PK_Decryptor &priv, PK_Encryptor &pub, bool thorough = false)
00137 {
00138         bool pass = true, fail;
00139 
00140         fail = !pub.GetMaterial().Validate(GlobalRNG(), thorough ? 3 : 2) || !priv.GetMaterial().Validate(GlobalRNG(), thorough ? 3 : 2);
00141         pass = pass && !fail;
00142 
00143         cout << (fail ? "FAILED    " : "passed    ");
00144         cout << "cryptosystem key validation\n";
00145 
00146         const byte *message = (byte *)"test message";
00147         const int messageLen = 12;
00148         SecByteBlock ciphertext(priv.CiphertextLength(messageLen));
00149         SecByteBlock plaintext(priv.MaxPlaintextLength(ciphertext.size()));
00150 
00151         pub.Encrypt(GlobalRNG(), message, messageLen, ciphertext);
00152         fail = priv.Decrypt(ciphertext, priv.CiphertextLength(messageLen), plaintext) != DecodingResult(messageLen);
00153         fail = fail || memcmp(message, plaintext, messageLen);
00154         pass = pass && !fail;
00155 
00156         cout << (fail ? "FAILED    " : "passed    ");
00157         cout << "encryption and decryption\n";
00158 
00159         return pass;
00160 }
00161 
00162 bool SimpleKeyAgreementValidate(SimpleKeyAgreementDomain &d)
00163 {
00164         if (d.GetCryptoParameters().Validate(GlobalRNG(), 3))
00165                 cout << "passed    simple key agreement domain parameters validation" << endl;
00166         else
00167         {
00168                 cout << "FAILED    simple key agreement domain parameters invalid" << endl;
00169                 return false;
00170         }
00171 
00172         SecByteBlock priv1(d.PrivateKeyLength()), priv2(d.PrivateKeyLength());
00173         SecByteBlock pub1(d.PublicKeyLength()), pub2(d.PublicKeyLength());
00174         SecByteBlock val1(d.AgreedValueLength()), val2(d.AgreedValueLength());
00175 
00176         d.GenerateKeyPair(GlobalRNG(), priv1, pub1);
00177         d.GenerateKeyPair(GlobalRNG(), priv2, pub2);
00178 
00179         memset(val1.begin(), 0x10, val1.size());
00180         memset(val2.begin(), 0x11, val2.size());
00181 
00182         if (!(d.Agree(val1, priv1, pub2) && d.Agree(val2, priv2, pub1)))
00183         {
00184                 cout << "FAILED    simple key agreement failed" << endl;
00185                 return false;
00186         }
00187 
00188         if (memcmp(val1.begin(), val2.begin(), d.AgreedValueLength()))
00189         {
00190                 cout << "FAILED    simple agreed values not equal" << endl;
00191                 return false;
00192         }
00193 
00194         cout << "passed    simple key agreement" << endl;
00195         return true;
00196 }
00197 
00198 bool AuthenticatedKeyAgreementValidate(AuthenticatedKeyAgreementDomain &d)
00199 {
00200         if (d.GetCryptoParameters().Validate(GlobalRNG(), 3))
00201                 cout << "passed    authenticated key agreement domain parameters validation" << endl;
00202         else
00203         {
00204                 cout << "FAILED    authenticated key agreement domain parameters invalid" << endl;
00205                 return false;
00206         }
00207 
00208         SecByteBlock spriv1(d.StaticPrivateKeyLength()), spriv2(d.StaticPrivateKeyLength());
00209         SecByteBlock epriv1(d.EphemeralPrivateKeyLength()), epriv2(d.EphemeralPrivateKeyLength());
00210         SecByteBlock spub1(d.StaticPublicKeyLength()), spub2(d.StaticPublicKeyLength());
00211         SecByteBlock epub1(d.EphemeralPublicKeyLength()), epub2(d.EphemeralPublicKeyLength());
00212         SecByteBlock val1(d.AgreedValueLength()), val2(d.AgreedValueLength());
00213 
00214         d.GenerateStaticKeyPair(GlobalRNG(), spriv1, spub1);
00215         d.GenerateStaticKeyPair(GlobalRNG(), spriv2, spub2);
00216         d.GenerateEphemeralKeyPair(GlobalRNG(), epriv1, epub1);
00217         d.GenerateEphemeralKeyPair(GlobalRNG(), epriv2, epub2);
00218 
00219         memset(val1.begin(), 0x10, val1.size());
00220         memset(val2.begin(), 0x11, val2.size());
00221 
00222         if (!(d.Agree(val1, spriv1, epriv1, spub2, epub2) && d.Agree(val2, spriv2, epriv2, spub1, epub1)))
00223         {
00224                 cout << "FAILED    authenticated key agreement failed" << endl;
00225                 return false;
00226         }
00227 
00228         if (memcmp(val1.begin(), val2.begin(), d.AgreedValueLength()))
00229         {
00230                 cout << "FAILED    authenticated agreed values not equal" << endl;
00231                 return false;
00232         }
00233 
00234         cout << "passed    authenticated key agreement" << endl;
00235         return true;
00236 }
00237 
00238 bool ValidateRSA()
00239 {
00240         cout << "\nRSA validation suite running...\n\n";
00241 
00242         byte out[100], outPlain[100];
00243         bool pass = true, fail;
00244 
00245         {
00246                 char *plain = "Everyone gets Friday off.";
00247                 byte *signature = (byte *)
00248                         "\x05\xfa\x6a\x81\x2f\xc7\xdf\x8b\xf4\xf2\x54\x25\x09\xe0\x3e\x84"
00249                         "\x6e\x11\xb9\xc6\x20\xbe\x20\x09\xef\xb4\x40\xef\xbc\xc6\x69\x21"
00250                         "\x69\x94\xac\x04\xf3\x41\xb5\x7d\x05\x20\x2d\x42\x8f\xb2\xa2\x7b"
00251                         "\x5c\x77\xdf\xd9\xb1\x5b\xfc\x3d\x55\x93\x53\x50\x34\x10\xc1\xe1";
00252 
00253                 FileSource keys("rsa512a.dat", true, new HexDecoder);
00254                 RSASSA_PKCS1v15_MD2_Signer rsaPriv(keys);
00255                 RSASSA_PKCS1v15_MD2_Verifier rsaPub(rsaPriv);
00256 
00257                 rsaPriv.SignMessage(GlobalRNG(), (byte *)plain, strlen(plain), out);
00258                 fail = memcmp(signature, out, 64) != 0;
00259                 pass = pass && !fail;
00260 
00261                 cout << (fail ? "FAILED    " : "passed    ");
00262                 cout << "signature check against test vector\n";
00263 
00264                 fail = !rsaPub.VerifyMessage((byte *)plain, strlen(plain), out);
00265                 pass = pass && !fail;
00266 
00267                 cout << (fail ? "FAILED    " : "passed    ");
00268                 cout << "verification check against test vector\n";
00269 
00270                 out[10]++;
00271                 fail = rsaPub.VerifyMessage((byte *)plain, strlen(plain), out);
00272                 pass = pass && !fail;
00273 
00274                 cout << (fail ? "FAILED    " : "passed    ");
00275                 cout << "invalid signature verification\n";
00276         }
00277         {
00278                 FileSource keys("rsa1024.dat", true, new HexDecoder);
00279                 RSAES_PKCS1v15_Decryptor rsaPriv(keys);
00280                 RSAES_PKCS1v15_Encryptor rsaPub(rsaPriv);
00281 
00282                 pass = CryptoSystemValidate(rsaPriv, rsaPub) && pass;
00283         }
00284         {
00285                 byte *plain = (byte *)
00286                         "\x54\x85\x9b\x34\x2c\x49\xea\x2a";
00287                 byte *encrypted = (byte *)
00288                         "\x14\xbd\xdd\x28\xc9\x83\x35\x19\x23\x80\xe8\xe5\x49\xb1\x58\x2a"
00289                         "\x8b\x40\xb4\x48\x6d\x03\xa6\xa5\x31\x1f\x1f\xd5\xf0\xa1\x80\xe4"
00290                         "\x17\x53\x03\x29\xa9\x34\x90\x74\xb1\x52\x13\x54\x29\x08\x24\x52"
00291                         "\x62\x51";
00292                 byte *oaepSeed = (byte *)
00293                         "\xaa\xfd\x12\xf6\x59\xca\xe6\x34\x89\xb4\x79\xe5\x07\x6d\xde\xc2"
00294                         "\xf0\x6c\xb5\x8f";
00295                 ByteQueue bq;
00296                 bq.Put(oaepSeed, 20);
00297                 FixedRNG rng(bq);
00298 
00299                 FileSource privFile("rsa400pv.dat", true, new HexDecoder);
00300                 FileSource pubFile("rsa400pb.dat", true, new HexDecoder);
00301                 RSAES_OAEP_SHA_Decryptor rsaPriv;
00302                 rsaPriv.AccessKey().BERDecodeKey(privFile);
00303                 RSAES_OAEP_SHA_Encryptor rsaPub(pubFile);
00304 
00305                 memset(out, 0, 50);
00306                 memset(outPlain, 0, 8);
00307                 rsaPub.Encrypt(rng, plain, 8, out);
00308                 DecodingResult result = rsaPriv.FixedLengthDecrypt(encrypted, outPlain);
00309                 fail = !result.isValidCoding || (result.messageLength!=8) || memcmp(out, encrypted, 50) || memcmp(plain, outPlain, 8);
00310                 pass = pass && !fail;
00311 
00312                 cout << (fail ? "FAILED    " : "passed    ");
00313                 cout << "PKCS 2.0 encryption and decryption\n";
00314         }
00315 
00316         return pass;
00317 }
00318 
00319 bool ValidateDH()
00320 {
00321         cout << "\nDH validation suite running...\n\n";
00322 
00323         FileSource f("dh1024.dat", true, new HexDecoder());
00324         DH dh(f);
00325         return SimpleKeyAgreementValidate(dh);
00326 }
00327 
00328 bool ValidateMQV()
00329 {
00330         cout << "\nMQV validation suite running...\n\n";
00331 
00332         FileSource f("mqv1024.dat", true, new HexDecoder());
00333         MQV mqv(f);
00334         return AuthenticatedKeyAgreementValidate(mqv);
00335 }
00336 
00337 bool ValidateLUC_DH()
00338 {
00339         cout << "\nLUC-DH validation suite running...\n\n";
00340 
00341         FileSource f("lucd512.dat", true, new HexDecoder());
00342         LUC_DH dh(f);
00343         return SimpleKeyAgreementValidate(dh);
00344 }
00345 
00346 bool ValidateXTR_DH()
00347 {
00348         cout << "\nXTR-DH validation suite running...\n\n";
00349 
00350         FileSource f("xtrdh171.dat", true, new HexDecoder());
00351         XTR_DH dh(f);
00352         return SimpleKeyAgreementValidate(dh);
00353 }
00354 
00355 bool ValidateElGamal()
00356 {
00357         cout << "\nElGamal validation suite running...\n\n";
00358         bool pass = true;
00359         {
00360                 FileSource fc("elgc1024.dat", true, new HexDecoder);
00361                 ElGamalDecryptor privC(fc);
00362                 ElGamalEncryptor pubC(privC);
00363                 privC.AccessKey().Precompute();
00364                 ByteQueue queue;
00365                 privC.AccessKey().SavePrecomputation(queue);
00366                 privC.AccessKey().LoadPrecomputation(queue);
00367 
00368                 pass = CryptoSystemValidate(privC, pubC) && pass;
00369         }
00370         return pass;
00371 }
00372 
00373 bool ValidateDLIES()
00374 {
00375         cout << "\nDLIES validation suite running...\n\n";
00376         bool pass = true;
00377         {
00378                 FileSource fc("dlie1024.dat", true, new HexDecoder);
00379                 DLIES<>::Decryptor privC(fc);
00380                 DLIES<>::Encryptor pubC(privC);
00381                 pass = CryptoSystemValidate(privC, pubC) && pass;
00382         }
00383         {
00384                 cout << "Generating new encryption key..." << endl;
00385                 DLIES<>::GroupParameters gp;
00386                 gp.GenerateRandomWithKeySize(GlobalRNG(), 128);
00387                 DLIES<>::Decryptor decryptor;
00388                 decryptor.AccessKey().GenerateRandom(GlobalRNG(), gp);
00389                 DLIES<>::Encryptor encryptor(decryptor);
00390 
00391                 pass = CryptoSystemValidate(decryptor, encryptor) && pass;
00392         }
00393         return pass;
00394 }
00395 
00396 bool ValidateNR()
00397 {
00398         cout << "\nNR validation suite running...\n\n";
00399         bool pass = true;
00400         {
00401                 FileSource f("nr2048.dat", true, new HexDecoder);
00402                 NR<SHA>::Signer privS(f);
00403                 privS.AccessKey().Precompute();
00404                 NR<SHA>::Verifier pubS(privS);
00405 
00406                 pass = SignatureValidate(privS, pubS) && pass;
00407         }
00408         {
00409                 cout << "Generating new signature key..." << endl;
00410                 NR<SHA>::Signer privS(GlobalRNG(), 256);
00411                 NR<SHA>::Verifier pubS(privS);
00412 
00413                 pass = SignatureValidate(privS, pubS) && pass;
00414         }
00415         return pass;
00416 }
00417 
00418 bool ValidateDSA(bool thorough)
00419 {
00420         cout << "\nDSA validation suite running...\n\n";
00421 
00422         bool pass = true, fail;
00423         {
00424         FileSource fs("dsa512.dat", true, new HexDecoder());
00425         GDSA<SHA>::Signer priv(fs);
00426         priv.AccessKey().Precompute(16);
00427         GDSA<SHA>::Verifier pub(priv);
00428 
00429         byte seed[]={0xd5, 0x01, 0x4e, 0x4b, 0x60, 0xef, 0x2b, 0xa8, 0xb6, 0x21, 
00430                                  0x1b, 0x40, 0x62, 0xba, 0x32, 0x24, 0xe0, 0x42, 0x7d, 0xd3};
00431         Integer k("358dad57 1462710f 50e254cf 1a376b2b deaadfbfh");
00432         Integer h("a9993e36 4706816a ba3e2571 7850c26c 9cd0d89dh");
00433         byte sig[]={0x8b, 0xac, 0x1a, 0xb6, 0x64, 0x10, 0x43, 0x5c, 0xb7, 0x18,
00434                                 0x1f, 0x95, 0xb1, 0x6a, 0xb9, 0x7c, 0x92, 0xb3, 0x41, 0xc0, 
00435                                 0x41, 0xe2, 0x34, 0x5f, 0x1f, 0x56, 0xdf, 0x24, 0x58, 0xf4, 
00436                                 0x26, 0xd1, 0x55, 0xb4, 0xba, 0x2d, 0xb6, 0xdc, 0xd8, 0xc8};
00437         Integer r(sig, 20);
00438         Integer s(sig+20, 20);
00439 
00440         Integer pGen, qGen, rOut, sOut;
00441         int c;
00442 
00443         fail = !DSA::GeneratePrimes(seed, 160, c, pGen, 512, qGen);
00444         fail = fail || (pGen != pub.GetKey().GetGroupParameters().GetModulus()) || (qGen != pub.GetKey().GetGroupParameters().GetSubgroupOrder());
00445         pass = pass && !fail;
00446 
00447         cout << (fail ? "FAILED    " : "passed    ");
00448         cout << "prime generation test\n";
00449 
00450         priv.GetDigestSignatureScheme().RawSign(k, h, rOut, sOut);
00451         fail = (rOut != r) || (sOut != s);
00452         pass = pass && !fail;
00453 
00454         cout << (fail ? "FAILED    " : "passed    ");
00455         cout << "signature check against test vector\n";
00456 
00457         fail = !pub.VerifyMessage((byte *)"abc", 3, sig);
00458         pass = pass && !fail;
00459 
00460         cout << (fail ? "FAILED    " : "passed    ");
00461         cout << "verification check against test vector\n";
00462 
00463         fail = pub.VerifyMessage((byte *)"xyz", 3, sig);
00464         pass = pass && !fail;
00465         }
00466         FileSource fs1("dsa1024.dat", true, new HexDecoder());
00467         DSA::Signer priv(fs1);
00468         DSA::Verifier pub(priv);
00469         FileSource fs2("dsa1024b.dat", true, new HexDecoder());
00470         DSA::Verifier pub1(fs2);
00471         assert(pub.GetKey() == pub1.GetKey());
00472         pass = SignatureValidate(priv, pub, thorough) && pass;
00473         return pass;
00474 }
00475 
00476 bool ValidateLUC()
00477 {
00478         cout << "\nLUC validation suite running...\n\n";
00479         bool pass=true;
00480 
00481         {
00482                 FileSource f("luc1024.dat", true, new HexDecoder);
00483                 LUCSSA_PKCS1v15_SHA_Signer priv(f);
00484                 LUCSSA_PKCS1v15_SHA_Verifier pub(priv);
00485                 pass = SignatureValidate(priv, pub) && pass;
00486         }
00487         {
00488                 LUCES_OAEP_SHA_Decryptor priv(GlobalRNG(), 512);
00489                 LUCES_OAEP_SHA_Encryptor pub(priv);
00490                 pass = CryptoSystemValidate(priv, pub) && pass;
00491         }
00492         return pass;
00493 }
00494 
00495 bool ValidateLUC_DL()
00496 {
00497         cout << "\nLUC-HMP validation suite running...\n\n";
00498 
00499         FileSource f("lucs512.dat", true, new HexDecoder);
00500         LUC_HMP<SHA>::Signer privS(f);
00501         LUC_HMP<SHA>::Verifier pubS(privS);
00502         bool pass = SignatureValidate(privS, pubS);
00503 
00504         cout << "\nLUC-IES validation suite running...\n\n";
00505 
00506         FileSource fc("lucc512.dat", true, new HexDecoder);
00507         LUC_IES<>::Decryptor privC(fc);
00508         LUC_IES<>::Encryptor pubC(privC);
00509         pass = CryptoSystemValidate(privC, pubC) && pass;
00510 
00511         return pass;
00512 }
00513 
00514 bool ValidateRabin()
00515 {
00516         cout << "\nRabin validation suite running...\n\n";
00517         bool pass=true;
00518 
00519         {
00520                 FileSource f("rabi1024.dat", true, new HexDecoder);
00521                 RabinPSSR<SHA>::Signer priv(f);
00522                 RabinPSSR<SHA>::Verifier pub(priv);
00523                 pass = SignatureValidate(priv, pub) && pass;
00524         }
00525         {
00526                 RabinES<OAEP<SHA> >::Decryptor priv(GlobalRNG(), 512);
00527                 RabinES<OAEP<SHA> >::Encryptor pub(priv);
00528                 pass = CryptoSystemValidate(priv, pub) && pass;
00529         }
00530         return pass;
00531 }
00532 
00533 bool ValidateRW()
00534 {
00535         cout << "\nRW validation suite running...\n\n";
00536 
00537         FileSource f("rw1024.dat", true, new HexDecoder);
00538         RWSSA<SHA>::Signer priv(f);
00539         RWSSA<SHA>::Verifier pub(priv);
00540 
00541         return SignatureValidate(priv, pub);
00542 }
00543 
00544 /*
00545 bool ValidateBlumGoldwasser()
00546 {
00547         cout << "\nBlumGoldwasser validation suite running...\n\n";
00548 
00549         FileSource f("blum512.dat", true, new HexDecoder);
00550         BlumGoldwasserPrivateKey priv(f);
00551         BlumGoldwasserPublicKey pub(priv);
00552 
00553         return CryptoSystemValidate(priv, pub);
00554 }
00555 */
00556 
00557 bool ValidateECP()
00558 {
00559         cout << "\nECP validation suite running...\n\n";
00560 
00561         ECIES<ECP>::Decryptor cpriv(GlobalRNG(), ASN1::secp192r1());
00562         ECIES<ECP>::Encryptor cpub(cpriv);
00563         ByteQueue bq;
00564         cpriv.GetKey().DEREncode(bq);
00565         cpub.AccessKey().AccessGroupParameters().SetEncodeAsOID(true);
00566         cpub.GetKey().DEREncode(bq);
00567         ECDSA<ECP, SHA>::Signer spriv(bq);
00568         ECDSA<ECP, SHA>::Verifier spub(bq);
00569         ECDH<ECP>::Domain ecdhc(ASN1::secp192r1());
00570         ECMQV<ECP>::Domain ecmqvc(ASN1::secp192r1());
00571 
00572         spriv.AccessKey().Precompute();
00573         ByteQueue queue;
00574         spriv.AccessKey().SavePrecomputation(queue);
00575         spriv.AccessKey().LoadPrecomputation(queue);
00576 
00577         bool pass = SignatureValidate(spriv, spub);
00578         cpub.AccessKey().Precompute();
00579         cpriv.AccessKey().Precompute();
00580         pass = CryptoSystemValidate(cpriv, cpub) && pass;
00581         pass = SimpleKeyAgreementValidate(ecdhc) && pass;
00582         pass = AuthenticatedKeyAgreementValidate(ecmqvc) && pass;
00583 
00584         cout << "Turning on point compression..." << endl;
00585         cpriv.AccessKey().AccessGroupParameters().SetPointCompression(true);
00586         cpub.AccessKey().AccessGroupParameters().SetPointCompression(true);
00587         ecdhc.AccessGroupParameters().SetPointCompression(true);
00588         ecmqvc.AccessGroupParameters().SetPointCompression(true);
00589         pass = CryptoSystemValidate(cpriv, cpub) && pass;
00590         pass = SimpleKeyAgreementValidate(ecdhc) && pass;
00591         pass = AuthenticatedKeyAgreementValidate(ecmqvc) && pass;
00592 
00593         cout << "Testing SEC 2 recommended curves..." << endl;
00594         OID oid;
00595         while (!(oid = DL_GroupParameters_EC<ECP>::GetNextRecommendedParametersOID(oid)).m_values.empty())
00596         {
00597                 DL_GroupParameters_EC<ECP> params(oid);
00598                 bool fail = !params.Validate(GlobalRNG(), 2);
00599                 cout << (fail ? "FAILED" : "passed") << "    " << dec << params.GetCurve().GetField().MaxElementBitLength() << " bits" << endl;
00600                 pass = pass && !fail;
00601         }
00602 
00603         return pass;
00604 }
00605 
00606 bool ValidateEC2N()
00607 {
00608         cout << "\nEC2N validation suite running...\n\n";
00609 
00610         ECIES<EC2N>::Decryptor cpriv(GlobalRNG(), ASN1::sect193r1());
00611         ECIES<EC2N>::Encryptor cpub(cpriv);
00612         ByteQueue bq;
00613         cpriv.DEREncode(bq);
00614         cpub.AccessKey().AccessGroupParameters().SetEncodeAsOID(true);
00615         cpub.DEREncode(bq);
00616         ECDSA<EC2N, SHA>::Signer spriv(bq);
00617         ECDSA<EC2N, SHA>::Verifier spub(bq);
00618         ECDH<EC2N>::Domain ecdhc(ASN1::sect193r1());
00619         ECMQV<EC2N>::Domain ecmqvc(ASN1::sect193r1());
00620 
00621         spriv.AccessKey().Precompute();
00622         ByteQueue queue;
00623         spriv.AccessKey().SavePrecomputation(queue);
00624         spriv.AccessKey().LoadPrecomputation(queue);
00625 
00626         bool pass = SignatureValidate(spriv, spub);
00627         pass = CryptoSystemValidate(cpriv, cpub) && pass;
00628         pass = SimpleKeyAgreementValidate(ecdhc) && pass;
00629         pass = AuthenticatedKeyAgreementValidate(ecmqvc) && pass;
00630 
00631         cout << "Turning on point compression..." << endl;
00632         cpriv.AccessKey().AccessGroupParameters().SetPointCompression(true);
00633         cpub.AccessKey().AccessGroupParameters().SetPointCompression(true);
00634         ecdhc.AccessGroupParameters().SetPointCompression(true);
00635         ecmqvc.AccessGroupParameters().SetPointCompression(true);
00636         pass = CryptoSystemValidate(cpriv, cpub) && pass;
00637         pass = SimpleKeyAgreementValidate(ecdhc) && pass;
00638         pass = AuthenticatedKeyAgreementValidate(ecmqvc) && pass;
00639 
00640 #if 0   // TODO: turn this back on when I make EC2N faster for pentanomial basis
00641         cout << "Testing SEC 2 recommended curves..." << endl;
00642         OID oid;
00643         while (!(oid = ECParameters<EC2N>::GetNextRecommendedParametersOID(oid)).m_values.empty())
00644         {
00645                 ECParameters<EC2N> params(oid);
00646                 bool fail = !params.ValidateParameters(GlobalRNG());
00647                 cout << (fail ? "FAILED" : "passed") << "    " << params.GetCurve().GetField().MaxElementBitLength() << " bits" << endl;
00648                 pass = pass && !fail;
00649         }
00650 #endif
00651 
00652         return pass;
00653 }
00654 
00655 bool ValidateECDSA()
00656 {
00657         cout << "\nECDSA validation suite running...\n\n";
00658 
00659         // from Sample Test Vectors for P1363
00660         GF2NT gf2n(191, 9, 0);
00661         byte a[]="\x28\x66\x53\x7B\x67\x67\x52\x63\x6A\x68\xF5\x65\x54\xE1\x26\x40\x27\x6B\x64\x9E\xF7\x52\x62\x67";
00662         byte b[]="\x2E\x45\xEF\x57\x1F\x00\x78\x6F\x67\xB0\x08\x1B\x94\x95\xA3\xD9\x54\x62\xF5\xDE\x0A\xA1\x85\xEC";
00663         EC2N ec(gf2n, PolynomialMod2(a,24), PolynomialMod2(b,24));
00664 
00665         EC2N::Point P;
00666         ec.DecodePoint(P, (byte *)"\x04\x36\xB3\xDA\xF8\xA2\x32\x06\xF9\xC4\xF2\x99\xD7\xB2\x1A\x9C\x36\x91\x37\xF2\xC8\x4A\xE1\xAA\x0D"
00667                 "\x76\x5B\xE7\x34\x33\xB3\xF9\x5E\x33\x29\x32\xE7\x0E\xA2\x45\xCA\x24\x18\xEA\x0E\xF9\x80\x18\xFB", ec.EncodedPointSize());
00668         Integer n("40000000000000000000000004a20e90c39067c893bbb9a5H");
00669         Integer d("340562e1dda332f9d2aec168249b5696ee39d0ed4d03760fH");
00670         EC2N::Point Q(ec.Multiply(d, P));
00671         ECDSA<EC2N, SHA>::Signer priv(ec, P, n, d);
00672         ECDSA<EC2N, SHA>::Verifier pub(priv);
00673 
00674         Integer h("A9993E364706816ABA3E25717850C26C9CD0D89DH");
00675         Integer k("3eeace72b4919d991738d521879f787cb590aff8189d2b69H");
00676         byte sig[]="\x03\x8e\x5a\x11\xfb\x55\xe4\xc6\x54\x71\xdc\xd4\x99\x84\x52\xb1\xe0\x2d\x8a\xf7\x09\x9b\xb9\x30"
00677                 "\x0c\x9a\x08\xc3\x44\x68\xc2\x44\xb4\xe5\xd6\xb2\x1b\x3c\x68\x36\x28\x07\x41\x60\x20\x32\x8b\x6e";
00678         Integer r(sig, 24);
00679         Integer s(sig+24, 24);
00680 
00681         Integer rOut, sOut;
00682         bool fail, pass=true;
00683 
00684         priv.GetDigestSignatureScheme().RawSign(k, h, rOut, sOut);
00685         fail = (rOut != r) || (sOut != s);
00686         pass = pass && !fail;
00687 
00688         cout << (fail ? "FAILED    " : "passed    ");
00689         cout << "signature check against test vector\n";
00690 
00691         fail = !pub.VerifyMessage((byte *)"abc", 3, sig);
00692         pass = pass && !fail;
00693 
00694         cout << (fail ? "FAILED    " : "passed    ");
00695         cout << "verification check against test vector\n";
00696 
00697         fail = pub.VerifyMessage((byte *)"xyz", 3, sig);
00698         pass = pass && !fail;
00699 
00700         pass = SignatureValidate(priv, pub) && pass;
00701 
00702         return pass;
00703 }
00704 
00705 bool ValidateESIGN()
00706 {
00707         cout << "\nESIGN validation suite running...\n\n";
00708 
00709         bool pass = true, fail;
00710 
00711         const char *plain = "test";
00712         const byte *signature = (byte *)
00713                 "\xA3\xE3\x20\x65\xDE\xDA\xE7\xEC\x05\xC1\xBF\xCD\x25\x79\x7D\x99\xCD\xD5\x73\x9D\x9D\xF3\xA4\xAA\x9A\xA4\x5A\xC8\x23\x3D\x0D\x37\xFE\xBC\x76\x3F\xF1\x84\xF6\x59"
00714                 "\x14\x91\x4F\x0C\x34\x1B\xAE\x9A\x5C\x2E\x2E\x38\x08\x78\x77\xCB\xDC\x3C\x7E\xA0\x34\x44\x5B\x0F\x67\xD9\x35\x2A\x79\x47\x1A\x52\x37\x71\xDB\x12\x67\xC1\xB6\xC6"
00715                 "\x66\x73\xB3\x40\x2E\xD6\xF2\x1A\x84\x0A\xB6\x7B\x0F\xEB\x8B\x88\xAB\x33\xDD\xE4\x83\x21\x90\x63\x2D\x51\x2A\xB1\x6F\xAB\xA7\x5C\xFD\x77\x99\xF2\xE1\xEF\x67\x1A"
00716                 "\x74\x02\x37\x0E\xED\x0A\x06\xAD\xF4\x15\x65\xB8\xE1\xD1\x45\xAE\x39\x19\xB4\xFF\x5D\xF1\x45\x7B\xE0\xFE\x72\xED\x11\x92\x8F\x61\x41\x4F\x02\x00\xF2\x76\x6F\x7C"
00717                 "\x79\xA2\xE5\x52\x20\x5D\x97\x5E\xFE\x39\xAE\x21\x10\xFB\x35\xF4\x80\x81\x41\x13\xDD\xE8\x5F\xCA\x1E\x4F\xF8\x9B\xB2\x68\xFB\x28";
00718 
00719         FileSource keys("esig1536.dat", true, new HexDecoder);
00720         ESIGN<SHA>::Signer signer(keys);
00721         ESIGN<SHA>::Verifier verifier(signer);
00722 
00723         fail = !SignatureValidate(signer, verifier);
00724         pass = pass && !fail;
00725 
00726         fail = !verifier.VerifyMessage((byte *)plain, strlen(plain), signature);
00727         pass = pass && !fail;
00728 
00729         cout << (fail ? "FAILED    " : "passed    ");
00730         cout << "verification check against test vector\n";
00731 
00732         cout << "Generating signature key from seed..." << endl;
00733         InvertibleESIGNFunction priv;
00734         priv.GenerateRandom(GlobalRNG(), MakeParameters("Seed", ConstByteArrayParameter((const byte *)"test", 4))("KeySize", 3*512));
00735 
00736         fail = !SignatureValidate(signer, verifier);
00737         pass = pass && !fail;
00738 
00739         return pass;
00740 }

Generated on Tue Jul 8 23:34:27 2003 for Crypto++ by doxygen 1.3.2