Git-Mirrors/keepassxc
1
0
Fork 0
mirror of https://github.com/keepassxreboot/keepassxc.git synced 2024-10-01 01:26:01 -04:00
Code Issues Packages Projects Releases Wiki Activity
854459068f
keepassxc/tests/TestKdbx4.cpp

618 lines
26 KiB
C++
Raw Normal View History

Fix KDBX reader tests not being executed
2018-01-17 12:15:37 -05:00
/*
* Copyright (C) 2018 KeePassXC Team <team@keepassxc.org>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 or (at your option)
* version 3 of the License.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "TestKdbx4.h"
Move useful QTest template specializations to global header file Fix KDBX test linker errors on Windows
2018-01-24 07:22:20 -05:00
Formatting the code.
2018-03-31 16:01:30 -04:00
#include "config-keepassx-tests.h"
Fix KDBX reader tests not being executed
2018-01-17 12:15:37 -05:00
#include "core/Metadata.h"
Formatting the code.
2018-03-31 16:01:30 -04:00
#include "format/KdbxXmlReader.h"
#include "format/KdbxXmlWriter.h"
Fix KDBX reader tests not being executed
2018-01-17 12:15:37 -05:00
#include "format/KeePass2.h"
Refactor and extend file format tests
2018-01-17 14:52:29 -05:00
#include "format/KeePass2Reader.h"
#include "format/KeePass2Writer.h"
Prevent byte-by-byte and attachment inference side channel attacks Attack - KeeShare attachments can be inferred because of attachment de-duplication. Solution - Prevent de-duplication of normal database entry attachments with those entry attachments synchronized/associated with a KeeShare database. This is done using the KeeShare database UUID injected into the hash calculation of the attachment prior to de-dupe. The attachments themselves are not modified in any way. -------- Attack - Side channel byte-by-byte inference due to compression de-duplication of data between a KeeShare database and it's parent. Solution - Generate a random array between 64 and 512 bytes, convert to hex, and store in the database custom data. -------- Attack vector assumptions: 1. Compression is enabled 2. The attacker has access to a KeeShare database actively syncing with the victim's database 3. The victim's database is unlocked and syncing 4. The attacker can see the exact size of the victim's database after saving, and syncing, the KeeShare database Thank you to Andrés Fábrega from Cornell University for theorizing and informing us of this attack vector.
2024-02-06 07:00:45 -05:00
#ifdef WITH_XC_KEESHARE
#include "keeshare/KeeShare.h"
#include "keeshare/KeeShareSettings.h"
#endif
Formatting the code.
2018-03-31 16:01:30 -04:00
#include "keys/FileKey.h"
#include "keys/PasswordKey.h"
#include "mock/MockChallengeResponseKey.h"
TestKdbx4Format: use MockClock Otherwise, assertions in TestKdbx4::testCustomData() may fail on rare occasions, because the customData in a cloned entry won't be identical to its original, because of its potentially-updated LastModified property. Originally noticed in https://github.com/keepassxreboot/keepassxc/pull/7783#issuecomment-1101404487.
2022-04-18 13:40:10 -04:00
#include "mock/MockClock.h"
Optimize includes across code base
2021-07-11 22:10:29 -04:00
#include <QTest>
Fix KDBX reader tests not being executed
2018-01-17 12:15:37 -05:00
Ensure challenge-response key buffer is properly cleared. The challenge-response key buffer is explicitly cleared before the key transformation if no such key is configured to ensure one is never injected into the hash even if the database had a challenge-response key previously. This patch also adds extensive tests for verifying that a key change will not add any expired key material to the hash. Fixes #4146
2020-01-09 20:11:43 -05:00
int main(int argc, char* argv[])
{
QCoreApplication app(argc, argv);
QCoreApplication::setAttribute(Qt::AA_Use96Dpi, true);
QTEST_SET_MAIN_SOURCE_PATH
TestKdbx4Argon2 argon2Test;
TestKdbx4AesKdf aesKdfTest;
Avoid redundant KDBX4 test runs
2021-11-13 12:46:05 -05:00
TestKdbx4Format kdbx4Test;
return QTest::qExec(&argon2Test, argc, argv) || QTest::qExec(&aesKdfTest, argc, argv)
|| QTest::qExec(&kdbx4Test, argc, argv);
Ensure challenge-response key buffer is properly cleared. The challenge-response key buffer is explicitly cleared before the key transformation if no such key is configured to ensure one is never injected into the hash even if the database had a challenge-response key previously. This patch also adds extensive tests for verifying that a key change will not add any expired key material to the hash. Fixes #4146
2020-01-09 20:11:43 -05:00
}
Fix KDBX reader tests not being executed
2018-01-17 12:15:37 -05:00
Ensure challenge-response key buffer is properly cleared. The challenge-response key buffer is explicitly cleared before the key transformation if no such key is configured to ensure one is never injected into the hash even if the database had a challenge-response key previously. This patch also adds extensive tests for verifying that a key change will not add any expired key material to the hash. Fixes #4146
2020-01-09 20:11:43 -05:00
void TestKdbx4Argon2::initTestCaseImpl()
Fix KDBX reader tests not being executed
2018-01-17 12:15:37 -05:00
{
Add Argon2id KDF
2020-11-20 15:49:56 -05:00
m_xmlDb->changeKdf(fastKdf(KeePass2::uuidToKdf(KeePass2::KDF_ARGON2D)));
m_kdbxSourceDb->changeKdf(fastKdf(KeePass2::uuidToKdf(KeePass2::KDF_ARGON2D)));
Fix KDBX reader tests not being executed
2018-01-17 12:15:37 -05:00
}
Ensure challenge-response key buffer is properly cleared. The challenge-response key buffer is explicitly cleared before the key transformation if no such key is configured to ensure one is never injected into the hash even if the database had a challenge-response key previously. This patch also adds extensive tests for verifying that a key change will not add any expired key material to the hash. Fixes #4146
2020-01-09 20:11:43 -05:00
QSharedPointer<Database>
TestKdbx4Argon2::readXml(const QString& path, bool strictMode, bool& hasError, QString& errorString)
Fix KDBX reader tests not being executed
2018-01-17 12:15:37 -05:00
{
Refactor and extend file format tests
2018-01-17 14:52:29 -05:00
KdbxXmlReader reader(KeePass2::FILE_VERSION_4);
Fix KDBX reader tests not being executed
2018-01-17 12:15:37 -05:00
reader.setStrictMode(strictMode);
auto db = reader.readDatabase(path);
hasError = reader.hasError();
errorString = reader.errorString();
return db;
}
Ensure challenge-response key buffer is properly cleared. The challenge-response key buffer is explicitly cleared before the key transformation if no such key is configured to ensure one is never injected into the hash even if the database had a challenge-response key previously. This patch also adds extensive tests for verifying that a key change will not add any expired key material to the hash. Fixes #4146
2020-01-09 20:11:43 -05:00
QSharedPointer<Database> TestKdbx4Argon2::readXml(QBuffer* buf, bool strictMode, bool& hasError, QString& errorString)
Fix KDBX reader tests not being executed
2018-01-17 12:15:37 -05:00
{
Refactor and extend file format tests
2018-01-17 14:52:29 -05:00
KdbxXmlReader reader(KeePass2::FILE_VERSION_4);
Fix KDBX reader tests not being executed
2018-01-17 12:15:37 -05:00
reader.setStrictMode(strictMode);
auto db = reader.readDatabase(buf);
hasError = reader.hasError();
errorString = reader.errorString();
return db;
}
Ensure challenge-response key buffer is properly cleared. The challenge-response key buffer is explicitly cleared before the key transformation if no such key is configured to ensure one is never injected into the hash even if the database had a challenge-response key previously. This patch also adds extensive tests for verifying that a key change will not add any expired key material to the hash. Fixes #4146
2020-01-09 20:11:43 -05:00
void TestKdbx4Argon2::writeXml(QBuffer* buf, Database* db, bool& hasError, QString& errorString)
Fix KDBX reader tests not being executed
2018-01-17 12:15:37 -05:00
{
Prevent byte-by-byte and attachment inference side channel attacks Attack - KeeShare attachments can be inferred because of attachment de-duplication. Solution - Prevent de-duplication of normal database entry attachments with those entry attachments synchronized/associated with a KeeShare database. This is done using the KeeShare database UUID injected into the hash calculation of the attachment prior to de-dupe. The attachments themselves are not modified in any way. -------- Attack - Side channel byte-by-byte inference due to compression de-duplication of data between a KeeShare database and it's parent. Solution - Generate a random array between 64 and 512 bytes, convert to hex, and store in the database custom data. -------- Attack vector assumptions: 1. Compression is enabled 2. The attacker has access to a KeeShare database actively syncing with the victim's database 3. The victim's database is unlocked and syncing 4. The attacker can see the exact size of the victim's database after saving, and syncing, the KeeShare database Thank you to Andrés Fábrega from Cornell University for theorizing and informing us of this attack vector.
2024-02-06 07:00:45 -05:00
KdbxXmlWriter writer(KeePass2::FILE_VERSION_4, {});
Fix KDBX reader tests not being executed
2018-01-17 12:15:37 -05:00
writer.writeDatabase(buf, db);
hasError = writer.hasError();
errorString = writer.errorString();
}
Refactor and extend file format tests
2018-01-17 14:52:29 -05:00
Ensure challenge-response key buffer is properly cleared. The challenge-response key buffer is explicitly cleared before the key transformation if no such key is configured to ensure one is never injected into the hash even if the database had a challenge-response key previously. This patch also adds extensive tests for verifying that a key change will not add any expired key material to the hash. Fixes #4146
2020-01-09 20:11:43 -05:00
void TestKdbx4Argon2::readKdbx(QIODevice* device,
QSharedPointer<const CompositeKey> key,
QSharedPointer<Database> db,
bool& hasError,
QString& errorString)
Refactor and extend file format tests
2018-01-17 14:52:29 -05:00
{
KeePass2Reader reader;
Refactor Database and Database widgets (#2491) The Database, DatabaseWidget, and DatabaseTabWidget classes share many responsibilities in inconsistent ways resulting in impenetrable and unmaintainable code and a diverse set of bugs and architecture restrictions. This patch reworks the architecture, responsibilities of, and dependencies between these classes. The core changes are: * Move loading and saving logic from widgets into the Database class * Get rid of the DatabaseManagerStruct and move all the information contained in it into the Database * Let database objects keep track of modifications and dirty/clean state instead of handing this to external widgets * Move GUI interactions for loading and saving from the DatabaseTabWidget into the DatabaseWidget (resolves #2494 as a side-effect) * Heavily clean up DatabaseTabWidget and degrade it to a slightly glorified QTabWidget * Use QSharedPointers for all Database objects * Remove the modifiedImmediate signal and replace it with a markAsModified() method * Implement proper tabName() method instead of reading back titles from GUI widgets (resolves #1389 and its duplicates #2146 #855) * Fix unwanted AES-KDF downgrade if database uses Argon2 and has CustomData * Improve code This patch is also the first major step towards solving issues #476 and #2322.
2018-11-22 05:47:31 -05:00
reader.readDatabase(device, key, db.data());
Refactor and extend file format tests
2018-01-17 14:52:29 -05:00
hasError = reader.hasError();
if (hasError) {
errorString = reader.errorString();
}
QCOMPARE(reader.version(), KeePass2::FILE_VERSION_4);
}
Ensure challenge-response key buffer is properly cleared. The challenge-response key buffer is explicitly cleared before the key transformation if no such key is configured to ensure one is never injected into the hash even if the database had a challenge-response key previously. This patch also adds extensive tests for verifying that a key change will not add any expired key material to the hash. Fixes #4146
2020-01-09 20:11:43 -05:00
void TestKdbx4Argon2::writeKdbx(QIODevice* device, Database* db, bool& hasError, QString& errorString)
Refactor and extend file format tests
2018-01-17 14:52:29 -05:00
{
if (db->kdf()->uuid() == KeePass2::KDF_AES_KDBX3) {
Add Argon2id KDF
2020-11-20 15:49:56 -05:00
db->changeKdf(fastKdf(KeePass2::uuidToKdf(KeePass2::KDF_ARGON2D)));
Refactor and extend file format tests
2018-01-17 14:52:29 -05:00
}
KeePass2Writer writer;
hasError = writer.writeDatabase(device, db);
hasError = writer.hasError();
if (hasError) {
errorString = writer.errorString();
}
QCOMPARE(writer.version(), KeePass2::FILE_VERSION_4);
}
Avoid redundant KDBX4 test runs
2021-11-13 12:46:05 -05:00
void TestKdbx4AesKdf::initTestCaseImpl()
{
m_xmlDb->changeKdf(fastKdf(KeePass2::uuidToKdf(KeePass2::KDF_AES_KDBX4)));
m_kdbxSourceDb->changeKdf(fastKdf(KeePass2::uuidToKdf(KeePass2::KDF_AES_KDBX4)));
}
Replaced Uuid with QUuid
2018-03-22 17:56:05 -04:00
Q_DECLARE_METATYPE(QUuid)
TestKdbx4Format: use MockClock Otherwise, assertions in TestKdbx4::testCustomData() may fail on rare occasions, because the customData in a cloned entry won't be identical to its original, because of its potentially-updated LastModified property. Originally noticed in https://github.com/keepassxreboot/keepassxc/pull/7783#issuecomment-1101404487.
2022-04-18 13:40:10 -04:00
void TestKdbx4Format::init()
{
MockClock::setup(new MockClock());
}
void TestKdbx4Format::cleanup()
{
MockClock::teardown();
}
Avoid redundant KDBX4 test runs
2021-11-13 12:46:05 -05:00
void TestKdbx4Format::testFormat400()
Refactor and extend file format tests
2018-01-17 14:52:29 -05:00
{
QString filename = QString(KEEPASSX_TEST_DATA_DIR).append("/Format400.kdbx");
Add a new database settings wizard 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.
2018-05-13 17:21:43 -04:00
auto key = QSharedPointer<CompositeKey>::create();
key->addKey(QSharedPointer<PasswordKey>::create("t"));
Refactor and extend file format tests
2018-01-17 14:52:29 -05:00
KeePass2Reader reader;
Refactor Database and Database widgets (#2491) The Database, DatabaseWidget, and DatabaseTabWidget classes share many responsibilities in inconsistent ways resulting in impenetrable and unmaintainable code and a diverse set of bugs and architecture restrictions. This patch reworks the architecture, responsibilities of, and dependencies between these classes. The core changes are: * Move loading and saving logic from widgets into the Database class * Get rid of the DatabaseManagerStruct and move all the information contained in it into the Database * Let database objects keep track of modifications and dirty/clean state instead of handing this to external widgets * Move GUI interactions for loading and saving from the DatabaseTabWidget into the DatabaseWidget (resolves #2494 as a side-effect) * Heavily clean up DatabaseTabWidget and degrade it to a slightly glorified QTabWidget * Use QSharedPointers for all Database objects * Remove the modifiedImmediate signal and replace it with a markAsModified() method * Implement proper tabName() method instead of reading back titles from GUI widgets (resolves #1389 and its duplicates #2146 #855) * Fix unwanted AES-KDF downgrade if database uses Argon2 and has CustomData * Improve code This patch is also the first major step towards solving issues #476 and #2322.
2018-11-22 05:47:31 -05:00
auto db = QSharedPointer<Database>::create();
reader.readDatabase(filename, key, db.data());
Refactor and extend file format tests
2018-01-17 14:52:29 -05:00
QCOMPARE(reader.version(), KeePass2::FILE_VERSION_4);
QVERIFY(db.data());
QVERIFY(!reader.hasError());
QCOMPARE(db->rootGroup()->name(), QString("Format400"));
QCOMPARE(db->metadata()->name(), QString("Format400"));
QCOMPARE(db->rootGroup()->entries().size(), 1);
auto entry = db->rootGroup()->entries().at(0);
QCOMPARE(entry->title(), QString("Format400"));
QCOMPARE(entry->username(), QString("Format400"));
QCOMPARE(entry->attributes()->keys().size(), 6);
QCOMPARE(entry->attributes()->value("Format400"), QString("Format400"));
QCOMPARE(entry->attachments()->keys().size(), 1);
QCOMPARE(entry->attachments()->value("Format400"), QByteArray("Format400\n"));
}
Avoid redundant KDBX4 test runs
2021-11-13 12:46:05 -05:00
void TestKdbx4Format::testFormat400Upgrade()
Refactor and extend file format tests
2018-01-17 14:52:29 -05:00
{
Replaced Uuid with QUuid
2018-03-22 17:56:05 -04:00
QFETCH(QUuid, kdfUuid);
QFETCH(QUuid, cipherUuid);
Properly save custom header data Ensure adding custom data upgrades to KDBX4 Implement review feedback
2018-02-18 15:01:22 -05:00
QFETCH(bool, addCustomData);
Refactor and extend file format tests
2018-01-17 14:52:29 -05:00
QFETCH(quint32, expectedVersion);
QScopedPointer<Database> sourceDb(new Database());
Test speedup (#1678) * Tests: Speed up AutoType testing Decrease default autotype delay to 1 to improve test suite speed by seconds. This shaves multiple seconds off the whole test suite. In some cases, the largest part. Also, initialize config just creating the test instance, just in case that it ever depends on the configuration values at that point already. * Tests: Speed up Kdbx4 testing This speeds up the Kdbx4 tests by using parameters optimized for speed for the key derivation functions. On an i7-6700K the tests run close to 50% faster with this change (about 1.5s vs. 3s).
2018-03-08 04:20:25 -05:00
sourceDb->changeKdf(fastKdf(sourceDb->kdf()));
Refactor and extend file format tests
2018-01-17 14:52:29 -05:00
sourceDb->metadata()->setName("Wubba lubba dub dub");
Formatting the code.
2018-03-31 16:01:30 -04:00
QCOMPARE(sourceDb->kdf()->uuid(), KeePass2::KDF_AES_KDBX3); // default is legacy AES-KDF
Refactor and extend file format tests
2018-01-17 14:52:29 -05:00
Add a new database settings wizard 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.
2018-05-13 17:21:43 -04:00
auto key = QSharedPointer<CompositeKey>::create();
key->addKey(QSharedPointer<PasswordKey>::create("I am in great pain, please help me!"));
Refactor and extend file format tests
2018-01-17 14:52:29 -05:00
sourceDb->setKey(key, true, true);
QBuffer buffer;
buffer.open(QBuffer::ReadWrite);
// upgrade to KDBX 4 by changing KDF and Cipher
Test speedup (#1678) * Tests: Speed up AutoType testing Decrease default autotype delay to 1 to improve test suite speed by seconds. This shaves multiple seconds off the whole test suite. In some cases, the largest part. Also, initialize config just creating the test instance, just in case that it ever depends on the configuration values at that point already. * Tests: Speed up Kdbx4 testing This speeds up the Kdbx4 tests by using parameters optimized for speed for the key derivation functions. On an i7-6700K the tests run close to 50% faster with this change (about 1.5s vs. 3s).
2018-03-08 04:20:25 -05:00
sourceDb->changeKdf(fastKdf(KeePass2::uuidToKdf(kdfUuid)));
Refactor and extend file format tests
2018-01-17 14:52:29 -05:00
sourceDb->setCipher(cipherUuid);
Properly save custom header data Ensure adding custom data upgrades to KDBX4 Implement review feedback
2018-02-18 15:01:22 -05:00
Don't upgrade to KDBX 4 when CustomData are present only in meta data section, resolves #1565
2018-02-28 17:02:45 -05:00
// CustomData in meta should not cause any version change
sourceDb->metadata()->customData()->set("CustomPublicData", "Hey look, I turned myself into a pickle!");
Properly save custom header data Ensure adding custom data upgrades to KDBX4 Implement review feedback
2018-02-18 15:01:22 -05:00
if (addCustomData) {
Don't upgrade to KDBX 4 when CustomData are present only in meta data section, resolves #1565
2018-02-28 17:02:45 -05:00
// this, however, should
Formatting the code.
2018-03-31 16:01:30 -04:00
sourceDb->rootGroup()->customData()->set("CustomGroupData",
"I just killed my family! I don't care who they were!");
Properly save custom header data Ensure adding custom data upgrades to KDBX4 Implement review feedback
2018-02-18 15:01:22 -05:00
}
Refactor and extend file format tests
2018-01-17 14:52:29 -05:00
KeePass2Writer writer;
writer.writeDatabase(&buffer, sourceDb.data());
if (writer.hasError()) {
QFAIL(qPrintable(QString("Error while writing database: %1").arg(writer.errorString())));
}
// read buffer back
buffer.seek(0);
KeePass2Reader reader;
Refactor Database and Database widgets (#2491) The Database, DatabaseWidget, and DatabaseTabWidget classes share many responsibilities in inconsistent ways resulting in impenetrable and unmaintainable code and a diverse set of bugs and architecture restrictions. This patch reworks the architecture, responsibilities of, and dependencies between these classes. The core changes are: * Move loading and saving logic from widgets into the Database class * Get rid of the DatabaseManagerStruct and move all the information contained in it into the Database * Let database objects keep track of modifications and dirty/clean state instead of handing this to external widgets * Move GUI interactions for loading and saving from the DatabaseTabWidget into the DatabaseWidget (resolves #2494 as a side-effect) * Heavily clean up DatabaseTabWidget and degrade it to a slightly glorified QTabWidget * Use QSharedPointers for all Database objects * Remove the modifiedImmediate signal and replace it with a markAsModified() method * Implement proper tabName() method instead of reading back titles from GUI widgets (resolves #1389 and its duplicates #2146 #855) * Fix unwanted AES-KDF downgrade if database uses Argon2 and has CustomData * Improve code This patch is also the first major step towards solving issues #476 and #2322.
2018-11-22 05:47:31 -05:00
auto targetDb = QSharedPointer<Database>::create();
reader.readDatabase(&buffer, key, targetDb.data());
Refactor and extend file format tests
2018-01-17 14:52:29 -05:00
if (reader.hasError()) {
QFAIL(qPrintable(QString("Error while reading database: %1").arg(reader.errorString())));
}
QVERIFY(targetDb->rootGroup());
QCOMPARE(targetDb->metadata()->name(), sourceDb->metadata()->name());
QCOMPARE(reader.version(), expectedVersion);
QCOMPARE(targetDb->cipher(), cipherUuid);
Support Database Custom Data Merging (#3002) * Introduce _LAST_MODIFIED custom data entry that stores the last modified datetime of the database's custom data entries * Merge custom data from source database to target * Modify tests to be aware of _LAST_MODIFIED entry
2019-05-01 18:35:08 -04:00
QCOMPARE(targetDb->metadata()->customData()->value("CustomPublicData"),
sourceDb->metadata()->customData()->value("CustomPublicData"));
QCOMPARE(targetDb->rootGroup()->customData()->value("CustomGroupData"),
sourceDb->rootGroup()->customData()->value("CustomGroupData"));
Refactor and extend file format tests
2018-01-17 14:52:29 -05:00
}
Add ClangFormat exceptions
2018-02-21 21:27:55 -05:00
// clang-format off
Avoid redundant KDBX4 test runs
2021-11-13 12:46:05 -05:00
void TestKdbx4Format::testFormat400Upgrade_data()
Refactor and extend file format tests
2018-01-17 14:52:29 -05:00
{
Replaced Uuid with QUuid
2018-03-22 17:56:05 -04:00
QTest::addColumn<QUuid>("kdfUuid");
QTest::addColumn<QUuid>("cipherUuid");
Properly save custom header data Ensure adding custom data upgrades to KDBX4 Implement review feedback
2018-02-18 15:01:22 -05:00
QTest::addColumn<bool>("addCustomData");
Refactor and extend file format tests
2018-01-17 14:52:29 -05:00
QTest::addColumn<quint32>("expectedVersion");
Correctly set KDBX envelope version Shows a warning when trying to open with a newer minor version than what is currently supported. We always try to save with the lowest KDBX version possible for maximum compatibility.
2021-11-19 18:32:09 -05:00
auto constexpr kdbx3 = KeePass2::FILE_VERSION_3_1;
auto constexpr kdbx4 = KeePass2::FILE_VERSION_4;
Refactor and extend file format tests
2018-01-17 14:52:29 -05:00
Add Argon2id KDF
2020-11-20 15:49:56 -05:00
QTest::newRow("Argon2d + AES") << KeePass2::KDF_ARGON2D << KeePass2::CIPHER_AES256 << false << kdbx4;
QTest::newRow("Argon2id + AES") << KeePass2::KDF_ARGON2ID << KeePass2::CIPHER_AES256 << false << kdbx4;
QTest::newRow("AES-KDF + AES") << KeePass2::KDF_AES_KDBX4 << KeePass2::CIPHER_AES256 << false << kdbx4;
QTest::newRow("AES-KDF (legacy) + AES") << KeePass2::KDF_AES_KDBX3 << KeePass2::CIPHER_AES256 << false << kdbx3;
QTest::newRow("Argon2d + AES + CustomData") << KeePass2::KDF_ARGON2D << KeePass2::CIPHER_AES256 << true << kdbx4;
QTest::newRow("Argon2id + AES + CustomData") << KeePass2::KDF_ARGON2ID << KeePass2::CIPHER_AES256 << true << kdbx4;
QTest::newRow("AES-KDF + AES + CustomData") << KeePass2::KDF_AES_KDBX4 << KeePass2::CIPHER_AES256 << true << kdbx4;
QTest::newRow("AES-KDF (legacy) + AES + CustomData") << KeePass2::KDF_AES_KDBX3 << KeePass2::CIPHER_AES256 << true << kdbx4;
QTest::newRow("Argon2d + ChaCha20") << KeePass2::KDF_ARGON2D << KeePass2::CIPHER_CHACHA20 << false << kdbx4;
QTest::newRow("Argon2id + ChaCha20") << KeePass2::KDF_ARGON2ID << KeePass2::CIPHER_CHACHA20 << false << kdbx4;
QTest::newRow("AES-KDF + ChaCha20") << KeePass2::KDF_AES_KDBX4 << KeePass2::CIPHER_CHACHA20 << false << kdbx4;
QTest::newRow("AES-KDF (legacy) + ChaCha20") << KeePass2::KDF_AES_KDBX3 << KeePass2::CIPHER_CHACHA20 << false << kdbx3;
QTest::newRow("Argon2d + ChaCha20 + CustomData") << KeePass2::KDF_ARGON2D << KeePass2::CIPHER_CHACHA20 << true << kdbx4;
QTest::newRow("Argon2id + ChaCha20 + CustomData") << KeePass2::KDF_ARGON2ID << KeePass2::CIPHER_CHACHA20 << true << kdbx4;
QTest::newRow("AES-KDF + ChaCha20 + CustomData") << KeePass2::KDF_AES_KDBX4 << KeePass2::CIPHER_CHACHA20 << true << kdbx4;
QTest::newRow("AES-KDF (legacy) + ChaCha20 + CustomData") << KeePass2::KDF_AES_KDBX3 << KeePass2::CIPHER_CHACHA20 << true << kdbx4;
QTest::newRow("Argon2d + Twofish") << KeePass2::KDF_ARGON2D << KeePass2::CIPHER_TWOFISH << false << kdbx4;
QTest::newRow("Argon2id + Twofish") << KeePass2::KDF_ARGON2ID << KeePass2::CIPHER_TWOFISH << false << kdbx4;
QTest::newRow("AES-KDF + Twofish") << KeePass2::KDF_AES_KDBX4 << KeePass2::CIPHER_TWOFISH << false << kdbx4;
QTest::newRow("AES-KDF (legacy) + Twofish") << KeePass2::KDF_AES_KDBX3 << KeePass2::CIPHER_TWOFISH << false << kdbx3;
QTest::newRow("Argon2d + Twofish + CustomData") << KeePass2::KDF_ARGON2D << KeePass2::CIPHER_TWOFISH << true << kdbx4;
QTest::newRow("Argon2id + Twofish + CustomData") << KeePass2::KDF_ARGON2ID << KeePass2::CIPHER_TWOFISH << true << kdbx4;
QTest::newRow("AES-KDF + Twofish + CustomData") << KeePass2::KDF_AES_KDBX4 << KeePass2::CIPHER_TWOFISH << true << kdbx4;
QTest::newRow("AES-KDF (legacy) + Twofish + CustomData") << KeePass2::KDF_AES_KDBX3 << KeePass2::CIPHER_TWOFISH << true << kdbx4;
Refactor and extend file format tests
2018-01-17 14:52:29 -05:00
}
Add ClangFormat exceptions
2018-02-21 21:27:55 -05:00
// clang-format on
Add additional tests for saving and reading KDBX files with custom data
2018-02-18 13:54:07 -05:00
Avoid redundant KDBX4 test runs
2021-11-13 12:46:05 -05:00
void TestKdbx4Format::testFormat410Upgrade()
{
Database db;
db.changeKdf(fastKdf(db.kdf()));
QCOMPARE(db.kdf()->uuid(), KeePass2::KDF_AES_KDBX3);
Correctly set KDBX envelope version Shows a warning when trying to open with a newer minor version than what is currently supported. We always try to save with the lowest KDBX version possible for maximum compatibility.
2021-11-19 18:32:09 -05:00
QCOMPARE(KeePass2Writer::kdbxVersionRequired(&db), KeePass2::FILE_VERSION_3_1);
Avoid redundant KDBX4 test runs
2021-11-13 12:46:05 -05:00
auto group1 = new Group();
group1->setUuid(QUuid::createUuid());
group1->setParent(db.rootGroup());
auto group2 = new Group();
group2->setUuid(QUuid::createUuid());
group2->setParent(db.rootGroup());
auto entry = new Entry();
entry->setUuid(QUuid::createUuid());
entry->setGroup(group1);
// Groups with tags
group1->setTags("tag");
Correctly set KDBX envelope version Shows a warning when trying to open with a newer minor version than what is currently supported. We always try to save with the lowest KDBX version possible for maximum compatibility.
2021-11-19 18:32:09 -05:00
QCOMPARE(KeePass2Writer::kdbxVersionRequired(&db), KeePass2::FILE_VERSION_4_1);
Avoid redundant KDBX4 test runs
2021-11-13 12:46:05 -05:00
group1->setTags("");
Correctly set KDBX envelope version Shows a warning when trying to open with a newer minor version than what is currently supported. We always try to save with the lowest KDBX version possible for maximum compatibility.
2021-11-19 18:32:09 -05:00
QCOMPARE(KeePass2Writer::kdbxVersionRequired(&db), KeePass2::FILE_VERSION_3_1);
Avoid redundant KDBX4 test runs
2021-11-13 12:46:05 -05:00
// PasswordQuality flag set
entry->setExcludeFromReports(true);
Correctly set KDBX envelope version Shows a warning when trying to open with a newer minor version than what is currently supported. We always try to save with the lowest KDBX version possible for maximum compatibility.
2021-11-19 18:32:09 -05:00
QCOMPARE(KeePass2Writer::kdbxVersionRequired(&db), KeePass2::FILE_VERSION_4_1);
Avoid redundant KDBX4 test runs
2021-11-13 12:46:05 -05:00
entry->setExcludeFromReports(false);
Correctly set KDBX envelope version Shows a warning when trying to open with a newer minor version than what is currently supported. We always try to save with the lowest KDBX version possible for maximum compatibility.
2021-11-19 18:32:09 -05:00
QCOMPARE(KeePass2Writer::kdbxVersionRequired(&db), KeePass2::FILE_VERSION_3_1);
Avoid redundant KDBX4 test runs
2021-11-13 12:46:05 -05:00
// Previous parent group set on group
group1->setPreviousParentGroup(group2);
QCOMPARE(group1->previousParentGroup(), group2);
Correctly set KDBX envelope version Shows a warning when trying to open with a newer minor version than what is currently supported. We always try to save with the lowest KDBX version possible for maximum compatibility.
2021-11-19 18:32:09 -05:00
QCOMPARE(KeePass2Writer::kdbxVersionRequired(&db), KeePass2::FILE_VERSION_4_1);
Avoid redundant KDBX4 test runs
2021-11-13 12:46:05 -05:00
group1->setPreviousParentGroup(nullptr);
Correctly set KDBX envelope version Shows a warning when trying to open with a newer minor version than what is currently supported. We always try to save with the lowest KDBX version possible for maximum compatibility.
2021-11-19 18:32:09 -05:00
QCOMPARE(KeePass2Writer::kdbxVersionRequired(&db), KeePass2::FILE_VERSION_3_1);
Avoid redundant KDBX4 test runs
2021-11-13 12:46:05 -05:00
// Previous parent group set on entry
entry->setPreviousParentGroup(group2);
QCOMPARE(entry->previousParentGroup(), group2);
Correctly set KDBX envelope version Shows a warning when trying to open with a newer minor version than what is currently supported. We always try to save with the lowest KDBX version possible for maximum compatibility.
2021-11-19 18:32:09 -05:00
QCOMPARE(KeePass2Writer::kdbxVersionRequired(&db), KeePass2::FILE_VERSION_4_1);
Avoid redundant KDBX4 test runs
2021-11-13 12:46:05 -05:00
entry->setPreviousParentGroup(nullptr);
Correctly set KDBX envelope version Shows a warning when trying to open with a newer minor version than what is currently supported. We always try to save with the lowest KDBX version possible for maximum compatibility.
2021-11-19 18:32:09 -05:00
QCOMPARE(KeePass2Writer::kdbxVersionRequired(&db), KeePass2::FILE_VERSION_3_1);
Avoid redundant KDBX4 test runs
2021-11-13 12:46:05 -05:00
// Custom icons with name or modification date
Metadata::CustomIconData customIcon;
auto iconUuid = QUuid::createUuid();
db.metadata()->addCustomIcon(iconUuid, customIcon);
Correctly set KDBX envelope version Shows a warning when trying to open with a newer minor version than what is currently supported. We always try to save with the lowest KDBX version possible for maximum compatibility.
2021-11-19 18:32:09 -05:00
QCOMPARE(KeePass2Writer::kdbxVersionRequired(&db), KeePass2::FILE_VERSION_3_1);
Avoid redundant KDBX4 test runs
2021-11-13 12:46:05 -05:00
customIcon.name = "abc";
db.metadata()->removeCustomIcon(iconUuid);
db.metadata()->addCustomIcon(iconUuid, customIcon);
Correctly set KDBX envelope version Shows a warning when trying to open with a newer minor version than what is currently supported. We always try to save with the lowest KDBX version possible for maximum compatibility.
2021-11-19 18:32:09 -05:00
QCOMPARE(KeePass2Writer::kdbxVersionRequired(&db), KeePass2::FILE_VERSION_4_1);
Avoid redundant KDBX4 test runs
2021-11-13 12:46:05 -05:00
customIcon.name.clear();
customIcon.lastModified = Clock::currentDateTimeUtc();
db.metadata()->removeCustomIcon(iconUuid);
Correctly set KDBX envelope version Shows a warning when trying to open with a newer minor version than what is currently supported. We always try to save with the lowest KDBX version possible for maximum compatibility.
2021-11-19 18:32:09 -05:00
QCOMPARE(KeePass2Writer::kdbxVersionRequired(&db), KeePass2::FILE_VERSION_3_1);
Avoid redundant KDBX4 test runs
2021-11-13 12:46:05 -05:00
db.metadata()->addCustomIcon(iconUuid, customIcon);
Correctly set KDBX envelope version Shows a warning when trying to open with a newer minor version than what is currently supported. We always try to save with the lowest KDBX version possible for maximum compatibility.
2021-11-19 18:32:09 -05:00
QCOMPARE(KeePass2Writer::kdbxVersionRequired(&db), KeePass2::FILE_VERSION_4_1);
Avoid redundant KDBX4 test runs
2021-11-13 12:46:05 -05:00
}
void TestKdbx4Format::testUpgradeMasterKeyIntegrity()
Add additional KDBX4 upgrade tests for composite key integrity
2018-03-01 15:25:29 -05:00
{
QFETCH(QString, upgradeAction);
QFETCH(quint32, expectedVersion);
// prepare composite key
Add a new database settings wizard 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.
2018-05-13 17:21:43 -04:00
auto passwordKey = QSharedPointer<PasswordKey>::create("turXpGMQiUE6CkPvWacydAKsnp4cxz");
Add additional KDBX4 upgrade tests for composite key integrity
2018-03-01 15:25:29 -05:00
QByteArray fileKeyBytes("Ma6hHov98FbPeyAL22XhcgmpJk8xjQ");
QBuffer fileKeyBuffer(&fileKeyBytes);
fileKeyBuffer.open(QBuffer::ReadOnly);
Add a new database settings wizard 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.
2018-05-13 17:21:43 -04:00
auto fileKey = QSharedPointer<FileKey>::create();
fileKey->load(&fileKeyBuffer);
Add additional KDBX4 upgrade tests for composite key integrity
2018-03-01 15:25:29 -05:00
auto crKey = QSharedPointer<MockChallengeResponseKey>::create(QByteArray("azdJnbVCFE76vV6t9RJ2DS6xvSS93k"));
Add a new database settings wizard 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.
2018-05-13 17:21:43 -04:00
auto compositeKey = QSharedPointer<CompositeKey>::create();
compositeKey->addKey(passwordKey);
compositeKey->addKey(fileKey);
compositeKey->addChallengeResponseKey(crKey);
Add additional KDBX4 upgrade tests for composite key integrity
2018-03-01 15:25:29 -05:00
QScopedPointer<Database> db(new Database());
Test speedup (#1678) * Tests: Speed up AutoType testing Decrease default autotype delay to 1 to improve test suite speed by seconds. This shaves multiple seconds off the whole test suite. In some cases, the largest part. Also, initialize config just creating the test instance, just in case that it ever depends on the configuration values at that point already. * Tests: Speed up Kdbx4 testing This speeds up the Kdbx4 tests by using parameters optimized for speed for the key derivation functions. On an i7-6700K the tests run close to 50% faster with this change (about 1.5s vs. 3s).
2018-03-08 04:20:25 -05:00
db->changeKdf(fastKdf(db->kdf()));
Ensure challenge-response key buffer is properly cleared. The challenge-response key buffer is explicitly cleared before the key transformation if no such key is configured to ensure one is never injected into the hash even if the database had a challenge-response key previously. This patch also adds extensive tests for verifying that a key change will not add any expired key material to the hash. Fixes #4146
2020-01-09 20:11:43 -05:00
QCOMPARE(db->kdf()->uuid(), KeePass2::KDF_AES_KDBX3); // default is legacy AES-KDF
Add additional KDBX4 upgrade tests for composite key integrity
2018-03-01 15:25:29 -05:00
db->setKey(compositeKey);
// upgrade the database by a specific method
if (upgradeAction == "none") {
// do nothing
} else if (upgradeAction == "meta-customdata") {
db->metadata()->customData()->set("abc", "def");
} else if (upgradeAction == "kdf-aes-kdbx3") {
Test speedup (#1678) * Tests: Speed up AutoType testing Decrease default autotype delay to 1 to improve test suite speed by seconds. This shaves multiple seconds off the whole test suite. In some cases, the largest part. Also, initialize config just creating the test instance, just in case that it ever depends on the configuration values at that point already. * Tests: Speed up Kdbx4 testing This speeds up the Kdbx4 tests by using parameters optimized for speed for the key derivation functions. On an i7-6700K the tests run close to 50% faster with this change (about 1.5s vs. 3s).
2018-03-08 04:20:25 -05:00
db->changeKdf(fastKdf(KeePass2::uuidToKdf(KeePass2::KDF_AES_KDBX3)));
Add additional KDBX4 upgrade tests for composite key integrity
2018-03-01 15:25:29 -05:00
} else if (upgradeAction == "kdf-argon2") {
Add Argon2id KDF
2020-11-20 15:49:56 -05:00
db->changeKdf(fastKdf(KeePass2::uuidToKdf(KeePass2::KDF_ARGON2D)));
Add additional KDBX4 upgrade tests for composite key integrity
2018-03-01 15:25:29 -05:00
} else if (upgradeAction == "kdf-aes-kdbx4") {
Test speedup (#1678) * Tests: Speed up AutoType testing Decrease default autotype delay to 1 to improve test suite speed by seconds. This shaves multiple seconds off the whole test suite. In some cases, the largest part. Also, initialize config just creating the test instance, just in case that it ever depends on the configuration values at that point already. * Tests: Speed up Kdbx4 testing This speeds up the Kdbx4 tests by using parameters optimized for speed for the key derivation functions. On an i7-6700K the tests run close to 50% faster with this change (about 1.5s vs. 3s).
2018-03-08 04:20:25 -05:00
db->changeKdf(fastKdf(KeePass2::uuidToKdf(KeePass2::KDF_AES_KDBX4)));
Add additional KDBX4 upgrade tests for composite key integrity
2018-03-01 15:25:29 -05:00
} else if (upgradeAction == "public-customdata") {
db->publicCustomData().insert("abc", "def");
} else if (upgradeAction == "rootgroup-customdata") {
db->rootGroup()->customData()->set("abc", "def");
} else if (upgradeAction == "group-customdata") {
auto group = new Group();
group->setParent(db->rootGroup());
Replaced Uuid with QUuid
2018-03-22 17:56:05 -04:00
group->setUuid(QUuid::createUuid());
Add additional KDBX4 upgrade tests for composite key integrity
2018-03-01 15:25:29 -05:00
group->customData()->set("abc", "def");
} else if (upgradeAction == "rootentry-customdata") {
auto entry = new Entry();
entry->setGroup(db->rootGroup());
Replaced Uuid with QUuid
2018-03-22 17:56:05 -04:00
entry->setUuid(QUuid::createUuid());
Add additional KDBX4 upgrade tests for composite key integrity
2018-03-01 15:25:29 -05:00
entry->customData()->set("abc", "def");
} else if (upgradeAction == "entry-customdata") {
auto group = new Group();
group->setParent(db->rootGroup());
Replaced Uuid with QUuid
2018-03-22 17:56:05 -04:00
group->setUuid(QUuid::createUuid());
Add additional KDBX4 upgrade tests for composite key integrity
2018-03-01 15:25:29 -05:00
auto entry = new Entry();
entry->setGroup(group);
Replaced Uuid with QUuid
2018-03-22 17:56:05 -04:00
entry->setUuid(QUuid::createUuid());
Add additional KDBX4 upgrade tests for composite key integrity
2018-03-01 15:25:29 -05:00
entry->customData()->set("abc", "def");
} else {
QFAIL(qPrintable(QString("Unknown action: %s").arg(upgradeAction)));
}
QBuffer buffer;
buffer.open(QBuffer::ReadWrite);
KeePass2Writer writer;
QVERIFY(writer.writeDatabase(&buffer, db.data()));
// paranoid check that we cannot decrypt the database without a key
buffer.seek(0);
KeePass2Reader reader;
Refactor Database and Database widgets (#2491) The Database, DatabaseWidget, and DatabaseTabWidget classes share many responsibilities in inconsistent ways resulting in impenetrable and unmaintainable code and a diverse set of bugs and architecture restrictions. This patch reworks the architecture, responsibilities of, and dependencies between these classes. The core changes are: * Move loading and saving logic from widgets into the Database class * Get rid of the DatabaseManagerStruct and move all the information contained in it into the Database * Let database objects keep track of modifications and dirty/clean state instead of handing this to external widgets * Move GUI interactions for loading and saving from the DatabaseTabWidget into the DatabaseWidget (resolves #2494 as a side-effect) * Heavily clean up DatabaseTabWidget and degrade it to a slightly glorified QTabWidget * Use QSharedPointers for all Database objects * Remove the modifiedImmediate signal and replace it with a markAsModified() method * Implement proper tabName() method instead of reading back titles from GUI widgets (resolves #1389 and its duplicates #2146 #855) * Fix unwanted AES-KDF downgrade if database uses Argon2 and has CustomData * Improve code This patch is also the first major step towards solving issues #476 and #2322.
2018-11-22 05:47:31 -05:00
auto db2 = QSharedPointer<Database>::create();
reader.readDatabase(&buffer, QSharedPointer<CompositeKey>::create(), db2.data());
Add additional KDBX4 upgrade tests for composite key integrity
2018-03-01 15:25:29 -05:00
QVERIFY(reader.hasError());
// check that we can read back the database with the original composite key,
// i.e., no components have been lost on the way
buffer.seek(0);
Refactor Database and Database widgets (#2491) The Database, DatabaseWidget, and DatabaseTabWidget classes share many responsibilities in inconsistent ways resulting in impenetrable and unmaintainable code and a diverse set of bugs and architecture restrictions. This patch reworks the architecture, responsibilities of, and dependencies between these classes. The core changes are: * Move loading and saving logic from widgets into the Database class * Get rid of the DatabaseManagerStruct and move all the information contained in it into the Database * Let database objects keep track of modifications and dirty/clean state instead of handing this to external widgets * Move GUI interactions for loading and saving from the DatabaseTabWidget into the DatabaseWidget (resolves #2494 as a side-effect) * Heavily clean up DatabaseTabWidget and degrade it to a slightly glorified QTabWidget * Use QSharedPointers for all Database objects * Remove the modifiedImmediate signal and replace it with a markAsModified() method * Implement proper tabName() method instead of reading back titles from GUI widgets (resolves #1389 and its duplicates #2146 #855) * Fix unwanted AES-KDF downgrade if database uses Argon2 and has CustomData * Improve code This patch is also the first major step towards solving issues #476 and #2322.
2018-11-22 05:47:31 -05:00
db2 = QSharedPointer<Database>::create();
reader.readDatabase(&buffer, compositeKey, db2.data());
Add additional KDBX4 upgrade tests for composite key integrity
2018-03-01 15:25:29 -05:00
if (reader.hasError()) {
QFAIL(qPrintable(reader.errorString()));
}
Correctly set KDBX envelope version Shows a warning when trying to open with a newer minor version than what is currently supported. We always try to save with the lowest KDBX version possible for maximum compatibility.
2021-11-19 18:32:09 -05:00
QCOMPARE(reader.version(), expectedVersion);
if (expectedVersion >= KeePass2::FILE_VERSION_4) {
Ensure challenge-response key buffer is properly cleared. The challenge-response key buffer is explicitly cleared before the key transformation if no such key is configured to ensure one is never injected into the hash even if the database had a challenge-response key previously. This patch also adds extensive tests for verifying that a key change will not add any expired key material to the hash. Fixes #4146
2020-01-09 20:11:43 -05:00
QVERIFY(db2->kdf()->uuid() != KeePass2::KDF_AES_KDBX3);
}
Add additional KDBX4 upgrade tests for composite key integrity
2018-03-01 15:25:29 -05:00
}
Avoid redundant KDBX4 test runs
2021-11-13 12:46:05 -05:00
void TestKdbx4Format::testUpgradeMasterKeyIntegrity_data()
Add additional KDBX4 upgrade tests for composite key integrity
2018-03-01 15:25:29 -05:00
{
QTest::addColumn<QString>("upgradeAction");
QTest::addColumn<quint32>("expectedVersion");
Correctly set KDBX envelope version Shows a warning when trying to open with a newer minor version than what is currently supported. We always try to save with the lowest KDBX version possible for maximum compatibility.
2021-11-19 18:32:09 -05:00
QTest::newRow("Upgrade: none") << QString("none") << KeePass2::FILE_VERSION_3_1;
QTest::newRow("Upgrade: none (meta-customdata)") << QString("meta-customdata") << KeePass2::FILE_VERSION_3_1;
QTest::newRow("Upgrade: none (explicit kdf-aes-kdbx3)") << QString("kdf-aes-kdbx3") << KeePass2::FILE_VERSION_3_1;
Formatting the code.
2018-03-31 16:01:30 -04:00
QTest::newRow("Upgrade (explicit): kdf-argon2") << QString("kdf-argon2") << KeePass2::FILE_VERSION_4;
QTest::newRow("Upgrade (explicit): kdf-aes-kdbx4") << QString("kdf-aes-kdbx4") << KeePass2::FILE_VERSION_4;
QTest::newRow("Upgrade (implicit): public-customdata") << QString("public-customdata") << KeePass2::FILE_VERSION_4;
Restore correct formatting Many lines were not conformant with the project's formatting rules. This patch should fix all formatting and whitespace issues in the code base. A clang-format directive was put around the connect() calls containing SIGNALs and SLOTs whose signatures would be denormalized because of the formatting rules.
2018-10-31 23:27:38 -04:00
QTest::newRow("Upgrade (implicit): rootgroup-customdata")
<< QString("rootgroup-customdata") << KeePass2::FILE_VERSION_4;
Formatting the code.
2018-03-31 16:01:30 -04:00
QTest::newRow("Upgrade (implicit): group-customdata") << QString("group-customdata") << KeePass2::FILE_VERSION_4;
Restore correct formatting Many lines were not conformant with the project's formatting rules. This patch should fix all formatting and whitespace issues in the code base. A clang-format directive was put around the connect() calls containing SIGNALs and SLOTs whose signatures would be denormalized because of the formatting rules.
2018-10-31 23:27:38 -04:00
QTest::newRow("Upgrade (implicit): rootentry-customdata")
<< QString("rootentry-customdata") << KeePass2::FILE_VERSION_4;
Formatting the code.
2018-03-31 16:01:30 -04:00
QTest::newRow("Upgrade (implicit): entry-customdata") << QString("entry-customdata") << KeePass2::FILE_VERSION_4;
Add additional KDBX4 upgrade tests for composite key integrity
2018-03-01 15:25:29 -05:00
}
Prevent byte-by-byte and attachment inference side channel attacks Attack - KeeShare attachments can be inferred because of attachment de-duplication. Solution - Prevent de-duplication of normal database entry attachments with those entry attachments synchronized/associated with a KeeShare database. This is done using the KeeShare database UUID injected into the hash calculation of the attachment prior to de-dupe. The attachments themselves are not modified in any way. -------- Attack - Side channel byte-by-byte inference due to compression de-duplication of data between a KeeShare database and it's parent. Solution - Generate a random array between 64 and 512 bytes, convert to hex, and store in the database custom data. -------- Attack vector assumptions: 1. Compression is enabled 2. The attacker has access to a KeeShare database actively syncing with the victim's database 3. The victim's database is unlocked and syncing 4. The attacker can see the exact size of the victim's database after saving, and syncing, the KeeShare database Thank you to Andrés Fábrega from Cornell University for theorizing and informing us of this attack vector.
2024-02-06 07:00:45 -05:00
void TestKdbx4Format::testAttachmentIndexStability()
{
QScopedPointer<Database> db(new Database());
db->changeKdf(fastKdf(KeePass2::uuidToKdf(KeePass2::KDF_ARGON2ID)));
auto compositeKey = QSharedPointer<CompositeKey>::create();
db->setKey(compositeKey);
QVERIFY(!db->uuid().isNull());
auto root = db->rootGroup();
auto group1 = new Group();
group1->setUuid(QUuid::createUuid());
QVERIFY(!group1->uuid().isNull());
group1->setParent(root);
// Simulate KeeShare group, which uses its own attachment namespace
auto group2 = new Group();
group2->setUuid(QUuid::createUuid());
QVERIFY(!group2->uuid().isNull());
group2->setParent(group1);
#ifdef WITH_XC_KEESHARE
KeeShareSettings::Reference ref;
ref.type = KeeShareSettings::SynchronizeWith;
ref.path = "123";
KeeShare::setReferenceTo(group2, ref);
QVERIFY(KeeShare::isShared(group2));
#endif
auto attachment1 = QByteArray("qwerty");
auto attachment2 = QByteArray("asdf");
auto attachment3 = QByteArray("zxcv");
auto entry1 = new Entry();
entry1->setUuid(QUuid::createUuid());
QVERIFY(!entry1->uuid().isNull());
auto uuid1 = entry1->uuid();
entry1->attachments()->set("a", attachment1);
QCOMPARE(entry1->attachments()->keys().size(), 1);
QCOMPARE(entry1->attachments()->values().size(), 1);
entry1->setGroup(root);
auto entry2 = new Entry();
entry2->setUuid(QUuid::createUuid());
QVERIFY(!entry2->uuid().isNull());
auto uuid2 = entry2->uuid();
entry2->attachments()->set("a", attachment1);
entry2->attachments()->set("b", attachment2);
QCOMPARE(entry2->attachments()->keys().size(), 2);
QCOMPARE(entry2->attachments()->values().size(), 2);
entry2->setGroup(group1);
auto entry3 = new Entry();
entry3->setUuid(QUuid::createUuid());
QVERIFY(!entry3->uuid().isNull());
auto uuid3 = entry3->uuid();
entry3->attachments()->set("a", attachment1);
entry3->attachments()->set("b", attachment2);
entry3->attachments()->set("x", attachment3);
entry3->attachments()->set("y", attachment3);
QCOMPARE(entry3->attachments()->keys().size(), 4);
QCOMPARE(entry3->attachments()->values().size(), 3);
entry3->setGroup(group2);
QBuffer buffer;
buffer.open(QBuffer::ReadWrite);
KeePass2Writer writer;
QVERIFY(writer.writeDatabase(&buffer, db.data()));
QVERIFY(writer.version() >= KeePass2::FILE_VERSION_4);
buffer.seek(0);
KeePass2Reader reader;
// Re-read database and check that all attachments are still correctly assigned
auto db2 = QSharedPointer<Database>::create();
reader.readDatabase(&buffer, QSharedPointer<CompositeKey>::create(), db2.data());
QVERIFY(!reader.hasError());
QVERIFY(!db->uuid().isNull());
auto a1 = db2->rootGroup()->findEntryByUuid(uuid1)->attachments();
QCOMPARE(a1->keys().size(), 1);
QCOMPARE(a1->values().size(), 1);
QCOMPARE(a1->value("a"), attachment1);
auto a2 = db2->rootGroup()->findEntryByUuid(uuid2)->attachments();
QCOMPARE(a2->keys().size(), 2);
QCOMPARE(a2->values().size(), 2);
QCOMPARE(a2->value("a"), attachment1);
QCOMPARE(a2->value("b"), attachment2);
#ifdef WITH_XC_KEESHARE
QVERIFY(KeeShare::isShared(db2->rootGroup()->findEntryByUuid(uuid3)->group()));
#endif
auto a3 = db2->rootGroup()->findEntryByUuid(uuid3)->attachments();
QCOMPARE(a3->keys().size(), 4);
QCOMPARE(a3->values().size(), 3);
QCOMPARE(a3->value("a"), attachment1);
QCOMPARE(a3->value("b"), attachment2);
QCOMPARE(a3->value("x"), attachment3);
QCOMPARE(a3->value("y"), attachment3);
}
Avoid redundant KDBX4 test runs
2021-11-13 12:46:05 -05:00
void TestKdbx4Format::testCustomData()
Add additional tests for saving and reading KDBX files with custom data
2018-02-18 13:54:07 -05:00
{
Database db;
// test public custom data
QVariantMap publicCustomData;
publicCustomData.insert("CD1", 123);
publicCustomData.insert("CD2", true);
publicCustomData.insert("CD3", "abcäöü");
db.setPublicCustomData(publicCustomData);
Add additional KDBX4 upgrade tests for composite key integrity
2018-03-01 15:25:29 -05:00
publicCustomData.insert("CD4", QByteArray::fromHex("ababa123ff"));
db.publicCustomData().insert("CD4", publicCustomData.value("CD4"));
Add additional tests for saving and reading KDBX files with custom data
2018-02-18 13:54:07 -05:00
QCOMPARE(db.publicCustomData(), publicCustomData);
const QString customDataKey1 = "CD1";
const QString customDataKey2 = "CD2";
const QString customData1 = "abcäöü";
const QString customData2 = "Hello World";
// test custom database data
db.metadata()->customData()->set(customDataKey1, customData1);
db.metadata()->customData()->set(customDataKey2, customData2);
Support Database Custom Data Merging (#3002) * Introduce _LAST_MODIFIED custom data entry that stores the last modified datetime of the database's custom data entries * Merge custom data from source database to target * Modify tests to be aware of _LAST_MODIFIED entry
2019-05-01 18:35:08 -04:00
auto lastModified = db.metadata()->customData()->value(CustomData::LastModified);
Implement KDBX 4.1 CustomData modification date We keep the old merging behaviour for now, since deleting a CustomData entry does not create DeletedObject.
2021-11-10 17:11:03 -05:00
const int dataSize = customDataKey1.toUtf8().size() + customDataKey2.toUtf8().size() + customData1.toUtf8().size()
Support Database Custom Data Merging (#3002) * Introduce _LAST_MODIFIED custom data entry that stores the last modified datetime of the database's custom data entries * Merge custom data from source database to target * Modify tests to be aware of _LAST_MODIFIED entry
2019-05-01 18:35:08 -04:00
+ customData2.toUtf8().size() + lastModified.toUtf8().size()
+ CustomData::LastModified.toUtf8().size();
QCOMPARE(db.metadata()->customData()->size(), 3);
Add additional tests for saving and reading KDBX files with custom data
2018-02-18 13:54:07 -05:00
QCOMPARE(db.metadata()->customData()->dataSize(), dataSize);
// test custom root group data
Group* root = db.rootGroup();
root->customData()->set(customDataKey1, customData1);
root->customData()->set(customDataKey2, customData2);
Support Database Custom Data Merging (#3002) * Introduce _LAST_MODIFIED custom data entry that stores the last modified datetime of the database's custom data entries * Merge custom data from source database to target * Modify tests to be aware of _LAST_MODIFIED entry
2019-05-01 18:35:08 -04:00
QCOMPARE(root->customData()->size(), 3);
Add additional tests for saving and reading KDBX files with custom data
2018-02-18 13:54:07 -05:00
QCOMPARE(root->customData()->dataSize(), dataSize);
// test copied custom group data
auto* group = new Group();
group->setParent(root);
Replaced Uuid with QUuid
2018-03-22 17:56:05 -04:00
group->setUuid(QUuid::createUuid());
Add additional tests for saving and reading KDBX files with custom data
2018-02-18 13:54:07 -05:00
group->customData()->copyDataFrom(root->customData());
QCOMPARE(*group->customData(), *root->customData());
// test copied custom entry data
auto* entry = new Entry();
entry->setGroup(group);
Replaced Uuid with QUuid
2018-03-22 17:56:05 -04:00
entry->setUuid(QUuid::createUuid());
Add additional tests for saving and reading KDBX files with custom data
2018-02-18 13:54:07 -05:00
entry->customData()->copyDataFrom(group->customData());
QCOMPARE(*entry->customData(), *root->customData());
// test custom data deletion
entry->customData()->set("additional item", "foobar");
Support Database Custom Data Merging (#3002) * Introduce _LAST_MODIFIED custom data entry that stores the last modified datetime of the database's custom data entries * Merge custom data from source database to target * Modify tests to be aware of _LAST_MODIFIED entry
2019-05-01 18:35:08 -04:00
QCOMPARE(entry->customData()->size(), 4);
Add additional tests for saving and reading KDBX files with custom data
2018-02-18 13:54:07 -05:00
entry->customData()->remove("additional item");
Support Database Custom Data Merging (#3002) * Introduce _LAST_MODIFIED custom data entry that stores the last modified datetime of the database's custom data entries * Merge custom data from source database to target * Modify tests to be aware of _LAST_MODIFIED entry
2019-05-01 18:35:08 -04:00
QCOMPARE(entry->customData()->size(), 3);
Add additional tests for saving and reading KDBX files with custom data
2018-02-18 13:54:07 -05:00
QCOMPARE(entry->customData()->dataSize(), dataSize);
// test custom data on cloned groups
QScopedPointer<Group> clonedGroup(group->clone());
QCOMPARE(*clonedGroup->customData(), *group->customData());
// test custom data on cloned entries
QScopedPointer<Entry> clonedEntry(entry->clone(Entry::CloneNoFlags));
QCOMPARE(*clonedEntry->customData(), *entry->customData());
QBuffer buffer;
buffer.open(QBuffer::ReadWrite);
KeePass2Writer writer;
writer.writeDatabase(&buffer, &db);
// read buffer back
buffer.seek(0);
KeePass2Reader reader;
Refactor Database and Database widgets (#2491) The Database, DatabaseWidget, and DatabaseTabWidget classes share many responsibilities in inconsistent ways resulting in impenetrable and unmaintainable code and a diverse set of bugs and architecture restrictions. This patch reworks the architecture, responsibilities of, and dependencies between these classes. The core changes are: * Move loading and saving logic from widgets into the Database class * Get rid of the DatabaseManagerStruct and move all the information contained in it into the Database * Let database objects keep track of modifications and dirty/clean state instead of handing this to external widgets * Move GUI interactions for loading and saving from the DatabaseTabWidget into the DatabaseWidget (resolves #2494 as a side-effect) * Heavily clean up DatabaseTabWidget and degrade it to a slightly glorified QTabWidget * Use QSharedPointers for all Database objects * Remove the modifiedImmediate signal and replace it with a markAsModified() method * Implement proper tabName() method instead of reading back titles from GUI widgets (resolves #1389 and its duplicates #2146 #855) * Fix unwanted AES-KDF downgrade if database uses Argon2 and has CustomData * Improve code This patch is also the first major step towards solving issues #476 and #2322.
2018-11-22 05:47:31 -05:00
auto newDb = QSharedPointer<Database>::create();
reader.readDatabase(&buffer, QSharedPointer<CompositeKey>::create(), newDb.data());
Add additional tests for saving and reading KDBX files with custom data
2018-02-18 13:54:07 -05:00
// test all custom data are read back successfully from KDBX
QCOMPARE(newDb->publicCustomData(), publicCustomData);
QCOMPARE(newDb->metadata()->customData()->value(customDataKey1), customData1);
QCOMPARE(newDb->metadata()->customData()->value(customDataKey2), customData2);
QCOMPARE(newDb->rootGroup()->customData()->value(customDataKey1), customData1);
QCOMPARE(newDb->rootGroup()->customData()->value(customDataKey2), customData2);
auto* newGroup = newDb->rootGroup()->children()[0];
QCOMPARE(newGroup->customData()->value(customDataKey1), customData1);
QCOMPARE(newGroup->customData()->value(customDataKey2), customData2);
auto* newEntry = newDb->rootGroup()->children()[0]->entries()[0];
QCOMPARE(newEntry->customData()->value(customDataKey1), customData1);
QCOMPARE(newEntry->customData()->value(customDataKey2), customData2);
}
Reference in New Issue Copy Permalink