qca

cipherunittest.cpp

00001 
00026 #include <QtCrypto>
00027 #include <QtTest/QtTest>
00028 
00029 class CipherUnitTest : public QObject
00030 {
00031 
00032   Q_OBJECT
00033 
00034 private slots:
00035     void initTestCase();
00036     void cleanupTestCase();
00037     void aes128_data();
00038     void aes128();
00039     void aes128_cbc_data();
00040     void aes128_cbc();
00041     void aes128_cbc_pkcs7_data();
00042     void aes128_cbc_pkcs7();
00043     void aes128_cfb_data();
00044     void aes128_cfb();
00045     void aes128_ofb_data();
00046     void aes128_ofb();
00047 
00048     void aes192_data();
00049     void aes192();
00050     void aes192_cbc_data();
00051     void aes192_cbc();
00052     void aes192_cbc_pkcs7_data();
00053     void aes192_cbc_pkcs7();
00054     void aes192_cfb_data();
00055     void aes192_cfb();
00056     void aes192_ofb_data();
00057     void aes192_ofb();
00058 
00059     void aes256_data();
00060     void aes256();
00061     void aes256_cbc_data();
00062     void aes256_cbc();
00063     void aes256_cbc_pkcs7_data();
00064     void aes256_cbc_pkcs7();
00065     void aes256_cfb_data();
00066     void aes256_cfb();
00067     void aes256_ofb_data();
00068     void aes256_ofb();
00069 
00070     void tripleDES_data();
00071     void tripleDES();
00072 
00073     void des_data();
00074     void des();
00075     void des_pkcs7_data();
00076     void des_pkcs7();
00077     void des_cbc_data();
00078     void des_cbc();
00079     void des_cbc_pkcs7_data();
00080     void des_cbc_pkcs7();
00081     void des_cfb_data();
00082     void des_cfb();
00083     void des_ofb_data();
00084     void des_ofb();
00085 
00086     void blowfish_data();
00087     void blowfish();
00088     void blowfish_cbc_data();
00089     void blowfish_cbc();
00090     void blowfish_cbc_pkcs7_data();
00091     void blowfish_cbc_pkcs7();
00092     void blowfish_cfb_data();
00093     void blowfish_cfb();
00094     void blowfish_ofb_data();
00095     void blowfish_ofb();
00096 
00097   
00098     void cast5_data();
00099     void cast5();
00100 private:
00101     QCA::Initializer* m_init;
00102 
00103 };
00104 
00105 void CipherUnitTest::initTestCase()
00106 {
00107     m_init = new QCA::Initializer;
00108 #include "../fixpaths.include"
00109 }
00110 
00111 void CipherUnitTest::cleanupTestCase()
00112 {
00113     delete m_init;
00114 }
00115 
00116 void CipherUnitTest::aes128_data()
00117 {
00118     QTest::addColumn<QString>("plainText");
00119     QTest::addColumn<QString>("cipherText");
00120     QTest::addColumn<QString>("keyText");
00121 
00122     // Not sure where this came from...
00123     QTest::newRow("mystery") << QString("506812a45f08c889b97f5980038b8359")
00124                  << QString("d8f532538289ef7d06b506a4fd5be9c9")
00125                  << QString("00010203050607080a0b0c0d0f101112");
00126 
00127     // From FIPS 197 Appendix C.1
00128     QTest::newRow("FIPS197 App C.1") << QString("00112233445566778899aabbccddeeff")
00129                      << QString("69c4e0d86a7b0430d8cdb78070b4c55a")
00130                      << QString("000102030405060708090a0b0c0d0e0f");
00131 
00132     // These are from the Botan test suite
00133     QTest::newRow("1") << QString("506812a45f08c889b97f5980038b8359")
00134                << QString("d8f532538289ef7d06b506a4fd5be9c9")
00135                << QString("00010203050607080a0b0c0d0f101112");
00136     QTest::newRow("2") << QString("5c6d71ca30de8b8b00549984d2ec7d4b")
00137                << QString("59ab30f4d4ee6e4ff9907ef65b1fb68c")
00138                << QString("14151617191a1b1c1e1f202123242526");
00139     QTest::newRow("3") << QString("53f3f4c64f8616e4e7c56199f48f21f6")
00140                << QString("bf1ed2fcb2af3fd41443b56d85025cb1")
00141                << QString("28292a2b2d2e2f30323334353738393a");
00142     QTest::newRow("4") << QString("a1eb65a3487165fb0f1c27ff9959f703")
00143                << QString("7316632d5c32233edcb0780560eae8b2")
00144                << QString("3c3d3e3f41424344464748494b4c4d4e");
00145     QTest::newRow("5") << QString("3553ecf0b1739558b08e350a98a39bfa")
00146                << QString("408c073e3e2538072b72625e68b8364b")
00147                << QString("50515253555657585a5b5c5d5f606162");
00148     QTest::newRow("6") << QString("67429969490b9711ae2b01dc497afde8")
00149                << QString("e1f94dfa776597beaca262f2f6366fea")
00150                << QString("64656667696a6b6c6e6f707173747576");
00151     QTest::newRow("7") << QString("93385c1f2aec8bed192f5a8e161dd508")
00152                << QString("f29e986c6a1c27d7b29ffd7ee92b75f1")
00153                << QString("78797a7b7d7e7f80828384858788898a");
00154     QTest::newRow("8") << QString("3e23b3bc065bcc152407e23896d77783")
00155                << QString("1959338344e945670678a5d432c90b93")
00156                << QString("54555657595a5b5c5e5f606163646566");
00157     QTest::newRow("9") << QString("79f0fba002be1744670e7e99290d8f52")
00158                << QString("e49bddd2369b83ee66e6c75a1161b394")
00159                << QString("68696a6b6d6e6f70727374757778797a");
00160     QTest::newRow("10") << QString("da23fe9d5bd63e1d72e3dafbe21a6c2a")
00161             << QString("d3388f19057ff704b70784164a74867d")
00162             << QString("7c7d7e7f81828384868788898b8c8d8e");
00163     QTest::newRow("11") << QString("e3f5698ba90b6a022efd7db2c7e6c823")
00164             << QString("23aa03e2d5e4cd24f3217e596480d1e1")
00165             << QString("a4a5a6a7a9aaabacaeafb0b1b3b4b5b6");
00166     QTest::newRow("12") << QString("bdc2691d4f1b73d2700679c3bcbf9c6e")
00167             << QString("c84113d68b666ab2a50a8bdb222e91b9")
00168             << QString("e0e1e2e3e5e6e7e8eaebecedeff0f1f2");
00169     QTest::newRow("13") << QString("ba74e02093217ee1ba1b42bd5624349a")
00170             << QString("ac02403981cd4340b507963db65cb7b6")
00171             << QString("08090a0b0d0e0f10121314151718191a");
00172     QTest::newRow("14") << QString("b5c593b5851c57fbf8b3f57715e8f680")
00173             << QString("8d1299236223359474011f6bf5088414")
00174             << QString("6c6d6e6f71727374767778797b7c7d7e");
00175 
00176 }
00177 
00178 
00179 void CipherUnitTest::aes128()
00180 {
00181     QStringList providersToTest;
00182     providersToTest.append("qca-ossl");
00183     providersToTest.append("qca-gcrypt");
00184     providersToTest.append("qca-botan");
00185     providersToTest.append("qca-nss");
00186 
00187     foreach(const QString provider, providersToTest) {
00188         if( !QCA::isSupported( "aes128-ecb", provider ) )
00189             QWARN( QString( "AES128 ECB not supported for "+provider).toLocal8Bit() );
00190         else {
00191         QFETCH( QString, plainText );
00192         QFETCH( QString, cipherText );
00193         QFETCH( QString, keyText );
00194 
00195         QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
00196         QCA::Cipher forwardCipher( QString( "aes128" ),
00197                        QCA::Cipher::ECB,
00198                        QCA::Cipher::NoPadding,
00199                        QCA::Encode,
00200                        key,
00201                        QCA::InitializationVector(),
00202                        provider );
00203 
00204         QCOMPARE( forwardCipher.blockSize(), 16 );
00205         QCOMPARE( forwardCipher.keyLength().minimum(), 16 );
00206         QCOMPARE( forwardCipher.keyLength().maximum(), 16 );
00207 
00208         QCOMPARE( QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ).toByteArray() ),
00209               cipherText );
00210         QVERIFY( forwardCipher.ok() );
00211         QCOMPARE( QCA::arrayToHex( forwardCipher.final().toByteArray() ), QString( "" ) );
00212         QVERIFY( forwardCipher.ok() );
00213 
00214         QCA::Cipher reverseCipher( QString( "aes128" ),
00215                        QCA::Cipher::ECB,
00216                        QCA::Cipher::NoPadding,
00217                        QCA::Decode,
00218                        key,
00219                        QCA::InitializationVector(),
00220                        provider );
00221 
00222         QCOMPARE( reverseCipher.blockSize(), 16 );
00223         QCOMPARE( reverseCipher.keyLength().minimum(), 16 );
00224         QCOMPARE( reverseCipher.keyLength().maximum(), 16 );
00225 
00226         QString update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ).toByteArray() );
00227         QVERIFY( reverseCipher.ok() );
00228         QCOMPARE( update, plainText.left(update.size() ) );
00229         QCOMPARE( update + QCA::arrayToHex( reverseCipher.final().toByteArray() ), plainText );
00230         QVERIFY( reverseCipher.ok() );
00231 
00232     }
00233     }
00234 }
00235 
00236 
00237 // This is from the Botan test suite
00238 void CipherUnitTest::aes128_cbc_data()
00239 {
00240     QTest::addColumn<QString>("plainText");
00241     QTest::addColumn<QString>("cipherText");
00242     QTest::addColumn<QString>("keyText");
00243     QTest::addColumn<QString>("ivText");
00244 
00245     QTest::newRow("1") << QString("6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710")
00246                << QString("7649abac8119b246cee98e9b12e9197d5086cb9b507219ee95db113a917678b273bed6b8e3c1743b7116e69e222295163ff1caa1681fac09120eca307586e1a7")
00247                << QString("2b7e151628aed2a6abf7158809cf4f3c")
00248                << QString("000102030405060708090a0b0c0d0e0f");
00249 }
00250 
00251 void CipherUnitTest::aes128_cbc()
00252 {
00253     QStringList providersToTest;
00254     providersToTest.append("qca-ossl");
00255     providersToTest.append("qca-gcrypt");
00256     providersToTest.append("qca-botan");
00257     providersToTest.append("qca-nss");
00258 
00259     foreach(const QString provider, providersToTest) {
00260         if( !QCA::isSupported( "aes128-cbc", provider ) )
00261             QWARN( QString( "AES128 CBC not supported for "+provider).toLocal8Bit() );
00262         else {
00263         QFETCH( QString, plainText );
00264         QFETCH( QString, cipherText );
00265         QFETCH( QString, keyText );
00266         QFETCH( QString, ivText );
00267 
00268         QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
00269         QCA::InitializationVector iv( QCA::hexToArray( ivText ) );
00270         QCA::Cipher forwardCipher( QString( "aes128" ),
00271                        QCA::Cipher::CBC,
00272                        QCA::Cipher::NoPadding,
00273                        QCA::Encode,
00274                        key,
00275                        iv,
00276                        provider);
00277         QString update = QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ).toByteArray() );
00278         QVERIFY( forwardCipher.ok() );
00279         QCOMPARE( update + QCA::arrayToHex( forwardCipher.final().toByteArray() ), cipherText );
00280         QVERIFY( forwardCipher.ok() );
00281 
00282         QCA::Cipher reverseCipher( QString( "aes128" ),
00283                        QCA::Cipher::CBC,
00284                        QCA::Cipher::NoPadding,
00285                        QCA::Decode,
00286                        key,
00287                        iv,
00288                        provider);
00289         update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ).toByteArray() );
00290         QVERIFY( reverseCipher.ok() );
00291         QCOMPARE( update, plainText.left(update.size() ) );
00292         QCOMPARE( update + QCA::arrayToHex( reverseCipher.final().toByteArray() ), plainText );
00293         QVERIFY( reverseCipher.ok() );
00294     }
00295     }
00296 }
00297 
00298 // These were generated using OpenSSL's enc command
00299 void CipherUnitTest::aes128_cbc_pkcs7_data()
00300 {
00301     QTest::addColumn<QString>("plainText");
00302     QTest::addColumn<QString>("cipherText");
00303     QTest::addColumn<QString>("keyText");
00304     QTest::addColumn<QString>("ivText");
00305 
00306     QTest::newRow("1") << QString("")
00307                << QString("18fe62efa4dc4b21a4127b225855b475")
00308                << QString("0123456789ABCDEF0123456789ABCDEF")
00309                << QString("00001111222233334444555566667777");
00310 
00311     QTest::newRow("2") << QString("610a")
00312                << QString("92823eab12924cd168f54d3f4baa9a4d")
00313                << QString("0123456789ABCDEF0123456789ABCDEF")
00314                << QString("00001111222233334444555566667777");
00315 
00316     QTest::newRow("3") << QString("6162636465666768696a0a")
00317                << QString("9d41b355abd61e3dfa482f3c1aeaae49")
00318                << QString("0123456789ABCDEF0123456789ABCDEF")
00319                << QString("00001111222233334444555566667777");
00320 
00321     QTest::newRow("block size - 1") << QString("6162636465666768696a6b6c6d6e0a")
00322                << QString("c86b53850815cae7ae4a6e7529a87587")
00323                << QString("0123456789ABCDEF0123456789ABCDEF")
00324                << QString("00001111222233334444555566667777");
00325 
00326     QTest::newRow("block size") << QString("6162636465666768696a6b6c6d6e310a")
00327                << QString("26fb0474b70d118f2b1d5b74e58c97bf3bb81bece1250509c5c68771ae23ceac")
00328                << QString("0123456789ABCDEF0123456789ABCDEF")
00329                << QString("00001111222233334444555566667777");
00330 
00331     QTest::newRow("block size+1") << QString("6162636465666768696a6b6c6d6e6f310a")
00332                << QString("656f5c5693741967e059149e9239452fa286ac7c86ef653182d226d543d53013")
00333                << QString("0123456789ABCDEF0123456789ABCDEF")
00334                << QString("00001111222233334444555566667777");
00335 
00336 }
00337 
00338 void CipherUnitTest::aes128_cbc_pkcs7()
00339 {
00340     QStringList providersToTest;
00341     providersToTest.append("qca-ossl");
00342     providersToTest.append("qca-gcrypt");
00343     providersToTest.append("qca-botan");
00344     providersToTest.append("qca-nss");
00345 
00346     foreach(const QString provider, providersToTest) {
00347         if( !QCA::isSupported( "aes128-cbc-pkcs7", provider ) )
00348             QWARN( QString( "AES128 CBC with PKCS7 padding not supported for "+provider).toLocal8Bit() );
00349         else {
00350         QFETCH( QString, plainText );
00351         QFETCH( QString, cipherText );
00352         QFETCH( QString, keyText );
00353         QFETCH( QString, ivText );
00354 
00355         QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
00356         QCA::InitializationVector iv( QCA::hexToArray( ivText ) );
00357         QCA::Cipher forwardCipher( QString( "aes128" ),
00358                        QCA::Cipher::CBC,
00359                        QCA::Cipher::DefaultPadding,
00360                        QCA::Encode,
00361                        key,
00362                        iv,
00363                        provider);
00364         QString update = QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ).toByteArray() );
00365         QVERIFY( forwardCipher.ok() );
00366         QCOMPARE( update + QCA::arrayToHex( forwardCipher.final().toByteArray() ), cipherText );
00367         QVERIFY( forwardCipher.ok() );
00368 
00369         QCA::Cipher reverseCipher( QString( "aes128" ),
00370                        QCA::Cipher::CBC,
00371                        QCA::Cipher::DefaultPadding,
00372                        QCA::Decode,
00373                        key,
00374                        iv,
00375                        provider);
00376         update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ).toByteArray() );
00377         QVERIFY( reverseCipher.ok() );
00378         QCOMPARE( update, plainText.left(update.size() ) );
00379         QCOMPARE( update + QCA::arrayToHex( reverseCipher.final().toByteArray() ), plainText );
00380         QVERIFY( reverseCipher.ok() );
00381     }
00382     }
00383 }
00384 
00385 // This is from the Botan test suite
00386 void CipherUnitTest::aes128_cfb_data()
00387 {
00388     QTest::addColumn<QString>("plainText");
00389     QTest::addColumn<QString>("cipherText");
00390     QTest::addColumn<QString>("keyText");
00391     QTest::addColumn<QString>("ivText");
00392 
00393     QTest::newRow("1") << QString("6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710")
00394                << QString("3b3fd92eb72dad20333449f8e83cfb4ac8a64537a0b3a93fcde3cdad9f1ce58b\
00395 26751f67a3cbb140b1808cf187a4f4dfc04b05357c5d1c0eeac4c66f9ff7f2e6")
00396                << QString("2b7e151628aed2a6abf7158809cf4f3c")
00397                << QString("000102030405060708090a0b0c0d0e0f");
00398 }
00399 
00400 void CipherUnitTest::aes128_cfb()
00401 {
00402     QStringList providersToTest;
00403     providersToTest.append("qca-ossl");
00404     providersToTest.append("qca-gcrypt");
00405     providersToTest.append("qca-botan");
00406     providersToTest.append("qca-nss");
00407 
00408     foreach(const QString provider, providersToTest) {
00409         if( !QCA::isSupported( "aes128-cfb", provider ) )
00410             QWARN( QString( "AES128 CFB not supported for "+provider).toLocal8Bit() );
00411         else {
00412         QFETCH( QString, plainText );
00413         QFETCH( QString, cipherText );
00414         QFETCH( QString, keyText );
00415         QFETCH( QString, ivText );
00416 
00417         QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
00418         QCA::InitializationVector iv( QCA::hexToArray( ivText ) );
00419         QCA::Cipher forwardCipher( QString( "aes128" ),
00420                        QCA::Cipher::CFB,
00421                        QCA::Cipher::NoPadding,
00422                        QCA::Encode,
00423                        key,
00424                        iv,
00425                        provider);
00426         QString update = QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ).toByteArray() );
00427         QVERIFY( forwardCipher.ok() );
00428         QCOMPARE( update + QCA::arrayToHex( forwardCipher.final().toByteArray() ), cipherText );
00429         QVERIFY( forwardCipher.ok() );
00430 
00431         QCA::Cipher reverseCipher( QString( "aes128" ),
00432                        QCA::Cipher::CFB,
00433                        QCA::Cipher::NoPadding,
00434                        QCA::Decode,
00435                        key,
00436                        iv,
00437                        provider);
00438         update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ).toByteArray() );
00439         QVERIFY( reverseCipher.ok() );
00440         QCOMPARE( update, plainText.left(update.size() ) );
00441         QCOMPARE( update + QCA::arrayToHex( reverseCipher.final().toByteArray() ), plainText );
00442         QVERIFY( reverseCipher.ok() );
00443     }
00444     }
00445 }
00446 
00447 // This is from the Botan test suite
00448 void CipherUnitTest::aes128_ofb_data()
00449 {
00450     QTest::addColumn<QString>("plainText");
00451     QTest::addColumn<QString>("cipherText");
00452     QTest::addColumn<QString>("keyText");
00453     QTest::addColumn<QString>("ivText");
00454 
00455     QTest::newRow("1") << QString("6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710")
00456                << QString("3b3fd92eb72dad20333449f8e83cfb4a7789508d16918f03f53c52dac54ed8259740051e9c5fecf64344f7a82260edcc304c6528f659c77866a510d9c1d6ae5e")
00457                << QString("2b7e151628aed2a6abf7158809cf4f3c")
00458                << QString("000102030405060708090a0b0c0d0e0f");
00459 }
00460 
00461 void CipherUnitTest::aes128_ofb()
00462 {
00463     QStringList providersToTest;
00464     providersToTest.append("qca-ossl");
00465     providersToTest.append("qca-gcrypt");
00466     providersToTest.append("qca-botan");
00467     providersToTest.append("qca-nss");
00468 
00469     foreach(const QString provider, providersToTest) {
00470         if( !QCA::isSupported( "aes128-ofb", provider ) )
00471             QWARN( QString( "AES128 OFB not supported for "+provider).toLocal8Bit() );
00472         else {
00473         QFETCH( QString, plainText );
00474         QFETCH( QString, cipherText );
00475         QFETCH( QString, keyText );
00476         QFETCH( QString, ivText );
00477 
00478         QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
00479         QCA::InitializationVector iv( QCA::hexToArray( ivText ) );
00480         QCA::Cipher forwardCipher( QString( "aes128" ),
00481                        QCA::Cipher::OFB,
00482                        QCA::Cipher::NoPadding,
00483                        QCA::Encode,
00484                        key,
00485                        iv,
00486                        provider);
00487         QString update = QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ).toByteArray() );
00488         QVERIFY( forwardCipher.ok() );
00489         QCOMPARE( update + QCA::arrayToHex( forwardCipher.final().toByteArray() ), cipherText );
00490         QVERIFY( forwardCipher.ok() );
00491 
00492         QCA::Cipher reverseCipher( QString( "aes128" ),
00493                        QCA::Cipher::OFB,
00494                        QCA::Cipher::NoPadding,
00495                        QCA::Decode,
00496                        key,
00497                        iv,
00498                        provider);
00499         update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ).toByteArray() );
00500         QVERIFY( reverseCipher.ok() );
00501         QCOMPARE( update, plainText.left(update.size() ) );
00502         QCOMPARE( update + QCA::arrayToHex( reverseCipher.final().toByteArray() ), plainText );
00503         QVERIFY( reverseCipher.ok() );
00504     }
00505     }
00506 }
00507 
00508 
00509 void CipherUnitTest::aes192_data()
00510 {
00511     QTest::addColumn<QString>("plainText");
00512     QTest::addColumn<QString>("cipherText");
00513     QTest::addColumn<QString>("keyText");
00514 
00515 
00516     // From FIPS 197 Appendix C.2
00517     QTest::newRow("FIPS197 App C.2") << QString("00112233445566778899aabbccddeeff")
00518                      << QString("dda97ca4864cdfe06eaf70a0ec0d7191")
00519                      << QString("000102030405060708090A0B0C0D0E0F1011121314151617");
00520 
00521     // These are from the Botan test suite
00522     QTest::newRow("1") << QString("fec1c04f529bbd17d8cecfcc4718b17f")
00523                << QString("62564c738f3efe186e1a127a0c4d3c61")
00524                << QString("4a4b4c4d4f50515254555657595a5b5c5e5f606163646566");
00525     QTest::newRow("2") << QString("32df99b431ed5dc5acf8caf6dc6ce475")
00526                << QString("07805aa043986eb23693e23bef8f3438")
00527                << QString("68696a6b6d6e6f70727374757778797a7c7d7e7f81828384");
00528     QTest::newRow("3") << QString("7fdc2b746f3f665296943b83710d1f82")
00529                << QString("df0b4931038bade848dee3b4b85aa44b")
00530                << QString("868788898b8c8d8e90919293959697989a9b9c9d9fa0a1a2");
00531     QTest::newRow("4") << QString("8fba1510a3c5b87e2eaa3f7a91455ca2")
00532                << QString("592d5fded76582e4143c65099309477c")
00533                << QString("a4a5a6a7a9aaabacaeafb0b1b3b4b5b6b8b9babbbdbebfc0");
00534     QTest::newRow("5") << QString("2c9b468b1c2eed92578d41b0716b223b")
00535                << QString("c9b8d6545580d3dfbcdd09b954ed4e92")
00536                << QString("c2c3c4c5c7c8c9cacccdcecfd1d2d3d4d6d7d8d9dbdcddde");
00537     QTest::newRow("6") << QString("0a2bbf0efc6bc0034f8a03433fca1b1a")
00538                << QString("5dccd5d6eb7c1b42acb008201df707a0")
00539                << QString("e0e1e2e3e5e6e7e8eaebecedeff0f1f2f4f5f6f7f9fafbfc");
00540     QTest::newRow("7") << QString("25260e1f31f4104d387222e70632504b")
00541                << QString("a2a91682ffeb6ed1d34340946829e6f9")
00542                << QString("fefe01010304050608090a0b0d0e0f10121314151718191a");
00543     QTest::newRow("8") << QString("c527d25a49f08a5228d338642ae65137")
00544                << QString("e45d185b797000348d9267960a68435d")
00545                << QString("1c1d1e1f21222324262728292b2c2d2e3031323335363738");
00546     QTest::newRow("9") << QString("3b49fc081432f5890d0e3d87e884a69e")
00547                << QString("45e060dae5901cda8089e10d4f4c246b")
00548                << QString("3a3b3c3d3f40414244454647494a4b4c4e4f505153545556");
00549     QTest::newRow("10") << QString("d173f9ed1e57597e166931df2754a083")
00550             << QString("f6951afacc0079a369c71fdcff45df50")
00551             << QString("58595a5b5d5e5f60626364656768696a6c6d6e6f71727374");
00552     QTest::newRow("11") << QString("8c2b7cafa5afe7f13562daeae1adede0")
00553             << QString("9e95e00f351d5b3ac3d0e22e626ddad6")
00554             << QString("767778797b7c7d7e80818283858687888a8b8c8d8f909192");
00555     QTest::newRow("12") << QString("aaf4ec8c1a815aeb826cab741339532c")
00556             << QString("9cb566ff26d92dad083b51fdc18c173c")
00557             << QString("94959697999a9b9c9e9fa0a1a3a4a5a6a8a9aaabadaeafb0");
00558     QTest::newRow("13") << QString("40be8c5d9108e663f38f1a2395279ecf")
00559             << QString("c9c82766176a9b228eb9a974a010b4fb")
00560             << QString("d0d1d2d3d5d6d7d8dadbdcdddfe0e1e2e4e5e6e7e9eaebec");
00561     QTest::newRow("14") << QString("0c8ad9bc32d43e04716753aa4cfbe351")
00562             << QString("d8e26aa02945881d5137f1c1e1386e88")
00563             << QString("2a2b2c2d2f30313234353637393a3b3c3e3f404143444546");
00564     QTest::newRow("15") << QString("1407b1d5f87d63357c8dc7ebbaebbfee")
00565             << QString("c0e024ccd68ff5ffa4d139c355a77c55")
00566             << QString("48494a4b4d4e4f50525354555758595a5c5d5e5f61626364");
00567 }
00568 
00569 
00570 void CipherUnitTest::aes192()
00571 {
00572     QStringList providersToTest;
00573     providersToTest.append("qca-ossl");
00574     providersToTest.append("qca-gcrypt");
00575     providersToTest.append("qca-botan");
00576     providersToTest.append("qca-nss");
00577 
00578     foreach(const QString provider, providersToTest) {
00579         if( !QCA::isSupported( "aes192-ecb", provider ) )
00580             QWARN( QString( "AES192 ECB not supported for "+provider).toLocal8Bit() );
00581         else {
00582         QFETCH( QString, plainText );
00583         QFETCH( QString, cipherText );
00584         QFETCH( QString, keyText );
00585 
00586         QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
00587         QCA::Cipher forwardCipher( QString( "aes192" ),
00588                        QCA::Cipher::ECB,
00589                        QCA::Cipher::NoPadding,
00590                        QCA::Encode,
00591                        key,
00592                        QCA::InitializationVector(),
00593                        provider );
00594 
00595         QCOMPARE( forwardCipher.blockSize(), 16 );
00596         QCOMPARE( forwardCipher.keyLength().minimum(), 24 );
00597         QCOMPARE( forwardCipher.keyLength().maximum(), 24 );
00598 
00599         QCOMPARE( QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ).toByteArray() ),
00600               cipherText );
00601         QVERIFY( forwardCipher.ok() );
00602         QCOMPARE( QCA::arrayToHex( forwardCipher.final().toByteArray() ), QString( "" ) );
00603         QVERIFY( forwardCipher.ok() );
00604 
00605         QCA::Cipher reverseCipher( QString( "aes192" ),
00606                        QCA::Cipher::ECB,
00607                        QCA::Cipher::NoPadding,
00608                        QCA::Decode,
00609                        key,
00610                        QCA::InitializationVector(),
00611                        provider );
00612 
00613         QCOMPARE( reverseCipher.blockSize(), 16 );
00614         QCOMPARE( reverseCipher.keyLength().minimum(), 24 );
00615         QCOMPARE( reverseCipher.keyLength().maximum(), 24 );
00616 
00617         QString update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ).toByteArray() );
00618         QVERIFY( reverseCipher.ok() );
00619         QCOMPARE( update, plainText.left(update.size() ) );
00620         QCOMPARE( update + QCA::arrayToHex( reverseCipher.final().toByteArray() ), plainText );
00621         QVERIFY( reverseCipher.ok() );
00622 
00623     }
00624     }
00625 }
00626 
00627 
00628 // This is from the Botan test suite
00629 void CipherUnitTest::aes192_cbc_data()
00630 {
00631     QTest::addColumn<QString>("plainText");
00632     QTest::addColumn<QString>("cipherText");
00633     QTest::addColumn<QString>("keyText");
00634     QTest::addColumn<QString>("ivText");
00635 
00636     QTest::newRow("1") << QString("6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710")
00637                << QString("4f021db243bc633d7178183a9fa071e8b4d9ada9ad7dedf4e5e738763f69145a571b242012fb7ae07fa9baac3df102e008b0e27988598881d920a9e64f5615cd")
00638                << QString("8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b")
00639                << QString("000102030405060708090a0b0c0d0e0f");
00640 }
00641 
00642 
00643 void CipherUnitTest::aes192_cbc()
00644 {
00645     QStringList providersToTest;
00646     providersToTest.append("qca-ossl");
00647     providersToTest.append("qca-gcrypt");
00648     providersToTest.append("qca-botan");
00649     providersToTest.append("qca-nss");
00650 
00651     foreach(const QString provider, providersToTest) {
00652         if( !QCA::isSupported( "aes192-cbc", provider ) )
00653             QWARN( QString( "AES192 CBC not supported for "+provider).toLocal8Bit() );
00654         else {
00655         QFETCH( QString, plainText );
00656         QFETCH( QString, cipherText );
00657         QFETCH( QString, keyText );
00658         QFETCH( QString, ivText );
00659 
00660         QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
00661         QCA::InitializationVector iv( QCA::hexToArray( ivText ) );
00662         QCA::Cipher forwardCipher( QString( "aes192" ),
00663                        QCA::Cipher::CBC,
00664                        QCA::Cipher::NoPadding,
00665                        QCA::Encode,
00666                        key,
00667                        iv,
00668                        provider);
00669         QString update = QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ).toByteArray() );
00670         QVERIFY( forwardCipher.ok() );
00671         QCOMPARE( update + QCA::arrayToHex( forwardCipher.final().toByteArray() ), cipherText );
00672         QVERIFY( forwardCipher.ok() );
00673 
00674         QCA::Cipher reverseCipher( QString( "aes192" ),
00675                        QCA::Cipher::CBC,
00676                        QCA::Cipher::NoPadding,
00677                        QCA::Decode,
00678                        key,
00679                        iv,
00680                        provider);
00681         update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ).toByteArray() );
00682         QVERIFY( reverseCipher.ok() );
00683         QCOMPARE( update, plainText.left(update.size() ) );
00684         QCOMPARE( update + QCA::arrayToHex( reverseCipher.final().toByteArray() ), plainText );
00685         QVERIFY( reverseCipher.ok() );
00686     }
00687     }
00688 }
00689 
00690 // These were generated using OpenSSL's enc command
00691 void CipherUnitTest::aes192_cbc_pkcs7_data()
00692 {
00693     QTest::addColumn<QString>("plainText");
00694     QTest::addColumn<QString>("cipherText");
00695     QTest::addColumn<QString>("keyText");
00696     QTest::addColumn<QString>("ivText");
00697 
00698     QTest::newRow("1") << QString("")
00699                << QString("49c1da70f461d1bb5147ded60f0f01ef")
00700                << QString("0123456789ABCDEF0123456789ABCDEF0011223344556677")
00701                << QString("00001111222233334444555566667777");
00702 
00703     QTest::newRow("2") << QString("610a")
00704                << QString("42e5a030df8b6bf896899853744e480c")
00705                << QString("0123456789ABCDEF0123456789ABCDEF0011223344556677")
00706                << QString("00001111222233334444555566667777");
00707 
00708     QTest::newRow("3") << QString("6162636465666768696a0a")
00709                << QString("160a3b6ff48d6850906ffa6b8291f511")
00710                << QString("0123456789ABCDEF0123456789ABCDEF0011223344556677")
00711                << QString("00001111222233334444555566667777");
00712 
00713     QTest::newRow("block size - 1") << QString("6162636465666768696a6b6c6d6e0a")
00714                     << QString("b113c5aec849e49dc8487f66ce29bab0")
00715                << QString("0123456789ABCDEF0123456789ABCDEF0011223344556677")
00716                << QString("00001111222233334444555566667777");
00717 
00718     QTest::newRow("block size") << QString("6162636465666768696a6b6c6d6e310a")
00719                << QString("80c4a001f93c468b7dd3525cc46020b470e3ac39a13be57ab18c7903d121a266")
00720                << QString("0123456789ABCDEF0123456789ABCDEF0011223344556677")
00721                << QString("00001111222233334444555566667777");
00722 
00723     QTest::newRow("block size+1") << QString("6162636465666768696a6b6c6d6e6f310a")
00724                   << QString("f0f9982e4118287cda37062f5acfd7b2f27741ddac7bd3882c7b4e4872b81047")
00725                   << QString("0123456789ABCDEF0123456789ABCDEF0011223344556677")
00726                   << QString("00001111222233334444555566667777");
00727 
00728 }
00729 
00730 void CipherUnitTest::aes192_cbc_pkcs7()
00731 {
00732     QStringList providersToTest;
00733     providersToTest.append("qca-ossl");
00734     providersToTest.append("qca-gcrypt");
00735     providersToTest.append("qca-botan");
00736     providersToTest.append("qca-nss");
00737 
00738     foreach(const QString provider, providersToTest) {
00739         if( !QCA::isSupported( "aes192-cbc-pkcs7", provider ) )
00740             QWARN( QString( "AES192 CBC with PKCS7 padding not supported for "+provider).toLocal8Bit() );
00741         else {
00742         QFETCH( QString, plainText );
00743         QFETCH( QString, cipherText );
00744         QFETCH( QString, keyText );
00745         QFETCH( QString, ivText );
00746 
00747         QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
00748         QCA::InitializationVector iv( QCA::hexToArray( ivText ) );
00749         QCA::Cipher forwardCipher( QString( "aes192" ),
00750                        QCA::Cipher::CBC,
00751                        QCA::Cipher::DefaultPadding,
00752                        QCA::Encode,
00753                        key,
00754                        iv,
00755                        provider);
00756         QString update = QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ).toByteArray() );
00757         QVERIFY( forwardCipher.ok() );
00758         QCOMPARE( update + QCA::arrayToHex( forwardCipher.final().toByteArray() ), cipherText );
00759         QVERIFY( forwardCipher.ok() );
00760 
00761         QCA::Cipher reverseCipher( QString( "aes192" ),
00762                        QCA::Cipher::CBC,
00763                        QCA::Cipher::DefaultPadding,
00764                        QCA::Decode,
00765                        key,
00766                        iv,
00767                        provider);
00768         update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ).toByteArray() );
00769         QVERIFY( reverseCipher.ok() );
00770         QCOMPARE( update, plainText.left(update.size() ) );
00771         QCOMPARE( update + QCA::arrayToHex( reverseCipher.final().toByteArray() ), plainText );
00772         QVERIFY( reverseCipher.ok() );
00773     }
00774     }
00775 }
00776 
00777 
00778 // This is from the Botan test suite
00779 void CipherUnitTest::aes192_cfb_data()
00780 {
00781     QTest::addColumn<QString>("plainText");
00782     QTest::addColumn<QString>("cipherText");
00783     QTest::addColumn<QString>("keyText");
00784     QTest::addColumn<QString>("ivText");
00785 
00786     QTest::newRow("1") << QString("6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710")
00787                << QString("cdc80d6fddf18cab34c25909c99a417467ce7f7f81173621961a2b70171d3d7a2e1e8a1dd59b88b1c8e60fed1efac4c9c05f9f9ca9834fa042ae8fba584b09ff")
00788                << QString("8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b")
00789                << QString("000102030405060708090a0b0c0d0e0f");
00790 }
00791 
00792 void CipherUnitTest::aes192_cfb()
00793 {
00794     QStringList providersToTest;
00795     providersToTest.append("qca-ossl");
00796     providersToTest.append("qca-gcrypt");
00797     providersToTest.append("qca-botan");
00798     providersToTest.append("qca-nss");
00799 
00800     foreach(const QString provider, providersToTest) {
00801         if( !QCA::isSupported( "aes192-cfb", provider ) )
00802             QWARN( QString( "AES192 CFB not supported for "+provider).toLocal8Bit() );
00803         else {
00804         QFETCH( QString, plainText );
00805         QFETCH( QString, cipherText );
00806         QFETCH( QString, keyText );
00807         QFETCH( QString, ivText );
00808 
00809         QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
00810         QCA::InitializationVector iv( QCA::hexToArray( ivText ) );
00811         QCA::Cipher forwardCipher( QString( "aes192" ),
00812                        QCA::Cipher::CFB,
00813                        QCA::Cipher::NoPadding,
00814                        QCA::Encode,
00815                        key,
00816                        iv,
00817                        provider);
00818         QString update = QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ).toByteArray() );
00819         QVERIFY( forwardCipher.ok() );
00820         QCOMPARE( update + QCA::arrayToHex( forwardCipher.final().toByteArray() ), cipherText );
00821         QVERIFY( forwardCipher.ok() );
00822 
00823         QCA::Cipher reverseCipher( QString( "aes192" ),
00824                        QCA::Cipher::CFB,
00825                        QCA::Cipher::NoPadding,
00826                        QCA::Decode,
00827                        key,
00828                        iv,
00829                        provider);
00830         update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ).toByteArray() );
00831         QVERIFY( reverseCipher.ok() );
00832         QCOMPARE( update, plainText.left(update.size() ) );
00833         QCOMPARE( update + QCA::arrayToHex( reverseCipher.final().toByteArray() ), plainText );
00834         QVERIFY( reverseCipher.ok() );
00835     }
00836     }
00837 }
00838 
00839 // This is from the Botan test suite
00840 void CipherUnitTest::aes192_ofb_data()
00841 {
00842     QTest::addColumn<QString>("plainText");
00843     QTest::addColumn<QString>("cipherText");
00844     QTest::addColumn<QString>("keyText");
00845     QTest::addColumn<QString>("ivText");
00846 
00847     QTest::newRow("1") << QString("6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710")
00848                << QString("cdc80d6fddf18cab34c25909c99a4174fcc28b8d4c63837c09e81700c11004018d9a9aeac0f6596f559c6d4daf59a5f26d9f200857ca6c3e9cac524bd9acc92a")
00849                << QString("8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b")
00850                << QString("000102030405060708090a0b0c0d0e0f");
00851 }
00852 
00853 void CipherUnitTest::aes192_ofb()
00854 {
00855     QStringList providersToTest;
00856     providersToTest.append("qca-ossl");
00857     providersToTest.append("qca-gcrypt");
00858     providersToTest.append("qca-botan");
00859     providersToTest.append("qca-nss");
00860 
00861     foreach(const QString provider, providersToTest) {
00862         if( !QCA::isSupported( "aes192-ofb", provider ) )
00863             QWARN( QString( "AES192 OFB not supported for "+provider).toLocal8Bit() );
00864         else {
00865         QFETCH( QString, plainText );
00866         QFETCH( QString, cipherText );
00867         QFETCH( QString, keyText );
00868         QFETCH( QString, ivText );
00869 
00870         QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
00871         QCA::InitializationVector iv( QCA::hexToArray( ivText ) );
00872         QCA::Cipher forwardCipher( QString( "aes192" ),
00873                        QCA::Cipher::OFB,
00874                        QCA::Cipher::NoPadding,
00875                        QCA::Encode,
00876                        key,
00877                        iv,
00878                        provider);
00879         QString update = QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ).toByteArray() );
00880         QVERIFY( forwardCipher.ok() );
00881         QCOMPARE( update + QCA::arrayToHex( forwardCipher.final().toByteArray() ), cipherText );
00882         QVERIFY( forwardCipher.ok() );
00883 
00884         QCA::Cipher reverseCipher( QString( "aes192" ),
00885                        QCA::Cipher::OFB,
00886                        QCA::Cipher::NoPadding,
00887                        QCA::Decode,
00888                        key,
00889                        iv,
00890                        provider);
00891         update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ).toByteArray() );
00892         QVERIFY( reverseCipher.ok() );
00893         QCOMPARE( update, plainText.left(update.size() ) );
00894         QCOMPARE( update + QCA::arrayToHex( reverseCipher.final().toByteArray() ), plainText );
00895         QVERIFY( reverseCipher.ok() );
00896     }
00897     }
00898 }
00899 
00900 void CipherUnitTest::aes256_data()
00901 {
00902     QTest::addColumn<QString>("plainText");
00903     QTest::addColumn<QString>("cipherText");
00904     QTest::addColumn<QString>("keyText");
00905 
00906 
00907     // From FIPS 197 Appendix C.3
00908     QTest::newRow("FIPS197 App C.3") << QString("00112233445566778899aabbccddeeff")
00909                      << QString("8ea2b7ca516745bfeafc49904b496089")
00910                      << QString("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f");
00911 
00912     // These are from the Botan test suite
00913     QTest::newRow("1") << QString("e51aa0b135dba566939c3b6359a980c5")
00914                << QString("8cd9423dfc459e547155c5d1d522e540")
00915                << QString("e0e1e2e3e5e6e7e8eaebecedeff0f1f2f4f5f6f7f9fafbfcfefe010103040506");
00916 
00917     QTest::newRow("2") << QString("069a007fc76a459f98baf917fedf9521")
00918                << QString("080e9517eb1677719acf728086040ae3")
00919                << QString("08090a0b0d0e0f10121314151718191a1c1d1e1f21222324262728292b2c2d2e");
00920 
00921     QTest::newRow("3") << QString("726165c1723fbcf6c026d7d00b091027")
00922                << QString("7c1700211a3991fc0ecded0ab3e576b0")
00923                << QString("30313233353637383a3b3c3d3f40414244454647494a4b4c4e4f505153545556");
00924 
00925     QTest::newRow("4") << QString("d7c544de91d55cfcde1f84ca382200ce")
00926                << QString("dabcbcc855839251db51e224fbe87435")
00927                << QString("58595a5b5d5e5f60626364656768696a6c6d6e6f71727374767778797b7c7d7e");
00928 
00929     QTest::newRow("5") << QString("fed3c9a161b9b5b2bd611b41dc9da357")
00930                << QString("68d56fad0406947a4dd27a7448c10f1d")
00931                << QString("80818283858687888a8b8c8d8f90919294959697999a9b9c9e9fa0a1a3a4a5a6");
00932 
00933     QTest::newRow("6") << QString("4f634cdc6551043409f30b635832cf82")
00934                << QString("da9a11479844d1ffee24bbf3719a9925")
00935                << QString("a8a9aaabadaeafb0b2b3b4b5b7b8b9babcbdbebfc1c2c3c4c6c7c8c9cbcccdce");
00936 
00937     QTest::newRow("7") << QString("109ce98db0dfb36734d9f3394711b4e6")
00938                << QString("5e4ba572f8d23e738da9b05ba24b8d81")
00939                << QString("d0d1d2d3d5d6d7d8dadbdcdddfe0e1e2e4e5e6e7e9eaebeceeeff0f1f3f4f5f6");
00940 
00941     QTest::newRow("8") << QString("4ea6dfaba2d8a02ffdffa89835987242")
00942                << QString("a115a2065d667e3f0b883837a6e903f8")
00943                << QString("70717273757677787a7b7c7d7f80818284858687898a8b8c8e8f909193949596");
00944 
00945     QTest::newRow("9") << QString("5ae094f54af58e6e3cdbf976dac6d9ef")
00946                << QString("3e9e90dc33eac2437d86ad30b137e66e")
00947                << QString("98999a9b9d9e9fa0a2a3a4a5a7a8a9aaacadaeafb1b2b3b4b6b7b8b9bbbcbdbe");
00948 
00949     QTest::newRow("10") << QString("764d8e8e0f29926dbe5122e66354fdbe")
00950             << QString("01ce82d8fbcdae824cb3c48e495c3692")
00951             << QString("c0c1c2c3c5c6c7c8cacbcccdcfd0d1d2d4d5d6d7d9dadbdcdedfe0e1e3e4e5e6");
00952 
00953     QTest::newRow("11") << QString("3f0418f888cdf29a982bf6b75410d6a9")
00954             << QString("0c9cff163ce936faaf083cfd3dea3117")
00955             << QString("e8e9eaebedeeeff0f2f3f4f5f7f8f9fafcfdfeff01020304060708090b0c0d0e");
00956 
00957     QTest::newRow("12") << QString("e4a3e7cb12cdd56aa4a75197a9530220")
00958             << QString("5131ba9bd48f2bba85560680df504b52")
00959             << QString("10111213151617181a1b1c1d1f20212224252627292a2b2c2e2f303133343536");
00960 
00961     QTest::newRow("13") << QString("211677684aac1ec1a160f44c4ebf3f26")
00962             << QString("9dc503bbf09823aec8a977a5ad26ccb2")
00963             << QString("38393a3b3d3e3f40424344454748494a4c4d4e4f51525354565758595b5c5d5e");
00964 
00965     QTest::newRow("14") << QString("d21e439ff749ac8f18d6d4b105e03895")
00966             << QString("9a6db0c0862e506a9e397225884041d7")
00967             << QString("60616263656667686a6b6c6d6f70717274757677797a7b7c7e7f808183848586");
00968 
00969     QTest::newRow("15") << QString("d9f6ff44646c4725bd4c0103ff5552a7")
00970             << QString("430bf9570804185e1ab6365fc6a6860c")
00971             << QString("88898a8b8d8e8f90929394959798999a9c9d9e9fa1a2a3a4a6a7a8a9abacadae");
00972 
00973     QTest::newRow("16") << QString("0b1256c2a00b976250cfc5b0c37ed382")
00974             << QString("3525ebc02f4886e6a5a3762813e8ce8a")
00975             << QString("b0b1b2b3b5b6b7b8babbbcbdbfc0c1c2c4c5c6c7c9cacbcccecfd0d1d3d4d5d6");
00976 
00977     QTest::newRow("17") << QString("b056447ffc6dc4523a36cc2e972a3a79")
00978             << QString("07fa265c763779cce224c7bad671027b")
00979             << QString("d8d9dadbdddedfe0e2e3e4e5e7e8e9eaecedeeeff1f2f3f4f6f7f8f9fbfcfdfe");
00980 
00981     QTest::newRow("18") << QString("5e25ca78f0de55802524d38da3fe4456")
00982             << QString("e8b72b4e8be243438c9fff1f0e205872")
00983             << QString("00010203050607080a0b0c0d0f10111214151617191a1b1c1e1f202123242526");
00984 
00985     QTest::newRow("19") << QString("a5bcf4728fa5eaad8567c0dc24675f83")
00986             << QString("109d4f999a0e11ace1f05e6b22cbcb50")
00987             << QString("28292a2b2d2e2f30323334353738393a3c3d3e3f41424344464748494b4c4d4e");
00988 
00989     QTest::newRow("20") << QString("814e59f97ed84646b78b2ca022e9ca43")
00990             << QString("45a5e8d4c3ed58403ff08d68a0cc4029")
00991             << QString("50515253555657585a5b5c5d5f60616264656667696a6b6c6e6f707173747576");
00992 
00993     QTest::newRow("21") << QString("15478beec58f4775c7a7f5d4395514d7")
00994             << QString("196865964db3d417b6bd4d586bcb7634")
00995             << QString("78797a7b7d7e7f80828384858788898a8c8d8e8f91929394969798999b9c9d9e");
00996 }
00997 
00998 
00999 
01000 void CipherUnitTest::aes256()
01001 {
01002     QStringList providersToTest;
01003     providersToTest.append("qca-ossl");
01004     providersToTest.append("qca-gcrypt");
01005     providersToTest.append("qca-botan");
01006     providersToTest.append("qca-nss");
01007 
01008     foreach(const QString provider, providersToTest) {
01009         if( !QCA::isSupported( "aes256-ecb", provider ) )
01010             QWARN( QString( "AES256 ECB not supported for "+provider).toLocal8Bit() );
01011         else {
01012         QFETCH( QString, plainText );
01013         QFETCH( QString, cipherText );
01014         QFETCH( QString, keyText );
01015 
01016         QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
01017         QCA::Cipher forwardCipher( QString( "aes256" ),
01018                        QCA::Cipher::ECB,
01019                        QCA::Cipher::NoPadding,
01020                        QCA::Encode,
01021                        key,
01022                        QCA::InitializationVector(),
01023                        provider );
01024 
01025         QCOMPARE( forwardCipher.blockSize(), 16 );
01026         QCOMPARE( forwardCipher.keyLength().minimum(), 32 );
01027         QCOMPARE( forwardCipher.keyLength().maximum(), 32 );
01028 
01029         QCOMPARE( QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ).toByteArray() ),
01030               cipherText );
01031         QVERIFY( forwardCipher.ok() );
01032         QCOMPARE( QCA::arrayToHex( forwardCipher.final().toByteArray() ), QString( "" ) );
01033         QVERIFY( forwardCipher.ok() );
01034 
01035         QCA::Cipher reverseCipher( QString( "aes256" ),
01036                        QCA::Cipher::ECB,
01037                        QCA::Cipher::NoPadding,
01038                        QCA::Decode,
01039                        key,
01040                        QCA::InitializationVector(),
01041                        provider );
01042 
01043         QCOMPARE( reverseCipher.blockSize(), 16 );
01044         QCOMPARE( reverseCipher.keyLength().minimum(), 32 );
01045         QCOMPARE( reverseCipher.keyLength().maximum(), 32 );
01046 
01047         QString update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ).toByteArray() );
01048         QVERIFY( reverseCipher.ok() );
01049         QCOMPARE( update, plainText.left(update.size() ) );
01050         QCOMPARE( update + QCA::arrayToHex( reverseCipher.final().toByteArray() ), plainText );
01051         QVERIFY( reverseCipher.ok() );
01052 
01053     }
01054     }
01055 }
01056 
01057 
01058 // These are from the Botan test suite
01059 void CipherUnitTest::aes256_cbc_data()
01060 {
01061     QTest::addColumn<QString>("plainText");
01062     QTest::addColumn<QString>("cipherText");
01063     QTest::addColumn<QString>("keyText");
01064     QTest::addColumn<QString>("ivText");
01065 
01066     QTest::newRow("1") << QString("6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710")
01067                << QString("f58c4c04d6e5f1ba779eabfb5f7bfbd69cfc4e967edb808d679f777bc6702c7d39f23369a9d9bacfa530e26304231461b2eb05e2c39be9fcda6c19078c6a9d1b")
01068                << QString("603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4")
01069                << QString("000102030405060708090a0b0c0d0e0f");
01070 }
01071 
01072 void CipherUnitTest::aes256_cbc()
01073 {
01074     QStringList providersToTest;
01075     providersToTest.append("qca-ossl");
01076     providersToTest.append("qca-gcrypt");
01077     providersToTest.append("qca-botan");
01078     providersToTest.append("qca-nss");
01079 
01080     foreach(const QString provider, providersToTest) {
01081         if( !QCA::isSupported( "aes256-cbc", provider ) )
01082             QWARN( QString( "AES256 CBC not supported for "+provider).toLocal8Bit() );
01083         else {
01084         QFETCH( QString, plainText );
01085         QFETCH( QString, cipherText );
01086         QFETCH( QString, keyText );
01087         QFETCH( QString, ivText );
01088 
01089         QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
01090         QCA::InitializationVector iv( QCA::hexToArray( ivText ) );
01091         QCA::Cipher forwardCipher( QString( "aes256" ),
01092                        QCA::Cipher::CBC,
01093                        QCA::Cipher::NoPadding,
01094                        QCA::Encode,
01095                        key,
01096                        iv,
01097                        provider);
01098         QString update = QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ).toByteArray() );
01099         QVERIFY( forwardCipher.ok() );
01100         QCOMPARE( update + QCA::arrayToHex( forwardCipher.final().toByteArray() ), cipherText );
01101         QVERIFY( forwardCipher.ok() );
01102 
01103         QCA::Cipher reverseCipher( QString( "aes256" ),
01104                        QCA::Cipher::CBC,
01105                        QCA::Cipher::NoPadding,
01106                        QCA::Decode,
01107                        key,
01108                        iv,
01109                        provider);
01110 
01111         update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ).toByteArray() );
01112         QVERIFY( reverseCipher.ok() );
01113         QCOMPARE( update, plainText.left(update.size() ) );
01114         QCOMPARE( update + QCA::arrayToHex( reverseCipher.final().toByteArray() ), plainText );
01115         QVERIFY( reverseCipher.ok() );
01116     }
01117     }
01118 }
01119 
01120 // These were generated using OpenSSL's enc command
01121 void CipherUnitTest::aes256_cbc_pkcs7_data()
01122 {
01123     QTest::addColumn<QString>("plainText");
01124     QTest::addColumn<QString>("cipherText");
01125     QTest::addColumn<QString>("keyText");
01126     QTest::addColumn<QString>("ivText");
01127 
01128     QTest::newRow("1") << QString("")
01129                << QString("99fac653629ddb546d65ac699d7323ba")
01130                << QString("0123456789ABCDEF0123456789ABCDEF00112233445566778899AABBCCDDEEFF")
01131                << QString("00001111222233334444555566667777");
01132 
01133     QTest::newRow("2") << QString("610a")
01134                << QString("1dd0366efe719f6bf0e2c30e8cc168fd")
01135                << QString("0123456789ABCDEF0123456789ABCDEF00112233445566778899AABBCCDDEEFF")
01136                << QString("00001111222233334444555566667777");
01137 
01138     QTest::newRow("3") << QString("6162636465666768696a0a")
01139                << QString("a433fb0dc673093f726d748c8f76cf0d")
01140                << QString("0123456789ABCDEF0123456789ABCDEF00112233445566778899AABBCCDDEEFF")
01141                << QString("00001111222233334444555566667777");
01142 
01143     QTest::newRow("block size - 1") << QString("6162636465666768696a6b6c6d6e0a")
01144                     << QString("b5cfa68d21ad91649eafc35dee06f007")
01145                << QString("0123456789ABCDEF0123456789ABCDEF00112233445566778899AABBCCDDEEFF")
01146                << QString("00001111222233334444555566667777");
01147 
01148     QTest::newRow("block size") << QString("6162636465666768696a6b6c6d6e310a")
01149                << QString("45c4b50e4d4433b011187983da5034fe14cf12c04cfc3bceb57a88c455491f46")
01150                << QString("0123456789ABCDEF0123456789ABCDEF00112233445566778899AABBCCDDEEFF")
01151                << QString("00001111222233334444555566667777");
01152 
01153     QTest::newRow("block size+1") << QString("6162636465666768696a6b6c6d6e6f310a")
01154                   << QString("4ef5702f0c16bbfda9b57e6e98186763325c81c99b6cdd8e4bc34dcaa82d00e9")
01155                   << QString("0123456789ABCDEF0123456789ABCDEF00112233445566778899AABBCCDDEEFF")
01156                   << QString("00001111222233334444555566667777");
01157 
01158 }
01159 
01160 void CipherUnitTest::aes256_cbc_pkcs7()
01161 {
01162     QStringList providersToTest;
01163     providersToTest.append("qca-ossl");
01164     providersToTest.append("qca-gcrypt");
01165     providersToTest.append("qca-botan");
01166     providersToTest.append("qca-nss");
01167 
01168     foreach(const QString provider, providersToTest) {
01169         if( !QCA::isSupported( "aes256-cbc-pkcs7", provider ) )
01170             QWARN( QString( "AES256 CBC with PKCS7 padding not supported for "+provider).toLocal8Bit() );
01171         else {
01172         QFETCH( QString, plainText );
01173         QFETCH( QString, cipherText );
01174         QFETCH( QString, keyText );
01175         QFETCH( QString, ivText );
01176 
01177         QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
01178         QCA::InitializationVector iv( QCA::hexToArray( ivText ) );
01179         QCA::Cipher forwardCipher( QString( "aes256" ),
01180                        QCA::Cipher::CBC,
01181                        QCA::Cipher::DefaultPadding,
01182                        QCA::Encode,
01183                        key,
01184                        iv,
01185                        provider);
01186         QString update = QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ).toByteArray() );
01187         QVERIFY( forwardCipher.ok() );
01188         QCOMPARE( update + QCA::arrayToHex( forwardCipher.final().toByteArray() ), cipherText );
01189         QVERIFY( forwardCipher.ok() );
01190 
01191         QCA::Cipher reverseCipher( QString( "aes256" ),
01192                        QCA::Cipher::CBC,
01193                        QCA::Cipher::DefaultPadding,
01194                        QCA::Decode,
01195                        key,
01196                        iv,
01197                        provider);
01198         update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ).toByteArray() );
01199         QVERIFY( reverseCipher.ok() );
01200         QCOMPARE( update, plainText.left(update.size() ) );
01201         QCOMPARE( update + QCA::arrayToHex( reverseCipher.final().toByteArray() ), plainText );
01202         QVERIFY( reverseCipher.ok() );
01203     }
01204     }
01205 }
01206 
01207 
01208 // These are from the Botan test suite
01209 void CipherUnitTest::aes256_cfb_data()
01210 {
01211     QTest::addColumn<QString>("plainText");
01212     QTest::addColumn<QString>("cipherText");
01213     QTest::addColumn<QString>("keyText");
01214     QTest::addColumn<QString>("ivText");
01215 
01216     QTest::newRow("1") << QString("6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710")
01217                << QString("dc7e84bfda79164b7ecd8486985d386039ffed143b28b1c832113c6331e5407bdf10132415e54b92a13ed0a8267ae2f975a385741ab9cef82031623d55b1e471")
01218                << QString("603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4")
01219                << QString("000102030405060708090a0b0c0d0e0f");
01220 }
01221 
01222 void CipherUnitTest::aes256_cfb()
01223 {
01224     QStringList providersToTest;
01225     providersToTest.append("qca-ossl");
01226     providersToTest.append("qca-gcrypt");
01227     providersToTest.append("qca-botan");
01228     providersToTest.append("qca-nss");
01229 
01230     foreach(const QString provider, providersToTest) {
01231         if( !QCA::isSupported( "aes256-cfb", provider ) )
01232             QWARN( QString( "AES256 CFB not supported for "+provider).toLocal8Bit() );
01233         else {
01234         QFETCH( QString, plainText );
01235         QFETCH( QString, cipherText );
01236         QFETCH( QString, keyText );
01237         QFETCH( QString, ivText );
01238 
01239         QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
01240         QCA::InitializationVector iv( QCA::hexToArray( ivText ) );
01241         QCA::Cipher forwardCipher( QString( "aes256" ),
01242                        QCA::Cipher::CFB,
01243                        QCA::Cipher::NoPadding,
01244                        QCA::Encode,
01245                        key,
01246                        iv,
01247                        provider);
01248         QString update = QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ).toByteArray() );
01249         QVERIFY( forwardCipher.ok() );
01250         QCOMPARE( update + QCA::arrayToHex( forwardCipher.final().toByteArray() ), cipherText );
01251         QVERIFY( forwardCipher.ok() );
01252 
01253         QCA::Cipher reverseCipher( QString( "aes256" ),
01254                        QCA::Cipher::CFB,
01255                        QCA::Cipher::NoPadding,
01256                        QCA::Decode,
01257                        key,
01258                        iv,
01259                        provider);
01260 
01261         QCOMPARE( QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ).toByteArray() ), plainText  );
01262         QVERIFY( reverseCipher.ok() );
01263         QCOMPARE( QCA::arrayToHex( reverseCipher.final().toByteArray() ), QString( "" ) );
01264         QVERIFY( reverseCipher.ok() );
01265     }
01266     }
01267 }
01268 
01269 void CipherUnitTest::aes256_ofb_data()
01270 {
01271     QTest::addColumn<QString>("plainText");
01272     QTest::addColumn<QString>("cipherText");
01273     QTest::addColumn<QString>("keyText");
01274     QTest::addColumn<QString>("ivText");
01275 
01276     QTest::newRow("1") << QString("6bc1bee22e409f96e93d7e117393172aae2d8a571e03ac9c9eb76fac45af8e5130c81c46a35ce411e5fbc1191a0a52eff69f2445df4f9b17ad2b417be66c3710")
01277                << QString("dc7e84bfda79164b7ecd8486985d38604febdc6740d20b3ac88f6ad82a4fb08d71ab47a086e86eedf39d1c5bba97c4080126141d67f37be8538f5a8be740e484")
01278                << QString("603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4")
01279                << QString("000102030405060708090a0b0c0d0e0f");
01280 }
01281 
01282 void CipherUnitTest::aes256_ofb()
01283 {
01284     QStringList providersToTest;
01285     providersToTest.append("qca-ossl");
01286     providersToTest.append("qca-gcrypt");
01287     providersToTest.append("qca-botan");
01288     providersToTest.append("qca-nss");
01289 
01290     foreach(const QString provider, providersToTest) {
01291         if( !QCA::isSupported( "aes256-ofb", provider ) )
01292             QWARN( QString( "AES256 OFB not supported for "+provider).toLocal8Bit() );
01293         else {
01294         QFETCH( QString, plainText );
01295         QFETCH( QString, cipherText );
01296         QFETCH( QString, keyText );
01297         QFETCH( QString, ivText );
01298 
01299         QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
01300         QCA::InitializationVector iv( QCA::hexToArray( ivText ) );
01301         QCA::Cipher forwardCipher( QString( "aes256" ),
01302                        QCA::Cipher::OFB,
01303                        QCA::Cipher::NoPadding,
01304                        QCA::Encode,
01305                        key,
01306                        iv,
01307                        provider);
01308         QString update = QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ).toByteArray() );
01309         QVERIFY( forwardCipher.ok() );
01310         QCOMPARE( update + QCA::arrayToHex( forwardCipher.final().toByteArray() ), cipherText );
01311         QVERIFY( forwardCipher.ok() );
01312 
01313         QCA::Cipher reverseCipher( QString( "aes256" ),
01314                        QCA::Cipher::OFB,
01315                        QCA::Cipher::NoPadding,
01316                        QCA::Decode,
01317                        key,
01318                        iv,
01319                        provider);
01320 
01321         QCOMPARE( QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ).toByteArray() ), plainText  );
01322         QVERIFY( reverseCipher.ok() );
01323         QCOMPARE( QCA::arrayToHex( reverseCipher.final().toByteArray() ), QString( "" ) );
01324         QVERIFY( reverseCipher.ok() );
01325     }
01326     }
01327 }
01328 
01329 void CipherUnitTest::tripleDES_data()
01330 {
01331     QTest::addColumn<QString>("plainText");
01332     QTest::addColumn<QString>("cipherText");
01333     QTest::addColumn<QString>("keyText");
01334 
01335     QTest::newRow("1") << QString("42fd443059577fa2")
01336                << QString("af37fb421f8c4095")
01337                << QString("04b915ba43feb5b604b915ba43feb5b604b915ba43feb5b6");
01338 
01339     QTest::newRow("2") << QString("736f6d6564617461")
01340                << QString("18d748e563620572")
01341                << QString("0123456789abcdef5555555555555555fedcba9876543210");
01342     QTest::newRow("3") << QString("7371756967676c65")
01343                << QString("c07d2a0fa566fa30")
01344                << QString("0352020767208217860287665908219864056abdfea93457");
01345     QTest::newRow("4") << QString("0123456789abcde7")
01346                << QString("de0b7c06ae5e0ed5")
01347                << QString("0123456789abcdeffedcba987654321089abcdef01234567");
01348     QTest::newRow("5") << QString("0123456789abcde7")
01349                << QString("7f1d0a77826b8aff")
01350                << QString("0123456789abcdeffedcba98765432100123456789abcdef");
01351     QTest::newRow("6") << QString("4115e551299a5c4b")
01352                << QString("f7a0822fc310686c")
01353                << QString("1ef743a68d629f68a5e3136c36ad7953a835cf849bb4ec3c");
01354     QTest::newRow("7") << QString("d5ab44e0fe46e1b5")
01355                << QString("02aed9bf72eca222")
01356                << QString("b7d560be49c3936728ef0bf57b602d2eb7e5c631dd7f753e");
01357     QTest::newRow("8") << QString("b4077dfdb721d88c")
01358                << QString("f76aba838b1c4372")
01359                << QString("d2d98706e9ab867647d244bdcdbcd5ef8b4dbc9cf4f35493");
01360     QTest::newRow("9") << QString("890e98ab385fa1a1")
01361                << QString("187087c77790c3b2")
01362                << QString("153b963004101d12683e8f87116001b8c5526475510b5036");
01363     QTest::newRow("10") << QString("02d5da6d5f247cd2")
01364                << QString("89fc7df1e7913163")
01365                << QString("45e4275dccc5d8b5a27993c16d9960ca939c023e2763216a");
01366     QTest::newRow("11") << QString("5af9e5a3525e3f7d")
01367                << QString("8fcc7a8bc337e484")
01368                << QString("f6c2474b33934ea76e6c841d9b1e86e37189095a895a3e5a");
01369     QTest::newRow("12") << QString("12864dde8e694bd1")
01370                << QString("5b4dde8f000a5a9b")
01371                << QString("5b4f6d3185efbae97d58ed9cc75e2bae655d2cefb2dd09cd");
01372     QTest::newRow("13") << QString("0123456789abcde7")
01373                << QString("c95744256a5ed31d")
01374                << QString("0123456789abcdef0123456789abcdef0123456789abcdef");
01375     QTest::newRow("14") << QString("68652074696d6520")
01376                << QString("6a271787ab8883f9")
01377                << QString("0123456789abcdef0123456789abcdef0123456789abcdef");
01378 
01379     QTest::newRow("15") << QString("4e6f772069732074")
01380                << QString("3fa40e8a984d4815")
01381                << QString("0123456789abcdef0123456789abcdef0123456789abcdef");
01382 
01383     // These are from the Botan test suite
01384     QTest::newRow("16") << QString("0123456789abcde7")
01385             << QString("7f1d0a77826b8aff")
01386             << QString("0123456789abcdeffedcba9876543210");
01387     QTest::newRow("17") << QString("4e6f772069732074")
01388             << QString("3fa40e8a984d4815")
01389             << QString("0123456789abcdef0123456789abcdef");
01390     QTest::newRow("18") << QString("42fd443059577fa2")
01391             << QString("af37fb421f8c4095")
01392             << QString("04b915ba43feb5b604b915ba43feb5b6");
01393     QTest::newRow("19") << QString("afa4284fcceaa61a")
01394             << QString("32527d5701d92b90")
01395             << QString("4bc59e2c68aca60767a9a4b623bbbccc");
01396     QTest::newRow("20") << QString("50b503a331d5b5cc")
01397             << QString("e46a59e18b0c41e3")
01398             << QString("b955bb7861fde77e7dc6418475457fe1");
01399     QTest::newRow("21") << QString("3404435d5df2cb47")
01400             << QString("644dd68ea73053ae")
01401             << QString("c0557629eaa72abd4c102c5dc9ce8b47");
01402     QTest::newRow("22") << QString("c7d80e955d1b6627")
01403             << QString("9fe1c5a12cce6dd9")
01404             << QString("9eaa94da916f30092e79dacdcdcc45c0");
01405     QTest::newRow("23") << QString("bdcbe8929cd0e12f")
01406             << QString("f2b6430450ab348b")
01407             << QString("a55279671807d9b71fe62a77341249f8");
01408     QTest::newRow("24") << QString("4b7a96b7051c64fc")
01409             << QString("1555f08b2de690a0")
01410             << QString("672e20826ad49c3df7579fab3752479e");
01411     QTest::newRow("25") << QString("902f4edd44eaf3c1")
01412             << QString("3ce357eba0fb3e26")
01413             << QString("0ce61ede2659b413ab9f717ae4afad3e");
01414     QTest::newRow("26") << QString("39c0f8e4c85cd70d")
01415             << QString("882de9b6d0209a58")
01416             << QString("e878020815ae517cd2808b6571eac2b4");
01417     QTest::newRow("27") << QString("f77a1947a921b209")
01418             << QString("e10dbee5615f312e")
01419             << QString("d891ca20919f06a054ba3943c7daba16");
01420     QTest::newRow("28") << QString("06d0416e0f0db7ce")
01421             << QString("0cec5d1e59d7e347")
01422             << QString("4909aed1f94eb77b6cacbcae2b25689a");
01423     QTest::newRow("29") << QString("f7bb3a396d73d8a8")
01424             << QString("f893b6b2a15d3fce")
01425             << QString("8b9a5c13b0b118a1ee35eb912866ffa6");
01426     QTest::newRow("30") << QString("bd35e3134b90ccbc")
01427             << QString("12a7af172fd0ca7f")
01428             << QString("fa7911d664326074b42e2f38e599b288");
01429     QTest::newRow("31") << QString("e046b7f5707da4fc")
01430             << QString("32b6a3fc72c7c480")
01431             << QString("406903b340b8637928fde8058bdd6710");
01432     QTest::newRow("32") << QString("58eb1dc16c482213")
01433             << QString("a6c6234a8bbaa116")
01434             << QString("37a2b53e2af8f6c9a73b39f919d969de");
01435     QTest::newRow("33") << QString("4bd0f4854297fbde")
01436             << QString("f4ab771861457dc6")
01437             << QString("711f2cecdb92b2e201dfefa79fa7ba2f");
01438 }
01439 
01440 // TODO: ECB-PKCS7
01441 void CipherUnitTest::tripleDES()
01442 {
01443     QStringList providersToTest;
01444     providersToTest.append("qca-ossl");
01445     // providersToTest.append("qca-gcrypt");
01446     providersToTest.append("qca-botan");
01447     providersToTest.append("qca-nss");
01448 
01449     foreach(const QString provider, providersToTest) {
01450         if( !QCA::isSupported( "tripledes-ecb", provider ) )
01451             QWARN( QString( "Triple DES, ECB not supported for "+provider).toLocal8Bit() );
01452         else {
01453         QCA::Cipher cipherObj1( QString( "tripledes" ),
01454                     QCA::Cipher::ECB,
01455                     QCA::Cipher::NoPadding,
01456                     QCA::Encode,
01457                     QCA::SymmetricKey( 24 ),
01458                     QCA::InitializationVector(),
01459                     provider );
01460         // checking minimum is a bit hairy, because it depends on whether you are
01461         // doing 2 key or 3 key triple DES.
01462         QCOMPARE( cipherObj1.keyLength().minimum(), 16 );
01463         QCOMPARE( cipherObj1.keyLength().maximum(), 24 );
01464         QCOMPARE( cipherObj1.blockSize(), 8 );
01465 
01466         QFETCH( QString, plainText );
01467         QFETCH( QString, cipherText );
01468         QFETCH( QString, keyText );
01469 
01470         QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
01471         QCA::Cipher forwardCipher( QString( "tripledes" ),
01472                        QCA::Cipher::ECB,
01473                        QCA::Cipher::NoPadding,
01474                        QCA::Encode,
01475                        key,
01476                        QCA::InitializationVector(),
01477                        provider );
01478         QCOMPARE( QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ).toByteArray() ),
01479               QString( cipherText ) );
01480         QVERIFY( forwardCipher.ok() );
01481         QCOMPARE( QCA::arrayToHex( forwardCipher.final().toByteArray() ), QString( "" ) );
01482         QVERIFY( forwardCipher.ok() );
01483 
01484         QCA::Cipher reverseCipher( QString( "tripledes" ),
01485                        QCA::Cipher::ECB,
01486                        QCA::Cipher::NoPadding,
01487                        QCA::Decode,
01488                        key,
01489                        QCA::InitializationVector(),
01490                        provider );
01491         QString update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ).toByteArray() );
01492         QVERIFY( reverseCipher.ok() );
01493         QCOMPARE( update, plainText.left(update.size() ) );
01494         QCOMPARE( update + QCA::arrayToHex( reverseCipher.final().toByteArray() ), plainText );
01495         QVERIFY( reverseCipher.ok() );
01496     }
01497     }
01498 }
01499 
01500 // These are from the Botan test suite - its ECB mode, no padding
01501 void CipherUnitTest::des_data()
01502 {
01503     QTest::addColumn<QString>("plainText");
01504     QTest::addColumn<QString>("cipherText");
01505     QTest::addColumn<QString>("keyText");
01506 
01507     QTest::newRow("") << QString("059b5e0851cf143a") << QString("86a560f10ec6d85b") << QString("0113b970fd34f2ce");
01508     QTest::newRow("") << QString("4e6f772069732074") << QString("3fa40e8a984d4815") << QString("0123456789abcdef");
01509     QTest::newRow("") << QString("666f7220616c6c20") << QString("893d51ec4b563b53") << QString("0123456789abcdef");
01510     QTest::newRow("") << QString("68652074696d6520") << QString("6a271787ab8883f9") << QString("0123456789abcdef");
01511     QTest::newRow("") << QString("5cd54ca83def57da") << QString("7a389d10354bd271") << QString("0131d9619dc1376e");
01512     QTest::newRow("") << QString("0756d8e0774761d2") << QString("0cd3da020021dc09") << QString("0170f175468fb5e6");
01513     QTest::newRow("") << QString("1d9d5c5018f728c2") << QString("5f4c038ed12b2e41") << QString("018310dc409b26d6");
01514     QTest::newRow("") << QString("480d39006ee762f2") << QString("a1f9915541020b56") << QString("025816164629b007");
01515     QTest::newRow("") << QString("26955f6835af609a") << QString("5c513c9c4886c088") << QString("04689104c2fd3b2f");
01516     QTest::newRow("") << QString("42fd443059577fa2") << QString("af37fb421f8c4095") << QString("04b915ba43feb5b6");
01517     QTest::newRow("") << QString("0248d43806f67172") << QString("868ebb51cab4599a") << QString("07a1133e4a0b2686");
01518     QTest::newRow("") << QString("3bdd119049372802") << QString("dfd64a815caf1a0f") << QString("07a7137045da2a16");
01519     QTest::newRow("") << QString("16393bcdd6560506") << QString("9966adcfc53bf968") << QString("0a3fddc8350aff39");
01520     QTest::newRow("") << QString("dc7fc6cf0358ecc0") << QString("a47a7485661f7085") << QString("10dd6dcd5c89e151");
01521     QTest::newRow("") << QString("305532286d6f295a") << QString("63fac0d034d9f793") << QString("1c587f1c13924fef");
01522     QTest::newRow("") << QString("f786d02413c574fc") << QString("54c160d369f62ae3") << QString("1eb00767bdee584e");
01523     QTest::newRow("") << QString("6b056e18759f5cca") << QString("ef1bf03e5dfa575a") << QString("1f08260d1ac2465e");
01524     QTest::newRow("") << QString("905ea29aeea26e07") << QString("2292e9aebee6a4b6") << QString("28ee445d8a21c534");
01525     QTest::newRow("") << QString("164d5e404f275232") << QString("0a2aeeae3ff4ab77") << QString("37d06bb516cb7546");
01526     QTest::newRow("") << QString("51454b582ddf440a") << QString("7178876e01f19b2a") << QString("3849674c2602319e");
01527     QTest::newRow("") << QString("68ff9d6068c71513") << QString("84595f5b9d046132") << QString("3cde816ef9ef8edb");
01528     QTest::newRow("") << QString("762514b829bf486a") << QString("ea676b2cb7db2b7a") << QString("43297fad38e373fe");
01529     QTest::newRow("") << QString("437540c8698f3cfa") << QString("6fbf1cafcffd0556") << QString("49793ebc79b3258f");
01530     QTest::newRow("") << QString("02fe55778117f12a") << QString("5a6b612cc26cce4a") << QString("49e95d6d4ca229bf");
01531     QTest::newRow("") << QString("1f508a50adb3d6e2") << QString("470204969876604a") << QString("4bb53ecfefb38dde");
01532     QTest::newRow("") << QString("072d43a077075292") << QString("2f22e49bab7ca1ac") << QString("4fb05e1515ab73a7");
01533     QTest::newRow("") << QString("004bd6ef09176062") << QString("88bf0db6d70dee56") << QString("584023641aba6176");
01534     QTest::newRow("") << QString("5aa1d62806ae0ead") << QString("6db0f280fef2b564") << QString("5f2b51f59e781d9c");
01535     QTest::newRow("") << QString("7e1b1c6776833772") << QString("eb11cd3c72f7e90e") << QString("699c920d7ce1e0b1");
01536     QTest::newRow("") << QString("5dbfb47c5f471136") << QString("9c8b904d4d772be7") << QString("7ac2fdeee4c79746");
01537     QTest::newRow("") << QString("01a1d6d039776742") << QString("690f5b0d9a26939b") << QString("7ca110454a1a6e57");
01538     QTest::newRow("") << QString("4de2f0926cf598d7") << QString("ba107655991df529") << QString("7fc92c3098ecf14a");
01539     QTest::newRow("") << QString("f45e6819e3108559") << QString("f0c76ba556283b2f") << QString("9ab645e268430854");
01540     QTest::newRow("") << QString("51d4eaaac6d76553") << QString("bf3c6e8fd15ba861") << QString("a6b0ae88f980011a");
01541     QTest::newRow("") << QString("6a89626ea8038511") << QString("1067b36913cbcc47") << QString("bafebafafeaeeaff");
01542     QTest::newRow("") << QString("7b0313c0d3a866f9") << QString("e49e15e4f46f10e9") << QString("bb2420b5fee5a6a1");
01543     QTest::newRow("") << QString("9d4a44aefce79965") << QString("77b2ecc9278e9714") << QString("bebafbeabaffeaaf");
01544     QTest::newRow("") << QString("59bcdfc253424cb5") << QString("0a50abbbcd07061a") << QString("c38c6f20230d9ed5");
01545     QTest::newRow("") << QString("d6c059a85ee2b13e") << QString("25977533635beb5b") << QString("c6f974504d954c7e");
01546     QTest::newRow("") << QString("f9e4821dfcaa5466") << QString("48ec3a79399e9a00") << QString("cb959b7ffd94f734");
01547     QTest::newRow("") << QString("35e8554bad60fb29") << QString("993a3af0bc0d77a4") << QString("cfb23034323cd19a");
01548     QTest::newRow("") << QString("9f97210d75b7e6df") << QString("4729e3396e57ae4e") << QString("d4d861035745f2c8");
01549     QTest::newRow("") << QString("ffffffffffffffff") << QString("b5ce4f28fdeb21e8") << QString("e36972fc4bec7587");
01550     QTest::newRow("") << QString("323837024123c918") << QString("7f28bf28adfa1cf0") << QString("e91a71a7ed5eb0ef");
01551     QTest::newRow("") << QString("37dfe527086af0a0") << QString("5f53c6c87760256e") << QString("ebbbbaebfbbefaba");
01552     QTest::newRow("") << QString("20678f45b5b8ac00") << QString("7cc8ecf2638cc808") << QString("ebbeeeaebbbbffff");
01553     QTest::newRow("") << QString("78481ed0c5a7c93e") << QString("4ca3a08300ea6afc") << QString("fbeaffeeffeeabab");
01554     QTest::newRow("") << QString("e2ccd415ac25412a") << QString("bd85b3b659ab7276") << QString("fd8a675c0ed08301");
01555     // weak key
01556     QTest::newRow("") << QString("cccc5bdfd9029507") << QString("da57553d7d55775f") << QString("ffffffffffffffff");
01557     QTest::newRow("") << QString("0000000000000000") << QString("23083a3ca70dd027") << QString("d5d44ff720683d0d");
01558     QTest::newRow("") << QString("0100000000000000") << QString("6f353e3388abe2ef") << QString("d5d44ff720683d0d");
01559     //weak keys till next comment.
01560     QTest::newRow("") << QString("95f8a5e5dd31d900") << QString("8000000000000000") << QString("0101010101010101");
01561     QTest::newRow("") << QString("95f8a5e5dd31d900") << QString("8000000000000000") << QString("0000000000000000");
01562     QTest::newRow("") << QString("dd7f121ca5015619") << QString("4000000000000000") << QString("0101010101010101");
01563     QTest::newRow("") << QString("2e8653104f3834ea") << QString("2000000000000000") << QString("0101010101010101");
01564     QTest::newRow("") << QString("4bd388ff6cd81d4f") << QString("1000000000000000") << QString("0101010101010101");
01565     QTest::newRow("") << QString("20b9e767b2fb1456") << QString("0800000000000000") << QString("0101010101010101");
01566     QTest::newRow("") << QString("20b9e767b2fb1456") << QString("0800000000000000") << QString("0001010101010100");
01567     QTest::newRow("") << QString("55579380d77138ef") << QString("0400000000000000") << QString("0101010101010101");
01568     QTest::newRow("") << QString("6cc5defaaf04512f") << QString("0200000000000000") << QString("0101010101010101");
01569     QTest::newRow("") << QString("0d9f279ba5d87260") << QString("0100000000000000") << QString("0101010101010101");
01570     QTest::newRow("") << QString("d9031b0271bd5a0a") << QString("0080000000000000") << QString("0101010101010101");
01571     QTest::newRow("") << QString("424250b37c3dd951") << QString("0040000000000000") << QString("0101010101010101");
01572     QTest::newRow("") << QString("b8061b7ecd9a21e5") << QString("0020000000000000") << QString("0101010101010101");
01573     QTest::newRow("") << QString("f15d0f286b65bd28") << QString("0010000000000000") << QString("0101010101010101");
01574     QTest::newRow("") << QString("add0cc8d6e5deba1") << QString("0008000000000000") << QString("0101010101010101");
01575     QTest::newRow("") << QString("e6d5f82752ad63d1") << QString("0004000000000000") << QString("0101010101010101");
01576     QTest::newRow("") << QString("ecbfe3bd3f591a5e") << QString("0002000000000000") << QString("0101010101010101");
01577     QTest::newRow("") << QString("f356834379d165cd") << QString("0001000000000000") << QString("0101010101010101");
01578     QTest::newRow("") << QString("2b9f982f20037fa9") << QString("0000800000000000") << QString("0101010101010101");
01579     QTest::newRow("") << QString("889de068a16f0be6") << QString("0000400000000000") << QString("0101010101010101");
01580     QTest::newRow("") << QString("e19e275d846a1298") << QString("0000200000000000") << QString("0101010101010101");
01581     QTest::newRow("") << QString("329a8ed523d71aec") << QString("0000100000000000") << QString("0101010101010101");
01582     QTest::newRow("") << QString("e7fce22557d23c97") << QString("0000080000000000") << QString("0101010101010101");
01583     QTest::newRow("") << QString("12a9f5817ff2d65d") << QString("0000040000000000") << QString("0101010101010101");
01584     QTest::newRow("") << QString("a484c3ad38dc9c19") << QString("0000020000000000") << QString("0101010101010101");
01585     QTest::newRow("") << QString("fbe00a8a1ef8ad72") << QString("0000010000000000") << QString("0101010101010101");
01586     QTest::newRow("") << QString("750d079407521363") << QString("0000008000000000") << QString("0101010101010101");
01587     QTest::newRow("") << QString("64feed9c724c2faf") << QString("0000004000000000") << QString("0101010101010101");
01588     QTest::newRow("") << QString("f02b263b328e2b60") << QString("0000002000000000") << QString("0101010101010101");
01589     QTest::newRow("") << QString("9d64555a9a10b852") << QString("0000001000000000") << QString("0101010101010101");
01590     QTest::newRow("") << QString("d106ff0bed5255d7") << QString("0000000800000000") << QString("0101010101010101");
01591     QTest::newRow("") << QString("e1652c6b138c64a5") << QString("0000000400000000") << QString("0101010101010101");
01592     QTest::newRow("") << QString("e428581186ec8f46") << QString("0000000200000000") << QString("0101010101010101");
01593     QTest::newRow("") << QString("aeb5f5ede22d1a36") << QString("0000000100000000") << QString("0101010101010101");
01594     QTest::newRow("") << QString("e943d7568aec0c5c") << QString("0000000080000000") << QString("0101010101010101");
01595     QTest::newRow("") << QString("df98c8276f54b04b") << QString("0000000040000000") << QString("0101010101010101");
01596     QTest::newRow("") << QString("b160e4680f6c696f") << QString("0000000020000000") << QString("0101010101010101");
01597     QTest::newRow("") << QString("fa0752b07d9c4ab8") << QString("0000000010000000") << QString("0101010101010101");
01598     QTest::newRow("") << QString("ca3a2b036dbc8502") << QString("0000000008000000") << QString("0101010101010101");
01599     QTest::newRow("") << QString("5e0905517bb59bcf") << QString("0000000004000000") << QString("0101010101010101");
01600     QTest::newRow("") << QString("814eeb3b91d90726") << QString("0000000002000000") << QString("0101010101010101");
01601     QTest::newRow("") << QString("4d49db1532919c9f") << QString("0000000001000000") << QString("0101010101010101");
01602     QTest::newRow("") << QString("25eb5fc3f8cf0621") << QString("0000000000800000") << QString("0101010101010101");
01603     QTest::newRow("") << QString("ab6a20c0620d1c6f") << QString("0000000000400000") << QString("0101010101010101");
01604     QTest::newRow("") << QString("79e90dbc98f92cca") << QString("0000000000200000") << QString("0101010101010101");
01605     QTest::newRow("") << QString("866ecedd8072bb0e") << QString("0000000000100000") << QString("0101010101010101");
01606     QTest::newRow("") << QString("8b54536f2f3e64a8") << QString("0000000000080000") << QString("0101010101010101");
01607     QTest::newRow("") << QString("ea51d3975595b86b") << QString("0000000000040000") << QString("0101010101010101");
01608     QTest::newRow("") << QString("caffc6ac4542de31") << QString("0000000000020000") << QString("0101010101010101");
01609     QTest::newRow("") << QString("8dd45a2ddf90796c") << QString("0000000000010000") << QString("0101010101010101");
01610     QTest::newRow("") << QString("1029d55e880ec2d0") << QString("0000000000008000") << QString("0101010101010101");
01611     QTest::newRow("") << QString("5d86cb23639dbea9") << QString("0000000000004000") << QString("0101010101010101");
01612     QTest::newRow("") << QString("1d1ca853ae7c0c5f") << QString("0000000000002000") << QString("0101010101010101");
01613     QTest::newRow("") << QString("ce332329248f3228") << QString("0000000000001000") << QString("0101010101010101");
01614     QTest::newRow("") << QString("8405d1abe24fb942") << QString("0000000000000800") << QString("0101010101010101");
01615     QTest::newRow("") << QString("e643d78090ca4207") << QString("0000000000000400") << QString("0101010101010101");
01616     QTest::newRow("") << QString("48221b9937748a23") << QString("0000000000000200") << QString("0101010101010101");
01617     QTest::newRow("") << QString("dd7c0bbd61fafd54") << QString("0000000000000100") << QString("0101010101010101");
01618     QTest::newRow("") << QString("2fbc291a570db5c4") << QString("0000000000000080") << QString("0101010101010101");
01619     QTest::newRow("") << QString("e07c30d7e4e26e12") << QString("0000000000000040") << QString("0101010101010101");
01620     QTest::newRow("") << QString("0953e2258e8e90a1") << QString("0000000000000020") << QString("0101010101010101");
01621     QTest::newRow("") << QString("5b711bc4ceebf2ee") << QString("0000000000000010") << QString("0101010101010101");
01622     QTest::newRow("") << QString("cc083f1e6d9e85f6") << QString("0000000000000008") << QString("0101010101010101");
01623     QTest::newRow("") << QString("d2fd8867d50d2dfe") << QString("0000000000000004") << QString("0101010101010101");
01624     QTest::newRow("") << QString("06e7ea22ce92708f") << QString("0000000000000002") << QString("0101010101010101");
01625     QTest::newRow("") << QString("166b40b44aba4bd6") << QString("0000000000000001") << QString("0101010101010101");
01626     QTest::newRow("") << QString("0000000000000000") << QString("95a8d72813daa94d") << QString("8001010101010101");
01627     QTest::newRow("") << QString("0000000000000000") << QString("0eec1487dd8c26d5") << QString("4001010101010101");
01628     QTest::newRow("") << QString("0000000000000000") << QString("7ad16ffb79c45926") << QString("2001010101010101");
01629     QTest::newRow("") << QString("0000000000000000") << QString("d3746294ca6a6cf3") << QString("1001010101010101");
01630     QTest::newRow("") << QString("0000000000000000") << QString("809f5f873c1fd761") << QString("0801010101010101");
01631     QTest::newRow("") << QString("0000000000000000") << QString("c02faffec989d1fc") << QString("0401010101010101");
01632     QTest::newRow("") << QString("0000000000000000") << QString("4615aa1d33e72f10") << QString("0201010101010101");
01633     QTest::newRow("") << QString("0000000000000000") << QString("2055123350c00858") << QString("0180010101010101");
01634     QTest::newRow("") << QString("0000000000000000") << QString("df3b99d6577397c8") << QString("0140010101010101");
01635     QTest::newRow("") << QString("0000000000000000") << QString("31fe17369b5288c9") << QString("0120010101010101");
01636     QTest::newRow("") << QString("0000000000000000") << QString("dfdd3cc64dae1642") << QString("0110010101010101");
01637     QTest::newRow("") << QString("0000000000000000") << QString("178c83ce2b399d94") << QString("0108010101010101");
01638     QTest::newRow("") << QString("0000000000000000") << QString("50f636324a9b7f80") << QString("0104010101010101");
01639     QTest::newRow("") << QString("0000000000000000") << QString("a8468ee3bc18f06d") << QString("0102010101010101");
01640     QTest::newRow("") << QString("0000000000000000") << QString("a2dc9e92fd3cde92") << QString("0101800101010101");
01641     QTest::newRow("") << QString("0000000000000000") << QString("cac09f797d031287") << QString("0101400101010101");
01642     QTest::newRow("") << QString("0000000000000000") << QString("90ba680b22aeb525") << QString("0101200101010101");
01643     QTest::newRow("") << QString("0000000000000000") << QString("ce7a24f350e280b6") << QString("0101100101010101");
01644     QTest::newRow("") << QString("0000000000000000") << QString("882bff0aa01a0b87") << QString("0101080101010101");
01645     QTest::newRow("") << QString("0000000000000000") << QString("25610288924511c2") << QString("0101040101010101");
01646     QTest::newRow("") << QString("0000000000000000") << QString("c71516c29c75d170") << QString("0101020101010101");
01647     QTest::newRow("") << QString("0000000000000000") << QString("5199c29a52c9f059") << QString("0101018001010101");
01648     QTest::newRow("") << QString("0000000000000000") << QString("c22f0a294a71f29f") << QString("0101014001010101");
01649     QTest::newRow("") << QString("0000000000000000") << QString("ee371483714c02ea") << QString("0101012001010101");
01650     QTest::newRow("") << QString("0000000000000000") << QString("a81fbd448f9e522f") << QString("0101011001010101");
01651     QTest::newRow("") << QString("0000000000000000") << QString("4f644c92e192dfed") << QString("0101010801010101");
01652     QTest::newRow("") << QString("0000000000000000") << QString("1afa9a66a6df92ae") << QString("0101010401010101");
01653     QTest::newRow("") << QString("0000000000000000") << QString("b3c1cc715cb879d8") << QString("0101010201010101");
01654     QTest::newRow("") << QString("0000000000000000") << QString("19d032e64ab0bd8b") << QString("0101010180010101");
01655     QTest::newRow("") << QString("0000000000000000") << QString("3cfaa7a7dc8720dc") << QString("0101010140010101");
01656     QTest::newRow("") << QString("0000000000000000") << QString("b7265f7f447ac6f3") << QString("0101010120010101");
01657     QTest::newRow("") << QString("0000000000000000") << QString("9db73b3c0d163f54") << QString("0101010110010101");
01658     QTest::newRow("") << QString("0000000000000000") << QString("8181b65babf4a975") << QString("0101010108010101");
01659     QTest::newRow("") << QString("0000000000000000") << QString("93c9b64042eaa240") << QString("0101010104010101");
01660     QTest::newRow("") << QString("0000000000000000") << QString("5570530829705592") << QString("0101010102010101");
01661     QTest::newRow("") << QString("0000000000000000") << QString("8638809e878787a0") << QString("0101010101800101");
01662     QTest::newRow("") << QString("0000000000000000") << QString("41b9a79af79ac208") << QString("0101010101400101");
01663     QTest::newRow("") << QString("0000000000000000") << QString("7a9be42f2009a892") << QString("0101010101200101");
01664     QTest::newRow("") << QString("0000000000000000") << QString("29038d56ba6d2745") << QString("0101010101100101");
01665     QTest::newRow("") << QString("0000000000000000") << QString("5495c6abf1e5df51") << QString("0101010101080101");
01666     QTest::newRow("") << QString("0000000000000000") << QString("ae13dbd561488933") << QString("0101010101040101");
01667     QTest::newRow("") << QString("0000000000000000") << QString("024d1ffa8904e389") << QString("0101010101020101");
01668     QTest::newRow("") << QString("0000000000000000") << QString("d1399712f99bf02e") << QString("0101010101018001");
01669     QTest::newRow("") << QString("0000000000000000") << QString("14c1d7c1cffec79e") << QString("0101010101014001");
01670     QTest::newRow("") << QString("0000000000000000") << QString("1de5279dae3bed6f") << QString("0101010101012001");
01671     QTest::newRow("") << QString("0000000000000000") << QString("e941a33f85501303") << QString("0101010101011001");
01672     QTest::newRow("") << QString("0000000000000000") << QString("da99dbbc9a03f379") << QString("0101010101010801");
01673     QTest::newRow("") << QString("0000000000000000") << QString("b7fc92f91d8e92e9") << QString("0101010101010401");
01674     QTest::newRow("") << QString("0000000000000000") << QString("ae8e5caa3ca04e85") << QString("0101010101010201");
01675     QTest::newRow("") << QString("0000000000000000") << QString("9cc62df43b6eed74") << QString("0101010101010180");
01676     QTest::newRow("") << QString("0000000000000000") << QString("d863dbb5c59a91a0") << QString("0101010101010140");
01677     QTest::newRow("") << QString("0000000000000000") << QString("a1ab2190545b91d7") << QString("0101010101010120");
01678     QTest::newRow("") << QString("0000000000000000") << QString("0875041e64c570f7") << QString("0101010101010110");
01679     QTest::newRow("") << QString("0000000000000000") << QString("5a594528bebef1cc") << QString("0101010101010108");
01680     QTest::newRow("") << QString("0000000000000000") << QString("fcdb3291de21f0c0") << QString("0101010101010104");
01681     QTest::newRow("") << QString("0000000000000000") << QString("869efd7f9f265a09") << QString("0101010101010102");
01682     //end of weak keys
01683     QTest::newRow("") << QString("0000000000000000") << QString("88d55e54f54c97b4") << QString("1046913489980131");
01684     QTest::newRow("") << QString("0000000000000000") << QString("0c0cc00c83ea48fd") << QString("1007103489988020");
01685     QTest::newRow("") << QString("0000000000000000") << QString("83bc8ef3a6570183") << QString("10071034c8980120");
01686     QTest::newRow("") << QString("0000000000000000") << QString("df725dcad94ea2e9") << QString("1046103489988020");
01687     QTest::newRow("") << QString("0000000000000000") << QString("e652b53b550be8b0") << QString("1086911519190101");
01688     QTest::newRow("") << QString("0000000000000000") << QString("af527120c485cbb0") << QString("1086911519580101");
01689     QTest::newRow("") << QString("0000000000000000") << QString("0f04ce393db926d5") << QString("5107b01519580101");
01690     QTest::newRow("") << QString("0000000000000000") << QString("c9f00ffc74079067") << QString("1007b01519190101");
01691     QTest::newRow("") << QString("0000000000000000") << QString("7cfd82a593252b4e") << QString("3107915498080101");
01692     QTest::newRow("") << QString("0000000000000000") << QString("cb49a2f9e91363e3") << QString("3107919498080101");
01693     QTest::newRow("") << QString("0000000000000000") << QString("00b588be70d23f56") << QString("10079115b9080140");
01694     QTest::newRow("") << QString("0000000000000000") << QString("406a9a6ab43399ae") << QString("3107911598090140");
01695     QTest::newRow("") << QString("0000000000000000") << QString("6cb773611dca9ada") << QString("1007d01589980101");
01696     QTest::newRow("") << QString("0000000000000000") << QString("67fd21c17dbb5d70") << QString("9107911589980101");
01697     QTest::newRow("") << QString("0000000000000000") << QString("9592cb4110430787") << QString("9107d01589190101");
01698     QTest::newRow("") << QString("0000000000000000") << QString("a6b7ff68a318ddd3") << QString("1007d01598980120");
01699     QTest::newRow("") << QString("0000000000000000") << QString("4d102196c914ca16") << QString("1007940498190101");
01700     QTest::newRow("") << QString("0000000000000000") << QString("2dfa9f4573594965") << QString("0107910491190401");
01701     QTest::newRow("") << QString("0000000000000000") << QString("b46604816c0e0774") << QString("0107910491190101");
01702     QTest::newRow("") << QString("0000000000000000") << QString("6e7e6221a4f34e87") << QString("0107940491190401");
01703     QTest::newRow("") << QString("0000000000000000") << QString("aa85e74643233199") << QString("19079210981a0101");
01704     QTest::newRow("") << QString("0000000000000000") << QString("2e5a19db4d1962d6") << QString("1007911998190801");
01705     QTest::newRow("") << QString("0000000000000000") << QString("23a866a809d30894") << QString("10079119981a0801");
01706     QTest::newRow("") << QString("0000000000000000") << QString("d812d961f017d320") << QString("1007921098190101");
01707     QTest::newRow("") << QString("0000000000000000") << QString("055605816e58608f") << QString("100791159819010b");
01708     QTest::newRow("") << QString("0000000000000000") << QString("abd88e8b1b7716f1") << QString("1004801598190101");
01709     QTest::newRow("") << QString("0000000000000000") << QString("537ac95be69da1e1") << QString("1004801598190102");
01710     QTest::newRow("") << QString("0000000000000000") << QString("aed0f6ae3c25cdd8") << QString("1004801598190108");
01711     QTest::newRow("") << QString("0000000000000000") << QString("b3e35a5ee53e7b8d") << QString("1002911598100104");
01712     QTest::newRow("") << QString("0000000000000000") << QString("61c79c71921a2ef8") << QString("1002911598190104");
01713     QTest::newRow("") << QString("0000000000000000") << QString("e2f5728f0995013c") << QString("1002911598100201");
01714     QTest::newRow("") << QString("0000000000000000") << QString("1aeac39a61f0a464") << QString("1002911698100101");
01715     QTest::newRow("") << QString("059b5e0851cf143a") << QString("86a560f10ec6d85b") << QString("0113b970fd34f2ce");
01716     QTest::newRow("") << QString("4e6f772069732074") << QString("3fa40e8a984d4815") << QString("0123456789abcdef");
01717 }
01718 
01719 
01720 void CipherUnitTest::des()
01721 {
01722     QStringList providersToTest;
01723     providersToTest.append("qca-ossl");
01724     providersToTest.append("qca-gcrypt");
01725     providersToTest.append("qca-botan");
01726     providersToTest.append("qca-nss");
01727 
01728     foreach(const QString provider, providersToTest) {
01729         if( !QCA::isSupported( "des-ecb", provider ) )
01730             QWARN( QString( "DES ECB not supported for "+provider).toLocal8Bit() );
01731         else {
01732         QFETCH( QString, plainText );
01733         QFETCH( QString, cipherText );
01734         QFETCH( QString, keyText );
01735 
01736         QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
01737         QCA::Cipher forwardCipher( QString( "des" ),
01738                        QCA::Cipher::ECB,
01739                        QCA::Cipher::NoPadding,
01740                        QCA::Encode,
01741                        key,
01742                        QCA::InitializationVector(),
01743                        provider );
01744 
01745         QCOMPARE( forwardCipher.blockSize(), 8 );
01746         QCOMPARE( forwardCipher.keyLength().minimum(), 8 );
01747         QCOMPARE( forwardCipher.keyLength().maximum(), 8 );
01748 
01749         QCOMPARE( QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ).toByteArray() ),
01750               cipherText );
01751         QVERIFY( forwardCipher.ok() );
01752         QCOMPARE( QCA::arrayToHex( forwardCipher.final().toByteArray() ), QString( "" ) );
01753         QVERIFY( forwardCipher.ok() );
01754 
01755         QCA::Cipher reverseCipher( QString( "des" ),
01756                        QCA::Cipher::ECB,
01757                        QCA::Cipher::NoPadding,
01758                        QCA::Decode,
01759                        key,
01760                        QCA::InitializationVector(),
01761                        provider );
01762 
01763         QCOMPARE( reverseCipher.blockSize(), 8 );
01764         QCOMPARE( reverseCipher.keyLength().minimum(), 8 );
01765         QCOMPARE( reverseCipher.keyLength().maximum(), 8 );
01766 
01767         QString update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ).toByteArray() );
01768         QVERIFY( reverseCipher.ok() );
01769         QCOMPARE( update, plainText.left(update.size() ) );
01770         QCOMPARE( update + QCA::arrayToHex( reverseCipher.final().toByteArray() ), plainText );
01771         QVERIFY( reverseCipher.ok() );
01772 
01773     }
01774     }
01775 }
01776 
01777 // This is from the Botan test suite
01778 void CipherUnitTest::des_cbc_data()
01779 {
01780     QTest::addColumn<QString>("plainText");
01781     QTest::addColumn<QString>("cipherText");
01782     QTest::addColumn<QString>("keyText");
01783     QTest::addColumn<QString>("ivText");
01784 
01785     QTest::newRow("1") << QString("4e6f77206973207468652074696d6520666f7220616c6c20")
01786                << QString("e5c7cdde872bf27c43e934008c389c0f683788499a7c05f6")
01787                << QString("0123456789abcdef")
01788                << QString("1234567890abcdef");
01789 }
01790 
01791 
01792 void CipherUnitTest::des_cbc()
01793 {
01794     QStringList providersToTest;
01795     providersToTest.append("qca-ossl");
01796     providersToTest.append("qca-gcrypt");
01797     providersToTest.append("qca-botan");
01798     providersToTest.append("qca-nss");
01799 
01800     foreach(const QString provider, providersToTest) {
01801         if( !QCA::isSupported( "des-cbc", provider ) )
01802             QWARN( QString( "DES CBC not supported for "+provider).toLocal8Bit() );
01803         else {
01804         QFETCH( QString, plainText );
01805         QFETCH( QString, cipherText );
01806         QFETCH( QString, keyText );
01807         QFETCH( QString, ivText );
01808 
01809         QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
01810         QCA::InitializationVector iv( QCA::hexToArray( ivText ) );
01811         QCA::Cipher forwardCipher( QString( "des" ),
01812                        QCA::Cipher::CBC,
01813                        QCA::Cipher::NoPadding,
01814                        QCA::Encode,
01815                        key,
01816                        iv,
01817                        provider);
01818         QString update = QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ).toByteArray() );
01819         QVERIFY( forwardCipher.ok() );
01820         QCOMPARE( update + QCA::arrayToHex( forwardCipher.final().toByteArray() ), cipherText );
01821         QVERIFY( forwardCipher.ok() );
01822 
01823         QCA::Cipher reverseCipher( QString( "des" ),
01824                        QCA::Cipher::CBC,
01825                        QCA::Cipher::NoPadding,
01826                        QCA::Decode,
01827                        key,
01828                        iv,
01829                        provider);
01830         update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ).toByteArray() );
01831         QVERIFY( reverseCipher.ok() );
01832         QCOMPARE( update, plainText.left(update.size() ) );
01833         QCOMPARE( update + QCA::arrayToHex( reverseCipher.final().toByteArray() ), plainText );
01834         QVERIFY( reverseCipher.ok() );
01835     }
01836     }
01837 }
01838 
01839 
01840 // This is from the Botan test suite
01841 void CipherUnitTest::des_cfb_data()
01842 {
01843     QTest::addColumn<QString>("plainText");
01844     QTest::addColumn<QString>("cipherText");
01845     QTest::addColumn<QString>("keyText");
01846     QTest::addColumn<QString>("ivText");
01847 
01848     QTest::newRow("") << QString("5eef8199471c2a7ef97509623cae32c35a90245b70a21ce36e")
01849               << QString("658b25e25df23948847afa4c9ffdd5b3ddf35d801cbe945168")
01850               << QString("add9ce7bcf48c44b") << QString("0f90e78835ba3183");
01851     QTest::newRow("") << QString("4e6f77206973207468652074696d6520666f7220616c6c20")
01852               << QString("f3096249c7f46e51a69e839b1a92f78403467133898ea622")
01853               << QString("0123456789abcdef") << QString("1234567890abcdef");
01854     QTest::newRow("") << QString("d14fd67a9b4d7b0f65b7ca3da91741603da446")
01855               << QString("0cb8929a854e61ab3beb72ce0f13ba328ba73a")
01856               << QString("7132d895529a7aff") << QString("fa1fe8f921706c75");
01857     QTest::newRow("") << QString("16") << QString("e1")
01858               << QString("f51cf13fd55f33b8") << QString("10e61c7f8276132e");
01859     QTest::newRow("") << QString("b8f7") << QString("9f09")
01860               << QString("6a2306397e6399af") << QString("6791874e16642dd8");
01861     QTest::newRow("") << QString("914aa4") << QString("1cddad")
01862               << QString("08d3b08cb02e2547") << QString("b35072a53fa36190");
01863     QTest::newRow("") << QString("252f0616") << QString("e22a706a")
01864               << QString("454a9aca108ad24c") << QString("64dadb33ccf1debd");
01865     QTest::newRow("") << QString("f06f376c6e") << QString("c2f054e435")
01866               << QString("087fc9f0b8be08f3") << QString("5e511251c063b3c7");
01867     QTest::newRow("") << QString("9a181afec04c") << QString("c49218c8a25b")
01868               << QString("fe1ea0f0ac5f2c02") << QString("a247e69ced4a2bf1");
01869     QTest::newRow("") << QString("ac465cbd745341") << QString("768b6f5bfa9c24")
01870               << QString("1e7c7274307edb90") << QString("afb634941c366c1d");
01871     QTest::newRow("") << QString("52bdfd51e3434e94") << QString("c5d84483756ac360")
01872               << QString("53e241e43aad03e7") << QString("be0a4ae59056d8fe");
01873     QTest::newRow("") << QString("a62c02059afe67cd7f") << QString("032a99be4df6b63f97")
01874               << QString("487c9fbd140ef278") << QString("43f88de155e98523");
01875     QTest::newRow("") << QString("32d3c8a283257f6276c3") << QString("bcfa26efe2d93a4b1364")
01876               << QString("8b068595d5b79177") << QString("7129287761d94d9f");
01877     QTest::newRow("") << QString("17cb11a60f880c16d6cc3a") << QString("3dc099d927b8aa66b2a5c8")
01878               << QString("750c87995afd65ee") << QString("a61398fff559faad");
01879     QTest::newRow("") << QString("eaa91cede4efc60f02b1e0ee") << QString("75614ea2fd5474fdfe3a5612")
01880               << QString("08a5f56200ac9300") << QString("9f9ed0928b8cd2dd");
01881     QTest::newRow("") << QString("68db8992e91d759256ab373748") << QString("9d0e14f0b2be2d3b47103da75f")
01882               << QString("b11dfa915ad86ff9") << QString("3885ecf48a611dc5");
01883     QTest::newRow("") << QString("d75acdd3e4040dfda924ce09e627")
01884               << QString("a878ce766412a9c387ad61642fb7")
01885               << QString("fbf9e6d9344b0f2c") << QString("6917f8fe1ac12101");
01886     QTest::newRow("") << QString("38b667a6e4458c8732aae6f4d0ac36")
01887               << QString("5bcfd93d6b4b45d9d0d03162fa8fb9")
01888               << QString("8616d2ea6e6106b3") << QString("cfe4dfa7044f56ab");
01889     QTest::newRow("") << QString("0b439a72a4430b3d15e234034ba2c066")
01890               << QString("1adae0a4a0d582b70b60ed1c859a07b3")
01891               << QString("e255e4a4c3606081") << QString("3f160dff918c3f78");
01892     QTest::newRow("") << QString("82e27182fc22cd8918dddbdb850034a4f2")
01893               << QString("9767881b1909db5e146caaf5fc6a118814")
01894               << QString("b9cdd5442e1c7fd7") << QString("5d1b1eceb7335274");
01895 }
01896 
01897 
01898 void CipherUnitTest::des_cfb()
01899 {
01900     QStringList providersToTest;
01901     providersToTest.append("qca-ossl");
01902     providersToTest.append("qca-gcrypt");
01903     providersToTest.append("qca-botan");
01904 
01905     foreach(const QString provider, providersToTest) {
01906         if( !QCA::isSupported( "des-cfb", provider ) )
01907             QWARN( QString( "DES CFB not supported for "+provider).toLocal8Bit() );
01908         else {
01909         QFETCH( QString, plainText );
01910         QFETCH( QString, cipherText );
01911         QFETCH( QString, keyText );
01912         QFETCH( QString, ivText );
01913 
01914         QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
01915         QCA::InitializationVector iv( QCA::hexToArray( ivText ) );
01916         QCA::Cipher forwardCipher( QString( "des" ),
01917                        QCA::Cipher::CFB,
01918                        QCA::Cipher::NoPadding,
01919                        QCA::Encode,
01920                        key,
01921                        iv,
01922                        provider);
01923         QString update = QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ).toByteArray() );
01924         QVERIFY( forwardCipher.ok() );
01925         QCOMPARE( update + QCA::arrayToHex( forwardCipher.final().toByteArray() ), cipherText );
01926         QVERIFY( forwardCipher.ok() );
01927 
01928         QCA::Cipher reverseCipher( QString( "des" ),
01929                        QCA::Cipher::CFB,
01930                        QCA::Cipher::NoPadding,
01931                        QCA::Decode,
01932                        key,
01933                        iv,
01934                        provider);
01935         update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ).toByteArray() );
01936         QVERIFY( reverseCipher.ok() );
01937         QCOMPARE( update, plainText.left(update.size() ) );
01938         QCOMPARE( update + QCA::arrayToHex( reverseCipher.final().toByteArray() ), plainText );
01939         QVERIFY( reverseCipher.ok() );
01940     }
01941     }
01942 }
01943 
01944 // This is from the Botan test suite
01945 void CipherUnitTest::des_ofb_data()
01946 {
01947     QTest::addColumn<QString>("plainText");
01948     QTest::addColumn<QString>("cipherText");
01949     QTest::addColumn<QString>("keyText");
01950     QTest::addColumn<QString>("ivText");
01951 
01952     QTest::newRow("1") << QString("4e6f77206973207468652074696d6520666f7220616c6c20")
01953                << QString("f3096249c7f46e5135f24a242eeb3d3f3d6d5be3255af8c3")
01954                << QString("0123456789abcdef") << QString("1234567890abcdef");
01955     QTest::newRow("2") << QString("b25330d1cab11fddff278192aa2c935a9c7745733e6da8")
01956                << QString("39b9bf284d6da6e639b8040b8da01e469dba4c6e50b1ab")
01957                << QString("f871822c7fd1d6a3") << QString("b311792c8bc02ee8");
01958     QTest::newRow("3") << QString("73ad356623a1d6e0717e838b9344b4fff21bda")
01959                << QString("0c06e63e9e81d9976e16d2009255f917797d51")
01960                << QString("5860f4a413de6c68") << QString("527a1e050a9d71f0");
01961     QTest::newRow("4") << QString("08a6091fa2987fdc682a8199a6d6bd1f")
01962                << QString("640b5033dcf26873fa8a34db644f2bf2")
01963                << QString("3307042dc775035e") << QString("99de32ff0351509b");
01964 }
01965 
01966 
01967 void CipherUnitTest::des_ofb()
01968 {
01969     QStringList providersToTest;
01970     providersToTest.append("qca-ossl");
01971     providersToTest.append("qca-gcrypt");
01972     providersToTest.append("qca-botan");
01973 
01974     foreach(const QString provider, providersToTest) {
01975         if( !QCA::isSupported( "des-ofb", provider ) )
01976             QWARN( QString( "DES OFB not supported for "+provider).toLocal8Bit() );
01977         else {
01978         QFETCH( QString, plainText );
01979         QFETCH( QString, cipherText );
01980         QFETCH( QString, keyText );
01981         QFETCH( QString, ivText );
01982 
01983         QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
01984         QCA::InitializationVector iv( QCA::hexToArray( ivText ) );
01985         QCA::Cipher forwardCipher( QString( "des" ),
01986                        QCA::Cipher::OFB,
01987                        QCA::Cipher::NoPadding,
01988                        QCA::Encode,
01989                        key,
01990                        iv,
01991                        provider);
01992         QString update = QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ).toByteArray() );
01993         QVERIFY( forwardCipher.ok() );
01994         QCOMPARE( update + QCA::arrayToHex( forwardCipher.final().toByteArray() ), cipherText );
01995         QVERIFY( forwardCipher.ok() );
01996 
01997         QCA::Cipher reverseCipher( QString( "des" ),
01998                        QCA::Cipher::OFB,
01999                        QCA::Cipher::NoPadding,
02000                        QCA::Decode,
02001                        key,
02002                        iv,
02003                        provider);
02004         update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ).toByteArray() );
02005         QVERIFY( reverseCipher.ok() );
02006         QCOMPARE( update, plainText.left(update.size() ) );
02007         QCOMPARE( update + QCA::arrayToHex( reverseCipher.final().toByteArray() ), plainText );
02008         QVERIFY( reverseCipher.ok() );
02009     }
02010     }
02011 }
02012 
02013 // These are from the Botan test suite
02014 void CipherUnitTest::des_pkcs7_data()
02015 {
02016     QTest::addColumn<QString>("plainText");
02017     QTest::addColumn<QString>("cipherText");
02018     QTest::addColumn<QString>("keyText");
02019 
02020     QTest::newRow("") << QString("") << QString("705fdf4dc7abfbfc") << QString("02d863a4885d417a");
02021     QTest::newRow("") << QString("fa") << QString("2281ac7cfa703ba9") << QString("05add235b01bbda7");
02022     QTest::newRow("") << QString("b895") << QString("8c3bf9ab9d16c8cf") << QString("93f04843afc3a191");
02023     QTest::newRow("") << QString("8e97de") << QString("be38bd2afe108d2a") << QString("1f4e2c013314b55a");
02024     QTest::newRow("") << QString("c1dae88e") << QString("998341e8b0cce82e") << QString("0f59c05186431e13");
02025     QTest::newRow("") << QString("a6e0360e88") << QString("f5e88fcc387b8883") << QString("e68bf7b98d61fed0");
02026     QTest::newRow("") << QString("55e67a79f043") << QString("a868b107bd96f35c") << QString("ae3ab00a0ba38be0");
02027     QTest::newRow("") << QString("d77c93b63d6d5b") << QString("19da07a34fa683c4") << QString("9b661c7a536afc6d");
02028     QTest::newRow("") << QString("328d09508e747ae1")
02029               << QString("9c75845c6bff94438eb7e7e4c77342f0") << QString("8e1c689280575f05");
02030     QTest::newRow("") << QString("421d4bdc3869e59f07")
02031               << QString("8df60dc27a2e2ee23360be31343fcbdb") << QString("eb4a6b437572e1e7");
02032     QTest::newRow("") << QString("160e525583c3e4fbc4fe")
02033               << QString("9b649660dfe5b875cd81180ad627943f") << QString("ffe58726b90c9f97");
02034     QTest::newRow("") << QString("e873b3c2b31130719e6469")
02035               << QString("6e33ae2af48cc39697800a3aa357cc5e")
02036               << QString("560ee1ed2cc2bffb");
02037     QTest::newRow("") << QString("405915adc0111eb8af225612")
02038               << QString("569be1f2ae91785b0634f8dd4ec1dff2") << QString("012a7de9cbfbd230");
02039     QTest::newRow("") << QString("e923c535186730f309cdea6dea")
02040               << QString("846d7314f76e00902054bd2b2ae1f580") << QString("3d5d56ca2e8e359c");
02041     QTest::newRow("") << QString("116053a5820f9d36650eef49a05b")
02042               << QString("9bd56c43036485b648efe6d31e69f0c6") << QString("2ad63a5312bf4259");
02043     QTest::newRow("") << QString("b6dcd40077fe89138b5a2ed35e1b3d")
02044               << QString("2fbe419bada6d4bf3f6c7bb2a1aac329") << QString("7ff12d4d8a9ef138");
02045     QTest::newRow("") << QString("08f0aa208f8a06c6292838a8cee9104e")
02046               << QString("44bfca2722d274504af482e9261cdb7b16918be77a461b3b")
02047               << QString("f71a3b1aabd660bd");
02048     QTest::newRow("") << QString("878412f6255ff4360a22772711289fd351")
02049               << QString("9c92fdde178d3b6c895aad1b8dc886176910b021d5b3aa77")
02050               << QString("1ed8b08898872631");
02051     QTest::newRow("") << QString("1399a0cd9f2778bcfba9c0f7e7c89ca069e3")
02052               << QString("5972f89d8c161dd30a409bcdbf43b20bb104e8a293c48fdd")
02053               << QString("0dcb3527035253a5");
02054     QTest::newRow("") << QString("ea1cc272d3725e4c5dc56079fa3c9f26a1373a")
02055               << QString("d1b2fcc83cbf11e022c058fcb988cbbbc3843517f5e9d900")
02056               << QString("bf4b260909243b2f");
02057     QTest::newRow("") << QString("098dd47ea5784d307c115824cfc3443983fdf58b")
02058               << QString("77dfae7f46af6db0d0e5775859943e2875854a680b54b59b")
02059               << QString("5d869f3486dfe1a1");
02060 
02061 }
02062 
02063 
02064 // This is DES ECB, PKCS7 padding
02065 void CipherUnitTest::des_pkcs7()
02066 {
02067     QStringList providersToTest;
02068     providersToTest.append("qca-ossl");
02069     providersToTest.append("qca-botan");
02070     providersToTest.append("qca-nss");
02071 
02072     foreach(const QString provider, providersToTest) {
02073         if( !QCA::isSupported( "des-ecb-pkcs7", provider ) )
02074             QWARN( QString( "DES ECB with PKCS7 padding not supported for "+provider).toLocal8Bit() );
02075         else {
02076         QFETCH( QString, plainText );
02077         QFETCH( QString, cipherText );
02078         QFETCH( QString, keyText );
02079 
02080         QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
02081         // just a filler
02082         QCA::InitializationVector iv;
02083         QCA::Cipher forwardCipher( QString( "des" ),
02084                        QCA::Cipher::ECB,
02085                        QCA::Cipher::PKCS7,
02086                        QCA::Encode,
02087                        key,
02088                        iv,
02089                        provider);
02090 
02091         QCOMPARE( forwardCipher.keyLength().minimum(), 8 );
02092         QCOMPARE( forwardCipher.keyLength().maximum(), 8 );
02093         QCOMPARE( forwardCipher.blockSize(), 8 );
02094 
02095         QString update = QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ).toByteArray() );
02096         QVERIFY( forwardCipher.ok() );
02097         QCOMPARE( update, cipherText.left(update.size())  );
02098         QCOMPARE( update + QCA::arrayToHex( forwardCipher.final().toByteArray() ), cipherText );
02099         QVERIFY( forwardCipher.ok() );
02100 
02101         QCA::Cipher reverseCipher( QString( "des" ),
02102                        QCA::Cipher::ECB,
02103                        QCA::Cipher::PKCS7,
02104                        QCA::Decode,
02105                        key,
02106                        iv,
02107                        provider);
02108 
02109         QCOMPARE( reverseCipher.keyLength().minimum(), 8 );
02110         QCOMPARE( reverseCipher.keyLength().maximum(), 8 );
02111         QCOMPARE( reverseCipher.blockSize(), 8 );
02112 
02113         update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ).toByteArray() );
02114         QVERIFY( reverseCipher.ok() );
02115         QCOMPARE( update, plainText.left(update.size())  );
02116         QCOMPARE( update + QCA::arrayToHex( reverseCipher.final().toByteArray() ), plainText );
02117         QVERIFY( reverseCipher.ok() );
02118     }
02119     }
02120 }
02121 
02122 // These are from the Botan test suite
02123 void CipherUnitTest::des_cbc_pkcs7_data()
02124 {
02125     QTest::addColumn<QString>("plainText");
02126     QTest::addColumn<QString>("cipherText");
02127     QTest::addColumn<QString>("keyText");
02128     QTest::addColumn<QString>("ivText");
02129 
02130     QTest::newRow("1") << QString("4e6f77206973207468652074696d6520666f7220616c6c20")
02131                << QString("e5c7cdde872bf27c43e934008c389c0f683788499a7c05f662c16a27e4fcf277")
02132                << QString("0123456789abcdef") << QString("1234567890abcdef");
02133     QTest::newRow("2") << QString("") << QString("ff4903e653af83c4")
02134                << QString("46b534fbffdae457") << QString("297873b948a44b5f");
02135     QTest::newRow("3") << QString("69") << QString("60fa7b46523aa51f")
02136               << QString("d581a1d0c70f94a1") << QString("c1ddd7447249ef80");
02137     QTest::newRow("4") << QString("02b7") << QString("63c1c1ef79555ed8")
02138               << QString("a415b62e7e94caf2") << QString("57fa9b2f95f57401");
02139     QTest::newRow("5") << QString("568960") << QString("d0321483090f524d")
02140               << QString("5dcbe42db374090e") << QString("b6215a095582763f");
02141     QTest::newRow("6") << QString("b6eaf23c") << QString("88e289e1de3e6451")
02142                << QString("8fe92291c654ec9b") << QString("0c054bbd31a9f623");
02143     QTest::newRow("7") << QString("60a658cbbd") << QString("89bffa9e36ff1780")
02144                << QString("dbcee35e86088501") << QString("11a8928bc6d0d117");
02145     QTest::newRow("8") << QString("7e10cbd9e95c") << QString("afc5cdf559abc6d3")
02146                << QString("72338f946012ced5") << QString("eaaa48b0c2ee2f3f");
02147     QTest::newRow("9") << QString("d907ce88f077fa") << QString("3476402272856ea8")
02148                << QString("837fbb3167f0ccaa") << QString("cd399dd3e402f8f2");
02149     QTest::newRow("10") << QString("9476e85b198c9aee") << QString("1af298a150514ca70d252f88271b3ca7")
02150             << QString("308d1c02e7a4e09d") << QString("6baa74f7f1a72e1f");
02151     QTest::newRow("11") << QString("5c11285270e9606cdf") << QString("78665abfe3def34f8bd55796825ee915")
02152             << QString("126aff39882542ea") << QString("51badb479de66a73");
02153     QTest::newRow("12") << QString("d1d3d8675e42a4242fba")
02154             << QString("e77bb4a24b4ee8c9ebda4971c2e60d10")
02155             << QString("0ae8510bb0fb3994") << QString("6c7293a8427bcb3b");
02156     QTest::newRow("13") << QString("65026a8a41edc1d880f6c9")
02157             << QString("45a6ef4acd49f9f1d892a808fa7b6f28")
02158             << QString("0be9277b3504d524") << QString("e47ec7a77db94755");
02159     QTest::newRow("14") << QString("d72e81f4130107e396d5fb27")
02160             << QString("a88eff91876a1b6958d52f99fe9b18fb")
02161             << QString("2f03c36de4f78e13") << QString("99fd2e8848f33fe7");
02162     QTest::newRow("15") << QString("c8a3971efda18af1b18bfad98f")
02163             << QString("54ff90bd90f6213d761f4b3ff89a8ded")
02164             << QString("69329672e546c969") << QString("294922cbe7e12341");
02165     QTest::newRow("16") << QString("bb9a90f11551531de512dd48270e")
02166             << QString("9ba7908e56edb1bef992faee40f5b1ca")
02167             << QString("3007d71e86d8eaf2") << QString("d7e300e168f60063");
02168     QTest::newRow("17") << QString("77d6c182e4ddd444d614bcff98fb13")
02169             << QString("cb50dec4728fc2f1a1a5dfb84fa1bd25")
02170             << QString("f73c8c3355092eb6") << QString("2e0db2552bb83ad3");
02171     QTest::newRow("18") << QString("40aed22f93dcfcb1d734b7e4657dd31a")
02172             << QString("66d17a6e9d5be3281e857b4c7e497988ca684524fd994882")
02173             << QString("dd006f15e727cb62") << QString("b256dc4fdb58451b");
02174     QTest::newRow("19") << QString("bb25564c7ea1e5bd22016915805c27b51b")
02175             << QString("b7ceb5f5ed2945f131064bbb9213694b19a04fbd1f138866")
02176             << QString("df70ff987582ccfe") << QString("88bb3b9bb2ea56d7");
02177     QTest::newRow("20") << QString("49dab8d85ea753cf4ae2ece7a80f0784e42b")
02178             << QString("d7fce9e5bed161ad7d950e453677e5bee422b7542afc0bd3")
02179             << QString("747e09fa9ba257dc") << QString("f1bbd406191de0d1");
02180     QTest::newRow("21") << QString("dc13a6abaa35ceb3e6650f825a67942114af2e")
02181             << QString("bafdb50e16c9ff4449bf336d410441d56e1e5335b54c9f11")
02182             << QString("cdad411d0fa80e9d") << QString("c83d55b1196958c4");
02183     QTest::newRow("22") << QString("a8896d88907ad77ae790828c0a3384c1614e07d9")
02184             << QString("70a9eb1c11bfd1b1d68c20a6b72c869dac5372a8ed46aa07")
02185             << QString("642d12c591f6a4f4") << QString("c17d0c69067af296");
02186     QTest::newRow("23") << QString("b3fec4cc29dc1abbcf7d86f01d2c02c2a723e7c2f8")
02187             << QString("48ed5583a04d333ffac9d6462fd96bf79222eeec70a6ae70")
02188             << QString("62c62f54c426c59f") << QString("cb6252ca271ff303");
02189     QTest::newRow("24") << QString("ac0b4d5752d2009bdcd42314d9723716294146424542")
02190             << QString("8a284713f8c9873ad5f558b995c5a67a66557a52601975d1")
02191             << QString("386dcad5eae86830") << QString("48153b966c8d686d");
02192     QTest::newRow("25") << QString("ea331f6e518a8aeab2ef0a4e92e0d198df5dd0cc74369e")
02193             << QString("6d3d7de9938935f9fb9af839e416ef6f842f2ed827334bfb")
02194             << QString("782545ea65d89b01") << QString("c2ce203020aabb0a");
02195     QTest::newRow("26") << QString("b292d3a3fdc5d709709c87ef91122761847871f9b4e33426")
02196             << QString("21dae17d157192146b52c49d90f898b25d0d1dfe677e8cd5b568814e9c6bb6a8")
02197             << QString("ecc650e1ed1ce8a0") << QString("aebc43ab811ab5f1");
02198     QTest::newRow("27") << QString("65026a8a41edc1d880f6c90be9277b3504d524e47ec7a77db9")
02199             << QString("a3b6404c4d87f72d5e0995d7cc20ece742d9705d48524cfa2820317087faf578")
02200             << QString("4755b8639fd7c8a1") << QString("4152e22f14baaf0a");
02201     QTest::newRow("28") << QString("d1d3d8675e42a4242fba0ae8510bb0fb39946c7293a8427bcb3b")
02202             << QString("db621f2fac9a924c83ed0b9e8acec9f1e23bf3ff2ad6efa814903f2ce293107b")
02203             << QString("92a18b78a25c4b7a") << QString("c3aabc68ceeb22d9");
02204     QTest::newRow("29") << QString("c8a3971efda18af1b18bfad98f69329672e546c969294922cbe7e1")
02205             << QString("940c610a41f04e7d9be0a74d5d00fe97a2647d3d16e9b76ff0db5bbdc197c82a")
02206             << QString("2341239c09c73427") << QString("c4d5b2b6863db060");
02207     QTest::newRow("30") << QString("d72e81f4130107e396d5fb272f03c36de4f78e1399fd2e8848f33fe7")
02208             << QString("7d495cba50c4127347e3ad29e3b8c098a3312782e3d45abfa1621f64bf8b8a06")
02209             << QString("166ea8ed9d29e1b0") << QString("2be993c1be8fe9ed");
02210     QTest::newRow("31") << QString("77d6c182e4ddd444d614bcff98fb13f73c8c3355092eb62e0db2552bb8")
02211             << QString("9d926142271e814ba4603509187c9020daa0d50f15af6e698e384644e9468c11")
02212             << QString("3ad3301094b2f471") << QString("8638489af44732f0");
02213     QTest::newRow("32") << QString("bb9a90f11551531de512dd48270e3007d71e86d8eaf2d7e300e168f60063")
02214             << QString("44858416f946c7fbdffd720282881630803803ab91ceab1af4f68f50e9c16dce")
02215             << QString("04bbfd95ac12e6ff") << QString("30cb120d13391c44");
02216     QTest::newRow("33") << QString("8eb8faf49126ad5b8a0aa6df8b52dbe50dd5aed271641ef983bd650da69816")
02217             << QString("5b4622f1c4faa817ee3ac181b969a7afed7117e23f68bc6017519a7d1399cfe9")
02218             << QString("35501029e137d63d") << QString("c1e0e3a06b357b51");
02219 }
02220 
02221 void CipherUnitTest::des_cbc_pkcs7()
02222 {
02223     QStringList providersToTest;
02224     providersToTest.append("qca-ossl");
02225