/**
 * Copyright (C)  2004-2006  Brad Hards <bradh@frogmouth.net>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <QtCrypto>
#include <QtTest/QtTest>

#ifdef QT_STATICPLUGIN
#include "import_plugins.h"
#endif

class MACUnitTest : public QObject
{
    Q_OBJECT

private Q_SLOTS:
    void initTestCase();
    void cleanupTestCase();
    void HMACMD5();
    void HMACSHA1();
    void HMACSHA256();
    void HMACSHA224();
    void HMACSHA384();
    void HMACSHA512();
    void HMACRMD160();

private:
    QCA::Initializer *m_init;
};

void MACUnitTest::initTestCase()
{
    m_init = new QCA::Initializer;
}

void MACUnitTest::cleanupTestCase()
{
    delete m_init;
}

void MACUnitTest::HMACMD5()
{
    QStringList providersToTest;
    providersToTest.append(QStringLiteral("qca-ossl"));
    providersToTest.append(QStringLiteral("qca-gcrypt"));
    providersToTest.append(QStringLiteral("qca-botan"));
    providersToTest.append(QStringLiteral("qca-nss"));

    foreach (const QString provider, providersToTest) {
        if (!QCA::isSupported("hmac(md5)", provider))
            QWARN((QStringLiteral("HMAC(MD5) not supported for ") + provider).toLocal8Bit().constData());
        else {
            QCA::MessageAuthenticationCode md5hmacLenTest(QStringLiteral("hmac(md5)"), QCA::SymmetricKey(), provider);
            QCOMPARE(md5hmacLenTest.validKeyLength(0), true);
            QCOMPARE(md5hmacLenTest.validKeyLength(1), true);
            QCOMPARE(md5hmacLenTest.validKeyLength(848888), true);
            QCOMPARE(md5hmacLenTest.validKeyLength(-2), false);

            QCA::MessageAuthenticationCode copy = md5hmacLenTest;
            copy.context(); // detach

            // These tests are from RFC2202, Section 2.
            // The first three are also in the Appendix to RFC2104
            QCA::MessageAuthenticationCode md5hmac1(QStringLiteral("hmac(md5)"), QCA::SymmetricKey(), provider);
            QCA::SymmetricKey              key1(QCA::SecureArray("Jefe"));
            md5hmac1.setup(key1);
            QCA::SecureArray data1("what do ya want for nothing?");
            md5hmac1.update(data1);
            QCOMPARE(QCA::arrayToHex(md5hmac1.final().toByteArray()),
                     QStringLiteral("750c783e6ab0b503eaa86e310a5db738"));

            QCA::MessageAuthenticationCode md5hmac2(QStringLiteral("hmac(md5)"), QCA::SymmetricKey(), provider);
            QCA::SymmetricKey              key2(QCA::hexToArray(QStringLiteral("0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b")));
            md5hmac2.setup(key2);
            QCA::SecureArray data2 = QCA::SecureArray("Hi There");
            md5hmac2.update(data2);
            QCOMPARE(QCA::arrayToHex(md5hmac2.final().toByteArray()),
                     QStringLiteral("9294727a3638bb1c13f48ef8158bfc9d"));

            // test reuse
            md5hmac2.clear();
            QCA::SymmetricKey key3(QCA::hexToArray(QStringLiteral("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA")));
            md5hmac2.setup(key3);
            QCA::SecureArray data3(50);
            for (int i = 0; i < data3.size(); i++)
                data3[i] = (char)0xDD;
            md5hmac2.update(data3);
            QCOMPARE(QCA::arrayToHex(md5hmac2.final().toByteArray()),
                     QStringLiteral("56be34521d144c88dbb8c733f0e8b3f6"));

            QCA::SymmetricKey key4(
                QCA::hexToArray(QStringLiteral("0102030405060708090a0b0c0d0e0f10111213141516171819")));
            QCA::MessageAuthenticationCode md5hmac4(QStringLiteral("hmac(md5)"), key4, provider);
            QCA::SecureArray               data4(50);
            for (int i = 0; i < data4.size(); i++)
                data4[i] = (char)0xcd;
            md5hmac4.update(data4);
            QCOMPARE(QCA::arrayToHex(md5hmac4.final().toByteArray()),
                     QStringLiteral("697eaf0aca3a3aea3a75164746ffaa79"));

            QCA::MessageAuthenticationCode md5hmac5(QStringLiteral("hmac(md5)"), QCA::SecureArray());
            QCA::SymmetricKey              key5(QCA::hexToArray(QStringLiteral("0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c")));
            md5hmac5.setup(key5);
            QCA::SecureArray data5("Test With Truncation");
            md5hmac5.update(data5);
            QCOMPARE(QCA::arrayToHex(md5hmac5.final().toByteArray()),
                     QStringLiteral("56461ef2342edc00f9bab995690efd4c"));

            QCA::MessageAuthenticationCode md5hmac6(QStringLiteral("hmac(md5)"), QCA::SymmetricKey(), provider);
            QCA::SymmetricKey              key6(80);
            for (int i = 0; i < key6.size(); i++)
                key6[i] = (char)0xaa;
            md5hmac6.setup(key6);
            QCA::SecureArray data6("Test Using Larger Than Block-Size Key - Hash Key First");
            md5hmac6.update(data6);
            QCOMPARE(QCA::arrayToHex(md5hmac6.final().toByteArray()),
                     QStringLiteral("6b1ab7fe4bd7bf8f0b62e6ce61b9d0cd"));

            md5hmac6.clear(); // reuse the same key
            QCA::SecureArray data7("Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data");
            md5hmac6.update(data7);
            QCOMPARE(QCA::arrayToHex(md5hmac6.final().toByteArray()),
                     QStringLiteral("6f630fad67cda0ee1fb1f562db3aa53e"));
        }
    }
}

void MACUnitTest::HMACSHA256()
{
    QStringList providersToTest;
    providersToTest.append(QStringLiteral("qca-ossl"));
    providersToTest.append(QStringLiteral("qca-gcrypt"));
    providersToTest.append(QStringLiteral("qca-botan"));
    providersToTest.append(QStringLiteral("qca-nss"));

    foreach (const QString provider, providersToTest) {
        if (!QCA::isSupported("hmac(sha256)", provider))
            QWARN((QStringLiteral("HMAC(SHA256) not supported for ") + provider).toLocal8Bit().constData());
        else {
            QCA::MessageAuthenticationCode hmacLenTest(QStringLiteral("hmac(sha256)"), QCA::SymmetricKey(), provider);
            QCOMPARE(hmacLenTest.validKeyLength(0), true);
            QCOMPARE(hmacLenTest.validKeyLength(1), true);
            QCOMPARE(hmacLenTest.validKeyLength(848888), true);
            QCOMPARE(hmacLenTest.validKeyLength(-2), false);

            QCA::MessageAuthenticationCode copy = hmacLenTest;
            copy.context(); // detach

            QCA::MessageAuthenticationCode hmac1(QStringLiteral("hmac(sha256)"), QCA::SymmetricKey(), provider);
            QCA::SymmetricKey              key1(QCA::SecureArray("Jefe"));
            hmac1.setup(key1);
            QCA::SecureArray data1("what do ya want for nothing?");
            hmac1.update(data1);
            QCOMPARE(QCA::arrayToHex(hmac1.final().toByteArray()),
                     QStringLiteral("5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843"));

            QCA::MessageAuthenticationCode hmac2(QStringLiteral("hmac(sha256)"), QCA::SymmetricKey(), provider);
            QCA::SymmetricKey key2(QCA::hexToArray(QStringLiteral("0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b")));
            hmac2.setup(key2);
            QCA::SecureArray data2 = QCA::SecureArray("Hi There");
            hmac2.update(data2);
            QCOMPARE(QCA::arrayToHex(hmac2.final().toByteArray()),
                     QStringLiteral("b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7"));

            // test reuse
            hmac2.clear();
            QCA::SymmetricKey key3(QCA::hexToArray(QStringLiteral("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")));
            hmac2.setup(key3);
            QCA::SecureArray data3(50);
            for (int i = 0; i < data3.size(); i++)
                data3[i] = (char)0xDD;
            hmac2.update(data3);
            QCOMPARE(QCA::arrayToHex(hmac2.final().toByteArray()),
                     QStringLiteral("773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514ced565fe"));

            QCA::SymmetricKey key4(
                QCA::hexToArray(QStringLiteral("0102030405060708090a0b0c0d0e0f10111213141516171819")));
            QCA::MessageAuthenticationCode hmac4(QStringLiteral("hmac(sha256)"), key4, provider);
            QCA::SecureArray               data4(50);
            for (int i = 0; i < data4.size(); i++)
                data4[i] = (char)0xcd;
            hmac4.update(data4);
            QCOMPARE(QCA::arrayToHex(hmac4.final().toByteArray()),
                     QStringLiteral("82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff46729665b"));

            QCA::MessageAuthenticationCode hmac5(QStringLiteral("hmac(sha256)"), QCA::SymmetricKey(), provider);
            QCA::SymmetricKey key5(QCA::hexToArray(QStringLiteral("0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c")));
            hmac5.setup(key5);
            QCA::SecureArray data5("Test With Truncation");
            hmac5.update(data5);
            QString resultWithTrunc = QCA::arrayToHex(hmac5.final().toByteArray());
            resultWithTrunc.resize(32);
            QCOMPARE(resultWithTrunc, QStringLiteral("a3b6167473100ee06e0c796c2955552b"));

            QCA::MessageAuthenticationCode hmac6(QStringLiteral("hmac(sha256)"), QCA::SymmetricKey(), provider);
            QCA::SymmetricKey              key6(131);
            for (int i = 0; i < key6.size(); i++)
                key6[i] = (char)0xaa;
            hmac6.setup(key6);
            QCA::SecureArray data6("Test Using Larger Than Block-Size Key - Hash Key First");
            hmac6.update(data6);
            QCOMPARE(QCA::arrayToHex(hmac6.final().toByteArray()),
                     QStringLiteral("60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f0ee37f54"));

            hmac6.clear(); // reuse the same key
            QCA::SecureArray data7(
                "This is a test using a larger than block-size key and a larger than block-size data. The key needs to "
                "be hashed before being used by the HMAC algorithm.");
            hmac6.update(data7);
            QCOMPARE(QCA::arrayToHex(hmac6.final().toByteArray()),
                     QStringLiteral("9b09ffa71b942fcb27635fbcd5b0e944bfdc63644f0713938a7f51535c3a35e2"));
        }
    }
}

void MACUnitTest::HMACSHA224()
{
    QStringList providersToTest;
    providersToTest.append(QStringLiteral("qca-ossl"));
    providersToTest.append(QStringLiteral("qca-gcrypt"));
    providersToTest.append(QStringLiteral("qca-botan"));

    foreach (const QString provider, providersToTest) {
        if (!QCA::isSupported("hmac(sha224)", provider))
            QWARN((QStringLiteral("HMAC(SHA224) not supported for ") + provider).toLocal8Bit().constData());
        else {
            QCA::MessageAuthenticationCode hmacLenTest(QStringLiteral("hmac(sha224)"), QCA::SymmetricKey(), provider);
            QCOMPARE(hmacLenTest.validKeyLength(0), true);
            QCOMPARE(hmacLenTest.validKeyLength(1), true);
            QCOMPARE(hmacLenTest.validKeyLength(848888), true);
            QCOMPARE(hmacLenTest.validKeyLength(-2), false);

            QCA::MessageAuthenticationCode copy = hmacLenTest;
            copy.context(); // detach

            QCA::MessageAuthenticationCode hmac1(QStringLiteral("hmac(sha224)"), QCA::SymmetricKey(), provider);
            QCA::SymmetricKey              key1(QCA::SecureArray("Jefe"));
            hmac1.setup(key1);
            QCA::SecureArray data1("what do ya want for nothing?");
            hmac1.update(data1);
            QCOMPARE(QCA::arrayToHex(hmac1.final().toByteArray()),
                     QStringLiteral("a30e01098bc6dbbf45690f3a7e9e6d0f8bbea2a39e6148008fd05e44"));

            QCA::MessageAuthenticationCode hmac2(QStringLiteral("hmac(sha224)"), QCA::SymmetricKey(), provider);
            QCA::SymmetricKey key2(QCA::hexToArray(QStringLiteral("0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b")));
            hmac2.setup(key2);
            QCA::SecureArray data2 = QCA::SecureArray("Hi There");
            hmac2.update(data2);
            QCOMPARE(QCA::arrayToHex(hmac2.final().toByteArray()),
                     QStringLiteral("896fb1128abbdf196832107cd49df33f47b4b1169912ba4f53684b22"));

            // test reuse
            hmac2.clear();
            QCA::SymmetricKey key3(QCA::hexToArray(QStringLiteral("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")));
            hmac2.setup(key3);
            QCA::SecureArray data3(50);
            for (int i = 0; i < data3.size(); i++)
                data3[i] = (char)0xDD;
            hmac2.update(data3);
            QCOMPARE(QCA::arrayToHex(hmac2.final().toByteArray()),
                     QStringLiteral("7fb3cb3588c6c1f6ffa9694d7d6ad2649365b0c1f65d69d1ec8333ea"));

            QCA::SymmetricKey key4(
                QCA::hexToArray(QStringLiteral("0102030405060708090a0b0c0d0e0f10111213141516171819")));
            QCA::MessageAuthenticationCode hmac4(QStringLiteral("hmac(sha224)"), key4, provider);
            QCA::SecureArray               data4(50);
            for (int i = 0; i < data4.size(); i++)
                data4[i] = (char)0xcd;
            hmac4.update(data4);
            QCOMPARE(QCA::arrayToHex(hmac4.final().toByteArray()),
                     QStringLiteral("6c11506874013cac6a2abc1bb382627cec6a90d86efc012de7afec5a"));

            QCA::MessageAuthenticationCode hmac5(QStringLiteral("hmac(sha224)"), QCA::SymmetricKey(), provider);
            QCA::SymmetricKey key5(QCA::hexToArray(QStringLiteral("0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c")));
            hmac5.setup(key5);
            QCA::SecureArray data5("Test With Truncation");
            hmac5.update(data5);
            QString resultWithTrunc = QCA::arrayToHex(hmac5.final().toByteArray());
            resultWithTrunc.resize(32);
            QCOMPARE(resultWithTrunc, QStringLiteral("0e2aea68a90c8d37c988bcdb9fca6fa8"));

            QCA::MessageAuthenticationCode hmac6(QStringLiteral("hmac(sha224)"), QCA::SymmetricKey(), provider);
            QCA::SymmetricKey              key6(131);
            for (int i = 0; i < key6.size(); i++)
                key6[i] = (char)0xaa;
            hmac6.setup(key6);
            QCA::SecureArray data6("Test Using Larger Than Block-Size Key - Hash Key First");
            hmac6.update(data6);
            QCOMPARE(QCA::arrayToHex(hmac6.final().toByteArray()),
                     QStringLiteral("95e9a0db962095adaebe9b2d6f0dbce2d499f112f2d2b7273fa6870e"));

            hmac6.clear(); // reuse the same key
            QCA::SecureArray data7(
                "This is a test using a larger than block-size key and a larger than block-size data. The key needs to "
                "be hashed before being used by the HMAC algorithm.");
            hmac6.update(data7);
            QCOMPARE(QCA::arrayToHex(hmac6.final().toByteArray()),
                     QStringLiteral("3a854166ac5d9f023f54d517d0b39dbd946770db9c2b95c9f6f565d1"));
        }
    }
}

void MACUnitTest::HMACSHA384()
{
    QStringList providersToTest;
    providersToTest.append(QStringLiteral("qca-ossl"));
    providersToTest.append(QStringLiteral("qca-gcrypt"));
    providersToTest.append(QStringLiteral("qca-botan"));
    providersToTest.append(QStringLiteral("qca-nss"));

    foreach (const QString provider, providersToTest) {
        if (!QCA::isSupported("hmac(sha384)", provider))
            QWARN((QStringLiteral("HMAC(SHA384) not supported for ") + provider).toLocal8Bit().constData());
        else {
            QCA::MessageAuthenticationCode hmacLenTest(QStringLiteral("hmac(sha384)"), QCA::SymmetricKey(), provider);
            QCOMPARE(hmacLenTest.validKeyLength(0), true);
            QCOMPARE(hmacLenTest.validKeyLength(1), true);
            QCOMPARE(hmacLenTest.validKeyLength(848888), true);
            QCOMPARE(hmacLenTest.validKeyLength(-2), false);

            QCA::MessageAuthenticationCode copy = hmacLenTest;
            copy.context(); // detach

            QCA::MessageAuthenticationCode hmac1(QStringLiteral("hmac(sha384)"), QCA::SymmetricKey(), provider);
            QCA::SymmetricKey              key1(QCA::SecureArray("Jefe"));
            hmac1.setup(key1);
            QCA::SecureArray data1("what do ya want for nothing?");
            hmac1.update(data1);
            QCOMPARE(QCA::arrayToHex(hmac1.final().toByteArray()),
                     QStringLiteral("af45d2e376484031617f78d2b58a6b1b9c7ef464f5a01b47e42ec3736322445e8e2240ca5e69e2c78b"
                                    "3239ecfab21649"));

            QCA::MessageAuthenticationCode hmac2(QStringLiteral("hmac(sha384)"), QCA::SymmetricKey(), provider);
            QCA::SymmetricKey key2(QCA::hexToArray(QStringLiteral("0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b")));
            hmac2.setup(key2);
            QCA::SecureArray data2 = QCA::SecureArray("Hi There");
            hmac2.update(data2);
            QCOMPARE(QCA::arrayToHex(hmac2.final().toByteArray()),
                     QStringLiteral("afd03944d84895626b0825f4ab46907f15f9dadbe4101ec682aa034c7cebc59cfaea9ea9076ede7f4a"
                                    "f152e8b2fa9cb6"));

            // test reuse
            hmac2.clear();
            QCA::SymmetricKey key3(QCA::hexToArray(QStringLiteral("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")));
            hmac2.setup(key3);
            QCA::SecureArray data3(50);
            for (int i = 0; i < data3.size(); i++)
                data3[i] = (char)0xDD;
            hmac2.update(data3);
            QCOMPARE(QCA::arrayToHex(hmac2.final().toByteArray()),
                     QStringLiteral("88062608d3e6ad8a0aa2ace014c8a86f0aa635d947ac9febe83ef4e55966144b2a5ab39dc13814b94e"
                                    "3ab6e101a34f27"));

            QCA::SymmetricKey key4(
                QCA::hexToArray(QStringLiteral("0102030405060708090a0b0c0d0e0f10111213141516171819")));
            QCA::MessageAuthenticationCode hmac4(QStringLiteral("hmac(sha384)"), key4, provider);
            QCA::SecureArray               data4(50);
            for (int i = 0; i < data4.size(); i++)
                data4[i] = (char)0xcd;
            hmac4.update(data4);
            QCOMPARE(QCA::arrayToHex(hmac4.final().toByteArray()),
                     QStringLiteral("3e8a69b7783c25851933ab6290af6ca77a9981480850009cc5577c6e1f573b4e6801dd23c4a7d679cc"
                                    "f8a386c674cffb"));

            QCA::MessageAuthenticationCode hmac5(QStringLiteral("hmac(sha384)"), QCA::SecureArray(), provider);
            QCA::SymmetricKey key5(QCA::hexToArray(QStringLiteral("0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c")));
            hmac5.setup(key5);
            QCA::SecureArray data5("Test With Truncation");
            hmac5.update(data5);
            QString resultWithTrunc = QCA::arrayToHex(hmac5.final().toByteArray());
            resultWithTrunc.resize(32);
            QCOMPARE(resultWithTrunc, QStringLiteral("3abf34c3503b2a23a46efc619baef897"));

            QCA::MessageAuthenticationCode hmac6(QStringLiteral("hmac(sha384)"), QCA::SymmetricKey(), provider);
            QCA::SymmetricKey              key6(131);
            for (int i = 0; i < key6.size(); i++)
                key6[i] = (char)0xaa;
            hmac6.setup(key6);
            QCA::SecureArray data6("Test Using Larger Than Block-Size Key - Hash Key First");
            hmac6.update(data6);
            QCOMPARE(QCA::arrayToHex(hmac6.final().toByteArray()),
                     QStringLiteral("4ece084485813e9088d2c63a041bc5b44f9ef1012a2b588f3cd11f05033ac4c60c2ef6ab4030fe8296"
                                    "248df163f44952"));

            hmac6.clear(); // reuse the same key
            QCA::SecureArray data7(
                "This is a test using a larger than block-size key and a larger than block-size data. The key needs to "
                "be hashed before being used by the HMAC algorithm.");
            hmac6.update(data7);
            QCOMPARE(QCA::arrayToHex(hmac6.final().toByteArray()),
                     QStringLiteral("6617178e941f020d351e2f254e8fd32c602420feb0b8fb9adccebb82461e99c5a678cc31e799176d38"
                                    "60e6110c46523e"));
        }
    }
}

void MACUnitTest::HMACSHA512()
{
    QStringList providersToTest;
    providersToTest.append(QStringLiteral("qca-ossl"));
    providersToTest.append(QStringLiteral("qca-gcrypt"));
    providersToTest.append(QStringLiteral("qca-botan"));
    providersToTest.append(QStringLiteral("qca-nss"));

    foreach (const QString provider, providersToTest) {
        if (!QCA::isSupported("hmac(sha512)", provider))
            QWARN((QStringLiteral("HMAC(SHA512) not supported for ") + provider).toLocal8Bit().constData());
        else {
            QCA::MessageAuthenticationCode hmacLenTest(QStringLiteral("hmac(sha512)"), QCA::SymmetricKey(), provider);
            QCOMPARE(hmacLenTest.validKeyLength(0), true);
            QCOMPARE(hmacLenTest.validKeyLength(1), true);
            QCOMPARE(hmacLenTest.validKeyLength(848888), true);
            QCOMPARE(hmacLenTest.validKeyLength(-2), false);

            QCA::MessageAuthenticationCode copy = hmacLenTest;
            copy.context(); // detach

            QCA::MessageAuthenticationCode hmac1(QStringLiteral("hmac(sha512)"), QCA::SymmetricKey(), provider);
            QCA::SymmetricKey              key1(QCA::SecureArray("Jefe"));
            hmac1.setup(key1);
            QCA::SecureArray data1("what do ya want for nothing?");
            hmac1.update(data1);
            QCOMPARE(QCA::arrayToHex(hmac1.final().toByteArray()),
                     QStringLiteral("164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7ea2505549758bf75c05a994a6d"
                                    "034f65f8f0e6fdcaeab1a34d4a6b4b636e070a38bce737"));

            QCA::MessageAuthenticationCode hmac2(QStringLiteral("hmac(sha512)"), QCA::SymmetricKey(), provider);
            QCA::SymmetricKey key2(QCA::hexToArray(QStringLiteral("0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b")));
            hmac2.setup(key2);
            QCA::SecureArray data2 = QCA::SecureArray("Hi There");
            hmac2.update(data2);
            QCOMPARE(QCA::arrayToHex(hmac2.final().toByteArray()),
                     QStringLiteral("87aa7cdea5ef619d4ff0b4241a1d6cb02379f4e2ce4ec2787ad0b30545e17cdedaa833b7d6b8a70203"
                                    "8b274eaea3f4e4be9d914eeb61f1702e696c203a126854"));

            // test reuse
            hmac2.clear();
            QCA::SymmetricKey key3(QCA::hexToArray(QStringLiteral("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")));
            hmac2.setup(key3);
            QCA::SecureArray data3(50);
            for (int i = 0; i < data3.size(); i++)
                data3[i] = (char)0xDD;
            hmac2.update(data3);
            QCOMPARE(QCA::arrayToHex(hmac2.final().toByteArray()),
                     QStringLiteral("fa73b0089d56a284efb0f0756c890be9b1b5dbdd8ee81a3655f83e33b2279d39bf3e848279a722c806"
                                    "b485a47e67c807b946a337bee8942674278859e13292fb"));

            QCA::SymmetricKey key4(
                QCA::hexToArray(QStringLiteral("0102030405060708090a0b0c0d0e0f10111213141516171819")));
            QCA::MessageAuthenticationCode hmac4(QStringLiteral("hmac(sha512)"), key4, provider);
            QCA::SecureArray               data4(50);
            for (int i = 0; i < data4.size(); i++)
                data4[i] = (char)0xcd;
            hmac4.update(data4);
            QCOMPARE(QCA::arrayToHex(hmac4.final().toByteArray()),
                     QStringLiteral("b0ba465637458c6990e5a8c5f61d4af7e576d97ff94b872de76f8050361ee3dba91ca5c11aa25eb4d6"
                                    "79275cc5788063a5f19741120c4f2de2adebeb10a298dd"));

            QCA::MessageAuthenticationCode hmac5(QStringLiteral("hmac(sha512)"), QCA::SecureArray(), provider);
            QCA::SymmetricKey key5(QCA::hexToArray(QStringLiteral("0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c")));
            hmac5.setup(key5);
            QCA::SecureArray data5("Test With Truncation");
            hmac5.update(data5);
            QString resultWithTrunc = QCA::arrayToHex(hmac5.final().toByteArray());
            resultWithTrunc.resize(32);
            QCOMPARE(resultWithTrunc, QStringLiteral("415fad6271580a531d4179bc891d87a6"));

            QCA::MessageAuthenticationCode hmac6(QStringLiteral("hmac(sha512)"), QCA::SymmetricKey(), provider);
            QCA::SymmetricKey              key6(131);
            for (int i = 0; i < key6.size(); i++)
                key6[i] = (char)0xaa;
            hmac6.setup(key6);
            QCA::SecureArray data6("Test Using Larger Than Block-Size Key - Hash Key First");
            hmac6.update(data6);
            QCOMPARE(QCA::arrayToHex(hmac6.final().toByteArray()),
                     QStringLiteral("80b24263c7c1a3ebb71493c1dd7be8b49b46d1f41b4aeec1121b013783f8f3526b56d037e05f2598bd"
                                    "0fd2215d6a1e5295e64f73f63f0aec8b915a985d786598"));

            hmac6.clear(); // reuse the same key
            QCA::SecureArray data7(
                "This is a test using a larger than block-size key and a larger than block-size data. The key needs to "
                "be hashed before being used by the HMAC algorithm.");
            hmac6.update(data7);
            QCOMPARE(QCA::arrayToHex(hmac6.final().toByteArray()),
                     QStringLiteral("e37b6a775dc87dbaa4dfa9f96e5e3ffddebd71f8867289865df5a32d20cdc944b6022cac3c4982b10d"
                                    "5eeb55c3e4de15134676fb6de0446065c97440fa8c6a58"));
        }
    }
}

void MACUnitTest::HMACSHA1()
{
    QStringList providersToTest;
    providersToTest.append(QStringLiteral("qca-ossl"));
    providersToTest.append(QStringLiteral("qca-gcrypt"));
    providersToTest.append(QStringLiteral("qca-botan"));
    providersToTest.append(QStringLiteral("qca-nss"));

    foreach (const QString provider, providersToTest) {
        if (!QCA::isSupported("hmac(sha1)", provider))
            QWARN((QStringLiteral("HMAC(SHA1) not supported for ") + provider).toLocal8Bit().constData());
        else {
            QCA::MessageAuthenticationCode sha1hmacLenTest(QStringLiteral("hmac(sha1)"), QCA::SymmetricKey(), provider);
            QCOMPARE(sha1hmacLenTest.validKeyLength(0), true);
            QCOMPARE(sha1hmacLenTest.validKeyLength(1), true);
            QCOMPARE(sha1hmacLenTest.validKeyLength(848888), true);
            QCOMPARE(sha1hmacLenTest.validKeyLength(-2), false);

            QCA::MessageAuthenticationCode copy = sha1hmacLenTest;
            copy.context(); // detach

            // These tests are from RFC2202, Section 3.
            QCA::MessageAuthenticationCode test1(QStringLiteral("hmac(sha1)"), QCA::SecureArray());
            QCA::SymmetricKey key1(QCA::hexToArray(QStringLiteral("0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b")));
            test1.setup(key1);
            QCA::SecureArray data1("Hi There");
            test1.update(data1);
            QCOMPARE(QCA::arrayToHex(test1.final().toByteArray()),
                     QStringLiteral("b617318655057264e28bc0b6fb378c8ef146be00"));

            QCA::MessageAuthenticationCode test2(QStringLiteral("hmac(sha1)"), QCA::SymmetricKey(), provider);
            QCA::SymmetricKey              key2(QCA::SecureArray("Jefe"));
            test2.setup(key2);
            QCA::SecureArray data2("what do ya want for nothing?");
            test2.update(data2);
            QCOMPARE(QCA::arrayToHex(test2.final().toByteArray()),
                     QStringLiteral("effcdf6ae5eb2fa2d27416d5f184df9c259a7c79"));

            QCA::MessageAuthenticationCode test3(QStringLiteral("hmac(sha1)"), QCA::SymmetricKey(), provider);
            QCA::SymmetricKey key3(QCA::hexToArray(QStringLiteral("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")));
            test3.setup(key3);
            QCA::SecureArray data3(50);
            for (int i = 0; i < data3.size(); i++)
                data3[i] = (char)0xDD;
            test3.update(data3);
            QCOMPARE(QCA::arrayToHex(test3.final().toByteArray()),
                     QStringLiteral("125d7342b9ac11cd91a39af48aa17b4f63f175d3"));

            QCA::MessageAuthenticationCode test4(QStringLiteral("hmac(sha1)"), QCA::SymmetricKey(), provider);
            QCA::SymmetricKey              key4(
                QCA::hexToArray(QStringLiteral("0102030405060708090a0b0c0d0e0f10111213141516171819")));
            test4.setup(key4);
            QCA::SecureArray data4(50);
            for (int i = 0; i < data4.size(); i++)
                data4[i] = (char)0xcd;
            test4.update(data4);
            QCOMPARE(QCA::arrayToHex(test4.final().toByteArray()),
                     QStringLiteral("4c9007f4026250c6bc8414f9bf50c86c2d7235da"));

            QCA::MessageAuthenticationCode test5(QStringLiteral("hmac(sha1)"), QCA::SymmetricKey(), provider);
            QCA::SymmetricKey key5(QCA::hexToArray(QStringLiteral("0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c")));
            test5.setup(key5);
            QCA::SecureArray data5("Test With Truncation");
            test5.update(data5);
            QCOMPARE(QCA::arrayToHex(test5.final().toByteArray()),
                     QStringLiteral("4c1a03424b55e07fe7f27be1d58bb9324a9a5a04"));

            QCA::MessageAuthenticationCode test6(QStringLiteral("hmac(sha1)"), QCA::SymmetricKey(), provider);
            QCA::SymmetricKey              key6(80);
            for (int i = 0; i < key6.size(); i++)
                key6[i] = (char)0xAA;
            test6.setup(key6);
            QCA::SecureArray data6("Test Using Larger Than Block-Size Key - Hash Key First");
            test6.update(data6);
            QCOMPARE(QCA::arrayToHex(test6.final().toByteArray()),
                     QStringLiteral("aa4ae5e15272d00e95705637ce8a3b55ed402112"));

            test6.clear(); // this should reuse the same key
            QCA::SecureArray data7("Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data");
            test6.update(data7);
            QCOMPARE(QCA::arrayToHex(test6.final().toByteArray()),
                     QStringLiteral("e8e99d0f45237d786d6bbaa7965c7808bbff1a91"));
        }
    }
}

void MACUnitTest::HMACRMD160()
{
    QStringList providersToTest;
    providersToTest.append(QStringLiteral("qca-ossl"));
    providersToTest.append(QStringLiteral("qca-gcrypt"));
    providersToTest.append(QStringLiteral("qca-botan"));
    providersToTest.append(QStringLiteral("qca-nss"));

    foreach (const QString provider, providersToTest) {
        if (!QCA::isSupported("hmac(ripemd160)", provider))
            QWARN((QStringLiteral("HMAC(RIPEMD160) not supported for ") + provider).toLocal8Bit().constData());
        else {
            QCA::MessageAuthenticationCode ripemd160hmacLenTest(
                QStringLiteral("hmac(ripemd160)"), QCA::SymmetricKey(), provider);
            QCOMPARE(ripemd160hmacLenTest.validKeyLength(0), true);
            QCOMPARE(ripemd160hmacLenTest.validKeyLength(1), true);
            QCOMPARE(ripemd160hmacLenTest.validKeyLength(848888), true);
            QCOMPARE(ripemd160hmacLenTest.validKeyLength(-2), false);

            QCA::MessageAuthenticationCode copy = ripemd160hmacLenTest;
            copy.context(); // detach

            // These tests are from RFC2286, Section 2.
            QCA::MessageAuthenticationCode test1(QStringLiteral("hmac(ripemd160)"), QCA::SymmetricKey(), provider);
            QCA::SymmetricKey key1(QCA::hexToArray(QStringLiteral("0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b")));
            test1.setup(key1);
            QCA::SecureArray data1("Hi There");
            test1.update(data1);
            QCOMPARE(QCA::arrayToHex(test1.final().toByteArray()),
                     QStringLiteral("24cb4bd67d20fc1a5d2ed7732dcc39377f0a5668"));

            QCA::MessageAuthenticationCode test2(QStringLiteral("hmac(ripemd160)"), QCA::SymmetricKey(), provider);
            QCA::SymmetricKey              key2(QCA::SecureArray("Jefe"));
            test2.setup(key2);
            QCA::SecureArray data2("what do ya want for nothing?");
            test2.update(data2);
            QCOMPARE(QCA::arrayToHex(test2.final().toByteArray()),
                     QStringLiteral("dda6c0213a485a9e24f4742064a7f033b43c4069"));

            QCA::MessageAuthenticationCode test3(QStringLiteral("hmac(ripemd160)"), QCA::SymmetricKey(), provider);
            QCA::SymmetricKey key3(QCA::hexToArray(QStringLiteral("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")));
            test3.setup(key3);
            QCA::SecureArray data3(50);
            for (int i = 0; i < data3.size(); i++)
                data3[i] = (char)0xDD;
            test3.update(data3);
            QCOMPARE(QCA::arrayToHex(test3.final().toByteArray()),
                     QStringLiteral("b0b105360de759960ab4f35298e116e295d8e7c1"));

            QCA::SymmetricKey key4(
                QCA::hexToArray(QStringLiteral("0102030405060708090a0b0c0d0e0f10111213141516171819")));
            QCA::MessageAuthenticationCode test4(QStringLiteral("hmac(ripemd160)"), key4, provider);
            QCA::SecureArray               data4(50);
            for (int i = 0; i < data4.size(); i++)
                data4[i] = (char)0xcd;
            test4.update(data4);
            QCOMPARE(QCA::arrayToHex(test4.final().toByteArray()),
                     QStringLiteral("d5ca862f4d21d5e610e18b4cf1beb97a4365ecf4"));

            QCA::MessageAuthenticationCode test5(QStringLiteral("hmac(ripemd160)"), QCA::SymmetricKey(), provider);
            QCA::SymmetricKey key5(QCA::hexToArray(QStringLiteral("0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c")));
            test5.setup(key5);
            QCA::SecureArray data5("Test With Truncation");
            test5.update(data5);
            QCOMPARE(QCA::arrayToHex(test5.final().toByteArray()),
                     QStringLiteral("7619693978f91d90539ae786500ff3d8e0518e39"));

            QCA::MessageAuthenticationCode test6(QStringLiteral("hmac(ripemd160)"), QCA::SymmetricKey(), provider);
            QCA::SymmetricKey              key6(80);
            for (int i = 0; i < key6.size(); i++)
                key6[i] = (char)0xAA;
            test6.setup(key6);
            QCA::SecureArray data6("Test Using Larger Than Block-Size Key - Hash Key First");
            test6.update(data6);
            QCOMPARE(QCA::arrayToHex(test6.final().toByteArray()),
                     QStringLiteral("6466ca07ac5eac29e1bd523e5ada7605b791fd8b"));

            test6.clear(); // reuse the key
            QCA::SecureArray data7("Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data");
            test6.update(data7);
            QCOMPARE(QCA::arrayToHex(test6.final().toByteArray()),
                     QStringLiteral("69ea60798d71616cce5fd0871e23754cd75d5a0a"));
        }
    }
}

QTEST_MAIN(MACUnitTest)

#include "macunittest.moc"