← Back to branch summary

~zooko/cryptopp/trunk

« back to all changes in this revision

Viewing changes to validat2.cpp

  • Committer: weidai
  • Date: 2011-01-07 01:30:24 UTC
  • Revision ID: svn-v4:57ff6487-cd31-0410-9ec3-f628ee90f5f0:trunk/c5:522
fix for compiling with Clang from Marshall Clow

Show diffs side-by-side

added added

removed removed

Lines of Context:
validat2.cpp
2
2
 
3
3
#include "pch.h"
4
4
 
 
5
#define CRYPTOPP_ENABLE_NAMESPACE_WEAK 1
5
6
#include "blumshub.h"
6
7
#include "rsa.h"
7
8
#include "md2.h"
38
39
public:
39
40
        FixedRNG(BufferedTransformation &source) : m_source(source) {}
40
41
 
41
 
        byte GenerateByte()
 
42
        void GenerateBlock(byte *output, size_t size)
42
43
        {
43
 
                byte b;
44
 
                m_source.Get(b);
45
 
                return b;
 
44
                m_source.Get(output, size);
46
45
        }
47
46
 
48
47
private:
262
261
        bool pass = true, fail;
263
262
 
264
263
        {
265
 
                char *plain = "Everyone gets Friday off.";
 
264
                const char *plain = "Everyone gets Friday off.";
266
265
                byte *signature = (byte *)
267
266
                        "\x05\xfa\x6a\x81\x2f\xc7\xdf\x8b\xf4\xf2\x54\x25\x09\xe0\x3e\x84"
268
267
                        "\x6e\x11\xb9\xc6\x20\xbe\x20\x09\xef\xb4\x40\xef\xbc\xc6\x69\x21"
269
268
                        "\x69\x94\xac\x04\xf3\x41\xb5\x7d\x05\x20\x2d\x42\x8f\xb2\xa2\x7b"
270
269
                        "\x5c\x77\xdf\xd9\xb1\x5b\xfc\x3d\x55\x93\x53\x50\x34\x10\xc1\xe1";
271
270
 
272
 
                FileSource keys("rsa512a.dat", true, new HexDecoder);
273
 
                RSASSA_PKCS1v15_MD2_Signer rsaPriv(keys);
274
 
                RSASSA_PKCS1v15_MD2_Verifier rsaPub(rsaPriv);
 
271
                FileSource keys("TestData/rsa512a.dat", true, new HexDecoder);
 
272
                Weak::RSASSA_PKCS1v15_MD2_Signer rsaPriv(keys);
 
273
                Weak::RSASSA_PKCS1v15_MD2_Verifier rsaPub(rsaPriv);
275
274
 
276
275
                size_t signatureLength = rsaPriv.SignMessage(GlobalRNG(), (byte *)plain, strlen(plain), out);
277
276
                fail = memcmp(signature, out, 64) != 0;
294
293
                cout << "invalid signature verification\n";
295
294
        }
296
295
        {
297
 
                FileSource keys("rsa1024.dat", true, new HexDecoder);
 
296
                FileSource keys("TestData/rsa1024.dat", true, new HexDecoder);
298
297
                RSAES_PKCS1v15_Decryptor rsaPriv(keys);
299
298
                RSAES_PKCS1v15_Encryptor rsaPub(rsaPriv);
300
299
 
301
300
                pass = CryptoSystemValidate(rsaPriv, rsaPub) && pass;
302
301
        }
303
302
        {
 
303
                RSAES<OAEP<SHA> >::Decryptor rsaPriv(GlobalRNG(), 512);
 
304
                RSAES<OAEP<SHA> >::Encryptor rsaPub(rsaPriv);
 
305
 
 
306
                pass = CryptoSystemValidate(rsaPriv, rsaPub) && pass;
 
307
        }
 
308
        {
304
309
                byte *plain = (byte *)
305
310
                        "\x54\x85\x9b\x34\x2c\x49\xea\x2a";
306
311
                byte *encrypted = (byte *)
315
320
                bq.Put(oaepSeed, 20);
316
321
                FixedRNG rng(bq);
317
322
 
318
 
                FileSource privFile("rsa400pv.dat", true, new HexDecoder);
319
 
                FileSource pubFile("rsa400pb.dat", true, new HexDecoder);
 
323
                FileSource privFile("TestData/rsa400pv.dat", true, new HexDecoder);
 
324
                FileSource pubFile("TestData/rsa400pb.dat", true, new HexDecoder);
320
325
                RSAES_OAEP_SHA_Decryptor rsaPriv;
321
 
                rsaPriv.AccessKey().BERDecodeKey(privFile);
 
326
                rsaPriv.AccessKey().BERDecodePrivateKey(privFile, false, 0);
322
327
                RSAES_OAEP_SHA_Encryptor rsaPub(pubFile);
323
328
 
324
329
                memset(out, 0, 50);
339
344
{
340
345
        cout << "\nDH validation suite running...\n\n";
341
346
 
342
 
        FileSource f("dh1024.dat", true, new HexDecoder());
 
347
        FileSource f("TestData/dh1024.dat", true, new HexDecoder());
343
348
        DH dh(f);
344
349
        return SimpleKeyAgreementValidate(dh);
345
350
}
348
353
{
349
354
        cout << "\nMQV validation suite running...\n\n";
350
355
 
351
 
        FileSource f("mqv1024.dat", true, new HexDecoder());
 
356
        FileSource f("TestData/mqv1024.dat", true, new HexDecoder());
352
357
        MQV mqv(f);
353
358
        return AuthenticatedKeyAgreementValidate(mqv);
354
359
}
357
362
{
358
363
        cout << "\nLUC-DH validation suite running...\n\n";
359
364
 
360
 
        FileSource f("lucd512.dat", true, new HexDecoder());
 
365
        FileSource f("TestData/lucd512.dat", true, new HexDecoder());
361
366
        LUC_DH dh(f);
362
367
        return SimpleKeyAgreementValidate(dh);
363
368
}
366
371
{
367
372
        cout << "\nXTR-DH validation suite running...\n\n";
368
373
 
369
 
        FileSource f("xtrdh171.dat", true, new HexDecoder());
 
374
        FileSource f("TestData/xtrdh171.dat", true, new HexDecoder());
370
375
        XTR_DH dh(f);
371
376
        return SimpleKeyAgreementValidate(dh);
372
377
}
376
381
        cout << "\nElGamal validation suite running...\n\n";
377
382
        bool pass = true;
378
383
        {
379
 
                FileSource fc("elgc1024.dat", true, new HexDecoder);
 
384
                FileSource fc("TestData/elgc1024.dat", true, new HexDecoder);
380
385
                ElGamalDecryptor privC(fc);
381
386
                ElGamalEncryptor pubC(privC);
382
387
                privC.AccessKey().Precompute();
394
399
        cout << "\nDLIES validation suite running...\n\n";
395
400
        bool pass = true;
396
401
        {
397
 
                FileSource fc("dlie1024.dat", true, new HexDecoder);
 
402
                FileSource fc("TestData/dlie1024.dat", true, new HexDecoder);
398
403
                DLIES<>::Decryptor privC(fc);
399
404
                DLIES<>::Encryptor pubC(privC);
400
405
                pass = CryptoSystemValidate(privC, pubC) && pass;
417
422
        cout << "\nNR validation suite running...\n\n";
418
423
        bool pass = true;
419
424
        {
420
 
                FileSource f("nr2048.dat", true, new HexDecoder);
 
425
                FileSource f("TestData/nr2048.dat", true, new HexDecoder);
421
426
                NR<SHA>::Signer privS(f);
422
427
                privS.AccessKey().Precompute();
423
428
                NR<SHA>::Verifier pubS(privS);
440
445
 
441
446
        bool pass = true, fail;
442
447
        {
443
 
        FileSource fs("dsa512.dat", true, new HexDecoder());
 
448
        FileSource fs("TestData/dsa512.dat", true, new HexDecoder());
444
449
        GDSA<SHA>::Signer priv(fs);
445
450
        priv.AccessKey().Precompute(16);
446
451
        GDSA<SHA>::Verifier pub(priv);
482
487
        fail = pub.VerifyMessage((byte *)"xyz", 3, sig, sizeof(sig));
483
488
        pass = pass && !fail;
484
489
        }
485
 
        FileSource fs1("dsa1024.dat", true, new HexDecoder());
 
490
        FileSource fs1("TestData/dsa1024.dat", true, new HexDecoder());
486
491
        DSA::Signer priv(fs1);
487
492
        DSA::Verifier pub(priv);
488
 
        FileSource fs2("dsa1024b.dat", true, new HexDecoder());
 
493
        FileSource fs2("TestData/dsa1024b.dat", true, new HexDecoder());
489
494
        DSA::Verifier pub1(fs2);
490
495
        assert(pub.GetKey() == pub1.GetKey());
491
496
        pass = SignatureValidate(priv, pub, thorough) && pass;
498
503
        bool pass=true;
499
504
 
500
505
        {
501
 
                FileSource f("luc1024.dat", true, new HexDecoder);
 
506
                FileSource f("TestData/luc1024.dat", true, new HexDecoder);
502
507
                LUCSSA_PKCS1v15_SHA_Signer priv(f);
503
508
                LUCSSA_PKCS1v15_SHA_Verifier pub(priv);
504
509
                pass = SignatureValidate(priv, pub) && pass;
515
520
{
516
521
        cout << "\nLUC-HMP validation suite running...\n\n";
517
522
 
518
 
        FileSource f("lucs512.dat", true, new HexDecoder);
 
523
        FileSource f("TestData/lucs512.dat", true, new HexDecoder);
519
524
        LUC_HMP<SHA>::Signer privS(f);
520
525
        LUC_HMP<SHA>::Verifier pubS(privS);
521
526
        bool pass = SignatureValidate(privS, pubS);
522
527
 
523
528
        cout << "\nLUC-IES validation suite running...\n\n";
524
529
 
525
 
        FileSource fc("lucc512.dat", true, new HexDecoder);
 
530
        FileSource fc("TestData/lucc512.dat", true, new HexDecoder);
526
531
        LUC_IES<>::Decryptor privC(fc);
527
532
        LUC_IES<>::Encryptor pubC(privC);
528
533
        pass = CryptoSystemValidate(privC, pubC) && pass;
536
541
        bool pass=true;
537
542
 
538
543
        {
539
 
                FileSource f("rabi1024.dat", true, new HexDecoder);
 
544
                FileSource f("TestData/rabi1024.dat", true, new HexDecoder);
540
545
                RabinSS<PSSR, SHA>::Signer priv(f);
541
546
                RabinSS<PSSR, SHA>::Verifier pub(priv);
542
547
                pass = SignatureValidate(priv, pub) && pass;
553
558
{
554
559
        cout << "\nRW validation suite running...\n\n";
555
560
 
556
 
        FileSource f("rw1024.dat", true, new HexDecoder);
 
561
        FileSource f("TestData/rw1024.dat", true, new HexDecoder);
557
562
        RWSS<PSSR, SHA>::Signer priv(f);
558
563
        RWSS<PSSR, SHA>::Verifier pub(priv);
559
564
 
565
570
{
566
571
        cout << "\nBlumGoldwasser validation suite running...\n\n";
567
572
 
568
 
        FileSource f("blum512.dat", true, new HexDecoder);
 
573
        FileSource f("TestData/blum512.dat", true, new HexDecoder);
569
574
        BlumGoldwasserPrivateKey priv(f);
570
575
        BlumGoldwasserPublicKey pub(priv);
571
576
 
609
614
        pass = SimpleKeyAgreementValidate(ecdhc) && pass;
610
615
        pass = AuthenticatedKeyAgreementValidate(ecmqvc) && pass;
611
616
 
612
 
        cout << "Testing SEC 2 recommended curves..." << endl;
 
617
        cout << "Testing SEC 2, NIST, and Brainpool recommended curves..." << endl;
613
618
        OID oid;
614
619
        while (!(oid = DL_GroupParameters_EC<ECP>::GetNextRecommendedParametersOID(oid)).m_values.empty())
615
620
        {
659
664
#if 0   // TODO: turn this back on when I make EC2N faster for pentanomial basis
660
665
        cout << "Testing SEC 2 recommended curves..." << endl;
661
666
        OID oid;
662
 
        while (!(oid = ECParameters<EC2N>::GetNextRecommendedParametersOID(oid)).m_values.empty())
 
667
        while (!(oid = DL_GroupParameters_EC<EC2N>::GetNextRecommendedParametersOID(oid)).m_values.empty())
663
668
        {
664
 
                ECParameters<EC2N> params(oid);
665
 
                bool fail = !params.ValidateParameters(GlobalRNG());
 
669
                DL_GroupParameters_EC<EC2N> params(oid);
 
670
                bool fail = !params.Validate(GlobalRNG(), 2);
666
671
                cout << (fail ? "FAILED" : "passed") << "    " << params.GetCurve().GetField().MaxElementBitLength() << " bits" << endl;
667
672
                pass = pass && !fail;
668
673
        }
735
740
                "\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"
736
741
                "\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";
737
742
 
738
 
        FileSource keys("esig1536.dat", true, new HexDecoder);
 
743
        FileSource keys("TestData/esig1536.dat", true, new HexDecoder);
739
744
        ESIGN<SHA>::Signer signer(keys);
740
745
        ESIGN<SHA>::Verifier verifier(signer);
741
746
 
749
754
        cout << "verification check against test vector\n";
750
755
 
751
756
        cout << "Generating signature key from seed..." << endl;
752
 
        InvertibleESIGNFunction priv;
753
 
        priv.GenerateRandom(GlobalRNG(), MakeParameters("Seed", ConstByteArrayParameter((const byte *)"test", 4))("KeySize", 3*512));
 
757
        signer.AccessKey().GenerateRandom(GlobalRNG(), MakeParameters("Seed", ConstByteArrayParameter((const byte *)"test", 4))("KeySize", 3*512));
 
758
        verifier = signer;
754
759
 
755
760
        fail = !SignatureValidate(signer, verifier);
756
761
        pass = pass && !fail;