5 #define CRYPTOPP_ENABLE_NAMESPACE_WEAK 1
34 USING_NAMESPACE(CryptoPP)
42 void GenerateBlock(byte *output,
size_t size)
44 m_source.Get(output, size);
53 cout <<
"\nBlumBlumShub validation suite running...\n\n";
55 Integer p(
"212004934506826557583707108431463840565872545889679278744389317666981496005411448865750399674653351");
56 Integer q(
"100677295735404212434355574418077394581488455772477016953458064183204108039226017738610663984508231");
57 Integer seed(
"63239752671357255800299643604761065219897634268887145610573595874544114193025997412441121667211431");
59 bool pass =
true, fail;
62 const byte output1[] = {
63 0x49,0xEA,0x2C,0xFD,0xB0,0x10,0x64,0xA0,0xBB,0xB9,
64 0x2A,0xF1,0x01,0xDA,0xC1,0x8A,0x94,0xF7,0xB7,0xCE};
65 const byte output2[] = {
66 0x74,0x45,0x48,0xAE,0xAC,0xB7,0x0E,0xDF,0xAF,0xD7,
67 0xD5,0x0E,0x8E,0x29,0x83,0x75,0x6B,0x27,0x46,0xA1};
71 bbs.GenerateBlock(buf, 20);
72 fail = memcmp(output1, buf, 20) != 0;
75 cout << (fail ?
"FAILED " :
"passed ");
77 cout << setw(2) << setfill(
'0') << hex << (int)buf[j];
81 bbs.GenerateBlock(buf, 10);
82 fail = memcmp(output1+10, buf, 10) != 0;
85 cout << (fail ?
"FAILED " :
"passed ");
87 cout << setw(2) << setfill(
'0') << hex << (int)buf[j];
91 bbs.GenerateBlock(buf, 20);
92 fail = memcmp(output2, buf, 20) != 0;
95 cout << (fail ?
"FAILED " :
"passed ");
97 cout << setw(2) << setfill(
'0') << hex << (int)buf[j];
105 bool pass =
true, fail;
108 pass = pass && !fail;
110 cout << (fail ?
"FAILED " :
"passed ");
111 cout <<
"signature key validation\n";
113 const byte *message = (byte *)
"test message";
114 const int messageLen = 12;
117 size_t signatureLength = priv.
SignMessage(GlobalRNG(), message, messageLen, signature);
118 fail = !pub.
VerifyMessage(message, messageLen, signature, signatureLength);
119 pass = pass && !fail;
121 cout << (fail ?
"FAILED " :
"passed ");
122 cout <<
"signature and verification\n";
125 fail = pub.
VerifyMessage(message, messageLen, signature, signatureLength);
126 pass = pass && !fail;
128 cout << (fail ?
"FAILED " :
"passed ");
129 cout <<
"checking invalid signature" << endl;
136 fail = !(result.isValidCoding && result.messageLength == messageLen && memcmp(recovered, message, messageLen) == 0);
137 pass = pass && !fail;
139 cout << (fail ?
"FAILED " :
"passed ");
140 cout <<
"signature and verification with recovery" << endl;
143 result = pub.
RecoverMessage(recovered, NULL, 0, signature, signatureLength);
144 fail = result.isValidCoding;
145 pass = pass && !fail;
147 cout << (fail ?
"FAILED " :
"passed ");
148 cout <<
"recovery with invalid signature" << endl;
156 bool pass =
true, fail;
159 pass = pass && !fail;
161 cout << (fail ?
"FAILED " :
"passed ");
162 cout <<
"cryptosystem key validation\n";
164 const byte *message = (byte *)
"test message";
165 const int messageLen = 12;
169 pub.
Encrypt(GlobalRNG(), message, messageLen, ciphertext);
171 fail = fail || memcmp(message, plaintext, messageLen);
172 pass = pass && !fail;
174 cout << (fail ?
"FAILED " :
"passed ");
175 cout <<
"encryption and decryption\n";
182 if (d.GetCryptoParameters().
Validate(GlobalRNG(), 3))
183 cout <<
"passed simple key agreement domain parameters validation" << endl;
186 cout <<
"FAILED simple key agreement domain parameters invalid" << endl;
197 memset(val1.begin(), 0x10, val1.size());
198 memset(val2.begin(), 0x11, val2.size());
200 if (!(d.
Agree(val1, priv1, pub2) && d.
Agree(val2, priv2, pub1)))
202 cout <<
"FAILED simple key agreement failed" << endl;
208 cout <<
"FAILED simple agreed values not equal" << endl;
212 cout <<
"passed simple key agreement" << endl;
218 if (d.GetCryptoParameters().
Validate(GlobalRNG(), 3))
219 cout <<
"passed authenticated key agreement domain parameters validation" << endl;
222 cout <<
"FAILED authenticated key agreement domain parameters invalid" << endl;
237 memset(val1.begin(), 0x10, val1.size());
238 memset(val2.begin(), 0x11, val2.size());
240 if (!(d.
Agree(val1, spriv1, epriv1, spub2, epub2) && d.
Agree(val2, spriv2, epriv2, spub1, epub1)))
242 cout <<
"FAILED authenticated key agreement failed" << endl;
248 cout <<
"FAILED authenticated agreed values not equal" << endl;
252 cout <<
"passed authenticated key agreement" << endl;
258 cout <<
"\nRSA validation suite running...\n\n";
260 byte out[100], outPlain[100];
261 bool pass =
true, fail;
264 const char *plain =
"Everyone gets Friday off.";
265 byte *signature = (byte *)
266 "\x05\xfa\x6a\x81\x2f\xc7\xdf\x8b\xf4\xf2\x54\x25\x09\xe0\x3e\x84"
267 "\x6e\x11\xb9\xc6\x20\xbe\x20\x09\xef\xb4\x40\xef\xbc\xc6\x69\x21"
268 "\x69\x94\xac\x04\xf3\x41\xb5\x7d\x05\x20\x2d\x42\x8f\xb2\xa2\x7b"
269 "\x5c\x77\xdf\xd9\xb1\x5b\xfc\x3d\x55\x93\x53\x50\x34\x10\xc1\xe1";
275 size_t signatureLength = rsaPriv.SignMessage(GlobalRNG(), (byte *)plain, strlen(plain), out);
276 fail = memcmp(signature, out, 64) != 0;
277 pass = pass && !fail;
279 cout << (fail ?
"FAILED " :
"passed ");
280 cout <<
"signature check against test vector\n";
282 fail = !rsaPub.VerifyMessage((byte *)plain, strlen(plain), out, signatureLength);
283 pass = pass && !fail;
285 cout << (fail ?
"FAILED " :
"passed ");
286 cout <<
"verification check against test vector\n";
289 fail = rsaPub.VerifyMessage((byte *)plain, strlen(plain), out, signatureLength);
290 pass = pass && !fail;
292 cout << (fail ?
"FAILED " :
"passed ");
293 cout <<
"invalid signature verification\n";
300 pass = CryptoSystemValidate(rsaPriv, rsaPub) && pass;
306 pass = CryptoSystemValidate(rsaPriv, rsaPub) && pass;
309 byte *plain = (byte *)
310 "\x54\x85\x9b\x34\x2c\x49\xea\x2a";
311 byte *encrypted = (byte *)
312 "\x14\xbd\xdd\x28\xc9\x83\x35\x19\x23\x80\xe8\xe5\x49\xb1\x58\x2a"
313 "\x8b\x40\xb4\x48\x6d\x03\xa6\xa5\x31\x1f\x1f\xd5\xf0\xa1\x80\xe4"
314 "\x17\x53\x03\x29\xa9\x34\x90\x74\xb1\x52\x13\x54\x29\x08\x24\x52"
316 byte *oaepSeed = (byte *)
317 "\xaa\xfd\x12\xf6\x59\xca\xe6\x34\x89\xb4\x79\xe5\x07\x6d\xde\xc2"
320 bq.
Put(oaepSeed, 20);
326 rsaPriv.AccessKey().BERDecodePrivateKey(privFile,
false, 0);
330 memset(outPlain, 0, 8);
331 rsaPub.Encrypt(rng, plain, 8, out);
332 DecodingResult result = rsaPriv.FixedLengthDecrypt(GlobalRNG(), encrypted, outPlain);
333 fail = !result.isValidCoding || (result.messageLength!=8) || memcmp(out, encrypted, 50) || memcmp(plain, outPlain, 8);
334 pass = pass && !fail;
336 cout << (fail ?
"FAILED " :
"passed ");
337 cout <<
"PKCS 2.0 encryption and decryption\n";
345 cout <<
"\nDH validation suite running...\n\n";
349 return SimpleKeyAgreementValidate(dh);
354 cout <<
"\nMQV validation suite running...\n\n";
358 return AuthenticatedKeyAgreementValidate(mqv);
361 bool ValidateLUC_DH()
363 cout <<
"\nLUC-DH validation suite running...\n\n";
367 return SimpleKeyAgreementValidate(dh);
370 bool ValidateXTR_DH()
372 cout <<
"\nXTR-DH validation suite running...\n\n";
376 return SimpleKeyAgreementValidate(dh);
379 bool ValidateElGamal()
381 cout <<
"\nElGamal validation suite running...\n\n";
387 privC.AccessKey().Precompute();
389 privC.AccessKey().SavePrecomputation(queue);
390 privC.AccessKey().LoadPrecomputation(queue);
392 pass = CryptoSystemValidate(privC, pubC) && pass;
399 cout <<
"\nDLIES validation suite running...\n\n";
405 pass = CryptoSystemValidate(privC, pubC) && pass;
408 cout <<
"Generating new encryption key..." << endl;
412 decryptor.AccessKey().GenerateRandom(GlobalRNG(), gp);
415 pass = CryptoSystemValidate(decryptor, encryptor) && pass;
422 cout <<
"\nNR validation suite running...\n\n";
427 privS.AccessKey().Precompute();
430 pass = SignatureValidate(privS, pubS) && pass;
433 cout <<
"Generating new signature key..." << endl;
437 pass = SignatureValidate(privS, pubS) && pass;
442 bool ValidateDSA(
bool thorough)
444 cout <<
"\nDSA validation suite running...\n\n";
452 assert(pub.GetKey() == pub1.GetKey());
453 pass = SignatureValidate(priv, pub, thorough) && pass;
454 pass = RunTestDataFile(PACKAGE_DATA_DIR
"TestVectors/dsa.txt", g_nullNameValuePairs, thorough) && pass;
460 cout <<
"\nLUC validation suite running...\n\n";
467 pass = SignatureValidate(priv, pub) && pass;
472 pass = CryptoSystemValidate(priv, pub) && pass;
477 bool ValidateLUC_DL()
479 cout <<
"\nLUC-HMP validation suite running...\n\n";
484 bool pass = SignatureValidate(privS, pubS);
486 cout <<
"\nLUC-IES validation suite running...\n\n";
491 pass = CryptoSystemValidate(privC, pubC) && pass;
498 cout <<
"\nRabin validation suite running...\n\n";
505 pass = SignatureValidate(priv, pub) && pass;
510 pass = CryptoSystemValidate(priv, pub) && pass;
517 cout <<
"\nRW validation suite running...\n\n";
523 return SignatureValidate(priv, pub);
541 cout <<
"\nECP validation suite running...\n\n";
546 cpriv.GetKey().DEREncode(bq);
547 cpub.AccessKey().AccessGroupParameters().SetEncodeAsOID(
true);
548 cpub.GetKey().DEREncode(bq);
554 spriv.AccessKey().Precompute();
556 spriv.AccessKey().SavePrecomputation(queue);
557 spriv.AccessKey().LoadPrecomputation(queue);
559 bool pass = SignatureValidate(spriv, spub);
560 cpub.AccessKey().Precompute();
561 cpriv.AccessKey().Precompute();
562 pass = CryptoSystemValidate(cpriv, cpub) && pass;
563 pass = SimpleKeyAgreementValidate(ecdhc) && pass;
564 pass = AuthenticatedKeyAgreementValidate(ecmqvc) && pass;
566 cout <<
"Turning on point compression..." << endl;
567 cpriv.AccessKey().AccessGroupParameters().SetPointCompression(
true);
568 cpub.AccessKey().AccessGroupParameters().SetPointCompression(
true);
569 ecdhc.AccessGroupParameters().SetPointCompression(
true);
570 ecmqvc.AccessGroupParameters().SetPointCompression(
true);
571 pass = CryptoSystemValidate(cpriv, cpub) && pass;
572 pass = SimpleKeyAgreementValidate(ecdhc) && pass;
573 pass = AuthenticatedKeyAgreementValidate(ecmqvc) && pass;
575 cout <<
"Testing SEC 2, NIST, and Brainpool recommended curves..." << endl;
580 bool fail = !params.Validate(GlobalRNG(), 2);
581 cout << (fail ?
"FAILED" :
"passed") <<
" " << dec << params.GetCurve().GetField().MaxElementBitLength() <<
" bits" << endl;
582 pass = pass && !fail;
590 cout <<
"\nEC2N validation suite running...\n\n";
596 cpub.AccessKey().AccessGroupParameters().SetEncodeAsOID(
true);
603 spriv.AccessKey().Precompute();
605 spriv.AccessKey().SavePrecomputation(queue);
606 spriv.AccessKey().LoadPrecomputation(queue);
608 bool pass = SignatureValidate(spriv, spub);
609 pass = CryptoSystemValidate(cpriv, cpub) && pass;
610 pass = SimpleKeyAgreementValidate(ecdhc) && pass;
611 pass = AuthenticatedKeyAgreementValidate(ecmqvc) && pass;
613 cout <<
"Turning on point compression..." << endl;
614 cpriv.AccessKey().AccessGroupParameters().SetPointCompression(
true);
615 cpub.AccessKey().AccessGroupParameters().SetPointCompression(
true);
616 ecdhc.AccessGroupParameters().SetPointCompression(
true);
617 ecmqvc.AccessGroupParameters().SetPointCompression(
true);
618 pass = CryptoSystemValidate(cpriv, cpub) && pass;
619 pass = SimpleKeyAgreementValidate(ecdhc) && pass;
620 pass = AuthenticatedKeyAgreementValidate(ecmqvc) && pass;
622 #if 0 // TODO: turn this back on when I make EC2N faster for pentanomial basis
623 cout <<
"Testing SEC 2 recommended curves..." << endl;
628 bool fail = !params.Validate(GlobalRNG(), 2);
629 cout << (fail ?
"FAILED" :
"passed") <<
" " << params.GetCurve().GetField().MaxElementBitLength() <<
" bits" << endl;
630 pass = pass && !fail;
639 cout <<
"\nECDSA validation suite running...\n\n";
642 GF2NT gf2n(191, 9, 0);
643 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";
644 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";
648 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"
649 "\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());
650 Integer n(
"40000000000000000000000004a20e90c39067c893bbb9a5H");
651 Integer d(
"340562e1dda332f9d2aec168249b5696ee39d0ed4d03760fH");
656 Integer h(
"A9993E364706816ABA3E25717850C26C9CD0D89DH");
657 Integer k(
"3eeace72b4919d991738d521879f787cb590aff8189d2b69H");
658 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"
659 "\x0c\x9a\x08\xc3\x44\x68\xc2\x44\xb4\xe5\xd6\xb2\x1b\x3c\x68\x36\x28\x07\x41\x60\x20\x32\x8b\x6e";
664 bool fail, pass=
true;
666 priv.RawSign(k, h, rOut, sOut);
667 fail = (rOut != r) || (sOut != s);
668 pass = pass && !fail;
670 cout << (fail ?
"FAILED " :
"passed ");
671 cout <<
"signature check against test vector\n";
673 fail = !pub.VerifyMessage((byte *)
"abc", 3, sig,
sizeof(sig));
674 pass = pass && !fail;
676 cout << (fail ?
"FAILED " :
"passed ");
677 cout <<
"verification check against test vector\n";
679 fail = pub.VerifyMessage((byte *)
"xyz", 3, sig,
sizeof(sig));
680 pass = pass && !fail;
682 pass = SignatureValidate(priv, pub) && pass;
689 cout <<
"\nESIGN validation suite running...\n\n";
691 bool pass =
true, fail;
693 const char *plain =
"test";
694 const byte *signature = (byte *)
695 "\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"
696 "\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"
697 "\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"
698 "\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"
699 "\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";
705 fail = !SignatureValidate(signer, verifier);
706 pass = pass && !fail;
708 fail = !verifier.VerifyMessage((byte *)plain, strlen(plain), signature, verifier.SignatureLength());
709 pass = pass && !fail;
711 cout << (fail ?
"FAILED " :
"passed ");
712 cout <<
"verification check against test vector\n";
714 cout <<
"Generating signature key from seed..." << endl;
715 signer.AccessKey().GenerateRandom(GlobalRNG(), MakeParameters(
"Seed",
ConstByteArrayParameter((
const byte *)
"test", 4))(
"KeySize", 3*512));
718 fail = !SignatureValidate(signer, verifier);
719 pass = pass && !fail;