5 #define CRYPTOPP_ENABLE_NAMESPACE_WEAK 1
34 USING_NAMESPACE(CryptoPP)
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;
used to pass byte array input as part of a NameValuePairs object
virtual bool Agree(byte *agreedValue, const byte *staticPrivateKey, const byte *ephemeralPrivateKey, const byte *staticOtherPublicKey, const byte *ephemeralOtherPublicKey, bool validateStaticOtherPublicKey=true) const =0
derive agreed value from your private keys and couterparty's public keys, return false in case of fai...
virtual void GenerateEphemeralKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const
generate private/public key pair
virtual size_t SignMessageWithRecovery(RandomNumberGenerator &rng, const byte *recoverableMessage, size_t recoverableMessageLength, const byte *nonrecoverableMessage, size_t nonrecoverableMessageLength, byte *signature) const
sign a recoverable message
void GenerateBlock(byte *output, size_t size)
generate random array of bytes
virtual unsigned int StaticPublicKeyLength() const =0
return length of static public keys in this domain
virtual unsigned int AgreedValueLength() const =0
return length of agreed value produced
GF(2^n) with Trinomial Basis.
file-based implementation of Source interface
interface for public-key signers
interface for public-key encryptors
Decode base 16 data back to bytes.
virtual void Encrypt(RandomNumberGenerator &rng, const byte *plaintext, size_t plaintextLength, byte *ciphertext, const NameValuePairs ¶meters=g_nullNameValuePairs) const =0
encrypt a byte string
virtual size_t MaxPlaintextLength(size_t ciphertextLength) const =0
maximum length of plaintext for a given ciphertext length
GF(p) group parameters that default to same primes.
virtual unsigned int PrivateKeyLength() const =0
return length of private keys in this domain
interface for random number generators
virtual unsigned int StaticPrivateKeyLength() const =0
return length of static private keys in this domain
virtual unsigned int PublicKeyLength() const =0
return length of public keys in this domain
const CryptoMaterial & GetMaterial() const
returns a const reference to the crypto material used by this object
This file contains classes that implement the ESIGN signature schemes as defined in IEEE P1363a...
Polynomial with Coefficients in GF(2)
virtual size_t MaxRecoverableLength() const =0
length of longest message that can be recovered, or 0 if this signature scheme does not support messa...
virtual unsigned int EphemeralPrivateKeyLength() const =0
return length of ephemeral private keys in this domain
interface for domains of simple key agreement protocols
used to return decoding results
This file contains classes that implement the Rabin-Williams signature schemes as defined in IEEE P13...
interface for public-key decryptors
XTR-DH with key validation.
virtual void GenerateKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const
generate private/public key pair
virtual bool Validate(RandomNumberGenerator &rng, unsigned int level) const =0
check this object for errors
virtual size_t MaxSignatureLength(size_t recoverablePartLength=0) const
maximum signature length produced for a given length of recoverable message part
virtual void GenerateStaticKeyPair(RandomNumberGenerator &rng, byte *privateKey, byte *publicKey) const
generate private/public key pair
multiple precision integer and basic arithmetics
Elliptic Curve over GF(2^n)
virtual DecodingResult RecoverMessage(byte *recoveredMessage, const byte *nonrecoverableMessage, size_t nonrecoverableMessageLength, const byte *signature, size_t signatureLength) const
recover a message from its signature
virtual unsigned int EphemeralPublicKeyLength() const =0
return length of ephemeral public keys in this domain
const CryptoMaterial & GetMaterial() const
returns a const reference to the crypto material used by this object
virtual size_t MaxRecoverableLengthFromSignatureLength(size_t signatureLength) const =0
length of longest message that can be recovered from a signature of given length, or 0 if this signat...
const NameValuePairs & g_nullNameValuePairs
empty set of name-value pairs
virtual size_t SignMessage(RandomNumberGenerator &rng, const byte *message, size_t messageLen, byte *signature) const
sign a message
virtual bool Agree(byte *agreedValue, const byte *privateKey, const byte *otherPublicKey, bool validateOtherPublicKey=true) const =0
derive agreed value from your private key and couterparty's public key, return false in case of failu...
virtual bool VerifyMessage(const byte *message, size_t messageLen, const byte *signature, size_t signatureLength) const
check whether input signature is a valid signature for input message
Elliptic Curve Parameters.
"The XTR public key system" by Arjen K.
This file contains classes that implement the RSA ciphers and signature schemes as defined in PKCS #1...
interface for public-key signature verifiers
BlumBlumShub with factorization of the modulus.
virtual size_t CiphertextLength(size_t plaintextLength) const =0
calculate length of ciphertext given length of plaintext
virtual unsigned int AgreedValueLength() const =0
return length of agreed value produced
void GenerateRandomWithKeySize(RandomNumberGenerator &rng, unsigned int keySize)
calls the above function with a NameValuePairs object that just specifies "KeySize" ...
interface for domains of authenticated key agreement protocols
virtual DecodingResult Decrypt(RandomNumberGenerator &rng, const byte *ciphertext, size_t ciphertextLength, byte *plaintext, const NameValuePairs ¶meters=g_nullNameValuePairs) const =0
decrypt a byte string, and return the length of plaintext
A template implementing constructors for public key algorithm classes.