qca

hashunittest.cpp

00001 
00026 #include <QtCrypto>
00027 #include <QtTest/QtTest>
00028 #include <QFile>
00029 
00030 class HashUnitTest : public QObject
00031 {
00032     Q_OBJECT
00033 
00034 private slots:
00035     void initTestCase();
00036     void cleanupTestCase();
00037     void md2test_data();
00038     void md2test();
00039     void md4test_data();
00040     void md4test();
00041     void md5test_data();
00042     void md5test();
00043     void md5filetest();
00044     void sha0test_data();
00045     void sha0test();
00046     void sha0longtest();
00047     void sha1test_data();
00048     void sha1test();
00049     void sha1longtest();
00050     void sha224test_data();
00051     void sha224test();
00052     void sha224longtest();
00053     void sha256test_data();
00054     void sha256test();
00055     void sha256longtest();
00056     void sha384test_data();
00057     void sha384test();
00058     void sha384longtest();
00059     void sha512test_data();
00060     void sha512test();
00061     void sha512longtest();
00062     void rmd160test_data();
00063     void rmd160test();
00064     void rmd160longtest();
00065     void whirlpooltest_data();
00066     void whirlpooltest();
00067     void whirlpoollongtest();
00068 private:
00069     QCA::Initializer* m_init;
00070 };
00071 
00072 void HashUnitTest::initTestCase()
00073 {
00074     m_init = new QCA::Initializer;
00075 #include "../fixpaths.include"
00076 }
00077 
00078 void HashUnitTest::cleanupTestCase()
00079 {
00080     QCA::unloadAllPlugins();
00081     delete m_init;
00082 }
00083 
00084 void HashUnitTest::md2test_data()
00085 {
00086     // These are as specified in RFC 1319
00087     QTest::addColumn<QByteArray>("input");
00088     QTest::addColumn<QString>("expectedHash");
00089 
00090     QTest::newRow("md2()") << QByteArray("") << QString("8350e5a3e24c153df2275c9f80692773");
00091     QTest::newRow("md2(a)") << QByteArray("a") << QString("32ec01ec4a6dac72c0ab96fb34c0b5d1");
00092     QTest::newRow("md2(abc)") << QByteArray("abc")
00093                << QString("da853b0d3f88d99b30283a69e6ded6bb");
00094     QTest::newRow("md2(messageDigest)") << QByteArray("message digest")
00095                      << QString("ab4f496bfb2a530b219ff33031fe06b0");
00096     QTest::newRow("md2([a-z])") << QByteArray("abcdefghijklmnopqrstuvwxyz")
00097                  << QString("4e8ddff3650292ab5a4108c3aa47940b");
00098     QTest::newRow("md2([A-z,0-9])") << QByteArray("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789")
00099                  << QString("da33def2a42df13975352846c30338cd");
00100     QTest::newRow("md2(nums)") << QByteArray("12345678901234567890123456789012345678901234567890123456789012345678901234567890")
00101                  << QString("d5976f79d83d3a0dc9806c3c66f3efd8");
00102 }
00103 
00104 void HashUnitTest::md2test()
00105 {
00106     QStringList providersToTest;
00107     providersToTest.append("qca-ossl");
00108     // no MD2 support for libgcrypt...
00109     providersToTest.append("qca-botan");
00110     providersToTest.append("qca-nss");
00111 
00112     QFETCH(QByteArray, input);
00113     QFETCH(QString, expectedHash);
00114 
00115     foreach(QString provider, providersToTest) {
00116     if(!QCA::isSupported("md2", provider))
00117         QSKIP(QString("MD2 not supported for "+provider).toLocal8Bit(), SkipSingle);
00118     QString hashResult = QCA::Hash("md2", provider).hashToString(input);
00119     QCOMPARE( hashResult, expectedHash );
00120     }
00121 }
00122 
00123 void HashUnitTest::md4test_data()
00124 {
00125     // These are as specified in RFC 1320
00126     QTest::addColumn<QByteArray>("input");
00127     QTest::addColumn<QString>("expectedHash");
00128 
00129     QTest::newRow("md4()") << QByteArray("") << QString("31d6cfe0d16ae931b73c59d7e0c089c0");
00130     QTest::newRow("md4(a)") << QByteArray("a") << QString("bde52cb31de33e46245e05fbdbd6fb24");
00131     QTest::newRow("md4(abc)") << QByteArray("abc")
00132                << QString("a448017aaf21d8525fc10ae87aa6729d");
00133     QTest::newRow("md4(messageDigest)") << QByteArray("message digest")
00134                      << QString("d9130a8164549fe818874806e1c7014b");
00135     QTest::newRow("md4([a-z])") << QByteArray("abcdefghijklmnopqrstuvwxyz")
00136                  << QString("d79e1c308aa5bbcdeea8ed63df412da9");
00137     QTest::newRow("md4([A-z,0-9])") << QByteArray("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789")
00138                  << QString("043f8582f241db351ce627e153e7f0e4");
00139     QTest::newRow("md4(nums)") << QByteArray("12345678901234567890123456789012345678901234567890123456789012345678901234567890")
00140                 << QString("e33b4ddc9c38f2199c3e7b164fcc0536");
00141 }
00142 
00143 
00144 void HashUnitTest::md4test()
00145 {
00146     QStringList providersToTest;
00147     providersToTest.append("qca-ossl");
00148     providersToTest.append("qca-gcrypt");
00149     providersToTest.append("qca-botan");
00150     // No MD4 support for NSS?
00151     // providersToTest.append("qca-nss");
00152 
00153     QFETCH(QByteArray, input);
00154     QFETCH(QString, expectedHash);
00155 
00156     foreach(QString provider, providersToTest) {
00157     if(!QCA::isSupported("md4", provider))
00158         QWARN(QString("MD4 not supported for "+provider).toLocal8Bit());
00159     else {
00160       QString hashResult = QCA::Hash("md4", provider).hashToString(input);
00161         QCOMPARE( hashResult, expectedHash );
00162     }
00163     }
00164 }
00165 
00166 void HashUnitTest::md5test_data()
00167 {
00168     // These are as specified in RFC 1321
00169     // They also match Australian Standard (AS) 2805.1.3.2-2000 Appendix A
00170     QTest::addColumn<QByteArray>("input");
00171     QTest::addColumn<QString>("expectedHash");
00172 
00173     QTest::newRow("md5()") << QByteArray("") << QString("d41d8cd98f00b204e9800998ecf8427e");
00174     QTest::newRow("md5(a)") << QByteArray("a") << QString("0cc175b9c0f1b6a831c399e269772661");
00175     QTest::newRow("md5(abc)") << QByteArray("abc")
00176                << QString("900150983cd24fb0d6963f7d28e17f72");
00177     QTest::newRow("md5(messageDigest)") << QByteArray("message digest")
00178                      << QString("f96b697d7cb7938d525a2f31aaf161d0");
00179     QTest::newRow("md5([a-z])") << QByteArray("abcdefghijklmnopqrstuvwxyz")
00180                  << QString("c3fcd3d76192e4007dfb496cca67e13b");
00181     QTest::newRow("md5([A-z,0-9])") << QByteArray("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789")
00182                  << QString("d174ab98d277d9f5a5611c2c9f419d9f");
00183     QTest::newRow("md5(nums)") << QByteArray("12345678901234567890123456789012345678901234567890123456789012345678901234567890")
00184                     << QString("57edf4a22be3c955ac49da2e2107b67a");
00185 }
00186 
00187 void HashUnitTest::md5test()
00188 {
00189     QStringList providersToTest;
00190     providersToTest.append("qca-ossl");
00191     providersToTest.append("qca-gcrypt");
00192     providersToTest.append("qca-botan");
00193     providersToTest.append("qca-nss");
00194     providersToTest.append("qca-ipp");
00195     providersToTest.append("default");
00196 
00197     QFETCH(QByteArray, input);
00198     QFETCH(QString, expectedHash);
00199 
00200     foreach(QString provider, providersToTest) {
00201     if(!QCA::isSupported("md5", provider))
00202         QWARN(QString("MD5 not supported for "+provider).toLocal8Bit());
00203     else {
00204         QString hashResult = QCA::Hash("md5", provider).hashToString(input);
00205         QCOMPARE( hashResult, expectedHash );
00206     }
00207     }
00208 }
00209 
00210 
00211 void HashUnitTest::md5filetest()
00212 {
00213     QStringList providersToTest;
00214     providersToTest.append("qca-ossl");
00215     providersToTest.append("qca-gcrypt");
00216     providersToTest.append("qca-botan");
00217     providersToTest.append("qca-nss");
00218     providersToTest.append("qca-ipp");
00219     providersToTest.append("default");
00220 
00221     foreach(QString provider, providersToTest) {
00222     if(!QCA::isSupported("md5", provider))
00223         QWARN(QString("MD5 not supported for "+provider).toLocal8Bit());
00224     else {
00225         QFile f1( "./data/empty" );
00226         if ( f1.open( QIODevice::ReadOnly ) ) {
00227         QCA::Hash hashObj("md5", provider);
00228         hashObj.update( &f1 );
00229         QCOMPARE( QString( QCA::arrayToHex( hashObj.final().toByteArray() ) ),
00230              QString( "d41d8cd98f00b204e9800998ecf8427e" ) );
00231         } else {
00232         QWARN( "./data/empty could not be opened - do you need to create it?");
00233         }
00234 
00235         QFile f2( "./data/twobytes" );
00236         if ( f2.open( QIODevice::ReadOnly ) ) {
00237         QCA::Hash hashObj("md5", provider);
00238         hashObj.update( &f2 );
00239         QCOMPARE( QString( QCA::arrayToHex( hashObj.final().toByteArray() ) ),
00240              QString( "5fc9808ed18e442ab4164c59f151e757" ) );
00241         } else {
00242         QWARN( "./data/twobytes could not be opened - do you need to download it?");
00243         }
00244 
00245 
00246         QFile f3( "./data/twohundredbytes" );
00247         if ( f3.open( QIODevice::ReadOnly ) ) {
00248         QCA::Hash hashObj("md5", provider);
00249         hashObj.update( &f3 );
00250         QCOMPARE( QString( QCA::arrayToHex( hashObj.final().toByteArray() ) ),
00251              QString( "b91c1f114d942520ecdf7e84e580cda3" ) );
00252         } else {
00253         QWARN( "./data/twohundredbytes could not be opened - do you need to download it?");
00254         }
00255 
00256     }
00257     }
00258 }
00259 
00260 void HashUnitTest::sha0test_data()
00261 {
00262     // These are extracted from OpenOffice.org 1.1.2, in sal/workben/t_digest.c
00263     // Check FIPS 180-1?
00264     QTest::addColumn<QByteArray>("input");
00265     QTest::addColumn<QString>("expectedHash");
00266 
00267     QTest::newRow("sha0(abc)") << QByteArray("abc") << QString("0164b8a914cd2a5e74c4f7ff082c4d97f1edf880");
00268     QTest::newRow("sha0(abc)") << QByteArray("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq")
00269                 << QString("d2516ee1acfa5baf33dfc1c471e438449ef134c8");
00270 }
00271 
00272 void HashUnitTest::sha0test()
00273 {
00274     QStringList providersToTest;
00275     providersToTest.append("qca-ossl");
00276     // No SHA0 for botan, gcrypt or nss
00277 
00278     QFETCH(QByteArray, input);
00279     QFETCH(QString, expectedHash);
00280 
00281     foreach(QString provider, providersToTest) {
00282     if(!QCA::isSupported("sha0", provider))
00283         QWARN(QString("SHA0 not supported for "+provider).toLocal8Bit());
00284     else {
00285         QString hashResult = QCA::Hash("sha0", provider).hashToString(input);
00286         QCOMPARE( hashResult, expectedHash );
00287     }
00288     }
00289 }
00290 
00291 void HashUnitTest::sha0longtest()
00292 {
00293     QByteArray fillerString;
00294     fillerString.fill('a', 1000);
00295 
00296     // This test extracted from OpenOffice.org 1.1.2, in sal/workben/t_digest.c
00297 
00298     QStringList providersToTest;
00299     providersToTest.append("qca-ossl");
00300     // No SHA0 for botan, gcrypt or nss
00301 
00302     foreach(QString provider, providersToTest) {
00303     if(!QCA::isSupported("sha0", provider))
00304         QWARN(QString("SHA0 not supported for "+provider).toLocal8Bit());
00305     else {
00306         QCA::Hash shaHash("sha0", provider);
00307         for (int i=0; i<1000; i++)
00308         shaHash.update(fillerString);
00309         QCOMPARE( QString(QCA::arrayToHex(shaHash.final().toByteArray())),
00310              QString("3232affa48628a26653b5aaa44541fd90d690603" ) );
00311 
00312         shaHash.clear();
00313         for (int i=0; i<1000; i++)
00314         shaHash.update(fillerString);
00315         QCOMPARE( QString(QCA::arrayToHex(shaHash.final().toByteArray())),
00316              QString("3232affa48628a26653b5aaa44541fd90d690603" ) );
00317     }
00318     }
00319 }
00320 
00321 void HashUnitTest::sha1test_data()
00322 {
00323     // These are as specified in FIPS 180-2. Matches RFC3174
00324     // Some additions from Australian Standard (AS) 2805.13.3-2000
00325     QTest::addColumn<QByteArray>("input");
00326     QTest::addColumn<QString>("expectedHash");
00327 
00328     // FIPS 180-2, Appendix A.1
00329     QTest::newRow("sha1(abc)") << QByteArray("abc") << QString("a9993e364706816aba3e25717850c26c9cd0d89d");
00330 
00331     // FIPS 180-2, Appendix A.2
00332     QTest::newRow("sha1(a-q)") << QByteArray("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq")
00333                 << QString("84983e441c3bd26ebaae4aa1f95129e5e54670f1");
00334 
00335     // AS 2805.13.3-200 Appendix A
00336     // also has some duplicates from FIPS 180-2
00337     QTest::newRow("sha1()") << QByteArray("") << QString("da39a3ee5e6b4b0d3255bfef95601890afd80709");
00338     QTest::newRow("sha1(a)") << QByteArray("a") << QString("86f7e437faa5a7fce15d1ddcb9eaeaea377667b8");
00339     QTest::newRow("sha1(a-z)") << QByteArray("abcdefghijklmnopqrstuvwxyz")
00340                 << QString("32d10c7b8cf96570ca04ce37f2a19d84240d3a89");
00341 }
00342 
00343 void HashUnitTest::sha1test()
00344 {
00345     QStringList providersToTest;
00346     providersToTest.append("qca-ossl");
00347     providersToTest.append("qca-botan");
00348     providersToTest.append("qca-gcrypt");
00349     providersToTest.append("qca-nss");
00350     providersToTest.append("qca-ipp");
00351     providersToTest.append("default");
00352 
00353     QFETCH(QByteArray, input);
00354     QFETCH(QString, expectedHash);
00355 
00356     foreach(QString provider, providersToTest) {
00357     if(!QCA::isSupported("sha1", provider))
00358         QWARN(QString("SHA1 not supported for "+provider).toLocal8Bit());
00359     else {
00360         QString hashResult = QCA::Hash("sha1", provider).hashToString(input);
00361         QCOMPARE( hashResult, expectedHash );
00362     }
00363     }
00364 }
00365 
00366 void HashUnitTest::sha1longtest()
00367 {
00368     QStringList providersToTest;
00369     providersToTest.append("qca-ossl");
00370     providersToTest.append("qca-botan");
00371     providersToTest.append("qca-gcrypt");
00372     providersToTest.append("qca-nss");
00373     providersToTest.append("qca-ipp");
00374     providersToTest.append("default");
00375 
00376     foreach(QString provider, providersToTest) {
00377     if(!QCA::isSupported("sha1", provider))
00378         QWARN(QString("SHA1 not supported for "+provider).toLocal8Bit());
00379     else {
00380         // QTime t;
00381         // t.start();
00382         QByteArray fillerString;
00383         fillerString.fill('a', 1000);
00384 
00385         // This test extracted from OpenOffice.org 1.1.2, in sal/workben/t_digest.c
00386         // It basically reflects FIPS 180-2, Appendix A.3
00387         // Also as per AS 2805.13.3-2000 Appendix A
00388         QCA::Hash shaHash("sha1", provider);
00389         for (int i=0; i<1000; i++)
00390         shaHash.update(fillerString);
00391         QCOMPARE( QString(QCA::arrayToHex(shaHash.final().toByteArray())),
00392              QString("34aa973cd4c4daa4f61eeb2bdbad27316534016f") );
00393 
00394         QFile f1( "./data/empty" );
00395         if ( f1.open( QIODevice::ReadOnly ) ) {
00396         QCA::Hash hashObj("sha1", provider);
00397         hashObj.update( &f1 );
00398         QCOMPARE( QString( QCA::arrayToHex( hashObj.final().toByteArray() ) ),
00399              QString( "da39a3ee5e6b4b0d3255bfef95601890afd80709" ) );
00400         } else {
00401         QWARN( "./data/empty could not be opened - do you need to create it?");
00402         }
00403 
00404         QFile f2( "./data/twobytes" );
00405         if ( f2.open( QIODevice::ReadOnly ) ) {
00406         QCA::Hash hashObj("sha1", provider);
00407         hashObj.update( &f2 );
00408         QCOMPARE( QString( QCA::arrayToHex( hashObj.final().toByteArray() ) ),
00409              QString( "efbd6de3c51ca16094391e837bf52f7452593e5c" ) );
00410         } else {
00411         QWARN( "./data/twobytes could not be opened - do you need to download it?");
00412         }
00413 
00414         QFile f3( "./data/twohundredbytes" );
00415         if ( f3.open( QIODevice::ReadOnly ) ) {
00416         QCA::Hash hashObj("sha1", provider);
00417         hashObj.update( &f3 );
00418         QCOMPARE( QString( QCA::arrayToHex( hashObj.final().toByteArray() ) ),
00419              QString( "d636519dfb18d913acbe69fc3ee5a4c7ac870297" ) );
00420         } else {
00421         QWARN( "./data/twohundredbytes could not be opened - do you need to download it?");
00422         }
00423 
00424     }
00425     }
00426 }
00427 
00428 void HashUnitTest::sha224test_data()
00429 {
00430     QTest::addColumn<QByteArray>("input");
00431     QTest::addColumn<QString>("expectedHash");
00432 
00433     // These are as specified in FIPS 180-2, change notice 1
00434 
00435     // FIPS 180-2, Appendix B.1
00436     QTest::newRow("sha224(abc)") << QByteArray("abc") << QString("23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7");
00437 
00438     // FIPS 180-2, Appendix B.2
00439     QTest::newRow("sha224(aq)") << QByteArray("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq")
00440                   << QString("75388b16512776cc5dba5da1fd890150b0c6455cb4f58b1952522525");
00441 }
00442 
00443 void HashUnitTest::sha224test()
00444 {
00445     QStringList providersToTest;
00446     providersToTest.append("qca-ossl");
00447     providersToTest.append("qca-gcrypt");
00448     providersToTest.append("qca-ipp");
00449 
00450     QFETCH(QByteArray, input);
00451     QFETCH(QString, expectedHash);
00452 
00453     foreach(QString provider, providersToTest) {
00454     if(!QCA::isSupported("sha224", provider))
00455         QWARN(QString("SHA224 not supported for "+provider).toLocal8Bit());
00456     else {
00457         QString hashResult = QCA::Hash("sha224", provider).hashToString(input);
00458         QCOMPARE( hashResult, expectedHash );
00459     }
00460     }
00461 }
00462 
00463 
00464 void HashUnitTest::sha224longtest()
00465 {
00466     QByteArray fillerString;
00467     fillerString.fill('a', 1000);
00468 
00469     QStringList providersToTest;
00470     providersToTest.append("qca-ossl");
00471     providersToTest.append("qca-gcrypt");
00472     providersToTest.append("qca-ipp");
00473 
00474     foreach(QString provider, providersToTest) {
00475     if(!QCA::isSupported("sha224", provider))
00476         QWARN(QString("SHA224 not supported for "+provider).toLocal8Bit());
00477     else {
00478         QCA::Hash shaHash("sha224", provider);
00479 
00480         // This basically reflects FIPS 180-2, change notice 1, section 3
00481         for (int i=0; i<1000; i++)
00482         shaHash.update(fillerString);
00483         QCOMPARE( QString(QCA::arrayToHex(shaHash.final().toByteArray())),
00484              QString("20794655980c91d8bbb4c1ea97618a4bf03f42581948b2ee4ee7ad67") );
00485 
00486         shaHash.clear();
00487         for (int i=0; i<1000; i++)
00488         shaHash.update(fillerString);
00489         QCOMPARE( QString(QCA::arrayToHex(shaHash.final().toByteArray())),
00490              QString("20794655980c91d8bbb4c1ea97618a4bf03f42581948b2ee4ee7ad67") );
00491     }
00492     }
00493 }
00494 
00495 void HashUnitTest::sha256test_data()
00496 {
00497     QTest::addColumn<QByteArray>("input");
00498     QTest::addColumn<QString>("expectedHash");
00499 
00500     // These are as specified in FIPS 180-2
00501 
00502     // FIPS 180-2, Appendix B.1
00503     QTest::newRow("sha256(abc)") << QByteArray("abc") << QString("ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad");
00504 
00505     // FIPS 180-2, Appendix B.2
00506     QTest::newRow("sha256(abc)") << QByteArray("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq")
00507                   << QString("248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1");
00508 }
00509 
00510 void HashUnitTest::sha256test()
00511 {
00512     QStringList providersToTest;
00513     providersToTest.append("qca-ossl");
00514     providersToTest.append("qca-gcrypt");
00515     providersToTest.append("qca-botan");
00516     providersToTest.append("qca-nss");
00517     providersToTest.append("qca-ipp");
00518 
00519     QFETCH(QByteArray, input);
00520     QFETCH(QString, expectedHash);
00521 
00522     foreach(QString provider, providersToTest) {
00523     if(!QCA::isSupported("sha256", provider))
00524         QWARN(QString("SHA256 not supported for "+provider).toLocal8Bit());
00525     else {
00526         QString hashResult = QCA::Hash("sha256", provider).hashToString(input);
00527         QCOMPARE( hashResult, expectedHash );
00528     }
00529     }
00530 }
00531 
00532 void HashUnitTest::sha256longtest()
00533 {
00534     QByteArray fillerString;
00535     fillerString.fill('a', 1000);
00536 
00537     QStringList providersToTest;
00538     providersToTest.append("qca-gcrypt");
00539     providersToTest.append("qca-botan");
00540     providersToTest.append("qca-nss");
00541     providersToTest.append("qca-ipp");
00542 
00543     foreach(QString provider, providersToTest) {
00544     if(!QCA::isSupported("sha256", provider))
00545         QWARN(QString("SHA256 not supported for "+provider).toLocal8Bit());
00546     else {
00547         QCA::Hash shaHash("sha256", provider);
00548 
00549         // This basically reflects FIPS 180-2, change notice 1, section 3
00550         for (int i=0; i<1000; i++)
00551         shaHash.update(fillerString);
00552         QCOMPARE( QString(QCA::arrayToHex(shaHash.final().toByteArray())),
00553              QString("cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0") );
00554 
00555 
00556         shaHash.clear();
00557         for (int i=0; i<1000; i++)
00558         shaHash.update(fillerString);
00559         QCOMPARE( QString(QCA::arrayToHex(shaHash.final().toByteArray())),
00560              QString("cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0") );
00561     }
00562     }
00563 }
00564 
00565 
00566 void HashUnitTest::sha384test_data()
00567 {
00568     QTest::addColumn<QByteArray>("input");
00569     QTest::addColumn<QString>("expectedHash");
00570 
00571     // These are as specified in FIPS 180-2, and from Aaron Gifford's SHA2 tests
00572 
00573     // FIPS 180-2, Appendix B.1
00574     QTest::newRow("sha384(abc)") << QByteArray("abc")
00575                   << QString("cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed8086072ba1e7cc2358baeca134c825a7");
00576 
00577     // FIPS 180-2, Appendix B.2
00578     QTest::newRow("sha384(a-u)") << QByteArray("abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu")
00579                   << QString("09330c33f71147e83d192fc782cd1b4753111b173b3b05d22fa08086e3b0f712fcc7c71a557e2db966c3e9fa91746039");
00580 
00581     // Aaron Gifford, vector002.info
00582     QTest::newRow("sha384(a-q)") << QByteArray("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq")
00583                   << QString("3391fdddfc8dc7393707a65b1b4709397cf8b1d162af05abfe8f450de5f36bc6b0455a8520bc4e6f5fe95b1fe3c8452b");
00584 
00585 
00586 }
00587 
00588 void HashUnitTest::sha384test()
00589 {
00590     QStringList providersToTest;
00591     providersToTest.append("qca-ossl");
00592     providersToTest.append("qca-gcrypt");
00593     providersToTest.append("qca-botan");
00594     providersToTest.append("qca-nss");
00595     providersToTest.append("qca-ipp");
00596 
00597     QFETCH(QByteArray, input);
00598     QFETCH(QString, expectedHash);
00599 
00600     foreach(QString provider, providersToTest) {
00601     if(!QCA::isSupported("sha384", provider))
00602         QWARN(QString("SHA384 not supported for "+provider).toLocal8Bit());
00603     else {
00604         QString hashResult = QCA::Hash("sha384", provider).hashToString(input);
00605         QCOMPARE( hashResult, expectedHash );
00606     }
00607     }
00608 }
00609 
00610 void HashUnitTest::sha384longtest()
00611 {
00612     QByteArray fillerString;
00613     fillerString.fill('a', 1000);
00614 
00615     QStringList providersToTest;
00616     providersToTest.append("qca-ossl");
00617     providersToTest.append("qca-gcrypt");
00618     providersToTest.append("qca-botan");
00619     providersToTest.append("qca-nss");
00620     providersToTest.append("qca-ipp");
00621 
00622     foreach(QString provider, providersToTest) {
00623     if(!QCA::isSupported("sha384", provider))
00624         QWARN(QString("SHA384 not supported for "+provider).toLocal8Bit());
00625     else {
00626         // QTime t;
00627         // t.start();
00628         QCA::Hash shaHash("sha384", provider);
00629 
00630         // This basically reflects FIPS 180-2, change notice 1, section 3
00631         for (int i=0; i<1000; i++)
00632         shaHash.update(fillerString);
00633         QCOMPARE( QString(QCA::arrayToHex(shaHash.final().toByteArray())),
00634              QString("9d0e1809716474cb086e834e310a4a1ced149e9c00f248527972cec5704c2a5b07b8b3dc38ecc4ebae97ddd87f3d8985") );
00635 
00636 
00637         shaHash.clear();
00638         for (int i=0; i<1000; i++)
00639         shaHash.update(fillerString);
00640         QCOMPARE( QString(QCA::arrayToHex(shaHash.final().toByteArray())),
00641              QString("9d0e1809716474cb086e834e310a4a1ced149e9c00f248527972cec5704c2a5b07b8b3dc38ecc4ebae97ddd87f3d8985") );
00642         // qDebug() << "SHA384: " << provider << " elapsed " << t.elapsed();
00643     }
00644     }
00645 }
00646 
00647 
00648 // These are as specified in FIPS 180-2, and from Aaron Gifford's SHA2 tests
00649 void HashUnitTest::sha512test_data()
00650 {
00651     QTest::addColumn<QByteArray>("input");
00652     QTest::addColumn<QString>("expectedHash");
00653 
00654     // FIPS 180-2, Appendix C.1
00655     QTest::newRow("sha512(abc)") << QByteArray("abc")
00656                   << QString("ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f");
00657     // FIPS 180-2, Appendix C.2
00658     QTest::newRow("sha512(a-u)") << QByteArray("abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu")
00659                   << QString("8e959b75dae313da8cf4f72814fc143f8f7779c6eb9f7fa17299aeadb6889018501d289e4900f7e4331b99dec4b5433ac7d329eeb6dd26545e96e55b874be909");
00660 
00661     // Aaron Gifford, vector002.info
00662     QTest::newRow("sha512(a-q)") << QByteArray("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq")
00663                   << QString("204a8fc6dda82f0a0ced7beb8e08a41657c16ef468b228a8279be331a703c33596fd15c13b1b07f9aa1d3bea57789ca031ad85c7a71dd70354ec631238ca3445");
00664 }
00665 
00666 void HashUnitTest::sha512test()
00667 {
00668     QStringList providersToTest;
00669     providersToTest.append("qca-ossl");
00670     providersToTest.append("qca-gcrypt");
00671     providersToTest.append("qca-botan");
00672     providersToTest.append("qca-nss");
00673     providersToTest.append("qca-ipp");
00674 
00675     QFETCH(QByteArray, input);
00676     QFETCH(QString, expectedHash);
00677 
00678     foreach(QString provider, providersToTest) {
00679     if(!QCA::isSupported("sha512", provider))
00680         QWARN(QString("SHA512 not supported for "+provider).toLocal8Bit());
00681     else {
00682         QString hashResult = QCA::Hash("sha512", provider).hashToString(input);
00683         QCOMPARE( hashResult, expectedHash );
00684     }
00685     }
00686 }
00687 
00688 void HashUnitTest::sha512longtest()
00689 {
00690     QByteArray fillerString;
00691     fillerString.fill('a', 1000);
00692 
00693     QStringList providersToTest;
00694     providersToTest.append("qca-ossl");
00695     providersToTest.append("qca-gcrypt");
00696     providersToTest.append("qca-botan");
00697     providersToTest.append("qca-nss");
00698     providersToTest.append("qca-ipp");
00699 
00700     foreach(QString provider, providersToTest) {
00701     if(!QCA::isSupported("sha512", provider))
00702         QWARN(QString("SHA512 not supported for "+provider).toLocal8Bit());
00703     else {
00704         QCA::Hash shaHash("sha512", provider);
00705 
00706         // This basically reflects FIPS 180-2, change notice 1, section 3
00707         for (int i=0; i<1000; i++)
00708         shaHash.update(fillerString);
00709         QCOMPARE( QString(QCA::arrayToHex(shaHash.final().toByteArray())),
00710              QString("e718483d0ce769644e2e42c7bc15b4638e1f98b13b2044285632a803afa973ebde0ff244877ea60a4cb0432ce577c31beb009c5c2c49aa2e4eadb217ad8cc09b") );
00711 
00712         shaHash.clear();
00713         for (int i=0; i<1000; i++)
00714         shaHash.update(fillerString);
00715         QCOMPARE( QString(QCA::arrayToHex(shaHash.final().toByteArray())),
00716              QString("e718483d0ce769644e2e42c7bc15b4638e1f98b13b2044285632a803afa973ebde0ff244877ea60a4cb0432ce577c31beb009c5c2c49aa2e4eadb217ad8cc09b") );
00717     }
00718     }
00719 }
00720 
00721 // These are as specified in http://www.esat.kuleuven.ac.be/~bosselae/ripemd160.html
00722 // ISO/IEC 10118-3 costs a bit of money.
00723 void HashUnitTest::rmd160test_data()
00724 {
00725     QTest::addColumn<QByteArray>("input");
00726     QTest::addColumn<QString>("expectedHash");
00727 
00728     QTest::newRow("rmd160()") << QByteArray("") << QString("9c1185a5c5e9fc54612808977ee8f548b2258d31");
00729     QTest::newRow("rmd160(a)") << QByteArray("a") << QString("0bdc9d2d256b3ee9daae347be6f4dc835a467ffe");
00730     QTest::newRow("rmd160(abc)") << QByteArray("abc") << QString("8eb208f7e05d987a9b044a8e98c6b087f15a0bfc");
00731     QTest::newRow("rmd160(md)") << QByteArray("message digest") << QString("5d0689ef49d2fae572b881b123a85ffa21595f36");
00732     QTest::newRow("rmd160(a-z)") << QByteArray("abcdefghijklmnopqrstuvwxyz") << QString("f71c27109c692c1b56bbdceb5b9d2865b3708dbc");
00733     QTest::newRow("rmd160(a-q)") << QByteArray("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq")
00734                   << QString("12a053384a9c0c88e405a06c27dcf49ada62eb2b");
00735     QTest::newRow("rmd160(A-9)") << QByteArray("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789")
00736                   << QString("b0e20b6e3116640286ed3a87a5713079b21f5189");
00737     QTest::newRow("rmd160(1-0)") << QByteArray("12345678901234567890123456789012345678901234567890123456789012345678901234567890")
00738                   << QString("9b752e45573d4b39f4dbd3323cab82bf63326bfb");
00739 }
00740 
00741 
00742 void HashUnitTest::rmd160test()
00743 {
00744     QStringList providersToTest;
00745     providersToTest.append("qca-ossl");
00746     providersToTest.append("qca-gcrypt");
00747     providersToTest.append("qca-botan");
00748 
00749     QFETCH(QByteArray, input);
00750     QFETCH(QString, expectedHash);
00751 
00752     foreach(QString provider, providersToTest) {
00753     if(!QCA::isSupported("ripemd160", provider))
00754         QWARN(QString("RIPEMD160 not supported for "+provider).toLocal8Bit());
00755     else {
00756         QString hashResult = QCA::Hash("ripemd160", provider).hashToString(input);
00757         QCOMPARE( hashResult, expectedHash );
00758     }
00759     }
00760 }
00761 
00762 void HashUnitTest::rmd160longtest()
00763 {
00764     QByteArray fillerString;
00765     fillerString.fill('a', 1000);
00766 
00767     QStringList providersToTest;
00768     providersToTest.append("qca-ossl");
00769     providersToTest.append("qca-gcrypt");
00770     providersToTest.append("qca-botan");
00771 
00772     foreach(QString provider, providersToTest) {
00773     if(!QCA::isSupported("ripemd160", provider))
00774         QWARN(QString("RIPEMD160 not supported for "+provider).toLocal8Bit());
00775     else {
00776         QCA::Hash rmdHash("ripemd160", provider);
00777 
00778         // This is the "million times 'a' test"
00779         for (int i=0; i<1000; i++)
00780             rmdHash.update(fillerString);
00781         QCOMPARE( QString(QCA::arrayToHex(rmdHash.final().toByteArray())),
00782              QString("52783243c1697bdbe16d37f97f68f08325dc1528") );
00783 
00784         rmdHash.clear();
00785         for (int i=0; i<1000; i++)
00786         rmdHash.update(fillerString);
00787         QCOMPARE( QString(QCA::arrayToHex(rmdHash.final().toByteArray())),
00788              QString("52783243c1697bdbe16d37f97f68f08325dc1528") );
00789 
00790         // This is the "8 rounds of 1234567890" test.
00791         // It also ensure that we can re-use hash objects correctly.
00792         static char bindata[] = { 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x30 };
00793         QByteArray fillerArray( bindata, sizeof(bindata) ); // "1234567890"
00794         rmdHash.clear();
00795         for (int i=0; i<8; i++)
00796         rmdHash.update(fillerArray);
00797         QCOMPARE( QString(QCA::arrayToHex(rmdHash.final().toByteArray())),
00798              QString("9b752e45573d4b39f4dbd3323cab82bf63326bfb") );
00799 
00800     }
00801     }
00802 }
00803 
00804 
00805 // These are from the documentation pack at http://paginas.terra.com.br/informatica/paulobarreto/WhirlpoolPage.html
00806 void HashUnitTest::whirlpooltest_data()
00807 {
00808     QTest::addColumn<QByteArray>("input");
00809     QTest::addColumn<QString>("expectedHash");
00810 
00811     QTest::newRow("whirlpool()") << QByteArray("") << QString("19fa61d75522a4669b44e39c1d2e1726c530232130d407f89afee0964997f7a73e83be698b288febcf88e3e03c4f0757ea8964e59b63d93708b138cc42a66eb3");
00812     QTest::newRow("whirlpool(a)") << QByteArray("a") << QString("8aca2602792aec6f11a67206531fb7d7f0dff59413145e6973c45001d0087b42d11bc645413aeff63a42391a39145a591a92200d560195e53b478584fdae231a");
00813     QTest::newRow("whirlpool(abc)") << QByteArray("abc") << QString("4e2448a4c6f486bb16b6562c73b4020bf3043e3a731bce721ae1b303d97e6d4c7181eebdb6c57e277d0e34957114cbd6c797fc9d95d8b582d225292076d4eef5");
00814     QTest::newRow("whirlpool(md)") << QByteArray("message digest") << QString("378c84a4126e2dc6e56dcc7458377aac838d00032230f53ce1f5700c0ffb4d3b8421557659ef55c106b4b52ac5a4aaa692ed920052838f3362e86dbd37a8903e");
00815     QTest::newRow("whirlpool(a-k)") << QByteArray("abcdbcdecdefdefgefghfghighijhijk")
00816                   << QString("2a987ea40f917061f5d6f0a0e4644f488a7a5a52deee656207c562f988e95c6916bdc8031bc5be1b7b947639fe050b56939baaa0adff9ae6745b7b181c3be3fd");
00817     QTest::newRow("whirlpool(a-z)") << QByteArray("abcdefghijklmnopqrstuvwxyz") << QString("f1d754662636ffe92c82ebb9212a484a8d38631ead4238f5442ee13b8054e41b08bf2a9251c30b6a0b8aae86177ab4a6f68f673e7207865d5d9819a3dba4eb3b");
00818     QTest::newRow("whirlpool(A-9)") << QByteArray("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789")
00819                   << QString("dc37e008cf9ee69bf11f00ed9aba26901dd7c28cdec066cc6af42e40f82f3a1e08eba26629129d8fb7cb57211b9281a65517cc879d7b962142c65f5a7af01467");
00820     QTest::newRow("whirlpool(1-0)") << QByteArray("12345678901234567890123456789012345678901234567890123456789012345678901234567890")
00821                     << QString("466ef18babb0154d25b9d38a6414f5c08784372bccb204d6549c4afadb6014294d5bd8df2a6c44e538cd047b2681a51a2c60481e88c5a20b2c2a80cf3a9a083b");
00822 
00823 }
00824 
00825 
00826 void HashUnitTest::whirlpooltest()
00827 {
00828     QStringList providersToTest;
00829     providersToTest.append("qca-ossl");
00830 
00831     QFETCH(QByteArray, input);
00832     QFETCH(QString, expectedHash);
00833 
00834     foreach(QString provider, providersToTest) {
00835     if(!QCA::isSupported("whirlpool", provider))
00836         QWARN(QString("Whirlpool not supported for "+provider).toLocal8Bit());
00837     else {
00838         QString hashResult = QCA::Hash("whirlpool", provider).hashToString(input);
00839         QCOMPARE( hashResult, expectedHash );
00840     }
00841     }
00842 }
00843 
00844 void HashUnitTest::whirlpoollongtest()
00845 {
00846     QByteArray fillerString;
00847     fillerString.fill('a', 1000);
00848 
00849     QStringList providersToTest;
00850     providersToTest.append("qca-ossl");
00851 
00852     foreach(QString provider, providersToTest) {
00853     if(!QCA::isSupported("whirlpool", provider))
00854         QWARN(QString("Whirlpool not supported for "+provider).toLocal8Bit());
00855     else {
00856         QCA::Hash rmdHash("whirlpool", provider);
00857 
00858         // This is the "million times 'a' test"
00859         for (int i=0; i<1000; i++)
00860             rmdHash.update(fillerString);
00861         QCOMPARE( QString(QCA::arrayToHex(rmdHash.final().toByteArray())),
00862              QString("0c99005beb57eff50a7cf005560ddf5d29057fd86b20bfd62deca0f1ccea4af51fc15490eddc47af32bb2b66c34ff9ad8c6008ad677f77126953b226e4ed8b01") );
00863 
00864         rmdHash.clear();
00865         for (int i=0; i<1000; i++)
00866         rmdHash.update(fillerString);
00867         QCOMPARE( QString(QCA::arrayToHex(rmdHash.final().toByteArray())),
00868              QString("0c99005beb57eff50a7cf005560ddf5d29057fd86b20bfd62deca0f1ccea4af51fc15490eddc47af32bb2b66c34ff9ad8c6008ad677f77126953b226e4ed8b01") );
00869 
00870         // This is the "8 rounds of 1234567890" test.
00871         // It also ensure that we can re-use hash objects correctly.
00872         static char bindata[] = { 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x30 };
00873         QByteArray fillerArray( bindata, sizeof(bindata) ); // "1234567890"
00874         rmdHash.clear();
00875         for (int i=0; i<8; i++)
00876         rmdHash.update(fillerArray);
00877         QCOMPARE( QString(QCA::arrayToHex(rmdHash.final().toByteArray())),
00878              QString("466ef18babb0154d25b9d38a6414f5c08784372bccb204d6549c4afadb6014294d5bd8df2a6c44e538cd047b2681a51a2c60481e88c5a20b2c2a80cf3a9a083b") );
00879 
00880     }
00881     }
00882 }
00883 
00884 
00885 QTEST_MAIN(HashUnitTest)
00886 
00887 #include "hashunittest.moc"
00888
qca

hashunittest.cpp

qca

KDE Support
