Katana_mirror/katie
1
0
Fork 0
mirror of https://bitbucket.org/smil3y/katie.git synced 2025-02-24 19:02:59 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
katie/tests/auto/qcryptographichash/tst_qcryptographichash.cpp
Ivailo Monev 6789138092 fix hash collision when input data has odd length for Katie's hash algorithm 
benchmark result:
********* Start testing of tst_qcryptographichash *********
Config: Using QTest library 4.12.0, Katie 4.12.0
PASS  : tst_qcryptographichash::initTestCase()
RESULT   : tst_qcryptographichash::append():"10 (Md5)":
     2,836.51288 CPU ticks per iteration (total: 567,302,577, iterations: 200000)
RESULT   : tst_qcryptographichash::append():"10 (Sha1)":
     3,380.76135 CPU ticks per iteration (total: 676,152,271, iterations: 200000)
RESULT   : tst_qcryptographichash::append():"10 (Sha256)":
     4,717.55225 CPU ticks per iteration (total: 943,510,450, iterations: 200000)
RESULT   : tst_qcryptographichash::append():"10 (Sha512)":
     3,633.18907 CPU ticks per iteration (total: 726,637,814, iterations: 200000)
RESULT   : tst_qcryptographichash::append():"10 (KAT)":
     1,379.36299 CPU ticks per iteration (total: 275,872,598, iterations: 200000)
RESULT   : tst_qcryptographichash::append():"100 (Md5)":
     659.939485 CPU ticks per iteration (total: 131,987,897, iterations: 200000)
RESULT   : tst_qcryptographichash::append():"100 (Sha1)":
     1,114.46593 CPU ticks per iteration (total: 222,893,186, iterations: 200000)
RESULT   : tst_qcryptographichash::append():"100 (Sha256)":
     951.730590 CPU ticks per iteration (total: 190,346,118, iterations: 200000)
RESULT   : tst_qcryptographichash::append():"100 (Sha512)":
     1,075.35127 CPU ticks per iteration (total: 215,070,254, iterations: 200000)
RESULT   : tst_qcryptographichash::append():"100 (KAT)":
     737.365180 CPU ticks per iteration (total: 147,473,036, iterations: 200000)
RESULT   : tst_qcryptographichash::append():"250 (Md5)":
     602.405905 CPU ticks per iteration (total: 120,481,181, iterations: 200000)
RESULT   : tst_qcryptographichash::append():"250 (Sha1)":
     1,365.34060 CPU ticks per iteration (total: 273,068,121, iterations: 200000)
RESULT   : tst_qcryptographichash::append():"250 (Sha256)":
     902.280725 CPU ticks per iteration (total: 180,456,145, iterations: 200000)
RESULT   : tst_qcryptographichash::append():"250 (Sha512)":
     1,023.72560 CPU ticks per iteration (total: 204,745,120, iterations: 200000)
RESULT   : tst_qcryptographichash::append():"250 (KAT)":
     630.126650 CPU ticks per iteration (total: 126,025,330, iterations: 200000)
RESULT   : tst_qcryptographichash::append():"500 (Md5)":
     583.649140 CPU ticks per iteration (total: 116,729,828, iterations: 200000)
RESULT   : tst_qcryptographichash::append():"500 (Sha1)":
     1,401.99279 CPU ticks per iteration (total: 280,398,558, iterations: 200000)
RESULT   : tst_qcryptographichash::append():"500 (Sha256)":
     884.796720 CPU ticks per iteration (total: 176,959,344, iterations: 200000)
RESULT   : tst_qcryptographichash::append():"500 (Sha512)":
     1,006.34675 CPU ticks per iteration (total: 201,269,350, iterations: 200000)
RESULT   : tst_qcryptographichash::append():"500 (KAT)":
     614.444045 CPU ticks per iteration (total: 122,888,809, iterations: 200000)
PASS  : tst_qcryptographichash::append()
RESULT   : tst_qcryptographichash::append_once():"Md5":
     1,573.19717 CPU ticks per iteration (total: 314,639,435, iterations: 200000)
RESULT   : tst_qcryptographichash::append_once():"Sha1":
     2,170.39628 CPU ticks per iteration (total: 434,079,257, iterations: 200000)
RESULT   : tst_qcryptographichash::append_once():"Sha256":
     4,227.21736 CPU ticks per iteration (total: 845,443,473, iterations: 200000)
RESULT   : tst_qcryptographichash::append_once():"Sha512":
     3,182.38488 CPU ticks per iteration (total: 636,476,976, iterations: 200000)
RESULT   : tst_qcryptographichash::append_once():"KAT":
     785.406275 CPU ticks per iteration (total: 157,081,255, iterations: 200000)
PASS  : tst_qcryptographichash::append_once()
RESULT   : tst_qcryptographichash::statichash():"Md5":
     1,492.78744 CPU ticks per iteration (total: 298,557,489, iterations: 200000)
RESULT   : tst_qcryptographichash::statichash():"Sha1":
     2,078.32221 CPU ticks per iteration (total: 415,664,442, iterations: 200000)
RESULT   : tst_qcryptographichash::statichash():"Sha256":
     4,147.89762 CPU ticks per iteration (total: 829,579,525, iterations: 200000)
RESULT   : tst_qcryptographichash::statichash():"Sha512":
     3,076.56835 CPU ticks per iteration (total: 615,313,671, iterations: 200000)
RESULT   : tst_qcryptographichash::statichash():"KAT":
     746.683995 CPU ticks per iteration (total: 149,336,799, iterations: 200000)
PASS  : tst_qcryptographichash::statichash()
PASS  : tst_qcryptographichash::cleanupTestCase()
Totals: 5 passed, 0 failed, 0 skipped
********* Finished testing of tst_qcryptographichash *********

Signed-off-by: Ivailo Monev <xakepa10@gmail.com>
2022-03-22 18:50:10 +02:00

250 lines
12 KiB
C++
Raw Blame History

/****************************************************************************
**
** Copyright (C) 2015 The Qt Company Ltd.
** Copyright (C) 2016 Ivailo Monev
**
** This file is part of the test suite of the Katie Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
**
** GNU Lesser General Public License Usage
** This file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include <QtTest/QtTest>
#include <QCryptographicHash>
#include <QDebug>
Q_DECLARE_METATYPE(QCryptographicHash::Algorithm)
class tst_QCryptographicHash : public QObject
{
Q_OBJECT
private slots:
void repeated_result_data();
void repeated_result();
void intermediary_result_data();
void intermediary_result();
void static_vs_incremental_result_data();
void static_vs_incremental_result();
void collision_data();
void collision();
};
void tst_QCryptographicHash::repeated_result_data()
{
intermediary_result_data();
}
void tst_QCryptographicHash::repeated_result()
{
QFETCH(QCryptographicHash::Algorithm, algo);
QCryptographicHash hash(algo);
QFETCH(QByteArray, first);
hash.addData(first);
QFETCH(QByteArray, hash_first);
QByteArray result = hash.result();
QCOMPARE(result, hash_first);
QCOMPARE(result, hash.result());
hash.reset();
hash.addData(first);
result = hash.result();
QCOMPARE(result, hash_first);
QCOMPARE(result, hash.result());
}
void tst_QCryptographicHash::intermediary_result_data()
{
QTest::addColumn<QCryptographicHash::Algorithm>("algo");
QTest::addColumn<QByteArray>("first");
QTest::addColumn<QByteArray>("second");
QTest::addColumn<QByteArray>("hash_first");
QTest::addColumn<QByteArray>("hash_firstsecond");
QTest::newRow("md5") << QCryptographicHash::Md5
<< QByteArray("abc") << QByteArray("abc")
<< QByteArray::fromHex("900150983CD24FB0D6963F7D28E17F72")
<< QByteArray::fromHex("440AC85892CA43AD26D44C7AD9D47D3E");
QTest::newRow("sha1") << QCryptographicHash::Sha1
<< QByteArray("abc") << QByteArray("abc")
<< QByteArray::fromHex("A9993E364706816ABA3E25717850C26C9CD0D89D")
<< QByteArray::fromHex("F8C1D87006FBF7E5CC4B026C3138BC046883DC71");
QTest::newRow("sha256") << QCryptographicHash::Sha256
<< QByteArray("abc") << QByteArray("abc")
<< QByteArray::fromHex("BA7816BF8F01CFEA414140DE5DAE2223B00361A396177A9CB410FF61F20015AD")
<< QByteArray::fromHex("BBB59DA3AF939F7AF5F360F2CEB80A496E3BAE1CD87DDE426DB0AE40677E1C2C");
QTest::newRow("sha512") << QCryptographicHash::Sha512
<< QByteArray("abc") << QByteArray("abc")
<< QByteArray::fromHex("DDAF35A193617ABACC417349AE20413112E6FA4E89A97EA20A9EEEE64B55D39A2192992A274FC1A836BA3C23A3FEEBBD454D4423643CE80E2A9AC94FA54CA49F")
<< QByteArray::fromHex("F3C41E7B63EE869596FC28BAD64120612C520F65928AB4D126C72C6998B551B8FF1CEDDFED4373E6717554DC89D1EEE6F0AB22FD3675E561ABA9AE26A3EEC53B");
QTest::newRow("KAT") << QCryptographicHash::KAT
<< QByteArray("abc") << QByteArray("abc")
<< QByteArray::fromHex("A96FAF705AF16834E6C632B61E964E1F8C19F5792EBF862E22775E3BD96F68BF")
<< QByteArray::fromHex("B9FE94D346D39B20369242A646A19333757D229E18328270F7B354793BCE8D36");
}
void tst_QCryptographicHash::intermediary_result()
{
QFETCH(QCryptographicHash::Algorithm, algo);
QCryptographicHash hash(algo);
QFETCH(QByteArray, first);
hash.addData(first);
QFETCH(QByteArray, hash_first);
QByteArray result = hash.result();
// qDebug() << result.toHex().toUpper();
QCOMPARE(result, hash_first);
// don't reset
QFETCH(QByteArray, second);
QFETCH(QByteArray, hash_firstsecond);
hash.addData(second);
result = hash.result();
// qDebug() << result.toHex().toUpper();
QCOMPARE(result, hash_firstsecond);
}
void tst_QCryptographicHash::static_vs_incremental_result_data()
{
QTest::addColumn<QCryptographicHash::Algorithm>("algo");
QTest::addColumn<QByteArray>("first");
QTest::addColumn<QByteArray>("second");
QTest::addColumn<QByteArray>("third");
QTest::newRow("123 (Md5)") << QCryptographicHash::Md5 << QByteArray("1") << QByteArray("2") << QByteArray("3");
QTest::newRow("1bar3 (Md5)") << QCryptographicHash::Md5 << QByteArray("1") << QByteArray("bar") << QByteArray("3");
QTest::newRow("12baz (Md5)") << QCryptographicHash::Md5 << QByteArray("1") << QByteArray("2") << QByteArray("baz");
QTest::newRow("foobarbaz (Md5)") << QCryptographicHash::Md5 << QByteArray("foo") << QByteArray("bar") << QByteArray("baz");
QTest::newRow("123 (Sha1)") << QCryptographicHash::Sha1 << QByteArray("1") << QByteArray("2") << QByteArray("3");
QTest::newRow("1bar3 (Sha1)") << QCryptographicHash::Sha1 << QByteArray("1") << QByteArray("bar") << QByteArray("3");
QTest::newRow("12baz (Sha1)") << QCryptographicHash::Sha1 << QByteArray("1") << QByteArray("2") << QByteArray("baz");
QTest::newRow("foobarbaz (Sha1)") << QCryptographicHash::Sha1 << QByteArray("foo") << QByteArray("bar") << QByteArray("baz");
QTest::newRow("123 (Sha256)") << QCryptographicHash::Sha256 << QByteArray("1") << QByteArray("2") << QByteArray("3");
QTest::newRow("1bar3 (Sha256)") << QCryptographicHash::Sha256 << QByteArray("1") << QByteArray("bar") << QByteArray("3");
QTest::newRow("12baz (Sha256)") << QCryptographicHash::Sha256 << QByteArray("1") << QByteArray("2") << QByteArray("baz");
QTest::newRow("foobarbaz (Sha256)") << QCryptographicHash::Sha256 << QByteArray("foo") << QByteArray("bar") << QByteArray("baz");
QTest::newRow("123 (Sha512)") << QCryptographicHash::Sha512 << QByteArray("1") << QByteArray("2") << QByteArray("3");
QTest::newRow("1bar3 (Sha512)") << QCryptographicHash::Sha512 << QByteArray("1") << QByteArray("bar") << QByteArray("3");
QTest::newRow("12baz (Sha512)") << QCryptographicHash::Sha512 << QByteArray("1") << QByteArray("2") << QByteArray("baz");
QTest::newRow("foobarbaz (Sha512)") << QCryptographicHash::Sha512 << QByteArray("foo") << QByteArray("bar") << QByteArray("baz");
QTest::newRow("123 (KAT)") << QCryptographicHash::KAT << QByteArray("1") << QByteArray("2") << QByteArray("3");
QTest::newRow("1bar3 (KAT)") << QCryptographicHash::KAT << QByteArray("1") << QByteArray("bar") << QByteArray("3");
QTest::newRow("12baz (KAT)") << QCryptographicHash::KAT << QByteArray("1") << QByteArray("2") << QByteArray("baz");
QTest::newRow("foobarbaz (KAT)") << QCryptographicHash::KAT << QByteArray("foo") << QByteArray("bar") << QByteArray("baz");
}
void tst_QCryptographicHash::static_vs_incremental_result()
{
QFETCH(QCryptographicHash::Algorithm, algo);
QFETCH(QByteArray, first);
QFETCH(QByteArray, second);
QFETCH(QByteArray, third);
QCryptographicHash incrementalhash(algo);
incrementalhash.addData(first);
incrementalhash.addData(second);
incrementalhash.addData(third);
const QByteArray incrementalresult = incrementalhash.result();
const QByteArray staticresult = QCryptographicHash::hash(first + second + third, algo);
// qDebug() << incrementalresult.toHex() << staticresult.toHex();
if (algo == QCryptographicHash::KAT) {
QEXPECT_FAIL("", "This is expected behaviour currently", Continue);
}
QCOMPARE(incrementalresult, staticresult);
}
void tst_QCryptographicHash::collision_data()
{
QTest::addColumn<QCryptographicHash::Algorithm>("algo");
QTest::addColumn<QByteArray>("data");
QTest::addColumn<QByteArray>("data2");
QTest::addColumn<bool>("incremental");
QTest::newRow("1vs2 (Md5)") << QCryptographicHash::Md5 << QByteArray("1") << QByteArray("2") << false;
QTest::newRow("1vs2 (Md5)") << QCryptographicHash::Md5 << QByteArray("1") << QByteArray("2") << true;
QTest::newRow("122vs222 (Md5)") << QCryptographicHash::Md5 << QByteArray("122") << QByteArray("222") << true;
QTest::newRow("122vs222 (Md5)") << QCryptographicHash::Md5 << QByteArray("122") << QByteArray("222") << false;
QTest::newRow("221vs222 (Md5)") << QCryptographicHash::Md5 << QByteArray("221") << QByteArray("222") << true;
QTest::newRow("221vs222 (Md5)") << QCryptographicHash::Md5 << QByteArray("221") << QByteArray("222") << false;
QTest::newRow("1vs2 (Sha1)") << QCryptographicHash::Sha1 << QByteArray("1") << QByteArray("2") << false;
QTest::newRow("1vs2 (Sha1)") << QCryptographicHash::Sha1 << QByteArray("1") << QByteArray("2") << true;
QTest::newRow("122vs222 (Sha1)") << QCryptographicHash::Sha1 << QByteArray("122") << QByteArray("222") << true;
QTest::newRow("122vs222 (Sha1)") << QCryptographicHash::Sha1 << QByteArray("122") << QByteArray("222") << false;
QTest::newRow("221vs222 (Sha1)") << QCryptographicHash::Sha1 << QByteArray("221") << QByteArray("222") << true;
QTest::newRow("221vs222 (Sha1)") << QCryptographicHash::Sha1 << QByteArray("221") << QByteArray("222") << false;
QTest::newRow("1vs2 (Sha256)") << QCryptographicHash::Sha256 << QByteArray("1") << QByteArray("2") << false;
QTest::newRow("1vs2 (Sha256)") << QCryptographicHash::Sha256 << QByteArray("1") << QByteArray("2") << true;
QTest::newRow("122vs222 (Sha256)") << QCryptographicHash::Sha256 << QByteArray("122") << QByteArray("222") << true;
QTest::newRow("122vs222 (Sha256)") << QCryptographicHash::Sha256 << QByteArray("122") << QByteArray("222") << false;
QTest::newRow("221vs222 (Sha256)") << QCryptographicHash::Sha256 << QByteArray("221") << QByteArray("222") << true;
QTest::newRow("221vs222 (Sha256)") << QCryptographicHash::Sha256 << QByteArray("221") << QByteArray("222") << false;
QTest::newRow("1vs2 (Sha512)") << QCryptographicHash::Sha512 << QByteArray("1") << QByteArray("2") << false;
QTest::newRow("1vs2 (Sha512)") << QCryptographicHash::Sha512 << QByteArray("1") << QByteArray("2") << true;
QTest::newRow("122vs222 (Sha512)") << QCryptographicHash::Sha512 << QByteArray("122") << QByteArray("222") << true;
QTest::newRow("122vs222 (Sha512)") << QCryptographicHash::Sha512 << QByteArray("122") << QByteArray("222") << false;
QTest::newRow("221vs222 (Sha512)") << QCryptographicHash::Sha512 << QByteArray("221") << QByteArray("222") << true;
QTest::newRow("221vs222 (Sha512)") << QCryptographicHash::Sha512 << QByteArray("221") << QByteArray("222") << false;
QTest::newRow("1vs2 (KAT)") << QCryptographicHash::KAT << QByteArray("1") << QByteArray("2") << false;
QTest::newRow("1vs2 (KAT)") << QCryptographicHash::KAT << QByteArray("1") << QByteArray("2") << true;
QTest::newRow("122vs222 (KAT)") << QCryptographicHash::KAT << QByteArray("122") << QByteArray("222") << true;
QTest::newRow("122vs222 (KAT)") << QCryptographicHash::KAT << QByteArray("122") << QByteArray("222") << false;
QTest::newRow("221vs222 (KAT)") << QCryptographicHash::KAT << QByteArray("221") << QByteArray("222") << true;
QTest::newRow("221vs222 (KAT)") << QCryptographicHash::KAT << QByteArray("221") << QByteArray("222") << false;
}
void tst_QCryptographicHash::collision()
{
QFETCH(QCryptographicHash::Algorithm, algo);
QFETCH(QByteArray, data);
QFETCH(QByteArray, data2);
QFETCH(bool, incremental);
if (incremental) {
QCryptographicHash incrementalhash(algo);
incrementalhash.addData(data);
const QByteArray incrementalresult = incrementalhash.result();
QCryptographicHash incrementalhash2(algo);
incrementalhash2.addData(data2);
const QByteArray incrementalresult2 = incrementalhash2.result();
QVERIFY(incrementalresult != incrementalresult2);
} else {
const QByteArray staticresult = QCryptographicHash::hash(data, algo);
const QByteArray staticresult2 = QCryptographicHash::hash(data2, algo);
QVERIFY(staticresult != staticresult2);
}
}
QTEST_MAIN(tst_QCryptographicHash)
#include "moc_tst_qcryptographichash.cpp"
Reference in a new issue View git blame Copy permalink