jacobpascual/keepassxc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add a new database settings wizard

Browse Source 
This patch implements a new database wizard to guide users through the process
of setting up a new database and choosing sane encryption settings.

It also reimplements the master key settings to be more
user-friendly. Users can now add, change, or remove individual composite
key components instead of having to set all components at once. This
avoids confusion about a password being reset if the user only wants to
add a key file.

With these changes comes a major refactor of how database composite keys and key
components are handled. Copying of keys is prohibited and each key
exists only once in memory and is referenced via shared pointers. GUI
components for changing individual keys are encapsulated into separate
classes to be more reusable. The password edit and generator widgets
have also been refactored to be more reusable.
This commit is contained in:
Janek Bevendorff
2018-05-13 23:21:43 +02:00
parent e4ded388b4
commit e443cde452
116 changed files with 5054 additions and 1692 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
tests/TestDatabase.cpp
View File

@@ -38,60 +38,54 @@ void TestDatabase::initTestCase()
void TestDatabase::testEmptyRecycleBinOnDisabled()
{
QString filename = QString(KEEPASSX_TEST_DATA_DIR).append("/RecycleBinDisabled.kdbx");
CompositeKey key;
key.addKey(PasswordKey("123"));
Database* db = Database::openDatabaseFile(filename, key);
auto key = QSharedPointer<CompositeKey>::create();
key->addKey(QSharedPointer<PasswordKey>::create("123"));
QScopedPointer<Database> db(Database::openDatabaseFile(filename, key));
QVERIFY(db);
QSignalSpy spyModified(db, SIGNAL(modifiedImmediate()));
QSignalSpy spyModified(db.data(), SIGNAL(modifiedImmediate()));
db->emptyRecycleBin();
// The database must be unmodified in this test after emptying the recycle bin.
QCOMPARE(spyModified.count(), 0);
delete db;
}
void TestDatabase::testEmptyRecycleBinOnNotCreated()
{
QString filename = QString(KEEPASSX_TEST_DATA_DIR).append("/RecycleBinNotYetCreated.kdbx");
CompositeKey key;
key.addKey(PasswordKey("123"));
Database* db = Database::openDatabaseFile(filename, key);
auto key = QSharedPointer<CompositeKey>::create();
key->addKey(QSharedPointer<PasswordKey>::create("123"));
QScopedPointer<Database> db(Database::openDatabaseFile(filename, key));
QVERIFY(db);
QSignalSpy spyModified(db, SIGNAL(modifiedImmediate()));
QSignalSpy spyModified(db.data(), SIGNAL(modifiedImmediate()));
db->emptyRecycleBin();
// The database must be unmodified in this test after emptying the recycle bin.
QCOMPARE(spyModified.count(), 0);
delete db;
}
void TestDatabase::testEmptyRecycleBinOnEmpty()
{
QString filename = QString(KEEPASSX_TEST_DATA_DIR).append("/RecycleBinEmpty.kdbx");
CompositeKey key;
key.addKey(PasswordKey("123"));
Database* db = Database::openDatabaseFile(filename, key);
auto key = QSharedPointer<CompositeKey>::create();
key->addKey(QSharedPointer<PasswordKey>::create("123"));
QScopedPointer<Database> db(Database::openDatabaseFile(filename, key));
QVERIFY(db);
QSignalSpy spyModified(db, SIGNAL(modifiedImmediate()));
QSignalSpy spyModified(db.data(), SIGNAL(modifiedImmediate()));
db->emptyRecycleBin();
// The database must be unmodified in this test after emptying the recycle bin.
QCOMPARE(spyModified.count(), 0);
delete db;
}
void TestDatabase::testEmptyRecycleBinWithHierarchicalData()
{
QString filename = QString(KEEPASSX_TEST_DATA_DIR).append("/RecycleBinWithData.kdbx");
CompositeKey key;
key.addKey(PasswordKey("123"));
Database* db = Database::openDatabaseFile(filename, key);
auto key = QSharedPointer<CompositeKey>::create();
key->addKey(QSharedPointer<PasswordKey>::create("123"));
QScopedPointer<Database> db(Database::openDatabaseFile(filename, key));
QVERIFY(db);
QFile originalFile(filename);
@@ -104,8 +98,6 @@ void TestDatabase::testEmptyRecycleBinWithHierarchicalData()
QTemporaryFile afterCleanup;
KeePass2Writer writer;
writer.writeDatabase(&afterCleanup, db);
writer.writeDatabase(&afterCleanup, db.data());
QVERIFY(afterCleanup.size() < initialSize);
delete db;
}

8
tests/TestKdbx2.cpp
View File

@@ -65,8 +65,8 @@ void TestKdbx2::verifyKdbx2Db(Database* db)
void TestKdbx2::testFormat200()
{
QString filename = QString(KEEPASSX_TEST_DATA_DIR).append("/Format200.kdbx");
CompositeKey key;
key.addKey(PasswordKey("a"));
auto key = QSharedPointer<CompositeKey>::create();
key->addKey(QSharedPointer<PasswordKey>::create("a"));
KeePass2Reader reader;
QScopedPointer<Database> db(reader.readDatabase(filename, key));
QCOMPARE(reader.version(), KeePass2::FILE_VERSION_2 & KeePass2::FILE_VERSION_CRITICAL_MASK);
@@ -78,8 +78,8 @@ void TestKdbx2::testFormat200()
void TestKdbx2::testFormat200Upgrade()
{
QString filename = QString(KEEPASSX_TEST_DATA_DIR).append("/Format200.kdbx");
CompositeKey key;
key.addKey(PasswordKey("a"));
auto key = QSharedPointer<CompositeKey>::create();
key->addKey(QSharedPointer<PasswordKey>::create("a"));
KeePass2Reader reader;
QScopedPointer<Database> db(reader.readDatabase(filename, key));
QVERIFY2(!reader.hasError(), reader.errorString().toStdString().c_str());

28
tests/TestKdbx3.cpp
View File

@@ -63,7 +63,7 @@ void TestKdbx3::writeXml(QBuffer* buf, Database* db, bool& hasError, QString& er
}
void TestKdbx3::readKdbx(QIODevice* device,
CompositeKey const& key,
QSharedPointer<const CompositeKey> key,
QScopedPointer<Database>& db,
bool& hasError,
QString& errorString)
@@ -78,7 +78,7 @@ void TestKdbx3::readKdbx(QIODevice* device,
}
void TestKdbx3::readKdbx(const QString& path,
CompositeKey const& key,
QSharedPointer<const CompositeKey> key,
QScopedPointer<Database>& db,
bool& hasError,
QString& errorString)
@@ -106,8 +106,8 @@ void TestKdbx3::writeKdbx(QIODevice* device, Database* db, bool& hasError, QStri
void TestKdbx3::testFormat300()
{
QString filename = QString(KEEPASSX_TEST_DATA_DIR).append("/Format300.kdbx");
CompositeKey key;
key.addKey(PasswordKey("a"));
auto key = QSharedPointer<CompositeKey>::create();
key->addKey(QSharedPointer<PasswordKey>::create("a"));
KeePass2Reader reader;
QScopedPointer<Database> db(reader.readDatabase(filename, key));
QCOMPARE(reader.version(), KeePass2::FILE_VERSION_3);
@@ -121,8 +121,8 @@ void TestKdbx3::testFormat300()
void TestKdbx3::testNonAscii()
{
QString filename = QString(KEEPASSX_TEST_DATA_DIR).append("/NonAscii.kdbx");
CompositeKey key;
key.addKey(PasswordKey(QString::fromUtf8("\xce\x94\xc3\xb6\xd8\xb6")));
auto key = QSharedPointer<CompositeKey>::create();
key->addKey(QSharedPointer<PasswordKey>::create(QString::fromUtf8("\xce\x94\xc3\xb6\xd8\xb6")));
KeePass2Reader reader;
QScopedPointer<Database> db(reader.readDatabase(filename, key));
QVERIFY(db.data());
@@ -134,8 +134,8 @@ void TestKdbx3::testNonAscii()
void TestKdbx3::testCompressed()
{
QString filename = QString(KEEPASSX_TEST_DATA_DIR).append("/Compressed.kdbx");
CompositeKey key;
key.addKey(PasswordKey(""));
auto key = QSharedPointer<CompositeKey>::create();
key->addKey(QSharedPointer<PasswordKey>::create(""));
KeePass2Reader reader;
QScopedPointer<Database> db(reader.readDatabase(filename, key));
QVERIFY(db.data());
@@ -147,8 +147,8 @@ void TestKdbx3::testCompressed()
void TestKdbx3::testProtectedStrings()
{
QString filename = QString(KEEPASSX_TEST_DATA_DIR).append("/ProtectedStrings.kdbx");
CompositeKey key;
key.addKey(PasswordKey("masterpw"));
auto key = QSharedPointer<CompositeKey>::create();
key->addKey(QSharedPointer<PasswordKey>::create("masterpw"));
KeePass2Reader reader;
QScopedPointer<Database> db(reader.readDatabase(filename, key));
QVERIFY(db.data());
@@ -174,8 +174,8 @@ void TestKdbx3::testBrokenHeaderHash()
// Make sure the database won't open.
QString filename = QString(KEEPASSX_TEST_DATA_DIR).append("/BrokenHeaderHash.kdbx");
CompositeKey key;
key.addKey(PasswordKey(""));
auto key = QSharedPointer<CompositeKey>::create();
key->addKey(QSharedPointer<PasswordKey>::create(""));
KeePass2Reader reader;
QScopedPointer<Database> db(reader.readDatabase(filename, key));
QVERIFY(!db.data());
@@ -188,8 +188,8 @@ void TestKdbx3::testKdbxRepair()
// master password = test
// entry username: testuser\x10\x20AC
// entry password: testpw
CompositeKey key;
key.addKey(PasswordKey("test"));
auto key = QSharedPointer<CompositeKey>::create();
key->addKey(QSharedPointer<PasswordKey>::create("test"));
// test that we can't open the broken database
bool hasError;

4
tests/TestKdbx3.h
View File

@@ -40,12 +40,12 @@ protected:
void writeXml(QBuffer* buf, Database* db, bool& hasError, QString& errorString) override;
void readKdbx(QIODevice* device,
CompositeKey const& key,
QSharedPointer<const CompositeKey> key,
QScopedPointer<Database>& db,
bool& hasError,
QString& errorString) override;
void readKdbx(const QString& path,
CompositeKey const& key,
QSharedPointer<const CompositeKey> key,
QScopedPointer<Database>& db,
bool& hasError,
QString& errorString) override;

30
tests/TestKdbx4.cpp
View File

@@ -66,7 +66,7 @@ void TestKdbx4::writeXml(QBuffer* buf, Database* db, bool& hasError, QString& er
}
void TestKdbx4::readKdbx(QIODevice* device,
CompositeKey const& key,
QSharedPointer<const CompositeKey> key,
QScopedPointer<Database>& db,
bool& hasError,
QString& errorString)
@@ -81,7 +81,7 @@ void TestKdbx4::readKdbx(QIODevice* device,
}
void TestKdbx4::readKdbx(const QString& path,
CompositeKey const& key,
QSharedPointer<const CompositeKey> key,
QScopedPointer<Database>& db,
bool& hasError,
QString& errorString)
@@ -113,8 +113,8 @@ Q_DECLARE_METATYPE(QUuid)
void TestKdbx4::testFormat400()
{
QString filename = QString(KEEPASSX_TEST_DATA_DIR).append("/Format400.kdbx");
CompositeKey key;
key.addKey(PasswordKey("t"));
auto key = QSharedPointer<CompositeKey>::create();
key->addKey(QSharedPointer<PasswordKey>::create("t"));
KeePass2Reader reader;
QScopedPointer<Database> db(reader.readDatabase(filename, key));
QCOMPARE(reader.version(), KeePass2::FILE_VERSION_4);
@@ -146,8 +146,8 @@ void TestKdbx4::testFormat400Upgrade()
sourceDb->metadata()->setName("Wubba lubba dub dub");
QCOMPARE(sourceDb->kdf()->uuid(), KeePass2::KDF_AES_KDBX3); // default is legacy AES-KDF
CompositeKey key;
key.addKey(PasswordKey("I am in great pain, please help me!"));
auto key = QSharedPointer<CompositeKey>::create();
key->addKey(QSharedPointer<PasswordKey>::create("I am in great pain, please help me!"));
sourceDb->setKey(key, true, true);
QBuffer buffer;
@@ -228,20 +228,20 @@ void TestKdbx4::testUpgradeMasterKeyIntegrity()
QFETCH(quint32, expectedVersion);
// prepare composite key
PasswordKey passwordKey("turXpGMQiUE6CkPvWacydAKsnp4cxz");
auto passwordKey = QSharedPointer<PasswordKey>::create("turXpGMQiUE6CkPvWacydAKsnp4cxz");
QByteArray fileKeyBytes("Ma6hHov98FbPeyAL22XhcgmpJk8xjQ");
QBuffer fileKeyBuffer(&fileKeyBytes);
fileKeyBuffer.open(QBuffer::ReadOnly);
FileKey fileKey;
fileKey.load(&fileKeyBuffer);
auto fileKey = QSharedPointer<FileKey>::create();
fileKey->load(&fileKeyBuffer);
auto crKey = QSharedPointer<MockChallengeResponseKey>::create(QByteArray("azdJnbVCFE76vV6t9RJ2DS6xvSS93k"));
CompositeKey compositeKey;
compositeKey.addKey(passwordKey);
compositeKey.addKey(fileKey);
compositeKey.addChallengeResponseKey(crKey);
auto compositeKey = QSharedPointer<CompositeKey>::create();
compositeKey->addKey(passwordKey);
compositeKey->addKey(fileKey);
compositeKey->addChallengeResponseKey(crKey);
QScopedPointer<Database> db(new Database());
db->changeKdf(fastKdf(db->kdf()));
@@ -293,7 +293,7 @@ void TestKdbx4::testUpgradeMasterKeyIntegrity()
buffer.seek(0);
KeePass2Reader reader;
QScopedPointer<Database> db2;
db2.reset(reader.readDatabase(&buffer, CompositeKey()));
db2.reset(reader.readDatabase(&buffer, QSharedPointer<CompositeKey>::create()));
QVERIFY(reader.hasError());
// check that we can read back the database with the original composite key,
@@ -396,7 +396,7 @@ void TestKdbx4::testCustomData()
// read buffer back
buffer.seek(0);
KeePass2Reader reader;
QSharedPointer<Database> newDb(reader.readDatabase(&buffer, CompositeKey()));
QSharedPointer<Database> newDb(reader.readDatabase(&buffer, QSharedPointer<CompositeKey>::create()));
// test all custom data are read back successfully from KDBX
QCOMPARE(newDb->publicCustomData(), publicCustomData);

4
tests/TestKdbx4.h
View File

@@ -40,12 +40,12 @@ protected:
void writeXml(QBuffer* buf, Database* db, bool& hasError, QString& errorString) override;
void readKdbx(const QString& path,
CompositeKey const& key,
QSharedPointer<const CompositeKey> key,
QScopedPointer<Database>& db,
bool& hasError,
QString& errorString) override;
void readKdbx(QIODevice* device,
CompositeKey const& key,
QSharedPointer<const CompositeKey> key,
QScopedPointer<Database>& db,
bool& hasError,
QString& errorString) override;

13
tests/TestKeePass1Reader.cpp
View File

@@ -273,19 +273,18 @@ void TestKeePass1Reader::reopenDatabase(Database* db, const QString& password, c
QVERIFY(!writer.hasError());
QVERIFY(buffer.seek(0));
CompositeKey key;
auto key = QSharedPointer<CompositeKey>::create();
if (!password.isNull()) {
key.addKey(PasswordKey(password));
key->addKey(QSharedPointer<PasswordKey>::create(password));
}
if (!keyfileName.isEmpty()) {
FileKey fileKey;
QVERIFY(fileKey.load(keyfileName));
key.addKey(fileKey);
auto fileKey = QSharedPointer<FileKey>::create();
QVERIFY(fileKey->load(keyfileName));
key->addKey(fileKey);
}
KeePass2Reader reader;
Database* newDb = reader.readDatabase(&buffer, key);
QScopedPointer<Database> newDb(reader.readDatabase(&buffer, key));
QVERIFY(newDb);
QVERIFY(!reader.hasError());
delete newDb;
}

16
tests/TestKeePass2Format.cpp
View File

@@ -40,8 +40,8 @@ void TestKeePass2Format::initTestCase()
QVERIFY(m_xmlDb.data());
// construct and write KDBX to buffer
CompositeKey key;
key.addKey(PasswordKey("test"));
auto key = QSharedPointer<CompositeKey>::create();
key->addKey(QSharedPointer<PasswordKey>::create("test"));
m_kdbxSourceDb.reset(new Database());
m_kdbxSourceDb->setKey(key);
@@ -495,8 +495,8 @@ void TestKeePass2Format::testXmlRepairUuidHistoryItem()
void TestKeePass2Format::testReadBackTargetDb()
{
// read back previously constructed KDBX
CompositeKey key;
key.addKey(PasswordKey("test"));
auto key = QSharedPointer<CompositeKey>::create();
key->addKey(QSharedPointer<PasswordKey>::create("test"));
bool hasError;
QString errorString;
@@ -542,8 +542,8 @@ void TestKeePass2Format::testKdbxNonAsciiPasswords()
void TestKeePass2Format::testKdbxDeviceFailure()
{
CompositeKey key;
key.addKey(PasswordKey("test"));
auto key = QSharedPointer<CompositeKey>::create();
key->addKey(QSharedPointer<PasswordKey>::create("test"));
QScopedPointer<Database> db(new Database());
db->setKey(key);
// Disable compression so we write a predictable number of bytes.
@@ -569,7 +569,7 @@ void TestKeePass2Format::testKdbxDeviceFailure()
void TestKeePass2Format::testDuplicateAttachments()
{
QScopedPointer<Database> db(new Database());
db->setKey(CompositeKey());
db->setKey(QSharedPointer<CompositeKey>::create());
const QByteArray attachment1("abc");
const QByteArray attachment2("def");
@@ -612,7 +612,7 @@ void TestKeePass2Format::testDuplicateAttachments()
}
buffer.seek(0);
readKdbx(&buffer, CompositeKey(), db, hasError, errorString);
readKdbx(&buffer, QSharedPointer<CompositeKey>::create(), db, hasError, errorString);
if (hasError) {
QFAIL(qPrintable(QString("Error while reading database: %1").arg(errorString)));
}

4
tests/TestKeePass2Format.h
View File

@@ -72,12 +72,12 @@ protected:
virtual void writeXml(QBuffer* buf, Database* db, bool& hasError, QString& errorString) = 0;
virtual void readKdbx(QIODevice* device,
CompositeKey const& key,
QSharedPointer<const CompositeKey> key,
QScopedPointer<Database>& db,
bool& hasError,
QString& errorString) = 0;
virtual void readKdbx(const QString& path,
CompositeKey const& key,
QSharedPointer<const CompositeKey> key,
QScopedPointer<Database>& db,
bool& hasError,
QString& errorString) = 0;

108
tests/TestKeys.cpp
View File

@@ -43,13 +43,13 @@ void TestKeys::initTestCase()
void TestKeys::testComposite()
{
QScopedPointer<CompositeKey> compositeKey1(new CompositeKey());
QScopedPointer<PasswordKey> passwordKey1(new PasswordKey());
QScopedPointer<PasswordKey> passwordKey2(new PasswordKey("test"));
auto compositeKey1 = QSharedPointer<CompositeKey>::create();
auto passwordKey1 = QSharedPointer<PasswordKey>::create();
auto passwordKey2 = QSharedPointer<PasswordKey>::create("test");
// make sure that addKey() creates a copy of the keys
compositeKey1->addKey(*passwordKey1);
compositeKey1->addKey(*passwordKey2);
compositeKey1->addKey(passwordKey1);
compositeKey1->addKey(passwordKey2);
AesKdf kdf;
kdf.setRounds(1);
@@ -57,29 +57,13 @@ void TestKeys::testComposite()
QVERIFY(compositeKey1->transform(kdf, transformed1));
QCOMPARE(transformed1.size(), 32);
// make sure the subkeys are copied
QScopedPointer<CompositeKey> compositeKey2(compositeKey1->clone());
QByteArray transformed2;
QVERIFY(compositeKey2->transform(kdf, transformed2));
QCOMPARE(transformed2.size(), 32);
QCOMPARE(transformed1, transformed2);
QScopedPointer<CompositeKey> compositeKey3(new CompositeKey());
QScopedPointer<CompositeKey> compositeKey4(new CompositeKey());
// test clear()
compositeKey3->addKey(PasswordKey("test"));
compositeKey3->addKey(QSharedPointer<PasswordKey>::create("test"));
compositeKey3->clear();
QCOMPARE(compositeKey3->rawKey(), compositeKey4->rawKey());
// test assignment operator
compositeKey3->addKey(PasswordKey("123"));
*compositeKey4 = *compositeKey3;
QCOMPARE(compositeKey3->rawKey(), compositeKey4->rawKey());
// test self-assignment
*compositeKey3 = *compositeKey3;
QCOMPARE(compositeKey3->rawKey(), compositeKey4->rawKey());
}
void TestKeys::testFileKey()
@@ -94,14 +78,14 @@ void TestKeys::testFileKey()
QString dbFilename = QString("%1/%2.kdbx").arg(QString(KEEPASSX_TEST_DATA_DIR), name);
QString keyFilename = QString("%1/%2.key").arg(QString(KEEPASSX_TEST_DATA_DIR), name);
CompositeKey compositeKey;
FileKey fileKey;
QVERIFY(fileKey.load(keyFilename));
QCOMPARE(fileKey.rawKey().size(), 32);
auto compositeKey = QSharedPointer<CompositeKey>::create();
auto fileKey = QSharedPointer<FileKey>::create();
QVERIFY(fileKey->load(keyFilename));
QCOMPARE(fileKey->rawKey().size(), 32);
QCOMPARE(fileKey.type(), type);
QCOMPARE(fileKey->type(), type);
compositeKey.addKey(fileKey);
compositeKey->addKey(fileKey);
QScopedPointer<Database> db(reader.readDatabase(dbFilename, compositeKey));
QVERIFY(db);
@@ -146,10 +130,10 @@ void TestKeys::testCreateAndOpenFileKey()
FileKey::create(&keyBuffer);
keyBuffer.reset();
FileKey fileKey;
QVERIFY(fileKey.load(&keyBuffer));
CompositeKey compositeKey;
compositeKey.addKey(fileKey);
auto fileKey = QSharedPointer<FileKey>::create();
QVERIFY(fileKey->load(&keyBuffer));
auto compositeKey = QSharedPointer<CompositeKey>::create();
compositeKey->addKey(fileKey);
QScopedPointer<Database> dbOrg(new Database());
QVERIFY(dbOrg->setKey(compositeKey));
@@ -218,10 +202,10 @@ void TestKeys::benchmarkTransformKey()
QSKIP("Benchmark skipped. Set env variable BENCHMARK=1 to enable.");
}
PasswordKey pwKey;
pwKey.setPassword("password");
CompositeKey compositeKey;
compositeKey.addKey(pwKey);
auto pwKey = QSharedPointer<PasswordKey>::create();
pwKey->setPassword("password");
auto compositeKey = QSharedPointer<CompositeKey>::create();
compositeKey->addKey(pwKey);
QByteArray seed(32, '\x4B');
@@ -232,25 +216,25 @@ void TestKeys::benchmarkTransformKey()
QBENCHMARK
{
Q_UNUSED(compositeKey.transform(kdf, result));
Q_UNUSED(compositeKey->transform(kdf, result));
};
}
void TestKeys::testCompositeKeyComponents()
{
PasswordKey passwordKeyEnc("password");
FileKey fileKeyEnc;
auto passwordKeyEnc = QSharedPointer<PasswordKey>::create("password");
auto fileKeyEnc = QSharedPointer<FileKey>::create();
QString error;
fileKeyEnc.load(QString("%1/%2").arg(QString(KEEPASSX_TEST_DATA_DIR), "FileKeyHashed.key"), &error);
fileKeyEnc->load(QString("%1/%2").arg(QString(KEEPASSX_TEST_DATA_DIR), "FileKeyHashed.key"), &error);
if (!error.isNull()) {
QFAIL(qPrintable(error));
}
auto challengeResponseKeyEnc = QSharedPointer<MockChallengeResponseKey>::create(QByteArray(16, 0x10));
CompositeKey compositeKeyEnc;
compositeKeyEnc.addKey(passwordKeyEnc);
compositeKeyEnc.addKey(fileKeyEnc);
compositeKeyEnc.addChallengeResponseKey(challengeResponseKeyEnc);
auto compositeKeyEnc = QSharedPointer<CompositeKey>::create();
compositeKeyEnc->addKey(passwordKeyEnc);
compositeKeyEnc->addKey(fileKeyEnc);
compositeKeyEnc->addChallengeResponseKey(challengeResponseKeyEnc);
QScopedPointer<Database> db1(new Database());
db1->setKey(compositeKeyEnc);
@@ -263,23 +247,23 @@ void TestKeys::testCompositeKeyComponents()
buffer.seek(0);
QScopedPointer<Database> db2;
KeePass2Reader reader;
CompositeKey compositeKeyDec1;
auto compositeKeyDec1 = QSharedPointer<CompositeKey>::create();
// try decryption and subsequently add key components until decryption is successful
db2.reset(reader.readDatabase(&buffer, compositeKeyDec1));
QVERIFY(reader.hasError());
compositeKeyDec1.addKey(passwordKeyEnc);
compositeKeyDec1->addKey(passwordKeyEnc);
buffer.seek(0);
db2.reset(reader.readDatabase(&buffer, compositeKeyDec1));
QVERIFY(reader.hasError());
compositeKeyDec1.addKey(fileKeyEnc);
compositeKeyDec1->addKey(fileKeyEnc);
buffer.seek(0);
db2.reset(reader.readDatabase(&buffer, compositeKeyDec1));
QVERIFY(reader.hasError());
compositeKeyDec1.addChallengeResponseKey(challengeResponseKeyEnc);
compositeKeyDec1->addChallengeResponseKey(challengeResponseKeyEnc);
buffer.seek(0);
db2.reset(reader.readDatabase(&buffer, compositeKeyDec1));
// now we should be able to open the database
@@ -288,31 +272,31 @@ void TestKeys::testCompositeKeyComponents()
}
// try the same again, but this time with one wrong key component each time
CompositeKey compositeKeyDec2;
compositeKeyDec2.addKey(PasswordKey("wrong password"));
compositeKeyDec2.addKey(fileKeyEnc);
compositeKeyDec2.addChallengeResponseKey(challengeResponseKeyEnc);
auto compositeKeyDec2 = QSharedPointer<CompositeKey>::create();
compositeKeyDec2->addKey(QSharedPointer<PasswordKey>::create("wrong password"));
compositeKeyDec2->addKey(fileKeyEnc);
compositeKeyDec2->addChallengeResponseKey(challengeResponseKeyEnc);
buffer.seek(0);
db2.reset(reader.readDatabase(&buffer, compositeKeyDec2));
QVERIFY(reader.hasError());
CompositeKey compositeKeyDec3;
compositeKeyDec3.addKey(passwordKeyEnc);
FileKey fileKeyWrong;
fileKeyWrong.load(QString("%1/%2").arg(QString(KEEPASSX_TEST_DATA_DIR), "FileKeyHashed2.key"), &error);
auto compositeKeyDec3 = QSharedPointer<CompositeKey>::create();
compositeKeyDec3->addKey(passwordKeyEnc);
auto fileKeyWrong = QSharedPointer<FileKey>::create();
fileKeyWrong->load(QString("%1/%2").arg(QString(KEEPASSX_TEST_DATA_DIR), "FileKeyHashed2.key"), &error);
if (!error.isNull()) {
QFAIL(qPrintable(error));
}
compositeKeyDec3.addKey(fileKeyWrong);
compositeKeyDec3.addChallengeResponseKey(challengeResponseKeyEnc);
compositeKeyDec3->addKey(fileKeyWrong);
compositeKeyDec3->addChallengeResponseKey(challengeResponseKeyEnc);
buffer.seek(0);
db2.reset(reader.readDatabase(&buffer, compositeKeyDec3));
QVERIFY(reader.hasError());
CompositeKey compositeKeyDec4;
compositeKeyDec4.addKey(passwordKeyEnc);
compositeKeyDec4.addKey(fileKeyEnc);
compositeKeyDec4.addChallengeResponseKey(QSharedPointer<MockChallengeResponseKey>::create(QByteArray(16, 0x20)));
auto compositeKeyDec4 = QSharedPointer<CompositeKey>::create();
compositeKeyDec4->addKey(passwordKeyEnc);
compositeKeyDec4->addKey(fileKeyEnc);
compositeKeyDec4->addChallengeResponseKey(QSharedPointer<MockChallengeResponseKey>::create(QByteArray(16, 0x20)));
buffer.seek(0);
db2.reset(reader.readDatabase(&buffer, compositeKeyDec4));
QVERIFY(reader.hasError());

2
tests/TestModified.cpp
View File

@@ -37,7 +37,7 @@ void TestModified::testSignals()
int spyCount = 0;
int spyCount2 = 0;
CompositeKey compositeKey;
auto compositeKey = QSharedPointer<CompositeKey>::create();
QScopedPointer<Database> db(new Database());
auto* root = db->rootGroup();

180
tests/gui/TestGui.cpp
View File

@@ -48,6 +48,13 @@
#include "crypto/Crypto.h"
#include "crypto/kdf/AesKdf.h"
#include "format/KeePass2Reader.h"
#include "keys/PasswordKey.h"
#include "keys/FileKey.h"
#include "gui/ApplicationSettingsWidget.h"
#include "gui/dbsettings/DatabaseSettingsDialog.h"
#include "gui/masterkey/PasswordEditWidget.h"
#include "gui/masterkey/KeyFileEditWidget.h"
#include "gui/CategoryListWidget.h"
#include "gui/CloneDialog.h"
#include "gui/DatabaseTabWidget.h"
#include "gui/DatabaseWidget.h"
@@ -63,6 +70,8 @@
#include "gui/group/EditGroupWidget.h"
#include "gui/group/GroupModel.h"
#include "gui/group/GroupView.h"
#include "gui/wizard/NewDatabaseWizard.h"
#include "gui/masterkey/KeyComponentWidget.h"
#include "keys/PasswordKey.h"
void TestGui::initTestCase()
@@ -70,9 +79,11 @@ void TestGui::initTestCase()
QVERIFY(Crypto::init());
Config::createTempFileInstance();
// Disable autosave so we can test the modified file indicator
Config::instance()->set("AutoSaveAfterEveryChange", false);
config()->set("AutoSaveAfterEveryChange", false);
// Enable the tray icon so we can test hiding/restoring the window
Config::instance()->set("GUI/ShowTrayIcon", true);
config()->set("GUI/ShowTrayIcon", true);
// Disable advanced settings mode (activate within individual tests to test advanced settings)
config()->set("GUI/AdvancedSettings", false);
m_mainWindow = new MainWindow();
m_tabWidget = m_mainWindow->findChild<DatabaseTabWidget*>("tabWidget");
@@ -135,43 +146,114 @@ void TestGui::cleanup()
m_dbWidget = nullptr;
}
void TestGui::testSettingsDefaultTabOrder()
{
// check application settings default tab order
triggerAction("actionSettings");
auto* settingsWidget = m_mainWindow->findChild<ApplicationSettingsWidget*>();
QVERIFY(settingsWidget->isVisible());
QCOMPARE(settingsWidget->findChild<CategoryListWidget*>("categoryList")->currentCategory(), 0);
for (auto* w: settingsWidget->findChildren<QTabWidget*>()) {
if (w->currentIndex() != 0) {
QFAIL("Application settings contain QTabWidgets whose default index is not 0");
}
}
QTest::keyClick(settingsWidget, Qt::Key::Key_Escape);
// check database settings default tab order
triggerAction("actionChangeDatabaseSettings");
auto* dbSettingsWidget = m_mainWindow->findChild<DatabaseSettingsDialog*>();
QVERIFY(dbSettingsWidget->isVisible());
QCOMPARE(dbSettingsWidget->findChild<CategoryListWidget*>("categoryList")->currentCategory(), 0);
for (auto* w: dbSettingsWidget->findChildren<QTabWidget*>()) {
if (w->currentIndex() != 0) {
QFAIL("Database settings contain QTabWidgets whose default index is not 0");
}
}
QTest::keyClick(dbSettingsWidget, Qt::Key::Key_Escape);
}
void TestGui::testCreateDatabase()
{
QTemporaryFile tmpFile;
QVERIFY(tmpFile.open());
QString tmpFileName = tmpFile.fileName();
tmpFile.remove();
fileDialog()->setNextFileName(tmpFileName);
QTimer::singleShot(0, this, SLOT(createDatabaseCallback()));
triggerAction("actionDatabaseNew");
DatabaseWidget* dbWidget = m_tabWidget->currentDatabaseWidget();
QWidget* databaseNewWidget = dbWidget->findChild<QWidget*>("changeMasterKeyWidget");
PasswordEdit* editPassword = databaseNewWidget->findChild<PasswordEdit*>("enterPasswordEdit");
QVERIFY(editPassword->isVisible());
QLineEdit* editPasswordRepeat = databaseNewWidget->findChild<QLineEdit*>("repeatPasswordEdit");
QVERIFY(editPasswordRepeat->isVisible());
m_tabWidget->currentDatabaseWidget()->setCurrentWidget(databaseNewWidget);
QTest::keyClicks(editPassword, "test");
QTest::keyClicks(editPasswordRepeat, "test");
QTest::keyClick(editPasswordRepeat, Qt::Key_Enter);
// Auto-save after every change is enabled by default, ensure the db saves right away
QTRY_VERIFY(m_tabWidget->tabText(m_tabWidget->currentIndex()).contains("*"));
m_db = m_tabWidget->currentDatabaseWidget()->database();
// there is a new empty db
m_db = m_tabWidget->currentDatabaseWidget()->database();
QCOMPARE(m_db->rootGroup()->children().size(), 0);
// check meta data
QCOMPARE(m_db->metadata()->name(), QString("Test Name"));
QCOMPARE(m_db->metadata()->description(), QString("Test Description"));
// check key and encryption
QCOMPARE(m_db->key()->keys().size(), 2);
QCOMPARE(m_db->kdf()->uuid(), KeePass2::KDF_ARGON2);
QCOMPARE(m_db->cipher(), KeePass2::CIPHER_AES);
auto compositeKey = QSharedPointer<CompositeKey>::create();
compositeKey->addKey(QSharedPointer<PasswordKey>::create("test"));
auto fileKey = QSharedPointer<FileKey>::create();
fileKey->load(QString("%1/%2").arg(QString(KEEPASSX_TEST_DATA_DIR), "FileKeyHashed.key"));
compositeKey->addKey(fileKey);
QCOMPARE(m_db->key()->rawKey(), compositeKey->rawKey());
// close the new database
MessageBox::setNextAnswer(QMessageBox::No);
triggerAction("actionDatabaseClose");
Tools::wait(100);
}
void TestGui::createDatabaseCallback()
{
auto* wizard = m_tabWidget->findChild<NewDatabaseWizard*>();
QVERIFY(wizard);
QTest::keyClicks(wizard->currentPage()->findChild<QLineEdit*>("databaseName"), "Test Name");
QTest::keyClicks(wizard->currentPage()->findChild<QLineEdit*>("databaseDescription"), "Test Description");
QCOMPARE(wizard->currentId(), 0);
QTest::keyClick(wizard, Qt::Key_Enter);
QCOMPARE(wizard->currentId(), 1);
QTest::keyClick(wizard, Qt::Key_Enter);
QCOMPARE(wizard->currentId(), 2);
// enter password
auto* passwordWidget = wizard->currentPage()->findChild<PasswordEditWidget*>();
QCOMPARE(passwordWidget->visiblePage(), KeyFileEditWidget::Page::Edit);
auto* passwordEdit = passwordWidget->findChild<QLineEdit*>("enterPasswordEdit");
auto* passwordRepeatEdit = passwordWidget->findChild<QLineEdit*>("repeatPasswordEdit");
QTRY_VERIFY(passwordEdit->isVisible());
QVERIFY(passwordEdit->hasFocus());
QTest::keyClicks(passwordEdit, "test");
QTest::keyClick(passwordEdit, Qt::Key::Key_Tab);
QTest::keyClicks(passwordRepeatEdit, "test");
// add key file
auto* additionalOptionsButton = wizard->currentPage()->findChild<QPushButton*>("additionalKeyOptionsToggle");
auto* keyFileWidget = wizard->currentPage()->findChild<KeyFileEditWidget*>();
QVERIFY(additionalOptionsButton->isVisible());
QTest::mouseClick(additionalOptionsButton, Qt::MouseButton::LeftButton);
QTRY_VERIFY(keyFileWidget->isVisible());
QTRY_VERIFY(!additionalOptionsButton->isVisible());
QCOMPARE(passwordWidget->visiblePage(), KeyFileEditWidget::Page::Edit);
QTest::mouseClick(keyFileWidget->findChild<QPushButton*>("addButton"), Qt::MouseButton::LeftButton);
auto* fileCombo = keyFileWidget->findChild<QComboBox*>("keyFileCombo");
QTRY_VERIFY(fileCombo);
QTRY_VERIFY(fileCombo->isVisible());
fileDialog()->setNextFileName(QString("%1/%2").arg(QString(KEEPASSX_TEST_DATA_DIR), "FileKeyHashed.key"));
QTest::keyClick(keyFileWidget->findChild<QPushButton*>("addButton"), Qt::Key::Key_Enter);
QVERIFY(fileCombo->hasFocus());
auto* browseButton = keyFileWidget->findChild<QPushButton*>("browseKeyFileButton");
QTest::keyClick(browseButton, Qt::Key::Key_Enter);
QCOMPARE(fileCombo->currentText(), QString("%1/%2").arg(QString(KEEPASSX_TEST_DATA_DIR), "FileKeyHashed.key"));
// save database to temporary file
TemporaryFile tmpFile;
QVERIFY(tmpFile.open());
tmpFile.close();
fileDialog()->setNextFileName(tmpFile.filePath());
QTest::keyClick(fileCombo, Qt::Key::Key_Enter);
}
void TestGui::testMergeDatabase()
@@ -390,7 +472,7 @@ void TestGui::testSearchEditEntry()
// Find buttons for group creation
EditGroupWidget* editGroupWidget = m_dbWidget->findChild<EditGroupWidget*>("editGroupWidget");
QLineEdit* nameEdit = editGroupWidget->findChild<QLineEdit*>("nameEdit");
QLineEdit* nameEdit = editGroupWidget->findChild<QLineEdit*>("editName");
QDialogButtonBox* editGroupWidgetButtonBox = editGroupWidget->findChild<QDialogButtonBox*>("buttonBox");
// Add groups "Good" and "Bad"
@@ -965,7 +1047,7 @@ void TestGui::testSaveAs()
QFileInfo fileInfo(m_dbFilePath);
QDateTime lastModified = fileInfo.lastModified();
m_db->metadata()->setName("SaveAs");
m_db->metadata()->setName("testSaveAs");
// open temporary file so it creates a filename
QTemporaryFile tmpFile;
@@ -977,7 +1059,7 @@ void TestGui::testSaveAs()
triggerAction("actionDatabaseSaveAs");
QCOMPARE(m_tabWidget->tabText(m_tabWidget->currentIndex()), QString("SaveAs"));
QCOMPARE(m_tabWidget->tabText(m_tabWidget->currentIndex()), QString("testSaveAs"));
checkDatabase(tmpFileName);
@@ -987,31 +1069,40 @@ void TestGui::testSaveAs()
void TestGui::testSave()
{
m_db->metadata()->setName("Save");
m_db->metadata()->setName("testSave");
// wait for modified timer
QTRY_COMPARE(m_tabWidget->tabText(m_tabWidget->currentIndex()), QString("Save*"));
QTRY_COMPARE(m_tabWidget->tabText(m_tabWidget->currentIndex()), QString("testSave*"));
triggerAction("actionDatabaseSave");
QCOMPARE(m_tabWidget->tabText(m_tabWidget->currentIndex()), QString("Save"));
QCOMPARE(m_tabWidget->tabText(m_tabWidget->currentIndex()), QString("testSave"));
checkDatabase();
}
void TestGui::testDatabaseSettings()
{
m_db->metadata()->setName("Save");
m_db->metadata()->setName("testDatabaseSettings");
triggerAction("actionChangeDatabaseSettings");
QWidget* dbSettingsWidget = m_dbWidget->findChild<QWidget*>("databaseSettingsWidget");
QSpinBox* transformRoundsSpinBox = dbSettingsWidget->findChild<QSpinBox*>("transformRoundsSpinBox");
auto* dbSettingsDialog = m_dbWidget->findChild<QWidget*>("databaseSettingsDialog");
auto* transformRoundsSpinBox = dbSettingsDialog->findChild<QSpinBox*>("transformRoundsSpinBox");
auto advancedToggle = dbSettingsDialog->findChild<QCheckBox*>("advancedSettingsToggle");
advancedToggle->setChecked(true);
QApplication::processEvents();
QVERIFY(transformRoundsSpinBox != nullptr);
transformRoundsSpinBox->setValue(123456);
QTest::keyClick(transformRoundsSpinBox, Qt::Key_Enter);
// wait for modified timer
QTRY_COMPARE(m_tabWidget->tabText(m_tabWidget->currentIndex()), QString("Save*"));
QTRY_COMPARE(m_tabWidget->tabText(m_tabWidget->currentIndex()), QString("testDatabaseSettings*"));
QCOMPARE(m_db->kdf()->rounds(), 123456);
triggerAction("actionDatabaseSave");
QCOMPARE(m_tabWidget->tabText(m_tabWidget->currentIndex()), QString("Save"));
QCOMPARE(m_tabWidget->tabText(m_tabWidget->currentIndex()), QString("testDatabaseSettings"));
advancedToggle->setChecked(false);
QApplication::processEvents();
checkDatabase();
}
@@ -1021,8 +1112,8 @@ void TestGui::testKeePass1Import()
fileDialog()->setNextFileName(QString(KEEPASSX_TEST_DATA_DIR).append("/basic.kdb"));
triggerAction("actionImportKeePass1");
QWidget* keepass1OpenWidget = m_mainWindow->findChild<QWidget*>("keepass1OpenWidget");
QLineEdit* editPassword = keepass1OpenWidget->findChild<QLineEdit*>("editPassword");
auto* keepass1OpenWidget = m_mainWindow->findChild<QWidget*>("keepass1OpenWidget");
auto* editPassword = keepass1OpenWidget->findChild<QLineEdit*>("editPassword");
QVERIFY(editPassword);
QTest::keyClicks(editPassword, "masterpw");
@@ -1174,8 +1265,8 @@ void TestGui::checkDatabase(QString dbFileName)
if (dbFileName.isEmpty())
dbFileName = m_dbFilePath;
CompositeKey key;
key.addKey(PasswordKey("a"));
auto key = QSharedPointer<CompositeKey>::create();
key->addKey(QSharedPointer<PasswordKey>::create("a"));
KeePass2Reader reader;
QScopedPointer<Database> dbSaved(reader.readDatabase(dbFileName, key));
QVERIFY(dbSaved);
@@ -1189,6 +1280,7 @@ void TestGui::triggerAction(const QString& name)
QVERIFY(action);
QVERIFY(action->isEnabled());
action->trigger();
QApplication::processEvents();
}
void TestGui::dragAndDropGroup(const QModelIndex& sourceIndex,

4
tests/gui/TestGui.h
View File

@@ -35,12 +35,16 @@ class TestGui : public QObject
{
Q_OBJECT
protected slots:
void createDatabaseCallback();
private slots:
void initTestCase();
void init();
void cleanup();
void cleanupTestCase();
void testSettingsDefaultTabOrder();
void testCreateDatabase();
void testMergeDatabase();
void testAutoreloadDatabase();

3
tests/mock/MockChallengeResponseKey.cpp
View File

@@ -18,7 +18,8 @@
#include "MockChallengeResponseKey.h"
MockChallengeResponseKey::MockChallengeResponseKey(const QByteArray& secret)
: m_secret(secret)
: ChallengeResponseKey(QUuid("aac5b480-cdc0-411e-9cb8-962062dcc1fd"))
, m_secret(secret)
{
}

1
tests/mock/MockChallengeResponseKey.h
View File

@@ -28,6 +28,7 @@ class MockChallengeResponseKey : public ChallengeResponseKey
{
public:
explicit MockChallengeResponseKey(const QByteArray& secret);
Q_DISABLE_COPY(MockChallengeResponseKey);
~MockChallengeResponseKey() override;
QByteArray rawKey() const override;
bool challenge(const QByteArray& challenge) override;