QuasarApp/qca
4
0
Fork 0
mirror of https://github.com/QuasarApp/qca.git synced 2025-04-27 20:14:32 +00:00
Code Issues Projects Releases Wiki Activity

Finally commit the big "primitives" API change.

Browse Source 
Essentially if you had previously used a subclass
of Cipher, Hash or MAC, then you need to change
your code. The change is pretty simple - you
just pass a string name as the first argument.


svn path=/trunk/kdesupport/qca/; revision=576204
This commit is contained in:
Brad Hards 2006-08-23 12:38:39 +00:00
parent 2a556750e1
commit 11d097e08d
10 changed files with 690 additions and 900 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
examples/aes-cmac/aes-cmac.cpp
View File

@ -92,7 +92,8 @@ public:
m_residual = QSecureArray();
// Figure 2.2, step 1.
QCA::AES128 aesObj(QCA::Cipher::ECB, QCA::Cipher::DefaultPadding,
QCA::Cipher aesObj(QString("aes128"),
QCA::Cipher::ECB, QCA::Cipher::DefaultPadding,
QCA::Encode, key);
QSecureArray L = aesObj.process(const_Zero);
@ -140,7 +141,8 @@ public:
m_Y = xorArray(m_X, thisBlock);
QCA::AES128 aesObj(QCA::Cipher::ECB, QCA::Cipher::DefaultPadding,
QCA::Cipher aesObj(QString("aes128"),
QCA::Cipher::ECB, QCA::Cipher::DefaultPadding,
QCA::Encode, m_key);
m_X = aesObj.process(m_Y);
}
@ -167,7 +169,8 @@ public:
lastBlock = xorArray(m_residual, m_k1);
}
m_Y = xorArray(m_X, lastBlock);
QCA::AES128 aesObj(QCA::Cipher::ECB, QCA::Cipher::DefaultPadding,
QCA::Cipher aesObj(QString("aes128"),
QCA::Cipher::ECB, QCA::Cipher::DefaultPadding,
QCA::Encode, m_key);
*out = aesObj.process(m_Y);
@ -219,7 +222,7 @@ public:
// AES CMAC is a Message Authentication Code based on a block cipher
// instead of the more normal keyed hash.
// See IETF draft-songlee-aes-cmac-03.txt
// See RFC 4493 "The AES-CMAC Algorithm"
class AES_CMAC: public QCA::MessageAuthenticationCode
{
public:
@ -240,6 +243,12 @@ int main(int argc, char **argv)
// also does cleanup when it goes out of scope
QCA::Initializer init;
qDebug() << "Completed initialisation";
if( ! QCA::isSupported("aes128-ecb") ) {
qDebug() << "AES not supported!";
}
if ( QCA::insertProvider(new ClientSideProvider, 0) )
qDebug() << "Inserted our provider";
else

6
examples/ciphertest/ciphertest.cpp
View File

@ -1,6 +1,6 @@
/*
Copyright (C) 2003 Justin Karneges
Copyright (C) 2005 Brad Hards <bradh@frogmouth.net>
Copyright (C) 2005-2006 Brad Hards <bradh@frogmouth.net>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
@ -37,7 +37,7 @@ int main(int argc, char **argv)
QSecureArray arg = (argc >= 2) ? argv[1] : "hello";
// AES128 testing
if(!QCA::isSupported("des-cbc-pkcs7"))
if(!QCA::isSupported("aes128-cbc-pkcs7"))
printf("AES128-CBC not supported!\n");
else {
// Create a random key - you'd probably use one from another
@ -50,7 +50,7 @@ int main(int argc, char **argv)
QCA::InitializationVector iv(16);
// create a 128 bit AES cipher object using Cipher Block Chaining (CBC) mode
QCA::AES128 cipher(QCA::Cipher::CBC,
QCA::Cipher cipher(QString("aes128"),QCA::Cipher::CBC,
// use Default padding, which is equivalent to PKCS7 for CBC
QCA::Cipher::DefaultPadding,
// this object will encrypt

4
examples/hashtest/hashtest.cpp
View File

@ -40,7 +40,7 @@ int main(int argc, char **argv)
printf("SHA1 not supported!\n");
else {
// this shows the "all in one" approach
QString result = QCA::SHA1().hashToString(arg);
QString result = QCA::Hash("sha1").hashToString(arg);
printf("sha1(\"%s\") = [%s]\n", arg.data(), result.toAscii().data());
}
@ -55,7 +55,7 @@ int main(int argc, char **argv)
QSecureArray part2(arg.toByteArray().mid(3)); // the rest - "lo"
// create the required object.
QCA::MD5 hashObject;
QCA::Hash hashObject("md5");
// we split it into two parts to show incremental update
hashObject.update(part1);
hashObject.update(part2);

7
examples/mactest/mactest.cpp
View File

@ -48,15 +48,16 @@ int main(int argc, char **argv)
printf("HMAC(SHA1) not supported!\n");
} else {
// create the required object. This is equivalent
// to QCA::HMAC hmacObject("sha1").
QCA::HMAC hmacObject;
// to QCA::MessageAuthenticationCode hmacObject("hmac(sha1)").
QCA::MessageAuthenticationCode hmacObject;
// create the key
QCA::SymmetricKey keyObject(key);
// set the HMAC object to use the key
hmacObject.setup(key);
// that could also have been done in the QCA::HMAC constructor
// that could also have been done in the
// QCA::MessageAuthenticationCode constructor
// we split it into two parts to show incremental update
QSecureArray part1(arg.left(3)); // three chars - "hel"

49
include/QtCrypto/qca.h
View File

@ -79,30 +79,30 @@
- RSA (QCA::RSAPrivateKey and QCA::RSAPublicKey)
- DSA (QCA::DSAPrivateKey and QCA::DSAPublicKey)
- Diffie-Hellman (QCA::DHPrivateKey and QCA::DHPublicKey)
- Hashing (QCA::Hash)
- QCA::SHA0
- QCA::SHA1
- QCA::MD2
- QCA::MD4
- QCA::MD5
- QCA::RIPEMD160
- QCA::SHA224
- QCA::SHA256
- QCA::SHA384
- QCA::SHA512
- Ciphers (QCA::Cipher)
- BlowFish (QCA::BlowFish)
- Triple %DES (QCA::TripleDES)
- %DES (QCA::DES)
- AES (QCA::AES128, QCA::AES192, QCA::AES256)
- Keyed Hash Message Authentication Code (QCA::HMAC), using
- SHA1
- Hashing (QCA::Hash) with
- SHA-0
- SHA-1
- MD2
- MD4
- MD5
- RIPEMD160
- SHA224
- SHA256
- SHA384
- SHA512
- SHA-224
- SHA-256
- SHA-384
- SHA-512
- Ciphers (QCA::Cipher) using
- BlowFish
- Triple DES
- DES
- AES (128, 192 and 256 bit)
- Message Authentication Code (QCA::MAC), using
- HMAC with SHA-1
- HMAC with MD5
- HMAC with RIPEMD160
- HMAC with SHA-224
- HMAC with SHA-256
- HMAC with SHA-384
- HMAC with SHA-512
- Encoding and decoding of hexadecimal (QCA::Hex) and
Base64 (QCA::Base64)
@ -116,7 +116,7 @@
And of course, you get a very simple crypto API for Qt, where you can
do things like:
\code
QString hash = QCA::SHA1().hashToString(blockOfData);
QString hash = QCA::Hash("sha1").hashToString(blockOfData);
\endcode
\section using Using QCA
@ -179,11 +179,10 @@ for this example):
class QCA_EXPORT Hash : public Algorithm, public BufferedComputation
{
public:
Hash(const QString &type, const QString &provider);
virtual void clear();
virtual void update(const QSecureArray &a);
virtual QSecureArray final();
protected:
Hash(const QString &type, const QString &provider);
}
\endcode

929
include/QtCrypto/qca_basic.h
View File

File diff suppressed because it is too large Load Diff

14
src/qca_basic.cpp
View File

@ -132,8 +132,11 @@ public:
bool ok, done;
};
Cipher::Cipher(const QString &type, Direction dir, const SymmetricKey &key, const InitializationVector &iv, const QString &provider)
:Algorithm(type, provider)
Cipher::Cipher( const QString &type, Mode m, Padding pad,
Direction dir, const SymmetricKey &key,
const InitializationVector &iv,
const QString &provider )
:Algorithm(withAlgorithms( type, m, pad ), provider)
{
d = new Private;
if(!key.isEmpty())
@ -267,8 +270,11 @@ public:
QSecureArray buf;
};
MessageAuthenticationCode::MessageAuthenticationCode(const QString &type, const SymmetricKey &key, const QString &provider)
:Algorithm(type, provider)
MessageAuthenticationCode::MessageAuthenticationCode(const QString &type,
const SymmetricKey &key,
const QString &provider)
:Algorithm(type, provider)
{
d = new Private;
setup(key);

426
unittest/cipherunittest/cipherunittest.cpp
View File

@ -118,8 +118,13 @@ void CipherUnitTest::aes128()
QFETCH( QString, keyText );
QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
QCA::AES128 forwardCipher( QCA::Cipher::ECB, QCA::Cipher::NoPadding, QCA::Encode, key,
QCA::InitializationVector(), provider );
QCA::Cipher forwardCipher( QString( "aes128" ),
QCA::Cipher::ECB,
QCA::Cipher::NoPadding,
QCA::Encode,
key,
QCA::InitializationVector(),
provider );
QCOMPARE( forwardCipher.blockSize(), (unsigned)16 );
QCOMPARE( forwardCipher.keyLength().minimum(), 16 );
@ -131,8 +136,13 @@ void CipherUnitTest::aes128()
QCOMPARE( QCA::arrayToHex( forwardCipher.final() ), QString( "" ) );
QVERIFY( forwardCipher.ok() );
QCA::AES128 reverseCipher( QCA::Cipher::ECB, QCA::Cipher::NoPadding, QCA::Decode, key,
QCA::InitializationVector(), provider );
QCA::Cipher reverseCipher( QString( "aes128" ),
QCA::Cipher::ECB,
QCA::Cipher::NoPadding,
QCA::Decode,
key,
QCA::InitializationVector(),
provider );
QCOMPARE( reverseCipher.blockSize(), (unsigned)16 );
QCOMPARE( reverseCipher.keyLength().minimum(), 16 );
@ -181,13 +191,25 @@ void CipherUnitTest::aes128_cbc()
QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
QCA::InitializationVector iv( QCA::hexToArray( ivText ) );
QCA::AES128 forwardCipher( QCA::Cipher::CBC, QCA::Cipher::NoPadding, QCA::Encode, key, iv, provider);
QCA::Cipher forwardCipher( QString( "aes128" ),
QCA::Cipher::CBC,
QCA::Cipher::NoPadding,
QCA::Encode,
key,
iv,
provider);
QString update = QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ) );
QVERIFY( forwardCipher.ok() );
QCOMPARE( update + QCA::arrayToHex( forwardCipher.final() ), cipherText );
QVERIFY( forwardCipher.ok() );
QCA::AES128 reverseCipher( QCA::Cipher::CBC, QCA::Cipher::NoPadding, QCA::Decode, key, iv, provider);
QCA::Cipher reverseCipher( QString( "aes128" ),
QCA::Cipher::CBC,
QCA::Cipher::NoPadding,
QCA::Decode,
key,
iv,
provider);
update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ) );
QVERIFY( reverseCipher.ok() );
QCOMPARE( update, plainText.left(update.size() ) );
@ -230,13 +252,25 @@ void CipherUnitTest::aes128_cfb()
QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
QCA::InitializationVector iv( QCA::hexToArray( ivText ) );
QCA::AES128 forwardCipher( QCA::Cipher::CFB, QCA::Cipher::NoPadding, QCA::Encode, key, iv, provider);
QCA::Cipher forwardCipher( QString( "aes128" ),
QCA::Cipher::CFB,
QCA::Cipher::NoPadding,
QCA::Encode,
key,
iv,
provider);
QString update = QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ) );
QVERIFY( forwardCipher.ok() );
QCOMPARE( update + QCA::arrayToHex( forwardCipher.final() ), cipherText );
QVERIFY( forwardCipher.ok() );
QCA::AES128 reverseCipher( QCA::Cipher::CFB, QCA::Cipher::NoPadding, QCA::Decode, key, iv, provider);
QCA::Cipher reverseCipher( QString( "aes128" ),
QCA::Cipher::CFB,
QCA::Cipher::NoPadding,
QCA::Decode,
key,
iv,
provider);
update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ) );
QVERIFY( reverseCipher.ok() );
QCOMPARE( update, plainText.left(update.size() ) );
@ -278,13 +312,25 @@ void CipherUnitTest::aes128_ofb()
QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
QCA::InitializationVector iv( QCA::hexToArray( ivText ) );
QCA::AES128 forwardCipher( QCA::Cipher::OFB, QCA::Cipher::NoPadding, QCA::Encode, key, iv, provider);
QCA::Cipher forwardCipher( QString( "aes128" ),
QCA::Cipher::OFB,
QCA::Cipher::NoPadding,
QCA::Encode,
key,
iv,
provider);
QString update = QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ) );
QVERIFY( forwardCipher.ok() );
QCOMPARE( update + QCA::arrayToHex( forwardCipher.final() ), cipherText );
QVERIFY( forwardCipher.ok() );
QCA::AES128 reverseCipher( QCA::Cipher::OFB, QCA::Cipher::NoPadding, QCA::Decode, key, iv, provider);
QCA::Cipher reverseCipher( QString( "aes128" ),
QCA::Cipher::OFB,
QCA::Cipher::NoPadding,
QCA::Decode,
key,
iv,
provider);
update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ) );
QVERIFY( reverseCipher.ok() );
QCOMPARE( update, plainText.left(update.size() ) );
@ -373,8 +419,13 @@ void CipherUnitTest::aes192()
QFETCH( QString, keyText );
QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
QCA::AES192 forwardCipher( QCA::Cipher::ECB, QCA::Cipher::NoPadding, QCA::Encode, key,
QCA::InitializationVector(), provider );
QCA::Cipher forwardCipher( QString( "aes192" ),
QCA::Cipher::ECB,
QCA::Cipher::NoPadding,
QCA::Encode,
key,
QCA::InitializationVector(),
provider );
QCOMPARE( forwardCipher.blockSize(), (unsigned)16 );
QCOMPARE( forwardCipher.keyLength().minimum(), 24 );
@ -386,8 +437,13 @@ void CipherUnitTest::aes192()
QCOMPARE( QCA::arrayToHex( forwardCipher.final() ), QString( "" ) );
QVERIFY( forwardCipher.ok() );
QCA::AES192 reverseCipher( QCA::Cipher::ECB, QCA::Cipher::NoPadding, QCA::Decode, key,
QCA::InitializationVector(), provider );
QCA::Cipher reverseCipher( QString( "aes192" ),
QCA::Cipher::ECB,
QCA::Cipher::NoPadding,
QCA::Decode,
key,
QCA::InitializationVector(),
provider );
QCOMPARE( reverseCipher.blockSize(), (unsigned)16 );
QCOMPARE( reverseCipher.keyLength().minimum(), 24 );
@ -437,13 +493,25 @@ void CipherUnitTest::aes192_cbc()
QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
QCA::InitializationVector iv( QCA::hexToArray( ivText ) );
QCA::AES192 forwardCipher( QCA::Cipher::CBC, QCA::Cipher::NoPadding, QCA::Encode, key, iv, provider);
QCA::Cipher forwardCipher( QString( "aes192" ),
QCA::Cipher::CBC,
QCA::Cipher::NoPadding,
QCA::Encode,
key,
iv,
provider);
QString update = QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ) );
QVERIFY( forwardCipher.ok() );
QCOMPARE( update + QCA::arrayToHex( forwardCipher.final() ), cipherText );
QVERIFY( forwardCipher.ok() );
QCA::AES192 reverseCipher( QCA::Cipher::CBC, QCA::Cipher::NoPadding, QCA::Decode, key, iv, provider);
QCA::Cipher reverseCipher( QString( "aes192" ),
QCA::Cipher::CBC,
QCA::Cipher::NoPadding,
QCA::Decode,
key,
iv,
provider);
update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ) );
QVERIFY( reverseCipher.ok() );
QCOMPARE( update, plainText.left(update.size() ) );
@ -485,13 +553,25 @@ void CipherUnitTest::aes192_cfb()
QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
QCA::InitializationVector iv( QCA::hexToArray( ivText ) );
QCA::AES192 forwardCipher( QCA::Cipher::CFB, QCA::Cipher::NoPadding, QCA::Encode, key, iv, provider);
QCA::Cipher forwardCipher( QString( "aes192" ),
QCA::Cipher::CFB,
QCA::Cipher::NoPadding,
QCA::Encode,
key,
iv,
provider);
QString update = QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ) );
QVERIFY( forwardCipher.ok() );
QCOMPARE( update + QCA::arrayToHex( forwardCipher.final() ), cipherText );
QVERIFY( forwardCipher.ok() );
QCA::AES192 reverseCipher( QCA::Cipher::CFB, QCA::Cipher::NoPadding, QCA::Decode, key, iv, provider);
QCA::Cipher reverseCipher( QString( "aes192" ),
QCA::Cipher::CFB,
QCA::Cipher::NoPadding,
QCA::Decode,
key,
iv,
provider);
update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ) );
QVERIFY( reverseCipher.ok() );
QCOMPARE( update, plainText.left(update.size() ) );
@ -533,13 +613,25 @@ void CipherUnitTest::aes192_ofb()
QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
QCA::InitializationVector iv( QCA::hexToArray( ivText ) );
QCA::AES192 forwardCipher( QCA::Cipher::OFB, QCA::Cipher::NoPadding, QCA::Encode, key, iv, provider);
QCA::Cipher forwardCipher( QString( "aes192" ),
QCA::Cipher::OFB,
QCA::Cipher::NoPadding,
QCA::Encode,
key,
iv,
provider);
QString update = QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ) );
QVERIFY( forwardCipher.ok() );
QCOMPARE( update + QCA::arrayToHex( forwardCipher.final() ), cipherText );
QVERIFY( forwardCipher.ok() );
QCA::AES192 reverseCipher( QCA::Cipher::OFB, QCA::Cipher::NoPadding, QCA::Decode, key, iv, provider);
QCA::Cipher reverseCipher( QString( "aes192" ),
QCA::Cipher::OFB,
QCA::Cipher::NoPadding,
QCA::Decode,
key,
iv,
provider);
update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ) );
QVERIFY( reverseCipher.ok() );
QCOMPARE( update, plainText.left(update.size() ) );
@ -666,9 +758,14 @@ void CipherUnitTest::aes256()
QFETCH( QString, keyText );
QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
QCA::AES256 forwardCipher( QCA::Cipher::ECB, QCA::Cipher::NoPadding, QCA::Encode, key,
QCA::InitializationVector(), provider );
QCA::Cipher forwardCipher( QString( "aes256" ),
QCA::Cipher::ECB,
QCA::Cipher::NoPadding,
QCA::Encode,
key,
QCA::InitializationVector(),
provider );
QCOMPARE( forwardCipher.blockSize(), (unsigned)16 );
QCOMPARE( forwardCipher.keyLength().minimum(), 32 );
QCOMPARE( forwardCipher.keyLength().maximum(), 32 );
@ -679,8 +776,13 @@ void CipherUnitTest::aes256()
QCOMPARE( QCA::arrayToHex( forwardCipher.final() ), QString( "" ) );
QVERIFY( forwardCipher.ok() );
QCA::AES256 reverseCipher( QCA::Cipher::ECB, QCA::Cipher::NoPadding, QCA::Decode, key,
QCA::InitializationVector(), provider );
QCA::Cipher reverseCipher( QString( "aes256" ),
QCA::Cipher::ECB,
QCA::Cipher::NoPadding,
QCA::Decode,
key,
QCA::InitializationVector(),
provider );
QCOMPARE( reverseCipher.blockSize(), (unsigned)16 );
QCOMPARE( reverseCipher.keyLength().minimum(), 32 );
@ -729,13 +831,25 @@ void CipherUnitTest::aes256_cbc()
QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
QCA::InitializationVector iv( QCA::hexToArray( ivText ) );
QCA::AES256 forwardCipher( QCA::Cipher::CBC, QCA::Cipher::NoPadding, QCA::Encode, key, iv, provider);
QCA::Cipher forwardCipher( QString( "aes256" ),
QCA::Cipher::CBC,
QCA::Cipher::NoPadding,
QCA::Encode,
key,
iv,
provider);
QString update = QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ) );
QVERIFY( forwardCipher.ok() );
QCOMPARE( update + QCA::arrayToHex( forwardCipher.final() ), cipherText );
QVERIFY( forwardCipher.ok() );
QCA::AES256 reverseCipher( QCA::Cipher::CBC, QCA::Cipher::NoPadding, QCA::Decode, key, iv, provider);
QCA::Cipher reverseCipher( QString( "aes256" ),
QCA::Cipher::CBC,
QCA::Cipher::NoPadding,
QCA::Decode,
key,
iv,
provider);
update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ) );
QVERIFY( reverseCipher.ok() );
@ -778,13 +892,25 @@ void CipherUnitTest::aes256_cfb()
QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
QCA::InitializationVector iv( QCA::hexToArray( ivText ) );
QCA::AES256 forwardCipher( QCA::Cipher::CFB, QCA::Cipher::NoPadding, QCA::Encode, key, iv, provider);
QCA::Cipher forwardCipher( QString( "aes256" ),
QCA::Cipher::CFB,
QCA::Cipher::NoPadding,
QCA::Encode,
key,
iv,
provider);
QString update = QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ) );
QVERIFY( forwardCipher.ok() );
QCOMPARE( update + QCA::arrayToHex( forwardCipher.final() ), cipherText );
QVERIFY( forwardCipher.ok() );
QCA::AES256 reverseCipher( QCA::Cipher::CFB, QCA::Cipher::NoPadding, QCA::Decode, key, iv, provider);
QCA::Cipher reverseCipher( QString( "aes256" ),
QCA::Cipher::CFB,
QCA::Cipher::NoPadding,
QCA::Decode,
key,
iv,
provider);
QCOMPARE( QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ) ), plainText );
QVERIFY( reverseCipher.ok() );
@ -825,13 +951,25 @@ void CipherUnitTest::aes256_ofb()
QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
QCA::InitializationVector iv( QCA::hexToArray( ivText ) );
QCA::AES256 forwardCipher( QCA::Cipher::OFB, QCA::Cipher::NoPadding, QCA::Encode, key, iv, provider);
QCA::Cipher forwardCipher( QString( "aes256" ),
QCA::Cipher::OFB,
QCA::Cipher::NoPadding,
QCA::Encode,
key,
iv,
provider);
QString update = QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ) );
QVERIFY( forwardCipher.ok() );
QCOMPARE( update + QCA::arrayToHex( forwardCipher.final() ), cipherText );
QVERIFY( forwardCipher.ok() );
QCA::AES256 reverseCipher( QCA::Cipher::OFB, QCA::Cipher::NoPadding, QCA::Decode, key, iv, provider);
QCA::Cipher reverseCipher( QString( "aes256" ),
QCA::Cipher::OFB,
QCA::Cipher::NoPadding,
QCA::Decode,
key,
iv,
provider);
QCOMPARE( QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ) ), plainText );
QVERIFY( reverseCipher.ok() );
@ -964,9 +1102,13 @@ void CipherUnitTest::tripleDES()
if( !QCA::isSupported( "tripledes-ecb", provider ) )
QWARN( QString( "Triple DES, ECB not supported for "+provider).toLocal8Bit() );
else {
QCA::TripleDES cipherObj1( QCA::Cipher::ECB, QCA::Cipher::NoPadding,
QCA::Encode, QCA::SymmetricKey( 24 ),
QCA::InitializationVector(), provider );
QCA::Cipher cipherObj1( QString( "tripledes" ),
QCA::Cipher::ECB,
QCA::Cipher::NoPadding,
QCA::Encode,
QCA::SymmetricKey( 24 ),
QCA::InitializationVector(),
provider );
// checking minimum is a bit hairy, because it depends on whether you are
// doing 2 key or 3 key triple DES.
QCOMPARE( cipherObj1.keyLength().minimum(), 16 );
@ -978,16 +1120,26 @@ void CipherUnitTest::tripleDES()
QFETCH( QString, keyText );
QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
QCA::TripleDES forwardCipher( QCA::Cipher::ECB, QCA::Cipher::NoPadding, QCA::Encode, key,
QCA::InitializationVector(), provider );
QCA::Cipher forwardCipher( QString( "tripledes" ),
QCA::Cipher::ECB,
QCA::Cipher::NoPadding,
QCA::Encode,
key,
QCA::InitializationVector(),
provider );
QCOMPARE( QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ) ),
QString( cipherText ) );
QVERIFY( forwardCipher.ok() );
QCOMPARE( QCA::arrayToHex( forwardCipher.final() ), QString( "" ) );
QVERIFY( forwardCipher.ok() );
QCA::TripleDES reverseCipher( QCA::Cipher::ECB, QCA::Cipher::NoPadding, QCA::Decode, key,
QCA::InitializationVector(), provider );
QCA::Cipher reverseCipher( QString( "tripledes" ),
QCA::Cipher::ECB,
QCA::Cipher::NoPadding,
QCA::Decode,
key,
QCA::InitializationVector(),
provider );
QString update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ) );
QVERIFY( reverseCipher.ok() );
QCOMPARE( update, plainText.left(update.size() ) );
@ -1233,8 +1385,13 @@ void CipherUnitTest::des()
QFETCH( QString, keyText );
QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
QCA::DES forwardCipher( QCA::Cipher::ECB, QCA::Cipher::NoPadding, QCA::Encode, key,
QCA::InitializationVector(), provider );
QCA::Cipher forwardCipher( QString( "des" ),
QCA::Cipher::ECB,
QCA::Cipher::NoPadding,
QCA::Encode,
key,
QCA::InitializationVector(),
provider );
QCOMPARE( forwardCipher.blockSize(), (unsigned)8 );
QCOMPARE( forwardCipher.keyLength().minimum(), 8 );
@ -1246,8 +1403,13 @@ void CipherUnitTest::des()
QCOMPARE( QCA::arrayToHex( forwardCipher.final() ), QString( "" ) );
QVERIFY( forwardCipher.ok() );
QCA::DES reverseCipher( QCA::Cipher::ECB, QCA::Cipher::NoPadding, QCA::Decode, key,
QCA::InitializationVector(), provider );
QCA::Cipher reverseCipher( QString( "des" ),
QCA::Cipher::ECB,
QCA::Cipher::NoPadding,
QCA::Decode,
key,
QCA::InitializationVector(),
provider );
QCOMPARE( reverseCipher.blockSize(), (unsigned)8 );
QCOMPARE( reverseCipher.keyLength().minimum(), 8 );
@ -1296,13 +1458,25 @@ void CipherUnitTest::des_cbc()
QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
QCA::InitializationVector iv( QCA::hexToArray( ivText ) );
QCA::DES forwardCipher( QCA::Cipher::CBC, QCA::Cipher::NoPadding, QCA::Encode, key, iv, provider);
QCA::Cipher forwardCipher( QString( "des" ),
QCA::Cipher::CBC,
QCA::Cipher::NoPadding,
QCA::Encode,
key,
iv,
provider);
QString update = QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ) );
QVERIFY( forwardCipher.ok() );
QCOMPARE( update + QCA::arrayToHex( forwardCipher.final() ), cipherText );
QVERIFY( forwardCipher.ok() );
QCA::DES reverseCipher( QCA::Cipher::CBC, QCA::Cipher::NoPadding, QCA::Decode, key, iv, provider);
QCA::Cipher reverseCipher( QString( "des" ),
QCA::Cipher::CBC,
QCA::Cipher::NoPadding,
QCA::Decode,
key,
iv,
provider);
update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ) );
QVERIFY( reverseCipher.ok() );
QCOMPARE( update, plainText.left(update.size() ) );
@ -1389,13 +1563,25 @@ void CipherUnitTest::des_cfb()
QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
QCA::InitializationVector iv( QCA::hexToArray( ivText ) );
QCA::DES forwardCipher( QCA::Cipher::CFB, QCA::Cipher::NoPadding, QCA::Encode, key, iv, provider);
QCA::Cipher forwardCipher( QString( "des" ),
QCA::Cipher::CFB,
QCA::Cipher::NoPadding,
QCA::Encode,
key,
iv,
provider);
QString update = QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ) );
QVERIFY( forwardCipher.ok() );
QCOMPARE( update + QCA::arrayToHex( forwardCipher.final() ), cipherText );
QVERIFY( forwardCipher.ok() );
QCA::DES reverseCipher( QCA::Cipher::CFB, QCA::Cipher::NoPadding, QCA::Decode, key, iv, provider);
QCA::Cipher reverseCipher( QString( "des" ),
QCA::Cipher::CFB,
QCA::Cipher::NoPadding,
QCA::Decode,
key,
iv,
provider);
update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ) );
QVERIFY( reverseCipher.ok() );
QCOMPARE( update, plainText.left(update.size() ) );
@ -1446,13 +1632,25 @@ void CipherUnitTest::des_ofb()
QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
QCA::InitializationVector iv( QCA::hexToArray( ivText ) );
QCA::DES forwardCipher( QCA::Cipher::OFB, QCA::Cipher::NoPadding, QCA::Encode, key, iv, provider);
QCA::Cipher forwardCipher( QString( "des" ),
QCA::Cipher::OFB,
QCA::Cipher::NoPadding,
QCA::Encode,
key,
iv,
provider);
QString update = QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ) );
QVERIFY( forwardCipher.ok() );
QCOMPARE( update + QCA::arrayToHex( forwardCipher.final() ), cipherText );
QVERIFY( forwardCipher.ok() );
QCA::DES reverseCipher( QCA::Cipher::OFB, QCA::Cipher::NoPadding, QCA::Decode, key, iv, provider);
QCA::Cipher reverseCipher( QString( "des" ),
QCA::Cipher::OFB,
QCA::Cipher::NoPadding,
QCA::Decode,
key,
iv,
provider);
update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ) );
QVERIFY( reverseCipher.ok() );
QCOMPARE( update, plainText.left(update.size() ) );
@ -1532,7 +1730,13 @@ void CipherUnitTest::des_pkcs7()
QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
// just a filler
QCA::InitializationVector iv;
QCA::DES forwardCipher( QCA::Cipher::ECB, QCA::Cipher::PKCS7, QCA::Encode, key, iv, provider);
QCA::Cipher forwardCipher( QString( "des" ),
QCA::Cipher::ECB,
QCA::Cipher::PKCS7,
QCA::Encode,
key,
iv,
provider);
QCOMPARE( forwardCipher.keyLength().minimum(), 8 );
QCOMPARE( forwardCipher.keyLength().maximum(), 8 );
@ -1544,7 +1748,13 @@ void CipherUnitTest::des_pkcs7()
QCOMPARE( update + QCA::arrayToHex( forwardCipher.final() ), cipherText );
QVERIFY( forwardCipher.ok() );
QCA::DES reverseCipher( QCA::Cipher::ECB, QCA::Cipher::PKCS7, QCA::Decode, key, iv, provider);
QCA::Cipher reverseCipher( QString( "des" ),
QCA::Cipher::ECB,
QCA::Cipher::PKCS7,
QCA::Decode,
key,
iv,
provider);
QCOMPARE( reverseCipher.keyLength().minimum(), 8 );
QCOMPARE( reverseCipher.keyLength().maximum(), 8 );
@ -1676,7 +1886,13 @@ void CipherUnitTest::des_cbc_pkcs7()
QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
QCA::InitializationVector iv( QCA::hexToArray( ivText ) );
QCA::DES forwardCipher( QCA::Cipher::CBC, QCA::Cipher::PKCS7, QCA::Encode, key, iv, provider);
QCA::Cipher forwardCipher( QString( "des" ),
QCA::Cipher::CBC,
QCA::Cipher::PKCS7,
QCA::Encode,
key,
iv,
provider);
QCOMPARE( forwardCipher.keyLength().minimum(), 8 );
QCOMPARE( forwardCipher.keyLength().maximum(), 8 );
@ -1688,7 +1904,13 @@ void CipherUnitTest::des_cbc_pkcs7()
QCOMPARE( update + QCA::arrayToHex( forwardCipher.final() ), cipherText );
QVERIFY( forwardCipher.ok() );
QCA::DES reverseCipher( QCA::Cipher::CBC, QCA::Cipher::PKCS7, QCA::Decode, key, iv, provider);
QCA::Cipher reverseCipher( QString( "des" ),
QCA::Cipher::CBC,
QCA::Cipher::PKCS7,
QCA::Decode,
key,
iv,
provider);
QCOMPARE( reverseCipher.keyLength().minimum(), 8 );
QCOMPARE( reverseCipher.keyLength().maximum(), 8 );
@ -1707,7 +1929,11 @@ void CipherUnitTest::des_cbc_pkcs7()
if (!QCA::isSupported("des-ecb-pkcs7") )
QWARN("DES, ECB mode with PKCS7 padding not supported!");
else {
QCA::DES cipherObj1( QCA::Cipher::ECB, QCA::Cipher::PKCS7, QCA::Encode, QCA::SymmetricKey( 8 ) );
QCA::Cipher cipherObj1( QString( "des" ),
QCA::Cipher::ECB,
QCA::Cipher::PKCS7,
QCA::Encode,
QCA::SymmetricKey( 8 ) );
QCOMPARE( cipherObj1.keyLength().minimum(), 8 );
QCOMPARE( cipherObj1.keyLength().maximum(), 8 );
QCOMPARE( cipherObj1.blockSize(), (unsigned)8 );
@ -1830,8 +2056,13 @@ void CipherUnitTest::blowfish()
if( !QCA::isSupported( "blowfish-ecb", provider ) )
QWARN( QString( "Blowfish ECB not supported for "+provider).toLocal8Bit() );
else {
QCA::BlowFish cipherObj1( QCA::Cipher::ECB, QCA::Cipher::NoPadding, QCA::Encode, QCA::SymmetricKey( 16 ),
QCA::InitializationVector(), provider );
QCA::Cipher cipherObj1( QString( "blowfish" ),
QCA::Cipher::ECB,
QCA::Cipher::NoPadding,
QCA::Encode,
QCA::SymmetricKey( 16 ),
QCA::InitializationVector(), provider );
// TODO: add some test for min and max keysizes
QCOMPARE( cipherObj1.blockSize(), (unsigned)8 );
@ -1840,16 +2071,26 @@ void CipherUnitTest::blowfish()
QFETCH( QString, keyText );
QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
QCA::BlowFish forwardCipher( QCA::Cipher::ECB, QCA::Cipher::NoPadding, QCA::Encode, key,
QCA::InitializationVector(), provider );
QCA::Cipher forwardCipher( QString( "blowfish" ),
QCA::Cipher::ECB,
QCA::Cipher::NoPadding,
QCA::Encode,
key,
QCA::InitializationVector(),
provider );
QCOMPARE( QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ) ),
QString( cipherText ) );
QVERIFY( forwardCipher.ok() );
QCOMPARE( QCA::arrayToHex( forwardCipher.final() ), QString( "" ) );
QVERIFY( forwardCipher.ok() );
QCA::BlowFish reverseCipher( QCA::Cipher::ECB, QCA::Cipher::NoPadding, QCA::Decode, key,
QCA::InitializationVector(), provider );
QCA::Cipher reverseCipher( QString( "blowfish" ),
QCA::Cipher::ECB,
QCA::Cipher::NoPadding,
QCA::Decode,
key,
QCA::InitializationVector(),
provider );
QString update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ) );
QVERIFY( reverseCipher.ok() );
QCOMPARE( update, plainText.left(update.size() ) );
@ -1897,14 +2138,25 @@ void CipherUnitTest::blowfish_cbc()
QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
QCA::InitializationVector iv( QCA::hexToArray( ivText ) );
QCA::BlowFish forwardCipher( QCA::Cipher::CBC, QCA::Cipher::NoPadding, QCA::Encode, key, iv, provider);
QCA::Cipher forwardCipher( QString( "blowfish" ),
QCA::Cipher::CBC,
QCA::Cipher::NoPadding,
QCA::Encode,
key,
iv,
provider);
QString update = QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ) );
QVERIFY( forwardCipher.ok() );
QCOMPARE( update + QCA::arrayToHex( forwardCipher.final() ), cipherText );
QVERIFY( forwardCipher.ok() );
QCA::BlowFish reverseCipher( QCA::Cipher::CBC, QCA::Cipher::NoPadding, QCA::Decode, key, iv, provider);
QCA::Cipher reverseCipher( QString( "blowfish" ),
QCA::Cipher::CBC,
QCA::Cipher::NoPadding,
QCA::Decode,
key,
iv,
provider);
update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ) );
QVERIFY( reverseCipher.ok() );
QCOMPARE( update, plainText.left(update.size() ) );
@ -1948,15 +2200,26 @@ void CipherUnitTest::blowfish_cbc_pkcs7()
QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
QCA::InitializationVector iv( QCA::hexToArray( ivText ) );
QCA::BlowFish forwardCipher( QCA::Cipher::CBC, QCA::Cipher::PKCS7, QCA::Encode, key, iv, provider);
QCA::Cipher forwardCipher( QString( "blowfish" ),
QCA::Cipher::CBC,
QCA::Cipher::PKCS7,
QCA::Encode,
key,
iv,
provider);
QString update = QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ) );
QVERIFY( forwardCipher.ok() );
QCOMPARE( update, cipherText.left(update.size()) );
QCOMPARE( update + QCA::arrayToHex( forwardCipher.final() ), cipherText );
QVERIFY( forwardCipher.ok() );
QCA::BlowFish reverseCipher( QCA::Cipher::CBC, QCA::Cipher::PKCS7, QCA::Decode, key, iv, provider);
QCA::Cipher reverseCipher( QString( "blowfish" ),
QCA::Cipher::CBC,
QCA::Cipher::PKCS7,
QCA::Decode,
key,
iv,
provider);
update = QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ) );
QVERIFY( reverseCipher.ok() );
QCOMPARE( update, plainText.left(update.size()) );
@ -1999,14 +2262,25 @@ void CipherUnitTest::blowfish_cfb()
QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
QCA::InitializationVector iv( QCA::hexToArray( ivText ) );
QCA::BlowFish forwardCipher( QCA::Cipher::CFB, QCA::Cipher::NoPadding, QCA::Encode, key, iv, provider);
QCA::Cipher forwardCipher( QString( "blowfish" ),
QCA::Cipher::CFB,
QCA::Cipher::NoPadding,
QCA::Encode,
key,
iv,
provider);
QString update = QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ) );
QVERIFY( forwardCipher.ok() );
QCOMPARE( update + QCA::arrayToHex( forwardCipher.final() ), cipherText );
QVERIFY( forwardCipher.ok() );
QCA::BlowFish reverseCipher( QCA::Cipher::CFB, QCA::Cipher::NoPadding, QCA::Decode, key, iv, provider);
QCA::Cipher reverseCipher( QString( "blowfish" ),
QCA::Cipher::CFB,
QCA::Cipher::NoPadding,
QCA::Decode,
key,
iv,
provider);
QCOMPARE( QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ) ), plainText );
QVERIFY( reverseCipher.ok() );
QCOMPARE( QCA::arrayToHex( reverseCipher.final() ), QString( "" ) );
@ -2047,13 +2321,25 @@ void CipherUnitTest::blowfish_ofb()
QCA::SymmetricKey key( QCA::hexToArray( keyText ) );
QCA::InitializationVector iv( QCA::hexToArray( ivText ) );
QCA::BlowFish forwardCipher( QCA::Cipher::OFB, QCA::Cipher::NoPadding, QCA::Encode, key, iv, provider);
QCA::Cipher forwardCipher( QString( "blowfish" ),
QCA::Cipher::OFB,
QCA::Cipher::NoPadding,
QCA::Encode,
key,
iv,
provider);
QString update = QCA::arrayToHex( forwardCipher.update( QCA::hexToArray( plainText ) ) );
QVERIFY( forwardCipher.ok() );
QCOMPARE( update + QCA::arrayToHex( forwardCipher.final() ), cipherText );
QVERIFY( forwardCipher.ok() );
QCA::BlowFish reverseCipher( QCA::Cipher::OFB, QCA::Cipher::NoPadding, QCA::Decode, key, iv, provider);
QCA::Cipher reverseCipher( QString( "blowfish" ),
QCA::Cipher::OFB,
QCA::Cipher::NoPadding,
QCA::Decode,
key,
iv,
provider);
QCOMPARE( QCA::arrayToHex( reverseCipher.update( QCA::hexToArray( cipherText ) ) ), plainText );
QVERIFY( reverseCipher.ok() );

50
unittest/hashunittest/hashunittest.cpp
View File

@ -71,7 +71,7 @@ void HashUnitTest::md2test()
foreach(QString provider, providersToTest) {
if(!QCA::isSupported("md2", provider))
QSKIP(QString("MD2 not supported for "+provider).toLocal8Bit(), SkipSingle);
QString hashResult = QCA::MD2(provider).hashToString(input);
QString hashResult = QCA::Hash("md2", provider).hashToString(input);
QCOMPARE( hashResult, expectedHash );
}
}
@ -113,7 +113,7 @@ void HashUnitTest::md4test()
if(!QCA::isSupported("md4", provider))
QWARN(QString("MD4 not supported for "+provider).toLocal8Bit());
else {
QString hashResult = QCA::MD4(provider).hashToString(input);
QString hashResult = QCA::Hash("md4", provider).hashToString(input);
QCOMPARE( hashResult, expectedHash );
}
}
@ -157,7 +157,7 @@ void HashUnitTest::md5test()
if(!QCA::isSupported("md5", provider))
QWARN(QString("MD5 not supported for "+provider).toLocal8Bit());
else {
QString hashResult = QCA::MD5(provider).hashToString(input);
QString hashResult = QCA::Hash("md5", provider).hashToString(input);
QCOMPARE( hashResult, expectedHash );
}
}
@ -180,7 +180,7 @@ void HashUnitTest::md5filetest()
else {
QFile f1( "./data/empty" );
if ( f1.open( QIODevice::ReadOnly ) ) {
QCA::MD5 hashObj(provider);
QCA::Hash hashObj("md5", provider);
hashObj.update( f1 );
QCOMPARE( QString( QCA::arrayToHex( hashObj.final() ) ),
QString( "d41d8cd98f00b204e9800998ecf8427e" ) );
@ -190,7 +190,7 @@ void HashUnitTest::md5filetest()
QFile f2( "./data/Botan-1.4.1.tar.bz2" );
if ( f2.open( QIODevice::ReadOnly ) ) {
QCA::MD5 hashObj(provider);
QCA::Hash hashObj("md5", provider);
hashObj.update( f2 );
QCOMPARE( QString( QCA::arrayToHex( hashObj.final() ) ),
QString( "7c4b3d8a360c6c3cb647160fa9adfe71" ) );
@ -201,7 +201,7 @@ void HashUnitTest::md5filetest()
QFile f3( "./data/linux-2.6.7.tar.bz2" );
if ( f3.open( QIODevice::ReadOnly ) ) {
QCA::MD5 hashObj(provider);
QCA::Hash hashObj("md5", provider);
hashObj.update( f3 );
QCOMPARE( QString( QCA::arrayToHex( hashObj.final() ) ),
QString( "a74671ea68b0e3c609e8785ed8497c14" ) );
@ -211,7 +211,7 @@ void HashUnitTest::md5filetest()
QFile f4( "./data/scribus-1.2.tar.bz2" );
if ( f4.open( QIODevice::ReadOnly ) ) {
QCA::MD5 hashObj(provider);
QCA::Hash hashObj("md5", provider);
hashObj.update( f4 );
QCOMPARE( QString( QCA::arrayToHex( hashObj.final() ) ),
QString( "7d2c2b228f9a6ff82c9401fd54bdbe16" ) );
@ -247,7 +247,7 @@ void HashUnitTest::sha0test()
if(!QCA::isSupported("sha0", provider))
QWARN(QString("SHA0 not supported for "+provider).toLocal8Bit());
else {
QString hashResult = QCA::SHA0(provider).hashToString(input);
QString hashResult = QCA::Hash("sha0", provider).hashToString(input);
QCOMPARE( hashResult, expectedHash );
}
}
@ -268,7 +268,7 @@ void HashUnitTest::sha0longtest()
if(!QCA::isSupported("sha0", provider))
QWARN(QString("SHA0 not supported for "+provider).toLocal8Bit());
else {
QCA::SHA0 shaHash(provider);
QCA::Hash shaHash("sha0", provider);
for (int i=0; i<1000; i++)
shaHash.update(fillerString);
QCOMPARE( QString(QCA::arrayToHex(shaHash.final())),
@ -322,7 +322,7 @@ void HashUnitTest::sha1test()
if(!QCA::isSupported("sha1", provider))
QWARN(QString("SHA1 not supported for "+provider).toLocal8Bit());
else {
QString hashResult = QCA::SHA1(provider).hashToString(input);
QString hashResult = QCA::Hash("sha1", provider).hashToString(input);
QCOMPARE( hashResult, expectedHash );
}
}
@ -350,7 +350,7 @@ void HashUnitTest::sha1longtest()
// This test extracted from OpenOffice.org 1.1.2, in sal/workben/t_digest.c
// It basically reflects FIPS 180-2, Appendix A.3
// Also as per AS 2805.13.3-2000 Appendix A
QCA::SHA1 shaHash(provider);
QCA::Hash shaHash("sha1", provider);
for (int i=0; i<1000; i++)
shaHash.update(fillerString);
QCOMPARE( QString(QCA::arrayToHex(shaHash.final())),
@ -358,7 +358,7 @@ void HashUnitTest::sha1longtest()
QFile f1( "./data/empty" );
if ( f1.open( QIODevice::ReadOnly ) ) {
QCA::SHA1 hashObj(provider);
QCA::Hash hashObj("sha1", provider);
hashObj.update( f1 );
QCOMPARE( QString( QCA::arrayToHex( hashObj.final() ) ),
QString( "da39a3ee5e6b4b0d3255bfef95601890afd80709" ) );
@ -368,7 +368,7 @@ void HashUnitTest::sha1longtest()
QFile f2( "./data/Botan-1.4.1.tar.bz2" );
if ( f2.open( QIODevice::ReadOnly ) ) {
QCA::SHA1 hashObj(provider);
QCA::Hash hashObj("sha1", provider);
hashObj.update( f2 );
QCOMPARE( QString( QCA::arrayToHex( hashObj.final() ) ),
QString( "cda343591428a68e22bd2e349b890cbafb642cf7" ) );
@ -378,7 +378,7 @@ void HashUnitTest::sha1longtest()
QFile f3( "./data/linux-2.6.7.tar.bz2" );
if ( f3.open( QIODevice::ReadOnly ) ) {
QCA::SHA1 hashObj(provider);
QCA::Hash hashObj("sha1", provider);
hashObj.update( f3 );
QCOMPARE( QString( QCA::arrayToHex( hashObj.final() ) ),
QString( "a030a9c6dcd10c5d90a86f915ad4710084cbca71" ) );
@ -388,7 +388,7 @@ void HashUnitTest::sha1longtest()
QFile f4( "./data/scribus-1.2.tar.bz2" );
if ( f4.open( QIODevice::ReadOnly ) ) {
QCA::SHA1 hashObj(provider);
QCA::Hash hashObj("sha1", provider);
hashObj.update( f4 );
QCOMPARE( QString( QCA::arrayToHex( hashObj.final() ) ),
QString( "a1fb6ed6acfd92381055b310d926d6e83e76ff1e" ) );
@ -429,7 +429,7 @@ void HashUnitTest::sha224test()
if(!QCA::isSupported("sha224", provider))
QWARN(QString("SHA224 not supported for "+provider).toLocal8Bit());
else {
QString hashResult = QCA::SHA224(provider).hashToString(input);
QString hashResult = QCA::Hash("sha224", provider).hashToString(input);
QCOMPARE( hashResult, expectedHash );
}
}
@ -450,7 +450,7 @@ void HashUnitTest::sha224longtest()
if(!QCA::isSupported("sha224", provider))
QWARN(QString("SHA224 not supported for "+provider).toLocal8Bit());
else {
QCA::SHA224 shaHash(provider);
QCA::Hash shaHash("sha224", provider);
// This basically reflects FIPS 180-2, change notice 1, section 3
for (int i=0; i<1000; i++)
@ -498,7 +498,7 @@ void HashUnitTest::sha256test()
if(!QCA::isSupported("sha256", provider))
QWARN(QString("SHA256 not supported for "+provider).toLocal8Bit());
else {
QString hashResult = QCA::SHA256(provider).hashToString(input);
QString hashResult = QCA::Hash("sha256", provider).hashToString(input);
QCOMPARE( hashResult, expectedHash );
}
}
@ -519,7 +519,7 @@ void HashUnitTest::sha256longtest()
if(!QCA::isSupported("sha256", provider))
QWARN(QString("SHA256 not supported for "+provider).toLocal8Bit());
else {
QCA::SHA256 shaHash(provider);
QCA::Hash shaHash("sha256", provider);
// This basically reflects FIPS 180-2, change notice 1, section 3
for (int i=0; i<1000; i++)
@ -576,7 +576,7 @@ void HashUnitTest::sha384test()
if(!QCA::isSupported("sha384", provider))
QWARN(QString("SHA384 not supported for "+provider).toLocal8Bit());
else {
QString hashResult = QCA::SHA384(provider).hashToString(input);
QString hashResult = QCA::Hash("sha384", provider).hashToString(input);
QCOMPARE( hashResult, expectedHash );
}
}
@ -600,7 +600,7 @@ void HashUnitTest::sha384longtest()
else {
// QTime t;
// t.start();
QCA::SHA384 shaHash(provider);
QCA::Hash shaHash("sha384", provider);
// This basically reflects FIPS 180-2, change notice 1, section 3
for (int i=0; i<1000; i++)
@ -654,7 +654,7 @@ void HashUnitTest::sha512test()
if(!QCA::isSupported("sha512", provider))
QWARN(QString("SHA512 not supported for "+provider).toLocal8Bit());
else {
QString hashResult = QCA::SHA512(provider).hashToString(input);
QString hashResult = QCA::Hash("sha512", provider).hashToString(input);
QCOMPARE( hashResult, expectedHash );
}
}
@ -676,7 +676,7 @@ void HashUnitTest::sha512longtest()
if(!QCA::isSupported("sha512", provider))
QWARN(QString("SHA512 not supported for "+provider).toLocal8Bit());
else {
QCA::SHA512 shaHash(provider);
QCA::Hash shaHash("sha512", provider);
// This basically reflects FIPS 180-2, change notice 1, section 3
for (int i=0; i<1000; i++)
@ -728,7 +728,7 @@ void HashUnitTest::rmd160test()
if(!QCA::isSupported("ripemd160", provider))
QWARN(QString("RIPEMD160 not supported for "+provider).toLocal8Bit());
else {
QString hashResult = QCA::RIPEMD160(provider).hashToString(input);
QString hashResult = QCA::Hash("ripemd160", provider).hashToString(input);
QCOMPARE( hashResult, expectedHash );
}
}
@ -748,7 +748,7 @@ void HashUnitTest::rmd160longtest()
if(!QCA::isSupported("ripemd160", provider))
QWARN(QString("RIPEMD160 not supported for "+provider).toLocal8Bit());
else {
QCA::RIPEMD160 rmdHash(provider);
QCA::Hash rmdHash("ripemd160", provider);
// This is the "million times 'a' test"
for (int i=0; i<1000; i++)

88
unittest/macunittest/macunittest.cpp
View File

@ -49,7 +49,7 @@ void MACUnitTest::HMACMD5()
if( !QCA::isSupported( "hmac(md5)", provider ) )
QWARN( QString( "HMAC(MD5) not supported for "+provider).toLocal8Bit() );
else {
QCA::HMAC md5hmacLenTest( "md5", QCA::SymmetricKey(), provider );
QCA::MessageAuthenticationCode md5hmacLenTest( "hmac(md5)", QCA::SymmetricKey(), provider );
QCOMPARE( md5hmacLenTest.validKeyLength( 0 ), true );
QCOMPARE( md5hmacLenTest.validKeyLength( 1 ), true );
QCOMPARE( md5hmacLenTest.validKeyLength( 848888 ), true );
@ -57,14 +57,14 @@ void MACUnitTest::HMACMD5()
// These tests are from RFC2202, Section 2.
// The first three are also in the Appendix to RFC2104
QCA::HMAC md5hmac1( "md5", QCA::SymmetricKey(), provider );
QCA::MessageAuthenticationCode md5hmac1( "hmac(md5)", QCA::SymmetricKey(), provider );
QCA::SymmetricKey key1( QSecureArray( "Jefe" ) );
md5hmac1.setup( key1 );
QSecureArray data1( "what do ya want for nothing?" );
md5hmac1.update( data1 );
QCOMPARE( QCA::arrayToHex( md5hmac1.final() ), QString( "750c783e6ab0b503eaa86e310a5db738" ) );
QCA::HMAC md5hmac2( "md5", QCA::SymmetricKey(), provider );
QCA::MessageAuthenticationCode md5hmac2( "hmac(md5)", QCA::SymmetricKey(), provider );
QCA::SymmetricKey key2( QCA::hexToArray( "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b" ) );
md5hmac2.setup( key2 );
QSecureArray data2 = QSecureArray( "Hi There" );
@ -82,21 +82,21 @@ void MACUnitTest::HMACMD5()
QCOMPARE( QCA::arrayToHex( md5hmac2.final() ), QString( "56be34521d144c88dbb8c733f0e8b3f6" ) );
QCA::SymmetricKey key4( QCA::hexToArray( "0102030405060708090a0b0c0d0e0f10111213141516171819") );
QCA::HMAC md5hmac4( "md5", key4, provider );
QCA::MessageAuthenticationCode md5hmac4( "hmac(md5)", key4, provider );
QSecureArray data4( 50 );
for (int i = 0; i < data4.size(); i++ )
data4[ i ] = (char)0xcd;
md5hmac4.update( data4 );
QCOMPARE( QCA::arrayToHex( md5hmac4.final() ), QString( "697eaf0aca3a3aea3a75164746ffaa79" ) );
QCA::HMAC md5hmac5( "md5" );
QCA::MessageAuthenticationCode md5hmac5( "hmac(md5)" );
QCA::SymmetricKey key5( QCA::hexToArray( "0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c" ) );
md5hmac5.setup( key5 );
QSecureArray data5( "Test With Truncation" );
md5hmac5.update( data5 );
QCOMPARE( QCA::arrayToHex( md5hmac5.final() ), QString( "56461ef2342edc00f9bab995690efd4c" ) );
QCA::HMAC md5hmac6( "md5", QCA::SymmetricKey(), provider );
QCA::MessageAuthenticationCode md5hmac6( "hmac(md5)", QCA::SymmetricKey(), provider );
QCA::SymmetricKey key6( 80 );
for (int i = 0; i < key6.size(); i++)
key6[ i ] = (char)0xaa;
@ -126,13 +126,13 @@ void MACUnitTest::HMACSHA256()
if( !QCA::isSupported( "hmac(sha256)", provider ) )
QWARN( QString( "HMAC(SHA256) not supported for "+provider).toLocal8Bit() );
else {
QCA::HMAC hmacLenTest( "sha256", QCA::SymmetricKey(), provider );
QCA::MessageAuthenticationCode hmacLenTest( "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::HMAC hmac1( "sha256", QCA::SymmetricKey(), provider );
QCA::MessageAuthenticationCode hmac1( "hmac(sha256)", QCA::SymmetricKey(), provider );
QCA::SymmetricKey key1( QSecureArray( "Jefe" ) );
hmac1.setup( key1 );
QSecureArray data1( "what do ya want for nothing?" );
@ -140,7 +140,7 @@ void MACUnitTest::HMACSHA256()
QCOMPARE( QCA::arrayToHex( hmac1.final() ),
QString( "5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843" ) );
QCA::HMAC hmac2( "sha256", QCA::SymmetricKey(), provider );
QCA::MessageAuthenticationCode hmac2( "hmac(sha256)", QCA::SymmetricKey(), provider );
QCA::SymmetricKey key2( QCA::hexToArray( "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b" ) );
hmac2.setup( key2 );
QSecureArray data2 = QSecureArray( "Hi There" );
@ -160,7 +160,7 @@ void MACUnitTest::HMACSHA256()
QString( "773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514ced565fe" ) );
QCA::SymmetricKey key4( QCA::hexToArray( "0102030405060708090a0b0c0d0e0f10111213141516171819") );
QCA::HMAC hmac4( "sha256", key4, provider );
QCA::MessageAuthenticationCode hmac4( "hmac(sha256)", key4, provider );
QSecureArray data4( 50 );
for (int i = 0; i < data4.size(); i++ )
data4[ i ] = (char)0xcd;
@ -168,7 +168,7 @@ void MACUnitTest::HMACSHA256()
QCOMPARE( QCA::arrayToHex( hmac4.final() ),
QString( "82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff46729665b" ) );
QCA::HMAC hmac5( "sha256", QCA::SymmetricKey(), provider );
QCA::MessageAuthenticationCode hmac5( "hmac(sha256)", QCA::SymmetricKey(), provider );
QCA::SymmetricKey key5( QCA::hexToArray( "0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c" ) );
hmac5.setup( key5 );
QSecureArray data5( "Test With Truncation" );
@ -177,7 +177,7 @@ void MACUnitTest::HMACSHA256()
resultWithTrunc.resize(32);
QCOMPARE( resultWithTrunc, QString( "a3b6167473100ee06e0c796c2955552b" ) );
QCA::HMAC hmac6( "sha256", QCA::SymmetricKey(), provider );
QCA::MessageAuthenticationCode hmac6( "hmac(sha256)", QCA::SymmetricKey(), provider );
QCA::SymmetricKey key6( 131 );
for (int i = 0; i < key6.size(); i++)
key6[ i ] = (char)0xaa;
@ -207,13 +207,13 @@ void MACUnitTest::HMACSHA224()
if( !QCA::isSupported( "hmac(sha224)", provider ) )
QWARN( QString( "HMAC(SHA224) not supported for "+provider).toLocal8Bit() );
else {
QCA::HMAC hmacLenTest( "sha224", QCA::SymmetricKey(), provider );
QCA::MessageAuthenticationCode hmacLenTest( "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::HMAC hmac1( "sha224", QCA::SymmetricKey(), provider );
QCA::MessageAuthenticationCode hmac1( "hmac(sha224)", QCA::SymmetricKey(), provider );
QCA::SymmetricKey key1( QSecureArray( "Jefe" ) );
hmac1.setup( key1 );
QSecureArray data1( "what do ya want for nothing?" );
@ -221,7 +221,7 @@ void MACUnitTest::HMACSHA224()
QCOMPARE( QCA::arrayToHex( hmac1.final() ),
QString( "a30e01098bc6dbbf45690f3a7e9e6d0f8bbea2a39e6148008fd05e44" ) );
QCA::HMAC hmac2( "sha224", QCA::SymmetricKey(), provider );
QCA::MessageAuthenticationCode hmac2( "hmac(sha224)", QCA::SymmetricKey(), provider );
QCA::SymmetricKey key2( QCA::hexToArray( "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b" ) );
hmac2.setup( key2 );
QSecureArray data2 = QSecureArray( "Hi There" );
@ -241,7 +241,7 @@ void MACUnitTest::HMACSHA224()
QString( "7fb3cb3588c6c1f6ffa9694d7d6ad2649365b0c1f65d69d1ec8333ea" ) );
QCA::SymmetricKey key4( QCA::hexToArray( "0102030405060708090a0b0c0d0e0f10111213141516171819") );
QCA::HMAC hmac4( "sha224", key4, provider );
QCA::MessageAuthenticationCode hmac4( "hmac(sha224)", key4, provider );
QSecureArray data4( 50 );
for (int i = 0; i < data4.size(); i++ )
data4[ i ] = (char)0xcd;
@ -249,7 +249,7 @@ void MACUnitTest::HMACSHA224()
QCOMPARE( QCA::arrayToHex( hmac4.final() ),
QString( "6c11506874013cac6a2abc1bb382627cec6a90d86efc012de7afec5a" ) );
QCA::HMAC hmac5( "sha224", QCA::SymmetricKey(), provider );
QCA::MessageAuthenticationCode hmac5( "hmac(sha224)", QCA::SymmetricKey(), provider );
QCA::SymmetricKey key5( QCA::hexToArray( "0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c" ) );
hmac5.setup( key5 );
QSecureArray data5( "Test With Truncation" );
@ -258,7 +258,7 @@ void MACUnitTest::HMACSHA224()
resultWithTrunc.resize(32);
QCOMPARE( resultWithTrunc, QString( "0e2aea68a90c8d37c988bcdb9fca6fa8" ) );
QCA::HMAC hmac6( "sha224", QCA::SymmetricKey(), provider );
QCA::MessageAuthenticationCode hmac6( "hmac(sha224)", QCA::SymmetricKey(), provider );
QCA::SymmetricKey key6( 131 );
for (int i = 0; i < key6.size(); i++)
key6[ i ] = (char)0xaa;
@ -289,13 +289,13 @@ void MACUnitTest::HMACSHA384()
if( !QCA::isSupported( "hmac(sha384)", provider ) )
QWARN( QString( "HMAC(SHA384) not supported for "+provider).toLocal8Bit() );
else {
QCA::HMAC hmacLenTest( "sha384", QCA::SymmetricKey(), provider );
QCA::MessageAuthenticationCode hmacLenTest( "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::HMAC hmac1( "sha384", QCA::SymmetricKey(), provider );
QCA::MessageAuthenticationCode hmac1( "hmac(sha384)", QCA::SymmetricKey(), provider );
QCA::SymmetricKey key1( QSecureArray( "Jefe" ) );
hmac1.setup( key1 );
QSecureArray data1( "what do ya want for nothing?" );
@ -303,7 +303,7 @@ void MACUnitTest::HMACSHA384()
QCOMPARE( QCA::arrayToHex( hmac1.final() ),
QString( "af45d2e376484031617f78d2b58a6b1b9c7ef464f5a01b47e42ec3736322445e8e2240ca5e69e2c78b3239ecfab21649" ) );
QCA::HMAC hmac2( "sha384", QCA::SymmetricKey(), provider );
QCA::MessageAuthenticationCode hmac2( "hmac(sha384)", QCA::SymmetricKey(), provider );
QCA::SymmetricKey key2( QCA::hexToArray( "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b" ) );
hmac2.setup( key2 );
QSecureArray data2 = QSecureArray( "Hi There" );
@ -323,7 +323,7 @@ void MACUnitTest::HMACSHA384()
QString( "88062608d3e6ad8a0aa2ace014c8a86f0aa635d947ac9febe83ef4e55966144b2a5ab39dc13814b94e3ab6e101a34f27" ) );
QCA::SymmetricKey key4( QCA::hexToArray( "0102030405060708090a0b0c0d0e0f10111213141516171819") );
QCA::HMAC hmac4( "sha384", key4, provider );
QCA::MessageAuthenticationCode hmac4( "hmac(sha384)", key4, provider );
QSecureArray data4( 50 );
for (int i = 0; i < data4.size(); i++ )
data4[ i ] = (char)0xcd;
@ -331,7 +331,7 @@ void MACUnitTest::HMACSHA384()
QCOMPARE( QCA::arrayToHex( hmac4.final() ),
QString( "3e8a69b7783c25851933ab6290af6ca77a9981480850009cc5577c6e1f573b4e6801dd23c4a7d679ccf8a386c674cffb" ) );
QCA::HMAC hmac5( "sha384", QSecureArray(), provider );
QCA::MessageAuthenticationCode hmac5( "hmac(sha384)", QSecureArray(), provider );
QCA::SymmetricKey key5( QCA::hexToArray( "0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c" ) );
hmac5.setup( key5 );
QSecureArray data5( "Test With Truncation" );
@ -340,7 +340,7 @@ void MACUnitTest::HMACSHA384()
resultWithTrunc.resize(32);
QCOMPARE( resultWithTrunc, QString( "3abf34c3503b2a23a46efc619baef897" ) );
QCA::HMAC hmac6( "sha384", QCA::SymmetricKey(), provider );
QCA::MessageAuthenticationCode hmac6( "hmac(sha384)", QCA::SymmetricKey(), provider );
QCA::SymmetricKey key6( 131 );
for (int i = 0; i < key6.size(); i++)
key6[ i ] = (char)0xaa;
@ -371,13 +371,13 @@ void MACUnitTest::HMACSHA512()
if( !QCA::isSupported( "hmac(sha512)", provider ) )
QWARN( QString( "HMAC(SHA512) not supported for "+provider).toLocal8Bit() );
else {
QCA::HMAC hmacLenTest( "sha512", QCA::SymmetricKey(), provider );
QCA::MessageAuthenticationCode hmacLenTest( "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::HMAC hmac1( "sha512", QCA::SymmetricKey(), provider );
QCA::MessageAuthenticationCode hmac1( "hmac(sha512)", QCA::SymmetricKey(), provider );
QCA::SymmetricKey key1( QSecureArray( "Jefe" ) );
hmac1.setup( key1 );
QSecureArray data1( "what do ya want for nothing?" );
@ -385,7 +385,7 @@ void MACUnitTest::HMACSHA512()
QCOMPARE( QCA::arrayToHex( hmac1.final() ),
QString( "164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7ea2505549758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b636e070a38bce737" ) );
QCA::HMAC hmac2( "sha512", QCA::SymmetricKey(), provider );
QCA::MessageAuthenticationCode hmac2( "hmac(sha512)", QCA::SymmetricKey(), provider );
QCA::SymmetricKey key2( QCA::hexToArray( "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b" ) );
hmac2.setup( key2 );
QSecureArray data2 = QSecureArray( "Hi There" );
@ -405,7 +405,7 @@ void MACUnitTest::HMACSHA512()
QString( "fa73b0089d56a284efb0f0756c890be9b1b5dbdd8ee81a3655f83e33b2279d39bf3e848279a722c806b485a47e67c807b946a337bee8942674278859e13292fb" ) );
QCA::SymmetricKey key4( QCA::hexToArray( "0102030405060708090a0b0c0d0e0f10111213141516171819") );
QCA::HMAC hmac4( "sha512", key4, provider );
QCA::MessageAuthenticationCode hmac4( "hmac(sha512)", key4, provider );
QSecureArray data4( 50 );
for (int i = 0; i < data4.size(); i++ )
data4[ i ] = (char)0xcd;
@ -413,7 +413,7 @@ void MACUnitTest::HMACSHA512()
QCOMPARE( QCA::arrayToHex( hmac4.final() ),
QString( "b0ba465637458c6990e5a8c5f61d4af7e576d97ff94b872de76f8050361ee3dba91ca5c11aa25eb4d679275cc5788063a5f19741120c4f2de2adebeb10a298dd" ) );
QCA::HMAC hmac5( "sha512", QSecureArray(), provider );
QCA::MessageAuthenticationCode hmac5( "hmac(sha512)", QSecureArray(), provider );
QCA::SymmetricKey key5( QCA::hexToArray( "0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c" ) );
hmac5.setup( key5 );
QSecureArray data5( "Test With Truncation" );
@ -422,7 +422,7 @@ void MACUnitTest::HMACSHA512()
resultWithTrunc.resize(32);
QCOMPARE( resultWithTrunc, QString( "415fad6271580a531d4179bc891d87a6" ) );
QCA::HMAC hmac6( "sha512", QCA::SymmetricKey(), provider );
QCA::MessageAuthenticationCode hmac6( "hmac(sha512)", QCA::SymmetricKey(), provider );
QCA::SymmetricKey key6( 131 );
for (int i = 0; i < key6.size(); i++)
key6[ i ] = (char)0xaa;
@ -453,28 +453,28 @@ void MACUnitTest::HMACSHA1()
if( !QCA::isSupported( "hmac(sha1)", provider ) )
QWARN( QString( "HMAC(SHA1) not supported for "+provider).toLocal8Bit() );
else {
QCA::HMAC sha1hmacLenTest( "sha1", QCA::SymmetricKey(), provider );
QCA::MessageAuthenticationCode sha1hmacLenTest( "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 );
// These tests are from RFC2202, Section 3.
QCA::HMAC test1; // should be default
QCA::MessageAuthenticationCode test1; // should be default
QCA::SymmetricKey key1( QCA::hexToArray( "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b" ) );
test1.setup( key1 );
QSecureArray data1( "Hi There" );
test1.update( data1 );
QCOMPARE( QCA::arrayToHex( test1.final() ), QString( "b617318655057264e28bc0b6fb378c8ef146be00" ) );
QCA::HMAC test2( "sha1", QCA::SymmetricKey(), provider);
QCA::MessageAuthenticationCode test2( "hmac(sha1)", QCA::SymmetricKey(), provider);
QCA::SymmetricKey key2( QSecureArray( "Jefe" ) );
test2.setup( key2 );
QSecureArray data2( "what do ya want for nothing?" );
test2.update( data2 );
QCOMPARE( QCA::arrayToHex( test2.final() ), QString( "effcdf6ae5eb2fa2d27416d5f184df9c259a7c79" ) );
QCA::HMAC test3( "sha1", QCA::SymmetricKey(), provider);
QCA::MessageAuthenticationCode test3( "hmac(sha1)", QCA::SymmetricKey(), provider);
QCA::SymmetricKey key3( QCA::hexToArray( "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" ) );
test3.setup( key3 );
QSecureArray data3( 50 );
@ -483,7 +483,7 @@ void MACUnitTest::HMACSHA1()
test3.update( data3 );
QCOMPARE( QCA::arrayToHex( test3.final() ), QString( "125d7342b9ac11cd91a39af48aa17b4f63f175d3" ) );
QCA::HMAC test4( "sha1", QCA::SymmetricKey(), provider);
QCA::MessageAuthenticationCode test4( "hmac(sha1)", QCA::SymmetricKey(), provider);
QCA::SymmetricKey key4( QCA::hexToArray( "0102030405060708090a0b0c0d0e0f10111213141516171819" ) );
test4.setup( key4 );
QSecureArray data4( 50 );
@ -492,14 +492,14 @@ void MACUnitTest::HMACSHA1()
test4.update( data4 );
QCOMPARE( QCA::arrayToHex( test4.final() ), QString( "4c9007f4026250c6bc8414f9bf50c86c2d7235da" ) );
QCA::HMAC test5( "sha1", QCA::SymmetricKey(), provider);
QCA::MessageAuthenticationCode test5( "hmac(sha1)", QCA::SymmetricKey(), provider);
QCA::SymmetricKey key5 ( QCA::hexToArray( "0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c" ) );
test5.setup( key5 );
QSecureArray data5( "Test With Truncation" );
test5.update( data5 );
QCOMPARE( QCA::arrayToHex( test5.final() ), QString( "4c1a03424b55e07fe7f27be1d58bb9324a9a5a04" ) );
QCA::HMAC test6( "sha1", QCA::SymmetricKey(), provider);
QCA::MessageAuthenticationCode test6( "hmac(sha1)", QCA::SymmetricKey(), provider);
QCA::SymmetricKey key6( 80 );
for ( int i = 0; i < key6.size(); i++ )
key6[i] = (char)0xAA;
@ -527,28 +527,28 @@ void MACUnitTest::HMACRMD160()
if( !QCA::isSupported( "hmac(ripemd160)", provider ) )
QWARN( QString( "HMAC(RIPEMD160) not supported for "+provider).toLocal8Bit() );
else {
QCA::HMAC ripemd160hmacLenTest( "ripemd160", QCA::SymmetricKey(), provider );
QCA::MessageAuthenticationCode ripemd160hmacLenTest( "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 );
// These tests are from RFC2286, Section 2.
QCA::HMAC test1( "ripemd160", QCA::SymmetricKey(), provider );
QCA::MessageAuthenticationCode test1( "hmac(ripemd160)", QCA::SymmetricKey(), provider );
QCA::SymmetricKey key1 ( QCA::hexToArray( "0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b" ) );
test1.setup( key1 );
QSecureArray data1( "Hi There" );
test1.update( data1 );
QCOMPARE( QCA::arrayToHex( test1.final() ), QString( "24cb4bd67d20fc1a5d2ed7732dcc39377f0a5668" ) );
QCA::HMAC test2( "ripemd160", QCA::SymmetricKey(), provider );
QCA::MessageAuthenticationCode test2( "hmac(ripemd160)", QCA::SymmetricKey(), provider );
QCA::SymmetricKey key2( QSecureArray( "Jefe" ) );
test2.setup( key2 );
QSecureArray data2( "what do ya want for nothing?" );
test2.update( data2 );
QCOMPARE( QCA::arrayToHex( test2.final() ), QString( "dda6c0213a485a9e24f4742064a7f033b43c4069" ) );
QCA::HMAC test3( "ripemd160", QCA::SymmetricKey(), provider );
QCA::MessageAuthenticationCode test3( "hmac(ripemd160)", QCA::SymmetricKey(), provider );
QCA::SymmetricKey key3( QCA::hexToArray( "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" ) );
test3.setup( key3 );
QSecureArray data3( 50 );
@ -558,21 +558,21 @@ void MACUnitTest::HMACRMD160()
QCOMPARE( QCA::arrayToHex( test3.final() ), QString( "b0b105360de759960ab4f35298e116e295d8e7c1" ) );
QCA::SymmetricKey key4( QCA::hexToArray( "0102030405060708090a0b0c0d0e0f10111213141516171819" ) );
QCA::HMAC test4( "ripemd160", key4, provider );
QCA::MessageAuthenticationCode test4( "hmac(ripemd160)", key4, provider );
QSecureArray data4( 50 );
for ( int i = 0; i < data4.size(); i++ )
data4[ i ] = (char)0xcd;
test4.update( data4 );
QCOMPARE( QCA::arrayToHex( test4.final() ), QString( "d5ca862f4d21d5e610e18b4cf1beb97a4365ecf4" ) );
QCA::HMAC test5( "ripemd160", QCA::SymmetricKey(), provider );
QCA::MessageAuthenticationCode test5( "hmac(ripemd160)", QCA::SymmetricKey(), provider );
QCA::SymmetricKey key5 ( QCA::hexToArray( "0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c0c" ) );
test5.setup( key5 );
QSecureArray data5( "Test With Truncation" );
test5.update( data5 );
QCOMPARE( QCA::arrayToHex( test5.final() ), QString( "7619693978f91d90539ae786500ff3d8e0518e39" ) );
QCA::HMAC test6( "ripemd160", QCA::SymmetricKey(), provider );
QCA::MessageAuthenticationCode test6( "hmac(ripemd160)", QCA::SymmetricKey(), provider );
QCA::SymmetricKey key6( 80 );
for ( int i = 0; i < key6.size(); i++ )
key6[i] = (char)0xAA;